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, pth_mutex_t **result)
  67 {
  68     file_cache_t *p = get_entry(md5file);
  69
  70     if (p)
  71         *result = p->mutex;
  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->mutex = g_malloc(sizeof(pth_mutex_t));
 127
 128     if (!p->mutex) {
 129         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 130         g_free(p);
 131         return FALSE;
 132     }
 133
 134     pth_mutex_init(p->mutex);
 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         g_free(p->mutex);
 150         memset(p, 0, sizeof(file_cache_t));
 151         g_free(p);
 152         return FALSE;
 153     }
 154
 155     key_cache = new;
 156     return TRUE;
 157 }
 158
 159 static void free_entry(file_cache_t *p)
 160 {
 161     if (!p)
 162         return;
 163
 164     if (p->mutex)
 165         g_free(p->mutex);
 166
 167     memset(p, 0, sizeof(file_cache_t));
 168     munlock(p, sysconf(_SC_PAGESIZE));
 169     key_cache = g_slist_remove(key_cache, p);
 170     g_free(p);
 171 }
 172
 173 void cache_free()
 174 {
 175     for (;;) {
 176         file_cache_t *p = g_slist_nth_data(key_cache, 0);
 177
 178         if (!p)
 179             break;
 180
 181         free_entry(p);
 182     }
 183 }
 184
 185 static void reset_entry(file_cache_t *p)
 186 {
 187     if (p && !p->refcount)
 188         free_entry(p);
 189     else if (p)
 190         memset(p->key, 0, sizeof(p->key));
 191 }
 192
 193 gboolean cache_clear(const guchar *md5file, gint which)
 194 {
 195     file_cache_t *p = md5file ? get_entry(md5file) : NULL;
 196
 197     if (which == 1) {
 198         if (!p)
 199             return FALSE;
 200
 201         reset_entry(p);
 202         send_status_all(STATUS_CACHE);
 203         return TRUE;
 204     }
 205
 206     do {
 207         file_cache_t *p = g_slist_nth_data(key_cache, 0);
 208
 209         if (!p)
 210             break;
 211
 212         reset_entry(p);
 213     } while (cache_file_count());
 214
 215     send_status_all(STATUS_CACHE);
 216     return TRUE;
 217 }
 218
 219 gboolean cache_iscached(const guchar *md5file)
 220 {
 221     file_cache_t *p = get_entry(md5file);
 222
 223     return p ? valid_key(p->key, sizeof(p->key)) : FALSE;
 224 }
 225
 226 gboolean cache_reset_timeout(const guchar *md5file, glong timeout)
 227 {
 228     file_cache_t *p = get_entry(md5file);
 229
 230     if (!p)
 231         return FALSE;
 232
 233     if (p->reset == -2)
 234         return cache_set_timeout(md5file, timeout);
 235
 236     return cache_set_timeout(md5file, p->reset);
 237 }
 238
 239 gboolean cache_set_timeout(const guchar *md5file, glong timeout)
 240 {
 241     file_cache_t *p = get_entry(md5file);
 242
 243     if (!p)
 244         return FALSE;
 245
 246     if (timeout == -2)
 247         p->timeout = p->reset;
 248     else
 249         p->reset = p->timeout = timeout;
 250
 251     return TRUE;
 252 }
 253
 254 gboolean cache_update_key(const guchar *md5file, const guchar *shakey)
 255 {
 256     file_cache_t *p = get_entry(md5file);
 257
 258     if (!p)
 259         return cache_add_file(md5file, shakey);
 260
 261     if (p->reset)
 262         memcpy(p->key, shakey, sizeof(p->key));
 263
 264     return TRUE;
 265 }
 266
 267 gboolean cache_get_key(const guchar *md5file, guchar *shakey)
 268 {
 269     file_cache_t *p = get_entry(md5file);
 270
 271     if (!p || valid_key(p->key, sizeof(p->key)) == FALSE)
 272         return FALSE;
 273
 274     memcpy(shakey, p->key, sizeof(p->key));
 275     return TRUE;
 276 }
 277
 278 gboolean cache_has_file(const guchar *md5file)
 279 {
 280     file_cache_t *p = get_entry(md5file);
 281
 282     return p ? TRUE : FALSE;
 283 }
 284
 285 gboolean cache_decr_refcount(const guchar *md5file)
 286 {
 287     file_cache_t *p = get_entry(md5file);
 288
 289     if (!p)
 290         return FALSE;
 291
 292     p->refcount--;
 293
 294     if (p->refcount < 0)
 295         p->refcount = 0;
 296
 297     return TRUE;
 298 }
 299
 300 gboolean cache_incr_refcount(const guchar *md5file)
 301 {
 302     file_cache_t *p = get_entry(md5file);
 303
 304     if (!p)
 305         return FALSE;
 306
 307     p->refcount++;
 308     return TRUE;
 309 }