first attempt at www downlods WIP
This commit is contained in:
Andrew Pamment
831
deps/hashids/hashids.c
vendored
Normal file
831
deps/hashids/hashids.c
vendored
Normal file
@@ -0,0 +1,831 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "hashids.h"
|
||||
|
||||
/* branch prediction hinting */
|
||||
#ifndef __has_builtin
|
||||
# define __has_builtin(x) (0)
|
||||
#endif
|
||||
#if defined(__builtin_expect) || __has_builtin(__builtin_expect)
|
||||
# define HASHIDS_LIKELY(x) (__builtin_expect(!!(x), 1))
|
||||
# define HASHIDS_UNLIKELY(x) (__builtin_expect(!!(x), 0))
|
||||
#else
|
||||
# define HASHIDS_LIKELY(x) (x)
|
||||
# define HASHIDS_UNLIKELY(x) (x)
|
||||
#endif
|
||||
|
||||
/* thread-local storage */
|
||||
#ifndef TLS
|
||||
#define TLS
|
||||
#endif
|
||||
|
||||
/* thread-safe hashids_errno indirection */
|
||||
TLS int __hashids_errno_val;
|
||||
int *
|
||||
__hashids_errno_addr()
|
||||
{
|
||||
return &__hashids_errno_val;
|
||||
}
|
||||
|
||||
/* default alloc() implementation */
|
||||
static inline void *
|
||||
hashids_alloc_f(size_t size)
|
||||
{
|
||||
return calloc(size, 1);
|
||||
}
|
||||
|
||||
/* default free() implementation */
|
||||
static inline void
|
||||
hashids_free_f(void *ptr)
|
||||
{
|
||||
free(ptr);
|
||||
}
|
||||
|
||||
void *(*_hashids_alloc)(size_t size) = hashids_alloc_f;
|
||||
void (*_hashids_free)(void *ptr) = hashids_free_f;
|
||||
|
||||
/* fast ceil(x / y) for size_t arguments */
|
||||
static inline size_t
|
||||
hashids_div_ceil_size_t(size_t x, size_t y)
|
||||
{
|
||||
return x / y + !!(x % y);
|
||||
}
|
||||
|
||||
/* fast ceil(x / y) for unsigned short arguments */
|
||||
static inline unsigned short
|
||||
hashids_div_ceil_unsigned_short(unsigned short x, unsigned short y) {
|
||||
return x / y + !!(x % y);
|
||||
}
|
||||
|
||||
/* fast log2(x) for unsigned long long */
|
||||
const unsigned short hashids_log2_64_tab[64] = {
|
||||
63, 0, 58, 1, 59, 47, 53, 2,
|
||||
60, 39, 48, 27, 54, 33, 42, 3,
|
||||
61, 51, 37, 40, 49, 18, 28, 20,
|
||||
55, 30, 34, 11, 43, 14, 22, 4,
|
||||
62, 57, 46, 52, 38, 26, 32, 41,
|
||||
50, 36, 17, 19, 29, 10, 13, 21,
|
||||
56, 45, 25, 31, 35, 16, 9, 12,
|
||||
44, 24, 15, 8, 23, 7, 6, 5
|
||||
};
|
||||
|
||||
static inline unsigned short
|
||||
hashids_log2_64(unsigned long long x)
|
||||
{
|
||||
x |= x >> 1;
|
||||
x |= x >> 2;
|
||||
x |= x >> 4;
|
||||
x |= x >> 8;
|
||||
x |= x >> 16;
|
||||
x |= x >> 32;
|
||||
|
||||
/* pure evil : ieee abuse */
|
||||
return hashids_log2_64_tab[
|
||||
((unsigned long long)((x - (x >> 1)) * 0x07EDD5E59A4E28C2)) >> 58];
|
||||
}
|
||||
|
||||
/* shuffle loop step */
|
||||
#define hashids_shuffle_step(iter) \
|
||||
if (i == 0) { break; } \
|
||||
if (v == salt_length) { v = 0; } \
|
||||
p += salt[v]; j = (salt[v] + v + p) % (iter); \
|
||||
temp = str[(iter)]; str[(iter)] = str[j]; str[j] = temp; \
|
||||
--i; ++v;
|
||||
|
||||
/* consistent shuffle */
|
||||
void
|
||||
hashids_shuffle(char *str, size_t str_length, char *salt, size_t salt_length)
|
||||
{
|
||||
ssize_t i;
|
||||
size_t j, v, p;
|
||||
char temp;
|
||||
|
||||
/* meh, meh */
|
||||
if (!salt_length) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* pure evil : loop unroll */
|
||||
for (i = str_length - 1, v = 0, p = 0; i > 0; /* empty */) {
|
||||
switch (i % 32) {
|
||||
case 31: hashids_shuffle_step(i);
|
||||
case 30: hashids_shuffle_step(i);
|
||||
case 29: hashids_shuffle_step(i);
|
||||
case 28: hashids_shuffle_step(i);
|
||||
case 27: hashids_shuffle_step(i);
|
||||
case 26: hashids_shuffle_step(i);
|
||||
case 25: hashids_shuffle_step(i);
|
||||
case 24: hashids_shuffle_step(i);
|
||||
case 23: hashids_shuffle_step(i);
|
||||
case 22: hashids_shuffle_step(i);
|
||||
case 21: hashids_shuffle_step(i);
|
||||
case 20: hashids_shuffle_step(i);
|
||||
case 19: hashids_shuffle_step(i);
|
||||
case 18: hashids_shuffle_step(i);
|
||||
case 17: hashids_shuffle_step(i);
|
||||
case 16: hashids_shuffle_step(i);
|
||||
case 15: hashids_shuffle_step(i);
|
||||
case 14: hashids_shuffle_step(i);
|
||||
case 13: hashids_shuffle_step(i);
|
||||
case 12: hashids_shuffle_step(i);
|
||||
case 11: hashids_shuffle_step(i);
|
||||
case 10: hashids_shuffle_step(i);
|
||||
case 9: hashids_shuffle_step(i);
|
||||
case 8: hashids_shuffle_step(i);
|
||||
case 7: hashids_shuffle_step(i);
|
||||
case 6: hashids_shuffle_step(i);
|
||||
case 5: hashids_shuffle_step(i);
|
||||
case 4: hashids_shuffle_step(i);
|
||||
case 3: hashids_shuffle_step(i);
|
||||
case 2: hashids_shuffle_step(i);
|
||||
case 1: hashids_shuffle_step(i);
|
||||
case 0: hashids_shuffle_step(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* "destructor" */
|
||||
void
|
||||
hashids_free(hashids_t *hashids)
|
||||
{
|
||||
if (hashids) {
|
||||
if (hashids->alphabet) {
|
||||
_hashids_free(hashids->alphabet);
|
||||
}
|
||||
if (hashids->alphabet_copy_1) {
|
||||
_hashids_free(hashids->alphabet_copy_1);
|
||||
}
|
||||
if (hashids->alphabet_copy_2) {
|
||||
_hashids_free(hashids->alphabet_copy_2);
|
||||
}
|
||||
if (hashids->salt) {
|
||||
_hashids_free(hashids->salt);
|
||||
}
|
||||
if (hashids->separators) {
|
||||
_hashids_free(hashids->separators);
|
||||
}
|
||||
if (hashids->guards) {
|
||||
_hashids_free(hashids->guards);
|
||||
}
|
||||
|
||||
_hashids_free(hashids);
|
||||
}
|
||||
}
|
||||
|
||||
/* common init */
|
||||
hashids_t *
|
||||
hashids_init3(const char *salt, size_t min_hash_length, const char *alphabet)
|
||||
{
|
||||
hashids_t *result;
|
||||
size_t i, j, len;
|
||||
char ch, *p;
|
||||
|
||||
hashids_errno = HASHIDS_ERROR_OK;
|
||||
|
||||
/* allocate the structure */
|
||||
result = _hashids_alloc(sizeof(hashids_t));
|
||||
if (HASHIDS_UNLIKELY(!result)) {
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* allocate enough space for the alphabet */
|
||||
len = strlen(alphabet) + 1;
|
||||
result->alphabet = _hashids_alloc(len);
|
||||
|
||||
/* extract only the unique characters */
|
||||
result->alphabet[0] = '\0';
|
||||
for (i = 0, j = 0; i < len; ++i) {
|
||||
ch = alphabet[i];
|
||||
if (!strchr(result->alphabet, ch)) {
|
||||
result->alphabet[j++] = ch;
|
||||
}
|
||||
}
|
||||
result->alphabet[j] = '\0';
|
||||
|
||||
/* store alphabet length */
|
||||
result->alphabet_length = j;
|
||||
|
||||
/* check length and whitespace */
|
||||
if (result->alphabet_length < HASHIDS_MIN_ALPHABET_LENGTH) {
|
||||
hashids_free(result);
|
||||
hashids_errno = HASHIDS_ERROR_ALPHABET_LENGTH;
|
||||
return NULL;
|
||||
}
|
||||
if (strchr(result->alphabet, 0x20) || strchr(result->alphabet, 0x09)) {
|
||||
hashids_free(result);
|
||||
hashids_errno = HASHIDS_ERROR_ALPHABET_SPACE;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* copy salt */
|
||||
result->salt_length = salt ? strlen(salt) : 0;
|
||||
result->salt = _hashids_alloc(result->salt_length + 1);
|
||||
if (HASHIDS_UNLIKELY(!result->salt)) {
|
||||
hashids_free(result);
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return NULL;
|
||||
}
|
||||
strncpy(result->salt, salt, result->salt_length);
|
||||
|
||||
/* allocate enough space for separators */
|
||||
len = strlen(HASHIDS_DEFAULT_SEPARATORS);
|
||||
j = (size_t)
|
||||
(ceil((float)result->alphabet_length / HASHIDS_SEPARATOR_DIVISOR) + 1);
|
||||
if (j < len + 1) {
|
||||
j = len + 1;
|
||||
}
|
||||
|
||||
result->separators = _hashids_alloc(j);
|
||||
if (HASHIDS_UNLIKELY(!result->separators)) {
|
||||
hashids_free(result);
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* take default separators out of the alphabet */
|
||||
for (i = 0, j = 0; i < strlen(HASHIDS_DEFAULT_SEPARATORS); ++i) {
|
||||
ch = HASHIDS_DEFAULT_SEPARATORS[i];
|
||||
|
||||
/* check if separator is actually in the used alphabet */
|
||||
if ((p = strchr(result->alphabet, ch))) {
|
||||
result->separators[j++] = ch;
|
||||
|
||||
/* remove that separator */
|
||||
memmove(p, p + 1,
|
||||
strlen(result->alphabet) - (p - result->alphabet));
|
||||
}
|
||||
}
|
||||
|
||||
/* store separators length */
|
||||
result->separators_count = j;
|
||||
|
||||
/* subtract separators count from alphabet length */
|
||||
result->alphabet_length -= result->separators_count;
|
||||
|
||||
/* shuffle the separators */
|
||||
if (result->separators_count) {
|
||||
hashids_shuffle(result->separators, result->separators_count,
|
||||
result->salt, result->salt_length);
|
||||
}
|
||||
|
||||
/* check if we have any/enough separators */
|
||||
if (!result->separators_count
|
||||
|| (((float)result->alphabet_length / (float)result->separators_count)
|
||||
> HASHIDS_SEPARATOR_DIVISOR)) {
|
||||
size_t separators_count = (size_t)ceil(
|
||||
(float)result->alphabet_length / HASHIDS_SEPARATOR_DIVISOR);
|
||||
|
||||
if (separators_count == 1) {
|
||||
separators_count = 2;
|
||||
}
|
||||
|
||||
if (separators_count > result->separators_count) {
|
||||
/* we need more separators - get some from alphabet */
|
||||
size_t diff = separators_count - result->separators_count;
|
||||
strncat(result->separators, result->alphabet, diff);
|
||||
memmove(result->alphabet, result->alphabet + diff,
|
||||
result->alphabet_length - diff + 1);
|
||||
|
||||
result->separators_count += diff;
|
||||
result->alphabet_length -= diff;
|
||||
} else {
|
||||
/* we have more than enough - truncate */
|
||||
result->separators[separators_count] = '\0';
|
||||
result->separators_count = separators_count;
|
||||
}
|
||||
}
|
||||
|
||||
/* shuffle alphabet */
|
||||
hashids_shuffle(result->alphabet, result->alphabet_length,
|
||||
result->salt, result->salt_length);
|
||||
|
||||
/* allocate guards */
|
||||
result->guards_count = hashids_div_ceil_size_t(result->alphabet_length,
|
||||
HASHIDS_GUARD_DIVISOR);
|
||||
result->guards = _hashids_alloc(result->guards_count + 1);
|
||||
if (HASHIDS_UNLIKELY(!result->guards)) {
|
||||
hashids_free(result);
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (HASHIDS_UNLIKELY(result->alphabet_length < 3)) {
|
||||
/* take some from separators */
|
||||
strncpy(result->guards, result->separators, result->guards_count);
|
||||
memmove(result->separators, result->separators + result->guards_count,
|
||||
result->separators_count - result->guards_count + 1);
|
||||
|
||||
result->separators_count -= result->guards_count;
|
||||
} else {
|
||||
/* take them from alphabet */
|
||||
strncpy(result->guards, result->alphabet, result->guards_count);
|
||||
memmove(result->alphabet, result->alphabet + result->guards_count,
|
||||
result->alphabet_length - result->guards_count + 1);
|
||||
|
||||
result->alphabet_length -= result->guards_count;
|
||||
}
|
||||
|
||||
/* allocate enough space for the alphabet copies */
|
||||
result->alphabet_copy_1 = _hashids_alloc(result->alphabet_length + 1);
|
||||
result->alphabet_copy_2 = _hashids_alloc(result->alphabet_length + 1);
|
||||
if (HASHIDS_UNLIKELY(!result->alphabet || !result->alphabet_copy_1
|
||||
|| !result->alphabet_copy_2)) {
|
||||
hashids_free(result);
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* set min hash length */
|
||||
result->min_hash_length = min_hash_length;
|
||||
|
||||
/* return result happily */
|
||||
return result;
|
||||
}
|
||||
|
||||
/* init with salt and minimum hash length */
|
||||
hashids_t *
|
||||
hashids_init2(const char *salt, size_t min_hash_length)
|
||||
{
|
||||
return hashids_init3(salt, min_hash_length, HASHIDS_DEFAULT_ALPHABET);
|
||||
}
|
||||
|
||||
/* init with hash only */
|
||||
hashids_t *
|
||||
hashids_init(const char *salt)
|
||||
{
|
||||
return hashids_init2(salt, HASHIDS_DEFAULT_MIN_HASH_LENGTH);
|
||||
}
|
||||
|
||||
/* estimate buffer size (generic) */
|
||||
size_t
|
||||
hashids_estimate_encoded_size(hashids_t *hashids,
|
||||
size_t numbers_count, unsigned long long *numbers)
|
||||
{
|
||||
int i, result_len;
|
||||
|
||||
for (i = 0, result_len = 1; i < numbers_count; ++i) {
|
||||
if (numbers[i] == 0) {
|
||||
result_len += 2;
|
||||
} else if (numbers[i] == 0xFFFFFFFFFFFFFFFFull) {
|
||||
result_len += hashids_div_ceil_unsigned_short(
|
||||
hashids_log2_64(numbers[i]),
|
||||
hashids_log2_64(hashids->alphabet_length)) - 1;
|
||||
} else {
|
||||
result_len += hashids_div_ceil_unsigned_short(
|
||||
hashids_log2_64(numbers[i] + 1),
|
||||
hashids_log2_64(hashids->alphabet_length));
|
||||
}
|
||||
}
|
||||
|
||||
if (numbers_count > 1) {
|
||||
result_len += numbers_count - 1;
|
||||
}
|
||||
|
||||
if (result_len < hashids->min_hash_length) {
|
||||
result_len = hashids->min_hash_length;
|
||||
}
|
||||
|
||||
return result_len + 2 /* fast log2 & ceil sometimes undershoot by 1 */;
|
||||
}
|
||||
|
||||
/* estimate buffer size (variadic) */
|
||||
size_t
|
||||
hashids_estimate_encoded_size_v(hashids_t *hashids,
|
||||
size_t numbers_count, ...)
|
||||
{
|
||||
size_t i, result;
|
||||
unsigned long long *numbers;
|
||||
va_list ap;
|
||||
|
||||
numbers = _hashids_alloc(numbers_count * sizeof(unsigned long long));
|
||||
|
||||
if (HASHIDS_UNLIKELY(!numbers)) {
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return 0;
|
||||
}
|
||||
|
||||
va_start(ap, numbers_count);
|
||||
for (i = 0; i < numbers_count; ++i) {
|
||||
numbers[i] = va_arg(ap, unsigned long long);
|
||||
}
|
||||
va_end(ap);
|
||||
|
||||
result = hashids_estimate_encoded_size(hashids, numbers_count, numbers);
|
||||
_hashids_free(numbers);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* encode many (generic) */
|
||||
size_t
|
||||
hashids_encode(hashids_t *hashids, char *buffer,
|
||||
size_t numbers_count, unsigned long long *numbers)
|
||||
{
|
||||
/* bail out if no numbers */
|
||||
if (HASHIDS_UNLIKELY(!numbers_count)) {
|
||||
buffer[0] = '\0';
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t i, j, result_len, guard_index, half_length_ceil, half_length_floor;
|
||||
unsigned long long number, number_copy, numbers_hash;
|
||||
int p_max;
|
||||
char lottery, ch, temp_ch, *p, *buffer_end, *buffer_temp;
|
||||
|
||||
/* return an estimation if no buffer */
|
||||
if (HASHIDS_UNLIKELY(!buffer)) {
|
||||
return hashids_estimate_encoded_size(hashids, numbers_count, numbers);
|
||||
}
|
||||
|
||||
/* copy the alphabet into internal buffer 1 */
|
||||
strncpy(hashids->alphabet_copy_1, hashids->alphabet,
|
||||
hashids->alphabet_length);
|
||||
|
||||
/* walk arguments once and generate a hash */
|
||||
for (i = 0, numbers_hash = 0; i < numbers_count; ++i) {
|
||||
number = numbers[i];
|
||||
numbers_hash += number % (i + 100);
|
||||
}
|
||||
|
||||
/* lottery character */
|
||||
lottery = hashids->alphabet[numbers_hash % hashids->alphabet_length];
|
||||
|
||||
/* start output buffer with it (or don't) */
|
||||
buffer[0] = lottery;
|
||||
buffer_end = buffer + 1;
|
||||
|
||||
/* alphabet-like buffer used for salt at each iteration */
|
||||
hashids->alphabet_copy_2[0] = lottery;
|
||||
hashids->alphabet_copy_2[1] = '\0';
|
||||
strncat(hashids->alphabet_copy_2, hashids->salt,
|
||||
hashids->alphabet_length - 1);
|
||||
p = hashids->alphabet_copy_2 + hashids->salt_length + 1;
|
||||
p_max = hashids->alphabet_length - 1 - hashids->salt_length;
|
||||
if (p_max > 0) {
|
||||
strncat(hashids->alphabet_copy_2, hashids->alphabet,
|
||||
p_max);
|
||||
} else {
|
||||
hashids->alphabet_copy_2[hashids->alphabet_length] = '\0';
|
||||
}
|
||||
|
||||
for (i = 0; i < numbers_count; ++i) {
|
||||
/* take number */
|
||||
number = number_copy = numbers[i];
|
||||
|
||||
/* create a salt for this iteration */
|
||||
if (p_max > 0) {
|
||||
strncpy(p, hashids->alphabet_copy_1, p_max);
|
||||
}
|
||||
|
||||
/* shuffle the alphabet */
|
||||
hashids_shuffle(hashids->alphabet_copy_1, hashids->alphabet_length,
|
||||
hashids->alphabet_copy_2, hashids->alphabet_length);
|
||||
|
||||
/* hash the number */
|
||||
buffer_temp = buffer_end;
|
||||
do {
|
||||
ch = hashids->alphabet_copy_1[number % hashids->alphabet_length];
|
||||
*buffer_end++ = ch;
|
||||
number /= hashids->alphabet_length;
|
||||
} while (number);
|
||||
|
||||
/* reverse the hash we got */
|
||||
for (j = 0; j < (buffer_end - buffer_temp) / 2; ++j) {
|
||||
temp_ch = *(buffer_temp + j);
|
||||
*(buffer_temp + j) = *(buffer_end - 1 - j);
|
||||
*(buffer_end - 1 - j) = temp_ch;
|
||||
}
|
||||
|
||||
if (i + 1 < numbers_count) {
|
||||
number_copy %= ch + i;
|
||||
*buffer_end = hashids->separators[number_copy %
|
||||
hashids->separators_count];
|
||||
++buffer_end;
|
||||
}
|
||||
}
|
||||
|
||||
/* intermediate string length */
|
||||
result_len = buffer_end - buffer;
|
||||
|
||||
if (result_len < hashids->min_hash_length) {
|
||||
/* add a guard before the encoded numbers */
|
||||
guard_index = (numbers_hash + buffer[0]) % hashids->guards_count;
|
||||
memmove(buffer + 1, buffer, result_len);
|
||||
buffer[0] = hashids->guards[guard_index];
|
||||
++result_len;
|
||||
|
||||
if (result_len < hashids->min_hash_length) {
|
||||
/* add a guard after the encoded numbers */
|
||||
guard_index = (numbers_hash + buffer[2]) % hashids->guards_count;
|
||||
buffer[result_len] = hashids->guards[guard_index];
|
||||
++result_len;
|
||||
|
||||
/* pad with half alphabet before and after */
|
||||
half_length_ceil = hashids_div_ceil_size_t(
|
||||
hashids->alphabet_length, 2);
|
||||
half_length_floor = floor((float)hashids->alphabet_length / 2);
|
||||
|
||||
/* pad, pad, pad */
|
||||
while (result_len < hashids->min_hash_length) {
|
||||
/* shuffle the alphabet */
|
||||
strncpy(hashids->alphabet_copy_2, hashids->alphabet_copy_1,
|
||||
hashids->alphabet_length);
|
||||
hashids_shuffle(hashids->alphabet_copy_1,
|
||||
hashids->alphabet_length, hashids->alphabet_copy_2,
|
||||
hashids->alphabet_length);
|
||||
|
||||
/* left pad from the end of the alphabet */
|
||||
i = hashids_div_ceil_size_t(
|
||||
hashids->min_hash_length - result_len, 2);
|
||||
/* right pad from the beginning */
|
||||
j = floor((float)(hashids->min_hash_length - result_len) / 2);
|
||||
|
||||
/* check bounds */
|
||||
if (i > half_length_ceil) {
|
||||
i = half_length_ceil;
|
||||
}
|
||||
if (j > half_length_floor) {
|
||||
j = half_length_floor;
|
||||
}
|
||||
|
||||
/* handle excessively excessive excess */
|
||||
if ((i + j) % 2 == 0 && hashids->alphabet_length % 2 == 1) {
|
||||
++i; --j;
|
||||
}
|
||||
|
||||
/* move the current result to "center" */
|
||||
memmove(buffer + i, buffer, result_len);
|
||||
/* pad left */
|
||||
memmove(buffer,
|
||||
hashids->alphabet_copy_1 + hashids->alphabet_length - i, i);
|
||||
/* pad right */
|
||||
memmove(buffer + i + result_len, hashids->alphabet_copy_1, j);
|
||||
|
||||
/* increment result_len */
|
||||
result_len += i + j;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
buffer[result_len] = '\0';
|
||||
return result_len;
|
||||
}
|
||||
|
||||
/* encode many (variadic) */
|
||||
size_t
|
||||
hashids_encode_v(hashids_t *hashids, char *buffer,
|
||||
size_t numbers_count, ...)
|
||||
{
|
||||
int i;
|
||||
size_t result;
|
||||
unsigned long long *numbers;
|
||||
va_list ap;
|
||||
|
||||
numbers = _hashids_alloc(numbers_count * sizeof(unsigned long long));
|
||||
|
||||
if (HASHIDS_UNLIKELY(!numbers)) {
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return 0;
|
||||
}
|
||||
|
||||
va_start(ap, numbers_count);
|
||||
for (i = 0; i < numbers_count; ++i) {
|
||||
numbers[i] = va_arg(ap, unsigned long long);
|
||||
}
|
||||
va_end(ap);
|
||||
|
||||
result = hashids_encode(hashids, buffer, numbers_count, numbers);
|
||||
_hashids_free(numbers);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* encode one */
|
||||
size_t
|
||||
hashids_encode_one(hashids_t *hashids, char *buffer,
|
||||
unsigned long long number)
|
||||
{
|
||||
return hashids_encode(hashids, buffer, 1, &number);
|
||||
}
|
||||
|
||||
/* numbers count */
|
||||
size_t
|
||||
hashids_numbers_count(hashids_t *hashids, char *str)
|
||||
{
|
||||
size_t numbers_count;
|
||||
char ch, *p;
|
||||
|
||||
/* skip characters until we find a guard */
|
||||
if (hashids->min_hash_length) {
|
||||
p = str;
|
||||
while ((ch = *p)) {
|
||||
if (strchr(hashids->guards, ch)) {
|
||||
str = p + 1;
|
||||
break;
|
||||
}
|
||||
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
/* parse */
|
||||
numbers_count = 0;
|
||||
while ((ch = *str)) {
|
||||
if (strchr(hashids->guards, ch)) {
|
||||
break;
|
||||
}
|
||||
if (strchr(hashids->separators, ch)) {
|
||||
numbers_count++;
|
||||
str++;
|
||||
continue;
|
||||
}
|
||||
if (!strchr(hashids->alphabet, ch)) {
|
||||
hashids_errno = HASHIDS_ERROR_INVALID_HASH;
|
||||
return 0;
|
||||
}
|
||||
|
||||
str++;
|
||||
}
|
||||
|
||||
/* account for the last number */
|
||||
return numbers_count + 1;
|
||||
}
|
||||
|
||||
/* decode */
|
||||
size_t
|
||||
hashids_decode(hashids_t *hashids, char *str,
|
||||
unsigned long long *numbers)
|
||||
{
|
||||
size_t numbers_count;
|
||||
unsigned long long number;
|
||||
char lottery, ch, *p, *c;
|
||||
int p_max;
|
||||
|
||||
numbers_count = hashids_numbers_count(hashids, str);
|
||||
|
||||
if (!numbers) {
|
||||
return numbers_count;
|
||||
}
|
||||
|
||||
/* skip characters until we find a guard */
|
||||
if (hashids->min_hash_length) {
|
||||
p = str;
|
||||
while ((ch = *p)) {
|
||||
if (strchr(hashids->guards, ch)) {
|
||||
str = p + 1;
|
||||
break;
|
||||
}
|
||||
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
/* get the lottery character */
|
||||
lottery = *str++;
|
||||
|
||||
/* copy the alphabet into internal buffer 1 */
|
||||
strncpy(hashids->alphabet_copy_1, hashids->alphabet,
|
||||
hashids->alphabet_length);
|
||||
|
||||
/* alphabet-like buffer used for salt at each iteration */
|
||||
hashids->alphabet_copy_2[0] = lottery;
|
||||
hashids->alphabet_copy_2[1] = '\0';
|
||||
strncat(hashids->alphabet_copy_2, hashids->salt,
|
||||
hashids->alphabet_length - 1);
|
||||
p = hashids->alphabet_copy_2 + hashids->salt_length + 1;
|
||||
p_max = hashids->alphabet_length - 1 - hashids->salt_length;
|
||||
if (p_max > 0) {
|
||||
strncat(hashids->alphabet_copy_2, hashids->alphabet,
|
||||
p_max);
|
||||
} else {
|
||||
hashids->alphabet_copy_2[hashids->alphabet_length] = '\0';
|
||||
}
|
||||
|
||||
/* first shuffle */
|
||||
hashids_shuffle(hashids->alphabet_copy_1, hashids->alphabet_length,
|
||||
hashids->alphabet_copy_2, hashids->alphabet_length);
|
||||
|
||||
/* parse */
|
||||
number = 0;
|
||||
while ((ch = *str)) {
|
||||
if (strchr(hashids->guards, ch)) {
|
||||
break;
|
||||
}
|
||||
if (strchr(hashids->separators, ch)) {
|
||||
*numbers++ = number;
|
||||
number = 0;
|
||||
|
||||
/* resalt the alphabet */
|
||||
if (p_max > 0) {
|
||||
strncpy(p, hashids->alphabet_copy_1, p_max);
|
||||
}
|
||||
hashids_shuffle(hashids->alphabet_copy_1, hashids->alphabet_length,
|
||||
hashids->alphabet_copy_2, hashids->alphabet_length);
|
||||
|
||||
str++;
|
||||
continue;
|
||||
}
|
||||
if (!(c = strchr(hashids->alphabet_copy_1, ch))) {
|
||||
hashids_errno = HASHIDS_ERROR_INVALID_HASH;
|
||||
return 0;
|
||||
}
|
||||
|
||||
number *= hashids->alphabet_length;
|
||||
number += c - hashids->alphabet_copy_1;
|
||||
|
||||
str++;
|
||||
}
|
||||
|
||||
/* store last number */
|
||||
*numbers = number;
|
||||
|
||||
return numbers_count;
|
||||
}
|
||||
|
||||
/* encode hex */
|
||||
size_t
|
||||
hashids_encode_hex(hashids_t *hashids, char *buffer,
|
||||
const char *hex_str)
|
||||
{
|
||||
int len;
|
||||
char *temp, *p;
|
||||
size_t result;
|
||||
unsigned long long number;
|
||||
|
||||
len = strlen(hex_str);
|
||||
temp = _hashids_alloc(len + 2);
|
||||
|
||||
if (!temp) {
|
||||
hashids_errno = HASHIDS_ERROR_ALLOC;
|
||||
return 0;
|
||||
}
|
||||
|
||||
temp[0] = '1';
|
||||
strncpy(temp + 1, hex_str, len);
|
||||
|
||||
number = strtoull(temp, &p, 16);
|
||||
|
||||
if (p == temp) {
|
||||
_hashids_free(temp);
|
||||
hashids_errno = HASHIDS_ERROR_INVALID_NUMBER;
|
||||
return 0;
|
||||
}
|
||||
|
||||
result = hashids_encode(hashids, buffer, 1, &number);
|
||||
_hashids_free(temp);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* decode hex */
|
||||
size_t
|
||||
hashids_decode_hex(hashids_t *hashids, char *str, char *output)
|
||||
{
|
||||
size_t result, i;
|
||||
unsigned long long number;
|
||||
char ch, *temp;
|
||||
|
||||
result = hashids_numbers_count(hashids, str);
|
||||
|
||||
if (result != 1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
result = hashids_decode(hashids, str, &number);
|
||||
|
||||
if (result != 1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
temp = output;
|
||||
|
||||
do {
|
||||
ch = number % 16;
|
||||
if (ch > 9) {
|
||||
ch += 'A' - 10;
|
||||
} else {
|
||||
ch += '0';
|
||||
}
|
||||
|
||||
*temp++ = (char)ch;
|
||||
|
||||
number /= 16;
|
||||
} while (number);
|
||||
|
||||
temp--;
|
||||
*temp = 0;
|
||||
|
||||
for (i = 0; i < (temp - output) / 2; ++i) {
|
||||
ch = *(output + i);
|
||||
*(output + i) = *(temp - 1 - i);
|
||||
*(temp - 1 - i) = ch;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
122
deps/hashids/hashids.h
vendored
Normal file
122
deps/hashids/hashids.h
vendored
Normal file
@@ -0,0 +1,122 @@
|
||||
#ifndef HASHIDS_H
|
||||
#define HASHIDS_H 1
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/* version constants */
|
||||
#define HASHIDS_VERSION "1.1.5"
|
||||
#define HASHIDS_VERSION_MAJOR 1
|
||||
#define HASHIDS_VERSION_MINOR 1
|
||||
#define HASHIDS_VERSION_PATCH 5
|
||||
|
||||
/* minimal alphabet length */
|
||||
#define HASHIDS_MIN_ALPHABET_LENGTH 16u
|
||||
|
||||
/* separator divisor */
|
||||
#define HASHIDS_SEPARATOR_DIVISOR 3.5f
|
||||
|
||||
/* guard divisor */
|
||||
#define HASHIDS_GUARD_DIVISOR 12u
|
||||
|
||||
/* default salt */
|
||||
#define HASHIDS_DEFAULT_SALT ""
|
||||
|
||||
/* default minimal hash length */
|
||||
#define HASHIDS_DEFAULT_MIN_HASH_LENGTH 0u
|
||||
|
||||
/* default alphabet */
|
||||
#define HASHIDS_DEFAULT_ALPHABET "abcdefghijklmnopqrstuvwxyz" \
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
|
||||
"1234567890"
|
||||
|
||||
/* default separators */
|
||||
#define HASHIDS_DEFAULT_SEPARATORS "cfhistuCFHISTU"
|
||||
|
||||
/* error codes */
|
||||
#define HASHIDS_ERROR_OK 0
|
||||
#define HASHIDS_ERROR_ALLOC -1
|
||||
#define HASHIDS_ERROR_ALPHABET_LENGTH -2
|
||||
#define HASHIDS_ERROR_ALPHABET_SPACE -3
|
||||
#define HASHIDS_ERROR_INVALID_HASH -4
|
||||
#define HASHIDS_ERROR_INVALID_NUMBER -5
|
||||
|
||||
/* thread-safe hashids_errno indirection */
|
||||
extern int *__hashids_errno_addr();
|
||||
#define hashids_errno (*__hashids_errno_addr())
|
||||
|
||||
/* alloc & free */
|
||||
extern void *(*_hashids_alloc)(size_t size);
|
||||
extern void (*_hashids_free)(void *ptr);
|
||||
|
||||
/* the hashids "object" */
|
||||
struct hashids_s {
|
||||
char *alphabet;
|
||||
char *alphabet_copy_1;
|
||||
char *alphabet_copy_2;
|
||||
size_t alphabet_length;
|
||||
|
||||
char *salt;
|
||||
size_t salt_length;
|
||||
|
||||
char *separators;
|
||||
size_t separators_count;
|
||||
|
||||
char *guards;
|
||||
size_t guards_count;
|
||||
|
||||
size_t min_hash_length;
|
||||
};
|
||||
typedef struct hashids_s hashids_t;
|
||||
|
||||
/* exported function definitions */
|
||||
void
|
||||
hashids_shuffle(char *str, size_t str_length, char *salt, size_t salt_length);
|
||||
|
||||
void
|
||||
hashids_free(hashids_t *hashids);
|
||||
|
||||
hashids_t *
|
||||
hashids_init3(const char *salt, size_t min_hash_length,
|
||||
const char *alphabet);
|
||||
|
||||
hashids_t *
|
||||
hashids_init2(const char *salt, size_t min_hash_length);
|
||||
|
||||
hashids_t *
|
||||
hashids_init(const char *salt);
|
||||
|
||||
size_t
|
||||
hashids_estimate_encoded_size(hashids_t *hashids,
|
||||
size_t numbers_count, unsigned long long *numbers);
|
||||
|
||||
size_t
|
||||
hashids_estimate_encoded_size_v(hashids_t *hashids,
|
||||
size_t numbers_count, ...);
|
||||
|
||||
size_t
|
||||
hashids_encode(hashids_t *hashids, char *buffer,
|
||||
size_t numbers_count, unsigned long long *numbers);
|
||||
|
||||
size_t
|
||||
hashids_encode_v(hashids_t *hashids, char *buffer,
|
||||
size_t numbers_count, ...);
|
||||
|
||||
size_t
|
||||
hashids_encode_one(hashids_t *hashids, char *buffer,
|
||||
unsigned long long number);
|
||||
|
||||
size_t
|
||||
hashids_numbers_count(hashids_t *hashids, char *str);
|
||||
|
||||
size_t
|
||||
hashids_decode(hashids_t *hashids, char *str,
|
||||
unsigned long long *numbers);
|
||||
|
||||
size_t
|
||||
hashids_encode_hex(hashids_t *hashids, char *buffer,
|
||||
const char *hex_str);
|
||||
|
||||
size_t
|
||||
hashids_decode_hex(hashids_t *hashids, char *str, char *output);
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user