9040 lines
253 KiB
C
9040 lines
253 KiB
C
|
// RETOOR - Dec 5 2024
|
|||
|
#ifndef SORM_H
|
|||
|
#define SORM_H
|
|||
|
#ifndef SORM_STR_H
|
|||
|
#define SORM_STR_H
|
|||
|
// RETOOR - Nov 28 2024
|
|||
|
// MIT License
|
|||
|
// ===========
|
|||
|
|
|||
|
// Copyright (c) 2024 Retoor
|
|||
|
|
|||
|
// 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.
|
|||
|
#ifndef RLIB_H
|
|||
|
#define RLIB_H
|
|||
|
// BEGIN OF RLIB
|
|||
|
|
|||
|
/*
|
|||
|
* Line below will be filtered by rmerge
|
|||
|
<script language="Javva script" type="woeiii" src="Pony.html" after-tag="after
|
|||
|
tag" />
|
|||
|
*/
|
|||
|
|
|||
|
#ifndef RTYPES_H
|
|||
|
#define RTYPES_H
|
|||
|
#ifdef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#endif
|
|||
|
#ifndef _POSIX_C_SOURCE
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE 200112L
|
|||
|
#endif
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdint.h> // uint
|
|||
|
#include <string.h>
|
|||
|
#include <sys/types.h> // ulong
|
|||
|
#ifndef ulonglong
|
|||
|
#define ulonglong unsigned long long
|
|||
|
#endif
|
|||
|
#ifndef uint
|
|||
|
typedef unsigned int uint;
|
|||
|
#endif
|
|||
|
#ifndef byte
|
|||
|
typedef unsigned char byte;
|
|||
|
#endif
|
|||
|
#ifdef _POSIX_C_SOURCE_TEMP
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
|
|||
|
#undef _POSIX_C_SOURCE_TEMP
|
|||
|
#else
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#endif
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef NSOCK_H
|
|||
|
#define NSOCK_H
|
|||
|
#ifndef RMALLOC_H
|
|||
|
#define RMALLOC_H
|
|||
|
#ifndef RMALLOC_OVERRIDE
|
|||
|
#define RMALLOC_OVERRIDE 1
|
|||
|
#endif
|
|||
|
#ifdef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#endif
|
|||
|
#ifndef _POSIX_C_SOURCE
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE 200112L
|
|||
|
#endif
|
|||
|
#ifndef ulonglong
|
|||
|
#define ulonglong unsigned long long
|
|||
|
#endif
|
|||
|
#include <locale.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#ifndef RTEMP_H
|
|||
|
#define RTEMP_H
|
|||
|
#include <pthread.h>
|
|||
|
#ifndef RTEMPC_SLOT_COUNT
|
|||
|
#define RTEMPC_SLOT_COUNT 20
|
|||
|
#endif
|
|||
|
#ifndef RTEMPC_SLOT_SIZE
|
|||
|
#define RTEMPC_SLOT_SIZE 1024 * 64 * 128
|
|||
|
#endif
|
|||
|
|
|||
|
bool _rtempc_initialized = 0;
|
|||
|
pthread_mutex_t _rtempc_thread_lock;
|
|||
|
bool rtempc_use_mutex = true;
|
|||
|
byte _current_rtempc_slot = 1;
|
|||
|
char _rtempc_buffer[RTEMPC_SLOT_COUNT][RTEMPC_SLOT_SIZE];
|
|||
|
char *rtempc(char *data) {
|
|||
|
|
|||
|
if (rtempc_use_mutex) {
|
|||
|
if (!_rtempc_initialized) {
|
|||
|
_rtempc_initialized = true;
|
|||
|
pthread_mutex_init(&_rtempc_thread_lock, NULL);
|
|||
|
}
|
|||
|
|
|||
|
pthread_mutex_lock(&_rtempc_thread_lock);
|
|||
|
}
|
|||
|
|
|||
|
uint current_rtempc_slot = _current_rtempc_slot;
|
|||
|
_rtempc_buffer[current_rtempc_slot][0] = 0;
|
|||
|
strcpy(_rtempc_buffer[current_rtempc_slot], data);
|
|||
|
_current_rtempc_slot++;
|
|||
|
if (_current_rtempc_slot == RTEMPC_SLOT_COUNT) {
|
|||
|
_current_rtempc_slot = 0;
|
|||
|
}
|
|||
|
if (rtempc_use_mutex)
|
|||
|
pthread_mutex_unlock(&_rtempc_thread_lock);
|
|||
|
return _rtempc_buffer[current_rtempc_slot];
|
|||
|
}
|
|||
|
|
|||
|
#define sstring(_pname, _psize) \
|
|||
|
static char _##_pname[_psize]; \
|
|||
|
_##_pname[0] = 0; \
|
|||
|
char *_pname = _##_pname;
|
|||
|
|
|||
|
#define string(_pname, _psize) \
|
|||
|
char _##_pname[_psize]; \
|
|||
|
_##_pname[0] = 0; \
|
|||
|
char *_pname = _##_pname;
|
|||
|
|
|||
|
#define sreset(_pname, _psize) _pname = _##_pname;
|
|||
|
|
|||
|
#define sbuf(val) rtempc(val)
|
|||
|
#endif
|
|||
|
#ifdef _POSIX_C_SOURCE_TEMP
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
|
|||
|
#undef _POSIX_C_SOURCE_TEMP
|
|||
|
#else
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#endif
|
|||
|
ulonglong rmalloc_count = 0;
|
|||
|
ulonglong rmalloc_alloc_count = 0;
|
|||
|
ulonglong rmalloc_free_count = 0;
|
|||
|
ulonglong rmalloc_total_bytes_allocated = 0;
|
|||
|
|
|||
|
void *_rmalloc_prev_realloc_obj = NULL;
|
|||
|
size_t _rmalloc_prev_realloc_obj_size = 0;
|
|||
|
|
|||
|
void *rmalloc(size_t size) {
|
|||
|
void *result;
|
|||
|
while (!(result = malloc(size))) {
|
|||
|
fprintf(stderr, "Warning: malloc failed, trying again.\n");
|
|||
|
}
|
|||
|
rmalloc_count++;
|
|||
|
rmalloc_alloc_count++;
|
|||
|
rmalloc_total_bytes_allocated += size;
|
|||
|
return result;
|
|||
|
}
|
|||
|
void *rcalloc(size_t count, size_t size) {
|
|||
|
void *result;
|
|||
|
while (!(result = calloc(count, size))) {
|
|||
|
fprintf(stderr, "Warning: calloc failed, trying again.\n");
|
|||
|
}
|
|||
|
rmalloc_alloc_count++;
|
|||
|
rmalloc_count++;
|
|||
|
rmalloc_total_bytes_allocated += count * size;
|
|||
|
return result;
|
|||
|
}
|
|||
|
void *rrealloc(void *obj, size_t size) {
|
|||
|
if (!obj) {
|
|||
|
rmalloc_count++;
|
|||
|
}
|
|||
|
|
|||
|
rmalloc_alloc_count++;
|
|||
|
if (obj == _rmalloc_prev_realloc_obj) {
|
|||
|
rmalloc_total_bytes_allocated += size - _rmalloc_prev_realloc_obj_size;
|
|||
|
_rmalloc_prev_realloc_obj_size = size - _rmalloc_prev_realloc_obj_size;
|
|||
|
|
|||
|
} else {
|
|||
|
_rmalloc_prev_realloc_obj_size = size;
|
|||
|
}
|
|||
|
void *result;
|
|||
|
while (!(result = realloc(obj, size))) {
|
|||
|
fprintf(stderr, "Warning: realloc failed, trying again.\n");
|
|||
|
}
|
|||
|
_rmalloc_prev_realloc_obj = result;
|
|||
|
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
char *rstrdup(const char *s) {
|
|||
|
if (!s)
|
|||
|
return NULL;
|
|||
|
|
|||
|
char *result;
|
|||
|
size_t size = strlen(s) + 1;
|
|||
|
|
|||
|
result = rmalloc(size);
|
|||
|
memcpy(result, s, size);
|
|||
|
rmalloc_total_bytes_allocated += size;
|
|||
|
return result;
|
|||
|
}
|
|||
|
void *rfree(void *obj) {
|
|||
|
rmalloc_count--;
|
|||
|
rmalloc_free_count++;
|
|||
|
free(obj);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
#if RMALLOC_OVERRIDE
|
|||
|
#define malloc rmalloc
|
|||
|
#define calloc rcalloc
|
|||
|
#define realloc rrealloc
|
|||
|
#define free rfree
|
|||
|
#define strdup rstrdup
|
|||
|
#endif
|
|||
|
|
|||
|
char *rmalloc_lld_format(ulonglong num) {
|
|||
|
|
|||
|
char res[100];
|
|||
|
res[0] = 0;
|
|||
|
sprintf(res, "%'lld", num);
|
|||
|
char *resp = res;
|
|||
|
while (*resp) {
|
|||
|
if (*resp == ',')
|
|||
|
*resp = '.';
|
|||
|
resp++;
|
|||
|
}
|
|||
|
return sbuf(res);
|
|||
|
}
|
|||
|
|
|||
|
char *rmalloc_bytes_format(int factor, ulonglong num) {
|
|||
|
char *sizes[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
|
|||
|
if (num > 1024) {
|
|||
|
return rmalloc_bytes_format(factor + 1, num / 1024);
|
|||
|
}
|
|||
|
char res[100];
|
|||
|
sprintf(res, "%s %s", rmalloc_lld_format(num), sizes[factor]);
|
|||
|
return sbuf(res);
|
|||
|
}
|
|||
|
|
|||
|
char *rmalloc_stats() {
|
|||
|
static char res[200];
|
|||
|
res[0] = 0;
|
|||
|
// int original_locale = localeconv();
|
|||
|
setlocale(LC_NUMERIC, "en_US.UTF-8");
|
|||
|
sprintf(res, "Memory usage: %s, %s (re)allocated, %s unqiue free'd, %s in use.", rmalloc_bytes_format(0, rmalloc_total_bytes_allocated),
|
|||
|
rmalloc_lld_format(rmalloc_alloc_count), rmalloc_lld_format(rmalloc_free_count),
|
|||
|
|
|||
|
rmalloc_lld_format(rmalloc_count));
|
|||
|
// setlocale(LC_NUMERIC, original_locale);
|
|||
|
|
|||
|
setlocale(LC_NUMERIC, "");
|
|||
|
return res;
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
#include <arpa/inet.h>
|
|||
|
#include <errno.h>
|
|||
|
#include <fcntl.h>
|
|||
|
#include <netdb.h>
|
|||
|
#include <netinet/in.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#include <sys/select.h>
|
|||
|
#include <sys/socket.h>
|
|||
|
#include <unistd.h>
|
|||
|
#ifndef RLIB_RIO
|
|||
|
#define RLIB_RIO
|
|||
|
#include <dirent.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <string.h>
|
|||
|
#include <sys/dir.h>
|
|||
|
#include <sys/select.h>
|
|||
|
#include <sys/stat.h>
|
|||
|
#include <unistd.h>
|
|||
|
#ifndef RSTRING_LIST_H
|
|||
|
#define RSTRING_LIST_H
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
|
|||
|
typedef struct rstring_list_t {
|
|||
|
unsigned int size;
|
|||
|
unsigned int count;
|
|||
|
char **strings;
|
|||
|
} rstring_list_t;
|
|||
|
|
|||
|
rstring_list_t *rstring_list_new() {
|
|||
|
rstring_list_t *rsl = (rstring_list_t *)malloc(sizeof(rstring_list_t));
|
|||
|
memset(rsl, 0, sizeof(rstring_list_t));
|
|||
|
return rsl;
|
|||
|
}
|
|||
|
|
|||
|
void rstring_list_free(rstring_list_t *rsl) {
|
|||
|
for (unsigned int i = 0; i < rsl->size; i++) {
|
|||
|
free(rsl->strings[i]);
|
|||
|
}
|
|||
|
if (rsl->strings)
|
|||
|
free(rsl->strings);
|
|||
|
free(rsl);
|
|||
|
rsl = NULL;
|
|||
|
}
|
|||
|
|
|||
|
void rstring_list_add(rstring_list_t *rsl, char *str) {
|
|||
|
if (rsl->count == rsl->size) {
|
|||
|
rsl->size++;
|
|||
|
|
|||
|
rsl->strings = (char **)realloc(rsl->strings, sizeof(char *) * rsl->size);
|
|||
|
}
|
|||
|
rsl->strings[rsl->count] = strdup(str);
|
|||
|
rsl->count++;
|
|||
|
}
|
|||
|
bool rstring_list_contains(rstring_list_t *rsl, char *str) {
|
|||
|
for (unsigned int i = 0; i < rsl->count; i++) {
|
|||
|
if (!strcmp(rsl->strings[i], str))
|
|||
|
return true;
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
bool rfile_exists(char *path) {
|
|||
|
struct stat s;
|
|||
|
return !stat(path, &s);
|
|||
|
}
|
|||
|
|
|||
|
void rjoin_path(char *p1, char *p2, char *output) {
|
|||
|
output[0] = 0;
|
|||
|
strcpy(output, p1);
|
|||
|
|
|||
|
if (output[strlen(output) - 1] != '/') {
|
|||
|
char slash[] = "/";
|
|||
|
strcat(output, slash);
|
|||
|
}
|
|||
|
if (p2[0] == '/') {
|
|||
|
p2++;
|
|||
|
}
|
|||
|
strcat(output, p2);
|
|||
|
}
|
|||
|
|
|||
|
int risprivatedir(const char *path) {
|
|||
|
struct stat statbuf;
|
|||
|
|
|||
|
if (stat(path, &statbuf) != 0) {
|
|||
|
perror("stat");
|
|||
|
return -1;
|
|||
|
}
|
|||
|
|
|||
|
if (!S_ISDIR(statbuf.st_mode)) {
|
|||
|
return -2;
|
|||
|
}
|
|||
|
|
|||
|
if ((statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) == S_IRWXU) {
|
|||
|
return 1; // Private (owner has all permissions, others have none)
|
|||
|
}
|
|||
|
|
|||
|
return 0;
|
|||
|
}
|
|||
|
bool risdir(const char *path) { return !risprivatedir(path); }
|
|||
|
|
|||
|
void rforfile(char *path, void callback(char *)) {
|
|||
|
if (!rfile_exists(path))
|
|||
|
return;
|
|||
|
DIR *dir = opendir(path);
|
|||
|
struct dirent *d;
|
|||
|
while ((d = readdir(dir)) != NULL) {
|
|||
|
if (!d)
|
|||
|
break;
|
|||
|
|
|||
|
if ((d->d_name[0] == '.' && strlen(d->d_name) == 1) || d->d_name[1] == '.') {
|
|||
|
continue;
|
|||
|
}
|
|||
|
char full_path[4096];
|
|||
|
rjoin_path(path, d->d_name, full_path);
|
|||
|
|
|||
|
if (risdir(full_path)) {
|
|||
|
callback(full_path);
|
|||
|
rforfile(full_path, callback);
|
|||
|
} else {
|
|||
|
callback(full_path);
|
|||
|
}
|
|||
|
}
|
|||
|
closedir(dir);
|
|||
|
}
|
|||
|
|
|||
|
bool rfd_wait(int fd, int ms) {
|
|||
|
|
|||
|
fd_set read_fds;
|
|||
|
struct timeval timeout;
|
|||
|
|
|||
|
FD_ZERO(&read_fds);
|
|||
|
FD_SET(fd, &read_fds);
|
|||
|
|
|||
|
timeout.tv_sec = 0;
|
|||
|
timeout.tv_usec = 1000 * ms;
|
|||
|
|
|||
|
int ret = select(fd + 1, &read_fds, NULL, NULL, &timeout);
|
|||
|
return ret > 0 && FD_ISSET(fd, &read_fds);
|
|||
|
}
|
|||
|
|
|||
|
bool rfd_wait_forever(int fd) {
|
|||
|
while ((!rfd_wait(fd, 10))) {
|
|||
|
}
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
size_t rfile_size(char *path) {
|
|||
|
struct stat s;
|
|||
|
stat(path, &s);
|
|||
|
return s.st_size;
|
|||
|
}
|
|||
|
|
|||
|
size_t rfile_readb(char *path, void *data, size_t size) {
|
|||
|
FILE *fd = fopen(path, "r");
|
|||
|
if (!fd) {
|
|||
|
return 0;
|
|||
|
}
|
|||
|
size_t bytes_read = fread(data, sizeof(char), size, fd);
|
|||
|
|
|||
|
fclose(fd);
|
|||
|
((char *)data)[bytes_read] = 0;
|
|||
|
return bytes_read;
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
int *nsock_socks = NULL;
|
|||
|
int *nsock_readable = NULL;
|
|||
|
void **nsock_data = NULL;
|
|||
|
int nsock_server_fd = 0;
|
|||
|
int nsock_max_socket_fd = 0;
|
|||
|
|
|||
|
typedef enum nsock_type_t { NSOCK_NONE = 0, NSOCK_SERVER, NSOCK_CLIENT, NSOCK_UPSTREAM } nsock_type_t;
|
|||
|
|
|||
|
typedef struct nsock_it {
|
|||
|
int fd;
|
|||
|
int *upstreams;
|
|||
|
bool connected;
|
|||
|
bool downstream;
|
|||
|
unsigned int upstream_count;
|
|||
|
nsock_type_t type;
|
|||
|
} nsock_t;
|
|||
|
|
|||
|
nsock_t **nsocks = NULL;
|
|||
|
int nsocks_count = 0;
|
|||
|
|
|||
|
void (*nsock_on_connect)(int fd) = NULL;
|
|||
|
void (*nsock_on_data)(int fd) = NULL;
|
|||
|
void (*nsock_on_close)(int fd) = NULL;
|
|||
|
void nsock_on_before_data(int fd);
|
|||
|
|
|||
|
nsock_t *nsock_get(int fd) {
|
|||
|
if (nsock_socks[fd] == 0) {
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (fd >= nsocks_count || nsocks[fd] == NULL) {
|
|||
|
if (fd >= nsocks_count) {
|
|||
|
nsocks_count = fd + 1;
|
|||
|
nsocks = (nsock_t **)realloc(nsocks, sizeof(nsock_t *) * sizeof(nsock_t) * (nsocks_count));
|
|||
|
nsocks[fd] = (nsock_t *)calloc(1, sizeof(nsock_t));
|
|||
|
}
|
|||
|
nsocks[fd]->upstreams = NULL;
|
|||
|
nsocks[fd]->fd = fd;
|
|||
|
nsocks[fd]->connected = false;
|
|||
|
nsocks[fd]->downstream = false;
|
|||
|
nsocks[fd]->upstream_count = 0;
|
|||
|
nsocks[fd]->type = NSOCK_CLIENT;
|
|||
|
return nsocks[fd];
|
|||
|
}
|
|||
|
return nsocks[fd];
|
|||
|
}
|
|||
|
|
|||
|
void nsock_close(int fd) {
|
|||
|
if (nsock_on_close)
|
|||
|
nsock_on_close(fd);
|
|||
|
nsock_t *sock = nsock_get(fd);
|
|||
|
if (sock) {
|
|||
|
for (unsigned int i = 0; i < sock->upstream_count; i++) {
|
|||
|
nsock_close(sock->upstreams[i]);
|
|||
|
sock->upstreams[i] = 0;
|
|||
|
}
|
|||
|
if (sock->upstream_count) {
|
|||
|
free(sock->upstreams);
|
|||
|
}
|
|||
|
sock->upstream_count = 0;
|
|||
|
sock->connected = false;
|
|||
|
}
|
|||
|
nsock_socks[fd] = 0;
|
|||
|
close(fd);
|
|||
|
}
|
|||
|
|
|||
|
nsock_t *nsock_create(int fd, nsock_type_t type) {
|
|||
|
if (fd <= 0)
|
|||
|
return NULL;
|
|||
|
nsock_socks[fd] = fd;
|
|||
|
nsock_t *sock = nsock_get(fd);
|
|||
|
sock->connected = true;
|
|||
|
sock->downstream = false;
|
|||
|
sock->type = type;
|
|||
|
return sock;
|
|||
|
}
|
|||
|
|
|||
|
int *nsock_init(int socket_count) {
|
|||
|
if (nsock_socks) {
|
|||
|
return nsock_socks;
|
|||
|
}
|
|||
|
nsock_socks = (int *)calloc(1, sizeof(int) * sizeof(int *) * socket_count + 1);
|
|||
|
if (nsock_data) {
|
|||
|
free(nsock_data);
|
|||
|
nsock_data = NULL;
|
|||
|
}
|
|||
|
nsock_data = (void **)malloc(sizeof(void **) * socket_count + 1);
|
|||
|
nsock_socks[socket_count] = -1;
|
|||
|
return nsock_socks;
|
|||
|
}
|
|||
|
|
|||
|
void nsock_free() {
|
|||
|
if (nsock_socks)
|
|||
|
free(nsock_socks);
|
|||
|
if (nsock_readable)
|
|||
|
free(nsock_readable);
|
|||
|
nsock_server_fd = 0;
|
|||
|
nsock_max_socket_fd = 0;
|
|||
|
if (nsock_data) {
|
|||
|
exit(1);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
void nsock_add_upstream(int source, int target, bool downstream) {
|
|||
|
if (!nsock_socks[target])
|
|||
|
return;
|
|||
|
if (!nsock_socks[source])
|
|||
|
return;
|
|||
|
nsock_t *sock = nsock_get(source);
|
|||
|
nsock_t *sock_target = nsock_get(target);
|
|||
|
sock_target->type = NSOCK_UPSTREAM;
|
|||
|
sock->upstreams = (int *)realloc(sock->upstreams, sizeof(int) * (sock->upstream_count + 1));
|
|||
|
sock->downstream = downstream;
|
|||
|
sock->upstreams[sock->upstream_count] = target;
|
|||
|
sock->upstream_count++;
|
|||
|
}
|
|||
|
|
|||
|
void *nsock_get_data(int socket) { return nsock_data[socket]; }
|
|||
|
void nsock_set_data(int socket, void *data) { nsock_data[socket] = data; }
|
|||
|
|
|||
|
int nsock_connect(const char *host, unsigned int port) {
|
|||
|
char port_str[10] = {0};
|
|||
|
sprintf(port_str, "%d", port);
|
|||
|
int status;
|
|||
|
int socket_fd = 0;
|
|||
|
struct addrinfo hints;
|
|||
|
struct addrinfo *res;
|
|||
|
struct addrinfo *p;
|
|||
|
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
memset(&hints, 0, sizeof(hints));
|
|||
|
hints.ai_family = AF_INET;
|
|||
|
hints.ai_socktype = SOCK_STREAM;
|
|||
|
if ((status = getaddrinfo(host, port_str, &hints, &res)) != 0) {
|
|||
|
return 0;
|
|||
|
}
|
|||
|
for (p = res; p != NULL; p = p->ai_next) {
|
|||
|
if ((socket_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (connect(socket_fd, p->ai_addr, p->ai_addrlen) == -1) {
|
|||
|
close(socket_fd);
|
|||
|
continue;
|
|||
|
}
|
|||
|
break;
|
|||
|
}
|
|||
|
if (p == NULL) {
|
|||
|
freeaddrinfo(res);
|
|||
|
return 0;
|
|||
|
}
|
|||
|
freeaddrinfo(res);
|
|||
|
if (socket_fd) {
|
|||
|
if (nsock_socks == NULL) {
|
|||
|
nsock_init(2048);
|
|||
|
}
|
|||
|
nsock_socks[socket_fd] = socket_fd;
|
|||
|
nsock_t *sock = nsock_create(socket_fd, NSOCK_CLIENT);
|
|||
|
sock->connected = true;
|
|||
|
}
|
|||
|
return socket_fd;
|
|||
|
}
|
|||
|
|
|||
|
void nsock_listen(int port) {
|
|||
|
int server_fd;
|
|||
|
struct sockaddr_in address;
|
|||
|
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
|
|||
|
perror("Socket failed");
|
|||
|
exit(EXIT_FAILURE);
|
|||
|
}
|
|||
|
int opt = 1;
|
|||
|
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
|
|||
|
perror("setsockopt failed");
|
|||
|
close(server_fd);
|
|||
|
exit(EXIT_FAILURE);
|
|||
|
}
|
|||
|
address.sin_family = AF_INET;
|
|||
|
address.sin_addr.s_addr = INADDR_ANY;
|
|||
|
address.sin_port = htons(port);
|
|||
|
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
|
|||
|
perror("Bind failed");
|
|||
|
close(server_fd);
|
|||
|
exit(EXIT_FAILURE);
|
|||
|
}
|
|||
|
if (listen(server_fd, 8096) < 0) {
|
|||
|
perror("Listen failed");
|
|||
|
close(server_fd);
|
|||
|
exit(EXIT_FAILURE);
|
|||
|
}
|
|||
|
nsock_server_fd = server_fd;
|
|||
|
}
|
|||
|
|
|||
|
int *nsock_select(suseconds_t timeout) {
|
|||
|
struct timeval tv;
|
|||
|
tv.tv_sec = 0;
|
|||
|
tv.tv_usec = timeout;
|
|||
|
int server_fd = nsock_server_fd;
|
|||
|
fd_set rfds;
|
|||
|
FD_ZERO(&rfds);
|
|||
|
FD_SET(server_fd, &rfds);
|
|||
|
int *socks = nsock_socks;
|
|||
|
fd_set efds;
|
|||
|
FD_ZERO(&efds);
|
|||
|
nsock_max_socket_fd = server_fd;
|
|||
|
for (int i = 0; socks[i] != -1; i++) {
|
|||
|
if (i == server_fd)
|
|||
|
continue;
|
|||
|
;
|
|||
|
if (!socks[i])
|
|||
|
continue;
|
|||
|
if (socks[i] > nsock_max_socket_fd) {
|
|||
|
nsock_max_socket_fd = socks[i];
|
|||
|
}
|
|||
|
FD_SET(socks[i], &rfds);
|
|||
|
FD_SET(socks[i], &efds);
|
|||
|
}
|
|||
|
int activity = select(nsock_max_socket_fd + 1, &rfds, NULL, &efds, timeout == 0 ? NULL : &tv);
|
|||
|
if ((activity < 0) && (errno != EINTR)) {
|
|||
|
perror("Select error\n");
|
|||
|
return NULL;
|
|||
|
} else if (activity == 0) {
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (FD_ISSET(server_fd, &rfds)) {
|
|||
|
struct sockaddr_in address;
|
|||
|
int addrlen = sizeof(address);
|
|||
|
address.sin_family = AF_INET;
|
|||
|
address.sin_addr.s_addr = INADDR_ANY;
|
|||
|
int new_socket = 0;
|
|||
|
if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
|
|||
|
perror("Accept failed");
|
|||
|
} else {
|
|||
|
nsock_socks[new_socket] = new_socket;
|
|||
|
nsock_create(new_socket, NSOCK_CLIENT);
|
|||
|
if (nsock_on_connect)
|
|||
|
nsock_on_connect(new_socket);
|
|||
|
if (new_socket > nsock_max_socket_fd)
|
|||
|
nsock_max_socket_fd = new_socket;
|
|||
|
}
|
|||
|
}
|
|||
|
if (nsock_readable) {
|
|||
|
free(nsock_readable);
|
|||
|
}
|
|||
|
nsock_readable = (int *)calloc(1, sizeof(int *) + sizeof(int) * (nsock_max_socket_fd + 2));
|
|||
|
nsock_readable[nsock_max_socket_fd + 1] = -1;
|
|||
|
nsock_readable[0] = 0;
|
|||
|
int readable_count = 0;
|
|||
|
for (int i = 0; i < nsock_max_socket_fd + 1; i++) {
|
|||
|
nsock_t *sock = nsock_get(i);
|
|||
|
if (!sock)
|
|||
|
continue;
|
|||
|
if (FD_ISSET(i, &efds)) {
|
|||
|
nsock_close(nsock_socks[i]);
|
|||
|
nsock_socks[i] = 0;
|
|||
|
nsock_readable[i] = 0;
|
|||
|
} else if (FD_ISSET(i, &rfds) && i != server_fd) {
|
|||
|
nsock_readable[i] = i;
|
|||
|
readable_count++;
|
|||
|
nsock_on_before_data(i);
|
|||
|
} else {
|
|||
|
nsock_readable[i] = 0;
|
|||
|
sock->connected = false;
|
|||
|
}
|
|||
|
}
|
|||
|
return nsock_readable;
|
|||
|
}
|
|||
|
|
|||
|
unsigned char *nsock_read(int fd, int length) {
|
|||
|
if (!nsock_socks[fd])
|
|||
|
return NULL;
|
|||
|
unsigned char *buffer = (unsigned char *)malloc(length + 1);
|
|||
|
int bytes_read = read(fd, buffer, length);
|
|||
|
if (bytes_read <= 0) {
|
|||
|
nsock_close(fd);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
buffer[bytes_read] = 0;
|
|||
|
return buffer;
|
|||
|
}
|
|||
|
|
|||
|
unsigned char *nsock_read_all(int fd, int length) {
|
|||
|
if (!nsock_socks[fd])
|
|||
|
return NULL;
|
|||
|
unsigned char *buffer = (unsigned char *)malloc(length + 1);
|
|||
|
int bytes_read = 0;
|
|||
|
while (bytes_read < length) {
|
|||
|
int bytes_chunk = read(fd, buffer + bytes_read, length - bytes_read);
|
|||
|
if (bytes_chunk <= 0) {
|
|||
|
nsock_close(fd);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
bytes_read += bytes_chunk;
|
|||
|
}
|
|||
|
buffer[bytes_read] = 0;
|
|||
|
return buffer;
|
|||
|
}
|
|||
|
|
|||
|
int nsock_write_all(int fd, unsigned char *data, int length) {
|
|||
|
if (!nsock_socks[fd])
|
|||
|
return 0;
|
|||
|
int bytes_written = 0;
|
|||
|
while (bytes_written < length) {
|
|||
|
int bytes_chunk = write(fd, data + bytes_written, length - bytes_written);
|
|||
|
if (bytes_chunk <= 0) {
|
|||
|
nsock_close(fd);
|
|||
|
return 0;
|
|||
|
}
|
|||
|
bytes_written += bytes_chunk;
|
|||
|
}
|
|||
|
return bytes_written;
|
|||
|
}
|
|||
|
|
|||
|
int nsock_execute_upstream(int source, size_t buffer_size) {
|
|||
|
int result = 0;
|
|||
|
nsock_t *sock = nsock_get(source);
|
|||
|
unsigned char data[buffer_size];
|
|||
|
memset(data, 0, buffer_size);
|
|||
|
int bytes_read = read(source, data, buffer_size);
|
|||
|
if (bytes_read <= 0) {
|
|||
|
nsock_close(source);
|
|||
|
return 0;
|
|||
|
}
|
|||
|
bool downstreamed = false;
|
|||
|
for (unsigned int i = 0; i < sock->upstream_count; i++) {
|
|||
|
if (!nsock_socks[sock->upstreams[i]])
|
|||
|
continue;
|
|||
|
int bytes_sent = nsock_write_all(sock->upstreams[i], data, bytes_read);
|
|||
|
if (bytes_sent <= 0) {
|
|||
|
nsock_close(sock->upstreams[i]);
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (sock->downstream && downstreamed == false) {
|
|||
|
downstreamed = true;
|
|||
|
unsigned char data[4096];
|
|||
|
memset(data, 0, 4096);
|
|||
|
int bytes_read = read(sock->upstreams[i], data, 4096);
|
|||
|
if (bytes_read <= 0) {
|
|||
|
nsock_close(source);
|
|||
|
return 0;
|
|||
|
}
|
|||
|
int bytes_sent = nsock_write_all(sock->fd, data, bytes_read);
|
|||
|
if (bytes_sent <= 0) {
|
|||
|
nsock_close(sock->upstreams[i]);
|
|||
|
return 0;
|
|||
|
}
|
|||
|
}
|
|||
|
result++;
|
|||
|
}
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
void nsock_on_before_data(int fd) {
|
|||
|
if (!nsock_socks[fd])
|
|||
|
return;
|
|||
|
nsock_t *sock = nsock_get(fd);
|
|||
|
if (sock->upstream_count) {
|
|||
|
int upstreamed_to_count = nsock_execute_upstream(fd, 4096);
|
|||
|
if (!upstreamed_to_count) {
|
|||
|
nsock_close(fd);
|
|||
|
}
|
|||
|
return;
|
|||
|
} else if (sock->type == NSOCK_UPSTREAM) {
|
|||
|
while (rfd_wait(sock->fd, 0)) {
|
|||
|
unsigned char *data = nsock_read(fd, 4096);
|
|||
|
(void)data;
|
|||
|
}
|
|||
|
}
|
|||
|
if (nsock_on_data)
|
|||
|
nsock_on_data(fd);
|
|||
|
}
|
|||
|
|
|||
|
void nsock(int port, void (*on_connect)(int fd), void (*on_data)(int fd), void (*on_close)(int fd)) {
|
|||
|
nsock_init(2048);
|
|||
|
nsock_listen(port);
|
|||
|
nsock_on_connect = on_connect;
|
|||
|
nsock_on_data = on_data;
|
|||
|
nsock_on_close = on_close;
|
|||
|
int serve_in_terminal = nsock_on_connect == NULL && nsock_on_data == NULL && nsock_on_close == NULL;
|
|||
|
while (1) {
|
|||
|
int *readable = nsock_select(0);
|
|||
|
if (!serve_in_terminal)
|
|||
|
continue;
|
|||
|
if (!readable)
|
|||
|
continue;
|
|||
|
for (int i = 0; readable[i] != -1; i++) {
|
|||
|
if (!readable[i])
|
|||
|
continue;
|
|||
|
char buffer[1024] = {0};
|
|||
|
int bytes_read = read(readable[i], buffer, 1);
|
|||
|
buffer[bytes_read] = 0;
|
|||
|
if (bytes_read <= 0) {
|
|||
|
nsock_close(readable[i]);
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (write(readable[i], buffer, bytes_read) <= 0) {
|
|||
|
nsock_close(readable[i]);
|
|||
|
continue;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef UUID_H
|
|||
|
#define UUID_H
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <time.h>
|
|||
|
|
|||
|
typedef struct {
|
|||
|
unsigned char bytes[16];
|
|||
|
} UUID;
|
|||
|
|
|||
|
void generate_random_bytes(unsigned char *bytes, size_t len) {
|
|||
|
for (size_t i = 0; i < len; i++) {
|
|||
|
bytes[i] = rand() % 256;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
UUID generate_uuid4(void) {
|
|||
|
UUID uuid;
|
|||
|
|
|||
|
generate_random_bytes(uuid.bytes, 16);
|
|||
|
|
|||
|
uuid.bytes[6] &= 0x0f;
|
|||
|
uuid.bytes[6] |= 0x40;
|
|||
|
|
|||
|
uuid.bytes[8] &= 0x3f;
|
|||
|
uuid.bytes[8] |= 0x80;
|
|||
|
|
|||
|
return uuid;
|
|||
|
}
|
|||
|
|
|||
|
void uuid_to_string(UUID uuid, char *str) {
|
|||
|
sprintf(str, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", uuid.bytes[0], uuid.bytes[1], uuid.bytes[2],
|
|||
|
uuid.bytes[3], uuid.bytes[4], uuid.bytes[5], uuid.bytes[6], uuid.bytes[7], uuid.bytes[8], uuid.bytes[9], uuid.bytes[10],
|
|||
|
uuid.bytes[11], uuid.bytes[12], uuid.bytes[13], uuid.bytes[14], uuid.bytes[15]);
|
|||
|
}
|
|||
|
|
|||
|
char *uuid4() {
|
|||
|
srand(time(NULL));
|
|||
|
UUID uuid = generate_uuid4();
|
|||
|
char str[37];
|
|||
|
uuid_to_string(uuid, str);
|
|||
|
return sbuf(str);
|
|||
|
}
|
|||
|
#endif
|
|||
|
#ifndef RNET_H
|
|||
|
#define RNET_H
|
|||
|
#ifdef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#endif
|
|||
|
#ifndef _POSIX_C_SOURCE
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE 200112L
|
|||
|
#endif
|
|||
|
#include <arpa/inet.h>
|
|||
|
#include <errno.h>
|
|||
|
#include <fcntl.h>
|
|||
|
#include <netdb.h>
|
|||
|
#include <signal.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#include <sys/select.h>
|
|||
|
|
|||
|
#include <sys/socket.h>
|
|||
|
#include <sys/types.h>
|
|||
|
|
|||
|
#include <unistd.h>
|
|||
|
#ifdef _POSIX_C_SOURCE_TEMP
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
|
|||
|
#undef _POSIX_C_SOURCE_TEMP
|
|||
|
#else
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#endif
|
|||
|
#define NET_SOCKET_MAX_CONNECTIONS 50000
|
|||
|
|
|||
|
typedef struct rnet_socket_t {
|
|||
|
int fd;
|
|||
|
char name[50];
|
|||
|
void *data;
|
|||
|
size_t bytes_received;
|
|||
|
size_t bytes_sent;
|
|||
|
bool connected;
|
|||
|
void (*on_read)(struct rnet_socket_t *);
|
|||
|
void (*on_close)(struct rnet_socket_t *);
|
|||
|
void (*on_connect)(struct rnet_socket_t *);
|
|||
|
} rnet_socket_t;
|
|||
|
|
|||
|
typedef struct rnet_select_result_t {
|
|||
|
int server_fd;
|
|||
|
rnet_socket_t **sockets;
|
|||
|
unsigned int socket_count;
|
|||
|
} rnet_select_result_t;
|
|||
|
|
|||
|
typedef struct rnet_server_t {
|
|||
|
int socket_fd;
|
|||
|
rnet_socket_t **sockets;
|
|||
|
unsigned int socket_count;
|
|||
|
unsigned int port;
|
|||
|
unsigned int backlog;
|
|||
|
rnet_select_result_t *select_result;
|
|||
|
int max_fd;
|
|||
|
void (*on_connect)(rnet_socket_t *socket);
|
|||
|
void (*on_close)(rnet_socket_t *socket);
|
|||
|
void (*on_read)(rnet_socket_t *socket);
|
|||
|
} rnet_server_t;
|
|||
|
|
|||
|
void rnet_select_result_free(rnet_select_result_t *result);
|
|||
|
int net_socket_accept(int server_fd);
|
|||
|
int net_socket_connect(const char *, unsigned int);
|
|||
|
int net_socket_init();
|
|||
|
rnet_server_t *net_socket_serve(unsigned int port, unsigned int backlog);
|
|||
|
rnet_select_result_t *net_socket_select(rnet_server_t *server);
|
|||
|
rnet_socket_t *net_socket_wait(rnet_socket_t *socket_fd);
|
|||
|
bool net_set_non_blocking(int sock);
|
|||
|
bool net_socket_bind(int sock, unsigned int port);
|
|||
|
bool net_socket_listen(int sock, unsigned int backlog);
|
|||
|
char *net_socket_name(int sock);
|
|||
|
size_t net_socket_write(rnet_socket_t *, unsigned char *, size_t);
|
|||
|
rnet_socket_t *get_net_socket_by_fd(int);
|
|||
|
unsigned char *net_socket_read(rnet_socket_t *, unsigned int buff_size);
|
|||
|
void _net_socket_close(int sock);
|
|||
|
void net_socket_close(rnet_socket_t *sock);
|
|||
|
|
|||
|
rnet_server_t *rnet_server_new(int socket_fd, unsigned int port, unsigned int backlog) {
|
|||
|
rnet_server_t *server = malloc(sizeof(rnet_server_t));
|
|||
|
server->socket_fd = socket_fd;
|
|||
|
server->sockets = NULL;
|
|||
|
server->socket_count = 0;
|
|||
|
server->port = port;
|
|||
|
server->backlog = backlog;
|
|||
|
server->max_fd = -1;
|
|||
|
server->select_result = NULL;
|
|||
|
server->on_connect = NULL;
|
|||
|
server->on_close = NULL;
|
|||
|
server->on_read = NULL;
|
|||
|
return server;
|
|||
|
}
|
|||
|
|
|||
|
rnet_server_t *rnet_server_add_socket(rnet_server_t *server, rnet_socket_t *sock) {
|
|||
|
server->sockets = realloc(server->sockets, sizeof(rnet_socket_t *) * (server->socket_count + 1));
|
|||
|
server->sockets[server->socket_count] = sock;
|
|||
|
server->socket_count++;
|
|||
|
sock->on_read = server->on_read;
|
|||
|
sock->on_connect = server->on_connect;
|
|||
|
sock->on_close = server->on_close;
|
|||
|
sock->connected = true;
|
|||
|
return server;
|
|||
|
}
|
|||
|
|
|||
|
rnet_socket_t sockets[NET_SOCKET_MAX_CONNECTIONS] = {0};
|
|||
|
unsigned long sockets_connected = 0;
|
|||
|
int net_socket_max_fd = 0;
|
|||
|
unsigned long sockets_total = 0;
|
|||
|
unsigned long sockets_disconnected = 0;
|
|||
|
unsigned long sockets_concurrent_record = 0;
|
|||
|
unsigned long sockets_errors = 0;
|
|||
|
|
|||
|
bool net_set_non_blocking(int sock) {
|
|||
|
int flags = fcntl(sock, F_GETFL, 0);
|
|||
|
if (flags < 0) {
|
|||
|
perror("fcntl");
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
|
|||
|
perror("fcntl");
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
int net_socket_init() {
|
|||
|
int socket_fd = -1;
|
|||
|
memset(sockets, 0, sizeof(sockets));
|
|||
|
int opt = 1;
|
|||
|
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
|
|||
|
perror("Socket failed.\n");
|
|||
|
return false;
|
|||
|
}
|
|||
|
if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
|
|||
|
perror("Setsockopt failed.\n");
|
|||
|
close(socket_fd);
|
|||
|
return false;
|
|||
|
}
|
|||
|
net_set_non_blocking(socket_fd);
|
|||
|
return socket_fd;
|
|||
|
}
|
|||
|
|
|||
|
char *net_socket_name(int fd) {
|
|||
|
rnet_socket_t *rnet_socket = get_net_socket_by_fd(fd);
|
|||
|
if (rnet_socket) {
|
|||
|
return rnet_socket->name;
|
|||
|
;
|
|||
|
}
|
|||
|
|
|||
|
// If socket disconnected or is no client from server
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
bool net_socket_bind(int socket_fd, unsigned int port) {
|
|||
|
struct sockaddr_in address;
|
|||
|
|
|||
|
address.sin_family = AF_INET; // IPv4
|
|||
|
address.sin_addr.s_addr = INADDR_ANY; // Bind to any available address
|
|||
|
address.sin_port = htons(port); // Convert port to network byte order
|
|||
|
|
|||
|
if (bind(socket_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
|
|||
|
perror("Bind failed");
|
|||
|
close(socket_fd);
|
|||
|
return false;
|
|||
|
}
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
int net_socket_connect(const char *host, unsigned int port) {
|
|||
|
char port_str[10] = {0};
|
|||
|
sprintf(port_str, "%d", port);
|
|||
|
int status;
|
|||
|
int socket_fd = -1;
|
|||
|
struct addrinfo hints;
|
|||
|
struct addrinfo *res;
|
|||
|
struct addrinfo *p;
|
|||
|
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
memset(&hints, 0, sizeof(hints));
|
|||
|
hints.ai_family = AF_INET;
|
|||
|
hints.ai_socktype = SOCK_STREAM;
|
|||
|
|
|||
|
if ((status = getaddrinfo(host, port_str, &hints, &res)) != 0) {
|
|||
|
return -1;
|
|||
|
}
|
|||
|
|
|||
|
for (p = res; p != NULL; p = p->ai_next) {
|
|||
|
if ((socket_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
|
|||
|
continue;
|
|||
|
}
|
|||
|
|
|||
|
if (connect(socket_fd, p->ai_addr, p->ai_addrlen) == -1) {
|
|||
|
close(socket_fd);
|
|||
|
continue;
|
|||
|
}
|
|||
|
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
if (p == NULL) {
|
|||
|
freeaddrinfo(res);
|
|||
|
return -1;
|
|||
|
}
|
|||
|
|
|||
|
freeaddrinfo(res);
|
|||
|
return socket_fd;
|
|||
|
}
|
|||
|
|
|||
|
bool net_socket_listen(int socket_fd, unsigned int backlog) {
|
|||
|
if (listen(socket_fd, backlog) < 0) { // '3' is the backlog size
|
|||
|
perror("Listen failed");
|
|||
|
close(socket_fd);
|
|||
|
return false;
|
|||
|
}
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
rnet_server_t *net_socket_serve(unsigned int port, unsigned int backlog) {
|
|||
|
signal(SIGPIPE, SIG_IGN);
|
|||
|
int socket_fd = net_socket_init();
|
|||
|
net_socket_bind(socket_fd, port);
|
|||
|
net_socket_listen(socket_fd, backlog);
|
|||
|
return rnet_server_new(socket_fd, port, backlog);
|
|||
|
}
|
|||
|
|
|||
|
int net_socket_accept(int net_socket_server_fd) {
|
|||
|
struct sockaddr_in address;
|
|||
|
int addrlen = sizeof(address);
|
|||
|
int new_socket = -1;
|
|||
|
if ((new_socket = accept(net_socket_server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
|
|||
|
close(new_socket);
|
|||
|
return -1;
|
|||
|
} else {
|
|||
|
|
|||
|
return new_socket;
|
|||
|
}
|
|||
|
}
|
|||
|
/*
|
|||
|
static void net_socket_stats(WrenVM *vm)
|
|||
|
{
|
|||
|
|
|||
|
wrenSetSlotNewList(vm, 0);
|
|||
|
|
|||
|
wrenSetSlotString(vm, 1, "sockets_total");
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
|
|||
|
wrenSetSlotDouble(vm, 1, (double)sockets_total);
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
|
|||
|
wrenSetSlotString(vm, 1, "sockets_concurrent_record");
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
|
|||
|
wrenSetSlotDouble(vm, 1, (double)sockets_concurrent_record);
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
|
|||
|
wrenSetSlotString(vm, 1, "sockets_connected");
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
|
|||
|
wrenSetSlotDouble(vm, 1, (double)sockets_connected);
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
|
|||
|
wrenSetSlotString(vm, 1, "sockets_disconnected");
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
|
|||
|
wrenSetSlotDouble(vm, 1, (double)sockets_disconnected);
|
|||
|
wrenInsertInList(vm, 0, -1, 1);
|
|||
|
}*/
|
|||
|
|
|||
|
size_t net_socket_write(rnet_socket_t *sock, unsigned char *message, size_t size) {
|
|||
|
ssize_t sent_total = 0;
|
|||
|
ssize_t sent = 0;
|
|||
|
ssize_t to_send = size;
|
|||
|
while ((sent = send(sock->fd, message, to_send, 0))) {
|
|||
|
if (sent == -1) {
|
|||
|
sockets_errors++;
|
|||
|
net_socket_close(sock);
|
|||
|
break;
|
|||
|
}
|
|||
|
if (sent == 0) {
|
|||
|
printf("EDGE CASE?\n");
|
|||
|
exit(1);
|
|||
|
sockets_errors++;
|
|||
|
net_socket_close(sock);
|
|||
|
break;
|
|||
|
}
|
|||
|
sent_total += sent;
|
|||
|
if (sent_total == to_send)
|
|||
|
break;
|
|||
|
}
|
|||
|
return sent_total;
|
|||
|
}
|
|||
|
|
|||
|
unsigned char *net_socket_read(rnet_socket_t *sock, unsigned int buff_size) {
|
|||
|
if (buff_size > 1024 * 1024 + 1) {
|
|||
|
perror("Buffer too big. Maximum is 1024*1024.\n");
|
|||
|
exit(1);
|
|||
|
}
|
|||
|
static unsigned char buffer[1024 * 1024];
|
|||
|
buffer[0] = 0;
|
|||
|
ssize_t received = recv(sock->fd, buffer, buff_size, 0);
|
|||
|
if (received <= 0) {
|
|||
|
buffer[0] = 0;
|
|||
|
net_socket_close(sock);
|
|||
|
if (received < 0) {
|
|||
|
sockets_errors++;
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
}
|
|||
|
buffer[received + 1] = 0;
|
|||
|
sock->bytes_received = received;
|
|||
|
return buffer;
|
|||
|
}
|
|||
|
|
|||
|
rnet_socket_t *net_socket_wait(rnet_socket_t *sock) {
|
|||
|
if (!sock)
|
|||
|
return NULL;
|
|||
|
if (sock->fd == -1)
|
|||
|
return NULL;
|
|||
|
fd_set read_fds;
|
|||
|
FD_ZERO(&read_fds);
|
|||
|
FD_SET(sock->fd, &read_fds);
|
|||
|
|
|||
|
int max_socket_fd = sock->fd;
|
|||
|
int activity = select(max_socket_fd + 1, &read_fds, NULL, NULL, NULL);
|
|||
|
if ((activity < 0) && (errno != EINTR)) {
|
|||
|
// perror("Select error");
|
|||
|
net_socket_close(sock);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (FD_ISSET(sock->fd, &read_fds)) {
|
|||
|
return sock;
|
|||
|
}
|
|||
|
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
void rnet_safe_str(char *str, size_t length) {
|
|||
|
if (!str || !length || !*str)
|
|||
|
return;
|
|||
|
for (unsigned int i = 0; i < length; i++) {
|
|||
|
if (str[i] < 32 || str[i] > 126)
|
|||
|
if (str[i] != 0)
|
|||
|
str[i] = '.';
|
|||
|
}
|
|||
|
str[length] = 0;
|
|||
|
}
|
|||
|
|
|||
|
rnet_select_result_t *rnet_new_socket_select_result(int socket_fd) {
|
|||
|
rnet_select_result_t *result = (rnet_select_result_t *)malloc(sizeof(rnet_select_result_t));
|
|||
|
memset(result, 0, sizeof(rnet_select_result_t));
|
|||
|
result->server_fd = socket_fd;
|
|||
|
result->socket_count = 0;
|
|||
|
result->sockets = NULL;
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
void rnet_select_result_add(rnet_select_result_t *result, rnet_socket_t *sock) {
|
|||
|
result->sockets = realloc(result->sockets, sizeof(rnet_socket_t *) * (result->socket_count + 1));
|
|||
|
result->sockets[result->socket_count] = sock;
|
|||
|
result->socket_count++;
|
|||
|
}
|
|||
|
void rnet_select_result_free(rnet_select_result_t *result) { free(result); }
|
|||
|
rnet_select_result_t *net_socket_select(rnet_server_t *server) {
|
|||
|
fd_set read_fds;
|
|||
|
FD_ZERO(&read_fds);
|
|||
|
FD_SET(server->socket_fd, &read_fds);
|
|||
|
|
|||
|
server->max_fd = server->socket_fd;
|
|||
|
int socket_fd = -1;
|
|||
|
for (unsigned int i = 0; i < server->socket_count; i++) {
|
|||
|
socket_fd = server->sockets[i]->fd;
|
|||
|
if (!server->sockets[i]->connected) {
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (socket_fd > 0) {
|
|||
|
FD_SET(socket_fd, &read_fds);
|
|||
|
if (socket_fd > server->max_fd) {
|
|||
|
server->max_fd = socket_fd;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
int new_socket = -1;
|
|||
|
struct sockaddr_in address;
|
|||
|
int addrlen = sizeof(struct sockaddr_in);
|
|||
|
int activity = select(server->max_fd + 1, &read_fds, NULL, NULL, NULL);
|
|||
|
if ((activity < 0) && (errno != EINTR)) {
|
|||
|
perror("Select error\n");
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (FD_ISSET(server->socket_fd, &read_fds)) {
|
|||
|
if ((new_socket = accept(server->socket_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
|
|||
|
perror("Accept failed\n");
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
// net_set_non_blocking(new_socket);
|
|||
|
char name[50] = {0};
|
|||
|
sprintf(name, "fd:%.4d:ip:%12s:port:%.6d", new_socket, inet_ntoa(address.sin_addr), ntohs(address.sin_port));
|
|||
|
rnet_socket_t *sock_obj = NULL;
|
|||
|
for (unsigned int i = 0; i < server->socket_count; i++) {
|
|||
|
if (server->sockets && server->sockets[i]->fd == -1) {
|
|||
|
sock_obj = server->sockets[i];
|
|||
|
}
|
|||
|
}
|
|||
|
if (!sock_obj) {
|
|||
|
sock_obj = (rnet_socket_t *)malloc(sizeof(rnet_socket_t));
|
|||
|
rnet_server_add_socket(server, sock_obj);
|
|||
|
}
|
|||
|
sock_obj->fd = new_socket;
|
|||
|
strcpy(sock_obj->name, name);
|
|||
|
sockets_connected++;
|
|||
|
sockets_total++;
|
|||
|
sockets_concurrent_record = sockets_connected > sockets_concurrent_record ? sockets_connected : sockets_concurrent_record;
|
|||
|
if (new_socket > net_socket_max_fd) {
|
|||
|
net_socket_max_fd = new_socket;
|
|||
|
}
|
|||
|
sock_obj->connected = true;
|
|||
|
sock_obj->on_connect(sock_obj);
|
|||
|
}
|
|||
|
rnet_select_result_t *result = rnet_new_socket_select_result(server->socket_fd);
|
|||
|
unsigned int readable_count = 0;
|
|||
|
for (unsigned int i = 0; i < server->socket_count; i++) {
|
|||
|
if (server->sockets[i]->fd == -1)
|
|||
|
continue;
|
|||
|
if (FD_ISSET(server->sockets[i]->fd, &read_fds)) {
|
|||
|
rnet_select_result_add(result, server->sockets[i]);
|
|||
|
readable_count++;
|
|||
|
if (server->sockets[i]->on_read) {
|
|||
|
server->sockets[i]->on_read(server->sockets[i]);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
if (server->select_result) {
|
|||
|
rnet_select_result_free(server->select_result);
|
|||
|
server->select_result = NULL;
|
|||
|
}
|
|||
|
if (readable_count == 0)
|
|||
|
rnet_select_result_free(result);
|
|||
|
return readable_count ? result : NULL;
|
|||
|
}
|
|||
|
|
|||
|
rnet_socket_t *get_net_socket_by_fd(int sock) {
|
|||
|
for (int i = 0; i < net_socket_max_fd; i++) {
|
|||
|
if (sockets[i].fd == sock) {
|
|||
|
return &sockets[i];
|
|||
|
}
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
void _net_socket_close(int sock) {
|
|||
|
if (sock > 0) {
|
|||
|
sockets_connected--;
|
|||
|
sockets_disconnected++;
|
|||
|
if (sock > 0) {
|
|||
|
if (close(sock) == -1) {
|
|||
|
perror("Error closing socket.\n");
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
void net_socket_close(rnet_socket_t *sock) {
|
|||
|
sock->connected = false;
|
|||
|
if (sock->on_close)
|
|||
|
sock->on_close(sock);
|
|||
|
_net_socket_close(sock->fd);
|
|||
|
sock->fd = -1;
|
|||
|
}
|
|||
|
#undef _POSIX_C_SOURCE
|
|||
|
#endif
|
|||
|
|
|||
|
#include <stdio.h>
|
|||
|
#ifndef RLIB_RARGS_H
|
|||
|
#define RLIB_RARGS_H
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
|
|||
|
bool rargs_isset(int argc, char *argv[], char *key) {
|
|||
|
|
|||
|
for (int i = 0; i < argc; i++) {
|
|||
|
if (!strcmp(argv[i], key)) {
|
|||
|
return true;
|
|||
|
}
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
char *rargs_get_option_string(int argc, char *argv[], char *key, const char *def) {
|
|||
|
|
|||
|
for (int i = 0; i < argc; i++) {
|
|||
|
if (!strcmp(argv[i], key)) {
|
|||
|
if (i < argc - 1) {
|
|||
|
return argv[i + 1];
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
return (char *)def;
|
|||
|
}
|
|||
|
|
|||
|
int rargs_get_option_int(int argc, char *argv[], char *key, int def) {
|
|||
|
|
|||
|
for (int i = 0; i < argc; i++) {
|
|||
|
if (!strcmp(argv[i], key)) {
|
|||
|
if (i < argc - 1) {
|
|||
|
return atoi(argv[i + 1]);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
return def;
|
|||
|
}
|
|||
|
|
|||
|
bool rargs_get_option_bool(int argc, char *argv[], char *key, bool def) {
|
|||
|
|
|||
|
for (int i = 0; i < argc; i++) {
|
|||
|
if (!strcmp(argv[i], key)) {
|
|||
|
if (i < argc - 1) {
|
|||
|
if (!strcmp(argv[i + 1], "false"))
|
|||
|
return false;
|
|||
|
if (!strcmp(argv[i + 1], "0"))
|
|||
|
return false;
|
|||
|
return true;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return def;
|
|||
|
}
|
|||
|
#endif
|
|||
|
#ifndef RCAT_H
|
|||
|
#define RCAT_H
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
|
|||
|
void rcat(char *filename) {
|
|||
|
FILE *f = fopen(filename, "rb");
|
|||
|
if (!f) {
|
|||
|
printf("rcat: couldn't open \"%s\" for read.\n", filename);
|
|||
|
return;
|
|||
|
}
|
|||
|
unsigned char c;
|
|||
|
while ((c = fgetc(f)) && !feof(f)) {
|
|||
|
printf("%c", c);
|
|||
|
}
|
|||
|
fclose(f);
|
|||
|
fflush(stdout);
|
|||
|
}
|
|||
|
|
|||
|
int rcat_main(int argc, char *argv[]) {
|
|||
|
if (argc < 2) {
|
|||
|
printf("Usage: [filename]\n");
|
|||
|
return 1;
|
|||
|
}
|
|||
|
rcat(argv[1]);
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef RLIZA_H
|
|||
|
#define RLIZA_H
|
|||
|
#ifndef RBUFFER_H
|
|||
|
#define RBUFFER_H
|
|||
|
#include <assert.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
typedef struct rbuffer_t {
|
|||
|
unsigned char *data;
|
|||
|
unsigned char *_data;
|
|||
|
size_t size;
|
|||
|
size_t pos;
|
|||
|
bool eof;
|
|||
|
} rbuffer_t;
|
|||
|
|
|||
|
rbuffer_t *rbuffer_new(unsigned char *data, size_t size);
|
|||
|
void rbuffer_free(rbuffer_t *rfb);
|
|||
|
void rbuffer_reset(rbuffer_t *rfb);
|
|||
|
void rbuffer_write(rbuffer_t *rfb, const unsigned char *data, size_t size);
|
|||
|
size_t rbuffer_push(rbuffer_t *rfb, unsigned char);
|
|||
|
unsigned char rbuffer_pop(rbuffer_t *rfb);
|
|||
|
unsigned char *rbuffer_expect(rbuffer_t *rfb, char *options, char *ignore);
|
|||
|
void rbuffer_set(rbuffer_t *rfb, const unsigned char *data, size_t size);
|
|||
|
|
|||
|
void rbuffer_set(rbuffer_t *rfb, const unsigned char *data, size_t size) {
|
|||
|
if (rfb->_data) {
|
|||
|
free(rfb->_data);
|
|||
|
rfb->_data = NULL;
|
|||
|
rfb->data = NULL;
|
|||
|
rfb->eof = true;
|
|||
|
}
|
|||
|
if (size) {
|
|||
|
rfb->_data = (unsigned char *)malloc(size);
|
|||
|
memcpy(rfb->_data, data, size);
|
|||
|
rfb->data = rfb->_data;
|
|||
|
rfb->eof = false;
|
|||
|
}
|
|||
|
rfb->size = size;
|
|||
|
rfb->pos = 0;
|
|||
|
}
|
|||
|
|
|||
|
rbuffer_t *rbuffer_new(unsigned char *data, size_t size) {
|
|||
|
rbuffer_t *rfb = (rbuffer_t *)malloc(sizeof(rbuffer_t));
|
|||
|
if (size) {
|
|||
|
rfb->_data = (unsigned char *)malloc(size);
|
|||
|
memcpy(rfb->_data, data, size);
|
|||
|
rfb->eof = false;
|
|||
|
} else {
|
|||
|
rfb->_data = NULL;
|
|||
|
rfb->eof = true;
|
|||
|
}
|
|||
|
rfb->size = size;
|
|||
|
rfb->pos = 0;
|
|||
|
rfb->data = rfb->_data;
|
|||
|
return rfb;
|
|||
|
}
|
|||
|
void rbuffer_free(rbuffer_t *rfb) {
|
|||
|
if (rfb->_data)
|
|||
|
free(rfb->_data);
|
|||
|
free(rfb);
|
|||
|
}
|
|||
|
|
|||
|
size_t rbuffer_push(rbuffer_t *rfb, unsigned char c) {
|
|||
|
if (rfb->pos < rfb->size) {
|
|||
|
rfb->_data[rfb->pos++] = c;
|
|||
|
return 1;
|
|||
|
}
|
|||
|
rfb->_data = realloc(rfb->_data, rfb->size ? rfb->size + 1 : rfb->size + 2);
|
|||
|
rfb->_data[rfb->pos++] = c;
|
|||
|
rfb->size++;
|
|||
|
return rfb->pos;
|
|||
|
}
|
|||
|
void rbuffer_write(rbuffer_t *rfb, const unsigned char *data, size_t size) {
|
|||
|
unsigned char *data_ptr = (unsigned char *)data;
|
|||
|
for (size_t i = 0; i < size; i++) {
|
|||
|
rbuffer_push(rfb, data_ptr[i]);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
unsigned char rbuffer_peek(rbuffer_t *rfb) {
|
|||
|
unsigned char result = EOF;
|
|||
|
if (rfb->pos != rfb->size) {
|
|||
|
result = rfb->_data[rfb->pos];
|
|||
|
return result;
|
|||
|
}
|
|||
|
rfb->eof = true;
|
|||
|
return EOF;
|
|||
|
}
|
|||
|
unsigned char rbuffer_pop(rbuffer_t *rfb) {
|
|||
|
unsigned char result = EOF;
|
|||
|
if (rfb->pos <= rfb->size) {
|
|||
|
result = rfb->_data[rfb->pos];
|
|||
|
rfb->pos++;
|
|||
|
rfb->data++;
|
|||
|
if (rfb->pos == rfb->size) {
|
|||
|
rfb->eof = true;
|
|||
|
}
|
|||
|
return result;
|
|||
|
}
|
|||
|
rfb->eof = true;
|
|||
|
return result;
|
|||
|
}
|
|||
|
void rbuffer_reset(rbuffer_t *rfb) {
|
|||
|
rfb->data = rfb->_data;
|
|||
|
rfb->pos = 0;
|
|||
|
}
|
|||
|
|
|||
|
unsigned char ustrncmp(const unsigned char *s1, const unsigned char *s2, size_t n) {
|
|||
|
return strncmp((char *)s1, (char *)s2, n);
|
|||
|
while (n && *s1 == *s2) {
|
|||
|
n--;
|
|||
|
s1++;
|
|||
|
s2++;
|
|||
|
}
|
|||
|
return *s1 != *s2;
|
|||
|
}
|
|||
|
size_t ustrlen(const unsigned char *s) { return strlen((char *)s); }
|
|||
|
|
|||
|
unsigned char *rbuffer_to_string(rbuffer_t *rfb) {
|
|||
|
unsigned char *result = rfb->_data;
|
|||
|
rfb->_data = NULL;
|
|||
|
rfb->data = NULL;
|
|||
|
rbuffer_free(rfb);
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
unsigned char *rbuffer_match_option(rbuffer_t *rfb, char *options) {
|
|||
|
char *option = NULL;
|
|||
|
char options_cpy[1024] = {0};
|
|||
|
strcpy(options_cpy, options);
|
|||
|
char *memory = options_cpy;
|
|||
|
while ((option = strtok_r(option == NULL ? memory : NULL, "|", &memory)) != NULL) {
|
|||
|
|
|||
|
size_t option_length = strlen(option);
|
|||
|
if (option_length > rfb->size - rfb->pos) {
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (!strcmp(option, "\\d") && *rfb->data >= '0' && *rfb->data <= '9') {
|
|||
|
return rfb->data;
|
|||
|
}
|
|||
|
if (rfb->size - rfb->pos >= 5 && !strcmp(option, "\\b") &&
|
|||
|
((!ustrncmp(rfb->data, (unsigned char *)"true", 4) || !ustrncmp(rfb->data, (unsigned char *)"false", 5)))) {
|
|||
|
return rfb->data;
|
|||
|
}
|
|||
|
if (!ustrncmp(rfb->data, (unsigned char *)option, option_length)) {
|
|||
|
return rfb->data;
|
|||
|
}
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
unsigned char *rbuffer_expect(rbuffer_t *rfb, char *options, char *ignore) {
|
|||
|
while (rfb->pos < rfb->size) {
|
|||
|
if (rbuffer_match_option(rfb, options) != NULL) {
|
|||
|
return rfb->data;
|
|||
|
}
|
|||
|
if (rbuffer_match_option(rfb, ignore)) {
|
|||
|
printf("SKIP:%s\n", rfb->data);
|
|||
|
rbuffer_pop(rfb);
|
|||
|
continue;
|
|||
|
}
|
|||
|
break;
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
unsigned char *rbuffer_consume(rbuffer_t *rfb, char *options, char *ignore) {
|
|||
|
unsigned char *result = NULL;
|
|||
|
if ((result = rbuffer_expect(rfb, options, ignore)) != NULL) {
|
|||
|
rbuffer_pop(rfb);
|
|||
|
}
|
|||
|
return result;
|
|||
|
}
|
|||
|
#endif
|
|||
|
#ifndef RSTRING_H
|
|||
|
#define RSTRING_H
|
|||
|
#ifndef RMATH_H
|
|||
|
#define RMATH_H
|
|||
|
#include <math.h>
|
|||
|
|
|||
|
#ifndef ceil
|
|||
|
double ceil(double x) {
|
|||
|
if (x == (double)(long long)x) {
|
|||
|
return x;
|
|||
|
} else if (x > 0.0) {
|
|||
|
return (double)(long long)x + 1.0;
|
|||
|
} else {
|
|||
|
return (double)(long long)x;
|
|||
|
}
|
|||
|
}
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef floor
|
|||
|
double floor(double x) {
|
|||
|
if (x >= 0.0) {
|
|||
|
return (double)(long long)x;
|
|||
|
} else {
|
|||
|
double result = (double)(long long)x;
|
|||
|
return (result == x) ? result : result - 1.0;
|
|||
|
}
|
|||
|
}
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef modf
|
|||
|
double modf(double x, double *iptr) {
|
|||
|
double int_part = (x >= 0.0) ? floor(x) : ceil(x);
|
|||
|
*iptr = int_part;
|
|||
|
return x - int_part;
|
|||
|
}
|
|||
|
#endif
|
|||
|
#endif
|
|||
|
#include <ctype.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#include <time.h>
|
|||
|
|
|||
|
char *rstrtimestamp() {
|
|||
|
time_t current_time;
|
|||
|
time(¤t_time);
|
|||
|
struct tm *local_time = localtime(¤t_time);
|
|||
|
static char time_string[100];
|
|||
|
time_string[0] = 0;
|
|||
|
strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", local_time);
|
|||
|
return time_string;
|
|||
|
}
|
|||
|
|
|||
|
ulonglong _r_generate_key_current = 0;
|
|||
|
|
|||
|
char *_rcat_int_int(int a, int b) {
|
|||
|
static char res[20];
|
|||
|
res[0] = 0;
|
|||
|
sprintf(res, "%d%d", a, b);
|
|||
|
return res;
|
|||
|
}
|
|||
|
char *_rcat_int_double(int a, double b) {
|
|||
|
static char res[20];
|
|||
|
res[0] = 0;
|
|||
|
sprintf(res, "%d%f", a, b);
|
|||
|
return res;
|
|||
|
}
|
|||
|
|
|||
|
char *_rcat_charp_int(char *a, int b) {
|
|||
|
char res[20];
|
|||
|
sprintf(res, "%c", b);
|
|||
|
return strcat(a, res);
|
|||
|
}
|
|||
|
|
|||
|
char *_rcat_charp_double(char *a, double b) {
|
|||
|
char res[20];
|
|||
|
sprintf(res, "%f", b);
|
|||
|
return strcat(a, res);
|
|||
|
}
|
|||
|
|
|||
|
char *_rcat_charp_charp(char *a, char *b) {
|
|||
|
;
|
|||
|
return strcat(a, b);
|
|||
|
}
|
|||
|
char *_rcat_charp_char(char *a, char b) {
|
|||
|
char extra[] = {b, 0};
|
|||
|
return strcat(a, extra);
|
|||
|
}
|
|||
|
char *_rcat_charp_bool(char *a, bool *b) {
|
|||
|
if (b) {
|
|||
|
return strcat(a, "true");
|
|||
|
} else {
|
|||
|
return strcat(a, "false");
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#define rcat(x, y) \
|
|||
|
_Generic((x), \
|
|||
|
int: _Generic((y), int: _rcat_int_int, double: _rcat_int_double, char *: _rcat_charp_charp), \
|
|||
|
char *: _Generic((y), \
|
|||
|
int: _rcat_charp_int, \
|
|||
|
double: _rcat_charp_double, \
|
|||
|
char *: _rcat_charp_charp, \
|
|||
|
char: _rcat_charp_char, \
|
|||
|
bool: _rcat_charp_bool))((x), (y))
|
|||
|
|
|||
|
char *rgenerate_key() {
|
|||
|
_r_generate_key_current++;
|
|||
|
static char key[100];
|
|||
|
key[0] = 0;
|
|||
|
sprintf(key, "%lld", _r_generate_key_current);
|
|||
|
return key;
|
|||
|
}
|
|||
|
|
|||
|
char *rformat_number(long long lnumber) {
|
|||
|
static char formatted[1024];
|
|||
|
|
|||
|
char number[1024] = {0};
|
|||
|
sprintf(number, "%lld", lnumber);
|
|||
|
|
|||
|
int len = strlen(number);
|
|||
|
int commas_needed = (len - 1) / 3;
|
|||
|
int new_len = len + commas_needed;
|
|||
|
|
|||
|
formatted[new_len] = '\0';
|
|||
|
|
|||
|
int i = len - 1;
|
|||
|
int j = new_len - 1;
|
|||
|
int count = 0;
|
|||
|
|
|||
|
while (i >= 0) {
|
|||
|
if (count == 3) {
|
|||
|
formatted[j--] = '.';
|
|||
|
count = 0;
|
|||
|
}
|
|||
|
formatted[j--] = number[i--];
|
|||
|
count++;
|
|||
|
}
|
|||
|
if (lnumber < 0)
|
|||
|
formatted[j--] = '-';
|
|||
|
return formatted;
|
|||
|
}
|
|||
|
|
|||
|
bool rstrextractdouble(char *str, double *d1) {
|
|||
|
for (size_t i = 0; i < strlen(str); i++) {
|
|||
|
if (isdigit(str[i])) {
|
|||
|
str += i;
|
|||
|
sscanf(str, "%lf", d1);
|
|||
|
return true;
|
|||
|
}
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
void rstrstripslashes(const char *content, char *result) {
|
|||
|
size_t content_length = strlen((char *)content);
|
|||
|
unsigned int index = 0;
|
|||
|
for (unsigned int i = 0; i < content_length; i++) {
|
|||
|
char c = content[i];
|
|||
|
if (c == '\\') {
|
|||
|
i++;
|
|||
|
c = content[i];
|
|||
|
if (c == 'r') {
|
|||
|
c = '\r';
|
|||
|
} else if (c == 't') {
|
|||
|
c = '\t';
|
|||
|
} else if (c == 'b') {
|
|||
|
c = '\b';
|
|||
|
} else if (c == 'n') {
|
|||
|
c = '\n';
|
|||
|
} else if (c == 'f') {
|
|||
|
c = '\f';
|
|||
|
} else if (c == '\\') {
|
|||
|
// No need tbh
|
|||
|
c = '\\';
|
|||
|
i++;
|
|||
|
}
|
|||
|
}
|
|||
|
result[index] = c;
|
|||
|
index++;
|
|||
|
}
|
|||
|
result[index] = 0;
|
|||
|
}
|
|||
|
|
|||
|
int rstrstartswith(const char *s1, const char *s2) {
|
|||
|
if (s1 == NULL)
|
|||
|
return s2 == NULL;
|
|||
|
if (s1 == s2 || s2 == NULL || *s2 == 0)
|
|||
|
return true;
|
|||
|
size_t len_s2 = strlen(s2);
|
|||
|
size_t len_s1 = strlen(s1);
|
|||
|
if (len_s2 > len_s1)
|
|||
|
return false;
|
|||
|
return !strncmp(s1, s2, len_s2);
|
|||
|
}
|
|||
|
|
|||
|
bool rstrendswith(const char *s1, const char *s2) {
|
|||
|
if (s1 == NULL)
|
|||
|
return s2 == NULL;
|
|||
|
if (s1 == s2 || s2 == NULL || *s2 == 0)
|
|||
|
return true;
|
|||
|
size_t len_s2 = strlen(s2);
|
|||
|
size_t len_s1 = strlen(s1);
|
|||
|
if (len_s2 > len_s1) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
s1 += len_s1 - len_s2;
|
|||
|
return !strncmp(s1, s2, len_s2);
|
|||
|
}
|
|||
|
|
|||
|
void rstraddslashes(const char *content, char *result) {
|
|||
|
size_t content_length = strlen((char *)content);
|
|||
|
unsigned int index = 0;
|
|||
|
for (unsigned int i = 0; i < content_length; i++) {
|
|||
|
if (content[i] == '\r') {
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
result[index] = 'r';
|
|||
|
index++;
|
|||
|
continue;
|
|||
|
} else if (content[i] == '\t') {
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
result[index] = 't';
|
|||
|
index++;
|
|||
|
continue;
|
|||
|
} else if (content[i] == '\n') {
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
result[index] = 'n';
|
|||
|
index++;
|
|||
|
continue;
|
|||
|
} else if (content[i] == '\\') {
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
continue;
|
|||
|
} else if (content[i] == '\b') {
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
result[index] = 'b';
|
|||
|
index++;
|
|||
|
continue;
|
|||
|
} else if (content[i] == '\f') {
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
result[index] = 'f';
|
|||
|
index++;
|
|||
|
continue;
|
|||
|
} else if (content[i] == '"') {
|
|||
|
result[index] = '\\';
|
|||
|
index++;
|
|||
|
result[index] = '"';
|
|||
|
index++;
|
|||
|
continue;
|
|||
|
}
|
|||
|
result[index] = content[i];
|
|||
|
index++;
|
|||
|
result[index] = 0;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
int rstrip_whitespace(char *input, char *output) {
|
|||
|
output[0] = 0;
|
|||
|
int count = 0;
|
|||
|
size_t len = strlen(input);
|
|||
|
for (size_t i = 0; i < len; i++) {
|
|||
|
if (input[i] == '\t' || input[i] == ' ' || input[i] == '\n') {
|
|||
|
continue;
|
|||
|
}
|
|||
|
count = i;
|
|||
|
size_t j;
|
|||
|
for (j = 0; j < len - count; j++) {
|
|||
|
output[j] = input[j + count];
|
|||
|
}
|
|||
|
output[j] = '\0';
|
|||
|
break;
|
|||
|
}
|
|||
|
return count;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* Converts "pony" to \"pony\". Addslashes does not
|
|||
|
* Converts "pony\npony" to "pony\n"
|
|||
|
* "pony"
|
|||
|
*/
|
|||
|
void rstrtocstring(const char *input, char *output) {
|
|||
|
int index = 0;
|
|||
|
char clean_input[strlen(input) * 2];
|
|||
|
char *iptr = clean_input;
|
|||
|
rstraddslashes(input, clean_input);
|
|||
|
output[index] = '"';
|
|||
|
index++;
|
|||
|
while (*iptr) {
|
|||
|
if (*iptr == '"') {
|
|||
|
output[index] = '\\';
|
|||
|
output++;
|
|||
|
} else if (*iptr == '\\' && *(iptr + 1) == 'n') {
|
|||
|
output[index] = '\\';
|
|||
|
output++;
|
|||
|
output[index] = 'n';
|
|||
|
output++;
|
|||
|
output[index] = '"';
|
|||
|
output++;
|
|||
|
output[index] = '\n';
|
|||
|
output++;
|
|||
|
output[index] = '"';
|
|||
|
output++;
|
|||
|
iptr++;
|
|||
|
iptr++;
|
|||
|
continue;
|
|||
|
}
|
|||
|
output[index] = *iptr;
|
|||
|
index++;
|
|||
|
iptr++;
|
|||
|
}
|
|||
|
if (output[index - 1] == '"' && output[index - 2] == '\n') {
|
|||
|
output[index - 1] = 0;
|
|||
|
} else if (output[index - 1] != '"') {
|
|||
|
output[index] = '"';
|
|||
|
output[index + 1] = 0;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
size_t rstrtokline(char *input, char *output, size_t offset, bool strip_nl) {
|
|||
|
|
|||
|
size_t len = strlen(input);
|
|||
|
output[0] = 0;
|
|||
|
size_t new_offset = 0;
|
|||
|
size_t j;
|
|||
|
size_t index = 0;
|
|||
|
|
|||
|
for (j = offset; j < len + offset; j++) {
|
|||
|
if (input[j] == 0) {
|
|||
|
index++;
|
|||
|
break;
|
|||
|
}
|
|||
|
index = j - offset;
|
|||
|
output[index] = input[j];
|
|||
|
|
|||
|
if (output[index] == '\n') {
|
|||
|
index++;
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
output[index] = 0;
|
|||
|
|
|||
|
new_offset = index + offset;
|
|||
|
|
|||
|
if (strip_nl) {
|
|||
|
if (output[index - 1] == '\n') {
|
|||
|
output[index - 1] = 0;
|
|||
|
}
|
|||
|
}
|
|||
|
return new_offset;
|
|||
|
}
|
|||
|
|
|||
|
void rstrjoin(char **lines, size_t count, char *glue, char *output) {
|
|||
|
output[0] = 0;
|
|||
|
for (size_t i = 0; i < count; i++) {
|
|||
|
strcat(output, lines[i]);
|
|||
|
if (i != count - 1)
|
|||
|
strcat(output, glue);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
int rstrsplit(char *input, char **lines) {
|
|||
|
int index = 0;
|
|||
|
size_t offset = 0;
|
|||
|
char line[1024];
|
|||
|
while ((offset = rstrtokline(input, line, offset, false)) && *line) {
|
|||
|
if (!*line) {
|
|||
|
break;
|
|||
|
}
|
|||
|
lines[index] = (char *)malloc(strlen(line) + 1);
|
|||
|
strcpy(lines[index], line);
|
|||
|
index++;
|
|||
|
}
|
|||
|
return index;
|
|||
|
}
|
|||
|
|
|||
|
bool rstartswithnumber(char *str) { return isdigit(str[0]); }
|
|||
|
|
|||
|
void rstrmove2(char *str, unsigned int start, size_t length, unsigned int new_pos) {
|
|||
|
size_t str_len = strlen(str);
|
|||
|
char new_str[str_len + 1];
|
|||
|
memset(new_str, 0, str_len);
|
|||
|
if (start < new_pos) {
|
|||
|
strncat(new_str, str + length, str_len - length - start);
|
|||
|
new_str[new_pos] = 0;
|
|||
|
strncat(new_str, str + start, length);
|
|||
|
strcat(new_str, str + strlen(new_str));
|
|||
|
memset(str, 0, str_len);
|
|||
|
strcpy(str, new_str);
|
|||
|
} else {
|
|||
|
strncat(new_str, str + start, length);
|
|||
|
strncat(new_str, str, start);
|
|||
|
strncat(new_str, str + start + length, str_len - start);
|
|||
|
memset(str, 0, str_len);
|
|||
|
strcpy(str, new_str);
|
|||
|
}
|
|||
|
new_str[str_len] = 0;
|
|||
|
}
|
|||
|
|
|||
|
void rstrmove(char *str, unsigned int start, size_t length, unsigned int new_pos) {
|
|||
|
size_t str_len = strlen(str);
|
|||
|
if (start >= str_len || new_pos >= str_len || start + length > str_len) {
|
|||
|
return;
|
|||
|
}
|
|||
|
char temp[length + 1];
|
|||
|
strncpy(temp, str + start, length);
|
|||
|
temp[length] = 0;
|
|||
|
if (start < new_pos) {
|
|||
|
memmove(str + start, str + start + length, new_pos - start);
|
|||
|
strncpy(str + new_pos - length + 1, temp, length);
|
|||
|
} else {
|
|||
|
memmove(str + new_pos + length, str + new_pos, start - new_pos);
|
|||
|
strncpy(str + new_pos, temp, length);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
int cmp_line(const void *left, const void *right) {
|
|||
|
char *l = *(char **)left;
|
|||
|
char *r = *(char **)right;
|
|||
|
|
|||
|
char lstripped[strlen(l) + 1];
|
|||
|
rstrip_whitespace(l, lstripped);
|
|||
|
char rstripped[strlen(r) + 1];
|
|||
|
rstrip_whitespace(r, rstripped);
|
|||
|
|
|||
|
double d1, d2;
|
|||
|
bool found_d1 = rstrextractdouble(lstripped, &d1);
|
|||
|
bool found_d2 = rstrextractdouble(rstripped, &d2);
|
|||
|
|
|||
|
if (found_d1 && found_d2) {
|
|||
|
double frac_part1;
|
|||
|
double int_part1;
|
|||
|
frac_part1 = modf(d1, &int_part1);
|
|||
|
double frac_part2;
|
|||
|
double int_part2;
|
|||
|
frac_part2 = modf(d2, &int_part2);
|
|||
|
if (d1 == d2) {
|
|||
|
return strcmp(lstripped, rstripped);
|
|||
|
} else if (frac_part1 && frac_part2) {
|
|||
|
return d1 > d2;
|
|||
|
} else if (frac_part1 && !frac_part2) {
|
|||
|
return 1;
|
|||
|
} else if (frac_part2 && !frac_part1) {
|
|||
|
return -1;
|
|||
|
} else if (!frac_part1 && !frac_part2) {
|
|||
|
return d1 > d2;
|
|||
|
}
|
|||
|
}
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
int rstrsort(char *input, char *output) {
|
|||
|
char **lines = (char **)malloc(strlen(input) * 10);
|
|||
|
int line_count = rstrsplit(input, lines);
|
|||
|
qsort(lines, line_count, sizeof(char *), cmp_line);
|
|||
|
rstrjoin(lines, line_count, "", output);
|
|||
|
for (int i = 0; i < line_count; i++) {
|
|||
|
free(lines[i]);
|
|||
|
}
|
|||
|
free(lines);
|
|||
|
return line_count;
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
#include <assert.h>
|
|||
|
#include <ctype.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
|
|||
|
typedef enum rliza_type_t {
|
|||
|
RLIZA_STRING = 's',
|
|||
|
RLIZA_BOOLEAN = 'b',
|
|||
|
RLIZA_NUMBER = 'n',
|
|||
|
RLIZA_OBJECT = 'o',
|
|||
|
RLIZA_ARRAY = 'a',
|
|||
|
RLIZA_NULL = 0,
|
|||
|
RLIZA_KEY = 'k',
|
|||
|
RLIZA_INTEGER = 'i'
|
|||
|
} rliza_type_t;
|
|||
|
|
|||
|
typedef struct rliza_t {
|
|||
|
rliza_type_t type;
|
|||
|
struct rliza_t *value;
|
|||
|
char *key;
|
|||
|
union {
|
|||
|
char *string;
|
|||
|
bool boolean;
|
|||
|
double number;
|
|||
|
struct rliza_t **map;
|
|||
|
long long integer;
|
|||
|
} content;
|
|||
|
unsigned int count;
|
|||
|
char *(*get_string)(struct rliza_t *, char *);
|
|||
|
long long (*get_integer)(struct rliza_t *, char *);
|
|||
|
double (*get_number)(struct rliza_t *, char *);
|
|||
|
bool (*get_boolean)(struct rliza_t *, char *);
|
|||
|
struct rliza_t *(*get_array)(struct rliza_t *, char *);
|
|||
|
struct rliza_t *(*get_object)(struct rliza_t *, char *);
|
|||
|
void (*set_string)(struct rliza_t *, char *, char *);
|
|||
|
void (*set_integer)(struct rliza_t *, char *, long long);
|
|||
|
void (*set_number)(struct rliza_t *, char *, double);
|
|||
|
void (*set_boolean)(struct rliza_t *, char *, bool);
|
|||
|
void (*set_array)(struct rliza_t *self, char *key, struct rliza_t *array);
|
|||
|
void (*set_object)(struct rliza_t *self, char *key, struct rliza_t *object);
|
|||
|
} rliza_t;
|
|||
|
|
|||
|
void rliza_free(rliza_t *rliza) {
|
|||
|
if (rliza->key) {
|
|||
|
free(rliza->key);
|
|||
|
rliza->key = NULL;
|
|||
|
}
|
|||
|
if (rliza->value) {
|
|||
|
rliza_free(rliza->value);
|
|||
|
rliza->value = NULL;
|
|||
|
}
|
|||
|
// if (rliza->content.array) {
|
|||
|
// printf("JAAAA\n");
|
|||
|
// }
|
|||
|
// if (rliza->content.object) {
|
|||
|
// rliza_free(rliza->content.object);
|
|||
|
// rliza->content.object = NULL;
|
|||
|
//}
|
|||
|
if (rliza->type == RLIZA_STRING) {
|
|||
|
if (rliza->content.string) {
|
|||
|
free(rliza->content.string);
|
|||
|
rliza->content.string = NULL;
|
|||
|
// else if (rliza->type == RLIZA_NUMBER) {
|
|||
|
// printf("STDring freed\n");
|
|||
|
}
|
|||
|
} else if (rliza->type == RLIZA_OBJECT || rliza->type == RLIZA_ARRAY) {
|
|||
|
|
|||
|
if (rliza->content.map) {
|
|||
|
for (unsigned int i = 0; i < rliza->count; i++) {
|
|||
|
rliza_free(rliza->content.map[i]);
|
|||
|
}
|
|||
|
free(rliza->content.map);
|
|||
|
}
|
|||
|
}
|
|||
|
// free(rliza->content.array);
|
|||
|
//}
|
|||
|
|
|||
|
free(rliza);
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new(rliza_type_t type);
|
|||
|
rliza_t *rliza_new_string(char *string);
|
|||
|
rliza_t *rliza_new_null();
|
|||
|
rliza_t *rliza_new_boolean(bool value);
|
|||
|
rliza_t *rliza_new_number(double value);
|
|||
|
rliza_t *rliza_new_integer(long long value);
|
|||
|
rliza_t *rliza_new_key_value(char *key, rliza_t *value);
|
|||
|
rliza_t *rliza_new_key_string(char *key, char *string);
|
|||
|
rliza_t *rliza_new_key_bool(char *key, bool value);
|
|||
|
rliza_t *rliza_new_key_number(char *key, double value);
|
|||
|
void rliza_push(rliza_t *self, rliza_t *obj);
|
|||
|
void rliza_push_object(rliza_t *self, rliza_t *object);
|
|||
|
void rliza_set_object(rliza_t *self, char *key, rliza_t *object);
|
|||
|
void rliza_set_string(rliza_t *self, char *key, char *string);
|
|||
|
void rliza_set_boolean(rliza_t *self, char *key, bool value);
|
|||
|
void rliza_set_number(rliza_t *self, char *key, double value);
|
|||
|
void rliza_set_integer(rliza_t *self, char *key, long long value);
|
|||
|
char *rliza_get_string(rliza_t *self, char *key);
|
|||
|
long long rliza_get_integer(rliza_t *self, char *key);
|
|||
|
double rliza_get_number(rliza_t *self, char *key);
|
|||
|
bool rliza_get_boolean(rliza_t *self, char *key);
|
|||
|
rliza_t *rliza_get_array(rliza_t *self, char *key);
|
|||
|
rliza_t *rliza_get_object(rliza_t *self, char *key);
|
|||
|
void rliza_set_array(rliza_t *self, char *key, rliza_t *array);
|
|||
|
|
|||
|
char *rliza_dumps(rliza_t *rliza);
|
|||
|
rliza_t *rliza_loads(char **content);
|
|||
|
rliza_t *_rliza_loads(char **content);
|
|||
|
|
|||
|
char *rliza_get_string(rliza_t *self, char *key) {
|
|||
|
for (unsigned int i = 0; i < self->count; i++) {
|
|||
|
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
|
|||
|
if (self->content.map[i]->type == RLIZA_STRING || self->content.map[i]->type == RLIZA_NULL) {
|
|||
|
return self->content.map[i]->content.string;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
long long rliza_get_integer(rliza_t *self, char *key) {
|
|||
|
for (unsigned int i = 0; i < self->count; i++) {
|
|||
|
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
|
|||
|
if (self->content.map[i]->type == RLIZA_INTEGER || self->content.map[i]->type == RLIZA_NULL) {
|
|||
|
return self->content.map[i]->content.integer;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
double rliza_get_number(rliza_t *self, char *key) {
|
|||
|
for (unsigned int i = 0; i < self->count; i++) {
|
|||
|
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
|
|||
|
if (self->content.map[i]->type == RLIZA_NUMBER || self->content.map[i]->type == RLIZA_NULL) {
|
|||
|
return self->content.map[i]->content.number;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
bool rliza_get_boolean(rliza_t *self, char *key) {
|
|||
|
for (unsigned int i = 0; i < self->count; i++) {
|
|||
|
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
|
|||
|
if (self->content.map[i]->type == RLIZA_BOOLEAN || self->content.map[i]->type == RLIZA_NULL) {
|
|||
|
return self->content.map[i]->content.boolean;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_get_object(rliza_t *self, char *key) {
|
|||
|
for (unsigned int i = 0; i < self->count; i++) {
|
|||
|
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
|
|||
|
return self->content.map[i];
|
|||
|
}
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_get_array(rliza_t *self, char *key) {
|
|||
|
for (unsigned int i = 0; i < self->count; i++) {
|
|||
|
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
|
|||
|
if (self->content.map[i]->type == RLIZA_ARRAY || self->content.map[i]->type == RLIZA_NULL) {
|
|||
|
return self->content.map[i];
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new_null() {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_NULL);
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
rliza_t *rliza_new_string(char *string) {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_STRING);
|
|||
|
if (string == NULL) {
|
|||
|
rliza->type = RLIZA_NULL;
|
|||
|
rliza->content.string = NULL;
|
|||
|
return rliza;
|
|||
|
} else {
|
|||
|
rliza->content.string = strdup(string);
|
|||
|
}
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
rliza_t *rliza_new_boolean(bool value) {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_BOOLEAN);
|
|||
|
rliza->content.boolean = value;
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new_number(double value) {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_NUMBER);
|
|||
|
rliza->content.number = value;
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new_integer(long long value) {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_INTEGER);
|
|||
|
rliza->content.integer = value;
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
rliza_t *rliza_new_key_array(char *key) {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_ARRAY);
|
|||
|
rliza->key = strdup(key);
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new_key_value(char *key, rliza_t *value) {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_OBJECT);
|
|||
|
if (key) {
|
|||
|
rliza->key = strdup(key);
|
|||
|
}
|
|||
|
rliza->value = value;
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new_key_string(char *key, char *string) {
|
|||
|
rliza_t *rliza = rliza_new_key_value(key, rliza_new_string(string));
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
rliza_t *rliza_new_key_bool(char *key, bool value) {
|
|||
|
rliza_t *rliza = rliza_new_key_value(key, rliza_new_boolean(value));
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
rliza_t *rliza_new_key_number(char *key, double value) {
|
|||
|
rliza_t *rliza = rliza_new_key_value(key, rliza_new_number(value));
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
|
|||
|
void rliza_set_null(rliza_t *self, char *key) {
|
|||
|
rliza_t *obj = rliza_get_object(self, key);
|
|||
|
if (!obj) {
|
|||
|
obj = rliza_new_null();
|
|||
|
obj->key = strdup(key);
|
|||
|
rliza_push_object(self, obj);
|
|||
|
}
|
|||
|
if (obj->type == RLIZA_OBJECT) {
|
|||
|
|
|||
|
rliza_free(obj->value);
|
|||
|
obj->value = NULL;
|
|||
|
} else if (obj->type == RLIZA_STRING) {
|
|||
|
if (obj->content.string)
|
|||
|
free(obj->content.string);
|
|||
|
obj->content.string = NULL;
|
|||
|
} else if (obj->type == RLIZA_ARRAY) {
|
|||
|
for (unsigned int i = 0; i < obj->count; i++) {
|
|||
|
rliza_free(obj->content.map[i]);
|
|||
|
}
|
|||
|
} else if (obj->type == RLIZA_NUMBER) {
|
|||
|
obj->content.number = 0;
|
|||
|
} else if (obj->type == RLIZA_INTEGER) {
|
|||
|
obj->content.integer = 0;
|
|||
|
}
|
|||
|
obj->type = RLIZA_NULL;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_duplicate(rliza_t *rliza) {
|
|||
|
if (!rliza)
|
|||
|
return NULL;
|
|||
|
char *str = rliza_dumps(rliza);
|
|||
|
char *strp = str;
|
|||
|
rliza_t *obj = rliza_loads(&strp);
|
|||
|
free(str);
|
|||
|
return obj;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new_object(rliza_t *obj) {
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_OBJECT);
|
|||
|
rliza->value = obj;
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
void rliza_set_object(rliza_t *self, char *key, rliza_t *value) {
|
|||
|
rliza_t *obj = rliza_duplicate(value);
|
|||
|
obj->key = strdup(key);
|
|||
|
obj->type = RLIZA_OBJECT;
|
|||
|
rliza_push(self, obj);
|
|||
|
}
|
|||
|
|
|||
|
void rliza_set_string(rliza_t *self, char *key, char *string) {
|
|||
|
rliza_t *obj = rliza_get_object(self, key);
|
|||
|
|
|||
|
if (!obj) {
|
|||
|
obj = rliza_new_string(string);
|
|||
|
obj->key = strdup(key);
|
|||
|
obj->type = RLIZA_STRING;
|
|||
|
rliza_push_object(self, obj);
|
|||
|
} else {
|
|||
|
obj->content.string = strdup(string);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
void rliza_set_array(rliza_t *self, char *key, rliza_t *array) {
|
|||
|
rliza_t *obj = rliza_get_object(self, key);
|
|||
|
if (obj)
|
|||
|
rliza_free(obj);
|
|||
|
if (array->key) {
|
|||
|
free(array->key);
|
|||
|
array->key = strdup(key);
|
|||
|
}
|
|||
|
rliza_push_object(self, array);
|
|||
|
}
|
|||
|
|
|||
|
void rliza_set_number(rliza_t *self, char *key, double value) {
|
|||
|
rliza_t *obj = rliza_get_object(self, key);
|
|||
|
if (!obj) {
|
|||
|
obj = rliza_new_number(value);
|
|||
|
obj->key = strdup(key);
|
|||
|
obj->type = RLIZA_NUMBER;
|
|||
|
rliza_push_object(self, obj);
|
|||
|
} else {
|
|||
|
obj->content.number = value;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
void rliza_push_object(rliza_t *self, rliza_t *object) {
|
|||
|
self->content.map = realloc(self->content.map, (sizeof(rliza_t **)) * (self->count + 1));
|
|||
|
self->content.map[self->count] = object;
|
|||
|
self->count++;
|
|||
|
}
|
|||
|
void rliza_set_integer(rliza_t *self, char *key, long long value) {
|
|||
|
rliza_t *obj = rliza_get_object(self, key);
|
|||
|
if (!obj) {
|
|||
|
obj = rliza_new_integer(value);
|
|||
|
obj->key = strdup(key);
|
|||
|
obj->type = RLIZA_INTEGER;
|
|||
|
rliza_push_object(self, obj);
|
|||
|
} else {
|
|||
|
obj->content.integer = value;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
void rliza_set_boolean(rliza_t *self, char *key, bool value) {
|
|||
|
rliza_t *obj = rliza_get_object(self, key);
|
|||
|
if (!obj) {
|
|||
|
obj = rliza_new_boolean(value);
|
|||
|
obj->key = strdup(key);
|
|||
|
obj->type = RLIZA_BOOLEAN;
|
|||
|
|
|||
|
rliza_push_object(self, obj);
|
|||
|
} else {
|
|||
|
obj->content.boolean = value;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *rliza_new(rliza_type_t type) {
|
|||
|
rliza_t *rliza = (rliza_t *)calloc(1, sizeof(rliza_t));
|
|||
|
rliza->type = type;
|
|||
|
rliza->get_boolean = rliza_get_boolean;
|
|||
|
rliza->get_integer = rliza_get_integer;
|
|||
|
rliza->get_number = rliza_get_number;
|
|||
|
rliza->get_string = rliza_get_string;
|
|||
|
rliza->get_array = rliza_get_array;
|
|||
|
rliza->get_object = rliza_get_object;
|
|||
|
rliza->set_string = rliza_set_string;
|
|||
|
rliza->set_number = rliza_set_number;
|
|||
|
rliza->set_boolean = rliza_set_boolean;
|
|||
|
rliza->set_integer = rliza_set_integer;
|
|||
|
rliza->set_array = rliza_set_array;
|
|||
|
rliza->set_object = rliza_set_object;
|
|||
|
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
|
|||
|
void *rliza_coalesce(void *result, void *default_value) {
|
|||
|
if (result == NULL)
|
|||
|
return default_value;
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
char *rliza_seek_string(char **content, char **options) {
|
|||
|
|
|||
|
while (**content == ' ' || **content == '\n' || **content == '\t' || **content == '\r') {
|
|||
|
(*content)++;
|
|||
|
}
|
|||
|
if (**content == 0) {
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
char *option = NULL;
|
|||
|
unsigned int option_index = 0;
|
|||
|
|
|||
|
while (true) {
|
|||
|
option = options[option_index];
|
|||
|
if (option == NULL)
|
|||
|
break;
|
|||
|
option_index++;
|
|||
|
if (option[0] == 'd') {
|
|||
|
if (**content >= '0' && **content <= '9') {
|
|||
|
return (char *)*content;
|
|||
|
}
|
|||
|
} else if (!strncmp(option, *content, strlen(option))) {
|
|||
|
return (char *)*content;
|
|||
|
}
|
|||
|
}
|
|||
|
return *content;
|
|||
|
}
|
|||
|
|
|||
|
char *rliza_extract_quotes(char **content) {
|
|||
|
rbuffer_t *buffer = rbuffer_new(NULL, 0);
|
|||
|
assert(**content == '"');
|
|||
|
char previous = 0;
|
|||
|
while (true) {
|
|||
|
|
|||
|
(*content)++;
|
|||
|
if (!**content) {
|
|||
|
rbuffer_free(buffer);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
if (**content == '"' && previous != '\\') {
|
|||
|
break;
|
|||
|
}
|
|||
|
rbuffer_push(buffer, **content);
|
|||
|
previous = **content;
|
|||
|
}
|
|||
|
assert(**content == '"');
|
|||
|
(*content)++;
|
|||
|
rbuffer_push(buffer, 0);
|
|||
|
char *result = (char *)rbuffer_to_string(buffer);
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
rliza_t *_rliza_loads(char **content) {
|
|||
|
static char *seek_for1[] = {"[", "{", "\"", "d", "true", "false", "null", NULL};
|
|||
|
char *token = (char *)rliza_seek_string(content, seek_for1);
|
|||
|
if (!token)
|
|||
|
return NULL;
|
|||
|
rliza_t *rliza = rliza_new(RLIZA_NULL);
|
|||
|
if (**content == '"') {
|
|||
|
char *extracted = rliza_extract_quotes(content);
|
|||
|
if (!extracted) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
// char *extracted_with_slashes = (char *)malloc(strlen((char *)extracted) * 2 + 1);
|
|||
|
// rstraddslashes(extracted, extracted_with_slashes);
|
|||
|
rliza->type = RLIZA_STRING;
|
|||
|
rliza->content.string = extracted; // extracted_with_slashes; // extracted_without_slashes;
|
|||
|
// free(extracted);
|
|||
|
return rliza;
|
|||
|
} else if (**content == '{') {
|
|||
|
rliza->type = RLIZA_OBJECT;
|
|||
|
(*content)++;
|
|||
|
char *result = NULL;
|
|||
|
static char *seek_for2[] = {"\"", ",", "}", NULL};
|
|||
|
while ((result = (char *)rliza_seek_string(content, seek_for2)) != NULL && *result) {
|
|||
|
|
|||
|
if (!**content) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (**content == ',') {
|
|||
|
(*content)++;
|
|||
|
if (!**content) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
continue;
|
|||
|
}
|
|||
|
char *key = NULL;
|
|||
|
if (**content == '"') {
|
|||
|
key = rliza_extract_quotes((char **)content);
|
|||
|
if (!key || !*key) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
char *escaped_key = (char *)malloc(strlen((char *)key) * 2 + 1);
|
|||
|
rstrstripslashes((char *)key, escaped_key);
|
|||
|
static char *seek_for3[] = {":", NULL};
|
|||
|
char *devider = rliza_seek_string(content, seek_for3);
|
|||
|
|
|||
|
if (!devider || !*devider) {
|
|||
|
free(escaped_key);
|
|||
|
free(key);
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
(*content)++;
|
|||
|
if (!**content) {
|
|||
|
free(key);
|
|||
|
free(escaped_key);
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
rliza_t *value = _rliza_loads(content);
|
|||
|
if (!value) {
|
|||
|
free(key);
|
|||
|
free(escaped_key);
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (value->key)
|
|||
|
free(value->key);
|
|||
|
value->key = escaped_key;
|
|||
|
free(key);
|
|||
|
rliza_push_object(rliza, value);
|
|||
|
} else if (**content == '}') {
|
|||
|
break;
|
|||
|
} else {
|
|||
|
// Parse error
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
};
|
|||
|
if ((**content != '}')) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
(*content)++;
|
|||
|
return rliza;
|
|||
|
} else if (**content == '[') {
|
|||
|
rliza->type = RLIZA_ARRAY;
|
|||
|
(*content)++;
|
|||
|
char *result;
|
|||
|
static char *seek_for4[] = {"[", "{", "\"", "d", ",", "]", "null", "true", "false", NULL};
|
|||
|
while ((result = (char *)rliza_seek_string(content, seek_for4)) != NULL && *result) {
|
|||
|
if (**content == ',') {
|
|||
|
(*content)++;
|
|||
|
|
|||
|
} else if (**content == ']') {
|
|||
|
break;
|
|||
|
}
|
|||
|
rliza_t *obj = _rliza_loads(content);
|
|||
|
if (!obj) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
rliza_push(rliza, obj);
|
|||
|
if (!**content) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
}
|
|||
|
if (**content != ']') {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
(*content)++;
|
|||
|
return rliza;
|
|||
|
} else if (**content >= '0' && **content <= '9') {
|
|||
|
char *ptr = *content;
|
|||
|
bool is_decimal = false;
|
|||
|
|
|||
|
while (**content) {
|
|||
|
if (**content == '.') {
|
|||
|
is_decimal = true;
|
|||
|
} else if (!isdigit(**content)) {
|
|||
|
break;
|
|||
|
}
|
|||
|
(*content)++;
|
|||
|
}
|
|||
|
if (*(*content - 1) == '.') {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (!**content) {
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
if (is_decimal) {
|
|||
|
rliza->type = RLIZA_NUMBER;
|
|||
|
rliza->content.number = strtod(ptr, NULL);
|
|||
|
} else {
|
|||
|
rliza->type = RLIZA_INTEGER;
|
|||
|
rliza->content.integer = strtoll(ptr, NULL, 10);
|
|||
|
}
|
|||
|
return rliza;
|
|||
|
} else if (!strncmp(*content, "true", 4)) {
|
|||
|
rliza->type = RLIZA_BOOLEAN;
|
|||
|
rliza->content.boolean = true;
|
|||
|
*content += 4;
|
|||
|
|
|||
|
return rliza;
|
|||
|
} else if (!strncmp(*content, "false", 5)) {
|
|||
|
rliza->type = RLIZA_BOOLEAN;
|
|||
|
rliza->content.boolean = false;
|
|||
|
*content += 5;
|
|||
|
|
|||
|
return rliza;
|
|||
|
} else if (!strncmp(*content, "null", 4)) {
|
|||
|
rliza->type = RLIZA_NULL;
|
|||
|
*content += 4;
|
|||
|
|
|||
|
return rliza;
|
|||
|
}
|
|||
|
// Parsing error
|
|||
|
rliza_free(rliza);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
rliza_t *rliza_loads(char **content) {
|
|||
|
if (!content || !**content) {
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
char *original_content = *content;
|
|||
|
rliza_t *result = _rliza_loads(content);
|
|||
|
if (!result) {
|
|||
|
*content = original_content;
|
|||
|
}
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
char *rliza_dumps(rliza_t *rliza) {
|
|||
|
size_t size = 4096;
|
|||
|
char *content = (char *)calloc(size, sizeof(char));
|
|||
|
content[0] = 0;
|
|||
|
if (rliza->type == RLIZA_INTEGER) {
|
|||
|
if (rliza->key) {
|
|||
|
sprintf(content, "\"%s\":%lld", rliza->key, rliza->content.integer);
|
|||
|
} else {
|
|||
|
sprintf(content, "%lld", rliza->content.integer);
|
|||
|
}
|
|||
|
} else if (rliza->type == RLIZA_STRING) {
|
|||
|
|
|||
|
// char *escaped_string = (char *)calloc(strlen((char *)rliza->content.string) * 2 + 1024,sizeof(char));
|
|||
|
char *escaped_string = rliza->content.string;
|
|||
|
// rstrstripslashes((char *)rliza->content.string, escaped_string);
|
|||
|
size_t min_size = strlen((char *)escaped_string) + (rliza->key ? strlen(rliza->key) : 0) + 1024;
|
|||
|
if (size < min_size) {
|
|||
|
size = min_size + 1;
|
|||
|
content = realloc(content, size);
|
|||
|
}
|
|||
|
if (rliza->key) {
|
|||
|
char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 20);
|
|||
|
rstrstripslashes((char *)rliza->key, escaped_key);
|
|||
|
if (strlen(content) > size) {
|
|||
|
size = size + strlen(escaped_string) + 20;
|
|||
|
content = realloc(content, size);
|
|||
|
}
|
|||
|
sprintf(content, "\"%s\":\"%s\"", escaped_key, escaped_string);
|
|||
|
free(escaped_key);
|
|||
|
} else {
|
|||
|
size = size + strlen(escaped_string) + 20;
|
|||
|
content = realloc(content, size);
|
|||
|
sprintf(content, "\"%s\"", escaped_string);
|
|||
|
}
|
|||
|
// free(escaped_string);
|
|||
|
} else if (rliza->type == RLIZA_NUMBER) {
|
|||
|
if (rliza->key) {
|
|||
|
sprintf(content, "\"%s\":%f", rliza->key, rliza->content.number);
|
|||
|
} else {
|
|||
|
sprintf(content, "%f", rliza->content.number);
|
|||
|
}
|
|||
|
int last_zero = 0;
|
|||
|
bool beyond_dot = false;
|
|||
|
for (size_t i = 0; i < strlen(content); i++) {
|
|||
|
if (content[i] == '.') {
|
|||
|
beyond_dot = true;
|
|||
|
} else if (beyond_dot == true) {
|
|||
|
if (content[i - 1] != '.') {
|
|||
|
if (content[i] == '0') {
|
|||
|
if (!last_zero)
|
|||
|
last_zero = i;
|
|||
|
} else {
|
|||
|
last_zero = 0;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
if (last_zero != 0) {
|
|||
|
content[last_zero] = 0;
|
|||
|
}
|
|||
|
} else if (rliza->type == RLIZA_BOOLEAN) {
|
|||
|
if (rliza->key) {
|
|||
|
sprintf(content, "\"%s\":%s", rliza->key, rliza->content.boolean ? "true" : "false");
|
|||
|
} else {
|
|||
|
sprintf(content, "%s", rliza->content.boolean ? "true" : "false");
|
|||
|
}
|
|||
|
} else if (rliza->type == RLIZA_OBJECT) {
|
|||
|
|
|||
|
strcat(content, "{");
|
|||
|
if (rliza->key) {
|
|||
|
strcat(content, "\"");
|
|||
|
strcat(content, rliza->key);
|
|||
|
strcat(content, "\":{");
|
|||
|
}
|
|||
|
// bool add_braces = false;
|
|||
|
for (unsigned i = 0; i < rliza->count; i++) {
|
|||
|
char *content_chunk = rliza_dumps(rliza->content.map[i]);
|
|||
|
char *content_chunk_stripped = content_chunk;
|
|||
|
if (*content_chunk_stripped == '{') {
|
|||
|
content_chunk_stripped++;
|
|||
|
content_chunk_stripped[strlen(content_chunk_stripped) - 1] = 0;
|
|||
|
}
|
|||
|
if (strlen(content_chunk_stripped) + strlen(content) > size) {
|
|||
|
size += strlen(content_chunk_stripped) + 20;
|
|||
|
content = realloc(content, size);
|
|||
|
}
|
|||
|
strcat(content, content_chunk_stripped);
|
|||
|
free(content_chunk);
|
|||
|
|
|||
|
strcat(content, ",");
|
|||
|
}
|
|||
|
if (content[strlen(content) - 1] == ',') {
|
|||
|
content[strlen(content) - 1] = '\0';
|
|||
|
|
|||
|
if (rliza->key) {
|
|||
|
strcat(content, "}");
|
|||
|
}
|
|||
|
}
|
|||
|
strcat(content, "}");
|
|||
|
} else if (rliza->type == RLIZA_ARRAY) {
|
|||
|
if (rliza->key) {
|
|||
|
char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 1);
|
|||
|
rstraddslashes((char *)rliza->key, escaped_key);
|
|||
|
if (strlen(escaped_key) > size) {
|
|||
|
size = strlen(escaped_key) + 10;
|
|||
|
content = realloc(content, size);
|
|||
|
}
|
|||
|
sprintf(content, "\"%s\":[", escaped_key);
|
|||
|
free(escaped_key);
|
|||
|
} else
|
|||
|
strcpy(content, "[");
|
|||
|
for (unsigned i = 0; i < rliza->count; i++) {
|
|||
|
char *content_chunk = rliza_dumps(rliza->content.map[i]);
|
|||
|
char *content_chunk_stripped = content_chunk;
|
|||
|
if (*content_chunk_stripped == '{') {
|
|||
|
// content_chunk_stripped++;
|
|||
|
// content_chunk_stripped[strlen(content_chunk_stripped) - 1] = 0;
|
|||
|
}
|
|||
|
if (strlen(content_chunk_stripped) + strlen(content) > size) {
|
|||
|
size += strlen(content_chunk_stripped) + 20;
|
|||
|
content = realloc(content, size);
|
|||
|
}
|
|||
|
strcat(content, content_chunk_stripped);
|
|||
|
free(content_chunk);
|
|||
|
strcat(content, ",");
|
|||
|
}
|
|||
|
if (content[strlen(content) - 1] != '[')
|
|||
|
content[strlen(content) - 1] = 0;
|
|||
|
strcat(content, "]");
|
|||
|
} else if (rliza->type == RLIZA_NULL) {
|
|||
|
|
|||
|
if (rliza->key) {
|
|||
|
char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 1);
|
|||
|
rstraddslashes((char *)rliza->key, escaped_key);
|
|||
|
sprintf(content, "\"%s\":null", escaped_key);
|
|||
|
free(escaped_key);
|
|||
|
} else
|
|||
|
strcpy(content, "null");
|
|||
|
}
|
|||
|
return content;
|
|||
|
}
|
|||
|
|
|||
|
void rliza_dumpss(rliza_t *rliza) {
|
|||
|
char *output = rliza_dumps(rliza);
|
|||
|
printf("%s\n", output);
|
|||
|
free(output);
|
|||
|
}
|
|||
|
|
|||
|
void rliza_push(rliza_t *self, rliza_t *obj) { rliza_push_object(self, obj); }
|
|||
|
|
|||
|
int rliza_validate(char *json_content) {
|
|||
|
if (!json_content || !*json_content) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
char *json_contentp = json_content;
|
|||
|
rliza_t *to_object = _rliza_loads(&json_contentp);
|
|||
|
if (to_object) {
|
|||
|
rliza_free(to_object);
|
|||
|
return json_contentp - json_content;
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef RCOV_H
|
|||
|
#define RCOV_H
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#include <unistd.h>
|
|||
|
#ifndef RBENCH_H
|
|||
|
#define RBENCH_H
|
|||
|
|
|||
|
#ifndef RPRINT_H
|
|||
|
#define RPRINT_H
|
|||
|
|
|||
|
#ifndef RLIB_TIME
|
|||
|
#define RLIB_TIME
|
|||
|
|
|||
|
#ifndef _POSIX_C_SOURCE_199309L
|
|||
|
|
|||
|
#define _POSIX_C_SOURCE_199309L
|
|||
|
#endif
|
|||
|
#include <sys/time.h>
|
|||
|
#include <time.h>
|
|||
|
#undef _POSIX_C_SOURCE_199309L
|
|||
|
#include <errno.h>
|
|||
|
#include <stdint.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <string.h>
|
|||
|
#ifndef CLOCK_MONOTONIC
|
|||
|
#define CLOCK_MONOTONIC 1
|
|||
|
#endif
|
|||
|
|
|||
|
typedef uint64_t nsecs_t;
|
|||
|
void nsleep(nsecs_t nanoseconds);
|
|||
|
|
|||
|
void tick() { nsleep(1); }
|
|||
|
|
|||
|
typedef unsigned long long msecs_t;
|
|||
|
|
|||
|
nsecs_t nsecs() {
|
|||
|
unsigned int lo, hi;
|
|||
|
__asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
|
|||
|
return ((uint64_t)hi << 32) | lo;
|
|||
|
}
|
|||
|
|
|||
|
msecs_t rnsecs_to_msecs(nsecs_t nsecs) { return nsecs / 1000 / 1000; }
|
|||
|
|
|||
|
nsecs_t rmsecs_to_nsecs(msecs_t msecs) { return msecs * 1000 * 1000; }
|
|||
|
|
|||
|
msecs_t usecs() {
|
|||
|
struct timeval tv;
|
|||
|
gettimeofday(&tv, NULL);
|
|||
|
return (long long)(tv.tv_sec) * 1000000 + (long long)(tv.tv_usec);
|
|||
|
}
|
|||
|
|
|||
|
msecs_t msecs() {
|
|||
|
struct timeval tv;
|
|||
|
gettimeofday(&tv, NULL);
|
|||
|
return (long long)(tv.tv_sec) * 1000 + (tv.tv_usec / 1000);
|
|||
|
}
|
|||
|
char *msecs_strs(msecs_t ms) {
|
|||
|
static char str[22];
|
|||
|
str[0] = 0;
|
|||
|
sprintf(str, "%f", ms * 0.001);
|
|||
|
for (int i = strlen(str); i > 0; i--) {
|
|||
|
if (str[i] > '0')
|
|||
|
break;
|
|||
|
str[i] = 0;
|
|||
|
}
|
|||
|
return str;
|
|||
|
}
|
|||
|
char *msecs_strms(msecs_t ms) {
|
|||
|
static char str[22];
|
|||
|
str[0] = 0;
|
|||
|
sprintf(str, "%lld", ms);
|
|||
|
return str;
|
|||
|
}
|
|||
|
char *msecs_str(long long ms) {
|
|||
|
static char result[30];
|
|||
|
result[0] = 0;
|
|||
|
if (ms > 999) {
|
|||
|
char *s = msecs_strs(ms);
|
|||
|
sprintf(result, "%ss", s);
|
|||
|
} else {
|
|||
|
char *s = msecs_strms(ms);
|
|||
|
sprintf(result, "%sMs", s);
|
|||
|
}
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
void nsleep(nsecs_t nanoseconds) {
|
|||
|
long seconds = 0;
|
|||
|
int factor = 0;
|
|||
|
while (nanoseconds > 1000000000) {
|
|||
|
factor++;
|
|||
|
nanoseconds = nanoseconds / 10;
|
|||
|
}
|
|||
|
if (factor) {
|
|||
|
seconds = 1;
|
|||
|
factor--;
|
|||
|
while (factor) {
|
|||
|
seconds = seconds * 10;
|
|||
|
factor--;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
struct timespec req = {seconds, nanoseconds};
|
|||
|
struct timespec rem;
|
|||
|
|
|||
|
nanosleep(&req, &rem);
|
|||
|
}
|
|||
|
|
|||
|
void ssleep(double s) {
|
|||
|
long nanoseconds = (long)(1000000000 * s);
|
|||
|
|
|||
|
// long seconds = 0;
|
|||
|
|
|||
|
// struct timespec req = {seconds, nanoseconds};
|
|||
|
// struct timespec rem;
|
|||
|
|
|||
|
nsleep(nanoseconds);
|
|||
|
}
|
|||
|
void msleep(long miliseonds) {
|
|||
|
long nanoseconds = miliseonds * 1000000;
|
|||
|
nsleep(nanoseconds);
|
|||
|
}
|
|||
|
|
|||
|
char *format_time(int64_t nanoseconds) {
|
|||
|
char output[1024];
|
|||
|
size_t output_size = sizeof(output);
|
|||
|
output[0] = 0;
|
|||
|
if (nanoseconds < 1000) {
|
|||
|
// Less than 1 microsecond
|
|||
|
snprintf(output, output_size, "%ldns", nanoseconds);
|
|||
|
} else if (nanoseconds < 1000000) {
|
|||
|
// Less than 1 millisecond
|
|||
|
double us = nanoseconds / 1000.0;
|
|||
|
snprintf(output, output_size, "%.2fµs", us);
|
|||
|
} else if (nanoseconds < 1000000000) {
|
|||
|
// Less than 1 second
|
|||
|
double ms = nanoseconds / 1000000.0;
|
|||
|
snprintf(output, output_size, "%.2fms", ms);
|
|||
|
} else {
|
|||
|
// 1 second or more
|
|||
|
double s = nanoseconds / 1000000000.0;
|
|||
|
if (s > 60 * 60) {
|
|||
|
s = s / 60 / 60;
|
|||
|
snprintf(output, output_size, "%.2fh", s);
|
|||
|
} else if (s > 60) {
|
|||
|
s = s / 60;
|
|||
|
snprintf(output, output_size, "%.2fm", s);
|
|||
|
} else {
|
|||
|
snprintf(output, output_size, "%.2fs", s);
|
|||
|
}
|
|||
|
}
|
|||
|
return sbuf(output);
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
#include <stdarg.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <unistd.h>
|
|||
|
|
|||
|
long rpline_number = 0;
|
|||
|
nsecs_t rprtime = 0;
|
|||
|
|
|||
|
int8_t _env_rdisable_colors = -1;
|
|||
|
bool _rprint_enable_colors = true;
|
|||
|
|
|||
|
bool rprint_is_color_enabled() {
|
|||
|
if (_env_rdisable_colors == -1) {
|
|||
|
_env_rdisable_colors = getenv("RDISABLE_COLORS") != NULL;
|
|||
|
}
|
|||
|
if (_env_rdisable_colors) {
|
|||
|
_rprint_enable_colors = false;
|
|||
|
}
|
|||
|
return _rprint_enable_colors;
|
|||
|
}
|
|||
|
|
|||
|
void rprint_disable_colors() { _rprint_enable_colors = false; }
|
|||
|
void rprint_enable_colors() { _rprint_enable_colors = true; }
|
|||
|
void rprint_toggle_colors() { _rprint_enable_colors = !_rprint_enable_colors; }
|
|||
|
|
|||
|
void rclear() { printf("\033[2J"); }
|
|||
|
|
|||
|
void rprintpf(FILE *f, const char *prefix, const char *format, va_list args) {
|
|||
|
char *pprefix = (char *)prefix;
|
|||
|
char *pformat = (char *)format;
|
|||
|
bool reset_color = false;
|
|||
|
bool press_any_key = false;
|
|||
|
char new_format[4096];
|
|||
|
bool enable_color = rprint_is_color_enabled();
|
|||
|
memset(new_format, 0, 4096);
|
|||
|
int new_format_length = 0;
|
|||
|
char temp[1000];
|
|||
|
memset(temp, 0, 1000);
|
|||
|
if (enable_color && pprefix[0]) {
|
|||
|
strcat(new_format, pprefix);
|
|||
|
new_format_length += strlen(pprefix);
|
|||
|
reset_color = true;
|
|||
|
}
|
|||
|
while (true) {
|
|||
|
if (pformat[0] == '\\' && pformat[1] == 'i') {
|
|||
|
strcat(new_format, "\e[3m");
|
|||
|
new_format_length += strlen("\e[3m");
|
|||
|
reset_color = true;
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'u') {
|
|||
|
strcat(new_format, "\e[4m");
|
|||
|
new_format_length += strlen("\e[4m");
|
|||
|
reset_color = true;
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'b') {
|
|||
|
strcat(new_format, "\e[1m");
|
|||
|
new_format_length += strlen("\e[1m");
|
|||
|
reset_color = true;
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'C') {
|
|||
|
press_any_key = true;
|
|||
|
rpline_number++;
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
reset_color = false;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'k') {
|
|||
|
press_any_key = true;
|
|||
|
rpline_number++;
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'c') {
|
|||
|
rpline_number++;
|
|||
|
strcat(new_format, "\e[2J\e[H");
|
|||
|
new_format_length += strlen("\e[2J\e[H");
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'L') {
|
|||
|
rpline_number++;
|
|||
|
temp[0] = 0;
|
|||
|
sprintf(temp, "%ld", rpline_number);
|
|||
|
strcat(new_format, temp);
|
|||
|
new_format_length += strlen(temp);
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'l') {
|
|||
|
rpline_number++;
|
|||
|
temp[0] = 0;
|
|||
|
sprintf(temp, "%.5ld", rpline_number);
|
|||
|
strcat(new_format, temp);
|
|||
|
new_format_length += strlen(temp);
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 'T') {
|
|||
|
nsecs_t nsecs_now = nsecs();
|
|||
|
nsecs_t end = rprtime ? nsecs_now - rprtime : 0;
|
|||
|
temp[0] = 0;
|
|||
|
sprintf(temp, "%s", format_time(end));
|
|||
|
strcat(new_format, temp);
|
|||
|
new_format_length += strlen(temp);
|
|||
|
rprtime = nsecs_now;
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else if (pformat[0] == '\\' && pformat[1] == 't') {
|
|||
|
rprtime = nsecs();
|
|||
|
pformat++;
|
|||
|
pformat++;
|
|||
|
} else {
|
|||
|
new_format[new_format_length] = *pformat;
|
|||
|
new_format_length++;
|
|||
|
if (!*pformat)
|
|||
|
break;
|
|||
|
|
|||
|
// printf("%c",*pformat);
|
|||
|
pformat++;
|
|||
|
}
|
|||
|
}
|
|||
|
if (reset_color) {
|
|||
|
strcat(new_format, "\e[0m");
|
|||
|
new_format_length += strlen("\e[0m");
|
|||
|
}
|
|||
|
|
|||
|
new_format[new_format_length] = 0;
|
|||
|
vfprintf(f, new_format, args);
|
|||
|
|
|||
|
fflush(stdout);
|
|||
|
if (press_any_key) {
|
|||
|
nsecs_t s = nsecs();
|
|||
|
fgetc(stdin);
|
|||
|
rprtime += nsecs() - s;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
void rprintp(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
void rprintf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprint(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
#define printf rprint
|
|||
|
|
|||
|
// Print line
|
|||
|
void rprintlf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\\l", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprintl(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\\l", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// Black
|
|||
|
void rprintkf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[30m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprintk(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[30m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// Red
|
|||
|
void rprintrf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[31m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprintr(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[31m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// Green
|
|||
|
void rprintgf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[32m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprintg(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[32m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// Yellow
|
|||
|
void rprintyf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[33m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprinty(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[33m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// Blue
|
|||
|
void rprintbf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[34m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
void rprintb(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[34m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// Magenta
|
|||
|
void rprintmf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[35m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprintm(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[35m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// Cyan
|
|||
|
void rprintcf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[36m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprintc(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[36m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
// White
|
|||
|
void rprintwf(FILE *f, const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(f, "\e[37m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rprintw(const char *format, ...) {
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rprintpf(stdout, "\e[37m", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
#endif
|
|||
|
#include <errno.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdint.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#include <sys/time.h>
|
|||
|
#include <time.h>
|
|||
|
|
|||
|
#ifndef RLIB_TERMINAL_H
|
|||
|
#define RLIB_TERMINAL_H
|
|||
|
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#ifndef RTEST_H
|
|||
|
#define RTEST_H
|
|||
|
#ifndef REMO_H
|
|||
|
#define REMO_H
|
|||
|
#include <ctype.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <string.h>
|
|||
|
|
|||
|
typedef struct {
|
|||
|
const char *str;
|
|||
|
const char *description;
|
|||
|
} remo_t;
|
|||
|
|
|||
|
remo_t remo[] = {
|
|||
|
{"\U0001F600", "Grinning Face"}, // 😀
|
|||
|
{"\U0001F601", "Beaming Face with Smiling Eyes"}, // 😁
|
|||
|
{"\U0001F602", "Face with Tears of Joy"}, // 😂
|
|||
|
{"\U0001F923", "Rolling on the Floor Laughing"}, // 🤣
|
|||
|
{"\U0001F603", "Grinning Face with Big Eyes"}, // 😃
|
|||
|
{"\U0001F604", "Grinning Face with Smiling Eyes"}, // 😄
|
|||
|
{"\U0001F609", "Winking Face"}, // 😉
|
|||
|
{"\U0001F60A", "Smiling Face with Smiling Eyes"}, // 😊
|
|||
|
{"\U0001F60D", "Smiling Face with Heart-Eyes"}, // 😍
|
|||
|
{"\U0001F618", "Face Blowing a Kiss"}, // 😘
|
|||
|
{"\U0001F617", "Kissing Face"}, // 😗
|
|||
|
{"\U0001F61A", "Kissing Face with Closed Eyes"}, // 😚
|
|||
|
{"\U0001F642", "Slightly Smiling Face"}, // 🙂
|
|||
|
{"\U0001F643", "Upside-Down Face"}, // 🙃
|
|||
|
{"\U0001F970", "Smiling Face with Hearts"}, // 🥰
|
|||
|
{"\U0001F60B", "Face Savoring Food"}, // 😋
|
|||
|
{"\U0001F61B", "Face with Tongue"}, // 😛
|
|||
|
{"\U0001F61C", "Winking Face with Tongue"}, // 😜
|
|||
|
{"\U0001F92A", "Zany Face"}, // 🤪
|
|||
|
{"\U0001F929", "Star-Struck"}, // 🤩
|
|||
|
{"\U0001F631", "Face Screaming in Fear"}, // 😱
|
|||
|
{"\U0001F62D", "Loudly Crying Face"}, // 😭
|
|||
|
{"\U0001F624", "Face with Steam From Nose"}, // 😤
|
|||
|
{"\U0001F620", "Angry Face"}, // 😠
|
|||
|
{"\U0001F621", "Pouting Face"}, // 😡
|
|||
|
{"\U0001F47B", "Ghost"}, // 👻
|
|||
|
{"\U0001F480", "Skull"}, // 💀
|
|||
|
{"\U0001F4A9", "Pile of Poo"}, // 💩
|
|||
|
{"\U0001F47D", "Alien"}, // 👽
|
|||
|
// Geometric Shapes
|
|||
|
{"\U000025A0", "Black Square"}, // ■
|
|||
|
{"\U000025B2", "Upward Triangle"}, // ▲
|
|||
|
{"\U000025CF", "Black Circle"}, // ●
|
|||
|
{"\U000025CB", "White Circle"}, // ○
|
|||
|
{"\U00002B1B", "Large Black Square"}, // ⬛
|
|||
|
{"\U00002B1C", "Large White Square"}, // ⬜
|
|||
|
|
|||
|
// Mathematical Symbols
|
|||
|
{"\U00002200", "For All"}, // ∀
|
|||
|
{"\U00002203", "Exists"}, // ∃
|
|||
|
{"\U00002205", "Empty Set"}, // ∅
|
|||
|
{"\U00002207", "Nabla"}, // ∇
|
|||
|
{"\U0000220F", "N-Ary Product"}, // ∏
|
|||
|
{"\U00002212", "Minus Sign"}, // −
|
|||
|
{"\U0000221E", "Infinity"}, // ∞
|
|||
|
|
|||
|
// Arrows
|
|||
|
{"\U00002190", "Left Arrow"}, // ←
|
|||
|
{"\U00002191", "Up Arrow"}, // ↑
|
|||
|
{"\U00002192", "Right Arrow"}, // →
|
|||
|
{"\U00002193", "Down Arrow"}, // ↓
|
|||
|
{"\U00002195", "Up Down Arrow"}, // ↕
|
|||
|
{"\U00002197", "Up Right Arrow"}, // ↗
|
|||
|
{"\U00002198", "Down Right Arrow"}, // ↘
|
|||
|
{"\U000027A1", "Black Right Arrow"}, // ➡️
|
|||
|
|
|||
|
// Dingbats
|
|||
|
{"\U00002714", "Check Mark"}, // ✔️
|
|||
|
{"\U00002716", "Heavy Multiplication X"}, // ✖️
|
|||
|
{"\U00002728", "Sparkles"}, // ✨
|
|||
|
{"\U00002757", "Exclamation Mark"}, // ❗
|
|||
|
{"\U0000274C", "Cross Mark"}, // ❌
|
|||
|
{"\U00002795", "Heavy Plus Sign"}, // ➕
|
|||
|
|
|||
|
// Miscellaneous Symbols
|
|||
|
{"\U00002600", "Sun"}, // ☀️
|
|||
|
{"\U00002614", "Umbrella with Rain Drops"}, // ☔
|
|||
|
{"\U00002620", "Skull and Crossbones"}, // ☠️
|
|||
|
{"\U000026A0", "Warning Sign"}, // ⚠️
|
|||
|
{"\U000026BD", "Soccer Ball"}, // ⚽
|
|||
|
{"\U000026C4", "Snowman"}, // ⛄
|
|||
|
|
|||
|
// Stars and Asterisks
|
|||
|
{"\U00002733", "Eight Pointed Black Star"}, // ✳️
|
|||
|
{"\U00002734", "Eight Spoked Asterisk"}, // ✴️
|
|||
|
{"\U00002B50", "White Star"}, // ⭐
|
|||
|
{"\U0001F31F", "Glowing Star"}, // 🌟
|
|||
|
{"\U00002728", "Sparkles"}, // ✨
|
|||
|
// Animals and Nature
|
|||
|
{"\U0001F98A", "Fox"}, // 🦊
|
|||
|
{"\U0001F415", "Dog"}, // 🐕
|
|||
|
{"\U0001F431", "Cat Face"}, // 🐱
|
|||
|
{"\U0001F435", "Monkey Face"}, // 🐵
|
|||
|
{"\U0001F408", "Black Cat"}, // 🐈
|
|||
|
{"\U0001F98C", "Deer"}, // 🦌
|
|||
|
{"\U0001F344", "Mushroom"}, // 🍄
|
|||
|
{"\U0001F333", "Tree"}, // 🌳
|
|||
|
|
|||
|
// Weather and Space Symbols
|
|||
|
{"\U0001F308", "Rainbow"}, // 🌈
|
|||
|
{"\U0001F320", "Shooting Star"}, // 🌠
|
|||
|
{"\U00002600", "Sun"}, // ☀️
|
|||
|
{"\U00002601", "Cloud"}, // ☁️
|
|||
|
{"\U000026A1", "High Voltage"}, // ⚡
|
|||
|
{"\U0001F525", "Fire"}, // 🔥
|
|||
|
{"\U000026C4", "Snowman"}, // ⛄
|
|||
|
{"\U0001F30A", "Water Wave"}, // 🌊
|
|||
|
|
|||
|
// Transport and Map Symbols
|
|||
|
{"\U0001F68C", "Bus"}, // 🚌
|
|||
|
{"\U0001F697", "Car"}, // 🚗
|
|||
|
{"\U0001F6B2", "Bicycle"}, // 🚲
|
|||
|
{"\U0001F6A2", "Ship"}, // 🚢
|
|||
|
{"\U0001F681", "Helicopter"}, // 🚁
|
|||
|
{"\U0001F680", "Rocket"}, // 🚀
|
|||
|
{"\U0001F6EB", "Airplane"}, // 🛫
|
|||
|
|
|||
|
// Currency Symbols
|
|||
|
{"\U00000024", "Dollar Sign"}, // $
|
|||
|
{"\U000000A3", "Pound Sign"}, // £
|
|||
|
{"\U000000A5", "Yen Sign"}, // ¥
|
|||
|
{"\U000020AC", "Euro Sign"}, // €
|
|||
|
{"\U0001F4B5", "Dollar Banknote"}, // 💵
|
|||
|
{"\U0001F4B4", "Yen Banknote"}, // 💴
|
|||
|
|
|||
|
// Card Suits
|
|||
|
{"\U00002660", "Black Spade Suit"}, // ♠️
|
|||
|
{"\U00002663", "Black Club Suit"}, // ♣️
|
|||
|
{"\U00002665", "Black Heart Suit"}, // ♥️
|
|||
|
{"\U00002666", "Black Diamond Suit"}, // ♦️
|
|||
|
{"\U0001F0CF", "Joker Card"}, // 🃏
|
|||
|
|
|||
|
// Office Supplies and Objects
|
|||
|
{"\U0001F4DA", "Books"}, // 📚
|
|||
|
{"\U0001F4D7", "Green Book"}, // 📗
|
|||
|
{"\U0001F4C8", "Chart with Upwards Trend"}, // 📈
|
|||
|
{"\U0001F4C9", "Chart with Downwards Trend"}, // 📉
|
|||
|
{"\U0001F4B0", "Money Bag"}, // 💰
|
|||
|
{"\U0001F4B8", "Money with Wings"}, // 💸
|
|||
|
{"\U0001F4E6", "Package"}, // 📦
|
|||
|
|
|||
|
// Miscellaneous Symbols
|
|||
|
{"\U00002757", "Exclamation Mark"}, // ❗
|
|||
|
{"\U00002714", "Check Mark"}, // ✔️
|
|||
|
{"\U0000274C", "Cross Mark"}, // ❌
|
|||
|
{"\U00002705", "Check Mark Button"}, // ✅
|
|||
|
{"\U00002B50", "White Star"}, // ⭐
|
|||
|
{"\U0001F31F", "Glowing Star"}, // 🌟
|
|||
|
{"\U0001F4A1", "Light Bulb"}, // 💡
|
|||
|
{"\U0001F4A3", "Bomb"}, // 💣
|
|||
|
{"\U0001F4A9", "Pile of Poo"}, // 💩
|
|||
|
// Musical Symbols
|
|||
|
{"\U0001F3B5", "Musical Note"}, // 🎵
|
|||
|
{"\U0001F3B6", "Multiple Musical Notes"}, // 🎶
|
|||
|
{"\U0001F3BC", "Musical Score"}, // 🎼
|
|||
|
{"\U0001F399", "Studio Microphone"}, // 🎙️
|
|||
|
{"\U0001F3A4", "Microphone"}, // 🎤
|
|||
|
|
|||
|
// Food and Drink
|
|||
|
{"\U0001F35F", "Cheese Wedge"}, // 🧀
|
|||
|
{"\U0001F355", "Slice of Pizza"}, // 🍕
|
|||
|
{"\U0001F32D", "Taco"}, // 🌮
|
|||
|
{"\U0001F37D", "Beer Mug"}, // 🍻
|
|||
|
{"\U0001F96B", "Cup with Straw"}, // 🥤
|
|||
|
{"\U0001F32E", "Hot Pepper"}, // 🌶️
|
|||
|
{"\U0001F95A", "Potato"}, // 🥔
|
|||
|
|
|||
|
// Zodiac Signs
|
|||
|
{"\U00002600", "Aries"}, // ♈
|
|||
|
{"\U00002601", "Taurus"}, // ♉
|
|||
|
{"\U00002602", "Gemini"}, // ♊
|
|||
|
{"\U00002603", "Cancer"}, // ♋
|
|||
|
{"\U00002604", "Leo"}, // ♌
|
|||
|
{"\U00002605", "Virgo"}, // ♍
|
|||
|
{"\U00002606", "Libra"}, // ♎
|
|||
|
{"\U00002607", "Scorpio"}, // ♏
|
|||
|
{"\U00002608", "Sagittarius"}, // ♐
|
|||
|
{"\U00002609", "Capricorn"}, // ♑
|
|||
|
{"\U0000260A", "Aquarius"}, // ♒
|
|||
|
{"\U0000260B", "Pisces"}, // ♓
|
|||
|
|
|||
|
// Miscellaneous Shapes
|
|||
|
{"\U0001F4C8", "Chart Increasing"}, // 📈
|
|||
|
{"\U0001F4C9", "Chart Decreasing"}, // 📉
|
|||
|
{"\U0001F4CA", "Bar Chart"}, // 📊
|
|||
|
{"\U0001F7E6", "Orange Circle"}, // 🟠
|
|||
|
{"\U0001F7E7", "Yellow Circle"}, // 🟡
|
|||
|
{"\U0001F7E8", "Green Circle"}, // 🟢
|
|||
|
{"\U0001F7E9", "Blue Circle"}, // 🔵
|
|||
|
{"\U0001F7EA", "Purple Circle"}, // 🟣
|
|||
|
|
|||
|
// Flags
|
|||
|
{"\U0001F1E6\U0001F1E9", "Flag of France"}, // 🇫🇷
|
|||
|
{"\U0001F1E8\U0001F1E6", "Flag of Germany"}, // 🇩🇪
|
|||
|
{"\U0001F1FA\U0001F1F8", "Flag of United States"}, // 🇺🇸
|
|||
|
{"\U0001F1E7\U0001F1F7", "Flag of Canada"}, // 🇨🇦
|
|||
|
{"\U0001F1EE\U0001F1F2", "Flag of Italy"}, // 🇮🇹
|
|||
|
{"\U0001F1F8\U0001F1EC", "Flag of Australia"}, // 🇦🇺
|
|||
|
{"\U0001F1F3\U0001F1F4", "Flag of Spain"}, // 🇪🇸
|
|||
|
|
|||
|
// Additional Miscellaneous Symbols
|
|||
|
{"\U0001F4A5", "Collision"}, // 💥
|
|||
|
{"\U0001F4A6", "Sweat Droplets"}, // 💦
|
|||
|
{"\U0001F4A8", "Dashing Away"}, // 💨
|
|||
|
{"\U0001F50B", "Battery"}, // 🔋
|
|||
|
{"\U0001F4BB", "Laptop Computer"}, // 💻
|
|||
|
{"\U0001F4DE", "Telephone"}, // 📞
|
|||
|
{"\U0001F4E7", "Incoming Envelope"}, // 📧
|
|||
|
};
|
|||
|
size_t remo_count = sizeof(remo) / sizeof(remo[0]);
|
|||
|
|
|||
|
void rstrtolower(const char *input, char *output) {
|
|||
|
while (*input) {
|
|||
|
*output = tolower(*input);
|
|||
|
input++;
|
|||
|
output++;
|
|||
|
}
|
|||
|
*output = 0;
|
|||
|
}
|
|||
|
bool rstrinstr(const char *haystack, const char *needle) {
|
|||
|
char lower1[strlen(haystack) + 1];
|
|||
|
char lower2[strlen(needle) + 1];
|
|||
|
rstrtolower(haystack, lower1);
|
|||
|
rstrtolower(needle, lower2);
|
|||
|
return strstr(lower1, lower2) ? true : false;
|
|||
|
}
|
|||
|
|
|||
|
void remo_print() {
|
|||
|
|
|||
|
for (size_t i = 0; i < remo_count; i++) {
|
|||
|
printf("%s - %s\n", remo[i].str, remo[i].description);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
const char *remo_get(char *name) {
|
|||
|
for (size_t i = 0; i < remo_count; i++) {
|
|||
|
if (rstrinstr(remo[i].description, name)) {
|
|||
|
return remo[i].str;
|
|||
|
}
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <unistd.h>
|
|||
|
#define debug(fmt, ...) printf("%s:%d: " fmt, __FILE__, __LINE__, __VA_ARGS__);
|
|||
|
|
|||
|
char *rcurrent_banner;
|
|||
|
int rassert_count = 0;
|
|||
|
unsigned short rtest_is_first = 1;
|
|||
|
unsigned int rtest_fail_count = 0;
|
|||
|
|
|||
|
int rtest_end(char *content) {
|
|||
|
// Returns application exit code. 0 == success
|
|||
|
printf("%s", content);
|
|||
|
printf("\n@assertions: %d\n", rassert_count);
|
|||
|
printf("@memory: %s%s\n", rmalloc_stats(), rmalloc_count == 0 ? remo_get("rainbow") : "fire");
|
|||
|
|
|||
|
if (rmalloc_count != 0) {
|
|||
|
printf("MEMORY ERROR %s\n", remo_get("cross mark"));
|
|||
|
return rtest_fail_count > 0;
|
|||
|
}
|
|||
|
return rtest_fail_count > 0;
|
|||
|
}
|
|||
|
|
|||
|
void rtest_test_banner(char *content, char *file) {
|
|||
|
if (rtest_is_first == 1) {
|
|||
|
char delimiter[] = ".";
|
|||
|
char *d = delimiter;
|
|||
|
char f[2048];
|
|||
|
strcpy(f, file);
|
|||
|
printf("%s tests", strtok(f, d));
|
|||
|
rtest_is_first = 0;
|
|||
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|||
|
}
|
|||
|
printf("\n - %s ", content);
|
|||
|
}
|
|||
|
|
|||
|
bool rtest_test_true_silent(char *expr, int res, int line) {
|
|||
|
rassert_count++;
|
|||
|
if (res) {
|
|||
|
return true;
|
|||
|
}
|
|||
|
rprintrf(stderr, "\nERROR on line %d: %s", line, expr);
|
|||
|
rtest_fail_count++;
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
bool rtest_test_true(char *expr, int res, int line) {
|
|||
|
rassert_count++;
|
|||
|
if (res) {
|
|||
|
fprintf(stdout, "%s", remo_get("Slightly Smiling Face"));
|
|||
|
return true;
|
|||
|
}
|
|||
|
rprintrf(stderr, "\nERROR %s on line %d: %s\n", remo_get("skull"), line, expr);
|
|||
|
rtest_fail_count++;
|
|||
|
return false;
|
|||
|
}
|
|||
|
bool rtest_test_false_silent(char *expr, int res, int line) { return rtest_test_true_silent(expr, !res, line); }
|
|||
|
bool rtest_test_false(char *expr, int res, int line) { return rtest_test_true(expr, !res, line); }
|
|||
|
void rtest_test_skip(char *expr, int line) { rprintgf(stderr, "\n @skip(%s) on line %d\n", expr, line); }
|
|||
|
void rtest_test_assert(char *expr, int res, int line) {
|
|||
|
if (rtest_test_true(expr, res, line)) {
|
|||
|
return;
|
|||
|
}
|
|||
|
rtest_end("");
|
|||
|
exit(40);
|
|||
|
}
|
|||
|
|
|||
|
#define rtest_banner(content) \
|
|||
|
rcurrent_banner = content; \
|
|||
|
rtest_test_banner(content, __FILE__);
|
|||
|
#define rtest_true(expr) rtest_test_true(#expr, expr, __LINE__);
|
|||
|
#define rtest_assert(expr) \
|
|||
|
{ \
|
|||
|
int __valid = expr ? 1 : 0; \
|
|||
|
rtest_test_true(#expr, __valid, __LINE__); \
|
|||
|
}; \
|
|||
|
;
|
|||
|
|
|||
|
#define rassert(expr) \
|
|||
|
{ \
|
|||
|
int __valid = expr ? 1 : 0; \
|
|||
|
rtest_test_true(#expr, __valid, __LINE__); \
|
|||
|
}; \
|
|||
|
;
|
|||
|
#define rtest_asserts(expr) \
|
|||
|
{ \
|
|||
|
int __valid = expr ? 1 : 0; \
|
|||
|
rtest_test_true_silent(#expr, __valid, __LINE__); \
|
|||
|
};
|
|||
|
#define rasserts(expr) \
|
|||
|
{ \
|
|||
|
int __valid = expr ? 1 : 0; \
|
|||
|
rtest_test_true_silent(#expr, __valid, __LINE__); \
|
|||
|
};
|
|||
|
#define rtest_false(expr) \
|
|||
|
rprintf(" [%s]\t%s\t\n", expr == 0 ? "OK" : "NOK", #expr); \
|
|||
|
assert_count++; \
|
|||
|
assert(#expr);
|
|||
|
#define rtest_skip(expr) rtest_test_skip(#expr, __LINE__);
|
|||
|
|
|||
|
FILE *rtest_create_file(char *path, char *content) {
|
|||
|
FILE *fd = fopen(path, "wb");
|
|||
|
|
|||
|
char c;
|
|||
|
int index = 0;
|
|||
|
|
|||
|
while ((c = content[index]) != 0) {
|
|||
|
fputc(c, fd);
|
|||
|
index++;
|
|||
|
}
|
|||
|
fclose(fd);
|
|||
|
fd = fopen(path, "rb");
|
|||
|
return fd;
|
|||
|
}
|
|||
|
|
|||
|
void rtest_delete_file(char *path) { unlink(path); }
|
|||
|
#endif
|
|||
|
|
|||
|
char *rfcaptured = NULL;
|
|||
|
|
|||
|
void rfcapture(FILE *f, char *buff, size_t size) {
|
|||
|
rfcaptured = buff;
|
|||
|
setvbuf(f, rfcaptured, _IOFBF, size);
|
|||
|
}
|
|||
|
void rfstopcapture(FILE *f) { setvbuf(f, 0, _IOFBF, 0); }
|
|||
|
|
|||
|
bool _r_disable_stdout_toggle = false;
|
|||
|
|
|||
|
FILE *_r_original_stdout = NULL;
|
|||
|
|
|||
|
bool rr_enable_stdout() {
|
|||
|
if (_r_disable_stdout_toggle)
|
|||
|
return false;
|
|||
|
if (!_r_original_stdout) {
|
|||
|
stdout = fopen("/dev/null", "rb");
|
|||
|
return false;
|
|||
|
}
|
|||
|
if (_r_original_stdout && _r_original_stdout != stdout) {
|
|||
|
fclose(stdout);
|
|||
|
}
|
|||
|
stdout = _r_original_stdout;
|
|||
|
return true;
|
|||
|
}
|
|||
|
bool rr_disable_stdout() {
|
|||
|
if (_r_disable_stdout_toggle) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
if (_r_original_stdout == NULL) {
|
|||
|
_r_original_stdout = stdout;
|
|||
|
}
|
|||
|
if (stdout == _r_original_stdout) {
|
|||
|
stdout = fopen("/dev/null", "rb");
|
|||
|
return true;
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
bool rr_toggle_stdout() {
|
|||
|
if (!_r_original_stdout) {
|
|||
|
rr_disable_stdout();
|
|||
|
return true;
|
|||
|
} else if (stdout != _r_original_stdout) {
|
|||
|
rr_enable_stdout();
|
|||
|
return true;
|
|||
|
} else {
|
|||
|
rr_disable_stdout();
|
|||
|
return true;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
typedef struct rprogressbar_t {
|
|||
|
unsigned long current_value;
|
|||
|
unsigned long min_value;
|
|||
|
unsigned long max_value;
|
|||
|
unsigned int length;
|
|||
|
bool changed;
|
|||
|
double percentage;
|
|||
|
unsigned int width;
|
|||
|
unsigned long draws;
|
|||
|
FILE *fout;
|
|||
|
} rprogressbar_t;
|
|||
|
|
|||
|
rprogressbar_t *rprogressbar_new(long min_value, long max_value, unsigned int width, FILE *fout) {
|
|||
|
rprogressbar_t *pbar = (rprogressbar_t *)malloc(sizeof(rprogressbar_t));
|
|||
|
pbar->min_value = min_value;
|
|||
|
pbar->max_value = max_value;
|
|||
|
pbar->current_value = min_value;
|
|||
|
pbar->width = width;
|
|||
|
pbar->draws = 0;
|
|||
|
pbar->length = 0;
|
|||
|
pbar->changed = false;
|
|||
|
pbar->fout = fout ? fout : stdout;
|
|||
|
return pbar;
|
|||
|
}
|
|||
|
|
|||
|
void rprogressbar_free(rprogressbar_t *pbar) { free(pbar); }
|
|||
|
|
|||
|
void rprogressbar_draw(rprogressbar_t *pbar) {
|
|||
|
if (!pbar->changed) {
|
|||
|
return;
|
|||
|
} else {
|
|||
|
pbar->changed = false;
|
|||
|
}
|
|||
|
pbar->draws++;
|
|||
|
char draws_text[22];
|
|||
|
draws_text[0] = 0;
|
|||
|
sprintf(draws_text, "%ld", pbar->draws);
|
|||
|
char *draws_textp = draws_text;
|
|||
|
// bool draws_text_len = strlen(draws_text);
|
|||
|
char bar_begin_char = ' ';
|
|||
|
char bar_progress_char = ' ';
|
|||
|
char bar_empty_char = ' ';
|
|||
|
char bar_end_char = ' ';
|
|||
|
char content[4096] = {0};
|
|||
|
char bar_content[1024];
|
|||
|
char buff[2048] = {0};
|
|||
|
bar_content[0] = '\r';
|
|||
|
bar_content[1] = bar_begin_char;
|
|||
|
unsigned int index = 2;
|
|||
|
for (unsigned long i = 0; i < pbar->length; i++) {
|
|||
|
if (*draws_textp) {
|
|||
|
bar_content[index] = *draws_textp;
|
|||
|
draws_textp++;
|
|||
|
} else {
|
|||
|
bar_content[index] = bar_progress_char;
|
|||
|
}
|
|||
|
index++;
|
|||
|
}
|
|||
|
char infix[] = "\033[0m";
|
|||
|
for (unsigned long i = 0; i < strlen(infix); i++) {
|
|||
|
bar_content[index] = infix[i];
|
|||
|
index++;
|
|||
|
}
|
|||
|
for (unsigned long i = 0; i < pbar->width - pbar->length; i++) {
|
|||
|
bar_content[index] = bar_empty_char;
|
|||
|
index++;
|
|||
|
}
|
|||
|
bar_content[index] = bar_end_char;
|
|||
|
bar_content[index + 1] = '\0';
|
|||
|
sprintf(buff, "\033[43m%s\033[0m \033[33m%.2f%%\033[0m ", bar_content, pbar->percentage * 100);
|
|||
|
strcat(content, buff);
|
|||
|
if (pbar->width == pbar->length) {
|
|||
|
strcat(content, "\r");
|
|||
|
for (unsigned long i = 0; i < pbar->width + 10; i++) {
|
|||
|
strcat(content, " ");
|
|||
|
}
|
|||
|
strcat(content, "\r");
|
|||
|
}
|
|||
|
fprintf(pbar->fout, "%s", content);
|
|||
|
fflush(pbar->fout);
|
|||
|
}
|
|||
|
|
|||
|
bool rprogressbar_update(rprogressbar_t *pbar, unsigned long value) {
|
|||
|
if (value == pbar->current_value) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
pbar->current_value = value;
|
|||
|
pbar->percentage = (double)pbar->current_value / (double)(pbar->max_value - pbar->min_value);
|
|||
|
unsigned long new_length = (unsigned long)(pbar->percentage * pbar->width);
|
|||
|
pbar->changed = new_length != pbar->length;
|
|||
|
if (pbar->changed) {
|
|||
|
pbar->length = new_length;
|
|||
|
rprogressbar_draw(pbar);
|
|||
|
return true;
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
size_t rreadline(char *data, size_t len, bool strip_ln) {
|
|||
|
__attribute__((unused)) char *unused = fgets(data, len, stdin);
|
|||
|
size_t length = strlen(data);
|
|||
|
if (length && strip_ln)
|
|||
|
data[length - 1] = 0;
|
|||
|
return length;
|
|||
|
}
|
|||
|
|
|||
|
void rlib_test_progressbar() {
|
|||
|
rtest_banner("Progress bar");
|
|||
|
rprogressbar_t *pbar = rprogressbar_new(0, 1000, 10, stderr);
|
|||
|
rprogressbar_draw(pbar);
|
|||
|
// No draws executed, nothing to show
|
|||
|
rassert(pbar->draws == 0);
|
|||
|
rprogressbar_update(pbar, 500);
|
|||
|
rassert(pbar->percentage == 0.5);
|
|||
|
rprogressbar_update(pbar, 500);
|
|||
|
rprogressbar_update(pbar, 501);
|
|||
|
rprogressbar_update(pbar, 502);
|
|||
|
// Should only have drawn one time since value did change, but percentage
|
|||
|
// did not
|
|||
|
rassert(pbar->draws == 1);
|
|||
|
// Changed is false because update function calls draw
|
|||
|
rassert(pbar->changed == false);
|
|||
|
rprogressbar_update(pbar, 777);
|
|||
|
rassert(pbar->percentage == 0.777);
|
|||
|
rprogressbar_update(pbar, 1000);
|
|||
|
rassert(pbar->percentage == 1);
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
#define RBENCH(times, action) \
|
|||
|
{ \
|
|||
|
unsigned long utimes = (unsigned long)times; \
|
|||
|
nsecs_t start = nsecs(); \
|
|||
|
for (unsigned long i = 0; i < utimes; i++) { \
|
|||
|
{ \
|
|||
|
action; \
|
|||
|
} \
|
|||
|
} \
|
|||
|
nsecs_t end = nsecs(); \
|
|||
|
printf("%s\n", format_time(end - start)); \
|
|||
|
}
|
|||
|
|
|||
|
#define RBENCHP(times, action) \
|
|||
|
{ \
|
|||
|
printf("\n"); \
|
|||
|
nsecs_t start = nsecs(); \
|
|||
|
unsigned int prev_percentage = 0; \
|
|||
|
unsigned long utimes = (unsigned long)times; \
|
|||
|
for (unsigned long i = 0; i < utimes; i++) { \
|
|||
|
unsigned int percentage = ((long double)i / (long double)times) * 100; \
|
|||
|
int percentage_changed = percentage != prev_percentage; \
|
|||
|
__attribute__((unused)) int first = i == 0; \
|
|||
|
__attribute__((unused)) int last = i == utimes - 1; \
|
|||
|
{ action; }; \
|
|||
|
if (percentage_changed) { \
|
|||
|
printf("\r%d%%", percentage); \
|
|||
|
fflush(stdout); \
|
|||
|
\
|
|||
|
prev_percentage = percentage; \
|
|||
|
} \
|
|||
|
} \
|
|||
|
nsecs_t end = nsecs(); \
|
|||
|
printf("\r%s\n", format_time(end - start)); \
|
|||
|
}
|
|||
|
|
|||
|
struct rbench_t;
|
|||
|
|
|||
|
typedef struct rbench_function_t {
|
|||
|
#ifdef __cplusplus
|
|||
|
void (*call)();
|
|||
|
#else
|
|||
|
void(*call);
|
|||
|
#endif
|
|||
|
char name[256];
|
|||
|
char group[256];
|
|||
|
void *arg;
|
|||
|
void *data;
|
|||
|
bool first;
|
|||
|
bool last;
|
|||
|
int argc;
|
|||
|
unsigned long times_executed;
|
|||
|
|
|||
|
nsecs_t average_execution_time;
|
|||
|
nsecs_t total_execution_time;
|
|||
|
} rbench_function_t;
|
|||
|
|
|||
|
typedef struct rbench_t {
|
|||
|
unsigned int function_count;
|
|||
|
rbench_function_t functions[100];
|
|||
|
rbench_function_t *current;
|
|||
|
rprogressbar_t *progress_bar;
|
|||
|
bool show_progress;
|
|||
|
int winner;
|
|||
|
bool stdout;
|
|||
|
unsigned long times;
|
|||
|
bool silent;
|
|||
|
nsecs_t execution_time;
|
|||
|
#ifdef __cplusplus
|
|||
|
void (*add_function)(struct rbench_t *r, const char *name, const char *group, void (*)());
|
|||
|
#else
|
|||
|
void (*add_function)(struct rbench_t *r, const char *name, const char *group, void *);
|
|||
|
#endif
|
|||
|
void (*rbench_reset)(struct rbench_t *r);
|
|||
|
struct rbench_t *(*execute)(struct rbench_t *r, long times);
|
|||
|
struct rbench_t *(*execute1)(struct rbench_t *r, long times, void *arg1);
|
|||
|
struct rbench_t *(*execute2)(struct rbench_t *r, long times, void *arg1, void *arg2);
|
|||
|
struct rbench_t *(*execute3)(struct rbench_t *r, long times, void *arg1, void *arg2, void *arg3);
|
|||
|
|
|||
|
} rbench_t;
|
|||
|
|
|||
|
FILE *_rbench_stdout = NULL;
|
|||
|
FILE *_rbench_stdnull = NULL;
|
|||
|
|
|||
|
void rbench_toggle_stdout(rbench_t *r) {
|
|||
|
if (!r->stdout) {
|
|||
|
if (_rbench_stdout == NULL) {
|
|||
|
_rbench_stdout = stdout;
|
|||
|
}
|
|||
|
if (_rbench_stdnull == NULL) {
|
|||
|
_rbench_stdnull = fopen("/dev/null", "wb");
|
|||
|
}
|
|||
|
if (stdout == _rbench_stdout) {
|
|||
|
stdout = _rbench_stdnull;
|
|||
|
} else {
|
|||
|
stdout = _rbench_stdout;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
void rbench_restore_stdout(rbench_t *r) {
|
|||
|
if (r->stdout)
|
|||
|
return;
|
|||
|
if (_rbench_stdout) {
|
|||
|
stdout = _rbench_stdout;
|
|||
|
}
|
|||
|
if (_rbench_stdnull) {
|
|||
|
fclose(_rbench_stdnull);
|
|||
|
_rbench_stdnull = NULL;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
rbench_t *rbench_new();
|
|||
|
|
|||
|
rbench_t *_rbench = NULL;
|
|||
|
rbench_function_t *rbf;
|
|||
|
rbench_t *rbench() {
|
|||
|
if (_rbench == NULL) {
|
|||
|
_rbench = rbench_new();
|
|||
|
}
|
|||
|
return _rbench;
|
|||
|
}
|
|||
|
|
|||
|
typedef void *(*rbench_call)();
|
|||
|
typedef void *(*rbench_call1)(void *);
|
|||
|
typedef void *(*rbench_call2)(void *, void *);
|
|||
|
typedef void *(*rbench_call3)(void *, void *, void *);
|
|||
|
|
|||
|
#ifdef __cplusplus
|
|||
|
void rbench_add_function(rbench_t *rp, const char *name, const char *group, void (*call)()) {
|
|||
|
#else
|
|||
|
void rbench_add_function(rbench_t *rp, const char *name, const char *group, void *call) {
|
|||
|
#endif
|
|||
|
rbench_function_t *f = &rp->functions[rp->function_count];
|
|||
|
rp->function_count++;
|
|||
|
f->average_execution_time = 0;
|
|||
|
f->total_execution_time = 0;
|
|||
|
f->times_executed = 0;
|
|||
|
f->call = call;
|
|||
|
strcpy(f->name, name);
|
|||
|
strcpy(f->group, group);
|
|||
|
}
|
|||
|
|
|||
|
void rbench_reset_function(rbench_function_t *f) {
|
|||
|
f->average_execution_time = 0;
|
|||
|
f->times_executed = 0;
|
|||
|
f->total_execution_time = 0;
|
|||
|
}
|
|||
|
|
|||
|
void rbench_reset(rbench_t *rp) {
|
|||
|
for (unsigned int i = 0; i < rp->function_count; i++) {
|
|||
|
rbench_reset_function(&rp->functions[i]);
|
|||
|
}
|
|||
|
}
|
|||
|
int rbench_get_winner_index(rbench_t *r) {
|
|||
|
int winner = 0;
|
|||
|
nsecs_t time = 0;
|
|||
|
for (unsigned int i = 0; i < r->function_count; i++) {
|
|||
|
if (time == 0 || r->functions[i].total_execution_time < time) {
|
|||
|
winner = i;
|
|||
|
time = r->functions[i].total_execution_time;
|
|||
|
}
|
|||
|
}
|
|||
|
return winner;
|
|||
|
}
|
|||
|
bool rbench_was_last_function(rbench_t *r) {
|
|||
|
for (unsigned int i = 0; i < r->function_count; i++) {
|
|||
|
if (i == r->function_count - 1 && r->current == &r->functions[i])
|
|||
|
return true;
|
|||
|
}
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
rbench_function_t *rbench_execute_prepare(rbench_t *r, int findex, long times, int argc) {
|
|||
|
rbench_toggle_stdout(r);
|
|||
|
if (findex == 0) {
|
|||
|
r->execution_time = 0;
|
|||
|
}
|
|||
|
rbench_function_t *rf = &r->functions[findex];
|
|||
|
rf->argc = argc;
|
|||
|
rbf = rf;
|
|||
|
r->current = rf;
|
|||
|
if (r->show_progress)
|
|||
|
r->progress_bar = rprogressbar_new(0, times, 20, stderr);
|
|||
|
r->times = times;
|
|||
|
// printf(" %s:%s gets executed for %ld times with %d
|
|||
|
// arguments.\n",rf->group, rf->name, times,argc);
|
|||
|
rbench_reset_function(rf);
|
|||
|
|
|||
|
return rf;
|
|||
|
}
|
|||
|
void rbench_execute_finish(rbench_t *r) {
|
|||
|
rbench_toggle_stdout(r);
|
|||
|
if (r->progress_bar) {
|
|||
|
free(r->progress_bar);
|
|||
|
r->progress_bar = NULL;
|
|||
|
}
|
|||
|
r->current->average_execution_time = r->current->total_execution_time / r->current->times_executed;
|
|||
|
;
|
|||
|
// printf(" %s:%s finished executing in
|
|||
|
// %s\n",r->current->group,r->current->name,
|
|||
|
// format_time(r->current->total_execution_time));
|
|||
|
// rbench_show_results_function(r->current);
|
|||
|
if (rbench_was_last_function(r)) {
|
|||
|
rbench_restore_stdout(r);
|
|||
|
unsigned int winner_index = rbench_get_winner_index(r);
|
|||
|
r->winner = winner_index + 1;
|
|||
|
if (!r->silent)
|
|||
|
rprintgf(stderr, "Benchmark results:\n");
|
|||
|
nsecs_t total_time = 0;
|
|||
|
|
|||
|
for (unsigned int i = 0; i < r->function_count; i++) {
|
|||
|
rbf = &r->functions[i];
|
|||
|
total_time += rbf->total_execution_time;
|
|||
|
bool is_winner = winner_index == i;
|
|||
|
if (is_winner) {
|
|||
|
if (!r->silent)
|
|||
|
rprintyf(stderr, " > %s:%s:%s\n", format_time(rbf->total_execution_time), rbf->group, rbf->name);
|
|||
|
} else {
|
|||
|
if (!r->silent)
|
|||
|
rprintbf(stderr, " %s:%s:%s\n", format_time(rbf->total_execution_time), rbf->group, rbf->name);
|
|||
|
}
|
|||
|
}
|
|||
|
if (!r->silent)
|
|||
|
rprintgf(stderr, "Total execution time: %s\n", format_time(total_time));
|
|||
|
}
|
|||
|
rbench_restore_stdout(r);
|
|||
|
rbf = NULL;
|
|||
|
r->current = NULL;
|
|||
|
}
|
|||
|
struct rbench_t *rbench_execute(rbench_t *r, long times) {
|
|||
|
|
|||
|
for (unsigned int i = 0; i < r->function_count; i++) {
|
|||
|
|
|||
|
rbench_function_t *f = rbench_execute_prepare(r, i, times, 0);
|
|||
|
rbench_call c = (rbench_call)f->call;
|
|||
|
nsecs_t start = nsecs();
|
|||
|
f->first = true;
|
|||
|
c();
|
|||
|
f->first = false;
|
|||
|
f->last = false;
|
|||
|
f->times_executed++;
|
|||
|
for (int j = 1; j < times; j++) {
|
|||
|
c();
|
|||
|
f->times_executed++;
|
|||
|
f->last = f->times_executed == r->times - 1;
|
|||
|
if (r->progress_bar) {
|
|||
|
rprogressbar_update(r->progress_bar, f->times_executed);
|
|||
|
}
|
|||
|
}
|
|||
|
f->total_execution_time = nsecs() - start;
|
|||
|
r->execution_time += f->total_execution_time;
|
|||
|
rbench_execute_finish(r);
|
|||
|
}
|
|||
|
return r;
|
|||
|
}
|
|||
|
|
|||
|
struct rbench_t *rbench_execute1(rbench_t *r, long times, void *arg1) {
|
|||
|
|
|||
|
for (unsigned int i = 0; i < r->function_count; i++) {
|
|||
|
rbench_function_t *f = rbench_execute_prepare(r, i, times, 1);
|
|||
|
rbench_call1 c = (rbench_call1)f->call;
|
|||
|
nsecs_t start = nsecs();
|
|||
|
f->first = true;
|
|||
|
c(arg1);
|
|||
|
f->first = false;
|
|||
|
f->last = false;
|
|||
|
f->times_executed++;
|
|||
|
for (int j = 1; j < times; j++) {
|
|||
|
c(arg1);
|
|||
|
f->times_executed++;
|
|||
|
f->last = f->times_executed == r->times - 1;
|
|||
|
if (r->progress_bar) {
|
|||
|
rprogressbar_update(r->progress_bar, f->times_executed);
|
|||
|
}
|
|||
|
}
|
|||
|
f->total_execution_time = nsecs() - start;
|
|||
|
r->execution_time += f->total_execution_time;
|
|||
|
rbench_execute_finish(r);
|
|||
|
}
|
|||
|
return r;
|
|||
|
}
|
|||
|
|
|||
|
struct rbench_t *rbench_execute2(rbench_t *r, long times, void *arg1, void *arg2) {
|
|||
|
|
|||
|
for (unsigned int i = 0; i < r->function_count; i++) {
|
|||
|
rbench_function_t *f = rbench_execute_prepare(r, i, times, 2);
|
|||
|
rbench_call2 c = (rbench_call2)f->call;
|
|||
|
nsecs_t start = nsecs();
|
|||
|
f->first = true;
|
|||
|
c(arg1, arg2);
|
|||
|
f->first = false;
|
|||
|
f->last = false;
|
|||
|
f->times_executed++;
|
|||
|
for (int j = 1; j < times; j++) {
|
|||
|
c(arg1, arg2);
|
|||
|
f->times_executed++;
|
|||
|
f->last = f->times_executed == r->times - 1;
|
|||
|
if (r->progress_bar) {
|
|||
|
rprogressbar_update(r->progress_bar, f->times_executed);
|
|||
|
}
|
|||
|
}
|
|||
|
f->total_execution_time = nsecs() - start;
|
|||
|
r->execution_time += f->total_execution_time;
|
|||
|
rbench_execute_finish(r);
|
|||
|
}
|
|||
|
return r;
|
|||
|
}
|
|||
|
|
|||
|
struct rbench_t *rbench_execute3(rbench_t *r, long times, void *arg1, void *arg2, void *arg3) {
|
|||
|
|
|||
|
for (unsigned int i = 0; i < r->function_count; i++) {
|
|||
|
rbench_function_t *f = rbench_execute_prepare(r, i, times, 3);
|
|||
|
|
|||
|
rbench_call3 c = (rbench_call3)f->call;
|
|||
|
nsecs_t start = nsecs();
|
|||
|
f->first = true;
|
|||
|
c(arg1, arg2, arg3);
|
|||
|
f->first = false;
|
|||
|
f->last = false;
|
|||
|
f->times_executed++;
|
|||
|
for (int j = 1; j < times; j++) {
|
|||
|
c(arg1, arg2, arg3);
|
|||
|
f->times_executed++;
|
|||
|
f->last = f->times_executed == r->times - 1;
|
|||
|
if (r->progress_bar) {
|
|||
|
rprogressbar_update(r->progress_bar, f->times_executed);
|
|||
|
}
|
|||
|
}
|
|||
|
f->total_execution_time = nsecs() - start;
|
|||
|
rbench_execute_finish(r);
|
|||
|
}
|
|||
|
return r;
|
|||
|
}
|
|||
|
|
|||
|
rbench_t *rbench_new() {
|
|||
|
|
|||
|
rbench_t *r = (rbench_t *)malloc(sizeof(rbench_t));
|
|||
|
memset(r, 0, sizeof(rbench_t));
|
|||
|
r->add_function = rbench_add_function;
|
|||
|
r->rbench_reset = rbench_reset;
|
|||
|
r->execute1 = rbench_execute1;
|
|||
|
r->execute2 = rbench_execute2;
|
|||
|
r->execute3 = rbench_execute3;
|
|||
|
r->execute = rbench_execute;
|
|||
|
r->stdout = true;
|
|||
|
r->silent = false;
|
|||
|
r->winner = 0;
|
|||
|
r->show_progress = true;
|
|||
|
return r;
|
|||
|
}
|
|||
|
void rbench_free(rbench_t *r) { free(r); }
|
|||
|
|
|||
|
#endif
|
|||
|
bool check_lcov() {
|
|||
|
char buffer[1024 * 64];
|
|||
|
FILE *fp;
|
|||
|
fp = popen("lcov --help", "r");
|
|||
|
if (fp == NULL) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
if (fgets(buffer, sizeof(buffer), fp) == NULL) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
pclose(fp);
|
|||
|
return strstr(buffer, "lcov: not found") ? false : true;
|
|||
|
}
|
|||
|
|
|||
|
int rcov_main(int argc, char *argv[]) {
|
|||
|
if (argc < 2) {
|
|||
|
printf("Usage: [source.c]\n");
|
|||
|
return 1;
|
|||
|
}
|
|||
|
char argstr[4096] = {0};
|
|||
|
for (int i = 2; i < argc; i++) {
|
|||
|
strcat(argstr, argv[i]);
|
|||
|
strcat(argstr, " ");
|
|||
|
}
|
|||
|
if (!check_lcov()) {
|
|||
|
|
|||
|
printf("lcov is not installed. Please execute `sudo apt install lcov`.\n");
|
|||
|
return 1;
|
|||
|
}
|
|||
|
char *source_file = argv[1];
|
|||
|
char *commands[] = {"rm -f *.gcda 2>/dev/null",
|
|||
|
"rm -f *.gcno 2>/dev/null",
|
|||
|
"rm -f %s.coverage.info 2>/dev/null",
|
|||
|
"gcc -pg -fprofile-arcs -ftest-coverage -g -o %s_coverage.o %s",
|
|||
|
"./%s_coverage.o",
|
|||
|
"lcov --capture --directory . --output-file %s.coverage.info",
|
|||
|
"genhtml %s.coverage.info --output-directory /tmp/%s.coverage",
|
|||
|
"rm -f *.gcda 2>/dev/null",
|
|||
|
"rm -f *.gcno 2>/dev/null",
|
|||
|
"rm -f %s.coverage.info 2>/dev/null", //"cat gmon.out",
|
|||
|
|
|||
|
"gprof %s_coverage.o gmon.out > output.rcov_analysis",
|
|||
|
|
|||
|
"rm -f gmon.out",
|
|||
|
"cat output.rcov_analysis",
|
|||
|
"rm output.rcov_analysis",
|
|||
|
"rm -f %s_coverage.o",
|
|||
|
|
|||
|
"google-chrome /tmp/%s.coverage/index.html"};
|
|||
|
uint command_count = sizeof(commands) / sizeof(commands[0]);
|
|||
|
RBENCH(1,{
|
|||
|
for (uint i = 0; i < command_count; i++) {
|
|||
|
char *formatted_command = sbuf("");
|
|||
|
sprintf(formatted_command, commands[i], source_file, source_file);
|
|||
|
// printf("%s\n", formatted_command);
|
|||
|
if (formatted_command[0] == '.' && formatted_command[1] == '/') {
|
|||
|
strcat(formatted_command, " ");
|
|||
|
strcat(formatted_command, argstr);
|
|||
|
}
|
|||
|
|
|||
|
if (system(formatted_command)) {
|
|||
|
printf("`%s` returned non-zero code.\n", formatted_command);
|
|||
|
}
|
|||
|
});
|
|||
|
}
|
|||
|
return 0;
|
|||
|
}
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef RHTTP_H
|
|||
|
#define RHTTP_H
|
|||
|
#include <arpa/inet.h>
|
|||
|
#include <pthread.h>
|
|||
|
#include <signal.h>
|
|||
|
#include <stdarg.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
#include <time.h>
|
|||
|
#include <unistd.h>
|
|||
|
|
|||
|
#define BUFF_SIZE 8096
|
|||
|
#define RHTTP_MAX_CONNECTIONS 100
|
|||
|
|
|||
|
int rhttp_opt_error = 1;
|
|||
|
int rhttp_opt_warn = 1;
|
|||
|
int rhttp_opt_info = 1;
|
|||
|
int rhttp_opt_port = 8080;
|
|||
|
int rhttp_opt_debug = 0;
|
|||
|
int rhttp_opt_request_logging = 0;
|
|||
|
int rhttp_sock = 0;
|
|||
|
int rhttp_opt_buffered = 0;
|
|||
|
int rhttp_c = 0;
|
|||
|
int rhttp_c_mutex_initialized = 0;
|
|||
|
pthread_mutex_t rhttp_c_mutex;
|
|||
|
char rhttp_opt_host[1024] = "0.0.0.0";
|
|||
|
unsigned int rhttp_connections_handled = 0;
|
|||
|
|
|||
|
typedef struct rhttp_header_t {
|
|||
|
char *name;
|
|||
|
char *value;
|
|||
|
struct rhttp_header_t *next;
|
|||
|
} rhttp_header_t;
|
|||
|
|
|||
|
typedef struct rhttp_request_t {
|
|||
|
int c;
|
|||
|
int closed;
|
|||
|
bool keep_alive;
|
|||
|
nsecs_t start;
|
|||
|
char *raw;
|
|||
|
char *line;
|
|||
|
char *body;
|
|||
|
char *method;
|
|||
|
char *path;
|
|||
|
char *version;
|
|||
|
void *context;
|
|||
|
unsigned int bytes_received;
|
|||
|
rhttp_header_t *headers;
|
|||
|
} rhttp_request_t;
|
|||
|
|
|||
|
char *rhttp_current_timestamp() {
|
|||
|
time_t current_time;
|
|||
|
time(¤t_time);
|
|||
|
struct tm *local_time = localtime(¤t_time);
|
|||
|
static char time_string[100];
|
|||
|
time_string[0] = 0;
|
|||
|
strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", local_time);
|
|||
|
|
|||
|
return time_string;
|
|||
|
}
|
|||
|
|
|||
|
void rhttp_logs(const char *prefix, const char *level, const char *format, va_list args) {
|
|||
|
char buf[strlen(format) + BUFSIZ + 1];
|
|||
|
buf[0] = 0;
|
|||
|
sprintf(buf, "%s%s %s %s\e[0m", prefix, rhttp_current_timestamp(), level, format);
|
|||
|
vfprintf(stdout, buf, args);
|
|||
|
}
|
|||
|
void rhttp_log_info(const char *format, ...) {
|
|||
|
if (!rhttp_opt_info)
|
|||
|
return;
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rhttp_logs("\e[32m", "INFO ", format, args);
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rhttp_log_debug(const char *format, ...) {
|
|||
|
if (!rhttp_opt_debug)
|
|||
|
return;
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
if (rhttp_opt_debug)
|
|||
|
rhttp_logs("\e[33m", "DEBUG", format, args);
|
|||
|
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rhttp_log_warn(const char *format, ...) {
|
|||
|
if (!rhttp_opt_warn)
|
|||
|
return;
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rhttp_logs("\e[34m", "WARN ", format, args);
|
|||
|
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
void rhttp_log_error(const char *format, ...) {
|
|||
|
if (!rhttp_opt_error)
|
|||
|
return;
|
|||
|
va_list args;
|
|||
|
va_start(args, format);
|
|||
|
rhttp_logs("\e[35m", "ERROR", format, args);
|
|||
|
|
|||
|
va_end(args);
|
|||
|
}
|
|||
|
|
|||
|
void http_request_init(rhttp_request_t *r) {
|
|||
|
r->raw = NULL;
|
|||
|
r->line = NULL;
|
|||
|
r->body = NULL;
|
|||
|
r->method = NULL;
|
|||
|
r->path = NULL;
|
|||
|
r->version = NULL;
|
|||
|
r->start = 0;
|
|||
|
r->headers = NULL;
|
|||
|
r->bytes_received = 0;
|
|||
|
r->closed = 0;
|
|||
|
}
|
|||
|
|
|||
|
void rhttp_free_header(rhttp_header_t *h) {
|
|||
|
if (!h)
|
|||
|
return;
|
|||
|
rhttp_header_t *next = h->next;
|
|||
|
free(h->name);
|
|||
|
free(h->value);
|
|||
|
free(h);
|
|||
|
if (next)
|
|||
|
rhttp_free_header(next);
|
|||
|
}
|
|||
|
void rhttp_rhttp_free_headers(rhttp_request_t *r) {
|
|||
|
if (!r->headers)
|
|||
|
return;
|
|||
|
rhttp_free_header(r->headers);
|
|||
|
r->headers = NULL;
|
|||
|
}
|
|||
|
|
|||
|
rhttp_header_t *rhttp_parse_headers(rhttp_request_t *s) {
|
|||
|
int first = 1;
|
|||
|
char *body = strdup(s->body);
|
|||
|
char *body_original = body;
|
|||
|
while (body && *body) {
|
|||
|
char *line = __strtok_r(first ? body : NULL, "\r\n", &body);
|
|||
|
if (!line)
|
|||
|
break;
|
|||
|
rhttp_header_t *h = (rhttp_header_t *)malloc(sizeof(rhttp_header_t));
|
|||
|
h->name = NULL;
|
|||
|
h->value = NULL;
|
|||
|
h->next = NULL;
|
|||
|
char *name = __strtok_r(line, ": ", &line);
|
|||
|
first = 0;
|
|||
|
if (!name) {
|
|||
|
rhttp_free_header(h);
|
|||
|
break;
|
|||
|
}
|
|||
|
h->name = strdup(name);
|
|||
|
char *value = __strtok_r(NULL, "\r\n", &line);
|
|||
|
if (!value) {
|
|||
|
rhttp_free_header(h);
|
|||
|
break;
|
|||
|
}
|
|||
|
h->value = value ? strdup(value + 1) : strdup("");
|
|||
|
h->next = s->headers;
|
|||
|
s->headers = h;
|
|||
|
}
|
|||
|
free(body_original);
|
|||
|
return s->headers;
|
|||
|
}
|
|||
|
|
|||
|
void rhttp_free_request(rhttp_request_t *r) {
|
|||
|
if (r->raw) {
|
|||
|
free(r->raw);
|
|||
|
free(r->body);
|
|||
|
free(r->method);
|
|||
|
free(r->path);
|
|||
|
free(r->version);
|
|||
|
rhttp_rhttp_free_headers(r);
|
|||
|
}
|
|||
|
free(r);
|
|||
|
}
|
|||
|
|
|||
|
long rhttp_header_get_long(rhttp_request_t *r, const char *name) {
|
|||
|
rhttp_header_t *h = r->headers;
|
|||
|
while (h) {
|
|||
|
if (!strcmp(h->name, name))
|
|||
|
return strtol(h->value, NULL, 10);
|
|||
|
h = h->next;
|
|||
|
}
|
|||
|
return -1;
|
|||
|
}
|
|||
|
char *rhttp_header_get_string(rhttp_request_t *r, const char *name) {
|
|||
|
rhttp_header_t *h = r->headers;
|
|||
|
while (h) {
|
|||
|
if (!strcmp(h->name, name))
|
|||
|
return h->value && *h->value ? h->value : NULL;
|
|||
|
h = h->next;
|
|||
|
}
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
|
|||
|
void rhttp_print_header(rhttp_header_t *h) { rhttp_log_debug("Header: <%s> \"%s\"\n", h->name, h->value); }
|
|||
|
void rhttp_print_headers(rhttp_header_t *h) {
|
|||
|
while (h) {
|
|||
|
rhttp_print_header(h);
|
|||
|
h = h->next;
|
|||
|
}
|
|||
|
}
|
|||
|
void rhttp_print_request_line(rhttp_request_t *r) { rhttp_log_info("%s %s %s\n", r->method, r->path, r->version); }
|
|||
|
void rhttp_print_request(rhttp_request_t *r) {
|
|||
|
rhttp_print_request_line(r);
|
|||
|
if (rhttp_opt_debug)
|
|||
|
rhttp_print_headers(r->headers);
|
|||
|
}
|
|||
|
void rhttp_close(rhttp_request_t *r) {
|
|||
|
if (!r)
|
|||
|
return;
|
|||
|
if (!r->closed)
|
|||
|
close(r->c);
|
|||
|
rhttp_free_request(r);
|
|||
|
}
|
|||
|
rhttp_request_t *rhttp_parse_request(int s) {
|
|||
|
rhttp_request_t *request = (rhttp_request_t *)malloc(sizeof(rhttp_request_t));
|
|||
|
http_request_init(request);
|
|||
|
char buf[BUFF_SIZE] = {0};
|
|||
|
request->c = s;
|
|||
|
int breceived = 0;
|
|||
|
while (!rstrendswith(buf, "\r\n\r\n")) {
|
|||
|
int chunk_size = read(s, buf + breceived, 1);
|
|||
|
if (chunk_size <= 0) {
|
|||
|
close(request->c);
|
|||
|
request->closed = 1;
|
|||
|
return request;
|
|||
|
}
|
|||
|
breceived += chunk_size;
|
|||
|
}
|
|||
|
if (breceived <= 0) {
|
|||
|
close(request->c);
|
|||
|
request->closed = 1;
|
|||
|
return request;
|
|||
|
}
|
|||
|
buf[breceived] = '\0';
|
|||
|
char *original_buf = buf;
|
|||
|
|
|||
|
char *b = original_buf;
|
|||
|
request->raw = strdup(b);
|
|||
|
b = original_buf;
|
|||
|
char *line = strtok(b, "\r\n");
|
|||
|
b = original_buf;
|
|||
|
char *body = b + strlen(line) + 2;
|
|||
|
request->body = strdup(body);
|
|||
|
b = original_buf;
|
|||
|
char *method = strtok(b, " ");
|
|||
|
char *path = strtok(NULL, " ");
|
|||
|
char *version = strtok(NULL, " ");
|
|||
|
request->bytes_received = breceived;
|
|||
|
request->line = line;
|
|||
|
request->start = nsecs();
|
|||
|
request->method = strdup(method);
|
|||
|
request->path = strdup(path);
|
|||
|
request->version = strdup(version);
|
|||
|
request->headers = NULL;
|
|||
|
request->keep_alive = false;
|
|||
|
if (rhttp_parse_headers(request)) {
|
|||
|
char *keep_alive_string = rhttp_header_get_string(request, "Connection");
|
|||
|
if (keep_alive_string && !strcmp(keep_alive_string, "keep-alive")) {
|
|||
|
request->keep_alive = 1;
|
|||
|
}
|
|||
|
}
|
|||
|
return request;
|
|||
|
}
|
|||
|
|
|||
|
void rhttp_close_server() {
|
|||
|
close(rhttp_sock);
|
|||
|
close(rhttp_c);
|
|||
|
printf("Connections handled: %d\n", rhttp_connections_handled);
|
|||
|
printf("Gracefully closed\n");
|
|||
|
exit(0);
|
|||
|
}
|
|||
|
|
|||
|
size_t rhttp_send_drain(int s, void *tsend, size_t to_send_len) {
|
|||
|
if (to_send_len == 0 && *(unsigned char *)tsend) {
|
|||
|
to_send_len = strlen(tsend);
|
|||
|
}
|
|||
|
unsigned char *to_send = (unsigned char *)malloc(to_send_len);
|
|||
|
unsigned char *to_send_original = to_send;
|
|||
|
|
|||
|
memcpy(to_send, tsend, to_send_len);
|
|||
|
// to_send[to_send_len] = '\0';
|
|||
|
long bytes_sent = 0;
|
|||
|
long bytes_sent_total = 0;
|
|||
|
while (1) {
|
|||
|
bytes_sent = send(s, to_send + bytes_sent_total, to_send_len - bytes_sent_total, 0);
|
|||
|
if (bytes_sent <= 0) {
|
|||
|
bytes_sent_total = 0;
|
|||
|
break;
|
|||
|
}
|
|||
|
bytes_sent_total += bytes_sent;
|
|||
|
|
|||
|
if (bytes_sent_total == (long)to_send_len) {
|
|||
|
break;
|
|||
|
} else if (!bytes_sent) {
|
|||
|
bytes_sent_total = 0;
|
|||
|
// error
|
|||
|
break;
|
|||
|
} else {
|
|||
|
rhttp_log_info("Extra send of %d/%d bytes.\n", bytes_sent_total, to_send_len);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
free(to_send_original);
|
|||
|
return bytes_sent_total;
|
|||
|
}
|
|||
|
|
|||
|
typedef int (*rhttp_request_handler_t)(rhttp_request_t *r);
|
|||
|
|
|||
|
void rhttp_serve(const char *host, int port, int backlog, int request_logging, int request_debug, rhttp_request_handler_t handler,
|
|||
|
void *context) {
|
|||
|
signal(SIGPIPE, SIG_IGN);
|
|||
|
rhttp_sock = socket(AF_INET, SOCK_STREAM, 0);
|
|||
|
struct sockaddr_in addr;
|
|||
|
addr.sin_family = AF_INET;
|
|||
|
addr.sin_port = htons(port);
|
|||
|
addr.sin_addr.s_addr = inet_addr(host ? host : "0.0.0.0");
|
|||
|
rhttp_opt_debug = request_debug;
|
|||
|
rhttp_opt_request_logging = request_logging;
|
|||
|
int opt = 1;
|
|||
|
setsockopt(rhttp_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
|
|||
|
if (bind(rhttp_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
|
|||
|
printf("Binding error\n");
|
|||
|
exit(1);
|
|||
|
}
|
|||
|
listen(rhttp_sock, backlog);
|
|||
|
while (1) {
|
|||
|
struct sockaddr_in client_addr;
|
|||
|
int addrlen = sizeof(client_addr);
|
|||
|
|
|||
|
rhttp_c = accept(rhttp_sock, (struct sockaddr *)&client_addr, (socklen_t *)&addrlen);
|
|||
|
|
|||
|
rhttp_connections_handled++;
|
|||
|
while (true) {
|
|||
|
rhttp_request_t *r = rhttp_parse_request(rhttp_c);
|
|||
|
r->context = context;
|
|||
|
if (!r->closed) {
|
|||
|
if (!handler(r) && !r->closed) {
|
|||
|
rhttp_close(r);
|
|||
|
}
|
|||
|
}
|
|||
|
if (!r->keep_alive && !r->closed) {
|
|||
|
rhttp_close(r);
|
|||
|
} else if (r->keep_alive && !r->closed) {
|
|||
|
}
|
|||
|
if (r->closed) {
|
|||
|
break;
|
|||
|
}
|
|||
|
rhttp_free_request(r);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
unsigned int rhttp_calculate_number_char_count(unsigned int number) {
|
|||
|
unsigned int width = 1;
|
|||
|
unsigned int tcounter = number;
|
|||
|
while (tcounter / 10 >= 1) {
|
|||
|
tcounter = tcounter / 10;
|
|||
|
width++;
|
|||
|
}
|
|||
|
return width;
|
|||
|
}
|
|||
|
|
|||
|
int rhttp_file_response(rhttp_request_t *r, char *path) {
|
|||
|
if (!*path)
|
|||
|
return 0;
|
|||
|
FILE *f = fopen(path, "rb");
|
|||
|
if (f == NULL)
|
|||
|
return 0;
|
|||
|
size_t file_size = rfile_size(path);
|
|||
|
char response[1024] = {0};
|
|||
|
char content_type_header[100] = {0};
|
|||
|
char *ext = strstr(path, ".");
|
|||
|
char *text_extensions = ".h,.c,.html";
|
|||
|
if (strstr(text_extensions, ext)) {
|
|||
|
sprintf(content_type_header, "Content-Type: %s\r\n", "text/html");
|
|||
|
}
|
|||
|
sprintf(response, "HTTP/1.1 200 OK\r\n%sContent-Length:%ld\r\n\r\n", content_type_header, file_size);
|
|||
|
if (!rhttp_send_drain(r->c, response, 0)) {
|
|||
|
rhttp_log_error("Error sending file: %s\n", path);
|
|||
|
}
|
|||
|
size_t bytes = 0;
|
|||
|
size_t bytes_sent = 0;
|
|||
|
unsigned char file_buff[1024];
|
|||
|
while ((bytes = fread(file_buff, sizeof(char), sizeof(file_buff), f))) {
|
|||
|
if (!rhttp_send_drain(r->c, file_buff, bytes)) {
|
|||
|
rhttp_log_error("Error sending file during chunking: %s\n", path);
|
|||
|
}
|
|||
|
bytes_sent += bytes;
|
|||
|
}
|
|||
|
if (bytes_sent != file_size) {
|
|||
|
rhttp_send_drain(r->c, file_buff, file_size - bytes_sent);
|
|||
|
}
|
|||
|
close(r->c);
|
|||
|
fclose(f);
|
|||
|
return 1;
|
|||
|
};
|
|||
|
|
|||
|
int rhttp_file_request_handler(rhttp_request_t *r) {
|
|||
|
char *path = r->path;
|
|||
|
while (*path == '/' || *path == '.')
|
|||
|
path++;
|
|||
|
if (strstr(path, "..")) {
|
|||
|
return 0;
|
|||
|
}
|
|||
|
return rhttp_file_response(r, path);
|
|||
|
};
|
|||
|
|
|||
|
unsigned int counter = 100000000;
|
|||
|
int rhttp_counter_request_handler(rhttp_request_t *r) {
|
|||
|
if (!strncmp(r->path, "/counter", strlen("/counter"))) {
|
|||
|
counter++;
|
|||
|
unsigned int width = rhttp_calculate_number_char_count(counter);
|
|||
|
char to_send2[1024] = {0};
|
|||
|
sprintf(to_send2,
|
|||
|
"HTTP/1.1 200 OK\r\nContent-Length: %d\r\nConnection: "
|
|||
|
"close\r\n\r\n%d",
|
|||
|
width, counter);
|
|||
|
rhttp_send_drain(r->c, to_send2, 0);
|
|||
|
close(r->c);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
return 0;
|
|||
|
}
|
|||
|
int rhttp_root_request_handler(rhttp_request_t *r) {
|
|||
|
if (!strcmp(r->path, "/")) {
|
|||
|
char to_send[1024] = {0};
|
|||
|
sprintf(to_send, "HTTP/1.1 200 OK\r\nContent-Length: 3\r\nConnection: "
|
|||
|
"close\r\n\r\nOk!");
|
|||
|
rhttp_send_drain(r->c, to_send, 0);
|
|||
|
close(r->c);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
return 0;
|
|||
|
}
|
|||
|
int rhttp_error_404_handler(rhttp_request_t *r) {
|
|||
|
char to_send[1024] = {0};
|
|||
|
sprintf(to_send, "HTTP/1.1 404 Document not found\r\nContent-Length: "
|
|||
|
"0\r\nConnection: close\r\n\r\n");
|
|||
|
rhttp_send_drain(r->c, to_send, 0);
|
|||
|
close(r->c);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
|
|||
|
int rhttp_default_request_handler(rhttp_request_t *r) {
|
|||
|
if (rhttp_opt_debug || rhttp_opt_request_logging)
|
|||
|
rhttp_print_request(r);
|
|||
|
if (rhttp_counter_request_handler(r)) {
|
|||
|
// Counter handler
|
|||
|
rhttp_log_info("Counter handler found for: %s\n", r->path);
|
|||
|
|
|||
|
} else if (rhttp_root_request_handler(r)) {
|
|||
|
// Root handler
|
|||
|
rhttp_log_info("Root handler found for: %s\n", r->path);
|
|||
|
} else if (rhttp_file_request_handler(r)) {
|
|||
|
rhttp_log_info("File %s sent\n", r->path);
|
|||
|
} else if (rhttp_error_404_handler(r)) {
|
|||
|
rhttp_log_warn("Error 404 for: %s\n", r->path);
|
|||
|
// Error handler
|
|||
|
} else {
|
|||
|
rhttp_log_warn("No handler found for: %s\n", r->path);
|
|||
|
close(rhttp_c);
|
|||
|
}
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
int rhttp_main(int argc, char *argv[]) {
|
|||
|
setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
|
|||
|
int opt;
|
|||
|
while ((opt = getopt(argc, argv, "p:drh:bewi")) != -1) {
|
|||
|
switch (opt) {
|
|||
|
case 'i':
|
|||
|
rhttp_opt_info = 1;
|
|||
|
rhttp_opt_warn = 1;
|
|||
|
rhttp_opt_error = 1;
|
|||
|
break;
|
|||
|
case 'e':
|
|||
|
rhttp_opt_error = 1;
|
|||
|
rhttp_opt_warn = 0;
|
|||
|
rhttp_opt_info = 0;
|
|||
|
break;
|
|||
|
case 'w':
|
|||
|
rhttp_opt_warn = 1;
|
|||
|
rhttp_opt_error = 1;
|
|||
|
rhttp_opt_info = 0;
|
|||
|
break;
|
|||
|
case 'p':
|
|||
|
rhttp_opt_port = atoi(optarg);
|
|||
|
break;
|
|||
|
case 'b':
|
|||
|
rhttp_opt_buffered = 1;
|
|||
|
printf("Logging is buffered. Output may be incomplete.\n");
|
|||
|
break;
|
|||
|
case 'h':
|
|||
|
strcpy(rhttp_opt_host, optarg);
|
|||
|
break;
|
|||
|
case 'd':
|
|||
|
printf("Debug enabled\n");
|
|||
|
rhttp_opt_debug = 1;
|
|||
|
rhttp_opt_warn = 1;
|
|||
|
rhttp_opt_info = 1;
|
|||
|
rhttp_opt_error = 1;
|
|||
|
break;
|
|||
|
case 'r':
|
|||
|
printf("Request logging enabled\n");
|
|||
|
rhttp_opt_request_logging = 1;
|
|||
|
break;
|
|||
|
default:
|
|||
|
printf("Usage: %s [-p port] [-h host] [-b]\n", argv[0]);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
printf("Starting server on: %s:%d\n", rhttp_opt_host, rhttp_opt_port);
|
|||
|
if (rhttp_opt_buffered)
|
|||
|
setvbuf(stdout, NULL, _IOFBF, BUFSIZ);
|
|||
|
|
|||
|
rhttp_serve(rhttp_opt_host, rhttp_opt_port, 1024, rhttp_opt_request_logging, rhttp_opt_debug, rhttp_default_request_handler, NULL);
|
|||
|
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
/* CLIENT CODE */
|
|||
|
|
|||
|
typedef struct rhttp_client_request_t {
|
|||
|
char *host;
|
|||
|
int port;
|
|||
|
char *path;
|
|||
|
bool is_done;
|
|||
|
char *request;
|
|||
|
char *response;
|
|||
|
pthread_t thread;
|
|||
|
int bytes_received;
|
|||
|
} rhttp_client_request_t;
|
|||
|
|
|||
|
rhttp_client_request_t *rhttp_create_request(const char *host, int port, const char *path) {
|
|||
|
rhttp_client_request_t *r = (rhttp_client_request_t *)malloc(sizeof(rhttp_client_request_t));
|
|||
|
char request_line[4096] = {0};
|
|||
|
sprintf(request_line,
|
|||
|
"GET %s HTTP/1.1\r\n"
|
|||
|
"Host: localhost:8000\r\n"
|
|||
|
"Connection: close\r\n"
|
|||
|
"Accept: */*\r\n"
|
|||
|
"User-Agent: mhttpc\r\n"
|
|||
|
"Accept-Language: en-US,en;q=0.5\r\n"
|
|||
|
"Accept-Encoding: gzip, deflate\r\n"
|
|||
|
"\r\n",
|
|||
|
path);
|
|||
|
r->request = strdup(request_line);
|
|||
|
r->host = strdup(host);
|
|||
|
r->port = port;
|
|||
|
r->path = strdup(path);
|
|||
|
r->is_done = false;
|
|||
|
r->response = NULL;
|
|||
|
r->bytes_received = 0;
|
|||
|
return r;
|
|||
|
}
|
|||
|
|
|||
|
int rhttp_execute_request(rhttp_client_request_t *r) {
|
|||
|
int s = socket(AF_INET, SOCK_STREAM, 0);
|
|||
|
struct sockaddr_in addr;
|
|||
|
|
|||
|
addr.sin_family = AF_INET;
|
|||
|
addr.sin_port = htons(r->port);
|
|||
|
addr.sin_addr.s_addr = inet_addr(r->host);
|
|||
|
|
|||
|
if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
send(s, r->request, strlen(r->request), 0);
|
|||
|
char buf[1024 * 1024] = {0};
|
|||
|
int ret = recv(s, buf, 1024 * 1024, 0);
|
|||
|
if (ret > 0) {
|
|||
|
r->response = strdup(buf);
|
|||
|
}
|
|||
|
|
|||
|
close(s);
|
|||
|
return ret;
|
|||
|
}
|
|||
|
void rhttp_reset_request(rhttp_client_request_t *r) {
|
|||
|
free(r->response);
|
|||
|
r->is_done = false;
|
|||
|
r->response = NULL;
|
|||
|
r->bytes_received = 0;
|
|||
|
}
|
|||
|
void rhttp_free_client_request(rhttp_client_request_t *r) {
|
|||
|
if (r->request)
|
|||
|
free(r->request);
|
|||
|
if (r->response)
|
|||
|
free(r->response);
|
|||
|
if (r->host)
|
|||
|
free(r->host);
|
|||
|
if (r->path)
|
|||
|
free(r->path);
|
|||
|
free(r);
|
|||
|
}
|
|||
|
|
|||
|
void rhttp_client_bench(int workers, int times, const char *host, int port, const char *path) {
|
|||
|
rhttp_client_request_t *requests[workers];
|
|||
|
while (times > 0) {
|
|||
|
|
|||
|
for (int i = 0; i < workers && times; i++) {
|
|||
|
requests[i] = rhttp_create_request(host, port, path);
|
|||
|
rhttp_execute_request(requests[i]);
|
|||
|
times--;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
char *rhttp_client_get(const char *host, int port, const char *path) {
|
|||
|
if (!rhttp_c_mutex_initialized) {
|
|||
|
rhttp_c_mutex_initialized = 1;
|
|||
|
pthread_mutex_init(&rhttp_c_mutex, NULL);
|
|||
|
}
|
|||
|
char http_response[1024 * 1024];
|
|||
|
http_response[0] = 0;
|
|||
|
rhttp_client_request_t *r = rhttp_create_request(host, port, path);
|
|||
|
unsigned int reconnects = 0;
|
|||
|
unsigned int reconnects_max = 100000;
|
|||
|
while (!rhttp_execute_request(r)) {
|
|||
|
reconnects++;
|
|||
|
tick();
|
|||
|
if (reconnects == reconnects_max) {
|
|||
|
fprintf(stderr, "Maxium reconnects exceeded for %s:%d\n", host, port);
|
|||
|
rhttp_free_client_request(r);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
}
|
|||
|
r->is_done = true;
|
|||
|
char *body = r->response ? strstr(r->response, "\r\n\r\n") : NULL;
|
|||
|
pthread_mutex_lock(&rhttp_c_mutex);
|
|||
|
if (body) {
|
|||
|
strcpy(http_response, body + 4);
|
|||
|
} else {
|
|||
|
strcpy(http_response, r->response);
|
|||
|
}
|
|||
|
rhttp_free_client_request(r);
|
|||
|
char *result = sbuf(http_response);
|
|||
|
pthread_mutex_unlock(&rhttp_c_mutex);
|
|||
|
return result;
|
|||
|
}
|
|||
|
/*END CLIENT CODE */
|
|||
|
#endif
|
|||
|
|
|||
|
#ifndef RJSON_H
|
|||
|
#define RJSON_H
|
|||
|
|
|||
|
typedef struct rjson_t {
|
|||
|
char *content;
|
|||
|
size_t length;
|
|||
|
size_t size;
|
|||
|
} rjson_t;
|
|||
|
|
|||
|
rjson_t *rjson() {
|
|||
|
rjson_t *json = rmalloc(sizeof(rjson_t));
|
|||
|
json->size = 1024;
|
|||
|
json->length = 0;
|
|||
|
json->content = (char *)rmalloc(json->size);
|
|||
|
json->content[0] = 0;
|
|||
|
return json;
|
|||
|
}
|
|||
|
|
|||
|
void rjson_write(rjson_t *rjs, char *content) {
|
|||
|
size_t len = strlen(content);
|
|||
|
while (rjs->size < rjs->length + len + 1) {
|
|||
|
rjs->content = realloc(rjs->content, rjs->size + 1024);
|
|||
|
rjs->size += 1024;
|
|||
|
}
|
|||
|
strcat(rjs->content, content);
|
|||
|
rjs->length += len;
|
|||
|
}
|
|||
|
|
|||
|
void rjson_object_start(rjson_t *rjs) {
|
|||
|
if (rstrendswith(rjs->content, "}"))
|
|||
|
rjson_write(rjs, ",");
|
|||
|
rjson_write(rjs, "{");
|
|||
|
}
|
|||
|
void rjson_object_close(rjson_t *rjs) {
|
|||
|
if (rstrendswith(rjs->content, ",")) {
|
|||
|
rjs->content[rjs->length - 1] = 0;
|
|||
|
rjs->length--;
|
|||
|
}
|
|||
|
rjson_write(rjs, "}");
|
|||
|
}
|
|||
|
void rjson_array_start(rjson_t *rjs) {
|
|||
|
if (rjs->length && (rstrendswith(rjs->content, "}") || rstrendswith(rjs->content, "]")))
|
|||
|
rjson_write(rjs, ",");
|
|||
|
rjson_write(rjs, "[");
|
|||
|
}
|
|||
|
void rjson_array_close(rjson_t *rjs) {
|
|||
|
if (rstrendswith(rjs->content, ",")) {
|
|||
|
rjs->content[rjs->length - 1] = 0;
|
|||
|
rjs->length--;
|
|||
|
}
|
|||
|
rjson_write(rjs, "]");
|
|||
|
}
|
|||
|
|
|||
|
void rjson_kv_string(rjson_t *rjs, char *key, char *value) {
|
|||
|
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
|
|||
|
rjson_write(rjs, ",");
|
|||
|
}
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
rjson_write(rjs, key);
|
|||
|
rjson_write(rjs, "\":\"");
|
|||
|
char *value_str = (char *)rmalloc(strlen(value) + 4096);
|
|||
|
rstraddslashes(value, value_str);
|
|||
|
rjson_write(rjs, value_str);
|
|||
|
free(value_str);
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
}
|
|||
|
|
|||
|
void rjson_kv_int(rjson_t *rjs, char *key, ulonglong value) {
|
|||
|
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
|
|||
|
rjson_write(rjs, ",");
|
|||
|
}
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
rjson_write(rjs, key);
|
|||
|
rjson_write(rjs, "\":");
|
|||
|
char value_str[100] = {0};
|
|||
|
sprintf(value_str, "%lld", value);
|
|||
|
rjson_write(rjs, value_str);
|
|||
|
}
|
|||
|
void rjson_kv_number(rjson_t *rjs, char *key, ulonglong value) {
|
|||
|
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
|
|||
|
rjson_write(rjs, ",");
|
|||
|
}
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
rjson_write(rjs, key);
|
|||
|
rjson_write(rjs, "\":");
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
|
|||
|
rjson_write(rjs, sbuf(rformat_number(value)));
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
}
|
|||
|
|
|||
|
void rjson_kv_bool(rjson_t *rjs, char *key, int value) {
|
|||
|
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
|
|||
|
rjson_write(rjs, ",");
|
|||
|
}
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
rjson_write(rjs, key);
|
|||
|
rjson_write(rjs, "\":");
|
|||
|
rjson_write(rjs, value > 0 ? "true" : "false");
|
|||
|
}
|
|||
|
|
|||
|
void rjson_kv_duration(rjson_t *rjs, char *key, nsecs_t value) {
|
|||
|
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
|
|||
|
rjson_write(rjs, ",");
|
|||
|
}
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
rjson_write(rjs, key);
|
|||
|
rjson_write(rjs, "\":");
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
|
|||
|
rjson_write(rjs, sbuf(format_time(value)));
|
|||
|
rjson_write(rjs, "\"");
|
|||
|
}
|
|||
|
void rjson_free(rjson_t *rsj) {
|
|||
|
free(rsj->content);
|
|||
|
free(rsj);
|
|||
|
}
|
|||
|
|
|||
|
void rjson_key(rjson_t *rsj, char *key) {
|
|||
|
rjson_write(rsj, "\"");
|
|||
|
rjson_write(rsj, key);
|
|||
|
rjson_write(rsj, "\":");
|
|||
|
}
|
|||
|
#endif
|
|||
|
#ifndef RAUTOCOMPLETE_H
|
|||
|
#define RAUTOCOMPLETE_H
|
|||
|
#define R4_DEBUG
|
|||
|
#ifndef RREX4_H
|
|||
|
#define RREX4_H
|
|||
|
#include <assert.h>
|
|||
|
#include <ctype.h>
|
|||
|
#include <stdbool.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <stdlib.h>
|
|||
|
#include <string.h>
|
|||
|
|
|||
|
#define R4_DEBUG_a
|
|||
|
|
|||
|
#ifdef R4_DEBUG
|
|||
|
static int _r4_debug = 1;
|
|||
|
#else
|
|||
|
static int _r4_debug = 0;
|
|||
|
#endif
|
|||
|
|
|||
|
static char *_format_function_name(const char *name) {
|
|||
|
static char result[100];
|
|||
|
result[0] = 0;
|
|||
|
|
|||
|
char *new_name = (char *)name;
|
|||
|
new_name += 11;
|
|||
|
if (new_name[0] == '_')
|
|||
|
new_name += 1;
|
|||
|
if (strlen(new_name) == 0) {
|
|||
|
return " -";
|
|||
|
}
|
|||
|
strcpy(result, new_name);
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
#define DEBUG_VALIDATE_FUNCTION \
|
|||
|
if (_r4_debug || r4->debug) \
|
|||
|
printf("DEBUG: %s %s <%s> \"%s\"\n", _format_function_name(__func__), r4->valid ? "valid" : "INVALID", r4->expr, r4->str);
|
|||
|
|
|||
|
struct r4_t;
|
|||
|
|
|||
|
void r4_enable_debug() { _r4_debug = true; }
|
|||
|
void r4_disable_debug() { _r4_debug = false; }
|
|||
|
|
|||
|
typedef bool (*r4_function)(struct r4_t *);
|
|||
|
|
|||
|
typedef struct r4_t {
|
|||
|
bool debug;
|
|||
|
bool valid;
|
|||
|
bool in_block;
|
|||
|
bool is_greedy;
|
|||
|
bool in_range;
|
|||
|
unsigned int backtracking;
|
|||
|
unsigned int loop_count;
|
|||
|
unsigned int in_group;
|
|||
|
unsigned int match_count;
|
|||
|
unsigned int validation_count;
|
|||
|
unsigned int start;
|
|||
|
unsigned int end;
|
|||
|
unsigned int length;
|
|||
|
bool (*functions[254])(struct r4_t *);
|
|||
|
bool (*slash_functions[254])(struct r4_t *);
|
|||
|
char *_str;
|
|||
|
char *_expr;
|
|||
|
char *match;
|
|||
|
char *str;
|
|||
|
char *expr;
|
|||
|
char *str_previous;
|
|||
|
char *expr_previous;
|
|||
|
char **matches;
|
|||
|
} r4_t;
|
|||
|
|
|||
|
static bool v4_initiated = false;
|
|||
|
typedef bool (*v4_function_map)(r4_t *);
|
|||
|
v4_function_map v4_function_map_global[256];
|
|||
|
v4_function_map v4_function_map_slash[256];
|
|||
|
v4_function_map v4_function_map_block[256];
|
|||
|
|
|||
|
void r4_free_matches(r4_t *r) {
|
|||
|
if (!r)
|
|||
|
return;
|
|||
|
if (r->match) {
|
|||
|
free(r->match);
|
|||
|
r->match = NULL;
|
|||
|
}
|
|||
|
if (!r->match_count) {
|
|||
|
return;
|
|||
|
}
|
|||
|
for (unsigned i = 0; i < r->match_count; i++) {
|
|||
|