src/ptclib/pldap.cxx

   1 /*
   2  * pldap.cxx
   3  *
   4  * Lightweight Directory Access Protocol interface class.
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 1993-2003 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * Contributor(s): ______________________________________.
  25  *
  26  * $Log$
  27  * Revision 1.15  2004/02/23 23:52:19  csoutheren
  28  * Added pragmas to avoid every Windows application needing to include libs explicitly
  29  *
  30  * Revision 1.14  2004/02/04 09:37:00  rjongbloed
  31  * Fixed memory leak and race condition, thanks Rossano Ravelli
  32  *
  33  * Revision 1.13  2004/01/17 17:45:29  csoutheren
  34  * Changed to use PString::MakeEmpty
  35  *
  36  * Revision 1.12  2003/07/15 12:12:11  csoutheren
  37  * Added support for multiple values in a single attribute string
  38  *    Thanks to Ravelli Rossano
  39  *
  40  * Revision 1.11  2003/07/12 00:10:40  csoutheren
  41  * Fixed problem where Modify routines were calling Add, thanks to Ravelli Rossano
  42  *
  43  * Revision 1.10  2003/06/06 09:14:01  dsandras
  44  *
  45  * Test that a search result has been returned before calling ldapresult2error.
  46  *
  47  * Revision 1.9  2003/06/05 23:17:52  rjongbloed
  48  * Changed default operation timeout to 30 seconds.
  49  *
  50  * Revision 1.8  2003/06/05 05:29:30  rjongbloed
  51  * Fixed LDAP bind authentication methods, thanks Ravelli Rossano
  52  *
  53  * Revision 1.7  2003/04/17 08:34:48  robertj
  54  * Changed LDAP structure output so if field is empty it leaves it out
  55  *   altogether rather then encoding an empty string, some servers barf.
  56  *
  57  * Revision 1.6  2003/04/16 08:00:19  robertj
  58  * Windoes psuedo autoconf support
  59  *
  60  * Revision 1.5  2003/04/07 11:59:52  robertj
  61  * Fixed search function returning an error if can't find anything for filter.
  62  *
  63  * Revision 1.4  2003/04/01 07:05:16  robertj
  64  * Added ability to specify host:port in opening an LDAP server
  65  *
  66  * Revision 1.3  2003/03/31 03:32:53  robertj
  67  * Major addition of functionality.
  68  *
  69  */
  70
  71 #ifdef __GNUC__
  72 #pragma implementation "pldap.h"
  73 #endif
  74
  75 #include <ptlib.h>
  76
  77 #include <ptlib/sockets.h>
  78 #include <ptclib/pldap.h>
  79
  80 #if P_LDAP
  81
  82 #include <ldap.h>
  83
  84
  85 #if defined(_WIN32)
  86 #pragma comment(lib, P_LDAP_LIBRARY)
  87
  88 #ifdef _DEBUG
  89 #pragma comment(linker, "/delayload:openldapd.dll")
  90 #else
  91 #pragma comment(linker, "/delayload:openldap.dll")
  92 #endif
  93 #pragma comment(lib,    "Delayimp.lib")
  94 #endif
  95
  96 ///////////////////////////////////////////////////////////////////////////////
  97
  98 PLDAPSession::PLDAPSession(const PString & baseDN)
  99   : ldapContext(NULL),
 100     errorNumber(LDAP_SUCCESS),
 101     protocolVersion(LDAP_VERSION3),
 102     defaultBaseDN(baseDN),
 103     searchLimit(UINT_MAX),
 104     timeout(0, 30),
 105     multipleValueSeparator('\n')
 106 {
 107 }
 108
 109
 110 PLDAPSession::~PLDAPSession()
 111 {
 112   Close();
 113 }
 114
 115
 116 BOOL PLDAPSession::Open(const PString & server, WORD port)
 117 {
 118   Close();
 119
 120   PString host = server;
 121   PINDEX colon = server.Find(':');
 122   if (colon != P_MAX_INDEX) {
 123     host = server.Left(colon);
 124     port = PIPSocket::GetPortByService(server.Mid(colon+1), "tcp");
 125   }
 126
 127   ldapContext = ldap_init(server, port);
 128   if (!IsOpen())
 129     return FALSE;
 130
 131   SetOption(LDAP_OPT_PROTOCOL_VERSION, protocolVersion);
 132   return TRUE;
 133 }
 134
 135
 136 BOOL PLDAPSession::Close()
 137 {
 138   if (!IsOpen())
 139     return FALSE;
 140
 141   ldap_unbind(ldapContext);
 142   ldapContext = NULL;
 143   return TRUE;
 144 }
 145
 146
 147 BOOL PLDAPSession::SetOption(int optcode, int value)
 148 {
 149   if (!IsOpen())
 150     return FALSE;
 151
 152   return ldap_set_option(ldapContext, optcode, &value);
 153 }
 154
 155
 156 BOOL PLDAPSession::SetOption(int optcode, void * value)
 157 {
 158   if (!IsOpen())
 159     return FALSE;
 160
 161   return ldap_set_option(ldapContext, optcode, value);
 162 }
 163
 164
 165 BOOL PLDAPSession::Bind(const PString & who,
 166                         const PString & passwd,
 167                         AuthenticationMethod authMethod)
 168 {
 169   if (!IsOpen())
 170     return FALSE;
 171
 172   const char * whoPtr;
 173   if (who.IsEmpty())
 174     whoPtr = NULL;
 175   else
 176     whoPtr = who;
 177
 178   static const int AuthMethodCode[NumAuthenticationMethod] = {
 179     LDAP_AUTH_SIMPLE, LDAP_AUTH_SASL, LDAP_AUTH_KRBV4
 180   };
 181   errorNumber = ldap_bind_s(ldapContext, whoPtr, passwd, AuthMethodCode[authMethod]);
 182   return errorNumber == LDAP_SUCCESS;
 183 }
 184
 185
 186 PLDAPSession::ModAttrib::ModAttrib(const PString & n, Operation o)
 187   : name(n),
 188     op(o)
 189 {
 190 }
 191
 192
 193 void PLDAPSession::ModAttrib::SetLDAPMod(struct ldapmod & mod, Operation defaultOp)
 194 {
 195   mod.mod_type = (char *)(const char *)name;
 196
 197   Operation realOp = op == NumOperations ? defaultOp : op;
 198   static const int OpCode[NumOperations] = {
 199     LDAP_MOD_ADD, LDAP_MOD_REPLACE, LDAP_MOD_DELETE
 200   };
 201   mod.mod_op = OpCode[realOp];
 202
 203   if (IsBinary())
 204     mod.mod_op |= LDAP_MOD_BVALUES;
 205
 206   SetLDAPModVars(mod);
 207 }
 208
 209
 210 PLDAPSession::StringModAttrib::StringModAttrib(const PString & name,
 211                                                Operation op)
 212   : ModAttrib(name, op)
 213 {
 214 }
 215
 216
 217 PLDAPSession::StringModAttrib::StringModAttrib(const PString & name,
 218                                                const PString & value,
 219                                                Operation op)
 220   : ModAttrib(name, op)
 221 {
 222   AddValue(value);
 223 }
 224
 225
 226 PLDAPSession::StringModAttrib::StringModAttrib(const PString & name,
 227                                                const PStringList & vals,
 228                                                Operation op)
 229   : ModAttrib(name, op),
 230     values(vals)
 231 {
 232 }
 233
 234
 235 void PLDAPSession::StringModAttrib::SetValue(const PString & value)
 236 {
 237   values.RemoveAll();
 238   values.AppendString(value);
 239 }
 240
 241
 242 void PLDAPSession::StringModAttrib::AddValue(const PString & value)
 243 {
 244   values.AppendString(value);
 245 }
 246
 247
 248 BOOL PLDAPSession::StringModAttrib::IsBinary() const
 249 {
 250   return FALSE;
 251 }
 252
 253
 254 void PLDAPSession::StringModAttrib::SetLDAPModVars(struct ldapmod & mod)
 255 {
 256   pointers.SetSize(values.GetSize()+1);
 257   PINDEX i;
 258   for (i = 0; i < values.GetSize(); i++)
 259     pointers[i] = values[i].GetPointer();
 260   pointers[i] = NULL;
 261   mod.mod_values = pointers.GetPointer();
 262 }
 263
 264
 265 PLDAPSession::BinaryModAttrib::BinaryModAttrib(const PString & name,
 266                                                Operation op)
 267   : ModAttrib(name, op)
 268 {
 269 }
 270
 271
 272 PLDAPSession::BinaryModAttrib::BinaryModAttrib(const PString & name,
 273                                                const PBYTEArray & value,
 274                                                Operation op)
 275   : ModAttrib(name, op)
 276 {
 277   AddValue(value);
 278 }
 279
 280
 281 PLDAPSession::BinaryModAttrib::BinaryModAttrib(const PString & name,
 282                                                const PList<PBYTEArray> & vals,
 283                                                Operation op)
 284   : ModAttrib(name, op),
 285     values(vals)
 286 {
 287 }
 288
 289
 290 void PLDAPSession::BinaryModAttrib::SetValue(const PBYTEArray & value)
 291 {
 292   values.RemoveAll();
 293   values.Append(new PBYTEArray(value));
 294 }
 295
 296
 297 void PLDAPSession::BinaryModAttrib::AddValue(const PBYTEArray & value)
 298 {
 299   values.Append(new PBYTEArray(value));
 300 }
 301
 302
 303 BOOL PLDAPSession::BinaryModAttrib::IsBinary() const
 304 {
 305   return TRUE;
 306 }
 307
 308
 309 void PLDAPSession::BinaryModAttrib::SetLDAPModVars(struct ldapmod & mod)
 310 {
 311   pointers.SetSize(values.GetSize()+1);
 312   bervals.SetSize(values.GetSize()*sizeof(berval));
 313   berval * ber = (berval *)bervals.GetPointer();
 314   PINDEX i;
 315   for (i = 0; i < values.GetSize(); i++) {
 316     ber[i].bv_val = (char *)values[i].GetPointer();
 317     ber[i].bv_len = values[i].GetSize();
 318     pointers[i] = &ber[i];
 319   }
 320   pointers[i] = NULL;
 321   mod.mod_bvalues = pointers.GetPointer();
 322 }
 323
 324
 325 static LDAPMod ** CreateLDAPModArray(const PList<PLDAPSession::ModAttrib> & attributes,
 326                                      PLDAPSession::ModAttrib::Operation defaultOp,
 327                                      PBYTEArray & storage)
 328 {
 329   PINDEX count = attributes.GetSize();
 330   storage.SetSize(count*sizeof(LDAPMod) + (count+1)*sizeof(LDAPMod *));
 331
 332   LDAPMod ** attrs = (LDAPMod **)storage.GetPointer();
 333   LDAPMod *  attr  = (LDAPMod * )&attrs[count+1];
 334   for (PINDEX i = 0; i < count; i++) {
 335     attrs[i] = &attr[i];
 336     attributes[i].SetLDAPMod(attr[i], defaultOp);
 337   }
 338
 339   return attrs;
 340 }
 341
 342
 343 static PList<PLDAPSession::ModAttrib> AttribsFromDict(const PStringToString & attributes)
 344 {
 345   PList<PLDAPSession::ModAttrib> attrs;
 346
 347   for (PINDEX i = 0; i < attributes.GetSize(); i++)
 348     attrs.Append(new PLDAPSession::StringModAttrib(attributes.GetKeyAt(i),
 349                                                    attributes.GetDataAt(i).Lines()));
 350
 351   return attrs;
 352 }
 353
 354
 355 static PList<PLDAPSession::ModAttrib> AttribsFromArray(const PStringArray & attributes)
 356 {
 357   PList<PLDAPSession::ModAttrib> attrs;
 358
 359   for (PINDEX i = 0; i < attributes.GetSize(); i++) {
 360     PString attr = attributes[i];
 361     PINDEX equal = attr.Find('=');
 362     if (equal != P_MAX_INDEX)
 363       attrs.Append(new PLDAPSession::StringModAttrib(attr.Left(equal),
 364                                                      attr.Mid(equal+1).Lines()));
 365   }
 366
 367   return attrs;
 368 }
 369
 370
 371 static PList<PLDAPSession::ModAttrib> AttribsFromStruct(const PLDAPStructBase & attributes)
 372 {
 373   PList<PLDAPSession::ModAttrib> attrs;
 374
 375   for (PINDEX i = 0; i < attributes.GetNumAttributes(); i++) {
 376     PLDAPAttributeBase & attr = attributes.GetAttribute(i);
 377     if (attr.IsBinary())
 378       attrs.Append(new PLDAPSession::BinaryModAttrib(attr.GetName(), attr.ToBinary()));
 379     else {
 380       PString str = attr.ToString();
 381       if (!str)
 382         attrs.Append(new PLDAPSession::StringModAttrib(attr.GetName(), str));
 383     }
 384   }
 385
 386   return attrs;
 387 }
 388
 389
 390 BOOL PLDAPSession::Add(const PString & dn, const PList<ModAttrib> & attributes)
 391 {
 392   if (!IsOpen())
 393     return FALSE;
 394
 395   PBYTEArray storage;
 396   int msgid;
 397   errorNumber = ldap_add_ext(ldapContext,
 398                              dn,
 399                              CreateLDAPModArray(attributes, ModAttrib::Add, storage),
 400                              NULL,
 401                              NULL,
 402                              &msgid);
 403   if (errorNumber != LDAP_SUCCESS)
 404     return FALSE;
 405
 406   P_timeval tval = timeout;
 407   LDAPMessage * result = NULL;
 408   ldap_result(ldapContext, msgid, LDAP_MSG_ALL, tval, &result);
 409   if (result)
 410     errorNumber = ldap_result2error(ldapContext, result, TRUE);
 411
 412   return errorNumber == LDAP_SUCCESS;
 413 }
 414
 415
 416 BOOL PLDAPSession::Add(const PString & dn, const PStringToString & attributes)
 417 {
 418   return Add(dn, AttribsFromDict(attributes));
 419 }
 420
 421
 422 BOOL PLDAPSession::Add(const PString & dn, const PStringArray & attributes)
 423 {
 424   return Add(dn, AttribsFromArray(attributes));
 425 }
 426
 427
 428 BOOL PLDAPSession::Add(const PString & dn, const PLDAPStructBase & attributes)
 429 {
 430   return Add(dn, AttribsFromStruct(attributes));
 431 }
 432
 433
 434 BOOL PLDAPSession::Modify(const PString & dn, const PList<ModAttrib> & attributes)
 435 {
 436   if (!IsOpen())
 437     return FALSE;
 438
 439   PBYTEArray storage;
 440   int msgid;
 441   errorNumber = ldap_modify_ext(ldapContext,
 442                                 dn,
 443                                 CreateLDAPModArray(attributes, ModAttrib::Replace, storage),
 444                                 NULL,
 445                                 NULL,
 446                                 &msgid);
 447   if (errorNumber != LDAP_SUCCESS)
 448     return FALSE;
 449
 450   P_timeval tval = timeout;
 451   LDAPMessage * result = NULL;
 452   ldap_result(ldapContext, msgid, LDAP_MSG_ALL, tval, &result);
 453   if (result)
 454     errorNumber = ldap_result2error(ldapContext, result, TRUE);
 455
 456   return errorNumber == LDAP_SUCCESS;
 457 }
 458
 459
 460 BOOL PLDAPSession::Modify(const PString & dn, const PStringToString & attributes)
 461 {
 462   return Modify(dn, AttribsFromDict(attributes));
 463 }
 464
 465
 466 BOOL PLDAPSession::Modify(const PString & dn, const PStringArray & attributes)
 467 {
 468   return Modify(dn, AttribsFromArray(attributes));
 469 }
 470
 471
 472 BOOL PLDAPSession::Modify(const PString & dn, const PLDAPStructBase & attributes)
 473 {
 474   return Modify(dn, AttribsFromStruct(attributes));
 475 }
 476
 477
 478 BOOL PLDAPSession::Delete(const PString & dn)
 479 {
 480   if (!IsOpen())
 481     return FALSE;
 482
 483   int msgid;
 484   errorNumber = ldap_delete_ext(ldapContext, dn, NULL, NULL, &msgid);
 485   if (errorNumber != LDAP_SUCCESS)
 486     return FALSE;
 487
 488   P_timeval tval = timeout;
 489   LDAPMessage * result = NULL;
 490   ldap_result(ldapContext, msgid, LDAP_MSG_ALL, tval, &result);
 491   if (result)
 492     errorNumber = ldap_result2error(ldapContext, result, TRUE);
 493
 494   return errorNumber == LDAP_SUCCESS;
 495 }
 496
 497
 498 PLDAPSession::SearchContext::SearchContext()
 499 {
 500   result = NULL;
 501   message = NULL;
 502   found = FALSE;
 503   completed = FALSE;
 504 }
 505
 506
 507 PLDAPSession::SearchContext::~SearchContext()
 508 {
 509   if (message != NULL)
 510     ldap_msgfree(message);
 511
 512   if (result != NULL && result != message)
 513     ldap_msgfree(result);
 514 }
 515
 516
 517 BOOL PLDAPSession::Search(SearchContext & context,
 518                           const PString & filter,
 519                           const PStringArray & attributes,
 520                           const PString & baseDN,
 521                           SearchScope scope)
 522 {
 523   if (!IsOpen())
 524     return FALSE;
 525
 526   PCharArray storage;
 527   char ** attribs = attributes.ToCharArray(&storage);
 528
 529   PString base = baseDN;
 530   if (base.IsEmpty())
 531     base = defaultBaseDN;
 532
 533   static const int ScopeCode[NumSearchScope] = {
 534     LDAP_SCOPE_BASE, LDAP_SCOPE_ONELEVEL, LDAP_SCOPE_SUBTREE
 535   };
 536
 537   P_timeval tval = timeout;
 538
 539   errorNumber = ldap_search_ext(ldapContext,
 540                                 base,
 541                                 ScopeCode[scope],
 542                                 filter,
 543                                 attribs,
 544                                 FALSE,
 545                                 NULL,
 546                                 NULL,
 547                                 tval,
 548                                 searchLimit,
 549                                 &context.msgid);
 550
 551   if (errorNumber != LDAP_SUCCESS)
 552     return FALSE;
 553
 554   if (ldap_result(ldapContext, context.msgid, LDAP_MSG_ONE, tval, &context.result) > 0)
 555     return GetNextSearchResult(context);
 556
 557   if (context.result)
 558     errorNumber = ldap_result2error(ldapContext, context.result, TRUE);
 559   if (errorNumber == 0)
 560     errorNumber = LDAP_OTHER;
 561   return FALSE;
 562 }
 563
 564
 565 BOOL PLDAPSession::GetSearchResult(SearchContext & context, PStringToString & data)
 566 {
 567   data.RemoveAll();
 568
 569   if (!IsOpen())
 570     return FALSE;
 571
 572   if (context.result == NULL || context.message == NULL || context.completed)
 573     return FALSE;
 574
 575   // Extract the resulting data
 576
 577   data.SetAt("dn", GetSearchResultDN(context));
 578
 579   BerElement * ber = NULL;
 580   char * attrib = ldap_first_attribute(ldapContext, context.message, &ber);
 581   while (attrib != NULL) {
 582
 583     struct berval ** bvals = ldap_get_values_len(ldapContext, context.message, attrib);
 584     if (bvals != NULL) {
 585       PString value = data(attrib);
 586
 587       for (PINDEX i = 0; bvals[i] != NULL; i++ ) {
 588         if (!value)
 589           value += multipleValueSeparator;
 590         value += PString(bvals[i]->bv_val, bvals[i]->bv_len);
 591       }
 592       ber_bvecfree(bvals);
 593
 594       data.SetAt(attrib, value);
 595     }
 596
 597     ldap_memfree(attrib);
 598     attrib = ldap_next_attribute(ldapContext, context.message, ber);
 599   }
 600
 601   if (ber != NULL)
 602     ber_free (ber, 0);
 603
 604   return TRUE;
 605 }
 606
 607
 608 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 609                                    const PString & attribute,
 610                                    PString & data)
 611 {
 612   data.MakeEmpty();
 613
 614   if (!IsOpen())
 615     return FALSE;
 616
 617   if (context.result == NULL || context.message == NULL || context.completed)
 618     return FALSE;
 619
 620   if (attribute == "dn") {
 621     data = GetSearchResultDN(context);
 622     return TRUE;
 623   }
 624
 625   char ** values = ldap_get_values(ldapContext, context.message, attribute);
 626   if (values == NULL)
 627     return FALSE;
 628
 629   PINDEX count = ldap_count_values(values);
 630   for (PINDEX i = 0; i < count; i++) {
 631     if (!data)
 632       data += multipleValueSeparator;
 633     data += values[i];
 634   }
 635
 636   ldap_value_free(values);
 637   return TRUE;
 638 }
 639
 640
 641 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 642                                    const PString & attribute,
 643                                    PStringArray & data)
 644 {
 645   data.RemoveAll();
 646
 647   if (!IsOpen())
 648     return FALSE;
 649
 650   if (context.result == NULL || context.message == NULL || context.completed)
 651     return FALSE;
 652
 653   if (attribute == "dn") {
 654     data.SetSize(1);
 655     data[0] = GetSearchResultDN(context);
 656     return TRUE;
 657   }
 658
 659   char ** values = ldap_get_values(ldapContext, context.message, attribute);
 660   if (values == NULL)
 661     return FALSE;
 662
 663   PINDEX count = ldap_count_values(values);
 664   data.SetSize(count);
 665   for (PINDEX i = 0; i < count; i++)
 666     data[i] = values[i];
 667
 668   ldap_value_free(values);
 669   return TRUE;
 670 }
 671
 672
 673 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 674                                    const PString & attribute,
 675                                    PArray<PBYTEArray> & data)
 676 {
 677   data.RemoveAll();
 678
 679   if (!IsOpen())
 680     return FALSE;
 681
 682   if (attribute == "dn") {
 683     char * dn = ldap_get_dn(ldapContext, context.message);
 684     data.Append(new PBYTEArray((const BYTE *)dn, ::strlen(dn)));
 685     ldap_memfree(dn);
 686     return TRUE;
 687   }
 688
 689   struct berval ** values = ldap_get_values_len(ldapContext, context.message, attribute);
 690   if (values == NULL)
 691     return FALSE;
 692
 693   PINDEX count = ldap_count_values_len(values);
 694   data.SetSize(count);
 695   for (PINDEX i = 0; i < count; i++)
 696     data[i] = PBYTEArray((const BYTE *)values[i]->bv_val, values[i]->bv_len);
 697
 698   ldap_value_free_len(values);
 699   return TRUE;
 700 }
 701
 702
 703 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 704                                    PLDAPStructBase & data)
 705 {
 706   if (!IsOpen())
 707     return FALSE;
 708
 709   BOOL atLeastOne = FALSE;
 710
 711   for (PINDEX i = 0; i < data.GetNumAttributes(); i++) {
 712     PLDAPAttributeBase & attr = data.GetAttribute(i);
 713     if (attr.IsBinary()) {
 714       PArray<PBYTEArray> bin;
 715       if (GetSearchResult(context, attr.GetName(), bin)) {
 716         attr.FromBinary(bin);
 717         atLeastOne = TRUE;
 718       }
 719     }
 720     else {
 721       PString str;
 722       if (GetSearchResult(context, attr.GetName(), str)) {
 723         attr.FromString(str);
 724         atLeastOne = TRUE;
 725       }
 726     }
 727   }
 728
 729   return atLeastOne;
 730 }
 731
 732
 733 PString PLDAPSession::GetSearchResultDN(SearchContext & context)
 734 {
 735   PString str;
 736
 737   if (context.message != NULL) {
 738     char * dn = ldap_get_dn(ldapContext, context.message);
 739     if (dn != NULL) {
 740       str = dn;
 741       ldap_memfree(dn);
 742     }
 743   }
 744
 745   return str;
 746 }
 747
 748
 749 BOOL PLDAPSession::GetNextSearchResult(SearchContext & context)
 750 {
 751   if (!IsOpen())
 752     return FALSE;
 753
 754   if (context.result == NULL || context.completed)
 755     return FALSE;
 756
 757   P_timeval tval = timeout;
 758   do {
 759     if (context.message == NULL)
 760       context.message = ldap_first_message(ldapContext, context.result);
 761     else
 762       context.message = ldap_next_message(ldapContext, context.message);
 763
 764     if (context.message != NULL) {
 765       switch (ldap_msgtype(context.message)) {
 766         case LDAP_RES_SEARCH_ENTRY :
 767           context.found = TRUE;
 768           errorNumber = LDAP_SUCCESS;
 769           return TRUE;
 770
 771         case LDAP_RES_SEARCH_RESULT :
 772           errorNumber = ldap_result2error(ldapContext, context.message, FALSE);
 773           if (errorNumber == 0 && !context.found)
 774             errorNumber = LDAP_NO_RESULTS_RETURNED;
 775           context.completed = TRUE;
 776           return FALSE;
 777       }
 778       // Ignore other result message types for now ...
 779     }
 780
 781     ldap_msgfree(context.result);
 782   } while (ldap_result(ldapContext, context.msgid, LDAP_MSG_ONE, tval, &context.result) > 0);
 783
 784   if (context.result)
 785     errorNumber = ldap_result2error(ldapContext, context.result, FALSE);
 786   if (errorNumber == 0)
 787     errorNumber = LDAP_OTHER;
 788   return FALSE;
 789 }
 790
 791
 792 PList<PStringToString> PLDAPSession::Search(const PString & filter,
 793                                             const PStringArray & attributes,
 794                                             const PString & base,
 795                                             SearchScope scope)
 796 {
 797   PList<PStringToString> data;
 798
 799   SearchContext context;
 800   if (!Search(context, filter, attributes, base, scope))
 801     return data;
 802
 803   do {
 804     PStringToString * entry = new PStringToString;
 805     if (GetSearchResult(context, *entry))
 806       data.Append(entry);
 807     else {
 808       delete entry;
 809       break;
 810     }
 811   } while (GetNextSearchResult(context));
 812
 813   return data;
 814 }
 815
 816
 817 PString PLDAPSession::GetErrorText() const
 818 {
 819   return ldap_err2string(errorNumber);
 820 }
 821
 822
 823 ///////////////////////////////////////////////////////////////////////////////
 824
 825 PLDAPAttributeBase::PLDAPAttributeBase(const char * n, void * ptr, PINDEX sz)
 826   : name(n),
 827     pointer(ptr),
 828     size(sz)
 829 {
 830   PLDAPStructBase::GetInitialiser().AddAttribute(this);
 831 }
 832
 833
 834 PString PLDAPAttributeBase::ToString() const
 835 {
 836   PStringStream stream;
 837   PrintOn(stream);
 838   return stream;
 839 }
 840
 841
 842 void PLDAPAttributeBase::FromString(const PString & str)
 843 {
 844   PStringStream stream(str);
 845   ReadFrom(stream);
 846 }
 847
 848
 849 PBYTEArray PLDAPAttributeBase::ToBinary() const
 850 {
 851   return PBYTEArray((const BYTE *)pointer, size, FALSE);
 852 }
 853
 854
 855 void PLDAPAttributeBase::FromBinary(const PArray<PBYTEArray> & data)
 856 {
 857   if (data.GetSize() > 0 && data[0].GetSize() == size)
 858     memcpy(pointer, data[0], size);
 859 }
 860
 861
 862 ///////////////////////////////////////////////////////////////////////////////
 863
 864 PMutex            PLDAPStructBase::initialiserMutex;
 865 PLDAPStructBase * PLDAPStructBase::initialiserInstance;
 866
 867 PLDAPStructBase::PLDAPStructBase()
 868 {
 869   attributes.DisallowDeleteObjects();
 870
 871   initialiserMutex.Wait();
 872   initialiserStack = initialiserInstance;
 873   initialiserInstance = this;
 874 }
 875
 876
 877 PLDAPStructBase & PLDAPStructBase::operator=(const PLDAPStructBase & other)
 878 {
 879   for (PINDEX i = 0; i < attributes.GetSize(); i++)
 880     attributes.GetDataAt(i).Copy(other.attributes.GetDataAt(i));
 881
 882   return *this;
 883 }
 884
 885
 886 PLDAPStructBase & PLDAPStructBase::operator=(const PStringArray & array)
 887 {
 888   for (PINDEX i = 0; i < array.GetSize(); i++) {
 889     PString str = array[i];
 890     PINDEX equal = str.Find('=');
 891     if (equal != P_MAX_INDEX) {
 892       PLDAPAttributeBase * attr = GetAttribute(str.Left(equal));
 893       if (attr != NULL)
 894         attr->FromString(str.Mid(equal+1));
 895     }
 896   }
 897   return *this;
 898 }
 899
 900
 901 PLDAPStructBase & PLDAPStructBase::operator=(const PStringToString & dict)
 902 {
 903   for (PINDEX i = 0; i < dict.GetSize(); i++) {
 904     PLDAPAttributeBase * attr = GetAttribute(dict.GetKeyAt(i));
 905     if (attr != NULL)
 906       attr->FromString(dict.GetDataAt(i));
 907   }
 908   return *this;
 909 }
 910
 911
 912 void PLDAPStructBase::PrintOn(ostream & strm) const
 913 {
 914   strm << attributes << '\n';
 915 }
 916
 917
 918 void PLDAPStructBase::AddAttribute(PLDAPAttributeBase * attr)
 919 {
 920   attributes.SetAt(attr->GetName(), attr);
 921 }
 922
 923
 924 void PLDAPStructBase::EndConstructor()
 925 {
 926   initialiserInstance = initialiserStack;
 927   initialiserMutex.Signal();
 928 }
 929
 930
 931 #endif // P_LDAP
 932
 933
 934 // End of file ////////////////////////////////////////////////////////////////
 935