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   return an automatic baseDN from the defaultNamingContext of the rootDSE
 827 */
 828 const struct ldb_dn *ldb_auto_basedn(struct ldb_context *ldb);
 829
 830 /**
 831   Search the database
 832
 833   This function searches the database, and returns
 834   records that match an LDAP-like search expression
 835
 836   \param ldb the context associated with the database (from ldb_init())
 837   \param base the Base Distinguished Name for the query (pass NULL for root DN)
 838   \param scope the search scope for the query
 839   \param expression the search expression to use for this query
 840   \param attrs the search attributes for the query (pass NULL if none required)
 841   \param res the return result
 842
 843   \return result code (LDB_SUCCESS on success, or a failure code)
 844
 845   \note use talloc_free() to free the ldb_result returned
 846 */
 847 int ldb_search(struct ldb_context *ldb,
 848                const struct ldb_dn *base,
 849                enum ldb_scope scope,
 850                const char *expression,
 851                const char * const *attrs, struct ldb_result **res);
 852
 853 /*
 854   like ldb_search() but takes a parse tree
 855 */
 856 int ldb_search_bytree(struct ldb_context *ldb,
 857                       const struct ldb_dn *base,
 858                       enum ldb_scope scope,
 859                       struct ldb_parse_tree *tree,
 860                       const char * const *attrs, struct ldb_result **res);
 861
 862 /**
 863   Add a record to the database.
 864
 865   This function adds a record to the database. This function will fail
 866   if a record with the specified class and key already exists in the
 867   database.
 868
 869   \param ldb the context associated with the database (from
 870   ldb_init())
 871   \param message the message containing the record to add.
 872
 873   \return result code (LDB_SUCCESS if the record was added, otherwise
 874   a failure code)
 875 */
 876 int ldb_add(struct ldb_context *ldb,
 877             const struct ldb_message *message);
 878
 879 /**
 880   Modify the specified attributes of a record
 881
 882   This function modifies a record that is in the database.
 883
 884   \param ldb the context associated with the database (from
 885   ldb_init())
 886   \param message the message containing the changes required.
 887
 888   \return result code (LDB_SUCCESS if the record was modified as
 889   requested, otherwise a failure code)
 890 */
 891 int ldb_modify(struct ldb_context *ldb,
 892                const struct ldb_message *message);
 893
 894 /**
 895   Rename a record in the database
 896
 897   This function renames a record in the database.
 898
 899   \param ldb the context associated with the database (from
 900   ldb_init())
 901   \param olddn the DN for the record to be renamed.
 902   \param newdn the new DN
 903
 904   \return result code (LDB_SUCCESS if the record was renamed as
 905   requested, otherwise a failure code)
 906 */
 907 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn);
 908
 909 /**
 910   Delete a record from the database
 911
 912   This function deletes a record from the database.
 913
 914   \param ldb the context associated with the database (from
 915   ldb_init())
 916   \param dn the DN for the record to be deleted.
 917
 918   \return result code (LDB_SUCCESS if the record was deleted,
 919   otherwise a failure code)
 920 */
 921 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn);
 922
 923 /**
 924   Obtain current database sequence number
 925 */
 926 int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num);
 927
 928 /**
 929   start a transaction
 930 */
 931 int ldb_transaction_start(struct ldb_context *ldb);
 932
 933 /**
 934   commit a transaction
 935 */
 936 int ldb_transaction_commit(struct ldb_context *ldb);
 937
 938 /**
 939   cancel a transaction
 940 */
 941 int ldb_transaction_cancel(struct ldb_context *ldb);
 942
 943
 944 /**
 945   return extended error information from the last call
 946 */
 947 const char *ldb_errstring(struct ldb_context *ldb);
 948
 949 /**
 950   return a string explaining what a ldb error constant meancs
 951 */
 952 const char *ldb_strerror(int ldb_err);
 953
 954 /**
 955   setup the default utf8 functions
 956   FIXME: these functions do not yet handle utf8
 957 */
 958 void ldb_set_utf8_default(struct ldb_context *ldb);
 959
 960 /**
 961    Casefold a string
 962
 963    \param ldb the ldb context
 964    \param mem_ctx the memory context to allocate the result string
 965    memory from.
 966    \param s the string that is to be folded
 967    \return a copy of the string, converted to upper case
 968
 969    \note The default function is not yet UTF8 aware. Provide your own
 970          set of functions through ldb_set_utf8_fns()
 971 */
 972 char *ldb_casefold(struct ldb_context *ldb, void *mem_ctx, const char *s);
 973
 974 /**
 975    Check the attribute name is valid according to rfc2251
 976    \param s tthe string to check
 977
 978    \return 1 if the name is ok
 979 */
 980 int ldb_valid_attr_name(const char *s);
 981
 982 /*
 983   ldif manipulation functions
 984 */
 985 /**
 986    Write an LDIF message
 987
 988    This function writes an LDIF message using a caller supplied  write
 989    function.
 990
 991    \param ldb the ldb context (from ldb_init())
 992    \param fprintf_fn a function pointer for the write function. This must take
 993    a private data pointer, followed by a format string, and then a variable argument
 994    list.
 995    \param private_data pointer that will be provided back to the write
 996    function. This is useful for maintaining state or context.
 997    \param ldif the message to write out
 998
 999    \return the total number of bytes written, or an error code as returned
1000    from the write function.
1001
1002    \sa ldb_ldif_write_file for a more convenient way to write to a
1003    file stream.
1004
1005    \sa ldb_ldif_read for the reader equivalent to this function.
1006 */
1007 int ldb_ldif_write(struct ldb_context *ldb,
1008                    int (*fprintf_fn)(void *, const char *, ...) PRINTF_ATTRIBUTE(2,3),
1009                    void *private_data,
1010                    const struct ldb_ldif *ldif);
1011
1012 /**
1013    Clean up an LDIF message
1014
1015    This function cleans up a LDIF message read using ldb_ldif_read()
1016    or related functions (such as ldb_ldif_read_string() and
1017    ldb_ldif_read_file().
1018
1019    \param ldb the ldb context (from ldb_init())
1020    \param msg the message to clean up and free
1021
1022 */
1023 void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *msg);
1024
1025 /**
1026    Read an LDIF message
1027
1028    This function creates an LDIF message using a caller supplied read
1029    function.
1030
1031    \param ldb the ldb context (from ldb_init())
1032    \param fgetc_fn a function pointer for the read function. This must
1033    take a private data pointer, and must return a pointer to an
1034    integer corresponding to the next byte read (or EOF if there is no
1035    more data to be read).
1036    \param private_data pointer that will be provided back to the read
1037    function. This is udeful for maintaining state or context.
1038
1039    \return the LDIF message that has been read in
1040
1041    \note You must free the LDIF message when no longer required, using
1042    ldb_ldif_read_free().
1043
1044    \sa ldb_ldif_read_file for a more convenient way to read from a
1045    file stream.
1046
1047    \sa ldb_ldif_read_string for a more convenient way to read from a
1048    string (char array).
1049
1050    \sa ldb_ldif_write for the writer equivalent to this function.
1051 */
1052 struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
1053                                int (*fgetc_fn)(void *), void *private_data);
1054
1055 /**
1056    Read an LDIF message from a file
1057
1058    This function reads the next LDIF message from the contents of a
1059    file stream. If you want to get all of the LDIF messages, you will
1060    need to repeatedly call this function, until it returns NULL.
1061
1062    \param ldb the ldb context (from ldb_init())
1063    \param f the file stream to read from (typically from fdopen())
1064
1065    \sa ldb_ldif_read_string for an equivalent function that will read
1066    from a string (char array).
1067
1068    \sa ldb_ldif_write_file for the writer equivalent to this function.
1069
1070 */
1071 struct ldb_ldif *ldb_ldif_read_file(struct ldb_context *ldb, FILE *f);
1072
1073 /**
1074    Read an LDIF message from a string
1075
1076    This function reads the next LDIF message from the contents of a char
1077    array. If you want to get all of the LDIF messages, you will need
1078    to repeatedly call this function, until it returns NULL.
1079
1080    \param ldb the ldb context (from ldb_init())
1081    \param s pointer to the char array to read from
1082
1083    \sa ldb_ldif_read_file for an equivalent function that will read
1084    from a file stream.
1085
1086    \sa ldb_ldif_write for a more general (arbitrary read function)
1087    version of this function.
1088 */
1089 struct ldb_ldif *ldb_ldif_read_string(struct ldb_context *ldb, const char **s);
1090
1091 /**
1092    Write an LDIF message to a file
1093
1094    \param ldb the ldb context (from ldb_init())
1095    \param f the file stream to write to (typically from fdopen())
1096    \param msg the message to write out
1097
1098    \return the total number of bytes written, or a negative error code
1099
1100    \sa ldb_ldif_read_file for the reader equivalent to this function.
1101 */
1102 int ldb_ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *msg);
1103
1104 /**
1105    Base64 encode a buffer
1106
1107    \param mem_ctx the memory context that the result is allocated
1108    from.
1109    \param buf pointer to the array that is to be encoded
1110    \param len the number of elements in the array to be encoded
1111
1112    \return pointer to an array containing the encoded data
1113
1114    \note The caller is responsible for freeing the result
1115 */
1116 char *ldb_base64_encode(void *mem_ctx, const char *buf, int len);
1117
1118 /**
1119    Base64 decode a buffer
1120
1121    This function decodes a base64 encoded string in place.
1122
1123    \param s the string to decode.
1124
1125    \return the length of the returned (decoded) string.
1126
1127    \note the string is null terminated, but the null terminator is not
1128    included in the length.
1129 */
1130 int ldb_base64_decode(char *s);
1131
1132 int ldb_attrib_add_handlers(struct ldb_context *ldb,
1133                             const struct ldb_attrib_handler *handlers,
1134                             unsigned num_handlers);
1135
1136 /* The following definitions come from lib/ldb/common/ldb_dn.c  */
1137
1138 int ldb_dn_is_special(const struct ldb_dn *dn);
1139 int ldb_dn_check_special(const struct ldb_dn *dn, const char *check);
1140 char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value);
1141 struct ldb_dn *ldb_dn_new(void *mem_ctx);
1142 struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn);
1143 struct ldb_dn *ldb_dn_explode_or_special(void *mem_ctx, const char *dn);
1144 char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn);
1145 char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *edn);
1146 int ldb_dn_compare_base(struct ldb_context *ldb, const struct ldb_dn *base, const struct ldb_dn *dn);
1147 int ldb_dn_compare(struct ldb_context *ldb, const struct ldb_dn *edn0, const struct ldb_dn *edn1);
1148 struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn);
1149 struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn);
1150 struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el);
1151 struct ldb_dn *ldb_dn_copy(void *mem_ctx, const struct ldb_dn *dn);
1152 struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, const struct ldb_dn *dn);
1153 struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
1154                                                                const char *val);
1155 struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
1156                                                  const char * value,
1157                                                  const struct ldb_dn *base);
1158 struct ldb_dn *ldb_dn_make_child(void *mem_ctx,
1159                                  const struct ldb_dn_component *component,
1160                                  const struct ldb_dn *base);
1161 struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2);
1162 struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, const char *child_fmt, ...) PRINTF_ATTRIBUTE(3,4);
1163 struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn);
1164
1165 /* useful functions for ldb_message structure manipulation */
1166 int ldb_dn_cmp(struct ldb_context *ldb, const char *dn1, const char *dn2);
1167
1168 /**
1169    Compare two attributes
1170
1171    This function compares to attribute names. Note that this is a
1172    case-insensitive comparison.
1173
1174    \param attr1 the first attribute name to compare
1175    \param attr2 the second attribute name to compare
1176
1177    \return 0 if the attribute names are the same, or only differ in
1178    case; non-zero if there are any differences
1179 */
1180 int ldb_attr_cmp(const char *attr1, const char *attr2);
1181 char *ldb_attr_casefold(void *mem_ctx, const char *s);
1182 int ldb_attr_dn(const char *attr);
1183
1184 /**
1185    Create an empty message
1186
1187    \param mem_ctx the memory context to create in. You can pass NULL
1188    to get the top level context, however the ldb context (from
1189    ldb_init()) may be a better choice
1190 */
1191 struct ldb_message *ldb_msg_new(void *mem_ctx);
1192
1193 /**
1194    Find an element within an message
1195 */
1196 struct ldb_message_element *ldb_msg_find_element(const struct ldb_message *msg,
1197                                                  const char *attr_name);
1198
1199 /**
1200    Compare two ldb_val values
1201
1202    \param v1 first ldb_val structure to be tested
1203    \param v2 second ldb_val structure to be tested
1204
1205    \return 1 for a match, 0 if there is any difference
1206 */
1207 int ldb_val_equal_exact(const struct ldb_val *v1, const struct ldb_val *v2);
1208
1209 /**
1210    find a value within an ldb_message_element
1211
1212    \param el the element to search
1213    \param val the value to search for
1214
1215    \note This search is case sensitive
1216 */
1217 struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
1218                                  struct ldb_val *val);
1219
1220 /**
1221    add a new empty element to a ldb_message
1222 */
1223 int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags);
1224
1225 /**
1226    add a element to a ldb_message
1227 */
1228 int ldb_msg_add(struct ldb_message *msg,
1229                 const struct ldb_message_element *el,
1230                 int flags);
1231 int ldb_msg_add_value(struct ldb_message *msg,
1232                       const char *attr_name,
1233                       const struct ldb_val *val);
1234 int ldb_msg_add_steal_value(struct ldb_message *msg,
1235                       const char *attr_name,
1236                       struct ldb_val *val);
1237 int ldb_msg_add_steal_string(struct ldb_message *msg,
1238                              const char *attr_name, char *str);
1239 int ldb_msg_add_string(struct ldb_message *msg,
1240                        const char *attr_name, const char *str);
1241 int ldb_msg_add_fmt(struct ldb_message *msg,
1242                     const char *attr_name, const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
1243
1244 /**
1245    compare two message elements - return 0 on match
1246 */
1247 int ldb_msg_element_compare(struct ldb_message_element *el1,
1248                             struct ldb_message_element *el2);
1249
1250 /**
1251    Find elements in a message.
1252
1253    This function finds elements and converts to a specific type, with
1254    a give default value if not found. Assumes that elements are
1255    single valued.
1256 */
1257 const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, const char *attr_name);
1258 int ldb_msg_find_attr_as_int(const struct ldb_message *msg,
1259                              const char *attr_name,
1260                              int default_value);
1261 unsigned int ldb_msg_find_attr_as_uint(const struct ldb_message *msg,
1262                                        const char *attr_name,
1263                                        unsigned int default_value);
1264 int64_t ldb_msg_find_attr_as_int64(const struct ldb_message *msg,
1265                                    const char *attr_name,
1266                                    int64_t default_value);
1267 uint64_t ldb_msg_find_attr_as_uint64(const struct ldb_message *msg,
1268                                      const char *attr_name,
1269                                      uint64_t default_value);
1270 double ldb_msg_find_attr_as_double(const struct ldb_message *msg,
1271                                    const char *attr_name,
1272                                    double default_value);
1273 int ldb_msg_find_attr_as_bool(const struct ldb_message *msg,
1274                               const char *attr_name,
1275                               int default_value);
1276 const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg,
1277                                         const char *attr_name,
1278                                         const char *default_value);
1279
1280 struct ldb_dn *ldb_msg_find_attr_as_dn(void *mem_ctx,
1281                                        const struct ldb_message *msg,
1282                                         const char *attr_name);
1283
1284 void ldb_msg_sort_elements(struct ldb_message *msg);
1285
1286 struct ldb_message *ldb_msg_copy_shallow(void *mem_ctx,
1287                                          const struct ldb_message *msg);
1288 struct ldb_message *ldb_msg_copy(void *mem_ctx,
1289                                  const struct ldb_message *msg);
1290
1291 struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
1292                                          const struct ldb_message *msg);
1293
1294
1295 struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
1296                                  struct ldb_message *msg1,
1297                                  struct ldb_message *msg2);
1298
1299 int ldb_msg_check_string_attribute(const struct ldb_message *msg,
1300                                    const char *name,
1301                                    const char *value);
1302
1303 /**
1304    Integrity check an ldb_message
1305
1306    This function performs basic sanity / integrity checks on an
1307    ldb_message.
1308
1309    \param msg the message to check
1310
1311    \return LDB_SUCCESS if the message is OK, or a non-zero error code
1312    (one of LDB_ERR_INVALID_DN_SYNTAX, LDB_ERR_ENTRY_ALREADY_EXISTS or
1313    LDB_ERR_INVALID_ATTRIBUTE_SYNTAX) if there is a problem with a
1314    message.
1315 */
1316 int ldb_msg_sanity_check(struct ldb_context *ldb,
1317                          const struct ldb_message *msg);
1318
1319 /**
1320    Duplicate an ldb_val structure
1321
1322    This function copies an ldb value structure.
1323
1324    \param mem_ctx the memory context that the duplicated value will be
1325    allocated from
1326    \param v the ldb_val to be duplicated.
1327
1328    \return the duplicated ldb_val structure.
1329 */
1330 struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v);
1331
1332 /**
1333   this allows the user to set a debug function for error reporting
1334 */
1335 int ldb_set_debug(struct ldb_context *ldb,
1336                   void (*debug)(void *context, enum ldb_debug_level level,
1337                                 const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0),
1338                   void *context);
1339
1340 /**
1341   this allows the user to set custom utf8 function for error reporting
1342 */
1343 void ldb_set_utf8_fns(struct ldb_context *ldb,
1344                         void *context,
1345                         char *(*casefold)(void *, void *, const char *));
1346
1347 /**
1348    this sets up debug to print messages on stderr
1349 */
1350 int ldb_set_debug_stderr(struct ldb_context *ldb);
1351
1352 /* control backend specific opaque values */
1353 int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value);
1354 void *ldb_get_opaque(struct ldb_context *ldb, const char *name);
1355
1356 const struct ldb_attrib_handler *ldb_attrib_handler(struct ldb_context *ldb,
1357                                                     const char *attrib);
1358
1359
1360 const char **ldb_attr_list_copy(void *mem_ctx, const char * const *attrs);
1361 const char **ldb_attr_list_copy_add(void *mem_ctx, const char * const *attrs, const char *new_attr);
1362 int ldb_attr_in_list(const char * const *attrs, const char *attr);
1363
1364
1365 void ldb_parse_tree_attr_replace(struct ldb_parse_tree *tree,
1366                                  const char *attr,
1367                                  const char *replace);
1368
1369 int ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *replace);
1370 int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *replace);
1371 void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr);
1372
1373 /**
1374    Convert a time structure to a string
1375
1376    This function converts a time_t structure to an LDAP formatted time
1377    string.
1378
1379    \param mem_ctx the memory context to allocate the return string in
1380    \param t the time structure to convert
1381
1382    \return the formatted string, or NULL if the time structure could
1383    not be converted
1384 */
1385 char *ldb_timestring(void *mem_ctx, time_t t);
1386
1387 /**
1388    Convert a string to a time structure
1389
1390    This function converts an LDAP formatted time string to a time_t
1391    structure.
1392
1393    \param s the string to convert
1394
1395    \return the time structure, or 0 if the string cannot be converted
1396 */
1397 time_t ldb_string_to_time(const char *s);
1398
1399 char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn);
1400 char *ldb_dn_canonical_ex_string(void *mem_ctx, const struct ldb_dn *dn);
1401
1402
1403 void ldb_qsort (void *const pbase, size_t total_elems, size_t size, void *opaque, ldb_qsort_cmp_fn_t cmp);
1404 #endif