mirror of
https://github.com/anope/anope.git
synced 2026-07-04 19:53:13 +02:00
Renamed all of source files from .c to .cpp
This commit is contained in:
Adam
+416
@@ -0,0 +1,416 @@
|
||||
/* base64 routines.
|
||||
*
|
||||
* (C) 2003-2010 Anope Team
|
||||
* Contact us at team@anope.org
|
||||
*
|
||||
* Please read COPYING and README for further details.
|
||||
*
|
||||
* Based on the original code of Epona by Lara.
|
||||
* Based on the original code of Services by Andy Church.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
This is borrowed from Unreal
|
||||
*/
|
||||
|
||||
#include "services.h"
|
||||
|
||||
static char *int_to_base64(long);
|
||||
static long base64_to_int(const char *);
|
||||
|
||||
const char *base64enc(long i)
|
||||
{
|
||||
if (i < 0)
|
||||
return "0";
|
||||
return int_to_base64(i);
|
||||
}
|
||||
|
||||
long base64dec(const char *b64)
|
||||
{
|
||||
if (b64)
|
||||
return base64_to_int(b64);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const char Base64[] =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
static const char Pad64 = '=';
|
||||
|
||||
/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
|
||||
The following encoding technique is taken from RFC 1521 by Borenstein
|
||||
and Freed. It is reproduced here in a slightly edited form for
|
||||
convenience.
|
||||
|
||||
A 65-character subset of US-ASCII is used, enabling 6 bits to be
|
||||
represented per printable character. (The extra 65th character, "=",
|
||||
is used to signify a special processing function.)
|
||||
|
||||
The encoding process represents 24-bit groups of input bits as output
|
||||
strings of 4 encoded characters. Proceeding from left to right, a
|
||||
24-bit input group is formed by concatenating 3 8-bit input groups.
|
||||
These 24 bits are then treated as 4 concatenated 6-bit groups, each
|
||||
of which is translated into a single digit in the base64 alphabet.
|
||||
|
||||
Each 6-bit group is used as an index into an array of 64 printable
|
||||
characters. The character referenced by the index is placed in the
|
||||
output string.
|
||||
|
||||
Table 1: The Base64 Alphabet
|
||||
|
||||
Value Encoding Value Encoding Value Encoding Value Encoding
|
||||
0 A 17 R 34 i 51 z
|
||||
1 B 18 S 35 j 52 0
|
||||
2 C 19 T 36 k 53 1
|
||||
3 D 20 U 37 l 54 2
|
||||
4 E 21 V 38 m 55 3
|
||||
5 F 22 W 39 n 56 4
|
||||
6 G 23 X 40 o 57 5
|
||||
7 H 24 Y 41 p 58 6
|
||||
8 I 25 Z 42 q 59 7
|
||||
9 J 26 a 43 r 60 8
|
||||
10 K 27 b 44 s 61 9
|
||||
11 L 28 c 45 t 62 +
|
||||
12 M 29 d 46 u 63 /
|
||||
13 N 30 e 47 v
|
||||
14 O 31 f 48 w (pad) =
|
||||
15 P 32 g 49 x
|
||||
16 Q 33 h 50 y
|
||||
|
||||
Special processing is performed if fewer than 24 bits are available
|
||||
at the end of the data being encoded. A full encoding quantum is
|
||||
always completed at the end of a quantity. When fewer than 24 input
|
||||
bits are available in an input group, zero bits are added (on the
|
||||
right) to form an integral number of 6-bit groups. Padding at the
|
||||
end of the data is performed using the '=' character.
|
||||
|
||||
Since all base64 input is an integral number of octets, only the
|
||||
-------------------------------------------------
|
||||
following cases can arise:
|
||||
|
||||
(1) the final quantum of encoding input is an integral
|
||||
multiple of 24 bits; here, the final unit of encoded
|
||||
output will be an integral multiple of 4 characters
|
||||
with no "=" padding,
|
||||
(2) the final quantum of encoding input is exactly 8 bits;
|
||||
here, the final unit of encoded output will be two
|
||||
characters followed by two "=" padding characters, or
|
||||
(3) the final quantum of encoding input is exactly 16 bits;
|
||||
here, the final unit of encoded output will be three
|
||||
characters followed by one "=" padding character.
|
||||
*/
|
||||
|
||||
int b64_encode(const char *src, size_t srclength, char *target, size_t targsize)
|
||||
{
|
||||
size_t datalength = 0;
|
||||
unsigned char input[3];
|
||||
unsigned char output[4];
|
||||
size_t i;
|
||||
|
||||
while (2 < srclength)
|
||||
{
|
||||
input[0] = *src++;
|
||||
input[1] = *src++;
|
||||
input[2] = *src++;
|
||||
srclength -= 3;
|
||||
|
||||
output[0] = input[0] >> 2;
|
||||
output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
|
||||
output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
|
||||
output[3] = input[2] & 0x3f;
|
||||
|
||||
if (datalength + 4 > targsize)
|
||||
return -1;
|
||||
target[datalength++] = Base64[output[0]];
|
||||
target[datalength++] = Base64[output[1]];
|
||||
target[datalength++] = Base64[output[2]];
|
||||
target[datalength++] = Base64[output[3]];
|
||||
}
|
||||
|
||||
/* Now we worry about padding. */
|
||||
if (srclength)
|
||||
{
|
||||
/* Get what's left. */
|
||||
input[0] = input[1] = input[2] = '\0';
|
||||
for (i = 0; i < srclength; ++i)
|
||||
input[i] = *src++;
|
||||
|
||||
output[0] = input[0] >> 2;
|
||||
output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
|
||||
output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
|
||||
|
||||
if (datalength + 4 > targsize)
|
||||
return -1;
|
||||
target[datalength++] = Base64[output[0]];
|
||||
target[datalength++] = Base64[output[1]];
|
||||
if (srclength == 1)
|
||||
target[datalength++] = Pad64;
|
||||
else
|
||||
target[datalength++] = Base64[output[2]];
|
||||
target[datalength++] = Pad64;
|
||||
}
|
||||
if (datalength >= targsize)
|
||||
return -1;
|
||||
target[datalength] = '\0'; /* Returned value doesn't count \0. */
|
||||
return datalength;
|
||||
}
|
||||
|
||||
/* skips all whitespace anywhere.
|
||||
converts characters, four at a time, starting at (or after)
|
||||
src from base - 64 numbers into three 8 bit bytes in the target area.
|
||||
it returns the number of data bytes stored at the target, or -1 on error.
|
||||
*/
|
||||
|
||||
int b64_decode(const char *src, char *target, size_t targsize)
|
||||
{
|
||||
int tarindex, state, ch;
|
||||
char *pos;
|
||||
|
||||
state = 0;
|
||||
tarindex = 0;
|
||||
|
||||
while ((ch = *src++) != '\0')
|
||||
{
|
||||
if (isspace(ch)) /* Skip whitespace anywhere. */
|
||||
continue;
|
||||
|
||||
if (ch == Pad64)
|
||||
break;
|
||||
|
||||
pos = const_cast<char *>(strchr(Base64, ch));
|
||||
if (!pos) /* A non-base64 character. */
|
||||
return -1;
|
||||
|
||||
switch (state)
|
||||
{
|
||||
case 0:
|
||||
if (target)
|
||||
{
|
||||
if (static_cast<size_t>(tarindex) >= targsize)
|
||||
return -1;
|
||||
target[tarindex] = (pos - Base64) << 2;
|
||||
}
|
||||
state = 1;
|
||||
break;
|
||||
case 1:
|
||||
if (target)
|
||||
{
|
||||
if (static_cast<size_t>(tarindex) + 1 >= targsize)
|
||||
return -1;
|
||||
target[tarindex] |= (pos - Base64) >> 4;
|
||||
target[tarindex + 1] = ((pos - Base64) & 0x0f) << 4;
|
||||
}
|
||||
++tarindex;
|
||||
state = 2;
|
||||
break;
|
||||
case 2:
|
||||
if (target)
|
||||
{
|
||||
if (static_cast<size_t>(tarindex) + 1 >= targsize)
|
||||
return -1;
|
||||
target[tarindex] |= (pos - Base64) >> 2;
|
||||
target[tarindex + 1] = ((pos - Base64) & 0x03) << 6;
|
||||
}
|
||||
++tarindex;
|
||||
state = 3;
|
||||
break;
|
||||
case 3:
|
||||
if (target)
|
||||
{
|
||||
if (static_cast<size_t>(tarindex) >= targsize)
|
||||
return -1;
|
||||
target[tarindex] |= (pos - Base64);
|
||||
}
|
||||
++tarindex;
|
||||
state = 0;
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* We are done decoding Base-64 chars. Let's see if we ended
|
||||
* on a byte boundary, and/or with erroneous trailing characters.
|
||||
*/
|
||||
|
||||
if (ch == Pad64) /* We got a pad char. */
|
||||
{
|
||||
ch = *src++; /* Skip it, get next. */
|
||||
switch (state)
|
||||
{
|
||||
case 0: /* Invalid = in first position */
|
||||
case 1: /* Invalid = in second position */
|
||||
return -1;
|
||||
|
||||
case 2: /* Valid, means one byte of info */
|
||||
/* Skip any number of spaces. */
|
||||
for (; ch != '\0'; ch = *src++)
|
||||
if (!isspace(ch))
|
||||
break;
|
||||
/* Make sure there is another trailing = sign. */
|
||||
if (ch != Pad64)
|
||||
return -1;
|
||||
ch = *src++; /* Skip the = */
|
||||
/* Fall through to "single trailing =" case. */
|
||||
/* FALLTHROUGH */
|
||||
|
||||
case 3: /* Valid, means two bytes of info */
|
||||
/*
|
||||
* We know this char is an =. Is there anything but
|
||||
* whitespace after it?
|
||||
*/
|
||||
for (; ch != '\0'; ch = *src++)
|
||||
if (!isspace(ch))
|
||||
return -1;
|
||||
|
||||
/*
|
||||
* Now make sure for cases 2 and 3 that the "extra"
|
||||
* bits that slopped past the last full byte were
|
||||
* zeros. If we don't check them, they become a
|
||||
* subliminal channel.
|
||||
*/
|
||||
if (target && target[tarindex])
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
* We ended by seeing the end of the string. Make sure we
|
||||
* have no partial bytes lying around.
|
||||
*/
|
||||
if (state)
|
||||
return -1;
|
||||
}
|
||||
|
||||
return tarindex;
|
||||
}
|
||||
|
||||
const char* encode_ip(unsigned char *ip)
|
||||
{
|
||||
static char buf[25];
|
||||
unsigned char *cp;
|
||||
struct in_addr ia; /* For IPv4 */
|
||||
char *s_ip; /* Signed ip string */
|
||||
|
||||
if (!ip)
|
||||
return "*";
|
||||
|
||||
if (strchr(reinterpret_cast<char *>(ip), ':'))
|
||||
return NULL;
|
||||
else
|
||||
{
|
||||
s_ip = str_signed(ip);
|
||||
ia.s_addr = inet_addr(s_ip);
|
||||
cp = reinterpret_cast<unsigned char *>(ia.s_addr);
|
||||
b64_encode(reinterpret_cast<const char *>(&cp), sizeof(struct in_addr), buf, 25);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
int decode_ip(const char *buf)
|
||||
{
|
||||
int len = strlen(buf);
|
||||
char targ[25];
|
||||
struct in_addr ia;
|
||||
|
||||
b64_decode(buf, targ, 25);
|
||||
ia = *reinterpret_cast<struct in_addr *>(targ);
|
||||
if (len == 24) /* IPv6 */
|
||||
return 0;
|
||||
else if (len == 8) /* IPv4 */
|
||||
return ia.s_addr;
|
||||
else /* Error?? */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ':' and '#' and '&' and '+' and '@' must never be in this table. */
|
||||
/* these tables must NEVER CHANGE! >) */
|
||||
char int6_to_base64_map[] = {
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
|
||||
'E', 'F',
|
||||
'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
|
||||
'U', 'V',
|
||||
'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
|
||||
'k', 'l',
|
||||
'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
|
||||
'{', '}'
|
||||
};
|
||||
|
||||
char base64_to_int6_map[] = {
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
|
||||
-1, 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, -1, -1, -1, -1, -1,
|
||||
-1, 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, -1, 63, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
|
||||
};
|
||||
|
||||
static char *int_to_base64(long val)
|
||||
{
|
||||
/* 32/6 == max 6 bytes for representation,
|
||||
* +1 for the null, +1 for byte boundaries
|
||||
*/
|
||||
static char base64buf[8];
|
||||
long i = 7;
|
||||
|
||||
base64buf[i] = '\0';
|
||||
|
||||
/* Temporary debugging code.. remove before 2038 ;p.
|
||||
* This might happen in case of 64bit longs (opteron/ia64),
|
||||
* if the value is then too large it can easily lead to
|
||||
* a buffer underflow and thus to a crash. -- Syzop
|
||||
*/
|
||||
if (val > 2147483647L)
|
||||
abort();
|
||||
|
||||
do
|
||||
{
|
||||
base64buf[--i] = int6_to_base64_map[val & 63];
|
||||
} while (val >>= 6);
|
||||
|
||||
return base64buf + i;
|
||||
}
|
||||
|
||||
static long base64_to_int(const char *b64)
|
||||
{
|
||||
int v = base64_to_int6_map[static_cast<const unsigned char>(*b64++)];
|
||||
|
||||
if (!b64)
|
||||
return 0;
|
||||
|
||||
while (*b64)
|
||||
{
|
||||
v <<= 6;
|
||||
v += base64_to_int6_map[static_cast<const unsigned char>(*b64++)];
|
||||
}
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
long base64dects(const char *ts)
|
||||
{
|
||||
if (!ts)
|
||||
return 0;
|
||||
|
||||
char *token = myStrGetToken(ts, '!', 1);
|
||||
if (!token)
|
||||
return strtoul(ts, NULL, 10);
|
||||
|
||||
long value = base64dec(token);
|
||||
delete [] token;
|
||||
return value;
|
||||
}
|
||||
Reference in New Issue
Block a user