s3:dbwrap: use the transaction wrapper in dbwrap_trans_delete().

[ira/wip.git] / source3 / lib / dbwrap_util.c

diff --git a/source3/lib/dbwrap_util.c b/source3/lib/dbwrap_util.c
index 07e50827d44d2437f80fce77e09653225fcfc2ec..32a1dd48e6faa148adf6290952e8908d5f09e715 100644 (file)
--- a/source3/lib/dbwrap_util.c
+++ b/source3/lib/dbwrap_util.c
@@ -2,6 +2,7 @@
    Unix SMB/CIFS implementation.
    Utility functions for the dbwrap API
    Copyright (C) Volker Lendecke 2007
+   Copyright (C) Michael Adam 2009
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -78,7 +79,7 @@ bool dbwrap_fetch_uint32(struct db_context *db, const char *keystr,
        return true;
 }
 
-bool dbwrap_store_uint32(struct db_context *db, const char *keystr, uint32_t v)
+int dbwrap_store_uint32(struct db_context *db, const char *keystr, uint32_t v)
 {
        struct db_record *rec;
        uint32 v_store;
@@ -86,7 +87,7 @@ bool dbwrap_store_uint32(struct db_context *db, const char *keystr, uint32_t v)
 
        rec = db->fetch_locked(db, NULL, string_term_tdb_data(keystr));
        if (rec == NULL) {
-               return false;
+               return -1;
        }
 
        SIVAL(&v_store, 0, v);
@@ -98,6 +99,13 @@ bool dbwrap_store_uint32(struct db_context *db, const char *keystr, uint32_t v)
        return NT_STATUS_IS_OK(status) ? 0 : -1;
 }
 
+/**
+ * Atomic unsigned integer change (addition):
+ *
+ * if value does not exist yet in the db, use *oldval as initial old value.
+ * return old value in *oldval.
+ * store *oldval + change_val to db.
+ */
 uint32_t dbwrap_change_uint32_atomic(struct db_context *db, const char *keystr,
                                     uint32_t *oldval, uint32_t change_val)
 {
@@ -110,9 +118,13 @@ uint32_t dbwrap_change_uint32_atomic(struct db_context *db, const char *keystr,
                return -1;
        }
 
-       if ((rec->value.dptr != NULL)
-           && (rec->value.dsize == sizeof(val))) {
+       if (rec->value.dptr == NULL) {
+               val = *oldval;
+       } else if (rec->value.dsize == sizeof(val)) {
                val = IVAL(rec->value.dptr, 0);
+               *oldval = val;
+       } else {
+               return -1;
        }
 
        val += change_val;
@@ -127,6 +139,13 @@ uint32_t dbwrap_change_uint32_atomic(struct db_context *db, const char *keystr,
        return 0;
 }
 
+/**
+ * Atomic integer change (addition):
+ *
+ * if value does not exist yet in the db, use *oldval as initial old value.
+ * return old value in *oldval.
+ * store *oldval + change_val to db.
+ */
 int32 dbwrap_change_int32_atomic(struct db_context *db, const char *keystr,
                                 int32 *oldval, int32 change_val)
 {
@@ -139,9 +158,13 @@ int32 dbwrap_change_int32_atomic(struct db_context *db, const char *keystr,
                return -1;
        }
 
-       if ((rec->value.dptr != NULL)
-           && (rec->value.dsize == sizeof(val))) {
+       if (rec->value.dptr == NULL) {
+               val = *oldval;
+       } else if (rec->value.dsize == sizeof(val)) {
                val = IVAL(rec->value.dptr, 0);
+               *oldval = val;
+       } else {
+               return -1;
        }
 
        val += change_val;
@@ -188,7 +211,8 @@ NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
        if (res != 0) {
                DEBUG(5, ("tdb_transaction_commit failed\n"));
                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
-               goto cancel;
+               TALLOC_FREE(rec);
+               return status;
        }
 
        return NT_STATUS_OK;
@@ -202,48 +226,33 @@ NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
        return status;
 }
 
-NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key)
+static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data)
 {
-       int res;
-       struct db_record *rec = NULL;
        NTSTATUS status;
+       struct db_record *rec;
+       TDB_DATA *key = (TDB_DATA *)private_data;
 
-       res = db->transaction_start(db);
-       if (res != 0) {
-               DEBUG(5, ("transaction_start failed\n"));
-               return NT_STATUS_INTERNAL_DB_CORRUPTION;
-       }
-
-       rec = db->fetch_locked(db, talloc_tos(), key);
+       rec = db->fetch_locked(db, talloc_tos(), *key);
        if (rec == NULL) {
                DEBUG(5, ("fetch_locked failed\n"));
-               status = NT_STATUS_NO_MEMORY;
-               goto cancel;
+               return NT_STATUS_NO_MEMORY;
        }
 
        status = rec->delete_rec(rec);
        if (!NT_STATUS_IS_OK(status)) {
                DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status)));
-               goto cancel;
        }
 
-       TALLOC_FREE(rec);
-
-       res = db->transaction_commit(db);
-       if (res != 0) {
-               DEBUG(5, ("tdb_transaction_commit failed\n"));
-               status = NT_STATUS_INTERNAL_DB_CORRUPTION;
-               goto cancel;
-       }
+       talloc_free(rec);
+       return  status;
+}
 
-       return NT_STATUS_OK;
+NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key)
+{
+       NTSTATUS status;
 
- cancel:
-       TALLOC_FREE(rec);
+       status = dbwrap_trans_do(db, dbwrap_delete_action, &key);
 
-       if (db->transaction_cancel(db) != 0) {
-               smb_panic("Cancelling transaction failed");
-       }
        return status;
 }
 
@@ -283,3 +292,86 @@ NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key)
 {
        return dbwrap_trans_delete(db, string_term_tdb_data(key));
 }
+
+/**
+ * Wrap db action(s) into a transaction.
+ */
+NTSTATUS dbwrap_trans_do(struct db_context *db,
+                        NTSTATUS (*action)(struct db_context *, void *),
+                        void *private_data)
+{
+       int res;
+       NTSTATUS status;
+
+       res = db->transaction_start(db);
+       if (res != 0) {
+               DEBUG(5, ("transaction_start failed\n"));
+               return NT_STATUS_INTERNAL_DB_CORRUPTION;
+       }
+
+       status = action(db, private_data);
+       if (!NT_STATUS_IS_OK(status)) {
+               if (db->transaction_cancel(db) != 0) {
+                       smb_panic("Cancelling transaction failed");
+               }
+               return status;
+       }
+
+       res = db->transaction_commit(db);
+       if (res == 0) {
+               return NT_STATUS_OK;
+       }
+
+       DEBUG(2, ("transaction_commit failed\n"));
+       return NT_STATUS_INTERNAL_DB_CORRUPTION;
+}
+
+NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key)
+{
+       char *key_upper;
+       NTSTATUS status;
+
+       key_upper = talloc_strdup_upper(talloc_tos(), key);
+       if (key_upper == NULL) {
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       status = dbwrap_delete_bystring(db, key_upper);
+
+       talloc_free(key_upper);
+       return status;
+}
+
+NTSTATUS dbwrap_store_bystring_upper(struct db_context *db, const char *key,
+                                    TDB_DATA data, int flags)
+{
+       char *key_upper;
+       NTSTATUS status;
+
+       key_upper = talloc_strdup_upper(talloc_tos(), key);
+       if (key_upper == NULL) {
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       status = dbwrap_store_bystring(db, key_upper, data, flags);
+
+       talloc_free(key_upper);
+       return status;
+}
+
+TDB_DATA dbwrap_fetch_bystring_upper(struct db_context *db, TALLOC_CTX *mem_ctx,
+                                    const char *key)
+{
+       char *key_upper;
+       TDB_DATA result;
+
+       key_upper = talloc_strdup_upper(talloc_tos(), key);
+       if (key_upper == NULL) {
+               return make_tdb_data(NULL, 0);
+       }
+
+       result = dbwrap_fetch_bystring(db, mem_ctx, key_upper);
+
+       talloc_free(key_upper);
+       return result;
+}