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