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

    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

    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)

    71

        else

    72

            return -1;

    73

    }

    74

    75

    // compare mtime

    81

}

    82

    83

/**

    84

 * Abort any incomplete open operation, cleaning up

    85

 */

    86

static void pt_cache_abort (struct pt_cache *cache)

    87

{

    88

    if (cache->header != NULL) {

    89

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

    90

    91

        cache->header = NULL;

    92

        cache->data = NULL;

    93

    }

    94

    95

    if (cache->fd >= 0) {

    96

        close(cache->fd);

    97

    98

        cache->fd = -1;

    99

    }

   100

}

   101

   102

/**

   103

 * Open the cache file as an fd for reading

   104

 *

   105

 * XXX: needs locking

   106

 */

   107

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

   108

{

   109

    int fd;

   110

   111

    // actual open()

   112

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

   113

        return -1;

   114

   115

    // ok

   116

    *fd_ptr = fd;

   117

   118

    return 0;

   119

}

   120

   121

/**

   122

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

   123

 */

   124

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

   125

{

   126

    int fd;

   127

    char tmp_path[1024];

   128

   129

    // check mode

   130

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

   131

        errno = EPERM;

   132

        return -1;

   133

    }

   134

   135

    // get .tmp path

   136

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

   137

        return -1;

   138

   139

    // open for write, create

   140

    // XXX: locking?

   141

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

   142

        return -1;

   143

   144

    // ok

   145

    *fd_ptr = fd;

   146

   147

    return 0;

   148

}

   149

   150

   151

/**

   152

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

   153

 */

   154

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

   155

{

   156

    int prot = 0;

   157

    void *addr;

   158

   159

    // determine prot

   160

    prot |= PROT_READ;

   161

   162

    if (cache->mode & PT_IMG_WRITE)

   163

        prot |= PROT_WRITE;

   164

   165

    // perform mmap() from second page on

   166

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

   167

        return -1;

   168

   169

    // ok

   170

    *addr_ptr = addr;

   171

   172

    return 0;

   173

}

   174

   175

/**

   176

 * Write out the cache header into the opened file

   177

 */

   178

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

   179

{

   180

    size_t len = sizeof(*header);

   181

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

   182

   183

    // seek to start

   184

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

   185

        return -1;

   186

   187

    // write out full header

   188

    while (len) {

   189

        ssize_t ret;

   190

   191

        // try and write out the header

   192

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

   193

            return -1;

   194

   195

        // update offset

   196

        buf += ret;

   197

        len -= ret;

   198

    }

   199

   200

    // done

   201

    return 0;

   202

}

   203

   204

/**

   205

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

   206

 */

   207

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

   208

{

   209

    void *base;

   210

   211

    // no access

   212

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

   213

        errno = EPERM;

   214

        return -1;

   215

    }

   216

   217

    // open as .tmp

   218

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

   219

        return -1;

   220

   221

    // calculate data size

   222

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

   223

   224

    // grow file

   225

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

   226

        goto error;

   227

   228

    // mmap header and data

   229

    if (pt_cache_open_mmap(cache, &base))

   230

        goto error;

   231

   232

    cache->header = base;

   233

    cache->data = base + PT_CACHE_HEADER_SIZE;

   234

   235

    // write header

   236

    // XXX: should just mmap...

   237

    if (pt_cache_write_header(cache, header))

   238

        goto error;

   239

   240

    // done

   241

    return 0;

   242

   243

error:

   244

    // cleanup

   245

    pt_cache_abort(cache);

   246

   247

    return -1;

   248

}

   249

   250

/**

   251

 * Rename the opened .tmp to .cache

   252

 */

   253

static int pt_cache_create_done (struct pt_cache *cache)

   254

{

   255

    char tmp_path[1024];

   256

   257

    // get .tmp path

   258

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

   259

        return -1;

   260

   261

    // rename

   262

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

   263

        return -1;

   264

   265

    // ok

   266

    return 0;

   267

}

   268

   269

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

   270

{

   271

    struct pt_cache_header header;

   272

   273

    // XXX: check cache_mode

   274

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

   275

   276

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

   277

   278

    // fill in basic info

   279

    header.width = png_get_image_width(png, info);

   280

    header.height = png_get_image_height(png, info);

   281

    header.bit_depth = png_get_bit_depth(png, info);

   282

    header.color_type = png_get_color_type(png, info);

   283

   284

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

   285

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

   286

    );

   287

   288

    // fill in other info

   289

    header.row_bytes = png_get_rowbytes(png, info);

   290

   291

    log_debug("row_bytes=%u", header.row_bytes);

   292

   293

    // palette etc.

   294

    if (header.color_type == PNG_COLOR_TYPE_PALETTE) {

   295

        int num_palette;

   296

        png_colorp palette;

   297

   298

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

   299

            // XXX: PLTE chunk not read?

   300

            return -1;

   301

   302

        // should only be 256 of them at most

   303

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   304

   305

        // copy

   306

        header.num_palette = num_palette;

   307

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

   308

   309

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

   310

    }

   311

   312

   313

    // create .tmp and write out header

   314

    if (pt_cache_open_create(cache, &header))

   315

        return -1;

   316

   317

   318

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

   319

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

   320

        // read row data, non-interlaced

   321

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

   322

    }

   323

   324

   325

    // move from .tmp to .cache

   326

    if (pt_cache_create_done(cache))

   327

        return -1;

   328

   329

    // done!

   330

    return 0;

   331

}

   332

   333

void pt_cache_destroy (struct pt_cache *cache)

   334

{

   335

    free(cache->path);

   336

   337

    pt_cache_abort(cache);

   338

   339

    free(cache);

   340

}