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 NTSTATUS dbwrap_fetch_int32_bystring(struct db_context *db, const char *keystr,
  30                                      int32_t *result)
  31 {
  32         TDB_DATA dbuf;
  33         NTSTATUS status;
  34
  35         if (result == NULL) {
  36                 return NT_STATUS_INVALID_PARAMETER;
  37         }
  38
  39         status = dbwrap_fetch_bystring(db, talloc_tos(), keystr, &dbuf);
  40         if (!NT_STATUS_IS_OK(status)) {
  41                 return status;
  42         }
  43
  44         if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(int32_t))) {
  45                 TALLOC_FREE(dbuf.dptr);
  46                 return NT_STATUS_NOT_FOUND;
  47         }
  48
  49         *result = IVAL(dbuf.dptr, 0);
  50         TALLOC_FREE(dbuf.dptr);
  51         return NT_STATUS_OK;
  52 }
  53
  54 NTSTATUS dbwrap_store_int32_bystring(struct db_context *db, const char *keystr,
  55                                      int32_t v)
  56 {
  57         struct db_record *rec;
  58         int32_t v_store;
  59         NTSTATUS status;
  60
  61         rec = dbwrap_fetch_locked(db, talloc_tos(),
  62                                   string_term_tdb_data(keystr));
  63         if (rec == NULL) {
  64                 return NT_STATUS_UNSUCCESSFUL;
  65         }
  66
  67         SIVAL(&v_store, 0, v);
  68
  69         status = dbwrap_record_store(rec,
  70                                      make_tdb_data((const uint8_t *)&v_store,
  71                                                    sizeof(v_store)),
  72                                      TDB_REPLACE);
  73         TALLOC_FREE(rec);
  74         return status;
  75 }
  76
  77 NTSTATUS dbwrap_fetch_uint32(struct db_context *db, const char *keystr,
  78                              uint32_t *val)
  79 {
  80         TDB_DATA dbuf;
  81         NTSTATUS status;
  82
  83         if (val == NULL) {
  84                 return NT_STATUS_INVALID_PARAMETER;
  85         }
  86
  87         status = dbwrap_fetch_bystring(db, talloc_tos(), keystr, &dbuf);
  88         if (!NT_STATUS_IS_OK(status)) {
  89                 return status;
  90         }
  91
  92         if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(uint32_t))) {
  93                 TALLOC_FREE(dbuf.dptr);
  94                 return NT_STATUS_NOT_FOUND;
  95         }
  96
  97         *val = IVAL(dbuf.dptr, 0);
  98         TALLOC_FREE(dbuf.dptr);
  99         return NT_STATUS_OK;
 100 }
 101
 102 NTSTATUS dbwrap_store_uint32(struct db_context *db, const char *keystr,
 103                              uint32_t v)
 104 {
 105         struct db_record *rec;
 106         uint32_t v_store;
 107         NTSTATUS status;
 108
 109         rec = dbwrap_fetch_locked(db, talloc_tos(),
 110                                   string_term_tdb_data(keystr));
 111         if (rec == NULL) {
 112                 return NT_STATUS_INVALID_PARAMETER;
 113         }
 114
 115         SIVAL(&v_store, 0, v);
 116
 117         status = dbwrap_record_store(rec,
 118                                      make_tdb_data((const uint8_t *)&v_store,
 119                                                    sizeof(v_store)),
 120                                      TDB_REPLACE);
 121         TALLOC_FREE(rec);
 122         return status;
 123 }
 124
 125 /**
 126  * Atomic unsigned integer change (addition):
 127  *
 128  * if value does not exist yet in the db, use *oldval as initial old value.
 129  * return old value in *oldval.
 130  * store *oldval + change_val to db.
 131  */
 132
 133 struct dbwrap_change_uint32_atomic_context {
 134         const char *keystr;
 135         uint32_t *oldval;
 136         uint32_t change_val;
 137 };
 138
 139 static NTSTATUS dbwrap_change_uint32_atomic_action(struct db_context *db,
 140                                                    void *private_data)
 141 {
 142         struct db_record *rec;
 143         uint32_t val = (uint32_t)-1;
 144         uint32_t v_store;
 145         NTSTATUS ret;
 146         struct dbwrap_change_uint32_atomic_context *state;
 147         TDB_DATA value;
 148
 149         state = (struct dbwrap_change_uint32_atomic_context *)private_data;
 150
 151         rec = dbwrap_fetch_locked(db, talloc_tos(),
 152                                   string_term_tdb_data(state->keystr));
 153         if (!rec) {
 154                 return NT_STATUS_UNSUCCESSFUL;
 155         }
 156
 157         value = dbwrap_record_get_value(rec);
 158
 159         if (value.dptr == NULL) {
 160                 val = *(state->oldval);
 161         } else if (value.dsize == sizeof(val)) {
 162                 val = IVAL(value.dptr, 0);
 163                 *(state->oldval) = val;
 164         } else {
 165                 ret = NT_STATUS_UNSUCCESSFUL;
 166                 goto done;
 167         }
 168
 169         val += state->change_val;
 170
 171         SIVAL(&v_store, 0, val);
 172
 173         ret = dbwrap_record_store(rec,
 174                                   make_tdb_data((const uint8_t *)&v_store,
 175                                                 sizeof(v_store)),
 176                                   TDB_REPLACE);
 177
 178 done:
 179         TALLOC_FREE(rec);
 180         return ret;
 181 }
 182
 183 NTSTATUS dbwrap_change_uint32_atomic(struct db_context *db, const char *keystr,
 184                                      uint32_t *oldval, uint32_t change_val)
 185 {
 186         NTSTATUS ret;
 187         struct dbwrap_change_uint32_atomic_context state;
 188
 189         state.keystr = keystr;
 190         state.oldval = oldval;
 191         state.change_val = change_val;
 192
 193         ret = dbwrap_change_uint32_atomic_action(db, &state);
 194
 195         return ret;
 196 }
 197
 198 NTSTATUS dbwrap_trans_change_uint32_atomic(struct db_context *db,
 199                                            const char *keystr,
 200                                            uint32_t *oldval,
 201                                            uint32_t change_val)
 202 {
 203         NTSTATUS ret;
 204         struct dbwrap_change_uint32_atomic_context state;
 205
 206         state.keystr = keystr;
 207         state.oldval = oldval;
 208         state.change_val = change_val;
 209
 210         ret = dbwrap_trans_do(db, dbwrap_change_uint32_atomic_action, &state);
 211
 212         return ret;
 213 }
 214
 215 /**
 216  * Atomic integer change (addition):
 217  *
 218  * if value does not exist yet in the db, use *oldval as initial old value.
 219  * return old value in *oldval.
 220  * store *oldval + change_val to db.
 221  */
 222
 223 struct dbwrap_change_int32_atomic_context {
 224         const char *keystr;
 225         int32_t *oldval;
 226         int32_t change_val;
 227 };
 228
 229 static NTSTATUS dbwrap_change_int32_atomic_action(struct db_context *db,
 230                                                   void *private_data)
 231 {
 232         struct db_record *rec;
 233         int32_t val = -1;
 234         int32_t v_store;
 235         NTSTATUS ret;
 236         struct dbwrap_change_int32_atomic_context *state;
 237         TDB_DATA value;
 238
 239         state = (struct dbwrap_change_int32_atomic_context *)private_data;
 240
 241         rec = dbwrap_fetch_locked(db, talloc_tos(),
 242                                   string_term_tdb_data(state->keystr));
 243         if (!rec) {
 244                 return NT_STATUS_UNSUCCESSFUL;
 245         }
 246
 247         value = dbwrap_record_get_value(rec);
 248
 249         if (value.dptr == NULL) {
 250                 val = *(state->oldval);
 251         } else if (value.dsize == sizeof(val)) {
 252                 val = IVAL(value.dptr, 0);
 253                 *(state->oldval) = val;
 254         } else {
 255                 ret = NT_STATUS_UNSUCCESSFUL;
 256                 goto done;
 257         }
 258
 259         val += state->change_val;
 260
 261         SIVAL(&v_store, 0, val);
 262
 263         ret = dbwrap_record_store(rec,
 264                                   make_tdb_data((const uint8_t *)&v_store,
 265                                                 sizeof(v_store)),
 266                                   TDB_REPLACE);
 267
 268 done:
 269         TALLOC_FREE(rec);
 270         return ret;
 271 }
 272
 273 NTSTATUS dbwrap_change_int32_atomic(struct db_context *db, const char *keystr,
 274                                     int32_t *oldval, int32_t change_val)
 275 {
 276         NTSTATUS ret;
 277         struct dbwrap_change_int32_atomic_context state;
 278
 279         state.keystr = keystr;
 280         state.oldval = oldval;
 281         state.change_val = change_val;
 282
 283         ret = dbwrap_change_int32_atomic_action(db, &state);
 284
 285         return ret;
 286 }
 287
 288 NTSTATUS dbwrap_trans_change_int32_atomic(struct db_context *db,
 289                                           const char *keystr,
 290                                           int32_t *oldval,
 291                                           int32_t change_val)
 292 {
 293         NTSTATUS ret;
 294         struct dbwrap_change_int32_atomic_context state;
 295
 296         state.keystr = keystr;
 297         state.oldval = oldval;
 298         state.change_val = change_val;
 299
 300         ret = dbwrap_trans_do(db, dbwrap_change_int32_atomic_action, &state);
 301
 302         return ret;
 303 }
 304
 305 struct dbwrap_store_context {
 306         TDB_DATA *key;
 307         TDB_DATA *dbuf;
 308         int flag;
 309 };
 310
 311 static NTSTATUS dbwrap_store_action(struct db_context *db, void *private_data)
 312 {
 313         struct db_record *rec = NULL;
 314         NTSTATUS status;
 315         struct dbwrap_store_context *store_ctx;
 316
 317         store_ctx = (struct dbwrap_store_context *)private_data;
 318
 319         rec = dbwrap_fetch_locked(db, talloc_tos(), *(store_ctx->key));
 320         if (rec == NULL) {
 321                 DEBUG(5, ("fetch_locked failed\n"));
 322                 return NT_STATUS_NO_MEMORY;
 323         }
 324
 325         status = dbwrap_record_store(rec, *(store_ctx->dbuf), store_ctx->flag);
 326         if (!NT_STATUS_IS_OK(status)) {
 327                 DEBUG(5, ("store returned %s\n", nt_errstr(status)));
 328         }
 329
 330         TALLOC_FREE(rec);
 331         return status;
 332 }
 333
 334 NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
 335                             int flag)
 336 {
 337         NTSTATUS status;
 338         struct dbwrap_store_context store_ctx;
 339
 340         store_ctx.key = &key;
 341         store_ctx.dbuf = &dbuf;
 342         store_ctx.flag = flag;
 343
 344         status = dbwrap_trans_do(db, dbwrap_store_action, &store_ctx);
 345
 346         return status;
 347 }
 348
 349 static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data)
 350 {
 351         NTSTATUS status;
 352         struct db_record *rec;
 353         TDB_DATA *key = (TDB_DATA *)private_data;
 354
 355         rec = dbwrap_fetch_locked(db, talloc_tos(), *key);
 356         if (rec == NULL) {
 357                 DEBUG(5, ("fetch_locked failed\n"));
 358                 return NT_STATUS_NO_MEMORY;
 359         }
 360
 361         status = dbwrap_record_delete(rec);
 362         if (!NT_STATUS_IS_OK(status)) {
 363                 DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status)));
 364         }
 365
 366         talloc_free(rec);
 367         return  status;
 368 }
 369
 370 NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key)
 371 {
 372         NTSTATUS status;
 373
 374         status = dbwrap_trans_do(db, dbwrap_delete_action, &key);
 375
 376         return status;
 377 }
 378
 379 NTSTATUS dbwrap_trans_store_int32(struct db_context *db, const char *keystr,
 380                                   int32_t v)
 381 {
 382         int32_t v_store;
 383
 384         SIVAL(&v_store, 0, v);
 385
 386         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
 387                                   make_tdb_data((const uint8_t *)&v_store,
 388                                                 sizeof(v_store)),
 389                                   TDB_REPLACE);
 390 }
 391
 392 NTSTATUS dbwrap_trans_store_uint32(struct db_context *db, const char *keystr,
 393                                    uint32_t v)
 394 {
 395         uint32_t v_store;
 396
 397         SIVAL(&v_store, 0, v);
 398
 399         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
 400                                   make_tdb_data((const uint8_t *)&v_store,
 401                                                 sizeof(v_store)),
 402                                   TDB_REPLACE);
 403 }
 404
 405 NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key,
 406                                      TDB_DATA data, int flags)
 407 {
 408         return dbwrap_trans_store(db, string_term_tdb_data(key), data, flags);
 409 }
 410
 411 NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key)
 412 {
 413         return dbwrap_trans_delete(db, string_term_tdb_data(key));
 414 }
 415
 416 /**
 417  * Wrap db action(s) into a transaction.
 418  */
 419 NTSTATUS dbwrap_trans_do(struct db_context *db,
 420                          NTSTATUS (*action)(struct db_context *, void *),
 421                          void *private_data)
 422 {
 423         int res;
 424         NTSTATUS status;
 425
 426         res = dbwrap_transaction_start(db);
 427         if (res != 0) {
 428                 DEBUG(5, ("transaction_start failed\n"));
 429                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 430         }
 431
 432         status = action(db, private_data);
 433         if (!NT_STATUS_IS_OK(status)) {
 434                 if (dbwrap_transaction_cancel(db) != 0) {
 435                         smb_panic("Cancelling transaction failed");
 436                 }
 437                 return status;
 438         }
 439
 440         res = dbwrap_transaction_commit(db);
 441         if (res == 0) {
 442                 return NT_STATUS_OK;
 443         }
 444
 445         DEBUG(2, ("transaction_commit failed\n"));
 446         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 447 }
 448
 449 struct dbwrap_trans_traverse_action_ctx {
 450         int (*f)(struct db_record* rec, void* private_data);
 451         void* private_data;
 452 };
 453
 454
 455 static NTSTATUS dbwrap_trans_traverse_action(struct db_context* db, void* private_data)
 456 {
 457         struct dbwrap_trans_traverse_action_ctx* ctx =
 458                 (struct dbwrap_trans_traverse_action_ctx*)private_data;
 459
 460         NTSTATUS status = dbwrap_traverse(db, ctx->f, ctx->private_data, NULL);
 461
 462         return status;
 463 }
 464
 465 NTSTATUS dbwrap_trans_traverse(struct db_context *db,
 466                                int (*f)(struct db_record*, void*),
 467                                void *private_data)
 468 {
 469         struct dbwrap_trans_traverse_action_ctx ctx = {
 470                 .f = f,
 471                 .private_data = private_data,
 472         };
 473         return dbwrap_trans_do(db, dbwrap_trans_traverse_action, &ctx);
 474 }
 475
 476 NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key)
 477 {
 478         return dbwrap_delete(db, string_term_tdb_data(key));
 479 }
 480
 481 NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
 482                                TDB_DATA data, int flags)
 483 {
 484         return dbwrap_store(db, string_term_tdb_data(key), data, flags);
 485 }
 486
 487 NTSTATUS dbwrap_fetch_bystring(struct db_context *db, TALLOC_CTX *mem_ctx,
 488                                const char *key, TDB_DATA *value)
 489 {
 490         return dbwrap_fetch(db, mem_ctx, string_term_tdb_data(key), value);
 491 }
 492
 493
 494
 495 NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key)
 496 {
 497         char *key_upper;
 498         NTSTATUS status;
 499
 500         key_upper = talloc_strdup_upper(talloc_tos(), key);
 501         if (key_upper == NULL) {
 502                 return NT_STATUS_NO_MEMORY;
 503         }
 504
 505         status = dbwrap_delete_bystring(db, key_upper);
 506
 507         talloc_free(key_upper);
 508         return status;
 509 }
 510
 511 NTSTATUS dbwrap_store_bystring_upper(struct db_context *db, const char *key,
 512                                      TDB_DATA data, int flags)
 513 {
 514         char *key_upper;
 515         NTSTATUS status;
 516
 517         key_upper = talloc_strdup_upper(talloc_tos(), key);
 518         if (key_upper == NULL) {
 519                 return NT_STATUS_NO_MEMORY;
 520         }
 521
 522         status = dbwrap_store_bystring(db, key_upper, data, flags);
 523
 524         talloc_free(key_upper);
 525         return status;
 526 }
 527
 528 NTSTATUS dbwrap_fetch_bystring_upper(struct db_context *db, TALLOC_CTX *mem_ctx,
 529                                      const char *key, TDB_DATA *value)
 530 {
 531         char *key_upper;
 532         NTSTATUS status;
 533
 534         key_upper = talloc_strdup_upper(talloc_tos(), key);
 535         if (key_upper == NULL) {
 536                 return NT_STATUS_NO_MEMORY;
 537         }
 538
 539         status = dbwrap_fetch_bystring(db, mem_ctx, key_upper, value);
 540
 541         talloc_free(key_upper);
 542         return status;
 543 }