lib/dbwrap/dbwrap_util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Utility functions for the dbwrap API
   4    Copyright (C) Volker Lendecke 2007
   5    Copyright (C) Michael Adam 2009
   6    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006
   7
   8    Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com)
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26 #include "dbwrap.h"
  27 #include "lib/util/util_tdb.h"
  28
  29 struct dbwrap_fetch_int32_state {
  30         NTSTATUS status;
  31         int32_t result;
  32 };
  33
  34 static void dbwrap_fetch_int32_parser(TDB_DATA key, TDB_DATA data,
  35                                       void *private_data)
  36 {
  37         struct dbwrap_fetch_int32_state *state =
  38                 (struct dbwrap_fetch_int32_state *)private_data;
  39
  40         if (data.dsize != sizeof(state->result)) {
  41                 state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
  42                 return;
  43         }
  44         state->result = IVAL(data.dptr, 0);
  45         state->status = NT_STATUS_OK;
  46 }
  47
  48 NTSTATUS dbwrap_fetch_int32(struct db_context *db, TDB_DATA key,
  49                             int32_t *result)
  50 {
  51         struct dbwrap_fetch_int32_state state;
  52         NTSTATUS status;
  53
  54         if (result == NULL) {
  55                 return NT_STATUS_INVALID_PARAMETER;
  56         }
  57
  58         state.status = NT_STATUS_INTERNAL_ERROR;
  59
  60         status = dbwrap_parse_record(db, key, dbwrap_fetch_int32_parser, &state);
  61         if (!NT_STATUS_IS_OK(status)) {
  62                 return status;
  63         }
  64
  65         if (NT_STATUS_IS_OK(state.status)) {
  66                 *result = state.result;
  67         }
  68         return state.status;
  69 }
  70
  71 NTSTATUS dbwrap_fetch_int32_bystring(struct db_context *db, const char *keystr,
  72                                      int32_t *result)
  73 {
  74         return dbwrap_fetch_int32(db, string_term_tdb_data(keystr), result);
  75 }
  76
  77 NTSTATUS dbwrap_store_int32_bystring(struct db_context *db, const char *keystr,
  78                                      int32_t v)
  79 {
  80         struct db_record *rec;
  81         int32_t v_store;
  82         NTSTATUS status;
  83
  84         rec = dbwrap_fetch_locked(db, talloc_tos(),
  85                                   string_term_tdb_data(keystr));
  86         if (rec == NULL) {
  87                 return NT_STATUS_UNSUCCESSFUL;
  88         }
  89
  90         SIVAL(&v_store, 0, v);
  91
  92         status = dbwrap_record_store(rec,
  93                                      make_tdb_data((const uint8_t *)&v_store,
  94                                                    sizeof(v_store)),
  95                                      TDB_REPLACE);
  96         TALLOC_FREE(rec);
  97         return status;
  98 }
  99
 100 NTSTATUS dbwrap_fetch_uint32_bystring(struct db_context *db,
 101                                       const char *keystr, uint32_t *val)
 102 {
 103         TDB_DATA dbuf;
 104         NTSTATUS status;
 105
 106         if (val == NULL) {
 107                 return NT_STATUS_INVALID_PARAMETER;
 108         }
 109
 110         status = dbwrap_fetch_bystring(db, talloc_tos(), keystr, &dbuf);
 111         if (!NT_STATUS_IS_OK(status)) {
 112                 return status;
 113         }
 114
 115         if ((dbuf.dptr == NULL) || (dbuf.dsize == 0)) {
 116                 return NT_STATUS_NOT_FOUND;
 117         }
 118         if (dbuf.dsize != sizeof(uint32_t)) {
 119                 TALLOC_FREE(dbuf.dptr);
 120                 return NT_STATUS_UNSUCCESSFUL;
 121         }
 122
 123         *val = IVAL(dbuf.dptr, 0);
 124         TALLOC_FREE(dbuf.dptr);
 125         return NT_STATUS_OK;
 126 }
 127
 128 NTSTATUS dbwrap_store_uint32_bystring(struct db_context *db,
 129                                       const char *keystr, uint32_t v)
 130 {
 131         struct db_record *rec;
 132         uint32_t v_store;
 133         NTSTATUS status;
 134
 135         rec = dbwrap_fetch_locked(db, talloc_tos(),
 136                                   string_term_tdb_data(keystr));
 137         if (rec == NULL) {
 138                 return NT_STATUS_INVALID_PARAMETER;
 139         }
 140
 141         SIVAL(&v_store, 0, v);
 142
 143         status = dbwrap_record_store(rec,
 144                                      make_tdb_data((const uint8_t *)&v_store,
 145                                                    sizeof(v_store)),
 146                                      TDB_REPLACE);
 147         TALLOC_FREE(rec);
 148         return status;
 149 }
 150
 151 /**
 152  * Atomic unsigned integer change (addition):
 153  *
 154  * if value does not exist yet in the db, use *oldval as initial old value.
 155  * return old value in *oldval.
 156  * store *oldval + change_val to db.
 157  */
 158
 159 struct dbwrap_change_uint32_atomic_context {
 160         const char *keystr;
 161         uint32_t *oldval;
 162         uint32_t change_val;
 163 };
 164
 165 static NTSTATUS dbwrap_change_uint32_atomic_action(struct db_context *db,
 166                                                    void *private_data)
 167 {
 168         struct db_record *rec;
 169         uint32_t val = (uint32_t)-1;
 170         uint32_t v_store;
 171         NTSTATUS ret;
 172         struct dbwrap_change_uint32_atomic_context *state;
 173         TDB_DATA value;
 174
 175         state = (struct dbwrap_change_uint32_atomic_context *)private_data;
 176
 177         rec = dbwrap_fetch_locked(db, talloc_tos(),
 178                                   string_term_tdb_data(state->keystr));
 179         if (!rec) {
 180                 return NT_STATUS_UNSUCCESSFUL;
 181         }
 182
 183         value = dbwrap_record_get_value(rec);
 184
 185         if (value.dptr == NULL) {
 186                 val = *(state->oldval);
 187         } else if (value.dsize == sizeof(val)) {
 188                 val = IVAL(value.dptr, 0);
 189                 *(state->oldval) = val;
 190         } else {
 191                 ret = NT_STATUS_UNSUCCESSFUL;
 192                 goto done;
 193         }
 194
 195         val += state->change_val;
 196
 197         SIVAL(&v_store, 0, val);
 198
 199         ret = dbwrap_record_store(rec,
 200                                   make_tdb_data((const uint8_t *)&v_store,
 201                                                 sizeof(v_store)),
 202                                   TDB_REPLACE);
 203
 204 done:
 205         TALLOC_FREE(rec);
 206         return ret;
 207 }
 208
 209 NTSTATUS dbwrap_change_uint32_atomic_bystring(struct db_context *db,
 210                                               const char *keystr,
 211                                               uint32_t *oldval,
 212                                               uint32_t change_val)
 213 {
 214         NTSTATUS ret;
 215         struct dbwrap_change_uint32_atomic_context state;
 216
 217         state.keystr = keystr;
 218         state.oldval = oldval;
 219         state.change_val = change_val;
 220
 221         ret = dbwrap_change_uint32_atomic_action(db, &state);
 222
 223         return ret;
 224 }
 225
 226 NTSTATUS dbwrap_trans_change_uint32_atomic_bystring(struct db_context *db,
 227                                                     const char *keystr,
 228                                                     uint32_t *oldval,
 229                                                     uint32_t change_val)
 230 {
 231         NTSTATUS ret;
 232         struct dbwrap_change_uint32_atomic_context state;
 233
 234         state.keystr = keystr;
 235         state.oldval = oldval;
 236         state.change_val = change_val;
 237
 238         ret = dbwrap_trans_do(db, dbwrap_change_uint32_atomic_action, &state);
 239
 240         return ret;
 241 }
 242
 243 /**
 244  * Atomic integer change (addition):
 245  *
 246  * if value does not exist yet in the db, use *oldval as initial old value.
 247  * return old value in *oldval.
 248  * store *oldval + change_val to db.
 249  */
 250
 251 struct dbwrap_change_int32_atomic_context {
 252         TDB_DATA key;
 253         int32_t *oldval;
 254         int32_t change_val;
 255 };
 256
 257 static NTSTATUS dbwrap_change_int32_atomic_action(struct db_context *db,
 258                                                   void *private_data)
 259 {
 260         struct db_record *rec;
 261         int32_t val = -1;
 262         int32_t v_store;
 263         NTSTATUS ret;
 264         struct dbwrap_change_int32_atomic_context *state;
 265         TDB_DATA value;
 266
 267         state = (struct dbwrap_change_int32_atomic_context *)private_data;
 268
 269         rec = dbwrap_fetch_locked(db, talloc_tos(), state->key);
 270         if (!rec) {
 271                 return NT_STATUS_UNSUCCESSFUL;
 272         }
 273
 274         value = dbwrap_record_get_value(rec);
 275
 276         if (value.dptr == NULL) {
 277                 val = *(state->oldval);
 278         } else if (value.dsize == sizeof(val)) {
 279                 val = IVAL(value.dptr, 0);
 280                 *(state->oldval) = val;
 281         } else {
 282                 ret = NT_STATUS_UNSUCCESSFUL;
 283                 goto done;
 284         }
 285
 286         val += state->change_val;
 287
 288         SIVAL(&v_store, 0, val);
 289
 290         ret = dbwrap_record_store(rec,
 291                                   make_tdb_data((const uint8_t *)&v_store,
 292                                                 sizeof(v_store)),
 293                                   TDB_REPLACE);
 294
 295 done:
 296         TALLOC_FREE(rec);
 297         return ret;
 298 }
 299
 300 NTSTATUS dbwrap_change_int32_atomic(struct db_context *db,
 301                                     TDB_DATA key,
 302                                     int32_t *oldval,
 303                                     int32_t change_val)
 304 {
 305         NTSTATUS ret;
 306         struct dbwrap_change_int32_atomic_context state;
 307
 308         state.key = key;
 309         state.oldval = oldval;
 310         state.change_val = change_val;
 311
 312         ret = dbwrap_change_int32_atomic_action(db, &state);
 313
 314         return ret;
 315 }
 316
 317 NTSTATUS dbwrap_change_int32_atomic_bystring(struct db_context *db,
 318                                              const char *keystr,
 319                                              int32_t *oldval,
 320                                              int32_t change_val)
 321 {
 322         return dbwrap_change_int32_atomic(db, string_term_tdb_data(keystr),
 323                                           oldval, change_val);
 324 }
 325
 326 NTSTATUS dbwrap_trans_change_int32_atomic_bystring(struct db_context *db,
 327                                                    const char *keystr,
 328                                                    int32_t *oldval,
 329                                                    int32_t change_val)
 330 {
 331         NTSTATUS ret;
 332         struct dbwrap_change_int32_atomic_context state;
 333
 334         state.key = string_term_tdb_data(keystr);
 335         state.oldval = oldval;
 336         state.change_val = change_val;
 337
 338         ret = dbwrap_trans_do(db, dbwrap_change_int32_atomic_action, &state);
 339
 340         return ret;
 341 }
 342
 343 struct dbwrap_store_context {
 344         TDB_DATA *key;
 345         TDB_DATA *dbuf;
 346         int flag;
 347 };
 348
 349 static NTSTATUS dbwrap_store_action(struct db_context *db, void *private_data)
 350 {
 351         struct db_record *rec = NULL;
 352         NTSTATUS status;
 353         struct dbwrap_store_context *store_ctx;
 354
 355         store_ctx = (struct dbwrap_store_context *)private_data;
 356
 357         rec = dbwrap_fetch_locked(db, talloc_tos(), *(store_ctx->key));
 358         if (rec == NULL) {
 359                 DEBUG(5, ("fetch_locked failed\n"));
 360                 return NT_STATUS_NO_MEMORY;
 361         }
 362
 363         status = dbwrap_record_store(rec, *(store_ctx->dbuf), store_ctx->flag);
 364         if (!NT_STATUS_IS_OK(status)) {
 365                 DEBUG(5, ("store returned %s\n", nt_errstr(status)));
 366         }
 367
 368         TALLOC_FREE(rec);
 369         return status;
 370 }
 371
 372 NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
 373                             int flag)
 374 {
 375         NTSTATUS status;
 376         struct dbwrap_store_context store_ctx;
 377
 378         store_ctx.key = &key;
 379         store_ctx.dbuf = &dbuf;
 380         store_ctx.flag = flag;
 381
 382         status = dbwrap_trans_do(db, dbwrap_store_action, &store_ctx);
 383
 384         return status;
 385 }
 386
 387 static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data)
 388 {
 389         NTSTATUS status;
 390         struct db_record *rec;
 391         TDB_DATA *key = (TDB_DATA *)private_data;
 392
 393         rec = dbwrap_fetch_locked(db, talloc_tos(), *key);
 394         if (rec == NULL) {
 395                 DEBUG(5, ("fetch_locked failed\n"));
 396                 return NT_STATUS_NO_MEMORY;
 397         }
 398
 399         status = dbwrap_record_delete(rec);
 400         if (!NT_STATUS_IS_OK(status)) {
 401                 DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status)));
 402         }
 403
 404         talloc_free(rec);
 405         return  status;
 406 }
 407
 408 NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key)
 409 {
 410         NTSTATUS status;
 411
 412         status = dbwrap_trans_do(db, dbwrap_delete_action, &key);
 413
 414         return status;
 415 }
 416
 417 NTSTATUS dbwrap_trans_store_int32_bystring(struct db_context *db,
 418                                            const char *keystr,
 419                                            int32_t v)
 420 {
 421         int32_t v_store;
 422
 423         SIVAL(&v_store, 0, v);
 424
 425         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
 426                                   make_tdb_data((const uint8_t *)&v_store,
 427                                                 sizeof(v_store)),
 428                                   TDB_REPLACE);
 429 }
 430
 431 NTSTATUS dbwrap_trans_store_uint32_bystring(struct db_context *db,
 432                                             const char *keystr,
 433                                             uint32_t v)
 434 {
 435         uint32_t v_store;
 436
 437         SIVAL(&v_store, 0, v);
 438
 439         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
 440                                   make_tdb_data((const uint8_t *)&v_store,
 441                                                 sizeof(v_store)),
 442                                   TDB_REPLACE);
 443 }
 444
 445 NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key,
 446                                      TDB_DATA data, int flags)
 447 {
 448         return dbwrap_trans_store(db, string_term_tdb_data(key), data, flags);
 449 }
 450
 451 NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key)
 452 {
 453         return dbwrap_trans_delete(db, string_term_tdb_data(key));
 454 }
 455
 456 /**
 457  * Wrap db action(s) into a transaction.
 458  */
 459 NTSTATUS dbwrap_trans_do(struct db_context *db,
 460                          NTSTATUS (*action)(struct db_context *, void *),
 461                          void *private_data)
 462 {
 463         int res;
 464         NTSTATUS status;
 465
 466         res = dbwrap_transaction_start(db);
 467         if (res != 0) {
 468                 DEBUG(5, ("transaction_start failed\n"));
 469                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 470         }
 471
 472         status = action(db, private_data);
 473         if (!NT_STATUS_IS_OK(status)) {
 474                 if (dbwrap_transaction_cancel(db) != 0) {
 475                         smb_panic("Cancelling transaction failed");
 476                 }
 477                 return status;
 478         }
 479
 480         res = dbwrap_transaction_commit(db);
 481         if (res == 0) {
 482                 return NT_STATUS_OK;
 483         }
 484
 485         DEBUG(2, ("transaction_commit failed\n"));
 486         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 487 }
 488
 489 struct dbwrap_trans_traverse_action_ctx {
 490         int (*f)(struct db_record* rec, void* private_data);
 491         void* private_data;
 492 };
 493
 494
 495 static NTSTATUS dbwrap_trans_traverse_action(struct db_context* db, void* private_data)
 496 {
 497         struct dbwrap_trans_traverse_action_ctx* ctx =
 498                 (struct dbwrap_trans_traverse_action_ctx*)private_data;
 499
 500         NTSTATUS status = dbwrap_traverse(db, ctx->f, ctx->private_data, NULL);
 501
 502         return status;
 503 }
 504
 505 NTSTATUS dbwrap_trans_traverse(struct db_context *db,
 506                                int (*f)(struct db_record*, void*),
 507                                void *private_data)
 508 {
 509         struct dbwrap_trans_traverse_action_ctx ctx = {
 510                 .f = f,
 511                 .private_data = private_data,
 512         };
 513         return dbwrap_trans_do(db, dbwrap_trans_traverse_action, &ctx);
 514 }
 515
 516 NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key)
 517 {
 518         return dbwrap_delete(db, string_term_tdb_data(key));
 519 }
 520
 521 NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
 522                                TDB_DATA data, int flags)
 523 {
 524         return dbwrap_store(db, string_term_tdb_data(key), data, flags);
 525 }
 526
 527 NTSTATUS dbwrap_fetch_bystring(struct db_context *db, TALLOC_CTX *mem_ctx,
 528                                const char *key, TDB_DATA *value)
 529 {
 530         return dbwrap_fetch(db, mem_ctx, string_term_tdb_data(key), value);
 531 }
 532
 533
 534
 535 NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key)
 536 {
 537         char *key_upper;
 538         NTSTATUS status;
 539
 540         key_upper = talloc_strdup_upper(talloc_tos(), key);
 541         if (key_upper == NULL) {
 542                 return NT_STATUS_NO_MEMORY;
 543         }
 544
 545         status = dbwrap_delete_bystring(db, key_upper);
 546
 547         talloc_free(key_upper);
 548         return status;
 549 }
 550
 551 NTSTATUS dbwrap_store_bystring_upper(struct db_context *db, const char *key,
 552                                      TDB_DATA data, int flags)
 553 {
 554         char *key_upper;
 555         NTSTATUS status;
 556
 557         key_upper = talloc_strdup_upper(talloc_tos(), key);
 558         if (key_upper == NULL) {
 559                 return NT_STATUS_NO_MEMORY;
 560         }
 561
 562         status = dbwrap_store_bystring(db, key_upper, data, flags);
 563
 564         talloc_free(key_upper);
 565         return status;
 566 }
 567
 568 NTSTATUS dbwrap_fetch_bystring_upper(struct db_context *db, TALLOC_CTX *mem_ctx,
 569                                      const char *key, TDB_DATA *value)
 570 {
 571         char *key_upper;
 572         NTSTATUS status;
 573
 574         key_upper = talloc_strdup_upper(talloc_tos(), key);
 575         if (key_upper == NULL) {
 576                 return NT_STATUS_NO_MEMORY;
 577         }
 578
 579         status = dbwrap_fetch_bystring(db, mem_ctx, key_upper, value);
 580
 581         talloc_free(key_upper);
 582         return status;
 583 }