Non puoi selezionare più di 25 argomenti
Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
266 righe
9.0 KiB
266 righe
9.0 KiB
/* ex: ts=4 sw=4 et
|
|
*
|
|
* Copyright (c) 2011-2016 Sergey Urbanovich
|
|
* http://github.com/urbanserj/cbase64-erlang-nif
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include "stdint.h"
|
|
#include "erl_nif.h"
|
|
|
|
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
|
|
|
|
#define TIMESLICE 10
|
|
#define SPEEDUP 30
|
|
#define REDUCTIONS 2000
|
|
#define ITER (REDUCTIONS * SPEEDUP / TIMESLICE)
|
|
|
|
|
|
static const char cb64[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
inline void encodeblock(const uint8_t in[3], uint8_t out[4], size_t len)
|
|
{
|
|
out[0] = cb64[ (in[0] >> 2) & 0x3f ];
|
|
out[1] = cb64[ ((in[0] << 4) + (--len ? in[1] >> 4 : 0)) & 0x3f ];
|
|
out[2] = len ? cb64[ ((in[1] << 2) + (--len ? in[2] >> 6 : 0)) & 0x3f ] : '=';
|
|
out[3] = len ? cb64[ in[2] & 0x3f ] : '=';
|
|
}
|
|
|
|
static ERL_NIF_TERM encode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
|
|
{
|
|
ERL_NIF_TERM tdst, tsrc;
|
|
ErlNifBinary src, dst;
|
|
|
|
if ( enif_inspect_binary(env, argv[0], &src) ) {
|
|
tsrc = argv[0];
|
|
} else if ( enif_inspect_iolist_as_binary(env, argv[0], &src) ) {
|
|
tsrc = enif_make_binary(env, &src);
|
|
} else {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
if (src.size == 0) {
|
|
return argv[0];
|
|
}
|
|
|
|
uint8_t *data;
|
|
size_t size = (src.size + 2) / 3 * 4;
|
|
if (argc == 1) {
|
|
data = enif_make_new_binary(env, size, &tdst);
|
|
} else {
|
|
tdst = argv[1];
|
|
if ( !enif_inspect_binary(env, argv[1], &dst) ) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
data = dst.data;
|
|
}
|
|
|
|
int i = size / 4 - 1;
|
|
if (argc == 3) {
|
|
if ( !enif_get_int(env, argv[2], &i) ) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
} else {
|
|
/* last block */
|
|
encodeblock(src.data + i * 3, data + i * 4, src.size - i * 3);
|
|
i--;
|
|
}
|
|
|
|
int reductions = 0;
|
|
for (; i >= 0; i--) {
|
|
encodeblock(src.data + i * 3, data + i * 4, 3);
|
|
reductions += 3;
|
|
if (reductions >= ITER) {
|
|
if (enif_consume_timeslice(env, TIMESLICE)) {
|
|
ERL_NIF_TERM schargv[3] = {tsrc, tdst, enif_make_int(env, i)};
|
|
return enif_schedule_nif(env, "encode", 0, &encode, 3, schargv);
|
|
}
|
|
reductions = 0;
|
|
}
|
|
}
|
|
|
|
return tdst;
|
|
}
|
|
|
|
|
|
#define DECODE_ERROR 0xff
|
|
#define DECODE_OK 0x00
|
|
|
|
#define B64(_) \
|
|
( (_) >= 'A' && (_) <= 'Z' ? 25 - 'Z' + (_) : \
|
|
(_) >= 'a' && (_) <= 'z' ? 51 - 'z' + (_) : \
|
|
(_) >= '0' && (_) <= '9' ? 61 - '9' + (_) : \
|
|
(_) == '+' ? 62 : (_) ? 63 : DECODE_ERROR )
|
|
|
|
static const int cd64[256] = {
|
|
B64( 0), B64( 1), B64( 2), B64( 3), B64( 4), B64( 5), B64( 6), B64( 7),
|
|
B64( 8), B64( 9), B64( 10), B64( 11), B64( 12), B64( 13), B64( 14), B64( 15),
|
|
B64( 16), B64( 17), B64( 18), B64( 19), B64( 20), B64( 21), B64( 22), B64( 23),
|
|
B64( 24), B64( 25), B64( 26), B64( 27), B64( 28), B64( 29), B64( 30), B64( 31),
|
|
B64( 32), B64( 33), B64( 34), B64( 35), B64( 36), B64( 37), B64( 38), B64( 39),
|
|
B64( 40), B64( 41), B64( 42), B64( 43), B64( 44), B64( 45), B64( 46), B64( 47),
|
|
B64( 48), B64( 49), B64( 50), B64( 51), B64( 52), B64( 53), B64( 54), B64( 55),
|
|
B64( 56), B64( 57), B64( 58), B64( 59), B64( 60), B64( 61), B64( 62), B64( 63),
|
|
B64( 64), B64( 65), B64( 66), B64( 67), B64( 68), B64( 69), B64( 70), B64( 71),
|
|
B64( 72), B64( 73), B64( 74), B64( 75), B64( 76), B64( 77), B64( 78), B64( 79),
|
|
B64( 80), B64( 81), B64( 82), B64( 83), B64( 84), B64( 85), B64( 86), B64( 87),
|
|
B64( 88), B64( 89), B64( 90), B64( 91), B64( 92), B64( 93), B64( 94), B64( 95),
|
|
B64( 96), B64( 97), B64( 98), B64( 99), B64(100), B64(101), B64(102), B64(103),
|
|
B64(104), B64(105), B64(106), B64(107), B64(108), B64(109), B64(110), B64(111),
|
|
B64(112), B64(113), B64(114), B64(115), B64(116), B64(117), B64(118), B64(119),
|
|
B64(120), B64(121), B64(122), B64(123), B64(124), B64(125), B64(126), B64(127),
|
|
B64(128), B64(129), B64(130), B64(131), B64(132), B64(133), B64(134), B64(135),
|
|
B64(136), B64(137), B64(138), B64(139), B64(140), B64(141), B64(142), B64(143),
|
|
B64(144), B64(145), B64(146), B64(147), B64(148), B64(149), B64(150), B64(151),
|
|
B64(152), B64(153), B64(154), B64(155), B64(156), B64(157), B64(158), B64(159),
|
|
B64(160), B64(161), B64(162), B64(163), B64(164), B64(165), B64(166), B64(167),
|
|
B64(168), B64(169), B64(170), B64(171), B64(172), B64(173), B64(174), B64(175),
|
|
B64(176), B64(177), B64(178), B64(179), B64(180), B64(181), B64(182), B64(183),
|
|
B64(184), B64(185), B64(186), B64(187), B64(188), B64(189), B64(190), B64(191),
|
|
B64(192), B64(193), B64(194), B64(195), B64(196), B64(197), B64(198), B64(199),
|
|
B64(200), B64(201), B64(202), B64(203), B64(204), B64(205), B64(206), B64(207),
|
|
B64(208), B64(209), B64(210), B64(211), B64(212), B64(213), B64(214), B64(215),
|
|
B64(216), B64(217), B64(218), B64(219), B64(220), B64(221), B64(222), B64(223),
|
|
B64(224), B64(225), B64(226), B64(227), B64(228), B64(229), B64(230), B64(231),
|
|
B64(232), B64(233), B64(234), B64(235), B64(236), B64(237), B64(238), B64(239),
|
|
B64(240), B64(241), B64(242), B64(243), B64(244), B64(245), B64(246), B64(247),
|
|
B64(248), B64(249), B64(250), B64(251), B64(252), B64(253), B64(254), B64(255)
|
|
};
|
|
|
|
inline uint8_t decodeblock(const uint8_t in[4], uint8_t out[3])
|
|
{
|
|
int code;
|
|
size_t it = 0;
|
|
unsigned int val = 0;
|
|
|
|
for (;it < 4; ++it) {
|
|
if ( (code = cd64[in[it]]) == DECODE_ERROR )
|
|
return DECODE_ERROR;
|
|
val = (val << 6) + code;
|
|
}
|
|
|
|
out[0] = (val >> 16) & 0xff;
|
|
out[1] = (val >> 8) & 0xff;
|
|
out[2] = val & 0xff;
|
|
|
|
return DECODE_OK;
|
|
}
|
|
|
|
inline uint8_t decodeblock_tail(const uint8_t in[4], uint8_t out[3])
|
|
{
|
|
int code;
|
|
size_t it = 0;
|
|
unsigned int val = 0;
|
|
|
|
if ( in[0] == '=' || in[1] == '=' ||
|
|
(in[2] == '=' && in[3] != '=') )
|
|
return DECODE_ERROR;
|
|
|
|
for (;it < 4; ++it) {
|
|
val <<= 6;
|
|
if ( in[it] == '=' )
|
|
continue;
|
|
if ( (code = cd64[in[it]]) == DECODE_ERROR )
|
|
return DECODE_ERROR;
|
|
val += code;
|
|
}
|
|
|
|
out[0] = (val >> 16) & 0xff;
|
|
if ( in[2] != '=' )
|
|
out[1] = (val >> 8) & 0xff;
|
|
if ( in[3] != '=' )
|
|
out[2] = val & 0xff;
|
|
|
|
return DECODE_OK;
|
|
}
|
|
|
|
static ERL_NIF_TERM decode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
|
|
{
|
|
ERL_NIF_TERM tdst, tsrc;
|
|
ErlNifBinary src, dst;
|
|
|
|
if ( enif_inspect_binary(env, argv[0], &src) ) {
|
|
tsrc = argv[0];
|
|
} else if ( enif_inspect_iolist_as_binary(env, argv[0], &src) ) {
|
|
tsrc = enif_make_binary(env, &src);
|
|
} else {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
if (src.size == 0) {
|
|
return argv[0];
|
|
}
|
|
|
|
if (src.size % 4 != 0) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
uint8_t *data;
|
|
size_t size =
|
|
src.size/4*3
|
|
- (src.data[src.size - 1] == '=' ? 1 : 0)
|
|
- (src.data[src.size - 2] == '=' ? 1 : 0);
|
|
if (argc == 1) {
|
|
data = enif_make_new_binary(env, size, &tdst);
|
|
} else {
|
|
tdst = argv[1];
|
|
if ( !enif_inspect_binary(env, argv[1], &dst) ) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
data = dst.data;
|
|
}
|
|
|
|
int i = src.size / 4 - 1;
|
|
if (argc == 3) {
|
|
if ( !enif_get_int(env, argv[2], &i) ) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
} else {
|
|
/* last block */
|
|
if ( decodeblock_tail(src.data + i*4, data + i*3) ) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
i--;
|
|
}
|
|
|
|
int reductions = 0;
|
|
for (; i >= 0; i--) {
|
|
if ( decodeblock(src.data + i*4, data + i*3) ) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
reductions += 4;
|
|
if (reductions >= ITER) {
|
|
if (enif_consume_timeslice(env, TIMESLICE)) {
|
|
ERL_NIF_TERM schargv[3] = {tsrc, tdst, enif_make_int(env, i)};
|
|
return enif_schedule_nif(env, "decode", 0, &decode, 3, schargv);
|
|
}
|
|
reductions = 0;
|
|
}
|
|
}
|
|
return tdst;
|
|
}
|
|
|
|
|
|
static ErlNifFunc nif_funcs[] =
|
|
{
|
|
{"encode", 1, encode},
|
|
{"decode", 1, decode}
|
|
};
|
|
ERL_NIF_INIT(cbase64, nif_funcs, NULL, NULL, NULL, NULL)
|