/*
 * 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 );
}