2 ldb database library - command line handling for ldb tools
4 Copyright (C) Andrew Tridgell 2005
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
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.
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.
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
26 #include "ldb/include/includes.h"
27 #include "ldb/tools/cmdline.h"
29 #if (_SAMBA_BUILD_ >= 4)
30 #include "lib/cmdline/popt_common.h"
31 #include "lib/ldb/samba/ldif_handlers.h"
32 #include "auth/gensec/gensec.h"
33 #include "auth/auth.h"
40 process command line options
42 struct ldb_cmdline
*ldb_cmdline_process(struct ldb_context
*ldb
, int argc
, const char **argv
,
45 static struct ldb_cmdline options
; /* needs to be static for older compilers */
46 struct ldb_cmdline
*ret
=NULL
;
48 #if (_SAMBA_BUILD_ >= 4)
55 struct poptOption popt_options
[] = {
57 { "url", 'H', POPT_ARG_STRING
, &options
.url
, 0, "database URL", "URL" },
58 { "basedn", 'b', POPT_ARG_STRING
, &options
.basedn
, 0, "base DN", "DN" },
59 { "editor", 'e', POPT_ARG_STRING
, &options
.editor
, 0, "external editor", "PROGRAM" },
60 { "scope", 's', POPT_ARG_STRING
, NULL
, 's', "search scope", "SCOPE" },
61 { "verbose", 'v', POPT_ARG_NONE
, NULL
, 'v', "increase verbosity", NULL
},
62 { "interactive", 'i', POPT_ARG_NONE
, &options
.interactive
, 0, "input from stdin", NULL
},
63 { "recursive", 'r', POPT_ARG_NONE
, &options
.recursive
, 0, "recursive delete", NULL
},
64 { "num-searches", 0, POPT_ARG_INT
, &options
.num_searches
, 0, "number of test searches", NULL
},
65 { "num-records", 0, POPT_ARG_INT
, &options
.num_records
, 0, "number of test records", NULL
},
66 { "all", 'a', POPT_ARG_NONE
, &options
.all_records
, 0, "(|(objectClass=*)(distinguishedName=*))", NULL
},
67 { "nosync", 0, POPT_ARG_NONE
, &options
.nosync
, 0, "non-synchronous transactions", NULL
},
68 { "sorted", 'S', POPT_ARG_NONE
, &options
.sorted
, 0, "sort attributes", NULL
},
69 { "sasl-mechanism", 0, POPT_ARG_STRING
, &options
.sasl_mechanism
, 0, "choose SASL mechanism", "MECHANISM" },
70 { "input", 'I', POPT_ARG_STRING
, &options
.input
, 0, "Input File", "Input" },
71 { "output", 'O', POPT_ARG_STRING
, &options
.output
, 0, "Output File", "Output" },
72 { NULL
, 'o', POPT_ARG_STRING
, NULL
, 'o', "ldb_connect option", "OPTION" },
73 { "controls", 0, POPT_ARG_STRING
, NULL
, 'c', "controls", NULL
},
74 #if (_SAMBA_BUILD_ >= 4)
76 POPT_COMMON_CREDENTIALS
84 #if (_SAMBA_BUILD_ >= 4)
85 r
= ldb_register_samba_handlers(ldb
);
92 ret
= talloc_zero(ldb
, struct ldb_cmdline
);
101 options
.url
= getenv("LDB_URL");
103 /* and editor (used by ldbedit) */
104 options
.editor
= getenv("VISUAL");
105 if (!options
.editor
) {
106 options
.editor
= getenv("EDITOR");
108 if (!options
.editor
) {
109 options
.editor
= "vi";
112 options
.scope
= LDB_SCOPE_DEFAULT
;
114 pc
= poptGetContext(argv
[0], argc
, argv
, popt_options
,
115 POPT_CONTEXT_KEEP_FIRST
);
117 while((opt
= poptGetNextOpt(pc
)) != -1) {
120 const char *arg
= poptGetOptArg(pc
);
121 if (strcmp(arg
, "base") == 0) {
122 options
.scope
= LDB_SCOPE_BASE
;
123 } else if (strcmp(arg
, "sub") == 0) {
124 options
.scope
= LDB_SCOPE_SUBTREE
;
125 } else if (strcmp(arg
, "one") == 0) {
126 options
.scope
= LDB_SCOPE_ONELEVEL
;
128 fprintf(stderr
, "Invalid scope '%s'\n", arg
);
139 options
.options
= talloc_realloc(ret
, options
.options
,
140 const char *, num_options
+3);
141 if (options
.options
== NULL
) {
145 options
.options
[num_options
] = poptGetOptArg(pc
);
146 options
.options
[num_options
+1] = NULL
;
151 const char *cs
= poptGetOptArg(pc
);
155 for (p
= cs
, cc
= 1; (q
= strchr(p
, ',')); cc
++, p
= q
+ 1) ;
157 options
.controls
= talloc_array(ret
, char *, cc
+ 1);
158 if (options
.controls
== NULL
) {
162 for (p
= cs
, cc
= 0; p
!= NULL
; cc
++) {
167 options
.controls
[cc
] = talloc_strdup(options
.controls
, p
);
170 options
.controls
[cc
] = talloc_strndup(options
.controls
, p
, t
-p
);
174 options
.controls
[cc
] = NULL
;
179 fprintf(stderr
, "Invalid option %s: %s\n",
180 poptBadOption(pc
, 0), poptStrerror(opt
));
186 /* setup the remaining options for the main program to use */
187 options
.argv
= poptGetArgs(pc
);
190 while (options
.argv
[options
.argc
]) options
.argc
++;
195 /* all utils need some option */
196 if (ret
->url
== NULL
) {
197 fprintf(stderr
, "You must supply a url with -H or with $LDB_URL\n");
202 if (strcmp(ret
->url
, "NONE") == 0) {
206 if (options
.nosync
) {
207 flags
|= LDB_FLG_NOSYNC
;
210 #if (_SAMBA_BUILD_ >= 4)
211 /* Must be after we have processed command line options */
214 if (ldb_set_opaque(ldb
, "sessionInfo", system_session(ldb
))) {
217 if (ldb_set_opaque(ldb
, "credentials", cmdline_credentials
)) {
220 ldb_set_utf8_fns(ldb
, NULL
, wrap_casefold
);
223 /* now connect to the ldb */
224 if (ldb_connect(ldb
, ret
->url
, flags
, ret
->options
) != 0) {
225 fprintf(stderr
, "Failed to connect to %s - %s\n",
226 ret
->url
, ldb_errstring(ldb
));
238 struct ldb_control
**parse_controls(void *mem_ctx
, char **control_strings
)
241 struct ldb_control
**ctrl
;
243 if (control_strings
== NULL
|| control_strings
[0] == NULL
)
246 for (i
= 0; control_strings
[i
]; i
++);
248 ctrl
= talloc_array(mem_ctx
, struct ldb_control
*, i
+ 1);
250 for (i
= 0; control_strings
[i
]; i
++) {
251 if (strncmp(control_strings
[i
], "vlv:", 4) == 0) {
252 struct ldb_vlv_req_control
*control
;
256 int crit
, bc
, ac
, os
, cc
, ret
;
260 p
= &(control_strings
[i
][4]);
261 ret
= sscanf(p
, "%d:%d:%d:%d:%d:%1023[^$]", &crit
, &bc
, &ac
, &os
, &cc
, ctxid
);
263 ret
= sscanf(p
, "%d:%d:%d:%1023[^:]:%1023[^$]", &crit
, &bc
, &ac
, attr
, ctxid
);
266 if ((ret
< 4) || (crit
< 0) || (crit
> 1)) {
267 fprintf(stderr
, "invalid server_sort control syntax\n");
268 fprintf(stderr
, " syntax: crit(b):bc(n):ac(n):<os(n):cc(n)|attr(s)>[:ctxid(o)]\n");
269 fprintf(stderr
, " note: b = boolean, n = number, s = string, o = b64 binary blob\n");
272 if (!(ctrl
[i
] = talloc(ctrl
, struct ldb_control
))) {
273 fprintf(stderr
, "talloc failed\n");
276 ctrl
[i
]->oid
= LDB_CONTROL_VLV_REQ_OID
;
277 ctrl
[i
]->critical
= crit
;
278 if (!(control
= talloc(ctrl
[i
],
279 struct ldb_vlv_req_control
))) {
280 fprintf(stderr
, "talloc failed\n");
283 control
->beforeCount
= bc
;
284 control
->afterCount
= ac
;
287 control
->match
.gtOrEq
.value
= talloc_strdup(control
, attr
);
288 control
->match
.gtOrEq
.value_len
= strlen(attr
);
291 control
->match
.byOffset
.offset
= os
;
292 control
->match
.byOffset
.contentCount
= cc
;
295 control
->ctxid_len
= ldb_base64_decode(ctxid
);
296 control
->contextId
= (char *)talloc_memdup(control
, ctxid
, control
->ctxid_len
);
298 control
->ctxid_len
= 0;
299 control
->contextId
= NULL
;
301 ctrl
[i
]->data
= control
;
306 if (strncmp(control_strings
[i
], "dirsync:", 8) == 0) {
307 struct ldb_dirsync_control
*control
;
310 int crit
, flags
, max_attrs
, ret
;
313 p
= &(control_strings
[i
][8]);
314 ret
= sscanf(p
, "%d:%d:%d:%1023[^$]", &crit
, &flags
, &max_attrs
, cookie
);
316 if ((ret
< 3) || (crit
< 0) || (crit
> 1) || (flags
< 0) || (max_attrs
< 0)) {
317 fprintf(stderr
, "invalid dirsync control syntax\n");
318 fprintf(stderr
, " syntax: crit(b):flags(n):max_attrs(n)[:cookie(o)]\n");
319 fprintf(stderr
, " note: b = boolean, n = number, o = b64 binary blob\n");
323 /* w2k3 seems to ignore the parameter,
324 * but w2k sends a wrong cookie when this value is to small
325 * this would cause looping forever, while getting
326 * the same data and same cookie forever
328 if (max_attrs
== 0) max_attrs
= 0x0FFFFFFF;
330 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
331 ctrl
[i
]->oid
= LDB_CONTROL_DIRSYNC_OID
;
332 ctrl
[i
]->critical
= crit
;
333 control
= talloc(ctrl
[i
], struct ldb_dirsync_control
);
334 control
->flags
= flags
;
335 control
->max_attributes
= max_attrs
;
337 control
->cookie_len
= ldb_base64_decode(cookie
);
338 control
->cookie
= (char *)talloc_memdup(control
, cookie
, control
->cookie_len
);
340 control
->cookie
= NULL
;
341 control
->cookie_len
= 0;
343 ctrl
[i
]->data
= control
;
348 if (strncmp(control_strings
[i
], "asq:", 4) == 0) {
349 struct ldb_asq_control
*control
;
355 p
= &(control_strings
[i
][4]);
356 ret
= sscanf(p
, "%d:%255[^$]", &crit
, attr
);
357 if ((ret
!= 2) || (crit
< 0) || (crit
> 1) || (attr
[0] == '\0')) {
358 fprintf(stderr
, "invalid asq control syntax\n");
359 fprintf(stderr
, " syntax: crit(b):attr(s)\n");
360 fprintf(stderr
, " note: b = boolean, s = string\n");
364 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
365 ctrl
[i
]->oid
= LDB_CONTROL_ASQ_OID
;
366 ctrl
[i
]->critical
= crit
;
367 control
= talloc(ctrl
[i
], struct ldb_asq_control
);
368 control
->request
= 1;
369 control
->source_attribute
= talloc_strdup(control
, attr
);
370 control
->src_attr_len
= strlen(attr
);
371 ctrl
[i
]->data
= control
;
376 if (strncmp(control_strings
[i
], "extended_dn:", 12) == 0) {
377 struct ldb_extended_dn_control
*control
;
381 p
= &(control_strings
[i
][12]);
382 ret
= sscanf(p
, "%d:%d", &crit
, &type
);
383 if ((ret
!= 2) || (crit
< 0) || (crit
> 1) || (type
< 0) || (type
> 1)) {
384 fprintf(stderr
, "invalid extended_dn control syntax\n");
385 fprintf(stderr
, " syntax: crit(b):type(b)\n");
386 fprintf(stderr
, " note: b = boolean\n");
390 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
391 ctrl
[i
]->oid
= LDB_CONTROL_EXTENDED_DN_OID
;
392 ctrl
[i
]->critical
= crit
;
393 control
= talloc(ctrl
[i
], struct ldb_extended_dn_control
);
394 control
->type
= type
;
395 ctrl
[i
]->data
= control
;
400 if (strncmp(control_strings
[i
], "sd_flags:", 9) == 0) {
401 struct ldb_sd_flags_control
*control
;
404 unsigned secinfo_flags
;
406 p
= &(control_strings
[i
][9]);
407 ret
= sscanf(p
, "%d:%u", &crit
, &secinfo_flags
);
408 if ((ret
!= 2) || (crit
< 0) || (crit
> 1) || (secinfo_flags
< 0) || (secinfo_flags
> 0xF)) {
409 fprintf(stderr
, "invalid sd_flags control syntax\n");
410 fprintf(stderr
, " syntax: crit(b):secinfo_flags(n)\n");
411 fprintf(stderr
, " note: b = boolean, n = number\n");
415 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
416 ctrl
[i
]->oid
= LDB_CONTROL_SD_FLAGS_OID
;
417 ctrl
[i
]->critical
= crit
;
418 control
= talloc(ctrl
[i
], struct ldb_sd_flags_control
);
419 control
->secinfo_flags
= secinfo_flags
;
420 ctrl
[i
]->data
= control
;
425 if (strncmp(control_strings
[i
], "search_options:", 15) == 0) {
426 struct ldb_search_options_control
*control
;
429 unsigned search_options
;
431 p
= &(control_strings
[i
][15]);
432 ret
= sscanf(p
, "%d:%u", &crit
, &search_options
);
433 if ((ret
!= 2) || (crit
< 0) || (crit
> 1) || (search_options
< 0) || (search_options
> 0xF)) {
434 fprintf(stderr
, "invalid search_options control syntax\n");
435 fprintf(stderr
, " syntax: crit(b):search_options(n)\n");
436 fprintf(stderr
, " note: b = boolean, n = number\n");
440 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
441 ctrl
[i
]->oid
= LDB_CONTROL_SEARCH_OPTIONS_OID
;
442 ctrl
[i
]->critical
= crit
;
443 control
= talloc(ctrl
[i
], struct ldb_search_options_control
);
444 control
->search_options
= search_options
;
445 ctrl
[i
]->data
= control
;
450 if (strncmp(control_strings
[i
], "domain_scope:", 13) == 0) {
454 p
= &(control_strings
[i
][13]);
455 ret
= sscanf(p
, "%d", &crit
);
456 if ((ret
!= 1) || (crit
< 0) || (crit
> 1)) {
457 fprintf(stderr
, "invalid domain_scope control syntax\n");
458 fprintf(stderr
, " syntax: crit(b)\n");
459 fprintf(stderr
, " note: b = boolean\n");
463 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
464 ctrl
[i
]->oid
= LDB_CONTROL_DOMAIN_SCOPE_OID
;
465 ctrl
[i
]->critical
= crit
;
466 ctrl
[i
]->data
= NULL
;
471 if (strncmp(control_strings
[i
], "paged_results:", 14) == 0) {
472 struct ldb_paged_control
*control
;
476 p
= &(control_strings
[i
][14]);
477 ret
= sscanf(p
, "%d:%d", &crit
, &size
);
479 if ((ret
!= 2) || (crit
< 0) || (crit
> 1) || (size
< 0)) {
480 fprintf(stderr
, "invalid paged_results control syntax\n");
481 fprintf(stderr
, " syntax: crit(b):size(n)\n");
482 fprintf(stderr
, " note: b = boolean, n = number\n");
486 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
487 ctrl
[i
]->oid
= LDB_CONTROL_PAGED_RESULTS_OID
;
488 ctrl
[i
]->critical
= crit
;
489 control
= talloc(ctrl
[i
], struct ldb_paged_control
);
490 control
->size
= size
;
491 control
->cookie
= NULL
;
492 control
->cookie_len
= 0;
493 ctrl
[i
]->data
= control
;
498 if (strncmp(control_strings
[i
], "server_sort:", 12) == 0) {
499 struct ldb_server_sort_control
**control
;
507 p
= &(control_strings
[i
][12]);
508 ret
= sscanf(p
, "%d:%d:%255[^:]:%127[^:]", &crit
, &rev
, attr
, rule
);
509 if ((ret
< 3) || (crit
< 0) || (crit
> 1) || (rev
< 0 ) || (rev
> 1) ||attr
[0] == '\0') {
510 fprintf(stderr
, "invalid server_sort control syntax\n");
511 fprintf(stderr
, " syntax: crit(b):rev(b):attr(s)[:rule(s)]\n");
512 fprintf(stderr
, " note: b = boolean, s = string\n");
515 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
516 ctrl
[i
]->oid
= LDB_CONTROL_SERVER_SORT_OID
;
517 ctrl
[i
]->critical
= crit
;
518 control
= talloc_array(ctrl
[i
], struct ldb_server_sort_control
*, 2);
519 control
[0] = talloc(control
, struct ldb_server_sort_control
);
520 control
[0]->attributeName
= talloc_strdup(control
, attr
);
522 control
[0]->orderingRule
= talloc_strdup(control
, rule
);
524 control
[0]->orderingRule
= NULL
;
525 control
[0]->reverse
= rev
;
527 ctrl
[i
]->data
= control
;
532 if (strncmp(control_strings
[i
], "notification:", 13) == 0) {
536 p
= &(control_strings
[i
][13]);
537 ret
= sscanf(p
, "%d", &crit
);
538 if ((ret
!= 1) || (crit
< 0) || (crit
> 1)) {
539 fprintf(stderr
, "invalid notification control syntax\n");
540 fprintf(stderr
, " syntax: crit(b)\n");
541 fprintf(stderr
, " note: b = boolean\n");
545 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
546 ctrl
[i
]->oid
= LDB_CONTROL_NOTIFICATION_OID
;
547 ctrl
[i
]->critical
= crit
;
548 ctrl
[i
]->data
= NULL
;
553 if (strncmp(control_strings
[i
], "show_deleted:", 13) == 0) {
557 p
= &(control_strings
[i
][13]);
558 ret
= sscanf(p
, "%d", &crit
);
559 if ((ret
!= 1) || (crit
< 0) || (crit
> 1)) {
560 fprintf(stderr
, "invalid show_deleted control syntax\n");
561 fprintf(stderr
, " syntax: crit(b)\n");
562 fprintf(stderr
, " note: b = boolean\n");
566 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
567 ctrl
[i
]->oid
= LDB_CONTROL_SHOW_DELETED_OID
;
568 ctrl
[i
]->critical
= crit
;
569 ctrl
[i
]->data
= NULL
;
574 if (strncmp(control_strings
[i
], "permissive_modify:", 18) == 0) {
578 p
= &(control_strings
[i
][18]);
579 ret
= sscanf(p
, "%d", &crit
);
580 if ((ret
!= 1) || (crit
< 0) || (crit
> 1)) {
581 fprintf(stderr
, "invalid permissive_modify control syntax\n");
582 fprintf(stderr
, " syntax: crit(b)\n");
583 fprintf(stderr
, " note: b = boolean\n");
587 ctrl
[i
] = talloc(ctrl
, struct ldb_control
);
588 ctrl
[i
]->oid
= LDB_CONTROL_PERMISSIVE_MODIFY_OID
;
589 ctrl
[i
]->critical
= crit
;
590 ctrl
[i
]->data
= NULL
;
595 /* no controls matched, throw an error */
596 fprintf(stderr
, "Invalid control name: '%s'\n", control_strings
[i
]);
606 /* this function check controls reply and determines if more
607 * processing is needed setting up the request controls correctly
612 * 1 all ok, more processing required
614 int handle_controls_reply(struct ldb_control
**reply
, struct ldb_control
**request
)
619 if (reply
== NULL
|| request
== NULL
) return -1;
621 for (i
= 0; reply
[i
]; i
++) {
622 if (strcmp(LDB_CONTROL_VLV_RESP_OID
, reply
[i
]->oid
) == 0) {
623 struct ldb_vlv_resp_control
*rep_control
;
625 rep_control
= talloc_get_type(reply
[i
]->data
, struct ldb_vlv_resp_control
);
627 /* check we have a matching control in the request */
628 for (j
= 0; request
[j
]; j
++) {
629 if (strcmp(LDB_CONTROL_VLV_REQ_OID
, request
[j
]->oid
) == 0)
633 fprintf(stderr
, "Warning VLV reply received but no request have been made\n");
637 /* check the result */
638 if (rep_control
->vlv_result
!= 0) {
639 fprintf(stderr
, "Warning: VLV not performed with error: %d\n", rep_control
->vlv_result
);
641 fprintf(stderr
, "VLV Info: target position = %d, content count = %d\n", rep_control
->targetPosition
, rep_control
->contentCount
);
647 if (strcmp(LDB_CONTROL_ASQ_OID
, reply
[i
]->oid
) == 0) {
648 struct ldb_asq_control
*rep_control
;
650 rep_control
= talloc_get_type(reply
[i
]->data
, struct ldb_asq_control
);
652 /* check the result */
653 if (rep_control
->result
!= 0) {
654 fprintf(stderr
, "Warning: ASQ not performed with error: %d\n", rep_control
->result
);
660 if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID
, reply
[i
]->oid
) == 0) {
661 struct ldb_paged_control
*rep_control
, *req_control
;
663 rep_control
= talloc_get_type(reply
[i
]->data
, struct ldb_paged_control
);
664 if (rep_control
->cookie_len
== 0) /* we are done */
667 /* more processing required */
668 /* let's fill in the request control with the new cookie */
670 for (j
= 0; request
[j
]; j
++) {
671 if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID
, request
[j
]->oid
) == 0)
674 /* if there's a reply control we must find a request
675 * control matching it */
676 if (! request
[j
]) return -1;
678 req_control
= talloc_get_type(request
[j
]->data
, struct ldb_paged_control
);
680 if (req_control
->cookie
)
681 talloc_free(req_control
->cookie
);
682 req_control
->cookie
= (char *)talloc_memdup(
683 req_control
, rep_control
->cookie
,
684 rep_control
->cookie_len
);
685 req_control
->cookie_len
= rep_control
->cookie_len
;
692 if (strcmp(LDB_CONTROL_SORT_RESP_OID
, reply
[i
]->oid
) == 0) {
693 struct ldb_sort_resp_control
*rep_control
;
695 rep_control
= talloc_get_type(reply
[i
]->data
, struct ldb_sort_resp_control
);
697 /* check we have a matching control in the request */
698 for (j
= 0; request
[j
]; j
++) {
699 if (strcmp(LDB_CONTROL_SERVER_SORT_OID
, request
[j
]->oid
) == 0)
703 fprintf(stderr
, "Warning Server Sort reply received but no request found\n");
707 /* check the result */
708 if (rep_control
->result
!= 0) {
709 fprintf(stderr
, "Warning: Sorting not performed with error: %d\n", rep_control
->result
);
715 if (strcmp(LDB_CONTROL_DIRSYNC_OID
, reply
[i
]->oid
) == 0) {
716 struct ldb_dirsync_control
*rep_control
, *req_control
;
719 rep_control
= talloc_get_type(reply
[i
]->data
, struct ldb_dirsync_control
);
720 if (rep_control
->cookie_len
== 0) /* we are done */
723 /* more processing required */
724 /* let's fill in the request control with the new cookie */
726 for (j
= 0; request
[j
]; j
++) {
727 if (strcmp(LDB_CONTROL_DIRSYNC_OID
, request
[j
]->oid
) == 0)
730 /* if there's a reply control we must find a request
731 * control matching it */
732 if (! request
[j
]) return -1;
734 req_control
= talloc_get_type(request
[j
]->data
, struct ldb_dirsync_control
);
736 if (req_control
->cookie
)
737 talloc_free(req_control
->cookie
);
738 req_control
->cookie
= (char *)talloc_memdup(
739 req_control
, rep_control
->cookie
,
740 rep_control
->cookie_len
);
741 req_control
->cookie_len
= rep_control
->cookie_len
;
743 cookie
= ldb_base64_encode(req_control
, rep_control
->cookie
, rep_control
->cookie_len
);
744 printf("# DIRSYNC cookie returned was:\n# %s\n", cookie
);
749 /* no controls matched, throw a warning */
750 fprintf(stderr
, "Unknown reply control oid: %s\n", reply
[i
]->oid
);