sortctrl.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
*
* Copyright %G% Sun Microsystems, Inc.
* All Rights Reserved
*
*
* Comments:
*
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "lber.h"
#include "ldap.h"
#include "ldap-private.h"
#include "ldap-int.h"
static int count_tokens(char *s);
static int isattrdescchar(char c);
{
int i, rc;
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;
}
return (rc);
return (LDAP_ENCODING_ERROR);
}
{
int i, foundSortControl;
unsigned int len;
char *attr;
int tag;
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(char *s)
{
int count = 0;
char *p = s;
int whitespace = 1;
/*
* 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);
}
/* Is this character a valid attribute description character ? */
static int isattrdescchar(char c)
{
/* Alphanumeric chars are in */
if (isalnum(c)) {
return (1);
}
/* As is ';' */
if (';' == c) {
return (1);
}
/* Everything else is out */
return (0);
}
{
char c = 0;
char *pos = *s;
int retval = 0;
char *matchrule_source = NULL;
int matchrule_size = 0;
char *attrdesc_source = NULL;
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) {
} else {
}
/* Copy over the strings */
if (NULL != matchrule_source) {
}
*s = pos - 1;
return (retval);
}
int
{
int count = 0;
char *current_position = NULL;
char *s = NULL;
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++) {
&(pointer_array[i])))) {
*sortKeyList = NULL;
return (retval);
}
}
return (LDAP_SUCCESS);
}
void
{
int i = 0;
if (NULL == sortKeyList) {
return;
}
/* Walk down the list freeing the LDAPsortkey structures */
this_one = sortKeyList[++i]) {
/* Free the strings, if present */
}
}
}
/* Free the pointer list */
}