/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "ldap_util.h"
#include "ldap_glob.h"

static time_t   msgtime[MSG_LASTMSG] = {0};
static time_t   msgtimeout = 3600;

static pthread_key_t            tsdKey;

/*
 * Log a message to the appropriate place.
 */
void
logmsg(int msgtype, int priority, const char *fmt, ...) {
        va_list         ap;
        struct timeval  tp;

        /*
         * Only log LOG_INFO priority if 'verbose' is on, or if
         * msgtype is MSG_ALWAYS.
         */
        if (priority == LOG_INFO && !verbose && msgtype != MSG_ALWAYS)
                return;

        /* Make sure we don't log the same message too often */
        if (msgtype != MSG_NOTIMECHECK && msgtype != MSG_ALWAYS &&
                        msgtype > 0 && msgtype < MSG_LASTMSG &&
                        gettimeofday(&tp, 0) != -1) {
                if (tp.tv_sec - msgtime[msgtype] < msgtimeout)
                        return;
                msgtime[msgtype] = tp.tv_sec;
        }

        va_start(ap, fmt);
        if (cons == 0) {
                vsyslog(priority, fmt, ap);
        } else {
                int     flen = slen(fmt);

                vfprintf(cons, fmt, ap);
                /*
                 * If the last character in 'fmt' wasn't a '\n', write one
                 * to the console.
                 */
                if (flen > 0 && fmt[flen-1] != '\n')
                        fprintf(cons, "\n");
        }
        va_end(ap);
}

void
__destroyTsdKey(void *arg) {
        __nis_deferred_error_t  *defErr = arg;

        if (defErr != 0) {
                sfree(defErr->message);
                free(defErr);
        }
}

static void
__initTsdKey(void)
{
        (void) pthread_key_create(&tsdKey, __destroyTsdKey);
}
#pragma init(__initTsdKey)

void
reportError(int error, char *fmt, ...) {
        __nis_deferred_error_t  *defErr = pthread_getspecific(tsdKey);
        int                     doStore = (defErr == 0);
        char                    *myself = "reportError";
        va_list                 ap;
        __nis_buffer_t          b = {0, 0};

        if (defErr == 0 && (defErr = am(myself, sizeof (*defErr))) == 0)
                return;

        va_start(ap, fmt);
        b.len = vp2buf(myself, &b.buf, b.len, fmt, ap);
        va_end(ap);

        if (b.len > 0) {
                defErr->error = error;
                defErr->message = b.buf;
                if (doStore) {
                        int     ret = pthread_setspecific(tsdKey, defErr);
                        if (ret != 0) {
                                logmsg(MSG_TSDERR, LOG_ERR,
                                        "%s: pthread_setspecific() => %d",
                                        myself, ret);
                                sfree(b.buf);
                                free(defErr);
                        }
                }
        }
}

int
getError(char **message) {
        __nis_deferred_error_t  *defErr = pthread_getspecific(tsdKey);
        char                    *myself = "getError";

        if (defErr == 0) {
                if (message != 0)
                        *message = sdup(myself, T, "no TSD");
                return (NPL_TSDERR);
        }

        if (message != 0)
                *message = sdup(myself, T, defErr->message);

        return (defErr->error);
}

void
clearError(void) {
        __nis_deferred_error_t  *defErr = pthread_getspecific(tsdKey);

        if (defErr != 0) {
                sfree(defErr->message);
                defErr->message = 0;
                defErr->error = NPL_NOERROR;
        }
}

void
logError(int priority) {
        __nis_deferred_error_t  *defErr = pthread_getspecific(tsdKey);
        int                     msgtype;

        if (defErr != 0) {
                switch (defErr->error) {
                case NPL_NOERROR:
                        msgtype = MSG_LASTMSG;
                        break;
                case NPL_NOMEM:
                        msgtype = MSG_NOMEM;
                        break;
                case NPL_TSDERR:
                        msgtype = MSG_TSDERR;
                        break;
                case NPL_BERENCODE:
                case NPL_BERDECODE:
                        msgtype = MSG_BER;
                        break;
                default:
                        msgtype = MSG_LASTMSG;
                        break;
                }

                if (msgtype != MSG_LASTMSG) {
                        logmsg(msgtype, priority, defErr->message);
                }
        }
}

/*
 * Allocate zero-initialized memory of the specified 'size'. If the
 * allocation fails, log a message and return NULL. Allocation of
 * zero bytes is legal, and returns a NULL pointer.
 */
void *
am(const char *msg, int size) {
        void    *p;

        if (size > 0) {
                p = calloc(1, size);
                if (p == 0) {
                        if (msg == 0)
                                msg = "<unknown>";
                        logmsg(MSG_NOMEM, LOG_ERR, "%s: calloc(%d) => NULL\n",
                                msg, size);
                        return (0);
                }
        } else if (size == 0) {
                p = 0;
        } else {
                if (msg == 0)
                        msg = "<unknown>";
                logmsg(MSG_MEMPARAM, LOG_INFO, "%s: size (%d) < 0\n", size);
                exit(-1);
        }
        return (p);
}

/*
 * Return the length of a string, just like strlen(), but don't croak
 * on a NULL pointer.
 */
int
slen(const char *str) {
        return ((str != 0) ? strlen(str) : 0);
}

/*
 * If allocate==0, return 'str'; othewise, duplicate the string just
 * like strdup(), but don't die if 'str' is a NULL pointer.
 */
char *
sdup(const char *msg, int allocate, char *str) {
        char    *s;

        if (!allocate)
                return (str);

        if (str == 0) {
                s = strdup("");
        } else {
                s = strdup(str);
        }
        if (s == 0) {
                logmsg(MSG_NOMEM, LOG_ERR, "%s: strdup(%d bytes) => NULL\n",
                        (msg != 0) ? msg : "<unknown>", slen(str)+1);
        }
        return (s);
}

/*
 * Concatenate strings like strcat(), but don't expire if passed a
 * NULL pointer or two. If deallocate!=0, free() the input strings.
 */
char *
scat(const char *msg, int deallocate, char *s1, char *s2) {
        char    *n;
        int     l1 = 0, l2 = 0;

        if (s1 == 0) {
                n = sdup(msg, T, s2);
                if (deallocate)
                        sfree(s2);
                return (n);
        } else if (s2 == 0) {
                n = sdup(msg, T, s1);
                if (deallocate)
                        free(s1);
                return (n);
        }

        l1 = strlen(s1);
        l2 = strlen(s2);

        n = malloc(l1+l2+1);
        if (n != 0) {
                memcpy(n, s1, l1);
                memcpy(&n[l1], s2, l2);
                n[l1+l2] = '\0';
        } else {
                logmsg(MSG_NOMEM, LOG_ERR, "%s: malloc(%d) => NULL\n",
                        (msg != 0) ? msg : "<unknown>", l1+l2+1);
        }

        if (deallocate) {
                free(s1);
                free(s2);
        }

        return (n);
}

/* For debugging */
static void             *PTR = 0;

/*
 * Counters for memory errors. Note that we don't protect access,
 * so the values aren't entirely reliable in an MT application.
 */
ulong_t numMisaligned = 0;
ulong_t numNotActive = 0;

/* free() the input, but don't pass away if it's NULL */
void
sfree(void *ptr) {

        /* NULL pointer OK */
        if (ptr == 0)
                return;

        /*
         * For use in the debugger, when we need to detect free of a
         * certain address.
         */
        if (ptr == PTR)
                abort();

        /*
         * All addresses returned by malloc() and friends are "suitably
         * aligned for any use", so they should fall on eight-byte boundaries.
         */
        if (((unsigned long)ptr % 8) != 0) {
                numMisaligned++;
                return;
        }

#ifdef  NISDB_LDAP_DEBUG
        /*
         * Malloc:ed memory should have the length (four bytes), starting
         * eight bytes before the block, and with the least-significant
         * bit set.
         */
        if ((((uint_t *)ptr)[-2] & 0x1) == 0) {
                numNotActive++;
                return;
        }
#endif  /* NISDB_LDAP_DEBUG */

        /* Finally, we believe it's OK to free() the pointer */
        free(ptr);
}

/*
 * If a __nis_single_value_t represents a string, the length count may or may
 * not include a concluding NUL. Hence this function, which returns the last
 * non-NUL character of the value.
 */
char
lastChar(__nis_single_value_t *v) {
        char    *s;

        if (v == 0 || v->value == 0 || v->length < 2)
                return ('\0');

        s = v->value;
        if (s[v->length - 1] != '\0')
                return (s[v->length - 1]);
        else
                return (s[v->length - 2]);
}

void *
appendString2SingleVal(char *str, __nis_single_value_t *v, int *newLen) {
        void    *s;
        int     l, nl;
        char    *myself = "appendString2SingleVal";

        if (v == 0 || v->length < 0)
                return (0);

        /*
         * If 'str' is NULL or empty, just return NULL so that the caller
         * does nothing.
         */
        l = slen(str);
        if (l <= 0)
                return (0);

        s = am(myself, (nl = l + v->length) + 1);
        if (s == 0) {
                /* Caller does nothing; let's hope for the best... */
                return (0);
        }

        if (v->value != 0)
                memcpy(s, v->value, v->length);

        memcpy(&(((char *)s)[v->length]), str, l);

        if (newLen != 0)
                *newLen = nl;

        return (s);
}


/*
 * Do the equivalent of a strcmp() between a string and a string-valued
 * __nis_single_value_t.
 */
int
scmp(char *s, __nis_single_value_t *v) {

        if (s == 0)
                return (1);
        else if (v == 0 || v->value == 0 || v->length <= 0)
                return (-1);

        return (strncmp(s, v->value, v->length));
}

/*
 * Do the equivalent of a strcasecmp() between a string and a string-valued
 * __nis_single_value_t.
 */
int
scasecmp(char *s, __nis_single_value_t *v) {

        if (s == 0)
                return (1);
        else if (v == 0 || v->value == 0 || v->length <= 0)
                return (-1);

        return (strncasecmp(s, v->value, v->length));
}

#define STDBUFSIZE      81

/*
 * vsprintf the 'fmt' and 'ap' to a buffer, then concatenate the
 * result to '*buf'.
 */
int
vp2buf(const char *msg, char **buf, int buflen, const char *fmt, va_list ap) {
        char            *newbuf = am(msg, STDBUFSIZE);
        int             size = 0;

        if (newbuf == 0)
                return (0);

        if (buf == 0 || buflen < 0 || fmt == 0) {
                free(newbuf);
                return (0);
        }

        /* Find out how large the new buffer needs to be */
        size = vsnprintf(newbuf, STDBUFSIZE, fmt, ap);

        if (size > STDBUFSIZE) {
                free(newbuf);
                newbuf = am(msg, size+1);
                if (newbuf == 0)
                        return (0);
                size = vsnprintf(newbuf, size+1, fmt, ap);
        }

        *buf = scat(msg, T, *buf, newbuf);
        /* Don't count the NUL. This enables us to concatenate correctly */
        buflen += size;

        return (buflen);
}

/* Generic print buffer */
__nis_buffer_t  pb = {0, 0};

/* sprintf to the generic __nis_buffer_t */
void
p2buf(char *msg, char *fmt, ...) {
        va_list ap;

        va_start(ap, fmt);
        pb.len = vp2buf(msg, &pb.buf, pb.len, fmt, ap);
        va_end(ap);
}

/* sprintf to the specified __nis_buffer_t */
void
bp2buf(const char *msg, __nis_buffer_t *b, const char *fmt, ...) {
        va_list ap;

        va_start(ap, fmt);
        b->len = vp2buf(msg, &b->buf, b->len, fmt, ap);
        va_end(ap);
}

/* Copy 'buf' to the specified __nis_buffer_t */
void
bc2buf(const char *msg, void *buf, int len, __nis_buffer_t *b) {
        void    *new;

        /*
         * Make buffer one byte larger than the lenghts indicate. This
         * gives us room to append a NUL, so that we can mix string and
         * non-string copies into the buffer, and still end up with
         * something that can be sent to printf(), strcat(), etc.
         */
        new = realloc(b->buf, b->len+len+1);
        if (new != 0) {
                b->buf = new;
                memcpy(&(b->buf[b->len]), buf, len);
                b->len += len;
                /* Put a NUL at the end, just in case we printf() */
                if (b->len > 0 && b->buf[b->len-1] != '\0')
                        b->buf[b->len] = '\0';
        } else {
                logmsg(MSG_NOMEM, LOG_ERR, "%s: realloc(%d) => NULL\n",
                        (msg != 0) ? msg : "<unknown", b->len+len);
        }
}

/* Like bc2buf(), but remove any trailing NUL bytes */
void
sbc2buf(const char *msg, void *buf, int len, __nis_buffer_t *b) {
        if (buf == 0 || len <= 0 || b == 0)
                return;
        /* Snip off trailing NULs */
        while (len > 0 && ((char *)buf)[len-1] == '\0')
                len--;
        if (len <= 0)
                return;
        bc2buf(msg, buf, len, b);
}

/* Copy 'buf' to the generic __nis_buffer_t */
void
c2buf(char *msg, void *buf, int len) {
        bc2buf(msg, buf, len, &pb);
}

/* Like c2buf(), but remove trailing NUL bytes */
void
sc2buf(char *msg, void *buf, int len) {
        sbc2buf(msg, buf, len, &pb);
}

/* How many times we try write(2) if it fails */
#define MAXTRY  10

/* Output the generic __nis_buffer_t to stdout */
void
printbuf(void) {
        int     maxtry = MAXTRY, len = pb.len;

        if (pb.buf != 0) {
                int     tmp;

                while (len > 0 && maxtry > 0) {
                        tmp = write(1, pb.buf, len);
                        if (tmp < 0)
                                break;
                        len -= tmp;
                        if (tmp > 0)
                                maxtry = MAXTRY;
                        else
                                maxtry--;
                }
                free(pb.buf);
                pb.buf = 0;
        }
        pb.len = 0;
}

void *
extendArray(void *array, int newsize) {
        void    *new = realloc(array, newsize);
        if (new == 0)
                sfree(array);
        return (new);
}

/*
 * Determine if the given string is an IP address (IPv4 or IPv6).
 * If so, it converts it to the format as required by rfc2307bis
 * and *newaddr will point to the new Address.
 *
 * Returns      -2              : error
 *              -1              : not an IP address
 *              0               : IP address not supported by rfc2307bis
 *              AF_INET         : IPv4
 *              AF_INET6        : IPv6
 */
int
checkIPaddress(char *addr, int len, char **newaddr) {
        ipaddr_t        addr_ipv4;
        in6_addr_t      addr_ipv6;
        char            *buffer;
        int             s, e;
        char            *myself = "checkIPaddress";

        /* skip leading whitespaces */
        for (s = 0; (s < len) && (addr[s] == ' ' || addr[s] == '\t'); s++);
        if (s >= len)
                return (-1);

        /* skip trailing whitespaces */
        for (e = len - 1; (e > s) && (addr[e] == ' ' || addr[e] == '\t'); e--);
        if (s == e)
                return (-1);

        /* adjust len */
        len = e - s + 1;

        if ((buffer = am(myself, len + 1)) == 0)
                return (-2);
        (void) memcpy(buffer, addr + s, len);

        if (inet_pton(AF_INET6, buffer, &addr_ipv6) == 1) {
                sfree(buffer);
                /*
                 * IPv4-compatible IPv6 address and IPv4-mapped
                 * IPv6 addresses not allowed by rfc2307bis
                 */
                if (IN6_IS_ADDR_V4COMPAT(&addr_ipv6))
                        return (0);
                if (IN6_IS_ADDR_V4MAPPED(&addr_ipv6))
                        return (0);
                if (newaddr == 0)
                        return (AF_INET6);
                if ((*newaddr = am(myself, INET6_ADDRSTRLEN)) == 0)
                        return (-2);
                if (inet_ntop(AF_INET6, &addr_ipv6, *newaddr, INET6_ADDRSTRLEN))
                        return (AF_INET6);
                sfree(*newaddr);
                return (-2);
        }

        if (inet_pton(AF_INET, buffer, &addr_ipv4) == 1) {
                sfree(buffer);
                if (newaddr == 0)
                        return (AF_INET);
                if ((*newaddr = am(myself, INET_ADDRSTRLEN)) == 0)
                        return (-2);
                if (inet_ntop(AF_INET, &addr_ipv4, *newaddr, INET_ADDRSTRLEN))
                        return (AF_INET);
                sfree(*newaddr);
                return (-2);
        }

        sfree(buffer);
        return (-1);
}

int
sstrncmp(const char *s1, const char *s2, int n) {
        if (s1 == 0 && s2 == 0)
                return (0);

        if (s1 == 0)
                return (1);

        if (s2 == 0)
                return (-1);

        return (strncmp(s1, s2, n));
}

/*
 * Does the following:
 * - Trims leading and trailing whitespaces
 * - Collapses two or more whitespaces into one space
 * - Converts all whitespaces into spaces
 * - At entrance, *len contains length of str
 * - At exit, *len will contain length of the return string
 * - In case of mem alloc failure, *len should be ignored
 */
char *
trimWhiteSpaces(char *str, int *len, int deallocate) {
        char    *ostr;
        int     olen = 0;
        int     first = 1, i;
        char    *myself = "trimWhiteSpaces";

        if ((ostr = am(myself, *len + 1)) == 0) {
                if (deallocate)
                        sfree(str);
                *len = 0;
                return (0);
        }

        /* Skip leading whitespaces */
        for (i = 0; i < *len && (str[i] == ' ' || str[i] == '\t'); i++);

        /* Collapse multiple whitespaces into one */
        for (; i < *len; i++) {
                if (str[i] == ' ' || str[i] == '\t') {
                        if (first) {
                                first = 0;
                                ostr[olen++] = ' ';
                        }
                        continue;
                }
                first = 1;
                ostr[olen++] = str[i];
        }

        /* Handle the trailing whitespace if any */
        if (olen && ostr[olen - 1] == ' ') {
                        olen--;
                        ostr[olen] = 0;
        }

        if (deallocate)
                        sfree(str);

        *len = olen;
        return (ostr);
}

/*
 * Escapes special characters in DN using the list from RFC 2253
 */
int
escapeSpecialChars(__nis_value_t *val) {
        int     i, j, k, count;
        char    *newval, *s;
        char    *myself = "escapeSpecialChars";

        /* Assume val is always non NULL */

        for (i = 0; i < val->numVals; i++) {
                /*
                 * Count the special characters in value to determine
                 * the length for the new value
                 */
                s = val->val[i].value;
                for (j = 0, count = 0; j < val->val[i].length; j++, s++) {
                        if (*s == '#' || *s == ',' || *s == '+' || *s == '"' ||
                        *s == '\\' || *s == '<' || *s == '>' || *s == ';')
                                count++;
                }
                if (count == 0)
                        continue;

                if ((newval = am(myself, val->val[i].length + count + 1)) == 0)
                        return (-1);

                /* Escape the special characters using '\\' */
                s = val->val[i].value;
                for (j = 0, k = 0; j < val->val[i].length; j++, k++, s++) {
                        if (*s == '#' || *s == ',' || *s == '+' || *s == '"' ||
                        *s == '\\' || *s == '<' || *s == '>' || *s == ';')
                                newval[k++] = '\\';
                        newval[k] = *s;
                }

                sfree(val->val[i].value);
                val->val[i].value = newval;
                val->val[i].length += count;
        }

        return (1);
}

/*
 * Remove escape characters from DN returned by LDAP server
 */
void
removeEscapeChars(__nis_value_t *val) {
        int     i;
        char    *s, *d, *end;


        for (i = 0; i < val->numVals; i++) {
                s = val->val[i].value;
                end = s + val->val[i].length;

                /*
                 * This function is called frequently and for most entries
                 * there will be no escapes. Process rapidly up to first escape.
                 */
                for (d = s; s < end;  s++, d++) {
                        if (*s == '\\')
                                break;
                }

                /*
                 * Reached the end, in which case will not go into loop,
                 * or found an escape and now have to start moving data.
                 */
                for (; s < end;  s++) {
                        if (*s == '\\') {
                                val->val[i].length--;
                                /*
                                 * Next character gets coppied without being
                                 * checked
                                 */
                                s++;
                                if (s >= end)
                                        break;
                        }

                        *d = *s;
                        d++;
                }
        }
}