lib/util/util_tdb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    tdb utility functions
   5
   6    Copyright (C) Andrew Tridgell 1992-2006
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "../lib/tdb_compat/tdb_compat.h"
  24 #include "../lib/util/util_tdb.h"
  25
  26 /* these are little tdb utility functions that are meant to make
  27    dealing with a tdb database a little less cumbersome in Samba */
  28
  29 /***************************************************************
  30  Make a TDB_DATA and keep the const warning in one place
  31 ****************************************************************/
  32
  33 TDB_DATA make_tdb_data(const uint8_t *dptr, size_t dsize)
  34 {
  35         TDB_DATA ret;
  36         ret.dptr = discard_const_p(uint8_t, dptr);
  37         ret.dsize = dsize;
  38         return ret;
  39 }
  40
  41 bool tdb_data_equal(TDB_DATA t1, TDB_DATA t2)
  42 {
  43         if (t1.dsize != t2.dsize) {
  44                 return false;
  45         }
  46         return (memcmp(t1.dptr, t2.dptr, t1.dsize) == 0);
  47 }
  48
  49 bool tdb_data_is_empty(TDB_DATA d)
  50 {
  51         return (d.dsize == 0) || (d.dptr == NULL);
  52 }
  53
  54 TDB_DATA string_tdb_data(const char *string)
  55 {
  56         return make_tdb_data((const uint8_t *)string, string ? strlen(string) : 0 );
  57 }
  58
  59 TDB_DATA string_term_tdb_data(const char *string)
  60 {
  61         return make_tdb_data((const uint8_t *)string, string ? strlen(string) + 1 : 0);
  62 }
  63
  64 /****************************************************************************
  65  Lock a chain by string. Return non-zero if lock failed.
  66 ****************************************************************************/
  67
  68 int tdb_lock_bystring(struct tdb_context *tdb, const char *keyval)
  69 {
  70         TDB_DATA key = string_term_tdb_data(keyval);
  71
  72         return tdb_chainlock(tdb, key);
  73 }
  74
  75 /****************************************************************************
  76  Unlock a chain by string.
  77 ****************************************************************************/
  78
  79 void tdb_unlock_bystring(struct tdb_context *tdb, const char *keyval)
  80 {
  81         TDB_DATA key = string_term_tdb_data(keyval);
  82
  83         tdb_chainunlock(tdb, key);
  84 }
  85
  86 /****************************************************************************
  87  Read lock a chain by string. Return non-zero if lock failed.
  88 ****************************************************************************/
  89
  90 int tdb_read_lock_bystring(struct tdb_context *tdb, const char *keyval)
  91 {
  92         TDB_DATA key = string_term_tdb_data(keyval);
  93
  94         return tdb_chainlock_read(tdb, key);
  95 }
  96
  97 /****************************************************************************
  98  Read unlock a chain by string.
  99 ****************************************************************************/
 100
 101 void tdb_read_unlock_bystring(struct tdb_context *tdb, const char *keyval)
 102 {
 103         TDB_DATA key = string_term_tdb_data(keyval);
 104
 105         tdb_chainunlock_read(tdb, key);
 106 }
 107
 108
 109 /****************************************************************************
 110  Fetch a int32_t value by a arbitrary blob key, return -1 if not found.
 111  Output is int32_t in native byte order.
 112 ****************************************************************************/
 113
 114 int32_t tdb_fetch_int32_byblob(struct tdb_context *tdb, TDB_DATA key)
 115 {
 116         TDB_DATA data;
 117         int32_t ret;
 118
 119         data = tdb_fetch_compat(tdb, key);
 120         if (!data.dptr || data.dsize != sizeof(int32_t)) {
 121                 SAFE_FREE(data.dptr);
 122                 return -1;
 123         }
 124
 125         ret = IVAL(data.dptr,0);
 126         SAFE_FREE(data.dptr);
 127         return ret;
 128 }
 129
 130 /****************************************************************************
 131  Fetch a int32_t value by string key, return -1 if not found.
 132  Output is int32_t in native byte order.
 133 ****************************************************************************/
 134
 135 int32_t tdb_fetch_int32(struct tdb_context *tdb, const char *keystr)
 136 {
 137         return tdb_fetch_int32_byblob(tdb, string_term_tdb_data(keystr));
 138 }
 139
 140 /****************************************************************************
 141  Store a int32_t value by an arbitrary blob key, return 0 on success, -ve on failure.
 142  Input is int32_t in native byte order. Output in tdb is in little-endian.
 143 ****************************************************************************/
 144
 145 int tdb_store_int32_byblob(struct tdb_context *tdb, TDB_DATA key, int32_t v)
 146 {
 147         TDB_DATA data;
 148         int32_t v_store;
 149
 150         SIVAL(&v_store,0,v);
 151         data.dptr = (unsigned char *)&v_store;
 152         data.dsize = sizeof(int32_t);
 153
 154         return tdb_store(tdb, key, data, TDB_REPLACE);
 155 }
 156
 157 /****************************************************************************
 158  Store a int32_t value by string key, return 0 on success, -ve on failure.
 159  Input is int32_t in native byte order. Output in tdb is in little-endian.
 160 ****************************************************************************/
 161
 162 int tdb_store_int32(struct tdb_context *tdb, const char *keystr, int32_t v)
 163 {
 164         return tdb_store_int32_byblob(tdb, string_term_tdb_data(keystr), v);
 165 }
 166
 167 /****************************************************************************
 168  Fetch a uint32_t value by a arbitrary blob key, return false if not found.
 169  Output is uint32_t in native byte order.
 170 ****************************************************************************/
 171
 172 bool tdb_fetch_uint32_byblob(struct tdb_context *tdb, TDB_DATA key, uint32_t *value)
 173 {
 174         TDB_DATA data;
 175
 176         data = tdb_fetch_compat(tdb, key);
 177         if (!data.dptr || data.dsize != sizeof(uint32_t)) {
 178                 SAFE_FREE(data.dptr);
 179                 return false;
 180         }
 181
 182         *value = IVAL(data.dptr,0);
 183         SAFE_FREE(data.dptr);
 184         return true;
 185 }
 186
 187 /****************************************************************************
 188  Fetch a uint32_t value by string key, return false if not found.
 189  Output is uint32_t in native byte order.
 190 ****************************************************************************/
 191
 192 bool tdb_fetch_uint32(struct tdb_context *tdb, const char *keystr, uint32_t *value)
 193 {
 194         return tdb_fetch_uint32_byblob(tdb, string_term_tdb_data(keystr), value);
 195 }
 196
 197 /****************************************************************************
 198  Store a uint32_t value by an arbitrary blob key, return true on success, false on failure.
 199  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 200 ****************************************************************************/
 201
 202 bool tdb_store_uint32_byblob(struct tdb_context *tdb, TDB_DATA key, uint32_t value)
 203 {
 204         TDB_DATA data;
 205         uint32_t v_store;
 206         bool ret = true;
 207
 208         SIVAL(&v_store, 0, value);
 209         data.dptr = (unsigned char *)&v_store;
 210         data.dsize = sizeof(uint32_t);
 211
 212         if (tdb_store(tdb, key, data, TDB_REPLACE) != 0)
 213                 ret = false;
 214
 215         return ret;
 216 }
 217
 218 /****************************************************************************
 219  Store a uint32_t value by string key, return true on success, false on failure.
 220  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 221 ****************************************************************************/
 222
 223 bool tdb_store_uint32(struct tdb_context *tdb, const char *keystr, uint32_t value)
 224 {
 225         return tdb_store_uint32_byblob(tdb, string_term_tdb_data(keystr), value);
 226 }
 227 /****************************************************************************
 228  Store a buffer by a null terminated string key.  Return 0 on success, -ve
 229  on failure.
 230 ****************************************************************************/
 231
 232 int tdb_store_bystring(struct tdb_context *tdb, const char *keystr, TDB_DATA data, int flags)
 233 {
 234         TDB_DATA key = string_term_tdb_data(keystr);
 235
 236         return tdb_store(tdb, key, data, flags);
 237 }
 238
 239 /****************************************************************************
 240  Fetch a buffer using a null terminated string key.  Don't forget to call
 241  free() on the result dptr.
 242 ****************************************************************************/
 243
 244 TDB_DATA tdb_fetch_bystring(struct tdb_context *tdb, const char *keystr)
 245 {
 246         TDB_DATA key = string_term_tdb_data(keystr);
 247
 248         return tdb_fetch_compat(tdb, key);
 249 }
 250
 251 /****************************************************************************
 252  Delete an entry using a null terminated string key.
 253 ****************************************************************************/
 254
 255 int tdb_delete_bystring(struct tdb_context *tdb, const char *keystr)
 256 {
 257         TDB_DATA key = string_term_tdb_data(keystr);
 258
 259         return tdb_delete(tdb, key);
 260 }
 261
 262 /****************************************************************************
 263  Atomic integer change. Returns old value. To create, set initial value in *oldval.
 264 ****************************************************************************/
 265
 266 int32_t tdb_change_int32_atomic(struct tdb_context *tdb, const char *keystr, int32_t *oldval, int32_t change_val)
 267 {
 268         int32_t val;
 269         int32_t ret = -1;
 270
 271         if (tdb_lock_bystring(tdb, keystr) != 0)
 272                 return -1;
 273
 274         if ((val = tdb_fetch_int32(tdb, keystr)) == -1) {
 275                 /* The lookup failed */
 276                 if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
 277                         /* but not because it didn't exist */
 278                         goto err_out;
 279                 }
 280
 281                 /* Start with 'old' value */
 282                 val = *oldval;
 283
 284         } else {
 285                 /* It worked, set return value (oldval) to tdb data */
 286                 *oldval = val;
 287         }
 288
 289         /* Increment value for storage and return next time */
 290         val += change_val;
 291
 292         if (tdb_store_int32(tdb, keystr, val) != 0)
 293                 goto err_out;
 294
 295         ret = 0;
 296
 297   err_out:
 298
 299         tdb_unlock_bystring(tdb, keystr);
 300         return ret;
 301 }
 302
 303 /****************************************************************************
 304  Atomic unsigned integer change. Returns old value. To create, set initial value in *oldval.
 305 ****************************************************************************/
 306
 307 bool tdb_change_uint32_atomic(struct tdb_context *tdb, const char *keystr, uint32_t *oldval, uint32_t change_val)
 308 {
 309         uint32_t val;
 310         bool ret = false;
 311
 312         if (tdb_lock_bystring(tdb, keystr) != 0)
 313                 return false;
 314
 315         if (!tdb_fetch_uint32(tdb, keystr, &val)) {
 316                 /* It failed */
 317                 if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
 318                         /* and not because it didn't exist */
 319                         goto err_out;
 320                 }
 321
 322                 /* Start with 'old' value */
 323                 val = *oldval;
 324
 325         } else {
 326                 /* it worked, set return value (oldval) to tdb data */
 327                 *oldval = val;
 328
 329         }
 330
 331         /* get a new value to store */
 332         val += change_val;
 333
 334         if (!tdb_store_uint32(tdb, keystr, val))
 335                 goto err_out;
 336
 337         ret = true;
 338
 339   err_out:
 340
 341         tdb_unlock_bystring(tdb, keystr);
 342         return ret;
 343 }
 344
 345 /****************************************************************************
 346  Allow tdb_delete to be used as a tdb_traversal_fn.
 347 ****************************************************************************/
 348
 349 int tdb_traverse_delete_fn(struct tdb_context *the_tdb, TDB_DATA key, TDB_DATA dbuf,
 350                      void *state)
 351 {
 352     return tdb_delete(the_tdb, key);
 353 }