lib/openldap.c

   1 /***************************************************************************
   2  *                      _   _ ____  _
   3  *  Project         ___| | | |  _ \| |
   4  *                 / __| | | | |_) | |
   5  *                | (__| |_| |  _ <| |___
   6  *                 \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 2010, Howard Chu, <hyc@openldap.org>
   9  * Copyright (C) 2011 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
  10  *
  11  * This software is licensed as described in the file COPYING, which
  12  * you should have received as part of this distribution. The terms
  13  * are also available at https://curl.haxx.se/docs/copyright.html.
  14  *
  15  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  16  * copies of the Software, and permit persons to whom the Software is
  17  * furnished to do so, under the terms of the COPYING file.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ***************************************************************************/
  23
  24 #include "curl_setup.h"
  25
  26 #if !defined(CURL_DISABLE_LDAP) && defined(USE_OPENLDAP)
  27
  28 /*
  29  * Notice that USE_OPENLDAP is only a source code selection switch. When
  30  * libcurl is built with USE_OPENLDAP defined the libcurl source code that
  31  * gets compiled is the code from openldap.c, otherwise the code that gets
  32  * compiled is the code from ldap.c.
  33  *
  34  * When USE_OPENLDAP is defined a recent version of the OpenLDAP library
  35  * might be required for compilation and runtime. In order to use ancient
  36  * OpenLDAP library versions, USE_OPENLDAP shall not be defined.
  37  */
  38
  39 #include <ldap.h>
  40
  41 #include "urldata.h"
  42 #include <curl/curl.h>
  43 #include "sendf.h"
  44 #include "vtls/vtls.h"
  45 #include "transfer.h"
  46 #include "curl_ldap.h"
  47 #include "curl_base64.h"
  48 #include "connect.h"
  49 /* The last 3 #include files should be in this order */
  50 #include "curl_printf.h"
  51 #include "curl_memory.h"
  52 #include "memdebug.h"
  53
  54 #ifndef _LDAP_PVT_H
  55 extern int ldap_pvt_url_scheme2proto(const char *);
  56 extern int ldap_init_fd(ber_socket_t fd, int proto, const char *url,
  57                         LDAP **ld);
  58 #endif
  59
  60 static CURLcode ldap_setup_connection(struct connectdata *conn);
  61 static CURLcode ldap_do(struct connectdata *conn, bool *done);
  62 static CURLcode ldap_done(struct connectdata *conn, CURLcode, bool);
  63 static CURLcode ldap_connect(struct connectdata *conn, bool *done);
  64 static CURLcode ldap_connecting(struct connectdata *conn, bool *done);
  65 static CURLcode ldap_disconnect(struct connectdata *conn, bool dead);
  66
  67 static Curl_recv ldap_recv;
  68
  69 /*
  70  * LDAP protocol handler.
  71  */
  72
  73 const struct Curl_handler Curl_handler_ldap = {
  74   "LDAP",                               /* scheme */
  75   ldap_setup_connection,                /* setup_connection */
  76   ldap_do,                              /* do_it */
  77   ldap_done,                            /* done */
  78   ZERO_NULL,                            /* do_more */
  79   ldap_connect,                         /* connect_it */
  80   ldap_connecting,                      /* connecting */
  81   ZERO_NULL,                            /* doing */
  82   ZERO_NULL,                            /* proto_getsock */
  83   ZERO_NULL,                            /* doing_getsock */
  84   ZERO_NULL,                            /* domore_getsock */
  85   ZERO_NULL,                            /* perform_getsock */
  86   ldap_disconnect,                      /* disconnect */
  87   ZERO_NULL,                            /* readwrite */
  88   PORT_LDAP,                            /* defport */
  89   CURLPROTO_LDAP,                       /* protocol */
  90   PROTOPT_NONE                          /* flags */
  91 };
  92
  93 #ifdef USE_SSL
  94 /*
  95  * LDAPS protocol handler.
  96  */
  97
  98 const struct Curl_handler Curl_handler_ldaps = {
  99   "LDAPS",                              /* scheme */
 100   ldap_setup_connection,                /* setup_connection */
 101   ldap_do,                              /* do_it */
 102   ldap_done,                            /* done */
 103   ZERO_NULL,                            /* do_more */
 104   ldap_connect,                         /* connect_it */
 105   ldap_connecting,                      /* connecting */
 106   ZERO_NULL,                            /* doing */
 107   ZERO_NULL,                            /* proto_getsock */
 108   ZERO_NULL,                            /* doing_getsock */
 109   ZERO_NULL,                            /* domore_getsock */
 110   ZERO_NULL,                            /* perform_getsock */
 111   ldap_disconnect,                      /* disconnect */
 112   ZERO_NULL,                            /* readwrite */
 113   PORT_LDAPS,                           /* defport */
 114   CURLPROTO_LDAP,                       /* protocol */
 115   PROTOPT_SSL                           /* flags */
 116 };
 117 #endif
 118
 119 static const char *url_errs[] = {
 120   "success",
 121   "out of memory",
 122   "bad parameter",
 123   "unrecognized scheme",
 124   "unbalanced delimiter",
 125   "bad URL",
 126   "bad host or port",
 127   "bad or missing attributes",
 128   "bad or missing scope",
 129   "bad or missing filter",
 130   "bad or missing extensions"
 131 };
 132
 133 typedef struct ldapconninfo {
 134   LDAP *ld;
 135   Curl_recv *recv;  /* for stacking SSL handler */
 136   Curl_send *send;
 137   int proto;
 138   int msgid;
 139   bool ssldone;
 140   bool sslinst;
 141   bool didbind;
 142 } ldapconninfo;
 143
 144 typedef struct ldapreqinfo {
 145   int msgid;
 146   int nument;
 147 } ldapreqinfo;
 148
 149 static CURLcode ldap_setup_connection(struct connectdata *conn)
 150 {
 151   ldapconninfo *li;
 152   LDAPURLDesc *lud;
 153   struct Curl_easy *data=conn->data;
 154   int rc, proto;
 155   CURLcode status;
 156
 157   rc = ldap_url_parse(data->change.url, &lud);
 158   if(rc != LDAP_URL_SUCCESS) {
 159     const char *msg = "url parsing problem";
 160     status = CURLE_URL_MALFORMAT;
 161     if(rc > LDAP_URL_SUCCESS && rc <= LDAP_URL_ERR_BADEXTS) {
 162       if(rc == LDAP_URL_ERR_MEM)
 163         status = CURLE_OUT_OF_MEMORY;
 164       msg = url_errs[rc];
 165     }
 166     failf(conn->data, "LDAP local: %s", msg);
 167     return status;
 168   }
 169   proto = ldap_pvt_url_scheme2proto(lud->lud_scheme);
 170   ldap_free_urldesc(lud);
 171
 172   li = calloc(1, sizeof(ldapconninfo));
 173   if(!li)
 174     return CURLE_OUT_OF_MEMORY;
 175   li->proto = proto;
 176   conn->proto.generic = li;
 177   connkeep(conn, "OpenLDAP default");
 178   /* TODO:
 179    * - provide option to choose SASL Binds instead of Simple
 180    */
 181   return CURLE_OK;
 182 }
 183
 184 #ifdef USE_SSL
 185 static Sockbuf_IO ldapsb_tls;
 186 #endif
 187
 188 static CURLcode ldap_connect(struct connectdata *conn, bool *done)
 189 {
 190   ldapconninfo *li = conn->proto.generic;
 191   struct Curl_easy *data = conn->data;
 192   int rc, proto = LDAP_VERSION3;
 193   char hosturl[1024];
 194   char *ptr;
 195
 196   (void)done;
 197
 198   strcpy(hosturl, "ldap");
 199   ptr = hosturl+4;
 200   if(conn->handler->flags & PROTOPT_SSL)
 201     *ptr++ = 's';
 202   snprintf(ptr, sizeof(hosturl)-(ptr-hosturl), "://%s:%d",
 203     conn->host.name, conn->remote_port);
 204
 205   rc = ldap_init_fd(conn->sock[FIRSTSOCKET], li->proto, hosturl, &li->ld);
 206   if(rc) {
 207     failf(data, "LDAP local: Cannot connect to %s, %s",
 208           hosturl, ldap_err2string(rc));
 209     return CURLE_COULDNT_CONNECT;
 210   }
 211
 212   ldap_set_option(li->ld, LDAP_OPT_PROTOCOL_VERSION, &proto);
 213
 214 #ifdef USE_SSL
 215   if(conn->handler->flags & PROTOPT_SSL) {
 216     CURLcode result;
 217     result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &li->ssldone);
 218     if(result)
 219       return result;
 220   }
 221 #endif
 222
 223   return CURLE_OK;
 224 }
 225
 226 static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
 227 {
 228   ldapconninfo *li = conn->proto.generic;
 229   struct Curl_easy *data = conn->data;
 230   LDAPMessage *msg = NULL;
 231   struct timeval tv = {0, 1}, *tvp;
 232   int rc, err;
 233   char *info = NULL;
 234
 235 #ifdef USE_SSL
 236   if(conn->handler->flags & PROTOPT_SSL) {
 237     /* Is the SSL handshake complete yet? */
 238     if(!li->ssldone) {
 239       CURLcode result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET,
 240                                                      &li->ssldone);
 241       if(result || !li->ssldone)
 242         return result;
 243     }
 244
 245     /* Have we installed the libcurl SSL handlers into the sockbuf yet? */
 246     if(!li->sslinst) {
 247       Sockbuf *sb;
 248       ldap_get_option(li->ld, LDAP_OPT_SOCKBUF, &sb);
 249       ber_sockbuf_add_io(sb, &ldapsb_tls, LBER_SBIOD_LEVEL_TRANSPORT, conn);
 250       li->sslinst = TRUE;
 251       li->recv = conn->recv[FIRSTSOCKET];
 252       li->send = conn->send[FIRSTSOCKET];
 253     }
 254   }
 255 #endif
 256
 257   tvp = &tv;
 258
 259 retry:
 260   if(!li->didbind) {
 261     char *binddn;
 262     struct berval passwd;
 263
 264     if(conn->bits.user_passwd) {
 265       binddn = conn->user;
 266       passwd.bv_val = conn->passwd;
 267       passwd.bv_len = strlen(passwd.bv_val);
 268     }
 269     else {
 270       binddn = NULL;
 271       passwd.bv_val = NULL;
 272       passwd.bv_len = 0;
 273     }
 274     rc = ldap_sasl_bind(li->ld, binddn, LDAP_SASL_SIMPLE, &passwd,
 275                         NULL, NULL, &li->msgid);
 276     if(rc)
 277       return CURLE_LDAP_CANNOT_BIND;
 278     li->didbind = TRUE;
 279     if(tvp)
 280       return CURLE_OK;
 281   }
 282
 283   rc = ldap_result(li->ld, li->msgid, LDAP_MSG_ONE, tvp, &msg);
 284   if(rc < 0) {
 285     failf(data, "LDAP local: bind ldap_result %s", ldap_err2string(rc));
 286     return CURLE_LDAP_CANNOT_BIND;
 287   }
 288   if(rc == 0) {
 289     /* timed out */
 290     return CURLE_OK;
 291   }
 292
 293   rc = ldap_parse_result(li->ld, msg, &err, NULL, &info, NULL, NULL, 1);
 294   if(rc) {
 295     failf(data, "LDAP local: bind ldap_parse_result %s", ldap_err2string(rc));
 296     return CURLE_LDAP_CANNOT_BIND;
 297   }
 298
 299   /* Try to fallback to LDAPv2? */
 300   if(err == LDAP_PROTOCOL_ERROR) {
 301     int proto;
 302     ldap_get_option(li->ld, LDAP_OPT_PROTOCOL_VERSION, &proto);
 303     if(proto == LDAP_VERSION3) {
 304       if(info) {
 305         ldap_memfree(info);
 306         info = NULL;
 307       }
 308       proto = LDAP_VERSION2;
 309       ldap_set_option(li->ld, LDAP_OPT_PROTOCOL_VERSION, &proto);
 310       li->didbind = FALSE;
 311       goto retry;
 312     }
 313   }
 314
 315   if(err) {
 316     failf(data, "LDAP remote: bind failed %s %s", ldap_err2string(rc),
 317           info ? info : "");
 318     if(info)
 319       ldap_memfree(info);
 320     return CURLE_LOGIN_DENIED;
 321   }
 322
 323   if(info)
 324     ldap_memfree(info);
 325   conn->recv[FIRSTSOCKET] = ldap_recv;
 326   *done = TRUE;
 327
 328   return CURLE_OK;
 329 }
 330
 331 static CURLcode ldap_disconnect(struct connectdata *conn, bool dead_connection)
 332 {
 333   ldapconninfo *li = conn->proto.generic;
 334   (void) dead_connection;
 335
 336   if(li) {
 337     if(li->ld) {
 338       ldap_unbind_ext(li->ld, NULL, NULL);
 339       li->ld = NULL;
 340     }
 341     conn->proto.generic = NULL;
 342     free(li);
 343   }
 344   return CURLE_OK;
 345 }
 346
 347 static CURLcode ldap_do(struct connectdata *conn, bool *done)
 348 {
 349   ldapconninfo *li = conn->proto.generic;
 350   ldapreqinfo *lr;
 351   CURLcode status = CURLE_OK;
 352   int rc = 0;
 353   LDAPURLDesc *ludp = NULL;
 354   int msgid;
 355   struct Curl_easy *data=conn->data;
 356
 357   connkeep(conn, "OpenLDAP do");
 358
 359   infof(data, "LDAP local: %s\n", data->change.url);
 360
 361   rc = ldap_url_parse(data->change.url, &ludp);
 362   if(rc != LDAP_URL_SUCCESS) {
 363     const char *msg = "url parsing problem";
 364     status = CURLE_URL_MALFORMAT;
 365     if(rc > LDAP_URL_SUCCESS && rc <= LDAP_URL_ERR_BADEXTS) {
 366       if(rc == LDAP_URL_ERR_MEM)
 367         status = CURLE_OUT_OF_MEMORY;
 368       msg = url_errs[rc];
 369     }
 370     failf(conn->data, "LDAP local: %s", msg);
 371     return status;
 372   }
 373
 374   rc = ldap_search_ext(li->ld, ludp->lud_dn, ludp->lud_scope,
 375                        ludp->lud_filter, ludp->lud_attrs, 0,
 376                        NULL, NULL, NULL, 0, &msgid);
 377   ldap_free_urldesc(ludp);
 378   if(rc != LDAP_SUCCESS) {
 379     failf(data, "LDAP local: ldap_search_ext %s", ldap_err2string(rc));
 380     return CURLE_LDAP_SEARCH_FAILED;
 381   }
 382   lr = calloc(1, sizeof(ldapreqinfo));
 383   if(!lr)
 384     return CURLE_OUT_OF_MEMORY;
 385   lr->msgid = msgid;
 386   data->req.protop = lr;
 387   Curl_setup_transfer(conn, FIRSTSOCKET, -1, FALSE, NULL, -1, NULL);
 388   *done = TRUE;
 389   return CURLE_OK;
 390 }
 391
 392 static CURLcode ldap_done(struct connectdata *conn, CURLcode res,
 393                           bool premature)
 394 {
 395   ldapreqinfo *lr = conn->data->req.protop;
 396
 397   (void)res;
 398   (void)premature;
 399
 400   if(lr) {
 401     /* if there was a search in progress, abandon it */
 402     if(lr->msgid) {
 403       ldapconninfo *li = conn->proto.generic;
 404       ldap_abandon_ext(li->ld, lr->msgid, NULL, NULL);
 405       lr->msgid = 0;
 406     }
 407     conn->data->req.protop = NULL;
 408     free(lr);
 409   }
 410
 411   return CURLE_OK;
 412 }
 413
 414 static ssize_t ldap_recv(struct connectdata *conn, int sockindex, char *buf,
 415                          size_t len, CURLcode *err)
 416 {
 417   ldapconninfo *li = conn->proto.generic;
 418   struct Curl_easy *data = conn->data;
 419   ldapreqinfo *lr = data->req.protop;
 420   int rc, ret;
 421   LDAPMessage *msg = NULL;
 422   LDAPMessage *ent;
 423   BerElement *ber = NULL;
 424   struct timeval tv = {0, 1};
 425
 426   (void)len;
 427   (void)buf;
 428   (void)sockindex;
 429
 430   rc = ldap_result(li->ld, lr->msgid, LDAP_MSG_RECEIVED, &tv, &msg);
 431   if(rc < 0) {
 432     failf(data, "LDAP local: search ldap_result %s", ldap_err2string(rc));
 433     *err = CURLE_RECV_ERROR;
 434     return -1;
 435   }
 436
 437   *err = CURLE_AGAIN;
 438   ret = -1;
 439
 440   /* timed out */
 441   if(!msg)
 442     return ret;
 443
 444   for(ent = ldap_first_message(li->ld, msg); ent;
 445     ent = ldap_next_message(li->ld, ent)) {
 446     struct berval bv, *bvals, **bvp = &bvals;
 447     int binary = 0, msgtype;
 448     CURLcode writeerr;
 449
 450     msgtype = ldap_msgtype(ent);
 451     if(msgtype == LDAP_RES_SEARCH_RESULT) {
 452       int code;
 453       char *info = NULL;
 454       rc = ldap_parse_result(li->ld, ent, &code, NULL, &info, NULL, NULL, 0);
 455       if(rc) {
 456         failf(data, "LDAP local: search ldap_parse_result %s",
 457               ldap_err2string(rc));
 458         *err = CURLE_LDAP_SEARCH_FAILED;
 459       }
 460       else if(code && code != LDAP_SIZELIMIT_EXCEEDED) {
 461         failf(data, "LDAP remote: search failed %s %s", ldap_err2string(rc),
 462               info ? info : "");
 463         *err = CURLE_LDAP_SEARCH_FAILED;
 464       }
 465       else {
 466         /* successful */
 467         if(code == LDAP_SIZELIMIT_EXCEEDED)
 468           infof(data, "There are more than %d entries\n", lr->nument);
 469         data->req.size = data->req.bytecount;
 470         *err = CURLE_OK;
 471         ret = 0;
 472       }
 473       lr->msgid = 0;
 474       ldap_memfree(info);
 475       break;
 476     }
 477     else if(msgtype != LDAP_RES_SEARCH_ENTRY)
 478       continue;
 479
 480     lr->nument++;
 481     rc = ldap_get_dn_ber(li->ld, ent, &ber, &bv);
 482     if(rc < 0) {
 483       /* TODO: verify that this is really how this return code should be
 484          handled */
 485       *err = CURLE_RECV_ERROR;
 486       return -1;
 487     }
 488     writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"DN: ", 4);
 489     if(writeerr) {
 490       *err = writeerr;
 491       return -1;
 492     }
 493
 494     writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val,
 495                                  bv.bv_len);
 496     if(writeerr) {
 497       *err = writeerr;
 498       return -1;
 499     }
 500
 501     writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 1);
 502     if(writeerr) {
 503       *err = writeerr;
 504       return -1;
 505     }
 506     data->req.bytecount += bv.bv_len + 5;
 507
 508     for(rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, bvp);
 509       rc == LDAP_SUCCESS;
 510       rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, bvp)) {
 511       int i;
 512
 513       if(bv.bv_val == NULL) break;
 514
 515       if(bv.bv_len > 7 && !strncmp(bv.bv_val + bv.bv_len - 7, ";binary", 7))
 516         binary = 1;
 517       else
 518         binary = 0;
 519
 520       for(i=0; bvals[i].bv_val != NULL; i++) {
 521         int binval = 0;
 522         writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\t", 1);
 523         if(writeerr) {
 524           *err = writeerr;
 525           return -1;
 526         }
 527
 528        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val,
 529                                     bv.bv_len);
 530        if(writeerr) {
 531          *err = writeerr;
 532          return -1;
 533        }
 534
 535         writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)":", 1);
 536        if(writeerr) {
 537          *err = writeerr;
 538          return -1;
 539        }
 540         data->req.bytecount += bv.bv_len + 2;
 541
 542         if(!binary) {
 543           /* check for leading or trailing whitespace */
 544           if(ISSPACE(bvals[i].bv_val[0]) ||
 545               ISSPACE(bvals[i].bv_val[bvals[i].bv_len-1]))
 546             binval = 1;
 547           else {
 548             /* check for unprintable characters */
 549             unsigned int j;
 550             for(j=0; j<bvals[i].bv_len; j++)
 551               if(!ISPRINT(bvals[i].bv_val[j])) {
 552                 binval = 1;
 553                 break;
 554               }
 555           }
 556         }
 557         if(binary || binval) {
 558           char *val_b64 = NULL;
 559           size_t val_b64_sz = 0;
 560           /* Binary value, encode to base64. */
 561           CURLcode error = Curl_base64_encode(data,
 562                                               bvals[i].bv_val,
 563                                               bvals[i].bv_len,
 564                                               &val_b64,
 565                                               &val_b64_sz);
 566           if(error) {
 567             ber_memfree(bvals);
 568             ber_free(ber, 0);
 569             ldap_msgfree(msg);
 570             *err = error;
 571             return -1;
 572           }
 573           writeerr = Curl_client_write(conn, CLIENTWRITE_BODY,
 574                                        (char *)": ", 2);
 575           if(writeerr) {
 576             *err = writeerr;
 577             return -1;
 578           }
 579
 580           data->req.bytecount += 2;
 581           if(val_b64_sz > 0) {
 582             writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, val_b64,
 583                                      val_b64_sz);
 584             if(writeerr) {
 585               *err = writeerr;
 586               return -1;
 587             }
 588             free(val_b64);
 589             data->req.bytecount += val_b64_sz;
 590           }
 591         }
 592         else {
 593           writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)" ", 1);
 594           if(writeerr) {
 595             *err = writeerr;
 596             return -1;
 597           }
 598
 599           writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, bvals[i].bv_val,
 600                                        bvals[i].bv_len);
 601           if(writeerr) {
 602             *err = writeerr;
 603             return -1;
 604           }
 605
 606           data->req.bytecount += bvals[i].bv_len + 1;
 607         }
 608         writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
 609         if(writeerr) {
 610           *err = writeerr;
 611           return -1;
 612         }
 613
 614         data->req.bytecount++;
 615       }
 616       ber_memfree(bvals);
 617       writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
 618       if(writeerr) {
 619         *err = writeerr;
 620         return -1;
 621       }
 622       data->req.bytecount++;
 623     }
 624     writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
 625     if(writeerr) {
 626       *err = writeerr;
 627       return -1;
 628     }
 629     data->req.bytecount++;
 630     ber_free(ber, 0);
 631   }
 632   ldap_msgfree(msg);
 633   return ret;
 634 }
 635
 636 #ifdef USE_SSL
 637 static int
 638 ldapsb_tls_setup(Sockbuf_IO_Desc *sbiod, void *arg)
 639 {
 640   sbiod->sbiod_pvt = arg;
 641   return 0;
 642 }
 643
 644 static int
 645 ldapsb_tls_remove(Sockbuf_IO_Desc *sbiod)
 646 {
 647   sbiod->sbiod_pvt = NULL;
 648   return 0;
 649 }
 650
 651 /* We don't need to do anything because libcurl does it already */
 652 static int
 653 ldapsb_tls_close(Sockbuf_IO_Desc *sbiod)
 654 {
 655   (void)sbiod;
 656   return 0;
 657 }
 658
 659 static int
 660 ldapsb_tls_ctrl(Sockbuf_IO_Desc *sbiod, int opt, void *arg)
 661 {
 662   (void)arg;
 663   if(opt == LBER_SB_OPT_DATA_READY) {
 664     struct connectdata *conn = sbiod->sbiod_pvt;
 665     return Curl_ssl_data_pending(conn, FIRSTSOCKET);
 666   }
 667   return 0;
 668 }
 669
 670 static ber_slen_t
 671 ldapsb_tls_read(Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 672 {
 673   struct connectdata *conn = sbiod->sbiod_pvt;
 674   ldapconninfo *li = conn->proto.generic;
 675   ber_slen_t ret;
 676   CURLcode err = CURLE_RECV_ERROR;
 677
 678   ret = li->recv(conn, FIRSTSOCKET, buf, len, &err);
 679   if(ret < 0 && err == CURLE_AGAIN) {
 680     SET_SOCKERRNO(EWOULDBLOCK);
 681   }
 682   return ret;
 683 }
 684
 685 static ber_slen_t
 686 ldapsb_tls_write(Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 687 {
 688   struct connectdata *conn = sbiod->sbiod_pvt;
 689   ldapconninfo *li = conn->proto.generic;
 690   ber_slen_t ret;
 691   CURLcode err = CURLE_SEND_ERROR;
 692
 693   ret = li->send(conn, FIRSTSOCKET, buf, len, &err);
 694   if(ret < 0 && err == CURLE_AGAIN) {
 695     SET_SOCKERRNO(EWOULDBLOCK);
 696   }
 697   return ret;
 698 }
 699
 700 static Sockbuf_IO ldapsb_tls =
 701 {
 702   ldapsb_tls_setup,
 703   ldapsb_tls_remove,
 704   ldapsb_tls_ctrl,
 705   ldapsb_tls_read,
 706   ldapsb_tls_write,
 707   ldapsb_tls_close
 708 };
 709 #endif /* USE_SSL */
 710
 711 #endif /* !CURL_DISABLE_LDAP && USE_OPENLDAP */