aura.h

#ifndef AURA_H
#define AURA_H

#include <search.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
#include <stdlib.h>
#include <aura/slog.h>
#include <search.h>
#include <errno.h>
#include <stdbool.h>

#include "list.h"
#include "format.h"
#include "endian.h"


enum aura_node_status {
        AURA_STATUS_OFFLINE,
        AURA_STATUS_ONLINE, 
};

enum aura_call_status {
        AURA_CALL_COMPLETED,     
        AURA_CALL_TIMEOUT,       
        AURA_CALL_TRANSPORT_FAIL,
};

enum aura_fd_action {
        AURA_FD_ADDED, 
        AURA_FD_REMOVED
};

struct aura_pollfds {
        int magic;
        struct aura_node *node;
        int fd;
        uint32_t events;
};

struct aura_object;
struct aura_node {
        const struct aura_transport    *tr;
        struct aura_export_table *tbl;
        void                     *transport_data;
        void                     *user_data;
        enum aura_node_status     status;
        struct list_head          outbound_buffers;
        struct list_head          inbound_buffers;

        /* A simple, memory efficient buffer pool */
        struct list_head          buffer_pool;
        int                       num_buffers_in_pool;
        int                       gc_threshold;
        /* Synchronos calls put their stuff here */
        bool sync_call_running;
        bool need_endian_swap;
        bool is_opening;
        struct aura_buffer *sync_ret_buf;
        int sync_call_result;

        /* Synchronous event storage */
        struct list_head          event_buffers;
        int sync_event_max;
        int sync_event_count;

        /* General callbacks */
        void *status_changed_arg;
        void (*status_changed_cb)(struct aura_node *node, int newstatus, void *arg);

        void *etable_changed_arg;
        void (*etable_changed_cb)(struct aura_node *node,
                                  struct aura_export_table *old,
                                  struct aura_export_table *newtbl,
                                  void *arg);

        void *object_migration_failed_arg;
        void (*object_migration_failed_cb)(struct aura_node *node,
                                        struct aura_object *failed,
                                        void *arg);

        void (*unhandled_evt_cb)(struct aura_node *node,
                                 struct aura_buffer *ret,
                                 void *arg);
        void *unhandled_evt_arg;
        void *fd_changed_arg;
        void (*fd_changed_cb)(const struct aura_pollfds *fd,
                              enum aura_fd_action act, void *arg);


        /* Event system and polling */
        int numfds; /* Currently available space for descriptors */
        int nextfd; /* Next descriptor to add */
        struct aura_pollfds *fds; /* descriptor and event array */

        void *eventsys_data; /* eventloop structure */
        unsigned int poll_timeout;
        uint64_t last_checked;
        struct list_head eventloop_node_list;
        const struct aura_object *current_object;
};


struct aura_object {
        int id;
        char *name;
        char *arg_fmt;
        char *ret_fmt;

        int valid;
        char* arg_pprinted;
        char* ret_pprinted;
        int num_args;
        int num_rets;

        int arglen;
        int retlen;

        /* Store callbacks here.
           TODO: Can there be several calls of the same method pending? */
        int pending;
        void (*calldonecb)(struct aura_node *dev, int status, struct aura_buffer *ret, void *arg);
        void *arg;
};

struct aura_eventloop {
        int autocreated;
        int keep_running;
        int poll_timeout;
        struct list_head nodelist;
        void *eventsysdata;
};


#define object_is_event(o)  (o->arg_fmt==NULL)
#define object_is_method(o) (o->arg_fmt!=NULL)

struct aura_export_table {
        int size;
        int next;
        struct aura_node *owner;
        struct hsearch_data index;
        struct aura_object objects[];
};


#define __BIT(n) (1<< n)

struct aura_transport
{
        const char *name;
        uint32_t flags;

        int      buffer_overhead;

        int      buffer_offset;

        int    (*open)(struct aura_node *node, const char *opts);
        void   (*close)(struct aura_node *node);
        void   (*loop)(struct aura_node *node, const struct aura_pollfds *fd);

        void               (*buffer_put)(struct aura_buffer *dst, struct aura_buffer *buf);
        struct aura_buffer *(*buffer_get)(struct aura_buffer *buf);
        struct aura_buffer *(*buffer_request)(struct aura_node *node, int size);
        void                (*buffer_release)(struct aura_buffer *buf);

        int usage;

        struct list_head registry;
};

struct aura_buffer {
        uint32_t magic;
        int                 size;
        int                 pos;
        struct aura_object *object;
        struct aura_node   *owner;
        struct list_head    qentry;
        char                *data;
};

struct aura_buffer *aura_serialize(struct aura_node *node, const char *fmt, int size, va_list ap);
int  aura_fmt_len(struct aura_node *node, const char *fmt);
char* aura_fmt_pretty_print(const char* fmt, int *valid, int *num_args);


const struct aura_transport *aura_transport_lookup(const char *name);
void aura_set_status(struct aura_node *node, int status);


#define AURA_TRANSPORT(s)                                          \
        void __attribute__((constructor (101))) do_reg_##s(void) { \
                aura_transport_register(&s);                       \
        }

enum aura_endianness aura_get_host_endianness();
void aura_hexdump (char *desc, void *addr, int len);
const char *aura_get_version();
unsigned int aura_get_version_code();

void aura_set_node_endian(struct aura_node *node, enum aura_endianness en);

void aura_queue_buffer(struct list_head *list, struct aura_buffer *buf);
struct aura_buffer *aura_dequeue_buffer(struct list_head *head);
void aura_requeue_buffer(struct list_head *head, struct aura_buffer *buf);
struct aura_buffer *aura_peek_buffer(struct list_head *head);

struct aura_export_table *aura_etable_create(struct aura_node *owner, int n);
void aura_etable_add(struct aura_export_table *tbl,
                    const char *name,
                    const char *argfmt,
                     const char *retfmt);
void aura_etable_activate(struct aura_export_table *tbl);

struct aura_object *aura_etable_find(struct aura_export_table *tbl,
                                     const char *name);
struct aura_object *aura_etable_find_id(struct aura_export_table *tbl,
                                        int id);

#define AURA_DECLARE_CACHED_ID(idvar, node, name)\
        static int idvar = -1; \
        if (idvar == -1) {\
                struct aura_object *tmp = aura_etable_find(node->tbl, name); \
                if (!tmp) \
                        BUG(node, "Static lobject lookup failed!"); \
                idvar = tmp->id; \
                }

void aura_etable_destroy(struct aura_export_table *tbl);

struct aura_node *aura_open(const char* name, const char *opts);
void aura_close(struct aura_node *dev);


int aura_queue_call(struct aura_node *node,
                    int id,
                    void (*calldonecb)(struct aura_node *dev, int status, struct aura_buffer *ret, void *arg),
                    void *arg,
                    struct aura_buffer *buf);

int aura_start_call_raw(
        struct aura_node *dev,
        int id,
        void (*calldonecb)(struct aura_node *dev, int status, struct aura_buffer *ret, void *arg),
        void *arg,
        ...);

int aura_start_call(
        struct aura_node *dev,
        const char *name,
        void (*calldonecb)(struct aura_node *dev, int status, struct aura_buffer *ret, void *arg),
        void *arg,
        ...);

int aura_call_raw(
        struct aura_node *dev,
        int id,
        struct aura_buffer **ret,
        ...);

int aura_call(
        struct aura_node *dev,
        const char *name,
        struct aura_buffer **ret,
        ...);

int aura_set_event_callback_raw(
        struct aura_node *node,
        int id,
        void (*calldonecb)(struct aura_node *dev, int status, struct aura_buffer *ret, void *arg),
        void *arg);

int aura_set_event_callback(
        struct aura_node *node,
        const char *event,
        void (*calldonecb)(struct aura_node *dev, int status, struct aura_buffer *ret, void *arg),
        void *arg);

void aura_enable_sync_events(struct aura_node *node, int count);
int aura_get_pending_events(struct aura_node *node);
int aura_get_next_event(struct aura_node *node, const struct aura_object ** obj, struct aura_buffer **retbuf);


void __attribute__((noreturn)) aura_panic(struct aura_node *node);
int BUG(struct aura_node *node, const char *msg, ...);

uint8_t  aura_buffer_get_u8 (struct aura_buffer *buf);

uint16_t aura_buffer_get_u16(struct aura_buffer *buf);

uint32_t aura_buffer_get_u32(struct aura_buffer *buf);

uint64_t aura_buffer_get_u64(struct aura_buffer *buf);

int8_t  aura_buffer_get_s8 (struct aura_buffer *buf);

int16_t aura_buffer_get_s16(struct aura_buffer *buf);

int32_t aura_buffer_get_s32(struct aura_buffer *buf);

int64_t aura_buffer_get_s64(struct aura_buffer *buf);

void  aura_buffer_put_u8 (struct aura_buffer *buf, uint8_t value);

void aura_buffer_put_u16(struct aura_buffer *buf, uint16_t value);

void aura_buffer_put_u32(struct aura_buffer *buf, uint32_t value);

void aura_buffer_put_u64(struct aura_buffer *buf, uint64_t value);

void  aura_buffer_put_s8 (struct aura_buffer *buf, int8_t value);

void aura_buffer_put_s16(struct aura_buffer *buf, int16_t value);

void aura_buffer_put_s32(struct aura_buffer *buf, int32_t value);

void aura_buffer_put_s64(struct aura_buffer *buf, int64_t value);


const void *aura_buffer_get_bin(struct aura_buffer *buf, int len);


void aura_buffer_put_bin(struct aura_buffer *buf, const void *data, int len);


struct aura_buffer *aura_buffer_get_buf(struct aura_buffer *buf);

const void *aura_buffer_get_ptr(struct aura_buffer *buf);

void aura_etable_changed_cb(struct aura_node *node,
                            void (*cb)(struct aura_node *node,
                                       struct aura_export_table *old,
                                       struct aura_export_table *newtbl,
                                       void *arg),
                            void *arg);

void aura_status_changed_cb(struct aura_node *node,
                            void (*cb)(struct aura_node *node, int newstatus, void *arg),
                            void *arg);

void aura_fd_changed_cb(struct aura_node *node,
                         void (*cb)(const struct aura_pollfds *fd, enum aura_fd_action act, void *arg),
                         void *arg);

void aura_unhandled_evt_cb(struct aura_node *node,
                           void (*cb)(struct aura_node *node,
                                      struct aura_buffer *buf,
                                      void *arg),
                           void *arg);

void aura_object_migration_failed_cb(struct aura_node *node,
                                     void (*cb)(struct aura_node *node,
                                                struct aura_object *failed,
                                                void *arg),
                                     void *arg);

const struct aura_object *aura_get_current_object(struct aura_node *node);

void aura_add_pollfds(struct aura_node *node, int fd, uint32_t events);
void aura_del_pollfds(struct aura_node *node, int fd);
int aura_get_pollfds(struct aura_node *node, const struct aura_pollfds **fds);


#define aura_eventloop_create(...) \
        aura_eventloop_create__(0, ##__VA_ARGS__, NULL)


void aura_eventloop_destroy(struct aura_eventloop *loop);
void *aura_eventloop_vcreate(va_list ap);
void *aura_eventloop_create__(int dummy, ...);
void *aura_eventloop_create_empty();
void aura_eventloop_add(struct aura_eventloop *loop, struct aura_node *node);
void aura_eventloop_del(struct aura_node *node);
void aura_eventloop_break(struct aura_eventloop *loop);


void aura_handle_events(struct aura_eventloop *loop);
void aura_handle_events_timeout(struct aura_eventloop *loop, int timeout_ms);
void aura_handle_events_forever(struct aura_eventloop *loop);
void aura_wait_status(struct aura_node *node, int status);

struct aura_buffer *aura_buffer_request(struct aura_node *nd, int size);

void aura_buffer_release(struct aura_buffer *buf);
void aura_buffer_destroy(struct aura_buffer *buf);
void aura_bufferpool_preheat(struct aura_node *nd, int size, int count);

/* event system data access functions */
struct aura_eventloop *aura_eventloop_get_data(struct aura_node *node);


#include <aura/inlines.h>

#define min_t(type, x, y) ({                                    \
                        type __min1 = (x);                      \
                        type __min2 = (y);                      \
                        __min1 < __min2 ? __min1: __min2; })


#define max_t(type, x, y) ({                                    \
                        type __max1 = (x);                      \
                        type __max2 = (y);                      \
                        __max1 > __max2 ? __max1: __max2; })


#endif