/*
 * -*- 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
 * http://www.mozilla.org/NPL/
 *
 * 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.
 */

/*
 * Copyright (c) 1990 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.
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <ber_der.h>
#include "kmfber_int.h"

#define EXBUFSIZ        1024

/*
 * Note: kmfber_read() only uses the ber_end and ber_ptr elements of ber.
 * Functions like kmfber_get_tag(), kmfber_skip_tag, and kmfber_peek_tag()
 * rely on that fact, so if this code is changed to use any additional
 * elements of the ber structure, those functions will need to be changed
 * as well.
 */
ber_int_t
kmfber_read(BerElement *ber, char *buf, ber_len_t len)
{
        size_t  actuallen;
        size_t  nleft;

        nleft = ber->ber_end - ber->ber_ptr;
        actuallen = nleft < len ? nleft : len;

        (void) memmove(buf, ber->ber_ptr, (size_t)actuallen);

        ber->ber_ptr += actuallen;

        return ((ber_int_t)actuallen);
}

/*
 * enlarge the ber buffer.
 * return 0 on success, -1 on error.
 */
int
kmfber_realloc(BerElement *ber, ber_len_t len)
{
        ber_uint_t      need, have, total;
        size_t          have_bytes;
        Seqorset        *s;
        size_t          off;
        char            *oldbuf;

        have_bytes = ber->ber_end - ber->ber_buf;
        have = have_bytes / EXBUFSIZ;
        need = (len < EXBUFSIZ ? 1 : (len + (EXBUFSIZ - 1)) / EXBUFSIZ);
        total = have * EXBUFSIZ + need * EXBUFSIZ;

        oldbuf = ber->ber_buf;

        if (ber->ber_buf == NULL) {
                if ((ber->ber_buf = (char *)malloc((size_t)total))
                    == NULL) {
                        return (-1);
                }
                ber->ber_flags &= ~KMFBER_FLAG_NO_FREE_BUFFER;
        } else {
                if (ber->ber_flags & KMFBER_FLAG_NO_FREE_BUFFER) {
                        /* transition to malloc'd buffer */
                        if ((ber->ber_buf = (char *)malloc(
                            (size_t)total)) == NULL) {
                                return (-1);
                        }
                        ber->ber_flags &= ~KMFBER_FLAG_NO_FREE_BUFFER;

                        /* copy existing data into new malloc'd buffer */
                        (void) memmove(ber->ber_buf, oldbuf, have_bytes);
                } else {
                        if ((ber->ber_buf = (char *)realloc(
                            oldbuf, (size_t)total)) == NULL) {
                                free(oldbuf);
                                return (-1);
                        }
                }
        }

        ber->ber_end = ber->ber_buf + total;

        /*
         * If the stinking thing was moved, we need to go through and
         * reset all the sos and ber pointers.  Offsets would've been
         * a better idea... oh well.
         */
        if (ber->ber_buf != oldbuf) {
                ber->ber_ptr = ber->ber_buf + (ber->ber_ptr - oldbuf);

                for (s = ber->ber_sos; s != NULLSEQORSET; s = s->sos_next) {
                        off = s->sos_first - oldbuf;
                        s->sos_first = ber->ber_buf + off;

                        off = s->sos_ptr - oldbuf;
                        s->sos_ptr = ber->ber_buf + off;
                }
        }

        return (0);
}

/*
 * returns "len" on success and -1 on failure.
 */
ber_int_t
kmfber_write(BerElement *ber, char *buf, ber_len_t len, int nosos)
{
        if (nosos || ber->ber_sos == NULL) {
                if (ber->ber_ptr + len > ber->ber_end) {
                        if (kmfber_realloc(ber, len) != 0)
                                return (-1);
                }
                (void) memmove(ber->ber_ptr, buf, (size_t)len);
                ber->ber_ptr += len;
                return (len);
        } else {
                if (ber->ber_sos->sos_ptr + len > ber->ber_end) {
                        if (kmfber_realloc(ber, len) != 0)
                                return (-1);
                }
                (void) memmove(ber->ber_sos->sos_ptr, buf, (size_t)len);
                ber->ber_sos->sos_ptr += len;
                ber->ber_sos->sos_clen += len;
                return (len);
        }
}

void
kmfber_free(BerElement *ber, int freebuf)
{
        if (ber != NULL) {
                if (freebuf &&
                    !(ber->ber_flags & KMFBER_FLAG_NO_FREE_BUFFER))
                        free(ber->ber_buf);
                free((char *)ber);
        }
}

/* we pre-allocate a buffer to save the extra malloc later */
BerElement *
kmfber_alloc_t(int options)
{
        BerElement      *ber;

        if ((ber = (BerElement*)calloc(1,
            sizeof (struct berelement) + EXBUFSIZ)) == NULL) {
                return (NULL);
        }

        ber->ber_tag = KMFBER_DEFAULT;
        ber->ber_options = options;
        ber->ber_buf = (char *)ber + sizeof (struct berelement);
        ber->ber_ptr = ber->ber_buf;
        ber->ber_end = ber->ber_buf + EXBUFSIZ;
        ber->ber_flags = KMFBER_FLAG_NO_FREE_BUFFER;

        return (ber);
}


BerElement *
kmfber_alloc()
{
        return (kmfber_alloc_t(0));
}

BerElement *
kmfder_alloc()
{
        return (kmfber_alloc_t(KMFBER_OPT_USE_DER));
}

BerElement *
kmfber_dup(BerElement *ber)
{
        BerElement      *new;

        if ((new = kmfber_alloc()) == NULL)
                return (NULL);

        *new = *ber;

        return (new);
}


void
ber_init_w_nullchar(BerElement *ber, int options)
{
        (void) memset((char *)ber, '\0', sizeof (struct berelement));
        ber->ber_tag = KMFBER_DEFAULT;

        ber->ber_options = options;
}


void
kmfber_reset(BerElement *ber, int was_writing)
{
        if (was_writing) {
                ber->ber_end = ber->ber_ptr;
                ber->ber_ptr = ber->ber_buf;
        } else {
                ber->ber_ptr = ber->ber_end;
        }

        ber->ber_rwptr = NULL;
}


#ifdef KMFBER_DEBUG

void
ber_dump(BerElement *ber, int inout)
{
        char msg[128];
        sprintf(msg, "ber_dump: buf 0x%lx, ptr 0x%lx, rwptr 0x%lx, end 0x%lx\n",
            ber->ber_buf, ber->ber_ptr, ber->ber_rwptr, ber->ber_end);
        ber_err_print(msg);
        if (inout == 1) {
                sprintf(msg, "          current len %ld, contents:\n",
                    ber->ber_end - ber->ber_ptr);
                ber_err_print(msg);
                lber_bprint(ber->ber_ptr, ber->ber_end - ber->ber_ptr);
        } else {
                sprintf(msg, "          current len %ld, contents:\n",
                    ber->ber_ptr - ber->ber_buf);
                ber_err_print(msg);
                lber_bprint(ber->ber_buf, ber->ber_ptr - ber->ber_buf);
        }
}

void
ber_sos_dump(Seqorset *sos)
{
        char msg[80];
        ber_err_print("*** sos dump ***\n");
        while (sos != NULLSEQORSET) {
                sprintf(msg, "ber_sos_dump: clen %ld first 0x%lx ptr 0x%lx\n",
                    sos->sos_clen, sos->sos_first, sos->sos_ptr);
                ber_err_print(msg);
                sprintf(msg, "              current len %ld contents:\n",
                    sos->sos_ptr - sos->sos_first);
                ber_err_print(msg);
                lber_bprint(sos->sos_first, sos->sos_ptr - sos->sos_first);

                sos = sos->sos_next;
        }
        ber_err_print("*** end dump ***\n");
}

#endif

/* new dboreham code below: */
struct byte_buffer  {
        unsigned char *p;
        int offset;
        int length;
};
typedef struct byte_buffer byte_buffer;

/*
 * The kmfber_flatten routine allocates a struct berval whose contents
 * are a BER encoding taken from the ber argument. The bvPtr pointer
 * points to the returned berval, which must be freed using
 * kmfber_bvfree().  This routine returns 0 on success and -1 on error.
 * The use of kmfber_flatten on a BerElement in which all '{' and '}'
 * format modifiers have not been properly matched can result in a
 * berval whose contents are not a valid BER encoding.
 * Note that the ber_ptr is not modified.
 */
int
kmfber_flatten(BerElement *ber, struct berval **bvPtr)
{
        struct berval *new;
        ber_len_t len;

        /* allocate a struct berval */
        new = (struct berval *)malloc((size_t)(sizeof (struct berval)));
        if (new == NULL) {
                return (-1);
        }
        (void) memset(new, 0, sizeof (struct berval));

        /*
         * Copy everything from the BerElement's ber_buf to ber_ptr
         * into the berval structure.
         */
        if (ber == NULL) {
                new->bv_val = NULL;
                new->bv_len = 0;
        } else {
                len = ber->ber_ptr - ber->ber_buf;
                new->bv_val = (char *)malloc((size_t)(len + 1));
                if (new->bv_val == NULL) {
                        kmfber_bvfree(new);
                        return (-1);
                }
                (void) memmove(new->bv_val, ber->ber_buf, (size_t)len);
                new->bv_val[len] = '\0';
                new->bv_len = len;
        }

        /* set bvPtr pointer to point to the returned berval */
        *bvPtr = new;

        return (0);
}

BerElement *
kmfder_init(const struct berval *bv)
{
        BerElement *ber;

        /* construct BerElement */
        if ((ber = kmfber_alloc_t(KMFBER_OPT_USE_DER)) != NULL) {
                /* copy data from the bv argument into BerElement */
                /* XXXmcs: had to cast unsigned long bv_len to long */
                if ((kmfber_write(ber, bv->bv_val, bv->bv_len, 0)) !=
                    (ber_slen_t)bv->bv_len) {
                        kmfber_free(ber, 1);
                        return (NULL);
                }
        }
        /*
         * reset ber_ptr back to the beginning of buffer so that this new
         * and initialized ber element can be READ
         */
        kmfber_reset(ber, 1);

        /*
         * return a ptr to a new BerElement containing a copy of the data
         * in the bv argument or a null pointer on error
         */
        return (ber);
}

BerElement *
kmfber_init(const struct berval *bv)
{
        BerElement *ber;

        /* construct BerElement */
        if ((ber = kmfber_alloc_t(0)) != NULL) {
                /* copy data from the bv argument into BerElement */
                /* XXXmcs: had to cast unsigned long bv_len to long */
                if ((kmfber_write(ber, bv->bv_val, bv->bv_len, 0)) !=
                    (ber_slen_t)bv->bv_len) {
                        kmfber_free(ber, 1);
                        return (NULL);
                }
        }
        /*
         * reset ber_ptr back to the beginning of buffer so that this new
         * and initialized ber element can be READ
         */
        kmfber_reset(ber, 1);

        /*
         * return a ptr to a new BerElement containing a copy of the data
         * in the bv argument or a null pointer on error
         */
        return (ber);
}