/* Copyright (C) 2001 by First Peer, Inc. All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
** 1. Redistributions of source code must retain the above copyright
**    notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
**    derived from this software without specific prior written permission. 
**  
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
** SUCH DAMAGE.
**
** There is more copyright information in the bottom half of this file. 
** Please see it for more details. */


/*=========================================================================
**  XML-RPC Base64 Utilities
**=========================================================================
**  This code was swiped from Jack Jansen's code in Python 1.5.2 and
**  modified to work with our data types.
*/

#include "xmlrpc_config.h"

#include "xmlrpc-c/base.h"

#define CRLF    "\015\012"
#define CR      '\015'
#define LF      '\012'


/***********************************************************
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.

STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

******************************************************************/

static char table_a2b_base64[] = {
    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
    52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1, /* Note PAD->0 */
    -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
    15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
    -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
    41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
};

#define BASE64_PAD '='
#define BASE64_MAXBIN 57    /* Max binary chunk size (76 char line) */
#define BASE64_LINE_SZ 128      /* Buffer size for a single line. */    

static unsigned char table_b2a_base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static xmlrpc_mem_block *
xmlrpc_base64_encode_internal (xmlrpc_env *env,
                               unsigned char *bin_data,
                               size_t bin_len,
                               int want_newlines)
{
    size_t chunk_start, chunk_left;
    unsigned char *ascii_data;
    int leftbits;
    unsigned char this_ch;
    unsigned int leftchar;
    xmlrpc_mem_block *output;
    unsigned char line_buffer[BASE64_LINE_SZ];

    /* Create a block to hold our lines when we finish them. */
    output = xmlrpc_mem_block_new(env, 0);
    XMLRPC_FAIL_IF_FAULT(env);

    /* Deal with empty data blocks gracefully. Yuck. */
    if (bin_len == 0) {
        if (want_newlines)
            XMLRPC_TYPED_MEM_BLOCK_APPEND(char, env, output, CRLF, 2);
        goto cleanup;
    }

    /* Process our binary data in line-sized chunks. */
    for (chunk_start=0; chunk_start < bin_len; chunk_start += BASE64_MAXBIN) {

        /* Set up our per-line state. */
        ascii_data = &line_buffer[0];
        chunk_left = bin_len - chunk_start;
        if (chunk_left > BASE64_MAXBIN)
            chunk_left = BASE64_MAXBIN;
        leftbits = 0;
        leftchar = 0;

        for(; chunk_left > 0; chunk_left--, bin_data++) {
            /* Shift the data into our buffer */
            leftchar = (leftchar << 8) | *bin_data;
            leftbits += 8;

            /* See if there are 6-bit groups ready */
            while (leftbits >= 6) {
                this_ch = (leftchar >> (leftbits-6)) & 0x3f;
                leftbits -= 6;
                *ascii_data++ = table_b2a_base64[this_ch];
            }
        }
        if (leftbits == 2) {
            *ascii_data++ = table_b2a_base64[(leftchar&3) << 4];
            *ascii_data++ = BASE64_PAD;
            *ascii_data++ = BASE64_PAD;
        } else if (leftbits == 4) {
            *ascii_data++ = table_b2a_base64[(leftchar&0xf) << 2];
            *ascii_data++ = BASE64_PAD;
        } 

        /* Append a courtesy CRLF. */
        if (want_newlines) {
            *ascii_data++ = CR;
            *ascii_data++ = LF;
        }
    
        /* Save our line. */
        XMLRPC_TYPED_MEM_BLOCK_APPEND(char, env, output, line_buffer,
                                      ascii_data - &line_buffer[0]);
        XMLRPC_FAIL_IF_FAULT(env);
    }

 cleanup:
    if (env->fault_occurred) {
        if (output)
            xmlrpc_mem_block_free(output);
        return NULL;
    }
    return output;
}


xmlrpc_mem_block *
xmlrpc_base64_encode (xmlrpc_env *env, unsigned char *bin_data, size_t bin_len)
{
    return xmlrpc_base64_encode_internal(env, bin_data, bin_len, 1);
}


xmlrpc_mem_block *
xmlrpc_base64_encode_without_newlines (xmlrpc_env *env,
                                       unsigned char *bin_data,
                                       size_t bin_len)
{
    return xmlrpc_base64_encode_internal(env, bin_data, bin_len, 0);
}


xmlrpc_mem_block *
xmlrpc_base64_decode (xmlrpc_env * const env,
                      const char * const ascii_data,
                      size_t       const ascii_len) {

    unsigned char *bin_data;
    int leftbits;
    unsigned char this_ch;
    unsigned int leftchar;
    size_t npad;
    size_t bin_len, buffer_size;
    xmlrpc_mem_block *output;
    const char * next_char;
    size_t remaining_len;

    /* Create a block to hold our chunks when we finish them.
    ** We overestimate the size now, and fix it later. */
    buffer_size = ((ascii_len+3)/4)*3;
    output = xmlrpc_mem_block_new(env, buffer_size);
    XMLRPC_FAIL_IF_FAULT(env);

    /* Set up our decoder state. */
    leftbits = 0;
    leftchar = 0;
    npad = 0;
    bin_data = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(unsigned char, output);
    bin_len = 0;

    for (remaining_len = ascii_len, next_char = ascii_data;
         remaining_len > 0; 
         --remaining_len, ++next_char) {

        /* Skip some punctuation. */
        this_ch = (*next_char & 0x7f);
        if ( this_ch == '\r' || this_ch == '\n' || this_ch == ' ' )
            continue;
        if ( this_ch == BASE64_PAD )
            npad++;
        this_ch = table_a2b_base64[(*next_char) & 0x7f];

        /* XXX - We just throw away invalid characters. Is this right? */
        if ( this_ch == (unsigned char) -1 ) continue;

        /* Shift it in on the low end, and see if there's
        ** a byte ready for output. */
        leftchar = (leftchar << 6) | (this_ch);
        leftbits += 6;
        if ( leftbits >= 8 ) {
            leftbits -= 8;
            XMLRPC_ASSERT(bin_len < buffer_size);
            *bin_data++ = (leftchar >> leftbits) & 0xFF;
            leftchar &= ((1 << leftbits) - 1);
            bin_len++;
        }
    }

    /* Check that no bits are left. */
    if ( leftbits )
        XMLRPC_FAIL(env, XMLRPC_PARSE_ERROR, "Incorrect Base64 padding");

    /* Check to make sure we have a sane amount of padding. */
    if (npad > bin_len || npad > 2)
        XMLRPC_FAIL(env, XMLRPC_PARSE_ERROR, "Malformed Base64 data");

    /* Remove any padding and set the correct size. */
    bin_len -= npad;
    XMLRPC_TYPED_MEM_BLOCK_RESIZE(char, env, output, bin_len);
    XMLRPC_ASSERT(!env->fault_occurred);

                      cleanup:
    if (env->fault_occurred) {
        if (output)
            xmlrpc_mem_block_free(output);
        return NULL;
    }
    return output;
}
