mirror of
https://codeberg.org/grunfink/snac2.git
synced 2024-12-24 16:43:36 +00:00
Imported xs.
This commit is contained in:
default
parent
ef03035ef0
commit
67288a763b
8 changed files with 2096 additions and 0 deletions
714
xs.h
Normal file
714
xs.h
Normal file
|
|
@ -0,0 +1,714 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_H
|
||||
|
||||
#define _XS_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <unistd.h>
|
||||
#include <stdarg.h>
|
||||
#include <signal.h>
|
||||
#include <errno.h>
|
||||
|
||||
typedef enum {
|
||||
XSTYPE_NULL = 0x18,
|
||||
XSTYPE_TRUE = 0x06,
|
||||
XSTYPE_FALSE = 0x15,
|
||||
XSTYPE_SOL = 0x11,
|
||||
XSTYPE_LITEM = 0x1f,
|
||||
XSTYPE_EOL = 0x12,
|
||||
XSTYPE_SOD = 0x13,
|
||||
XSTYPE_DITEM = 0x1e,
|
||||
XSTYPE_EOD = 0x14,
|
||||
XSTYPE_NUMBER = 0x17,
|
||||
XSTYPE_STRING = 0x02
|
||||
} xstype;
|
||||
|
||||
|
||||
/* dynamic strings */
|
||||
typedef char d_char;
|
||||
|
||||
/* auto-destroyable strings */
|
||||
#define xs __attribute__ ((__cleanup__ (_xs_destroy))) d_char
|
||||
|
||||
#define _XS_BLK_SIZE 16
|
||||
#define _xs_blk_size(sz) ((((sz) + _XS_BLK_SIZE) / _XS_BLK_SIZE) * _XS_BLK_SIZE)
|
||||
|
||||
#define xs_debug() kill(getpid(), 5)
|
||||
xstype xs_type(const char *data);
|
||||
int xs_size(const char *data);
|
||||
d_char *xs_dup(const char *data);
|
||||
d_char *xs_expand(d_char *data, int offset, int size);
|
||||
d_char *xs_collapse(d_char *data, int offset, int size);
|
||||
d_char *xs_insert_m(d_char *data, int offset, const char *mem, int size);
|
||||
#define xs_insert(data, offset, data2) xs_insert_m(data, offset, data2, xs_size(data2))
|
||||
#define xs_append_m(data, mem, size) xs_insert_m(data, xs_size(data) - 1, mem, size)
|
||||
d_char *xs_str_new(const char *str);
|
||||
#define xs_str_cat(str1, str2) xs_insert(str1, xs_size(str1) - 1, str2)
|
||||
d_char *xs_replace(const char *str, const char *sfrom, const char *sto);
|
||||
d_char *xs_fmt(const char *fmt, ...);
|
||||
int xs_str_in(char *haystack, char *needle);
|
||||
int xs_startswith(char *str, char *prefix);
|
||||
int xs_endswith(char *str, char *postfix);
|
||||
d_char *xs_crop(d_char *str, int start, int end);
|
||||
d_char *xs_strip(d_char *str);
|
||||
d_char *xs_tolower(d_char *str);
|
||||
d_char *xs_list_new(void);
|
||||
d_char *xs_list_append_m(d_char *list, const char *mem, int dsz);
|
||||
#define xs_list_append(list, data) xs_list_append_m(list, data, xs_size(data))
|
||||
int xs_list_iter(char **list, char **value);
|
||||
int xs_list_len(char *list);
|
||||
char *xs_list_get(char *list, int num);
|
||||
int xs_list_in(char *list, char *val);
|
||||
d_char *xs_join(char *list, const char *sep);
|
||||
d_char *xs_splitn(const char *str, const char *sep, int times);
|
||||
#define xs_split(str, sep) xs_splitn(str, sep, 0xfffffff)
|
||||
d_char *xs_dict_new(void);
|
||||
d_char *xs_dict_append_m(d_char *dict, const char *key, const char *mem, int dsz);
|
||||
#define xs_dict_append(dict, key, data) xs_dict_append_m(dict, key, data, xs_size(data))
|
||||
int xs_dict_iter(char **dict, char **key, char **value);
|
||||
char *xs_dict_get(char *dict, const char *key);
|
||||
d_char *xs_dict_del(d_char *dict, const char *key);
|
||||
d_char *xs_dict_set(d_char *dict, const char *key, const char *data);
|
||||
d_char *xs_val_new(xstype t);
|
||||
d_char *xs_number_new(float f);
|
||||
float xs_get_number(char *v);
|
||||
|
||||
extern int _xs_debug;
|
||||
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
int _xs_debug = 0;
|
||||
|
||||
void _xs_destroy(char **var)
|
||||
{
|
||||
if (_xs_debug)
|
||||
printf("_xs_destroy %p\n", var);
|
||||
|
||||
free(*var);
|
||||
}
|
||||
|
||||
xstype xs_type(const char *data)
|
||||
/* return the type of data */
|
||||
{
|
||||
xstype t;
|
||||
|
||||
switch (data[0]) {
|
||||
case XSTYPE_NULL:
|
||||
case XSTYPE_TRUE:
|
||||
case XSTYPE_FALSE:
|
||||
case XSTYPE_SOL:
|
||||
case XSTYPE_EOL:
|
||||
case XSTYPE_SOD:
|
||||
case XSTYPE_EOD:
|
||||
case XSTYPE_LITEM:
|
||||
case XSTYPE_DITEM:
|
||||
case XSTYPE_NUMBER:
|
||||
t = data[0];
|
||||
break;
|
||||
default:
|
||||
t = XSTYPE_STRING;
|
||||
break;
|
||||
}
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
int xs_size(const char *data)
|
||||
/* returns the size of data in bytes */
|
||||
{
|
||||
int len = 0;
|
||||
int c = 0;
|
||||
const char *p;
|
||||
|
||||
if (data == NULL)
|
||||
return 0;
|
||||
|
||||
switch (xs_type(data)) {
|
||||
case XSTYPE_STRING:
|
||||
len = strlen(data) + 1;
|
||||
break;
|
||||
|
||||
case XSTYPE_SOL:
|
||||
/* look for a balanced EOL */
|
||||
do {
|
||||
c += data[len] == XSTYPE_SOL ? 1 : data[len] == XSTYPE_EOL ? -1 : 0;
|
||||
len++;
|
||||
} while (c);
|
||||
|
||||
break;
|
||||
|
||||
case XSTYPE_SOD:
|
||||
/* look for a balanced EOD */
|
||||
do {
|
||||
c += data[len] == XSTYPE_SOD ? 1 : data[len] == XSTYPE_EOD ? -1 : 0;
|
||||
len++;
|
||||
} while (c);
|
||||
|
||||
break;
|
||||
|
||||
case XSTYPE_DITEM:
|
||||
/* calculate the size of the key and the value */
|
||||
p = data + 1;
|
||||
p += xs_size(p);
|
||||
p += xs_size(p);
|
||||
|
||||
len = p - data;
|
||||
|
||||
break;
|
||||
|
||||
case XSTYPE_LITEM:
|
||||
/* it's the size of the item + 1 */
|
||||
p = data + 1;
|
||||
p += xs_size(p);
|
||||
|
||||
len = p - data;
|
||||
|
||||
break;
|
||||
|
||||
case XSTYPE_NUMBER:
|
||||
len = sizeof(float) + 1;
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
len = 1;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_dup(const char *data)
|
||||
/* creates a duplicate of data */
|
||||
{
|
||||
int sz = xs_size(data);
|
||||
d_char *s = malloc(_xs_blk_size(sz));
|
||||
|
||||
memcpy(s, data, sz);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_expand(d_char *data, int offset, int size)
|
||||
/* opens a hole in data */
|
||||
{
|
||||
int sz = xs_size(data);
|
||||
int n;
|
||||
|
||||
/* open room */
|
||||
if (sz == 0 || _xs_blk_size(sz) != _xs_blk_size(sz + size))
|
||||
data = realloc(data, _xs_blk_size(sz + size));
|
||||
|
||||
/* move up the rest of the data */
|
||||
for (n = sz + size - 1; n >= offset + size; n--)
|
||||
data[n] = data[n - size];
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_collapse(d_char *data, int offset, int size)
|
||||
/* shrinks data */
|
||||
{
|
||||
int sz = xs_size(data);
|
||||
int n;
|
||||
|
||||
/* don't try to delete beyond the limit */
|
||||
if (offset + size > sz)
|
||||
size = sz - offset;
|
||||
|
||||
/* shrink total size */
|
||||
sz -= size;
|
||||
|
||||
for (n = offset; n < sz; n++)
|
||||
data[n] = data[n + size];
|
||||
|
||||
return realloc(data, _xs_blk_size(sz));
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_insert_m(d_char *data, int offset, const char *mem, int size)
|
||||
/* inserts a memory block */
|
||||
{
|
||||
data = xs_expand(data, offset, size);
|
||||
memcpy(data + offset, mem, size);
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
/** strings **/
|
||||
|
||||
d_char *xs_str_new(const char *str)
|
||||
/* creates a new string */
|
||||
{
|
||||
return xs_insert(NULL, 0, str ? str : "");
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_replace(const char *str, const char *sfrom, const char *sto)
|
||||
/* replaces all occurrences of sfrom with sto in str */
|
||||
{
|
||||
d_char *s;
|
||||
char *ss;
|
||||
int sfsz;
|
||||
|
||||
/* cache the sizes */
|
||||
sfsz = strlen(sfrom);
|
||||
|
||||
/* create the new string */
|
||||
s = xs_str_new(NULL);
|
||||
|
||||
while ((ss = strstr(str, sfrom)) != NULL) {
|
||||
/* copy the first part */
|
||||
s = xs_append_m(s, str, ss - str);
|
||||
|
||||
/* copy sto */
|
||||
s = xs_str_cat(s, sto);
|
||||
|
||||
/* move forward */
|
||||
str = ss + sfsz;
|
||||
}
|
||||
|
||||
/* copy the rest */
|
||||
s = xs_str_cat(s, str);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_fmt(const char *fmt, ...)
|
||||
/* formats a string with printf()-like marks */
|
||||
{
|
||||
int n;
|
||||
d_char *s = NULL;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
n = vsnprintf(s, 0, fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
if (n > 0) {
|
||||
n = _xs_blk_size(n + 1);
|
||||
s = calloc(n, 1);
|
||||
|
||||
va_start(ap, fmt);
|
||||
n = vsnprintf(s, n, fmt, ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
int xs_str_in(char *haystack, char *needle)
|
||||
/* finds needle in haystack and returns the offset or -1 */
|
||||
{
|
||||
char *s;
|
||||
int r = -1;
|
||||
|
||||
if ((s = strstr(haystack, needle)) != NULL)
|
||||
r = s - haystack;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
int xs_startswith(char *str, char *prefix)
|
||||
/* returns true if str starts with prefix */
|
||||
{
|
||||
return !!(xs_str_in(str, prefix) == 0);
|
||||
}
|
||||
|
||||
|
||||
int xs_endswith(char *str, char *postfix)
|
||||
/* returns true if str ends with postfix */
|
||||
{
|
||||
int ssz = strlen(str);
|
||||
int psz = strlen(postfix);
|
||||
|
||||
return !!(ssz >= psz && memcmp(postfix, str + ssz - psz, psz) == 0);
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_crop(d_char *str, int start, int end)
|
||||
/* crops the d_char to be only from start to end */
|
||||
{
|
||||
int sz = strlen(str);
|
||||
|
||||
if (end <= 0)
|
||||
end = sz + end;
|
||||
|
||||
/* crop from the top */
|
||||
str[end] = '\0';
|
||||
|
||||
/* crop from the bottom */
|
||||
str = xs_collapse(str, 0, start);
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_strip(d_char *str)
|
||||
/* strips the string of blanks from the start and the end */
|
||||
{
|
||||
int s, e;
|
||||
|
||||
for (s = 0; isspace(str[s]); s++);
|
||||
for (e = strlen(str); e > 0 && isspace(str[e - 1]); e--);
|
||||
|
||||
return xs_crop(str, s, e);
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_tolower(d_char *str)
|
||||
/* convert to lowercase */
|
||||
{
|
||||
int n;
|
||||
|
||||
for (n = 0; str[n]; n++)
|
||||
str[n] = tolower(str[n]);
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
|
||||
/** lists **/
|
||||
|
||||
d_char *xs_list_new(void)
|
||||
/* creates a new list */
|
||||
{
|
||||
d_char *list;
|
||||
|
||||
list = malloc(_xs_blk_size(2));
|
||||
list[0] = XSTYPE_SOL;
|
||||
list[1] = XSTYPE_EOL;
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_list_append_m(d_char *list, const char *mem, int dsz)
|
||||
/* adds a memory block to the list */
|
||||
{
|
||||
char c = XSTYPE_LITEM;
|
||||
int lsz = xs_size(list);
|
||||
|
||||
list = xs_insert_m(list, lsz - 1, &c, 1);
|
||||
list = xs_insert_m(list, lsz, mem, dsz);
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
|
||||
int xs_list_iter(char **list, char **value)
|
||||
/* iterates a list value */
|
||||
{
|
||||
int goon = 1;
|
||||
char *p;
|
||||
|
||||
if (list == NULL || *list == NULL)
|
||||
return 0;
|
||||
|
||||
p = *list;
|
||||
|
||||
/* skip a possible start of the list */
|
||||
if (*p == XSTYPE_SOL)
|
||||
p++;
|
||||
|
||||
/* an element? */
|
||||
if (*p == XSTYPE_LITEM) {
|
||||
p++;
|
||||
|
||||
*value = p;
|
||||
|
||||
p += xs_size(*value);
|
||||
}
|
||||
else {
|
||||
/* end of list */
|
||||
p++;
|
||||
goon = 0;
|
||||
}
|
||||
|
||||
/* store back the pointer */
|
||||
*list = p;
|
||||
|
||||
return goon;
|
||||
}
|
||||
|
||||
|
||||
int xs_list_len(char *list)
|
||||
/* returns the number of elements in the list */
|
||||
{
|
||||
int c = 0;
|
||||
char *v;
|
||||
|
||||
while (xs_list_iter(&list, &v))
|
||||
c++;
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
char *xs_list_get(char *list, int num)
|
||||
/* returns the element #num */
|
||||
{
|
||||
char *v, *r = NULL;
|
||||
int c = 0;
|
||||
|
||||
if (num < 0)
|
||||
num = xs_list_len(list) + num;
|
||||
|
||||
while (xs_list_iter(&list, &v)) {
|
||||
if (c == num) {
|
||||
r = v;
|
||||
break;
|
||||
}
|
||||
c++;
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
int xs_list_in(char *list, char *val)
|
||||
/* returns the position of val in list or -1 */
|
||||
{
|
||||
int n = 0;
|
||||
int r = -1;
|
||||
char *v;
|
||||
int sz = xs_size(val);
|
||||
|
||||
while (r == -1 && xs_list_iter(&list, &v)) {
|
||||
int vsz = xs_size(v);
|
||||
|
||||
if (sz == vsz && memcmp(val, v, sz) == 0)
|
||||
r = n;
|
||||
|
||||
n++;
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_join(char *list, const char *sep)
|
||||
/* joins a list into a string */
|
||||
{
|
||||
d_char *s;
|
||||
char *v;
|
||||
int c = 0;
|
||||
|
||||
s = xs_str_new(NULL);
|
||||
|
||||
while (xs_list_iter(&list, &v)) {
|
||||
/* refuse to join non-string values */
|
||||
if (xs_type(v) == XSTYPE_STRING) {
|
||||
/* add the separator */
|
||||
if (c != 0)
|
||||
s = xs_str_cat(s, sep);
|
||||
|
||||
/* add the element */
|
||||
s = xs_str_cat(s, v);
|
||||
|
||||
c++;
|
||||
}
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_splitn(const char *str, const char *sep, int times)
|
||||
/* splits a string into a list upto n times */
|
||||
{
|
||||
int sz = strlen(sep);
|
||||
char *ss;
|
||||
d_char *list;
|
||||
|
||||
list = xs_list_new();
|
||||
|
||||
while (times > 0 && (ss = strstr(str, sep)) != NULL) {
|
||||
/* add the first part (without the asciiz) */
|
||||
list = xs_list_append_m(list, str, ss - str);
|
||||
|
||||
/* add the asciiz */
|
||||
list = xs_str_cat(list, "");
|
||||
|
||||
/* skip past the separator */
|
||||
str = ss + sz;
|
||||
|
||||
times--;
|
||||
}
|
||||
|
||||
/* add the rest of the string */
|
||||
list = xs_list_append(list, str);
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
|
||||
/** dicts **/
|
||||
|
||||
d_char *xs_dict_new(void)
|
||||
/* creates a new dict */
|
||||
{
|
||||
d_char *dict;
|
||||
|
||||
dict = malloc(_xs_blk_size(2));
|
||||
dict[0] = XSTYPE_SOD;
|
||||
dict[1] = XSTYPE_EOD;
|
||||
|
||||
return dict;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_dict_append_m(d_char *dict, const char *key, const char *mem, int dsz)
|
||||
/* adds a memory block to the dict */
|
||||
{
|
||||
char c = XSTYPE_DITEM;
|
||||
int sz = xs_size(dict);
|
||||
int ksz = xs_size(key);
|
||||
|
||||
dict = xs_insert_m(dict, sz - 1, &c, 1);
|
||||
dict = xs_insert_m(dict, sz, key, ksz);
|
||||
dict = xs_insert_m(dict, sz + ksz, mem, dsz);
|
||||
|
||||
return dict;
|
||||
}
|
||||
|
||||
|
||||
int xs_dict_iter(char **dict, char **key, char **value)
|
||||
/* iterates a dict value */
|
||||
{
|
||||
int goon = 1;
|
||||
char *p;
|
||||
|
||||
if (dict == NULL || *dict == NULL)
|
||||
return 0;
|
||||
|
||||
p = *dict;
|
||||
|
||||
/* skip a possible start of the list */
|
||||
if (*p == XSTYPE_SOD)
|
||||
p++;
|
||||
|
||||
/* an element? */
|
||||
if (*p == XSTYPE_DITEM) {
|
||||
p++;
|
||||
|
||||
*key = p;
|
||||
p += xs_size(*key);
|
||||
|
||||
*value = p;
|
||||
p += xs_size(*value);
|
||||
}
|
||||
else {
|
||||
/* end of list */
|
||||
p++;
|
||||
goon = 0;
|
||||
}
|
||||
|
||||
/* store back the pointer */
|
||||
*dict = p;
|
||||
|
||||
return goon;
|
||||
}
|
||||
|
||||
|
||||
char *xs_dict_get(char *dict, const char *key)
|
||||
/* returns the value directed by key */
|
||||
{
|
||||
char *k, *v, *r = NULL;
|
||||
|
||||
while (xs_dict_iter(&dict, &k, &v)) {
|
||||
if (strcmp(k, key) == 0) {
|
||||
r = v;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_dict_del(d_char *dict, const char *key)
|
||||
/* deletes a key */
|
||||
{
|
||||
char *k, *v;
|
||||
char *p = dict;
|
||||
|
||||
while (xs_dict_iter(&p, &k, &v)) {
|
||||
if (strcmp(k, key) == 0) {
|
||||
/* the address of the item is just behind the key */
|
||||
char *i = k - 1;
|
||||
|
||||
dict = xs_collapse(dict, i - dict, xs_size(i));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return dict;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_dict_set(d_char *dict, const char *key, const char *data)
|
||||
/* sets (replaces) a key */
|
||||
{
|
||||
/* delete the possibly existing key */
|
||||
dict = xs_dict_del(dict, key);
|
||||
|
||||
/* append the data */
|
||||
dict = xs_dict_append(dict, key, data);
|
||||
|
||||
return dict;
|
||||
}
|
||||
|
||||
|
||||
/** other values **/
|
||||
|
||||
d_char *xs_val_new(xstype t)
|
||||
/* adds a new special value */
|
||||
{
|
||||
d_char *v = malloc(_xs_blk_size(1));
|
||||
|
||||
v[0] = t;
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_number_new(float f)
|
||||
/* adds a new number value */
|
||||
{
|
||||
d_char *v = malloc(_xs_blk_size(1 + sizeof(float)));
|
||||
|
||||
v[0] = XSTYPE_NUMBER;
|
||||
memcpy(&v[1], &f, sizeof(float));
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
float xs_get_number(char *v)
|
||||
/* gets the number as a float */
|
||||
{
|
||||
float f = 0.0;
|
||||
|
||||
if (v[0] == XSTYPE_NUMBER)
|
||||
memcpy(&f, &v[1], sizeof(float));
|
||||
|
||||
return f;
|
||||
}
|
||||
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* _XS_H */
|
||||
177
xs_curl.h
Normal file
177
xs_curl.h
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_CURL_H
|
||||
|
||||
#define _XS_CURL_H
|
||||
|
||||
d_char *xs_http_request(char *method, char *url, d_char *headers,
|
||||
d_char *body, int b_size,
|
||||
int *status, d_char **payload, int *p_size);
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
#include <curl/curl.h>
|
||||
|
||||
static size_t _header_callback(char *buffer, size_t size,
|
||||
size_t nitems, d_char **userdata)
|
||||
{
|
||||
d_char *headers = *userdata;
|
||||
xs *l;
|
||||
|
||||
/* get the line */
|
||||
l = xs_str_new(NULL);
|
||||
l = xs_append_m(l, buffer, size * nitems);
|
||||
l = xs_strip(l);
|
||||
|
||||
/* only the HTTP/x 200 line and the last one doesn't have ': ' */
|
||||
if (xs_str_in(l, ": ") != -1) {
|
||||
xs *knv = xs_splitn(l, ": ", 1);
|
||||
|
||||
headers = xs_dict_append(headers, xs_list_get(knv, 0), xs_list_get(knv, 1));
|
||||
}
|
||||
else
|
||||
if (xs_startswith(l, "HTTP/"))
|
||||
headers = xs_dict_append(headers, "_proto", l);
|
||||
|
||||
*userdata = headers;
|
||||
|
||||
return nitems * size;
|
||||
}
|
||||
|
||||
|
||||
struct _payload_data {
|
||||
char *data;
|
||||
int size;
|
||||
int offset;
|
||||
};
|
||||
|
||||
static int _data_callback(void *buffer, size_t size,
|
||||
size_t nitems, struct _payload_data *pd)
|
||||
{
|
||||
int sz = size * nitems;
|
||||
|
||||
/* open space */
|
||||
pd->size += sz;
|
||||
pd->data = realloc(pd->data, pd->size + 1);
|
||||
|
||||
/* copy data */
|
||||
memcpy(pd->data + pd->offset, buffer, sz);
|
||||
pd->offset += sz;
|
||||
|
||||
return sz;
|
||||
}
|
||||
|
||||
|
||||
static int _post_callback(char *buffer, size_t size,
|
||||
size_t nitems, struct _payload_data *pd)
|
||||
{
|
||||
/* size of data left */
|
||||
int sz = pd->size - pd->offset;
|
||||
|
||||
/* if it's still bigger than the provided space, trim */
|
||||
if (sz > size * nitems)
|
||||
sz = size * nitems;
|
||||
|
||||
memcpy(buffer, pd->data + pd->offset, sz);
|
||||
|
||||
/* skip sent data */
|
||||
pd->offset += sz;
|
||||
|
||||
return sz;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_http_request(char *method, char *url, d_char *headers,
|
||||
d_char *body, int b_size,
|
||||
int *status, d_char **payload, int *p_size)
|
||||
/* does an HTTP request */
|
||||
{
|
||||
d_char *response;
|
||||
CURL *curl;
|
||||
struct curl_slist *list = NULL;
|
||||
char *k, *v, *p;
|
||||
long lstatus;
|
||||
|
||||
response = xs_dict_new();
|
||||
|
||||
curl = curl_easy_init();
|
||||
|
||||
curl_easy_setopt(curl, CURLOPT_URL, url);
|
||||
|
||||
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5L);
|
||||
|
||||
/* force HTTP/1.1 */
|
||||
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
|
||||
|
||||
/* obey redirections */
|
||||
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
|
||||
|
||||
/* store response headers here */
|
||||
curl_easy_setopt(curl, CURLOPT_HEADERDATA, &response);
|
||||
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, _header_callback);
|
||||
|
||||
struct _payload_data ipd = { NULL, 0, 0 };
|
||||
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ipd);
|
||||
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, _data_callback);
|
||||
|
||||
if (strcmp(method, "POST") == 0) {
|
||||
curl_easy_setopt(curl, CURLOPT_POST, 1L);
|
||||
|
||||
if (body != NULL) {
|
||||
if (b_size <= 0)
|
||||
b_size = xs_size(body);
|
||||
|
||||
/* add the content-length header */
|
||||
char tmp[32];
|
||||
sprintf(tmp, "content-length: %d", b_size);
|
||||
list = curl_slist_append(list, tmp);
|
||||
|
||||
struct _payload_data pd = { body, b_size, 0 };
|
||||
|
||||
curl_easy_setopt(curl, CURLOPT_READDATA, &pd);
|
||||
curl_easy_setopt(curl, CURLOPT_READFUNCTION, _post_callback);
|
||||
}
|
||||
}
|
||||
|
||||
/* fill the request headers */
|
||||
p = headers;
|
||||
while (xs_dict_iter(&p, &k, &v)) {
|
||||
xs *h;
|
||||
|
||||
const char *args[] = { k, v, NULL };
|
||||
h = xs_fmt("%s: %s", args);
|
||||
|
||||
list = curl_slist_append(list, h);
|
||||
}
|
||||
|
||||
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
|
||||
|
||||
/* do it */
|
||||
curl_easy_perform(curl);
|
||||
|
||||
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &lstatus);
|
||||
|
||||
curl_easy_cleanup(curl);
|
||||
|
||||
if (status != NULL)
|
||||
*status = (int) lstatus;
|
||||
|
||||
if (p_size != NULL)
|
||||
*p_size = ipd.size;
|
||||
|
||||
if (payload != NULL) {
|
||||
*payload = ipd.data;
|
||||
|
||||
/* add an asciiz just in case (but not touching p_size) */
|
||||
if (ipd.data != NULL)
|
||||
ipd.data[ipd.size] = '\0';
|
||||
}
|
||||
else
|
||||
free(ipd.data);
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* _XS_CURL_H */
|
||||
180
xs_encdec.h
Normal file
180
xs_encdec.h
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_ENCDEC_H
|
||||
|
||||
#define _XS_ENCDEC_H
|
||||
|
||||
d_char *xs_hex_enc(const char *data, int size);
|
||||
d_char *xs_hex_dec(const char *hex);
|
||||
d_char *xs_base64_enc(const char *data, int sz);
|
||||
d_char *xs_base64_dec(const char *data, int *size);
|
||||
d_char *xs_utf8_enc(d_char *str, unsigned int cpoint);
|
||||
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
d_char *xs_hex_enc(const char *data, int size)
|
||||
/* returns an hexdump of data */
|
||||
{
|
||||
d_char *s;
|
||||
char *p;
|
||||
int n;
|
||||
|
||||
p = s = calloc(size * 2 + 1, 1);
|
||||
|
||||
for (n = 0; n < size; n++) {
|
||||
sprintf(p, "%02x", (unsigned char)data[n]);
|
||||
p += 2;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_hex_dec(const char *hex)
|
||||
/* decodes an hexdump into data */
|
||||
{
|
||||
int sz = strlen(hex);
|
||||
d_char *s;
|
||||
char *p;
|
||||
int n;
|
||||
|
||||
p = s = calloc(sz / 2, 1);
|
||||
|
||||
for (n = 0; n < sz; n += 2) {
|
||||
int i;
|
||||
if (sscanf(&hex[n], "%02x", &i) == 0) {
|
||||
/* decoding error */
|
||||
free(s);
|
||||
s = NULL;
|
||||
}
|
||||
else
|
||||
*p = i;
|
||||
|
||||
p++;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_base64_enc(const char *data, int sz)
|
||||
/* encodes data to base64 */
|
||||
{
|
||||
d_char *s;
|
||||
unsigned char *p;
|
||||
int n;
|
||||
static char *b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
||||
"abcdefghijklmnopqrstuvwxyz"
|
||||
"0123456789+/";
|
||||
|
||||
s = xs_str_new(NULL);
|
||||
p = (unsigned char *)data;
|
||||
|
||||
for (n = 0; n < sz; n += 3) {
|
||||
int l = sz - n;
|
||||
|
||||
if (l == 1) {
|
||||
s = xs_append_m(s, &b64_tbl[(p[n] >> 2) & 0x3f], 1);
|
||||
s = xs_append_m(s, &b64_tbl[(p[n] << 4) & 0x3f], 1);
|
||||
s = xs_append_m(s, "==", 2);
|
||||
}
|
||||
else
|
||||
if (l == 2) {
|
||||
s = xs_append_m(s, &b64_tbl[(p[n] >> 2) & 0x3f], 1);
|
||||
s = xs_append_m(s, &b64_tbl[(p[n] << 4 | p[n + 1] >> 4) & 0x3f], 1);
|
||||
s = xs_append_m(s, &b64_tbl[(p[n + 1] << 2) & 0x3f], 1);
|
||||
s = xs_append_m(s, "=", 1);
|
||||
}
|
||||
else {
|
||||
s = xs_append_m(s, &b64_tbl[(p[n] >> 2) & 0x3f], 1);
|
||||
s = xs_append_m(s, &b64_tbl[(p[n] << 4 | p[n + 1] >> 4) & 0x3f], 1);
|
||||
s = xs_append_m(s, &b64_tbl[(p[n + 1] << 2 | p[n + 2] >> 6) & 0x3f], 1);
|
||||
s = xs_append_m(s, &b64_tbl[(p[n + 2]) & 0x3f], 1);
|
||||
}
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_base64_dec(const char *data, int *size)
|
||||
/* decodes data from base64 */
|
||||
{
|
||||
d_char *s = NULL;
|
||||
int sz = 0;
|
||||
char *p;
|
||||
static char *b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
||||
"abcdefghijklmnopqrstuvwxyz"
|
||||
"0123456789+/=";
|
||||
|
||||
p = (char *)data;
|
||||
|
||||
for (p = (char *)data; *p; p += 4) {
|
||||
int cs[4];
|
||||
int n;
|
||||
unsigned char tmp[3];
|
||||
|
||||
for (n = 0; n < 4; n++) {
|
||||
char *ss = strchr(b64_tbl, p[n]);
|
||||
|
||||
if (ss == NULL) {
|
||||
/* not a base64 char */
|
||||
free(s);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cs[n] = ss - b64_tbl;
|
||||
}
|
||||
|
||||
n = 0;
|
||||
|
||||
/* first byte */
|
||||
tmp[n++] = cs[0] << 2 | ((cs[1] >> 4) & 0x0f);
|
||||
|
||||
/* second byte */
|
||||
if (cs[2] != 64)
|
||||
tmp[n++] = cs[1] << 4 | ((cs[2] >> 2) & 0x3f);
|
||||
|
||||
/* third byte */
|
||||
if (cs[3] != 64)
|
||||
tmp[n++] = cs[2] << 6 | (cs[3] & 0x3f);
|
||||
|
||||
/* must be done manually because data can be pure binary */
|
||||
s = realloc(s, sz + n);
|
||||
memcpy(s + sz, tmp, n);
|
||||
sz += n;
|
||||
}
|
||||
|
||||
*size = sz;
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_utf8_enc(d_char *str, unsigned int cpoint)
|
||||
/* encodes an Unicode codepoint to utf8 */
|
||||
{
|
||||
unsigned char tmp[4];
|
||||
int n = 0;
|
||||
|
||||
if (cpoint < 0x80)
|
||||
tmp[n++] = cpoint & 0xff;
|
||||
else
|
||||
if (cpoint < 0x800) {
|
||||
tmp[n++] = 0xc0 | (cpoint >> 6);
|
||||
tmp[n++] = 0x80 | (cpoint & 0x3f);
|
||||
}
|
||||
else
|
||||
if (cpoint < 0x10000) {
|
||||
tmp[n++] = 0xe0 | (cpoint >> 12);
|
||||
tmp[n++] = 0x80 | ((cpoint >> 6) & 0x3f);
|
||||
tmp[n++] = 0x80 | (cpoint & 0x3f);
|
||||
}
|
||||
|
||||
return xs_append_m(str, (char *)tmp, n);
|
||||
}
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* _XS_ENCDEC_H */
|
||||
184
xs_httpd.h
Normal file
184
xs_httpd.h
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_HTTPD_H
|
||||
|
||||
#define _XS_HTTPD_H
|
||||
|
||||
d_char *xs_url_dec(char *str);
|
||||
d_char *xs_url_vars(char *str);
|
||||
d_char *xs_httpd_request(FILE *f);
|
||||
void xs_httpd_response(FILE *f, int status, d_char *headers, char *body, int b_size);
|
||||
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
d_char *xs_url_dec(char *str)
|
||||
/* decodes an URL */
|
||||
{
|
||||
d_char *s = xs_str_new(NULL);
|
||||
|
||||
while (*str) {
|
||||
if (*str == '%') {
|
||||
int i;
|
||||
|
||||
if (sscanf(str + 1, "%02x", &i) == 1) {
|
||||
unsigned char uc = i;
|
||||
|
||||
s = xs_append_m(s, (char *)&uc, 1);
|
||||
str += 2;
|
||||
}
|
||||
}
|
||||
else
|
||||
if (*str == '+')
|
||||
s = xs_append_m(s, " ", 1);
|
||||
else
|
||||
s = xs_append_m(s, str, 1);
|
||||
|
||||
str++;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_url_vars(char *str)
|
||||
/* parse url variables */
|
||||
{
|
||||
d_char *vars;
|
||||
|
||||
vars = xs_dict_new();
|
||||
|
||||
if (str != NULL) {
|
||||
char *v, *l;
|
||||
xs *args;
|
||||
|
||||
/* split by arguments */
|
||||
args = xs_split(str, "&");
|
||||
|
||||
l = args;
|
||||
while (xs_list_iter(&l, &v)) {
|
||||
xs *kv = xs_splitn(v, "=", 2);
|
||||
|
||||
if (xs_list_len(kv) == 2)
|
||||
vars = xs_dict_append(vars,
|
||||
xs_list_get(kv, 0), xs_list_get(kv, 1));
|
||||
}
|
||||
}
|
||||
|
||||
return vars;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_httpd_request(FILE *f)
|
||||
/* processes an httpd connection */
|
||||
{
|
||||
xs *headers = NULL;
|
||||
xs *q_vars = NULL;
|
||||
xs *p_vars = NULL;
|
||||
d_char *req = NULL;
|
||||
xs *l1, *l2;
|
||||
char *v;
|
||||
|
||||
xs_socket_timeout(fileno(f), 2.0, 0.0);
|
||||
|
||||
/* read the first line and split it */
|
||||
l1 = xs_strip(xs_readline(f));
|
||||
l2 = xs_split(l1, " ");
|
||||
|
||||
if (xs_list_len(l2) != 3) {
|
||||
/* error or timeout */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
headers = xs_dict_new();
|
||||
|
||||
headers = xs_dict_append(headers, "method", xs_list_get(l2, 0));
|
||||
headers = xs_dict_append(headers, "proto", xs_list_get(l2, 2));
|
||||
|
||||
{
|
||||
/* split the path with its optional variables */
|
||||
xs *udp = xs_url_dec(xs_list_get(l2, 1));
|
||||
xs *pnv = xs_splitn(udp, "?", 1);
|
||||
|
||||
/* store the path */
|
||||
headers = xs_dict_append(headers, "path", xs_list_get(pnv, 0));
|
||||
|
||||
/* get the variables */
|
||||
q_vars = xs_url_vars(xs_list_get(pnv, 1));
|
||||
}
|
||||
|
||||
/* read the headers */
|
||||
for (;;) {
|
||||
xs *l, *p = NULL;
|
||||
|
||||
l = xs_strip(xs_readline(f));
|
||||
|
||||
/* done with the header? */
|
||||
if (strcmp(l, "") == 0)
|
||||
break;
|
||||
|
||||
/* split header and content */
|
||||
p = xs_splitn(l, ": ", 1);
|
||||
|
||||
if (xs_list_len(p) == 2)
|
||||
headers = xs_dict_append(headers,
|
||||
xs_tolower(xs_list_get(p, 0)), xs_list_get(p, 1));
|
||||
}
|
||||
|
||||
xs_socket_timeout(fileno(f), 5.0, 0.0);
|
||||
|
||||
/* does it have a payload with form urlencoded variables? */
|
||||
v = xs_dict_get(headers, "content-type");
|
||||
|
||||
if (v && strcmp(v, "application/x-www-form-urlencoded") == 0) {
|
||||
if ((v = xs_dict_get(headers, "content-length")) != NULL) {
|
||||
int cl = atoi(v);
|
||||
xs *payload;
|
||||
|
||||
if ((payload = xs_read(f, cl)) != NULL) {
|
||||
xs *upl = xs_url_dec(payload);
|
||||
p_vars = xs_url_vars(upl);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
p_vars = xs_dict_new();
|
||||
|
||||
if (errno == 0) {
|
||||
req = xs_dict_new();
|
||||
req = xs_dict_append(req, "headers", headers);
|
||||
req = xs_dict_append(req, "q_vars", q_vars);
|
||||
req = xs_dict_append(req, "p_vars", p_vars);
|
||||
}
|
||||
|
||||
return req;
|
||||
}
|
||||
|
||||
|
||||
void xs_httpd_response(FILE *f, int status, d_char *headers, char *body, int b_size)
|
||||
/* sends an httpd response */
|
||||
{
|
||||
xs *proto;
|
||||
char *p, *k, *v;
|
||||
|
||||
proto = xs_fmt("HTTP/1.1 %d", status);
|
||||
fprintf(f, "%s\r\n", proto);
|
||||
|
||||
p = headers;
|
||||
while (xs_dict_iter(&p, &k, &v)) {
|
||||
fprintf(f, "%s: %s\r\n", k, v);
|
||||
}
|
||||
|
||||
if (b_size != 0)
|
||||
fprintf(f, "content-length: %d\r\n", b_size);
|
||||
|
||||
fprintf(f, "\r\n");
|
||||
|
||||
if (body != NULL && b_size != 0)
|
||||
fwrite(body, b_size, 1, f);
|
||||
}
|
||||
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* XS_HTTPD_H */
|
||||
86
xs_io.h
Normal file
86
xs_io.h
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_IO_H
|
||||
|
||||
#define _XS_IO_H
|
||||
|
||||
d_char *xs_readall(FILE *f);
|
||||
d_char *xs_readline(FILE *f);
|
||||
d_char *xs_read(FILE *f, int size);
|
||||
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
d_char *xs_readall(FILE *f)
|
||||
/* reads the rest of the file into a string */
|
||||
{
|
||||
d_char *s;
|
||||
char tmp[1024];
|
||||
|
||||
errno = 0;
|
||||
|
||||
/* create the new string */
|
||||
s = xs_str_new(NULL);
|
||||
|
||||
while (fgets(tmp, sizeof(tmp), f))
|
||||
s = xs_str_cat(s, tmp);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_readline(FILE *f)
|
||||
/* reads a line from a file */
|
||||
{
|
||||
d_char *s = NULL;
|
||||
|
||||
errno = 0;
|
||||
|
||||
/* don't even try on eof */
|
||||
if (!feof(f)) {
|
||||
int c;
|
||||
|
||||
s = xs_str_new(NULL);
|
||||
|
||||
while ((c = fgetc(f)) != EOF) {
|
||||
unsigned char rc = c;
|
||||
|
||||
s = xs_append_m(s, (char *)&rc, 1);
|
||||
|
||||
if (c == '\n')
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_read(FILE *f, int size)
|
||||
/* reads up to size bytes from f */
|
||||
{
|
||||
d_char *s;
|
||||
|
||||
errno = 0;
|
||||
|
||||
s = xs_str_new(NULL);
|
||||
|
||||
while (size != 0 && !feof(f)) {
|
||||
char tmp[2048];
|
||||
int n, r;
|
||||
|
||||
if ((n = sizeof(tmp)) > size)
|
||||
n = size;
|
||||
|
||||
r = fread(tmp, 1, n, f);
|
||||
s = xs_append_m(s, tmp, r);
|
||||
|
||||
size -= r;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* _XS_IO_H */
|
||||
501
xs_json.h
Normal file
501
xs_json.h
Normal file
|
|
@ -0,0 +1,501 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_JSON_H
|
||||
|
||||
#define _XS_JSON_H
|
||||
|
||||
d_char *xs_json_dumps_pp(char *data, int indent);
|
||||
#define xs_json_dumps(data) xs_json_dumps_pp(data, 0)
|
||||
d_char *xs_json_loads(const char *json);
|
||||
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
/** IMPLEMENTATION **/
|
||||
|
||||
/** JSON dumps **/
|
||||
|
||||
d_char *_xs_json_dumps_str(d_char *s, char *data)
|
||||
/* dumps a string in JSON format */
|
||||
{
|
||||
unsigned char c;
|
||||
s = xs_str_cat(s, "\"");
|
||||
|
||||
while ((c = *data)) {
|
||||
if (c == '\n')
|
||||
s = xs_str_cat(s, "\\n");
|
||||
else
|
||||
if (c == '\r')
|
||||
s = xs_str_cat(s, "\\r");
|
||||
else
|
||||
if (c == '\t')
|
||||
s = xs_str_cat(s, "\\t");
|
||||
else
|
||||
if (c == '\\')
|
||||
s = xs_str_cat(s, "\\\\");
|
||||
else
|
||||
if (c == '"')
|
||||
s = xs_str_cat(s, "\\\"");
|
||||
else
|
||||
if (c < 32) {
|
||||
char tmp[10];
|
||||
|
||||
sprintf(tmp, "\\u%04x", (unsigned int) c);
|
||||
s = xs_str_cat(s, tmp);
|
||||
}
|
||||
else
|
||||
s = xs_append_m(s, data, 1);
|
||||
|
||||
data++;
|
||||
}
|
||||
|
||||
s = xs_str_cat(s, "\"");
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *_xs_json_indent(d_char *s, int level, int indent)
|
||||
/* adds indentation */
|
||||
{
|
||||
if (indent) {
|
||||
int n;
|
||||
|
||||
s = xs_str_cat(s, "\n");
|
||||
|
||||
for (n = 0; n < level * indent; n++)
|
||||
s = xs_str_cat(s, " ");
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *_xs_json_dumps(d_char *s, char *data, int level, int indent)
|
||||
/* dumps partial data as JSON */
|
||||
{
|
||||
char *k, *v;
|
||||
int c = 0;
|
||||
|
||||
switch (xs_type(data)) {
|
||||
case XSTYPE_NULL:
|
||||
s = xs_str_cat(s, "null");
|
||||
break;
|
||||
|
||||
case XSTYPE_TRUE:
|
||||
s = xs_str_cat(s, "true");
|
||||
break;
|
||||
|
||||
case XSTYPE_FALSE:
|
||||
s = xs_str_cat(s, "false");
|
||||
break;
|
||||
|
||||
case XSTYPE_NUMBER:
|
||||
{
|
||||
char tmp[32];
|
||||
snprintf(tmp, sizeof(tmp), "%g", xs_get_number(data));
|
||||
s = xs_str_cat(s, tmp);
|
||||
}
|
||||
break;
|
||||
|
||||
case XSTYPE_SOL:
|
||||
s = xs_str_cat(s, "[");
|
||||
|
||||
while (xs_list_iter(&data, &v)) {
|
||||
if (c != 0)
|
||||
s = xs_str_cat(s, ",");
|
||||
|
||||
s = _xs_json_indent(s, level + 1, indent);
|
||||
s = _xs_json_dumps(s, v, level + 1, indent);
|
||||
|
||||
c++;
|
||||
}
|
||||
|
||||
s = _xs_json_indent(s, level, indent);
|
||||
s = xs_str_cat(s, "]");
|
||||
|
||||
break;
|
||||
|
||||
case XSTYPE_SOD:
|
||||
s = xs_str_cat(s, "{");
|
||||
|
||||
while (xs_dict_iter(&data, &k, &v)) {
|
||||
if (c != 0)
|
||||
s = xs_str_cat(s, ",");
|
||||
|
||||
s = _xs_json_indent(s, level + 1, indent);
|
||||
|
||||
s = _xs_json_dumps_str(s, k);
|
||||
s = xs_str_cat(s, ":");
|
||||
|
||||
if (indent)
|
||||
s = xs_str_cat(s, " ");
|
||||
|
||||
s = _xs_json_dumps(s, v, level + 1, indent);
|
||||
|
||||
c++;
|
||||
}
|
||||
|
||||
s = _xs_json_indent(s, level, indent);
|
||||
s = xs_str_cat(s, "}");
|
||||
break;
|
||||
|
||||
case XSTYPE_STRING:
|
||||
s = _xs_json_dumps_str(s, data);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_json_dumps_pp(char *data, int indent)
|
||||
/* dumps a piece of data as JSON */
|
||||
{
|
||||
xstype t = xs_type(data);
|
||||
d_char *s = NULL;
|
||||
|
||||
if (t == XSTYPE_SOL || t == XSTYPE_SOD) {
|
||||
s = xs_str_new(NULL);
|
||||
s = _xs_json_dumps(s, data, 0, indent);
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
/** JSON loads **/
|
||||
|
||||
/* this code comes mostly from the Minimum Profit Text Editor (MPDM) */
|
||||
|
||||
typedef enum {
|
||||
JS_ERROR = -1,
|
||||
JS_INCOMPLETE,
|
||||
JS_OCURLY,
|
||||
JS_OBRACK,
|
||||
JS_CCURLY,
|
||||
JS_CBRACK,
|
||||
JS_COMMA,
|
||||
JS_COLON,
|
||||
JS_VALUE,
|
||||
JS_STRING,
|
||||
JS_INTEGER,
|
||||
JS_REAL,
|
||||
JS_TRUE,
|
||||
JS_FALSE,
|
||||
JS_NULL,
|
||||
JS_ARRAY,
|
||||
JS_OBJECT
|
||||
} js_type;
|
||||
|
||||
|
||||
d_char *_xs_json_loads_lexer(const char **json, js_type *t)
|
||||
{
|
||||
char c;
|
||||
const char *s = *json;
|
||||
d_char *v = NULL;
|
||||
|
||||
/* skip blanks */
|
||||
while (*s == L' ' || *s == L'\t' || *s == L'\n' || *s == L'\r')
|
||||
s++;
|
||||
|
||||
c = *s++;
|
||||
|
||||
if (c == '{')
|
||||
*t = JS_OCURLY;
|
||||
else
|
||||
if (c == '}')
|
||||
*t = JS_CCURLY;
|
||||
else
|
||||
if (c == '[')
|
||||
*t = JS_OBRACK;
|
||||
else
|
||||
if (c == ']')
|
||||
*t = JS_CBRACK;
|
||||
else
|
||||
if (c == ',')
|
||||
*t = JS_COMMA;
|
||||
else
|
||||
if (c == ':')
|
||||
*t = JS_COLON;
|
||||
else
|
||||
if (c == '"') {
|
||||
*t = JS_STRING;
|
||||
|
||||
v = xs_str_new(NULL);
|
||||
|
||||
while ((c = *s) != '"' && c != '\0') {
|
||||
char tmp[5];
|
||||
int i;
|
||||
|
||||
if (c == '\\') {
|
||||
s++;
|
||||
c = *s;
|
||||
switch (c) {
|
||||
case 'n': c = '\n'; break;
|
||||
case 'r': c = '\r'; break;
|
||||
case 't': c = '\t'; break;
|
||||
case 'u': /* Unicode codepoint as an hex char */
|
||||
s++;
|
||||
tmp[0] = (char)*s; s++;
|
||||
tmp[1] = (char)*s; s++;
|
||||
tmp[2] = (char)*s; s++;
|
||||
tmp[3] = (char)*s;
|
||||
tmp[4] = '\0';
|
||||
|
||||
sscanf(tmp, "%04x", &i);
|
||||
|
||||
v = xs_utf8_enc(v, i);
|
||||
c = '\0';
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (c)
|
||||
v = xs_append_m(v, &c, 1);
|
||||
|
||||
s++;
|
||||
}
|
||||
|
||||
if (c != '\0')
|
||||
s++;
|
||||
}
|
||||
else
|
||||
if (c == '-' || (c >= '0' && c <= '9') || c == '.') {
|
||||
xs *vn = NULL;
|
||||
|
||||
*t = JS_INTEGER;
|
||||
|
||||
vn = xs_str_new(NULL);
|
||||
vn = xs_append_m(vn, &c, 1);
|
||||
|
||||
while (((c = *s) >= '0' && c <= '9') || c == '.') {
|
||||
if (c == '.')
|
||||
*t = JS_REAL;
|
||||
|
||||
vn = xs_append_m(vn, &c, 1);
|
||||
s++;
|
||||
}
|
||||
|
||||
/* convert to XSTYPE_NUMBER */
|
||||
v = xs_number_new(atof(vn));
|
||||
}
|
||||
else
|
||||
if (c == 't' && strncmp(s, "rue", 3) == 0) {
|
||||
s += 3;
|
||||
*t = JS_TRUE;
|
||||
|
||||
v = xs_val_new(XSTYPE_TRUE);
|
||||
}
|
||||
else
|
||||
if (c == 'f' && strncmp(s, "alse", 4) == 0) {
|
||||
s += 4;
|
||||
*t = JS_FALSE;
|
||||
|
||||
v = xs_val_new(XSTYPE_FALSE);
|
||||
}
|
||||
else
|
||||
if (c == 'n' && strncmp(s, "ull", 3) == 0) {
|
||||
s += 3;
|
||||
*t = JS_NULL;
|
||||
|
||||
v = xs_val_new(XSTYPE_NULL);
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
|
||||
*json = s;
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
d_char *_xs_json_loads_array(const char **json, js_type *t);
|
||||
d_char *_xs_json_loads_object(const char **json, js_type *t);
|
||||
|
||||
d_char *_xs_json_loads_value(const char **json, js_type *t, d_char *v)
|
||||
/* parses a JSON value */
|
||||
{
|
||||
if (*t == JS_OBRACK)
|
||||
v = _xs_json_loads_array(json, t);
|
||||
else
|
||||
if (*t == JS_OCURLY)
|
||||
v = _xs_json_loads_object(json, t);
|
||||
|
||||
if (*t >= JS_VALUE)
|
||||
*t = JS_VALUE;
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
d_char *_xs_json_loads_array(const char **json, js_type *t)
|
||||
/* parses a JSON array */
|
||||
{
|
||||
const char *s = *json;
|
||||
xs *v;
|
||||
d_char *l;
|
||||
js_type tt;
|
||||
|
||||
l = xs_list_new();
|
||||
|
||||
*t = JS_INCOMPLETE;
|
||||
|
||||
v = _xs_json_loads_lexer(&s, &tt);
|
||||
|
||||
if (tt == JS_CBRACK)
|
||||
*t = JS_ARRAY;
|
||||
else {
|
||||
v = _xs_json_loads_value(&s, &tt, v);
|
||||
|
||||
if (tt == JS_VALUE) {
|
||||
l = xs_list_append(l, v);
|
||||
|
||||
while (*t == JS_INCOMPLETE) {
|
||||
_xs_json_loads_lexer(&s, &tt);
|
||||
|
||||
if (tt == JS_CBRACK)
|
||||
*t = JS_ARRAY;
|
||||
else
|
||||
if (tt == JS_COMMA) {
|
||||
xs *v2;
|
||||
|
||||
v2 = _xs_json_loads_lexer(&s, &tt);
|
||||
v2 = _xs_json_loads_value(&s, &tt, v2);
|
||||
|
||||
if (tt == JS_VALUE)
|
||||
l = xs_list_append(l, v2);
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
|
||||
if (*t == JS_ERROR) {
|
||||
free(l);
|
||||
l = NULL;
|
||||
}
|
||||
|
||||
*json = s;
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
|
||||
d_char *_xs_json_loads_object(const char **json, js_type *t)
|
||||
/* parses a JSON object */
|
||||
{
|
||||
const char *s = *json;
|
||||
xs *k1;
|
||||
d_char *d;
|
||||
js_type tt;
|
||||
|
||||
d = xs_dict_new();
|
||||
|
||||
*t = JS_INCOMPLETE;
|
||||
|
||||
k1 = _xs_json_loads_lexer(&s, &tt);
|
||||
|
||||
if (tt == JS_CCURLY)
|
||||
*t = JS_OBJECT;
|
||||
else
|
||||
if (tt == JS_STRING) {
|
||||
_xs_json_loads_lexer(&s, &tt);
|
||||
|
||||
if (tt == JS_COLON) {
|
||||
xs *v1;
|
||||
|
||||
v1 = _xs_json_loads_lexer(&s, &tt);
|
||||
v1 = _xs_json_loads_value(&s, &tt, v1);
|
||||
|
||||
if (tt == JS_VALUE) {
|
||||
d = xs_dict_append(d, k1, v1);
|
||||
|
||||
while (*t == JS_INCOMPLETE) {
|
||||
_xs_json_loads_lexer(&s, &tt);
|
||||
|
||||
if (tt == JS_CCURLY)
|
||||
*t = JS_OBJECT;
|
||||
else
|
||||
if (tt == JS_COMMA) {
|
||||
xs *k;
|
||||
|
||||
k = _xs_json_loads_lexer(&s, &tt);
|
||||
|
||||
if (tt == JS_STRING) {
|
||||
_xs_json_loads_lexer(&s, &tt);
|
||||
|
||||
if (tt == JS_COLON) {
|
||||
xs *v;
|
||||
|
||||
v = _xs_json_loads_lexer(&s, &tt);
|
||||
v = _xs_json_loads_value(&s, &tt, v);
|
||||
|
||||
if (tt == JS_VALUE)
|
||||
d = xs_dict_append(d, k, v);
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
}
|
||||
else
|
||||
*t = JS_ERROR;
|
||||
|
||||
if (*t == JS_ERROR) {
|
||||
free(d);
|
||||
d = NULL;
|
||||
}
|
||||
|
||||
*json = s;
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_json_loads(const char *json)
|
||||
/* loads a string in JSON format and converts to a multiple data */
|
||||
{
|
||||
d_char *v = NULL;
|
||||
js_type t;
|
||||
|
||||
_xs_json_loads_lexer(&json, &t);
|
||||
|
||||
if (t == JS_OBRACK)
|
||||
v = _xs_json_loads_array(&json, &t);
|
||||
else
|
||||
if (t == JS_OCURLY)
|
||||
v = _xs_json_loads_object(&json, &t);
|
||||
else
|
||||
t = JS_ERROR;
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* _XS_JSON_H */
|
||||
159
xs_openssl.h
Normal file
159
xs_openssl.h
Normal file
|
|
@ -0,0 +1,159 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_OPENSSL_H
|
||||
|
||||
#define _XS_OPENSSL_H
|
||||
|
||||
d_char *xs_md5_hex(const void *input, int size);
|
||||
d_char *xs_sha1_hex(const void *input, int size);
|
||||
d_char *xs_sha256_hex(const void *input, int size);
|
||||
d_char *xs_rsa_genkey(int bits);
|
||||
d_char *xs_rsa_sign(char *secret, char *mem, int size);
|
||||
int xs_rsa_verify(char *pubkey, char *mem, int size, char *b64sig);
|
||||
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
#include "openssl/md5.h"
|
||||
#include "openssl/sha.h"
|
||||
#include "openssl/rsa.h"
|
||||
#include "openssl/pem.h"
|
||||
|
||||
d_char *xs_md5_hex(const void *input, int size)
|
||||
{
|
||||
unsigned char md5[16];
|
||||
MD5_CTX ctx;
|
||||
|
||||
MD5_Init(&ctx);
|
||||
MD5_Update(&ctx, input, size);
|
||||
MD5_Final(md5, &ctx);
|
||||
|
||||
return xs_hex_enc((char *)md5, sizeof(md5));
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_sha1_hex(const void *input, int size)
|
||||
{
|
||||
unsigned char sha1[20];
|
||||
SHA_CTX ctx;
|
||||
|
||||
SHA1_Init(&ctx);
|
||||
SHA1_Update(&ctx, input, size);
|
||||
SHA1_Final(sha1, &ctx);
|
||||
|
||||
return xs_hex_enc((char *)sha1, sizeof(sha1));
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_sha256_hex(const void *input, int size)
|
||||
{
|
||||
unsigned char sha256[32];
|
||||
SHA256_CTX ctx;
|
||||
|
||||
SHA256_Init(&ctx);
|
||||
SHA256_Update(&ctx, input, size);
|
||||
SHA256_Final(sha256, &ctx);
|
||||
|
||||
return xs_hex_enc((char *)sha256, sizeof(sha256));
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_rsa_genkey(int bits)
|
||||
/* generates an RSA keypair */
|
||||
{
|
||||
BIGNUM *bne;
|
||||
RSA *rsa;
|
||||
d_char *keypair = NULL;
|
||||
|
||||
if ((bne = BN_new()) != NULL) {
|
||||
if (BN_set_word(bne, RSA_F4) == 1) {
|
||||
if ((rsa = RSA_new()) != NULL) {
|
||||
if (RSA_generate_key_ex(rsa, bits, bne, NULL) == 1) {
|
||||
BIO *bs = BIO_new(BIO_s_mem());
|
||||
BIO *bp = BIO_new(BIO_s_mem());
|
||||
BUF_MEM *sptr;
|
||||
BUF_MEM *pptr;
|
||||
|
||||
PEM_write_bio_RSAPrivateKey(bs, rsa, NULL, NULL, 0, 0, NULL);
|
||||
BIO_get_mem_ptr(bs, &sptr);
|
||||
|
||||
PEM_write_bio_RSA_PUBKEY(bp, rsa);
|
||||
BIO_get_mem_ptr(bp, &pptr);
|
||||
|
||||
keypair = xs_dict_new();
|
||||
|
||||
keypair = xs_dict_append(keypair, "secret", sptr->data);
|
||||
keypair = xs_dict_append(keypair, "public", pptr->data);
|
||||
|
||||
BIO_free(bs);
|
||||
BIO_free(bp);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return keypair;
|
||||
}
|
||||
|
||||
|
||||
d_char *xs_rsa_sign(char *secret, char *mem, int size)
|
||||
/* signs a memory block (secret is in PEM format) */
|
||||
{
|
||||
d_char *signature = NULL;
|
||||
BIO *b;
|
||||
RSA *rsa;
|
||||
unsigned char *sig;
|
||||
unsigned int sig_len;
|
||||
|
||||
/* un-PEM the key */
|
||||
b = BIO_new_mem_buf(secret, strlen(secret));
|
||||
rsa = PEM_read_bio_RSAPrivateKey(b, NULL, NULL, NULL);
|
||||
|
||||
/* alloc space */
|
||||
sig = malloc(RSA_size(rsa));
|
||||
|
||||
if (RSA_sign(NID_sha256, (unsigned char *)mem, size, sig, &sig_len, rsa) == 1)
|
||||
signature = xs_base64_enc((char *)sig, sig_len);
|
||||
|
||||
BIO_free(b);
|
||||
RSA_free(rsa);
|
||||
free(sig);
|
||||
|
||||
return signature;
|
||||
}
|
||||
|
||||
|
||||
int xs_rsa_verify(char *pubkey, char *mem, int size, char *b64sig)
|
||||
/* verifies a base64 block, returns non-zero on ok */
|
||||
{
|
||||
int r = 0;
|
||||
BIO *b;
|
||||
RSA *rsa;
|
||||
|
||||
/* un-PEM the key */
|
||||
b = BIO_new_mem_buf(pubkey, strlen(pubkey));
|
||||
rsa = PEM_read_bio_RSA_PUBKEY(b, NULL, NULL, NULL);
|
||||
|
||||
if (rsa != NULL) {
|
||||
d_char *sig = NULL;
|
||||
int s_size;
|
||||
|
||||
/* de-base64 */
|
||||
sig = xs_base64_dec(b64sig, &s_size);
|
||||
|
||||
if (sig != NULL)
|
||||
r = RSA_verify(NID_sha256, (unsigned char *)mem, size,
|
||||
(unsigned char *)sig, s_size, rsa);
|
||||
|
||||
free(sig);
|
||||
}
|
||||
|
||||
BIO_free(b);
|
||||
RSA_free(rsa);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* _XS_OPENSSL_H */
|
||||
95
xs_socket.h
Normal file
95
xs_socket.h
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
/* copyright (c) 2022 grunfink - MIT license */
|
||||
|
||||
#ifndef _XS_SOCKET_H
|
||||
|
||||
#define _XS_SOCKET_H
|
||||
|
||||
int xs_socket_timeout(int s, float rto, float sto);
|
||||
int xs_socket_server(char *addr, int port);
|
||||
FILE *xs_socket_accept(int rs);
|
||||
|
||||
|
||||
#ifdef XS_IMPLEMENTATION
|
||||
|
||||
#include <sys/socket.h>
|
||||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
|
||||
|
||||
int xs_socket_timeout(int s, float rto, float sto)
|
||||
/* sets the socket timeout in seconds */
|
||||
{
|
||||
struct timeval tv;
|
||||
int ret = 0;
|
||||
|
||||
if (rto > 0.0) {
|
||||
tv.tv_sec = (int)rto;
|
||||
tv.tv_usec = (int)((rto - (float)(int)rto) * 1000000.0);
|
||||
|
||||
ret = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
|
||||
}
|
||||
|
||||
if (sto > 0.0) {
|
||||
tv.tv_sec = (int)sto;
|
||||
tv.tv_usec = (int)((sto - (float)(int)sto) * 1000000.0);
|
||||
|
||||
ret = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv));
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int xs_socket_server(char *addr, int port)
|
||||
/* opens a server socket */
|
||||
{
|
||||
int rs = -1;
|
||||
struct sockaddr_in host;
|
||||
|
||||
memset(&host, '\0', sizeof(host));
|
||||
|
||||
if (addr != NULL) {
|
||||
struct hostent *he;
|
||||
|
||||
if ((he = gethostbyname(addr)) != NULL)
|
||||
memcpy(&host.sin_addr, he->h_addr_list[0], he->h_length);
|
||||
else
|
||||
goto end;
|
||||
}
|
||||
|
||||
host.sin_family = AF_INET;
|
||||
host.sin_port = htons(port);
|
||||
|
||||
if ((rs = socket(AF_INET, SOCK_STREAM, 0)) != -1) {
|
||||
/* reuse addr */
|
||||
int i = 1;
|
||||
setsockopt(rs, SOL_SOCKET, SO_REUSEADDR, (char *)&i, sizeof(i));
|
||||
|
||||
if (bind(rs, (struct sockaddr *)&host, sizeof(host)) == -1) {
|
||||
close(rs);
|
||||
rs = -1;
|
||||
}
|
||||
else
|
||||
listen(rs, SOMAXCONN);
|
||||
}
|
||||
|
||||
end:
|
||||
return rs;
|
||||
}
|
||||
|
||||
|
||||
FILE *xs_socket_accept(int rs)
|
||||
/* accepts an incoming connection */
|
||||
{
|
||||
int cs = -1;
|
||||
struct sockaddr_in host;
|
||||
socklen_t l = sizeof(host);
|
||||
|
||||
cs = accept(rs, (struct sockaddr *)&host, &l);
|
||||
|
||||
return cs == -1 ? NULL : fdopen(cs, "r+");
|
||||
}
|
||||
|
||||
#endif /* XS_IMPLEMENTATION */
|
||||
|
||||
#endif /* _XS_SOCKET_H */
|
||||
Loading…
Reference in a new issue