source4/lib/ldb/include/ldb.h

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Andrew Tridgell  2004
   5    Copyright (C) Stefan Metzmacher  2004
   6    Copyright (C) Simo Sorce  2005
   7
   8      ** NOTE! The following LGPL license applies to the ldb
   9      ** library. This does NOT imply that all of Samba is released
  10      ** under the LGPL
  11
  12    This library is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Lesser General Public
  14    License as published by the Free Software Foundation; either
  15    version 2 of the License, or (at your option) any later version.
  16
  17    This library is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    Lesser General Public License for more details.
  21
  22    You should have received a copy of the GNU Lesser General Public
  23    License along with this library; if not, write to the Free Software
  24    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25 */
  26
  27 /*
  28  *  Name: ldb
  29  *
  30  *  Component: ldb header
  31  *
  32  *  Description: defines for base ldb API
  33  *
  34  *  Author: Andrew Tridgell
  35  *  Author: Stefan Metzmacher
  36  */
  37
  38 /**
  39    \file ldb.h Samba's ldb database
  40
  41    This header file provides the main API for ldb.
  42 */
  43
  44 #ifndef _LDB_H_
  45
  46 /*! \cond DOXYGEN_IGNORE */
  47 #define _LDB_H_ 1
  48 /*! \endcond */
  49
  50 /*
  51   major restrictions as compared to normal LDAP:
  52
  53      - no async calls.
  54      - each record must have a unique key field
  55      - the key must be representable as a NULL terminated C string and may not
  56        contain a comma or braces
  57
  58   major restrictions as compared to tdb:
  59
  60      - no explicit locking calls
  61      UPDATE: we have transactions now, better than locking --SSS.
  62
  63 */
  64
  65 #ifndef ldb_val
  66 /**
  67    Result value
  68
  69    An individual lump of data in a result comes in this format. The
  70    pointer will usually be to a UTF-8 string if the application is
  71    sensible, but it can be to anything you like, including binary data
  72    blobs of arbitrary size.
  73
  74    \note the data is null (0x00) terminated, but the length does not
  75    include the terminator.
  76 */
  77 struct ldb_val {
  78         uint8_t *data; /*!< result data */
  79         size_t length; /*!< length of data */
  80 };
  81 #endif
  82
  83 /*! \cond DOXYGEN_IGNORE */
  84 #ifndef PRINTF_ATTRIBUTE
  85 #define PRINTF_ATTRIBUTE(a,b)
  86 #endif
  87 /*! \endcond */
  88
  89 /**
  90    internal ldb exploded dn structures
  91 */
  92 struct ldb_dn_component {
  93         char *name;
  94         struct ldb_val value;
  95 };
  96
  97 struct ldb_dn {
  98         int comp_num;
  99         struct ldb_dn_component *components;
 100 };
 101
 102 /**
 103  There are a number of flags that are used with ldap_modify() in
 104  ldb_message_element.flags fields. The LDA_FLAGS_MOD_ADD,
 105  LDA_FLAGS_MOD_DELETE and LDA_FLAGS_MOD_REPLACE flags are used in
 106  ldap_modify() calls to specify whether attributes are being added,
 107  deleted or modified respectively.
 108 */
 109 #define LDB_FLAG_MOD_MASK  0x3
 110
 111 /**
 112    Flag value used in ldap_modify() to indicate that attributes are
 113    being added.
 114
 115    \sa LDB_FLAG_MOD_MASK
 116 */
 117 #define LDB_FLAG_MOD_ADD     1
 118
 119 /**
 120    Flag value used in ldap_modify() to indicate that attributes are
 121    being replaced.
 122
 123    \sa LDB_FLAG_MOD_MASK
 124 */
 125 #define LDB_FLAG_MOD_REPLACE 2
 126
 127 /**
 128    Flag value used in ldap_modify() to indicate that attributes are
 129    being deleted.
 130
 131    \sa LDB_FLAG_MOD_MASK
 132 */
 133 #define LDB_FLAG_MOD_DELETE  3
 134
 135 /**
 136   OID for logic AND comaprison.
 137
 138   This is the well known object ID for a logical AND comparitor.
 139 */
 140 #define LDB_OID_COMPARATOR_AND  "1.2.840.113556.1.4.803"
 141
 142 /**
 143   OID for logic OR comparison.
 144
 145   This is the well known object ID for a logical OR comparitor.
 146 */
 147 #define LDB_OID_COMPARATOR_OR   "1.2.840.113556.1.4.804"
 148
 149 /**
 150   results are given back as arrays of ldb_message_element
 151 */
 152 struct ldb_message_element {
 153         unsigned int flags;
 154         const char *name;
 155         unsigned int num_values;
 156         struct ldb_val *values;
 157 };
 158
 159
 160 /**
 161   a ldb_message represents all or part of a record. It can contain an arbitrary
 162   number of elements.
 163 */
 164 struct ldb_message {
 165         struct ldb_dn *dn;
 166         unsigned int num_elements;
 167         struct ldb_message_element *elements;
 168         void *private_data; /* private to the backend */
 169 };
 170
 171 enum ldb_changetype {
 172         LDB_CHANGETYPE_NONE=0,
 173         LDB_CHANGETYPE_ADD,
 174         LDB_CHANGETYPE_DELETE,
 175         LDB_CHANGETYPE_MODIFY
 176 };
 177
 178 /**
 179   LDIF record
 180
 181   This structure contains a LDIF record, as returned from ldif_read()
 182   and equivalent functions.
 183 */
 184 struct ldb_ldif {
 185         enum ldb_changetype changetype; /*!< The type of change */
 186         struct ldb_message *msg;  /*!< The changes */
 187 };
 188
 189 enum ldb_scope {LDB_SCOPE_DEFAULT=-1,
 190                 LDB_SCOPE_BASE=0,
 191                 LDB_SCOPE_ONELEVEL=1,
 192                 LDB_SCOPE_SUBTREE=2};
 193
 194 struct ldb_context;
 195
 196 /*
 197   the fuction type for the callback used in traversing the database
 198 */
 199 typedef int (*ldb_traverse_fn)(struct ldb_context *, const struct ldb_message *);
 200
 201
 202 /* debugging uses one of the following levels */
 203 enum ldb_debug_level {LDB_DEBUG_FATAL, LDB_DEBUG_ERROR,
 204                       LDB_DEBUG_WARNING, LDB_DEBUG_TRACE};
 205
 206 /**
 207   the user can optionally supply a debug function. The function
 208   is based on the vfprintf() style of interface, but with the addition
 209   of a severity level
 210 */
 211 struct ldb_debug_ops {
 212         void (*debug)(void *context, enum ldb_debug_level level,
 213                       const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
 214         void *context;
 215 };
 216
 217 /**
 218   The user can optionally supply a custom utf8 functions,
 219   to handle comparisons and casefolding.
 220 */
 221 struct ldb_utf8_fns {
 222         void *context;
 223         char *(*casefold)(void *context, void *mem_ctx, const char *s);
 224 };
 225
 226 /**
 227    Flag value for database connection mode.
 228
 229    If LDB_FLG_RDONLY is used in ldb_connect, then the database will be
 230    opened read-only, if possible.
 231 */
 232 #define LDB_FLG_RDONLY 1
 233
 234 /**
 235    Flag value for database connection mode.
 236
 237    If LDB_FLG_NOSYNC is used in ldb_connect, then the database will be
 238    opened without synchronous operations, if possible.
 239 */
 240 #define LDB_FLG_NOSYNC 2
 241
 242 /**
 243    Flag value to specify autoreconnect mode.
 244
 245    If LDB_FLG_RECONNECT is used in ldb_connect, then the backend will
 246    be opened in a way that makes it try to auto reconnect if the
 247    connection is dropped (actually make sense only with ldap).
 248 */
 249 #define LDB_FLG_RECONNECT 4
 250
 251 /*
 252    structures for ldb_parse_tree handling code
 253 */
 254 enum ldb_parse_op { LDB_OP_AND=1, LDB_OP_OR=2, LDB_OP_NOT=3,
 255                     LDB_OP_EQUALITY=4, LDB_OP_SUBSTRING=5,
 256                     LDB_OP_GREATER=6, LDB_OP_LESS=7, LDB_OP_PRESENT=8,
 257                     LDB_OP_APPROX=9, LDB_OP_EXTENDED=10 };
 258
 259 struct ldb_parse_tree {
 260         enum ldb_parse_op operation;
 261         union {
 262                 struct {
 263                         struct ldb_parse_tree *child;
 264                 } isnot;
 265                 struct {
 266                         const char *attr;
 267                         struct ldb_val value;
 268                 } equality;
 269                 struct {
 270                         const char *attr;
 271                         int start_with_wildcard;
 272                         int end_with_wildcard;
 273                         struct ldb_val **chunks;
 274                 } substring;
 275                 struct {
 276                         const char *attr;
 277                 } present;
 278                 struct {
 279                         const char *attr;
 280                         struct ldb_val value;
 281                 } comparison;
 282                 struct {
 283                         const char *attr;
 284                         int dnAttributes;
 285                         char *rule_id;
 286                         struct ldb_val value;
 287                 } extended;
 288                 struct {
 289                         unsigned int num_elements;
 290                         struct ldb_parse_tree **elements;
 291                 } list;
 292         } u;
 293 };
 294
 295 struct ldb_parse_tree *ldb_parse_tree(void *mem_ctx, const char *s);
 296 char *ldb_filter_from_tree(void *mem_ctx, struct ldb_parse_tree *tree);
 297
 298 /**
 299    Encode a binary blob
 300
 301    This function encodes a binary blob using the encoding rules in RFC
 302    2254 (Section 4). This function also escapes any non-printable
 303    characters.
 304
 305    \param ctx the memory context to allocate the return string in.
 306    \param val the (potentially) binary data to be encoded
 307
 308    \return the encoded data as a null terminated string
 309
 310    \sa <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>.
 311 */
 312 char *ldb_binary_encode(void *ctx, struct ldb_val val);
 313
 314 /**
 315    Encode a string
 316
 317    This function encodes a string using the encoding rules in RFC 2254
 318    (Section 4). This function also escapes any non-printable
 319    characters.
 320
 321    \param mem_ctx the memory context to allocate the return string in.
 322    \param string the string to be encoded
 323
 324    \return the encoded data as a null terminated string
 325
 326    \sa <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>.
 327 */
 328 char *ldb_binary_encode_string(void *mem_ctx, const char *string);
 329
 330 /*
 331   functions for controlling attribute handling
 332 */
 333 typedef int (*ldb_attr_handler_t)(struct ldb_context *, void *mem_ctx, const struct ldb_val *, struct ldb_val *);
 334 typedef int (*ldb_attr_comparison_t)(struct ldb_context *, void *mem_ctx, const struct ldb_val *, const struct ldb_val *);
 335
 336 struct ldb_attrib_handler {
 337         const char *attr;
 338
 339         /* LDB_ATTR_FLAG_* */
 340         unsigned flags;
 341
 342         /* convert from ldif to binary format */
 343         ldb_attr_handler_t ldif_read_fn;
 344
 345         /* convert from binary to ldif format */
 346         ldb_attr_handler_t ldif_write_fn;
 347
 348         /* canonicalise a value, for use by indexing and dn construction */
 349         ldb_attr_handler_t canonicalise_fn;
 350
 351         /* compare two values */
 352         ldb_attr_comparison_t comparison_fn;
 353 };
 354
 355 /**
 356    The attribute is not returned by default
 357 */
 358 #define LDB_ATTR_FLAG_HIDDEN       (1<<0)
 359
 360 /**
 361    The attribute is constructed from other attributes
 362 */
 363 #define LDB_ATTR_FLAG_CONSTRUCTED  (1<<1)
 364
 365 /**
 366   LDAP attribute syntax for a DN
 367
 368   This is the well-known LDAP attribute syntax for a DN.
 369
 370   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 371 */
 372 #define LDB_SYNTAX_DN                   "1.3.6.1.4.1.1466.115.121.1.12"
 373
 374 /**
 375   LDAP attribute syntax for a Directory String
 376
 377   This is the well-known LDAP attribute syntax for a Directory String.
 378
 379   \sa <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 380 */
 381 #define LDB_SYNTAX_DIRECTORY_STRING     "1.3.6.1.4.1.1466.115.121.1.15"
 382
 383 /**
 384   LDAP attribute syntax for an integer
 385
 386   This is the well-known LDAP attribute syntax for an integer.
 387
 388   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 389 */
 390 #define LDB_SYNTAX_INTEGER              "1.3.6.1.4.1.1466.115.121.1.27"
 391
 392 /**
 393   LDAP attribute syntax for an octet string
 394
 395   This is the well-known LDAP attribute syntax for an octet string.
 396
 397   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 398 */
 399 #define LDB_SYNTAX_OCTET_STRING         "1.3.6.1.4.1.1466.115.121.1.40"
 400
 401 /**
 402   LDAP attribute syntax for UTC time.
 403
 404   This is the well-known LDAP attribute syntax for a UTC time.
 405
 406   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 407 */
 408 #define LDB_SYNTAX_UTC_TIME             "1.3.6.1.4.1.1466.115.121.1.53"
 409
 410 #define LDB_SYNTAX_OBJECTCLASS          "LDB_SYNTAX_OBJECTCLASS"
 411
 412 /* sorting helpers */
 413 typedef int (*ldb_qsort_cmp_fn_t) (void *v1, void *v2, void *opaque);
 414
 415 /**
 416    OID for the paged results control. This control is included in the
 417    searchRequest and searchResultDone messages as part of the controls
 418    field of the LDAPMessage, as defined in Section 4.1.12 of
 419    LDAP v3.
 420
 421    \sa <a href="http://www.ietf.org/rfc/rfc2696.txt">RFC 2696</a>.
 422 */
 423 #define LDB_CONTROL_PAGED_RESULTS_OID   "1.2.840.113556.1.4.319"
 424
 425 /**
 426    OID for specifying the returned elements of the ntSecurityDescriptor
 427
 428    \sa <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ldap/ldap/ldap_server_sd_flags_oid.asp">Microsoft documentation of this OID</a>
 429 */
 430 #define LDB_CONTROL_SD_FLAGS_OID        "1.2.840.113556.1.4.801"
 431
 432 /**
 433    OID for specifying an advanced scope for the search (one partition)
 434
 435    \sa <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ldap/ldap/ldap_server_domain_scope_oid.asp">Microsoft documentation of this OID</a>
 436 */
 437 #define LDB_CONTROL_DOMAIN_SCOPE_OID    "1.2.840.113556.1.4.1339"
 438
 439 /**
 440    OID for specifying an advanced scope for a search
 441
 442    \sa <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ldap/ldap/ldap_server_search_options_oid.asp">Microsoft documentation of this OID</a>
 443 */
 444 #define LDB_CONTROL_SEARCH_OPTIONS_OID  "1.2.840.113556.1.4.1340"
 445
 446 /**
 447    OID for notification
 448
 449    \sa <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ldap/ldap/ldap_server_notification_oid.asp">Microsoft documentation of this OID</a>
 450 */
 451 #define LDB_CONTROL_NOTIFICATION_OID    "1.2.840.113556.1.4.528"
 452
 453 /**
 454    OID for getting deleted objects
 455
 456    \sa <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ldap/ldap/ldap_server_show_deleted_oid.asp">Microsoft documentation of this OID</a>
 457 */
 458 #define LDB_CONTROL_SHOW_DELETED_OID    "1.2.840.113556.1.4.417"
 459
 460 /**
 461    OID for extended DN
 462
 463    \sa <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ldap/ldap/ldap_server_extended_dn_oid.asp">Microsoft documentation of this OID</a>
 464 */
 465 #define LDB_CONTROL_EXTENDED_DN_OID     "1.2.840.113556.1.4.529"
 466
 467 /**
 468    OID for LDAP server sort result extension.
 469
 470    This control is included in the searchRequest message as part of
 471    the controls field of the LDAPMessage, as defined in Section 4.1.12
 472    of LDAP v3. The controlType is set to
 473    "1.2.840.113556.1.4.473". The criticality MAY be either TRUE or
 474    FALSE (where absent is also equivalent to FALSE) at the client's
 475    option.
 476
 477    \sa <a href="http://www.ietf.org/rfc/rfc2891.txt">RFC 2891</a>.
 478 */
 479 #define LDB_CONTROL_SERVER_SORT_OID     "1.2.840.113556.1.4.473"
 480
 481 /**
 482    OID for LDAP server sort result response extension.
 483
 484    This control is included in the searchResultDone message as part of
 485    the controls field of the LDAPMessage, as defined in Section 4.1.12 of
 486    LDAP v3.
 487
 488    \sa <a href="http://www.ietf.org/rfc/rfc2891.txt">RFC 2891</a>.
 489 */
 490 #define LDB_CONTROL_SORT_RESP_OID       "1.2.840.113556.1.4.474"
 491
 492 /**
 493    OID for LDAP Attribute Scoped Query extension.
 494
 495    This control is included in SearchRequest or SearchResponse
 496    messages as part of the controls field of the LDAPMessage.
 497 */
 498 #define LDB_CONTROL_ASQ_OID             "1.2.840.113556.1.4.1504"
 499
 500 /**
 501    OID for LDAP Directory Sync extension.
 502
 503    This control is included in SearchRequest or SearchResponse
 504    messages as part of the controls field of the LDAPMessage.
 505 */
 506 #define LDB_CONTROL_DIRSYNC_OID         "1.2.840.113556.1.4.841"
 507
 508
 509 /**
 510    OID for LDAP Virtual List View Request extension.
 511
 512    This control is included in SearchRequest messages
 513    as part of the controls field of the LDAPMessage.
 514 */
 515 #define LDB_CONTROL_VLV_REQ_OID         "2.16.840.1.113730.3.4.9"
 516
 517 /**
 518    OID for LDAP Virtual List View Response extension.
 519
 520    This control is included in SearchResponse messages
 521    as part of the controls field of the LDAPMessage.
 522 */
 523 #define LDB_CONTROL_VLV_RESP_OID        "2.16.840.1.113730.3.4.10"
 524
 525 /**
 526    OID to let modifies don't give an error when adding an existing
 527    attribute with the same value or deleting an nonexisting one attribute
 528
 529    \sa <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ldap/ldap/ldap_server_permissive_modify_oid.asp">Microsoft documentation of this OID</a>
 530 */
 531 #define LDB_CONTROL_PERMISSIVE_MODIFY_OID       "1.2.840.113556.1.4.1413"
 532
 533 /**
 534    OID for LDAP Extended Operation START_TLS.
 535
 536    This Extended operation is used to start a new TLS
 537    channel on top of a clear text channel.
 538 */
 539 #define LDB_EXTENDED_START_TLS_OID      "1.3.6.1.4.1.1466.20037"
 540
 541 /**
 542    OID for LDAP Extended Operation START_TLS.
 543
 544    This Extended operation is used to start a new TLS
 545    channel on top of a clear text channel.
 546 */
 547 #define LDB_EXTENDED_DYNAMIC_OID        "1.3.6.1.4.1.1466.101.119.1"
 548
 549 /**
 550    OID for LDAP Extended Operation START_TLS.
 551
 552    This Extended operation is used to start a new TLS
 553    channel on top of a clear text channel.
 554 */
 555 #define LDB_EXTENDED_FAST_BIND_OID      "1.2.840.113556.1.4.1781"
 556
 557 struct ldb_sd_flags_control {
 558         /*
 559          * request the owner    0x00000001
 560          * request the group    0x00000002
 561          * request the DACL     0x00000004
 562          * request the SACL     0x00000008
 563          */
 564         unsigned secinfo_flags;
 565 };
 566
 567 struct ldb_search_options_control {
 568         /*
 569          * DOMAIN_SCOPE         0x00000001
 570          * this limits the search to one partition,
 571          * and no referrals will be returned.
 572          * (Note this doesn't limit the entries by there
 573          *  objectSid belonging to a domain! Builtin and Foreign Sids
 574          *  are still returned)
 575          *
 576          * PHANTOM_ROOT         0x00000002
 577          * this search on the whole tree on a domain controller
 578          * over multiple partitions without referrals.
 579          * (This is the default behavior on the Global Catalog Port)
 580          */
 581         unsigned search_options;
 582 };
 583
 584 struct ldb_paged_control {
 585         int size;
 586         int cookie_len;
 587         char *cookie;
 588 };
 589
 590 struct ldb_extended_dn_control {
 591         int type;
 592 };
 593
 594 struct ldb_server_sort_control {
 595         char *attributeName;
 596         char *orderingRule;
 597         int reverse;
 598 };
 599
 600 struct ldb_sort_resp_control {
 601         int result;
 602         char *attr_desc;
 603 };
 604
 605 struct ldb_asq_control {
 606         int request;
 607         char *source_attribute;
 608         int src_attr_len;
 609         int result;
 610 };
 611
 612 struct ldb_dirsync_control {
 613         int flags;
 614         int max_attributes;
 615         int cookie_len;
 616         char *cookie;
 617 };
 618
 619 struct ldb_vlv_req_control {
 620         int beforeCount;
 621         int afterCount;
 622         int type;
 623         union {
 624                 struct {
 625                         int offset;
 626                         int contentCount;
 627                 } byOffset;
 628                 struct {
 629                         int value_len;
 630                         char *value;
 631                 } gtOrEq;
 632         } match;
 633         int ctxid_len;
 634         char *contextId;
 635 };
 636
 637 struct ldb_vlv_resp_control {
 638         int targetPosition;
 639         int contentCount;
 640         int vlv_result;
 641         int ctxid_len;
 642         char *contextId;
 643 };
 644
 645 struct ldb_control {
 646         const char *oid;
 647         int critical;
 648         void *data;
 649 };
 650
 651 enum ldb_request_type {
 652         LDB_SEARCH,
 653         LDB_ADD,
 654         LDB_MODIFY,
 655         LDB_DELETE,
 656         LDB_RENAME,
 657         LDB_EXTENDED,
 658         LDB_REQ_REGISTER_CONTROL,
 659         LDB_REQ_REGISTER_PARTITION,
 660         LDB_SEQUENCE_NUMBER
 661 };
 662
 663 enum ldb_reply_type {
 664         LDB_REPLY_ENTRY,
 665         LDB_REPLY_REFERRAL,
 666         LDB_REPLY_EXTENDED,
 667         LDB_REPLY_DONE
 668 };
 669
 670 enum ldb_wait_type {
 671         LDB_WAIT_ALL,
 672         LDB_WAIT_NONE
 673 };
 674
 675 enum ldb_state {
 676         LDB_ASYNC_INIT,
 677         LDB_ASYNC_PENDING,
 678         LDB_ASYNC_DONE
 679 };
 680
 681 struct ldb_result {
 682         unsigned int count;
 683         struct ldb_message **msgs;
 684         char **refs;
 685         struct ldb_control **controls;
 686 };
 687
 688 struct ldb_extended {
 689         const char *oid;
 690         const char *value;
 691         int value_len;
 692 };
 693
 694 struct ldb_reply {
 695         enum ldb_reply_type type;
 696         struct ldb_message *message;
 697         struct ldb_extended *response;
 698         char *referral;
 699         struct ldb_control **controls;
 700 };
 701
 702 struct ldb_handle {
 703         int status;
 704         enum ldb_state state;
 705         void *private_data;
 706         struct ldb_module *module;
 707 };
 708
 709 struct ldb_search {
 710         const struct ldb_dn *base;
 711         enum ldb_scope scope;
 712         const struct ldb_parse_tree *tree;
 713         const char * const *attrs;
 714         struct ldb_result *res;
 715 };
 716
 717 struct ldb_add {
 718         const struct ldb_message *message;
 719 };
 720
 721 struct  ldb_modify {
 722         const struct ldb_message *message;
 723 };
 724
 725 struct ldb_delete {
 726         const struct ldb_dn *dn;
 727 };
 728
 729 struct ldb_rename {
 730         const struct ldb_dn *olddn;
 731         const struct ldb_dn *newdn;
 732 };
 733
 734 struct ldb_register_control {
 735         const char *oid;
 736 };
 737
 738 struct ldb_register_partition {
 739         const struct ldb_dn *dn;
 740 };
 741
 742 struct ldb_sequence_number {
 743         uint64_t seq_num;
 744 };
 745
 746 struct ldb_request {
 747
 748         enum ldb_request_type operation;
 749
 750         union {
 751                 struct ldb_search search;
 752                 struct ldb_add    add;
 753                 struct ldb_modify mod;
 754                 struct ldb_delete del;
 755                 struct ldb_rename rename;
 756                 struct ldb_register_control reg_control;
 757                 struct ldb_register_partition reg_partition;
 758                 struct ldb_sequence_number seq_num;
 759         } op;
 760
 761         struct ldb_control **controls;
 762
 763         void *context;
 764         int (*callback)(struct ldb_context *, void *, struct ldb_reply *);
 765
 766         int timeout;
 767         time_t starttime;
 768         struct ldb_handle *handle;
 769 };
 770
 771 int ldb_request(struct ldb_context *ldb, struct ldb_request *request);
 772
 773 int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type);
 774
 775 int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeout);
 776 int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *oldreq, struct ldb_request *newreq);
 777
 778 /**
 779   Initialise ldbs' global information
 780
 781   This is required before any other LDB call
 782
 783   \return 0 if initialisation succeeded, -1 otherwise
 784 */
 785 int ldb_global_init(void);
 786
 787 /**
 788   Initialise an ldb context
 789
 790   This is required before any other LDB call.
 791
 792   \param mem_ctx pointer to a talloc memory context. Pass NULL if there is
 793   no suitable context available.
 794
 795   \return pointer to ldb_context that should be free'd (using talloc_free())
 796   at the end of the program.
 797 */
 798 struct ldb_context *ldb_init(void *mem_ctx);
 799
 800 /**
 801    Connect to a database.
 802
 803    This is typically called soon after ldb_init(), and is required prior to
 804    any search or database modification operations.
 805
 806    The URL can be one of the following forms:
 807     - tdb://path
 808     - ldapi://path
 809     - ldap://host
 810     - sqlite://path
 811
 812    \param ldb the context associated with the database (from ldb_init())
 813    \param url the URL of the database to connect to, as noted above
 814    \param flags a combination of LDB_FLG_* to modify the connection behaviour
 815    \param options backend specific options - passed uninterpreted to the backend
 816
 817    \return result code (LDB_SUCCESS on success, or a failure code)
 818
 819    \note It is an error to connect to a database that does not exist in readonly mode
 820    (that is, with LDB_FLG_RDONLY). However in read-write mode, the database will be
 821    created if it does not exist.
 822 */
 823 int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[]);
 824
 825 /**
 826   Search the database
 827
 828   This function searches the database, and returns
 829   records that match an LDAP-like search expression
 830
 831   \param ldb the context associated with the database (from ldb_init())
 832   \param base the Base Distinguished Name for the query (pass NULL for root DN)
 833   \param scope the search scope for the query
 834   \param expression the search expression to use for this query
 835   \param attrs the search attributes for the query (pass NULL if none required)
 836   \param res the return result
 837
 838   \return result code (LDB_SUCCESS on success, or a failure code)
 839
 840   \note use talloc_free() to free the ldb_result returned
 841 */
 842 int ldb_search(struct ldb_context *ldb,
 843                const struct ldb_dn *base,
 844                enum ldb_scope scope,
 845                const char *expression,
 846                const char * const *attrs, struct ldb_result **res);
 847
 848 /*
 849   like ldb_search() but takes a parse tree
 850 */
 851 int ldb_search_bytree(struct ldb_context *ldb,
 852                       const struct ldb_dn *base,
 853                       enum ldb_scope scope,
 854                       struct ldb_parse_tree *tree,
 855                       const char * const *attrs, struct ldb_result **res);
 856
 857 /**
 858   Add a record to the database.
 859
 860   This function adds a record to the database. This function will fail
 861   if a record with the specified class and key already exists in the
 862   database.
 863
 864   \param ldb the context associated with the database (from
 865   ldb_init())
 866   \param message the message containing the record to add.
 867
 868   \return result code (LDB_SUCCESS if the record was added, otherwise
 869   a failure code)
 870 */
 871 int ldb_add(struct ldb_context *ldb,
 872             const struct ldb_message *message);
 873
 874 /**
 875   Modify the specified attributes of a record
 876
 877   This function modifies a record that is in the database.
 878
 879   \param ldb the context associated with the database (from
 880   ldb_init())
 881   \param message the message containing the changes required.
 882
 883   \return result code (LDB_SUCCESS if the record was modified as
 884   requested, otherwise a failure code)
 885 */
 886 int ldb_modify(struct ldb_context *ldb,
 887                const struct ldb_message *message);
 888
 889 /**
 890   Rename a record in the database
 891
 892   This function renames a record in the database.
 893
 894   \param ldb the context associated with the database (from
 895   ldb_init())
 896   \param olddn the DN for the record to be renamed.
 897   \param newdn the new DN
 898
 899   \return result code (LDB_SUCCESS if the record was renamed as
 900   requested, otherwise a failure code)
 901 */
 902 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn);
 903
 904 /**
 905   Delete a record from the database
 906
 907   This function deletes a record from the database.
 908
 909   \param ldb the context associated with the database (from
 910   ldb_init())
 911   \param dn the DN for the record to be deleted.
 912
 913   \return result code (LDB_SUCCESS if the record was deleted,
 914   otherwise a failure code)
 915 */
 916 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn);
 917
 918 /**
 919   Obtain current database sequence number
 920 */
 921 int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num);
 922
 923 /**
 924   start a transaction
 925 */
 926 int ldb_transaction_start(struct ldb_context *ldb);
 927
 928 /**
 929   commit a transaction
 930 */
 931 int ldb_transaction_commit(struct ldb_context *ldb);
 932
 933 /**
 934   cancel a transaction
 935 */
 936 int ldb_transaction_cancel(struct ldb_context *ldb);
 937
 938
 939 /**
 940   return extended error information from the last call
 941 */
 942 const char *ldb_errstring(struct ldb_context *ldb);
 943
 944 /**
 945   return a string explaining what a ldb error constant meancs
 946 */
 947 const char *ldb_strerror(int ldb_err);
 948
 949 /**
 950   setup the default utf8 functions
 951   FIXME: these functions do not yet handle utf8
 952 */
 953 void ldb_set_utf8_default(struct ldb_context *ldb);
 954
 955 /**
 956    Casefold a string
 957
 958    \param ldb the ldb context
 959    \param mem_ctx the memory context to allocate the result string
 960    memory from.
 961    \param s the string that is to be folded
 962    \return a copy of the string, converted to upper case
 963
 964    \note The default function is not yet UTF8 aware. Provide your own
 965          set of functions through ldb_set_utf8_fns()
 966 */
 967 char *ldb_casefold(struct ldb_context *ldb, void *mem_ctx, const char *s);
 968
 969 /**
 970    Check the attribute name is valid according to rfc2251
 971    \param s tthe string to check
 972
 973    \return 1 if the name is ok
 974 */
 975 int ldb_valid_attr_name(const char *s);
 976
 977 /*
 978   ldif manipulation functions
 979 */
 980 /**
 981    Write an LDIF message
 982
 983    This function writes an LDIF message using a caller supplied  write
 984    function.
 985
 986    \param ldb the ldb context (from ldb_init())
 987    \param fprintf_fn a function pointer for the write function. This must take
 988    a private data pointer, followed by a format string, and then a variable argument
 989    list.
 990    \param private_data pointer that will be provided back to the write
 991    function. This is useful for maintaining state or context.
 992    \param ldif the message to write out
 993
 994    \return the total number of bytes written, or an error code as returned
 995    from the write function.
 996
 997    \sa ldb_ldif_write_file for a more convenient way to write to a
 998    file stream.
 999
1000    \sa ldb_ldif_read for the reader equivalent to this function.
1001 */
1002 int ldb_ldif_write(struct ldb_context *ldb,
1003                    int (*fprintf_fn)(void *, const char *, ...) PRINTF_ATTRIBUTE(2,3),
1004                    void *private_data,
1005                    const struct ldb_ldif *ldif);
1006
1007 /**
1008    Clean up an LDIF message
1009
1010    This function cleans up a LDIF message read using ldb_ldif_read()
1011    or related functions (such as ldb_ldif_read_string() and
1012    ldb_ldif_read_file().
1013
1014    \param ldb the ldb context (from ldb_init())
1015    \param msg the message to clean up and free
1016
1017 */
1018 void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *msg);
1019
1020 /**
1021    Read an LDIF message
1022
1023    This function creates an LDIF message using a caller supplied read
1024    function.
1025
1026    \param ldb the ldb context (from ldb_init())
1027    \param fgetc_fn a function pointer for the read function. This must
1028    take a private data pointer, and must return a pointer to an
1029    integer corresponding to the next byte read (or EOF if there is no
1030    more data to be read).
1031    \param private_data pointer that will be provided back to the read
1032    function. This is udeful for maintaining state or context.
1033
1034    \return the LDIF message that has been read in
1035
1036    \note You must free the LDIF message when no longer required, using
1037    ldb_ldif_read_free().
1038
1039    \sa ldb_ldif_read_file for a more convenient way to read from a
1040    file stream.
1041
1042    \sa ldb_ldif_read_string for a more convenient way to read from a
1043    string (char array).
1044
1045    \sa ldb_ldif_write for the writer equivalent to this function.
1046 */
1047 struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
1048                                int (*fgetc_fn)(void *), void *private_data);
1049
1050 /**
1051    Read an LDIF message from a file
1052
1053    This function reads the next LDIF message from the contents of a
1054    file stream. If you want to get all of the LDIF messages, you will
1055    need to repeatedly call this function, until it returns NULL.
1056
1057    \param ldb the ldb context (from ldb_init())
1058    \param f the file stream to read from (typically from fdopen())
1059
1060    \sa ldb_ldif_read_string for an equivalent function that will read
1061    from a string (char array).
1062
1063    \sa ldb_ldif_write_file for the writer equivalent to this function.
1064
1065 */
1066 struct ldb_ldif *ldb_ldif_read_file(struct ldb_context *ldb, FILE *f);
1067
1068 /**
1069    Read an LDIF message from a string
1070
1071    This function reads the next LDIF message from the contents of a char
1072    array. If you want to get all of the LDIF messages, you will need
1073    to repeatedly call this function, until it returns NULL.
1074
1075    \param ldb the ldb context (from ldb_init())
1076    \param s pointer to the char array to read from
1077
1078    \sa ldb_ldif_read_file for an equivalent function that will read
1079    from a file stream.
1080
1081    \sa ldb_ldif_write for a more general (arbitrary read function)
1082    version of this function.
1083 */
1084 struct ldb_ldif *ldb_ldif_read_string(struct ldb_context *ldb, const char **s);
1085
1086 /**
1087    Write an LDIF message to a file
1088
1089    \param ldb the ldb context (from ldb_init())
1090    \param f the file stream to write to (typically from fdopen())
1091    \param msg the message to write out
1092
1093    \return the total number of bytes written, or a negative error code
1094
1095    \sa ldb_ldif_read_file for the reader equivalent to this function.
1096 */
1097 int ldb_ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *msg);
1098
1099 /**
1100    Base64 encode a buffer
1101
1102    \param mem_ctx the memory context that the result is allocated
1103    from.
1104    \param buf pointer to the array that is to be encoded
1105    \param len the number of elements in the array to be encoded
1106
1107    \return pointer to an array containing the encoded data
1108
1109    \note The caller is responsible for freeing the result
1110 */
1111 char *ldb_base64_encode(void *mem_ctx, const char *buf, int len);
1112
1113 /**
1114    Base64 decode a buffer
1115
1116    This function decodes a base64 encoded string in place.
1117
1118    \param s the string to decode.
1119
1120    \return the length of the returned (decoded) string.
1121
1122    \note the string is null terminated, but the null terminator is not
1123    included in the length.
1124 */
1125 int ldb_base64_decode(char *s);
1126
1127 int ldb_attrib_add_handlers(struct ldb_context *ldb,
1128                             const struct ldb_attrib_handler *handlers,
1129                             unsigned num_handlers);
1130
1131 /* The following definitions come from lib/ldb/common/ldb_dn.c  */
1132
1133 int ldb_dn_is_special(const struct ldb_dn *dn);
1134 int ldb_dn_check_special(const struct ldb_dn *dn, const char *check);
1135 char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value);
1136 struct ldb_dn *ldb_dn_new(void *mem_ctx);
1137 struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn);
1138 struct ldb_dn *ldb_dn_explode_or_special(void *mem_ctx, const char *dn);
1139 char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn);
1140 char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *edn);
1141 int ldb_dn_compare_base(struct ldb_context *ldb, const struct ldb_dn *base, const struct ldb_dn *dn);
1142 int ldb_dn_compare(struct ldb_context *ldb, const struct ldb_dn *edn0, const struct ldb_dn *edn1);
1143 struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn);
1144 struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn);
1145 struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el);
1146 struct ldb_dn *ldb_dn_copy(void *mem_ctx, const struct ldb_dn *dn);
1147 struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, const struct ldb_dn *dn);
1148 struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
1149                                                                const char *val);
1150 struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
1151                                                  const char * value,
1152                                                  const struct ldb_dn *base);
1153 struct ldb_dn *ldb_dn_make_child(void *mem_ctx,
1154                                  const struct ldb_dn_component *component,
1155                                  const struct ldb_dn *base);
1156 struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2);
1157 struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, const char *child_fmt, ...) PRINTF_ATTRIBUTE(3,4);
1158 struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn);
1159
1160 /* useful functions for ldb_message structure manipulation */
1161 int ldb_dn_cmp(struct ldb_context *ldb, const char *dn1, const char *dn2);
1162
1163 /**
1164    Compare two attributes
1165
1166    This function compares to attribute names. Note that this is a
1167    case-insensitive comparison.
1168
1169    \param attr1 the first attribute name to compare
1170    \param attr2 the second attribute name to compare
1171
1172    \return 0 if the attribute names are the same, or only differ in
1173    case; non-zero if there are any differences
1174 */
1175 int ldb_attr_cmp(const char *attr1, const char *attr2);
1176 char *ldb_attr_casefold(void *mem_ctx, const char *s);
1177 int ldb_attr_dn(const char *attr);
1178
1179 /**
1180    Create an empty message
1181
1182    \param mem_ctx the memory context to create in. You can pass NULL
1183    to get the top level context, however the ldb context (from
1184    ldb_init()) may be a better choice
1185 */
1186 struct ldb_message *ldb_msg_new(void *mem_ctx);
1187
1188 /**
1189    Find an element within an message
1190 */
1191 struct ldb_message_element *ldb_msg_find_element(const struct ldb_message *msg,
1192                                                  const char *attr_name);
1193
1194 /**
1195    Compare two ldb_val values
1196
1197    \param v1 first ldb_val structure to be tested
1198    \param v2 second ldb_val structure to be tested
1199
1200    \return 1 for a match, 0 if there is any difference
1201 */
1202 int ldb_val_equal_exact(const struct ldb_val *v1, const struct ldb_val *v2);
1203
1204 /**
1205    find a value within an ldb_message_element
1206
1207    \param el the element to search
1208    \param val the value to search for
1209
1210    \note This search is case sensitive
1211 */
1212 struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
1213                                  struct ldb_val *val);
1214
1215 /**
1216    add a new empty element to a ldb_message
1217 */
1218 int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags);
1219
1220 /**
1221    add a element to a ldb_message
1222 */
1223 int ldb_msg_add(struct ldb_message *msg,
1224                 const struct ldb_message_element *el,
1225                 int flags);
1226 int ldb_msg_add_value(struct ldb_message *msg,
1227                       const char *attr_name,
1228                       const struct ldb_val *val);
1229 int ldb_msg_add_steal_value(struct ldb_message *msg,
1230                       const char *attr_name,
1231                       struct ldb_val *val);
1232 int ldb_msg_add_steal_string(struct ldb_message *msg,
1233                              const char *attr_name, char *str);
1234 int ldb_msg_add_string(struct ldb_message *msg,
1235                        const char *attr_name, const char *str);
1236 int ldb_msg_add_fmt(struct ldb_message *msg,
1237                     const char *attr_name, const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
1238
1239 /**
1240    compare two message elements - return 0 on match
1241 */
1242 int ldb_msg_element_compare(struct ldb_message_element *el1,
1243                             struct ldb_message_element *el2);
1244
1245 /**
1246    Find elements in a message.
1247
1248    This function finds elements and converts to a specific type, with
1249    a give default value if not found. Assumes that elements are
1250    single valued.
1251 */
1252 const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, const char *attr_name);
1253 int ldb_msg_find_attr_as_int(const struct ldb_message *msg,
1254                              const char *attr_name,
1255                              int default_value);
1256 unsigned int ldb_msg_find_attr_as_uint(const struct ldb_message *msg,
1257                                        const char *attr_name,
1258                                        unsigned int default_value);
1259 int64_t ldb_msg_find_attr_as_int64(const struct ldb_message *msg,
1260                                    const char *attr_name,
1261                                    int64_t default_value);
1262 uint64_t ldb_msg_find_attr_as_uint64(const struct ldb_message *msg,
1263                                      const char *attr_name,
1264                                      uint64_t default_value);
1265 double ldb_msg_find_attr_as_double(const struct ldb_message *msg,
1266                                    const char *attr_name,
1267                                    double default_value);
1268 int ldb_msg_find_attr_as_bool(const struct ldb_message *msg,
1269                               const char *attr_name,
1270                               int default_value);
1271 const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg,
1272                                         const char *attr_name,
1273                                         const char *default_value);
1274
1275 struct ldb_dn *ldb_msg_find_attr_as_dn(void *mem_ctx,
1276                                        const struct ldb_message *msg,
1277                                         const char *attr_name);
1278
1279 void ldb_msg_sort_elements(struct ldb_message *msg);
1280
1281 struct ldb_message *ldb_msg_copy_shallow(void *mem_ctx,
1282                                          const struct ldb_message *msg);
1283 struct ldb_message *ldb_msg_copy(void *mem_ctx,
1284                                  const struct ldb_message *msg);
1285
1286 struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
1287                                          const struct ldb_message *msg);
1288
1289
1290 struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
1291                                  struct ldb_message *msg1,
1292                                  struct ldb_message *msg2);
1293
1294 int ldb_msg_check_string_attribute(const struct ldb_message *msg,
1295                                    const char *name,
1296                                    const char *value);
1297
1298 /**
1299    Integrity check an ldb_message
1300
1301    This function performs basic sanity / integrity checks on an
1302    ldb_message.
1303
1304    \param msg the message to check
1305
1306    \return LDB_SUCCESS if the message is OK, or a non-zero error code
1307    (one of LDB_ERR_INVALID_DN_SYNTAX, LDB_ERR_ENTRY_ALREADY_EXISTS or
1308    LDB_ERR_INVALID_ATTRIBUTE_SYNTAX) if there is a problem with a
1309    message.
1310 */
1311 int ldb_msg_sanity_check(struct ldb_context *ldb,
1312                          const struct ldb_message *msg);
1313
1314 /**
1315    Duplicate an ldb_val structure
1316
1317    This function copies an ldb value structure.
1318
1319    \param mem_ctx the memory context that the duplicated value will be
1320    allocated from
1321    \param v the ldb_val to be duplicated.
1322
1323    \return the duplicated ldb_val structure.
1324 */
1325 struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v);
1326
1327 /**
1328   this allows the user to set a debug function for error reporting
1329 */
1330 int ldb_set_debug(struct ldb_context *ldb,
1331                   void (*debug)(void *context, enum ldb_debug_level level,
1332                                 const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0),
1333                   void *context);
1334
1335 /**
1336   this allows the user to set custom utf8 function for error reporting
1337 */
1338 void ldb_set_utf8_fns(struct ldb_context *ldb,
1339                         void *context,
1340                         char *(*casefold)(void *, void *, const char *));
1341
1342 /**
1343    this sets up debug to print messages on stderr
1344 */
1345 int ldb_set_debug_stderr(struct ldb_context *ldb);
1346
1347 /* control backend specific opaque values */
1348 int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value);
1349 void *ldb_get_opaque(struct ldb_context *ldb, const char *name);
1350
1351 const struct ldb_attrib_handler *ldb_attrib_handler(struct ldb_context *ldb,
1352                                                     const char *attrib);
1353
1354
1355 const char **ldb_attr_list_copy(void *mem_ctx, const char * const *attrs);
1356 const char **ldb_attr_list_copy_add(void *mem_ctx, const char * const *attrs, const char *new_attr);
1357 int ldb_attr_in_list(const char * const *attrs, const char *attr);
1358
1359
1360 void ldb_parse_tree_attr_replace(struct ldb_parse_tree *tree,
1361                                  const char *attr,
1362                                  const char *replace);
1363
1364 int ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *replace);
1365 int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *replace);
1366 void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr);
1367
1368 /**
1369    Convert a time structure to a string
1370
1371    This function converts a time_t structure to an LDAP formatted time
1372    string.
1373
1374    \param mem_ctx the memory context to allocate the return string in
1375    \param t the time structure to convert
1376
1377    \return the formatted string, or NULL if the time structure could
1378    not be converted
1379 */
1380 char *ldb_timestring(void *mem_ctx, time_t t);
1381
1382 /**
1383    Convert a string to a time structure
1384
1385    This function converts an LDAP formatted time string to a time_t
1386    structure.
1387
1388    \param s the string to convert
1389
1390    \return the time structure, or 0 if the string cannot be converted
1391 */
1392 time_t ldb_string_to_time(const char *s);
1393
1394 char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn);
1395 char *ldb_dn_canonical_ex_string(void *mem_ctx, const struct ldb_dn *dn);
1396
1397
1398 void ldb_qsort (void *const pbase, size_t total_elems, size_t size, void *opaque, ldb_qsort_cmp_fn_t cmp);
1399 #endif