TextEncoder *TextEncoder_New(int max_mbchars, int (*fn_encode)(wchar_t, unsigned char *, int)) {
TextEncoder *ter;
ter = (TextEncoder *)MALLOC(sizeof(TextEncoder));
if( ter == NULL ) {
print_perror("malloc");
return NULL;
}
ter->mbchars = NULL;
ter->mb_buff = NULL;
ter->fn_encode = NULL;
ter->mb_buff = DataList_New(4096, sizeof(unsigned char));
if( ter->mb_buff == NULL ) {
TextEncoder_Free(ter);
return NULL;
}
ter->max_mbchars = max_mbchars;
ter->mbchars = (unsigned char *)MALLOC(sizeof(unsigned char) * (max_mbchars + 1));
if( ter->mbchars == NULL ) {
print_perror("malloc");
TextEncoder_Free(ter);
return NULL;
}
ter->fn_encode = fn_encode;
return ter;
}
int state_key_generate(state *s)
{
unsigned char entropy_pool[1024]; /* 160 + 8032 bits */
const int real_random = 20;
const int pseudo_random = sizeof(entropy_pool) - real_random;
const int salt = s->flags & FLAG_SALTED;
/* TODO: It's almost certain that it's better To read whole
* key from dev/random instead of this weird splitting.
*/
/* Gather entropy from random + urandom to speed things up... */
if (crypto_file_rng("/dev/random", NULL,
entropy_pool, real_random) != 0)
{
print_perror(PRINT_ERROR, "Unable to open /dev/random");
return 1;
}
if (crypto_file_rng("/dev/urandom", NULL,
entropy_pool+real_random, pseudo_random) != 0)
{
print_perror(PRINT_ERROR, "Unable to open /dev/random");
return 1;
}
if (salt == 0) {
crypto_sha256(entropy_pool, sizeof(entropy_pool), s->sequence_key);
memset(entropy_pool, 0, sizeof(entropy_pool));
s->counter = num_i(0);
s->latest_card = num_i(0);
s->flags &= ~(FLAG_SALTED);
} else {
unsigned char cnt_bin[32] = {'\0'};
/* Use half of entropy to generate key */
crypto_sha256(entropy_pool, sizeof(entropy_pool)/2, s->sequence_key);
/* And half to initialize counter */
crypto_sha256(entropy_pool + sizeof(entropy_pool)/2, sizeof(entropy_pool)/2, cnt_bin);
num_import(&s->counter, (char *)cnt_bin, NUM_FORMAT_BIN);
s->counter = num_and(s->counter, s->salt_mask);
s->latest_card = num_i(0);
memset(entropy_pool, 0, sizeof(entropy_pool));
memset(cnt_bin, 0, sizeof(cnt_bin));
s->flags |= FLAG_SALTED;
}
s->new_key = 1;
return 0;
}
static bool get_logfile(char ** logfile)
{
char * home;
if (!(home = getenv("HOME")))
return (print_perror(false, "getenv"));
if (!(*logfile = strdupcat(home, LOGFILE)))
return (print_perror(false, "malloc"));
return (true);
}
JsonParser *JsonParser_New(TextEncoding *te) {
JsonParser *jpsr;
jpsr = (JsonParser *)MALLOC(sizeof(JsonParser));
if( jpsr == NULL ) {
print_perror("malloc");
return NULL;
}
jpsr->jsonpull = NULL;
jpsr->node = NULL;
jpsr->stack = NULL;
if( te == NULL ) {
te = TextEncoding_New_UTF8();
jpsr->jsonpull = JsonPull_New(te);
TextEncoding_Free(te);
}
else {
jpsr->jsonpull = JsonPull_New(te);
}
if( jpsr->jsonpull == NULL ) {
JsonParser_Free(jpsr);
return NULL;
}
jpsr->stack = DataList_New(16, sizeof(JsonNode **));
if( jpsr->stack == NULL ) {
JsonParser_Free(jpsr);
return NULL;
}
return jpsr;
}
t_sock tcp_sock_create(void)
{
t_sock sock;
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
print_perror("failed to create socket");
return (-1);
}
return (sock);
}
t_list *list_create()
{
t_list *tmp;
if (!(tmp = malloc(sizeof(t_list))))
print_perror("failed to allocate new list");
tmp->size = 0;
tmp->nodes = NULL;
tmp->last = NULL;
return (tmp);
}
DataListCell *DataListCell_New(int bytes) {
DataListCell *datalistcell;
datalistcell = (DataListCell *)MALLOC(sizeof(DataListCell)+bytes);
if( datalistcell == NULL ) {
print_perror("malloc");
return NULL;
}
datalistcell->body = (char *)datalistcell + sizeof(DataListCell);
datalistcell->prev = NULL;
datalistcell->next = NULL;
return datalistcell;
}
bool init_db0chrono(t_db0chrono * c)
{
int fd;
int r;
c_global = c;
if (!get_logfile(&(c->logfile)))
return (false);
if (!access(c->logfile, F_OK))
{
if ((fd = open(c->logfile, O_RDONLY)) == ERR_OPEN)
return (print_perror(false, "open"));
if ((r = read(fd, c->time.buf, sizeof(int))) == ERR_READ)
return (print_perror(false, "read"));
close(fd);
}
if ((signal(SIGINT, update_signal) == SIG_ERR)
|| (signal(SIGQUIT, update_signal) == SIG_ERR))
return (print_perror(false, "signal"));
return (true);
}
int injectbuf_write(t_injectbuf *buf, int fd)
{
int len;
if ((len = write(fd, &buf->data[buf->head], buf->len)) == -1)
{
print_perror("failed to write buffer");
return (-1);
}
buf->head += len;
buf->len -= len;
return (len);
}
static bool tcp_sock_set_reusable(t_sock *sock, bool reusable)
{
int optVal;
optVal = (reusable ? 1 : 0);
if (setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR,
(void *)&optVal, sizeof(optVal)) == -1)
{
close(*sock);
print_perror("failed to set socket reusability");
return (false);
}
return (true);
}
/*
** These functions are callable in two different ways
** depending on what the first argument is :
** - a pointer to t_sock returned by tcp_sock_create()
** - a pointer to a t_sock set to -1
**
** If the socket received as argument was not a
** pre-created socket then these functions will create one
** before initializing it and storing it in the pointer.
**
** Also, if either of theses functions fail, the socket will
** be closed and no longer valid.
*/
bool tcp_sock_passive_init(t_sock *sock, int port,
int nbClients)
{
struct sockaddr_in sock_addr;
if ((*sock == -1 && (*sock = tcp_sock_create()) == -1)
|| tcp_sock_get_addr(&sock_addr, INADDR_ANY, port) == NULL)
return (false);
if (bind(*sock, (const struct sockaddr *)&sock_addr,
sizeof(sock_addr)) == -1)
{
close(*sock);
return (print_perror("failed to bind socket to address"));
}
if (tcp_sock_set_reusable(sock, true) == false)
return (false);
if (nbClients == 0 || listen(*sock, nbClients) == -1)
{
close(*sock);
return (print_perror("failed to set socket as passive"));
}
return (true);
}
t_egg *egg_create(int id, t_team *team)
{
t_egg *egg;
if (!(egg = malloc(sizeof(t_egg))))
{
print_perror("failed to allocate new egg");
return (NULL);
}
egg->is_hatches = false;
egg->event_handler = &egg_event_handler;
egg->id = id;
egg->team = team;
return (egg);
}
t_graphic *graphic_create(t_client *client)
{
t_graphic *new_graph;
if ((new_graph = malloc(sizeof(*new_graph))) == NULL)
{
print_perror("failed to create new graphic handle");
return (NULL);
}
new_graph->receive = &graphic_receive;
new_graph->destroy = &graphic_destroy;
new_graph->client = client;
list_push_back(&g_server.graphic_manager.graphic_handlers, new_graph);
graphic_connexion(new_graph);
return (new_graph);
}
t_event *event_create(t_event_handler *data, t_pl_func func,
long double timestamp, void *arg)
{
t_event *event;
if ((event = malloc(sizeof(*event))) == NULL)
{
print_perror("failed to allocate new event");
return (NULL);
}
event->data = data;
event->func = func;
event->timestamp = timestamp;
event->arg = (arg ? strdup(arg) : NULL);
return (event);
}
bool tcp_sock_active_init(t_sock *sock, char *host,
int port)
{
struct sockaddr_in sock_addr;
if ((*sock == -1 && (*sock = tcp_sock_create()) == -1)
|| tcp_sock_get_addr(&sock_addr, inet_addr(host), port) == NULL)
return (false);
if (connect(*sock, (const struct sockaddr *)&sock_addr,
sizeof(sock_addr)) == -1)
{
close(*sock);
return (print_perror("socket connection failed"));
}
return (true);
}
static bool check_fd_set(t_sockpool *pool, t_sockpool_node *node,
fd_set *fds, int (*action)(t_sockpool_node *))
{
int rc;
if (FD_ISSET(node->socket, fds))
{
--pool->nbset;
if ((rc = action(node)) <= 0)
{
if (rc == -1)
print_perror("network I/O error");
client_shutdown(node);
return (false);
}
}
return (true);
}
/**
* Constructs New DataList
* @param cell_elements Element count in one cell.
* @param element_bytes Bytes in one element.
* @return New DataList instance. If malloc error occurres, returns NULL.
*/
DataList *DataList_New(int cell_elements, int element_bytes) {
DataList *datalist;
datalist = (DataList *)MALLOC(sizeof(DataList));
if( datalist == NULL ) {
print_perror("malloc");
return NULL;
}
datalist->cell_elements = cell_elements;
datalist->element_bytes = element_bytes;
datalist->length = 0;
datalist->head = DataListCell_New(datalist->cell_elements * datalist->element_bytes);
if( datalist->head == NULL ) {
FREE(datalist);
return NULL;
}
datalist->tail = datalist->head;
datalist->hix = 0;
datalist->tix = 0;
return datalist;
}
bool graphic_bct2(t_graphic *graphic, void *arg1, void *arg2)
{
char *answer;
bool success;
uint x;
uint y;
uint *res;
x = *((uint *)arg1);
y = *((uint *)arg2);
res = g_server.world.cell[(x + (y * gs_get_map_width()))].res;
if (asprintf(&answer, "bct %u %u %u %u %u %u %u %u %u", x, y, res[0],
res[1], res[2], res[3], res[4], res[5], res[6]) == -1)
{
graphic_smg_KO(graphic);
return (print_perror("fail to allocate new graphic message"));
}
success = client_write_to(graphic->client, answer);
free(answer);
return (success);
}
bool graphic_bct(t_graphic *graphic, char *cmd)
{
uint x;
uint y;
bool success;
char *answer;
uint *res;
if (!get_position(cmd, &x, &y))
return (error_type_sbp(graphic, cmd));
if (x >= gs_get_map_width() || y >= gs_get_map_height())
return (error_type_sbp(graphic, cmd));
res = g_server.world.cell[(x + (y * gs_get_map_width()))].res;
if (asprintf(&answer, "bct %u %u %u %u %u %u %u %u %u", x, y, res[0],
res[1], res[2], res[3], res[4], res[5], res[6]) == -1)
{
graphic_smg_KO(graphic);
return (print_perror("fail to allocate new graphic message"));
}
success = client_write_to(graphic->client, answer);
free(answer);
return (success);
}
void *memory_set(void *info)
{
DEBUG_PRINT("notice: memory_set\n");
int val_len = 0;
int val_differs = 1; // if the values are the same
store_entry *entry = NULL;
store_db *db = NULL;
// extract information from our info variable
char *key = ((struct entry_inf *) info)->key;
char *value = ((struct entry_inf *) info)->value;
char *db_name = ((struct entry_inf *) info)->db_name;
store_db **dbs = ((struct entry_inf *) info)->dbs;
int *error = &(((struct entry_inf *) info)->error);
// we shouldn't write while reading/writing
write_lock();
// locate our db and find our entry
db = locate_db(db_name, *dbs);
// create our db if it doesn't exist
if(db == NULL)
{
DEBUG_PRINT("notice: db \"%s\" %p not found, creating...\n", db_name, dbs);
db = create_db(db_name, dbs);
}
// error allocating data while creating the db?
if(db == NULL)
{
perror("create_db");
*error = ERR_ALLOC;
}
// are we unsetting an entry?
else if(value[0] == '\0')
{
// we don't wan't to give any error if entry was not found
delete_entry(key, db);
}
else
{
entry = locate_entry(key, db);
// no value size limit?
if(MAX_VAL_SIZE <= 0)
{
val_len = strlen(value) + 1;
}
// if we have set a value limit, apply it
else
{
val_len = (size_t) min((int) strlen(value) + 1, MAX_VAL_SIZE);
}
// did we find an entry?
if(entry != NULL)
{
if(0 == strncmp(value, entry->val, val_len))
{
DEBUG_PRINT("notice: %s: values are equal\n", db_name);
val_differs = 0;
}
else
{
// if the value has changed, free the previous one
free(entry->val);
entry->val = NULL;
}
}
// if we didn't, create a new one
else
{
entry = create_entry(key, db);
if(entry == NULL)
{
print_perror("create_entry");
*error = ERR_ALLOC;
}
}
if(*error == ERR_NONE)
{
// reserve space for our value as long as it was not the same
if(val_differs)
{
entry->val = (char *) malloc(val_len * sizeof(char));
if(entry->val == NULL)
{
print_perror("malloc");
*error = ERR_ALLOC;
}
else
{
strncpy(entry->val, value, val_len);
entry->val[val_len - 1] = '\0';
}
}
DEBUG_PRINT("notice: \"%s\": setting \"%s\"=\"%s\" (\"%d\"B) DONE\n",
db_name, entry->key, entry->val, val_len);
// save the entry to our info variable (as output)
((struct entry_inf *) info)->entry = entry;
#ifdef __DEBUG__
print_store_tree(dbs);
#endif
}
}
// done!
write_unlock();
DEBUG_PRINT("notice: memory_set returning thread error %d\n", *error);
pthread_exit(NULL);
}
void *memory_get(void *info)
{
DEBUG_PRINT("notice: memory_get\n");
store_entry *ent = NULL;
// extract information from our info variable
char *key = ((struct entry_inf *) info)->key;
char *value = NULL;
char *db_name = ((struct entry_inf *) info)->db_name;
store_db *dbs = *(((struct entry_inf *) info)->dbs);
store_db *db = NULL;
int *error = &(((struct entry_inf *) info)->error);
// we have a limit of max readers at once
read_lock();
DEBUG_PRINT("notice: locating db %s in dbs %p\n", db_name, dbs);
// locate our db and find our entry
if(NULL == (db = locate_db(db_name, dbs)))
{
*error = ERR_DB;
}
else if(NULL == (ent = locate_entry(key, db)))
{
*error = ERR_ENTRY;
}
else if(NULL == (value = (char *) malloc((strlen(ent->val) + 1)
* sizeof(char))))
{
print_perror("malloc");
*error = ERR_ALLOC;
}
else
{
DEBUG_PRINT("notice: getting from db \"%s\" key \"%s\"\n",
db->name, ((store_entry *) ent)->key);
// get the value from the db
// write semaphore not needed because the entry_info is not shared
strcpy(value, ent->val);
DEBUG_PRINT("notice: %s: got \"%s\"=\"%s\"\n", db_name, key, value);
// save the entry and value to our info variable (as output)
((struct entry_inf *) info)->entry = ent;
((struct entry_inf *) info)->value = value;
#ifdef __DEBUG__
print_store_tree(&dbs);
if(ent != NULL)
{
DEBUG_PRINT("\nnotice: %s: got entry %p \"%s\"=\"%s\"\n\n",
db_name, ent, ent->key, ent->val);
}
else
{
DEBUG_PRINT("\nnotice: %s: entry \"%s\" *NOT FOUND* \n\n",
db_name, key);
}
#endif
}
// reading done!
read_unlock();
DEBUG_PRINT("notice: memory_get returning thread error %d\n", *error);
pthread_exit(NULL);
}
