base64.c File Reference

#include <sys/types.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "assert.h"
#include "utils.h"

Go to the source code of this file.

Functions
int	b64_encode (const void *_src, size_t srclength, void *dest, size_t targsize)
int	b64_decode (const void *_src, void *dest, size_t targsize)

Variables
static const char	Base64 []
static const char	Pad64 = '='

Function Documentation

b64_decode()

int b64_decode	(	const void *	_src,
		void *	dest,
		size_t	targsize
	)

Definition at line 203 of file base64.c.

{
        const char *src = _src;
        unsigned char *target = dest;
        int state, ch;
        size_t tarindex;
        u_char nextbyte;
        char *pos;
 
        state = 0;
        tarindex = 0;
 
        assert(dest && targsize > 0);
 
        while ((ch = (unsigned char)*src++) != '\0') {
                if (isspace(ch))        /* Skip whitespace anywhere. */
                        continue;
 
                if (ch == Pad64)
                        break;
 
                pos = strchr(Base64, ch);
                if (pos == 0)           /* A non-base64 character. */
                        return (-1);
 
                switch (state) {
                case 0:
                        if (target) {
                                if (tarindex >= targsize)
                                        return (-1);
                                target[tarindex] = (pos - Base64) << 2;
                        }
                        state = 1;
                        break;
                case 1:
                        if (target) {
                                if (tarindex >= targsize)
                                        return (-1);
                                target[tarindex]   |=  (pos - Base64) >> 4;
                                nextbyte = ((pos - Base64) & 0x0f) << 4;
                                if (tarindex + 1 < targsize)
                                        target[tarindex+1] = nextbyte;
                                else if (nextbyte)
                                        return (-1);
                        }
                        tarindex++;
                        state = 2;
                        break;
                case 2:
                        if (target) {
                                if (tarindex >= targsize)
                                        return (-1);
                                target[tarindex]   |=  (pos - Base64) >> 2;
                                nextbyte = ((pos - Base64) & 0x03) << 6;
                                if (tarindex + 1 < targsize)
                                        target[tarindex+1] = nextbyte;
                                else if (nextbyte)
                                        return (-1);
                        }
                        tarindex++;
                        state = 3;
                        break;
                case 3:
                        if (target) {
                                if (tarindex >= targsize)
                                        return (-1);
                                target[tarindex] |= (pos - Base64);
                        }
                        tarindex++;
                        state = 0;
                        break;
                }
        }
 
        /*
         * We are done decoding Base-64 chars.  Let's see if we ended
         * on a byte boundary, and/or with erroneous trailing characters.
         */
 
        if (ch == Pad64) {                      /* We got a pad char. */
                ch = (unsigned char)*src++;     /* Skip it, get next. */
                switch (state) {
                case 0:         /* Invalid = in first position */
                case 1:         /* Invalid = in second position */
                        return (-1);
 
                case 2:         /* Valid, means one byte of info */
                        /* Skip any number of spaces. */
                        for (; ch != '\0'; ch = (unsigned char)*src++)
                                if (!isspace(ch))
                                        break;
                        /* Make sure there is another trailing = sign. */
                        if (ch != Pad64)
                                return (-1);
                        ch = (unsigned char)*src++;             /* Skip the = */
                        /* Fall through to "single trailing =" case. */
                        /* FALLTHROUGH */
 
                case 3:         /* Valid, means two bytes of info */
                        /*
                         * We know this char is an =.  Is there anything but
                         * whitespace after it?
                         */
                        for (; ch != '\0'; ch = (unsigned char)*src++)
                                if (!isspace(ch))
                                        return (-1);
 
                        /*
                         * Now make sure for cases 2 and 3 that the "extra"
                         * bits that slopped past the last full byte were
                         * zeros.  If we don't check them, they become a
                         * subliminal channel.
                         */
                        if (target && tarindex < targsize &&
                            target[tarindex] != 0)
                                return (-1);
                }
        } else {
                /*
                 * We ended by seeing the end of the string.  Make sure we
                 * have no partial bytes lying around.
                 */
                if (state != 0)
                        return (-1);
        }
 
        /* Null-terminate if we have room left */
        if (tarindex < targsize)
                target[tarindex] = 0;
 
        return (tarindex);
}

Here is the caller graph for this function:

b64_encode()

int b64_encode	(	const void *	_src,
		size_t	srclength,
		void *	dest,
		size_t	targsize
	)

Definition at line 139 of file base64.c.

{
        const unsigned char *src = _src;
        char *target = dest;
        size_t datalength = 0;
        u_char input[3] = {0};
        u_char output[4];
        size_t i;
 
        assert(dest && targsize > 0);
 
        while (2 < srclength) {
                input[0] = *src++;
                input[1] = *src++;
                input[2] = *src++;
                srclength -= 3;
 
                output[0] = input[0] >> 2;
                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
                output[3] = input[2] & 0x3f;
 
                if (datalength + 4 > targsize)
                        return (-1);
                target[datalength++] = Base64[output[0]];
                target[datalength++] = Base64[output[1]];
                target[datalength++] = Base64[output[2]];
                target[datalength++] = Base64[output[3]];
        }
 
        /* Now we worry about padding. */
        if (0 != srclength) {
                /* Get what's left. */
                input[0] = input[1] = input[2] = '\0';
                for (i = 0; i < srclength; i++)
                        input[i] = *src++;
 
                output[0] = input[0] >> 2;
                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
 
                if (datalength + 4 > targsize)
                        return (-1);
                target[datalength++] = Base64[output[0]];
                target[datalength++] = Base64[output[1]];
                if (srclength == 1)
                        target[datalength++] = Pad64;
                else
                        target[datalength++] = Base64[output[2]];
                target[datalength++] = Pad64;
        }
        if (datalength >= targsize)
                return (-1);
        target[datalength] = '\0';      /* Returned value doesn't count \0. */
        return (datalength);
}

Here is the caller graph for this function:

Variable Documentation

Base64

const char Base64[]

static

Initial value:

=
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 72 of file base64.c.

Pad64

const char Pad64 = '='

static

Definition at line 74 of file base64.c.