source/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 /* the attribute handler name should be freed when released */
 361 #define LDB_ATTR_FLAG_ALLOCATED    (1<<1)
 362
 363 /**
 364    The attribute is constructed from other attributes
 365 */
 366 #define LDB_ATTR_FLAG_CONSTRUCTED  (1<<1)
 367
 368 /**
 369   LDAP attribute syntax for a DN
 370
 371   This is the well-known LDAP attribute syntax for a DN.
 372
 373   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 374 */
 375 #define LDB_SYNTAX_DN                   "1.3.6.1.4.1.1466.115.121.1.12"
 376
 377 /**
 378   LDAP attribute syntax for a Directory String
 379
 380   This is the well-known LDAP attribute syntax for a Directory String.
 381
 382   \sa <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 383 */
 384 #define LDB_SYNTAX_DIRECTORY_STRING     "1.3.6.1.4.1.1466.115.121.1.15"
 385
 386 /**
 387   LDAP attribute syntax for an integer
 388
 389   This is the well-known LDAP attribute syntax for an integer.
 390
 391   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 392 */
 393 #define LDB_SYNTAX_INTEGER              "1.3.6.1.4.1.1466.115.121.1.27"
 394
 395 /**
 396   LDAP attribute syntax for an octet string
 397
 398   This is the well-known LDAP attribute syntax for an octet string.
 399
 400   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 401 */
 402 #define LDB_SYNTAX_OCTET_STRING         "1.3.6.1.4.1.1466.115.121.1.40"
 403
 404 /**
 405   LDAP attribute syntax for UTC time.
 406
 407   This is the well-known LDAP attribute syntax for a UTC time.
 408
 409   See <a href="http://www.ietf.org/rfc/rfc2252.txt">RFC 2252</a>, Section 4.3.2
 410 */
 411 #define LDB_SYNTAX_UTC_TIME             "1.3.6.1.4.1.1466.115.121.1.53"
 412
 413 #define LDB_SYNTAX_OBJECTCLASS          "LDB_SYNTAX_OBJECTCLASS"
 414
 415 /* sorting helpers */
 416 typedef int (*ldb_qsort_cmp_fn_t) (void *v1, void *v2, void *opaque);
 417
 418 /**
 419    OID for the paged results control. This control is included in the
 420    searchRequest and searchResultDone messages as part of the controls
 421    field of the LDAPMessage, as defined in Section 4.1.12 of
 422    LDAP v3.
 423
 424    \sa <a href="http://www.ietf.org/rfc/rfc2696.txt">RFC 2696</a>.
 425 */
 426 #define LDB_CONTROL_PAGED_RESULTS_OID   "1.2.840.113556.1.4.319"
 427
 428 /**
 429    OID for specifying the returned elements of the ntSecurityDescriptor
 430
 431    \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>
 432 */
 433 #define LDB_CONTROL_SD_FLAGS_OID        "1.2.840.113556.1.4.801"
 434
 435 /**
 436    OID for specifying an advanced scope for the search (one partition)
 437
 438    \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>
 439 */
 440 #define LDB_CONTROL_DOMAIN_SCOPE_OID    "1.2.840.113556.1.4.1339"
 441
 442 /**
 443    OID for specifying an advanced scope for a search
 444
 445    \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>
 446 */
 447 #define LDB_CONTROL_SEARCH_OPTIONS_OID  "1.2.840.113556.1.4.1340"
 448
 449 /**
 450    OID for notification
 451
 452    \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>
 453 */
 454 #define LDB_CONTROL_NOTIFICATION_OID    "1.2.840.113556.1.4.528"
 455
 456 /**
 457    OID for getting deleted objects
 458
 459    \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>
 460 */
 461 #define LDB_CONTROL_SHOW_DELETED_OID    "1.2.840.113556.1.4.417"
 462
 463 /**
 464    OID for extended DN
 465
 466    \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>
 467 */
 468 #define LDB_CONTROL_EXTENDED_DN_OID     "1.2.840.113556.1.4.529"
 469
 470 /**
 471    OID for LDAP server sort result extension.
 472
 473    This control is included in the searchRequest message as part of
 474    the controls field of the LDAPMessage, as defined in Section 4.1.12
 475    of LDAP v3. The controlType is set to
 476    "1.2.840.113556.1.4.473". The criticality MAY be either TRUE or
 477    FALSE (where absent is also equivalent to FALSE) at the client's
 478    option.
 479
 480    \sa <a href="http://www.ietf.org/rfc/rfc2891.txt">RFC 2891</a>.
 481 */
 482 #define LDB_CONTROL_SERVER_SORT_OID     "1.2.840.113556.1.4.473"
 483
 484 /**
 485    OID for LDAP server sort result response extension.
 486
 487    This control is included in the searchResultDone message as part of
 488    the controls field of the LDAPMessage, as defined in Section 4.1.12 of
 489    LDAP v3.
 490
 491    \sa <a href="http://www.ietf.org/rfc/rfc2891.txt">RFC 2891</a>.
 492 */
 493 #define LDB_CONTROL_SORT_RESP_OID       "1.2.840.113556.1.4.474"
 494
 495 /**
 496    OID for LDAP Attribute Scoped Query extension.
 497
 498    This control is included in SearchRequest or SearchResponse
 499    messages as part of the controls field of the LDAPMessage.
 500 */
 501 #define LDB_CONTROL_ASQ_OID             "1.2.840.113556.1.4.1504"
 502
 503 /**
 504    OID for LDAP Directory Sync extension.
 505
 506    This control is included in SearchRequest or SearchResponse
 507    messages as part of the controls field of the LDAPMessage.
 508 */
 509 #define LDB_CONTROL_DIRSYNC_OID         "1.2.840.113556.1.4.841"
 510
 511
 512 /**
 513    OID for LDAP Virtual List View Request extension.
 514
 515    This control is included in SearchRequest messages
 516    as part of the controls field of the LDAPMessage.
 517 */
 518 #define LDB_CONTROL_VLV_REQ_OID         "2.16.840.1.113730.3.4.9"
 519
 520 /**
 521    OID for LDAP Virtual List View Response extension.
 522
 523    This control is included in SearchResponse messages
 524    as part of the controls field of the LDAPMessage.
 525 */
 526 #define LDB_CONTROL_VLV_RESP_OID        "2.16.840.1.113730.3.4.10"
 527
 528 /**
 529    OID to let modifies don't give an error when adding an existing
 530    attribute with the same value or deleting an nonexisting one attribute
 531
 532    \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>
 533 */
 534 #define LDB_CONTROL_PERMISSIVE_MODIFY_OID       "1.2.840.113556.1.4.1413"
 535
 536 /**
 537    OID for LDAP Extended Operation START_TLS.
 538
 539    This Extended operation is used to start a new TLS
 540    channel on top of a clear text channel.
 541 */
 542 #define LDB_EXTENDED_START_TLS_OID      "1.3.6.1.4.1.1466.20037"
 543
 544 /**
 545    OID for LDAP Extended Operation START_TLS.
 546
 547    This Extended operation is used to start a new TLS
 548    channel on top of a clear text channel.
 549 */
 550 #define LDB_EXTENDED_DYNAMIC_OID        "1.3.6.1.4.1.1466.101.119.1"
 551
 552 /**
 553    OID for LDAP Extended Operation START_TLS.
 554
 555    This Extended operation is used to start a new TLS
 556    channel on top of a clear text channel.
 557 */
 558 #define LDB_EXTENDED_FAST_BIND_OID      "1.2.840.113556.1.4.1781"
 559
 560 struct ldb_sd_flags_control {
 561         /*
 562          * request the owner    0x00000001
 563          * request the group    0x00000002
 564          * request the DACL     0x00000004
 565          * request the SACL     0x00000008
 566          */
 567         unsigned secinfo_flags;
 568 };
 569
 570 struct ldb_search_options_control {
 571         /*
 572          * DOMAIN_SCOPE         0x00000001
 573          * this limits the search to one partition,
 574          * and no referrals will be returned.
 575          * (Note this doesn't limit the entries by there
 576          *  objectSid belonging to a domain! Builtin and Foreign Sids
 577          *  are still returned)
 578          *
 579          * PHANTOM_ROOT         0x00000002
 580          * this search on the whole tree on a domain controller
 581          * over multiple partitions without referrals.
 582          * (This is the default behavior on the Global Catalog Port)
 583          */
 584         unsigned search_options;
 585 };
 586
 587 struct ldb_paged_control {
 588         int size;
 589         int cookie_len;
 590         char *cookie;
 591 };
 592
 593 struct ldb_extended_dn_control {
 594         int type;
 595 };
 596
 597 struct ldb_server_sort_control {
 598         char *attributeName;
 599         char *orderingRule;
 600         int reverse;
 601 };
 602
 603 struct ldb_sort_resp_control {
 604         int result;
 605         char *attr_desc;
 606 };
 607
 608 struct ldb_asq_control {
 609         int request;
 610         char *source_attribute;
 611         int src_attr_len;
 612         int result;
 613 };
 614
 615 struct ldb_dirsync_control {
 616         int flags;
 617         int max_attributes;
 618         int cookie_len;
 619         char *cookie;
 620 };
 621
 622 struct ldb_vlv_req_control {
 623         int beforeCount;
 624         int afterCount;
 625         int type;
 626         union {
 627                 struct {
 628                         int offset;
 629                         int contentCount;
 630                 } byOffset;
 631                 struct {
 632                         int value_len;
 633                         char *value;
 634                 } gtOrEq;
 635         } match;
 636         int ctxid_len;
 637         char *contextId;
 638 };
 639
 640 struct ldb_vlv_resp_control {
 641         int targetPosition;
 642         int contentCount;
 643         int vlv_result;
 644         int ctxid_len;
 645         char *contextId;
 646 };
 647
 648 struct ldb_control {
 649         const char *oid;
 650         int critical;
 651         void *data;
 652 };
 653
 654 enum ldb_request_type {
 655         LDB_SEARCH,
 656         LDB_ADD,
 657         LDB_MODIFY,
 658         LDB_DELETE,
 659         LDB_RENAME,
 660         LDB_EXTENDED,
 661         LDB_REQ_REGISTER_CONTROL,
 662         LDB_REQ_REGISTER_PARTITION,
 663         LDB_SEQUENCE_NUMBER
 664 };
 665
 666 enum ldb_reply_type {
 667         LDB_REPLY_ENTRY,
 668         LDB_REPLY_REFERRAL,
 669         LDB_REPLY_EXTENDED,
 670         LDB_REPLY_DONE
 671 };
 672
 673 enum ldb_wait_type {
 674         LDB_WAIT_ALL,
 675         LDB_WAIT_NONE
 676 };
 677
 678 enum ldb_state {
 679         LDB_ASYNC_INIT,
 680         LDB_ASYNC_PENDING,
 681         LDB_ASYNC_DONE
 682 };
 683
 684 struct ldb_result {
 685         unsigned int count;
 686         struct ldb_message **msgs;
 687         char **refs;
 688         struct ldb_control **controls;
 689 };
 690
 691 struct ldb_extended {
 692         const char *oid;
 693         const char *value;
 694         int value_len;
 695 };
 696
 697 struct ldb_reply {
 698         enum ldb_reply_type type;
 699         struct ldb_message *message;
 700         struct ldb_extended *response;
 701         char *referral;
 702         struct ldb_control **controls;
 703 };
 704
 705 struct ldb_handle {
 706         int status;
 707         enum ldb_state state;
 708         void *private_data;
 709         struct ldb_module *module;
 710 };
 711
 712 struct ldb_search {
 713         const struct ldb_dn *base;
 714         enum ldb_scope scope;
 715         const struct ldb_parse_tree *tree;
 716         const char * const *attrs;
 717         struct ldb_result *res;
 718 };
 719
 720 struct ldb_add {
 721         const struct ldb_message *message;
 722 };
 723
 724 struct  ldb_modify {
 725         const struct ldb_message *message;
 726 };
 727
 728 struct ldb_delete {
 729         const struct ldb_dn *dn;
 730 };
 731
 732 struct ldb_rename {
 733         const struct ldb_dn *olddn;
 734         const struct ldb_dn *newdn;
 735 };
 736
 737 struct ldb_register_control {
 738         const char *oid;
 739 };
 740
 741 struct ldb_register_partition {
 742         const struct ldb_dn *dn;
 743 };
 744
 745 struct ldb_sequence_number {
 746         enum ldb_sequence_type {
 747                 LDB_SEQ_HIGHEST_SEQ,
 748                 LDB_SEQ_HIGHEST_TIMESTAMP,
 749                 LDB_SEQ_NEXT
 750         } type;
 751         uint64_t seq_num;
 752         uint32_t flags;
 753 };
 754
 755 typedef int (*ldb_request_callback_t)(struct ldb_context *, void *, struct ldb_reply *);
 756 struct ldb_request {
 757
 758         enum ldb_request_type operation;
 759
 760         union {
 761                 struct ldb_search search;
 762                 struct ldb_add    add;
 763                 struct ldb_modify mod;
 764                 struct ldb_delete del;
 765                 struct ldb_rename rename;
 766                 struct ldb_register_control reg_control;
 767                 struct ldb_register_partition reg_partition;
 768                 struct ldb_sequence_number seq_num;
 769         } op;
 770
 771         struct ldb_control **controls;
 772
 773         void *context;
 774         ldb_request_callback_t callback;
 775
 776         int timeout;
 777         time_t starttime;
 778         struct ldb_handle *handle;
 779 };
 780
 781 int ldb_request(struct ldb_context *ldb, struct ldb_request *request);
 782
 783 int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type);
 784
 785 int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeout);
 786 int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *oldreq, struct ldb_request *newreq);
 787 void ldb_set_create_perms(struct ldb_context *ldb, unsigned int perms);
 788
 789 /**
 790   Initialise ldbs' global information
 791
 792   This is required before any other LDB call
 793
 794   \return 0 if initialisation succeeded, -1 otherwise
 795 */
 796 int ldb_global_init(void);
 797
 798 /**
 799   Initialise an ldb context
 800
 801   This is required before any other LDB call.
 802
 803   \param mem_ctx pointer to a talloc memory context. Pass NULL if there is
 804   no suitable context available.
 805
 806   \return pointer to ldb_context that should be free'd (using talloc_free())
 807   at the end of the program.
 808 */
 809 struct ldb_context *ldb_init(void *mem_ctx);
 810
 811 /**
 812    Connect to a database.
 813
 814    This is typically called soon after ldb_init(), and is required prior to
 815    any search or database modification operations.
 816
 817    The URL can be one of the following forms:
 818     - tdb://path
 819     - ldapi://path
 820     - ldap://host
 821     - sqlite://path
 822
 823    \param ldb the context associated with the database (from ldb_init())
 824    \param url the URL of the database to connect to, as noted above
 825    \param flags a combination of LDB_FLG_* to modify the connection behaviour
 826    \param options backend specific options - passed uninterpreted to the backend
 827
 828    \return result code (LDB_SUCCESS on success, or a failure code)
 829
 830    \note It is an error to connect to a database that does not exist in readonly mode
 831    (that is, with LDB_FLG_RDONLY). However in read-write mode, the database will be
 832    created if it does not exist.
 833 */
 834 int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[]);
 835
 836 /*
 837   return an automatic baseDN from the defaultNamingContext of the rootDSE
 838   This value have been set in an opaque pointer at connection time
 839 */
 840 const struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb);
 841
 842 /**
 843   Search the database
 844
 845   This function searches the database, and returns
 846   records that match an LDAP-like search expression
 847
 848   \param ldb the context associated with the database (from ldb_init())
 849   \param base the Base Distinguished Name for the query (pass NULL for root DN)
 850   \param scope the search scope for the query
 851   \param expression the search expression to use for this query
 852   \param attrs the search attributes for the query (pass NULL if none required)
 853   \param res the return result
 854
 855   \return result code (LDB_SUCCESS on success, or a failure code)
 856
 857   \note use talloc_free() to free the ldb_result returned
 858 */
 859 int ldb_search(struct ldb_context *ldb,
 860                const struct ldb_dn *base,
 861                enum ldb_scope scope,
 862                const char *expression,
 863                const char * const *attrs, struct ldb_result **res);
 864
 865 /*
 866   like ldb_search() but takes a parse tree
 867 */
 868 int ldb_search_bytree(struct ldb_context *ldb,
 869                       const struct ldb_dn *base,
 870                       enum ldb_scope scope,
 871                       struct ldb_parse_tree *tree,
 872                       const char * const *attrs, struct ldb_result **res);
 873
 874 /**
 875   Add a record to the database.
 876
 877   This function adds a record to the database. This function will fail
 878   if a record with the specified class and key already exists in the
 879   database.
 880
 881   \param ldb the context associated with the database (from
 882   ldb_init())
 883   \param message the message containing the record to add.
 884
 885   \return result code (LDB_SUCCESS if the record was added, otherwise
 886   a failure code)
 887 */
 888 int ldb_add(struct ldb_context *ldb,
 889             const struct ldb_message *message);
 890
 891 /**
 892   Modify the specified attributes of a record
 893
 894   This function modifies a record that is in the database.
 895
 896   \param ldb the context associated with the database (from
 897   ldb_init())
 898   \param message the message containing the changes required.
 899
 900   \return result code (LDB_SUCCESS if the record was modified as
 901   requested, otherwise a failure code)
 902 */
 903 int ldb_modify(struct ldb_context *ldb,
 904                const struct ldb_message *message);
 905
 906 /**
 907   Rename a record in the database
 908
 909   This function renames a record in the database.
 910
 911   \param ldb the context associated with the database (from
 912   ldb_init())
 913   \param olddn the DN for the record to be renamed.
 914   \param newdn the new DN
 915
 916   \return result code (LDB_SUCCESS if the record was renamed as
 917   requested, otherwise a failure code)
 918 */
 919 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn);
 920
 921 /**
 922   Delete a record from the database
 923
 924   This function deletes a record from the database.
 925
 926   \param ldb the context associated with the database (from
 927   ldb_init())
 928   \param dn the DN for the record to be deleted.
 929
 930   \return result code (LDB_SUCCESS if the record was deleted,
 931   otherwise a failure code)
 932 */
 933 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn);
 934
 935 /**
 936   start a transaction
 937 */
 938 int ldb_transaction_start(struct ldb_context *ldb);
 939
 940 /**
 941   commit a transaction
 942 */
 943 int ldb_transaction_commit(struct ldb_context *ldb);
 944
 945 /**
 946   cancel a transaction
 947 */
 948 int ldb_transaction_cancel(struct ldb_context *ldb);
 949
 950
 951 /**
 952   return extended error information from the last call
 953 */
 954 const char *ldb_errstring(struct ldb_context *ldb);
 955
 956 /**
 957   return a string explaining what a ldb error constant meancs
 958 */
 959 const char *ldb_strerror(int ldb_err);
 960
 961 /**
 962   setup the default utf8 functions
 963   FIXME: these functions do not yet handle utf8
 964 */
 965 void ldb_set_utf8_default(struct ldb_context *ldb);
 966
 967 /**
 968    Casefold a string
 969
 970    \param ldb the ldb context
 971    \param mem_ctx the memory context to allocate the result string
 972    memory from.
 973    \param s the string that is to be folded
 974    \return a copy of the string, converted to upper case
 975
 976    \note The default function is not yet UTF8 aware. Provide your own
 977          set of functions through ldb_set_utf8_fns()
 978 */
 979 char *ldb_casefold(struct ldb_context *ldb, void *mem_ctx, const char *s);
 980
 981 /**
 982    Check the attribute name is valid according to rfc2251
 983    \param s tthe string to check
 984
 985    \return 1 if the name is ok
 986 */
 987 int ldb_valid_attr_name(const char *s);
 988
 989 /*
 990   ldif manipulation functions
 991 */
 992 /**
 993    Write an LDIF message
 994
 995    This function writes an LDIF message using a caller supplied  write
 996    function.
 997
 998    \param ldb the ldb context (from ldb_init())
 999    \param fprintf_fn a function pointer for the write function. This must take
1000    a private data pointer, followed by a format string, and then a variable argument
1001    list.
1002    \param private_data pointer that will be provided back to the write
1003    function. This is useful for maintaining state or context.
1004    \param ldif the message to write out
1005
1006    \return the total number of bytes written, or an error code as returned
1007    from the write function.
1008
1009    \sa ldb_ldif_write_file for a more convenient way to write to a
1010    file stream.
1011
1012    \sa ldb_ldif_read for the reader equivalent to this function.
1013 */
1014 int ldb_ldif_write(struct ldb_context *ldb,
1015                    int (*fprintf_fn)(void *, const char *, ...) PRINTF_ATTRIBUTE(2,3),
1016                    void *private_data,
1017                    const struct ldb_ldif *ldif);
1018
1019 /**
1020    Clean up an LDIF message
1021
1022    This function cleans up a LDIF message read using ldb_ldif_read()
1023    or related functions (such as ldb_ldif_read_string() and
1024    ldb_ldif_read_file().
1025
1026    \param ldb the ldb context (from ldb_init())
1027    \param msg the message to clean up and free
1028
1029 */
1030 void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *msg);
1031
1032 /**
1033    Read an LDIF message
1034
1035    This function creates an LDIF message using a caller supplied read
1036    function.
1037
1038    \param ldb the ldb context (from ldb_init())
1039    \param fgetc_fn a function pointer for the read function. This must
1040    take a private data pointer, and must return a pointer to an
1041    integer corresponding to the next byte read (or EOF if there is no
1042    more data to be read).
1043    \param private_data pointer that will be provided back to the read
1044    function. This is udeful for maintaining state or context.
1045
1046    \return the LDIF message that has been read in
1047
1048    \note You must free the LDIF message when no longer required, using
1049    ldb_ldif_read_free().
1050
1051    \sa ldb_ldif_read_file for a more convenient way to read from a
1052    file stream.
1053
1054    \sa ldb_ldif_read_string for a more convenient way to read from a
1055    string (char array).
1056
1057    \sa ldb_ldif_write for the writer equivalent to this function.
1058 */
1059 struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
1060                                int (*fgetc_fn)(void *), void *private_data);
1061
1062 /**
1063    Read an LDIF message from a file
1064
1065    This function reads the next LDIF message from the contents of a
1066    file stream. If you want to get all of the LDIF messages, you will
1067    need to repeatedly call this function, until it returns NULL.
1068
1069    \param ldb the ldb context (from ldb_init())
1070    \param f the file stream to read from (typically from fdopen())
1071
1072    \sa ldb_ldif_read_string for an equivalent function that will read
1073    from a string (char array).
1074
1075    \sa ldb_ldif_write_file for the writer equivalent to this function.
1076
1077 */
1078 struct ldb_ldif *ldb_ldif_read_file(struct ldb_context *ldb, FILE *f);
1079
1080 /**
1081    Read an LDIF message from a string
1082
1083    This function reads the next LDIF message from the contents of a char
1084    array. If you want to get all of the LDIF messages, you will need
1085    to repeatedly call this function, until it returns NULL.
1086
1087    \param ldb the ldb context (from ldb_init())
1088    \param s pointer to the char array to read from
1089
1090    \sa ldb_ldif_read_file for an equivalent function that will read
1091    from a file stream.
1092
1093    \sa ldb_ldif_write for a more general (arbitrary read function)
1094    version of this function.
1095 */
1096 struct ldb_ldif *ldb_ldif_read_string(struct ldb_context *ldb, const char **s);
1097
1098 /**
1099    Write an LDIF message to a file
1100
1101    \param ldb the ldb context (from ldb_init())
1102    \param f the file stream to write to (typically from fdopen())
1103    \param msg the message to write out
1104
1105    \return the total number of bytes written, or a negative error code
1106
1107    \sa ldb_ldif_read_file for the reader equivalent to this function.
1108 */
1109 int ldb_ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *msg);
1110
1111 /**
1112    Base64 encode a buffer
1113
1114    \param mem_ctx the memory context that the result is allocated
1115    from.
1116    \param buf pointer to the array that is to be encoded
1117    \param len the number of elements in the array to be encoded
1118
1119    \return pointer to an array containing the encoded data
1120
1121    \note The caller is responsible for freeing the result
1122 */
1123 char *ldb_base64_encode(void *mem_ctx, const char *buf, int len);
1124
1125 /**
1126    Base64 decode a buffer
1127
1128    This function decodes a base64 encoded string in place.
1129
1130    \param s the string to decode.
1131
1132    \return the length of the returned (decoded) string.
1133
1134    \note the string is null terminated, but the null terminator is not
1135    included in the length.
1136 */
1137 int ldb_base64_decode(char *s);
1138
1139 int ldb_attrib_add_handlers(struct ldb_context *ldb,
1140                             const struct ldb_attrib_handler *handlers,
1141                             unsigned num_handlers);
1142
1143 /* The following definitions come from lib/ldb/common/ldb_dn.c  */
1144
1145 int ldb_dn_is_special(const struct ldb_dn *dn);
1146 int ldb_dn_check_special(const struct ldb_dn *dn, const char *check);
1147 char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value);
1148 struct ldb_dn *ldb_dn_new(void *mem_ctx);
1149 struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn);
1150 struct ldb_dn *ldb_dn_explode_or_special(void *mem_ctx, const char *dn);
1151 char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn);
1152 char *ldb_dn_linearize_casefold(struct ldb_context *ldb, void *mem_ctx, const struct ldb_dn *edn);
1153 int ldb_dn_compare_base(struct ldb_context *ldb, const struct ldb_dn *base, const struct ldb_dn *dn);
1154 int ldb_dn_compare(struct ldb_context *ldb, const struct ldb_dn *edn0, const struct ldb_dn *edn1);
1155 struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, void *mem_ctx, const struct ldb_dn *edn);
1156 struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, void *mem_ctx, const char *dn);
1157 struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el);
1158 struct ldb_dn *ldb_dn_copy(void *mem_ctx, const struct ldb_dn *dn);
1159 struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, const struct ldb_dn *dn);
1160 struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
1161                                                                const char *val);
1162 struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
1163                                                  const char * value,
1164                                                  const struct ldb_dn *base);
1165 struct ldb_dn *ldb_dn_make_child(void *mem_ctx,
1166                                  const struct ldb_dn_component *component,
1167                                  const struct ldb_dn *base);
1168 struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2);
1169 struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, const char *child_fmt, ...) PRINTF_ATTRIBUTE(3,4);
1170 struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn);
1171
1172 /* useful functions for ldb_message structure manipulation */
1173 int ldb_dn_cmp(struct ldb_context *ldb, const char *dn1, const char *dn2);
1174
1175 /**
1176    Compare two attributes
1177
1178    This function compares to attribute names. Note that this is a
1179    case-insensitive comparison.
1180
1181    \param attr1 the first attribute name to compare
1182    \param attr2 the second attribute name to compare
1183
1184    \return 0 if the attribute names are the same, or only differ in
1185    case; non-zero if there are any differences
1186 */
1187 int ldb_attr_cmp(const char *attr1, const char *attr2);
1188 char *ldb_attr_casefold(void *mem_ctx, const char *s);
1189 int ldb_attr_dn(const char *attr);
1190
1191 /**
1192    Create an empty message
1193
1194    \param mem_ctx the memory context to create in. You can pass NULL
1195    to get the top level context, however the ldb context (from
1196    ldb_init()) may be a better choice
1197 */
1198 struct ldb_message *ldb_msg_new(void *mem_ctx);
1199
1200 /**
1201    Find an element within an message
1202 */
1203 struct ldb_message_element *ldb_msg_find_element(const struct ldb_message *msg,
1204                                                  const char *attr_name);
1205
1206 /**
1207    Compare two ldb_val values
1208
1209    \param v1 first ldb_val structure to be tested
1210    \param v2 second ldb_val structure to be tested
1211
1212    \return 1 for a match, 0 if there is any difference
1213 */
1214 int ldb_val_equal_exact(const struct ldb_val *v1, const struct ldb_val *v2);
1215
1216 /**
1217    find a value within an ldb_message_element
1218
1219    \param el the element to search
1220    \param val the value to search for
1221
1222    \note This search is case sensitive
1223 */
1224 struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
1225                                  struct ldb_val *val);
1226
1227 /**
1228    add a new empty element to a ldb_message
1229 */
1230 int ldb_msg_add_empty(struct ldb_message *msg,
1231                       const char *attr_name,
1232                       int flags,
1233                       struct ldb_message_element **return_el);
1234
1235 /**
1236    add a element to a ldb_message
1237 */
1238 int ldb_msg_add(struct ldb_message *msg,
1239                 const struct ldb_message_element *el,
1240                 int flags);
1241 int ldb_msg_add_value(struct ldb_message *msg,
1242                       const char *attr_name,
1243                       const struct ldb_val *val,
1244                       struct ldb_message_element **return_el);
1245 int ldb_msg_add_steal_value(struct ldb_message *msg,
1246                       const char *attr_name,
1247                       struct ldb_val *val);
1248 int ldb_msg_add_steal_string(struct ldb_message *msg,
1249                              const char *attr_name, char *str);
1250 int ldb_msg_add_string(struct ldb_message *msg,
1251                        const char *attr_name, const char *str);
1252 int ldb_msg_add_fmt(struct ldb_message *msg,
1253                     const char *attr_name, const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
1254
1255 /**
1256    compare two message elements - return 0 on match
1257 */
1258 int ldb_msg_element_compare(struct ldb_message_element *el1,
1259                             struct ldb_message_element *el2);
1260
1261 /**
1262    Find elements in a message.
1263
1264    This function finds elements and converts to a specific type, with
1265    a give default value if not found. Assumes that elements are
1266    single valued.
1267 */
1268 const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, const char *attr_name);
1269 int ldb_msg_find_attr_as_int(const struct ldb_message *msg,
1270                              const char *attr_name,
1271                              int default_value);
1272 unsigned int ldb_msg_find_attr_as_uint(const struct ldb_message *msg,
1273                                        const char *attr_name,
1274                                        unsigned int default_value);
1275 int64_t ldb_msg_find_attr_as_int64(const struct ldb_message *msg,
1276                                    const char *attr_name,
1277                                    int64_t default_value);
1278 uint64_t ldb_msg_find_attr_as_uint64(const struct ldb_message *msg,
1279                                      const char *attr_name,
1280                                      uint64_t default_value);
1281 double ldb_msg_find_attr_as_double(const struct ldb_message *msg,
1282                                    const char *attr_name,
1283                                    double default_value);
1284 int ldb_msg_find_attr_as_bool(const struct ldb_message *msg,
1285                               const char *attr_name,
1286                               int default_value);
1287 const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg,
1288                                         const char *attr_name,
1289                                         const char *default_value);
1290
1291 struct ldb_dn *ldb_msg_find_attr_as_dn(void *mem_ctx,
1292                                        const struct ldb_message *msg,
1293                                         const char *attr_name);
1294
1295 void ldb_msg_sort_elements(struct ldb_message *msg);
1296
1297 struct ldb_message *ldb_msg_copy_shallow(void *mem_ctx,
1298                                          const struct ldb_message *msg);
1299 struct ldb_message *ldb_msg_copy(void *mem_ctx,
1300                                  const struct ldb_message *msg);
1301
1302 struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
1303                                          const struct ldb_message *msg);
1304
1305
1306 struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
1307                                  struct ldb_message *msg1,
1308                                  struct ldb_message *msg2);
1309
1310 int ldb_msg_check_string_attribute(const struct ldb_message *msg,
1311                                    const char *name,
1312                                    const char *value);
1313
1314 /**
1315    Integrity check an ldb_message
1316
1317    This function performs basic sanity / integrity checks on an
1318    ldb_message.
1319
1320    \param msg the message to check
1321
1322    \return LDB_SUCCESS if the message is OK, or a non-zero error code
1323    (one of LDB_ERR_INVALID_DN_SYNTAX, LDB_ERR_ENTRY_ALREADY_EXISTS or
1324    LDB_ERR_INVALID_ATTRIBUTE_SYNTAX) if there is a problem with a
1325    message.
1326 */
1327 int ldb_msg_sanity_check(struct ldb_context *ldb,
1328                          const struct ldb_message *msg);
1329
1330 /**
1331    Duplicate an ldb_val structure
1332
1333    This function copies an ldb value structure.
1334
1335    \param mem_ctx the memory context that the duplicated value will be
1336    allocated from
1337    \param v the ldb_val to be duplicated.
1338
1339    \return the duplicated ldb_val structure.
1340 */
1341 struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v);
1342
1343 /**
1344   this allows the user to set a debug function for error reporting
1345 */
1346 int ldb_set_debug(struct ldb_context *ldb,
1347                   void (*debug)(void *context, enum ldb_debug_level level,
1348                                 const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0),
1349                   void *context);
1350
1351 /**
1352   this allows the user to set custom utf8 function for error reporting
1353 */
1354 void ldb_set_utf8_fns(struct ldb_context *ldb,
1355                         void *context,
1356                         char *(*casefold)(void *, void *, const char *));
1357
1358 /**
1359    this sets up debug to print messages on stderr
1360 */
1361 int ldb_set_debug_stderr(struct ldb_context *ldb);
1362
1363 /* control backend specific opaque values */
1364 int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value);
1365 void *ldb_get_opaque(struct ldb_context *ldb, const char *name);
1366
1367 const struct ldb_attrib_handler *ldb_attrib_handler(struct ldb_context *ldb,
1368                                                     const char *attrib);
1369
1370
1371 const char **ldb_attr_list_copy(void *mem_ctx, const char * const *attrs);
1372 const char **ldb_attr_list_copy_add(void *mem_ctx, const char * const *attrs, const char *new_attr);
1373 int ldb_attr_in_list(const char * const *attrs, const char *attr);
1374
1375
1376 void ldb_parse_tree_attr_replace(struct ldb_parse_tree *tree,
1377                                  const char *attr,
1378                                  const char *replace);
1379
1380 int ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *replace);
1381 int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *replace);
1382 void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr);
1383
1384 /**
1385    Convert a time structure to a string
1386
1387    This function converts a time_t structure to an LDAP formatted time
1388    string.
1389
1390    \param mem_ctx the memory context to allocate the return string in
1391    \param t the time structure to convert
1392
1393    \return the formatted string, or NULL if the time structure could
1394    not be converted
1395 */
1396 char *ldb_timestring(void *mem_ctx, time_t t);
1397
1398 /**
1399    Convert a string to a time structure
1400
1401    This function converts an LDAP formatted time string to a time_t
1402    structure.
1403
1404    \param s the string to convert
1405
1406    \return the time structure, or 0 if the string cannot be converted
1407 */
1408 time_t ldb_string_to_time(const char *s);
1409
1410 char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn);
1411 char *ldb_dn_canonical_ex_string(void *mem_ctx, const struct ldb_dn *dn);
1412
1413
1414 void ldb_qsort (void *const pbase, size_t total_elems, size_t size, void *opaque, ldb_qsort_cmp_fn_t cmp);
1415 #endif