source3/lib/tldap_util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Infrastructure for async ldap client requests
   4    Copyright (C) Volker Lendecke 2009
   5
   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.
  10
  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.
  15
  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/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "tldap.h"
  22 #include "tldap_util.h"
  23 #include "../libcli/security/security.h"
  24
  25 bool tldap_entry_values(struct tldap_message *msg, const char *attribute,
  26                         DATA_BLOB **values, int *num_values)
  27 {
  28         struct tldap_attribute *attributes;
  29         int i, num_attributes;
  30
  31         if (!tldap_entry_attributes(msg, &num_attributes, &attributes)) {
  32                 return false;
  33         }
  34
  35         for (i=0; i<num_attributes; i++) {
  36                 if (strequal(attribute, attributes[i].name)) {
  37                         break;
  38                 }
  39         }
  40         if (i == num_attributes) {
  41                 return false;
  42         }
  43         *num_values = attributes[i].num_values;
  44         *values = attributes[i].values;
  45         return true;
  46 }
  47
  48 bool tldap_get_single_valueblob(struct tldap_message *msg,
  49                                 const char *attribute, DATA_BLOB *blob)
  50 {
  51         int num_values;
  52         DATA_BLOB *values;
  53
  54         if (attribute == NULL) {
  55                 return NULL;
  56         }
  57         if (!tldap_entry_values(msg, attribute, &values, &num_values)) {
  58                 return NULL;
  59         }
  60         if (num_values != 1) {
  61                 return NULL;
  62         }
  63         *blob = values[0];
  64         return true;
  65 }
  66
  67 char *tldap_talloc_single_attribute(struct tldap_message *msg,
  68                                     const char *attribute,
  69                                     TALLOC_CTX *mem_ctx)
  70 {
  71         DATA_BLOB val;
  72         char *result;
  73         size_t len;
  74
  75         if (!tldap_get_single_valueblob(msg, attribute, &val)) {
  76                 return false;
  77         }
  78         if (!convert_string_talloc(mem_ctx, CH_UTF8, CH_UNIX,
  79                                    val.data, val.length,
  80                                    &result, &len, false)) {
  81                 return NULL;
  82         }
  83         return result;
  84 }
  85
  86 bool tldap_pull_binsid(struct tldap_message *msg, const char *attribute,
  87                        struct dom_sid *sid)
  88 {
  89         DATA_BLOB val;
  90
  91         if (!tldap_get_single_valueblob(msg, attribute, &val)) {
  92                 return false;
  93         }
  94         return sid_parse((char *)val.data, val.length, sid);
  95 }
  96
  97 bool tldap_pull_guid(struct tldap_message *msg, const char *attribute,
  98                      struct GUID *guid)
  99 {
 100         DATA_BLOB val;
 101
 102         if (!tldap_get_single_valueblob(msg, attribute, &val)) {
 103                 return false;
 104         }
 105         return NT_STATUS_IS_OK(GUID_from_data_blob(&val, guid));
 106 }
 107
 108 static bool tldap_add_blob_vals(TALLOC_CTX *mem_ctx, struct tldap_mod *mod,
 109                                 DATA_BLOB *newvals, int num_newvals)
 110 {
 111         int num_values = talloc_array_length(mod->values);
 112         int i;
 113         DATA_BLOB *tmp;
 114
 115         tmp = talloc_realloc(mem_ctx, mod->values, DATA_BLOB,
 116                              num_values + num_newvals);
 117         if (tmp == NULL) {
 118                 return false;
 119         }
 120         mod->values = tmp;
 121
 122         for (i=0; i<num_newvals; i++) {
 123                 mod->values[i+num_values].data = (uint8_t *)talloc_memdup(
 124                         mod->values, newvals[i].data, newvals[i].length);
 125                 if (mod->values[i+num_values].data == NULL) {
 126                         return false;
 127                 }
 128                 mod->values[i+num_values].length = newvals[i].length;
 129         }
 130         mod->num_values = num_values + num_newvals;
 131         return true;
 132 }
 133
 134 bool tldap_add_mod_blobs(TALLOC_CTX *mem_ctx,
 135                          struct tldap_mod **pmods, int *pnum_mods,
 136                          int mod_op, const char *attrib,
 137                          DATA_BLOB *newvals, int num_newvals)
 138 {
 139         struct tldap_mod new_mod;
 140         struct tldap_mod *mods = *pmods;
 141         struct tldap_mod *mod = NULL;
 142         int i, num_mods;
 143
 144         if (mods == NULL) {
 145                 mods = talloc_array(mem_ctx, struct tldap_mod, 0);
 146         }
 147         if (mods == NULL) {
 148                 return false;
 149         }
 150
 151         num_mods = *pnum_mods;
 152
 153         for (i=0; i<num_mods; i++) {
 154                 if ((mods[i].mod_op == mod_op)
 155                     && strequal(mods[i].attribute, attrib)) {
 156                         mod = &mods[i];
 157                         break;
 158                 }
 159         }
 160
 161         if (mod == NULL) {
 162                 new_mod.mod_op = mod_op;
 163                 new_mod.attribute = talloc_strdup(mods, attrib);
 164                 if (new_mod.attribute == NULL) {
 165                         return false;
 166                 }
 167                 new_mod.num_values = 0;
 168                 new_mod.values = NULL;
 169                 mod = &new_mod;
 170         }
 171
 172         if ((num_newvals != 0)
 173             && !tldap_add_blob_vals(mods, mod, newvals, num_newvals)) {
 174                 return false;
 175         }
 176
 177         if ((i == num_mods) && (talloc_array_length(mods) < num_mods + 1)) {
 178                 mods = talloc_realloc(talloc_tos(), mods, struct tldap_mod,
 179                                       num_mods+1);
 180                 if (mods == NULL) {
 181                         return false;
 182                 }
 183                 mods[num_mods] = *mod;
 184         }
 185
 186         *pmods = mods;
 187         *pnum_mods += 1;
 188         return true;
 189 }
 190
 191 bool tldap_add_mod_str(TALLOC_CTX *mem_ctx,
 192                        struct tldap_mod **pmods, int *pnum_mods,
 193                        int mod_op, const char *attrib, const char *str)
 194 {
 195         DATA_BLOB utf8;
 196         bool ret;
 197
 198         if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF8, str,
 199                                    strlen(str), &utf8.data, &utf8.length,
 200                                    false)) {
 201                 return false;
 202         }
 203
 204         ret = tldap_add_mod_blobs(mem_ctx, pmods, pnum_mods, mod_op, attrib,
 205                                   &utf8, 1);
 206         TALLOC_FREE(utf8.data);
 207         return ret;
 208 }
 209
 210 static bool tldap_make_mod_blob_int(struct tldap_message *existing,
 211                                     TALLOC_CTX *mem_ctx,
 212                                     struct tldap_mod **pmods, int *pnum_mods,
 213                                     const char *attrib, DATA_BLOB newval,
 214                                     int (*comparison)(const DATA_BLOB *d1,
 215                                                       const DATA_BLOB *d2))
 216 {
 217         int num_values = 0;
 218         DATA_BLOB *values = NULL;
 219         DATA_BLOB oldval = data_blob_null;
 220
 221         if ((existing != NULL)
 222             && tldap_entry_values(existing, attrib, &values, &num_values)) {
 223
 224                 if (num_values > 1) {
 225                         /* can't change multivalue attributes atm */
 226                         return false;
 227                 }
 228                 if (num_values == 1) {
 229                         oldval = values[0];
 230                 }
 231         }
 232
 233         if ((oldval.data != NULL) && (newval.data != NULL)
 234             && (comparison(&oldval, &newval) == 0)) {
 235                 /* Believe it or not, but LDAP will deny a delete and
 236                    an add at the same time if the values are the
 237                    same... */
 238                 DEBUG(10,("smbldap_make_mod_blob: attribute |%s| not "
 239                           "changed.\n", attrib));
 240                 return true;
 241         }
 242
 243         if (oldval.data != NULL) {
 244                 /* By deleting exactly the value we found in the entry this
 245                  * should be race-free in the sense that the LDAP-Server will
 246                  * deny the complete operation if somebody changed the
 247                  * attribute behind our back. */
 248                 /* This will also allow modifying single valued attributes in
 249                  * Novell NDS. In NDS you have to first remove attribute and
 250                  * then you could add new value */
 251
 252                 DEBUG(10, ("smbldap_make_mod_blob: deleting attribute |%s|\n",
 253                            attrib));
 254                 if (!tldap_add_mod_blobs(mem_ctx, pmods, pnum_mods,
 255                                          TLDAP_MOD_DELETE,
 256                                          attrib, &oldval, 1)) {
 257                         return false;
 258                 }
 259         }
 260
 261         /* Regardless of the real operation (add or modify)
 262            we add the new value here. We rely on deleting
 263            the old value, should it exist. */
 264
 265         if (newval.data != NULL) {
 266                 DEBUG(10, ("smbldap_make_mod: adding attribute |%s| value len "
 267                            "%d\n", attrib, (int)newval.length));
 268                 if (!tldap_add_mod_blobs(mem_ctx, pmods, pnum_mods,
 269                                          TLDAP_MOD_ADD,
 270                                          attrib, &newval, 1)) {
 271                         return false;
 272                 }
 273         }
 274         return true;
 275 }
 276
 277 bool tldap_make_mod_blob(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
 278                          struct tldap_mod **pmods, int *pnum_mods,
 279                          const char *attrib, DATA_BLOB newval)
 280 {
 281         return tldap_make_mod_blob_int(existing, mem_ctx, pmods, pnum_mods,
 282                                        attrib, newval, data_blob_cmp);
 283 }
 284
 285 static int compare_utf8_blobs(const DATA_BLOB *d1, const DATA_BLOB *d2)
 286 {
 287         char *s1, *s2;
 288         size_t s1len, s2len;
 289         int ret;
 290
 291         if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d1->data,
 292                                    d1->length, &s1, &s1len, false)) {
 293                 /* can't do much here */
 294                 return 0;
 295         }
 296         if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d2->data,
 297                                    d2->length, &s2, &s2len, false)) {
 298                 /* can't do much here */
 299                 TALLOC_FREE(s1);
 300                 return 0;
 301         }
 302         ret = StrCaseCmp(s1, s2);
 303         TALLOC_FREE(s2);
 304         TALLOC_FREE(s1);
 305         return ret;
 306 }
 307
 308 bool tldap_make_mod_fmt(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
 309                         struct tldap_mod **pmods, int *pnum_mods,
 310                         const char *attrib, const char *fmt, ...)
 311 {
 312         va_list ap;
 313         char *newval;
 314         bool ret;
 315         DATA_BLOB blob = data_blob_null;
 316
 317         va_start(ap, fmt);
 318         newval = talloc_vasprintf(talloc_tos(), fmt, ap);
 319         va_end(ap);
 320
 321         if (newval == NULL) {
 322                 return false;
 323         }
 324
 325         blob.length = strlen(newval);
 326         if (blob.length != 0) {
 327                 blob.data = CONST_DISCARD(uint8_t *, newval);
 328         }
 329         ret = tldap_make_mod_blob_int(existing, mem_ctx, pmods, pnum_mods,
 330                                       attrib, blob, compare_utf8_blobs);
 331         TALLOC_FREE(newval);
 332         return ret;
 333 }
 334
 335 const char *tldap_errstr(TALLOC_CTX *mem_ctx, struct tldap_context *ld, int rc)
 336 {
 337         const char *ld_error = NULL;
 338         char *res;
 339
 340         ld_error = tldap_msg_diagnosticmessage(tldap_ctx_lastmsg(ld));
 341         res = talloc_asprintf(mem_ctx, "LDAP error %d (%s), %s", rc,
 342                               tldap_err2string(rc),
 343                               ld_error ? ld_error : "unknown");
 344         return res;
 345 }
 346
 347 int tldap_search_va(struct tldap_context *ld, const char *base, int scope,
 348                     const char *attrs[], int num_attrs, int attrsonly,
 349                     TALLOC_CTX *mem_ctx, struct tldap_message ***res,
 350                     const char *fmt, va_list ap)
 351 {
 352         char *filter;
 353         int ret;
 354
 355         filter = talloc_vasprintf(talloc_tos(), fmt, ap);
 356         if (filter == NULL) {
 357                 return TLDAP_NO_MEMORY;
 358         }
 359
 360         ret = tldap_search(ld, base, scope, filter,
 361                            attrs, num_attrs, attrsonly,
 362                            NULL /*sctrls*/, 0, NULL /*cctrls*/, 0,
 363                            0 /*timelimit*/, 0 /*sizelimit*/, 0 /*deref*/,
 364                            mem_ctx, res, NULL);
 365         TALLOC_FREE(filter);
 366         return ret;
 367 }
 368
 369 int tldap_search_fmt(struct tldap_context *ld, const char *base, int scope,
 370                      const char *attrs[], int num_attrs, int attrsonly,
 371                      TALLOC_CTX *mem_ctx, struct tldap_message ***res,
 372                      const char *fmt, ...)
 373 {
 374         va_list ap;
 375         int ret;
 376
 377         va_start(ap, fmt);
 378         ret = tldap_search_va(ld, base, scope, attrs, num_attrs, attrsonly,
 379                               mem_ctx, res, fmt, ap);
 380         va_end(ap);
 381         return ret;
 382 }
 383
 384 bool tldap_pull_uint64(struct tldap_message *msg, const char *attr,
 385                        uint64_t *presult)
 386 {
 387         char *str;
 388         uint64_t result;
 389
 390         str = tldap_talloc_single_attribute(msg, attr, talloc_tos());
 391         if (str == NULL) {
 392                 DEBUG(10, ("Could not find attribute %s\n", attr));
 393                 return false;
 394         }
 395         result = strtoull(str, NULL, 10);
 396         TALLOC_FREE(str);
 397         *presult = result;
 398         return true;
 399 }
 400
 401 bool tldap_pull_uint32(struct tldap_message *msg, const char *attr,
 402                        uint32_t *presult)
 403 {
 404         uint64_t result;
 405
 406         if (!tldap_pull_uint64(msg, attr, &result)) {
 407                 return false;
 408         }
 409         *presult = (uint32_t)result;
 410         return true;
 411 }
 412
 413 struct tldap_fetch_rootdse_state {
 414         struct tldap_context *ld;
 415         struct tldap_message *rootdse;
 416 };
 417
 418 static void tldap_fetch_rootdse_done(struct tevent_req *subreq);
 419
 420 struct tevent_req *tldap_fetch_rootdse_send(TALLOC_CTX *mem_ctx,
 421                                             struct tevent_context *ev,
 422                                             struct tldap_context *ld)
 423 {
 424         struct tevent_req *req, *subreq;
 425         struct tldap_fetch_rootdse_state *state;
 426         static const char *attrs[2] = { "*", "+" };
 427
 428         req = tevent_req_create(mem_ctx, &state,
 429                                 struct tldap_fetch_rootdse_state);
 430         if (req == NULL) {
 431                 return NULL;
 432         }
 433         state->ld = ld;
 434         state->rootdse = NULL;
 435
 436         subreq = tldap_search_send(
 437                 mem_ctx, ev, ld, "", TLDAP_SCOPE_BASE, "(objectclass=*)",
 438                 attrs, ARRAY_SIZE(attrs), 0, NULL, 0, NULL, 0, 0, 0, 0);
 439         if (tevent_req_nomem(subreq, req)) {
 440                 return tevent_req_post(req, ev);
 441         }
 442         tevent_req_set_callback(subreq, tldap_fetch_rootdse_done, req);
 443         return req;
 444 }
 445
 446 static void tldap_fetch_rootdse_done(struct tevent_req *subreq)
 447 {
 448         struct tevent_req *req = tevent_req_callback_data(
 449                 subreq, struct tevent_req);
 450         struct tldap_fetch_rootdse_state *state = tevent_req_data(
 451                 req, struct tldap_fetch_rootdse_state);
 452         struct tldap_message *msg;
 453         int rc;
 454
 455         rc = tldap_search_recv(subreq, state, &msg);
 456         if (rc != TLDAP_SUCCESS) {
 457                 TALLOC_FREE(subreq);
 458                 tevent_req_error(req, rc);
 459                 return;
 460         }
 461
 462         switch (tldap_msg_type(msg)) {
 463         case TLDAP_RES_SEARCH_ENTRY:
 464                 if (state->rootdse != NULL) {
 465                         goto protocol_error;
 466                 }
 467                 state->rootdse = msg;
 468                 break;
 469         case TLDAP_RES_SEARCH_RESULT:
 470                 TALLOC_FREE(subreq);
 471                 if (state->rootdse == NULL) {
 472                         goto protocol_error;
 473                 }
 474                 tevent_req_done(req);
 475                 break;
 476         default:
 477                 goto protocol_error;
 478         }
 479         return;
 480
 481 protocol_error:
 482         tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
 483         return;
 484 }
 485
 486 int tldap_fetch_rootdse_recv(struct tevent_req *req)
 487 {
 488         struct tldap_fetch_rootdse_state *state = tevent_req_data(
 489                 req, struct tldap_fetch_rootdse_state);
 490         int err;
 491         char *dn;
 492
 493         if (tevent_req_is_ldap_error(req, &err)) {
 494                 return err;
 495         }
 496         /* Trigger parsing the dn, just to make sure it's ok */
 497         if (!tldap_entry_dn(state->rootdse, &dn)) {
 498                 return TLDAP_DECODING_ERROR;
 499         }
 500         if (!tldap_context_setattr(state->ld, "tldap:rootdse",
 501                                    &state->rootdse)) {
 502                 return TLDAP_NO_MEMORY;
 503         }
 504         return 0;
 505 }
 506
 507 int tldap_fetch_rootdse(struct tldap_context *ld)
 508 {
 509         TALLOC_CTX *frame = talloc_stackframe();
 510         struct tevent_context *ev;
 511         struct tevent_req *req;
 512         int result;
 513
 514         ev = event_context_init(frame);
 515         if (ev == NULL) {
 516                 result = TLDAP_NO_MEMORY;
 517                 goto fail;
 518         }
 519
 520         req = tldap_fetch_rootdse_send(frame, ev, ld);
 521         if (req == NULL) {
 522                 result = TLDAP_NO_MEMORY;
 523                 goto fail;
 524         }
 525
 526         if (!tevent_req_poll(req, ev)) {
 527                 result = TLDAP_OPERATIONS_ERROR;
 528                 goto fail;
 529         }
 530
 531         result = tldap_fetch_rootdse_recv(req);
 532  fail:
 533         TALLOC_FREE(frame);
 534         return result;
 535 }
 536
 537 struct tldap_message *tldap_rootdse(struct tldap_context *ld)
 538 {
 539         return talloc_get_type(tldap_context_getattr(ld, "tldap:rootdse"),
 540                                struct tldap_message);
 541 }
 542
 543 bool tldap_entry_has_attrvalue(struct tldap_message *msg,
 544                                const char *attribute,
 545                                const DATA_BLOB blob)
 546 {
 547         int i, num_values;
 548         DATA_BLOB *values;
 549
 550         if (!tldap_entry_values(msg, attribute, &values, &num_values)) {
 551                 return false;
 552         }
 553         for (i=0; i<num_values; i++) {
 554                 if (data_blob_cmp(&values[i], &blob) == 0) {
 555                         return true;
 556                 }
 557         }
 558         return false;
 559 }
 560
 561 bool tldap_supports_control(struct tldap_context *ld, const char *oid)
 562 {
 563         struct tldap_message *rootdse = tldap_rootdse(ld);
 564
 565         if (rootdse == NULL) {
 566                 return false;
 567         }
 568         return tldap_entry_has_attrvalue(rootdse, "supportedControl",
 569                                          data_blob_const(oid, strlen(oid)));
 570 }
 571
 572 struct tldap_control *tldap_add_control(TALLOC_CTX *mem_ctx,
 573                                         struct tldap_control *ctrls,
 574                                         int num_ctrls,
 575                                         struct tldap_control *ctrl)
 576 {
 577         struct tldap_control *result;
 578
 579         result = talloc_array(mem_ctx, struct tldap_control, num_ctrls+1);
 580         if (result == NULL) {
 581                 return NULL;
 582         }
 583         memcpy(result, ctrls, sizeof(struct tldap_control) * num_ctrls);
 584         result[num_ctrls] = *ctrl;
 585         return result;
 586 }
 587
 588 /*
 589  * Find a control returned by the server
 590  */
 591 struct tldap_control *tldap_msg_findcontrol(struct tldap_message *msg,
 592                                             const char *oid)
 593 {
 594         struct tldap_control *controls;
 595         int i, num_controls;
 596
 597         tldap_msg_sctrls(msg, &num_controls, &controls);
 598
 599         for (i=0; i<num_controls; i++) {
 600                 if (strcmp(controls[i].oid, oid) == 0) {
 601                         return &controls[i];
 602                 }
 603         }
 604         return NULL;
 605 }
 606
 607 struct tldap_search_paged_state {
 608         struct tevent_context *ev;
 609         struct tldap_context *ld;
 610         const char *base;
 611         const char *filter;
 612         int scope;
 613         const char **attrs;
 614         int num_attrs;
 615         int attrsonly;
 616         struct tldap_control *sctrls;
 617         int num_sctrls;
 618         struct tldap_control *cctrls;
 619         int num_cctrls;
 620         int timelimit;
 621         int sizelimit;
 622         int deref;
 623
 624         int page_size;
 625         struct asn1_data *asn1;
 626         DATA_BLOB cookie;
 627         struct tldap_message *result;
 628 };
 629
 630 static struct tevent_req *tldap_ship_paged_search(
 631         TALLOC_CTX *mem_ctx,
 632         struct tldap_search_paged_state *state)
 633 {
 634         struct tldap_control *pgctrl;
 635         struct asn1_data *asn1;
 636
 637         asn1 = asn1_init(state);
 638         if (asn1 == NULL) {
 639                 return NULL;
 640         }
 641         asn1_push_tag(asn1, ASN1_SEQUENCE(0));
 642         asn1_write_Integer(asn1, state->page_size);
 643         asn1_write_OctetString(asn1, state->cookie.data, state->cookie.length);
 644         asn1_pop_tag(asn1);
 645         if (asn1->has_error) {
 646                 TALLOC_FREE(asn1);
 647                 return NULL;
 648         }
 649         state->asn1 = asn1;
 650
 651         pgctrl = &state->sctrls[state->num_sctrls-1];
 652         pgctrl->oid = TLDAP_CONTROL_PAGEDRESULTS;
 653         pgctrl->critical = true;
 654         if (!asn1_blob(state->asn1, &pgctrl->value)) {
 655                 TALLOC_FREE(asn1);
 656                 return NULL;
 657         }
 658         return tldap_search_send(mem_ctx, state->ev, state->ld, state->base,
 659                                  state->scope, state->filter, state->attrs,
 660                                  state->num_attrs, state->attrsonly,
 661                                  state->sctrls, state->num_sctrls,
 662                                  state->cctrls, state->num_cctrls,
 663                                  state->timelimit, state->sizelimit,
 664                                  state->deref);
 665 }
 666
 667 static void tldap_search_paged_done(struct tevent_req *subreq);
 668
 669 struct tevent_req *tldap_search_paged_send(TALLOC_CTX *mem_ctx,
 670                                            struct tevent_context *ev,
 671                                            struct tldap_context *ld,
 672                                            const char *base, int scope,
 673                                            const char *filter,
 674                                            const char **attrs,
 675                                            int num_attrs,
 676                                            int attrsonly,
 677                                            struct tldap_control *sctrls,
 678                                            int num_sctrls,
 679                                            struct tldap_control *cctrls,
 680                                            int num_cctrls,
 681                                            int timelimit,
 682                                            int sizelimit,
 683                                            int deref,
 684                                            int page_size)
 685 {
 686         struct tevent_req *req, *subreq;
 687         struct tldap_search_paged_state *state;
 688         struct tldap_control empty_control;
 689
 690         req = tevent_req_create(mem_ctx, &state,
 691                                 struct tldap_search_paged_state);
 692         if (req == NULL) {
 693                 return NULL;
 694         }
 695         state->ev = ev;
 696         state->ld = ld;
 697         state->base = base;
 698         state->filter = filter;
 699         state->scope = scope;
 700         state->attrs = attrs;
 701         state->num_attrs = num_attrs;
 702         state->attrsonly = attrsonly;
 703         state->cctrls = cctrls;
 704         state->num_cctrls = num_cctrls;
 705         state->timelimit = timelimit;
 706         state->sizelimit = sizelimit;
 707         state->deref = deref;
 708
 709         state->page_size = page_size;
 710         state->asn1 = NULL;
 711         state->cookie = data_blob_null;
 712
 713         ZERO_STRUCT(empty_control);
 714
 715         state->sctrls = tldap_add_control(state, sctrls, num_sctrls,
 716                                           &empty_control);
 717         if (tevent_req_nomem(state->sctrls, req)) {
 718                 return tevent_req_post(req, ev);
 719         }
 720         state->num_sctrls = num_sctrls+1;
 721
 722         subreq = tldap_ship_paged_search(state, state);
 723         if (tevent_req_nomem(subreq, req)) {
 724                 return tevent_req_post(req, ev);
 725         }
 726         tevent_req_set_callback(subreq, tldap_search_paged_done, req);
 727
 728         return req;
 729 }
 730
 731 static void tldap_search_paged_done(struct tevent_req *subreq)
 732 {
 733         struct tevent_req *req = tevent_req_callback_data(
 734                 subreq, struct tevent_req);
 735         struct tldap_search_paged_state *state = tevent_req_data(
 736                 req, struct tldap_search_paged_state);
 737         struct asn1_data *asn1;
 738         struct tldap_control *pgctrl;
 739         int rc, size;
 740
 741         rc = tldap_search_recv(subreq, state, &state->result);
 742         if (rc != TLDAP_SUCCESS) {
 743                 TALLOC_FREE(subreq);
 744                 tevent_req_error(req, rc);
 745                 return;
 746         }
 747
 748         TALLOC_FREE(state->asn1);
 749
 750         switch (tldap_msg_type(state->result)) {
 751         case TLDAP_RES_SEARCH_ENTRY:
 752         case TLDAP_RES_SEARCH_REFERENCE:
 753                 tevent_req_notify_callback(req);
 754                 return;
 755         case TLDAP_RES_SEARCH_RESULT:
 756                 break;
 757         default:
 758                 TALLOC_FREE(subreq);
 759                 tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
 760                 return;
 761         }
 762
 763         TALLOC_FREE(subreq);
 764
 765         /* We've finished one paged search, fire the next */
 766
 767         pgctrl = tldap_msg_findcontrol(state->result,
 768                                        TLDAP_CONTROL_PAGEDRESULTS);
 769         if (pgctrl == NULL) {
 770                 /* RFC2696 requires the server to return the control */
 771                 tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
 772                 return;
 773         }
 774
 775         TALLOC_FREE(state->cookie.data);
 776
 777         asn1 = asn1_init(talloc_tos());
 778         if (asn1 == NULL) {
 779                 tevent_req_error(req, TLDAP_NO_MEMORY);
 780                 return;
 781         }
 782
 783         asn1_load_nocopy(asn1, pgctrl->value.data, pgctrl->value.length);
 784         asn1_start_tag(asn1, ASN1_SEQUENCE(0));
 785         asn1_read_Integer(asn1, &size);
 786         asn1_read_OctetString(asn1, state, &state->cookie);
 787         asn1_end_tag(asn1);
 788         if (asn1->has_error) {
 789                 tevent_req_error(req, TLDAP_DECODING_ERROR);
 790                 return;
 791         }
 792         TALLOC_FREE(asn1);
 793
 794         if (state->cookie.length == 0) {
 795                 /* We're done, no cookie anymore */
 796                 tevent_req_done(req);
 797                 return;
 798         }
 799
 800         TALLOC_FREE(state->result);
 801
 802         subreq = tldap_ship_paged_search(state, state);
 803         if (tevent_req_nomem(subreq, req)) {
 804                 return;
 805         }
 806         tevent_req_set_callback(subreq, tldap_search_paged_done, req);
 807 }
 808
 809 int tldap_search_paged_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 810                             struct tldap_message **pmsg)
 811 {
 812         struct tldap_search_paged_state *state = tevent_req_data(
 813                 req, struct tldap_search_paged_state);
 814         int err;
 815
 816         if (!tevent_req_is_in_progress(req)
 817             && tevent_req_is_ldap_error(req, &err)) {
 818                 return err;
 819         }
 820         if (tevent_req_is_in_progress(req)) {
 821                 switch (tldap_msg_type(state->result)) {
 822                 case TLDAP_RES_SEARCH_ENTRY:
 823                 case TLDAP_RES_SEARCH_REFERENCE:
 824                         break;
 825                 default:
 826                         return TLDAP_PROTOCOL_ERROR;
 827                 }
 828         }
 829         *pmsg = talloc_move(mem_ctx, &state->result);
 830         return TLDAP_SUCCESS;
 831 }