arduino-esp32-lora/cores/esp32/libb64/cencode.c at master · DFRobot/arduino-esp32-lora · GitHub

Name: arduino-esp32-lora/cores/esp32/libb64/cencode.c at master · DFRobot/arduino-esp32-lora · GitHub
Rating: 4.6 (9992 reviews)
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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
/*
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"cencode.h"

voidbase64_init_encodestate(base64_encodestate*state_in) {
state_in->step=step_A;
state_in->result=0;
}

charbase64_encode_value(charvalue_in) {
staticconstchar*encoding="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
if (value_in>63) {
return'=';
 }
returnencoding[(int)value_in];
}

intbase64_encode_block(constchar*plaintext_in, intlength_in, char*code_out, base64_encodestate*state_in) {
constchar*plainchar=plaintext_in;
constchar*constplaintextend=plaintext_in+length_in;
char*codechar=code_out;
charresult;
charfragment;

result=state_in->result;

switch (state_in->step) {
while (1) {
casestep_A:
if (plainchar==plaintextend) {
state_in->result=result;
state_in->step=step_A;
returncodechar-code_out;
 }
fragment=*plainchar++;
result= (fragment&0x0fc) >> 2;
*codechar++=base64_encode_value(result);
result= (fragment&0x003) << 4;
// fall through
casestep_B:
if (plainchar==plaintextend) {
state_in->result=result;
state_in->step=step_B;
returncodechar-code_out;
 }
fragment=*plainchar++;
result |= (fragment&0x0f0) >> 4;
*codechar++=base64_encode_value(result);
result= (fragment&0x00f) << 2;
// fall through
casestep_C:
if (plainchar==plaintextend) {
state_in->result=result;
state_in->step=step_C;
returncodechar-code_out;
 }
fragment=*plainchar++;
result |= (fragment&0x0c0) >> 6;
*codechar++=base64_encode_value(result);
result= (fragment&0x03f) >> 0;
*codechar++=base64_encode_value(result);
 }
 }
/* control should not reach here */
returncodechar-code_out;
}

intbase64_encode_blockend(char*code_out, base64_encodestate*state_in) {
char*codechar=code_out;

switch (state_in->step) {
casestep_B:
*codechar++=base64_encode_value(state_in->result);
*codechar++='=';
*codechar++='=';
break;
casestep_C:
*codechar++=base64_encode_value(state_in->result);
*codechar++='=';
break;
casestep_A: break;
 }
*codechar=0x00;

returncodechar-code_out;
}

intbase64_encode_chars(constchar*plaintext_in, intlength_in, char*code_out) {
base64_encodestate_state;
base64_init_encodestate(&_state);
intlen=base64_encode_block(plaintext_in, length_in, code_out, &_state);
returnlen+base64_encode_blockend((code_out+len), &_state);
}