src/cache.c

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