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