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
  29 static gint cache_valid_key(const guchar *key, gsize len)
  30 {
  31     gint b;
  32
  33     for (b = 0; b < len; b++) {
  34         if (key[b])
  35             return TRUE;
  36     }
  37
  38     return FALSE;
  39 }
  40
  41 gint cache_file_count()
  42 {
  43     void *p;
  44     gint n = 0;
  45     glong len;
  46     file_cache_t f;
  47
  48     for (p = shm_data, len = 0; len <= cache_size;) {
  49         memcpy(&f, p, sizeof(file_cache_t));
  50
  51         if (f.used == TRUE)
  52             n++;
  53
  54         p += sizeof(file_cache_t);
  55         len += sizeof(file_cache_t);
  56
  57         if (len + sizeof(file_cache_t) > cache_size)
  58             break;
  59     }
  60
  61     memset(&f, 0, sizeof(file_cache_t));
  62     return n;
  63 }
  64
  65 void cache_adjust_timer()
  66 {
  67     file_cache_t f;
  68     void *p;
  69     glong len;
  70
  71     for (p = shm_data, len = 0; len <= cache_size;) {
  72         memcpy(&f, p, sizeof(file_cache_t));
  73
  74         if (f.used == TRUE && f.reset >= 0) {
  75             f.timeout--;
  76
  77             if (f.timeout <= 0) {
  78                 memset(&f.key, 0, sizeof(f.key));
  79                 f.timeout = 0;
  80             }
  81
  82             memcpy(p, &f, sizeof(file_cache_t));
  83         }
  84
  85         p += sizeof(file_cache_t);
  86         len += sizeof(file_cache_t);
  87
  88         if (len + sizeof(file_cache_t) > cache_size)
  89             break;
  90     }
  91
  92     memset(&f, 0, sizeof(file_cache_t));
  93 }
  94
  95 gboolean cache_add_file(const guchar *md5file, const guchar *shakey)
  96 {
  97     void *p;
  98     file_cache_t f;
  99     gint nfiles = cache_file_count();
 100     glong len;
 101
 102     /*
 103      * Make sure there is enough secure memory.
 104      */
 105     if (!md5file || (nfiles + 1) * sizeof(file_cache_t) > cache_size)
 106         return FALSE;
 107
 108     /*
 109      * Find the first available "slot".
 110      */
 111     for (p = shm_data, len = 0; len <= cache_size;) {
 112         memcpy(&f, p, sizeof(file_cache_t));
 113
 114         if (f.used == FALSE) {
 115             memset(&f, 0, sizeof(f));
 116             memcpy(&f.filename, md5file, sizeof(f.filename));
 117
 118             if (shakey)
 119                 memcpy(&f.key, shakey, sizeof(f.key));
 120
 121             f.used = TRUE;
 122             f.reset = f.timeout = -2;
 123             memcpy(p, &f, sizeof(file_cache_t));
 124             memset(&f, 0, sizeof(file_cache_t));
 125             return TRUE;
 126         }
 127
 128         p += sizeof(file_cache_t);
 129         len += sizeof(file_cache_t);
 130
 131         if (len + sizeof(file_cache_t) > cache_size)
 132             break;
 133     }
 134
 135     memset(&f, 0, sizeof(file_cache_t));
 136     return FALSE;
 137 }
 138
 139 gboolean cache_clear(const guchar *md5filename, gint which)
 140 {
 141     void *p;
 142     file_cache_t f;
 143     glong len;
 144
 145     for (p = shm_data, len = 0; len <= cache_size;) {
 146         memcpy(&f, p, sizeof(file_cache_t));
 147
 148         if (which == 2) {
 149             memset(&f, 0, sizeof(file_cache_t));
 150             memcpy(p, &f, sizeof(file_cache_t));
 151         }
 152         else if (f.used == TRUE && which == 1) {
 153             if (memcmp(&f.filename, md5filename, sizeof(f.filename)) == 0) {
 154                 memset(&f, 0, sizeof(file_cache_t));
 155                 memcpy(p, &f, sizeof(file_cache_t));
 156                 return TRUE;
 157             }
 158         }
 159
 160         p += sizeof(file_cache_t);
 161         len += sizeof(file_cache_t);
 162
 163         if (len + sizeof(file_cache_t) > cache_size)
 164             break;
 165     }
 166
 167     memset(&f, 0, sizeof(file_cache_t));
 168     return (which == 2) ? TRUE : FALSE;
 169 }
 170
 171 gboolean cache_iscached(const guchar *md5filename)
 172 {
 173     void *p;
 174     file_cache_t f;
 175     glong len;
 176     gboolean ret = FALSE;
 177
 178     for (p = shm_data, len = 0; len <= cache_size;) {
 179         memcpy(&f, p, sizeof(file_cache_t));
 180
 181         if (f.used == TRUE) {
 182             if (memcmp(&f.filename, md5filename, sizeof(f.filename)) == 0) {
 183                 ret = cache_valid_key(f.key, sizeof(f.key));
 184                 memset(&f, 0, sizeof(file_cache_t));
 185                 return ret;
 186             }
 187         }
 188
 189         p += sizeof(file_cache_t);
 190         len += sizeof(file_cache_t);
 191
 192         if (len + sizeof(file_cache_t) > cache_size)
 193             break;
 194     }
 195
 196     memset(&f, 0, sizeof(file_cache_t));
 197     return FALSE;
 198 }
 199
 200 gboolean cache_reset_timeout(const guchar *md5filename, glong timeout)
 201 {
 202     void *p;
 203     file_cache_t f;
 204     glong len;
 205     glong t = -2;
 206
 207     if (!md5filename)
 208         return FALSE;
 209
 210     for (p = shm_data, len = 0; len <= cache_size;) {
 211         memcpy(&f, p, sizeof(file_cache_t));
 212
 213         if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 214             t = f.reset;
 215             break;
 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 (t == -2)
 228         return cache_set_timeout(md5filename, timeout);
 229
 230     return cache_set_timeout(md5filename, t);
 231 }
 232
 233 gboolean cache_set_timeout(const guchar *md5filename, glong timeout)
 234 {
 235     void *p;
 236     file_cache_t f;
 237     glong len;
 238
 239     for (p = shm_data, len = 0; len <= cache_size;) {
 240         memcpy(&f, p, sizeof(file_cache_t));
 241
 242         if (md5filename) {
 243             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 244                 f.reset = f.timeout = timeout;
 245                 memcpy(p, &f, sizeof(file_cache_t));
 246                 memset(&f, 0, sizeof(file_cache_t));
 247                 return TRUE;
 248             }
 249         }
 250
 251         p += sizeof(file_cache_t);
 252         len += sizeof(file_cache_t);
 253
 254         if (len + sizeof(file_cache_t) > cache_size)
 255             break;
 256     }
 257
 258     memset(&f, 0, sizeof(file_cache_t));
 259     return (md5filename) ? FALSE : TRUE;
 260 }
 261
 262 gboolean cache_update_key(const guchar *md5filename, const guchar *shakey)
 263 {
 264     void *p;
 265     file_cache_t f;
 266     glong len;
 267
 268     for (p = shm_data, len = 0; len <= cache_size;) {
 269         memcpy(&f, p, sizeof(file_cache_t));
 270
 271         if (f.used == TRUE) {
 272             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 273                 memcpy(&f.key, shakey, sizeof(f.key));
 274                 memcpy(p, &f, sizeof(file_cache_t));
 275                 memset(&f, 0, sizeof(file_cache_t));
 276                 return TRUE;
 277             }
 278         }
 279
 280         p += sizeof(file_cache_t);
 281         len += sizeof(file_cache_t);
 282
 283         if (len + sizeof(file_cache_t) > cache_size)
 284             break;
 285     }
 286
 287     memset(&f, 0, sizeof(file_cache_t));
 288     return cache_add_file(md5filename, shakey);
 289 }
 290
 291 gboolean cache_get_key(const guchar *md5file, guchar *shakey)
 292 {
 293     void *p;
 294     file_cache_t f;
 295     glong len;
 296
 297     for (p = shm_data, len = 0; len <= cache_size;) {
 298         memcpy(&f, p, sizeof(file_cache_t));
 299
 300         /*
 301          * The slot may be used but not yet contain a key.
 302          */
 303         if (f.used == TRUE) {
 304             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 305                 if (cache_valid_key(f.key, sizeof(f.key)) == FALSE)
 306                     goto fail;
 307
 308                 memcpy(shakey, &f.key, sizeof(f.key));
 309                 memset(&f, 0, sizeof(file_cache_t));
 310                 return TRUE;
 311             }
 312         }
 313
 314         p += sizeof(file_cache_t);
 315         len += sizeof(file_cache_t);
 316
 317         if (len + sizeof(file_cache_t) > cache_size)
 318             break;
 319     }
 320
 321 fail:
 322     memset(&f, 0, sizeof(file_cache_t));
 323     return FALSE;
 324 }