hb-blob.c

   1 // C99 port from c++ is protected by a GNU Lesser GPLv3
   2 // Copyright © 2013 Sylvain BERTRAND <sylvain.bertrand@gmail.com>
   3 //                                   <sylware@legeek.net>
   4 #include <stdlib.h>
   5 #include <unistd.h>
   6 #include <sys/mman.h>
   7 #include <string.h>
   8
   9 #include "hb.h"
  10 #include "hb-private.h"
  11 #include "hb-atomic-private.h"
  12 #include "hb-open-file-private.h"
  13 #include "hb-blob-private.h"
  14
  15 struct hb_blob_t {
  16   atomic_int32_t ref_cnt;
  17   hb_bool_t immutable;
  18
  19   const char *data;
  20   unsigned length;
  21   hb_memory_mode_t mode;
  22
  23   void *user_data;
  24   hb_destroy_func_t destroy;
  25 };
  26
  27 static hb_blob_t hb_blob_nil = {
  28     REF_CNT_INVALID_VAL,//ref_cnt
  29     TRUE,//immutable
  30     NULL,//data
  31     0,//length
  32     HB_MEMORY_MODE_READONLY,//mode
  33     NULL,//user_data
  34     NULL//destroy
  35   };
  36
  37 hb_blob_t *
  38 hb_blob_get_empty(void)
  39 {
  40   return &hb_blob_nil;
  41 }
  42
  43 hb_blob_t *
  44 hb_blob_reference(hb_blob_t *blob)
  45 {
  46   if (hb_atomic_int32_get(&blob->ref_cnt) != REF_CNT_INVALID_VAL)
  47     hb_atomic_int32_add(&blob->ref_cnt, 1);
  48   return blob;
  49 }
  50
  51 void
  52 hb_blob_make_immutable(hb_blob_t *blob)
  53 {
  54   if (hb_atomic_int32_get(&blob->ref_cnt) == REF_CNT_INVALID_VAL)
  55     return;
  56   blob->immutable = TRUE;
  57 }
  58
  59 unsigned
  60 hb_blob_get_length(hb_blob_t *blob)
  61 {
  62   return blob->length;
  63 }
  64
  65 const char *
  66 hb_blob_get_data(hb_blob_t *blob, unsigned *length)
  67 {
  68   if (length)
  69     *length = blob->length;
  70   return blob->data;
  71 }
  72
  73 static hb_bool_t
  74 try_make_writable_inplace_unix(hb_blob_t *blob)
  75 {
  76   uintptr_t pagesize = -1, mask, length;
  77   const char *addr;
  78
  79   pagesize = (uintptr_t)sysconf(_SC_PAGESIZE);
  80
  81   if ((uintptr_t) -1L == pagesize)
  82     return FALSE;
  83
  84   mask = ~(pagesize-1);
  85   addr = (const char*)(((uintptr_t)blob->data) & mask);
  86   length = (const char*)(((uintptr_t)blob->data + blob->length + pagesize-1)
  87                                                                 & mask)  - addr;
  88   if (-1 == mprotect((void*)addr, length, PROT_READ | PROT_WRITE))
  89     return FALSE;
  90
  91   blob->mode = HB_MEMORY_MODE_WRITABLE;
  92   return TRUE;
  93 }
  94
  95 static hb_bool_t
  96 try_writable_inplace(hb_blob_t *blob)
  97 {
  98   if (try_make_writable_inplace_unix(blob))
  99     return TRUE;
 100
 101   //Failed to make writable inplace, mark that
 102   blob->mode = HB_MEMORY_MODE_READONLY;
 103   return FALSE;
 104 }
 105
 106 static void
 107 hb_blob_destroy_user_data(hb_blob_t *blob)
 108 {
 109   if (blob->destroy) {
 110     blob->destroy(blob->user_data);
 111     blob->user_data = NULL;
 112     blob->destroy = NULL;
 113   }
 114 }
 115
 116 static hb_bool_t
 117 try_writable(hb_blob_t *blob)
 118 {
 119   if (blob->immutable)
 120     return FALSE;
 121
 122   if (blob->mode == HB_MEMORY_MODE_WRITABLE)
 123     return TRUE;
 124
 125   if (blob->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE
 126                                                   && try_writable_inplace(blob))
 127     return TRUE;
 128
 129   if (blob->mode == HB_MEMORY_MODE_WRITABLE)
 130     return TRUE;
 131
 132   char *new_data;
 133
 134   new_data = malloc(blob->length);
 135   if (!new_data)
 136     return FALSE;
 137
 138   memcpy(new_data, blob->data, blob->length);
 139   hb_blob_destroy_user_data(blob);
 140   blob->mode = HB_MEMORY_MODE_WRITABLE;
 141   blob->data = new_data;
 142   blob->user_data = new_data;
 143   blob->destroy = free;
 144   return TRUE;
 145 }
 146
 147 void
 148 hb_blob_destroy(hb_blob_t *blob)
 149 {
 150   if (!blob)
 151     return;
 152   if (hb_atomic_int32_get(&blob->ref_cnt) == REF_CNT_INVALID_VAL)
 153     return;
 154   hb_atomic_int32_add(&blob->ref_cnt, -1);
 155   if (hb_atomic_int32_get(&blob->ref_cnt) > 0)
 156     return;
 157   hb_atomic_int32_set(&blob->ref_cnt, REF_CNT_INVALID_VAL);
 158
 159   hb_blob_destroy_user_data(blob);
 160   free (blob);
 161 }
 162
 163 hb_blob_t *
 164 hb_blob_create_sub_blob(hb_blob_t *parent,
 165                         unsigned offset,
 166                         unsigned length)
 167 {
 168   hb_blob_t *blob;
 169
 170   if (!length || offset >= parent->length)
 171     return hb_blob_get_empty();
 172
 173   hb_blob_make_immutable(parent);
 174
 175   blob = hb_blob_create(parent->data + offset,
 176                         MIN(length, parent->length - offset),
 177                         HB_MEMORY_MODE_READONLY,
 178                         hb_blob_reference(parent),
 179                         (hb_destroy_func_t)hb_blob_destroy);
 180   return blob;
 181 }
 182
 183 hb_blob_t *
 184 hb_blob_create(const char *data,
 185                unsigned length,
 186                hb_memory_mode_t mode,
 187                void *user_data,
 188                hb_destroy_func_t destroy)
 189 {
 190   hb_blob_t *blob = calloc(1, sizeof(*blob));
 191   if (!length || !blob) {
 192     if (blob)
 193       free(blob);
 194     if (destroy)
 195       destroy(user_data);
 196     return hb_blob_get_empty();
 197   }
 198   hb_atomic_int32_set(&blob->ref_cnt, 1);
 199   blob->immutable = FALSE;
 200
 201   blob->data = data;
 202   blob->length = length;
 203   blob->mode = mode;
 204
 205   blob->user_data = user_data;
 206   blob->destroy = destroy;
 207
 208   if (blob->mode == HB_MEMORY_MODE_DUPLICATE) {
 209     blob->mode = HB_MEMORY_MODE_READONLY;
 210     if (!try_writable(blob)) {
 211       hb_blob_destroy(blob);
 212       return hb_blob_get_empty();
 213     }
 214   }
 215   return blob;
 216 }
 217
 218 struct ot_fnt_file *
 219 hb_blob_lock_instance(hb_blob_t *blob)
 220 {
 221     hb_blob_make_immutable (blob);
 222     const char *base = hb_blob_get_data(blob, NULL);
 223     return (struct ot_fnt_file*)base;
 224 }