2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1998-2006 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.
30 /* Portions Copyright (C) The Internet Society (1997)
31 * ASN.1 fragments are from RFC 2251; see RFC for full legal notices.
37 #include <ac/stdlib.h>
38 #include <ac/string.h>
43 #define LDAP_MATCHRULE_IDENTIFIER 0x80L
44 #define LDAP_REVERSEORDER_IDENTIFIER 0x81L
45 #define LDAP_ATTRTYPES_IDENTIFIER 0x80L
49 /* ---------------------------------------------------------------------------
52 Internal function to determine the number of keys in the string.
54 keyString (IN) String of items separated by whitespace.
55 ---------------------------------------------------------------------------*/
57 static int countKeys(char *keyString)
64 while (LDAP_SPACE(*p)) /* Skip leading whitespace */
67 if (*p == '\0') /* End of string? */
70 count++; /* Found start of a key */
72 while (!LDAP_SPACE(*p)) /* Skip till next space or end of string. */
79 /* ---------------------------------------------------------------------------
82 Internal function to parse the next sort key in the string.
83 Allocate an LDAPSortKey structure and initialize it with
84 attribute name, reverse flag, and matching rule OID.
86 Each sort key in the string has the format:
87 [whitespace][-]attribute[:[OID]]
89 pNextKey (IN/OUT) Points to the next key in the sortkey string to parse.
90 The pointer is updated to point to the next character
91 after the sortkey being parsed.
93 key (OUT) Points to the address of an LDAPSortKey stucture
94 which has been allocated by this routine and
95 initialized with information from the next sortkey.
96 ---------------------------------------------------------------------------*/
98 static int readNextKey( char **pNextKey, LDAPSortKey **key)
104 char *oidStart = NULL;
107 /* Skip leading white space. */
108 while (LDAP_SPACE(*p))
111 if (*p == '-') /* Check if the reverse flag is present. */
117 /* We're now positioned at the start of the attribute. */
120 /* Get the length of the attribute until the next whitespace or ":". */
121 attrLen = strcspn(p, " \t:");
124 if (attrLen == 0) /* If no attribute name was present, quit. */
125 return LDAP_PARAM_ERROR;
129 oidStart = ++p; /* Start of the OID, after the colon */
130 oidLen = strcspn(p, " \t"); /* Get length of OID till next whitespace */
134 *pNextKey = p; /* Update argument to point to next key */
136 /* Allocate an LDAPSortKey structure */
137 *key = LDAP_MALLOC(sizeof(LDAPSortKey));
138 if (*key == NULL) return LDAP_NO_MEMORY;
140 /* Allocate memory for the attribute and copy to it. */
141 (*key)->attributeType = LDAP_MALLOC(attrLen+1);
142 if ((*key)->attributeType == NULL) {
144 return LDAP_NO_MEMORY;
147 strncpy((*key)->attributeType, attrStart, attrLen);
148 (*key)->attributeType[attrLen] = 0;
150 /* If present, allocate memory for the OID and copy to it. */
152 (*key)->orderingRule = LDAP_MALLOC(oidLen+1);
153 if ((*key)->orderingRule == NULL) {
154 LDAP_FREE((*key)->attributeType);
156 return LDAP_NO_MEMORY;
158 strncpy((*key)->orderingRule, oidStart, oidLen);
159 (*key)->orderingRule[oidLen] = 0;
162 (*key)->orderingRule = NULL;
165 (*key)->reverseOrder = rev;
171 /* ---------------------------------------------------------------------------
172 ldap_create_sort_keylist
174 Create an array of pointers to LDAPSortKey structures, containing the
175 information specified by the string representation of one or more
178 sortKeyList (OUT) Points to a null-terminated array of pointers to
179 LDAPSortKey structures allocated by this routine.
180 This memory SHOULD be freed by the calling program
181 using ldap_free_sort_keylist().
183 keyString (IN) Points to a string of one or more sort keys.
185 ---------------------------------------------------------------------------*/
188 ldap_create_sort_keylist ( LDAPSortKey ***sortKeyList, char *keyString )
192 LDAPSortKey **keyList = NULL;
194 assert( sortKeyList != NULL );
195 assert( keyString != NULL );
199 /* Determine the number of sort keys so we can allocate memory. */
200 if (( numKeys = countKeys(keyString)) == 0) {
201 return LDAP_PARAM_ERROR;
204 /* Allocate the array of pointers. Initialize to NULL. */
205 keyList=(LDAPSortKey**)LBER_CALLOC(numKeys+1, sizeof(LDAPSortKey*));
206 if ( keyList == NULL) return LDAP_NO_MEMORY;
208 /* For each sort key in the string, create an LDAPSortKey structure
209 and add it to the list.
211 nextKey = keyString; /* Points to the next key in the string */
212 for (i=0; i < numKeys; i++) {
213 rc = readNextKey(&nextKey, &keyList[i]);
215 if (rc != LDAP_SUCCESS) {
216 ldap_free_sort_keylist(keyList);
221 *sortKeyList = keyList;
226 /* ---------------------------------------------------------------------------
227 ldap_free_sort_keylist
229 Frees the sort key structures created by ldap_create_sort_keylist().
230 Frees the memory referenced by the LDAPSortKey structures,
231 the LDAPSortKey structures themselves, and the array of pointers
234 keyList (IN) Points to an array of pointers to LDAPSortKey structures.
235 ---------------------------------------------------------------------------*/
238 ldap_free_sort_keylist ( LDAPSortKey **keyList )
241 LDAPSortKey *nextKeyp;
243 if (keyList == NULL) return;
246 while ( 0 != (nextKeyp = keyList[i++]) ) {
247 if (nextKeyp->attributeType) {
248 LBER_FREE(nextKeyp->attributeType);
251 if (nextKeyp->orderingRule != NULL) {
252 LBER_FREE(nextKeyp->orderingRule);
262 /* ---------------------------------------------------------------------------
263 ldap_create_sort_control
265 Create and encode the server-side sort control.
267 ld (IN) An LDAP session handle, as obtained from a call to
270 keyList (IN) Points to a null-terminated array of pointers to
271 LDAPSortKey structures, containing a description of
272 each of the sort keys to be used. The description
273 consists of an attribute name, ascending/descending flag,
274 and an optional matching rule (OID) to use.
276 isCritical (IN) 0 - Indicates the control is not critical to the operation.
277 non-zero - The control is critical to the operation.
279 ctrlp (OUT) Returns a pointer to the LDAPControl created. This control
280 SHOULD be freed by calling ldap_control_free() when done.
285 SortKeyList ::= SEQUENCE OF SEQUENCE {
286 attributeType AttributeDescription,
287 orderingRule [0] MatchingRuleId OPTIONAL,
288 reverseOrder [1] BOOLEAN DEFAULT FALSE }
290 ---------------------------------------------------------------------------*/
293 ldap_create_sort_control (
295 LDAPSortKey **keyList,
297 LDAPControl **ctrlp )
304 if ( (ld == NULL) || (keyList == NULL) || (ctrlp == NULL) ) {
305 ld->ld_errno = LDAP_PARAM_ERROR;
306 return(ld->ld_errno);
309 if ((ber = ldap_alloc_ber_with_options(ld)) == NULL) {
310 ld->ld_errno = LDAP_NO_MEMORY;
311 return( ld->ld_errno );
314 tag = ber_printf(ber, "{" /*}*/);
315 if (tag == LBER_ERROR) goto exit;
317 for (i = 0; keyList[i] != NULL; i++) {
318 tag = ber_printf(ber, "{s" /*}*/, (keyList[i])->attributeType);
319 if (tag == LBER_ERROR) goto exit;
321 if ((keyList[i])->orderingRule != NULL) {
322 tag = ber_printf( ber, "ts",
323 LDAP_MATCHRULE_IDENTIFIER,
324 (keyList[i])->orderingRule );
326 if( tag == LBER_ERROR ) goto exit;
329 if ((keyList[i])->reverseOrder) {
330 tag = ber_printf(ber, "tb",
331 LDAP_REVERSEORDER_IDENTIFIER,
332 (keyList[i])->reverseOrder );
334 if( tag == LBER_ERROR ) goto exit;
337 tag = ber_printf(ber, /*{*/ "N}");
338 if( tag == LBER_ERROR ) goto exit;
341 tag = ber_printf(ber, /*{*/ "N}");
342 if( tag == LBER_ERROR ) goto exit;
344 ld->ld_errno = ldap_create_control( LDAP_CONTROL_SORTREQUEST,
345 ber, isCritical, ctrlp);
349 return(ld->ld_errno);
353 ld->ld_errno = LDAP_ENCODING_ERROR;
354 return(ld->ld_errno);
358 /* ---------------------------------------------------------------------------
359 ldap_parse_sortedresult_control
361 Decode the server-side sort control return information.
363 ld (IN) An LDAP session handle, as obtained from a call to
366 ctrl (IN) The address of the LDAP Control Structure.
368 returnCode (OUT) This result parameter is filled in with the sort control
369 result code. This parameter MUST not be NULL.
371 attribute (OUT) If an error occured the server may return a string
372 indicating the first attribute in the sortkey list
373 that was in error. If a string is returned, the memory
374 should be freed with ldap_memfree. If this parameter is
375 NULL, no string is returned.
378 Ber encoding for sort control
380 SortResult ::= SEQUENCE {
381 sortResult ENUMERATED {
382 success (0), -- results are sorted
383 operationsError (1), -- server internal failure
384 timeLimitExceeded (3), -- timelimit reached before
385 -- sorting was completed
386 strongAuthRequired (8), -- refused to return sorted
387 -- results via insecure
389 adminLimitExceeded (11), -- too many matching entries
390 -- for the server to sort
391 noSuchAttribute (16), -- unrecognized attribute
393 inappropriateMatching (18), -- unrecognized or inappro-
394 -- priate matching rule in
396 insufficientAccessRights (50), -- refused to return sorted
397 -- results to this client
398 busy (51), -- too busy to process
399 unwillingToPerform (53), -- unable to sort
402 attributeType [0] AttributeDescription OPTIONAL }
403 ---------------------------------------------------------------------------*/
406 ldap_parse_sortedresult_control(
409 unsigned long *returnCode,
413 LDAPControl *pControl;
415 ber_tag_t tag, berTag;
419 ld->ld_errno = LDAP_PARAM_ERROR;
420 return(ld->ld_errno);
424 ld->ld_errno = LDAP_PARAM_ERROR;
425 return(ld->ld_errno);
432 if ( strcmp(LDAP_CONTROL_SORTRESPONSE, ctrl->ldctl_oid) != 0 ) {
433 /* Not sort result control */
434 ld->ld_errno = LDAP_CONTROL_NOT_FOUND;
435 return(ld->ld_errno);
438 /* Create a BerElement from the berval returned in the control. */
439 ber = ber_init(&ctrl->ldctl_value);
442 ld->ld_errno = LDAP_NO_MEMORY;
443 return(ld->ld_errno);
446 /* Extract the result code from the control. */
447 tag = ber_scanf(ber, "{e" /*}*/, returnCode);
449 if( tag == LBER_ERROR ) {
451 ld->ld_errno = LDAP_DECODING_ERROR;
452 return(ld->ld_errno);
455 /* If caller wants the attribute name, and if it's present in the control,
456 extract the attribute name which caused the error. */
457 if (attribute && (LDAP_ATTRTYPES_IDENTIFIER == ber_peek_tag(ber, &berLen)))
459 tag = ber_scanf(ber, "ta", &berTag, attribute);
461 if (tag == LBER_ERROR ) {
463 ld->ld_errno = LDAP_DECODING_ERROR;
464 return(ld->ld_errno);
470 ld->ld_errno = LDAP_SUCCESS;
471 return(ld->ld_errno);