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.23  2007/09/08 11:34:28  rjongbloed
  28  * Improved memory checking (leaks etc), especially when using MSVC debug library.
  29  *
  30  * Revision 1.22  2007/07/19 15:05:36  shorne
  31  * Added Factory loaded LDAP schemas
  32  *
  33  * Revision 1.21  2007/04/20 07:23:53  csoutheren
  34  * Applied 1703646 - Fixed behaviour of PLDAPSession::GetSearchResult
  35  * Thanks to Fabrizio Ammollo
  36  *
  37  * Revision 1.20  2006/01/16 19:52:05  dsandras
  38  * Applied patch from Brian Lu <brian lu sun com> to allow compilation on
  39  * Solaris using SUN's LDAP. Thanks!!
  40  *
  41  * Revision 1.19  2005/09/18 13:01:43  dominance
  42  * fixed pragma warnings when building with gcc.
  43  *
  44  * Revision 1.18  2005/08/31 15:21:34  dominance
  45  * fix building with recent OpenLDAP
  46  *
  47  * Revision 1.17  2004/05/24 12:02:49  csoutheren
  48  * Add function to permit setting a limit on the number of results returned
  49  * from an LDAP query. Change the default number of results to unlimited,
  50  * rather than MAX_INT which apparently is clamped to some arbitrary low value.
  51  * Thanks to Damien Sandras
  52  *
  53  * Revision 1.16  2004/04/09 06:52:17  rjongbloed
  54  * Removed #pargma linker command for /delayload of DLL as documentations sais that
  55  *   you cannot do this.
  56  *
  57  * Revision 1.15  2004/02/23 23:52:19  csoutheren
  58  * Added pragmas to avoid every Windows application needing to include libs explicitly
  59  *
  60  * Revision 1.14  2004/02/04 09:37:00  rjongbloed
  61  * Fixed memory leak and race condition, thanks Rossano Ravelli
  62  *
  63  * Revision 1.13  2004/01/17 17:45:29  csoutheren
  64  * Changed to use PString::MakeEmpty
  65  *
  66  * Revision 1.12  2003/07/15 12:12:11  csoutheren
  67  * Added support for multiple values in a single attribute string
  68  *    Thanks to Ravelli Rossano
  69  *
  70  * Revision 1.11  2003/07/12 00:10:40  csoutheren
  71  * Fixed problem where Modify routines were calling Add, thanks to Ravelli Rossano
  72  *
  73  * Revision 1.10  2003/06/06 09:14:01  dsandras
  74  *
  75  * Test that a search result has been returned before calling ldapresult2error.
  76  *
  77  * Revision 1.9  2003/06/05 23:17:52  rjongbloed
  78  * Changed default operation timeout to 30 seconds.
  79  *
  80  * Revision 1.8  2003/06/05 05:29:30  rjongbloed
  81  * Fixed LDAP bind authentication methods, thanks Ravelli Rossano
  82  *
  83  * Revision 1.7  2003/04/17 08:34:48  robertj
  84  * Changed LDAP structure output so if field is empty it leaves it out
  85  *   altogether rather then encoding an empty string, some servers barf.
  86  *
  87  * Revision 1.6  2003/04/16 08:00:19  robertj
  88  * Windoes psuedo autoconf support
  89  *
  90  * Revision 1.5  2003/04/07 11:59:52  robertj
  91  * Fixed search function returning an error if can't find anything for filter.
  92  *
  93  * Revision 1.4  2003/04/01 07:05:16  robertj
  94  * Added ability to specify host:port in opening an LDAP server
  95  *
  96  * Revision 1.3  2003/03/31 03:32:53  robertj
  97  * Major addition of functionality.
  98  *
  99  */
 100
 101 #ifdef __GNUC__
 102 #pragma implementation "pldap.h"
 103 #endif
 104
 105 #include <ptlib.h>
 106
 107 #include <ptlib/sockets.h>
 108 #include <ptclib/pldap.h>
 109
 110 #define new PNEW
 111
 112
 113 #if P_LDAP
 114
 115 #define LDAP_DEPRECATED 1
 116 #include <ldap.h>
 117
 118
 119 #if defined(_MSC_VER)
 120 #pragma comment(lib, P_LDAP_LIBRARY)
 121 #endif
 122
 123 ///////////////////////////////////////////////////////////////////////////////
 124
 125 PLDAPSession::PLDAPSession(const PString & baseDN)
 126   : ldapContext(NULL),
 127     errorNumber(LDAP_SUCCESS),
 128     protocolVersion(LDAP_VERSION3),
 129     defaultBaseDN(baseDN),
 130     searchLimit(0),
 131     timeout(0, 30),
 132     multipleValueSeparator('\n')
 133 {
 134 }
 135
 136
 137 PLDAPSession::~PLDAPSession()
 138 {
 139   Close();
 140 }
 141
 142
 143 BOOL PLDAPSession::Open(const PString & server, WORD port)
 144 {
 145   Close();
 146
 147   PString host = server;
 148   PINDEX colon = server.Find(':');
 149   if (colon != P_MAX_INDEX) {
 150     host = server.Left(colon);
 151     port = PIPSocket::GetPortByService(server.Mid(colon+1), "tcp");
 152   }
 153
 154   ldapContext = ldap_init(server, port);
 155   if (!IsOpen())
 156     return FALSE;
 157
 158   SetOption(LDAP_OPT_PROTOCOL_VERSION, protocolVersion);
 159   return TRUE;
 160 }
 161
 162
 163 BOOL PLDAPSession::Close()
 164 {
 165   if (!IsOpen())
 166     return FALSE;
 167
 168   ldap_unbind(ldapContext);
 169   ldapContext = NULL;
 170   return TRUE;
 171 }
 172
 173
 174 BOOL PLDAPSession::SetOption(int optcode, int value)
 175 {
 176   if (!IsOpen())
 177     return FALSE;
 178
 179   return ldap_set_option(ldapContext, optcode, &value);
 180 }
 181
 182
 183 BOOL PLDAPSession::SetOption(int optcode, void * value)
 184 {
 185   if (!IsOpen())
 186     return FALSE;
 187
 188   return ldap_set_option(ldapContext, optcode, value);
 189 }
 190
 191
 192 BOOL PLDAPSession::Bind(const PString & who,
 193                         const PString & passwd,
 194                         AuthenticationMethod authMethod)
 195 {
 196   if (!IsOpen())
 197     return FALSE;
 198
 199   const char * whoPtr;
 200   if (who.IsEmpty())
 201     whoPtr = NULL;
 202   else
 203     whoPtr = who;
 204
 205 #ifdef SOLARIS
 206   static const int AuthMethodCode[NumAuthenticationMethod2] = {
 207     LDAP_AUTH_SIMPLE, LDAP_AUTH_SASL, LDAP_AUTH_KRBV41_30, LDAP_AUTH_KRBV42_30
 208 #else
 209   static const int AuthMethodCode[NumAuthenticationMethod] = {
 210     LDAP_AUTH_SIMPLE, LDAP_AUTH_SASL, LDAP_AUTH_KRBV4
 211 #endif
 212   };
 213   errorNumber = ldap_bind_s(ldapContext, whoPtr, passwd, AuthMethodCode[authMethod]);
 214   return errorNumber == LDAP_SUCCESS;
 215 }
 216
 217
 218 PLDAPSession::ModAttrib::ModAttrib(const PString & n, Operation o)
 219   : name(n),
 220     op(o)
 221 {
 222 }
 223
 224
 225 void PLDAPSession::ModAttrib::SetLDAPMod(struct ldapmod & mod, Operation defaultOp)
 226 {
 227   mod.mod_type = (char *)(const char *)name;
 228
 229   Operation realOp = op == NumOperations ? defaultOp : op;
 230   static const int OpCode[NumOperations] = {
 231     LDAP_MOD_ADD, LDAP_MOD_REPLACE, LDAP_MOD_DELETE
 232   };
 233   mod.mod_op = OpCode[realOp];
 234
 235   if (IsBinary())
 236     mod.mod_op |= LDAP_MOD_BVALUES;
 237
 238   SetLDAPModVars(mod);
 239 }
 240
 241
 242 PLDAPSession::StringModAttrib::StringModAttrib(const PString & name,
 243                                                Operation op)
 244   : ModAttrib(name, op)
 245 {
 246 }
 247
 248
 249 PLDAPSession::StringModAttrib::StringModAttrib(const PString & name,
 250                                                const PString & value,
 251                                                Operation op)
 252   : ModAttrib(name, op)
 253 {
 254   AddValue(value);
 255 }
 256
 257
 258 PLDAPSession::StringModAttrib::StringModAttrib(const PString & name,
 259                                                const PStringList & vals,
 260                                                Operation op)
 261   : ModAttrib(name, op),
 262     values(vals)
 263 {
 264 }
 265
 266
 267 void PLDAPSession::StringModAttrib::SetValue(const PString & value)
 268 {
 269   values.RemoveAll();
 270   values.AppendString(value);
 271 }
 272
 273
 274 void PLDAPSession::StringModAttrib::AddValue(const PString & value)
 275 {
 276   values.AppendString(value);
 277 }
 278
 279
 280 BOOL PLDAPSession::StringModAttrib::IsBinary() const
 281 {
 282   return FALSE;
 283 }
 284
 285
 286 void PLDAPSession::StringModAttrib::SetLDAPModVars(struct ldapmod & mod)
 287 {
 288   pointers.SetSize(values.GetSize()+1);
 289   PINDEX i;
 290   for (i = 0; i < values.GetSize(); i++)
 291     pointers[i] = values[i].GetPointer();
 292   pointers[i] = NULL;
 293   mod.mod_values = pointers.GetPointer();
 294 }
 295
 296
 297 PLDAPSession::BinaryModAttrib::BinaryModAttrib(const PString & name,
 298                                                Operation op)
 299   : ModAttrib(name, op)
 300 {
 301 }
 302
 303
 304 PLDAPSession::BinaryModAttrib::BinaryModAttrib(const PString & name,
 305                                                const PBYTEArray & value,
 306                                                Operation op)
 307   : ModAttrib(name, op)
 308 {
 309   AddValue(value);
 310 }
 311
 312
 313 PLDAPSession::BinaryModAttrib::BinaryModAttrib(const PString & name,
 314                                                const PList<PBYTEArray> & vals,
 315                                                Operation op)
 316   : ModAttrib(name, op),
 317     values(vals)
 318 {
 319 }
 320
 321
 322 void PLDAPSession::BinaryModAttrib::SetValue(const PBYTEArray & value)
 323 {
 324   values.RemoveAll();
 325   values.Append(new PBYTEArray(value));
 326 }
 327
 328
 329 void PLDAPSession::BinaryModAttrib::AddValue(const PBYTEArray & value)
 330 {
 331   values.Append(new PBYTEArray(value));
 332 }
 333
 334
 335 BOOL PLDAPSession::BinaryModAttrib::IsBinary() const
 336 {
 337   return TRUE;
 338 }
 339
 340
 341 void PLDAPSession::BinaryModAttrib::SetLDAPModVars(struct ldapmod & mod)
 342 {
 343   pointers.SetSize(values.GetSize()+1);
 344   bervals.SetSize(values.GetSize()*sizeof(berval));
 345   berval * ber = (berval *)bervals.GetPointer();
 346   PINDEX i;
 347   for (i = 0; i < values.GetSize(); i++) {
 348     ber[i].bv_val = (char *)values[i].GetPointer();
 349     ber[i].bv_len = values[i].GetSize();
 350     pointers[i] = &ber[i];
 351   }
 352   pointers[i] = NULL;
 353   mod.mod_bvalues = pointers.GetPointer();
 354 }
 355
 356
 357 static LDAPMod ** CreateLDAPModArray(const PList<PLDAPSession::ModAttrib> & attributes,
 358                                      PLDAPSession::ModAttrib::Operation defaultOp,
 359                                      PBYTEArray & storage)
 360 {
 361   PINDEX count = attributes.GetSize();
 362   storage.SetSize(count*sizeof(LDAPMod) + (count+1)*sizeof(LDAPMod *));
 363
 364   LDAPMod ** attrs = (LDAPMod **)storage.GetPointer();
 365   LDAPMod *  attr  = (LDAPMod * )&attrs[count+1];
 366   for (PINDEX i = 0; i < count; i++) {
 367     attrs[i] = &attr[i];
 368     attributes[i].SetLDAPMod(attr[i], defaultOp);
 369   }
 370
 371   return attrs;
 372 }
 373
 374
 375 static PList<PLDAPSession::ModAttrib> AttribsFromDict(const PStringToString & attributes)
 376 {
 377   PList<PLDAPSession::ModAttrib> attrs;
 378
 379   for (PINDEX i = 0; i < attributes.GetSize(); i++)
 380     attrs.Append(new PLDAPSession::StringModAttrib(attributes.GetKeyAt(i),
 381                                                    attributes.GetDataAt(i).Lines()));
 382
 383   return attrs;
 384 }
 385
 386
 387 static PList<PLDAPSession::ModAttrib> AttribsFromArray(const PStringArray & attributes)
 388 {
 389   PList<PLDAPSession::ModAttrib> attrs;
 390
 391   for (PINDEX i = 0; i < attributes.GetSize(); i++) {
 392     PString attr = attributes[i];
 393     PINDEX equal = attr.Find('=');
 394     if (equal != P_MAX_INDEX)
 395       attrs.Append(new PLDAPSession::StringModAttrib(attr.Left(equal),
 396                                                      attr.Mid(equal+1).Lines()));
 397   }
 398
 399   return attrs;
 400 }
 401
 402
 403 static PList<PLDAPSession::ModAttrib> AttribsFromStruct(const PLDAPStructBase & attributes)
 404 {
 405   PList<PLDAPSession::ModAttrib> attrs;
 406
 407   for (PINDEX i = 0; i < attributes.GetNumAttributes(); i++) {
 408     PLDAPAttributeBase & attr = attributes.GetAttribute(i);
 409     if (attr.IsBinary())
 410       attrs.Append(new PLDAPSession::BinaryModAttrib(attr.GetName(), attr.ToBinary()));
 411     else {
 412       PString str = attr.ToString();
 413       if (!str)
 414         attrs.Append(new PLDAPSession::StringModAttrib(attr.GetName(), str));
 415     }
 416   }
 417
 418   return attrs;
 419 }
 420
 421
 422 BOOL PLDAPSession::Add(const PString & dn, const PList<ModAttrib> & attributes)
 423 {
 424   if (!IsOpen())
 425     return FALSE;
 426
 427   PBYTEArray storage;
 428   int msgid;
 429   errorNumber = ldap_add_ext(ldapContext,
 430                              dn,
 431                              CreateLDAPModArray(attributes, ModAttrib::Add, storage),
 432                              NULL,
 433                              NULL,
 434                              &msgid);
 435   if (errorNumber != LDAP_SUCCESS)
 436     return FALSE;
 437
 438   P_timeval tval = timeout;
 439   LDAPMessage * result = NULL;
 440   ldap_result(ldapContext, msgid, LDAP_MSG_ALL, tval, &result);
 441   if (result)
 442     errorNumber = ldap_result2error(ldapContext, result, TRUE);
 443
 444   return errorNumber == LDAP_SUCCESS;
 445 }
 446
 447
 448 BOOL PLDAPSession::Add(const PString & dn, const PStringToString & attributes)
 449 {
 450   return Add(dn, AttribsFromDict(attributes));
 451 }
 452
 453
 454 BOOL PLDAPSession::Add(const PString & dn, const PStringArray & attributes)
 455 {
 456   return Add(dn, AttribsFromArray(attributes));
 457 }
 458
 459
 460 BOOL PLDAPSession::Add(const PString & dn, const PLDAPStructBase & attributes)
 461 {
 462   return Add(dn, AttribsFromStruct(attributes));
 463 }
 464
 465
 466 BOOL PLDAPSession::Modify(const PString & dn, const PList<ModAttrib> & attributes)
 467 {
 468   if (!IsOpen())
 469     return FALSE;
 470
 471   PBYTEArray storage;
 472   int msgid;
 473   errorNumber = ldap_modify_ext(ldapContext,
 474                                 dn,
 475                                 CreateLDAPModArray(attributes, ModAttrib::Replace, storage),
 476                                 NULL,
 477                                 NULL,
 478                                 &msgid);
 479   if (errorNumber != LDAP_SUCCESS)
 480     return FALSE;
 481
 482   P_timeval tval = timeout;
 483   LDAPMessage * result = NULL;
 484   ldap_result(ldapContext, msgid, LDAP_MSG_ALL, tval, &result);
 485   if (result)
 486     errorNumber = ldap_result2error(ldapContext, result, TRUE);
 487
 488   return errorNumber == LDAP_SUCCESS;
 489 }
 490
 491
 492 BOOL PLDAPSession::Modify(const PString & dn, const PStringToString & attributes)
 493 {
 494   return Modify(dn, AttribsFromDict(attributes));
 495 }
 496
 497
 498 BOOL PLDAPSession::Modify(const PString & dn, const PStringArray & attributes)
 499 {
 500   return Modify(dn, AttribsFromArray(attributes));
 501 }
 502
 503
 504 BOOL PLDAPSession::Modify(const PString & dn, const PLDAPStructBase & attributes)
 505 {
 506   return Modify(dn, AttribsFromStruct(attributes));
 507 }
 508
 509
 510 BOOL PLDAPSession::Delete(const PString & dn)
 511 {
 512   if (!IsOpen())
 513     return FALSE;
 514
 515   int msgid;
 516   errorNumber = ldap_delete_ext(ldapContext, dn, NULL, NULL, &msgid);
 517   if (errorNumber != LDAP_SUCCESS)
 518     return FALSE;
 519
 520   P_timeval tval = timeout;
 521   LDAPMessage * result = NULL;
 522   ldap_result(ldapContext, msgid, LDAP_MSG_ALL, tval, &result);
 523   if (result)
 524     errorNumber = ldap_result2error(ldapContext, result, TRUE);
 525
 526   return errorNumber == LDAP_SUCCESS;
 527 }
 528
 529
 530 PLDAPSession::SearchContext::SearchContext()
 531 {
 532   result = NULL;
 533   message = NULL;
 534   found = FALSE;
 535   completed = FALSE;
 536 }
 537
 538
 539 PLDAPSession::SearchContext::~SearchContext()
 540 {
 541   if (message != NULL)
 542     ldap_msgfree(message);
 543
 544   if (result != NULL && result != message)
 545     ldap_msgfree(result);
 546 }
 547
 548
 549 BOOL PLDAPSession::Search(SearchContext & context,
 550                           const PString & filter,
 551                           const PStringArray & attributes,
 552                           const PString & baseDN,
 553                           SearchScope scope)
 554 {
 555   if (!IsOpen())
 556     return FALSE;
 557
 558   PCharArray storage;
 559   char ** attribs = attributes.ToCharArray(&storage);
 560
 561   PString base = baseDN;
 562   if (base.IsEmpty())
 563     base = defaultBaseDN;
 564
 565   static const int ScopeCode[NumSearchScope] = {
 566     LDAP_SCOPE_BASE, LDAP_SCOPE_ONELEVEL, LDAP_SCOPE_SUBTREE
 567   };
 568
 569   P_timeval tval = timeout;
 570
 571   errorNumber = ldap_search_ext(ldapContext,
 572                                 base,
 573                                 ScopeCode[scope],
 574                                 filter,
 575                                 attribs,
 576                                 FALSE,
 577                                 NULL,
 578                                 NULL,
 579                                 tval,
 580                                 searchLimit,
 581                                 &context.msgid);
 582
 583   if (errorNumber != LDAP_SUCCESS)
 584     return FALSE;
 585
 586   if (ldap_result(ldapContext, context.msgid, LDAP_MSG_ONE, tval, &context.result) > 0)
 587     return GetNextSearchResult(context);
 588
 589   if (context.result)
 590     errorNumber = ldap_result2error(ldapContext, context.result, TRUE);
 591   if (errorNumber == 0)
 592     errorNumber = LDAP_OTHER;
 593   return FALSE;
 594 }
 595
 596
 597 BOOL PLDAPSession::GetSearchResult(SearchContext & context, PStringToString & data)
 598 {
 599   data.RemoveAll();
 600
 601   if (!IsOpen())
 602     return FALSE;
 603
 604   if (context.result == NULL || context.message == NULL || context.completed)
 605     return FALSE;
 606
 607   // Extract the resulting data
 608
 609   data.SetAt("dn", GetSearchResultDN(context));
 610
 611   BerElement * ber = NULL;
 612   char * attrib = ldap_first_attribute(ldapContext, context.message, &ber);
 613   while (attrib != NULL) {
 614
 615     struct berval ** bvals = ldap_get_values_len(ldapContext, context.message, attrib);
 616     if (bvals != NULL) {
 617       PString value = data(attrib);
 618
 619       for (PINDEX i = 0; bvals[i] != NULL; i++ ) {
 620         if (!value)
 621           value += multipleValueSeparator;
 622         value += PString(bvals[i]->bv_val, bvals[i]->bv_len);
 623       }
 624       ber_bvecfree(bvals);
 625
 626       data.SetAt(attrib, value);
 627     }
 628
 629     ldap_memfree(attrib);
 630     attrib = ldap_next_attribute(ldapContext, context.message, ber);
 631   }
 632
 633   if (ber != NULL)
 634     ber_free (ber, 0);
 635
 636   return TRUE;
 637 }
 638
 639
 640 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 641                                    const PString & attribute,
 642                                    PString & data)
 643 {
 644   data.MakeEmpty();
 645
 646   if (!IsOpen())
 647     return FALSE;
 648
 649   if (context.result == NULL || context.message == NULL || context.completed)
 650     return FALSE;
 651
 652   if (attribute == "dn") {
 653     data = GetSearchResultDN(context);
 654     return TRUE;
 655   }
 656
 657   char ** values = ldap_get_values(ldapContext, context.message, attribute);
 658   if (values == NULL)
 659     return FALSE;
 660
 661   PINDEX count = ldap_count_values(values);
 662   for (PINDEX i = 0; i < count; i++) {
 663     if (!data)
 664       data += multipleValueSeparator;
 665     data += values[i];
 666   }
 667
 668   ldap_value_free(values);
 669   return TRUE;
 670 }
 671
 672
 673 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 674                                    const PString & attribute,
 675                                    PStringArray & data)
 676 {
 677   data.RemoveAll();
 678
 679   if (!IsOpen())
 680     return FALSE;
 681
 682   if (context.result == NULL || context.message == NULL || context.completed)
 683     return FALSE;
 684
 685   if (attribute == "dn") {
 686     data.SetSize(1);
 687     data[0] = GetSearchResultDN(context);
 688     return TRUE;
 689   }
 690
 691   char ** values = ldap_get_values(ldapContext, context.message, attribute);
 692   if (values == NULL)
 693     return FALSE;
 694
 695   PINDEX count = ldap_count_values(values);
 696   data.SetSize(count);
 697   for (PINDEX i = 0; i < count; i++)
 698     data[i] = values[i];
 699
 700   ldap_value_free(values);
 701   return TRUE;
 702 }
 703
 704
 705 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 706                                    const PString & attribute,
 707                                    PArray<PBYTEArray> & data)
 708 {
 709   data.RemoveAll();
 710
 711   if (!IsOpen())
 712     return FALSE;
 713
 714   if (attribute == "dn") {
 715     char * dn = ldap_get_dn(ldapContext, context.message);
 716     data.Append(new PBYTEArray((const BYTE *)dn, ::strlen(dn)));
 717     ldap_memfree(dn);
 718     return TRUE;
 719   }
 720
 721   struct berval ** values = ldap_get_values_len(ldapContext, context.message, attribute);
 722   if (values == NULL)
 723     return FALSE;
 724
 725   PINDEX count = ldap_count_values_len(values);
 726   data.SetSize(count);
 727   for (PINDEX i = 0; i < count; i++) {
 728     PBYTEArray* dataPtr = new PBYTEArray(values[i]->bv_len);
 729     data.SetAt(i, dataPtr);
 730
 731     memcpy(data[i].GetPointer(), (const BYTE *)values[i]->bv_val, values[i]->bv_len);
 732   }
 733
 734   ldap_value_free_len(values);
 735   return TRUE;
 736 }
 737
 738
 739 BOOL PLDAPSession::GetSearchResult(SearchContext & context,
 740                                    PLDAPStructBase & data)
 741 {
 742   if (!IsOpen())
 743     return FALSE;
 744
 745   BOOL atLeastOne = FALSE;
 746
 747   for (PINDEX i = 0; i < data.GetNumAttributes(); i++) {
 748     PLDAPAttributeBase & attr = data.GetAttribute(i);
 749     if (attr.IsBinary()) {
 750       PArray<PBYTEArray> bin;
 751       if (GetSearchResult(context, attr.GetName(), bin)) {
 752         attr.FromBinary(bin);
 753         atLeastOne = TRUE;
 754       }
 755     }
 756     else {
 757       PString str;
 758       if (GetSearchResult(context, attr.GetName(), str)) {
 759         attr.FromString(str);
 760         atLeastOne = TRUE;
 761       }
 762     }
 763   }
 764
 765   return atLeastOne;
 766 }
 767
 768
 769 PString PLDAPSession::GetSearchResultDN(SearchContext & context)
 770 {
 771   PString str;
 772
 773   if (context.message != NULL) {
 774     char * dn = ldap_get_dn(ldapContext, context.message);
 775     if (dn != NULL) {
 776       str = dn;
 777       ldap_memfree(dn);
 778     }
 779   }
 780
 781   return str;
 782 }
 783
 784
 785 BOOL PLDAPSession::GetNextSearchResult(SearchContext & context)
 786 {
 787   if (!IsOpen())
 788     return FALSE;
 789
 790   if (context.result == NULL || context.completed)
 791     return FALSE;
 792
 793   P_timeval tval = timeout;
 794   do {
 795     if (context.message == NULL)
 796       context.message = ldap_first_message(ldapContext, context.result);
 797     else
 798       context.message = ldap_next_message(ldapContext, context.message);
 799
 800     if (context.message != NULL) {
 801       switch (ldap_msgtype(context.message)) {
 802         case LDAP_RES_SEARCH_ENTRY :
 803           context.found = TRUE;
 804           errorNumber = LDAP_SUCCESS;
 805           return TRUE;
 806
 807         case LDAP_RES_SEARCH_RESULT :
 808           errorNumber = ldap_result2error(ldapContext, context.message, FALSE);
 809           if (errorNumber == 0 && !context.found)
 810             errorNumber = LDAP_NO_RESULTS_RETURNED;
 811           context.completed = TRUE;
 812           return FALSE;
 813       }
 814       // Ignore other result message types for now ...
 815     }
 816
 817     ldap_msgfree(context.result);
 818   } while (ldap_result(ldapContext, context.msgid, LDAP_MSG_ONE, tval, &context.result) > 0);
 819
 820   if (context.result)
 821     errorNumber = ldap_result2error(ldapContext, context.result, FALSE);
 822   if (errorNumber == 0)
 823     errorNumber = LDAP_OTHER;
 824   return FALSE;
 825 }
 826
 827
 828 PList<PStringToString> PLDAPSession::Search(const PString & filter,
 829                                             const PStringArray & attributes,
 830                                             const PString & base,
 831                                             SearchScope scope)
 832 {
 833   PList<PStringToString> data;
 834
 835   SearchContext context;
 836   if (!Search(context, filter, attributes, base, scope))
 837     return data;
 838
 839   do {
 840     PStringToString * entry = new PStringToString;
 841     if (GetSearchResult(context, *entry))
 842       data.Append(entry);
 843     else {
 844       delete entry;
 845       break;
 846     }
 847   } while (GetNextSearchResult(context));
 848
 849   return data;
 850 }
 851
 852
 853 PString PLDAPSession::GetErrorText() const
 854 {
 855   return ldap_err2string(errorNumber);
 856 }
 857
 858
 859 ///////////////////////////////////////////////////////////////////////////////
 860
 861 PLDAPAttributeBase::PLDAPAttributeBase(const char * n, void * ptr, PINDEX sz)
 862   : name(n),
 863     pointer(ptr),
 864     size(sz)
 865 {
 866   PLDAPStructBase::GetInitialiser().AddAttribute(this);
 867 }
 868
 869
 870 PString PLDAPAttributeBase::ToString() const
 871 {
 872   PStringStream stream;
 873   PrintOn(stream);
 874   return stream;
 875 }
 876
 877
 878 void PLDAPAttributeBase::FromString(const PString & str)
 879 {
 880   PStringStream stream(str);
 881   ReadFrom(stream);
 882 }
 883
 884
 885 PBYTEArray PLDAPAttributeBase::ToBinary() const
 886 {
 887   return PBYTEArray((const BYTE *)pointer, size, FALSE);
 888 }
 889
 890
 891 void PLDAPAttributeBase::FromBinary(const PArray<PBYTEArray> & data)
 892 {
 893   if (data.GetSize() > 0 && data[0].GetSize() == size)
 894     memcpy(pointer, data[0], size);
 895 }
 896
 897
 898 ///////////////////////////////////////////////////////////////////////////////
 899
 900 PMutex            PLDAPStructBase::initialiserMutex;
 901 PLDAPStructBase * PLDAPStructBase::initialiserInstance;
 902
 903 PLDAPStructBase::PLDAPStructBase()
 904 {
 905   attributes.DisallowDeleteObjects();
 906
 907   initialiserMutex.Wait();
 908   initialiserStack = initialiserInstance;
 909   initialiserInstance = this;
 910 }
 911
 912
 913 PLDAPStructBase & PLDAPStructBase::operator=(const PLDAPStructBase & other)
 914 {
 915   for (PINDEX i = 0; i < attributes.GetSize(); i++)
 916     attributes.GetDataAt(i).Copy(other.attributes.GetDataAt(i));
 917
 918   return *this;
 919 }
 920
 921
 922 PLDAPStructBase & PLDAPStructBase::operator=(const PStringArray & array)
 923 {
 924   for (PINDEX i = 0; i < array.GetSize(); i++) {
 925     PString str = array[i];
 926     PINDEX equal = str.Find('=');
 927     if (equal != P_MAX_INDEX) {
 928       PLDAPAttributeBase * attr = GetAttribute(str.Left(equal));
 929       if (attr != NULL)
 930         attr->FromString(str.Mid(equal+1));
 931     }
 932   }
 933   return *this;
 934 }
 935
 936
 937 PLDAPStructBase & PLDAPStructBase::operator=(const PStringToString & dict)
 938 {
 939   for (PINDEX i = 0; i < dict.GetSize(); i++) {
 940     PLDAPAttributeBase * attr = GetAttribute(dict.GetKeyAt(i));
 941     if (attr != NULL)
 942       attr->FromString(dict.GetDataAt(i));
 943   }
 944   return *this;
 945 }
 946
 947
 948 void PLDAPStructBase::PrintOn(ostream & strm) const
 949 {
 950   strm << attributes << '\n';
 951 }
 952
 953
 954 void PLDAPStructBase::AddAttribute(PLDAPAttributeBase * attr)
 955 {
 956   attributes.SetAt(attr->GetName(), attr);
 957 }
 958
 959
 960 void PLDAPStructBase::EndConstructor()
 961 {
 962   initialiserInstance = initialiserStack;
 963   initialiserMutex.Signal();
 964 }
 965
 966 ///////////////////////////////////////////////////////////////////
 967
 968 static const char PLDAPSchemaPluginBaseClass[] = "PLDAPSchema";
 969
 970 template <> PLDAPSchema * PDevicePluginFactory<PLDAPSchema>::Worker::Create(const PString & type) const
 971 {
 972   return PLDAPSchema::CreateSchema(type);
 973 }
 974
 975 PLDAPSchema::PLDAPSchema()
 976 {
 977 }
 978
 979 PLDAPSchema::Attribute::Attribute(const PString & name, AttributeType type)
 980 : m_name(name),m_type(type)
 981 {
 982 }
 983
 984 void PLDAPSchema::LoadSchema()
 985 {
 986         AttributeList(attributelist);
 987 }
 988
 989 PLDAPSchema * PLDAPSchema::CreateSchema(const PString & schemaname, PPluginManager * pluginMgr)
 990 {
 991   if (pluginMgr == NULL)
 992     pluginMgr = &PPluginManager::GetPluginManager();
 993
 994   return (PLDAPSchema *)pluginMgr->CreatePluginsDeviceByName(schemaname, PLDAPSchemaPluginBaseClass);
 995 }
 996
 997 PStringList PLDAPSchema::GetSchemaNames(PPluginManager * pluginMgr)
 998 {
 999   if (pluginMgr == NULL)
1000     pluginMgr = &PPluginManager::GetPluginManager();
1001
1002   return pluginMgr->GetPluginsProviding(PLDAPSchemaPluginBaseClass);
1003 }
1004
1005 PStringList PLDAPSchema::GetSchemaFriendlyNames(const PString & schema, PPluginManager * pluginMgr)
1006 {
1007   if (pluginMgr == NULL)
1008     pluginMgr = &PPluginManager::GetPluginManager();
1009
1010   return pluginMgr->GetPluginsDeviceNames(schema, PLDAPSchemaPluginBaseClass);
1011 }
1012
1013 void PLDAPSchema::OnReceivedAttribute(const PString & attribute, const PString & value)
1014 {
1015    SetAttribute(attribute,value);
1016 }
1017
1018 BOOL PLDAPSchema::SetAttribute(const PString & attribute, const PString & value)
1019 {
1020
1021         for (std::list<Attribute>::const_iterator r = attributelist.begin(); r != attributelist.end(); ++r) {
1022                 if ((r->m_name == attribute) &&  (r->m_type != AttributeBinary)) {
1023                attributes.insert(make_pair(attribute,value));
1024                    PTRACE(4, "schema\tMatch " << attribute);
1025                    return TRUE;
1026                 }
1027         }
1028
1029         return FALSE;
1030 }
1031
1032 BOOL PLDAPSchema::SetAttribute(const PString & attribute, const PBYTEArray & value)
1033 {
1034         for (std::list<Attribute>::const_iterator r = attributelist.begin(); r != attributelist.end(); ++r) {
1035                 if ((r->m_name == attribute) && (r->m_type == AttributeBinary)) {
1036                binattributes.insert(make_pair(attribute,value));
1037                    PTRACE(4, "schema\tMatch Binary " << attribute);
1038                    return TRUE;
1039                 }
1040         }
1041
1042         return FALSE;
1043 }
1044
1045 BOOL PLDAPSchema::GetAttribute(const PString & attribute, PString & value)
1046 {
1047         for (ldapAttributes::const_iterator r = attributes.begin(); r != attributes.end(); ++r) {
1048                 if (r->first == attribute) {
1049                         value = r->second;
1050                         return TRUE;
1051                 }
1052         }
1053         return FALSE;
1054 }
1055
1056 BOOL PLDAPSchema::GetAttribute(const PString & attribute, PBYTEArray & value)
1057 {
1058         for (ldapBinAttributes::const_iterator r = binattributes.begin(); r != binattributes.end(); ++r) {
1059                 if (r->first == attribute) {
1060                         value = r->second;
1061                         return TRUE;
1062                 }
1063         }
1064         return FALSE;
1065 }
1066
1067 PStringList PLDAPSchema::GetAttributeList()
1068 {
1069         PStringList att;
1070         for (std::list<Attribute>::iterator r = attributelist.begin(); r != attributelist.end(); ++r) {
1071         att.AppendString(r->m_name);
1072         }
1073         return att;
1074 }
1075
1076 BOOL PLDAPSchema::Exists(const PString & attribute)
1077 {
1078         for (std::list<Attribute>::const_iterator r = attributelist.begin(); r != attributelist.end(); ++r) {
1079           if (r->m_name == attribute) {
1080                   if (r->m_type == AttributeString) {
1081                   for (ldapAttributes::const_iterator r = attributes.begin(); r != attributes.end(); ++r) {
1082                   if (r->first == attribute)
1083                                  return TRUE;
1084                       }
1085                   } else if (r->m_type == AttributeBinary) {
1086                   for (ldapBinAttributes::const_iterator r = binattributes.begin(); r != binattributes.end(); ++r) {
1087                   if (r->first == attribute)
1088                                  return TRUE;
1089                           }
1090                   }
1091           }
1092         }
1093         return FALSE;
1094 }
1095
1096 PLDAPSchema::AttributeType PLDAPSchema::GetAttributeType(const PString & attribute)
1097 {
1098         for (std::list<Attribute>::const_iterator r = attributelist.begin(); r != attributelist.end(); ++r) {
1099                 if (r->m_name == attribute)
1100                    return (AttributeType)r->m_type;
1101         }
1102         return AttibuteUnknown;
1103 }
1104
1105 void PLDAPSchema::OnSendSchema(PList<PLDAPSession::ModAttrib> & attrib, PLDAPSession::ModAttrib::Operation op)
1106 {
1107         for (ldapAttributes::const_iterator r = attributes.begin(); r != attributes.end(); ++r)
1108         attrib.Append(new PLDAPSession::StringModAttrib(r->first,r->second,op));
1109
1110         for (ldapBinAttributes::const_iterator s = binattributes.begin(); s != binattributes.end(); ++s) {
1111         attrib.Append(new PLDAPSession::BinaryModAttrib(s->first,s->second,op));
1112         }
1113 }
1114
1115
1116 #endif // P_LDAP
1117
1118
1119 // End of file ////////////////////////////////////////////////////////////////
1120