src/cache.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2009 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  02110-1301  USA
  18 */
  19 #include <stdio.h>
  20 #include <unistd.h>
  21 #include <glib.h>
  22 #include <string.h>
  23 #include <sys/mman.h>
  24 #include <errno.h>
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include "cache.h"
  31 #include "status.h"
  32 #include "mem.h"
  33
  34 void log_write(const gchar *fmt, ...);
  35
  36 static gboolean valid_key(const guchar *key, gsize len)
  37 {
  38     gint b;
  39
  40     for (b = 0; b < len; b++) {
  41         if (key[b])
  42             return TRUE;
  43     }
  44
  45     return FALSE;
  46 }
  47
  48 static file_cache_t *get_entry(const guchar *md5file)
  49 {
  50     gint t = g_slist_length(key_cache);
  51     gint i;
  52
  53     if (!md5file)
  54         return NULL;
  55
  56     for (i = 0; i < t; i++) {
  57         file_cache_t *p = g_slist_nth_data(key_cache, i);
  58
  59         if (!memcmp(p->filename, md5file, sizeof(p->filename)))
  60             return p;
  61     }
  62
  63     return NULL;
  64 }
  65
  66 gboolean cache_get_mutex(const guchar *md5file, struct file_mutex_s **result)
  67 {
  68     file_cache_t *p = get_entry(md5file);
  69
  70     if (p)
  71         *result = p->fmutex;
  72
  73     return p ? TRUE : FALSE;
  74 }
  75
  76 gint cache_file_count()
  77 {
  78     gint t = g_slist_length(key_cache);
  79     gint i;
  80     gint n = 0;
  81
  82     for (i = 0; i < t; i++) {
  83         file_cache_t *p = g_slist_nth_data(key_cache, i);
  84
  85         if (valid_key(p->key, sizeof(p->key)) == TRUE)
  86             n++;
  87     }
  88
  89     return n;
  90 }
  91
  92 void cache_adjust_timer()
  93 {
  94     gint t = g_slist_length(key_cache);
  95     gint i;
  96
  97     for (i = 0; i < t; i++) {
  98         file_cache_t *p = g_slist_nth_data(key_cache, i);
  99
 100         if (p->reset >= 0) {
 101             if (p->timeout > 0)
 102                 p->timeout--;
 103
 104             if (p->timeout == 0) {
 105                 if (valid_key(p->key, sizeof(p->key)) == TRUE) {
 106                     memset(&p->key, 0, sizeof(p->key));
 107                     send_status_all(STATUS_CACHE);
 108                 }
 109
 110                 p->timeout = -1;
 111             }
 112         }
 113     }
 114 }
 115
 116 gboolean cache_add_file(const guchar *md5file, const guchar *shakey)
 117 {
 118     file_cache_t *p = g_malloc0(sizeof(file_cache_t));
 119     GSList *new;
 120
 121     if (!p) {
 122         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 123         return FALSE;
 124     }
 125
 126     p->fmutex = g_malloc(sizeof(struct file_mutex_s));
 127
 128     if (!p->fmutex) {
 129         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 130         g_free(p);
 131         return FALSE;
 132     }
 133
 134     pthread_mutex_init(&p->fmutex->mutex, NULL);
 135     memcpy(p->filename, md5file, sizeof(p->filename));
 136
 137     if (shakey)
 138         memcpy(p->key, shakey, sizeof(p->key));
 139
 140     p->reset = p->timeout = -2;
 141
 142     if (mlock(p, sysconf(_SC_PAGESIZE)))
 143         log_write("mlock(): %s", strerror(errno));
 144
 145     new = g_slist_append(key_cache, p);
 146
 147     if (!new) {
 148         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 149         pthread_mutex_destroy(&p->fmutex->mutex);
 150         g_free(p->fmutex);
 151         memset(p, 0, sizeof(file_cache_t));
 152         g_free(p);
 153         return FALSE;
 154     }
 155
 156     key_cache = new;
 157     return TRUE;
 158 }
 159
 160 static void free_entry(file_cache_t *p)
 161 {
 162     if (!p)
 163         return;
 164
 165     if (p->fmutex) {
 166         pthread_mutex_destroy(&p->fmutex->mutex);
 167         g_free(p->fmutex);
 168     }
 169
 170     memset(p, 0, sizeof(file_cache_t));
 171     munlock(p, sysconf(_SC_PAGESIZE));
 172     key_cache = g_slist_remove(key_cache, p);
 173     g_free(p);
 174 }
 175
 176 void cache_free()
 177 {
 178     for (;;) {
 179         file_cache_t *p = g_slist_nth_data(key_cache, 0);
 180
 181         if (!p)
 182             break;
 183
 184         free_entry(p);
 185     }
 186 }
 187
 188 static void reset_entry(file_cache_t *p)
 189 {
 190     if (p && !p->refcount)
 191         free_entry(p);
 192     else if (p)
 193         memset(p->key, 0, sizeof(p->key));
 194 }
 195
 196 gboolean cache_clear(const guchar *md5file, gint which)
 197 {
 198     file_cache_t *p = md5file ? get_entry(md5file) : NULL;
 199
 200     if (which == 1) {
 201         if (!p)
 202             return FALSE;
 203
 204         reset_entry(p);
 205         send_status_all(STATUS_CACHE);
 206         return TRUE;
 207     }
 208
 209     do {
 210         file_cache_t *p = g_slist_nth_data(key_cache, 0);
 211
 212         if (!p)
 213             break;
 214
 215         reset_entry(p);
 216     } while (cache_file_count());
 217
 218     send_status_all(STATUS_CACHE);
 219     return TRUE;
 220 }
 221
 222 gboolean cache_iscached(const guchar *md5file)
 223 {
 224     file_cache_t *p = get_entry(md5file);
 225
 226     return p ? valid_key(p->key, sizeof(p->key)) : FALSE;
 227 }
 228
 229 gboolean cache_reset_timeout(const guchar *md5file, glong timeout)
 230 {
 231     file_cache_t *p = get_entry(md5file);
 232
 233     if (!p)
 234         return FALSE;
 235
 236     if (p->reset == -2)
 237         return cache_set_timeout(md5file, timeout);
 238
 239     return cache_set_timeout(md5file, p->reset);
 240 }
 241
 242 gboolean cache_set_timeout(const guchar *md5file, glong timeout)
 243 {
 244     file_cache_t *p = get_entry(md5file);
 245
 246     if (!p)
 247         return FALSE;
 248
 249     if (timeout == -2)
 250         p->timeout = p->reset;
 251     else
 252         p->reset = p->timeout = timeout;
 253
 254     return TRUE;
 255 }
 256
 257 gboolean cache_update_key(const guchar *md5file, const guchar *shakey)
 258 {
 259     file_cache_t *p = get_entry(md5file);
 260
 261     if (!p)
 262         return cache_add_file(md5file, shakey);
 263
 264     if (p->reset)
 265         memcpy(p->key, shakey, sizeof(p->key));
 266
 267     return TRUE;
 268 }
 269
 270 gboolean cache_get_key(const guchar *md5file, guchar *shakey)
 271 {
 272     file_cache_t *p = get_entry(md5file);
 273
 274     if (!p || valid_key(p->key, sizeof(p->key)) == FALSE)
 275         return FALSE;
 276
 277     memcpy(shakey, p->key, sizeof(p->key));
 278     return TRUE;
 279 }
 280
 281 gboolean cache_has_file(const guchar *md5file)
 282 {
 283     file_cache_t *p = get_entry(md5file);
 284
 285     return p ? TRUE : FALSE;
 286 }
 287
 288 gboolean cache_decr_refcount(const guchar *md5file)
 289 {
 290     file_cache_t *p = get_entry(md5file);
 291
 292     if (!p)
 293         return FALSE;
 294
 295     p->refcount--;
 296
 297     if (p->refcount < 0)
 298         p->refcount = 0;
 299
 300     return TRUE;
 301 }
 302
 303 gboolean cache_incr_refcount(const guchar *md5file)
 304 {
 305     file_cache_t *p = get_entry(md5file);
 306
 307     if (!p)
 308         return FALSE;
 309
 310     p->refcount++;
 311     return TRUE;
 312 }