Remove extra 0x prefix for the "%p" format specifiers, avoiding 0x0x0 strings in...
[kai/samba-autobuild/.git] / 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         uint8_t v_store[sizeof(int32_t)];
81         TDB_DATA data = { .dptr = v_store, .dsize = sizeof(v_store) };
82         NTSTATUS status;
83
84         SIVAL(v_store, 0, v);
85
86         status = dbwrap_store(db, string_term_tdb_data(keystr), data,
87                               TDB_REPLACE);
88         return status;
89 }
90
91 struct dbwrap_fetch_uint32_state {
92         NTSTATUS status;
93         uint32_t result;
94 };
95
96 static void dbwrap_fetch_uint32_parser(TDB_DATA key, TDB_DATA data,
97                                        void *private_data)
98 {
99         struct dbwrap_fetch_uint32_state *state =
100                 (struct dbwrap_fetch_uint32_state *)private_data;
101
102         if (data.dsize != sizeof(state->result)) {
103                 state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
104                 return;
105         }
106         state->result = IVAL(data.dptr, 0);
107         state->status = NT_STATUS_OK;
108 }
109
110 NTSTATUS dbwrap_fetch_uint32_bystring(struct db_context *db,
111                                       const char *keystr, uint32_t *val)
112 {
113         struct dbwrap_fetch_uint32_state state;
114         NTSTATUS status;
115
116         if (val == NULL) {
117                 return NT_STATUS_INVALID_PARAMETER;
118         }
119
120         state.status = NT_STATUS_INTERNAL_ERROR;
121
122         status = dbwrap_parse_record(db, string_term_tdb_data(keystr),
123                                      dbwrap_fetch_uint32_parser, &state);
124         if (!NT_STATUS_IS_OK(status)) {
125                 return status;
126         }
127         if (NT_STATUS_IS_OK(state.status)) {
128                 *val = state.result;
129         }
130         return state.status;
131 }
132
133 NTSTATUS dbwrap_store_uint32_bystring(struct db_context *db,
134                                       const char *keystr, uint32_t v)
135 {
136         uint8_t v_store[sizeof(uint32_t)];
137         TDB_DATA data = { .dptr = v_store, .dsize = sizeof(v_store) };
138         NTSTATUS status;
139
140         SIVAL(v_store, 0, v);
141
142         status = dbwrap_store(db, string_term_tdb_data(keystr), data,
143                               TDB_REPLACE);
144         return status;
145 }
146
147 /**
148  * Atomic unsigned integer change (addition):
149  *
150  * if value does not exist yet in the db, use *oldval as initial old value.
151  * return old value in *oldval.
152  * store *oldval + change_val to db.
153  */
154
155 struct dbwrap_change_uint32_atomic_context {
156         const char *keystr;
157         uint32_t *oldval;
158         uint32_t change_val;
159 };
160
161 static NTSTATUS dbwrap_change_uint32_atomic_action(struct db_context *db,
162                                                    void *private_data)
163 {
164         struct db_record *rec;
165         uint32_t val = (uint32_t)-1;
166         uint32_t v_store;
167         NTSTATUS ret;
168         struct dbwrap_change_uint32_atomic_context *state;
169         TDB_DATA value;
170
171         state = (struct dbwrap_change_uint32_atomic_context *)private_data;
172
173         rec = dbwrap_fetch_locked(db, talloc_tos(),
174                                   string_term_tdb_data(state->keystr));
175         if (!rec) {
176                 return NT_STATUS_UNSUCCESSFUL;
177         }
178
179         value = dbwrap_record_get_value(rec);
180
181         if (value.dptr == NULL) {
182                 val = *(state->oldval);
183         } else if (value.dsize == sizeof(val)) {
184                 val = IVAL(value.dptr, 0);
185                 *(state->oldval) = val;
186         } else {
187                 ret = NT_STATUS_UNSUCCESSFUL;
188                 goto done;
189         }
190
191         val += state->change_val;
192
193         SIVAL(&v_store, 0, val);
194
195         ret = dbwrap_record_store(rec,
196                                   make_tdb_data((const uint8_t *)&v_store,
197                                                 sizeof(v_store)),
198                                   TDB_REPLACE);
199
200 done:
201         TALLOC_FREE(rec);
202         return ret;
203 }
204
205 NTSTATUS dbwrap_change_uint32_atomic_bystring(struct db_context *db,
206                                               const char *keystr,
207                                               uint32_t *oldval,
208                                               uint32_t change_val)
209 {
210         NTSTATUS ret;
211         struct dbwrap_change_uint32_atomic_context state;
212
213         state.keystr = keystr;
214         state.oldval = oldval;
215         state.change_val = change_val;
216
217         ret = dbwrap_change_uint32_atomic_action(db, &state);
218
219         return ret;
220 }
221
222 NTSTATUS dbwrap_trans_change_uint32_atomic_bystring(struct db_context *db,
223                                                     const char *keystr,
224                                                     uint32_t *oldval,
225                                                     uint32_t change_val)
226 {
227         NTSTATUS ret;
228         struct dbwrap_change_uint32_atomic_context state;
229
230         state.keystr = keystr;
231         state.oldval = oldval;
232         state.change_val = change_val;
233
234         ret = dbwrap_trans_do(db, dbwrap_change_uint32_atomic_action, &state);
235
236         return ret;
237 }
238
239 /**
240  * Atomic integer change (addition):
241  *
242  * if value does not exist yet in the db, use *oldval as initial old value.
243  * return old value in *oldval.
244  * store *oldval + change_val to db.
245  */
246
247 struct dbwrap_change_int32_atomic_context {
248         TDB_DATA key;
249         int32_t *oldval;
250         int32_t change_val;
251 };
252
253 static NTSTATUS dbwrap_change_int32_atomic_action(struct db_context *db,
254                                                   void *private_data)
255 {
256         struct db_record *rec;
257         int32_t val = -1;
258         int32_t v_store;
259         NTSTATUS ret;
260         struct dbwrap_change_int32_atomic_context *state;
261         TDB_DATA value;
262
263         state = (struct dbwrap_change_int32_atomic_context *)private_data;
264
265         rec = dbwrap_fetch_locked(db, talloc_tos(), state->key);
266         if (!rec) {
267                 return NT_STATUS_UNSUCCESSFUL;
268         }
269
270         value = dbwrap_record_get_value(rec);
271
272         if (value.dptr == NULL) {
273                 val = *(state->oldval);
274         } else if (value.dsize == sizeof(val)) {
275                 val = IVAL(value.dptr, 0);
276                 *(state->oldval) = val;
277         } else {
278                 ret = NT_STATUS_UNSUCCESSFUL;
279                 goto done;
280         }
281
282         val += state->change_val;
283
284         SIVAL(&v_store, 0, val);
285
286         ret = dbwrap_record_store(rec,
287                                   make_tdb_data((const uint8_t *)&v_store,
288                                                 sizeof(v_store)),
289                                   TDB_REPLACE);
290
291 done:
292         TALLOC_FREE(rec);
293         return ret;
294 }
295
296 NTSTATUS dbwrap_change_int32_atomic(struct db_context *db,
297                                     TDB_DATA key,
298                                     int32_t *oldval,
299                                     int32_t change_val)
300 {
301         NTSTATUS ret;
302         struct dbwrap_change_int32_atomic_context state;
303
304         state.key = key;
305         state.oldval = oldval;
306         state.change_val = change_val;
307
308         ret = dbwrap_change_int32_atomic_action(db, &state);
309
310         return ret;
311 }
312
313 NTSTATUS dbwrap_change_int32_atomic_bystring(struct db_context *db,
314                                              const char *keystr,
315                                              int32_t *oldval,
316                                              int32_t change_val)
317 {
318         return dbwrap_change_int32_atomic(db, string_term_tdb_data(keystr),
319                                           oldval, change_val);
320 }
321
322 NTSTATUS dbwrap_trans_change_int32_atomic_bystring(struct db_context *db,
323                                                    const char *keystr,
324                                                    int32_t *oldval,
325                                                    int32_t change_val)
326 {
327         NTSTATUS ret;
328         struct dbwrap_change_int32_atomic_context state;
329
330         state.key = string_term_tdb_data(keystr);
331         state.oldval = oldval;
332         state.change_val = change_val;
333
334         ret = dbwrap_trans_do(db, dbwrap_change_int32_atomic_action, &state);
335
336         return ret;
337 }
338
339 struct dbwrap_store_context {
340         TDB_DATA *key;
341         TDB_DATA *dbuf;
342         int flag;
343 };
344
345 static NTSTATUS dbwrap_store_action(struct db_context *db, void *private_data)
346 {
347         NTSTATUS status;
348         struct dbwrap_store_context *store_ctx;
349
350         store_ctx = (struct dbwrap_store_context *)private_data;
351
352         status = dbwrap_store(db, *(store_ctx->key), *(store_ctx->dbuf),
353                               store_ctx->flag);
354         if (!NT_STATUS_IS_OK(status)) {
355                 DEBUG(5, ("store returned %s\n", nt_errstr(status)));
356         }
357
358         return status;
359 }
360
361 NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
362                             int flag)
363 {
364         NTSTATUS status;
365         struct dbwrap_store_context store_ctx;
366
367         store_ctx.key = &key;
368         store_ctx.dbuf = &dbuf;
369         store_ctx.flag = flag;
370
371         status = dbwrap_trans_do(db, dbwrap_store_action, &store_ctx);
372
373         return status;
374 }
375
376 static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data)
377 {
378         NTSTATUS status;
379         TDB_DATA *key = (TDB_DATA *)private_data;
380
381         status = dbwrap_delete(db, *key);
382         if (!NT_STATUS_IS_OK(status)) {
383                 DBG_INFO("dbwrap_record_delete returned %s\n",
384                          nt_errstr(status));
385         }
386         return  status;
387 }
388
389 NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key)
390 {
391         NTSTATUS status;
392
393         status = dbwrap_trans_do(db, dbwrap_delete_action, &key);
394
395         return status;
396 }
397
398 NTSTATUS dbwrap_trans_store_int32_bystring(struct db_context *db,
399                                            const char *keystr,
400                                            int32_t v)
401 {
402         int32_t v_store;
403
404         SIVAL(&v_store, 0, v);
405
406         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
407                                   make_tdb_data((const uint8_t *)&v_store,
408                                                 sizeof(v_store)),
409                                   TDB_REPLACE);
410 }
411
412 NTSTATUS dbwrap_trans_store_uint32_bystring(struct db_context *db,
413                                             const char *keystr,
414                                             uint32_t v)
415 {
416         uint32_t v_store;
417
418         SIVAL(&v_store, 0, v);
419
420         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
421                                   make_tdb_data((const uint8_t *)&v_store,
422                                                 sizeof(v_store)),
423                                   TDB_REPLACE);
424 }
425
426 NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key,
427                                      TDB_DATA data, int flags)
428 {
429         return dbwrap_trans_store(db, string_term_tdb_data(key), data, flags);
430 }
431
432 NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key)
433 {
434         return dbwrap_trans_delete(db, string_term_tdb_data(key));
435 }
436
437 /**
438  * Wrap db action(s) into a transaction.
439  */
440 NTSTATUS dbwrap_trans_do(struct db_context *db,
441                          NTSTATUS (*action)(struct db_context *, void *),
442                          void *private_data)
443 {
444         int res;
445         NTSTATUS status;
446
447         res = dbwrap_transaction_start(db);
448         if (res != 0) {
449                 DEBUG(5, ("transaction_start failed\n"));
450                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
451         }
452
453         status = action(db, private_data);
454         if (!NT_STATUS_IS_OK(status)) {
455                 if (dbwrap_transaction_cancel(db) != 0) {
456                         smb_panic("Cancelling transaction failed");
457                 }
458                 return status;
459         }
460
461         res = dbwrap_transaction_commit(db);
462         if (res == 0) {
463                 return NT_STATUS_OK;
464         }
465
466         DEBUG(2, ("transaction_commit failed\n"));
467         return NT_STATUS_INTERNAL_DB_CORRUPTION;
468 }
469
470 struct dbwrap_trans_traverse_action_ctx {
471         int (*f)(struct db_record* rec, void* private_data);
472         void* private_data;
473 };
474
475
476 static NTSTATUS dbwrap_trans_traverse_action(struct db_context* db, void* private_data)
477 {
478         struct dbwrap_trans_traverse_action_ctx* ctx =
479                 (struct dbwrap_trans_traverse_action_ctx*)private_data;
480
481         NTSTATUS status = dbwrap_traverse(db, ctx->f, ctx->private_data, NULL);
482
483         return status;
484 }
485
486 NTSTATUS dbwrap_trans_traverse(struct db_context *db,
487                                int (*f)(struct db_record*, void*),
488                                void *private_data)
489 {
490         struct dbwrap_trans_traverse_action_ctx ctx = {
491                 .f = f,
492                 .private_data = private_data,
493         };
494         return dbwrap_trans_do(db, dbwrap_trans_traverse_action, &ctx);
495 }
496
497 NTSTATUS dbwrap_purge(struct db_context *db, TDB_DATA key)
498 {
499         NTSTATUS status;
500
501         status = dbwrap_delete(db, key);
502         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
503                 status = NT_STATUS_OK;
504         }
505
506         return status;
507 }
508
509 NTSTATUS dbwrap_purge_bystring(struct db_context *db, const char *key)
510 {
511         return dbwrap_purge(db, string_term_tdb_data(key));
512 }
513
514 NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key)
515 {
516         return dbwrap_delete(db, string_term_tdb_data(key));
517 }
518
519 NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
520                                TDB_DATA data, int flags)
521 {
522         return dbwrap_store(db, string_term_tdb_data(key), data, flags);
523 }
524
525 NTSTATUS dbwrap_fetch_bystring(struct db_context *db, TALLOC_CTX *mem_ctx,
526                                const char *key, TDB_DATA *value)
527 {
528         return dbwrap_fetch(db, mem_ctx, string_term_tdb_data(key), value);
529 }
530
531
532
533 NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key)
534 {
535         char *key_upper;
536         NTSTATUS status;
537
538         key_upper = talloc_strdup_upper(talloc_tos(), key);
539         if (key_upper == NULL) {
540                 return NT_STATUS_NO_MEMORY;
541         }
542
543         status = dbwrap_delete_bystring(db, key_upper);
544
545         talloc_free(key_upper);
546         return status;
547 }
548
549 NTSTATUS dbwrap_store_bystring_upper(struct db_context *db, const char *key,
550                                      TDB_DATA data, int flags)
551 {
552         char *key_upper;
553         NTSTATUS status;
554
555         key_upper = talloc_strdup_upper(talloc_tos(), key);
556         if (key_upper == NULL) {
557                 return NT_STATUS_NO_MEMORY;
558         }
559
560         status = dbwrap_store_bystring(db, key_upper, data, flags);
561
562         talloc_free(key_upper);
563         return status;
564 }
565
566 NTSTATUS dbwrap_fetch_bystring_upper(struct db_context *db, TALLOC_CTX *mem_ctx,
567                                      const char *key, TDB_DATA *value)
568 {
569         char *key_upper;
570         NTSTATUS status;
571
572         key_upper = talloc_strdup_upper(talloc_tos(), key);
573         if (key_upper == NULL) {
574                 return NT_STATUS_NO_MEMORY;
575         }
576
577         status = dbwrap_fetch_bystring(db, mem_ctx, key_upper, value);
578
579         talloc_free(key_upper);
580         return status;
581 }
582
583 struct dbwrap_marshall_state {
584         uint8_t *buf;
585         size_t bufsize;
586         size_t dbsize;
587 };
588
589 static int dbwrap_marshall_fn(struct db_record *rec, void *private_data)
590 {
591         struct dbwrap_marshall_state *state = private_data;
592         TDB_DATA key, value;
593         size_t new_dbsize;
594
595         key = dbwrap_record_get_key(rec);
596         value = dbwrap_record_get_value(rec);
597
598         new_dbsize = state->dbsize;
599         new_dbsize += 8 + key.dsize;
600         new_dbsize += 8 + value.dsize;
601
602         if (new_dbsize <= state->bufsize) {
603                 uint8_t *p = state->buf + state->dbsize;
604
605                 SBVAL(p, 0, key.dsize);
606                 p += 8;
607                 memcpy(p, key.dptr, key.dsize);
608                 p += key.dsize;
609
610                 SBVAL(p, 0, value.dsize);
611                 p += 8;
612                 memcpy(p, value.dptr, value.dsize);
613         }
614         state->dbsize = new_dbsize;
615         return 0;
616 }
617
618 size_t dbwrap_marshall(struct db_context *db, uint8_t *buf, size_t bufsize)
619 {
620         struct dbwrap_marshall_state state;
621
622         state.bufsize = bufsize;
623         state.buf = buf;
624         state.dbsize = 0;
625
626         dbwrap_traverse_read(db, dbwrap_marshall_fn, &state, NULL);
627
628         return state.dbsize;
629 }
630
631 static ssize_t dbwrap_unmarshall_get_data(const uint8_t *buf, size_t buflen,
632                                           size_t ofs, TDB_DATA *pdata)
633 {
634         uint64_t space, len;
635         const uint8_t *p;
636
637         if (ofs == buflen) {
638                 return 0;
639         }
640         if (ofs > buflen) {
641                 return -1;
642         }
643
644         space = buflen - ofs;
645         if (space < 8) {
646                 return -1;
647         }
648
649         p = buf + ofs;
650         len = BVAL(p, 0);
651
652         p += 8;
653         space -= 8;
654
655         if (len > space) {
656                 return -1;
657         }
658
659         *pdata = (TDB_DATA) { .dptr = discard_const_p(uint8_t, p),
660                               .dsize = len };
661         return len + 8;
662 }
663
664 NTSTATUS dbwrap_parse_marshall_buf(const uint8_t *buf, size_t buflen,
665                                    bool (*fn)(TDB_DATA key, TDB_DATA value,
666                                               void *private_data),
667                                    void *private_data)
668 {
669         size_t ofs = 0;
670
671         while (true) {
672                 ssize_t len;
673                 TDB_DATA key, value;
674                 bool ok;
675
676                 len = dbwrap_unmarshall_get_data(buf, buflen, ofs, &key);
677                 if (len == 0) {
678                         break;
679                 }
680                 if (len == -1) {
681                         return NT_STATUS_INVALID_PARAMETER;
682                 }
683                 ofs += len;
684
685                 len = dbwrap_unmarshall_get_data(buf, buflen, ofs, &value);
686                 if (len == 0) {
687                         break;
688                 }
689                 if (len == -1) {
690                         return NT_STATUS_INVALID_PARAMETER;
691                 }
692                 ofs += len;
693
694                 ok = fn(key, value, private_data);
695                 if (!ok) {
696                         break;
697                 }
698         }
699
700         return NT_STATUS_OK;
701 }
702
703 struct dbwrap_unmarshall_state {
704         struct db_context *db;
705         NTSTATUS ret;
706 };
707
708 static bool dbwrap_unmarshall_fn(TDB_DATA key, TDB_DATA value,
709                                  void *private_data)
710 {
711         struct dbwrap_unmarshall_state *state = private_data;
712         NTSTATUS status;
713
714         status = dbwrap_store(state->db, key, value, 0);
715         if (!NT_STATUS_IS_OK(status)) {
716                 DBG_DEBUG("dbwrap_record_store failed: %s\n",
717                           nt_errstr(status));
718                 state->ret = status;
719                 return false;
720         }
721
722         return true;
723 }
724
725 NTSTATUS dbwrap_unmarshall(struct db_context *db, const uint8_t *buf,
726                            size_t buflen)
727 {
728         struct dbwrap_unmarshall_state state = { .db = db };
729         NTSTATUS status;
730
731         status = dbwrap_parse_marshall_buf(buf, buflen,
732                                            dbwrap_unmarshall_fn, &state);
733         if (!NT_STATUS_IS_OK(status)) {
734                 return status;
735         }
736         return state.ret;
737 }