src/cache.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2008 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <stdio.h>
  20 #include <glib.h>
  21 #include <string.h>
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include "cache.h"
  28 #include "mem.h"
  29
  30 static gboolean valid_key(const guchar *key, gsize len)
  31 {
  32     gint b;
  33
  34     for (b = 0; b < len; b++) {
  35         if (key[b])
  36             return TRUE;
  37     }
  38
  39     return FALSE;
  40 }
  41
  42 gboolean cache_get_mutex(const guchar *md5filename, pth_mutex_t **result)
  43 {
  44     void *p;
  45     glong len;
  46     file_cache_t f;
  47
  48     for (p = key_cache, len = 0; len <= cache_size;) {
  49         memcpy(&f, p, sizeof(file_cache_t));
  50
  51         if (f.used == TRUE) {
  52             if (memcmp(&f.filename, md5filename, sizeof(f.filename)) == 0) {
  53                 *result = f.mutex;
  54                 memset(&f, 0, sizeof(file_cache_t));
  55                 return *result ? TRUE : FALSE;
  56             }
  57         }
  58
  59         p += sizeof(file_cache_t);
  60         len += sizeof(file_cache_t);
  61
  62         if (len + sizeof(file_cache_t) > cache_size)
  63             break;
  64     }
  65
  66     memset(&f, 0, sizeof(file_cache_t));
  67     return FALSE;
  68 }
  69
  70 gint cache_file_count()
  71 {
  72     void *p;
  73     gint n = 0;
  74     glong len;
  75     file_cache_t f;
  76
  77     for (p = key_cache, len = 0; len <= cache_size;) {
  78         memcpy(&f, p, sizeof(file_cache_t));
  79
  80         if (f.used == TRUE && valid_key(f.key, sizeof(f.key)) == TRUE)
  81             n++;
  82
  83         p += sizeof(file_cache_t);
  84         len += sizeof(file_cache_t);
  85
  86         if (len + sizeof(file_cache_t) > cache_size)
  87             break;
  88     }
  89
  90     memset(&f, 0, sizeof(file_cache_t));
  91     return n;
  92 }
  93
  94 void cache_adjust_timer()
  95 {
  96     file_cache_t f;
  97     void *p;
  98     glong len;
  99
 100     for (p = key_cache, len = 0; len <= cache_size;) {
 101         memcpy(&f, p, sizeof(file_cache_t));
 102
 103         if (f.used == TRUE && f.reset >= 0) {
 104             if (f.timeout > 0)
 105                 f.timeout--;
 106
 107             if (f.timeout == 0) {
 108                 if (valid_key(f.key, sizeof(f.key)) == TRUE) {
 109                     memset(&f.key, 0, sizeof(f.key));
 110                     send_cache_status_all();
 111                 }
 112
 113                 f.timeout = -1;
 114             }
 115
 116             memcpy(p, &f, sizeof(file_cache_t));
 117         }
 118
 119         p += sizeof(file_cache_t);
 120         len += sizeof(file_cache_t);
 121
 122         if (len + sizeof(file_cache_t) > cache_size)
 123             break;
 124     }
 125
 126     memset(&f, 0, sizeof(file_cache_t));
 127 }
 128
 129 gboolean cache_add_file(const guchar *md5file, const guchar *shakey)
 130 {
 131     void *p;
 132     file_cache_t f;
 133     gint nfiles = cache_file_count();
 134     glong len;
 135
 136     /*
 137      * Make sure there is enough secure memory.
 138      */
 139     if (!md5file || (nfiles + 1) * sizeof(file_cache_t) > cache_size)
 140         return FALSE;
 141
 142     /*
 143      * Find the first available "slot".
 144      */
 145     for (p = key_cache, len = 0; len <= cache_size;) {
 146         memcpy(&f, p, sizeof(file_cache_t));
 147
 148         if (f.used == FALSE) {
 149             memset(&f, 0, sizeof(file_cache_t));
 150             f.mutex = xmalloc(sizeof(pth_mutex_t));
 151
 152             if (!f.mutex)
 153                 return FALSE;
 154
 155             pth_mutex_init(f.mutex);
 156             memcpy(&f.filename, md5file, sizeof(f.filename));
 157
 158             if (shakey)
 159                 memcpy(&f.key, shakey, sizeof(f.key));
 160
 161             f.used = TRUE;
 162             f.reset = f.timeout = -2;
 163             memcpy(p, &f, sizeof(file_cache_t));
 164             memset(&f, 0, sizeof(file_cache_t));
 165             return TRUE;
 166         }
 167
 168         p += sizeof(file_cache_t);
 169         len += sizeof(file_cache_t);
 170
 171         if (len + sizeof(file_cache_t) > cache_size)
 172             break;
 173     }
 174
 175     memset(&f, 0, sizeof(file_cache_t));
 176     return FALSE;
 177 }
 178
 179 static void reset_entry(file_cache_t *f)
 180 {
 181     pth_mutex_t *m = f->mutex;
 182
 183     if (!f->refcount && m) {
 184         xfree(m);
 185         memset(f, 0, sizeof(file_cache_t));
 186     }
 187     else
 188         memset(f->key, 0, sizeof(f->key));
 189 }
 190
 191 gboolean cache_clear(const guchar *md5filename, gint which)
 192 {
 193     void *p;
 194     file_cache_t f;
 195     glong len;
 196
 197     for (p = key_cache, len = 0; len <= cache_size;) {
 198         memcpy(&f, p, sizeof(file_cache_t));
 199
 200         if (which == 2) {
 201             reset_entry(&f);
 202             memcpy(p, &f, sizeof(file_cache_t));
 203             memset(&f, 0, sizeof(file_cache_t));
 204         }
 205         else if (f.used == TRUE && which == 1) {
 206             if (memcmp(&f.filename, md5filename, sizeof(f.filename)) == 0) {
 207                 reset_entry(&f);
 208                 memcpy(p, &f, sizeof(file_cache_t));
 209
 210                 if (f.reset)
 211                     send_cache_status_all();
 212
 213                 memset(&f, 0, sizeof(file_cache_t));
 214                 return TRUE;
 215             }
 216         }
 217
 218         p += sizeof(file_cache_t);
 219         len += sizeof(file_cache_t);
 220
 221         if (len + sizeof(file_cache_t) > cache_size)
 222             break;
 223     }
 224
 225     memset(&f, 0, sizeof(file_cache_t));
 226
 227     if (which == 2) {
 228         send_cache_status_all();
 229         return TRUE;
 230     }
 231
 232     return FALSE;
 233 }
 234
 235 gboolean cache_iscached(const guchar *md5filename)
 236 {
 237     void *p;
 238     file_cache_t f;
 239     glong len;
 240     gboolean ret = FALSE;
 241
 242     for (p = key_cache, len = 0; len <= cache_size;) {
 243         memcpy(&f, p, sizeof(file_cache_t));
 244
 245         if (f.used == TRUE) {
 246             if (memcmp(&f.filename, md5filename, sizeof(f.filename)) == 0) {
 247                 ret = valid_key(f.key, sizeof(f.key));
 248                 memset(&f, 0, sizeof(file_cache_t));
 249                 return ret;
 250             }
 251         }
 252
 253         p += sizeof(file_cache_t);
 254         len += sizeof(file_cache_t);
 255
 256         if (len + sizeof(file_cache_t) > cache_size)
 257             break;
 258     }
 259
 260     memset(&f, 0, sizeof(file_cache_t));
 261     return FALSE;
 262 }
 263
 264 gboolean cache_reset_timeout(const guchar *md5filename, glong timeout)
 265 {
 266     void *p;
 267     file_cache_t f;
 268     glong len;
 269     glong t = -2;
 270
 271     if (!md5filename)
 272         return FALSE;
 273
 274     for (p = key_cache, len = 0; len <= cache_size;) {
 275         memcpy(&f, p, sizeof(file_cache_t));
 276
 277         if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 278             t = f.reset;
 279             break;
 280         }
 281
 282         p += sizeof(file_cache_t);
 283         len += sizeof(file_cache_t);
 284
 285         if (len + sizeof(file_cache_t) > cache_size)
 286             break;
 287     }
 288
 289     memset(&f, 0, sizeof(file_cache_t));
 290
 291     if (t == -2)
 292         return cache_set_timeout(md5filename, timeout);
 293
 294     return cache_set_timeout(md5filename, t);
 295 }
 296
 297 gboolean cache_set_timeout(const guchar *md5filename, glong timeout)
 298 {
 299     void *p;
 300     file_cache_t f;
 301     glong len;
 302
 303     for (p = key_cache, len = 0; len <= cache_size;) {
 304         memcpy(&f, p, sizeof(file_cache_t));
 305
 306         if (md5filename) {
 307             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 308                 if (timeout == -2)
 309                     f.timeout = f.reset;
 310                 else
 311                     f.reset = f.timeout = timeout;
 312
 313                 memcpy(p, &f, sizeof(file_cache_t));
 314                 memset(&f, 0, sizeof(file_cache_t));
 315                 return TRUE;
 316             }
 317         }
 318
 319         p += sizeof(file_cache_t);
 320         len += sizeof(file_cache_t);
 321
 322         if (len + sizeof(file_cache_t) > cache_size)
 323             break;
 324     }
 325
 326     memset(&f, 0, sizeof(file_cache_t));
 327     return (md5filename) ? FALSE : TRUE;
 328 }
 329
 330 gboolean cache_update_key(const guchar *md5filename, const guchar *shakey)
 331 {
 332     void *p;
 333     file_cache_t f;
 334     glong len;
 335
 336     for (p = key_cache, len = 0; len <= cache_size;) {
 337         memcpy(&f, p, sizeof(file_cache_t));
 338
 339         if (f.used == TRUE) {
 340             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 341                 if (f.reset)
 342                     memcpy(&f.key, shakey, sizeof(f.key));
 343
 344                 memcpy(p, &f, sizeof(file_cache_t));
 345                 memset(&f, 0, sizeof(file_cache_t));
 346                 return TRUE;
 347             }
 348         }
 349
 350         p += sizeof(file_cache_t);
 351         len += sizeof(file_cache_t);
 352
 353         if (len + sizeof(file_cache_t) > cache_size)
 354             break;
 355     }
 356
 357     memset(&f, 0, sizeof(file_cache_t));
 358     return cache_add_file(md5filename, shakey);
 359 }
 360
 361 gboolean cache_get_key(const guchar *md5file, guchar *shakey)
 362 {
 363     void *p;
 364     file_cache_t f;
 365     glong len;
 366
 367     for (p = key_cache, len = 0; len <= cache_size;) {
 368         memcpy(&f, p, sizeof(file_cache_t));
 369
 370         /*
 371          * The slot may be used but not yet contain a key.
 372          */
 373         if (f.used == TRUE) {
 374             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 375                 if (valid_key(f.key, sizeof(f.key)) == FALSE)
 376                     goto fail;
 377
 378                 memcpy(shakey, &f.key, sizeof(f.key));
 379                 memset(&f, 0, sizeof(file_cache_t));
 380                 return TRUE;
 381             }
 382         }
 383
 384         p += sizeof(file_cache_t);
 385         len += sizeof(file_cache_t);
 386
 387         if (len + sizeof(file_cache_t) > cache_size)
 388             break;
 389     }
 390
 391 fail:
 392     memset(&f, 0, sizeof(file_cache_t));
 393     return FALSE;
 394 }
 395
 396 gboolean cache_has_file(const guchar *md5file)
 397 {
 398     void *p;
 399     file_cache_t f;
 400     glong len;
 401
 402     for (p = key_cache, len = 0; len <= cache_size;) {
 403         memcpy(&f, p, sizeof(file_cache_t));
 404
 405         if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 406             memset(&f, 0, sizeof(file_cache_t));
 407             return TRUE;
 408         }
 409
 410         p += sizeof(file_cache_t);
 411         len += sizeof(file_cache_t);
 412
 413         if (len + sizeof(file_cache_t) > cache_size)
 414             break;
 415     }
 416
 417     memset(&f, 0, sizeof(file_cache_t));
 418     return FALSE;
 419 }
 420
 421 gboolean cache_decr_refcount(const guchar *md5file)
 422 {
 423     void *p;
 424     file_cache_t f;
 425     glong len;
 426
 427     for (p = key_cache, len = 0; len <= cache_size;) {
 428         memcpy(&f, p, sizeof(file_cache_t));
 429
 430         if (f.used == TRUE) {
 431             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 432                 f.refcount--;
 433
 434                 if (f.refcount < 0)
 435                     f.refcount = 0;
 436
 437                 memcpy(p, &f, sizeof(file_cache_t));
 438                 memset(&f, 0, sizeof(file_cache_t));
 439                 return TRUE;
 440             }
 441         }
 442
 443         p += sizeof(file_cache_t);
 444         len += sizeof(file_cache_t);
 445
 446         if (len + sizeof(file_cache_t) > cache_size)
 447             break;
 448     }
 449
 450     memset(&f, 0, sizeof(file_cache_t));
 451     return FALSE;
 452 }
 453
 454 gboolean cache_incr_refcount(const guchar *md5file)
 455 {
 456     void *p;
 457     file_cache_t f;
 458     glong len;
 459
 460     for (p = key_cache, len = 0; len <= cache_size;) {
 461         memcpy(&f, p, sizeof(file_cache_t));
 462
 463         if (f.used == TRUE) {
 464             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 465                 f.refcount++;
 466                 memcpy(p, &f, sizeof(file_cache_t));
 467                 memset(&f, 0, sizeof(file_cache_t));
 468                 return TRUE;
 469             }
 470         }
 471
 472         p += sizeof(file_cache_t);
 473         len += sizeof(file_cache_t);
 474
 475         if (len + sizeof(file_cache_t) > cache_size)
 476             break;
 477     }
 478
 479     memset(&f, 0, sizeof(file_cache_t));
 480     return FALSE;
 481 }