source/utils/tdb/tdbtool.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba database functions
   4    Copyright (C) Andrew Tridgell              1999-2000
   5    Copyright (C) Paul `Rusty' Russell              2000
   6    Copyright (C) Jeremy Allison                    2000
   7    Copyright (C) Andrew Esh                        2001
   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 2 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, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include <errno.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29 #include <string.h>
  30 #include <fcntl.h>
  31 #include <time.h>
  32 #include <sys/mman.h>
  33 #include <sys/stat.h>
  34 #include <sys/time.h>
  35 #include <ctype.h>
  36 #include <signal.h>
  37 #include "tdb.h"
  38
  39 /* a tdb tool for manipulating a tdb database */
  40
  41 #define FSTRING_LEN 256
  42 typedef char fstring[FSTRING_LEN];
  43
  44 typedef struct connections_key {
  45         pid_t pid;
  46         int cnum;
  47         fstring name;
  48 } connections_key;
  49
  50 typedef struct connections_data {
  51         int magic;
  52         pid_t pid;
  53         int cnum;
  54         uid_t uid;
  55         gid_t gid;
  56         char name[24];
  57         char addr[24];
  58         char machine[128];
  59         time_t start;
  60 } connections_data;
  61
  62 static TDB_CONTEXT *tdb;
  63
  64 static int print_rec(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state);
  65
  66 static void print_asc(unsigned char *buf,int len)
  67 {
  68         int i;
  69
  70         /* We're probably printing ASCII strings so don't try to display
  71            the trailing NULL character. */
  72
  73         if (buf[len - 1] == 0)
  74                 len--;
  75
  76         for (i=0;i<len;i++)
  77                 printf("%c",isprint(buf[i])?buf[i]:'.');
  78 }
  79
  80 static void print_data(unsigned char *buf,int len)
  81 {
  82         int i=0;
  83         if (len<=0) return;
  84         printf("[%03X] ",i);
  85         for (i=0;i<len;) {
  86                 printf("%02X ",(int)buf[i]);
  87                 i++;
  88                 if (i%8 == 0) printf(" ");
  89                 if (i%16 == 0) {
  90                         print_asc(&buf[i-16],8); printf(" ");
  91                         print_asc(&buf[i-8],8); printf("\n");
  92                         if (i<len) printf("[%03X] ",i);
  93                 }
  94         }
  95         if (i%16) {
  96                 int n;
  97
  98                 n = 16 - (i%16);
  99                 printf(" ");
 100                 if (n>8) printf(" ");
 101                 while (n--) printf("   ");
 102
 103                 n = i%16;
 104                 if (n > 8) n = 8;
 105                 print_asc(&buf[i-(i%16)],n); printf(" ");
 106                 n = (i%16) - n;
 107                 if (n>0) print_asc(&buf[i-n],n);
 108                 printf("\n");
 109         }
 110 }
 111
 112 static void help(void)
 113 {
 114         printf("
 115 tdbtool:
 116   create    dbname     : create a database
 117   open      dbname     : open an existing database
 118   erase                : erase the database
 119   dump                 : dump the database as strings
 120   insert    key  data  : insert a record
 121   store     key  data  : store a record (replace)
 122   show      key        : show a record by key
 123   delete    key        : delete a record by key
 124   list                 : print the database hash table and freelist
 125   free                 : print the database freelist
 126   1 | first            : print the first record
 127   n | next             : print the next record
 128   q | quit             : terminate
 129   \\n                   : repeat 'next' command
 130 ");
 131 }
 132
 133 static void terror(char *why)
 134 {
 135         printf("%s\n", why);
 136 }
 137
 138 static char *get_token(int startover)
 139 {
 140         static char tmp[1024];
 141         static char *cont = NULL;
 142         char *insert, *start;
 143         char *k = strtok(NULL, " ");
 144
 145         if (!k)
 146           return NULL;
 147
 148         if (startover)
 149           start = tmp;
 150         else
 151           start = cont;
 152
 153         strcpy(start, k);
 154         insert = start + strlen(start) - 1;
 155         while (*insert == '\\') {
 156           *insert++ = ' ';
 157           k = strtok(NULL, " ");
 158           if (!k)
 159             break;
 160           strcpy(insert, k);
 161           insert = start + strlen(start) - 1;
 162         }
 163
 164         /* Get ready for next call */
 165         cont = start + strlen(start) + 1;
 166         return start;
 167 }
 168
 169 static void create_tdb(void)
 170 {
 171         char *tok = get_token(1);
 172         if (!tok) {
 173                 help();
 174                 return;
 175         }
 176         if (tdb) tdb_close(tdb);
 177         tdb = tdb_open(tok, 0, TDB_CLEAR_IF_FIRST,
 178                        O_RDWR | O_CREAT | O_TRUNC, 0600);
 179         if (!tdb) {
 180                 printf("Could not create %s: %s\n", tok, strerror(errno));
 181         }
 182 }
 183
 184 static void open_tdb(void)
 185 {
 186         char *tok = get_token(1);
 187         if (!tok) {
 188                 help();
 189                 return;
 190         }
 191         if (tdb) tdb_close(tdb);
 192         tdb = tdb_open(tok, 0, 0, O_RDWR, 0600);
 193         if (!tdb) {
 194                 printf("Could not open %s: %s\n", tok, strerror(errno));
 195         }
 196 }
 197
 198 static void insert_tdb(void)
 199 {
 200         char *k = get_token(1);
 201         char *d = get_token(0);
 202         TDB_DATA key, dbuf;
 203
 204         if (!k || !d) {
 205                 help();
 206                 return;
 207         }
 208
 209         key.dptr = k;
 210         key.dsize = strlen(k)+1;
 211         dbuf.dptr = d;
 212         dbuf.dsize = strlen(d)+1;
 213
 214         if (tdb_store(tdb, key, dbuf, TDB_INSERT) == -1) {
 215                 terror("insert failed");
 216         }
 217 }
 218
 219 static void store_tdb(void)
 220 {
 221         char *k = get_token(1);
 222         char *d = get_token(0);
 223         TDB_DATA key, dbuf;
 224
 225         if (!k || !d) {
 226                 help();
 227                 return;
 228         }
 229
 230         key.dptr = k;
 231         key.dsize = strlen(k)+1;
 232         dbuf.dptr = d;
 233         dbuf.dsize = strlen(d)+1;
 234
 235         printf("Storing key:\n");
 236         print_rec(tdb, key, dbuf, NULL);
 237
 238         if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1) {
 239                 terror("store failed");
 240         }
 241 }
 242
 243 static void show_tdb(void)
 244 {
 245         char *k = get_token(1);
 246         TDB_DATA key, dbuf;
 247
 248         if (!k) {
 249                 help();
 250                 return;
 251         }
 252
 253         key.dptr = k;
 254 /*      key.dsize = strlen(k)+1;*/
 255         key.dsize = strlen(k);
 256
 257         dbuf = tdb_fetch(tdb, key);
 258         if (!dbuf.dptr) {
 259                 terror("fetch failed");
 260                 return;
 261         }
 262         /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
 263         print_rec(tdb, key, dbuf, NULL);
 264 }
 265
 266 static void delete_tdb(void)
 267 {
 268         char *k = get_token(1);
 269         TDB_DATA key;
 270
 271         if (!k) {
 272                 help();
 273                 return;
 274         }
 275
 276         key.dptr = k;
 277         key.dsize = strlen(k)+1;
 278
 279         if (tdb_delete(tdb, key) != 0) {
 280                 terror("delete failed");
 281         }
 282 }
 283
 284 #if 0
 285 static int print_conn_key(TDB_DATA key)
 286 {
 287         printf( "pid    =%5d   ", ((connections_key*)key.dptr)->pid);
 288         printf( "cnum   =%10d  ", ((connections_key*)key.dptr)->cnum);
 289         printf( "name   =[%s]\n", ((connections_key*)key.dptr)->name);
 290         return 0;
 291 }
 292
 293 static int print_conn_data(TDB_DATA dbuf)
 294 {
 295         printf( "pid    =%5d   ", ((connections_data*)dbuf.dptr)->pid);
 296         printf( "cnum   =%10d  ", ((connections_data*)dbuf.dptr)->cnum);
 297         printf( "name   =[%s]\n", ((connections_data*)dbuf.dptr)->name);
 298
 299         printf( "uid    =%5d   ",  ((connections_data*)dbuf.dptr)->uid);
 300         printf( "addr   =[%s]\n", ((connections_data*)dbuf.dptr)->addr);
 301         printf( "gid    =%5d   ",  ((connections_data*)dbuf.dptr)->gid);
 302         printf( "machine=[%s]\n", ((connections_data*)dbuf.dptr)->machine);
 303         printf( "start  = %s\n",   ctime(&((connections_data*)dbuf.dptr)->start));
 304         return 0;
 305 }
 306 #endif
 307
 308 static int print_rec(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
 309 {
 310 #if 0
 311         print_conn_key(key);
 312         print_conn_data(dbuf);
 313         return 0;
 314 #else
 315         printf("\nkey %d bytes\n", key.dsize);
 316         print_asc(key.dptr, key.dsize);
 317         printf("\ndata %d bytes\n", dbuf.dsize);
 318         print_data(dbuf.dptr, dbuf.dsize);
 319         return 0;
 320 #endif
 321 }
 322
 323 static int print_key(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
 324 {
 325         print_asc(key.dptr, key.dsize);
 326         printf("\n");
 327         return 0;
 328 }
 329
 330 static int total_bytes;
 331
 332 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
 333 {
 334         total_bytes += dbuf.dsize;
 335         return 0;
 336 }
 337
 338 static void info_tdb(void)
 339 {
 340         int count;
 341         total_bytes = 0;
 342         if ((count = tdb_traverse(tdb, traverse_fn, NULL) == -1))
 343                 printf("Error = %s\n", tdb_errorstr(tdb));
 344         else
 345                 printf("%d records totalling %d bytes\n", count, total_bytes);
 346 }
 347
 348 static char *tdb_getline(char *prompt)
 349 {
 350         static char line[1024];
 351         char *p;
 352         fputs(prompt, stdout);
 353         line[0] = 0;
 354         p = fgets(line, sizeof(line)-1, stdin);
 355         if (p) p = strchr(p, '\n');
 356         if (p) *p = 0;
 357         return p?line:NULL;
 358 }
 359
 360 static int do_delete_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf,
 361                      void *state)
 362 {
 363     return tdb_delete(the_tdb, key);
 364 }
 365
 366 static void first_record(TDB_CONTEXT *the_tdb, TDB_DATA *pkey)
 367 {
 368         TDB_DATA dbuf;
 369         *pkey = tdb_firstkey(the_tdb);
 370
 371         dbuf = tdb_fetch(the_tdb, *pkey);
 372         if (!dbuf.dptr) terror("fetch failed");
 373         else {
 374                 /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
 375                 print_rec(the_tdb, *pkey, dbuf, NULL);
 376         }
 377 }
 378
 379 static void next_record(TDB_CONTEXT *the_tdb, TDB_DATA *pkey)
 380 {
 381         TDB_DATA dbuf;
 382         *pkey = tdb_nextkey(the_tdb, *pkey);
 383
 384         dbuf = tdb_fetch(the_tdb, *pkey);
 385         if (!dbuf.dptr)
 386                 terror("fetch failed");
 387         else
 388                 /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
 389                 print_rec(the_tdb, *pkey, dbuf, NULL);
 390 }
 391
 392 int main(int argc, char *argv[])
 393 {
 394     int bIterate = 0;
 395     char *line;
 396     char *tok;
 397         TDB_DATA iterate_kbuf;
 398
 399     if (argv[1]) {
 400         static char tmp[1024];
 401         sprintf(tmp, "open %s", argv[1]);
 402         tok=strtok(tmp," ");
 403         open_tdb();
 404     }
 405
 406     while ((line = tdb_getline("tdb> "))) {
 407
 408         /* Shell command */
 409
 410         if (line[0] == '!') {
 411             system(line + 1);
 412             continue;
 413         }
 414
 415         if ((tok = strtok(line," "))==NULL) {
 416            if (bIterate)
 417               next_record(tdb, &iterate_kbuf);
 418            continue;
 419         }
 420         if (strcmp(tok,"create") == 0) {
 421             bIterate = 0;
 422             create_tdb();
 423             continue;
 424         } else if (strcmp(tok,"open") == 0) {
 425             open_tdb();
 426             continue;
 427         } else if ((strcmp(tok, "q") == 0) ||
 428                    (strcmp(tok, "quit") == 0)) {
 429             break;
 430         }
 431
 432         /* all the rest require a open database */
 433         if (!tdb) {
 434             bIterate = 0;
 435             terror("database not open");
 436             help();
 437             continue;
 438         }
 439
 440         if (strcmp(tok,"insert") == 0) {
 441             bIterate = 0;
 442             insert_tdb();
 443         } else if (strcmp(tok,"store") == 0) {
 444             bIterate = 0;
 445             store_tdb();
 446         } else if (strcmp(tok,"show") == 0) {
 447             bIterate = 0;
 448             show_tdb();
 449         } else if (strcmp(tok,"erase") == 0) {
 450             bIterate = 0;
 451             tdb_traverse(tdb, do_delete_fn, NULL);
 452         } else if (strcmp(tok,"delete") == 0) {
 453             bIterate = 0;
 454             delete_tdb();
 455         } else if (strcmp(tok,"dump") == 0) {
 456             bIterate = 0;
 457             tdb_traverse(tdb, print_rec, NULL);
 458         } else if (strcmp(tok,"list") == 0) {
 459             tdb_dump_all(tdb);
 460         } else if (strcmp(tok, "free") == 0) {
 461             tdb_printfreelist(tdb);
 462         } else if (strcmp(tok,"info") == 0) {
 463             info_tdb();
 464         } else if ( (strcmp(tok, "1") == 0) ||
 465                     (strcmp(tok, "first") == 0)) {
 466             bIterate = 1;
 467             first_record(tdb, &iterate_kbuf);
 468         } else if ((strcmp(tok, "n") == 0) ||
 469                    (strcmp(tok, "next") == 0)) {
 470             next_record(tdb, &iterate_kbuf);
 471         } else if ((strcmp(tok, "keys") == 0)) {
 472                 bIterate = 0;
 473                 tdb_traverse(tdb, print_key, NULL);
 474         } else {
 475             help();
 476         }
 477     }
 478
 479     if (tdb) tdb_close(tdb);
 480
 481     return 0;
 482 }