1

#include "cache.h"

     2

#include "shared/util.h"

     4

     5

#include <stdlib.h>

     6

#include <unistd.h>

     7

#include <sys/types.h>

     8

#include <sys/stat.h>

     9

#include <fcntl.h>

    10

#include <sys/mman.h>

    11

#include <errno.h>

    13

    14

    15

    16

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

    17

{

    18

    struct pt_cache *cache;

    19

    20

    // alloc

    21

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

    22

        return -1;

    23

    24

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

    25

        goto error;

    26

    27

    // init

    28

    cache->fd = -1;

    29

    cache->mode = mode;

    30

    31

    // ok

    32

    *cache_ptr = cache;

    33

    34

    return 0;

    35

    36

error:

    37

    // cleanup

    38

    if (cache)

    39

        pt_cache_destroy(cache);

    40

    41

    return -1;

    42

}

    43

    44

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

    45

{

    46

    struct pt_cache *cache;

    47

    48

    // alloc

    49

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

    50

        return -1;

    51

    52

    // ok

    53

    *cache_ptr = cache;

    54

    55

    return 0;

    56

}

    57

    58

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

    59

{

    60

    struct stat st_img, st_cache;

    61

    62

    // test original file

    63

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

    64

        return -1;

    65

    66

    // test cache file

    67

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

    68

        // always stale if it doesn't exist yet

    69

        if (errno == ENOENT)

    70

            return 1;

    71

        else

    72

            return -1;

    73

    }

    74

    75

    // compare mtime

    76

    return (st_img.st_mtime > st_cache.st_mtime);

    77

}

    78

    79

/**

    80

 * Abort any incomplete open operation, cleaning up

    81

 */

    82

static void pt_cache_abort (struct pt_cache *cache)

    83

{

    84

    if (cache->mmap != NULL) {

    85

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

    86

    87

        cache->mmap = NULL;

    88

    }

    89

    90

    if (cache->fd >= 0) {

    91

        close(cache->fd);

    92

    93

        cache->fd = -1;

    94

    }

    95

}

    96

    97

/**

    98

 * Open the cache file as an fd for reading

    99

 *

   100

 * XXX: needs locking

   101

 */

   103

{

   104

    int fd;

   105

   106

    // actual open()

   107

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

   108

        return -1;

   109

   110

    // ok

   111

    *fd_ptr = fd;

   112

   113

    return 0;

   114

}

   115

   116

/**

   117

 * Open the .tmp cache file as an fd for writing

   118

 */

   120

{

   121

    int fd;

   122

    char tmp_path[1024];

   123

   124

    // check mode

   125

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

   126

        errno = EPERM;

   127

        return -1;

   128

    }

   129

   130

    // get .tmp path

   131

    if (path_with_fext(cache->path, tmp_path, sizeof(tmp_path), ".tmp"))

   132

        return -1;

   133

   134

    // open for write, create

   135

    // XXX: locking?

   136

    if ((fd = open(tmp_path, O_RDWR | O_CREAT, 0644)) < 0)

   137

        return -1;

   138

   139

    // ok

   140

    *fd_ptr = fd;

   141

   142

    return 0;

   143

}

   144

   145

   146

/**

   147

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

   148

 */

   149

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

   150

{

   151

    int prot = 0;

   152

    void *addr;

   153

   154

    // determine prot

   156

   157

    if (cache->mode & PT_IMG_WRITE)

   158

        prot |= PROT_WRITE;

   159

   160

    // perform mmap() from second page on

   161

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

   162

        return -1;

   163

   164

    // ok

   165

    *addr_ptr = addr;

   166

   167

    return 0;

   168

}

   169

   170

/**

   171

 * Write out the cache header into the opened file

   172

 */

   173

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

   174

{

   175

    size_t len = sizeof(*header);

   176

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

   177

   178

    // seek to start

   179

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

   180

        return -1;

   181

   182

    // write out full header

   183

    while (len) {

   184

        ssize_t ret;

   185

   186

        // try and write out the header

   187

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

   188

            return -1;

   189

   190

        // update offset

   191

        buf += ret;

   192

        len -= ret;

   193

    }

   194

   195

    // done

   196

    return 0;

   197

}

   198

   199

/**

   200

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

   201

 */

   202

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

   203

{

   204

    // no access

   205

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

   206

        errno = EPERM;

   207

        return -1;

   208

    }

   209

   210

    // open as .tmp

   212

        return -1;

   213

   214

    // calculate data size

   215

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

   216

   217

    // grow file

   218

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

   219

        goto error;

   220

   221

    // open mmap

   222

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

   223

        goto error;

   224

   225

    // write header

   226

    if (pt_cache_write_header(cache, header))

   227

        goto error;

   228

   229

    // done

   230

    return 0;

   231

   232

error:

   233

    // cleanup

   234

    pt_cache_abort(cache);

   235

   236

    return -1;

   237

}

   238

   239

/**

   240

 * Rename the opened .tmp to .cache

   241

 */

   242

static int pt_cache_create_done (struct pt_cache *cache)

   243

{

   244

    char tmp_path[1024];

   245

   246

    // get .tmp path

   247

    if (path_with_fext(cache->path, tmp_path, sizeof(tmp_path), ".tmp"))

   248

        return -1;

   249

   250

    // rename

   251

    if (rename(tmp_path, cache->path) < 0)

   252

        return -1;

   253

   254

    // ok

   255

    return 0;

   256

}

   257

   258

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

   259

{

   260

    struct pt_cache_header header;

   261

   262

    // XXX: check cache_mode

   263

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

   264

   265

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

   266

   267

    // fill in basic info

   268

    header.width = png_get_image_width(png, info);

   269

    header.height = png_get_image_height(png, info);

   270

    header.bit_depth = png_get_bit_depth(png, info);

   271

    header.color_type = png_get_color_type(png, info);

   272

   277

    // fill in other info

   278

    header.row_bytes = png_get_rowbytes(png, info);

   279

   300

    // create .tmp and write out header

   301

    if (pt_cache_open_create(cache, &header))

   302

        return -1;

   303

   304

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

   305

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

   306

        // read row data, non-interlaced

   307

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

   308

    }

   309

   310

    // move from .tmp to .cache

   311

    if (pt_cache_create_done(cache))

   312

        return -1;

   313

   314

    // done!

   315

    return 0;

   316

}

   317

   318

void pt_cache_destroy (struct pt_cache *cache)

   319

{

   320

    free(cache->path);

   321

   322

    pt_cache_abort(cache);

   323

   324

    free(cache);

   325

}