118 lines
2.8 KiB
C
118 lines
2.8 KiB
C
|
|
/**
|
|
* `decode.c' - b64
|
|
*
|
|
* copyright (c) 2014 joseph werle
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include "b64.h"
|
|
|
|
#ifdef b64_USE_CUSTOM_MALLOC
|
|
extern void* b64_malloc(size_t);
|
|
#endif
|
|
|
|
#ifdef b64_USE_CUSTOM_REALLOC
|
|
extern void* b64_realloc(void*, size_t);
|
|
#endif
|
|
|
|
unsigned char *
|
|
b64_decode (const char *src, size_t len) {
|
|
return b64_decode_ex(src, len, NULL);
|
|
}
|
|
|
|
unsigned char *
|
|
b64_decode_ex (const char *src, size_t len, size_t *decsize) {
|
|
int i = 0;
|
|
int j = 0;
|
|
int l = 0;
|
|
size_t size = 0;
|
|
b64_buffer_t decbuf;
|
|
unsigned char buf[3];
|
|
unsigned char tmp[4];
|
|
|
|
// alloc
|
|
if (b64_buf_malloc(&decbuf) == -1) { return NULL; }
|
|
|
|
// parse until end of source
|
|
while (len--) {
|
|
// break if char is `=' or not base64 char
|
|
if ('=' == src[j]) { break; }
|
|
if (!(isalnum(src[j]) || '+' == src[j] || '/' == src[j])) { break; }
|
|
|
|
// read up to 4 bytes at a time into `tmp'
|
|
tmp[i++] = src[j++];
|
|
|
|
// if 4 bytes read then decode into `buf'
|
|
if (4 == i) {
|
|
// translate values in `tmp' from table
|
|
for (i = 0; i < 4; ++i) {
|
|
// find translation char in `b64_table'
|
|
for (l = 0; l < 64; ++l) {
|
|
if (tmp[i] == b64_table[l]) {
|
|
tmp[i] = l;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// decode
|
|
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
|
|
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
|
|
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
|
|
|
|
// write decoded buffer to `decbuf.ptr'
|
|
if (b64_buf_realloc(&decbuf, size + 3) == -1) return NULL;
|
|
for (i = 0; i < 3; ++i) {
|
|
((unsigned char*)decbuf.ptr)[size++] = buf[i];
|
|
}
|
|
|
|
// reset
|
|
i = 0;
|
|
}
|
|
}
|
|
|
|
// remainder
|
|
if (i > 0) {
|
|
// fill `tmp' with `\0' at most 4 times
|
|
for (j = i; j < 4; ++j) {
|
|
tmp[j] = '\0';
|
|
}
|
|
|
|
// translate remainder
|
|
for (j = 0; j < 4; ++j) {
|
|
// find translation char in `b64_table'
|
|
for (l = 0; l < 64; ++l) {
|
|
if (tmp[j] == b64_table[l]) {
|
|
tmp[j] = l;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// decode remainder
|
|
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
|
|
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
|
|
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
|
|
|
|
// write remainer decoded buffer to `decbuf.ptr'
|
|
if (b64_buf_realloc(&decbuf, size + (i - 1)) == -1) return NULL;
|
|
for (j = 0; (j < i - 1); ++j) {
|
|
((unsigned char*)decbuf.ptr)[size++] = buf[j];
|
|
}
|
|
}
|
|
|
|
// Make sure we have enough space to add '\0' character at end.
|
|
if (b64_buf_realloc(&decbuf, size + 1) == -1) return NULL;
|
|
((unsigned char*)decbuf.ptr)[size] = '\0';
|
|
|
|
// Return back the size of decoded string if demanded.
|
|
if (decsize != NULL) {
|
|
*decsize = size;
|
|
}
|
|
|
|
return (unsigned char*) decbuf.ptr;
|
|
}
|