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