src/cache.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2007 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                 memset(&f.key, 0, sizeof(f.key));
 109                 f.timeout = -1;
 110                 send_cache_status_all();
 111             }
 112
 113             memcpy(p, &f, sizeof(file_cache_t));
 114         }
 115
 116         p += sizeof(file_cache_t);
 117         len += sizeof(file_cache_t);
 118
 119         if (len + sizeof(file_cache_t) > cache_size)
 120             break;
 121     }
 122
 123     memset(&f, 0, sizeof(file_cache_t));
 124 }
 125
 126 gboolean cache_add_file(const guchar *md5file, const guchar *shakey)
 127 {
 128     void *p;
 129     file_cache_t f;
 130     gint nfiles = cache_file_count();
 131     glong len;
 132
 133     /*
 134      * Make sure there is enough secure memory.
 135      */
 136     if (!md5file || (nfiles + 1) * sizeof(file_cache_t) > cache_size)
 137         return FALSE;
 138
 139     /*
 140      * Find the first available "slot".
 141      */
 142     for (p = key_cache, len = 0; len <= cache_size;) {
 143         memcpy(&f, p, sizeof(file_cache_t));
 144
 145         if (f.used == FALSE) {
 146             memset(&f, 0, sizeof(file_cache_t));
 147             f.mutex = xmalloc(sizeof(pth_mutex_t));
 148
 149             if (!f.mutex)
 150                 return FALSE;
 151
 152             pth_mutex_init(f.mutex);
 153             memcpy(&f.filename, md5file, sizeof(f.filename));
 154
 155             if (shakey)
 156                 memcpy(&f.key, shakey, sizeof(f.key));
 157
 158             f.used = TRUE;
 159             f.reset = f.timeout = -2;
 160             memcpy(p, &f, sizeof(file_cache_t));
 161             memset(&f, 0, sizeof(file_cache_t));
 162             return TRUE;
 163         }
 164
 165         p += sizeof(file_cache_t);
 166         len += sizeof(file_cache_t);
 167
 168         if (len + sizeof(file_cache_t) > cache_size)
 169             break;
 170     }
 171
 172     memset(&f, 0, sizeof(file_cache_t));
 173     return FALSE;
 174 }
 175
 176 static void reset_entry(file_cache_t *f)
 177 {
 178     pth_mutex_t *m = f->mutex;
 179
 180     if (!f->refcount && m) {
 181         xfree(m);
 182         memset(f, 0, sizeof(file_cache_t));
 183     }
 184     else
 185         memset(f->key, 0, sizeof(f->key));
 186 }
 187
 188 gboolean cache_clear(const guchar *md5filename, gint which)
 189 {
 190     void *p;
 191     file_cache_t f;
 192     glong len;
 193
 194     for (p = key_cache, len = 0; len <= cache_size;) {
 195         memcpy(&f, p, sizeof(file_cache_t));
 196
 197         if (which == 2) {
 198             reset_entry(&f);
 199             memcpy(p, &f, sizeof(file_cache_t));
 200             memset(&f, 0, sizeof(file_cache_t));
 201         }
 202         else if (f.used == TRUE && which == 1) {
 203             if (memcmp(&f.filename, md5filename, sizeof(f.filename)) == 0) {
 204                 reset_entry(&f);
 205                 memcpy(p, &f, sizeof(file_cache_t));
 206                 memset(&f, 0, sizeof(file_cache_t));
 207                 send_cache_status_all();
 208                 return TRUE;
 209             }
 210         }
 211
 212         p += sizeof(file_cache_t);
 213         len += sizeof(file_cache_t);
 214
 215         if (len + sizeof(file_cache_t) > cache_size)
 216             break;
 217     }
 218
 219     memset(&f, 0, sizeof(file_cache_t));
 220
 221     if (which == 2) {
 222         send_cache_status_all();
 223         return TRUE;
 224     }
 225
 226     return FALSE;
 227 }
 228
 229 gboolean cache_iscached(const guchar *md5filename)
 230 {
 231     void *p;
 232     file_cache_t f;
 233     glong len;
 234     gboolean ret = FALSE;
 235
 236     for (p = key_cache, len = 0; len <= cache_size;) {
 237         memcpy(&f, p, sizeof(file_cache_t));
 238
 239         if (f.used == TRUE) {
 240             if (memcmp(&f.filename, md5filename, sizeof(f.filename)) == 0) {
 241                 ret = valid_key(f.key, sizeof(f.key));
 242                 memset(&f, 0, sizeof(file_cache_t));
 243                 return ret;
 244             }
 245         }
 246
 247         p += sizeof(file_cache_t);
 248         len += sizeof(file_cache_t);
 249
 250         if (len + sizeof(file_cache_t) > cache_size)
 251             break;
 252     }
 253
 254     memset(&f, 0, sizeof(file_cache_t));
 255     return FALSE;
 256 }
 257
 258 gboolean cache_reset_timeout(const guchar *md5filename, glong timeout)
 259 {
 260     void *p;
 261     file_cache_t f;
 262     glong len;
 263     glong t = -2;
 264
 265     if (!md5filename)
 266         return FALSE;
 267
 268     for (p = key_cache, len = 0; len <= cache_size;) {
 269         memcpy(&f, p, sizeof(file_cache_t));
 270
 271         if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 272             t = f.reset;
 273             break;
 274         }
 275
 276         p += sizeof(file_cache_t);
 277         len += sizeof(file_cache_t);
 278
 279         if (len + sizeof(file_cache_t) > cache_size)
 280             break;
 281     }
 282
 283     memset(&f, 0, sizeof(file_cache_t));
 284
 285     if (t == -2)
 286         return cache_set_timeout(md5filename, timeout);
 287
 288     return cache_set_timeout(md5filename, t);
 289 }
 290
 291 gboolean cache_set_timeout(const guchar *md5filename, glong timeout)
 292 {
 293     void *p;
 294     file_cache_t f;
 295     glong len;
 296
 297     for (p = key_cache, len = 0; len <= cache_size;) {
 298         memcpy(&f, p, sizeof(file_cache_t));
 299
 300         if (md5filename) {
 301             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 302                 f.reset = f.timeout = timeout;
 303                 memcpy(p, &f, sizeof(file_cache_t));
 304                 memset(&f, 0, sizeof(file_cache_t));
 305                 return TRUE;
 306             }
 307         }
 308
 309         p += sizeof(file_cache_t);
 310         len += sizeof(file_cache_t);
 311
 312         if (len + sizeof(file_cache_t) > cache_size)
 313             break;
 314     }
 315
 316     memset(&f, 0, sizeof(file_cache_t));
 317     return (md5filename) ? FALSE : TRUE;
 318 }
 319
 320 gboolean cache_update_key(const guchar *md5filename, const guchar *shakey)
 321 {
 322     void *p;
 323     file_cache_t f;
 324     glong len;
 325
 326     for (p = key_cache, len = 0; len <= cache_size;) {
 327         memcpy(&f, p, sizeof(file_cache_t));
 328
 329         if (f.used == TRUE) {
 330             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 331                 memcpy(&f.key, shakey, sizeof(f.key));
 332                 memcpy(p, &f, sizeof(file_cache_t));
 333                 memset(&f, 0, sizeof(file_cache_t));
 334                 return TRUE;
 335             }
 336         }
 337
 338         p += sizeof(file_cache_t);
 339         len += sizeof(file_cache_t);
 340
 341         if (len + sizeof(file_cache_t) > cache_size)
 342             break;
 343     }
 344
 345     memset(&f, 0, sizeof(file_cache_t));
 346     return cache_add_file(md5filename, shakey);
 347 }
 348
 349 gboolean cache_get_key(const guchar *md5file, guchar *shakey)
 350 {
 351     void *p;
 352     file_cache_t f;
 353     glong len;
 354
 355     for (p = key_cache, len = 0; len <= cache_size;) {
 356         memcpy(&f, p, sizeof(file_cache_t));
 357
 358         /*
 359          * The slot may be used but not yet contain a key.
 360          */
 361         if (f.used == TRUE) {
 362             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 363                 if (valid_key(f.key, sizeof(f.key)) == FALSE)
 364                     goto fail;
 365
 366                 memcpy(shakey, &f.key, sizeof(f.key));
 367                 memset(&f, 0, sizeof(file_cache_t));
 368                 return TRUE;
 369             }
 370         }
 371
 372         p += sizeof(file_cache_t);
 373         len += sizeof(file_cache_t);
 374
 375         if (len + sizeof(file_cache_t) > cache_size)
 376             break;
 377     }
 378
 379 fail:
 380     memset(&f, 0, sizeof(file_cache_t));
 381     return FALSE;
 382 }
 383
 384 gboolean cache_has_file(const guchar *md5file)
 385 {
 386     void *p;
 387     file_cache_t f;
 388     glong len;
 389
 390     for (p = key_cache, len = 0; len <= cache_size;) {
 391         memcpy(&f, p, sizeof(file_cache_t));
 392
 393         if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 394             memset(&f, 0, sizeof(file_cache_t));
 395             return TRUE;
 396         }
 397
 398         p += sizeof(file_cache_t);
 399         len += sizeof(file_cache_t);
 400
 401         if (len + sizeof(file_cache_t) > cache_size)
 402             break;
 403     }
 404
 405     memset(&f, 0, sizeof(file_cache_t));
 406     return FALSE;
 407 }
 408
 409 gboolean cache_decr_refcount(const guchar *md5file)
 410 {
 411     void *p;
 412     file_cache_t f;
 413     glong len;
 414
 415     for (p = key_cache, len = 0; len <= cache_size;) {
 416         memcpy(&f, p, sizeof(file_cache_t));
 417
 418         if (f.used == TRUE) {
 419             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 420                 f.refcount--;
 421
 422                 if (f.refcount < 0)
 423                     f.refcount = 0;
 424
 425                 memcpy(p, &f, sizeof(file_cache_t));
 426                 memset(&f, 0, sizeof(file_cache_t));
 427                 return TRUE;
 428             }
 429         }
 430
 431         p += sizeof(file_cache_t);
 432         len += sizeof(file_cache_t);
 433
 434         if (len + sizeof(file_cache_t) > cache_size)
 435             break;
 436     }
 437
 438     memset(&f, 0, sizeof(file_cache_t));
 439     return FALSE;
 440 }
 441
 442 gboolean cache_incr_refcount(const guchar *md5file)
 443 {
 444     void *p;
 445     file_cache_t f;
 446     glong len;
 447
 448     for (p = key_cache, len = 0; len <= cache_size;) {
 449         memcpy(&f, p, sizeof(file_cache_t));
 450
 451         if (f.used == TRUE) {
 452             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 453                 f.refcount++;
 454                 memcpy(p, &f, sizeof(file_cache_t));
 455                 memset(&f, 0, sizeof(file_cache_t));
 456                 return TRUE;
 457             }
 458         }
 459
 460         p += sizeof(file_cache_t);
 461         len += sizeof(file_cache_t);
 462
 463         if (len + sizeof(file_cache_t) > cache_size)
 464             break;
 465     }
 466
 467     memset(&f, 0, sizeof(file_cache_t));
 468     return FALSE;
 469 }