2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1998-2007 The OpenLDAP Foundation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted only as authorized by the OpenLDAP
11 * A copy of this license is available in the file LICENSE in the
12 * top-level directory of the distribution or, alternatively, at
13 * <http://www.OpenLDAP.org/license.html>.
15 /* Portions Copyright (C) 1999, 2000 Novell, Inc. All Rights Reserved.
17 * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND
18 * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT
19 * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS
20 * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE"
21 * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION
22 * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP
23 * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT
24 * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
26 /* Note: A verbatim copy of version 2.0.1 of the OpenLDAP Public License
27 * can be found in the file "build/LICENSE-2.0.1" in this distribution
28 * of OpenLDAP Software.
34 #include <ac/stdlib.h>
35 #include <ac/string.h>
40 #define LDAP_MATCHRULE_IDENTIFIER 0x80L
41 #define LDAP_REVERSEORDER_IDENTIFIER 0x81L
42 #define LDAP_ATTRTYPES_IDENTIFIER 0x80L
46 /* ---------------------------------------------------------------------------
49 Internal function to determine the number of keys in the string.
51 keyString (IN) String of items separated by whitespace.
52 ---------------------------------------------------------------------------*/
54 static int countKeys(char *keyString)
61 while (LDAP_SPACE(*p)) /* Skip leading whitespace */
64 if (*p == '\0') /* End of string? */
67 count++; /* Found start of a key */
69 while (!LDAP_SPACE(*p)) /* Skip till next space or end of string. */
76 /* ---------------------------------------------------------------------------
79 Internal function to parse the next sort key in the string.
80 Allocate an LDAPSortKey structure and initialize it with
81 attribute name, reverse flag, and matching rule OID.
83 Each sort key in the string has the format:
84 [whitespace][-]attribute[:[OID]]
86 pNextKey (IN/OUT) Points to the next key in the sortkey string to parse.
87 The pointer is updated to point to the next character
88 after the sortkey being parsed.
90 key (OUT) Points to the address of an LDAPSortKey stucture
91 which has been allocated by this routine and
92 initialized with information from the next sortkey.
93 ---------------------------------------------------------------------------*/
95 static int readNextKey( char **pNextKey, LDAPSortKey **key)
101 char *oidStart = NULL;
104 /* Skip leading white space. */
105 while (LDAP_SPACE(*p))
108 if (*p == '-') /* Check if the reverse flag is present. */
114 /* We're now positioned at the start of the attribute. */
117 /* Get the length of the attribute until the next whitespace or ":". */
118 attrLen = strcspn(p, " \t:");
121 if (attrLen == 0) /* If no attribute name was present, quit. */
122 return LDAP_PARAM_ERROR;
126 oidStart = ++p; /* Start of the OID, after the colon */
127 oidLen = strcspn(p, " \t"); /* Get length of OID till next whitespace */
131 *pNextKey = p; /* Update argument to point to next key */
133 /* Allocate an LDAPSortKey structure */
134 *key = LDAP_MALLOC(sizeof(LDAPSortKey));
135 if (*key == NULL) return LDAP_NO_MEMORY;
137 /* Allocate memory for the attribute and copy to it. */
138 (*key)->attributeType = LDAP_MALLOC(attrLen+1);
139 if ((*key)->attributeType == NULL) {
141 return LDAP_NO_MEMORY;
144 strncpy((*key)->attributeType, attrStart, attrLen);
145 (*key)->attributeType[attrLen] = 0;
147 /* If present, allocate memory for the OID and copy to it. */
149 (*key)->orderingRule = LDAP_MALLOC(oidLen+1);
150 if ((*key)->orderingRule == NULL) {
151 LDAP_FREE((*key)->attributeType);
153 return LDAP_NO_MEMORY;
155 strncpy((*key)->orderingRule, oidStart, oidLen);
156 (*key)->orderingRule[oidLen] = 0;
159 (*key)->orderingRule = NULL;
162 (*key)->reverseOrder = rev;
168 /* ---------------------------------------------------------------------------
169 ldap_create_sort_keylist
171 Create an array of pointers to LDAPSortKey structures, containing the
172 information specified by the string representation of one or more
175 sortKeyList (OUT) Points to a null-terminated array of pointers to
176 LDAPSortKey structures allocated by this routine.
177 This memory SHOULD be freed by the calling program
178 using ldap_free_sort_keylist().
180 keyString (IN) Points to a string of one or more sort keys.
182 ---------------------------------------------------------------------------*/
185 ldap_create_sort_keylist ( LDAPSortKey ***sortKeyList, char *keyString )
189 LDAPSortKey **keyList = NULL;
191 assert( sortKeyList != NULL );
192 assert( keyString != NULL );
196 /* Determine the number of sort keys so we can allocate memory. */
197 if (( numKeys = countKeys(keyString)) == 0) {
198 return LDAP_PARAM_ERROR;
201 /* Allocate the array of pointers. Initialize to NULL. */
202 keyList=(LDAPSortKey**)LBER_CALLOC(numKeys+1, sizeof(LDAPSortKey*));
203 if ( keyList == NULL) return LDAP_NO_MEMORY;
205 /* For each sort key in the string, create an LDAPSortKey structure
206 and add it to the list.
208 nextKey = keyString; /* Points to the next key in the string */
209 for (i=0; i < numKeys; i++) {
210 rc = readNextKey(&nextKey, &keyList[i]);
212 if (rc != LDAP_SUCCESS) {
213 ldap_free_sort_keylist(keyList);
218 *sortKeyList = keyList;
223 /* ---------------------------------------------------------------------------
224 ldap_free_sort_keylist
226 Frees the sort key structures created by ldap_create_sort_keylist().
227 Frees the memory referenced by the LDAPSortKey structures,
228 the LDAPSortKey structures themselves, and the array of pointers
231 keyList (IN) Points to an array of pointers to LDAPSortKey structures.
232 ---------------------------------------------------------------------------*/
235 ldap_free_sort_keylist ( LDAPSortKey **keyList )
238 LDAPSortKey *nextKeyp;
240 if (keyList == NULL) return;
243 while ( 0 != (nextKeyp = keyList[i++]) ) {
244 if (nextKeyp->attributeType) {
245 LBER_FREE(nextKeyp->attributeType);
248 if (nextKeyp->orderingRule != NULL) {
249 LBER_FREE(nextKeyp->orderingRule);
259 /* ---------------------------------------------------------------------------
260 ldap_create_sort_control_value
262 Create and encode the value of the server-side sort control.
264 ld (IN) An LDAP session handle, as obtained from a call to
267 keyList (IN) Points to a null-terminated array of pointers to
268 LDAPSortKey structures, containing a description of
269 each of the sort keys to be used. The description
270 consists of an attribute name, ascending/descending flag,
271 and an optional matching rule (OID) to use.
273 value (OUT) Contains the control value; the bv_val member of the berval structure
274 SHOULD be freed by calling ldap_memfree() when done.
279 SortKeyList ::= SEQUENCE OF SEQUENCE {
280 attributeType AttributeDescription,
281 orderingRule [0] MatchingRuleId OPTIONAL,
282 reverseOrder [1] BOOLEAN DEFAULT FALSE }
284 ---------------------------------------------------------------------------*/
287 ldap_create_sort_control_value(
289 LDAPSortKey **keyList,
290 struct berval *value )
293 BerElement *ber = NULL;
296 assert( ld != NULL );
297 assert( LDAP_VALID( ld ) );
299 if ( ld == NULL ) return LDAP_PARAM_ERROR;
300 if ( keyList == NULL || value == NULL ) {
301 ld->ld_errno = LDAP_PARAM_ERROR;
302 return LDAP_PARAM_ERROR;
305 value->bv_val = NULL;
308 ber = ldap_alloc_ber_with_options( ld );
310 ld->ld_errno = LDAP_NO_MEMORY;
314 tag = ber_printf( ber, "{" /*}*/ );
315 if ( tag == LBER_ERROR ) {
319 for ( i = 0; keyList[i] != NULL; i++ ) {
320 tag = ber_printf( ber, "{s" /*}*/, keyList[i]->attributeType );
321 if ( tag == LBER_ERROR ) {
325 if ( keyList[i]->orderingRule != NULL ) {
326 tag = ber_printf( ber, "ts",
327 LDAP_MATCHRULE_IDENTIFIER,
328 keyList[i]->orderingRule );
330 if ( tag == LBER_ERROR ) {
335 if ( keyList[i]->reverseOrder ) {
336 tag = ber_printf( ber, "tb",
337 LDAP_REVERSEORDER_IDENTIFIER,
338 keyList[i]->reverseOrder );
340 if ( tag == LBER_ERROR ) {
345 tag = ber_printf( ber, /*{*/ "N}" );
346 if ( tag == LBER_ERROR ) {
351 tag = ber_printf( ber, /*{*/ "N}" );
352 if ( tag == LBER_ERROR ) {
356 if ( ber_flatten2( ber, value, 1 ) == -1 ) {
357 ld->ld_errno = LDAP_NO_MEMORY;
362 ld->ld_errno = LDAP_ENCODING_ERROR;
373 /* ---------------------------------------------------------------------------
374 ldap_create_sort_control
376 Create and encode the server-side sort control.
378 ld (IN) An LDAP session handle, as obtained from a call to
381 keyList (IN) Points to a null-terminated array of pointers to
382 LDAPSortKey structures, containing a description of
383 each of the sort keys to be used. The description
384 consists of an attribute name, ascending/descending flag,
385 and an optional matching rule (OID) to use.
387 isCritical (IN) 0 - Indicates the control is not critical to the operation.
388 non-zero - The control is critical to the operation.
390 ctrlp (OUT) Returns a pointer to the LDAPControl created. This control
391 SHOULD be freed by calling ldap_control_free() when done.
396 SortKeyList ::= SEQUENCE OF SEQUENCE {
397 attributeType AttributeDescription,
398 orderingRule [0] MatchingRuleId OPTIONAL,
399 reverseOrder [1] BOOLEAN DEFAULT FALSE }
401 ---------------------------------------------------------------------------*/
404 ldap_create_sort_control(
406 LDAPSortKey **keyList,
408 LDAPControl **ctrlp )
413 assert( ld != NULL );
414 assert( LDAP_VALID( ld ) );
416 if ( ld == NULL ) return LDAP_PARAM_ERROR;
417 if ( ctrlp == NULL ) {
418 ld->ld_errno = LDAP_PARAM_ERROR;
422 ld->ld_errno = ldap_create_sort_control_value( ld, keyList, &value );
423 if ( ld->ld_errno == LDAP_SUCCESS ) {
424 if ((ber = ldap_alloc_ber_with_options(ld)) == NULL) {
425 ld->ld_errno = LDAP_NO_MEMORY;
426 return LDAP_NO_MEMORY;
429 ld->ld_errno = ldap_create_control( LDAP_CONTROL_SORTREQUEST,
430 ber, isCritical, ctrlp );
431 if ( ld->ld_errno == LDAP_SUCCESS ) {
432 (*ctrlp)->ldctl_value = value;
434 LDAP_FREE( value.bv_val );
443 /* ---------------------------------------------------------------------------
444 ldap_parse_sortedresult_control
446 Decode the server-side sort control return information.
448 ld (IN) An LDAP session handle, as obtained from a call to
451 ctrl (IN) The address of the LDAP Control Structure.
453 returnCode (OUT) This result parameter is filled in with the sort control
454 result code. This parameter MUST not be NULL.
456 attribute (OUT) If an error occured the server may return a string
457 indicating the first attribute in the sortkey list
458 that was in error. If a string is returned, the memory
459 should be freed with ldap_memfree. If this parameter is
460 NULL, no string is returned.
463 Ber encoding for sort control
465 SortResult ::= SEQUENCE {
466 sortResult ENUMERATED {
467 success (0), -- results are sorted
468 operationsError (1), -- server internal failure
469 timeLimitExceeded (3), -- timelimit reached before
470 -- sorting was completed
471 strongAuthRequired (8), -- refused to return sorted
472 -- results via insecure
474 adminLimitExceeded (11), -- too many matching entries
475 -- for the server to sort
476 noSuchAttribute (16), -- unrecognized attribute
478 inappropriateMatching (18), -- unrecognized or inappro-
479 -- priate matching rule in
481 insufficientAccessRights (50), -- refused to return sorted
482 -- results to this client
483 busy (51), -- too busy to process
484 unwillingToPerform (53), -- unable to sort
487 attributeType [0] AttributeDescription OPTIONAL }
488 ---------------------------------------------------------------------------*/
491 ldap_parse_sortresponse_control(
494 ber_int_t *returnCode,
498 ber_tag_t tag, berTag;
501 assert( ld != NULL );
502 assert( LDAP_VALID( ld ) );
505 return LDAP_PARAM_ERROR;
509 ld->ld_errno = LDAP_PARAM_ERROR;
510 return(ld->ld_errno);
517 if ( strcmp(LDAP_CONTROL_SORTRESPONSE, ctrl->ldctl_oid) != 0 ) {
518 /* Not sort result control */
519 ld->ld_errno = LDAP_CONTROL_NOT_FOUND;
520 return(ld->ld_errno);
523 /* Create a BerElement from the berval returned in the control. */
524 ber = ber_init(&ctrl->ldctl_value);
527 ld->ld_errno = LDAP_NO_MEMORY;
528 return(ld->ld_errno);
531 /* Extract the result code from the control. */
532 tag = ber_scanf(ber, "{e" /*}*/, returnCode);
534 if( tag == LBER_ERROR ) {
536 ld->ld_errno = LDAP_DECODING_ERROR;
537 return(ld->ld_errno);
540 /* If caller wants the attribute name, and if it's present in the control,
541 extract the attribute name which caused the error. */
542 if (attribute && (LDAP_ATTRTYPES_IDENTIFIER == ber_peek_tag(ber, &berLen)))
544 tag = ber_scanf(ber, "ta", &berTag, attribute);
546 if (tag == LBER_ERROR ) {
548 ld->ld_errno = LDAP_DECODING_ERROR;
549 return(ld->ld_errno);
555 ld->ld_errno = LDAP_SUCCESS;
556 return(ld->ld_errno);