ldap/common/sort.c

	sort.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * The contents of this file are subject to the Netscape Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is Mozilla Communicator client code, released
 * March 31, 1998.
 *
 * The Initial Developer of the Original Code is Netscape
 * Communications Corporation. Portions created by Netscape are
 * Copyright (C) 1998-1999 Netscape Communications Corporation. All
 * Rights Reserved.
 *
 * Contributor(s):
 */
/*
 * Copyright (c) 1994 Regents of the University of Michigan.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that this notice is preserved and that due credit is given
 * to the University of Michigan at Ann Arbor. The name of the University
 * may not be used to endorse or promote products derived from this
 * software without specific prior written permission. This software
 * is provided ``as is'' without express or implied warranty.
 */
/*
 * sort.c:  LDAP library entry and value sort routines
 */

#include "ldap-int.h"

/* This xp_qsort fixes a memory problem (ABR) on Solaris for the client.
 * Server is welcome to use it too, but I wasn't sure if it
 * would be ok to use XP code here.  -slamm
 *
 * We don't want to require use of libxp when linking with libldap, so
 * I'll leave use of xp_qsort as a MOZILLA_CLIENT-only thing for now. --mcs
 */
#if defined(MOZILLA_CLIENT) && defined(SOLARIS)
#include "xp_qsort.h"
#else
#define XP_QSORT qsort
#endif

typedef struct keycmp {
    void                 *kc_arg;
    LDAP_KEYCMP_CALLBACK *kc_cmp;
} keycmp_t;

typedef struct keything {
    keycmp_t            *kt_cmp;
    const struct berval *kt_key;
    LDAPMessage         *kt_msg;
} keything_t;

static int LDAP_C LDAP_CALLBACK
ldapi_keycmp( const void *Lv, const void *Rv )
{
    auto keything_t **L = (keything_t**)Lv;
    auto keything_t **R = (keything_t**)Rv;
    auto keycmp_t *cmp = (*L)->kt_cmp;
    return cmp->kc_cmp( cmp->kc_arg, (*L)->kt_key, (*R)->kt_key );
}

int
LDAP_CALL
ldap_keysort_entries(
    LDAP        *ld,
    LDAPMessage **chain,
    void                  *arg,
    LDAP_KEYGEN_CALLBACK  *gen,
    LDAP_KEYCMP_CALLBACK  *cmp,
    LDAP_KEYFREE_CALLBACK *fre)
{
    size_t      count, i;
    keycmp_t    kc = {0};
    keything_t  **kt;
    LDAPMessage *e, *last;
    LDAPMessage **ep;

    if ( !NSLDAPI_VALID_LDAP_POINTER( ld )
        || chain == NULL || cmp == NULL ) {
        return( LDAP_PARAM_ERROR );
    }

    count = ldap_count_entries( ld, *chain );

    kt = (keything_t**)NSLDAPI_MALLOC( count * (sizeof(keything_t*) + sizeof(keything_t)) );
    if ( kt == NULL ) {
        LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL );
        return( -1 );
    }
    for ( i = 0; i < count; i++ ) {
        kt[i] = i + (keything_t*)(kt + count);
    }
    kc.kc_arg = arg;
    kc.kc_cmp = cmp;

    for ( e = *chain, i = 0; i < count; i++, e = e->lm_chain ) {
        kt[i]->kt_msg = e;
        kt[i]->kt_cmp = &kc;
        kt[i]->kt_key = gen( arg, ld, e );
        if ( kt[i]->kt_key == NULL ) {
            if ( fre ) while ( i-- > 0 ) fre( arg, kt[i]->kt_key );
            NSLDAPI_FREE( (char*)kt );
            LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL );
            return( -1 );
        }
    }
    last = e;

    XP_QSORT( (void*)kt, count, (size_t)sizeof(keything_t*), ldapi_keycmp );

    ep = chain;
    for ( i = 0; i < count; i++ ) {
        *ep = kt[i]->kt_msg;
        ep = &(*ep)->lm_chain;
        if ( fre ) fre( arg, kt[i]->kt_key );
    }
    *ep = last;
    NSLDAPI_FREE( (char*)kt );
    return( 0 );
}


struct entrything {
    char        **et_vals;
    LDAPMessage *et_msg;
};

typedef int (LDAP_C LDAP_CALLBACK LDAP_CHARCMP_CALLBACK)(char*, char*);
typedef int (LDAP_C LDAP_CALLBACK LDAP_VOIDCMP_CALLBACK)(const void*,
    const void*);

static LDAP_CHARCMP_CALLBACK *et_cmp_fn;
static LDAP_VOIDCMP_CALLBACK et_cmp;

int
LDAP_C
LDAP_CALLBACK
ldap_sort_strcasecmp(
    const char  **a,
    const char  **b
)
{
    /* XXXceb
     * I am not 100% sure this is the way this should be handled.
     * For now we will return a 0 on invalid.
     */
    if (NULL == a || NULL == b)
        return (0);
    return( strcasecmp( (char *)*a, (char *)*b ) );
}

static int
LDAP_C
LDAP_CALLBACK
et_cmp(
    const void  *aa,
    const void  *bb
)
{
    int         i, rc;
    struct entrything   *a = (struct entrything *)aa;
    struct entrything   *b = (struct entrything *)bb;

    if ( a->et_vals == NULL && b->et_vals == NULL )
        return( 0 );
    if ( a->et_vals == NULL )
        return( -1 );
    if ( b->et_vals == NULL )
        return( 1 );

    for ( i = 0; a->et_vals[i] && b->et_vals[i]; i++ ) {
        if ( (rc = (*et_cmp_fn)( a->et_vals[i], b->et_vals[i] ))
            != 0 ) {
            return( rc );
        }
    }

    if ( a->et_vals[i] == NULL && b->et_vals[i] == NULL )
        return( 0 );
    if ( a->et_vals[i] == NULL )
        return( -1 );
    return( 1 );
}

int
LDAP_CALL
ldap_multisort_entries(
    LDAP    *ld,
    LDAPMessage **chain,
    char    **attr,     /* NULL => sort by DN */
    LDAP_CMP_CALLBACK *cmp
)
{
    int         i, count;
    struct entrything   *et;
    LDAPMessage     *e, *last;
    LDAPMessage     **ep;

    if ( !NSLDAPI_VALID_LDAP_POINTER( ld )
        || chain == NULL || cmp == NULL ) {
        return( LDAP_PARAM_ERROR );
    }

    count = ldap_count_entries( ld, *chain );

    if ( (et = (struct entrything *)NSLDAPI_MALLOC( count *
        sizeof(struct entrything) )) == NULL ) {
        LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL );
        return( -1 );
    }

    e = *chain;
    for ( i = 0; i < count; i++ ) {
        et[i].et_msg = e;
        et[i].et_vals = NULL;
        if ( attr == NULL ) {
            char    *dn;

            dn = ldap_get_dn( ld, e );
            et[i].et_vals = ldap_explode_dn( dn, 1 );
            NSLDAPI_FREE( dn );
        } else {
            int attrcnt;
            char    **vals;

            for ( attrcnt = 0; attr[attrcnt] != NULL; attrcnt++ ) {
                vals = ldap_get_values( ld, e, attr[attrcnt] );
                if ( ldap_charray_merge( &(et[i].et_vals), vals )
                != 0 ) {
                int j;

                /* XXX risky: ldap_value_free( vals ); */
                for ( j = 0; j <= i; j++ )
                    ldap_value_free( et[j].et_vals );
                NSLDAPI_FREE( (char *) et );
                LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL,
                    NULL );
                return( -1 );
                }
                if ( vals != NULL ) {
                NSLDAPI_FREE( (char *)vals );
                }
            }
        }

        e = e->lm_chain;
    }
    last = e;

    et_cmp_fn = (LDAP_CHARCMP_CALLBACK *)cmp;
    XP_QSORT( (void *) et, (size_t) count,
        (size_t) sizeof(struct entrything), et_cmp );

    ep = chain;
    for ( i = 0; i < count; i++ ) {
        *ep = et[i].et_msg;
        ep = &(*ep)->lm_chain;

        ldap_value_free( et[i].et_vals );
    }
    *ep = last;
    NSLDAPI_FREE( (char *) et );

    return( 0 );
}

int
LDAP_CALL
ldap_sort_entries(
    LDAP    *ld,
    LDAPMessage **chain,
    char    *attr,      /* NULL => sort by DN */
    LDAP_CMP_CALLBACK *cmp
)
{
    char    *attrs[2];

    attrs[0] = attr;
    attrs[1] = NULL;
    return( ldap_multisort_entries( ld, chain, attr ? attrs : NULL, cmp ) );
}

int
LDAP_CALL
ldap_sort_values(
    LDAP    *ld,
    char    **vals,
    LDAP_VALCMP_CALLBACK *cmp
)
{
    int nel;

    if ( !NSLDAPI_VALID_LDAP_POINTER( ld ) || cmp == NULL ) {
        return( LDAP_PARAM_ERROR );
    }

    if ( NULL == vals)
    {
        LDAP_SET_LDERRNO( ld, LDAP_PARAM_ERROR, NULL, NULL );
        return( LDAP_PARAM_ERROR );
    }
    for ( nel = 0; vals[nel] != NULL; nel++ )
        ;   /* NULL */

    XP_QSORT( vals, nel, sizeof(char *), (LDAP_VOIDCMP_CALLBACK *)cmp );

    return( LDAP_SUCCESS );
}