import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / 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("\n"
115 "tdbtool: \n"
116 "  create    dbname     : create a database\n"
117 "  open      dbname     : open an existing database\n"
118 "  erase                : erase the database\n"
119 "  dump                 : dump the database as strings\n"
120 "  insert    key  data  : insert a record\n"
121 "  move      key  file  : move a record to a destination tdb\n"
122 "  store     key  data  : store a record (replace)\n"
123 "  show      key        : show a record by key\n"
124 "  delete    key        : delete a record by key\n"
125 "  list                 : print the database hash table and freelist\n"
126 "  free                 : print the database freelist\n"
127 "  1 | first            : print the first record\n"
128 "  n | next             : print the next record\n"
129 "  q | quit             : terminate\n"
130 "  \\n                   : repeat 'next' command\n"
131 "\n");
132 }
133
134 static void terror(char *why)
135 {
136         printf("%s\n", why);
137 }
138
139 static char *get_token(int startover)
140 {
141         static char tmp[1024];
142         static char *cont = NULL;
143         char *insert, *start;
144         char *k = strtok(NULL, " ");
145
146         if (!k)
147           return NULL;
148
149         if (startover)
150           start = tmp;
151         else
152           start = cont;
153
154         strcpy(start, k);
155         insert = start + strlen(start) - 1;
156         while (*insert == '\\') {
157           *insert++ = ' ';
158           k = strtok(NULL, " ");
159           if (!k)
160             break;
161           strcpy(insert, k);
162           insert = start + strlen(start) - 1;
163         }
164
165         /* Get ready for next call */
166         cont = start + strlen(start) + 1;
167         return start;
168 }
169
170 static void create_tdb(void)
171 {
172         char *tok = get_token(1);
173         if (!tok) {
174                 help();
175                 return;
176         }
177         if (tdb) tdb_close(tdb);
178         tdb = tdb_open(tok, 0, TDB_CLEAR_IF_FIRST,
179                        O_RDWR | O_CREAT | O_TRUNC, 0600);
180         if (!tdb) {
181                 printf("Could not create %s: %s\n", tok, strerror(errno));
182         }
183 }
184
185 static void open_tdb(void)
186 {
187         char *tok = get_token(1);
188         if (!tok) {
189                 help();
190                 return;
191         }
192         if (tdb) tdb_close(tdb);
193         tdb = tdb_open(tok, 0, 0, O_RDWR, 0600);
194         if (!tdb) {
195                 printf("Could not open %s: %s\n", tok, strerror(errno));
196         }
197 }
198
199 static void insert_tdb(void)
200 {
201         char *k = get_token(1);
202         char *d = get_token(0);
203         TDB_DATA key, dbuf;
204
205         if (!k || !d) {
206                 help();
207                 return;
208         }
209
210         key.dptr = k;
211         key.dsize = strlen(k)+1;
212         dbuf.dptr = d;
213         dbuf.dsize = strlen(d)+1;
214
215         if (tdb_store(tdb, key, dbuf, TDB_INSERT) == -1) {
216                 terror("insert failed");
217         }
218 }
219
220 static void store_tdb(void)
221 {
222         char *k = get_token(1);
223         char *d = get_token(0);
224         TDB_DATA key, dbuf;
225
226         if (!k || !d) {
227                 help();
228                 return;
229         }
230
231         key.dptr = k;
232         key.dsize = strlen(k)+1;
233         dbuf.dptr = d;
234         dbuf.dsize = strlen(d)+1;
235
236         printf("Storing key:\n");
237         print_rec(tdb, key, dbuf, NULL);
238
239         if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1) {
240                 terror("store failed");
241         }
242 }
243
244 static void show_tdb(void)
245 {
246         char *k = get_token(1);
247         TDB_DATA key, dbuf;
248
249         if (!k) {
250                 help();
251                 return;
252         }
253
254         key.dptr = k;
255         key.dsize = strlen(k)+1;
256
257         dbuf = tdb_fetch(tdb, key);
258         if (!dbuf.dptr) {
259                 /* maybe it is non-NULL terminated key? */
260                 key.dsize = strlen(k); 
261                 dbuf = tdb_fetch(tdb, key);
262                 
263                 if ( !dbuf.dptr ) {
264                         terror("fetch failed");
265                         return;
266                 }
267         }
268         
269         /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
270         print_rec(tdb, key, dbuf, NULL);
271         
272         free( dbuf.dptr );
273         
274         return;
275 }
276
277 static void delete_tdb(void)
278 {
279         char *k = get_token(1);
280         TDB_DATA key;
281
282         if (!k) {
283                 help();
284                 return;
285         }
286
287         key.dptr = k;
288         key.dsize = strlen(k)+1;
289
290         if (tdb_delete(tdb, key) != 0) {
291                 terror("delete failed");
292         }
293 }
294
295 static void move_rec(void)
296 {
297         char *k = get_token(1);
298         char *file = get_token(0);      
299         TDB_DATA key, dbuf;
300         TDB_CONTEXT *dst_tdb;
301
302         if (!k) {
303                 help();
304                 return;
305         }
306         
307         if ( !file ) {
308                 terror("need destination tdb name");
309                 return;
310         }
311
312         key.dptr = k;
313         key.dsize = strlen(k)+1;
314
315         dbuf = tdb_fetch(tdb, key);
316         if (!dbuf.dptr) {
317                 /* maybe it is non-NULL terminated key? */
318                 key.dsize = strlen(k); 
319                 dbuf = tdb_fetch(tdb, key);
320                 
321                 if ( !dbuf.dptr ) {
322                         terror("fetch failed");
323                         return;
324                 }
325         }
326         
327         print_rec(tdb, key, dbuf, NULL);
328         
329         dst_tdb = tdb_open(file, 0, 0, O_RDWR, 0600);
330         if ( !dst_tdb ) {
331                 terror("unable to open destination tdb");
332                 return;
333         }
334         
335         if ( tdb_store( dst_tdb, key, dbuf, TDB_REPLACE ) == -1 ) {
336                 terror("failed to move record");
337         }
338         else
339                 printf("record moved\n");
340         
341         tdb_close( dst_tdb );
342         
343         return;
344 }
345
346 #if 0
347 static int print_conn_key(TDB_DATA key)
348 {
349         printf( "pid    =%5d   ", ((connections_key*)key.dptr)->pid);
350         printf( "cnum   =%10d  ", ((connections_key*)key.dptr)->cnum);
351         printf( "name   =[%s]\n", ((connections_key*)key.dptr)->name);
352         return 0;
353 }
354
355 static int print_conn_data(TDB_DATA dbuf)
356 {
357         printf( "pid    =%5d   ", ((connections_data*)dbuf.dptr)->pid);
358         printf( "cnum   =%10d  ", ((connections_data*)dbuf.dptr)->cnum);
359         printf( "name   =[%s]\n", ((connections_data*)dbuf.dptr)->name);
360         
361         printf( "uid    =%5d   ",  ((connections_data*)dbuf.dptr)->uid);
362         printf( "addr   =[%s]\n", ((connections_data*)dbuf.dptr)->addr);
363         printf( "gid    =%5d   ",  ((connections_data*)dbuf.dptr)->gid);
364         printf( "machine=[%s]\n", ((connections_data*)dbuf.dptr)->machine);
365         printf( "start  = %s\n",   ctime(&((connections_data*)dbuf.dptr)->start));
366         return 0;
367 }
368 #endif
369
370 static int print_rec(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
371 {
372 #if 0
373         print_conn_key(key);
374         print_conn_data(dbuf);
375         return 0;
376 #else
377         printf("\nkey %d bytes\n", key.dsize);
378         print_asc(key.dptr, key.dsize);
379         printf("\ndata %d bytes\n", dbuf.dsize);
380         print_data(dbuf.dptr, dbuf.dsize);
381         return 0;
382 #endif
383 }
384
385 static int print_key(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
386 {
387         print_asc(key.dptr, key.dsize);
388         printf("\n");
389         return 0;
390 }
391
392 static int total_bytes;
393
394 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
395 {
396         total_bytes += dbuf.dsize;
397         return 0;
398 }
399
400 static void info_tdb(void)
401 {
402         int count;
403         total_bytes = 0;
404         if ((count = tdb_traverse(tdb, traverse_fn, NULL) == -1))
405                 printf("Error = %s\n", tdb_errorstr(tdb));
406         else
407                 printf("%d records totalling %d bytes\n", count, total_bytes);
408 }
409
410 static char *tdb_getline(char *prompt)
411 {
412         static char line[1024];
413         char *p;
414         fputs(prompt, stdout);
415         line[0] = 0;
416         p = fgets(line, sizeof(line)-1, stdin);
417         if (p) p = strchr(p, '\n');
418         if (p) *p = 0;
419         return p?line:NULL;
420 }
421
422 static int do_delete_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf,
423                      void *state)
424 {
425     return tdb_delete(the_tdb, key);
426 }
427
428 static void first_record(TDB_CONTEXT *the_tdb, TDB_DATA *pkey)
429 {
430         TDB_DATA dbuf;
431         *pkey = tdb_firstkey(the_tdb);
432         
433         dbuf = tdb_fetch(the_tdb, *pkey);
434         if (!dbuf.dptr) terror("fetch failed");
435         else {
436                 /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
437                 print_rec(the_tdb, *pkey, dbuf, NULL);
438         }
439 }
440
441 static void next_record(TDB_CONTEXT *the_tdb, TDB_DATA *pkey)
442 {
443         TDB_DATA dbuf;
444         *pkey = tdb_nextkey(the_tdb, *pkey);
445         
446         dbuf = tdb_fetch(the_tdb, *pkey);
447         if (!dbuf.dptr) 
448                 terror("fetch failed");
449         else
450                 /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
451                 print_rec(the_tdb, *pkey, dbuf, NULL);
452 }
453
454 int main(int argc, char *argv[])
455 {
456     int bIterate = 0;
457     char *line;
458     char *tok;
459         TDB_DATA iterate_kbuf;
460
461     if (argv[1]) {
462         static char tmp[1024];
463         sprintf(tmp, "open %s", argv[1]);
464         tok=strtok(tmp," ");
465         open_tdb();
466     }
467
468     while ((line = tdb_getline("tdb> "))) {
469
470         /* Shell command */
471         
472         if (line[0] == '!') {
473             system(line + 1);
474             continue;
475         }
476         
477         if ((tok = strtok(line," "))==NULL) {
478            if (bIterate)
479               next_record(tdb, &iterate_kbuf);
480            continue;
481         }
482         if (strcmp(tok,"create") == 0) {
483             bIterate = 0;
484             create_tdb();
485             continue;
486         } else if (strcmp(tok,"open") == 0) {
487             open_tdb();
488             continue;
489         } else if ((strcmp(tok, "q") == 0) ||
490                    (strcmp(tok, "quit") == 0)) {
491             break;
492         }
493             
494         /* all the rest require a open database */
495         if (!tdb) {
496             bIterate = 0;
497             terror("database not open");
498             help();
499             continue;
500         }
501             
502         if (strcmp(tok,"insert") == 0) {
503             bIterate = 0;
504             insert_tdb();
505         } else if (strcmp(tok,"store") == 0) {
506             bIterate = 0;
507             store_tdb();
508         } else if (strcmp(tok,"show") == 0) {
509             bIterate = 0;
510             show_tdb();
511         } else if (strcmp(tok,"erase") == 0) {
512             bIterate = 0;
513             tdb_traverse(tdb, do_delete_fn, NULL);
514         } else if (strcmp(tok,"delete") == 0) {
515             bIterate = 0;
516             delete_tdb();
517         } else if (strcmp(tok,"dump") == 0) {
518             bIterate = 0;
519             tdb_traverse(tdb, print_rec, NULL);
520         } else if (strcmp(tok,"move") == 0) {
521             bIterate = 0;
522             move_rec();
523         } else if (strcmp(tok,"list") == 0) {
524             tdb_dump_all(tdb);
525         } else if (strcmp(tok, "free") == 0) {
526             tdb_printfreelist(tdb);
527         } else if (strcmp(tok,"info") == 0) {
528             info_tdb();
529         } else if ( (strcmp(tok, "1") == 0) ||
530                     (strcmp(tok, "first") == 0)) {
531             bIterate = 1;
532             first_record(tdb, &iterate_kbuf);
533         } else if ((strcmp(tok, "n") == 0) ||
534                    (strcmp(tok, "next") == 0)) {
535             next_record(tdb, &iterate_kbuf);
536         } else if ((strcmp(tok, "keys") == 0)) {
537                 bIterate = 0;
538                 tdb_traverse(tdb, print_key, NULL);
539         } else {
540             help();
541         }
542     }
543
544     if (tdb) tdb_close(tdb);
545
546     return 0;
547 }