1

#include "cache.h"

     3

     4

#include <stdlib.h>

     5

#include <unistd.h>

     6

#include <sys/types.h>

     7

#include <sys/stat.h>

     8

#include <fcntl.h>

     9

#include <sys/mman.h>

    10

#include <errno.h>

    11

    12

    13

    14

static int pt_cache_new (struct pt_cache **cache_ptr, const char *path, int mode)

    15

{

    16

    struct pt_cache *cache;

    17

    18

    // alloc

    19

    if ((cache = calloc(1, sizeof(*cache))) == NULL)

    20

        return -1;

    21

    22

    if ((cache->path = strdup(path)) == NULL)

    23

        goto error;

    24

    25

    // init

    26

    cache->fd = -1;

    27

    cache->mode = mode;

    28

    29

    // ok

    30

    *cache_ptr = cache;

    31

    32

    return 0;

    33

    34

error:

    35

    // cleanup

    36

    if (cache)

    37

        pt_cache_destroy(cache);

    38

    39

    return -1;

    40

}

    41

    42

int pt_cache_open (struct pt_cache **cache_ptr, const char *path, int mode)

    43

{

    44

    struct pt_cache *cache;

    45

    46

    // alloc

    47

    if (pt_cache_new(&cache, path, mode))

    48

        return -1;

    49

    50

    // ok

    51

    *cache_ptr = cache;

    52

    53

    return 0;

    54

}

    55

    56

int pt_cache_stale (struct pt_cache *cache, const char *img_path)

    57

{

    58

    struct stat st_img, st_cache;

    59

    60

    // test original file

    61

    if (stat(img_path, &st_img) < 0)

    62

        return -1;

    63

    64

    // test cache file

    65

    if (stat(cache->path, &st_cache) < 0) {

    66

        // always stale if it doesn't exist yet

    67

        if (errno == ENOENT)

    68

            return 1;

    69

        else

    70

            return -1;

    71

    }

    72

    73

    // compare mtime

    74

    return (st_img.st_mtime > st_cache.st_mtime);

    75

}

    76

    77

/**

    78

 * Abort any incomplete open operation, cleaning up

    79

 */

    80

static void pt_cache_abort (struct pt_cache *cache)

    81

{

    82

    if (cache->mmap != NULL) {

    83

        munmap(cache->mmap, cache->size);

    84

    85

        cache->mmap = NULL;

    86

    }

    87

    88

    if (cache->fd >= 0) {

    89

        close(cache->fd);

    90

    91

        cache->fd = -1;

    92

    }

    93

}

    94

    95

/**

    97

 *

    98

 * XXX: needs locking

    99

 */

   101

{

   102

    int fd;

   104

    // actual open()

   106

        return -1;

   107

   108

    // ok

   109

    *fd_ptr = fd;

   110

   111

    return 0;

   112

}

   113

   114

/**

   145

 * Mmap the opened cache file from offset PT_CACHE_PAGE, using the calculated size stored in cache->size

   146

 */

   147

static int pt_cache_open_mmap (struct pt_cache *cache, void **addr_ptr)

   148

{

   149

    int prot = 0;

   150

    void *addr;

   151

   152

    // determine prot

   153

    if (cache->mode & PT_IMG_READ)

   154

        prot |= PROT_READ;

   155

   156

    if (cache->mode & PT_IMG_WRITE)

   157

        prot |= PROT_WRITE;

   158

   159

    // perform mmap() from second page on

   160

    if ((addr = mmap(NULL, cache->size, prot, MAP_SHARED, cache->fd, PT_CACHE_PAGE)) == MAP_FAILED)

   161

        return -1;

   162

   163

    // ok

   164

    *addr_ptr = addr;

   165

   166

    return 0;

   167

}

   168

   169

/**

   170

 * Write out the cache header into the opened file

   171

 */

   172

static int pt_cache_write_header (struct pt_cache *cache, const struct pt_cache_header *header)

   173

{

   174

    size_t len = sizeof(*header);

   175

    const char *buf = (const char *) header;

   176

   177

    // seek to start

   178

    if (lseek(cache->fd, 0, SEEK_SET) != 0)

   179

        return -1;

   180

   181

    // write out full header

   182

    while (len) {

   183

        ssize_t ret;

   184

   185

        // try and write out the header

   186

        if ((ret = write(cache->fd, buf, len)) < 0)

   187

            return -1;

   188

   189

        // update offset

   190

        buf += ret;

   191

        len -= ret;

   192

    }

   193

   194

    // done

   195

    return 0;

   196

}

   197

   198

/**

   200

 */

   201

static int pt_cache_open_create (struct pt_cache *cache, struct pt_cache_header *header)

   202

{

   203

    // no access

   204

    if (!(cache->mode & PT_IMG_WRITE)) {

   205

        errno = EPERM;

   206

        return -1;

   207

    }

   208

   211

        return -1;

   212

   213

    // calculate data size

   214

    cache->size = sizeof(*header) + header->height * header->row_bytes;

   215

   216

    // grow file

   217

    if (ftruncate(cache->fd, PT_CACHE_PAGE + cache->size) < 0)

   218

        goto error;

   219

   220

    // open mmap

   221

    if (pt_cache_open_mmap(cache, (void **) &cache->mmap))

   222

        goto error;

   223

   224

    // write header

   225

    if (pt_cache_write_header(cache, header))

   226

        goto error;

   227

   228

    // done

   229

    return 0;

   230

   231

error:

   232

    // cleanup

   233

    pt_cache_abort(cache);

   234

   235

    return -1;

   236

}

   237

   257

int pt_cache_update_png (struct pt_cache *cache, png_structp png, png_infop info)

   258

{

   259

    struct pt_cache_header header;

   260

   261

    // XXX: check cache_mode

   262

    // XXX: check image doesn't use any options we don't handle

   263

   264

    memset(&header, 0, sizeof(header));

   265

   266

    // fill in basic info

   267

    header.width = png_get_image_width(png, info);

   268

    header.height = png_get_image_height(png, info);

   269

    header.bit_depth = png_get_bit_depth(png, info);

   270

    header.color_type = png_get_color_type(png, info);

   271

   272

    // fill in other info

   273

    header.row_bytes = png_get_rowbytes(png, info);

   274

   276

    if (pt_cache_open_create(cache, &header))

   277

        return -1;

   278

   279

    // XXX: pallette etc.

   280

   281

    // write out raw image data a row at a time

   282

    for (size_t row = 0; row < header.height; row++) {

   283

        // read row data, non-interlaced

   284

        png_read_row(png, cache->mmap + row * header.row_bytes, NULL);

   285

    }

   286

   291

    // done!

   292

    return 0;

   293

}

   294

   295

void pt_cache_destroy (struct pt_cache *cache)

   296

{

   297

    free(cache->path);

   298

   299

    pt_cache_abort(cache);

   300

   301

    free(cache);

   302

}