qev.h

Go to the documentation of this file.

#pragma once

#define GLIB_VERSION_MIN_REQUIRED GLIB_VERSION_2_32

#define GLIB_VERSION_MAX_ALLOWED GLIB_VERSION_2_32

#define _GNU_SOURCE

#include <arpa/inet.h>
#include <errno.h>
#include <glib.h>
#include <glib/gstdio.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <openssl/ssl.h>
#include <stdio.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/times.h>
#include <sys/types.h>
#include <unistd.h>

#define QEV_VERSION_MAJOR 0

#define QEV_VERSION_MINOR 2

#define QEV_VERSION_MICRO 0

#ifndef VERSION_NAME

        #define VERSION_NAME UNKNOWN
#endif

#ifndef VERSION_MAJOR

        #define VERSION_MAJOR 0
#endif

#ifndef VERSION_MINOR

        #define VERSION_MINOR 0
#endif

#ifndef VERSION_MICRO

        #define VERSION_MICRO 0
#endif

#if !defined(__linux__)
        #error quick-event is not able to run on this platform.
#endif

#ifndef QEV_SSL_CIPHERS

        #define QEV_SSL_CIPHERS "HIGH:!aNULL:!MD5:"
#endif

#ifndef QEV_CLIENT

        #define QEV_CLIENT qev_client
#endif

struct QEV_CLIENT;

#define QEV_MS_TO_USEC(ms) (ms * 1000)

#define QEV_MS_TO_NSEC(ms) (QEV_MS_TO_USEC(ms) * 1000)

#define QEV_SEC_TO_USEC(secs) QEV_MS_TO_USEC(secs * 1000)

#define QEV_YIELD_AFTER 1024

#define QEV_WAIT_FOR(cond) { \
        register guint spins = 0; \
        while (!(cond)) { \
                if (++spins > QEV_YIELD_AFTER) { \
                        g_thread_yield(); \
                } \
        }}

typedef int qev_fd_t;

typedef struct qev_timeout qev_timeout_t;

typedef void (*qev_cb)();

typedef void (*qev_free_fn)(void*);

typedef qev_free_fn qev_data_cb;

struct qev_flags {
        gboolean listening:1;

        gboolean udp:1;

        gboolean timer:1;

        gboolean ssl:1;

        gboolean ssl_handshaking:1;

        gboolean opened:1;

        gboolean closing:1;

        gboolean closed:1;

        gboolean surrogate:1;
};

struct qev_client {
        GString *rbuff;

        GString *_wbuff;

        union {
                SSL *ssl;

                SSL_CTX *ssl_ctx;

                qev_cb timer_fn;
        } _type;

        qev_timeout_t *_ssl_handshake_timeout;

        void *_locking_thread;

        guint _lock;

        qev_fd_t _fd;

        gint32 _clients_slot;

        guint _refs;

        gint _read_operations;

        struct qev_flags _flags;

        gchar ip[INET6_ADDRSTRLEN];
};

typedef void (*qev_client_cb)(struct QEV_CLIENT *client, void *data);

enum qev_close_reasons {
        QEV_CLOSE_HUP,

        QEV_CLOSE_READ_FAIL,

        QEV_CLOSE_TIMEOUT,

        QEV_CLOSE_OS_ERROR,

        QEV_CLOSE_OUT_OF_MEM,

        QEV_CLOSE_EXITING,

        QEV_CLOSE_LEN,
};

gint64 qev_time;

gint64 qev_monotonic;

void qev_init(const gchar *app_name, gchar **argv, gint argc);

void qev_run();

void qev_kill();

void qev_wait_for_exit();

void qev_exit();

void qev_listen(const gchar *ip_address, const guint16 port);

void qev_listen_ssl(
        const gchar *ip_address,
        const guint16 port,
        const gchar *cert_path0,
        const gchar *key_path0,
        const gchar *cert_path1,
        const gchar *key_path1);

void qev_listen_unix(const gchar *path);

void qev_listen_udp(const gchar *ip_address, const guint16 port);

void qev_chuser(const char *username);

void qev_setnofile(const gint nofile);

void qev_timer(
        const qev_cb fn,
        const guint seconds,
        const guint ms);

const gchar* qev_get_hostname();

struct QEV_CLIENT* qev_surrogate_new();

GString* qev_surrogate_flush(struct QEV_CLIENT *surrogate);

void qev_write(struct QEV_CLIENT *client, const gchar *buff, const gsize len);

void qev_writef(struct QEV_CLIENT *client, const gchar *format, ...)
                                G_GNUC_PRINTF(2, 3);

void qev_close(struct QEV_CLIENT *client, guint reason);

gboolean qev_is_surrogate(struct QEV_CLIENT *client);

gboolean qev_is_closing(struct QEV_CLIENT *client);

void qev_foreach(qev_client_cb cb, gint threads, void *data);

struct QEV_CLIENT* qev_ref(struct QEV_CLIENT *client);

void qev_unref(struct QEV_CLIENT *client);

void qev_unref0(struct QEV_CLIENT **client);

void qev_unref_as_free(void *client_);

void qev_lock(struct QEV_CLIENT *client);

void qev_unlock(struct QEV_CLIENT *client);

void qev_timeout(struct QEV_CLIENT *client, qev_timeout_t **timeout);

void qev_timeout_clear(qev_timeout_t **timeout);

void qev_chuser(const gchar *username);

void qev_on_before_run();

void qev_on_open(struct QEV_CLIENT *client);

void qev_on_close(struct QEV_CLIENT *client, guint reason);

void qev_on_read(struct QEV_CLIENT *client);

void qev_on_udp(const gchar *msg, const gsize len, const gchar *ip);

void qev_on_tick();

void qev_on_exit();

struct QEV_CLIENT* qev_client_new();

void qev_client_free(struct QEV_CLIENT *client);

#include "bench.h"
#include "buffer.h"
#include "cleanup.h"
#include "config.h"
#include "fair.h"
#include "http.h"
#include "job.h"
#include "json.h"
#include "latch.h"
#include "list.h"
#include "lock.h"
#include "log.h"
#include "mock.h"
#include "pool.h"
#include "queue.h"
#include "rsock.h"
#include "safe.h"
#include "stats.h"
#include "strfuncs.h"