code.delx.au - pulseaudio/blob - src/pulsecore/database-tdb.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2009 Lennart Poettering
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29
  30 /* Some versions of tdb lack inclusion of signal.h in the header files but use sigatomic_t */
  31 #include <signal.h>
  32 #include <tdb.h>
  33
  34 #include <pulse/xmalloc.h>
  35 #include <pulsecore/core-util.h>
  36 #include <pulsecore/log.h>
  37
  38 #include "database.h"
  39
  40 #define MAKE_TDB_CONTEXT(x) ((struct tdb_context*) (x))
  41
  42 static inline TDB_DATA* datum_to_tdb(TDB_DATA *to, const pa_datum *from) {
  43     pa_assert(from);
  44     pa_assert(to);
  45
  46     to->dptr = from->data;
  47     to->dsize = from->size;
  48
  49     return to;
  50 }
  51
  52 static inline pa_datum* datum_from_tdb(pa_datum *to, const TDB_DATA *from) {
  53     pa_assert(from);
  54     pa_assert(to);
  55
  56     to->data = from->dptr;
  57     to->size = from->dsize;
  58
  59     return to;
  60 }
  61
  62 void pa_datum_free(pa_datum *d) {
  63     pa_assert(d);
  64
  65     free(d->data); /* tdb uses raw malloc/free hence we should do that here, too */
  66     pa_zero(d);
  67 }
  68
  69 static struct tdb_context *tdb_open_cloexec(
  70         const char *name,
  71         int hash_size,
  72         int tdb_flags,
  73         int open_flags,
  74         mode_t mode) {
  75
  76     /* Mimics pa_open_cloexec() */
  77
  78     struct tdb_context *c;
  79
  80 #ifdef O_NOCTTY
  81     open_flags |= O_NOCTTY;
  82 #endif
  83
  84 #ifdef O_CLOEXEC
  85     errno = 0;
  86     if ((c = tdb_open(name, hash_size, tdb_flags, open_flags | O_CLOEXEC, mode)))
  87         goto finish;
  88
  89     if (errno != EINVAL)
  90         return NULL;
  91 #endif
  92
  93     errno = 0;
  94     if (!(c = tdb_open(name, hash_size, tdb_flags, open_flags, mode)))
  95         return NULL;
  96
  97 finish:
  98     pa_make_fd_cloexec(tdb_fd(c));
  99     return c;
 100 }
 101
 102 pa_database* pa_database_open(const char *fn, bool for_write) {
 103     struct tdb_context *c;
 104     char *path;
 105
 106     pa_assert(fn);
 107
 108     path = pa_sprintf_malloc("%s.tdb", fn);
 109     if ((c = tdb_open_cloexec(path, 0, TDB_NOSYNC|TDB_NOLOCK, (for_write ? O_RDWR|O_CREAT : O_RDONLY), 0644)))
 110         pa_log_debug("Opened TDB database '%s'", path);
 111
 112     pa_xfree(path);
 113
 114     if (!c) {
 115         if (errno == 0)
 116             errno = EIO;
 117         return NULL;
 118     }
 119
 120     return (pa_database*) c;
 121 }
 122
 123 void pa_database_close(pa_database *db) {
 124     pa_assert(db);
 125
 126     tdb_close(MAKE_TDB_CONTEXT(db));
 127 }
 128
 129 pa_datum* pa_database_get(pa_database *db, const pa_datum *key, pa_datum* data) {
 130     TDB_DATA tdb_key, tdb_data;
 131
 132     pa_assert(db);
 133     pa_assert(key);
 134     pa_assert(data);
 135
 136     tdb_data = tdb_fetch(MAKE_TDB_CONTEXT(db), *datum_to_tdb(&tdb_key, key));
 137
 138     return tdb_data.dptr ?
 139         datum_from_tdb(data, &tdb_data) :
 140         NULL;
 141 }
 142
 143 int pa_database_set(pa_database *db, const pa_datum *key, const pa_datum* data, bool overwrite) {
 144     TDB_DATA tdb_key, tdb_data;
 145
 146     pa_assert(db);
 147     pa_assert(key);
 148     pa_assert(data);
 149
 150     return tdb_store(MAKE_TDB_CONTEXT(db),
 151                       *datum_to_tdb(&tdb_key, key),
 152                       *datum_to_tdb(&tdb_data, data),
 153                      overwrite ? TDB_REPLACE : TDB_INSERT) != 0 ? -1 : 0;
 154 }
 155
 156 int pa_database_unset(pa_database *db, const pa_datum *key) {
 157     TDB_DATA tdb_key;
 158
 159     pa_assert(db);
 160     pa_assert(key);
 161
 162     return tdb_delete(MAKE_TDB_CONTEXT(db), *datum_to_tdb(&tdb_key, key)) != 0 ? -1 : 0;
 163 }
 164
 165 int pa_database_clear(pa_database *db) {
 166     pa_assert(db);
 167
 168     return tdb_wipe_all(MAKE_TDB_CONTEXT(db)) != 0 ? -1 : 0;
 169 }
 170
 171 signed pa_database_size(pa_database *db) {
 172     TDB_DATA tdb_key;
 173     unsigned n = 0;
 174
 175     pa_assert(db);
 176
 177     /* This sucks */
 178
 179     tdb_key = tdb_firstkey(MAKE_TDB_CONTEXT(db));
 180
 181     while (tdb_key.dptr) {
 182         TDB_DATA next;
 183
 184         n++;
 185
 186         next = tdb_nextkey(MAKE_TDB_CONTEXT(db), tdb_key);
 187         free(tdb_key.dptr);
 188         tdb_key = next;
 189     }
 190
 191     return (signed) n;
 192 }
 193
 194 pa_datum* pa_database_first(pa_database *db, pa_datum *key, pa_datum *data) {
 195     TDB_DATA tdb_key, tdb_data;
 196
 197     pa_assert(db);
 198     pa_assert(key);
 199
 200     tdb_key = tdb_firstkey(MAKE_TDB_CONTEXT(db));
 201
 202     if (!tdb_key.dptr)
 203         return NULL;
 204
 205     if (data) {
 206         tdb_data = tdb_fetch(MAKE_TDB_CONTEXT(db), tdb_key);
 207
 208         if (!tdb_data.dptr) {
 209             free(tdb_key.dptr);
 210             return NULL;
 211         }
 212
 213         datum_from_tdb(data, &tdb_data);
 214     }
 215
 216     datum_from_tdb(key, &tdb_key);
 217
 218     return key;
 219 }
 220
 221 pa_datum* pa_database_next(pa_database *db, const pa_datum *key, pa_datum *next, pa_datum *data) {
 222     TDB_DATA tdb_key, tdb_data;
 223
 224     pa_assert(db);
 225     pa_assert(key);
 226
 227     tdb_key = tdb_nextkey(MAKE_TDB_CONTEXT(db), *datum_to_tdb(&tdb_key, key));
 228
 229     if (!tdb_key.dptr)
 230         return NULL;
 231
 232     if (data) {
 233         tdb_data = tdb_fetch(MAKE_TDB_CONTEXT(db), tdb_key);
 234
 235         if (!tdb_data.dptr) {
 236             free(tdb_key.dptr);
 237             return NULL;
 238         }
 239
 240         datum_from_tdb(data, &tdb_data);
 241     }
 242
 243     datum_from_tdb(next, &tdb_key);
 244
 245     return next;
 246 }
 247
 248 int pa_database_sync(pa_database *db) {
 249     pa_assert(db);
 250
 251     return 0;
 252 }