home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ldapsdk.zip / libraries / libldap / ldap-int.h < prev    next >
C/C++ Source or Header  |  2001-09-17  |  16KB  |  562 lines
  1. /*  ldap-int.h - defines & prototypes internal to the LDAP library */
  2. /* $OpenLDAP: pkg/ldap/libraries/libldap/ldap-int.h,v 1.49.2.18 2001/09/16 20:37:25 kurt Exp $ */
  3. /*
  4.  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
  5.  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  6.  */
  7. /*  Portions
  8.  *  Copyright (c) 1995 Regents of the University of Michigan.
  9.  *  All rights reserved.
  10.  */
  11.  
  12. #ifndef    _LDAP_INT_H
  13. #define    _LDAP_INT_H 1
  14.  
  15. #ifdef LDAP_R_COMPILE
  16. #define LDAP_THREAD_SAFE 1
  17. #endif
  18.  
  19. #include "../liblber/lber-int.h"
  20.  
  21. #ifdef HAVE_CYRUS_SASL
  22.     /* the need for this should be removed */
  23. #include <sasl.h>
  24.  
  25. #define SASL_MAX_BUFF_SIZE    65536
  26. #define SASL_MIN_BUFF_SIZE    4096
  27. #endif
  28.  
  29. /* 
  30.  * Support needed if the library is running in the kernel
  31.  */
  32. #if LDAP_INT_IN_KERNEL
  33.     /* 
  34.      * Platform specific function to return a pointer to the
  35.      * process-specific global options. 
  36.      *
  37.      * This function should perform the following functions:
  38.      *  Allocate and initialize a global options struct on a per process basis
  39.      *  Use callers process identifier to return its global options struct
  40.      *  Note: Deallocate structure when the process exits
  41.      */
  42. #    define LDAP_INT_GLOBAL_OPT() ldap_int_global_opt()
  43.    struct ldapoptions *ldap_int_global_opt(void);
  44. #else
  45. #    define LDAP_INT_GLOBAL_OPT() (&ldap_int_global_options)
  46. #endif
  47.  
  48. #define ldap_debug    ((LDAP_INT_GLOBAL_OPT())->ldo_debug)
  49.  
  50. #include "ldap_log.h"
  51.  
  52. #undef Debug
  53. #define Debug( level, fmt, arg1, arg2, arg3 ) \
  54.     ldap_log_printf( NULL, (level), (fmt), (arg1), (arg2), (arg3) )
  55.  
  56. #include "ldap.h"
  57.  
  58. #include "ldap_pvt.h"
  59.  
  60. LDAP_BEGIN_DECL
  61.  
  62. #define LDAP_URL_PREFIX         "ldap://"
  63. #define LDAP_URL_PREFIX_LEN     (sizeof(LDAP_URL_PREFIX)-1)
  64. #define LDAPS_URL_PREFIX        "ldaps://"
  65. #define LDAPS_URL_PREFIX_LEN    (sizeof(LDAPS_URL_PREFIX)-1)
  66. #define LDAPI_URL_PREFIX    "ldapi://"
  67. #define LDAPI_URL_PREFIX_LEN    (sizeof(LDAPI_URL_PREFIX)-1)
  68. #define LDAP_URL_URLCOLON        "URL:"
  69. #define LDAP_URL_URLCOLON_LEN    (sizeof(LDAP_URL_URLCOLON)-1)
  70.  
  71. #define LDAP_REF_STR        "Referral:\n"
  72. #define LDAP_REF_STR_LEN    (sizeof(LDAP_REF_STR)-1)
  73. #define LDAP_LDAP_REF_STR    LDAP_URL_PREFIX
  74. #define LDAP_LDAP_REF_STR_LEN    LDAP_URL_PREFIX_LEN
  75.  
  76. #define LDAP_DEFAULT_REFHOPLIMIT 5
  77.  
  78. #define LDAP_BOOL_REFERRALS        0
  79. #define LDAP_BOOL_RESTART        1
  80. #define LDAP_BOOL_TLS            3
  81.  
  82. #define LDAP_BOOLEANS    unsigned long
  83. #define LDAP_BOOL(n)    (1 << (n))
  84. #define LDAP_BOOL_GET(lo, bool)    \
  85.     ((lo)->ldo_booleans & LDAP_BOOL(bool) ? -1 : 0)
  86. #define LDAP_BOOL_SET(lo, bool) ((lo)->ldo_booleans |= LDAP_BOOL(bool))
  87. #define LDAP_BOOL_CLR(lo, bool) ((lo)->ldo_booleans &= ~LDAP_BOOL(bool))
  88. #define LDAP_BOOL_ZERO(lo) ((lo)->ldo_booleans = 0)
  89.  
  90. /*
  91.  * This structure represents both ldap messages and ldap responses.
  92.  * These are really the same, except in the case of search responses,
  93.  * where a response has multiple messages.
  94.  */
  95.  
  96. struct ldapmsg {
  97.     ber_int_t        lm_msgid;    /* the message id */
  98.     ber_tag_t        lm_msgtype;    /* the message type */
  99.     BerElement    *lm_ber;    /* the ber encoded message contents */
  100.     struct ldapmsg    *lm_chain;    /* for search - next msg in the resp */
  101.     struct ldapmsg    *lm_next;    /* next response */
  102.     time_t    lm_time;    /* used to maintain cache */
  103. };
  104.  
  105. /*
  106.  * structure representing get/set'able options
  107.  * which have global defaults.
  108.  */
  109. struct ldapoptions {
  110.     short ldo_valid;
  111. #define LDAP_UNINITIALIZED    0x0
  112. #define LDAP_INITIALIZED    0x1
  113. #define LDAP_VALID_SESSION    0x2
  114.  
  115.     int        ldo_debug;
  116.     /* per API call timeout */
  117.     struct timeval        *ldo_tm_api;
  118.     struct timeval        *ldo_tm_net;
  119.  
  120.     ber_int_t        ldo_version;
  121.     ber_int_t        ldo_deref;
  122.     ber_int_t        ldo_timelimit;
  123.     ber_int_t        ldo_sizelimit;
  124.  
  125. #ifdef HAVE_TLS
  126.        int            ldo_tls_mode;
  127. #endif
  128.  
  129.     LDAPURLDesc *ldo_defludp;
  130.     int        ldo_defport;
  131.     char*    ldo_defbase;
  132.     char*    ldo_defbinddn;    /* bind dn */
  133.  
  134. #ifdef HAVE_CYRUS_SASL
  135.     char*    ldo_def_sasl_mech;        /* SASL Mechanism(s) */
  136.     char*    ldo_def_sasl_realm;        /* SASL realm */
  137.     char*    ldo_def_sasl_authcid;    /* SASL authentication identity */
  138.     char*    ldo_def_sasl_authzid;    /* SASL authorization identity */
  139.  
  140.     /* SASL Security Properties */
  141.     struct sasl_security_properties    ldo_sasl_secprops;
  142. #endif
  143.  
  144.     int        ldo_refhoplimit;    /* limit on referral nesting */
  145.  
  146.     /* LDAPv3 server and client controls */
  147.     LDAPControl    **ldo_sctrls;
  148.     LDAPControl **ldo_cctrls;
  149.  
  150.     /* LDAP rebind callback function */
  151.     LDAP_REBIND_PROC        *ldo_rebindproc;
  152.  
  153.     LDAP_BOOLEANS ldo_booleans;    /* boolean options */
  154. };
  155.  
  156.  
  157. /*
  158.  * structure for representing an LDAP server connection
  159.  */
  160. typedef struct ldap_conn {
  161.     Sockbuf        *lconn_sb;
  162. #ifdef HAVE_TLS
  163.        /* tls context */
  164.        void        *lconn_tls_ctx;
  165. #endif
  166. #ifdef HAVE_CYRUS_SASL
  167.     void        *lconn_sasl_ctx;
  168. #endif
  169.     int            lconn_refcnt;
  170.     time_t        lconn_lastused;    /* time */
  171.     int            lconn_rebind_inprogress;    /* set if rebind in progress */
  172.     char        ***lconn_rebind_queue;        /* used if rebind in progress */
  173.     int            lconn_status;
  174. #define LDAP_CONNST_NEEDSOCKET        1
  175. #define LDAP_CONNST_CONNECTING        2
  176. #define LDAP_CONNST_CONNECTED        3
  177.     LDAPURLDesc        *lconn_server;
  178. #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
  179.     char            *lconn_krbinstance;
  180. #endif
  181.     BerElement        *lconn_ber;    /* ber receiving on this conn. */
  182.  
  183.     struct ldap_conn    *lconn_next;
  184. } LDAPConn;
  185.  
  186.  
  187. /*
  188.  * structure used to track outstanding requests
  189.  */
  190. typedef struct ldapreq {
  191.     ber_int_t        lr_msgid;    /* the message id */
  192.     int        lr_status;    /* status of request */
  193. #define LDAP_REQST_COMPLETED    0
  194. #define LDAP_REQST_INPROGRESS    1
  195. #define LDAP_REQST_CHASINGREFS    2
  196. #define LDAP_REQST_NOTCONNECTED    3
  197. #define LDAP_REQST_WRITING    4
  198.     int        lr_outrefcnt;    /* count of outstanding referrals */
  199.     ber_int_t        lr_origid;    /* original request's message id */
  200.     int        lr_parentcnt;    /* count of parent requests */
  201.     ber_tag_t        lr_res_msgtype;    /* result message type */
  202.     ber_int_t        lr_res_errno;    /* result LDAP errno */
  203.     char        *lr_res_error;    /* result error string */
  204.     char        *lr_res_matched;/* result matched DN string */
  205.     BerElement    *lr_ber;    /* ber encoded request contents */
  206.     LDAPConn    *lr_conn;    /* connection used to send request */
  207.     struct ldapreq    *lr_parent;    /* request that spawned this referral */
  208.     struct ldapreq    *lr_refnext;    /* next referral spawned */
  209.     struct ldapreq    *lr_prev;    /* previous request */
  210.     struct ldapreq    *lr_next;    /* next request */
  211. } LDAPRequest;
  212.  
  213. /*
  214.  * structure for client cache
  215.  */
  216. #define LDAP_CACHE_BUCKETS    31    /* cache hash table size */
  217. typedef struct ldapcache {
  218.     LDAPMessage    *lc_buckets[LDAP_CACHE_BUCKETS];/* hash table */
  219.     LDAPMessage    *lc_requests;            /* unfulfilled reqs */
  220.     long        lc_timeout;            /* request timeout */
  221.     ber_len_t        lc_maxmem;            /* memory to use */
  222.     ber_len_t        lc_memused;            /* memory in use */
  223.     int        lc_enabled;            /* enabled? */
  224.     unsigned long    lc_options;            /* options */
  225. #define LDAP_CACHE_OPT_CACHENOERRS    0x00000001
  226. #define LDAP_CACHE_OPT_CACHEALLERRS    0x00000002
  227. }  LDAPCache;
  228.  
  229. /*
  230.  * structure containing referral request info for rebind procedure
  231.  */
  232. typedef struct ldapreqinfo {
  233.     ber_len_t    ri_msgid;
  234.     int            ri_request;
  235.     char         *ri_url;
  236. } LDAPreqinfo;
  237.  
  238. /*
  239.  * structure representing an ldap connection
  240.  */
  241.  
  242. struct ldap {
  243.     Sockbuf        *ld_sb;        /* socket descriptor & buffer */
  244.  
  245.     struct ldapoptions ld_options;
  246.  
  247. #define ld_valid        ld_options.ldo_valid
  248. #define ld_debug        ld_options.ldo_debug
  249.  
  250. #define ld_deref        ld_options.ldo_deref
  251. #define ld_timelimit    ld_options.ldo_timelimit
  252. #define ld_sizelimit    ld_options.ldo_sizelimit
  253.  
  254. #define ld_defbinddn    ld_options.ldo_defbinddn
  255. #define ld_defbase        ld_options.ldo_defbase
  256. #define ld_defhost        ld_options.ldo_defhost
  257. #define ld_defport        ld_options.ldo_defport
  258.  
  259. #define ld_refhoplimit    ld_options.ldo_refhoplimit
  260.  
  261. #define ld_sctrls        ld_options.ldo_sctrls
  262. #define ld_cctrls        ld_options.ldo_cctrls
  263. #define ld_rebindproc    ld_options.ldo_rebindproc
  264.  
  265. #define ld_version        ld_options.ldo_version
  266.  
  267.     unsigned short    ld_lberoptions;
  268.  
  269.     LDAPFiltDesc    *ld_filtd;    /* from getfilter for ufn searches */
  270.     char        *ld_ufnprefix;    /* for incomplete ufn's */
  271.  
  272.     ber_int_t    ld_errno;
  273.     char    *ld_error;
  274.     char    *ld_matched;
  275.     ber_len_t        ld_msgid;
  276.  
  277.     /* do not mess with these */
  278.     LDAPRequest    *ld_requests;    /* list of outstanding requests */
  279.     LDAPMessage    *ld_responses;    /* list of outstanding responses */
  280.  
  281.     ber_int_t        *ld_abandoned;    /* array of abandoned requests */
  282.  
  283.     LDAPCache    *ld_cache;    /* non-null if cache is initialized */
  284.  
  285.     /* do not mess with the rest though */
  286.  
  287.     LDAPConn    *ld_defconn;    /* default connection */
  288.     LDAPConn    *ld_conns;    /* list of server connections */
  289.     void        *ld_selectinfo;    /* platform specifics for select */
  290. };
  291. #define LDAP_VALID(ld)    ( (ld)->ld_valid == LDAP_VALID_SESSION )
  292.  
  293. #ifdef LDAP_R_COMPILE
  294. #include <ldap_pvt_thread.h>
  295.  
  296. #ifdef HAVE_RES_QUERY
  297. LDAP_V ( ldap_pvt_thread_mutex_t ) ldap_int_resolv_mutex;
  298. #endif
  299.  
  300. #ifdef HAVE_CYRUS_SASL
  301. LDAP_V ( ldap_pvt_thread_mutex_t ) ldap_int_sasl_mutex;
  302. #endif
  303. #endif
  304.  
  305. /*
  306.  * in init.c
  307.  */
  308.  
  309. LDAP_V ( struct ldapoptions ) ldap_int_global_options;
  310.  
  311. LDAP_F ( void ) ldap_int_initialize LDAP_P((struct ldapoptions *, int *));
  312. LDAP_F ( void ) ldap_int_initialize_global_options LDAP_P((
  313.     struct ldapoptions *, int *));
  314.  
  315. /* memory.c */
  316.     /* simple macros to realloc for now */
  317. #define LDAP_INT_MALLOC(s)        (LBER_MALLOC((s)))
  318. #define LDAP_INT_CALLOC(n,s)    (LBER_CALLOC((n),(s)))
  319. #define LDAP_INT_REALLOC(p,s)    (LBER_REALLOC((p),(s)))
  320. #define LDAP_INT_FREE(p)        (LBER_FREE((p)))
  321. #define LDAP_INT_VFREE(v)        (LBER_VFREE((void **)(v)))
  322. #define LDAP_INT_STRDUP(s)        (LBER_STRDUP((s)))
  323.  
  324. #define LDAP_MALLOC(s)        (LBER_MALLOC((s)))
  325. #define LDAP_CALLOC(n,s)    (LBER_CALLOC((n),(s)))
  326. #define LDAP_REALLOC(p,s)    (LBER_REALLOC((p),(s)))
  327. #define LDAP_FREE(p)        (LBER_FREE((p)))
  328. #define LDAP_VFREE(v)        (LBER_VFREE((void **)(v)))
  329. #define LDAP_STRDUP(s)        (LBER_STRDUP((s)))
  330.  
  331. /*
  332.  * in unit-int.c
  333.  */
  334. LDAP_F (void) ldap_int_utils_init LDAP_P(( void ));
  335.  
  336.  
  337. /*
  338.  * in print.c
  339.  */
  340. LDAP_F (int) ldap_log_printf LDAP_P((LDAP *ld, int level, const char *fmt, ...)) LDAP_GCCATTR((format(printf, 3, 4)));
  341.  
  342. /*
  343.  * in cache.c
  344.  */
  345. LDAP_F (void) ldap_add_request_to_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype,
  346.         BerElement *request ));
  347. LDAP_F (void) ldap_add_result_to_cache LDAP_P(( LDAP *ld, LDAPMessage *result ));
  348. LDAP_F (int) ldap_check_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype, BerElement *request ));
  349.  
  350. /*
  351.  * in controls.c
  352.  */
  353. LDAP_F (LDAPControl *) ldap_control_dup LDAP_P((
  354.     const LDAPControl *ctrl ));
  355.  
  356. LDAP_F (LDAPControl **) ldap_controls_dup LDAP_P((
  357.     LDAPControl *const *ctrls ));
  358.  
  359. LDAP_F (int) ldap_int_get_controls LDAP_P((
  360.     BerElement *be,
  361.     LDAPControl ***ctrlsp));
  362.  
  363. LDAP_F (int) ldap_int_put_controls LDAP_P((
  364.     LDAP *ld,
  365.     LDAPControl *const *ctrls,
  366.     BerElement *ber ));
  367.  
  368. LDAP_F (int) ldap_int_client_controls LDAP_P((
  369.     LDAP *ld,
  370.     LDAPControl **ctrlp ));
  371.  
  372. /*
  373.  * in dsparse.c
  374.  */
  375. LDAP_F (int) ldap_int_next_line_tokens LDAP_P(( char **bufp, ber_len_t *blenp, char ***toksp ));
  376.  
  377. #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
  378. /*
  379.  * in kerberos.c
  380.  */
  381. LDAP_F (char *) ldap_get_kerberosv4_credentials LDAP_P((
  382.     LDAP *ld,
  383.     LDAP_CONST char *who,
  384.     LDAP_CONST char *service,
  385.     ber_len_t *len ));
  386.  
  387. #endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND */
  388.  
  389.  
  390. /*
  391.  * in open.c
  392.  */
  393. LDAP_F (int) ldap_open_defconn( LDAP *ld );
  394. LDAP_F (int) ldap_int_open_connection( LDAP *ld,
  395.     LDAPConn *conn, LDAPURLDesc *srvlist, int async );
  396.  
  397. /*
  398.  * in os-ip.c
  399.  */
  400. LDAP_F (int) ldap_int_tblsize;
  401. LDAP_F (int) ldap_int_timeval_dup( struct timeval **dest, const struct timeval *tm );
  402. LDAP_F (int) ldap_connect_to_host( LDAP *ld, Sockbuf *sb,
  403.     int proto, const char *host, unsigned long address, int port,
  404.     int async );
  405.  
  406. #if defined(LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND) || \
  407.     defined(HAVE_TLS) || defined(HAVE_CYRUS_SASL)
  408. LDAP_V (char *) ldap_int_hostname;
  409. LDAP_F (char *) ldap_host_connected_to( Sockbuf *sb );
  410. #endif
  411.  
  412. LDAP_F (void) ldap_int_ip_init( void );
  413. LDAP_F (int) do_ldap_select( LDAP *ld, struct timeval *timeout );
  414. LDAP_F (void *) ldap_new_select_info( void );
  415. LDAP_F (void) ldap_free_select_info( void *sip );
  416. LDAP_F (void) ldap_mark_select_write( LDAP *ld, Sockbuf *sb );
  417. LDAP_F (void) ldap_mark_select_read( LDAP *ld, Sockbuf *sb );
  418. LDAP_F (void) ldap_mark_select_clear( LDAP *ld, Sockbuf *sb );
  419. LDAP_F (int) ldap_is_read_ready( LDAP *ld, Sockbuf *sb );
  420. LDAP_F (int) ldap_is_write_ready( LDAP *ld, Sockbuf *sb );
  421.  
  422. /*
  423.  * in os-local.c
  424.  */
  425. #ifdef LDAP_PF_LOCAL
  426. LDAP_F (int) ldap_connect_to_path( LDAP *ld, Sockbuf *sb,
  427.     const char *path, int async );
  428. #endif /* LDAP_PF_LOCAL */
  429.  
  430. /*
  431.  * in request.c
  432.  */
  433. LDAP_F (ber_int_t) ldap_send_initial_request( LDAP *ld, ber_tag_t msgtype,
  434.     const char *dn, BerElement *ber );
  435. LDAP_F (BerElement *) ldap_alloc_ber_with_options( LDAP *ld );
  436. LDAP_F (void) ldap_set_ber_options( LDAP *ld, BerElement *ber );
  437.  
  438. LDAP_F (int) ldap_send_server_request( LDAP *ld, BerElement *ber, ber_int_t msgid, LDAPRequest *parentreq, LDAPURLDesc *srvlist, LDAPConn *lc, LDAPreqinfo *bind );
  439. LDAP_F (LDAPConn *) ldap_new_connection( LDAP *ld, LDAPURLDesc *srvlist, int use_ldsb, int connect, LDAPreqinfo *bind );
  440. LDAP_F (LDAPRequest *) ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid );
  441. LDAP_F (void) ldap_free_request( LDAP *ld, LDAPRequest *lr );
  442. LDAP_F (void) ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind );
  443. LDAP_F (void) ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all );
  444. LDAP_F (void) ldap_dump_requests_and_responses( LDAP *ld );
  445. LDAP_F (int) ldap_chase_referrals( LDAP *ld, LDAPRequest *lr,
  446.     char **errstrp, int sref, int *hadrefp );
  447. LDAP_F (int) ldap_chase_v3referrals( LDAP *ld, LDAPRequest *lr,
  448.     char **refs, int sref, char **referralsp, int *hadrefp );
  449. LDAP_F (int) ldap_append_referral( LDAP *ld, char **referralsp, char *s );
  450.  
  451. /*
  452.  * in result.c:
  453.  */
  454. LDAP_F (char *) ldap_int_msgtype2str( ber_tag_t tag );
  455.  
  456. /*
  457.  * in search.c
  458.  */
  459. LDAP_F (BerElement *) ldap_build_search_req LDAP_P((
  460.     LDAP *ld,
  461.     const char *base,
  462.     ber_int_t scope,
  463.     const char *filter,
  464.     char **attrs,
  465.     ber_int_t attrsonly,
  466.     LDAPControl **sctrls,
  467.     LDAPControl **cctrls,
  468.     ber_int_t timelimit,
  469.     ber_int_t sizelimit ));
  470.  
  471. /*
  472.  * in string.c
  473.  */
  474.     /* see <ac/string.h> */
  475.  
  476. /*
  477.  * in unbind.c
  478.  */
  479. LDAP_F (int) ldap_ld_free LDAP_P((
  480.     LDAP *ld,
  481.     int close,
  482.     LDAPControl **sctrls,
  483.     LDAPControl **cctrls ));
  484.  
  485. LDAP_F (int) ldap_send_unbind LDAP_P((
  486.     LDAP *ld,
  487.     Sockbuf *sb,
  488.     LDAPControl **sctrls,
  489.     LDAPControl **cctrls ));
  490.  
  491. /*
  492.  * in url.c
  493.  */
  494. LDAP_F (LDAPURLDesc *) ldap_url_dup LDAP_P((
  495.     LDAPURLDesc *ludp ));
  496.  
  497. LDAP_F (LDAPURLDesc *) ldap_url_duplist LDAP_P((
  498.     LDAPURLDesc *ludlist ));
  499.  
  500. LDAP_F (int) ldap_url_parselist LDAP_P((
  501.     LDAPURLDesc **ludlist,
  502.     const char *url ));
  503.  
  504. LDAP_F (int) ldap_url_parsehosts LDAP_P((
  505.     LDAPURLDesc **ludlist,
  506.     const char *hosts,
  507.     int port ));
  508.  
  509. LDAP_F (char *) ldap_url_list2hosts LDAP_P((
  510.     LDAPURLDesc *ludlist ));
  511.  
  512. LDAP_F (char *) ldap_url_list2urls LDAP_P((
  513.     LDAPURLDesc *ludlist ));
  514.  
  515. LDAP_F (void) ldap_free_urllist LDAP_P((
  516.     LDAPURLDesc *ludlist ));
  517.  
  518. /*
  519.  * in cyrus.c
  520.  */
  521. LDAP_F (int) ldap_int_sasl_init LDAP_P(( void ));
  522.  
  523. LDAP_F (int) ldap_int_sasl_open LDAP_P((
  524.     LDAP *ld, LDAPConn *conn,
  525.     const char* host, ber_len_t ssf ));
  526. LDAP_F (int) ldap_int_sasl_close LDAP_P(( LDAP *ld, LDAPConn *conn ));
  527.  
  528. LDAP_F (int) ldap_int_sasl_external LDAP_P((
  529.     LDAP *ld, LDAPConn *conn,
  530.     const char* authid, ber_len_t ssf ));
  531.  
  532. LDAP_F (int) ldap_int_sasl_get_option LDAP_P(( LDAP *ld,
  533.     int option, void *arg ));
  534. LDAP_F (int) ldap_int_sasl_set_option LDAP_P(( LDAP *ld,
  535.     int option, void *arg ));
  536. LDAP_F (int) ldap_int_sasl_config LDAP_P(( struct ldapoptions *lo,
  537.     int option, const char *arg ));
  538.  
  539. LDAP_F (int) ldap_int_sasl_bind LDAP_P((
  540.     LDAP *ld,
  541.     const char *,
  542.     const char *,
  543.     LDAPControl **, LDAPControl **,
  544.  
  545.     /* should be passed in client controls */
  546.     unsigned flags,
  547.     LDAP_SASL_INTERACT_PROC *interact,
  548.     void *defaults ));
  549.  
  550. /*
  551.  * in tls.c
  552.  */
  553. LDAP_F (int) ldap_int_tls_config LDAP_P(( LDAP *ld,
  554.     int option, const char *arg ));
  555.  
  556. LDAP_F (int) ldap_int_tls_start LDAP_P(( LDAP *ld,
  557.     LDAPConn *conn, LDAPURLDesc *srv ));
  558.  
  559. LDAP_END_DECL
  560.  
  561. #endif /* _LDAP_INT_H */
  562.