#pragma ident "%Z%%M% %I% %E% SMI"
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#include "ldap-int.h"
/* ldap_create_sort_control:
Parameters are
ld LDAP pointer to the desired connection
sortKeyList an array of sortkeys
ctl_iscritical Indicates whether the control is critical of not. If
this field is non-zero, the operation will only be car-
ried out if the control is recognized by the server
ctrlp the address of a place to put the constructed control
*/
int
const char ctl_iscritical,
)
{
int i, rc;
if ( !NSLDAPI_VALID_LDAP_POINTER( ld )) {
return( LDAP_PARAM_ERROR );
}
return ( LDAP_PARAM_ERROR );
}
/* create a ber package to hold the controlValue */
return( LDAP_NO_MEMORY );
}
/* encode the start of the sequence of sequences into the ber */
goto encoding_error_exit;
}
/* the sort control value will be encoded as a sequence of sequences
which are each encoded as one of the following: {s} or {sts} or {stb} or {ststb}
since the orderingRule and reverseOrder flag are both optional */
for ( i = 0; sortKeyList[i] != NULL; i++ ) {
/* encode the attributeType into the ber */
== -1 ) {
goto encoding_error_exit;
}
/* encode the optional orderingRule into the ber */
(sortKeyList[i])->sk_matchruleoid )
== -1 ) {
goto encoding_error_exit;
}
}
/* Encode the optional reverseOrder flag into the ber. */
/* If the flag is false, it should be absent. */
if ( (sortKeyList[i])->sk_reverseorder ) {
goto encoding_error_exit;
}
} else {
goto encoding_error_exit;
}
}
}
/* encode the end of the sequence of sequences into the ber */
goto encoding_error_exit;
}
ctl_iscritical, ctrlp );
return( rc );
return( LDAP_ENCODING_ERROR );
}
/* ldap_parse_sort_control:
Parameters are
ld LDAP pointer to the desired connection
ctrlp An array of controls obtained from calling
ldap_parse_result on the set of results returned by
the server
result the address of a place to put the result code
attribute the address of a place to put the name of the
attribute which cause the operation to fail, optionally
returned by the server */
int
LDAPControl **ctrlp,
unsigned long *result,
char **attribute
)
{
int i, foundSortControl;
char *attr;
return( LDAP_PARAM_ERROR );
}
/* find the sortControl in the list of controls if it exists */
return ( LDAP_CONTROL_NOT_FOUND );
}
foundSortControl = 0;
}
if ( !foundSortControl ) {
return ( LDAP_CONTROL_NOT_FOUND );
} else {
/* let local var point to the sortControl */
}
/* allocate a Ber element with the contents of the sort_control's struct berval */
return( LDAP_NO_MEMORY );
}
/* decode the result from the Berelement */
return( LDAP_DECODING_ERROR );
}
/* if the server returned one, decode the attribute from the Ber element */
return( LDAP_DECODING_ERROR );
}
} else {
}
return( LDAP_DECODING_ERROR );
}
/* the ber encoding is no longer needed */
return( LDAP_SUCCESS );
}
/* Routines for the manipulation of string-representations of sort control keylists */
static int count_tokens(const char *s)
{
int count = 0;
const char *p = s;
/* Loop along the string counting the number of times we see the
* beginning of non-whitespace. This tells us
* the number of tokens in the string
*/
while (*p != '\0') {
if (whitespace) {
if (!isspace(*p)) {
whitespace = 0;
count++;
}
} else {
if (isspace(*p)) {
whitespace = 1;
}
}
p++;
}
return count;
}
{
char c = 0;
const char *pos = *s;
int retval = 0;
int matchrule_size = 0;
int attrdesc_size = 0;
int reverse = 0;
int state = 0;
switch (state) {
case 0:
/* case where we've not seen the beginning of the attr yet */
/* If we still see whitespace, nothing to do */
if (!isspace(c)) {
/* Otherwise, something to look at */
/* Is it a minus sign ? */
if ('-' == c) {
reverse = 1;
} else {
state = 1;
}
}
break;
case 1:
/* case where we've seen the beginning of the attr, but not the end */
/* Is this char either whitespace or a ';' ? */
if ( isspace(c) || (':' == c)) {
if (':' == c) {
state = 2;
} else {
state = 4;
}
}
break;
case 2:
/* case where we've seen the end of the attr and want the beginning of match rule */
if (!isspace(c)) {
state = 3;
} else {
state = 4;
}
break;
case 3:
/* case where we've seen the beginning of match rule and want to find the end */
if (isspace(c)) {
state = 4;
}
break;
default:
break;
}
}
if (3 == state) {
/* means we fell off the end of the string looking for the end of the marching rule */
}
if (1 == state) {
/* means we fell of the end of the string looking for the end of the attribute */
}
if (NULL == attrdesc_source) {
/* Didn't find anything */
return -1;
}
if (0 == new_key) {
return LDAP_NO_MEMORY;
}
/* Allocate the strings */
if (NULL != matchrule_source) {
matchrule_size + 1);
} else {
}
/* Copy over the strings */
if (NULL != matchrule_source) {
}
*s = pos - 1;
return retval;
}
int
const char *string_rep
)
{
int count = 0;
int retval = 0;
int i = 0;
/* Figure out how many there are */
if (NULL == string_rep) {
return LDAP_PARAM_ERROR;
}
if (NULL == sortKeyList) {
return LDAP_PARAM_ERROR;
}
if (0 == count) {
*sortKeyList = NULL;
return LDAP_PARAM_ERROR;
}
/* Allocate enough memory for the pointers */
* (count + 1) );
if (NULL == pointer_array) {
return LDAP_NO_MEMORY;
}
/* Now walk along the string, allocating and filling in the LDAPsearchkey structure */
for (i = 0; i < count; i++) {
*sortKeyList = NULL;
return retval;
}
}
return LDAP_SUCCESS;
}
void
)
{
int i = 0;
if ( NULL == sortKeyList ) {
return;
}
/* Walk down the list freeing the LDAPsortkey structures */
/* Free the strings, if present */
}
}
}
/* Free the pointer list */
}