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

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

    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

int pt_cache_info (struct pt_cache *cache, struct pt_image_info *info)

    69

{

    70

    // ensure open

    71

    if (pt_cache_open(cache))

    72

        return -1;

    73

    74

    info->width = cache->header->width;

    75

    info->height = cache->header->height;

    76

    77

    return 0;

    78

}

    79

    80

/**

    81

 * Abort any incomplete open operation, cleaning up

    82

 */

    83

static void pt_cache_abort (struct pt_cache *cache)

    84

{

    85

    if (cache->header != NULL) {

    86

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

    87

    88

        cache->header = NULL;

    89

        cache->data = NULL;

    90

    }

    91

    92

    if (cache->fd >= 0) {

    93

        close(cache->fd);

    94

    95

        cache->fd = -1;

    96

    }

    97

}

    98

    99

/**

   100

 * Open the cache file as an fd for reading

   101

 *

   102

 * XXX: needs locking

   103

 */

   104

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

   105

{

   106

    int fd;

   107

   108

    // actual open()

   109

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

   110

        return -1;

   111

   112

    // ok

   113

    *fd_ptr = fd;

   114

   115

    return 0;

   116

}

   117

   118

/**

   119

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

   120

 */

   121

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

   122

{

   123

    int fd;

   124

    char tmp_path[1024];

   125

   126

    // get .tmp path

   127

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

   128

        return -1;

   129

   130

    // open for write, create

   131

    // XXX: locking?

   132

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

   133

        return -1;

   134

   135

    // ok

   136

    *fd_ptr = fd;

   137

   138

    return 0;

   139

}

   140

   141

   142

/**

   143

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

   144

 */

   145

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

   146

{

   147

    int prot = 0;

   148

    void *addr;

   149

   150

    // determine prot

   151

    prot |= PROT_READ;

   152

   153

    if (!readonly) {

   154

        assert(cache->mode & PT_OPEN_UPDATE);

   155

   156

        prot |= PROT_WRITE;

   157

    }

   158

   159

    // perform mmap() from second page on

   160

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

   161

        return -1;

   162

   163

    // ok

   164

    *addr_ptr = addr;

   165

   166

    return 0;

   167

}

   168

   169

/**

   170

 * Read in the cache header from the open file

   171

 */

   172

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

   173

{

   174

    size_t len = sizeof(*header);

   175

    char *buf = (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 = read(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

/**

   199

 * Write out the cache header into the opened file

   200

 */

   201

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

   202

{

   203

    size_t len = sizeof(*header);

   204

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

   205

   206

    // seek to start

   207

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

   208

        return -1;

   209

   210

    // write out full header

   211

    while (len) {

   212

        ssize_t ret;

   213

   214

        // try and write out the header

   215

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

   216

            return -1;

   217

   218

        // update offset

   219

        buf += ret;

   220

        len -= ret;

   221

    }

   222

   223

    // done

   224

    return 0;

   225

}

   226

   227

/**

   228

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

   229

 */

   230

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

   231

{

   232

    void *base;

   233

   234

    // no access

   235

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

   236

        errno = EPERM;

   237

        return -1;

   238

    }

   239

   240

    // open as .tmp

   241

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

   242

        return -1;

   243

   244

    // calculate data size

   245

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

   246

   247

    // grow file

   248

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

   249

        goto error;

   250

   251

    // mmap header and data

   252

    if (pt_cache_open_mmap(cache, &base, false))

   253

        goto error;

   254

   255

    cache->header = base;

   256

    cache->data = base + PT_CACHE_HEADER_SIZE;

   257

   258

    // write header

   259

    // XXX: should just mmap...

   260

    if (pt_cache_write_header(cache, header))

   261

        goto error;

   262

   263

    // done

   264

    return 0;

   265

   266

error:

   267

    // cleanup

   268

    pt_cache_abort(cache);

   269

   270

    return -1;

   271

}

   272

   273

/**

   274

 * Rename the opened .tmp to .cache

   275

 */

   276

static int pt_cache_create_done (struct pt_cache *cache)

   277

{

   278

    char tmp_path[1024];

   279

   280

    // get .tmp path

   281

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

   282

        return -1;

   283

   284

    // rename

   285

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

   286

        return -1;

   287

   288

    // ok

   289

    return 0;

   290

}

   291

   292

int pt_cache_open (struct pt_cache *cache)

   293

{

   294

    struct pt_cache_header header;

   295

    void *base;

   296

   297

    // ignore if already open

   298

    if (cache->header && cache->data)

   299

        return 0;

   300

   301

    // open the .cache

   302

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

   303

        return -1;

   304

   305

    // read in header

   306

    if (pt_cache_read_header(cache, &header))

   307

        return -1;

   308

   309

    // calculate data size

   310

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

   311

   312

    // mmap header and data

   313

    if (pt_cache_open_mmap(cache, &base, true))

   314

        goto error;

   315

   316

    cache->header = base;

   317

    cache->data = base + PT_CACHE_HEADER_SIZE;

   318

   319

    // done

   320

    return 0;

   321

   322

error:

   323

    // cleanup

   324

    pt_cache_abort(cache);

   325

   326

    return -1;

   327

}

   328

   329

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

   330

{

   331

    struct pt_cache_header header;

   332

   333

    // XXX: check cache_mode

   334

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

   335

    // XXX: close any already-opened cache file

   336

   337

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

   338

   339

    // fill in basic info

   340

    header.width = png_get_image_width(png, info);

   341

    header.height = png_get_image_height(png, info);

   342

    header.bit_depth = png_get_bit_depth(png, info);

   343

    header.color_type = png_get_color_type(png, info);

   344

   345

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

   346

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

   347

    );

   348

   349

    // only pack 1 pixel per byte, changes rowbytes

   350

    if (header.bit_depth < 8)

   351

        png_set_packing(png);

   352

   353

    // fill in other info

   354

    header.row_bytes = png_get_rowbytes(png, info);

   355

   356

    // calculate bpp as num_channels * bpc

   357

    // XXX: this assumes the packed bit depth will be either 8 or 16

   358

    header.col_bytes = png_get_channels(png, info) * (header.bit_depth == 16 ? 2 : 1);

   359

   360

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

   361

   362

    // palette etc.

   363

    if (header.color_type == PNG_COLOR_TYPE_PALETTE) {

   364

        int num_palette;

   365

        png_colorp palette;

   366

   367

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

   368

            // XXX: PLTE chunk not read?

   369

            return -1;

   370

   371

        // should only be 256 of them at most

   372

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   373

   374

        // copy

   375

        header.num_palette = num_palette;

   376

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

   377

   378

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

   379

    }

   380

   381

    // create .tmp and write out header

   382

    if (pt_cache_create(cache, &header))

   383

        return -1;

   384

   385

   386

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

   387

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

   388

        // read row data, non-interlaced

   389

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

   390

    }

   391

   392

   393

    // move from .tmp to .cache

   394

    if (pt_cache_create_done(cache))

   395

        return -1;

   396

   397

    // done!

   398

    return 0;

   399

}

   400

   490

int pt_cache_tile_png (struct pt_cache *cache, png_structp png, png_infop info, const struct pt_tile_info *ti)

   491

{