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 "replace.h"
  24 #include <talloc.h>
  25 #include "libcli/util/ntstatus.h"
  26 #include "lib/util/memory.h"
  27 #include "lib/util/byteorder.h"
  28 #include "system/filesys.h"
  29 #include "../lib/tdb/include/tdb.h"
  30 #include "../lib/util/util_tdb.h"
  31
  32 /* these are little tdb utility functions that are meant to make
  33    dealing with a tdb database a little less cumbersome in Samba */
  34
  35 /***************************************************************
  36  Make a TDB_DATA and keep the const warning in one place
  37 ****************************************************************/
  38
  39 TDB_DATA make_tdb_data(const uint8_t *dptr, size_t dsize)
  40 {
  41         TDB_DATA ret;
  42         ret.dptr = discard_const_p(uint8_t, dptr);
  43         ret.dsize = dsize;
  44         return ret;
  45 }
  46
  47 bool tdb_data_equal(TDB_DATA t1, TDB_DATA t2)
  48 {
  49         if (t1.dsize != t2.dsize) {
  50                 return false;
  51         }
  52         return (memcmp(t1.dptr, t2.dptr, t1.dsize) == 0);
  53 }
  54
  55 bool tdb_data_is_empty(TDB_DATA d)
  56 {
  57         return (d.dsize == 0) || (d.dptr == NULL);
  58 }
  59
  60 TDB_DATA string_tdb_data(const char *string)
  61 {
  62         return make_tdb_data((const uint8_t *)string, string ? strlen(string) : 0 );
  63 }
  64
  65 TDB_DATA string_term_tdb_data(const char *string)
  66 {
  67         return make_tdb_data((const uint8_t *)string, string ? strlen(string) + 1 : 0);
  68 }
  69
  70 TDB_DATA tdb_data_talloc_copy(TALLOC_CTX* mem_ctx, TDB_DATA data) {
  71         TDB_DATA ret = {
  72                 .dptr  = (uint8_t *)talloc_size(mem_ctx, data.dsize+1),
  73                 .dsize = data.dsize
  74         };
  75         if (ret.dptr == NULL) {
  76                 ret.dsize = 0;
  77         } else {
  78                 memcpy(ret.dptr, data.dptr, data.dsize);
  79                 ret.dptr[ret.dsize] = '\0';
  80         }
  81         return ret;
  82 }
  83
  84
  85 /****************************************************************************
  86  Lock a chain by string. Return non-zero if lock failed.
  87 ****************************************************************************/
  88
  89 int tdb_lock_bystring(struct tdb_context *tdb, const char *keyval)
  90 {
  91         TDB_DATA key = string_term_tdb_data(keyval);
  92
  93         return tdb_chainlock(tdb, key);
  94 }
  95
  96 /****************************************************************************
  97  Unlock a chain by string.
  98 ****************************************************************************/
  99
 100 void tdb_unlock_bystring(struct tdb_context *tdb, const char *keyval)
 101 {
 102         TDB_DATA key = string_term_tdb_data(keyval);
 103
 104         tdb_chainunlock(tdb, key);
 105 }
 106
 107 /****************************************************************************
 108  Read lock a chain by string. Return non-zero if lock failed.
 109 ****************************************************************************/
 110
 111 int tdb_read_lock_bystring(struct tdb_context *tdb, const char *keyval)
 112 {
 113         TDB_DATA key = string_term_tdb_data(keyval);
 114
 115         return tdb_chainlock_read(tdb, key);
 116 }
 117
 118 /****************************************************************************
 119  Read unlock a chain by string.
 120 ****************************************************************************/
 121
 122 void tdb_read_unlock_bystring(struct tdb_context *tdb, const char *keyval)
 123 {
 124         TDB_DATA key = string_term_tdb_data(keyval);
 125
 126         tdb_chainunlock_read(tdb, key);
 127 }
 128
 129
 130 /****************************************************************************
 131  Fetch a int32_t value by a arbitrary blob key, return -1 if not found.
 132  Output is int32_t in native byte order.
 133 ****************************************************************************/
 134
 135 static int fetch_int32_parser(TDB_DATA key, TDB_DATA data, void *private_data)
 136 {
 137         if (data.dsize == sizeof(int32_t)) {
 138                 *((int32_t *)private_data) = PULL_LE_I32(data.dptr, 0);
 139         }
 140         return 0;
 141 }
 142
 143 static int32_t tdb_fetch_int32_byblob(struct tdb_context *tdb, TDB_DATA key)
 144 {
 145         int32_t v = -1;
 146         int32_t ret = tdb_parse_record(tdb, key, fetch_int32_parser, &v);
 147         if (ret == -1) {
 148                 return ret;
 149         }
 150         return v;
 151 }
 152
 153 /****************************************************************************
 154  Fetch a int32_t value by string key, return -1 if not found.
 155  Output is int32_t in native byte order.
 156 ****************************************************************************/
 157
 158 int32_t tdb_fetch_int32(struct tdb_context *tdb, const char *keystr)
 159 {
 160         return tdb_fetch_int32_byblob(tdb, string_term_tdb_data(keystr));
 161 }
 162
 163 /****************************************************************************
 164  Store a int32_t value by an arbitrary blob key, return 0 on success, -ve on failure.
 165  Input is int32_t in native byte order. Output in tdb is in little-endian.
 166 ****************************************************************************/
 167
 168 static int tdb_store_int32_byblob(struct tdb_context *tdb, TDB_DATA key,
 169                                   int32_t v)
 170 {
 171         TDB_DATA data;
 172         int32_t v_store;
 173
 174         SIVAL(&v_store,0,v);
 175         data.dptr = (unsigned char *)&v_store;
 176         data.dsize = sizeof(int32_t);
 177
 178         return tdb_store(tdb, key, data, TDB_REPLACE);
 179 }
 180
 181 /****************************************************************************
 182  Store a int32_t value by string key, return 0 on success, -ve on failure.
 183  Input is int32_t in native byte order. Output in tdb is in little-endian.
 184 ****************************************************************************/
 185
 186 int tdb_store_int32(struct tdb_context *tdb, const char *keystr, int32_t v)
 187 {
 188         return tdb_store_int32_byblob(tdb, string_term_tdb_data(keystr), v);
 189 }
 190
 191 /****************************************************************************
 192  Fetch a uint32_t value by a arbitrary blob key, return false if not found.
 193  Output is uint32_t in native byte order.
 194 ****************************************************************************/
 195
 196 static int fetch_uint32_parser(TDB_DATA key, TDB_DATA data, void *private_data)
 197 {
 198         if (data.dsize != sizeof(uint32_t)) {
 199                 return -1;
 200         }
 201         *((uint32_t *)private_data) = PULL_LE_U32(data.dptr, 0);
 202         return 0;
 203 }
 204
 205 static bool tdb_fetch_uint32_byblob(struct tdb_context *tdb, TDB_DATA key,
 206                                     uint32_t *value)
 207 {
 208         int ret = tdb_parse_record(tdb, key, fetch_uint32_parser, value);
 209
 210         if (ret == -1) {
 211                 return false;
 212         }
 213
 214         return true;
 215 }
 216
 217 /****************************************************************************
 218  Fetch a uint32_t value by string key, return false if not found.
 219  Output is uint32_t in native byte order.
 220 ****************************************************************************/
 221
 222 bool tdb_fetch_uint32(struct tdb_context *tdb, const char *keystr, uint32_t *value)
 223 {
 224         return tdb_fetch_uint32_byblob(tdb, string_term_tdb_data(keystr), value);
 225 }
 226
 227 /****************************************************************************
 228  Store a uint32_t value by an arbitrary blob key, return true on success, false on failure.
 229  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 230 ****************************************************************************/
 231
 232 static bool tdb_store_uint32_byblob(struct tdb_context *tdb, TDB_DATA key,
 233                                     uint32_t value)
 234 {
 235         TDB_DATA data;
 236         uint32_t v_store;
 237         bool ret = true;
 238
 239         SIVAL(&v_store, 0, value);
 240         data.dptr = (unsigned char *)&v_store;
 241         data.dsize = sizeof(uint32_t);
 242
 243         if (tdb_store(tdb, key, data, TDB_REPLACE) != 0)
 244                 ret = false;
 245
 246         return ret;
 247 }
 248
 249 /****************************************************************************
 250  Store a uint32_t value by string key, return true on success, false on failure.
 251  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 252 ****************************************************************************/
 253
 254 bool tdb_store_uint32(struct tdb_context *tdb, const char *keystr, uint32_t value)
 255 {
 256         return tdb_store_uint32_byblob(tdb, string_term_tdb_data(keystr), value);
 257 }
 258 /****************************************************************************
 259  Store a buffer by a null terminated string key.  Return 0 on success, -ve
 260  on failure.
 261 ****************************************************************************/
 262
 263 int tdb_store_bystring(struct tdb_context *tdb, const char *keystr, TDB_DATA data, int flags)
 264 {
 265         TDB_DATA key = string_term_tdb_data(keystr);
 266
 267         return tdb_store(tdb, key, data, flags);
 268 }
 269
 270 /****************************************************************************
 271  Fetch a buffer using a null terminated string key.  Don't forget to call
 272  free() on the result dptr.
 273 ****************************************************************************/
 274
 275 TDB_DATA tdb_fetch_bystring(struct tdb_context *tdb, const char *keystr)
 276 {
 277         TDB_DATA key = string_term_tdb_data(keystr);
 278
 279         return tdb_fetch(tdb, key);
 280 }
 281
 282 /****************************************************************************
 283  Delete an entry using a null terminated string key.
 284 ****************************************************************************/
 285
 286 int tdb_delete_bystring(struct tdb_context *tdb, const char *keystr)
 287 {
 288         TDB_DATA key = string_term_tdb_data(keystr);
 289
 290         return tdb_delete(tdb, key);
 291 }
 292
 293 /****************************************************************************
 294  Atomic integer change. Returns old value. To create, set initial value in *oldval.
 295 ****************************************************************************/
 296
 297 int32_t tdb_change_int32_atomic(struct tdb_context *tdb, const char *keystr, int32_t *oldval, int32_t change_val)
 298 {
 299         int32_t val;
 300         int32_t ret = -1;
 301
 302         if (tdb_lock_bystring(tdb, keystr) != 0)
 303                 return -1;
 304
 305         if ((val = tdb_fetch_int32(tdb, keystr)) == -1) {
 306                 /* The lookup failed */
 307                 if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
 308                         /* but not because it didn't exist */
 309                         goto err_out;
 310                 }
 311
 312                 /* Start with 'old' value */
 313                 val = *oldval;
 314
 315         } else {
 316                 /* It worked, set return value (oldval) to tdb data */
 317                 *oldval = val;
 318         }
 319
 320         /* Increment value for storage and return next time */
 321         val += change_val;
 322
 323         if (tdb_store_int32(tdb, keystr, val) != 0)
 324                 goto err_out;
 325
 326         ret = 0;
 327
 328   err_out:
 329
 330         tdb_unlock_bystring(tdb, keystr);
 331         return ret;
 332 }
 333
 334 /****************************************************************************
 335  Atomic unsigned integer change. Returns old value. To create, set initial value in *oldval.
 336 ****************************************************************************/
 337
 338 bool tdb_change_uint32_atomic(struct tdb_context *tdb, const char *keystr, uint32_t *oldval, uint32_t change_val)
 339 {
 340         uint32_t val;
 341         bool ret = false;
 342
 343         if (tdb_lock_bystring(tdb, keystr) != 0)
 344                 return false;
 345
 346         if (!tdb_fetch_uint32(tdb, keystr, &val)) {
 347                 /* It failed */
 348                 if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
 349                         /* and not because it didn't exist */
 350                         goto err_out;
 351                 }
 352
 353                 /* Start with 'old' value */
 354                 val = *oldval;
 355
 356         } else {
 357                 /* it worked, set return value (oldval) to tdb data */
 358                 *oldval = val;
 359
 360         }
 361
 362         /* get a new value to store */
 363         val += change_val;
 364
 365         if (!tdb_store_uint32(tdb, keystr, val))
 366                 goto err_out;
 367
 368         ret = true;
 369
 370   err_out:
 371
 372         tdb_unlock_bystring(tdb, keystr);
 373         return ret;
 374 }
 375
 376 /****************************************************************************
 377  Return an NTSTATUS from a TDB_ERROR
 378 ****************************************************************************/
 379
 380 NTSTATUS map_nt_error_from_tdb(enum TDB_ERROR err)
 381 {
 382         NTSTATUS result;
 383
 384         switch (err) {
 385         case TDB_SUCCESS:
 386                 result = NT_STATUS_OK;
 387                 break;
 388         case TDB_ERR_CORRUPT:
 389                 result = NT_STATUS_INTERNAL_DB_CORRUPTION;
 390                 break;
 391         case TDB_ERR_IO:
 392                 result = NT_STATUS_UNEXPECTED_IO_ERROR;
 393                 break;
 394         case TDB_ERR_OOM:
 395                 result = NT_STATUS_NO_MEMORY;
 396                 break;
 397         case TDB_ERR_EXISTS:
 398                 result = NT_STATUS_OBJECT_NAME_COLLISION;
 399                 break;
 400
 401         case TDB_ERR_LOCK:
 402                 /*
 403                  * TDB_ERR_LOCK is very broad, we could for example
 404                  * distinguish between fcntl locks and invalid lock
 405                  * sequences. So NT_STATUS_FILE_LOCK_CONFLICT is a
 406                  * compromise.
 407                  */
 408                 result = NT_STATUS_FILE_LOCK_CONFLICT;
 409                 break;
 410
 411         case TDB_ERR_NOLOCK:
 412         case TDB_ERR_LOCK_TIMEOUT:
 413                 /*
 414                  * These two ones in the enum are not actually used
 415                  */
 416                 result = NT_STATUS_FILE_LOCK_CONFLICT;
 417                 break;
 418         case TDB_ERR_NOEXIST:
 419                 result = NT_STATUS_NOT_FOUND;
 420                 break;
 421         case TDB_ERR_EINVAL:
 422                 result = NT_STATUS_INVALID_PARAMETER;
 423                 break;
 424         case TDB_ERR_RDONLY:
 425                 result = NT_STATUS_ACCESS_DENIED;
 426                 break;
 427         case TDB_ERR_NESTING:
 428                 result = NT_STATUS_INTERNAL_ERROR;
 429                 break;
 430         default:
 431                 result = NT_STATUS_INTERNAL_ERROR;
 432                 break;
 433         };
 434         return result;
 435 }
 436
 437 int map_unix_error_from_tdb(enum TDB_ERROR err)
 438 {
 439         int result = EINVAL;
 440
 441         switch (err) {
 442         case TDB_SUCCESS:
 443                 result = 0;
 444                 break;
 445         case TDB_ERR_CORRUPT:
 446                 result = EILSEQ;
 447                 break;
 448         case TDB_ERR_IO:
 449                 result = EIO;
 450                 break;
 451         case TDB_ERR_OOM:
 452                 result = ENOMEM;
 453                 break;
 454         case TDB_ERR_EXISTS:
 455                 result = EEXIST;
 456                 break;
 457
 458         case TDB_ERR_LOCK:
 459                 /*
 460                  * TDB_ERR_LOCK is very broad, we could for example
 461                  * distinguish between fcntl locks and invalid lock
 462                  * sequences. EWOULDBLOCK is wrong, but there is no real
 463                  * generic lock error code in errno.h
 464                  */
 465                 result = EWOULDBLOCK;
 466                 break;
 467
 468         case TDB_ERR_NOLOCK:
 469         case TDB_ERR_LOCK_TIMEOUT:
 470                 /*
 471                  * These two ones in the enum are not actually used
 472                  */
 473                 result = ENOLCK;
 474                 break;
 475         case TDB_ERR_NOEXIST:
 476                 result = ENOENT;
 477                 break;
 478         case TDB_ERR_EINVAL:
 479                 result = EINVAL;
 480                 break;
 481         case TDB_ERR_RDONLY:
 482                 result = EROFS;
 483                 break;
 484         case TDB_ERR_NESTING:
 485                 /*
 486                  * Well, this db is already busy...
 487                  */
 488                 result = EBUSY;
 489                 break;
 490         };
 491         return result;
 492 }
 493
 494 struct tdb_fetch_talloc_state {
 495         TALLOC_CTX *mem_ctx;
 496         uint8_t *buf;
 497 };
 498
 499 static int tdb_fetch_talloc_parser(TDB_DATA key, TDB_DATA data,
 500                                    void *private_data)
 501 {
 502         struct tdb_fetch_talloc_state *state = private_data;
 503         state->buf = talloc_memdup(state->mem_ctx, data.dptr, data.dsize);
 504         return 0;
 505 }
 506
 507 int tdb_fetch_talloc(struct tdb_context *tdb, TDB_DATA key,
 508                      TALLOC_CTX *mem_ctx, uint8_t **buf)
 509 {
 510         struct tdb_fetch_talloc_state state = { .mem_ctx = mem_ctx };
 511         int ret;
 512
 513         ret = tdb_parse_record(tdb, key, tdb_fetch_talloc_parser, &state);
 514         if (ret == -1) {
 515                 enum TDB_ERROR err = tdb_error(tdb);
 516                 return map_unix_error_from_tdb(err);
 517         }
 518
 519         if (state.buf == NULL) {
 520                 return ENOMEM;
 521         }
 522
 523         *buf = state.buf;
 524         return 0;
 525 }