Replaced libb64-1.2.1 with cbase64-1.0
This commit is contained in:
parent
87a3d645e4
commit
ef50be7054
@ -1,8 +1,10 @@
|
||||
|
||||
#include "jsonfile.h"
|
||||
#include "b64/encode.h"
|
||||
#include <cstdlib>
|
||||
|
||||
#define CBASE64_IMPLEMENTATION
|
||||
#include "cbase64/cbase64.h"
|
||||
|
||||
namespace base
|
||||
{
|
||||
JsonWriterFile::JsonWriterFile(FILE* fp, char* buffer, std::size_t length):
|
||||
@ -164,29 +166,28 @@ namespace base
|
||||
auto& writer = m_writer;
|
||||
writer.String(name);
|
||||
|
||||
base64::base64_encodestate state;
|
||||
base64::base64_init_encodestate(&state);
|
||||
state.flags = base64::BASE64_ENC_NO_NEWLINE_TERM;
|
||||
cbase64_encodestate state;
|
||||
cbase64_init_encodestate(&state);
|
||||
|
||||
const std::size_t numBytes = ((numBits + 7) >> 3);
|
||||
const int encodedLenMax = base64::base64_calc_buffer_length(numBytes, &state);
|
||||
const int encodedLength = cbase64_calc_encoded_length(numBytes);
|
||||
|
||||
char* const encoded = (char*)calloc(encodedLenMax, 1);
|
||||
char* const encoded = (char*)malloc(encodedLength);
|
||||
char* encodedCurOut = encoded;
|
||||
|
||||
const std::size_t numTrailingBits = (numBits & 7);
|
||||
if (numTrailingBits > 0)
|
||||
{
|
||||
const std::size_t numBytesWithoutBits = (numBits >> 3);
|
||||
encodedCurOut += base64::base64_encode_block((const char*)data, numBytesWithoutBits, encodedCurOut, &state);
|
||||
const char lastByteClean = data[numBytesWithoutBits] & ~(0xFF >> numTrailingBits);
|
||||
encodedCurOut += base64::base64_encode_block(&lastByteClean, 1, encodedCurOut, &state);
|
||||
encodedCurOut += cbase64_encode_block(data, numBytesWithoutBits, encodedCurOut, &state);
|
||||
const unsigned char lastByteClean = data[numBytesWithoutBits] & ~(0xFF >> numTrailingBits);
|
||||
encodedCurOut += cbase64_encode_block(&lastByteClean, 1, encodedCurOut, &state);
|
||||
}
|
||||
else
|
||||
{
|
||||
encodedCurOut += base64::base64_encode_block((const char*)data, numBytes, encodedCurOut, &state);
|
||||
encodedCurOut += cbase64_encode_block(data, numBytes, encodedCurOut, &state);
|
||||
}
|
||||
encodedCurOut += base64::base64_encode_blockend(encodedCurOut, &state);
|
||||
encodedCurOut += cbase64_encode_blockend(encodedCurOut, &state);
|
||||
|
||||
writer.String(encoded, encodedCurOut - encoded);
|
||||
free(encoded);
|
||||
|
@ -1,3 +1,12 @@
|
||||
cbase64: Base64 Encoding/Decoding Routines
|
||||
======================================
|
||||
|
||||
Authors:
|
||||
-------
|
||||
|
||||
Jordan Cristiano
|
||||
|
||||
|
||||
libb64: Base64 Encoding/Decoding Routines
|
||||
======================================
|
||||
|
@ -1,6 +1,28 @@
|
||||
b64: Base64 Encoding/Decoding Routines
|
||||
cbase64: Base64 Encoding/Decoding Routines
|
||||
======================================
|
||||
|
||||
Forked from libb64-1.2.1.
|
||||
* Removed c++ helpers
|
||||
* Made header only
|
||||
* Added output length calculation functions
|
||||
* Removed chars per line limit
|
||||
* Removed ending newline
|
||||
|
||||
### Usage
|
||||
```
|
||||
#define CBASE64_IMPLEMENTATION
|
||||
```
|
||||
before you include this file in *one* C or C++ file to create the implementation.
|
||||
|
||||
```
|
||||
// i.e. it should look like this:
|
||||
#include ...
|
||||
#include ...
|
||||
#include ...
|
||||
#define CBASE64_IMPLEMENTATION
|
||||
#include "cbase64.h"
|
||||
```
|
||||
|
||||
Overview:
|
||||
--------
|
||||
libb64 is a library of ANSI C routines for fast encoding/decoding data into and
|
||||
@ -60,6 +82,7 @@ Programming:
|
||||
Some C++ wrappers are provided as well, so you don't have to get your hands
|
||||
dirty. Encoding from standard input to standard output is as simple as
|
||||
|
||||
```
|
||||
#include <b64/encode.h>
|
||||
#include <iostream>
|
||||
int main()
|
||||
@ -68,6 +91,7 @@ dirty. Encoding from standard input to standard output is as simple as
|
||||
E.encode(std::cin, std::cout);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Both standalone executables and a static library is provided in the package,
|
||||
|
||||
@ -91,6 +115,7 @@ this method, can be found in the above mentioned "Coroutines in C", by Simon
|
||||
Tatham: http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
|
||||
|
||||
For example, an RLE decompressing routine, adapted from the article:
|
||||
```
|
||||
1 static int STATE = 0;
|
||||
2 static int len, c;
|
||||
3 switch (STATE)
|
||||
@ -115,6 +140,7 @@ For example, an RLE decompressing routine, adapted from the article:
|
||||
22 }
|
||||
23 }
|
||||
24 }
|
||||
```
|
||||
|
||||
As can be seen from this example, a coroutine depends on a state variable,
|
||||
which it sets directly before exiting (lines 14 and 119). The next time the
|
245
external/cbase64-1.0/include/cbase64/cbase64.h
vendored
Normal file
245
external/cbase64-1.0/include/cbase64/cbase64.h
vendored
Normal file
@ -0,0 +1,245 @@
|
||||
|
||||
/* cbase64 - public domain base64 encoder/decoder
|
||||
|
||||
Do this:
|
||||
#define CBASE64_IMPLEMENTATION
|
||||
before you include this file in *one* C or C++ file to create the implementation.
|
||||
|
||||
// i.e. it should look like this:
|
||||
#include ...
|
||||
#include ...
|
||||
#include ...
|
||||
#define CBASE64_IMPLEMENTATION
|
||||
#include "cbase64.h"
|
||||
|
||||
*/
|
||||
|
||||
#ifndef CBASE64_H
|
||||
#define CBASE64_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum
|
||||
{
|
||||
step_A, step_B, step_C, step_D
|
||||
} cbase64_step;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
cbase64_step step;
|
||||
unsigned char result;
|
||||
} cbase64_encodestate;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
cbase64_step step;
|
||||
char result;
|
||||
} cbase64_decodestate;
|
||||
|
||||
void cbase64_init_encodestate(cbase64_encodestate* state_in);
|
||||
void cbase64_init_decodestate(cbase64_decodestate* state_in);
|
||||
|
||||
unsigned int cbase64_calc_encoded_length(unsigned int length_in);
|
||||
unsigned int cbase64_calc_decoded_length(const char* code_in, unsigned int length_in);
|
||||
|
||||
unsigned int cbase64_encode_block(const unsigned char* data_in, unsigned int length_in,
|
||||
char* code_out, cbase64_encodestate* state_in);
|
||||
|
||||
unsigned int cbase64_decode_block(const char* code_in, unsigned int length_in,
|
||||
unsigned char* data_out, cbase64_decodestate* state_in);
|
||||
|
||||
unsigned int cbase64_encode_blockend(char* code_out, cbase64_encodestate* state_in);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // CBASE64_H
|
||||
|
||||
#ifdef CBASE64_IMPLEMENTATION
|
||||
|
||||
char cbase64__encode_value(unsigned char value_in)
|
||||
{
|
||||
static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
return encoding[(int)value_in];
|
||||
}
|
||||
|
||||
char cbase64__decode_value(char value_in)
|
||||
{
|
||||
static const char decoding[] = {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 char decoding_size = sizeof(decoding);
|
||||
value_in -= 43;
|
||||
if (value_in < 0 || value_in >= decoding_size) return -1;
|
||||
return decoding[(int)value_in];
|
||||
}
|
||||
|
||||
void cbase64_init_encodestate(cbase64_encodestate* state_in)
|
||||
{
|
||||
state_in->step = step_A;
|
||||
state_in->result = '\0';
|
||||
}
|
||||
|
||||
void cbase64_init_decodestate(cbase64_decodestate* state_in)
|
||||
{
|
||||
state_in->step = step_A;
|
||||
state_in->result = '\0';
|
||||
}
|
||||
|
||||
unsigned int cbase64_calc_encoded_length(unsigned int length_in)
|
||||
{
|
||||
return 4 * (length_in / 3) + ((length_in % 3 != 0) ? 4 : 0);
|
||||
}
|
||||
|
||||
unsigned int cbase64_calc_decoded_length(const char* code_in, unsigned int length_in)
|
||||
{
|
||||
if (length_in == 0 || ((length_in & 3) != 0))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
const char secondlast = code_in[length_in - 2];
|
||||
const char last = code_in[length_in - 1];
|
||||
return 3 * (length_in / 4) - (secondlast == '=') - (last == '=');
|
||||
}
|
||||
|
||||
unsigned int cbase64_encode_block(const unsigned char* data_in, unsigned int length_in,
|
||||
char* code_out, cbase64_encodestate* state_in)
|
||||
{
|
||||
const unsigned char* datachar = data_in;
|
||||
const unsigned char* const datatextend = data_in + length_in;
|
||||
char* codechar = code_out;
|
||||
unsigned char result = state_in->result;
|
||||
unsigned char fragment;
|
||||
|
||||
switch (state_in->step)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
case step_A:
|
||||
if (datachar == datatextend)
|
||||
{
|
||||
state_in->step = step_A;
|
||||
state_in->result = result;
|
||||
return codechar - code_out;
|
||||
}
|
||||
fragment = *datachar++;
|
||||
result = (fragment & 0x0fc) >> 2;
|
||||
*codechar++ = cbase64__encode_value(result);
|
||||
result = (fragment & 0x003) << 4;
|
||||
case step_B:
|
||||
if (datachar == datatextend)
|
||||
{
|
||||
state_in->step = step_B;
|
||||
state_in->result = result;
|
||||
return codechar - code_out;
|
||||
}
|
||||
fragment = *datachar++;
|
||||
result |= (fragment & 0x0f0) >> 4;
|
||||
*codechar++ = cbase64__encode_value(result);
|
||||
result = (fragment & 0x00f) << 2;
|
||||
case step_C:
|
||||
if (datachar == datatextend)
|
||||
{
|
||||
state_in->step = step_C;
|
||||
state_in->result = result;
|
||||
return codechar - code_out;
|
||||
}
|
||||
fragment = *datachar++;
|
||||
result |= (fragment & 0x0c0) >> 6;
|
||||
*codechar++ = cbase64__encode_value(result);
|
||||
result = (fragment & 0x03f) >> 0;
|
||||
*codechar++ = cbase64__encode_value(result);
|
||||
}
|
||||
}
|
||||
// control should not reach here
|
||||
return codechar - code_out;
|
||||
}
|
||||
|
||||
unsigned int cbase64_decode_block(const char* code_in, unsigned int length_in,
|
||||
unsigned char* data_out, cbase64_decodestate* state_in)
|
||||
{
|
||||
const char* codechar = code_in;
|
||||
const char* const codeend = code_in + length_in;
|
||||
unsigned char* datachar = data_out;
|
||||
char fragment;
|
||||
|
||||
*datachar = state_in->result;
|
||||
|
||||
switch (state_in->step)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
case step_A:
|
||||
do {
|
||||
if (codechar == codeend)
|
||||
{
|
||||
state_in->step = step_A;
|
||||
state_in->result = *datachar;
|
||||
return datachar - data_out;
|
||||
}
|
||||
fragment = cbase64__decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*datachar = (fragment & 0x03f) << 2;
|
||||
case step_B:
|
||||
do {
|
||||
if (codechar == codeend)
|
||||
{
|
||||
state_in->step = step_B;
|
||||
state_in->result = *datachar;
|
||||
return datachar - data_out;
|
||||
}
|
||||
fragment = cbase64__decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*datachar++ |= (fragment & 0x030) >> 4;
|
||||
*datachar = (fragment & 0x00f) << 4;
|
||||
case step_C:
|
||||
do {
|
||||
if (codechar == codeend)
|
||||
{
|
||||
state_in->step = step_C;
|
||||
state_in->result = *datachar;
|
||||
return datachar - data_out;
|
||||
}
|
||||
fragment = cbase64__decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*datachar++ |= (fragment & 0x03c) >> 2;
|
||||
*datachar = (fragment & 0x003) << 6;
|
||||
case step_D:
|
||||
do {
|
||||
if (codechar == codeend)
|
||||
{
|
||||
state_in->step = step_D;
|
||||
state_in->result = *datachar;
|
||||
return datachar - data_out;
|
||||
}
|
||||
fragment = cbase64__decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*datachar++ |= (fragment & 0x03f);
|
||||
}
|
||||
}
|
||||
// control should not reach here
|
||||
return datachar - data_out;
|
||||
}
|
||||
|
||||
unsigned int cbase64_encode_blockend(char* code_out, cbase64_encodestate* state_in)
|
||||
{
|
||||
char* codechar = code_out;
|
||||
switch (state_in->step)
|
||||
{
|
||||
case step_B:
|
||||
*codechar++ = cbase64__encode_value(state_in->result);
|
||||
*codechar++ = '=';
|
||||
*codechar++ = '=';
|
||||
break;
|
||||
case step_C:
|
||||
*codechar++ = cbase64__encode_value(state_in->result);
|
||||
*codechar++ = '=';
|
||||
break;
|
||||
case step_A:
|
||||
break;
|
||||
}
|
||||
return codechar - code_out;
|
||||
}
|
||||
|
||||
#endif // CBASE64_IMPLEMENTATION
|
33
external/libb64-1.2.1/CHANGELOG
vendored
33
external/libb64-1.2.1/CHANGELOG
vendored
@ -1,33 +0,0 @@
|
||||
libb64: Base64 Encoding/Decoding Routines
|
||||
======================================
|
||||
|
||||
## Changelog ##
|
||||
|
||||
Version 1.2.1 Release
|
||||
---------------------
|
||||
Fixed a long-standing bug in src/cdecode.c where value_in was not correctly
|
||||
checked against the bounds [0..decoding_size)
|
||||
Thanks to both Mario Rugiero and Shlok Datye for pointing this out.
|
||||
Added some simple example code to answer some of the most common misconceptions
|
||||
people have about the library usage.
|
||||
|
||||
Version 1.2 Release
|
||||
-------------------
|
||||
Removed the b64dec, b64enc, encoder and decoder programs in favour of
|
||||
a better example, called base64, which encodes and decodes
|
||||
depending on its arguments.
|
||||
|
||||
Created a solution for Microsoft Visual Studio C++ Express 2010
|
||||
edition, which simply builds the base64 example as a console application.
|
||||
|
||||
Version 1.1 Release
|
||||
-------------------
|
||||
Modified encode.h to (correctly) read from the iostream argument,
|
||||
instead of std::cin.
|
||||
Thanks to Peter K. Lee for the heads-up.
|
||||
|
||||
No API changes.
|
||||
|
||||
Version 1.0 Release
|
||||
-------------------
|
||||
The current content is the changeset.
|
29
external/libb64-1.2.1/include/b64/cdecode.h
vendored
29
external/libb64-1.2.1/include/b64/cdecode.h
vendored
@ -1,29 +0,0 @@
|
||||
/*
|
||||
cdecode.h - c header for a base64 decoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
|
||||
#ifndef BASE64_CDECODE_H
|
||||
#define BASE64_CDECODE_H
|
||||
|
||||
typedef enum
|
||||
{
|
||||
step_a, step_b, step_c, step_d
|
||||
} base64_decodestep;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
base64_decodestep step;
|
||||
char plainchar;
|
||||
} base64_decodestate;
|
||||
|
||||
void base64_init_decodestate(base64_decodestate* state_in);
|
||||
|
||||
int base64_decode_value(char value_in);
|
||||
|
||||
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
|
||||
|
||||
#endif /* BASE64_CDECODE_H */
|
||||
|
38
external/libb64-1.2.1/include/b64/cencode.h
vendored
38
external/libb64-1.2.1/include/b64/cencode.h
vendored
@ -1,38 +0,0 @@
|
||||
/*
|
||||
cencode.h - c header for a base64 encoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
|
||||
#ifndef BASE64_CENCODE_H
|
||||
#define BASE64_CENCODE_H
|
||||
|
||||
typedef enum
|
||||
{
|
||||
step_A, step_B, step_C
|
||||
} base64_encodestep;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
BASE64_ENC_NO_NEWLINE_TERM = 0x1
|
||||
} base64_encodeflags;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
base64_encodeflags flags;
|
||||
base64_encodestep step;
|
||||
int stepcount;
|
||||
char result;
|
||||
} base64_encodestate;
|
||||
|
||||
void base64_init_encodestate(base64_encodestate* state_in);
|
||||
|
||||
int base64_calc_buffer_length(int length_in, const base64_encodestate* state_in);
|
||||
|
||||
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
|
||||
|
||||
int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
|
||||
|
||||
#endif /* BASE64_CENCODE_H */
|
||||
|
20
external/libb64-1.2.1/include/b64/decode.h
vendored
20
external/libb64-1.2.1/include/b64/decode.h
vendored
@ -1,20 +0,0 @@
|
||||
// :mode=c++:
|
||||
/*
|
||||
decode.h - c++ wrapper for a base64 decoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
#ifndef BASE64_DECODE_H
|
||||
#define BASE64_DECODE_H
|
||||
|
||||
namespace base64
|
||||
{
|
||||
extern "C"
|
||||
{
|
||||
#include "cdecode.h"
|
||||
}
|
||||
} // namespace base64
|
||||
|
||||
#endif // BASE64_DECODE_H
|
||||
|
20
external/libb64-1.2.1/include/b64/encode.h
vendored
20
external/libb64-1.2.1/include/b64/encode.h
vendored
@ -1,20 +0,0 @@
|
||||
// :mode=c++:
|
||||
/*
|
||||
encode.h - c++ wrapper for a base64 encoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
#ifndef BASE64_ENCODE_H
|
||||
#define BASE64_ENCODE_H
|
||||
|
||||
namespace base64
|
||||
{
|
||||
extern "C"
|
||||
{
|
||||
#include "cencode.h"
|
||||
}
|
||||
} // namespace base64
|
||||
|
||||
#endif // BASE64_ENCODE_H
|
||||
|
88
external/libb64-1.2.1/src/cdecode.c
vendored
88
external/libb64-1.2.1/src/cdecode.c
vendored
@ -1,88 +0,0 @@
|
||||
/*
|
||||
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 <b64/cdecode.h>
|
||||
|
||||
int base64_decode_value(char value_in)
|
||||
{
|
||||
static const char decoding[] = {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 char decoding_size = sizeof(decoding);
|
||||
value_in -= 43;
|
||||
if (value_in < 0 || value_in >= decoding_size) return -1;
|
||||
return decoding[(int)value_in];
|
||||
}
|
||||
|
||||
void base64_init_decodestate(base64_decodestate* state_in)
|
||||
{
|
||||
state_in->step = step_a;
|
||||
state_in->plainchar = 0;
|
||||
}
|
||||
|
||||
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in)
|
||||
{
|
||||
const char* codechar = code_in;
|
||||
char* plainchar = plaintext_out;
|
||||
char 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 = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar = (fragment & 0x03f) << 2;
|
||||
case step_b:
|
||||
do {
|
||||
if (codechar == code_in+length_in)
|
||||
{
|
||||
state_in->step = step_b;
|
||||
state_in->plainchar = *plainchar;
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
fragment = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar++ |= (fragment & 0x030) >> 4;
|
||||
*plainchar = (fragment & 0x00f) << 4;
|
||||
case step_c:
|
||||
do {
|
||||
if (codechar == code_in+length_in)
|
||||
{
|
||||
state_in->step = step_c;
|
||||
state_in->plainchar = *plainchar;
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
fragment = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar++ |= (fragment & 0x03c) >> 2;
|
||||
*plainchar = (fragment & 0x003) << 6;
|
||||
case step_d:
|
||||
do {
|
||||
if (codechar == code_in+length_in)
|
||||
{
|
||||
state_in->step = step_d;
|
||||
state_in->plainchar = *plainchar;
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
fragment = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar++ |= (fragment & 0x03f);
|
||||
}
|
||||
}
|
||||
/* control should not reach here */
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
|
127
external/libb64-1.2.1/src/cencode.c
vendored
127
external/libb64-1.2.1/src/cencode.c
vendored
@ -1,127 +0,0 @@
|
||||
/*
|
||||
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;
|
||||
}
|
||||
|
@ -29,7 +29,7 @@ solution "demboyz"
|
||||
includedirs
|
||||
{
|
||||
"../external/json_checker/include",
|
||||
"../external/libb64-1.2.1/include",
|
||||
"../external/cbase64-1.0/include",
|
||||
"../external/sourcesdk/include",
|
||||
"../external/rapidjson-1.0.2/include",
|
||||
"../demboyz"
|
||||
|
Loading…
Reference in New Issue
Block a user