home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / winldap.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  92KB  |  2,969 lines
  1. /*++
  2.  
  3. Copyright (c) 1996-1999  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     winldap.h   LDAP client 32 API header file
  8.  
  9. Abstract:
  10.  
  11.    This module is the header file for the 32 bit LDAP client API for
  12.    Windows NT and Windows 95.  This API is based on RFC 1823 with some
  13.    enhancements for LDAP v3.
  14.  
  15.    Notes about Unicode support :
  16.  
  17.    If you have UNICODE defined at compile time, you'll pull in the unicode
  18.    versions of the calls.  Note that your executable may then not work with
  19.    other implementations of the LDAP API that don't support Unicode.  If
  20.    UNICODE is not defined, then we define the LDAP calls without the trailing
  21.    'A' (as in ldap_bind rather than ldap_bindA) so that your app may work
  22.    with other implementations that don't support Unicode.
  23.  
  24.    The import library has all three forms of the call present... ldap_bindW,
  25.    ldap_bindA, and ldap_bind.  ldap_bindA simply calls ldap_bind.  ldap_bind
  26.    simply converts the arguments to unicode and calls ldap_bindW.  The
  27.    reason this is done is because we have to put UTF-8 on the wire, so if
  28.    we converted from Unicode to single byte, we'd loose information.  Since
  29.    all core processing is done in Unicode, nothing is lost.
  30.  
  31. Updates :
  32.  
  33.    11/01/96  Modified for new API RFC draft.
  34.  
  35. Environments :
  36.  
  37.     Win32 user mode
  38.  
  39. --*/
  40.  
  41. //
  42. //  Only pull in this header file once... controlled by LDAP_CLIENT_DEFINED
  43. //  variable.
  44. //
  45.  
  46. #ifndef LDAP_CLIENT_DEFINED
  47. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  48. #define LDAP_CLIENT_DEFINED
  49.  
  50. #if _MSC_VER > 1000
  51. #pragma once
  52. #endif
  53.  
  54. #ifdef __cplusplus
  55. extern "C" {
  56. #endif
  57.  
  58. #ifndef BASETYPES
  59. #include <windef.h>
  60. #endif
  61.  
  62. #ifndef _SCHNLSP_H_
  63. #include <schnlsp.h>
  64. #endif
  65.  
  66. #if !defined(_WINLDAP_)
  67. #define WINLDAPAPI DECLSPEC_IMPORT
  68. #else
  69. //#define WINLDAPAPI __declspec(dllexport)
  70. #define WINLDAPAPI
  71. #endif
  72.  
  73. #ifndef LDAPAPI
  74. #define LDAPAPI __cdecl
  75. #endif
  76.  
  77. //
  78. //  The #define LDAP_UNICODE controls if we map the undecorated calls to
  79. //  their unicode counterparts or just leave them defined as the normal
  80. //  single byte entry points.
  81. //
  82. //  If you want to write a UNICODE enabled application, you'd normally
  83. //  just have UNICODE defined and then we'll default to using all LDAP
  84. //  Unicode calls.
  85. //
  86.  
  87. #ifndef LDAP_UNICODE
  88. #ifdef UNICODE
  89. #define LDAP_UNICODE 1
  90. #else
  91. #define LDAP_UNICODE 0
  92. #endif
  93. #endif
  94.  
  95. //
  96. //  Global constants
  97. //
  98.  
  99. #define LDAP_PORT               389
  100. #define LDAP_SSL_PORT           636
  101. #define LDAP_GC_PORT            3268
  102. #define LDAP_SSL_GC_PORT        3269
  103.  
  104. //
  105. //  We currently support going to either v2 or v3 servers, though the API
  106. //  is only a V2 API.  We'll add support for result sets, server side
  107. //  sorting, extended operations, etc as soon as they stabilize.
  108. //
  109.  
  110. #define LDAP_VERSION1           1
  111. #define LDAP_VERSION2           2
  112. #define LDAP_VERSION3           3
  113. #define LDAP_VERSION            LDAP_VERSION2
  114.  
  115. //
  116. //  All tags are CCFTTTTT.
  117. //               CC        Tag Class 00 = universal
  118. //                                   01 = application wide
  119. //                                   10 = context specific
  120. //                                   11 = private use
  121. //
  122. //                 F       Form 0 primitive
  123. //                              1 constructed
  124. //
  125. //                  TTTTT  Tag Number
  126. //
  127.  
  128. //
  129. // LDAP v2 & v3 commands.
  130. //
  131.  
  132. #define LDAP_BIND_CMD           0x60L   // application + constructed
  133. #define LDAP_UNBIND_CMD         0x42L   // application + primitive
  134. #define LDAP_SEARCH_CMD         0x63L   // application + constructed
  135. #define LDAP_MODIFY_CMD         0x66L   // application + constructed
  136. #define LDAP_ADD_CMD            0x68L   // application + constructed
  137. #define LDAP_DELETE_CMD         0x4aL   // application + primitive
  138. #define LDAP_MODRDN_CMD         0x6cL   // application + constructed
  139. #define LDAP_COMPARE_CMD        0x6eL   // application + constructed
  140. #define LDAP_ABANDON_CMD        0x50L   // application + primitive
  141. #define LDAP_SESSION_CMD        0x71L   // not in base LDAP protocol
  142. #define LDAP_EXTENDED_CMD       0x77L   // application + constructed
  143.  
  144. //
  145. // Responses/Results for LDAP v2 & v3
  146. //
  147.  
  148. #define LDAP_RES_BIND           0x61L   // application + constructed
  149. #define LDAP_RES_SEARCH_ENTRY   0x64L   // application + constructed
  150. #define LDAP_RES_SEARCH_RESULT  0x65L   // application + constructed
  151. #define LDAP_RES_MODIFY         0x67L   // application + constructed
  152. #define LDAP_RES_ADD            0x69L   // application + constructed
  153. #define LDAP_RES_DELETE         0x6bL   // application + constructed
  154. #define LDAP_RES_MODRDN         0x6dL   // application + constructed
  155. #define LDAP_RES_COMPARE        0x6fL   // application + constructed
  156. #define LDAP_RES_SESSION        0x72L   // not in base LDAP protocol
  157. #define LDAP_RES_REFERRAL       0x73L   // application + constructed
  158. #define LDAP_RES_EXTENDED       0x78L   // application + constructed
  159. #define LDAP_RES_ANY            (-1L)
  160.  
  161. #define LDAP_INVALID_CMD         0xff
  162. #define LDAP_INVALID_RES         0xff
  163.  
  164.  
  165. //
  166. // We'll make the error codes compatible with reference implementation
  167. //
  168.  
  169. typedef enum {
  170.     LDAP_SUCCESS                    =   0x00,
  171.     LDAP_OPERATIONS_ERROR           =   0x01,
  172.     LDAP_PROTOCOL_ERROR             =   0x02,
  173.     LDAP_TIMELIMIT_EXCEEDED         =   0x03,
  174.     LDAP_SIZELIMIT_EXCEEDED         =   0x04,
  175.     LDAP_COMPARE_FALSE              =   0x05,
  176.     LDAP_COMPARE_TRUE               =   0x06,
  177.     LDAP_AUTH_METHOD_NOT_SUPPORTED  =   0x07,
  178.     LDAP_STRONG_AUTH_REQUIRED       =   0x08,
  179.     LDAP_REFERRAL_V2                =   0x09,
  180.     LDAP_PARTIAL_RESULTS            =   0x09,
  181.     LDAP_REFERRAL                   =   0x0a,
  182.     LDAP_ADMIN_LIMIT_EXCEEDED       =   0x0b,
  183.     LDAP_UNAVAILABLE_CRIT_EXTENSION =   0x0c,
  184.     LDAP_CONFIDENTIALITY_REQUIRED   =   0x0d,
  185.     LDAP_SASL_BIND_IN_PROGRESS      =   0x0e,
  186.  
  187.     LDAP_NO_SUCH_ATTRIBUTE          =   0x10,
  188.     LDAP_UNDEFINED_TYPE             =   0x11,
  189.     LDAP_INAPPROPRIATE_MATCHING     =   0x12,
  190.     LDAP_CONSTRAINT_VIOLATION       =   0x13,
  191.     LDAP_ATTRIBUTE_OR_VALUE_EXISTS  =   0x14,
  192.     LDAP_INVALID_SYNTAX             =   0x15,
  193.  
  194.     LDAP_NO_SUCH_OBJECT             =   0x20,
  195.     LDAP_ALIAS_PROBLEM              =   0x21,
  196.     LDAP_INVALID_DN_SYNTAX          =   0x22,
  197.     LDAP_IS_LEAF                    =   0x23,
  198.     LDAP_ALIAS_DEREF_PROBLEM        =   0x24,
  199.  
  200.     LDAP_INAPPROPRIATE_AUTH         =   0x30,
  201.     LDAP_INVALID_CREDENTIALS        =   0x31,
  202.     LDAP_INSUFFICIENT_RIGHTS        =   0x32,
  203.     LDAP_BUSY                       =   0x33,
  204.     LDAP_UNAVAILABLE                =   0x34,
  205.     LDAP_UNWILLING_TO_PERFORM       =   0x35,
  206.     LDAP_LOOP_DETECT                =   0x36,
  207.  
  208.     LDAP_NAMING_VIOLATION           =   0x40,
  209.     LDAP_OBJECT_CLASS_VIOLATION     =   0x41,
  210.     LDAP_NOT_ALLOWED_ON_NONLEAF     =   0x42,
  211.     LDAP_NOT_ALLOWED_ON_RDN         =   0x43,
  212.     LDAP_ALREADY_EXISTS             =   0x44,
  213.     LDAP_NO_OBJECT_CLASS_MODS       =   0x45,
  214.     LDAP_RESULTS_TOO_LARGE          =   0x46,
  215.     LDAP_AFFECTS_MULTIPLE_DSAS      =   0x47,
  216.  
  217.     LDAP_OTHER                      =   0x50,
  218.     LDAP_SERVER_DOWN                =   0x51,
  219.     LDAP_LOCAL_ERROR                =   0x52,
  220.     LDAP_ENCODING_ERROR             =   0x53,
  221.     LDAP_DECODING_ERROR             =   0x54,
  222.     LDAP_TIMEOUT                    =   0x55,
  223.     LDAP_AUTH_UNKNOWN               =   0x56,
  224.     LDAP_FILTER_ERROR               =   0x57,
  225.     LDAP_USER_CANCELLED             =   0x58,
  226.     LDAP_PARAM_ERROR                =   0x59,
  227.     LDAP_NO_MEMORY                  =   0x5a,
  228.     LDAP_CONNECT_ERROR              =   0x5b,
  229.     LDAP_NOT_SUPPORTED              =   0x5c,
  230.     LDAP_NO_RESULTS_RETURNED        =   0x5e,
  231.     LDAP_CONTROL_NOT_FOUND          =   0x5d,
  232.     LDAP_MORE_RESULTS_TO_RETURN     =   0x5f,
  233.  
  234.     LDAP_CLIENT_LOOP                =   0x60,
  235.     LDAP_REFERRAL_LIMIT_EXCEEDED    =   0x61
  236. } LDAP_RETCODE;
  237.  
  238. //
  239. //  Bind methods.  We support the following methods :
  240. //
  241. //      Simple         Clear text password... try not to use as it's not secure.
  242. //
  243. //      MSN            MSN (Microsoft Network) authentication. This package
  244. //                     may bring up UI to prompt the user for MSN credentials.
  245. //
  246. //      DPA            Normandy authentication... new MSN authentication.  Same
  247. //                     usage as MSN.
  248. //
  249. //      NTLM           NT domain authentication.  Use NULL credentials and
  250. //                     we'll try to use default logged in user credentials.
  251. //
  252. //      Sicily         Negotiate with the server for any of: MSN, DPA, NTLM
  253. //                     Should be used for LDAPv2 servers only.
  254. //
  255. //      Negotiate      Use GSSAPI Negotiate package to negotiate security
  256. //                     package of either Kerberos v5 or NTLM (or any other
  257. //                     package the client and server negotiate).  Pass in
  258. //                     NULL credentials to specify default logged in user.
  259. //                     If Negotiate package is not installed on server or
  260. //                     client, this will fall back to Sicily negotiation.
  261. //
  262. //  For all bind methods except for Simple, you may pass in a
  263. //  SEC_WINNT_AUTH_IDENTITY_W (defined in rpcdce.h) or the newer
  264. //  SEC_WINNT_AUTH_IDENTITY_EXW (defined in secext.h) to specify alternate
  265. //  credentials.
  266. //
  267. //  All bind methods other than simple are synchronous only calls.
  268. //  Calling the asynchronous bind call for any of these messages will
  269. //  return LDAP_PARAM_ERROR.
  270. //
  271. //  Using any other method besides simple will cause WLDAP32 to pull in
  272. //  the SSPI security DLLs (SECURITY.DLL etc).
  273. //
  274. //  On non-Simple methods, if you specify NULL credentials, we'll attempt to use
  275. //  the default logged in user.
  276. //
  277.  
  278. #define LDAP_AUTH_SIMPLE                0x80L
  279. #define LDAP_AUTH_SASL                  0x83L   // don't use... should go away
  280.  
  281. #define LDAP_AUTH_OTHERKIND             0x86L
  282.  
  283. // The SICILY type covers package negotiation to MSN servers.
  284. // Each of the supported types can also be specified without
  285. // doing the package negotiation, assuming the caller knows
  286. // what the server supports.
  287.  
  288. #define LDAP_AUTH_SICILY                (LDAP_AUTH_OTHERKIND | 0x0200)
  289.  
  290. #define LDAP_AUTH_MSN                   (LDAP_AUTH_OTHERKIND | 0x0800)
  291. #define LDAP_AUTH_NTLM                  (LDAP_AUTH_OTHERKIND | 0x1000)
  292. #define LDAP_AUTH_DPA                   (LDAP_AUTH_OTHERKIND | 0x2000)
  293.  
  294. // This will cause the client to use the GSSAPI negotiation
  295. // package to determine the most appropriate authentication type.
  296. // This type should be used when talking to NT5.
  297.  
  298. #define LDAP_AUTH_NEGOTIATE             (LDAP_AUTH_OTHERKIND | 0x0400)
  299.  
  300. // backward compatible #define for older constant name.
  301.  
  302. #define LDAP_AUTH_SSPI                   LDAP_AUTH_NEGOTIATE
  303.  
  304. //
  305. //  Client applications typically don't have to encode/decode LDAP filters,
  306. //  but if they do, we define the operators here.
  307. //
  308. //  Filter types.
  309.  
  310. #define LDAP_FILTER_AND         0xa0    // context specific + constructed - SET OF Filters.
  311. #define LDAP_FILTER_OR          0xa1    // context specific + constructed - SET OF Filters.
  312. #define LDAP_FILTER_NOT         0xa2    // context specific + constructed - Filter
  313. #define LDAP_FILTER_EQUALITY    0xa3    // context specific + constructed - AttributeValueAssertion.
  314. #define LDAP_FILTER_SUBSTRINGS  0xa4    // context specific + constructed - SubstringFilter
  315. #define LDAP_FILTER_GE          0xa5    // context specific + constructed - AttributeValueAssertion.
  316. #define LDAP_FILTER_LE          0xa6    // context specific + constructed - AttributeValueAssertion.
  317. #define LDAP_FILTER_PRESENT     0x87    // context specific + primitive   - AttributeType.
  318. #define LDAP_FILTER_APPROX      0xa8    // context specific + constructed - AttributeValueAssertion.
  319. #define LDAP_FILTER_EXTENSIBLE  0xa9    // context specific + constructed - MatchingRuleAssertion.
  320.  
  321. //  Substring filter types
  322.  
  323. #define LDAP_SUBSTRING_INITIAL  0x80L   // class context specific
  324. #define LDAP_SUBSTRING_ANY      0x81L   // class context specific
  325. #define LDAP_SUBSTRING_FINAL    0x82L   // class context specific
  326.  
  327. //
  328. //  Possible values for ld_deref field.
  329. //      "Never"     - never deref aliases.  return only the alias.
  330. //      "Searching" - only deref aliases when searching, not when locating
  331. //                    the base object of a search.
  332. //      "Finding"   - dereference the alias when locating the base object but
  333. //                    not during a search.
  334. //      "Always"    - always dereference aliases.
  335. //
  336.  
  337. #define LDAP_DEREF_NEVER        0
  338. #define LDAP_DEREF_SEARCHING    1
  339. #define LDAP_DEREF_FINDING      2
  340. #define LDAP_DEREF_ALWAYS       3
  341.  
  342. //  Special values for ld_sizelimit :
  343.  
  344. #define LDAP_NO_LIMIT       0
  345.  
  346. //  Flags for ld_options field :
  347.  
  348. #define LDAP_OPT_DNS                0x00000001  // utilize DN & DNS
  349. #define LDAP_OPT_CHASE_REFERRALS    0x00000002  // chase referrals
  350. #define LDAP_OPT_RETURN_REFS        0x00000004  // return referrals to calling app
  351.  
  352. //
  353. //  LDAP structure per connection
  354. //
  355.  
  356. #if !defined(_WIN64)
  357. #pragma pack(push, 4)
  358. #endif
  359.  
  360. typedef struct ldap {
  361.  
  362.     struct {
  363.  
  364.         UINT_PTR sb_sd;
  365.  
  366.         UCHAR Reserved1[(10*sizeof(ULONG))+1];
  367.  
  368.         ULONG_PTR sb_naddr;   // notzero implies CLDAP available
  369.  
  370.         UCHAR Reserved2[(6*sizeof(ULONG))];
  371.  
  372.     } ld_sb;
  373.  
  374.     //
  375.     //  Following parameters MAY match up to reference implementation of LDAP
  376.     //
  377.  
  378.     PCHAR   ld_host;
  379.     ULONG   ld_version;
  380.     UCHAR   ld_lberoptions;
  381.  
  382.     //
  383.     //  Safe to assume that these parameters are in same location as
  384.     //  reference implementation of LDAP API.
  385.     //
  386.  
  387.     ULONG   ld_deref;
  388.  
  389.     ULONG   ld_timelimit;
  390.     ULONG   ld_sizelimit;
  391.  
  392.     ULONG   ld_errno;
  393.     PCHAR   ld_matched;
  394.     PCHAR   ld_error;
  395.     ULONG   ld_msgid;
  396.  
  397.     UCHAR Reserved3[(6*sizeof(ULONG))+1];
  398.  
  399.     //
  400.     //  Following parameters may match up to reference implementation of LDAP API.
  401.     //
  402.  
  403.     ULONG   ld_cldaptries;
  404.     ULONG   ld_cldaptimeout;
  405.     ULONG   ld_refhoplimit;
  406.     ULONG   ld_options;
  407.  
  408. } LDAP, * PLDAP;
  409.  
  410. //
  411. //  Our timeval structure is a bit different from the reference implementation
  412. //  since Win32 defines a _timeval structure that is different from the LDAP
  413. //  one.
  414. //
  415.  
  416. typedef struct l_timeval {
  417.     LONG    tv_sec;
  418.     LONG    tv_usec;
  419. } LDAP_TIMEVAL, * PLDAP_TIMEVAL;
  420.  
  421. //
  422. //  The berval structure is used to pass in any arbitrary octet string.  It
  423. //  is useful for attributes that cannot be represented using a null
  424. //  terminated string.
  425. //
  426.  
  427. typedef struct berval {
  428.     ULONG  bv_len;
  429.     PCHAR  bv_val;
  430. } LDAP_BERVAL, * PLDAP_BERVAL, BERVAL, * PBERVAL;
  431.  
  432. //
  433. //  The following structure has to be compatible with reference implementation.
  434. //
  435.  
  436. typedef struct ldapmsg {
  437.  
  438.     ULONG lm_msgid;             // message number for given connection
  439.     ULONG lm_msgtype;           // message type of the form LDAP_RES_xxx
  440.  
  441.     PVOID lm_ber;               // ber form of message
  442.  
  443.     struct ldapmsg *lm_chain;   // pointer to next result value
  444.     struct ldapmsg *lm_next;    // pointer to next message
  445.     ULONG lm_time;
  446.  
  447.     //
  448.     //  new fields below not in reference implementation
  449.     //
  450.  
  451.     PLDAP   Connection;         // connection from which we received response
  452.     PVOID   Request;            // owning request (opaque structure)
  453.     ULONG   lm_returncode;      // server's return code
  454.     USHORT  lm_referral;        // index of referral within ref table
  455.     BOOLEAN lm_chased;          // has referral been chased already?
  456.     BOOLEAN lm_eom;             // is this the last entry for this message?
  457.     BOOLEAN ConnectionReferenced; // is the Connection still valid?
  458.  
  459. } LDAPMessage, *PLDAPMessage;
  460.  
  461. //
  462. //  Controls... there are three types :
  463. //
  464. //   1) those passed to the server
  465. //   2) those passed to the client and handled by the client API
  466. //   3) those returned by the server
  467. //
  468.  
  469. typedef struct ldapcontrolA {
  470.  
  471.     PCHAR         ldctl_oid;
  472.     struct berval ldctl_value;
  473.     BOOLEAN       ldctl_iscritical;
  474.  
  475. } LDAPControlA, *PLDAPControlA;
  476.  
  477. typedef struct ldapcontrolW {
  478.  
  479.     PWCHAR        ldctl_oid;
  480.     struct berval ldctl_value;
  481.     BOOLEAN       ldctl_iscritical;
  482.  
  483. } LDAPControlW, *PLDAPControlW;
  484.  
  485. #if LDAP_UNICODE
  486. #define LDAPControl LDAPControlW
  487. #define PLDAPControl PLDAPControlW
  488. #else
  489. #define LDAPControl LDAPControlA
  490. #define PLDAPControl PLDAPControlA
  491. #endif
  492.  
  493. //
  494. //  Client controls section : these are the client controls that wldap32.dll
  495. //  supports.
  496. //
  497. //  If you specify LDAP_CONTROL_REFERRALS in a control, the value field should
  498. //  point to a ULONG of the following flags :
  499. //
  500. //      LDAP_CHASE_SUBORDINATE_REFERRALS
  501. //      LDAP_CHASE_EXTERNAL_REFERRALS
  502. //
  503.  
  504. #define LDAP_CONTROL_REFERRALS_W L"1.2.840.113556.1.4.616"
  505. #define LDAP_CONTROL_REFERRALS    "1.2.840.113556.1.4.616"
  506.  
  507. //
  508. //  Values required for Modification command  These are options for the
  509. //  mod_op field of LDAPMod structure
  510. //
  511.  
  512. #define LDAP_MOD_ADD            0x00
  513. #define LDAP_MOD_DELETE         0x01
  514. #define LDAP_MOD_REPLACE        0x02
  515. #define LDAP_MOD_BVALUES        0x80  // AND in this flag if berval structure used
  516.  
  517. typedef struct ldapmodW {
  518.      ULONG     mod_op;
  519.      PWCHAR    mod_type;
  520.      union {
  521.         PWCHAR  *modv_strvals;
  522.         struct berval   **modv_bvals;
  523.     } mod_vals;
  524. } LDAPModW, *PLDAPModW;
  525.  
  526. typedef struct ldapmodA {
  527.      ULONG     mod_op;
  528.      PCHAR     mod_type;
  529.      union {
  530.         PCHAR  *modv_strvals;
  531.         struct berval   **modv_bvals;
  532.     } mod_vals;
  533. } LDAPModA, *PLDAPModA;
  534.  
  535. #if LDAP_UNICODE
  536. #define LDAPMod LDAPModW
  537. #define PLDAPMod PLDAPModW
  538. #else
  539. #define LDAPMod LDAPModA
  540. #define PLDAPMod PLDAPModA
  541. #endif
  542.  
  543. #if !defined(_WIN64)
  544. #pragma pack(pop)
  545. #endif
  546.  
  547. //
  548. //  macros compatible with reference implementation...
  549. //
  550.  
  551. #define LDAP_IS_CLDAP( ld ) ( (ld)->ld_sb.sb_naddr > 0 )
  552. #define mod_values      mod_vals.modv_strvals
  553. #define mod_bvalues     mod_vals.modv_bvals
  554. #define NAME_ERROR(n)   ((n & 0xf0) == 0x20)
  555.  
  556. //
  557. //  function definitions for LDAP API
  558. //
  559.  
  560. //
  561. //  Create a connection block to an LDAP server.  HostName can be NULL, in
  562. //  which case we'll try to go off and find the "default" LDAP server.
  563. //
  564. //  Note that if we have to go off and find the default server, we'll pull
  565. //  in NETAPI32.DLL and ADVAPI32.DLL.
  566. //
  567. //  If it returns NULL, an error occurred.  Pick up error code with
  568. //     GetLastError().
  569. //
  570. //  ldap_open actually opens the connection at the time of the call,
  571. //  whereas ldap_init only opens the connection when an operation is performed
  572. //  that requires it.
  573. //
  574. //  multi-thread: ldap_open*, ldap_init*, and ldap_sslinit* calls are safe.
  575. //
  576.  
  577. WINLDAPAPI LDAP * LDAPAPI ldap_openW( const PWCHAR HostName, ULONG PortNumber );
  578. WINLDAPAPI LDAP * LDAPAPI ldap_openA( const PCHAR HostName, ULONG PortNumber );
  579.  
  580. WINLDAPAPI LDAP * LDAPAPI ldap_initW( const PWCHAR HostName, ULONG PortNumber );
  581. WINLDAPAPI LDAP * LDAPAPI ldap_initA( const PCHAR HostName, ULONG PortNumber );
  582.  
  583. WINLDAPAPI LDAP * LDAPAPI ldap_sslinitW( PWCHAR HostName, ULONG PortNumber, int secure );
  584. WINLDAPAPI LDAP * LDAPAPI ldap_sslinitA( PCHAR HostName, ULONG PortNumber, int secure );
  585.  
  586. //
  587. //  when calling ldap_init, you can call ldap_connect explicitly to have the
  588. //  library contact the server.  This is useful for checking for server
  589. //  availability.  This call is not required however, since the other functions
  590. //  will call it internally if it hasn't already been called.
  591. //
  592.  
  593. WINLDAPAPI ULONG LDAPAPI ldap_connect(  LDAP *ld,
  594.                                         struct l_timeval  *timeout
  595.                                         );
  596.  
  597. #if LDAP_UNICODE
  598.  
  599. #define ldap_open ldap_openW
  600. #define ldap_init ldap_initW
  601. #define ldap_sslinit ldap_sslinitW
  602.  
  603. #else
  604.  
  605. WINLDAPAPI LDAP * LDAPAPI ldap_open( PCHAR HostName, ULONG PortNumber );
  606. WINLDAPAPI LDAP * LDAPAPI ldap_init( PCHAR HostName, ULONG PortNumber );
  607. WINLDAPAPI LDAP * LDAPAPI ldap_sslinit( PCHAR HostName, ULONG PortNumber, int secure );
  608.  
  609. #endif
  610.  
  611. //
  612. //  This is similar to ldap_open except it creates a connection block for
  613. //  UDP based Connectionless LDAP services.  No TCP session is maintained.
  614. //
  615. //  If it returns NULL, an error occurred.  Pick up error code with
  616. //     GetLastError().
  617. //
  618. //  multi-thread: cldap_open* calls are safe.
  619. //
  620.  
  621. WINLDAPAPI LDAP * LDAPAPI cldap_openW( PWCHAR HostName, ULONG PortNumber );
  622. WINLDAPAPI LDAP * LDAPAPI cldap_openA( PCHAR HostName, ULONG PortNumber );
  623.  
  624.  
  625. #if LDAP_UNICODE
  626.  
  627. #define cldap_open cldap_openW
  628.  
  629. #else
  630.  
  631. WINLDAPAPI LDAP * LDAPAPI cldap_open( PCHAR HostName, ULONG PortNumber );
  632.  
  633. #endif
  634.  
  635.  
  636.  
  637. //
  638. //  Call unbind when you're done with the connection, it will free all
  639. //  resources associated with the connection.
  640. //
  641. //  There is no ldap_close... use ldap_unbind even if you haven't called
  642. //  ldap_bind on the connection.
  643. //
  644. //  multi-thread: ldap_unbind* calls are safe EXCEPT don't use the LDAP *
  645. //                stucture after it's been freed.
  646. //
  647.  
  648. WINLDAPAPI ULONG LDAPAPI ldap_unbind( LDAP *ld );
  649. WINLDAPAPI ULONG LDAPAPI ldap_unbind_s( LDAP *ld ); // calls ldap_unbind
  650.  
  651. //
  652. //  Calls to get and set options on connection blocks... use them rather
  653. //  than modifying the LDAP block directly.
  654. //
  655. //
  656. //  multi-thread: ldap_get_option is safe
  657. //  multi-thread: ldap_set_option is not safe in that it affects the
  658. //                connection as a whole.  beware if threads share connections.
  659.  
  660.  
  661. WINLDAPAPI ULONG LDAPAPI ldap_get_option( LDAP *ld, int option, void *outvalue );
  662. WINLDAPAPI ULONG LDAPAPI ldap_get_optionW( LDAP *ld, int option, void *outvalue );
  663.  
  664. WINLDAPAPI ULONG LDAPAPI ldap_set_option( LDAP *ld, int option, const void *invalue );
  665. WINLDAPAPI ULONG LDAPAPI ldap_set_optionW( LDAP *ld, int option, const void *invalue );
  666.  
  667. #if LDAP_UNICODE
  668.  
  669. #define ldap_get_option ldap_get_optionW
  670. #define ldap_set_option ldap_set_optionW
  671.  
  672. #endif
  673.  
  674. //
  675. //  These are the values to pass to ldap_get/set_option :
  676. //
  677.  
  678. #define LDAP_OPT_DESC               0x01
  679. #define LDAP_OPT_DEREF              0x02
  680. #define LDAP_OPT_SIZELIMIT          0x03
  681. #define LDAP_OPT_TIMELIMIT          0x04
  682. #define LDAP_OPT_THREAD_FN_PTRS     0x05
  683. #define LDAP_OPT_REBIND_FN          0x06
  684. #define LDAP_OPT_REBIND_ARG         0x07
  685. #define LDAP_OPT_REFERRALS          0x08
  686. #define LDAP_OPT_RESTART            0x09
  687.  
  688. #define LDAP_OPT_SSL                0x0a
  689. #define LDAP_OPT_IO_FN_PTRS         0x0b
  690. #define LDAP_OPT_CACHE_FN_PTRS      0x0d
  691. #define LDAP_OPT_CACHE_STRATEGY     0x0e
  692. #define LDAP_OPT_CACHE_ENABLE       0x0f
  693. #define LDAP_OPT_REFERRAL_HOP_LIMIT 0x10
  694.  
  695. #define LDAP_OPT_PROTOCOL_VERSION   0x11        // known by two names.
  696. #define LDAP_OPT_VERSION            0x11
  697.  
  698. //
  699. //  These are new ones that we've defined, not in current RFC draft.
  700. //
  701.  
  702. #define LDAP_OPT_HOST_NAME          0x30
  703. #define LDAP_OPT_ERROR_NUMBER       0x31
  704. #define LDAP_OPT_ERROR_STRING       0x32
  705. #define LDAP_OPT_SERVER_ERROR       0x33
  706. #define LDAP_OPT_SERVER_EXT_ERROR   0x34
  707. #define LDAP_OPT_HOST_REACHABLE     0x3E
  708.  
  709. //
  710. //  These options control the keep-alive logic.  Keep alives are sent as
  711. //  ICMP ping messages (which currently don't go through firewalls).
  712. //
  713. //  There are three values that control how this works :
  714. //  PING_KEEP_ALIVE : min number of seconds since we last received a response
  715. //                    from the server before we send a keep-alive ping
  716. //  PING_WAIT_TIME  : number of milliseconds we wait for the response to
  717. //                    come back when we send a ping
  718. //  PING_LIMIT      : number of unanswered pings we send before we close the
  719. //                    connection.
  720. //
  721. //  To disable the keep-alive logic, set any of the values (PING_KEEP_ALIVE,
  722. //  PING_LIMIT, or PING_WAIT_TIME) to zero.
  723. //
  724. //  The current default/min/max for these values are as follows :
  725. //
  726. //  PING_KEEP_ALIVE :  120/5/maxInt  seconds (may also be zero)
  727. //  PING_WAIT_TIME  :  2000/10/60000 milliseconds (may also be zero)
  728. //  PING_LIMIT      :  4/0/maxInt
  729. //
  730.  
  731. #define LDAP_OPT_PING_KEEP_ALIVE    0x36
  732. #define LDAP_OPT_PING_WAIT_TIME     0x37
  733. #define LDAP_OPT_PING_LIMIT         0x38
  734.  
  735. //
  736. //  These won't be in the RFC.  Only use these if you're going to be dependent
  737. //  on our implementation.
  738. //
  739.  
  740. #define LDAP_OPT_DNSDOMAIN_NAME     0x3B    // return DNS name of domain
  741. #define LDAP_OPT_GETDSNAME_FLAGS    0x3D    // flags for DsGetDcName
  742.  
  743. #define LDAP_OPT_PROMPT_CREDENTIALS 0x3F    // prompt for creds? currently
  744.                                             // only for DPA & NTLM if no creds
  745.                                             // are loaded
  746.  
  747. #define LDAP_OPT_AUTO_RECONNECT     0x91    // enable/disable autoreconnect
  748. #define LDAP_OPT_SSPI_FLAGS         0x92    // flags to pass to InitSecurityContext
  749.  
  750. //
  751. // To retrieve information on an secure connection, a pointer to a
  752. // SecPkgContext_connectionInfo structure (defined in schnlsp.h) must be
  753. // passed in. On success, it is filled with relevent security information.
  754. //
  755.  
  756. #define LDAP_OPT_SSL_INFO           0x93
  757.  
  758. //
  759. // Turing on either the sign or the encrypt option prior to binding using
  760. // LDAP_AUTH_NEGOTIATE will result in the ensuing LDAP session to be signed
  761. // or encrypted using either Kerberos or NTLM (as negotiated by the underlying
  762. // security packages). Note that these options can't be used with SSL.
  763. //
  764.  
  765. #define LDAP_OPT_SIGN               0x95
  766. #define LDAP_OPT_ENCRYPT            0x96
  767.  
  768. //
  769. // The user can set a preferred SASL method prior to binding using LDAP_AUTH_NEGOTIATE
  770. // We will try to use this mechanism while binding. One example is "GSSAPI".
  771. //
  772.  
  773. #define LDAP_OPT_SASL_METHOD        0x97
  774.  
  775. //
  776. // Setting this option to LDAP_OPT_ON will instruct the library to only perform an
  777. // A-Record DNS lookup on the supplied host string. This option is OFF by default.
  778. //
  779.  
  780. #define LDAP_OPT_AREC_EXCLUSIVE     0x98
  781.  
  782. //
  783. // Retrieve the security context associated with the connection.
  784. //
  785.  
  786. #define LDAP_OPT_SECURITY_CONTEXT   0x99
  787.  
  788. //
  789. //  End of Microsoft only options
  790. //
  791.  
  792. #define LDAP_OPT_ON                 ((void *) 1)
  793. #define LDAP_OPT_OFF                ((void *) 0)
  794.  
  795. //
  796. //  For chasing referrals, we extend this a bit for LDAP_OPT_REFERRALS.  If
  797. //  the value is not LDAP_OPT_ON or LDAP_OPT_OFF, we'll treat them as the
  798. //  following :
  799. //
  800. //  LDAP_CHASE_SUBORDINATE_REFERRALS  : chase subordinate referrals (or
  801. //                                      references) returned in a v3 search
  802. //  LDAP_CHASE_EXTERNAL_REFERRALS : chase external referrals. These are
  803. //                          returned possibly on any operation except bind.
  804. //
  805. //  If you OR these flags together, it's equivalent to setting referrals to
  806. //  LDAP_OPT_ON.
  807. //
  808.  
  809. #define LDAP_CHASE_SUBORDINATE_REFERRALS    0x00000020
  810. #define LDAP_CHASE_EXTERNAL_REFERRALS       0x00000040
  811.  
  812. //
  813. //  Bind is required as the first operation to v2 servers, not so for v3
  814. //  servers.  See above description of authentication methods.
  815. //
  816. //  multi-thread: bind calls are not safe in that it affects the
  817. //                connection as a whole.  beware if threads share connections
  818. //                and try to mulithread binds with other operations.
  819.  
  820.  
  821. WINLDAPAPI ULONG LDAPAPI ldap_simple_bindW( LDAP *ld, PWCHAR dn, PWCHAR passwd );
  822. WINLDAPAPI ULONG LDAPAPI ldap_simple_bindA( LDAP *ld, PCHAR dn, PCHAR passwd );
  823. WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_sW( LDAP *ld, PWCHAR dn, PWCHAR passwd );
  824. WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_sA( LDAP *ld, PCHAR dn, PCHAR passwd );
  825.  
  826. WINLDAPAPI ULONG LDAPAPI ldap_bindW( LDAP *ld, PWCHAR dn, PWCHAR cred, ULONG method );
  827. WINLDAPAPI ULONG LDAPAPI ldap_bindA( LDAP *ld, PCHAR dn, PCHAR cred, ULONG method );
  828. WINLDAPAPI ULONG LDAPAPI ldap_bind_sW( LDAP *ld, PWCHAR dn, PWCHAR cred, ULONG method );
  829. WINLDAPAPI ULONG LDAPAPI ldap_bind_sA( LDAP *ld, PCHAR dn, PCHAR cred, ULONG method );
  830.  
  831.  
  832. //
  833. // The following functions can be used to pass in any arbitrary credentials
  834. // to the server. The application must be ready to interpret the response
  835. // sent back from the server.
  836. //
  837.  
  838.  WINLDAPAPI INT LDAPAPI ldap_sasl_bindA(
  839.          LDAP  *ExternalHandle,
  840.          const  PCHAR DistName,
  841.          const PCHAR AuthMechanism,
  842.          const BERVAL   *cred,
  843.          PLDAPControlA *ServerCtrls,
  844.          PLDAPControlA *ClientCtrls,
  845.          int *MessageNumber
  846.          );
  847.  
  848.  WINLDAPAPI INT LDAPAPI ldap_sasl_bindW(
  849.          LDAP  *ExternalHandle,
  850.          const PWCHAR DistName,
  851.          const PWCHAR AuthMechanism,
  852.          const BERVAL   *cred,
  853.          PLDAPControlW *ServerCtrls,
  854.          PLDAPControlW *ClientCtrls,
  855.          int *MessageNumber
  856.          );
  857.  
  858.  WINLDAPAPI INT LDAPAPI ldap_sasl_bind_sA(
  859.          LDAP  *ExternalHandle,
  860.          const PCHAR DistName,
  861.          const PCHAR AuthMechanism,
  862.          const BERVAL   *cred,
  863.          PLDAPControlA *ServerCtrls,
  864.          PLDAPControlA *ClientCtrls,
  865.          PBERVAL *ServerData
  866.          );
  867.  
  868.  WINLDAPAPI INT LDAPAPI ldap_sasl_bind_sW(
  869.          LDAP  *ExternalHandle,
  870.          const PWCHAR DistName,
  871.          const PWCHAR AuthMechanism,
  872.          const BERVAL   *cred,
  873.          PLDAPControlW *ServerCtrls,
  874.          PLDAPControlW *ClientCtrls,
  875.          PBERVAL *ServerData
  876.          );
  877.  
  878.  
  879. #if LDAP_UNICODE
  880.  
  881. #define ldap_simple_bind ldap_simple_bindW
  882. #define ldap_simple_bind_s ldap_simple_bind_sW
  883.  
  884. #define ldap_bind ldap_bindW
  885. #define ldap_bind_s ldap_bind_sW
  886.  
  887. #define ldap_sasl_bind ldap_sasl_bindW
  888. #define ldap_sasl_bind_s ldap_sasl_bind_sW
  889.  
  890. #else
  891.  
  892. WINLDAPAPI ULONG LDAPAPI ldap_simple_bind( LDAP *ld, const PCHAR dn, const PCHAR passwd );
  893. WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_s( LDAP *ld, const PCHAR dn, const PCHAR passwd );
  894.  
  895. WINLDAPAPI ULONG LDAPAPI ldap_bind( LDAP *ld, const PCHAR dn, const PCHAR cred, ULONG method );
  896. WINLDAPAPI ULONG LDAPAPI ldap_bind_s( LDAP *ld, const PCHAR dn, const PCHAR cred, ULONG method );
  897.  
  898. #define ldap_sasl_bind ldap_sasl_bindA
  899. #define ldap_sasl_bind_s ldap_sasl_bind_sA
  900.  
  901. #endif
  902.  
  903. //
  904. //  Synchronous and asynch search routines.
  905. //
  906. //  filter follows RFC 1960 with the addition that '(' ')' '*' ' ' '\' and
  907. //   '\0' are all escaped with '\'
  908. //
  909. // Scope of search.  This corresponds to the "scope" parameter on search
  910.  
  911. #define LDAP_SCOPE_BASE         0x00
  912. #define LDAP_SCOPE_ONELEVEL     0x01
  913. #define LDAP_SCOPE_SUBTREE      0x02
  914.  
  915. //
  916. //  multi-thread: ldap_search calls are not safe in that the message number
  917. //                is returned rather than the return code.  You have to look
  918. //                at the connection block in an error case and the return code
  919. //                may be overwritten by another thread inbetween.
  920. //
  921. //                Use ldap_search_ext instead, as these are thread safe.
  922. //
  923. //                ldap_search_s and ldap_search_ext* calls are thread safe.
  924. //
  925.  
  926. WINLDAPAPI ULONG LDAPAPI ldap_searchW(
  927.         LDAP    *ld,
  928.         const PWCHAR  base,     // distinguished name or ""
  929.         ULONG   scope,          // LDAP_SCOPE_xxxx
  930.         const PWCHAR  filter,
  931.         PWCHAR  attrs[],        // pointer to an array of PCHAR attribute names
  932.         ULONG   attrsonly       // boolean on whether to only return attr names
  933.     );
  934. WINLDAPAPI ULONG LDAPAPI ldap_searchA(
  935.         LDAP    *ld,
  936.         const PCHAR   base,     // distinguished name or ""
  937.         ULONG   scope,          // LDAP_SCOPE_xxxx
  938.         const PCHAR   filter,
  939.         PCHAR   attrs[],        // pointer to an array of PCHAR attribute names
  940.         ULONG   attrsonly       // boolean on whether to only return attr names
  941.     );
  942.  
  943. WINLDAPAPI ULONG LDAPAPI ldap_search_sW(
  944.         LDAP            *ld,
  945.         const PWCHAR    base,
  946.         ULONG           scope,
  947.         const PWCHAR    filter,
  948.         PWCHAR          attrs[],
  949.         ULONG           attrsonly,
  950.         LDAPMessage     **res
  951.     );
  952. WINLDAPAPI ULONG LDAPAPI ldap_search_sA(
  953.         LDAP            *ld,
  954.         const PCHAR     base,
  955.         ULONG           scope,
  956.         const PCHAR     filter,
  957.         PCHAR           attrs[],
  958.         ULONG           attrsonly,
  959.         LDAPMessage     **res
  960.     );
  961.  
  962. WINLDAPAPI ULONG LDAPAPI ldap_search_stW(
  963.         LDAP            *ld,
  964.         const PWCHAR    base,
  965.         ULONG           scope,
  966.         const PWCHAR    filter,
  967.         PWCHAR          attrs[],
  968.         ULONG           attrsonly,
  969.         struct l_timeval  *timeout,
  970.         LDAPMessage     **res
  971.     );
  972. WINLDAPAPI ULONG LDAPAPI ldap_search_stA(
  973.         LDAP            *ld,
  974.         const PCHAR     base,
  975.         ULONG           scope,
  976.         const PCHAR     filter,
  977.         PCHAR           attrs[],
  978.         ULONG           attrsonly,
  979.         struct l_timeval  *timeout,
  980.         LDAPMessage     **res
  981.     );
  982.  
  983.  
  984. WINLDAPAPI ULONG LDAPAPI ldap_search_extW(
  985.         LDAP            *ld,
  986.         const PWCHAR    base,
  987.         ULONG           scope,
  988.         const PWCHAR    filter,
  989.         PWCHAR          attrs[],
  990.         ULONG           attrsonly,
  991.         PLDAPControlW   *ServerControls,
  992.         PLDAPControlW   *ClientControls,
  993.         ULONG           TimeLimit,
  994.         ULONG           SizeLimit,
  995.         ULONG           *MessageNumber
  996.     );
  997.  
  998. WINLDAPAPI ULONG LDAPAPI ldap_search_extA(
  999.         LDAP            *ld,
  1000.         const PCHAR     base,
  1001.         ULONG           scope,
  1002.         const PCHAR     filter,
  1003.         PCHAR           attrs[],
  1004.         ULONG           attrsonly,
  1005.         PLDAPControlA   *ServerControls,
  1006.         PLDAPControlA   *ClientControls,
  1007.         ULONG           TimeLimit,
  1008.         ULONG           SizeLimit,
  1009.         ULONG           *MessageNumber
  1010.     );
  1011.  
  1012. WINLDAPAPI ULONG LDAPAPI ldap_search_ext_sW(
  1013.         LDAP            *ld,
  1014.         const PWCHAR    base,
  1015.         ULONG           scope,
  1016.         const PWCHAR    filter,
  1017.         PWCHAR          attrs[],
  1018.         ULONG           attrsonly,
  1019.         PLDAPControlW   *ServerControls,
  1020.         PLDAPControlW   *ClientControls,
  1021.         struct l_timeval  *timeout,
  1022.         ULONG           SizeLimit,
  1023.         LDAPMessage     **res
  1024.     );
  1025.  
  1026. WINLDAPAPI ULONG LDAPAPI ldap_search_ext_sA(
  1027.         LDAP            *ld,
  1028.         const PCHAR     base,
  1029.         ULONG           scope,
  1030.         const PCHAR     filter,
  1031.         PCHAR           attrs[],
  1032.         ULONG           attrsonly,
  1033.         PLDAPControlA   *ServerControls,
  1034.         PLDAPControlA   *ClientControls,
  1035.         struct l_timeval  *timeout,
  1036.         ULONG           SizeLimit,
  1037.         LDAPMessage     **res
  1038.     );
  1039.  
  1040. #if LDAP_UNICODE
  1041.  
  1042. #define ldap_search ldap_searchW
  1043. #define ldap_search_s ldap_search_sW
  1044. #define ldap_search_st ldap_search_stW
  1045.  
  1046. #define ldap_search_ext ldap_search_extW
  1047. #define ldap_search_ext_s ldap_search_ext_sW
  1048.  
  1049. #else
  1050.  
  1051. WINLDAPAPI ULONG LDAPAPI ldap_search(
  1052.         LDAP    *ld,
  1053.         PCHAR   base,           // distinguished name or ""
  1054.         ULONG   scope,          // LDAP_SCOPE_xxxx
  1055.         PCHAR   filter,
  1056.         PCHAR   attrs[],        // pointer to an array of PCHAR attribute names
  1057.         ULONG   attrsonly       // boolean on whether to only return attr names
  1058.     );
  1059.  
  1060. WINLDAPAPI ULONG LDAPAPI ldap_search_s(
  1061.         LDAP            *ld,
  1062.         PCHAR           base,
  1063.         ULONG           scope,
  1064.         PCHAR           filter,
  1065.         PCHAR           attrs[],
  1066.         ULONG           attrsonly,
  1067.         LDAPMessage     **res
  1068.     );
  1069.  
  1070. WINLDAPAPI ULONG LDAPAPI ldap_search_st(
  1071.         LDAP            *ld,
  1072.         PCHAR           base,
  1073.         ULONG           scope,
  1074.         PCHAR           filter,
  1075.         PCHAR           attrs[],
  1076.         ULONG           attrsonly,
  1077.         struct l_timeval  *timeout,
  1078.         LDAPMessage     **res
  1079.     );
  1080.  
  1081. WINLDAPAPI ULONG LDAPAPI ldap_search_ext(
  1082.         LDAP            *ld,
  1083.         PCHAR           base,
  1084.         ULONG           scope,
  1085.         PCHAR           filter,
  1086.         PCHAR           attrs[],
  1087.         ULONG           attrsonly,
  1088.         PLDAPControlA   *ServerControls,
  1089.         PLDAPControlA   *ClientControls,
  1090.         ULONG           TimeLimit,
  1091.         ULONG           SizeLimit,
  1092.         ULONG           *MessageNumber
  1093.     );
  1094.  
  1095. WINLDAPAPI ULONG LDAPAPI ldap_search_ext_s(
  1096.         LDAP            *ld,
  1097.         PCHAR           base,
  1098.         ULONG           scope,
  1099.         PCHAR           filter,
  1100.         PCHAR           attrs[],
  1101.         ULONG           attrsonly,
  1102.         PLDAPControlA   *ServerControls,
  1103.         PLDAPControlA   *ClientControls,
  1104.         struct l_timeval  *timeout,
  1105.         ULONG           SizeLimit,
  1106.         LDAPMessage     **res
  1107.     );
  1108.  
  1109. #endif
  1110.  
  1111. //
  1112. //  Extended API to check filter syntax.  Returns LDAP error code if syntax
  1113. //  is invalid or LDAP_SUCCESS if it's ok.
  1114. //
  1115.  
  1116. WINLDAPAPI ULONG LDAPAPI
  1117. ldap_check_filterW(
  1118.         LDAP    *ld,
  1119.         PWCHAR  SearchFilter
  1120.     );
  1121.  
  1122. WINLDAPAPI ULONG LDAPAPI
  1123. ldap_check_filterA(
  1124.         LDAP    *ld,
  1125.         PCHAR   SearchFilter
  1126.     );
  1127.  
  1128. #if LDAP_UNICODE
  1129. #define ldap_check_filter ldap_check_filterW
  1130. #else
  1131. #define ldap_check_filter ldap_check_filterA
  1132. #endif
  1133.  
  1134.  
  1135. //
  1136. //  modify an existing entry
  1137. //
  1138.  
  1139. //
  1140. //  multi-thread: ldap_modify calls are not safe in that the message number
  1141. //                is returned rather than the return code.  You have to look
  1142. //                at the connection block in an error case and the return code
  1143. //                may be overwritten by another thread inbetween.
  1144. //
  1145. //                Use ldap_modify_ext instead, as these are thread safe.
  1146. //
  1147. //                ldap_modify_s and ldap_modify_ext* calls are thread safe.
  1148. //
  1149.  
  1150. WINLDAPAPI ULONG LDAPAPI ldap_modifyW( LDAP *ld, PWCHAR dn, LDAPModW *mods[] );
  1151. WINLDAPAPI ULONG LDAPAPI ldap_modifyA( LDAP *ld, PCHAR dn, LDAPModA *mods[] );
  1152.  
  1153. WINLDAPAPI ULONG LDAPAPI ldap_modify_sW( LDAP *ld, PWCHAR dn, LDAPModW *mods[] );
  1154. WINLDAPAPI ULONG LDAPAPI ldap_modify_sA( LDAP *ld, PCHAR dn, LDAPModA *mods[] );
  1155.  
  1156. WINLDAPAPI ULONG LDAPAPI ldap_modify_extW(
  1157.         LDAP *ld,
  1158.         const PWCHAR dn,
  1159.         LDAPModW *mods[],
  1160.         PLDAPControlW   *ServerControls,
  1161.         PLDAPControlW   *ClientControls,
  1162.         ULONG           *MessageNumber
  1163.         );
  1164.  
  1165. WINLDAPAPI ULONG LDAPAPI ldap_modify_extA(
  1166.         LDAP *ld,
  1167.         const PCHAR dn,
  1168.         LDAPModA *mods[],
  1169.         PLDAPControlA   *ServerControls,
  1170.         PLDAPControlA   *ClientControls,
  1171.         ULONG           *MessageNumber
  1172.         );
  1173.  
  1174. WINLDAPAPI ULONG LDAPAPI ldap_modify_ext_sW(
  1175.         LDAP *ld,
  1176.         const PWCHAR dn,
  1177.         LDAPModW *mods[],
  1178.         PLDAPControlW   *ServerControls,
  1179.         PLDAPControlW   *ClientControls
  1180.         );
  1181.  
  1182. WINLDAPAPI ULONG LDAPAPI ldap_modify_ext_sA(
  1183.         LDAP *ld,
  1184.         const PCHAR dn,
  1185.         LDAPModA *mods[],
  1186.         PLDAPControlA   *ServerControls,
  1187.         PLDAPControlA   *ClientControls
  1188.         );
  1189.  
  1190. #if LDAP_UNICODE
  1191.  
  1192. #define ldap_modify ldap_modifyW
  1193. #define ldap_modify_s ldap_modify_sW
  1194.  
  1195. #define ldap_modify_ext ldap_modify_extW
  1196. #define ldap_modify_ext_s ldap_modify_ext_sW
  1197.  
  1198. #else
  1199.  
  1200. WINLDAPAPI ULONG LDAPAPI ldap_modify( LDAP *ld, PCHAR dn, LDAPModA *mods[] );
  1201. WINLDAPAPI ULONG LDAPAPI ldap_modify_s( LDAP *ld, PCHAR dn, LDAPModA *mods[] );
  1202.  
  1203. WINLDAPAPI ULONG LDAPAPI ldap_modify_ext(
  1204.         LDAP *ld,
  1205.         const PCHAR dn,
  1206.         LDAPModA *mods[],
  1207.         PLDAPControlA   *ServerControls,
  1208.         PLDAPControlA   *ClientControls,
  1209.         ULONG           *MessageNumber
  1210.         );
  1211.  
  1212. WINLDAPAPI ULONG LDAPAPI ldap_modify_ext_s(
  1213.         LDAP *ld,
  1214.         const PCHAR dn,
  1215.         LDAPModA *mods[],
  1216.         PLDAPControlA   *ServerControls,
  1217.         PLDAPControlA   *ClientControls
  1218.         );
  1219. #endif
  1220.  
  1221. //
  1222. //  modrdn and modrdn2 function both as RenameObject and MoveObject.
  1223. //
  1224. //  Note that to LDAP v2 servers, only rename within a given container
  1225. //  is supported... therefore NewDistinguishedName is actually NewRDN.
  1226. //  Here are some examples :
  1227. //
  1228. //  This works to both v2 and v3 servers :
  1229. //
  1230. //    DN = CN=Bob,OU=FOO,O=BAR
  1231. //    NewDN = CN=Joe
  1232. //
  1233. //    result is: CN=Joe,OU=FOO,O=BAR
  1234. //
  1235. //  This works to only v3 and above servers :
  1236. //
  1237. //    DN = CN=Bob,OU=FOO,O=BAR
  1238. //    NewDN = CN=Joe,OU=FOOBAR,O=BAR
  1239. //
  1240. //    result is: CN=Joe,OU=FOOBAR,O=BAR
  1241. //
  1242. //  If you try the second example to a v2 server, we'll send the whole
  1243. //  NewDN over as the new RDN (rather than break up the parent OU and
  1244. //  child).  The server will then give you back some unknown error.
  1245. //
  1246.  
  1247. //
  1248. //  multi-thread: ldap_modrdn and ldap_modrdn2 calls are not safe in that
  1249. //                the message number is returned rather than the return code.
  1250. //                You have to look   at the connection block in an error case
  1251. //                and the return code may be overwritten by another thread
  1252. //                inbetween.
  1253. //
  1254. //                Use ldap_rename_ext instead, as these are thread safe.
  1255. //
  1256.  
  1257. WINLDAPAPI ULONG LDAPAPI ldap_modrdn2W (
  1258.     LDAP    *ExternalHandle,
  1259.     const PWCHAR  DistinguishedName,
  1260.     const PWCHAR  NewDistinguishedName,
  1261.     INT     DeleteOldRdn
  1262.     );
  1263. WINLDAPAPI ULONG LDAPAPI ldap_modrdn2A (
  1264.     LDAP    *ExternalHandle,
  1265.     const PCHAR   DistinguishedName,
  1266.     const PCHAR   NewDistinguishedName,
  1267.     INT     DeleteOldRdn
  1268.     );
  1269.  
  1270. //
  1271. //  ldap_modrdn simply calls ldap_modrdn2 with a value of 1 for DeleteOldRdn.
  1272. //
  1273.  
  1274. WINLDAPAPI ULONG LDAPAPI ldap_modrdnW (
  1275.     LDAP    *ExternalHandle,
  1276.     const PWCHAR   DistinguishedName,
  1277.     const PWCHAR   NewDistinguishedName
  1278.     );
  1279. WINLDAPAPI ULONG LDAPAPI ldap_modrdnA (
  1280.     LDAP    *ExternalHandle,
  1281.     const PCHAR   DistinguishedName,
  1282.     const PCHAR   NewDistinguishedName
  1283.     );
  1284.  
  1285. WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_sW (
  1286.     LDAP    *ExternalHandle,
  1287.     const PWCHAR   DistinguishedName,
  1288.     const PWCHAR   NewDistinguishedName,
  1289.     INT     DeleteOldRdn
  1290.     );
  1291. WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_sA (
  1292.     LDAP    *ExternalHandle,
  1293.     const PCHAR   DistinguishedName,
  1294.     const PCHAR   NewDistinguishedName,
  1295.     INT     DeleteOldRdn
  1296.     );
  1297.  
  1298. WINLDAPAPI ULONG LDAPAPI ldap_modrdn_sW (
  1299.     LDAP    *ExternalHandle,
  1300.     const PWCHAR   DistinguishedName,
  1301.     const PWCHAR   NewDistinguishedName
  1302.     );
  1303. WINLDAPAPI ULONG LDAPAPI ldap_modrdn_sA (
  1304.     LDAP    *ExternalHandle,
  1305.     const PCHAR   DistinguishedName,
  1306.     const PCHAR   NewDistinguishedName
  1307.     );
  1308.  
  1309. #if LDAP_UNICODE
  1310.  
  1311. #define ldap_modrdn2 ldap_modrdn2W
  1312. #define ldap_modrdn ldap_modrdnW
  1313. #define ldap_modrdn2_s ldap_modrdn2_sW
  1314. #define ldap_modrdn_s ldap_modrdn_sW
  1315.  
  1316. #else
  1317.  
  1318. WINLDAPAPI ULONG LDAPAPI ldap_modrdn2 (
  1319.     LDAP    *ExternalHandle,
  1320.     const PCHAR   DistinguishedName,
  1321.     const PCHAR   NewDistinguishedName,
  1322.     INT     DeleteOldRdn
  1323.     );
  1324. WINLDAPAPI ULONG LDAPAPI ldap_modrdn (
  1325.     LDAP    *ExternalHandle,
  1326.     const PCHAR   DistinguishedName,
  1327.     const PCHAR   NewDistinguishedName
  1328.     );
  1329. WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_s (
  1330.     LDAP    *ExternalHandle,
  1331.     const PCHAR   DistinguishedName,
  1332.     const PCHAR   NewDistinguishedName,
  1333.     INT     DeleteOldRdn
  1334.     );
  1335. WINLDAPAPI ULONG LDAPAPI ldap_modrdn_s (
  1336.     LDAP    *ExternalHandle,
  1337.     const PCHAR   DistinguishedName,
  1338.     const PCHAR   NewDistinguishedName
  1339.     );
  1340.  
  1341. #endif
  1342.  
  1343. //
  1344. //  Extended Rename operations.  These take controls and separate out the
  1345. //  parent from the RDN, for clarity.
  1346. //
  1347.  
  1348. WINLDAPAPI ULONG LDAPAPI ldap_rename_extW(
  1349.         LDAP *ld,
  1350.         const PWCHAR dn,
  1351.         const PWCHAR NewRDN,
  1352.         const PWCHAR NewParent,
  1353.         INT DeleteOldRdn,
  1354.         PLDAPControlW   *ServerControls,
  1355.         PLDAPControlW   *ClientControls,
  1356.         ULONG           *MessageNumber
  1357.         );
  1358.  
  1359. WINLDAPAPI ULONG LDAPAPI ldap_rename_extA(
  1360.         LDAP *ld,
  1361.         const PCHAR dn,
  1362.         const PCHAR NewRDN,
  1363.         const PCHAR NewParent,
  1364.         INT DeleteOldRdn,
  1365.         PLDAPControlA   *ServerControls,
  1366.         PLDAPControlA   *ClientControls,
  1367.         ULONG           *MessageNumber
  1368.         );
  1369.  
  1370. WINLDAPAPI ULONG LDAPAPI ldap_rename_ext_sW(
  1371.         LDAP *ld,
  1372.         const PWCHAR dn,
  1373.         const PWCHAR NewRDN,
  1374.         const PWCHAR NewParent,
  1375.         INT DeleteOldRdn,
  1376.         PLDAPControlW   *ServerControls,
  1377.         PLDAPControlW   *ClientControls
  1378.         );
  1379.  
  1380. WINLDAPAPI ULONG LDAPAPI ldap_rename_ext_sA(
  1381.         LDAP *ld,
  1382.         const PCHAR dn,
  1383.         const PCHAR NewRDN,
  1384.         const PCHAR NewParent,
  1385.         INT DeleteOldRdn,
  1386.         PLDAPControlA   *ServerControls,
  1387.         PLDAPControlA   *ClientControls
  1388.         );
  1389.  
  1390. #if LDAP_UNICODE
  1391.  
  1392. #define ldap_rename   ldap_rename_extW
  1393. #define ldap_rename_s ldap_rename_ext_sW
  1394.  
  1395. #else
  1396.  
  1397. #define ldap_rename   ldap_rename_extA
  1398. #define ldap_rename_s ldap_rename_ext_sA
  1399.  
  1400. #endif
  1401.  
  1402. #if LDAP_UNICODE
  1403.  
  1404. #define ldap_rename_ext ldap_rename_extW
  1405. #define ldap_rename_ext_s ldap_rename_ext_sW
  1406.  
  1407. #else
  1408.  
  1409. WINLDAPAPI ULONG LDAPAPI ldap_rename_ext(
  1410.         LDAP *ld,
  1411.         const PCHAR dn,
  1412.         const PCHAR NewRDN,
  1413.         const PCHAR NewParent,
  1414.         INT DeleteOldRdn,
  1415.         PLDAPControlA   *ServerControls,
  1416.         PLDAPControlA   *ClientControls,
  1417.         ULONG           *MessageNumber
  1418.         );
  1419.  
  1420. WINLDAPAPI ULONG LDAPAPI ldap_rename_ext_s(
  1421.         LDAP *ld,
  1422.         const PCHAR dn,
  1423.         const PCHAR NewRDN,
  1424.         const PCHAR NewParent,
  1425.         INT DeleteOldRdn,
  1426.         PLDAPControlA   *ServerControls,
  1427.         PLDAPControlA   *ClientControls
  1428.         );
  1429. #endif
  1430.  
  1431. //
  1432. //  Add an entry to the tree
  1433. //
  1434.  
  1435. //
  1436. //  multi-thread: ldap_add calls are not safe in that the message number
  1437. //                is returned rather than the return code.  You have to look
  1438. //                at the connection block in an error case and the return code
  1439. //                may be overwritten by another thread inbetween.
  1440. //
  1441. //                Use ldap_add_ext instead, as these are thread safe.
  1442. //
  1443. //                ldap_add_s and ldap_add_ext* calls are thread safe.
  1444. //
  1445.  
  1446. WINLDAPAPI ULONG LDAPAPI ldap_addW( LDAP *ld, PWCHAR dn, LDAPModW *attrs[] );
  1447. WINLDAPAPI ULONG LDAPAPI ldap_addA( LDAP *ld, PCHAR dn, LDAPModA *attrs[] );
  1448.  
  1449. WINLDAPAPI ULONG LDAPAPI ldap_add_sW( LDAP *ld, PWCHAR dn, LDAPModW *attrs[] );
  1450. WINLDAPAPI ULONG LDAPAPI ldap_add_sA( LDAP *ld, PCHAR dn, LDAPModA *attrs[] );
  1451.  
  1452. WINLDAPAPI ULONG LDAPAPI ldap_add_extW(
  1453.         LDAP *ld,
  1454.         const PWCHAR dn,
  1455.         LDAPModW *attrs[],
  1456.         PLDAPControlW   *ServerControls,
  1457.         PLDAPControlW   *ClientControls,
  1458.         ULONG           *MessageNumber
  1459.         );
  1460.  
  1461. WINLDAPAPI ULONG LDAPAPI ldap_add_extA(
  1462.         LDAP *ld,
  1463.         const PCHAR dn,
  1464.         LDAPModA *attrs[],
  1465.         PLDAPControlA   *ServerControls,
  1466.         PLDAPControlA   *ClientControls,
  1467.         ULONG           *MessageNumber
  1468.         );
  1469.  
  1470. WINLDAPAPI ULONG LDAPAPI ldap_add_ext_sW(
  1471.         LDAP *ld,
  1472.         const PWCHAR dn,
  1473.         LDAPModW *attrs[],
  1474.         PLDAPControlW   *ServerControls,
  1475.         PLDAPControlW   *ClientControls
  1476.         );
  1477.  
  1478. WINLDAPAPI ULONG LDAPAPI ldap_add_ext_sA(
  1479.         LDAP *ld,
  1480.         const PCHAR dn,
  1481.         LDAPModA *attrs[],
  1482.         PLDAPControlA   *ServerControls,
  1483.         PLDAPControlA   *ClientControls
  1484.         );
  1485.  
  1486. #if LDAP_UNICODE
  1487.  
  1488. #define ldap_add ldap_addW
  1489. #define ldap_add_s ldap_add_sW
  1490.  
  1491. #define ldap_add_ext ldap_add_extW
  1492. #define ldap_add_ext_s ldap_add_ext_sW
  1493.  
  1494. #else
  1495.  
  1496. WINLDAPAPI ULONG LDAPAPI ldap_add( LDAP *ld, PCHAR dn, LDAPMod *attrs[] );
  1497. WINLDAPAPI ULONG LDAPAPI ldap_add_s( LDAP *ld, PCHAR dn, LDAPMod *attrs[] );
  1498.  
  1499. WINLDAPAPI ULONG LDAPAPI ldap_add_ext(
  1500.         LDAP *ld,
  1501.         const PCHAR dn,
  1502.         LDAPModA *attrs[],
  1503.         PLDAPControlA   *ServerControls,
  1504.         PLDAPControlA   *ClientControls,
  1505.         ULONG           *MessageNumber
  1506.         );
  1507.  
  1508. WINLDAPAPI ULONG LDAPAPI ldap_add_ext_s(
  1509.         LDAP *ld,
  1510.         const PCHAR dn,
  1511.         LDAPModA *attrs[],
  1512.         PLDAPControlA   *ServerControls,
  1513.         PLDAPControlA   *ClientControls
  1514.         );
  1515.  
  1516. #endif
  1517.  
  1518.  
  1519. //
  1520. //  Compare the attribute for a given entry to a known value.
  1521. //
  1522.  
  1523. //
  1524. //  multi-thread: ldap_compare calls are not safe in that the message number
  1525. //                is returned rather than the return code.  You have to look
  1526. //                at the connection block in an error case and the return code
  1527. //                may be overwritten by another thread inbetween.
  1528. //
  1529. //                Use ldap_compare_ext instead, as these are thread safe.
  1530. //
  1531. //                ldap_compare_s and ldap_compare_ext* calls are thread safe.
  1532. //
  1533.  
  1534.  
  1535. WINLDAPAPI ULONG LDAPAPI ldap_compareW( LDAP *ld, const PWCHAR dn, const PWCHAR attr, PWCHAR value );
  1536. WINLDAPAPI ULONG LDAPAPI ldap_compareA( LDAP *ld, const PCHAR dn, const PCHAR attr, PCHAR value );
  1537.  
  1538. WINLDAPAPI ULONG LDAPAPI ldap_compare_sW( LDAP *ld, const PWCHAR dn, const PWCHAR attr, PWCHAR value );
  1539. WINLDAPAPI ULONG LDAPAPI ldap_compare_sA( LDAP *ld, const PCHAR dn, const PCHAR attr, PCHAR value );
  1540.  
  1541. #if LDAP_UNICODE
  1542.  
  1543. #define ldap_compare ldap_compareW
  1544. #define ldap_compare_s ldap_compare_sW
  1545.  
  1546. #else
  1547.  
  1548. WINLDAPAPI ULONG LDAPAPI ldap_compare( LDAP *ld, const PCHAR dn, const PCHAR attr, PCHAR value );
  1549. WINLDAPAPI ULONG LDAPAPI ldap_compare_s( LDAP *ld, const PCHAR dn, const PCHAR attr, PCHAR value );
  1550.  
  1551. #endif
  1552.  
  1553. //
  1554. //  Extended Compare operations.  These take controls and are thread safe.
  1555. //  They also allow you to specify a bval structure for the data, so that it
  1556. //  isn't translated from Unicode or ANSI to UTF8.  Allows for comparison of
  1557. //  raw binary data.
  1558. //
  1559. //  Specify either Data or Value as not NULL.  If both are not NULL, the
  1560. //  berval Data will be used.
  1561. //
  1562.  
  1563. WINLDAPAPI ULONG LDAPAPI ldap_compare_extW(
  1564.         LDAP *ld,
  1565.         const PWCHAR dn,
  1566.         const PWCHAR Attr,
  1567.         const PWCHAR Value,           // either value or Data is not null, not both
  1568.         struct berval   *Data,
  1569.         PLDAPControlW   *ServerControls,
  1570.         PLDAPControlW   *ClientControls,
  1571.         ULONG           *MessageNumber
  1572.         );
  1573.  
  1574. WINLDAPAPI ULONG LDAPAPI ldap_compare_extA(
  1575.         LDAP *ld,
  1576.         const PCHAR dn,
  1577.         const PCHAR Attr,
  1578.         const PCHAR Value,            // either value or Data is not null, not both
  1579.         struct berval   *Data,
  1580.         PLDAPControlA   *ServerControls,
  1581.         PLDAPControlA   *ClientControls,
  1582.         ULONG           *MessageNumber
  1583.         );
  1584.  
  1585. WINLDAPAPI ULONG LDAPAPI ldap_compare_ext_sW(
  1586.         LDAP *ld,
  1587.         const PWCHAR dn,
  1588.         const PWCHAR Attr,
  1589.         const PWCHAR Value,           // either value or Data is not null, not both
  1590.         struct berval   *Data,
  1591.         PLDAPControlW   *ServerControls,
  1592.         PLDAPControlW   *ClientControls
  1593.         );
  1594.  
  1595. WINLDAPAPI ULONG LDAPAPI ldap_compare_ext_sA(
  1596.         LDAP *ld,
  1597.         const PCHAR dn,
  1598.         const PCHAR Attr,
  1599.         const PCHAR Value,            // either value or Data is not null, not both
  1600.         struct berval   *Data,
  1601.         PLDAPControlA   *ServerControls,
  1602.         PLDAPControlA   *ClientControls
  1603.         );
  1604.  
  1605. #if LDAP_UNICODE
  1606.  
  1607. #define ldap_compare_ext ldap_compare_extW
  1608. #define ldap_compare_ext_s ldap_compare_ext_sW
  1609.  
  1610. #else
  1611.  
  1612. WINLDAPAPI ULONG LDAPAPI ldap_compare_ext(
  1613.         LDAP *ld,
  1614.         const PCHAR dn,
  1615.         const PCHAR Attr,
  1616.         const PCHAR Value,            // either value or Data is not null, not both
  1617.         struct berval   *Data,
  1618.         PLDAPControlA   *ServerControls,
  1619.         PLDAPControlA   *ClientControls,
  1620.         ULONG           *MessageNumber
  1621.         );
  1622.  
  1623. WINLDAPAPI ULONG LDAPAPI ldap_compare_ext_s(
  1624.         LDAP *ld,
  1625.         const PCHAR dn,
  1626.         const PCHAR Attr,
  1627.         const PCHAR Value,            // either value or Data is not null, not both
  1628.         struct berval   *Data,
  1629.         PLDAPControlA   *ServerControls,
  1630.         PLDAPControlA   *ClientControls
  1631.         );
  1632. #endif
  1633.  
  1634.  
  1635. //
  1636. //  Delete an object out of the tree
  1637. //
  1638.  
  1639. //
  1640. //  multi-thread: ldap_delete calls are not safe in that the message number
  1641. //                is returned rather than the return code.  You have to look
  1642. //                at the connection block in an error case and the return code
  1643. //                may be overwritten by another thread inbetween.
  1644. //
  1645. //                Use ldap_delete_ext instead, as these are thread safe.
  1646. //
  1647. //                ldap_delete_s and ldap_delete_ext* calls are thread safe.
  1648. //
  1649.  
  1650.  
  1651. WINLDAPAPI ULONG LDAPAPI ldap_deleteW( LDAP *ld, const PWCHAR dn );
  1652. WINLDAPAPI ULONG LDAPAPI ldap_deleteA( LDAP *ld, const PCHAR dn );
  1653.  
  1654. WINLDAPAPI ULONG LDAPAPI ldap_delete_sW( LDAP *ld, const PWCHAR dn );
  1655. WINLDAPAPI ULONG LDAPAPI ldap_delete_sA( LDAP *ld, const PCHAR dn );
  1656.  
  1657. WINLDAPAPI ULONG LDAPAPI ldap_delete_extW(
  1658.         LDAP *ld,
  1659.         const PWCHAR dn,
  1660.         PLDAPControlW   *ServerControls,
  1661.         PLDAPControlW   *ClientControls,
  1662.         ULONG           *MessageNumber
  1663.         );
  1664.  
  1665. WINLDAPAPI ULONG LDAPAPI ldap_delete_extA(
  1666.         LDAP *ld,
  1667.         const PCHAR dn,
  1668.         PLDAPControlA   *ServerControls,
  1669.         PLDAPControlA   *ClientControls,
  1670.         ULONG           *MessageNumber
  1671.         );
  1672.  
  1673. WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_sW(
  1674.         LDAP *ld,
  1675.         const PWCHAR dn,
  1676.         PLDAPControlW   *ServerControls,
  1677.         PLDAPControlW   *ClientControls
  1678.         );
  1679.  
  1680. WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_sA(
  1681.         LDAP *ld,
  1682.         const PCHAR dn,
  1683.         PLDAPControlA   *ServerControls,
  1684.         PLDAPControlA   *ClientControls
  1685.         );
  1686.  
  1687. #if LDAP_UNICODE
  1688.  
  1689. #define ldap_delete ldap_deleteW
  1690. #define ldap_delete_ext ldap_delete_extW
  1691. #define ldap_delete_s ldap_delete_sW
  1692. #define ldap_delete_ext_s ldap_delete_ext_sW
  1693.  
  1694. #else
  1695.  
  1696. WINLDAPAPI ULONG LDAPAPI ldap_delete( LDAP *ld, PCHAR dn );
  1697. WINLDAPAPI ULONG LDAPAPI ldap_delete_s( LDAP *ld, PCHAR dn );
  1698.  
  1699. WINLDAPAPI ULONG LDAPAPI ldap_delete_ext(
  1700.         LDAP *ld,
  1701.         const PCHAR dn,
  1702.         PLDAPControlA   *ServerControls,
  1703.         PLDAPControlA   *ClientControls,
  1704.         ULONG           *MessageNumber
  1705.         );
  1706.  
  1707. WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_s(
  1708.         LDAP *ld,
  1709.         const PCHAR dn,
  1710.         PLDAPControlA   *ServerControls,
  1711.         PLDAPControlA   *ClientControls
  1712.         );
  1713. #endif
  1714.  
  1715.  
  1716.  
  1717. //
  1718. //  Give up on a request.  No guarentee that it got there as there is no
  1719. //  response from the server.
  1720. //
  1721.  
  1722. //  multi-thread: ldap_abandon calls are thread safe
  1723.  
  1724. WINLDAPAPI ULONG LDAPAPI ldap_abandon( LDAP *ld, ULONG msgid );
  1725.  
  1726.  
  1727.  
  1728. //
  1729. //  Possible values for "all" field in ldap_result.  We've enhanced it such
  1730. //  that if someone passes in LDAP_MSG_RECEIVED, we'll pass all values we've
  1731. //  received up to that point.
  1732. //
  1733.  
  1734. #define LDAP_MSG_ONE    0
  1735. #define LDAP_MSG_ALL    1
  1736. #define LDAP_MSG_RECEIVED  2
  1737.  
  1738. //
  1739. //  Get a response from a connection.  One enhancement here is that ld can
  1740. //  be null, in which case we'll return responses from any server.  Free
  1741. //  responses here with ldap_msgfree.
  1742. //
  1743. //  For connection-less LDAP, you should pass in both a LDAP connection
  1744. //  handle and a msgid.  This will ensure we know which request the app
  1745. //  is waiting on a reply to.  ( we actively resend request until we get
  1746. //  a response.)
  1747. //
  1748.  
  1749. //  multi-thread: ldap_result calls are thread safe
  1750.  
  1751. WINLDAPAPI ULONG LDAPAPI ldap_result(
  1752.         LDAP            *ld,
  1753.         ULONG           msgid,
  1754.         ULONG           all,
  1755.         struct l_timeval  *timeout,
  1756.         LDAPMessage     **res
  1757.     );
  1758.  
  1759. WINLDAPAPI ULONG LDAPAPI ldap_msgfree( LDAPMessage *res );
  1760.  
  1761. //
  1762. //  This parses a message and returns the error code.  It optionally frees
  1763. //  the message by calling ldap_msgfree.
  1764. //
  1765.  
  1766. //  multi-thread: ldap_result2error call is thread safe
  1767.  
  1768. WINLDAPAPI ULONG LDAPAPI ldap_result2error(
  1769.         LDAP            *ld,
  1770.         LDAPMessage     *res,
  1771.         ULONG           freeit      // boolean.. free the message?
  1772.     );
  1773.  
  1774.  
  1775. //
  1776. //  Similar to ldap_result2error, this parses responses from the server and
  1777. //  returns the appropriate fields.  Use this one if you want to get at the
  1778. //  referrals, matchingDNs, or server controls returned.
  1779. //
  1780.  
  1781. //  multi-thread: ldap_parse_result call is thread safe
  1782.  
  1783. WINLDAPAPI ULONG LDAPAPI ldap_parse_resultW (
  1784.         LDAP *Connection,
  1785.         LDAPMessage *ResultMessage,
  1786.         ULONG *ReturnCode OPTIONAL,          // returned by server
  1787.         PWCHAR *MatchedDNs OPTIONAL,         // free with ldap_memfree
  1788.         PWCHAR *ErrorMessage OPTIONAL,       // free with ldap_memfree
  1789.         PWCHAR **Referrals OPTIONAL,         // free with ldap_value_freeW
  1790.         PLDAPControlW **ServerControls OPTIONAL,    // free with ldap_free_controlsW
  1791.         BOOLEAN Freeit
  1792.         );
  1793.  
  1794. WINLDAPAPI ULONG LDAPAPI ldap_parse_resultA (
  1795.         LDAP *Connection,
  1796.         LDAPMessage *ResultMessage,
  1797.         ULONG *ReturnCode OPTIONAL,         // returned by server
  1798.         PCHAR *MatchedDNs OPTIONAL,         // free with ldap_memfree
  1799.         PCHAR *ErrorMessage OPTIONAL,       // free with ldap_memfree
  1800.         PCHAR **Referrals OPTIONAL,         // free with ldap_value_freeA
  1801.         PLDAPControlA **ServerControls OPTIONAL,    // free with ldap_free_controlsA
  1802.         BOOLEAN Freeit
  1803.         );
  1804.  
  1805. WINLDAPAPI ULONG LDAPAPI ldap_parse_extended_resultA (
  1806.         LDAP           *Connection,
  1807.         LDAPMessage    *ResultMessage,      // returned by server
  1808.         PCHAR          *ResultOID,          // free with ldap_memfree
  1809.         struct berval **ResultData,         // free with ldap_memfree
  1810.         BOOLEAN         Freeit              // Don't need the message anymore
  1811.         );
  1812.  
  1813. WINLDAPAPI ULONG LDAPAPI ldap_parse_extended_resultW (
  1814.         LDAP           *Connection,
  1815.         LDAPMessage    *ResultMessage,      // returned by server
  1816.         PWCHAR          *ResultOID,         // free with ldap_memfree
  1817.         struct berval **ResultData,         // free with ldap_memfree
  1818.         BOOLEAN         Freeit              // Don't need the message anymore
  1819.         );
  1820.  
  1821. WINLDAPAPI ULONG LDAPAPI ldap_controls_freeA (
  1822.         LDAPControlA **Controls
  1823.         );
  1824.  
  1825. WINLDAPAPI ULONG LDAPAPI ldap_control_freeA (
  1826.         LDAPControlA *Controls
  1827.         );
  1828.  
  1829. WINLDAPAPI ULONG LDAPAPI ldap_controls_freeW (
  1830.         LDAPControlW **Control
  1831.         );
  1832.  
  1833. WINLDAPAPI ULONG LDAPAPI ldap_control_freeW (
  1834.         LDAPControlW *Control
  1835.         );
  1836.  
  1837. //
  1838. // ldap_free_controls are old, use ldap_controls_free
  1839. //
  1840.  
  1841. WINLDAPAPI ULONG LDAPAPI ldap_free_controlsW (
  1842.         LDAPControlW **Controls
  1843.         );
  1844.  
  1845. WINLDAPAPI ULONG LDAPAPI ldap_free_controlsA (
  1846.         LDAPControlA **Controls
  1847.         );
  1848.  
  1849. #if LDAP_UNICODE
  1850.  
  1851. #define ldap_parse_result ldap_parse_resultW
  1852. #define ldap_controls_free ldap_controls_freeW
  1853. #define ldap_control_free ldap_control_freeW
  1854. #define ldap_free_controls ldap_free_controlsW
  1855. #define ldap_parse_extended_result ldap_parse_extended_resultW
  1856.  
  1857. #else
  1858.  
  1859. #define ldap_parse_extended_result ldap_parse_extended_resultA
  1860.  
  1861. WINLDAPAPI ULONG LDAPAPI ldap_parse_result (
  1862.         LDAP *Connection,
  1863.         LDAPMessage *ResultMessage,
  1864.         ULONG *ReturnCode OPTIONAL,         // returned by server
  1865.         PCHAR *MatchedDNs OPTIONAL,         // free with ldap_memfree
  1866.         PCHAR *ErrorMessage OPTIONAL,       // free with ldap_memfree
  1867.         PCHAR **Referrals OPTIONAL,         // free with ldap_value_free
  1868.         PLDAPControlA **ServerControls OPTIONAL,    // free with ldap_free_controls
  1869.         BOOLEAN Freeit
  1870.         );
  1871.  
  1872. WINLDAPAPI ULONG LDAPAPI ldap_controls_free (
  1873.         LDAPControlA **Controls
  1874.         );
  1875.  
  1876. WINLDAPAPI ULONG LDAPAPI ldap_control_free (
  1877.         LDAPControlA *Control
  1878.         );
  1879.  
  1880. WINLDAPAPI ULONG LDAPAPI ldap_free_controls (
  1881.         LDAPControlA **Controls
  1882.         );
  1883.  
  1884. #endif
  1885.  
  1886. //
  1887. //  ldap_err2string returns a pointer to a string describing the error.  This
  1888. //  string should not be freed.
  1889. //
  1890.  
  1891. WINLDAPAPI PWCHAR LDAPAPI ldap_err2stringW( ULONG err );
  1892. WINLDAPAPI PCHAR LDAPAPI ldap_err2stringA( ULONG err );
  1893.  
  1894. #if LDAP_UNICODE
  1895.  
  1896. #define ldap_err2string ldap_err2stringW
  1897.  
  1898. #else
  1899.  
  1900. WINLDAPAPI PCHAR LDAPAPI ldap_err2string( ULONG err );
  1901.  
  1902. #endif
  1903.  
  1904. //
  1905. //  ldap_perror does nothing and is here just for compatibility.
  1906. //
  1907.  
  1908. WINLDAPAPI void LDAPAPI ldap_perror( LDAP *ld, const PCHAR msg );
  1909.  
  1910. //
  1911. //  Return the first entry of a message.  It is freed when the message is
  1912. //  freed so should not be freed explicitly.
  1913. //
  1914.  
  1915. WINLDAPAPI LDAPMessage *LDAPAPI ldap_first_entry( LDAP *ld, LDAPMessage *res );
  1916.  
  1917. //
  1918. //  Return the next entry of a message.  It is freed when the message is
  1919. //  freed so should not be freed explicitly.
  1920. //
  1921.  
  1922. WINLDAPAPI LDAPMessage *LDAPAPI ldap_next_entry( LDAP *ld, LDAPMessage *entry );
  1923.  
  1924. //
  1925. //  Count the number of search entries returned by the server in a response
  1926. //  to a server request.
  1927. //
  1928.  
  1929. WINLDAPAPI ULONG LDAPAPI ldap_count_entries( LDAP *ld, LDAPMessage *res );
  1930.  
  1931. //
  1932. //  A BerElement really maps out to a C++ class object that does BER encoding.
  1933. //  Don't mess with it as it's opaque.
  1934. //
  1935.  
  1936. typedef struct berelement {
  1937.     PCHAR   opaque;     // this is an opaque structure used just for
  1938.                         // compatibility with reference implementation
  1939. } BerElement;
  1940. #define NULLBER ((BerElement *) 0)
  1941.  
  1942. //
  1943. //  For a given entry, return the first attribute.  The pointer returned is
  1944. //  actually a buffer in the connection block (with allowances for
  1945. //  multi-threaded apps) so it should not be freed.
  1946. //
  1947.  
  1948. WINLDAPAPI PWCHAR LDAPAPI ldap_first_attributeW(
  1949.         LDAP            *ld,
  1950.         LDAPMessage     *entry,
  1951.         BerElement      **ptr
  1952.         );
  1953.  
  1954. WINLDAPAPI PCHAR LDAPAPI ldap_first_attributeA(
  1955.         LDAP            *ld,
  1956.         LDAPMessage     *entry,
  1957.         BerElement      **ptr
  1958.         );
  1959.  
  1960. #if LDAP_UNICODE
  1961.  
  1962. #define ldap_first_attribute ldap_first_attributeW
  1963.  
  1964. #else
  1965.  
  1966. WINLDAPAPI PCHAR LDAPAPI ldap_first_attribute(
  1967.         LDAP            *ld,
  1968.         LDAPMessage     *entry,
  1969.         BerElement      **ptr
  1970.         );
  1971. #endif
  1972.  
  1973. //
  1974. //  Return the next attribute... again, the attribute pointer should not be
  1975. //  freed.
  1976. //
  1977.  
  1978. WINLDAPAPI PWCHAR LDAPAPI ldap_next_attributeW(
  1979.         LDAP            *ld,
  1980.         LDAPMessage     *entry,
  1981.         BerElement      *ptr
  1982.         );
  1983.  
  1984. WINLDAPAPI PCHAR LDAPAPI ldap_next_attributeA(
  1985.         LDAP            *ld,
  1986.         LDAPMessage     *entry,
  1987.         BerElement      *ptr
  1988.         );
  1989.  
  1990.  
  1991. #if LDAP_UNICODE
  1992.  
  1993. #define ldap_next_attribute ldap_next_attributeW
  1994.  
  1995. #else
  1996.  
  1997. WINLDAPAPI PCHAR LDAPAPI ldap_next_attribute(
  1998.         LDAP            *ld,
  1999.         LDAPMessage     *entry,
  2000.         BerElement      *ptr
  2001.         );
  2002. #endif
  2003.  
  2004. //
  2005. //  Get a given attribute's list of values.  This is used during parsing of
  2006. //  a search response.  It returns a list of pointers to values, the list is
  2007. //  null terminated.
  2008. //
  2009. //  If the values are generic octet strings and not null terminated strings,
  2010. //  use ldap_get_values_len instead.
  2011. //
  2012. //  The returned value should be freed when your done with it by calling
  2013. //  ldap_value_free.
  2014. //
  2015.  
  2016. WINLDAPAPI PWCHAR *LDAPAPI ldap_get_valuesW(
  2017.         LDAP            *ld,
  2018.         LDAPMessage     *entry,
  2019.         const PWCHAR          attr
  2020.         );
  2021. WINLDAPAPI PCHAR *LDAPAPI ldap_get_valuesA(
  2022.         LDAP            *ld,
  2023.         LDAPMessage     *entry,
  2024.         const PCHAR           attr
  2025.         );
  2026.  
  2027. #if LDAP_UNICODE
  2028.  
  2029. #define ldap_get_values ldap_get_valuesW
  2030.  
  2031. #else
  2032.  
  2033. WINLDAPAPI PCHAR *LDAPAPI ldap_get_values(
  2034.         LDAP            *ld,
  2035.         LDAPMessage     *entry,
  2036.         const PCHAR           attr
  2037.         );
  2038. #endif
  2039.  
  2040.  
  2041.  
  2042.  
  2043. //
  2044. //  Get a given attribute's list of values.  This is used during parsing of
  2045. //  a search response.  It returns a list of berval structures to values,
  2046. //  the list is null terminated.
  2047. //
  2048. //  If the values are null terminated strings, it may be easier to process them
  2049. //  by calling ldap_get_values instead.
  2050. //
  2051. //  The returned value should be freed when your done with it by calling
  2052. //  ldap_value_free_len.
  2053. //
  2054.  
  2055. WINLDAPAPI struct berval **LDAPAPI ldap_get_values_lenW (
  2056.     LDAP            *ExternalHandle,
  2057.     LDAPMessage     *Message,
  2058.     const PWCHAR          attr
  2059.     );
  2060. WINLDAPAPI struct berval **LDAPAPI ldap_get_values_lenA (
  2061.     LDAP            *ExternalHandle,
  2062.     LDAPMessage     *Message,
  2063.     const PCHAR           attr
  2064.     );
  2065.  
  2066. #if LDAP_UNICODE
  2067.  
  2068. #define ldap_get_values_len ldap_get_values_lenW
  2069.  
  2070. #else
  2071.  
  2072. WINLDAPAPI struct berval **LDAPAPI ldap_get_values_len (
  2073.     LDAP            *ExternalHandle,
  2074.     LDAPMessage     *Message,
  2075.     const PCHAR           attr
  2076.     );
  2077.  
  2078. #endif
  2079.  
  2080.  
  2081. //
  2082. //  Return the number of values in a list returned by ldap_get_values.
  2083. //
  2084.  
  2085. WINLDAPAPI ULONG LDAPAPI ldap_count_valuesW( PWCHAR *vals );
  2086. WINLDAPAPI ULONG LDAPAPI ldap_count_valuesA( PCHAR *vals );
  2087.  
  2088. #if LDAP_UNICODE
  2089.  
  2090. #define ldap_count_values ldap_count_valuesW
  2091.  
  2092. #else
  2093.  
  2094. WINLDAPAPI ULONG LDAPAPI ldap_count_values( PCHAR *vals );
  2095.  
  2096. #endif
  2097.  
  2098.  
  2099.  
  2100. //
  2101. //  Return the number of values in a list returned by ldap_get_values_len.
  2102. //
  2103.  
  2104. WINLDAPAPI ULONG LDAPAPI ldap_count_values_len( struct berval **vals );
  2105.  
  2106. //
  2107. //  Free structures returned by ldap_get_values.
  2108. //
  2109.  
  2110. WINLDAPAPI ULONG LDAPAPI ldap_value_freeW( PWCHAR *vals );
  2111. WINLDAPAPI ULONG LDAPAPI ldap_value_freeA( PCHAR *vals );
  2112.  
  2113. #if LDAP_UNICODE
  2114.  
  2115. #define ldap_value_free ldap_value_freeW
  2116.  
  2117. #else
  2118.  
  2119. WINLDAPAPI ULONG LDAPAPI ldap_value_free( PCHAR *vals );
  2120.  
  2121. #endif
  2122.  
  2123.  
  2124.  
  2125. //
  2126. //  Free structures returned by ldap_get_values_len.
  2127. //
  2128.  
  2129. WINLDAPAPI ULONG LDAPAPI ldap_value_free_len( struct berval **vals );
  2130.  
  2131. //
  2132. //  Get the distinguished name for a given search entry.  It should be freed
  2133. //  by calling ldap_memfree.
  2134. //
  2135.  
  2136. WINLDAPAPI PWCHAR LDAPAPI ldap_get_dnW( LDAP *ld, LDAPMessage *entry );
  2137. WINLDAPAPI PCHAR LDAPAPI ldap_get_dnA( LDAP *ld, LDAPMessage *entry );
  2138.  
  2139. #if LDAP_UNICODE
  2140.  
  2141. #define ldap_get_dn ldap_get_dnW
  2142.  
  2143. #else
  2144.  
  2145. WINLDAPAPI PCHAR LDAPAPI ldap_get_dn( LDAP *ld, LDAPMessage *entry );
  2146.  
  2147. #endif
  2148.  
  2149.  
  2150. //
  2151. //  When using ldap_explode_dn, you should free the returned string by
  2152. //  calling ldap_value_free.
  2153. //
  2154.  
  2155. WINLDAPAPI PWCHAR *LDAPAPI ldap_explode_dnW( const PWCHAR dn, ULONG notypes );
  2156. WINLDAPAPI PCHAR *LDAPAPI ldap_explode_dnA( const PCHAR dn, ULONG notypes );
  2157.  
  2158. #if LDAP_UNICODE
  2159.  
  2160. #define ldap_explode_dn ldap_explode_dnW
  2161.  
  2162. #else
  2163.  
  2164. WINLDAPAPI PCHAR *LDAPAPI ldap_explode_dn( const PCHAR dn, ULONG notypes );
  2165.  
  2166. #endif
  2167.  
  2168.  
  2169. //
  2170. //  When calling ldap_dn2ufn, you should free the returned string by calling
  2171. //  ldap_memfree.
  2172. //
  2173.  
  2174. WINLDAPAPI PWCHAR LDAPAPI ldap_dn2ufnW( const PWCHAR dn );
  2175. WINLDAPAPI PCHAR LDAPAPI ldap_dn2ufnA( const PCHAR dn );
  2176.  
  2177. #if LDAP_UNICODE
  2178.  
  2179. #define ldap_dn2ufn ldap_dn2ufnW
  2180.  
  2181. #else
  2182.  
  2183. WINLDAPAPI PCHAR LDAPAPI ldap_dn2ufn( const PCHAR dn );
  2184.  
  2185. #endif
  2186.  
  2187.  
  2188.  
  2189. //
  2190. //  This is used to free strings back to the LDAP API heap.  Don't pass in
  2191. //  values that you've gotten from ldap_open, ldap_get_values, etc.
  2192. //
  2193.  
  2194. WINLDAPAPI VOID LDAPAPI ldap_memfreeW( PWCHAR Block );
  2195. WINLDAPAPI VOID LDAPAPI ldap_memfreeA( PCHAR Block );
  2196.  
  2197. WINLDAPAPI VOID LDAPAPI ber_bvfree( struct berval *bv );
  2198.  
  2199. #if LDAP_UNICODE
  2200.  
  2201. #define ldap_memfree ldap_memfreeW
  2202.  
  2203. #else
  2204.  
  2205. WINLDAPAPI VOID LDAPAPI ldap_memfree( PCHAR Block );
  2206.  
  2207. #endif
  2208.  
  2209.  
  2210. //
  2211. //  The function ldap_ufn2dn attempts to "normalize" a user specified DN
  2212. //  to make it "proper".  It follows RFC 1781 (add CN= if not present,
  2213. //  add OU= if none present, etc).  If it runs into any problems at all
  2214. //  while normalizing, it simply returns a copy of what was passed in.
  2215. //
  2216. //  It allocates the output string from the LDAP memory pool.  If the pDn
  2217. //  comes back as non-NULL, you should free it when you're done with a call
  2218. //  to ldap_memfree.
  2219. //
  2220.  
  2221. WINLDAPAPI ULONG LDAPAPI ldap_ufn2dnW (
  2222.     const PWCHAR ufn,
  2223.     PWCHAR *pDn
  2224.     );
  2225. WINLDAPAPI ULONG LDAPAPI ldap_ufn2dnA (
  2226.     const PCHAR ufn,
  2227.     PCHAR *pDn
  2228.     );
  2229.  
  2230. #if LDAP_UNICODE
  2231.  
  2232. #define ldap_ufn2dn ldap_ufn2dnW
  2233.  
  2234. #else
  2235.  
  2236. WINLDAPAPI ULONG LDAPAPI ldap_ufn2dn (
  2237.     const PCHAR ufn,
  2238.     PCHAR *pDn
  2239.     );
  2240.  
  2241. #endif
  2242.  
  2243. #define LBER_USE_DER        0x01
  2244. #define LBER_USE_INDEFINITE_LEN 0x02
  2245. #define LBER_TRANSLATE_STRINGS  0x04
  2246.  
  2247. //
  2248. //  Call to initialize the LDAP library.  Pass in a version structure with
  2249. //  lv_size set to sizeof( LDAP_VERSION ), lv_major set to LAPI_MAJOR_VER1,
  2250. //  and lv_minor set to LAPI_MINOR_VER1.  Return value will be either
  2251. //  LDAP_SUCCESS if OK or LDAP_OPERATIONS_ERROR if can't be supported.
  2252. //
  2253.  
  2254. #define LAPI_MAJOR_VER1     1
  2255. #define LAPI_MINOR_VER1     1
  2256.  
  2257. typedef struct ldap_version_info {
  2258.      ULONG   lv_size;
  2259.      ULONG   lv_major;
  2260.      ULONG   lv_minor;
  2261. } LDAP_VERSION_INFO, *PLDAP_VERSION_INFO;
  2262.  
  2263. WINLDAPAPI ULONG LDAPAPI ldap_startup (
  2264.     PLDAP_VERSION_INFO version,
  2265.     HANDLE *Instance
  2266.     );
  2267.  
  2268. //
  2269. //  ldap_cleanup unloads the library when the refcount of opens goes to zero.
  2270. //  (i.e. if a DLL calls it within a program that is also using it, it won't
  2271. //  free all resources)
  2272. //
  2273.  
  2274. WINLDAPAPI ULONG LDAPAPI ldap_cleanup (
  2275.     HANDLE hInstance
  2276.     );
  2277.  
  2278. //
  2279. //  Extended API to support allowing opaque blobs of data in search filters.
  2280. //  This API takes any filter element and converts it to a safe text string that
  2281. //  can safely be passed in a search filter.
  2282. //  An example of using this is :
  2283. //
  2284. //  filter is something like guid=4826BF6CF0123444
  2285. //  this will put out on the wire guid of binary 0x4826BF6CF0123444
  2286. //
  2287. //  call ldap_escape_filter_element with sourceFilterElement pointing to
  2288. //  raw data, sourceCount set appropriately to length of data.
  2289. //
  2290. //  if destFilterElement is NULL, then return value is length required for
  2291. //  output buffer.
  2292. //
  2293. //  if destFilterElement is not NULL, then the function will copy the source
  2294. //  into the dest buffer and ensure that it is of a safe format.
  2295. //
  2296. //  then simply insert the dest buffer into your search filter after the
  2297. //  "attributetype=".
  2298. //
  2299. //  this will put out on the wire guid of binary 0x004826BF6CF000123444
  2300. //
  2301. //  Note : don't call this for attribute values that are really strings, as
  2302. //  we won't do any conversion from what you passed in to UTF-8.  Should only
  2303. //  be used for attributes that really are raw binary.
  2304. //
  2305.  
  2306. WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_elementW (
  2307.    PCHAR   sourceFilterElement,
  2308.    ULONG   sourceLength,
  2309.    PWCHAR   destFilterElement,
  2310.    ULONG   destLength
  2311.    );
  2312. WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_elementA (
  2313.    PCHAR   sourceFilterElement,
  2314.    ULONG   sourceLength,
  2315.    PCHAR   destFilterElement,
  2316.    ULONG   destLength
  2317.    );
  2318.  
  2319. #if LDAP_UNICODE
  2320.  
  2321. #define ldap_escape_filter_element ldap_escape_filter_elementW
  2322.  
  2323. #else
  2324.  
  2325. WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_element (
  2326.    PCHAR   sourceFilterElement,
  2327.    ULONG   sourceLength,
  2328.    PCHAR   destFilterElement,
  2329.    ULONG   destLength
  2330.    );
  2331.  
  2332. #endif
  2333.  
  2334. //
  2335. //  Misc extensions for additional debugging.
  2336. //
  2337. //  Note that these do nothing on free builds.
  2338. //
  2339.  
  2340. WINLDAPAPI ULONG LDAPAPI ldap_set_dbg_flags( ULONG NewFlags );
  2341.  
  2342. typedef ULONG (_cdecl *DBGPRINT)( PCH Format, ... );
  2343.  
  2344. WINLDAPAPI VOID LDAPAPI ldap_set_dbg_routine( DBGPRINT DebugPrintRoutine );
  2345.  
  2346. //
  2347. //  These routines are possibly useful by other modules.  Note that Win95
  2348. //  doesn't by default have the UTF-8 codepage loaded.  So a good way to
  2349. //  convert from UTF-8 to Unicode.
  2350. //
  2351.  
  2352.  
  2353. WINLDAPAPI int LDAPAPI
  2354. LdapUTF8ToUnicode(
  2355.     LPCSTR lpSrcStr,
  2356.     int cchSrc,
  2357.     LPWSTR lpDestStr,
  2358.     int cchDest
  2359.     );
  2360.  
  2361. WINLDAPAPI
  2362. int LDAPAPI
  2363. LdapUnicodeToUTF8(
  2364.     LPCWSTR lpSrcStr,
  2365.     int cchSrc,
  2366.     LPSTR lpDestStr,
  2367.     int cchDest
  2368.     );
  2369.  
  2370. //
  2371. //  LDAPv3 features :
  2372. //
  2373. //  Sort Keys... these are used to ask the server to sort the results
  2374. //  before sending the results back.  LDAPv3 only and optional to implement
  2375. //  on the server side.  Check supportedControl for an OID of
  2376. //  "1.2.840.113556.1.4.473" to see if the server supports it.
  2377. //
  2378.  
  2379. #define LDAP_SERVER_SORT_OID "1.2.840.113556.1.4.473"
  2380. #define LDAP_SERVER_SORT_OID_W L"1.2.840.113556.1.4.473"
  2381.  
  2382. #define LDAP_SERVER_RESP_SORT_OID "1.2.840.113556.1.4.474"
  2383. #define LDAP_SERVER_RESP_SORT_OID_W L"1.2.840.113556.1.4.474"
  2384.  
  2385. typedef struct ldapsearch LDAPSearch, *PLDAPSearch;
  2386.  
  2387. typedef struct ldapsortkeyW {
  2388.  
  2389.     PWCHAR  sk_attrtype;
  2390.     PWCHAR  sk_matchruleoid;
  2391.     BOOLEAN sk_reverseorder;
  2392.  
  2393. } LDAPSortKeyW, *PLDAPSortKeyW;
  2394.  
  2395. typedef struct ldapsortkeyA {
  2396.  
  2397.     PCHAR   sk_attrtype;
  2398.     PCHAR   sk_matchruleoid;
  2399.     BOOLEAN sk_reverseorder;
  2400.  
  2401. } LDAPSortKeyA, *PLDAPSortKeyA;
  2402.  
  2403. #if LDAP_UNICODE
  2404. #define LDAPSortKey LDAPSortKeyW
  2405. #define PLDAPSortKey PLDAPSortKeyW
  2406. #else
  2407. #define LDAPSortKey LDAPSortKeyA
  2408. #define PLDAPSortKey PLDAPSortKeyA
  2409. #endif
  2410.  
  2411. //
  2412. //  This API formats a list of sort keys into a search control.  Call
  2413. //  ldap_control_free when you're finished with the control.
  2414. //
  2415. //  Use this one rather than ldap_encode_sort_control as this is per RFC.
  2416. //
  2417.  
  2418. WINLDAPAPI ULONG LDAPAPI ldap_create_sort_controlA (
  2419.         PLDAP           ExternalHandle,
  2420.         PLDAPSortKeyA  *SortKeys,
  2421.         UCHAR           IsCritical,
  2422.         PLDAPControlA  *Control
  2423.         );
  2424.  
  2425. WINLDAPAPI ULONG LDAPAPI ldap_create_sort_controlW (
  2426.         PLDAP           ExternalHandle,
  2427.         PLDAPSortKeyW  *SortKeys,
  2428.         UCHAR           IsCritical,
  2429.         PLDAPControlW  *Control
  2430.         );
  2431.  
  2432. //
  2433. //  This API parses the sort control returned by the server.  Use ldap_memfree
  2434. //  to free the attribute value, if it's returned.
  2435. //
  2436.  
  2437. WINLDAPAPI ULONG LDAPAPI ldap_parse_sort_controlA (
  2438.         PLDAP           ExternalHandle,
  2439.         PLDAPControlA  *Control,
  2440.         ULONG          *Result,
  2441.         PCHAR          *Attribute
  2442.         );
  2443.  
  2444. WINLDAPAPI ULONG LDAPAPI ldap_parse_sort_controlW (
  2445.         PLDAP           ExternalHandle,
  2446.         PLDAPControlW  *Control,
  2447.         ULONG          *Result,
  2448.         PWCHAR         *Attribute
  2449.         );
  2450.  
  2451. #if LDAP_UNICODE
  2452.  
  2453. #define ldap_create_sort_control ldap_create_sort_controlW
  2454. #define ldap_parse_sort_control ldap_parse_sort_controlW
  2455.  
  2456. #else
  2457.  
  2458. WINLDAPAPI ULONG LDAPAPI ldap_create_sort_control (
  2459.         PLDAP           ExternalHandle,
  2460.         PLDAPSortKeyA  *SortKeys,
  2461.         UCHAR           IsCritical,
  2462.         PLDAPControlA  *Control
  2463.         );
  2464.  
  2465. WINLDAPAPI ULONG LDAPAPI ldap_parse_sort_control (
  2466.         PLDAP           ExternalHandle,
  2467.         PLDAPControlA  *Control,
  2468.         ULONG          *Result,
  2469.         PCHAR          *Attribute
  2470.         );
  2471. #endif
  2472.  
  2473. //
  2474. //  This API formats a list of sort keys into a search control.  Call
  2475. //  ldap_memfree for both Control->ldctl_value.bv_val and
  2476. //  Control->currentControl->ldctl_oid when you're finished with the control.
  2477. //
  2478. //  This is the old sort API that will be shortly pulled.  Please use
  2479. //  ldap_create_sort_control defined above.
  2480. //
  2481.  
  2482. WINLDAPAPI ULONG LDAPAPI ldap_encode_sort_controlW (
  2483.         PLDAP           ExternalHandle,
  2484.         PLDAPSortKeyW  *SortKeys,
  2485.         PLDAPControlW  Control,
  2486.         BOOLEAN Criticality
  2487.         );
  2488.  
  2489. WINLDAPAPI ULONG LDAPAPI ldap_encode_sort_controlA (
  2490.         PLDAP           ExternalHandle,
  2491.         PLDAPSortKeyA  *SortKeys,
  2492.         PLDAPControlA  Control,
  2493.         BOOLEAN Criticality
  2494.         );
  2495.  
  2496. #if LDAP_UNICODE
  2497.  
  2498. #define ldap_encode_sort_control ldap_encode_sort_controlW
  2499.  
  2500. #else
  2501.  
  2502. WINLDAPAPI ULONG LDAPAPI ldap_encode_sort_control (
  2503.         PLDAP           ExternalHandle,
  2504.         PLDAPSortKeyA  *SortKeys,
  2505.         PLDAPControlA  Control,
  2506.         BOOLEAN Criticality
  2507.         );
  2508. #endif
  2509.  
  2510. //
  2511. //  LDAPv3: This is the RFC defined API for the simple paging of results
  2512. //  control.  Use ldap_control_free to free the control allocated by
  2513. //  ldap_create_page_control.
  2514. //
  2515.  
  2516. WINLDAPAPI ULONG LDAPAPI ldap_create_page_controlW(
  2517.         PLDAP           ExternalHandle,
  2518.         ULONG           PageSize,
  2519.         struct berval  *Cookie,
  2520.         UCHAR           IsCritical,
  2521.         PLDAPControlW  *Control
  2522.         );
  2523.  
  2524. WINLDAPAPI ULONG LDAPAPI ldap_create_page_controlA(
  2525.         PLDAP           ExternalHandle,
  2526.         ULONG           PageSize,
  2527.         struct berval  *Cookie,
  2528.         UCHAR           IsCritical,
  2529.         PLDAPControlA  *Control
  2530.         );
  2531.  
  2532. WINLDAPAPI ULONG LDAPAPI ldap_parse_page_controlW (
  2533.         PLDAP           ExternalHandle,
  2534.         PLDAPControlW  *ServerControls,
  2535.         ULONG          *TotalCount,
  2536.         struct berval  **Cookie     // Use ber_bvfree to free
  2537.         );
  2538.  
  2539. WINLDAPAPI ULONG LDAPAPI ldap_parse_page_controlA (
  2540.         PLDAP           ExternalHandle,
  2541.         PLDAPControlA  *ServerControls,
  2542.         ULONG          *TotalCount,
  2543.         struct berval  **Cookie     // Use ber_bvfree to free
  2544.         );
  2545.  
  2546. #if LDAP_UNICODE
  2547.  
  2548. #define ldap_create_page_control ldap_create_page_controlW
  2549. #define ldap_parse_page_control  ldap_parse_page_controlW
  2550.  
  2551. #else
  2552.  
  2553. WINLDAPAPI ULONG LDAPAPI ldap_create_page_control(
  2554.         PLDAP           ExternalHandle,
  2555.         ULONG           PageSize,
  2556.         struct berval  *Cookie,
  2557.         UCHAR           IsCritical,
  2558.         PLDAPControlA  *Control
  2559.         );
  2560.  
  2561. WINLDAPAPI ULONG LDAPAPI ldap_parse_page_control (
  2562.         PLDAP           ExternalHandle,
  2563.         PLDAPControlA  *ServerControls,
  2564.         ULONG          *TotalCount,
  2565.         struct berval  **Cookie     // Use ber_bvfree to free
  2566.         );
  2567. #endif
  2568.  
  2569. //
  2570. //  LDAPv3: This is the interface for simple paging of results.  To ensure
  2571. //  that the server supports it, check the supportedControl property off of
  2572. //  the root for an OID of 1.2.840.113556.1.4.319.  If it is there, then it
  2573. //  supports this feature.
  2574. //
  2575. //  If you're going to specify sort keys, see section above on sort keys on
  2576. //  now to tell if they're supported by the server.
  2577. //
  2578. //  You first call ldap_search_init_page.  If it returns a non-NULL LDAPSearch
  2579. //  block, then it worked ok.  Otherwise call LdapGetLastError to find error.
  2580. //
  2581. //  With a valid LDAPSearch block (there are opaque), call ldap_get_next_page
  2582. //  or ldap_get_next_page_s.  If you call ldap_get_next_page, you MUST call
  2583. //  ldap_get_paged_count for each set of results that you get for that message.
  2584. //  This allows the library to save off the cookie that the server sent to
  2585. //  resume the search.
  2586. //
  2587. //  Other than calling ldap_get_paged_count, the results you get back from
  2588. //  ldap_get_next_page can be treated as any other search result, and should
  2589. //  be freed when you're done by calling ldap_msgfree.
  2590. //
  2591. //  When the end of the search is hit, you'll get a return code of
  2592. //  LDAP_NO_RESULTS_RETURNED.  At this point, (or any point after LDAPSearch
  2593. //  structure has been allocated), you call ldap_search_abandon_page.  You
  2594. //  need to call this even after you get a return code of
  2595. //  LDAP_NO_RESULTS_RETURNED.
  2596. //
  2597. //  If you call ldap_get_next_page_s, you don't need to call
  2598. //  ldap_get_paged_count.
  2599. //
  2600.  
  2601. #define LDAP_PAGED_RESULT_OID_STRING "1.2.840.113556.1.4.319"
  2602. #define LDAP_PAGED_RESULT_OID_STRING_W L"1.2.840.113556.1.4.319"
  2603.  
  2604. WINLDAPAPI PLDAPSearch LDAPAPI ldap_search_init_pageW(
  2605.         PLDAP           ExternalHandle,
  2606.         const PWCHAR    DistinguishedName,
  2607.         ULONG           ScopeOfSearch,
  2608.         const PWCHAR    SearchFilter,
  2609.         PWCHAR          AttributeList[],
  2610.         ULONG           AttributesOnly,
  2611.         PLDAPControlW   *ServerControls,
  2612.         PLDAPControlW   *ClientControls,
  2613.         ULONG           PageTimeLimit,
  2614.         ULONG           TotalSizeLimit,
  2615.         PLDAPSortKeyW  *SortKeys
  2616.     );
  2617.  
  2618. WINLDAPAPI PLDAPSearch LDAPAPI ldap_search_init_pageA(
  2619.         PLDAP           ExternalHandle,
  2620.         const PCHAR     DistinguishedName,
  2621.         ULONG           ScopeOfSearch,
  2622.         const PCHAR     SearchFilter,
  2623.         PCHAR           AttributeList[],
  2624.         ULONG           AttributesOnly,
  2625.         PLDAPControlA   *ServerControls,
  2626.         PLDAPControlA   *ClientControls,
  2627.         ULONG           PageTimeLimit,
  2628.         ULONG           TotalSizeLimit,
  2629.         PLDAPSortKeyA  *SortKeys
  2630.     );
  2631.  
  2632. #if LDAP_UNICODE
  2633.  
  2634. #define ldap_search_init_page ldap_search_init_pageW
  2635.  
  2636. #else
  2637.  
  2638. WINLDAPAPI PLDAPSearch LDAPAPI ldap_search_init_page(
  2639.         PLDAP           ExternalHandle,
  2640.         const PCHAR     DistinguishedName,
  2641.         ULONG           ScopeOfSearch,
  2642.         const PCHAR     SearchFilter,
  2643.         PCHAR           AttributeList[],
  2644.         ULONG           AttributesOnly,
  2645.         PLDAPControl    *ServerControls,
  2646.         PLDAPControl    *ClientControls,
  2647.         ULONG           PageTimeLimit,
  2648.         ULONG           TotalSizeLimit,
  2649.         PLDAPSortKey    *SortKeys
  2650.     );
  2651.  
  2652. #endif
  2653.  
  2654. WINLDAPAPI ULONG LDAPAPI ldap_get_next_page(
  2655.         PLDAP           ExternalHandle,
  2656.         PLDAPSearch     SearchHandle,
  2657.         ULONG           PageSize,
  2658.         ULONG          *MessageNumber
  2659.     );
  2660.  
  2661. WINLDAPAPI ULONG LDAPAPI ldap_get_next_page_s(
  2662.         PLDAP           ExternalHandle,
  2663.         PLDAPSearch     SearchHandle,
  2664.         struct l_timeval  *timeout,
  2665.         ULONG           PageSize,
  2666.         ULONG          *TotalCount,
  2667.         LDAPMessage     **Results
  2668.     );
  2669.  
  2670. WINLDAPAPI ULONG LDAPAPI ldap_get_paged_count(
  2671.         PLDAP           ExternalHandle,
  2672.         PLDAPSearch     SearchBlock,
  2673.         ULONG          *TotalCount,
  2674.         PLDAPMessage    Results
  2675.     );
  2676.  
  2677. WINLDAPAPI ULONG LDAPAPI ldap_search_abandon_page(
  2678.         PLDAP           ExternalHandle,
  2679.         PLDAPSearch     SearchBlock
  2680.     );
  2681.  
  2682. //
  2683. //  These functions return subordinate referrals (references) that are returned
  2684. //  in search responses.  There are two types of referrals.  External referrals
  2685. //  where the naming context doesn't reside on the server (e.g. server says "I
  2686. //  don't have the data, look over there") and Subordinate referrals (or
  2687. //  references) where some data has been returned and the referrals are passed
  2688. //  to other naming contexts below the current one (e.g. servers says "Here's
  2689. //  some data from the tree I hold, go look here, there, and over there for
  2690. //  more data that is further down in the tree.").
  2691. //
  2692. //  These routines handle the latter.  For external references, use
  2693. //  ldap_parse_result.
  2694. //
  2695. //  Return the first reference from a message.  It is freed when the message is
  2696. //  freed so should not be freed explicitly.
  2697. //
  2698.  
  2699. WINLDAPAPI LDAPMessage *LDAPAPI ldap_first_reference( LDAP *ld, LDAPMessage *res );
  2700.  
  2701. //
  2702. //  Return the next entry of a message.  It is freed when the message is
  2703. //  freed so should not be freed explicitly.
  2704. //
  2705.  
  2706. WINLDAPAPI LDAPMessage *LDAPAPI ldap_next_reference( LDAP *ld, LDAPMessage *entry );
  2707.  
  2708. //
  2709. //  Count the number of subordinate references returned by the server in a
  2710. //  response to a search request.
  2711. //
  2712.  
  2713. WINLDAPAPI ULONG LDAPAPI ldap_count_references( LDAP *ld, LDAPMessage *res );
  2714.  
  2715. //
  2716. //  We return the list of subordinate referrals in a search response message.
  2717. //
  2718.  
  2719. WINLDAPAPI ULONG LDAPAPI ldap_parse_referenceW (
  2720.         LDAP *Connection,
  2721.         LDAPMessage *ResultMessage,
  2722.         PWCHAR **Referrals                   // free with ldap_value_freeW
  2723.         );
  2724.  
  2725. WINLDAPAPI ULONG LDAPAPI ldap_parse_referenceA (
  2726.         LDAP *Connection,
  2727.         LDAPMessage *ResultMessage,
  2728.         PCHAR **Referrals                   // free with ldap_value_freeA
  2729.         );
  2730.  
  2731. #if LDAP_UNICODE
  2732.  
  2733. #define ldap_parse_reference ldap_parse_referenceW
  2734.  
  2735. #else
  2736.  
  2737. WINLDAPAPI ULONG LDAPAPI ldap_parse_reference (
  2738.         LDAP *Connection,
  2739.         LDAPMessage *ResultMessage,
  2740.         PCHAR **Referrals                   // free with ldap_value_free
  2741.         );
  2742.  
  2743. #endif
  2744.  
  2745.  
  2746. //
  2747. //  These APIs allow a client to send an extended request (free for all) to
  2748. //  an LDAPv3 (or above) server.  The functionality is fairly open... you can
  2749. //  send any request you'd like.  Note that since we don't know if you'll
  2750. //  be receiving a single or multiple responses, you'll have to explicitly tell
  2751. //  us when you're done with the request by calling ldap_close_extended_op.
  2752. //
  2753. //  These are thread safe.
  2754. //
  2755.  
  2756. WINLDAPAPI ULONG LDAPAPI ldap_extended_operationW(
  2757.         LDAP *ld,
  2758.         const PWCHAR Oid,
  2759.         struct berval   *Data,
  2760.         PLDAPControlW   *ServerControls,
  2761.         PLDAPControlW   *ClientControls,
  2762.         ULONG           *MessageNumber
  2763.         );
  2764.  
  2765. WINLDAPAPI ULONG LDAPAPI ldap_extended_operationA(
  2766.         LDAP *ld,
  2767.         const PCHAR Oid,
  2768.         struct berval   *Data,
  2769.         PLDAPControlA   *ServerControls,
  2770.         PLDAPControlA   *ClientControls,
  2771.         ULONG           *MessageNumber
  2772.         );
  2773.  
  2774. #if LDAP_UNICODE
  2775.  
  2776. #define ldap_extended_operation ldap_extended_operationW
  2777.  
  2778. #else
  2779.  
  2780. WINLDAPAPI ULONG LDAPAPI ldap_extended_operation(
  2781.         LDAP *ld,
  2782.         const PCHAR Oid,
  2783.         struct berval   *Data,
  2784.         PLDAPControlA   *ServerControls,
  2785.         PLDAPControlA   *ClientControls,
  2786.         ULONG           *MessageNumber
  2787.         );
  2788. #endif
  2789.  
  2790. WINLDAPAPI ULONG LDAPAPI ldap_close_extended_op(
  2791.         LDAP    *ld,
  2792.         ULONG   MessageNumber
  2793.         );
  2794.  
  2795.  
  2796. //
  2797. //  Some enhancements that will probably never make it into the RFC related
  2798. //  to callouts to allow external caching of connections.
  2799. //
  2800. //  Call ldap_set_option( conn, LDAP_OPT_REFERRAL_CALLBACK, &referralRoutines )
  2801. //  where referralRoutines is the address of an LDAP_REFERRAL_CALLBACK
  2802. //  structure with your routines.  They may be NULL, in which case we'll
  2803. //  obviously not make the calls.
  2804. //
  2805. //  Any connections that are created will inherit the current callbacks from
  2806. //  the primary connection that the request was initiated on.
  2807. //
  2808.  
  2809. #define LDAP_OPT_REFERRAL_CALLBACK  0x70
  2810.  
  2811. //
  2812. //  This first routine is called when we're about to chase a referral.  We
  2813. //  callout to it to see if there is already a connection cached that we
  2814. //  can use.  If so, the callback routine returns the pointer to the
  2815. //  connection to use in ConnectionToUse.  If not, it sets
  2816. //  *ConnectionToUse to NULL.
  2817. //
  2818. //  For a return code, it should return 0 if we should continue to chase the
  2819. //  referral.  If it returns a non-zero return code, we'll treat that as the
  2820. //  error code for chasing the referral.  This allows caching of host names
  2821. //  that are not reachable, if we decide to add that in the future.
  2822. //
  2823.  
  2824. typedef ULONG (_cdecl QUERYFORCONNECTION)(
  2825.     PLDAP       PrimaryConnection,
  2826.     PLDAP       ReferralFromConnection,
  2827.     PWCHAR      NewDN,
  2828.     PCHAR       HostName,
  2829.     ULONG       PortNumber,
  2830.     PVOID       SecAuthIdentity,    // if null, use CurrentUser below
  2831.     PVOID       CurrentUserToken,   // pointer to current user's LUID
  2832.     PLDAP       *ConnectionToUse
  2833.     );
  2834.  
  2835. //
  2836. //  This next function is called when we've created a new connection while
  2837. //  chasing a referral.  Note that it gets assigned the same callback functions
  2838. //  as the PrimaryConnection.  If the return code is FALSE, then the call
  2839. //  back function doesn't want to cache the connection and it will be
  2840. //  destroyed after the operation is complete.  If TRUE is returned, we'll
  2841. //  assume that the callee has taken ownership of the connection and it will
  2842. //  not be destroyed after the operation is complete.
  2843. //
  2844. //  If the ErrorCodeFromBind field is not 0, then the bind operation to
  2845. //  that server failed.
  2846. //
  2847.  
  2848. typedef BOOLEAN (_cdecl NOTIFYOFNEWCONNECTION) (
  2849.     PLDAP       PrimaryConnection,
  2850.     PLDAP       ReferralFromConnection,
  2851.     PWCHAR      NewDN,
  2852.     PCHAR       HostName,
  2853.     PLDAP       NewConnection,
  2854.     ULONG       PortNumber,
  2855.     PVOID       SecAuthIdentity,    // if null, use CurrentUser below
  2856.     PVOID       CurrentUser,        // pointer to current user's LUID
  2857.     ULONG       ErrorCodeFromBind
  2858.     );
  2859.  
  2860. //
  2861. //  This next function is called when we've successfully called off to the
  2862. //  QueryForConnection call and received a connection OR when we called off
  2863. //  to the NotifyOfNewConnection call and it returned TRUE.  We call this
  2864. //  function when we're dereferencing the connection after we're done with it.
  2865. //
  2866. //  Return code is currently ignored, but the function should return
  2867. //  LDAP_SUCCESS if all went well.
  2868. //
  2869.  
  2870. typedef ULONG (_cdecl DEREFERENCECONNECTION)(
  2871.     PLDAP       PrimaryConnection,
  2872.     PLDAP       ConnectionToDereference
  2873.     );
  2874.  
  2875. typedef struct LdapReferralCallback {
  2876.  
  2877.     ULONG   SizeOfCallbacks;        // set to sizeof( LDAP_REFERRAL_CALLBACK )
  2878.     QUERYFORCONNECTION *QueryForConnection;
  2879.     NOTIFYOFNEWCONNECTION *NotifyRoutine;
  2880.     DEREFERENCECONNECTION *DereferenceRoutine;
  2881.  
  2882. } LDAP_REFERRAL_CALLBACK, *PLDAP_REFERRAL_CALLBACK;
  2883.  
  2884. //
  2885. //  Thread Safe way to get last error code returned by LDAP API is to call
  2886. //  LdapGetLastError();
  2887. //
  2888.  
  2889. WINLDAPAPI ULONG LDAPAPI LdapGetLastError( VOID );
  2890.  
  2891. //
  2892. //  Translate from LdapError to closest Win32 error code.
  2893. //
  2894.  
  2895. WINLDAPAPI ULONG LDAPAPI LdapMapErrorToWin32( ULONG LdapError );
  2896.  
  2897. //
  2898. // This is an arrangement for specifying client certificates while establishing
  2899. // an SSL connection.
  2900. // Simply Call ldap_set_option( conn, LDAP_OPT_CLIENT_CERTIFICATE, &CertRoutine )
  2901. // where CertRoutine is the address of your callback routine. If it is NULL,
  2902. // we will obviously not make the call.
  2903. //
  2904.  
  2905. #define LDAP_OPT_CLIENT_CERTIFICATE    0x80
  2906.  
  2907. //
  2908. // This callback is invoked when the server demands a client certificate for
  2909. // authorization. We pass a structure containing a list of server-trusted
  2910. // Certificate Authorities. If the client has certificates to provide, it
  2911. // converts them to CERT_CONTEXTs and adds them to the given certificate
  2912. // store. LDAP subsequently passes these credentials to the SSL server as part
  2913. // of the handshake.
  2914. //
  2915.  
  2916. typedef BOOLEAN (_cdecl QUERYCLIENTCERT) (
  2917.     IN PLDAP Connection,
  2918.     IN PSecPkgContext_IssuerListInfoEx trusted_CAs,
  2919.     IN OUT HCERTSTORE hCertStore,
  2920.     IN OUT DWORD *pcCreds
  2921.     );
  2922.  
  2923. //
  2924. // We are also giving an opportunity for the client to verify the certificate
  2925. // of the server. The client registers a callback which is invoked after the
  2926. // secure connection is setup. The server certificate is presented to the
  2927. // client who invokes it and decides it it is acceptable. To register this
  2928. // callback, simply call ldap_set_option( conn, LDAP_OPT_SERVER_CERTIFICATE, &CertRoutine )
  2929. //
  2930.  
  2931. #define LDAP_OPT_SERVER_CERTIFICATE    0x81
  2932.  
  2933. //
  2934. // This function is called after the secure connection has been established. The
  2935. // certificate of the server is supplied for examination by the client. If the
  2936. // client approves it, it returns TRUE else, it returns false and the secure
  2937. // connection is torn down.
  2938. //
  2939.  
  2940. typedef BOOLEAN (_cdecl VERIFYSERVERCERT) (
  2941.      PLDAP Connection,
  2942.      PCCERT_CONTEXT pServerCert);
  2943.  
  2944.  
  2945.  
  2946. //
  2947. //  Given an LDAP message, return the connection pointer where the message
  2948. //  came from.  It can return NULL if the connection has already been freed.
  2949. //
  2950.  
  2951. WINLDAPAPI LDAP * LDAPAPI ldap_conn_from_msg (
  2952.     LDAP *PrimaryConn,
  2953.     LDAPMessage *res
  2954.     );
  2955.  
  2956. //
  2957. //  Do we reference the connection for each message so that we can safely get
  2958. //  the connection pointer back by calling ldap_conn_from_msg?
  2959. //
  2960.  
  2961. #define LDAP_OPT_REF_DEREF_CONN_PER_MSG 0x94
  2962.  
  2963. #ifdef __cplusplus
  2964. }
  2965. #endif
  2966.  
  2967. #pragma option pop /*P_O_Pop*/
  2968. #endif  // LDAP_CLIENT_DEFINED
  2969.