1

#include "cache.h"

     2

#include "shared/util.h"

     3

#include "shared/log.h" // only LOG_DEBUG

     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>

    12

#include <assert.h>

    13

    14

    16

{

    17

    struct pt_cache *cache;

    18

    19

    // alloc

    20

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

    21

        return -1;

    22

    23

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

    24

        goto error;

    25

    26

    // init

    27

    cache->fd = -1;

    28

    cache->mode = mode;

    29

    30

    // ok

    31

    *cache_ptr = cache;

    32

    33

    return 0;

    34

    35

error:

    36

    // cleanup

    37

    if (cache)

    38

        pt_cache_destroy(cache);

    39

    40

    return -1;

    41

}

    42

    43

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

    44

{

    45

    struct stat st_img, st_cache;

    46

    47

    // test original file

    48

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

    49

        return -1;

    50

    51

    // test cache file

    52

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

    53

        // always stale if it doesn't exist yet

    54

        if (errno == ENOENT)

    55

            return PT_CACHE_NONE;

    56

        else

    57

            return -1;

    58

    }

    59

    60

    // compare mtime

    61

    if (st_img.st_mtime > st_cache.st_mtime)

    62

        return PT_CACHE_STALE;

    63

    64

    else

    65

        return PT_CACHE_FRESH;

    66

}

    67

    68

/**

    69

 * Abort any incomplete open operation, cleaning up

    70

 */

    71

static void pt_cache_abort (struct pt_cache *cache)

    72

{

    73

    if (cache->header != NULL) {

    74

        munmap(cache->header, PT_CACHE_HEADER_SIZE + cache->size);

    75

    76

        cache->header = NULL;

    77

        cache->data = NULL;

    78

    }

    79

    80

    if (cache->fd >= 0) {

    81

        close(cache->fd);

    82

    83

        cache->fd = -1;

    84

    }

    85

}

    86

    87

/**

    88

 * Open the cache file as an fd for reading

    89

 *

    90

 * XXX: needs locking

    91

 */

    92

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

    93

{

    94

    int fd;

    95

    96

    // actual open()

    97

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

    98

        return -1;

    99

   100

    // ok

   101

    *fd_ptr = fd;

   102

   103

    return 0;

   104

}

   105

   106

/**

   107

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

   108

 */

   109

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

   110

{

   111

    int fd;

   112

    char tmp_path[1024];

   113

   114

    // check mode

   115

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

   116

        errno = EPERM;

   117

        return -1;

   118

    }

   119

   120

    // get .tmp path

   121

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

   122

        return -1;

   123

   124

    // open for write, create

   125

    // XXX: locking?

   126

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

   127

        return -1;

   128

   129

    // ok

   130

    *fd_ptr = fd;

   131

   132

    return 0;

   133

}

   134

   135

   136

/**

   137

 * Mmap the opened cache file using PT_CACHE_HEADER_SIZE plus the calculated size stored in cache->size

   138

 */

   140

{

   141

    int prot = 0;

   142

    void *addr;

   143

   144

    // determine prot

   145

    prot |= PROT_READ;

   146

   150

        prot |= PROT_WRITE;

   152

   153

    // perform mmap() from second page on

   154

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

   155

        return -1;

   156

   157

    // ok

   158

    *addr_ptr = addr;

   159

   160

    return 0;

   161

}

   162

   163

/**

   193

 * Write out the cache header into the opened file

   194

 */

   195

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

   196

{

   197

    size_t len = sizeof(*header);

   198

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

   199

   200

    // seek to start

   201

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

   202

        return -1;

   203

   204

    // write out full header

   205

    while (len) {

   206

        ssize_t ret;

   207

   208

        // try and write out the header

   209

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

   210

            return -1;

   211

   212

        // update offset

   213

        buf += ret;

   214

        len -= ret;

   215

    }

   216

   217

    // done

   218

    return 0;

   219

}

   220

   221

/**

   222

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

   223

 */

   224

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

   225

{

   226

    void *base;

   227

   228

    // no access

   229

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

   230

        errno = EPERM;

   231

        return -1;

   232

    }

   233

   234

    // open as .tmp

   235

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

   236

        return -1;

   237

   238

    // calculate data size

   239

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

   240

   241

    // grow file

   242

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

   243

        goto error;

   244

   245

    // mmap header and data

   247

        goto error;

   248

   249

    cache->header = base;

   250

    cache->data = base + PT_CACHE_HEADER_SIZE;

   251

   252

    // write header

   253

    // XXX: should just mmap...

   254

    if (pt_cache_write_header(cache, header))

   255

        goto error;

   256

   257

    // done

   258

    return 0;

   259

   260

error:

   261

    // cleanup

   262

    pt_cache_abort(cache);

   263

   264

    return -1;

   265

}

   266

   267

/**

   268

 * Rename the opened .tmp to .cache

   269

 */

   270

static int pt_cache_create_done (struct pt_cache *cache)

   271

{

   272

    char tmp_path[1024];

   273

   274

    // get .tmp path

   275

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

   276

        return -1;

   277

   278

    // rename

   279

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

   280

        return -1;

   281

   282

    // ok

   283

    return 0;

   284

}

   285

   319

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

   320

{

   321

    struct pt_cache_header header;

   322

   323

    // XXX: check cache_mode

   324

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

   326

   327

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

   328

   329

    // fill in basic info

   330

    header.width = png_get_image_width(png, info);

   331

    header.height = png_get_image_height(png, info);

   332

    header.bit_depth = png_get_bit_depth(png, info);

   333

    header.color_type = png_get_color_type(png, info);

   334

   335

    log_debug("width=%u, height=%u, bit_depth=%u, color_type=%u", 

   336

            header.width, header.height, header.bit_depth, header.color_type

   337

    );

   338

   343

    // fill in other info

   344

    header.row_bytes = png_get_rowbytes(png, info);

   345

   351

   352

    // palette etc.

   353

    if (header.color_type == PNG_COLOR_TYPE_PALETTE) {

   354

        int num_palette;

   355

        png_colorp palette;

   356

   357

        if (png_get_PLTE(png, info, &palette, &num_palette) == 0)

   358

            // XXX: PLTE chunk not read?

   359

            return -1;

   360

   361

        // should only be 256 of them at most

   362

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   363

   364

        // copy

   365

        header.num_palette = num_palette;

   366

        memcpy(&header.palette, palette, num_palette * sizeof(*palette));

   367

   368

        log_debug("num_palette=%u", num_palette);

   369

    }

   370

   371

    // create .tmp and write out header

   372

    if (pt_cache_open_create(cache, &header))

   373

        return -1;

   374

   375

   376

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

   377

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

   378

        // read row data, non-interlaced

   379

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

   380

    }

   381

   382

   383

    // move from .tmp to .cache

   384

    if (pt_cache_create_done(cache))

   385

        return -1;

   386

   387

    // done!

   388

    return 0;

   389

}

   390

   429

void pt_cache_destroy (struct pt_cache *cache)

   430

{

   431

    free(cache->path);

   432

   433

    pt_cache_abort(cache);

   434

   435

    free(cache);

   436

}