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