mirror of
https://github.com/esp8266/Arduino.git
synced 2025-07-04 01:23:50 +03:00
6bd4b1c4f7
After verifying that they really were spurious, clean up the warnings that gcc -wextra reports, except for LeaMDNS. Upgrade GCC to gcc-7 for host builds
117 lines
3.2 KiB
C++
Executable File
117 lines
3.2 KiB
C++
Executable File
/*
|
|
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 <pgmspace.h>
|
|
#include "cencode.h"
|
|
|
|
extern "C" {
|
|
|
|
void base64_init_encodestate(base64_encodestate* state_in){
|
|
state_in->step = step_A;
|
|
state_in->result = 0;
|
|
state_in->stepcount = 0;
|
|
state_in->stepsnewline = BASE64_CHARS_PER_LINE;
|
|
}
|
|
|
|
|
|
void base64_init_encodestate_nonewlines(base64_encodestate* state_in){
|
|
base64_init_encodestate(state_in);
|
|
state_in->stepsnewline = -1;
|
|
}
|
|
|
|
char base64_encode_value(char value_in){
|
|
static const char encoding[] PROGMEM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
if (value_in > 63) return '=';
|
|
return pgm_read_byte( &encoding[(int)value_in] );
|
|
}
|
|
|
|
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 codechar - code_out;
|
|
}
|
|
fragment = *plainchar++;
|
|
result = (fragment & 0x0fc) >> 2;
|
|
*codechar++ = base64_encode_value(result);
|
|
result = (fragment & 0x003) << 4;
|
|
// falls through
|
|
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;
|
|
// falls through
|
|
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 == BASE64_CHARS_PER_LINE/4) && (state_in->stepsnewline > 0)){
|
|
*codechar++ = '\n';
|
|
state_in->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;
|
|
}
|
|
*codechar = 0x00;
|
|
|
|
return codechar - code_out;
|
|
}
|
|
|
|
int base64_encode_chars(const char* plaintext_in, int length_in, char* code_out){
|
|
base64_encodestate _state;
|
|
base64_init_encodestate(&_state);
|
|
int len = base64_encode_block(plaintext_in, length_in, code_out, &_state);
|
|
return len + base64_encode_blockend((code_out + len), &_state);
|
|
}
|
|
|
|
};
|