utils.h

Go to the documentation of this file.

 
#ifndef IMQUIC_UTILS_H
#define IMQUIC_UTILS_H
 
#include <glib.h>
#include <jansson.h>
 
#ifndef htonll
#define htonll(x) ((1==htonl(1)) ? (x) : ((guint64)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
#endif
#ifndef ntohll
#define ntohll(x) ((1==ntohl(1)) ? (x) : ((guint64)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))
#endif
 
/* https://stackoverflow.com/a/3208376 */
#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte)  \
        ((byte) & 0x80 ? '1' : '0'), \
        ((byte) & 0x40 ? '1' : '0'), \
        ((byte) & 0x20 ? '1' : '0'), \
        ((byte) & 0x10 ? '1' : '0'), \
        ((byte) & 0x08 ? '1' : '0'), \
        ((byte) & 0x04 ? '1' : '0'), \
        ((byte) & 0x02 ? '1' : '0'), \
        ((byte) & 0x01 ? '1' : '0')


size_t imquic_strlcat(char *dest, const char *src, size_t dest_size);
int imquic_strlcat_fast(char *dest, const char *src, size_t dest_size, size_t *offset);


uint64_t imquic_random_uint64(void);
uint64_t *imquic_dup_uint64(uint64_t num);


uint64_t imquic_read_varint(uint8_t *bytes, size_t blen, uint8_t *length);
uint8_t imquic_write_varint(uint64_t number, uint8_t *bytes, size_t blen);
uint64_t imquic_read_pfxint(uint8_t n, uint8_t *bytes, size_t blen, uint8_t *length);
uint8_t imquic_write_pfxint(uint64_t number, uint8_t n, uint8_t *bytes, size_t blen);

void imquic_print_hex(int level, uint8_t *buf, size_t buflen);

const char *imquic_hex_str(uint8_t *buf, size_t buflen, char *buffer, size_t blen);


typedef struct imquic_data {
        uint8_t *buffer;
        size_t length;
} imquic_data;

imquic_data *imquic_data_create(uint8_t *buffer, size_t length);
gboolean imquic_data_equal(const void *a, const void *b);
void imquic_data_destroy(imquic_data *data);
typedef struct imquic_data_fixed {
        uint8_t buffer[1500];   /* FIXME */
        size_t length;
} imquic_data_fixed;



typedef struct imquic_bitstream {
        uint8_t *buffer;
        size_t size;
        size_t offset;
} imquic_bitstream;

uint8_t imquic_bitstream_peek(imquic_bitstream *bs, uint8_t *len);
size_t imquic_bitstream_write(imquic_bitstream *bs, uint32_t value, uint8_t bits);

#define IMQUIC_JSON_STRING                      JSON_STRING
#define IMQUIC_JSON_INTEGER                     JSON_INTEGER
#define IMQUIC_JSON_OBJECT                      JSON_OBJECT
#define IMQUIC_JSON_ARRAY                       JSON_ARRAY
/* Use IMQUIC_JSON_BOOL instead of the non-existing JSON_BOOLEAN */
#define IMQUIC_JSON_BOOL                        JSON_TRUE
#define IMQUIC_JSON_PARAM_REQUIRED      1
#define IMQUIC_JSON_PARAM_POSITIVE      2
#define IMQUIC_JSON_PARAM_NONEMPTY      4
#define IMQUIC_JSON_MISSING_ELEMENT     404
#define IMQUIC_JSON_INVALID_ELEMENT     400

typedef struct imquic_json_parameter {
        const gchar *name;
        json_type jtype;
        unsigned int flags;
} imquic_json_parameter;

void imquic_get_json_type_name(int jtype, unsigned int flags, char *type_name);

gboolean imquic_json_is_valid(json_t *val, json_type jtype, unsigned int flags);

#define IMQUIC_VALIDATE_JSON_OBJECT_FORMAT(missing_format, invalid_format, obj, params, res) \
        do { \
                res = 0; \
                unsigned int i; \
                for(i = 0; i < sizeof(params) / sizeof(struct imquic_json_parameter); i++) { \
                        json_t *val = json_object_get(obj, params[i].name); \
                        if(!val) { \
                                if((params[i].flags & IMQUIC_JSON_PARAM_REQUIRED) != 0) {       \
                                        res = IMQUIC_JSON_MISSING_ELEMENT; \
                                        IMQUIC_LOG(IMQUIC_LOG_ERR, missing_format "\n", params[i].name); \
                                        break; \
                                } \
                                continue; \
                        } \
                        if(!imquic_json_is_valid(val, params[i].jtype, params[i].flags)) { \
                                res = IMQUIC_JSON_INVALID_ELEMENT; \
                                char type_name[20]; \
                                imquic_get_json_type_name(params[i].jtype, params[i].flags, type_name); \
                                IMQUIC_LOG(IMQUIC_LOG_ERR, invalid_format "\n", params[i].name, type_name); \
                                break; \
                        } \
                } \
        } while(0)

#define IMQUIC_VALIDATE_JSON_OBJECT(obj, params, res) \
        IMQUIC_VALIDATE_JSON_OBJECT_FORMAT("Missing mandatory element (%s)", "Invalid element type (%s should be %s)", obj, params, res)

 
#endif