2 Unix SMB/CIFS implementation.
3 Infrastructure for async ldap client requests
4 Copyright (C) Volker Lendecke 2009
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 bool tldap_entry_values(struct tldap_message *msg, const char *attribute,
23 int *num_values, DATA_BLOB **values)
25 struct tldap_attribute *attributes;
26 int i, num_attributes;
28 if (!tldap_entry_attributes(msg, &num_attributes, &attributes)) {
32 for (i=0; i<num_attributes; i++) {
33 if (strequal(attribute, attributes[i].name)) {
37 if (i == num_attributes) {
40 *num_values = attributes[i].num_values;
41 *values = attributes[i].values;
45 bool tldap_get_single_valueblob(struct tldap_message *msg,
46 const char *attribute, DATA_BLOB *blob)
51 if (attribute == NULL) {
54 if (!tldap_entry_values(msg, attribute, &num_values, &values)) {
57 if (num_values != 1) {
64 char *tldap_talloc_single_attribute(struct tldap_message *msg,
65 const char *attribute,
72 if (!tldap_get_single_valueblob(msg, attribute, &val)) {
75 if (!convert_string_talloc(mem_ctx, CH_UTF8, CH_UNIX,
77 &result, &len, false)) {
83 bool tldap_pull_binsid(struct tldap_message *msg, const char *attribute,
88 if (!tldap_get_single_valueblob(msg, attribute, &val)) {
91 return sid_parse((char *)val.data, val.length, sid);
94 static bool tldap_add_blob_vals(TALLOC_CTX *mem_ctx, struct tldap_mod *mod,
95 int num_newvals, DATA_BLOB *newvals)
97 int num_values = talloc_array_length(mod->values);
101 tmp = talloc_realloc(mem_ctx, mod->values, DATA_BLOB,
102 num_values + num_newvals);
108 for (i=0; i<num_newvals; i++) {
109 mod->values[i+num_values].data = (uint8_t *)talloc_memdup(
110 mod->values, newvals[i].data, newvals[i].length);
111 if (mod->values[i+num_values].data == NULL) {
114 mod->values[i+num_values].length = newvals[i].length;
116 mod->num_values = num_values + num_newvals;
120 bool tldap_add_mod_blobs(TALLOC_CTX *mem_ctx, struct tldap_mod **pmods,
121 int mod_op, const char *attrib,
122 int num_newvals, DATA_BLOB *newvals)
124 struct tldap_mod new_mod;
125 struct tldap_mod *mods = *pmods;
126 struct tldap_mod *mod = NULL;
130 mods = talloc_array(mem_ctx, struct tldap_mod, 0);
136 num_mods = talloc_array_length(mods);
138 for (i=0; i<num_mods; i++) {
139 if ((mods[i].mod_op == mod_op)
140 && strequal(mods[i].attribute, attrib)) {
147 new_mod.mod_op = mod_op;
148 new_mod.attribute = talloc_strdup(mods, attrib);
149 if (new_mod.attribute == NULL) {
152 new_mod.num_values = 0;
153 new_mod.values = NULL;
157 if ((num_newvals != 0)
158 && !tldap_add_blob_vals(mods, mod, num_newvals, newvals)) {
163 mods = talloc_realloc(talloc_tos(), mods, struct tldap_mod,
168 mods[num_mods] = *mod;
175 bool tldap_add_mod_str(TALLOC_CTX *mem_ctx, struct tldap_mod **pmods,
176 int mod_op, const char *attrib, const char *str)
181 if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF8, str,
182 strlen(str), &utf8.data, &utf8.length,
187 ret = tldap_add_mod_blobs(mem_ctx, pmods, mod_op, attrib, 1, &utf8);
188 TALLOC_FREE(utf8.data);
192 static bool tldap_make_mod_blob_int(struct tldap_message *existing,
194 int *pnum_mods, struct tldap_mod **pmods,
195 const char *attrib, DATA_BLOB newval,
196 int (*comparison)(const DATA_BLOB *d1,
197 const DATA_BLOB *d2))
200 DATA_BLOB *values = NULL;
201 DATA_BLOB oldval = data_blob_null;
203 if ((existing != NULL)
204 && tldap_entry_values(existing, attrib, &num_values, &values)) {
206 if (num_values > 1) {
207 /* can't change multivalue attributes atm */
210 if (num_values == 1) {
215 if ((oldval.data != NULL) && (newval.data != NULL)
216 && (comparison(&oldval, &newval) == 0)) {
217 /* Believe it or not, but LDAP will deny a delete and
218 an add at the same time if the values are the
220 DEBUG(10,("smbldap_make_mod_blob: attribute |%s| not "
221 "changed.\n", attrib));
225 if (oldval.data != NULL) {
226 /* By deleting exactly the value we found in the entry this
227 * should be race-free in the sense that the LDAP-Server will
228 * deny the complete operation if somebody changed the
229 * attribute behind our back. */
230 /* This will also allow modifying single valued attributes in
231 * Novell NDS. In NDS you have to first remove attribute and
232 * then you could add new value */
234 DEBUG(10, ("smbldap_make_mod_blob: deleting attribute |%s|\n",
236 if (!tldap_add_mod_blobs(mem_ctx, pmods, TLDAP_MOD_DELETE,
237 attrib, 1, &oldval)) {
242 /* Regardless of the real operation (add or modify)
243 we add the new value here. We rely on deleting
244 the old value, should it exist. */
246 if (newval.data != NULL) {
247 DEBUG(10, ("smbldap_make_mod: adding attribute |%s| value len "
248 "%d\n", attrib, (int)newval.length));
249 if (!tldap_add_mod_blobs(mem_ctx, pmods, TLDAP_MOD_ADD,
250 attrib, 1, &newval)) {
254 *pnum_mods = talloc_array_length(*pmods);
258 bool tldap_make_mod_blob(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
259 int *pnum_mods, struct tldap_mod **pmods,
260 const char *attrib, DATA_BLOB newval)
262 return tldap_make_mod_blob_int(existing, mem_ctx, pnum_mods, pmods,
263 attrib, newval, data_blob_cmp);
266 static int compare_utf8_blobs(const DATA_BLOB *d1, const DATA_BLOB *d2)
272 if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d1->data,
273 d1->length, &s1, &s1len, false)) {
274 /* can't do much here */
277 if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d2->data,
278 d2->length, &s2, &s2len, false)) {
279 /* can't do much here */
283 ret = StrCaseCmp(s1, s2);
289 bool tldap_make_mod_fmt(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
290 int *pnum_mods, struct tldap_mod **pmods,
291 const char *attrib, const char *fmt, ...)
296 DATA_BLOB blob = data_blob_null;
299 newval = talloc_vasprintf(talloc_tos(), fmt, ap);
302 if (newval == NULL) {
306 blob.length = strlen(newval);
307 if (blob.length != 0) {
308 blob.data = CONST_DISCARD(uint8_t *, newval);
310 ret = tldap_make_mod_blob_int(existing, mem_ctx, pnum_mods, pmods,
311 attrib, blob, compare_utf8_blobs);
316 const char *tldap_errstr(TALLOC_CTX *mem_ctx, struct tldap_context *ld, int rc)
318 const char *ld_error = NULL;
321 ld_error = tldap_msg_diagnosticmessage(tldap_ctx_lastmsg(ld));
322 res = talloc_asprintf(mem_ctx, "LDAP error %d (%s), %s", rc,
323 tldap_err2string(rc),
324 ld_error ? ld_error : "unknown");
328 int tldap_search_fmt(struct tldap_context *ld, const char *base, int scope,
329 const char *attrs[], int num_attrs, int attrsonly,
330 TALLOC_CTX *mem_ctx, struct tldap_message ***res,
331 const char *fmt, ...)
338 filter = talloc_vasprintf(talloc_tos(), fmt, ap);
341 if (filter == NULL) {
342 return TLDAP_NO_MEMORY;
344 ret = tldap_search(ld, base, scope, filter,
345 attrs, num_attrs, attrsonly,
346 NULL /*sctrls*/, 0, NULL /*cctrls*/, 0,
347 0 /*timelimit*/, 0 /*sizelimit*/, 0 /*deref*/,
353 bool tldap_pull_uint64(struct tldap_message *msg, const char *attr,
359 str = tldap_talloc_single_attribute(msg, attr, talloc_tos());
361 DEBUG(10, ("Could not find attribute %s\n", attr));
364 result = strtoull(str, NULL, 10);
370 bool tldap_pull_uint32(struct tldap_message *msg, const char *attr,
375 if (!tldap_pull_uint64(msg, attr, &result)) {
378 *presult = (uint32_t)result;
382 struct tldap_fetch_rootdse_state {
383 struct tldap_context *ld;
384 struct tldap_message *rootdse;
387 static void tldap_fetch_rootdse_done(struct tevent_req *subreq);
389 struct tevent_req *tldap_fetch_rootdse_send(TALLOC_CTX *mem_ctx,
390 struct tevent_context *ev,
391 struct tldap_context *ld)
393 struct tevent_req *req, *subreq;
394 struct tldap_fetch_rootdse_state *state;
395 static const char *attrs[2] = { "*", "+" };
397 req = tevent_req_create(mem_ctx, &state,
398 struct tldap_fetch_rootdse_state);
403 state->rootdse = NULL;
405 subreq = tldap_search_send(
406 mem_ctx, ev, ld, "", TLDAP_SCOPE_BASE, "(objectclass=*)",
407 attrs, ARRAY_SIZE(attrs), 0, NULL, 0, NULL, 0, 0, 0, 0);
408 if (tevent_req_nomem(subreq, req)) {
409 return tevent_req_post(req, ev);
411 tevent_req_set_callback(subreq, tldap_fetch_rootdse_done, req);
415 static void tldap_fetch_rootdse_done(struct tevent_req *subreq)
417 struct tevent_req *req = tevent_req_callback_data(
418 subreq, struct tevent_req);
419 struct tldap_fetch_rootdse_state *state = tevent_req_data(
420 req, struct tldap_fetch_rootdse_state);
421 struct tldap_message *msg;
424 rc = tldap_search_recv(subreq, state, &msg);
425 if (rc != TLDAP_SUCCESS) {
427 tevent_req_error(req, rc);
431 switch (tldap_msg_type(msg)) {
432 case TLDAP_RES_SEARCH_ENTRY:
433 if (state->rootdse != NULL) {
436 state->rootdse = msg;
438 case TLDAP_RES_SEARCH_RESULT:
440 if (state->rootdse == NULL) {
443 tevent_req_done(req);
448 tevent_req_done(req);
452 tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
456 int tldap_fetch_rootdse_recv(struct tevent_req *req)
458 struct tldap_fetch_rootdse_state *state = tevent_req_data(
459 req, struct tldap_fetch_rootdse_state);
463 if (tevent_req_is_ldap_error(req, &err)) {
466 /* Trigger parsing the dn, just to make sure it's ok */
467 if (!tldap_entry_dn(state->rootdse, &dn)) {
468 return TLDAP_DECODING_ERROR;
470 if (!tldap_context_setattr(state->ld, "tldap:rootdse",
472 return TLDAP_NO_MEMORY;
477 int tldap_fetch_rootdse(struct tldap_context *ld)
479 TALLOC_CTX *frame = talloc_stackframe();
480 struct tevent_context *ev;
481 struct tevent_req *req;
484 ev = event_context_init(frame);
486 result = TLDAP_NO_MEMORY;
490 req = tldap_fetch_rootdse_send(frame, ev, ld);
492 result = TLDAP_NO_MEMORY;
496 if (!tevent_req_poll(req, ev)) {
497 result = TLDAP_OPERATIONS_ERROR;
501 result = tldap_fetch_rootdse_recv(req);
507 struct tldap_message *tldap_rootdse(struct tldap_context *ld)
509 return talloc_get_type(tldap_context_getattr(ld, "tldap:rootdse"),
510 struct tldap_message);
513 bool tldap_entry_has_attrvalue(struct tldap_message *msg,
514 const char *attribute,
515 const DATA_BLOB blob)
520 if (!tldap_entry_values(msg, attribute, &num_values, &values)) {
523 for (i=0; i<num_values; i++) {
524 if (data_blob_cmp(&values[i], &blob) == 0) {
531 bool tldap_supports_control(struct tldap_context *ld, const char *oid)
533 struct tldap_message *rootdse = tldap_rootdse(ld);
535 if (rootdse == NULL) {
538 return tldap_entry_has_attrvalue(rootdse, "supportedControl",
539 data_blob_const(oid, strlen(oid)));
542 struct tldap_control *tldap_add_control(TALLOC_CTX *mem_ctx,
543 struct tldap_control *ctrls,
545 struct tldap_control *ctrl)
547 struct tldap_control *result;
549 result = talloc_array(mem_ctx, struct tldap_control, num_ctrls+1);
550 if (result == NULL) {
553 memcpy(result, ctrls, sizeof(struct tldap_control) * num_ctrls);
554 result[num_ctrls] = *ctrl;
559 * Find a control returned by the server
561 struct tldap_control *tldap_msg_findcontrol(struct tldap_message *msg,
564 struct tldap_control *controls;
567 tldap_msg_sctrls(msg, &num_controls, &controls);
569 for (i=0; i<num_controls; i++) {
570 if (strcmp(controls[i].oid, oid) == 0) {
577 struct tldap_search_paged_state {
578 struct tevent_context *ev;
579 struct tldap_context *ld;
586 struct tldap_control *sctrls;
588 struct tldap_control *cctrls;
595 struct asn1_data *asn1;
597 struct tldap_message *result;
600 static struct tevent_req *tldap_ship_paged_search(
602 struct tldap_search_paged_state *state)
604 struct tldap_control *pgctrl;
605 struct asn1_data *asn1;
607 asn1 = asn1_init(state);
611 asn1_push_tag(asn1, ASN1_SEQUENCE(0));
612 asn1_write_Integer(asn1, state->page_size);
613 asn1_write_OctetString(asn1, state->cookie.data, state->cookie.length);
615 if (asn1->has_error) {
621 pgctrl = &state->sctrls[state->num_sctrls-1];
622 pgctrl->oid = TLDAP_CONTROL_PAGEDRESULTS;
623 pgctrl->critical = true;
624 if (!asn1_blob(state->asn1, &pgctrl->value)) {
628 return tldap_search_send(mem_ctx, state->ev, state->ld, state->base,
629 state->scope, state->filter, state->attrs,
630 state->num_attrs, state->attrsonly,
631 state->sctrls, state->num_sctrls,
632 state->cctrls, state->num_cctrls,
633 state->timelimit, state->sizelimit,
637 static void tldap_search_paged_done(struct tevent_req *subreq);
639 struct tevent_req *tldap_search_paged_send(TALLOC_CTX *mem_ctx,
640 struct tevent_context *ev,
641 struct tldap_context *ld,
642 const char *base, int scope,
647 struct tldap_control *sctrls,
649 struct tldap_control *cctrls,
656 struct tevent_req *req, *subreq;
657 struct tldap_search_paged_state *state;
658 struct tldap_control empty_control;
660 req = tevent_req_create(mem_ctx, &state,
661 struct tldap_search_paged_state);
668 state->filter = filter;
669 state->scope = scope;
670 state->attrs = attrs;
671 state->num_attrs = num_attrs;
672 state->attrsonly = attrsonly;
673 state->cctrls = cctrls;
674 state->num_cctrls = num_cctrls;
675 state->timelimit = timelimit;
676 state->sizelimit = sizelimit;
677 state->deref = deref;
679 state->page_size = page_size;
681 state->cookie = data_blob_null;
683 ZERO_STRUCT(empty_control);
685 state->sctrls = tldap_add_control(state, sctrls, num_sctrls,
687 if (tevent_req_nomem(state->sctrls, req)) {
688 return tevent_req_post(req, ev);
690 state->num_sctrls = num_sctrls+1;
692 subreq = tldap_ship_paged_search(state, state);
693 if (tevent_req_nomem(subreq, req)) {
694 return tevent_req_post(req, ev);
696 tevent_req_set_callback(subreq, tldap_search_paged_done, req);
701 static void tldap_search_paged_done(struct tevent_req *subreq)
703 struct tevent_req *req = tevent_req_callback_data(
704 subreq, struct tevent_req);
705 struct tldap_search_paged_state *state = tevent_req_data(
706 req, struct tldap_search_paged_state);
707 struct asn1_data *asn1;
708 struct tldap_control *pgctrl;
711 rc = tldap_search_recv(subreq, state, &state->result);
712 if (rc != TLDAP_SUCCESS) {
714 tevent_req_error(req, rc);
718 TALLOC_FREE(state->asn1);
720 switch (tldap_msg_type(state->result)) {
721 case TLDAP_RES_SEARCH_ENTRY:
722 case TLDAP_RES_SEARCH_REFERENCE:
723 tevent_req_notify_callback(req);
725 case TLDAP_RES_SEARCH_RESULT:
729 tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
735 /* We've finished one paged search, fire the next */
737 pgctrl = tldap_msg_findcontrol(state->result,
738 TLDAP_CONTROL_PAGEDRESULTS);
739 if (pgctrl == NULL) {
740 /* RFC2696 requires the server to return the control */
741 tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
745 TALLOC_FREE(state->cookie.data);
747 asn1 = asn1_init(talloc_tos());
749 tevent_req_error(req, TLDAP_NO_MEMORY);
753 asn1_load_nocopy(asn1, pgctrl->value.data, pgctrl->value.length);
754 asn1_start_tag(asn1, ASN1_SEQUENCE(0));
755 asn1_read_Integer(asn1, &size);
756 asn1_read_OctetString(asn1, state, &state->cookie);
758 if (asn1->has_error) {
759 tevent_req_error(req, TLDAP_DECODING_ERROR);
764 if (state->cookie.length == 0) {
765 /* We're done, no cookie anymore */
766 tevent_req_done(req);
770 TALLOC_FREE(state->result);
772 subreq = tldap_ship_paged_search(state, state);
773 if (tevent_req_nomem(subreq, req)) {
776 tevent_req_set_callback(subreq, tldap_search_paged_done, req);
779 int tldap_search_paged_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
780 struct tldap_message **pmsg)
782 struct tldap_search_paged_state *state = tevent_req_data(
783 req, struct tldap_search_paged_state);
786 if (!tevent_req_is_in_progress(req)
787 && tevent_req_is_ldap_error(req, &err)) {
790 if (tevent_req_is_in_progress(req)) {
791 switch (tldap_msg_type(state->result)) {
792 case TLDAP_RES_SEARCH_ENTRY:
793 case TLDAP_RES_SEARCH_REFERENCE:
796 return TLDAP_PROTOCOL_ERROR;
799 *pmsg = talloc_move(mem_ctx, &state->result);
800 return TLDAP_SUCCESS;