source3/utils/dbwrap_tool.c

   1 /*
   2    Samba Unix/Linux CIFS implementation
   3
   4    low level TDB/CTDB tool using the dbwrap interface
   5
   6    Copyright (C) 2009 Michael Adam <obnox@samba.org>
   7    Copyright (C) 2011 Bjoern Baumbach <bb@sernet.de>
   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 "includes.h"
  24 #include "system/filesys.h"
  25 #include "popt_common.h"
  26 #include "dbwrap/dbwrap.h"
  27 #include "dbwrap/dbwrap_open.h"
  28 #include "messages.h"
  29 #include "util_tdb.h"
  30
  31 typedef enum { OP_FETCH, OP_STORE, OP_DELETE, OP_ERASE, OP_LISTKEYS } dbwrap_op;
  32
  33 typedef enum { TYPE_INT32, TYPE_UINT32, TYPE_STRING } dbwrap_type;
  34
  35 static int dbwrap_tool_fetch_int32(struct db_context *db,
  36                                    const char *keyname,
  37                                    const char *data)
  38 {
  39         int32_t value;
  40         NTSTATUS status;
  41
  42         status = dbwrap_fetch_int32(db, keyname, &value);
  43         if (!NT_STATUS_IS_OK(status)) {
  44                 d_printf("Error fetching int32 from key '%s': %s\n",
  45                          keyname, nt_errstr(status));
  46                 return -1;
  47         }
  48         d_printf("%d\n", value);
  49
  50         return 0;
  51 }
  52
  53 static int dbwrap_tool_fetch_uint32(struct db_context *db,
  54                                     const char *keyname,
  55                                     const char *data)
  56 {
  57         uint32_t value;
  58         NTSTATUS ret;
  59
  60         ret = dbwrap_fetch_uint32(db, keyname, &value);
  61         if (NT_STATUS_IS_OK(ret)) {
  62                 d_printf("%u\n", value);
  63                 return 0;
  64         } else {
  65                 d_fprintf(stderr, "ERROR: could not fetch uint32 key '%s': "
  66                           "%s\n", nt_errstr(ret), keyname);
  67                 return -1;
  68         }
  69 }
  70
  71 static int dbwrap_tool_store_int32(struct db_context *db,
  72                                    const char *keyname,
  73                                    const char *data)
  74 {
  75         NTSTATUS status;
  76         int32_t value = (int32_t)strtol(data, NULL, 10);
  77
  78         status = dbwrap_trans_store_int32(db, keyname, value);
  79
  80         if (!NT_STATUS_IS_OK(status)) {
  81                 d_fprintf(stderr, "ERROR: could not store int32 key '%s': %s\n",
  82                           keyname, nt_errstr(status));
  83                 return -1;
  84         }
  85
  86         return 0;
  87 }
  88
  89 static int dbwrap_tool_store_uint32(struct db_context *db,
  90                                     const char *keyname,
  91                                     const char *data)
  92 {
  93         NTSTATUS status;
  94         uint32_t value = (uint32_t)strtol(data, NULL, 10);
  95
  96         status = dbwrap_trans_store_uint32(db, keyname, value);
  97
  98         if (!NT_STATUS_IS_OK(status)) {
  99                 d_fprintf(stderr,
 100                           "ERROR: could not store uint32 key '%s': %s\n",
 101                           keyname, nt_errstr(status));
 102                 return -1;
 103         }
 104
 105         return 0;
 106 }
 107
 108 static int dbwrap_tool_store_string(struct db_context *db,
 109                                     const char *keyname,
 110                                     const char *data)
 111 {
 112         NTSTATUS status;
 113
 114         status = dbwrap_trans_store_bystring(db, keyname,
 115                            string_term_tdb_data(data), TDB_REPLACE);
 116
 117         if (!NT_STATUS_IS_OK(status)) {
 118                 d_fprintf(stderr,
 119                           "ERROR: could not store string key '%s': %s\n",
 120                           keyname, nt_errstr(status));
 121                 return -1;
 122         }
 123
 124         return 0;
 125 }
 126
 127 static int dbwrap_tool_delete(struct db_context *db,
 128                               const char *keyname,
 129                               const char *data)
 130 {
 131         NTSTATUS status;
 132
 133         status = dbwrap_trans_delete_bystring(db, keyname);
 134
 135         if (!NT_STATUS_IS_OK(status)) {
 136                 d_fprintf(stderr, "ERROR deleting record %s : %s\n",
 137                           keyname, nt_errstr(status));
 138                 return -1;
 139         }
 140
 141         return 0;
 142 }
 143
 144 static int delete_fn(struct db_record *rec, void *priv)
 145 {
 146         dbwrap_record_delete(rec);
 147         return 0;
 148 }
 149
 150 /**
 151  * dbwrap_tool_erase: erase the whole data base
 152  * the keyname argument is not used.
 153  */
 154 static int dbwrap_tool_erase(struct db_context *db,
 155                              const char *keyname,
 156                              const char *data)
 157 {
 158         NTSTATUS status;
 159
 160         status = dbwrap_traverse(db, delete_fn, NULL, NULL);
 161
 162         if (!NT_STATUS_IS_OK(status)) {
 163                 d_fprintf(stderr, "ERROR erasing the database\n");
 164                 return -1;
 165         }
 166
 167         return 0;
 168 }
 169
 170 static int listkey_fn(struct db_record *rec, void *private_data)
 171 {
 172         int length = dbwrap_record_get_key(rec).dsize;
 173         unsigned char *p = (unsigned char *)dbwrap_record_get_key(rec).dptr;
 174
 175         while (length--) {
 176                 if (isprint(*p) && !strchr("\"\\", *p)) {
 177                         d_printf("%c", *p);
 178                 } else {
 179                         d_printf("\\%02X", *p);
 180                 }
 181                 p++;
 182         }
 183
 184         d_printf("\n");
 185
 186         return 0;
 187 }
 188
 189 static int dbwrap_tool_listkeys(struct db_context *db,
 190                                 const char *keyname,
 191                                 const char *data)
 192 {
 193         NTSTATUS status;
 194
 195         status = dbwrap_traverse_read(db, listkey_fn, NULL, NULL);
 196
 197         if (!NT_STATUS_IS_OK(status)) {
 198                 d_fprintf(stderr, "ERROR listing db keys\n");
 199                 return -1;
 200         }
 201
 202         return 0;
 203 }
 204
 205 struct dbwrap_op_dispatch_table {
 206         dbwrap_op op;
 207         dbwrap_type type;
 208         int (*cmd)(struct db_context *db,
 209                    const char *keyname,
 210                    const char *data);
 211 };
 212
 213 struct dbwrap_op_dispatch_table dispatch_table[] = {
 214         { OP_FETCH,  TYPE_INT32,  dbwrap_tool_fetch_int32 },
 215         { OP_FETCH,  TYPE_UINT32, dbwrap_tool_fetch_uint32 },
 216         { OP_STORE,  TYPE_INT32,  dbwrap_tool_store_int32 },
 217         { OP_STORE,  TYPE_UINT32, dbwrap_tool_store_uint32 },
 218         { OP_STORE,  TYPE_STRING, dbwrap_tool_store_string },
 219         { OP_DELETE, TYPE_INT32,  dbwrap_tool_delete },
 220         { OP_ERASE,  TYPE_INT32,  dbwrap_tool_erase },
 221         { OP_LISTKEYS, TYPE_INT32, dbwrap_tool_listkeys },
 222         { 0, 0, NULL },
 223 };
 224
 225 int main(int argc, const char **argv)
 226 {
 227         struct tevent_context *evt_ctx;
 228         struct messaging_context *msg_ctx;
 229         struct db_context *db;
 230
 231         uint16_t count;
 232
 233         const char *dbname;
 234         const char *opname;
 235         dbwrap_op op;
 236         const char *keyname = "";
 237         const char *keytype = "int32";
 238         dbwrap_type type;
 239         const char *valuestr = "0";
 240
 241         TALLOC_CTX *mem_ctx = talloc_stackframe();
 242
 243         int ret = 1;
 244
 245         struct poptOption popt_options[] = {
 246                 POPT_AUTOHELP
 247                 POPT_COMMON_SAMBA
 248                 POPT_TABLEEND
 249         };
 250         int opt;
 251         const char **extra_argv;
 252         int extra_argc = 0;
 253         poptContext pc;
 254
 255         load_case_tables();
 256         lp_set_cmdline("log level", "0");
 257         setup_logging(argv[0], DEBUG_STDERR);
 258
 259         pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
 260
 261         while ((opt = poptGetNextOpt(pc)) != -1) {
 262                 switch (opt) {
 263                 default:
 264                         fprintf(stderr, "Invalid option %s: %s\n",
 265                                 poptBadOption(pc, 0), poptStrerror(opt));
 266                         goto done;
 267                 }
 268         }
 269
 270         /* setup the remaining options for the main program to use */
 271         extra_argv = poptGetArgs(pc);
 272         if (extra_argv) {
 273                 extra_argv++;
 274                 while (extra_argv[extra_argc]) extra_argc++;
 275         }
 276
 277         lp_load_global(get_dyn_CONFIGFILE());
 278
 279         if ((extra_argc < 2) || (extra_argc > 5)) {
 280                 d_fprintf(stderr,
 281                           "USAGE: %s <database> <op> [<key> [<type> [<value>]]]\n"
 282                           "       ops: fetch, store, delete, erase, listkeys\n"
 283                           "       types: int32, uint32, string\n",
 284                          argv[0]);
 285                 goto done;
 286         }
 287
 288         dbname = extra_argv[0];
 289         opname = extra_argv[1];
 290
 291         if (strcmp(opname, "store") == 0) {
 292                 if (extra_argc != 5) {
 293                         d_fprintf(stderr, "ERROR: operation 'store' requires "
 294                                   "value argument\n");
 295                         goto done;
 296                 }
 297                 valuestr = extra_argv[4];
 298                 keytype = extra_argv[3];
 299                 keyname = extra_argv[2];
 300                 op = OP_STORE;
 301         } else if (strcmp(opname, "fetch") == 0) {
 302                 if (extra_argc != 4) {
 303                         d_fprintf(stderr, "ERROR: operation 'fetch' requires "
 304                                   "type but not value argument\n");
 305                         goto done;
 306                 }
 307                 op = OP_FETCH;
 308                 keytype = extra_argv[3];
 309                 keyname = extra_argv[2];
 310         } else if (strcmp(opname, "delete") == 0) {
 311                 if (extra_argc != 3) {
 312                         d_fprintf(stderr, "ERROR: operation 'delete' does "
 313                                   "not allow type nor value argument\n");
 314                         goto done;
 315                 }
 316                 keyname = extra_argv[2];
 317                 op = OP_DELETE;
 318         } else if (strcmp(opname, "erase") == 0) {
 319                 if (extra_argc != 2) {
 320                         d_fprintf(stderr, "ERROR: operation 'erase' does "
 321                                   "not take a key argument\n");
 322                         goto done;
 323                 }
 324                 op = OP_ERASE;
 325         } else if (strcmp(opname, "listkeys") == 0) {
 326                 if (extra_argc != 2) {
 327                         d_fprintf(stderr, "ERROR: operation 'listkeys' does "
 328                                   "not take a key argument\n");
 329                         goto done;
 330                 }
 331                 op = OP_LISTKEYS;
 332         } else {
 333                 d_fprintf(stderr,
 334                           "ERROR: invalid op '%s' specified\n"
 335                           "       supported ops: fetch, store, delete\n",
 336                           opname);
 337                 goto done;
 338         }
 339
 340         if (strcmp(keytype, "int32") == 0) {
 341                 type = TYPE_INT32;
 342         } else if (strcmp(keytype, "uint32") == 0) {
 343                 type = TYPE_UINT32;
 344         } else if (strcmp(keytype, "string") == 0) {
 345                 type = TYPE_STRING;
 346         } else {
 347                 d_fprintf(stderr, "ERROR: invalid type '%s' specified.\n"
 348                                   "       supported types: int32, uint32, string\n",
 349                                   keytype);
 350                 goto done;
 351         }
 352
 353         evt_ctx = tevent_context_init(mem_ctx);
 354         if (evt_ctx == NULL) {
 355                 d_fprintf(stderr, "ERROR: could not init event context\n");
 356                 goto done;
 357         }
 358
 359         msg_ctx = messaging_init(mem_ctx, procid_self(), evt_ctx);
 360         if (msg_ctx == NULL) {
 361                 d_fprintf(stderr, "ERROR: could not init messaging context\n");
 362                 goto done;
 363         }
 364
 365         db = db_open(mem_ctx, dbname, 0, TDB_DEFAULT, O_RDWR | O_CREAT, 0644);
 366         if (db == NULL) {
 367                 d_fprintf(stderr, "ERROR: could not open dbname\n");
 368                 goto done;
 369         }
 370
 371         for (count = 0; dispatch_table[count].cmd != NULL; count++) {
 372                 if ((op == dispatch_table[count].op) &&
 373                     (type == dispatch_table[count].type))
 374                 {
 375                         ret = dispatch_table[count].cmd(db, keyname, valuestr);
 376                         break;
 377                 }
 378         }
 379
 380 done:
 381         TALLOC_FREE(mem_ctx);
 382         return ret;
 383 }