dac.h

Go to the documentation of this file.

#ifndef MOBI_DA_DAC_H
#define MOBI_DA_DAC_H

#include <sys/types.h>
#include <pcre.h>
#include <limits.h>
#include <inttypes.h>
#include <stdlib.h>
#include <stdarg.h>

#ifndef __cplusplus
#ifndef true
#define bool _Bool

#define true   1
#define false  0
#endif
#endif

enum da_type {
    DA_TYPE_NONE,
    DA_TYPE_BOOLEAN,
    DA_TYPE_INTEGER,
    DA_TYPE_NUMBER, 
    DA_TYPE_STRING,
    DA_TYPE_ARRAY,
    DA_TYPE_OBJECT,
    DA_TYPE_NULL
};

enum da_status {
    DA_OK,              /* Success. */
    DA_INVALID_JSON,    /* The JSON format is invalid, or the content is unexpected in a given context. */
    DA_OVERFLOW,        /* Overflow occurred. Note this is used to indicate an unfinished string parse in JSON */
    DA_FORMAT_ERROR,    /* The data supplied is formatted incorrectly. */
    DA_NOMEM,           /* There was not enough space to complete the operation */
    DA_SYS,             /* A system error occurred - consult the OS for more details (eg, check errno) */
    DA_NOTIMPL,         /* This method is not implemented */
    DA_NOTFOUND,        /* The requested item was not found. */
    DA_REGEXBAD,        /* An invalid regex was provided. */
    DA_NOMORE,          /* Used to indicate the end of an iterator. */
    DA_INVALID_COOKIE,  /* Cookie value supplied was invalid */
    DA_INVALID_TYPE,    /* A value of an unexpected type was found. */
    DA_INTERNAL_ERROR,
    DA_STATUS_LAST      /* Placeholder to indicate highest possible error value. (value will change as API matures) */
};

enum da_severity {
    DA_SEV_FATAL, /* The operation will not continue, and the operation will return an error. */
    DA_SEV_ERROR, /* An error occurred, but the API call will return at least some valid information */
    DA_SEV_WARN,  /* An unexpected event occured, but the system dealt with it */
    DA_SEV_INFO   /* An informational message. */
};
/* Forward references to tagged types */
struct atlas_image;
struct da_atlas;
struct da_deviceinfo;
struct da_jsonparser;
struct da_node;
struct da_propset;
union da_value;
struct da_evidence;
struct da_bitset;
struct da_allocator;

typedef enum da_severity da_severity_t; /* A severity for the error callback. */
typedef enum da_status da_status_t; /* An error code - returned from most API calls. */
typedef da_status_t (*da_setpos_fn)(void *ctx, off_t off); /* callback provided to API to rewind input stream */
typedef enum da_type da_type_t; /* A value type (integer, string, etc) */

typedef int da_evidence_id_t;

typedef int da_propid_t;
typedef size_t (*da_read_fn)(void *ctx, size_t maxlen, char *ptr);
typedef struct da_atlas da_atlas_t;
typedef struct da_deviceinfo da_deviceinfo_t;
typedef struct da_evidence da_evidence_t;
typedef struct da_jsonparser da_jsonparser_t;
typedef struct da_node da_node_t;
typedef struct da_property_decl da_property_decl_t;
typedef struct da_propset da_propset_t;
typedef void *(*da_alloc_fn)(void *ctx, size_t);
typedef void (*da_free_fn)(void *ctx, void *);
typedef void *(*da_realloc_fn)(void *ctx, void *, size_t);
typedef void (*da_errorfunc_t)(da_severity_t severity, da_status_t status, const char *msg, va_list args);


/* Manifest constants. */
enum {
    /*
     * used as the initial guess for the compiled size of an atlas.
     * If atlas sizes grow more beyond this, it can be expanded to avoid multiple scans of the data.
     */
    DA_INITIAL_MEMORY_ESTIMATE = 1024 * 1024 * 30
};


void da_init();


void da_fini();

void da_seterrorfunc(da_errorfunc_t callback);

da_evidence_id_t da_atlas_header_evidence_id(const da_atlas_t *atlas, const char *header_name);
da_evidence_id_t da_atlas_clientprop_evidence_id(const da_atlas_t *atlas);

da_status_t da_atlas_compile(void *ctx, da_read_fn readfn, da_setpos_fn setposfn, void **ptr, size_t *len);

da_status_t da_atlas_open(da_atlas_t *atlas, da_property_decl_t *extra_props, const void *ptr, size_t pos);

void da_atlas_close(da_atlas_t *atlas);

da_status_t da_searchv(const da_atlas_t *atlas, da_deviceinfo_t *info, da_evidence_t *ev, size_t count);

da_status_t da_search(const da_atlas_t *atlas, da_deviceinfo_t *info, ...);

void da_close(da_deviceinfo_t *info);

da_status_t da_atlas_getpropid(const da_atlas_t *atlas, const char *propname, da_propid_t *propid);

da_status_t da_atlas_getproptype(const da_atlas_t *atlas, da_propid_t propid, da_type_t *type);

da_status_t da_atlas_getpropname(const da_atlas_t *atlas, da_propid_t propid, const char **propname);

da_status_t da_getpropstring(const da_deviceinfo_t *info, da_propid_t propid, const char **value);
da_status_t da_getpropinteger(const da_deviceinfo_t *info, da_propid_t propid, long *value);
da_status_t da_getpropboolean(const da_deviceinfo_t *info, da_propid_t propid, bool *value);
da_status_t da_getpropfloat(const da_deviceinfo_t *info, da_propid_t propid, double *value);

da_status_t da_getproptype(const da_deviceinfo_t *info, da_propid_t propid, da_type_t *type);
da_status_t da_getpropname(const da_deviceinfo_t *info, da_propid_t propid, const char **propname);

da_status_t da_getfirstprop(const da_deviceinfo_t *info, da_propid_t **propid);
da_status_t da_getnextprop(const da_deviceinfo_t *info, da_propid_t **propid);

da_status_t da_reporterror(da_status_t severity, const char *fmt, ...);

const char *da_typename(da_type_t type);

const char *da_atlas_get_property_name(const da_atlas_t *atlas, da_propid_t propid);

size_t da_getpropcount(const da_deviceinfo_t *info);


/*
 * Details below should not be required for usage of the API
 */

struct da_atlas {
    const struct atlas_image *image;
    struct header_evidence_entry *header_priorities;
    size_t header_evidence_count;

    struct pcre_regex_info *uar_regexes;
    size_t uar_regex_count;

    struct pcre_regex_info *replacement_regexes;
    size_t replacement_regex_count;

    da_evidence_id_t user_agent_evidence;
    da_evidence_id_t clientprops_evidence;
    da_evidence_id_t next_evidence;

    da_propset_t *properties;
    da_propid_t id_propid;

    da_deviceinfo_t **cpr_props;
    size_t cpr_count;
};

/* fixed constants. */
enum {
    DA_BUFSIZE = 16000
};

struct da_buf {
    struct da_buf *next;
    char *cur;
    char *limit;
    char buf[DA_BUFSIZE];
};

struct da_allocator {
    da_alloc_fn alloc;
    da_free_fn free;
    da_realloc_fn realloc;
    void *context;
};

struct da_deviceinfo {
    struct da_allocator allocator;
    const da_atlas_t *atlas;   /* reference to the atlas the search was carried out on. */
    struct da_bitset *present; /* property received from tree */
    struct da_bitset *localprop; /* property was received from UAR rule or CPR */
    struct da_bitset *cprprop;  /* property was received from CPR */
    union da_value *properties; /* properties - indexed by property id. */
    da_propid_t *proplist; /* list of properties present in this result. */
    size_t propcount; /* size of proplist */
    da_propset_t *local_types; /* property descriptors local to this search result. */

    struct da_buf *heap;
    struct da_buf initial_heap;
};

struct da_evidence {
    da_evidence_id_t key;
    char *value;
};

struct da_property_decl {
    const char *name;
    da_type_t type;
};


#endif /* DEVATLAS_DAC_H */