0edba2ee2a
* Add HTTP-parser lib to support ESP32 WebServer * Add WebServer from ESP32. Only supports HTTP * Separate HTTP server from the network server Instead of managing the WiFiServer/WiFiServerSecure in the same object as the HTTP handling, split them into separate objects. This lets HTTP and HTTPS servers work without templates or duplicating code. The HTTP block just gets a `WiFiClient*` and works with that to only do HTTP processing, while the upper object handles the appropriate server and client types. * Add HTTPS server * Clean up some THandlerFunction refs * Refactor into a template-ized WebServer/WebServerSecure * Add DNSServer examples which need WebServer * Fix CoreMutex infinite recursion crash Core could crash while Serial debugging was going on and prints were happening from LWIP/IRQ land and the main app. * Add HTTPUpdateServer(Secure) * Add MIME include, optimize WebServer::send(size,len) When send()ing a large buffer, the WebServer::send() call would actually convert that buffer into a String (i.e. duplicate it, and potential issues with embedded \0s in binary data). Make a simple override to send(size, len) to allow writing from the source buffer instead. * Fix WiFiClient::send(Stream), add FSBrowser example
111 lines
4.5 KiB
C++
Executable file
111 lines
4.5 KiB
C++
Executable file
/*
|
|
cdecoder.c - c source to a base64 decoding 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 <stdint.h>
|
|
#include "cdecode.h"
|
|
|
|
extern "C" {
|
|
|
|
static int base64_decode_value_signed(int8_t value_in) {
|
|
static const int8_t decoding[] PROGMEM = {62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
|
|
static const int8_t decoding_size = sizeof(decoding);
|
|
value_in -= 43;
|
|
if (value_in < 0 || value_in > decoding_size) {
|
|
return -1;
|
|
}
|
|
return pgm_read_byte(&decoding[(int)value_in]);
|
|
}
|
|
|
|
void base64_init_decodestate(base64_decodestate* state_in) {
|
|
state_in->step = step_a;
|
|
state_in->plainchar = 0;
|
|
}
|
|
|
|
static int base64_decode_block_signed(const int8_t* code_in, const int length_in, int8_t* plaintext_out, base64_decodestate* state_in) {
|
|
const int8_t* codechar = code_in;
|
|
int8_t* plainchar = plaintext_out;
|
|
int8_t fragment;
|
|
|
|
*plainchar = state_in->plainchar;
|
|
|
|
switch (state_in->step) {
|
|
while (1) {
|
|
case step_a:
|
|
do {
|
|
if (codechar == code_in + length_in) {
|
|
state_in->step = step_a;
|
|
state_in->plainchar = *plainchar;
|
|
return plainchar - plaintext_out;
|
|
}
|
|
fragment = (int8_t)base64_decode_value_signed(*codechar++);
|
|
} while (fragment < 0);
|
|
*plainchar = (fragment & 0x03f) << 2;
|
|
// falls through
|
|
case step_b:
|
|
do {
|
|
if (codechar == code_in + length_in) {
|
|
state_in->step = step_b;
|
|
state_in->plainchar = *plainchar;
|
|
return plainchar - plaintext_out;
|
|
}
|
|
fragment = (int8_t)base64_decode_value_signed(*codechar++);
|
|
} while (fragment < 0);
|
|
*plainchar++ |= (fragment & 0x030) >> 4;
|
|
*plainchar = (fragment & 0x00f) << 4;
|
|
// falls through
|
|
case step_c:
|
|
do {
|
|
if (codechar == code_in + length_in) {
|
|
state_in->step = step_c;
|
|
state_in->plainchar = *plainchar;
|
|
return plainchar - plaintext_out;
|
|
}
|
|
fragment = (int8_t)base64_decode_value_signed(*codechar++);
|
|
} while (fragment < 0);
|
|
*plainchar++ |= (fragment & 0x03c) >> 2;
|
|
*plainchar = (fragment & 0x003) << 6;
|
|
// falls through
|
|
case step_d:
|
|
do {
|
|
if (codechar == code_in + length_in) {
|
|
state_in->step = step_d;
|
|
state_in->plainchar = *plainchar;
|
|
return plainchar - plaintext_out;
|
|
}
|
|
fragment = (int8_t)base64_decode_value_signed(*codechar++);
|
|
} while (fragment < 0);
|
|
*plainchar++ |= (fragment & 0x03f);
|
|
}
|
|
}
|
|
/* control should not reach here */
|
|
return plainchar - plaintext_out;
|
|
}
|
|
|
|
static int base64_decode_chars_signed(const int8_t* code_in, const int length_in, int8_t* plaintext_out) {
|
|
base64_decodestate _state;
|
|
base64_init_decodestate(&_state);
|
|
int len = base64_decode_block_signed(code_in, length_in, plaintext_out, &_state);
|
|
if (len > 0) {
|
|
plaintext_out[len] = 0;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
int base64_decode_value(char value_in) {
|
|
return base64_decode_value_signed(*((int8_t *) &value_in));
|
|
}
|
|
|
|
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in) {
|
|
return base64_decode_block_signed((int8_t *) code_in, length_in, (int8_t *) plaintext_out, state_in);
|
|
}
|
|
|
|
int base64_decode_chars(const char* code_in, const int length_in, char* plaintext_out) {
|
|
return base64_decode_chars_signed((int8_t *) code_in, length_in, (int8_t *) plaintext_out);
|
|
}
|
|
|
|
};
|