static int
base64_encode_blockend(char *out_base64, int out_len,
struct base64_encodestate *state)
{
char *out_pos = out_base64;
char *out_end = out_base64 + out_len;
switch (state->step) {
case step_B:
if (out_pos + 2 >= out_end)
return out_pos - out_base64;
*out_pos++ = base64_encode_value(state->result);
*out_pos++ = '=';
*out_pos++ = '=';
break;
case step_C:
if (out_pos + 1 >= out_end)
return out_pos - out_base64;
*out_pos++ = base64_encode_value(state->result);
*out_pos++ = '=';
break;
case step_A:
break;
}
if (out_pos >= out_end)
return out_pos - out_base64;
#if 0
/* Sometimes the output is useful without a newline. */
*out_pos++ = '\n';
if (out_pos >= out_end)
return out_pos - out_base64;
#endif
*out_pos = '\0';
return out_pos - out_base64;
}
int base64_encode_block(char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
{
char* plainchar = plaintext_in;
char* plaintextend = plaintext_in + length_in;
char* codechar = code_out;
char result;
char fragment;
result = state_in->result;
switch (state_in->step)
{
while (1)
{
case step_A:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_A;
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->result = result;
state_in->step = step_B;
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->result = result;
state_in->step = step_C;
return codechar - code_out;
}
fragment = *plainchar++;
result |= (fragment & 0x0c0) >> 6;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x03f) >> 0;
*codechar++ = base64_encode_value(result);
++(state_in->stepcount);
if (state_in->stepcount == CHARS_PER_LINE/4)
{
*codechar++ = '\n';
state_in->stepcount = 0;
}
}
}
/* control should not reach here */
return codechar - code_out;
}
size_t base64_encode_blockend(void* 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 (state_in->chars_per_line > 0)
{
*codechar++ = '\n';
}
return codechar - (char*)code_out;
}
int base64_encode_blockend(char* code_out, int newLineEnabled, 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( newLineEnabled )
{
*codechar++ = '\n';
}
return codechar - code_out;
}
int base64_encode_blockend(char* code_out, base64_encodestate* state_in, int with_newline)
{
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 (with_newline) { // added by ajc on 2016jan22, normally citadel doesn't want this
*codechar++ = '\r';
*codechar++ = '\n';
}
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;
}
*codechar = 0x00;
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;
}
// *codechar++ = '\n'; commit by xxseekerj
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;
}
#ifdef B64_FANCY_OUTPUT
*codechar++ = '\n';
#endif
return (int) (codechar - code_out);
}
size_t base64_encode_block(const uint8_t* plaintext_in, size_t length_in, void* code_out,
base64_encodestate* state_in)
{
const uint8_t* plainchar = plaintext_in;
const uint8_t* const plaintextend = plaintext_in + length_in;
char* codechar = code_out;
char result;
char fragment;
result = state_in->result;
switch (state_in->step)
{
while (1)
{
case step_A:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_A;
return codechar - (char*)code_out;
}
fragment = *plainchar++;
result = (fragment & 0x0fc) >> 2;
*codechar++ = base64_encode_value(result);
result = (char)((fragment & 0x003) << 4);
case step_B:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_B;
return codechar - (char*)code_out;
}
fragment = *plainchar++;
result |= (fragment & 0x0f0) >> 4;
*codechar++ = base64_encode_value(result);
result = (char)((fragment & 0x00f) << 2);
case step_C:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_C;
return codechar - (char*)code_out;
}
fragment = *plainchar++;
result |= (fragment & 0x0c0) >> 6;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x03f) >> 0;
*codechar++ = base64_encode_value(result);
if (state_in->chars_per_line > 0)
{
++(state_in->stepcount);
if (state_in->stepcount == state_in->chars_per_line/4)
{
*codechar++ = '\n';
state_in->stepcount = 0;
}
}
}
}
/* control should not reach here */
return codechar - (char*)code_out;
}
static int
base64_encode_block(const char *in_bin, int in_len,
char *out_base64, int out_len,
struct base64_encodestate *state)
{
const char *const in_end = in_bin + in_len;
const char *in_pos = in_bin;
char *out_pos = out_base64;
char *out_end = out_base64 + out_len;
char result;
char fragment;
result = state->result;
switch (state->step)
{
while (1)
{
case step_A:
if (in_pos == in_end || out_pos >= out_end) {
state->result = result;
state->step = step_A;
return out_pos - out_base64;
}
fragment = *in_pos++;
result = (fragment & 0x0fc) >> 2;
*out_pos++ = base64_encode_value(result);
result = (fragment & 0x003) << 4;
case step_B:
if (in_pos == in_end || out_pos >= out_end) {
state->result = result;
state->step = step_B;
return out_pos - out_base64;
}
fragment = *in_pos++;
result |= (fragment & 0x0f0) >> 4;
*out_pos++ = base64_encode_value(result);
result = (fragment & 0x00f) << 2;
case step_C:
if (in_pos == in_end || out_pos + 2 >= out_end) {
state->result = result;
state->step = step_C;
return out_pos - out_base64;
}
fragment = *in_pos++;
result |= (fragment & 0x0c0) >> 6;
*out_pos++ = base64_encode_value(result);
result = (fragment & 0x03f) >> 0;
*out_pos++ = base64_encode_value(result);
/*
* Each full step (A->B->C) yields
* 4 characters.
*/
if (++state->stepcount * 4 == BASE64_CHARS_PER_LINE) {
if (out_pos >= out_end)
return out_pos - out_base64;
*out_pos++ = '\n';
state->stepcount = 0;
}
}
}
/* control should not reach here */
return out_pos - out_base64;
}
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
{
const char* plainchar = plaintext_in;
const char* const plaintextend = plaintext_in + length_in;
char* codechar = code_out;
char result;
char fragment;
result = state_in->result;
switch (state_in->step)
{
while (1)
{
case step_A:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_A;
return (int)(codechar - code_out);
}
fragment = *plainchar++;
result = (fragment & 0x0fc) >> 2;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x003) << 4;
#ifndef _MSC_VER
/* fall through */
#endif
case step_B:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_B;
return (int)(codechar - code_out);
}
fragment = *plainchar++;
result |= (fragment & 0x0f0) >> 4;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x00f) << 2;
#ifndef _MSC_VER
/* fall through */
#endif
case step_C:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_C;
return (int)(codechar - code_out);
}
fragment = *plainchar++;
result |= (fragment & 0x0c0) >> 6;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x03f) >> 0;
*codechar++ = base64_encode_value(result);
++(state_in->stepcount);
}
}
/* control should not reach here */
return (int)(codechar - code_out);
}
int Base64encoder::encode(char value_in)
{
return base64_encode_value(value_in);
}
int encode(char value_in)
{
return base64_encode_value(value_in);
}
