1

#include "cache.h"

     2

     3

#include <stdlib.h>

     4

#include <unistd.h>

     5

#include <sys/types.h>

     6

#include <sys/stat.h>

     7

#include <fcntl.h>

     8

#include <sys/mman.h>

     9

#include <errno.h>

    10

    11

    12

    14

{

    15

    struct pt_cache *cache;

    16

    17

    // alloc

    18

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

    19

        return -1;

    20

    21

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

    22

        goto error;

    23

    24

    // init

    25

    cache->fd = -1;

    27

    28

    // ok

    29

    *cache_ptr = cache;

    30

    31

    return 0;

    32

    33

error:

    34

    // cleanup

    35

    if (cache)

    36

        pt_cache_destroy(cache);

    37

    38

    return -1;

    39

}

    40

    41

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

    42

{

    43

    struct pt_cache *cache;

    44

    45

    // alloc

    47

        return -1;

    48

    49

    // ok

    50

    *cache_ptr = cache;

    51

    52

    return 0;

    53

}

    54

    55

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

    56

{

    57

    struct stat st_img, st_cache;

    58

    59

    // test original file

    60

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

    61

        return -1;

    62

    63

    // test cache file

    64

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

    65

        // always stale if it doesn't exist yet

    66

        if (errno == ENOENT)

    67

            return 1;

    68

        else

    69

            return -1;

    70

    }

    71

    72

    // compare mtime

    73

    return (st_img.st_mtime > st_cache.st_mtime);

    74

}

    75

    76

/**

    77

 * Abort any incomplete open operation, cleaning up

    78

 */

    79

static void pt_cache_abort (struct pt_cache *cache)

    80

{

    81

    if (cache->mmap != NULL) {

    82

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

    83

    84

        cache->mmap = NULL;

    85

    }

    86

    87

    if (cache->fd >= 0) {

    88

        close(cache->fd);

    89

    90

        cache->fd = -1;

    91

    }

    92

}

    93

    94

/**

    95

 * Open the cache file as an fd.

    96

 *

    97

 * XXX: needs locking

    98

 */

    99

static int pt_cache_open_fd (struct pt_cache *cache, int *fd_ptr)

   100

{

   101

    int fd;

   102

    int flags = 0;

   103

   104

    // determine open flags

   105

    // XXX: O_RDONLY | O_WRONLY == O_RDWR?

   106

    if (cache->mode & PT_IMG_READ)

   107

        flags |= O_RDONLY;

   108

   109

    if (cache->mode & PT_IMG_WRITE)

   110

        flags |= (O_WRONLY | O_CREAT);

   111

   112

    // actual open()

   113

    if ((fd = open(cache->path, flags)) < 0)

   114

        return -1;

   115

   116

    // ok

   117

    *fd_ptr = fd;

   118

   119

    return 0;

   120

}

   121

   122

/**

   123

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

   124

 */

   125

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

   126

{

   127

    int prot = 0;

   128

    void *addr;

   129

   130

    // determine prot

   131

    if (cache->mode & PT_IMG_READ)

   132

        prot |= PROT_READ;

   133

   134

    if (cache->mode & PT_IMG_WRITE)

   135

        prot |= PROT_WRITE;

   136

   137

    // perform mmap() from second page on

   138

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

   139

        return -1;

   140

   141

    // ok

   142

    *addr_ptr = addr;

   143

   144

    return 0;

   145

}

   146

   147

/**

   148

 * Write out the cache header into the opened file

   149

 */

   150

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

   151

{

   152

    size_t len = sizeof(*header);

   153

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

   154

   155

    // seek to start

   156

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

   157

        return -1;

   158

   159

    // write out full header

   160

    while (len) {

   161

        ssize_t ret;

   162

   163

        // try and write out the header

   164

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

   165

            return -1;

   166

   167

        // update offset

   168

        buf += ret;

   169

        len -= ret;

   170

    }

   171

   172

    // done

   173

    return 0;

   174

}

   175

   176

/**

   177

 * Create a new cache file, open it, and write out the header.

   178

 */

   179

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

   180

{

   181

    // no access

   182

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

   183

        errno = EPERM;

   184

        return -1;

   185

    }

   186

   187

    // open

   188

    if (pt_cache_open_fd(cache, &cache->fd))

   189

        return -1;

   190

   191

    // calculate data size

   192

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

   193

   194

    // grow file

   195

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

   196

        goto error;

   197

   198

    // open mmap

   199

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

   200

        goto error;

   201

   202

    // write header

   203

    if (pt_cache_write_header(cache, header))

   204

        goto error;

   205

   206

    // done

   207

    return 0;

   208

   209

error:

   210

    // cleanup

   211

    pt_cache_abort(cache);

   212

   213

    return -1;

   214

}

   215

   216

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

   217

{

   218

    struct pt_cache_header header;

   219

   220

    // XXX: check cache_mode

   221

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

   222

   223

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

   224

   225

    // fill in basic info

   226

    header.width = png_get_image_width(png, info);

   227

    header.height = png_get_image_height(png, info);

   228

    header.bit_depth = png_get_bit_depth(png, info);

   229

    header.color_type = png_get_color_type(png, info);

   230

   231

    // fill in other info

   232

    header.row_bytes = png_get_rowbytes(png, info);

   233

   234

    // create and write out header

   235

    if (pt_cache_open_create(cache, &header))

   236

        return -1;

   237

   238

    // XXX: pallette etc.

   239

   240

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

   241

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

   242

        // read row data, non-interlaced

   243

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

   244

    }

   245

   246

    // done!

   247

    return 0;

   248

}

   249

   250

void pt_cache_destroy (struct pt_cache *cache)

   251

{

   252

    free(cache->path);

   253

   254

    pt_cache_abort(cache);

   255

   256

    free(cache);

   257

}