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