128 lines
3.2 KiB
C
128 lines
3.2 KiB
C
/*
|
|
cencoder.c - c source to a base64 encoding algorithm implementation
|
|
|
|
This is part of the libb64 project, and has been placed in the public domain.
|
|
For details, see http://sourceforge.net/projects/libb64
|
|
*/
|
|
|
|
#include <b64/cencode.h>
|
|
|
|
const int CHARS_PER_LINE = 72;
|
|
|
|
void base64_init_encodestate(base64_encodestate* state_in)
|
|
{
|
|
state_in->flags = 0;
|
|
state_in->step = step_A;
|
|
state_in->stepcount = 0;
|
|
state_in->result = 0;
|
|
}
|
|
|
|
char base64_encode_value(char value_in)
|
|
{
|
|
static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
if (value_in > 63) return '=';
|
|
return encoding[(int)value_in];
|
|
}
|
|
|
|
/*
|
|
Output_size calculation from:
|
|
http://stackoverflow.com/questions/1533113/calculate-the-size-to-a-base-64-encoded-message
|
|
Never more than a byte larger than the actual encoded size.
|
|
Guaranteed equal to or larger than the actual encoded size.
|
|
*/
|
|
int base64_calc_buffer_length(int length_in, const base64_encodestate* state_in)
|
|
{
|
|
const int blockend_newline = ((BASE64_ENC_NO_NEWLINE_TERM & state_in->flags) == 0);
|
|
const int output_length = ((((length_in - 1) / 3) * 4) + 4);
|
|
return output_length + blockend_newline + (output_length / CHARS_PER_LINE);
|
|
}
|
|
|
|
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
|
|
{
|
|
int stepcount = state_in->stepcount;
|
|
const char* plainchar = plaintext_in;
|
|
const char* const plaintextend = plaintext_in + length_in;
|
|
char* codechar = code_out;
|
|
char result = state_in->result;
|
|
char fragment;
|
|
|
|
switch (state_in->step)
|
|
{
|
|
while (1)
|
|
{
|
|
case step_A:
|
|
if (plainchar == plaintextend)
|
|
{
|
|
state_in->step = step_A;
|
|
state_in->stepcount = stepcount;
|
|
state_in->result = result;
|
|
return codechar - code_out;
|
|
}
|
|
fragment = *plainchar++;
|
|
result = (fragment & 0x0fc) >> 2;
|
|
*codechar++ = base64_encode_value(result);
|
|
result = (fragment & 0x003) << 4;
|
|
case step_B:
|
|
if (plainchar == plaintextend)
|
|
{
|
|
state_in->step = step_B;
|
|
state_in->stepcount = stepcount;
|
|
state_in->result = result;
|
|
return codechar - code_out;
|
|
}
|
|
fragment = *plainchar++;
|
|
result |= (fragment & 0x0f0) >> 4;
|
|
*codechar++ = base64_encode_value(result);
|
|
result = (fragment & 0x00f) << 2;
|
|
case step_C:
|
|
if (plainchar == plaintextend)
|
|
{
|
|
state_in->step = step_C;
|
|
state_in->stepcount = stepcount;
|
|
state_in->result = result;
|
|
return codechar - code_out;
|
|
}
|
|
fragment = *plainchar++;
|
|
result |= (fragment & 0x0c0) >> 6;
|
|
*codechar++ = base64_encode_value(result);
|
|
result = (fragment & 0x03f) >> 0;
|
|
*codechar++ = base64_encode_value(result);
|
|
|
|
if (++stepcount == CHARS_PER_LINE/4)
|
|
{
|
|
*codechar++ = '\n';
|
|
stepcount = 0;
|
|
}
|
|
}
|
|
}
|
|
/* control should not reach here */
|
|
return codechar - code_out;
|
|
}
|
|
|
|
int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
|
|
{
|
|
char* codechar = code_out;
|
|
|
|
switch (state_in->step)
|
|
{
|
|
case step_B:
|
|
*codechar++ = base64_encode_value(state_in->result);
|
|
*codechar++ = '=';
|
|
*codechar++ = '=';
|
|
break;
|
|
case step_C:
|
|
*codechar++ = base64_encode_value(state_in->result);
|
|
*codechar++ = '=';
|
|
break;
|
|
case step_A:
|
|
break;
|
|
}
|
|
if ((BASE64_ENC_NO_NEWLINE_TERM & state_in->flags) == 0)
|
|
{
|
|
*codechar++ = '\n';
|
|
}
|
|
|
|
return codechar - code_out;
|
|
}
|
|
|