1 /* $OpenLDAP$ */ 2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 3 * 4 * Copyright 1998-2021 The OpenLDAP Foundation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted only as authorized by the OpenLDAP 9 * Public License. 10 * 11 * A copy of this license is available in file LICENSE in the 12 * top-level directory of the distribution or, alternatively, at 13 * <http://www.OpenLDAP.org/license.html>. 14 */ 15 /* Portions Copyright (c) 1990 Regents of the University of Michigan. 16 * All rights reserved. 17 * 18 * Redistribution and use in source and binary forms are permitted 19 * provided that this notice is preserved and that due credit is given 20 * to the University of Michigan at Ann Arbor. The name of the University 21 * may not be used to endorse or promote products derived from this 22 * software without specific prior written permission. This software 23 * is provided ``as is'' without express or implied warranty. 24 */ 25 26 #ifndef _LBER_H 27 #define _LBER_H 28 29 #include <lber_types.h> 30 #include <string.h> 31 32 LDAP_BEGIN_DECL 33 34 /* 35 * ber_tag_t represents the identifier octets at the beginning of BER 36 * elements. OpenLDAP treats them as mere big-endian unsigned integers. 37 * 38 * Actually the BER identifier octets look like this: 39 * 40 * Bits of 1st octet: 41 * ______ 42 * 8 7 | CLASS 43 * 0 0 = UNIVERSAL 44 * 0 1 = APPLICATION 45 * 1 0 = CONTEXT-SPECIFIC 46 * 1 1 = PRIVATE 47 * _____ 48 * | 6 | DATA-TYPE 49 * 0 = PRIMITIVE 50 * 1 = CONSTRUCTED 51 * ___________ 52 * | 5 ... 1 | TAG-NUMBER 53 * 54 * For ASN.1 tag numbers >= 0x1F, TAG-NUMBER above is 0x1F and the next 55 * BER octets contain the actual ASN.1 tag number: Big-endian, base 56 * 128, 8.bit = 1 in all but the last octet, minimum number of octets. 57 */ 58 59 /* BER classes and mask (in 1st identifier octet) */ 60 #define LBER_CLASS_UNIVERSAL ((ber_tag_t) 0x00U) 61 #define LBER_CLASS_APPLICATION ((ber_tag_t) 0x40U) 62 #define LBER_CLASS_CONTEXT ((ber_tag_t) 0x80U) 63 #define LBER_CLASS_PRIVATE ((ber_tag_t) 0xc0U) 64 #define LBER_CLASS_MASK ((ber_tag_t) 0xc0U) 65 66 /* BER encoding type and mask (in 1st identifier octet) */ 67 #define LBER_PRIMITIVE ((ber_tag_t) 0x00U) 68 #define LBER_CONSTRUCTED ((ber_tag_t) 0x20U) 69 #define LBER_ENCODING_MASK ((ber_tag_t) 0x20U) 70 71 #define LBER_BIG_TAG_MASK ((ber_tag_t) 0x1fU) 72 #define LBER_MORE_TAG_MASK ((ber_tag_t) 0x80U) 73 74 /* 75 * LBER_ERROR and LBER_DEFAULT are values that can never appear 76 * as valid BER tags, so it is safe to use them to report errors. 77 * Valid tags have (tag & (ber_tag_t) 0xFF) != 0xFF. 78 */ 79 #define LBER_ERROR ((ber_tag_t) -1) 80 #define LBER_DEFAULT ((ber_tag_t) -1) 81 82 /* general BER types we know about */ 83 #define LBER_BOOLEAN ((ber_tag_t) 0x01UL) 84 #define LBER_INTEGER ((ber_tag_t) 0x02UL) 85 #define LBER_BITSTRING ((ber_tag_t) 0x03UL) 86 #define LBER_OCTETSTRING ((ber_tag_t) 0x04UL) 87 #define LBER_NULL ((ber_tag_t) 0x05UL) 88 #define LBER_ENUMERATED ((ber_tag_t) 0x0aUL) 89 #define LBER_SEQUENCE ((ber_tag_t) 0x30UL) /* constructed */ 90 #define LBER_SET ((ber_tag_t) 0x31UL) /* constructed */ 91 92 /* LBER BerElement options */ 93 #define LBER_USE_DER 0x01 94 95 /* get/set options for BerElement */ 96 #define LBER_OPT_BER_OPTIONS 0x01 97 #define LBER_OPT_BER_DEBUG 0x02 98 #define LBER_OPT_BER_REMAINING_BYTES 0x03 99 #define LBER_OPT_BER_TOTAL_BYTES 0x04 100 #define LBER_OPT_BER_BYTES_TO_WRITE 0x05 101 #define LBER_OPT_BER_MEMCTX 0x06 102 103 #define LBER_OPT_DEBUG_LEVEL LBER_OPT_BER_DEBUG 104 #define LBER_OPT_REMAINING_BYTES LBER_OPT_BER_REMAINING_BYTES 105 #define LBER_OPT_TOTAL_BYTES LBER_OPT_BER_TOTAL_BYTES 106 #define LBER_OPT_BYTES_TO_WRITE LBER_OPT_BER_BYTES_TO_WRITE 107 108 #define LBER_OPT_LOG_PRINT_FN 0x8001 109 #define LBER_OPT_MEMORY_FNS 0x8002 110 #define LBER_OPT_ERROR_FN 0x8003 111 #define LBER_OPT_LOG_PRINT_FILE 0x8004 112 113 /* get/set Memory Debug options */ 114 #define LBER_OPT_MEMORY_INUSE 0x8005 /* for memory debugging */ 115 #define LBER_OPT_LOG_PROC 0x8006 /* for external logging function */ 116 117 typedef int* (*BER_ERRNO_FN) LDAP_P(( void )); 118 119 typedef void (*BER_LOG_PRINT_FN) LDAP_P(( LDAP_CONST char *buf )); 120 121 typedef void* (BER_MEMALLOC_FN) LDAP_P(( ber_len_t size, void *ctx )); 122 typedef void* (BER_MEMCALLOC_FN) LDAP_P(( ber_len_t n, ber_len_t size, void *ctx )); 123 typedef void* (BER_MEMREALLOC_FN) LDAP_P(( void *p, ber_len_t size, void *ctx )); 124 typedef void (BER_MEMFREE_FN) LDAP_P(( void *p, void *ctx )); 125 126 typedef struct lber_memory_fns { 127 BER_MEMALLOC_FN *bmf_malloc; 128 BER_MEMCALLOC_FN *bmf_calloc; 129 BER_MEMREALLOC_FN *bmf_realloc; 130 BER_MEMFREE_FN *bmf_free; 131 } BerMemoryFunctions; 132 133 /* LBER Sockbuf_IO options */ 134 #define LBER_SB_OPT_GET_FD 1 135 #define LBER_SB_OPT_SET_FD 2 136 #define LBER_SB_OPT_HAS_IO 3 137 #define LBER_SB_OPT_SET_NONBLOCK 4 138 #define LBER_SB_OPT_GET_SSL 7 139 #define LBER_SB_OPT_DATA_READY 8 140 #define LBER_SB_OPT_SET_READAHEAD 9 141 #define LBER_SB_OPT_DRAIN 10 142 #define LBER_SB_OPT_NEEDS_READ 11 143 #define LBER_SB_OPT_NEEDS_WRITE 12 144 #define LBER_SB_OPT_GET_MAX_INCOMING 13 145 #define LBER_SB_OPT_SET_MAX_INCOMING 14 146 147 /* Only meaningful ifdef LDAP_PF_LOCAL_SENDMSG */ 148 #define LBER_SB_OPT_UNGET_BUF 15 149 150 /* Largest option used by the library */ 151 #define LBER_SB_OPT_OPT_MAX 15 152 153 /* LBER IO operations stacking levels */ 154 #define LBER_SBIOD_LEVEL_PROVIDER 10 155 #define LBER_SBIOD_LEVEL_TRANSPORT 20 156 #define LBER_SBIOD_LEVEL_APPLICATION 30 157 158 /* get/set options for Sockbuf */ 159 #define LBER_OPT_SOCKBUF_DESC 0x1000 160 #define LBER_OPT_SOCKBUF_OPTIONS 0x1001 161 #define LBER_OPT_SOCKBUF_DEBUG 0x1002 162 163 /* on/off values */ 164 LBER_V( char ) ber_pvt_opt_on; 165 #define LBER_OPT_ON ((void *) &ber_pvt_opt_on) 166 #define LBER_OPT_OFF ((void *) 0) 167 168 #define LBER_OPT_SUCCESS (0) 169 #define LBER_OPT_ERROR (-1) 170 171 typedef struct berelement BerElement; 172 typedef struct sockbuf Sockbuf; 173 174 typedef struct sockbuf_io Sockbuf_IO; 175 176 /* Structure for LBER IO operation descriptor */ 177 typedef struct sockbuf_io_desc { 178 int sbiod_level; 179 Sockbuf *sbiod_sb; 180 Sockbuf_IO *sbiod_io; 181 void *sbiod_pvt; 182 struct sockbuf_io_desc *sbiod_next; 183 } Sockbuf_IO_Desc; 184 185 /* Structure for LBER IO operation functions */ 186 struct sockbuf_io { 187 int (*sbi_setup)( Sockbuf_IO_Desc *sbiod, void *arg ); 188 int (*sbi_remove)( Sockbuf_IO_Desc *sbiod ); 189 int (*sbi_ctrl)( Sockbuf_IO_Desc *sbiod, int opt, void *arg); 190 191 ber_slen_t (*sbi_read)( Sockbuf_IO_Desc *sbiod, void *buf, 192 ber_len_t len ); 193 ber_slen_t (*sbi_write)( Sockbuf_IO_Desc *sbiod, void *buf, 194 ber_len_t len ); 195 196 int (*sbi_close)( Sockbuf_IO_Desc *sbiod ); 197 }; 198 199 /* Helper macros for LBER IO functions */ 200 #define LBER_SBIOD_READ_NEXT( sbiod, buf, len ) \ 201 ( (sbiod)->sbiod_next->sbiod_io->sbi_read( (sbiod)->sbiod_next, \ 202 buf, len ) ) 203 #define LBER_SBIOD_WRITE_NEXT( sbiod, buf, len ) \ 204 ( (sbiod)->sbiod_next->sbiod_io->sbi_write( (sbiod)->sbiod_next, \ 205 buf, len ) ) 206 #define LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg ) \ 207 ( (sbiod)->sbiod_next ? \ 208 ( (sbiod)->sbiod_next->sbiod_io->sbi_ctrl( \ 209 (sbiod)->sbiod_next, opt, arg ) ) : 0 ) 210 211 /* structure for returning a sequence of octet strings + length */ 212 typedef struct berval { 213 ber_len_t bv_len; 214 char *bv_val; 215 } BerValue; 216 217 typedef BerValue *BerVarray; /* To distinguish from a single bv */ 218 219 /* this should be moved to lber-int.h */ 220 221 /* 222 * in bprint.c: 223 */ 224 LBER_F( void ) 225 ber_error_print LDAP_P(( 226 LDAP_CONST char *data )); 227 228 LBER_F( void ) 229 ber_bprint LDAP_P(( 230 LDAP_CONST char *data, ber_len_t len )); 231 232 LBER_F( void ) 233 ber_dump LDAP_P(( 234 BerElement *ber, int inout )); 235 236 /* 237 * in decode.c: 238 */ 239 typedef int (*BERDecodeCallback) LDAP_P(( 240 BerElement *ber, 241 void *data, 242 int mode )); 243 244 LBER_F( ber_tag_t ) 245 ber_get_tag LDAP_P(( 246 BerElement *ber )); 247 248 LBER_F( ber_tag_t ) 249 ber_skip_tag LDAP_P(( 250 BerElement *ber, 251 ber_len_t *len )); 252 253 LBER_F( ber_tag_t ) 254 ber_peek_tag LDAP_P(( 255 BerElement *ber, 256 ber_len_t *len )); 257 258 LBER_F( ber_tag_t ) 259 ber_skip_raw LDAP_P(( 260 BerElement *ber, 261 struct berval *bv )); 262 263 LBER_F( ber_tag_t ) 264 ber_skip_element LDAP_P(( 265 BerElement *ber, 266 struct berval *bv )); 267 268 LBER_F( ber_tag_t ) 269 ber_peek_element LDAP_P(( 270 LDAP_CONST BerElement *ber, 271 struct berval *bv )); 272 273 LBER_F( ber_tag_t ) 274 ber_get_int LDAP_P(( 275 BerElement *ber, 276 ber_int_t *num )); 277 278 LBER_F( ber_tag_t ) 279 ber_get_enum LDAP_P(( 280 BerElement *ber, 281 ber_int_t *num )); 282 283 LBER_F( int ) 284 ber_decode_int LDAP_P(( 285 const struct berval *bv, 286 ber_int_t *num )); 287 288 LBER_F( ber_tag_t ) 289 ber_get_stringb LDAP_P(( 290 BerElement *ber, 291 char *buf, 292 ber_len_t *len )); 293 294 #define LBER_BV_ALLOC 0x01 /* allocate/copy result, otherwise in-place */ 295 #define LBER_BV_NOTERM 0x02 /* omit NUL-terminator if parsing in-place */ 296 #define LBER_BV_STRING 0x04 /* fail if berval contains embedded \0 */ 297 /* LBER_BV_STRING currently accepts a terminating \0 in the berval, because 298 * Active Directory sends that in at least the diagonsticMessage field. 299 */ 300 301 LBER_F( ber_tag_t ) 302 ber_get_stringbv LDAP_P(( 303 BerElement *ber, 304 struct berval *bv, 305 int options )); 306 307 LBER_F( ber_tag_t ) 308 ber_get_stringa LDAP_P(( 309 BerElement *ber, 310 char **buf )); 311 312 LBER_F( ber_tag_t ) 313 ber_get_stringal LDAP_P(( 314 BerElement *ber, 315 struct berval **bv )); 316 317 LBER_F( ber_tag_t ) 318 ber_get_bitstringa LDAP_P(( 319 BerElement *ber, 320 char **buf, 321 ber_len_t *len )); 322 323 LBER_F( ber_tag_t ) 324 ber_get_null LDAP_P(( 325 BerElement *ber )); 326 327 LBER_F( ber_tag_t ) 328 ber_get_boolean LDAP_P(( 329 BerElement *ber, 330 ber_int_t *boolval )); 331 332 LBER_F( ber_tag_t ) 333 ber_first_element LDAP_P(( 334 BerElement *ber, 335 ber_len_t *len, 336 char **last )); 337 338 LBER_F( ber_tag_t ) 339 ber_next_element LDAP_P(( 340 BerElement *ber, 341 ber_len_t *len, 342 LDAP_CONST char *last )); 343 344 LBER_F( ber_tag_t ) 345 ber_scanf LDAP_P(( 346 BerElement *ber, 347 LDAP_CONST char *fmt, 348 ... )); 349 350 LBER_F( int ) 351 ber_decode_oid LDAP_P(( 352 struct berval *in, 353 struct berval *out )); 354 355 /* 356 * in encode.c 357 */ 358 LBER_F( int ) 359 ber_encode_oid LDAP_P(( 360 struct berval *in, 361 struct berval *out )); 362 363 typedef int (*BEREncodeCallback) LDAP_P(( 364 BerElement *ber, 365 void *data )); 366 367 LBER_F( int ) 368 ber_put_enum LDAP_P(( 369 BerElement *ber, 370 ber_int_t num, 371 ber_tag_t tag )); 372 373 LBER_F( int ) 374 ber_put_int LDAP_P(( 375 BerElement *ber, 376 ber_int_t num, 377 ber_tag_t tag )); 378 379 LBER_F( int ) 380 ber_put_ostring LDAP_P(( 381 BerElement *ber, 382 LDAP_CONST char *str, 383 ber_len_t len, 384 ber_tag_t tag )); 385 386 LBER_F( int ) 387 ber_put_berval LDAP_P(( 388 BerElement *ber, 389 struct berval *bv, 390 ber_tag_t tag )); 391 392 LBER_F( int ) 393 ber_put_string LDAP_P(( 394 BerElement *ber, 395 LDAP_CONST char *str, 396 ber_tag_t tag )); 397 398 LBER_F( int ) 399 ber_put_bitstring LDAP_P(( 400 BerElement *ber, 401 LDAP_CONST char *str, 402 ber_len_t bitlen, 403 ber_tag_t tag )); 404 405 LBER_F( int ) 406 ber_put_null LDAP_P(( 407 BerElement *ber, 408 ber_tag_t tag )); 409 410 LBER_F( int ) 411 ber_put_boolean LDAP_P(( 412 BerElement *ber, 413 ber_int_t boolval, 414 ber_tag_t tag )); 415 416 LBER_F( int ) 417 ber_start_seq LDAP_P(( 418 BerElement *ber, 419 ber_tag_t tag )); 420 421 LBER_F( int ) 422 ber_start_set LDAP_P(( 423 BerElement *ber, 424 ber_tag_t tag )); 425 426 LBER_F( int ) 427 ber_put_seq LDAP_P(( 428 BerElement *ber )); 429 430 LBER_F( int ) 431 ber_put_set LDAP_P(( 432 BerElement *ber )); 433 434 LBER_F( int ) 435 ber_printf LDAP_P(( 436 BerElement *ber, 437 LDAP_CONST char *fmt, 438 ... )); 439 440 441 /* 442 * in io.c: 443 */ 444 445 LBER_F( ber_slen_t ) 446 ber_skip_data LDAP_P(( 447 BerElement *ber, 448 ber_len_t len )); 449 450 LBER_F( ber_slen_t ) 451 ber_read LDAP_P(( 452 BerElement *ber, 453 char *buf, 454 ber_len_t len )); 455 456 LBER_F( ber_slen_t ) 457 ber_write LDAP_P(( 458 BerElement *ber, 459 LDAP_CONST char *buf, 460 ber_len_t len, 461 int zero )); /* nonzero is unsupported from OpenLDAP 2.4.18 */ 462 463 LBER_F( void ) 464 ber_free LDAP_P(( 465 BerElement *ber, 466 int freebuf )); 467 468 LBER_F( void ) 469 ber_free_buf LDAP_P(( BerElement *ber )); 470 471 LBER_F( int ) 472 ber_flush2 LDAP_P(( 473 Sockbuf *sb, 474 BerElement *ber, 475 int freeit )); 476 #define LBER_FLUSH_FREE_NEVER (0x0) /* traditional behavior */ 477 #define LBER_FLUSH_FREE_ON_SUCCESS (0x1) /* traditional behavior */ 478 #define LBER_FLUSH_FREE_ON_ERROR (0x2) 479 #define LBER_FLUSH_FREE_ALWAYS (LBER_FLUSH_FREE_ON_SUCCESS|LBER_FLUSH_FREE_ON_ERROR) 480 481 LBER_F( int ) 482 ber_flush LDAP_P(( 483 Sockbuf *sb, 484 BerElement *ber, 485 int freeit )); /* DEPRECATED */ 486 487 LBER_F( BerElement * ) 488 ber_alloc LDAP_P(( void )); /* DEPRECATED */ 489 490 LBER_F( BerElement * ) 491 der_alloc LDAP_P(( void )); /* DEPRECATED */ 492 493 LBER_F( BerElement * ) 494 ber_alloc_t LDAP_P(( 495 int beroptions )); 496 497 LBER_F( BerElement * ) 498 ber_dup LDAP_P(( 499 BerElement *ber )); 500 501 LBER_F( ber_tag_t ) 502 ber_get_next LDAP_P(( 503 Sockbuf *sb, 504 ber_len_t *len, 505 BerElement *ber )); 506 507 LBER_F( void ) 508 ber_init2 LDAP_P(( 509 BerElement *ber, 510 struct berval *bv, 511 int options )); 512 513 LBER_F( void ) 514 ber_init_w_nullc LDAP_P(( /* DEPRECATED */ 515 BerElement *ber, 516 int options )); 517 518 LBER_F( void ) 519 ber_reset LDAP_P(( 520 BerElement *ber, 521 int was_writing )); 522 523 LBER_F( BerElement * ) 524 ber_init LDAP_P(( 525 struct berval *bv )); 526 527 LBER_F( int ) 528 ber_flatten LDAP_P(( 529 BerElement *ber, 530 struct berval **bvPtr )); 531 532 LBER_F( int ) 533 ber_flatten2 LDAP_P(( 534 BerElement *ber, 535 struct berval *bv, 536 int alloc )); 537 538 LBER_F( int ) 539 ber_remaining LDAP_P(( 540 BerElement *ber )); 541 542 /* 543 * LBER ber accessor functions 544 */ 545 546 LBER_F( int ) 547 ber_get_option LDAP_P(( 548 void *item, 549 int option, 550 void *outvalue)); 551 552 LBER_F( int ) 553 ber_set_option LDAP_P(( 554 void *item, 555 int option, 556 LDAP_CONST void *invalue)); 557 558 /* 559 * LBER sockbuf.c 560 */ 561 562 LBER_F( Sockbuf * ) 563 ber_sockbuf_alloc LDAP_P(( 564 void )); 565 566 LBER_F( void ) 567 ber_sockbuf_free LDAP_P(( 568 Sockbuf *sb )); 569 570 LBER_F( int ) 571 ber_sockbuf_add_io LDAP_P(( 572 Sockbuf *sb, 573 Sockbuf_IO *sbio, 574 int layer, 575 void *arg )); 576 577 LBER_F( int ) 578 ber_sockbuf_remove_io LDAP_P(( 579 Sockbuf *sb, 580 Sockbuf_IO *sbio, 581 int layer )); 582 583 LBER_F( int ) 584 ber_sockbuf_ctrl LDAP_P(( 585 Sockbuf *sb, 586 int opt, 587 void *arg )); 588 589 LBER_V( Sockbuf_IO ) ber_sockbuf_io_tcp; 590 LBER_V( Sockbuf_IO ) ber_sockbuf_io_readahead; 591 LBER_V( Sockbuf_IO ) ber_sockbuf_io_fd; 592 LBER_V( Sockbuf_IO ) ber_sockbuf_io_debug; 593 LBER_V( Sockbuf_IO ) ber_sockbuf_io_udp; 594 595 /* 596 * LBER memory.c 597 */ 598 LBER_F( void * ) 599 ber_memalloc LDAP_P(( 600 ber_len_t s )); 601 602 LBER_F( void * ) 603 ber_memrealloc LDAP_P(( 604 void* p, 605 ber_len_t s )); 606 607 LBER_F( void * ) 608 ber_memcalloc LDAP_P(( 609 ber_len_t n, 610 ber_len_t s )); 611 612 LBER_F( void ) 613 ber_memfree LDAP_P(( 614 void* p )); 615 616 LBER_F( void ) 617 ber_memvfree LDAP_P(( 618 void** vector )); 619 620 LBER_F( void ) 621 ber_bvfree LDAP_P(( 622 struct berval *bv )); 623 624 LBER_F( void ) 625 ber_bvecfree LDAP_P(( 626 struct berval **bv )); 627 628 LBER_F( int ) 629 ber_bvecadd LDAP_P(( 630 struct berval ***bvec, 631 struct berval *bv )); 632 633 LBER_F( struct berval * ) 634 ber_dupbv LDAP_P(( 635 struct berval *dst, struct berval *src )); 636 637 LBER_F( struct berval * ) 638 ber_bvdup LDAP_P(( 639 struct berval *src )); 640 641 LBER_F( struct berval * ) 642 ber_mem2bv LDAP_P(( 643 LDAP_CONST char *, ber_len_t len, int duplicate, struct berval *bv)); 644 645 LBER_F( struct berval * ) 646 ber_str2bv LDAP_P(( 647 LDAP_CONST char *, ber_len_t len, int duplicate, struct berval *bv)); 648 649 #define ber_bvstr(a) ((ber_str2bv)((a), 0, 0, NULL)) 650 #define ber_bvstrdup(a) ((ber_str2bv)((a), 0, 1, NULL)) 651 652 LBER_F( char * ) 653 ber_strdup LDAP_P(( 654 LDAP_CONST char * )); 655 656 LBER_F( ber_len_t ) 657 ber_strnlen LDAP_P(( 658 LDAP_CONST char *s, ber_len_t len )); 659 660 LBER_F( char * ) 661 ber_strndup LDAP_P(( 662 LDAP_CONST char *s, ber_len_t l )); 663 664 LBER_F( struct berval * ) 665 ber_bvreplace LDAP_P(( 666 struct berval *dst, LDAP_CONST struct berval *src )); 667 668 LBER_F( void ) 669 ber_bvarray_free LDAP_P(( BerVarray p )); 670 671 LBER_F( int ) 672 ber_bvarray_add LDAP_P(( BerVarray *p, BerValue *bv )); 673 674 #define ber_bvcmp(v1,v2) \ 675 ((v1)->bv_len < (v2)->bv_len \ 676 ? -1 : ((v1)->bv_len > (v2)->bv_len \ 677 ? 1 : memcmp((v1)->bv_val, (v2)->bv_val, (v1)->bv_len) )) 678 679 /* 680 * error.c 681 */ 682 LBER_F( int * ) ber_errno_addr LDAP_P((void)); 683 #define ber_errno (*(ber_errno_addr)()) 684 685 #define LBER_ERROR_NONE 0 686 #define LBER_ERROR_PARAM 0x1 687 #define LBER_ERROR_MEMORY 0x2 688 689 LDAP_END_DECL 690 691 #endif /* _LBER_H */ 692