446923f282d1a7970d1dd3091a32b77758e9bd47
[samba.git] / source / lib / ldb / tools / cmdline.c
1 /* 
2    ldb database library - command line handling for ldb tools
3
4    Copyright (C) Andrew Tridgell  2005
5
6      ** NOTE! The following LGPL license applies to the ldb
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9    
10    This library is free software; you can redistribute it and/or
11    modify it under the terms of the GNU Lesser General Public
12    License as published by the Free Software Foundation; either
13    version 2 of the License, or (at your option) any later version.
14
15    This library 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 GNU
18    Lesser General Public License for more details.
19
20    You should have received a copy of the GNU Lesser General Public
21    License along with this library; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 */
24
25 #include "includes.h"
26 #include "ldb/include/includes.h"
27 #include "ldb/tools/cmdline.h"
28
29 #ifdef _SAMBA_BUILD_
30 #include "lib/cmdline/popt_common.h"
31 #include "auth/auth.h"
32 #endif
33
34 /*
35   process command line options
36 */
37 struct ldb_cmdline *ldb_cmdline_process(struct ldb_context *ldb, int argc, const char **argv,
38                                         void (*usage)(void))
39 {
40         struct ldb_cmdline options, *ret=NULL;
41         poptContext pc;
42 #ifdef _SAMBA_BUILD_
43         int r;
44 #endif
45         int num_options = 0;
46         int opt;
47         struct poptOption popt_options[] = {
48                 POPT_AUTOHELP
49                 { "url",       'H', POPT_ARG_STRING, &options.url, 0, "database URL", "URL" },
50                 { "basedn",    'b', POPT_ARG_STRING, &options.basedn, 0, "base DN", "DN" },
51                 { "editor",    'e', POPT_ARG_STRING, &options.editor, 0, "external editor", "PROGRAM" },
52                 { "scope",     's', POPT_ARG_STRING, NULL, 's', "search scope", "SCOPE" },
53                 { "verbose",   'v', POPT_ARG_NONE, NULL, 'v', "increase verbosity", NULL },
54                 { "interactive", 'i', POPT_ARG_NONE, &options.interactive, 0, "input from stdin", NULL },
55                 { "recursive", 'r', POPT_ARG_NONE, &options.recursive, 0, "recursive delete", NULL },
56                 { "num-searches", 0, POPT_ARG_INT, &options.num_searches, 0, "number of test searches", NULL },
57                 { "num-records", 0, POPT_ARG_INT, &options.num_records, 0, "number of test records", NULL },
58                 { "all", 'a',    POPT_ARG_NONE, &options.all_records, 0, "(|(objectClass=*)(distinguishedName=*))", NULL },
59                 { "nosync", 0,   POPT_ARG_NONE, &options.nosync, 0, "non-synchronous transactions", NULL },
60                 { "sorted", 'S', POPT_ARG_NONE, &options.sorted, 0, "sort attributes", NULL },
61                 { "sasl-mechanism", 0, POPT_ARG_STRING, &options.sasl_mechanism, 0, "choose SASL mechanism", "MECHANISM" },
62                 { "input", 'I', POPT_ARG_STRING, &options.input, 0, "Input File", "Input" },
63                 { "output", 'O', POPT_ARG_STRING, &options.output, 0, "Output File", "Output" },
64                 { NULL,    'o', POPT_ARG_STRING, NULL, 'o', "ldb_connect option", "OPTION" },
65                 { "controls", 0, POPT_ARG_STRING, NULL, 'c', "controls", NULL },
66 #ifdef _SAMBA_BUILD_
67                 POPT_COMMON_SAMBA
68                 POPT_COMMON_CREDENTIALS
69                 POPT_COMMON_VERSION
70 #endif
71                 POPT_TABLEEND
72         };
73
74 #ifdef _SAMBA_BUILD_
75         gensec_init(); 
76
77         r = ldb_register_samba_handlers(ldb);
78         if (r != 0) {
79                 goto failed;
80         }
81
82 #endif
83
84         ret = talloc_zero(ldb, struct ldb_cmdline);
85         if (ret == NULL) {
86                 ldb_oom(ldb);
87                 goto failed;
88         }
89
90         options = *ret;
91         
92         /* pull in URL */
93         options.url = getenv("LDB_URL");
94
95         /* and editor (used by ldbedit) */
96         options.editor = getenv("VISUAL");
97         if (!options.editor) {
98                 options.editor = getenv("EDITOR");
99         }
100         if (!options.editor) {
101                 options.editor = "vi";
102         }
103
104         options.scope = LDB_SCOPE_DEFAULT;
105
106         pc = poptGetContext(argv[0], argc, argv, popt_options, 
107                             POPT_CONTEXT_KEEP_FIRST);
108
109         while((opt = poptGetNextOpt(pc)) != -1) {
110                 switch (opt) {
111                 case 's': {
112                         const char *arg = poptGetOptArg(pc);
113                         if (strcmp(arg, "base") == 0) {
114                                 options.scope = LDB_SCOPE_BASE;
115                         } else if (strcmp(arg, "sub") == 0) {
116                                 options.scope = LDB_SCOPE_SUBTREE;
117                         } else if (strcmp(arg, "one") == 0) {
118                                 options.scope = LDB_SCOPE_ONELEVEL;
119                         } else {
120                                 fprintf(stderr, "Invalid scope '%s'\n", arg);
121                                 goto failed;
122                         }
123                         break;
124                 }
125
126                 case 'v':
127                         options.verbose++;
128                         break;
129
130                 case 'o':
131                         options.options = talloc_realloc(ret, options.options, 
132                                                          const char *, num_options+3);
133                         if (options.options == NULL) {
134                                 ldb_oom(ldb);
135                                 goto failed;
136                         }
137                         options.options[num_options] = poptGetOptArg(pc);
138                         options.options[num_options+1] = NULL;
139                         num_options++;
140                         break;
141
142                 case 'c': {
143                         const char *cs = poptGetOptArg(pc);
144                         const char *p, *q;
145                         int cc;
146
147                         for (p = cs, cc = 1; (q = strchr(p, ',')); cc++, p = q + 1) ;
148
149                         options.controls = talloc_array(ret, char *, cc + 1);
150                         if (options.controls == NULL) {
151                                 ldb_oom(ldb);
152                                 goto failed;
153                         }
154                         for (p = cs, cc = 0; p != NULL; cc++) {
155                                 const char *t;
156
157                                 t = strchr(p, ',');
158                                 if (t == NULL) {
159                                         options.controls[cc] = talloc_strdup(options.controls, p);
160                                         p = NULL;
161                                 } else {
162                                         options.controls[cc] = talloc_strndup(options.controls, p, t-p);
163                                         p = t + 1;
164                                 }
165                         }
166                         options.controls[cc] = NULL;
167
168                         break;    
169                 }
170                 default:
171                         fprintf(stderr, "Invalid option %s: %s\n", 
172                                 poptBadOption(pc, 0), poptStrerror(opt));
173                         if (usage) usage();
174                         goto failed;
175                 }
176         }
177
178         /* setup the remaining options for the main program to use */
179         options.argv = poptGetArgs(pc);
180         if (options.argv) {
181                 options.argv++;
182                 while (options.argv[options.argc]) options.argc++;
183         }
184
185         *ret = options;
186
187         /* all utils need some option */
188         if (ret->url == NULL) {
189                 fprintf(stderr, "You must supply a url with -H or with $LDB_URL\n");
190                 if (usage) usage();
191                 goto failed;
192         }
193
194         if (strcmp(ret->url, "NONE") != 0) {
195                 int flags = 0;
196                 if (options.nosync) {
197                         flags |= LDB_FLG_NOSYNC;
198                 }
199
200 #ifdef _SAMBA_BUILD_
201                 if (ldb_set_opaque(ldb, "sessionInfo", system_session(ldb))) {
202                         goto failed;
203                 }
204                 if (ldb_set_opaque(ldb, "credentials", cmdline_credentials)) {
205                         goto failed;
206                 }
207                 ldb_set_utf8_fns(ldb, NULL, wrap_caseless_cmp, wrap_casefold);
208 #endif
209                 if (ldb_connect(ldb, ret->url, flags, ret->options) != 0) {
210                         fprintf(stderr, "Failed to connect to %s - %s\n", 
211                                 ret->url, ldb_errstring(ldb));
212                         goto failed;
213                 }
214         }
215
216         return ret;
217
218 failed:
219         talloc_free(ret);
220         exit(1);
221         return NULL;
222 }
223
224 struct ldb_control **parse_controls(void *mem_ctx, char **control_strings)
225 {
226         int i;
227         struct ldb_control **ctrl;
228
229         if (control_strings == NULL || control_strings[0] == NULL)
230                 return NULL;
231
232         for (i = 0; control_strings[i]; i++);
233
234         ctrl = talloc_array(mem_ctx, struct ldb_control *, i + 1);
235
236         for (i = 0; control_strings[i]; i++) {
237                 if (strncmp(control_strings[i], "dirsync:", 8) == 0) {
238                         struct ldb_dirsync_control *control;
239                         const char *p;
240                         char cookie[1024];
241                         int crit, flags, max_attrs, ret;
242                        
243                         cookie[0] = '\0';
244                         p = &(control_strings[i][8]);
245                         ret = sscanf(p, "%d:%d:%d:%1023[^$]", &crit, &flags, &max_attrs, cookie);
246
247                         if ((ret < 3) || (crit < 0) || (crit > 1) || (flags < 0) || (max_attrs < 0)) {
248                                 fprintf(stderr, "invalid dirsync control syntax\n");
249                                 return NULL;
250                         }
251
252                         /* w2k3 seems to ignore the parameter,
253                          * but w2k sends a wrong cookie when this value is to small
254                          * this would cause looping forever, while getting
255                          * the same data and same cookie forever
256                          */
257                         if (max_attrs == 0) max_attrs = 0x0FFFFFFF;
258
259                         ctrl[i] = talloc(ctrl, struct ldb_control);
260                         ctrl[i]->oid = LDB_CONTROL_DIRSYNC_OID;
261                         ctrl[i]->critical = crit;
262                         control = talloc(ctrl[i], struct ldb_dirsync_control);
263                         control->flags = flags;
264                         control->max_attributes = max_attrs;
265                         if (*cookie) {
266                                 control->cookie_len = ldb_base64_decode(cookie);
267                                 control->cookie = talloc_memdup(control, cookie, control->cookie_len);
268                         } else {
269                                 control->cookie = NULL;
270                                 control->cookie_len = 0;
271                         }
272                         ctrl[i]->data = control;
273
274                         continue;
275                 }
276
277                 if (strncmp(control_strings[i], "asq:", 4) == 0) {
278                         struct ldb_asq_control *control;
279                         const char *p;
280                         char attr[256];
281                         int crit, ret;
282
283                         attr[0] = '\0';
284                         p = &(control_strings[i][4]);
285                         ret = sscanf(p, "%d:%255[^$]", &crit, attr);
286                         if ((ret != 2) || (crit < 0) || (crit > 1) || (attr[0] == '\0')) {
287                                 fprintf(stderr, "invalid asq control syntax\n");
288                                 return NULL;
289                         }
290
291                         ctrl[i] = talloc(ctrl, struct ldb_control);
292                         ctrl[i]->oid = LDB_CONTROL_ASQ_OID;
293                         ctrl[i]->critical = crit;
294                         control = talloc(ctrl[i], struct ldb_asq_control);
295                         control->request = 1;
296                         control->source_attribute = talloc_strdup(control, attr);
297                         control->src_attr_len = strlen(attr);
298                         ctrl[i]->data = control;
299
300                         continue;
301                 }
302
303                 if (strncmp(control_strings[i], "extended_dn:", 12) == 0) {
304                         struct ldb_extended_dn_control *control;
305                         const char *p;
306                         int crit, type, ret;
307
308                         p = &(control_strings[i][12]);
309                         ret = sscanf(p, "%d:%d", &crit, &type);
310                         if ((ret != 2) || (crit < 0) || (crit > 1) || (type < 0) || (type > 1)) {
311                                 fprintf(stderr, "invalid extended_dn control syntax\n");
312                                 return NULL;
313                         }
314
315                         ctrl[i] = talloc(ctrl, struct ldb_control);
316                         ctrl[i]->oid = LDB_CONTROL_EXTENDED_DN_OID;
317                         ctrl[i]->critical = crit;
318                         control = talloc(ctrl[i], struct ldb_extended_dn_control);
319                         control->type = type;
320                         ctrl[i]->data = control;
321
322                         continue;
323                 }
324
325                 if (strncmp(control_strings[i], "paged_results:", 14) == 0) {
326                         struct ldb_paged_control *control;
327                         const char *p;
328                         int crit, size, ret;
329                        
330                         p = &(control_strings[i][14]);
331                         ret = sscanf(p, "%d:%d", &crit, &size);
332
333                         if ((ret != 2) || (crit < 0) || (crit > 1) || (size < 0)) {
334                                 fprintf(stderr, "invalid paged_results control syntax\n");
335                                 return NULL;
336                         }
337
338                         ctrl[i] = talloc(ctrl, struct ldb_control);
339                         ctrl[i]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
340                         ctrl[i]->critical = crit;
341                         control = talloc(ctrl[i], struct ldb_paged_control);
342                         control->size = size;
343                         control->cookie = NULL;
344                         control->cookie_len = 0;
345                         ctrl[i]->data = control;
346
347                         continue;
348                 }
349
350                 if (strncmp(control_strings[i], "server_sort:", 12) == 0) {
351                         struct ldb_server_sort_control **control;
352                         const char *p;
353                         char attr[256];
354                         char rule[128];
355                         int crit, rev, ret;
356
357                         attr[0] = '\0';
358                         rule[0] = '\0';
359                         p = &(control_strings[i][12]);
360                         ret = sscanf(p, "%d:%d:%255[^:]:%127[^:]", &crit, &rev, attr, rule);
361                         if ((ret < 3) || (crit < 0) || (crit > 1) || (rev < 0 ) || (rev > 1) ||attr[0] == '\0') {
362                                 fprintf(stderr, "invalid server_sort control syntax\n");
363                                 return NULL;
364                         }
365                         ctrl[i] = talloc(ctrl, struct ldb_control);
366                         ctrl[i]->oid = LDB_CONTROL_SERVER_SORT_OID;
367                         ctrl[i]->critical = crit;
368                         control = talloc_array(ctrl[i], struct ldb_server_sort_control *, 2);
369                         control[0] = talloc(control, struct ldb_server_sort_control);
370                         control[0]->attributeName = talloc_strdup(control, attr);
371                         if (rule[0])
372                                 control[0]->orderingRule = talloc_strdup(control, rule);
373                         else
374                                 control[0]->orderingRule = NULL;
375                         control[0]->reverse = rev;
376                         control[1] = NULL;
377                         ctrl[i]->data = control;
378
379                         continue;
380                 }
381
382                 if (strncmp(control_strings[i], "notification:", 13) == 0) {
383                         const char *p;
384                         int crit, ret;
385
386                         p = &(control_strings[i][13]);
387                         ret = sscanf(p, "%d", &crit);
388                         if ((ret != 1) || (crit < 0) || (crit > 1)) {
389                                 fprintf(stderr, "invalid notification control syntax\n");
390                                 return NULL;
391                         }
392
393                         ctrl[i] = talloc(ctrl, struct ldb_control);
394                         ctrl[i]->oid = LDB_CONTROL_NOTIFICATION_OID;
395                         ctrl[i]->critical = crit;
396                         ctrl[i]->data = NULL;
397
398                         continue;
399                 }
400
401                 /* no controls matched, throw an error */
402                 fprintf(stderr, "Invalid control name\n");
403                 return NULL;
404         }
405
406         ctrl[i] = NULL;
407
408         return ctrl;
409 }
410
411
412 /* this function check controls reply and determines if more
413  * processing is needed setting up the request controls correctly
414  *
415  * returns:
416  *      -1 error
417  *      0 all ok
418  *      1 all ok, more processing required
419  */
420 int handle_controls_reply(struct ldb_control **reply, struct ldb_control **request)
421 {
422         int i, j;
423         int ret = 0;
424
425         if (reply == NULL || request == NULL) return -1;
426         
427         for (i = 0; reply[i]; i++) {
428                 if (strcmp(LDB_CONTROL_ASQ_OID, reply[i]->oid) == 0) {
429                         struct ldb_asq_control *rep_control;
430
431                         rep_control = talloc_get_type(reply[i]->data, struct ldb_asq_control);
432
433                         /* check the result */
434                         if (rep_control->result != 0) {
435                                 fprintf(stderr, "Warning: ASQ not performed with error: %d\n", rep_control->result);
436                         }
437
438                         continue;
439                 }
440                 if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID, reply[i]->oid) == 0) {
441                         struct ldb_paged_control *rep_control, *req_control;
442
443                         rep_control = talloc_get_type(reply[i]->data, struct ldb_paged_control);
444                         if (rep_control->cookie_len == 0) /* we are done */
445                                 break;
446
447                         /* more processing required */
448                         /* let's fill in the request control with the new cookie */
449
450                         for (j = 0; request[j]; j++) {
451                                 if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID, request[j]->oid) == 0)
452                                         break;
453                         }
454                         /* if there's a reply control we must find a request
455                          * control matching it */
456                         if (! request[j]) return -1;
457
458                         req_control = talloc_get_type(request[j]->data, struct ldb_paged_control);
459
460                         if (req_control->cookie)
461                                 talloc_free(req_control->cookie);
462                         req_control->cookie = talloc_memdup(req_control,
463                                                             rep_control->cookie,
464                                                             rep_control->cookie_len);
465                         req_control->cookie_len = rep_control->cookie_len;
466
467                         ret = 1;
468
469                         continue;
470                 }
471
472                 if (strcmp(LDB_CONTROL_SORT_RESP_OID, reply[i]->oid) == 0) {
473                         struct ldb_sort_resp_control *rep_control;
474
475                         rep_control = talloc_get_type(reply[i]->data, struct ldb_sort_resp_control);
476
477                         /* check we have a matching control in the request */
478                         for (j = 0; request[j]; j++) {
479                                 if (strcmp(LDB_CONTROL_SERVER_SORT_OID, request[j]->oid) == 0)
480                                         break;
481                         }
482                         if (! request[j]) {
483                                 fprintf(stderr, "Warning Server Sort reply received but no request found\n");
484                                 continue;
485                         }
486
487                         /* check the result */
488                         if (rep_control->result != 0) {
489                                 fprintf(stderr, "Warning: Sorting not performed with error: %d\n", rep_control->result);
490                         }
491
492                         continue;
493                 }
494
495                 if (strcmp(LDB_CONTROL_DIRSYNC_OID, reply[i]->oid) == 0) {
496                         struct ldb_dirsync_control *rep_control, *req_control;
497                         char *cookie;
498
499                         rep_control = talloc_get_type(reply[i]->data, struct ldb_dirsync_control);
500                         if (rep_control->cookie_len == 0) /* we are done */
501                                 break;
502
503                         /* more processing required */
504                         /* let's fill in the request control with the new cookie */
505
506                         for (j = 0; request[j]; j++) {
507                                 if (strcmp(LDB_CONTROL_DIRSYNC_OID, request[j]->oid) == 0)
508                                         break;
509                         }
510                         /* if there's a reply control we must find a request
511                          * control matching it */
512                         if (! request[j]) return -1;
513
514                         req_control = talloc_get_type(request[j]->data, struct ldb_dirsync_control);
515
516                         if (req_control->cookie)
517                                 talloc_free(req_control->cookie);
518                         req_control->cookie = talloc_memdup(req_control, 
519                                                             rep_control->cookie,
520                                                             rep_control->cookie_len);
521                         req_control->cookie_len = rep_control->cookie_len;
522
523                         cookie = ldb_base64_encode(req_control, rep_control->cookie, rep_control->cookie_len);
524                         printf("# DIRSYNC cookie returned was:\n# %s\n", cookie);
525
526                         sleep(120);
527                         
528                         ret = 1;
529
530                         continue;
531                 }
532
533                 /* no controls matched, throw a warning */
534                 fprintf(stderr, "Unknown reply control oid: %s\n", reply[i]->oid);
535         }
536
537         return ret;
538 }
539