From 2bd21ee138d9d72242758f43e5fd8d61a0879bad Mon Sep 17 00:00:00 2001 From: viandoxdev Date: Wed, 31 Aug 2022 18:59:06 +0200 Subject: [PATCH] housekeeping 2 --- client.c | 2 + hid.c | 1 + hid.h | 2 +- json.c | 351 ++++++++++++++++++++++++++++--------------------------- json.h | 19 ++- net.c | 10 +- net.h | 6 +- server.c | 7 +- 8 files changed, 202 insertions(+), 196 deletions(-) diff --git a/client.c b/client.c index 10e6eef..6e79980 100644 --- a/client.c +++ b/client.c @@ -6,12 +6,14 @@ #include #include +#include #include #include #include #include #include #include +#include #include #include #include diff --git a/hid.c b/hid.c index 7819b41..0977c67 100644 --- a/hid.c +++ b/hid.c @@ -4,6 +4,7 @@ #include #include +#include #include #include #include diff --git a/hid.h b/hid.h index 64d1999..fa7b2d3 100644 --- a/hid.h +++ b/hid.h @@ -3,7 +3,7 @@ #define HID_H_ #include "net.h" -#include +#include #include typedef uint64_t uniq_t; diff --git a/json.c b/json.c index f5cc868..0eb65df 100644 --- a/json.c +++ b/json.c @@ -4,21 +4,16 @@ #include #include #include -#include -#include #include #include +#include -static JSONError jerrno = NoError; -static size_t jerr_index = 0; +static JSONError jerrno = NoError; +static size_t jerr_index = 0; -const char * json_strerr() { - return JSONErrorMessage[jerrno]; -} +const char *json_strerr() { return JSONErrorMessage[jerrno]; } -size_t json_err_loc() { - return jerr_index; -} +size_t json_err_loc() { return jerr_index; } // Shorthand to set jerno and return -1; static inline int set_jerrno(JSONError err) { @@ -26,7 +21,7 @@ static inline int set_jerrno(JSONError err) { return -1; } static inline size_t align_8(size_t n) { return (((n - 1) >> 3) + 1) << 3; } -static inline bool is_whitespace(char c) { return c == ' ' || c == '\t' || c == '\n'; } +static inline bool is_whitespace(char c) { return c == ' ' || c == '\t' || c == '\n'; } static int json_parse_value(const char **buf, const char *buf_end, uint8_t **restrict dst, const uint8_t *dst_end); @@ -272,22 +267,24 @@ static int json_parse_boolean(const char **buf, const char *buf_end, uint8_t **r } JSONHeader *header = (JSONHeader *)(*dst); - uint64_t *value = (uint64_t *)((*dst) + sizeof(JSONHeader)); + uint64_t *value = (uint64_t *)((*dst) + sizeof(JSONHeader)); *dst += sizeof(JSONHeader) + 8; header->type = (uint32_t)Boolean; header->len = 8; - if(**buf == 't') { - if(*buf + 4 > buf_end) return set_jerrno(SrcOverflow); - if(strncmp(*buf, "true", 4) != 0) { + if (**buf == 't') { + if (*buf + 4 > buf_end) + return set_jerrno(SrcOverflow); + if (strncmp(*buf, "true", 4) != 0) { return set_jerrno(BadKeyword); } *buf += 4; *value = 1; - } else if(**buf == 'f') { - if(*buf + 5 > buf_end) return set_jerrno(SrcOverflow); - if(strncmp(*buf, "false", 5) != 0) { + } else if (**buf == 'f') { + if (*buf + 5 > buf_end) + return set_jerrno(SrcOverflow); + if (strncmp(*buf, "false", 5) != 0) { return set_jerrno(BadKeyword); } *buf += 5; @@ -300,7 +297,7 @@ static int json_parse_boolean(const char **buf, const char *buf_end, uint8_t **r // *dst must be 8 aligned static int json_parse_null(const char **buf, const char *buf_end, uint8_t **restrict dst, - const uint8_t *dst_end) { + const uint8_t *dst_end) { if (*dst + sizeof(JSONHeader) >= dst_end) { return set_jerrno(DstOverflow); @@ -312,8 +309,9 @@ static int json_parse_null(const char **buf, const char *buf_end, uint8_t **rest header->type = (uint32_t)Null; header->len = 0; - if(*buf + 4 > buf_end) return set_jerrno(SrcOverflow); - if(strncmp(*buf, "null", 4) != 0) { + if (*buf + 4 > buf_end) + return set_jerrno(SrcOverflow); + if (strncmp(*buf, "null", 4) != 0) { return set_jerrno(BadKeyword); } *buf += 4; @@ -322,7 +320,7 @@ static int json_parse_null(const char **buf, const char *buf_end, uint8_t **rest // *dst must be 8 aligned static int json_parse_array(const char **buf, const char *buf_end, uint8_t **restrict dst, - const uint8_t *dst_end) { + const uint8_t *dst_end) { if (*dst + sizeof(JSONHeader) >= dst_end) { return set_jerrno(DstOverflow); @@ -330,25 +328,30 @@ static int json_parse_array(const char **buf, const char *buf_end, uint8_t **res JSONHeader *header = (JSONHeader *)(*dst); *dst += sizeof(JSONHeader); - uint8_t * dst_arr_start = *dst; + uint8_t *dst_arr_start = *dst; header->type = (uint32_t)Array; (*buf)++; // Skip [ // skip initial whitespace - for(; *buf < buf_end && is_whitespace(**buf); (*buf)++); - if(*buf == buf_end) return set_jerrno(SrcOverflow); - if(**buf == ']') { + for (; *buf < buf_end && is_whitespace(**buf); (*buf)++) + ; + if (*buf == buf_end) + return set_jerrno(SrcOverflow); + if (**buf == ']') { header->len = 0; return 0; } - while(1) { - if (json_parse_value(buf, buf_end, dst, dst_end) != 0) return -1; - for(; *buf < buf_end && is_whitespace(**buf); (*buf)++); - if (*buf == buf_end) return set_jerrno(SrcOverflow); - if(**buf == ',') { + while (1) { + if (json_parse_value(buf, buf_end, dst, dst_end) != 0) + return -1; + for (; *buf < buf_end && is_whitespace(**buf); (*buf)++) + ; + if (*buf == buf_end) + return set_jerrno(SrcOverflow); + if (**buf == ',') { (*buf)++; - } else if(**buf == ']') { + } else if (**buf == ']') { (*buf)++; break; } else { @@ -361,7 +364,7 @@ static int json_parse_array(const char **buf, const char *buf_end, uint8_t **res // *dst must be 8 aligned static int json_parse_object(const char **buf, const char *buf_end, uint8_t **restrict dst, - const uint8_t *dst_end) { + const uint8_t *dst_end) { if (*dst + sizeof(JSONHeader) >= dst_end) { return set_jerrno(DstOverflow); @@ -369,41 +372,51 @@ static int json_parse_object(const char **buf, const char *buf_end, uint8_t **re JSONHeader *header = (JSONHeader *)(*dst); *dst += sizeof(JSONHeader); - uint8_t * dst_obj_start = *dst; + uint8_t *dst_obj_start = *dst; header->type = (uint32_t)Object; (*buf)++; // Skip { - for(; *buf < buf_end && is_whitespace(**buf); (*buf)++); - if(*buf == buf_end) return set_jerrno(SrcOverflow); - if(**buf == '}') { + for (; *buf < buf_end && is_whitespace(**buf); (*buf)++) + ; + if (*buf == buf_end) + return set_jerrno(SrcOverflow); + if (**buf == '}') { header->len = 0; return 0; } - while(1) { + while (1) { // Skip whitespace before key - for(; *buf < buf_end && is_whitespace(**buf); (*buf)++); + for (; *buf < buf_end && is_whitespace(**buf); (*buf)++) + ; // Parse key - if (json_parse_string(buf, buf_end, dst, dst_end) != 0) return -1; + if (json_parse_string(buf, buf_end, dst, dst_end) != 0) + return -1; // Skip whitespace after key - for(; *buf < buf_end && is_whitespace(**buf); (*buf)++); + for (; *buf < buf_end && is_whitespace(**buf); (*buf)++) + ; // There should be at least one char - if(*buf == buf_end) return set_jerrno(SrcOverflow); + if (*buf == buf_end) + return set_jerrno(SrcOverflow); // There should be a colon - if(**buf != ':') return set_jerrno(ObjectBadChar); + if (**buf != ':') + return set_jerrno(ObjectBadChar); // Skip colon (*buf)++; // Parse value (takes char of whitespace) - if (json_parse_value(buf, buf_end, dst, dst_end) != 0) return -1; + if (json_parse_value(buf, buf_end, dst, dst_end) != 0) + return -1; // Skip whitespace after value - for(; *buf < buf_end && is_whitespace(**buf); (*buf)++); + for (; *buf < buf_end && is_whitespace(**buf); (*buf)++) + ; // There should be at least one char (} or ,) - if (*buf == buf_end) return set_jerrno(SrcOverflow); - if(**buf == ',') { + if (*buf == buf_end) + return set_jerrno(SrcOverflow); + if (**buf == ',') { (*buf)++; - } else if(**buf == '}') { + } else if (**buf == '}') { (*buf)++; break; } else { @@ -418,7 +431,8 @@ static int json_parse_object(const char **buf, const char *buf_end, uint8_t **re static int json_parse_value(const char **buf, const char *buf_end, uint8_t **restrict dst, const uint8_t *dst_end) { for (; *buf < buf_end; (*buf)++) { - if(is_whitespace(**buf)) continue; + if (is_whitespace(**buf)) + continue; switch (**buf) { case '"': @@ -453,82 +467,76 @@ static int json_parse_value(const char **buf, const char *buf_end, uint8_t **res return 0; } -int json_parse(const char * src, size_t src_len, uint8_t * dst, size_t dst_len) { +int json_parse(const char *src, size_t src_len, uint8_t *dst, size_t dst_len) { memset(dst, 0, dst_len); - const char * buf = src; - const char * buf_end = src + src_len; - uint8_t * dst_end = dst + dst_len; - int rc = json_parse_value(&buf, buf_end, &dst, dst_end); - jerr_index = buf - src; + const char *buf = src; + const char *buf_end = src + src_len; + uint8_t *dst_end = dst + dst_len; + int rc = json_parse_value(&buf, buf_end, &dst, dst_end); + jerr_index = buf - src; return rc; } -void json_print_value(uint8_t ** buf) { - JSONHeader * header = (JSONHeader*) *buf; +void json_print_value(uint8_t **buf) { + JSONHeader *header = (JSONHeader *)*buf; *buf += sizeof(header); - switch(header->type) { - case String: - printf("\"%.*s\"", header->len, *buf); - *buf += align_8(header->len); - break; - case Number: - printf("%lf", *(double *)*buf); - *buf += sizeof(double); - break; - case Boolean: - { - uint64_t value = *(uint64_t*)*buf; - if(value == 1) { - printf("true"); - } else if(value == 0) { - printf("false"); - } else { - printf("(boolean) garbage"); - } - *buf += 8; + switch (header->type) { + case String: + printf("\"%.*s\"", header->len, *buf); + *buf += align_8(header->len); + break; + case Number: + printf("%lf", *(double *)*buf); + *buf += sizeof(double); + break; + case Boolean: { + uint64_t value = *(uint64_t *)*buf; + if (value == 1) { + printf("true"); + } else if (value == 0) { + printf("false"); + } else { + printf("(boolean) garbage"); + } + *buf += 8; + } break; + case Null: + printf("null"); + break; + case Array: { + uint8_t *end = *buf + header->len; + printf("["); + while (1) { + json_print_value(buf); + if (*buf < end) { + printf(", "); + } else { + printf("]"); + break; } - break; - case Null: - printf("null"); - break; - case Array: - { - uint8_t * end = *buf + header->len; - printf("["); - while(1) { - json_print_value(buf); - if(*buf < end) { - printf(", "); - } else { - printf("]"); - break; - } - } + } + } break; + case Object: { + uint8_t *end = *buf + header->len; + printf("{"); + while (1) { + json_print_value(buf); + printf(":"); + json_print_value(buf); + if (*buf < end) { + printf(","); + } else { + printf("}"); + break; } - break; - case Object: - { - uint8_t * end = *buf + header->len; - printf("{"); - while(1) { - json_print_value(buf); - printf(":"); - json_print_value(buf); - if(*buf < end) { - printf(","); - } else { - printf("}"); - break; - } - } - } - break; + } + } break; } } struct Test { double a; - char * b; + char *b; }; const JSONAdapter TestAdapter[] = { @@ -536,79 +544,74 @@ const JSONAdapter TestAdapter[] = { {".b", String, offsetof(struct Test, b)}, }; -static void json_adapt_set(uint8_t * buf, JSONAdapter * adapters, size_t adapter_count, void * ptr, char * path) { - JSONHeader * header = (JSONHeader *)buf; - for(int i = 0; i < adapter_count; i++) { - if(strcmp(path, adapters[i].path) == 0 && header->type == adapters[i].type) { - void * p = ptr + adapters[i].offset; - switch(header->type) { - case String: - { - char * v = malloc(header->len + 1); - strncpy(v, (char *)(buf + sizeof(JSONHeader)), header->len); - v[header->len] = '\0'; - *(char**)p = v; - } - break; - case Number: - *(double*)p = *(double*)(buf + sizeof(JSONHeader)); - break; - case Boolean: - *(bool*)p = *(uint64_t*)(buf + sizeof(JSONHeader)) == 1; - break; +static void json_adapt_set(uint8_t *buf, JSONAdapter *adapters, size_t adapter_count, void *ptr, char *path) { + JSONHeader *header = (JSONHeader *)buf; + for (int i = 0; i < adapter_count; i++) { + if (strcmp(path, adapters[i].path) == 0 && header->type == adapters[i].type) { + void *p = ptr + adapters[i].offset; + switch (header->type) { + case String: { + char *v = malloc(header->len + 1); + strncpy(v, (char *)(buf + sizeof(JSONHeader)), header->len); + v[header->len] = '\0'; + *(char **)p = v; + } break; + case Number: + *(double *)p = *(double *)(buf + sizeof(JSONHeader)); + break; + case Boolean: + *(bool *)p = *(uint64_t *)(buf + sizeof(JSONHeader)) == 1; + break; } } } } -static void json_adapt_priv(uint8_t ** buf, JSONAdapter * adapters, size_t adapter_count, void * ptr, char * full_path, char * path) { - JSONHeader * header = (JSONHeader *)*buf; +static void json_adapt_priv(uint8_t **buf, JSONAdapter *adapters, size_t adapter_count, void *ptr, + char *full_path, char *path) { + JSONHeader *header = (JSONHeader *)*buf; - switch(header->type) { - case String: - json_adapt_set(*buf, adapters, adapter_count, ptr, full_path); - *buf += sizeof(JSONHeader) + align_8(header->len); - break; - case Number: - json_adapt_set(*buf, adapters, adapter_count, ptr, full_path); - *buf += sizeof(JSONHeader) + sizeof(double); - break; - case Boolean: - json_adapt_set(*buf, adapters, adapter_count, ptr, full_path); - *buf += sizeof(JSONHeader) + 8; - break; - case Null: + switch (header->type) { + case String: + json_adapt_set(*buf, adapters, adapter_count, ptr, full_path); + *buf += sizeof(JSONHeader) + align_8(header->len); + break; + case Number: + json_adapt_set(*buf, adapters, adapter_count, ptr, full_path); + *buf += sizeof(JSONHeader) + sizeof(double); + break; + case Boolean: + json_adapt_set(*buf, adapters, adapter_count, ptr, full_path); + *buf += sizeof(JSONHeader) + 8; + break; + case Null: + *buf += sizeof(JSONHeader); + break; + case Array: { + *buf += sizeof(JSONHeader); + uint8_t *end = *buf + header->len; + for (size_t index = 0; *buf < end; index++) { + int len = sprintf(path, ".%lu", index); + json_adapt_priv(buf, adapters, adapter_count, ptr, full_path, path + len); + } + } break; + case Object: { + *buf += sizeof(JSONHeader); + uint8_t *end = *buf + header->len; + while (*buf < end) { + JSONHeader *key_header = (JSONHeader *)*buf; *buf += sizeof(JSONHeader); - break; - case Array: - { - *buf += sizeof(JSONHeader); - uint8_t * end = *buf + header->len; - for(size_t index = 0; *buf < end; index++) { - int len = sprintf(path, ".%lu", index); - json_adapt_priv(buf, adapters, adapter_count, ptr, full_path, path + len); - } - } - break; - case Object: - { - *buf += sizeof(JSONHeader); - uint8_t * end = *buf + header->len; - while(*buf < end) { - JSONHeader * key_header = (JSONHeader*)*buf; - *buf += sizeof(JSONHeader); - int len = sprintf(path, ".%.*s", key_header->len, *buf); - *buf += align_8(key_header->len); + int len = sprintf(path, ".%.*s", key_header->len, *buf); + *buf += align_8(key_header->len); - json_adapt_priv(buf, adapters, adapter_count, ptr, full_path, path + len); - } - } - break; + json_adapt_priv(buf, adapters, adapter_count, ptr, full_path, path + len); + } + } break; } } -void json_adapt(uint8_t * buf, JSONAdapter * adapters, size_t adapter_count, void * ptr) { +void json_adapt(uint8_t *buf, JSONAdapter *adapters, size_t adapter_count, void *ptr) { char path[512] = "."; json_adapt_priv(&buf, adapters, adapter_count, ptr, path, path); } diff --git a/json.h b/json.h index 4db5f16..9feef36 100644 --- a/json.h +++ b/json.h @@ -1,10 +1,9 @@ // vi:ft=c #ifndef JSON_H_ #define JSON_H_ -#include #include -#include #include +#include typedef struct __attribute__((packed, aligned(8))) { uint32_t type; @@ -39,7 +38,7 @@ typedef enum { } JSONError; #ifdef JSON_C_ -static const char * JSONErrorMessage[JERRORNO_MAX + 1] = { +static const char *JSONErrorMessage[JERRORNO_MAX + 1] = { "No error", "Destination buffer is not big enough", "Source buffer overflowed before parsing finished", @@ -50,19 +49,19 @@ static const char * JSONErrorMessage[JERRORNO_MAX + 1] = { "Illegal escape in string", "Unexpected character in number", "Unexpected character in object", - "?" + "?", }; #endif typedef struct { - char * path; + char *path; JSONType type; - size_t offset; + size_t offset; } JSONAdapter; -void json_adapt(uint8_t * buf, JSONAdapter * adapters, size_t adapter_count, void * ptr); -int json_parse(const char * src, size_t src_len, uint8_t * dst, size_t dst_len); -const char * json_strerr(); -size_t json_err_loc(); +void json_adapt(uint8_t *buf, JSONAdapter *adapters, size_t adapter_count, void *ptr); +int json_parse(const char *src, size_t src_len, uint8_t *dst, size_t dst_len); +const char *json_strerr(); +size_t json_err_loc(); #endif diff --git a/net.c b/net.c index fcf6431..01a8dcc 100644 --- a/net.c +++ b/net.c @@ -13,7 +13,7 @@ Message msg_device_info() { // Deserialize the message in buf, buf must be at least 4 aligned. Returns -1 on error, otherwise returns 0 // and writes result to dst -int msg_deserialize(const uint8_t *buf, size_t len, Message * restrict dst) { +int msg_deserialize(const uint8_t *buf, size_t len, Message *restrict dst) { // Decrement len so that it becomes the len of the data without the code. if (len-- < 1) return -1; @@ -118,7 +118,7 @@ int msg_deserialize(const uint8_t *buf, size_t len, Message * restrict dst) { } // Serialize the message msg in buf, buf must be at least 4 aligned. Returns -1 on error (buf not big enough); -int msg_serialize(uint8_t * restrict buf, size_t len, const Message *msg) { +int msg_serialize(uint8_t *restrict buf, size_t len, const Message *msg) { // If len is 0 we can't serialize any message if (len-- == 0) return -1; @@ -134,9 +134,9 @@ int msg_serialize(uint8_t * restrict buf, size_t len, const Message *msg) { return -1; // We begin 4 aligned - buf[0] = (uint8_t)msg->code; + buf[0] = (uint8_t)msg->code; // buf + 2: a byte for code and a byte for padding - buf16 = (uint16_t *)(buf + 2); + buf16 = (uint16_t *)(buf + 2); // 2 aligned here buf16[0] = abs; buf16[1] = rel; @@ -177,7 +177,7 @@ int msg_serialize(uint8_t * restrict buf, size_t len, const Message *msg) { if (len < MSS_DEVICE_REPORT(abs, rel, key)) return -1; - buf[0] = (uint8_t)msg->code; + buf[0] = (uint8_t)msg->code; // buf + 2: a byte for code and a byte for padding buf16 = (uint16_t *)(buf + 2); buf16[0] = abs; diff --git a/net.h b/net.h index bfd01cb..6d22c07 100644 --- a/net.h +++ b/net.h @@ -1,7 +1,7 @@ // vi:ft=c #ifndef NET_H_ #define NET_H_ -#include +#include #include #include @@ -71,7 +71,7 @@ typedef union { MessageControllerState controller_state; } Message; -int msg_deserialize(const uint8_t *buf, size_t len, Message * restrict dst); -int msg_serialize(uint8_t * restrict buf, size_t len, const Message *msg); +int msg_deserialize(const uint8_t *buf, size_t len, Message *restrict dst); +int msg_serialize(uint8_t *restrict buf, size_t len, const Message *msg); #endif diff --git a/server.c b/server.c index 213846c..ad32e80 100644 --- a/server.c +++ b/server.c @@ -2,6 +2,7 @@ #include "net.h" #include "util.h" +#include #include #include #include @@ -40,14 +41,14 @@ void *server_handle_conn(void *args_) { printf("ERR(server_handle_conn): Setting idle retry interval\n"); uint8_t buf[2048] __attribute__((aligned(4))) = {}; - PhysicalDevice dev = get_device(); + PhysicalDevice dev = get_device(); printf("CONN(%u): got device '%s'\n", args->id, dev.name); char *closing_message = ""; int len = msg_serialize(buf, 2048, (Message *)&dev.device_info); - if(len > 0) { - if(write(args->socket, buf, len) == -1) { + if (len > 0) { + if (write(args->socket, buf, len) == -1) { perror("SERVER: Couldn't send device info, "); closing_message = "Socket error"; goto conn_end;