diff options
| author | luwenpeng <[email protected]> | 2022-07-27 18:32:22 +0800 |
|---|---|---|
| committer | luwenpeng <[email protected]> | 2022-08-02 18:50:17 +0800 |
| commit | 50111e7cd09ff83ecbd53017d0edf6d33b84a801 (patch) | |
| tree | 5dda7ae697f246f811b4acacbd340c68dc07af71 | |
| parent | 649d29e53887dc122a828d13696d356310ae86d7 (diff) | |
Plugin Management support C plugin
35 files changed, 4214 insertions, 187 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 29429de..fdb093f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,6 +17,7 @@ include_directories(${CMAKE_SOURCE_DIR}/sdk/include) #add vendor and source directory add_subdirectory(vendor) +add_subdirectory(deps/toml) add_subdirectory(src) add_subdirectory(sdk/example) diff --git a/deps/toml/CMakeLists.txt b/deps/toml/CMakeLists.txt new file mode 100644 index 0000000..504c0bf --- /dev/null +++ b/deps/toml/CMakeLists.txt @@ -0,0 +1,3 @@ +set(CMAKE_C_FLAGS "-std=c99") +add_definitions(-fPIC) +add_library(toml STATIC toml.c)
\ No newline at end of file diff --git a/deps/toml/toml.c b/deps/toml/toml.c new file mode 100644 index 0000000..fafe0da --- /dev/null +++ b/deps/toml/toml.c @@ -0,0 +1,2379 @@ +/* + + MIT License + + Copyright (c) CK Tan + https://github.com/cktan/tomlc99 + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + +*/ +#define _POSIX_C_SOURCE 200809L +#include "toml.h" +#include <assert.h> +#include <ctype.h> +#include <errno.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static void *(*ppmalloc)(size_t) = malloc; +static void (*ppfree)(void *) = free; + +void toml_set_memutil(void *(*xxmalloc)(size_t), void (*xxfree)(void *)) { + if (xxmalloc) + ppmalloc = xxmalloc; + if (xxfree) + ppfree = xxfree; +} + +#define MALLOC(a) ppmalloc(a) +#define FREE(a) ppfree(a) + +#define malloc(x) error - forbidden - use MALLOC instead +#define free(x) error - forbidden - use FREE instead +#define calloc(x, y) error - forbidden - use CALLOC instead + +static void *CALLOC(size_t nmemb, size_t sz) { + int nb = sz * nmemb; + void *p = MALLOC(nb); + if (p) { + memset(p, 0, nb); + } + return p; +} + +// some old platforms define strdup macro -- drop it. +#undef strdup +#define strdup(x) error - forbidden - use STRDUP instead + +static char *STRDUP(const char *s) { + int len = strlen(s); + char *p = MALLOC(len + 1); + if (p) { + memcpy(p, s, len); + p[len] = 0; + } + return p; +} + +// some old platforms define strndup macro -- drop it. +#undef strndup +#define strndup(x) error - forbiden - use STRNDUP instead + +static char *STRNDUP(const char *s, size_t n) { + size_t len = strnlen(s, n); + char *p = MALLOC(len + 1); + if (p) { + memcpy(p, s, len); + p[len] = 0; + } + return p; +} + +/** + * Convert a char in utf8 into UCS, and store it in *ret. + * Return #bytes consumed or -1 on failure. + */ +int toml_utf8_to_ucs(const char *orig, int len, int64_t *ret) { + const unsigned char *buf = (const unsigned char *)orig; + unsigned i = *buf++; + int64_t v; + + /* 0x00000000 - 0x0000007F: + 0xxxxxxx + */ + if (0 == (i >> 7)) { + if (len < 1) + return -1; + v = i; + return *ret = v, 1; + } + /* 0x00000080 - 0x000007FF: + 110xxxxx 10xxxxxx + */ + if (0x6 == (i >> 5)) { + if (len < 2) + return -1; + v = i & 0x1f; + for (int j = 0; j < 1; j++) { + i = *buf++; + if (0x2 != (i >> 6)) + return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char *)buf - orig; + } + + /* 0x00000800 - 0x0000FFFF: + 1110xxxx 10xxxxxx 10xxxxxx + */ + if (0xE == (i >> 4)) { + if (len < 3) + return -1; + v = i & 0x0F; + for (int j = 0; j < 2; j++) { + i = *buf++; + if (0x2 != (i >> 6)) + return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char *)buf - orig; + } + + /* 0x00010000 - 0x001FFFFF: + 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (0x1E == (i >> 3)) { + if (len < 4) + return -1; + v = i & 0x07; + for (int j = 0; j < 3; j++) { + i = *buf++; + if (0x2 != (i >> 6)) + return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char *)buf - orig; + } + + /* 0x00200000 - 0x03FFFFFF: + 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (0x3E == (i >> 2)) { + if (len < 5) + return -1; + v = i & 0x03; + for (int j = 0; j < 4; j++) { + i = *buf++; + if (0x2 != (i >> 6)) + return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char *)buf - orig; + } + + /* 0x04000000 - 0x7FFFFFFF: + 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (0x7e == (i >> 1)) { + if (len < 6) + return -1; + v = i & 0x01; + for (int j = 0; j < 5; j++) { + i = *buf++; + if (0x2 != (i >> 6)) + return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char *)buf - orig; + } + return -1; +} + +/** + * Convert a UCS char to utf8 code, and return it in buf. + * Return #bytes used in buf to encode the char, or + * -1 on error. + */ +int toml_ucs_to_utf8(int64_t code, char buf[6]) { + /* http://stackoverflow.com/questions/6240055/manually-converting-unicode-codepoints-into-utf-8-and-utf-16 + */ + /* The UCS code values 0xd800–0xdfff (UTF-16 surrogates) as well + * as 0xfffe and 0xffff (UCS noncharacters) should not appear in + * conforming UTF-8 streams. + */ + if (0xd800 <= code && code <= 0xdfff) + return -1; + if (0xfffe <= code && code <= 0xffff) + return -1; + + /* 0x00000000 - 0x0000007F: + 0xxxxxxx + */ + if (code < 0) + return -1; + if (code <= 0x7F) { + buf[0] = (unsigned char)code; + return 1; + } + + /* 0x00000080 - 0x000007FF: + 110xxxxx 10xxxxxx + */ + if (code <= 0x000007FF) { + buf[0] = (unsigned char) (0xc0 | (code >> 6)); + buf[1] = (unsigned char) (0x80 | (code & 0x3f)); + return 2; + } + + /* 0x00000800 - 0x0000FFFF: + 1110xxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x0000FFFF) { + buf[0] = (unsigned char) (0xe0 | (code >> 12)); + buf[1] = (unsigned char) (0x80 | ((code >> 6) & 0x3f)); + buf[2] = (unsigned char) (0x80 | (code & 0x3f)); + return 3; + } + + /* 0x00010000 - 0x001FFFFF: + 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x001FFFFF) { + buf[0] = (unsigned char) (0xf0 | (code >> 18)); + buf[1] = (unsigned char) (0x80 | ((code >> 12) & 0x3f)); + buf[2] = (unsigned char) (0x80 | ((code >> 6) & 0x3f)); + buf[3] = (unsigned char) (0x80 | (code & 0x3f)); + return 4; + } + + /* 0x00200000 - 0x03FFFFFF: + 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x03FFFFFF) { + buf[0] = (unsigned char) (0xf8 | (code >> 24)); + buf[1] = (unsigned char) (0x80 | ((code >> 18) & 0x3f)); + buf[2] = (unsigned char) (0x80 | ((code >> 12) & 0x3f)); + buf[3] = (unsigned char) (0x80 | ((code >> 6) & 0x3f)); + buf[4] = (unsigned char) (0x80 | (code & 0x3f)); + return 5; + } + + /* 0x04000000 - 0x7FFFFFFF: + 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x7FFFFFFF) { + buf[0] = (unsigned char) (0xfc | (code >> 30)); + buf[1] = (unsigned char) (0x80 | ((code >> 24) & 0x3f)); + buf[2] = (unsigned char) (0x80 | ((code >> 18) & 0x3f)); + buf[3] = (unsigned char) (0x80 | ((code >> 12) & 0x3f)); + buf[4] = (unsigned char) (0x80 | ((code >> 6) & 0x3f)); + buf[5] = (unsigned char) (0x80 | (code & 0x3f)); + return 6; + } + + return -1; +} + +/* + * TOML has 3 data structures: value, array, table. + * Each of them can have identification key. + */ +typedef struct toml_keyval_t toml_keyval_t; +struct toml_keyval_t { + const char *key; /* key to this value */ + const char *val; /* the raw value */ +}; + +typedef struct toml_arritem_t toml_arritem_t; +struct toml_arritem_t { + int valtype; /* for value kind: 'i'nt, 'd'ouble, 'b'ool, 's'tring, 't'ime, + 'D'ate, 'T'imestamp */ + char *val; + toml_array_t *arr; + toml_table_t *tab; +}; + +struct toml_array_t { + const char *key; /* key to this array */ + int kind; /* element kind: 'v'alue, 'a'rray, or 't'able, 'm'ixed */ + int type; /* for value kind: 'i'nt, 'd'ouble, 'b'ool, 's'tring, 't'ime, + 'D'ate, 'T'imestamp, 'm'ixed */ + + int nitem; /* number of elements */ + toml_arritem_t *item; +}; + +struct toml_table_t { + const char *key; /* key to this table */ + bool implicit; /* table was created implicitly */ + bool readonly; /* no more modification allowed */ + + /* key-values in the table */ + int nkval; + toml_keyval_t **kval; + + /* arrays in the table */ + int narr; + toml_array_t **arr; + + /* tables in the table */ + int ntab; + toml_table_t **tab; +}; + +static inline void xfree(const void *x) { + if (x) + FREE((void *)(intptr_t)x); +} + +enum tokentype_t { + INVALID, + DOT, + COMMA, + EQUAL, + LBRACE, + RBRACE, + NEWLINE, + LBRACKET, + RBRACKET, + STRING, +}; +typedef enum tokentype_t tokentype_t; + +typedef struct token_t token_t; +struct token_t { + tokentype_t tok; + int lineno; + char *ptr; /* points into context->start */ + int len; + int eof; +}; + +typedef struct context_t context_t; +struct context_t { + char *start; + char *stop; + char *errbuf; + int errbufsz; + + token_t tok; + toml_table_t *root; + toml_table_t *curtab; + + struct { + int top; + char *key[10]; + token_t tok[10]; + } tpath; +}; + +#define STRINGIFY(x) #x +#define TOSTRING(x) STRINGIFY(x) +#define FLINE __FILE__ ":" TOSTRING(__LINE__) + +static int next_token(context_t *ctx, int dotisspecial); + +/* + Error reporting. Call when an error is detected. Always return -1. +*/ +static int e_outofmemory(context_t *ctx, const char *fline) { + snprintf(ctx->errbuf, ctx->errbufsz, "ERROR: out of memory (%s)", fline); + return -1; +} + +static int e_internal(context_t *ctx, const char *fline) { + snprintf(ctx->errbuf, ctx->errbufsz, "internal error (%s)", fline); + return -1; +} + +static int e_syntax(context_t *ctx, int lineno, const char *msg) { + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: %s", lineno, msg); + return -1; +} + +static int e_badkey(context_t *ctx, int lineno) { + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: bad key", lineno); + return -1; +} + +static int e_keyexists(context_t *ctx, int lineno) { + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: key exists", lineno); + return -1; +} + +static int e_forbid(context_t *ctx, int lineno, const char *msg) { + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: %s", lineno, msg); + return -1; +} + +static void *expand(void *p, int sz, int newsz) { + void *s = MALLOC(newsz); + if (!s) + return 0; + + memcpy(s, p, sz); + FREE(p); + return s; +} + +static void **expand_ptrarr(void **p, int n) { + void **s = MALLOC((n + 1) * sizeof(void *)); + if (!s) + return 0; + + s[n] = 0; + memcpy(s, p, n * sizeof(void *)); + FREE(p); + return s; +} + +static toml_arritem_t *expand_arritem(toml_arritem_t *p, int n) { + toml_arritem_t *pp = expand(p, n * sizeof(*p), (n + 1) * sizeof(*p)); + if (!pp) + return 0; + + memset(&pp[n], 0, sizeof(pp[n])); + return pp; +} + +static char *norm_lit_str(const char *src, int srclen, int multiline, + char *errbuf, int errbufsz) { + char *dst = 0; /* will write to dst[] and return it */ + int max = 0; /* max size of dst[] */ + int off = 0; /* cur offset in dst[] */ + const char *sp = src; + const char *sq = src + srclen; + int ch; + + /* scan forward on src */ + for (;;) { + if (off >= max - 10) { /* have some slack for misc stuff */ + int newmax = max + 50; + char *x = expand(dst, max, newmax); + if (!x) { + xfree(dst); + snprintf(errbuf, errbufsz, "out of memory"); + return 0; + } + dst = x; + max = newmax; + } + + /* finished? */ + if (sp >= sq) + break; + + ch = *sp++; + /* control characters other than tab is not allowed */ + if ((0 <= ch && ch <= 0x08) || (0x0a <= ch && ch <= 0x1f) || (ch == 0x7f)) { + if (!(multiline && (ch == '\r' || ch == '\n'))) { + xfree(dst); + snprintf(errbuf, errbufsz, "invalid char U+%04x", ch); + return 0; + } + } + + // a plain copy suffice + dst[off++] = ch; + } + + dst[off++] = 0; + return dst; +} + +/* + * Convert src to raw unescaped utf-8 string. + * Returns NULL if error with errmsg in errbuf. + */ +static char *norm_basic_str(const char *src, int srclen, int multiline, + char *errbuf, int errbufsz) { + char *dst = 0; /* will write to dst[] and return it */ + int max = 0; /* max size of dst[] */ + int off = 0; /* cur offset in dst[] */ + const char *sp = src; + const char *sq = src + srclen; + int ch; + + /* scan forward on src */ + for (;;) { + if (off >= max - 10) { /* have some slack for misc stuff */ + int newmax = max + 50; + char *x = expand(dst, max, newmax); + if (!x) { + xfree(dst); + snprintf(errbuf, errbufsz, "out of memory"); + return 0; + } + dst = x; + max = newmax; + } + + /* finished? */ + if (sp >= sq) + break; + + ch = *sp++; + if (ch != '\\') { + /* these chars must be escaped: U+0000 to U+0008, U+000A to U+001F, U+007F + */ + if ((0 <= ch && ch <= 0x08) || (0x0a <= ch && ch <= 0x1f) || + (ch == 0x7f)) { + if (!(multiline && (ch == '\r' || ch == '\n'))) { + xfree(dst); + snprintf(errbuf, errbufsz, "invalid char U+%04x", ch); + return 0; + } + } + + // a plain copy suffice + dst[off++] = ch; + continue; + } + + /* ch was backslash. we expect the escape char. */ + if (sp >= sq) { + snprintf(errbuf, errbufsz, "last backslash is invalid"); + xfree(dst); + return 0; + } + + /* for multi-line, we want to kill line-ending-backslash ... */ + if (multiline) { + + // if there is only whitespace after the backslash ... + if (sp[strspn(sp, " \t\r")] == '\n') { + /* skip all the following whitespaces */ + sp += strspn(sp, " \t\r\n"); + continue; + } + } + + /* get the escaped char */ + ch = *sp++; + switch (ch) { + case 'u': + case 'U': { + int64_t ucs = 0; + int nhex = (ch == 'u' ? 4 : 8); + for (int i = 0; i < nhex; i++) { + if (sp >= sq) { + snprintf(errbuf, errbufsz, "\\%c expects %d hex chars", ch, nhex); + xfree(dst); + return 0; + } + ch = *sp++; + int v = ('0' <= ch && ch <= '9') + ? ch - '0' + : (('A' <= ch && ch <= 'F') ? ch - 'A' + 10 : -1); + if (-1 == v) { + snprintf(errbuf, errbufsz, "invalid hex chars for \\u or \\U"); + xfree(dst); + return 0; + } + ucs = ucs * 16 + v; + } + int n = toml_ucs_to_utf8(ucs, &dst[off]); + if (-1 == n) { + snprintf(errbuf, errbufsz, "illegal ucs code in \\u or \\U"); + xfree(dst); + return 0; + } + off += n; + } + continue; + + case 'b': + ch = '\b'; + break; + case 't': + ch = '\t'; + break; + case 'n': + ch = '\n'; + break; + case 'f': + ch = '\f'; + break; + case 'r': + ch = '\r'; + break; + case '"': + ch = '"'; + break; + case '\\': + ch = '\\'; + break; + default: + snprintf(errbuf, errbufsz, "illegal escape char \\%c", ch); + xfree(dst); + return 0; + } + + dst[off++] = ch; + } + + // Cap with NUL and return it. + dst[off++] = 0; + return dst; +} + +/* Normalize a key. Convert all special chars to raw unescaped utf-8 chars. */ +static char *normalize_key(context_t *ctx, token_t strtok) { + const char *sp = strtok.ptr; + const char *sq = strtok.ptr + strtok.len; + int lineno = strtok.lineno; + char *ret; + int ch = *sp; + char ebuf[80]; + + /* handle quoted string */ + if (ch == '\'' || ch == '\"') { + /* if ''' or """, take 3 chars off front and back. Else, take 1 char off. */ + int multiline = 0; + if (sp[1] == ch && sp[2] == ch) { + sp += 3, sq -= 3; + multiline = 1; + } else + sp++, sq--; + + if (ch == '\'') { + /* for single quote, take it verbatim. */ + if (!(ret = STRNDUP(sp, sq - sp))) { + e_outofmemory(ctx, FLINE); + return 0; + } + } else { + /* for double quote, we need to normalize */ + ret = norm_basic_str(sp, sq - sp, multiline, ebuf, sizeof(ebuf)); + if (!ret) { + e_syntax(ctx, lineno, ebuf); + return 0; + } + } + + /* newlines are not allowed in keys */ + if (strchr(ret, '\n')) { + xfree(ret); + e_badkey(ctx, lineno); + return 0; + } + return ret; + } + + /* for bare-key allow only this regex: [A-Za-z0-9_-]+ */ + const char *xp; + for (xp = sp; xp != sq; xp++) { + int k = *xp; + if (isalnum(k)) + continue; + if (k == '_' || k == '-') + continue; + e_badkey(ctx, lineno); + return 0; + } + + /* dup and return it */ + if (!(ret = STRNDUP(sp, sq - sp))) { + e_outofmemory(ctx, FLINE); + return 0; + } + return ret; +} + +/* + * Look up key in tab. Return 0 if not found, or + * 'v'alue, 'a'rray or 't'able depending on the element. + */ +static int check_key(toml_table_t *tab, const char *key, + toml_keyval_t **ret_val, toml_array_t **ret_arr, + toml_table_t **ret_tab) { + int i; + void *dummy; + + if (!ret_tab) + ret_tab = (toml_table_t **)&dummy; + if (!ret_arr) + ret_arr = (toml_array_t **)&dummy; + if (!ret_val) + ret_val = (toml_keyval_t **)&dummy; + + *ret_tab = 0; + *ret_arr = 0; + *ret_val = 0; + + for (i = 0; i < tab->nkval; i++) { + if (0 == strcmp(key, tab->kval[i]->key)) { + *ret_val = tab->kval[i]; + return 'v'; + } + } + for (i = 0; i < tab->narr; i++) { + if (0 == strcmp(key, tab->arr[i]->key)) { + *ret_arr = tab->arr[i]; + return 'a'; + } + } + for (i = 0; i < tab->ntab; i++) { + if (0 == strcmp(key, tab->tab[i]->key)) { + *ret_tab = tab->tab[i]; + return 't'; + } + } + return 0; +} + +static int key_kind(toml_table_t *tab, const char *key) { + return check_key(tab, key, 0, 0, 0); +} + +/* Create a keyval in the table. + */ +static toml_keyval_t *create_keyval_in_table(context_t *ctx, toml_table_t *tab, + token_t keytok) { + /* first, normalize the key to be used for lookup. + * remember to free it if we error out. + */ + char *newkey = normalize_key(ctx, keytok); + if (!newkey) + return 0; + + /* if key exists: error out. */ + toml_keyval_t *dest = 0; + if (key_kind(tab, newkey)) { + xfree(newkey); + e_keyexists(ctx, keytok.lineno); + return 0; + } + + /* make a new entry */ + int n = tab->nkval; + toml_keyval_t **base; + if (0 == (base = (toml_keyval_t **)expand_ptrarr((void **)tab->kval, n))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + tab->kval = base; + + if (0 == (base[n] = (toml_keyval_t *)CALLOC(1, sizeof(*base[n])))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + dest = tab->kval[tab->nkval++]; + + /* save the key in the new value struct */ + dest->key = newkey; + return dest; +} + +/* Create a table in the table. + */ +static toml_table_t *create_keytable_in_table(context_t *ctx, toml_table_t *tab, + token_t keytok) { + /* first, normalize the key to be used for lookup. + * remember to free it if we error out. + */ + char *newkey = normalize_key(ctx, keytok); + if (!newkey) + return 0; + + /* if key exists: error out */ + toml_table_t *dest = 0; + if (check_key(tab, newkey, 0, 0, &dest)) { + xfree(newkey); /* don't need this anymore */ + + /* special case: if table exists, but was created implicitly ... */ + if (dest && dest->implicit) { + /* we make it explicit now, and simply return it. */ + dest->implicit = false; + return dest; + } + e_keyexists(ctx, keytok.lineno); + return 0; + } + + /* create a new table entry */ + int n = tab->ntab; + toml_table_t **base; + if (0 == (base = (toml_table_t **)expand_ptrarr((void **)tab->tab, n))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + tab->tab = base; + + if (0 == (base[n] = (toml_table_t *)CALLOC(1, sizeof(*base[n])))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + dest = tab->tab[tab->ntab++]; + + /* save the key in the new table struct */ + dest->key = newkey; + return dest; +} + +/* Create an array in the table. + */ +static toml_array_t *create_keyarray_in_table(context_t *ctx, toml_table_t *tab, + token_t keytok, char kind) { + /* first, normalize the key to be used for lookup. + * remember to free it if we error out. + */ + char *newkey = normalize_key(ctx, keytok); + if (!newkey) + return 0; + + /* if key exists: error out */ + if (key_kind(tab, newkey)) { + xfree(newkey); /* don't need this anymore */ + e_keyexists(ctx, keytok.lineno); + return 0; + } + + /* make a new array entry */ + int n = tab->narr; + toml_array_t **base; + if (0 == (base = (toml_array_t **)expand_ptrarr((void **)tab->arr, n))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + tab->arr = base; + + if (0 == (base[n] = (toml_array_t *)CALLOC(1, sizeof(*base[n])))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + toml_array_t *dest = tab->arr[tab->narr++]; + + /* save the key in the new array struct */ + dest->key = newkey; + dest->kind = kind; + return dest; +} + +static toml_arritem_t *create_value_in_array(context_t *ctx, + toml_array_t *parent) { + const int n = parent->nitem; + toml_arritem_t *base = expand_arritem(parent->item, n); + if (!base) { + e_outofmemory(ctx, FLINE); + return 0; + } + parent->item = base; + parent->nitem++; + return &parent->item[n]; +} + +/* Create an array in an array + */ +static toml_array_t *create_array_in_array(context_t *ctx, + toml_array_t *parent) { + const int n = parent->nitem; + toml_arritem_t *base = expand_arritem(parent->item, n); + if (!base) { + e_outofmemory(ctx, FLINE); + return 0; + } + toml_array_t *ret = (toml_array_t *)CALLOC(1, sizeof(toml_array_t)); + if (!ret) { + e_outofmemory(ctx, FLINE); + return 0; + } + base[n].arr = ret; + parent->item = base; + parent->nitem++; + return ret; +} + +/* Create a table in an array + */ +static toml_table_t *create_table_in_array(context_t *ctx, + toml_array_t *parent) { + int n = parent->nitem; + toml_arritem_t *base = expand_arritem(parent->item, n); + if (!base) { + e_outofmemory(ctx, FLINE); + return 0; + } + toml_table_t *ret = (toml_table_t *)CALLOC(1, sizeof(toml_table_t)); + if (!ret) { + e_outofmemory(ctx, FLINE); + return 0; + } + base[n].tab = ret; + parent->item = base; + parent->nitem++; + return ret; +} + +static int skip_newlines(context_t *ctx, int isdotspecial) { + while (ctx->tok.tok == NEWLINE) { + if (next_token(ctx, isdotspecial)) + return -1; + if (ctx->tok.eof) + break; + } + return 0; +} + +static int parse_keyval(context_t *ctx, toml_table_t *tab); + +static inline int eat_token(context_t *ctx, tokentype_t typ, int isdotspecial, + const char *fline) { + if (ctx->tok.tok != typ) + return e_internal(ctx, fline); + + if (next_token(ctx, isdotspecial)) + return -1; + + return 0; +} + +/* We are at '{ ... }'. + * Parse the table. + */ +static int parse_inline_table(context_t *ctx, toml_table_t *tab) { + if (eat_token(ctx, LBRACE, 1, FLINE)) + return -1; + + for (;;) { + if (ctx->tok.tok == NEWLINE) + return e_syntax(ctx, ctx->tok.lineno, + "newline not allowed in inline table"); + + /* until } */ + if (ctx->tok.tok == RBRACE) + break; + + if (ctx->tok.tok != STRING) + return e_syntax(ctx, ctx->tok.lineno, "expect a string"); + + if (parse_keyval(ctx, tab)) + return -1; + + if (ctx->tok.tok == NEWLINE) + return e_syntax(ctx, ctx->tok.lineno, + "newline not allowed in inline table"); + + /* on comma, continue to scan for next keyval */ + if (ctx->tok.tok == COMMA) { + if (eat_token(ctx, COMMA, 1, FLINE)) + return -1; + continue; + } + break; + } + + if (eat_token(ctx, RBRACE, 1, FLINE)) + return -1; + + tab->readonly = 1; + + return 0; +} + +static int valtype(const char *val) { + toml_timestamp_t ts; + if (*val == '\'' || *val == '"') + return 's'; + if (0 == toml_rtob(val, 0)) + return 'b'; + if (0 == toml_rtoi(val, 0)) + return 'i'; + if (0 == toml_rtod(val, 0)) + return 'd'; + if (0 == toml_rtots(val, &ts)) { + if (ts.year && ts.hour) + return 'T'; /* timestamp */ + if (ts.year) + return 'D'; /* date */ + return 't'; /* time */ + } + return 'u'; /* unknown */ +} + +/* We are at '[...]' */ +static int parse_array(context_t *ctx, toml_array_t *arr) { + if (eat_token(ctx, LBRACKET, 0, FLINE)) + return -1; + + for (;;) { + if (skip_newlines(ctx, 0)) + return -1; + + /* until ] */ + if (ctx->tok.tok == RBRACKET) + break; + + switch (ctx->tok.tok) { + case STRING: { + /* set array kind if this will be the first entry */ + if (arr->kind == 0) + arr->kind = 'v'; + else if (arr->kind != 'v') + arr->kind = 'm'; + + char *val = ctx->tok.ptr; + int vlen = ctx->tok.len; + + /* make a new value in array */ + toml_arritem_t *newval = create_value_in_array(ctx, arr); + if (!newval) + return e_outofmemory(ctx, FLINE); + + if (!(newval->val = STRNDUP(val, vlen))) + return e_outofmemory(ctx, FLINE); + + newval->valtype = valtype(newval->val); + + /* set array type if this is the first entry */ + if (arr->nitem == 1) + arr->type = newval->valtype; + else if (arr->type != newval->valtype) + arr->type = 'm'; /* mixed */ + + if (eat_token(ctx, STRING, 0, FLINE)) + return -1; + break; + } + + case LBRACKET: { /* [ [array], [array] ... ] */ + /* set the array kind if this will be the first entry */ + if (arr->kind == 0) + arr->kind = 'a'; + else if (arr->kind != 'a') + arr->kind = 'm'; + + toml_array_t *subarr = create_array_in_array(ctx, arr); + if (!subarr) + return -1; + if (parse_array(ctx, subarr)) + return -1; + break; + } + + case LBRACE: { /* [ {table}, {table} ... ] */ + /* set the array kind if this will be the first entry */ + if (arr->kind == 0) + arr->kind = 't'; + else if (arr->kind != 't') + arr->kind = 'm'; + + toml_table_t *subtab = create_table_in_array(ctx, arr); + if (!subtab) + return -1; + if (parse_inline_table(ctx, subtab)) + return -1; + break; + } + + default: + return e_syntax(ctx, ctx->tok.lineno, "syntax error"); + } + + if (skip_newlines(ctx, 0)) + return -1; + + /* on comma, continue to scan for next element */ + if (ctx->tok.tok == COMMA) { + if (eat_token(ctx, COMMA, 0, FLINE)) + return -1; + continue; + } + break; + } + + if (eat_token(ctx, RBRACKET, 1, FLINE)) + return -1; + return 0; +} + +/* handle lines like these: + key = "value" + key = [ array ] + key = { table } +*/ +static int parse_keyval(context_t *ctx, toml_table_t *tab) { + if (tab->readonly) { + return e_forbid(ctx, ctx->tok.lineno, + "cannot insert new entry into existing table"); + } + + token_t key = ctx->tok; + if (eat_token(ctx, STRING, 1, FLINE)) + return -1; + + if (ctx->tok.tok == DOT) { + /* handle inline dotted key. + e.g. + physical.color = "orange" + physical.shape = "round" + */ + toml_table_t *subtab = 0; + { + char *subtabstr = normalize_key(ctx, key); + if (!subtabstr) + return -1; + + subtab = toml_table_in(tab, subtabstr); + xfree(subtabstr); + } + if (!subtab) { + subtab = create_keytable_in_table(ctx, tab, key); + if (!subtab) + return -1; + } + if (next_token(ctx, 1)) + return -1; + if (parse_keyval(ctx, subtab)) + return -1; + return 0; + } + + if (ctx->tok.tok != EQUAL) { + return e_syntax(ctx, ctx->tok.lineno, "missing ="); + } + + if (next_token(ctx, 0)) + return -1; + + switch (ctx->tok.tok) { + case STRING: { /* key = "value" */ + toml_keyval_t *keyval = create_keyval_in_table(ctx, tab, key); + if (!keyval) + return -1; + token_t val = ctx->tok; + + assert(keyval->val == 0); + if (!(keyval->val = STRNDUP(val.ptr, val.len))) + return e_outofmemory(ctx, FLINE); + + if (next_token(ctx, 1)) + return -1; + + return 0; + } + + case LBRACKET: { /* key = [ array ] */ + toml_array_t *arr = create_keyarray_in_table(ctx, tab, key, 0); + if (!arr) + return -1; + if (parse_array(ctx, arr)) + return -1; + return 0; + } + + case LBRACE: { /* key = { table } */ + toml_table_t *nxttab = create_keytable_in_table(ctx, tab, key); + if (!nxttab) + return -1; + if (parse_inline_table(ctx, nxttab)) + return -1; + return 0; + } + + default: + return e_syntax(ctx, ctx->tok.lineno, "syntax error"); + } + return 0; +} + +typedef struct tabpath_t tabpath_t; +struct tabpath_t { + int cnt; + token_t key[10]; +}; + +/* at [x.y.z] or [[x.y.z]] + * Scan forward and fill tabpath until it enters ] or ]] + * There will be at least one entry on return. + */ +static int fill_tabpath(context_t *ctx) { + int lineno = ctx->tok.lineno; + int i; + + /* clear tpath */ + for (i = 0; i < ctx->tpath.top; i++) { + char **p = &ctx->tpath.key[i]; + xfree(*p); + *p = 0; + } + ctx->tpath.top = 0; + + for (;;) { + if (ctx->tpath.top >= 10) + return e_syntax(ctx, lineno, + "table path is too deep; max allowed is 10."); + + if (ctx->tok.tok != STRING) + return e_syntax(ctx, lineno, "invalid or missing key"); + + char *key = normalize_key(ctx, ctx->tok); + if (!key) + return -1; + ctx->tpath.tok[ctx->tpath.top] = ctx->tok; + ctx->tpath.key[ctx->tpath.top] = key; + ctx->tpath.top++; + + if (next_token(ctx, 1)) + return -1; + + if (ctx->tok.tok == RBRACKET) + break; + + if (ctx->tok.tok != DOT) + return e_syntax(ctx, lineno, "invalid key"); + + if (next_token(ctx, 1)) + return -1; + } + + if (ctx->tpath.top <= 0) + return e_syntax(ctx, lineno, "empty table selector"); + + return 0; +} + +/* Walk tabpath from the root, and create new tables on the way. + * Sets ctx->curtab to the final table. + */ +static int walk_tabpath(context_t *ctx) { + /* start from root */ + toml_table_t *curtab = ctx->root; + + for (int i = 0; i < ctx->tpath.top; i++) { + const char *key = ctx->tpath.key[i]; + + toml_keyval_t *nextval = 0; + toml_array_t *nextarr = 0; + toml_table_t *nexttab = 0; + switch (check_key(curtab, key, &nextval, &nextarr, &nexttab)) { + case 't': + /* found a table. nexttab is where we will go next. */ + break; + + case 'a': + /* found an array. nexttab is the last table in the array. */ + if (nextarr->kind != 't') + return e_internal(ctx, FLINE); + + if (nextarr->nitem == 0) + return e_internal(ctx, FLINE); + + nexttab = nextarr->item[nextarr->nitem - 1].tab; + break; + + case 'v': + return e_keyexists(ctx, ctx->tpath.tok[i].lineno); + + default: { /* Not found. Let's create an implicit table. */ + int n = curtab->ntab; + toml_table_t **base = + (toml_table_t **)expand_ptrarr((void **)curtab->tab, n); + if (0 == base) + return e_outofmemory(ctx, FLINE); + + curtab->tab = base; + + if (0 == (base[n] = (toml_table_t *)CALLOC(1, sizeof(*base[n])))) + return e_outofmemory(ctx, FLINE); + + if (0 == (base[n]->key = STRDUP(key))) + return e_outofmemory(ctx, FLINE); + + nexttab = curtab->tab[curtab->ntab++]; + + /* tabs created by walk_tabpath are considered implicit */ + nexttab->implicit = true; + } break; + } + + /* switch to next tab */ + curtab = nexttab; + } + + /* save it */ + ctx->curtab = curtab; + + return 0; +} + +/* handle lines like [x.y.z] or [[x.y.z]] */ +static int parse_select(context_t *ctx) { + assert(ctx->tok.tok == LBRACKET); + + /* true if [[ */ + int llb = (ctx->tok.ptr + 1 < ctx->stop && ctx->tok.ptr[1] == '['); + /* need to detect '[[' on our own because next_token() will skip whitespace, + and '[ [' would be taken as '[[', which is wrong. */ + + /* eat [ or [[ */ + if (eat_token(ctx, LBRACKET, 1, FLINE)) + return -1; + if (llb) { + assert(ctx->tok.tok == LBRACKET); + if (eat_token(ctx, LBRACKET, 1, FLINE)) + return -1; + } + + if (fill_tabpath(ctx)) + return -1; + + /* For [x.y.z] or [[x.y.z]], remove z from tpath. + */ + token_t z = ctx->tpath.tok[ctx->tpath.top - 1]; + xfree(ctx->tpath.key[ctx->tpath.top - 1]); + ctx->tpath.top--; + + /* set up ctx->curtab */ + if (walk_tabpath(ctx)) + return -1; + + if (!llb) { + /* [x.y.z] -> create z = {} in x.y */ + toml_table_t *curtab = create_keytable_in_table(ctx, ctx->curtab, z); + if (!curtab) + return -1; + ctx->curtab = curtab; + } else { + /* [[x.y.z]] -> create z = [] in x.y */ + toml_array_t *arr = 0; + { + char *zstr = normalize_key(ctx, z); + if (!zstr) + return -1; + arr = toml_array_in(ctx->curtab, zstr); + xfree(zstr); + } + if (!arr) { + arr = create_keyarray_in_table(ctx, ctx->curtab, z, 't'); + if (!arr) + return -1; + } + if (arr->kind != 't') + return e_syntax(ctx, z.lineno, "array mismatch"); + + /* add to z[] */ + toml_table_t *dest; + { + toml_table_t *t = create_table_in_array(ctx, arr); + if (!t) + return -1; + + if (0 == (t->key = STRDUP("__anon__"))) + return e_outofmemory(ctx, FLINE); + + dest = t; + } + + ctx->curtab = dest; + } + + if (ctx->tok.tok != RBRACKET) { + return e_syntax(ctx, ctx->tok.lineno, "expects ]"); + } + if (llb) { + if (!(ctx->tok.ptr + 1 < ctx->stop && ctx->tok.ptr[1] == ']')) { + return e_syntax(ctx, ctx->tok.lineno, "expects ]]"); + } + if (eat_token(ctx, RBRACKET, 1, FLINE)) + return -1; + } + + if (eat_token(ctx, RBRACKET, 1, FLINE)) + return -1; + + if (ctx->tok.tok != NEWLINE) + return e_syntax(ctx, ctx->tok.lineno, "extra chars after ] or ]]"); + + return 0; +} + +toml_table_t *toml_parse(char *conf, char *errbuf, int errbufsz) { + context_t ctx; + + // clear errbuf + if (errbufsz <= 0) + errbufsz = 0; + if (errbufsz > 0) + errbuf[0] = 0; + + // init context + memset(&ctx, 0, sizeof(ctx)); + ctx.start = conf; + ctx.stop = ctx.start + strlen(conf); + ctx.errbuf = errbuf; + ctx.errbufsz = errbufsz; + + // start with an artificial newline of length 0 + ctx.tok.tok = NEWLINE; + ctx.tok.lineno = 1; + ctx.tok.ptr = conf; + ctx.tok.len = 0; + + // make a root table + if (0 == (ctx.root = CALLOC(1, sizeof(*ctx.root)))) { + e_outofmemory(&ctx, FLINE); + // Do not goto fail, root table not set up yet + return 0; + } + + // set root as default table + ctx.curtab = ctx.root; + + /* Scan forward until EOF */ + for (token_t tok = ctx.tok; !tok.eof; tok = ctx.tok) { + switch (tok.tok) { + + case NEWLINE: + if (next_token(&ctx, 1)) + goto fail; + break; + + case STRING: + if (parse_keyval(&ctx, ctx.curtab)) + goto fail; + + if (ctx.tok.tok != NEWLINE) { + e_syntax(&ctx, ctx.tok.lineno, "extra chars after value"); + goto fail; + } + + if (eat_token(&ctx, NEWLINE, 1, FLINE)) + goto fail; + break; + + case LBRACKET: /* [ x.y.z ] or [[ x.y.z ]] */ + if (parse_select(&ctx)) + goto fail; + break; + + default: + e_syntax(&ctx, tok.lineno, "syntax error"); + goto fail; + } + } + + /* success */ + for (int i = 0; i < ctx.tpath.top; i++) + xfree(ctx.tpath.key[i]); + return ctx.root; + +fail: + // Something bad has happened. Free resources and return error. + for (int i = 0; i < ctx.tpath.top; i++) + xfree(ctx.tpath.key[i]); + toml_free(ctx.root); + return 0; +} + +toml_table_t *toml_parse_file(FILE *fp, char *errbuf, int errbufsz) { + int bufsz = 0; + char *buf = 0; + int off = 0; + + /* read from fp into buf */ + while (!feof(fp)) { + + if (off == bufsz) { + int xsz = bufsz + 1000; + char *x = expand(buf, bufsz, xsz); + if (!x) { + snprintf(errbuf, errbufsz, "out of memory"); + xfree(buf); + return 0; + } + buf = x; + bufsz = xsz; + } + + errno = 0; + int n = fread(buf + off, 1, bufsz - off, fp); + if (ferror(fp)) { + snprintf(errbuf, errbufsz, "%s", + errno ? strerror(errno) : "Error reading file"); + xfree(buf); + return 0; + } + off += n; + } + + /* tag on a NUL to cap the string */ + if (off == bufsz) { + int xsz = bufsz + 1; + char *x = expand(buf, bufsz, xsz); + if (!x) { + snprintf(errbuf, errbufsz, "out of memory"); + xfree(buf); + return 0; + } + buf = x; + bufsz = xsz; + } + buf[off] = 0; + + /* parse it, cleanup and finish */ + toml_table_t *ret = toml_parse(buf, errbuf, errbufsz); + xfree(buf); + return ret; +} + +static void xfree_kval(toml_keyval_t *p) { + if (!p) + return; + xfree(p->key); + xfree(p->val); + xfree(p); +} + +static void xfree_tab(toml_table_t *p); + +static void xfree_arr(toml_array_t *p) { + if (!p) + return; + + xfree(p->key); + const int n = p->nitem; + for (int i = 0; i < n; i++) { + toml_arritem_t *a = &p->item[i]; + if (a->val) + xfree(a->val); + else if (a->arr) + xfree_arr(a->arr); + else if (a->tab) + xfree_tab(a->tab); + } + xfree(p->item); + xfree(p); +} + +static void xfree_tab(toml_table_t *p) { + int i; + + if (!p) + return; + + xfree(p->key); + + for (i = 0; i < p->nkval; i++) + xfree_kval(p->kval[i]); + xfree(p->kval); + + for (i = 0; i < p->narr; i++) + xfree_arr(p->arr[i]); + xfree(p->arr); + + for (i = 0; i < p->ntab; i++) + xfree_tab(p->tab[i]); + xfree(p->tab); + + xfree(p); +} + +void toml_free(toml_table_t *tab) { xfree_tab(tab); } + +static void set_token(context_t *ctx, tokentype_t tok, int lineno, char *ptr, + int len) { + token_t t; + t.tok = tok; + t.lineno = lineno; + t.ptr = ptr; + t.len = len; + t.eof = 0; + ctx->tok = t; +} + +static void set_eof(context_t *ctx, int lineno) { + set_token(ctx, NEWLINE, lineno, ctx->stop, 0); + ctx->tok.eof = 1; +} + +/* Scan p for n digits compositing entirely of [0-9] */ +static int scan_digits(const char *p, int n) { + int ret = 0; + for (; n > 0 && isdigit(*p); n--, p++) { + ret = 10 * ret + (*p - '0'); + } + return n ? -1 : ret; +} + +static int scan_date(const char *p, int *YY, int *MM, int *DD) { + int year, month, day; + year = scan_digits(p, 4); + month = (year >= 0 && p[4] == '-') ? scan_digits(p + 5, 2) : -1; + day = (month >= 0 && p[7] == '-') ? scan_digits(p + 8, 2) : -1; + if (YY) + *YY = year; + if (MM) + *MM = month; + if (DD) + *DD = day; + return (year >= 0 && month >= 0 && day >= 0) ? 0 : -1; +} + +static int scan_time(const char *p, int *hh, int *mm, int *ss) { + int hour, minute, second; + hour = scan_digits(p, 2); + minute = (hour >= 0 && p[2] == ':') ? scan_digits(p + 3, 2) : -1; + second = (minute >= 0 && p[5] == ':') ? scan_digits(p + 6, 2) : -1; + if (hh) + *hh = hour; + if (mm) + *mm = minute; + if (ss) + *ss = second; + return (hour >= 0 && minute >= 0 && second >= 0) ? 0 : -1; +} + +static int scan_string(context_t *ctx, char *p, int lineno, int dotisspecial) { + char *orig = p; + if (0 == strncmp(p, "'''", 3)) { + char *q = p + 3; + + while (1) { + q = strstr(q, "'''"); + if (0 == q) { + return e_syntax(ctx, lineno, "unterminated triple-s-quote"); + } + while (q[3] == '\'') + q++; + break; + } + + set_token(ctx, STRING, lineno, orig, q + 3 - orig); + return 0; + } + + if (0 == strncmp(p, "\"\"\"", 3)) { + char *q = p + 3; + + while (1) { + q = strstr(q, "\"\"\""); + if (0 == q) { + return e_syntax(ctx, lineno, "unterminated triple-d-quote"); + } + if (q[-1] == '\\') { + q++; + continue; + } + while (q[3] == '\"') + q++; + break; + } + + // the string is [p+3, q-1] + + int hexreq = 0; /* #hex required */ + int escape = 0; + for (p += 3; p < q; p++) { + if (escape) { + escape = 0; + if (strchr("btnfr\"\\", *p)) + continue; + if (*p == 'u') { + hexreq = 4; + continue; + } + if (*p == 'U') { + hexreq = 8; + continue; + } + if (p[strspn(p, " \t\r")] == '\n') + continue; /* allow for line ending backslash */ + return e_syntax(ctx, lineno, "bad escape char"); + } + if (hexreq) { + hexreq--; + if (strchr("0123456789ABCDEF", *p)) + continue; + return e_syntax(ctx, lineno, "expect hex char"); + } + if (*p == '\\') { + escape = 1; + continue; + } + } + if (escape) + return e_syntax(ctx, lineno, "expect an escape char"); + if (hexreq) + return e_syntax(ctx, lineno, "expected more hex char"); + + set_token(ctx, STRING, lineno, orig, q + 3 - orig); + return 0; + } + + if ('\'' == *p) { + for (p++; *p && *p != '\n' && *p != '\''; p++) + ; + if (*p != '\'') { + return e_syntax(ctx, lineno, "unterminated s-quote"); + } + + set_token(ctx, STRING, lineno, orig, p + 1 - orig); + return 0; + } + + if ('\"' == *p) { + int hexreq = 0; /* #hex required */ + int escape = 0; + for (p++; *p; p++) { + if (escape) { + escape = 0; + if (strchr("btnfr\"\\", *p)) + continue; + if (*p == 'u') { + hexreq = 4; + continue; + } + if (*p == 'U') { + hexreq = 8; + continue; + } + return e_syntax(ctx, lineno, "bad escape char"); + } + if (hexreq) { + hexreq--; + if (strchr("0123456789ABCDEF", *p)) + continue; + return e_syntax(ctx, lineno, "expect hex char"); + } + if (*p == '\\') { + escape = 1; + continue; + } + if (*p == '\'') { + if (p[1] == '\'' && p[2] == '\'') { + return e_syntax(ctx, lineno, "triple-s-quote inside string lit"); + } + continue; + } + if (*p == '\n') + break; + if (*p == '"') + break; + } + if (*p != '"') { + return e_syntax(ctx, lineno, "unterminated quote"); + } + + set_token(ctx, STRING, lineno, orig, p + 1 - orig); + return 0; + } + + /* check for timestamp without quotes */ + if (0 == scan_date(p, 0, 0, 0) || 0 == scan_time(p, 0, 0, 0)) { + // forward thru the timestamp + p += strspn(p, "0123456789.:+-T Z"); + // squeeze out any spaces at end of string + for (; p[-1] == ' '; p--) + ; + // tokenize + set_token(ctx, STRING, lineno, orig, p - orig); + return 0; + } + + /* literals */ + for (; *p && *p != '\n'; p++) { + int ch = *p; + if (ch == '.' && dotisspecial) + break; + if ('A' <= ch && ch <= 'Z') + continue; + if ('a' <= ch && ch <= 'z') + continue; + if (strchr("0123456789+-_.", ch)) + continue; + break; + } + + set_token(ctx, STRING, lineno, orig, p - orig); + return 0; +} + +static int next_token(context_t *ctx, int dotisspecial) { + int lineno = ctx->tok.lineno; + char *p = ctx->tok.ptr; + int i; + + /* eat this tok */ + for (i = 0; i < ctx->tok.len; i++) { + if (*p++ == '\n') + lineno++; + } + + /* make next tok */ + while (p < ctx->stop) { + /* skip comment. stop just before the \n. */ + if (*p == '#') { + for (p++; p < ctx->stop && *p != '\n'; p++) + ; + continue; + } + + if (dotisspecial && *p == '.') { + set_token(ctx, DOT, lineno, p, 1); + return 0; + } + + switch (*p) { + case ',': + set_token(ctx, COMMA, lineno, p, 1); + return 0; + case '=': + set_token(ctx, EQUAL, lineno, p, 1); + return 0; + case '{': + set_token(ctx, LBRACE, lineno, p, 1); + return 0; + case '}': + set_token(ctx, RBRACE, lineno, p, 1); + return 0; + case '[': + set_token(ctx, LBRACKET, lineno, p, 1); + return 0; + case ']': + set_token(ctx, RBRACKET, lineno, p, 1); + return 0; + case '\n': + set_token(ctx, NEWLINE, lineno, p, 1); + return 0; + case '\r': + case ' ': + case '\t': + /* ignore white spaces */ + p++; + continue; + } + + return scan_string(ctx, p, lineno, dotisspecial); + } + + set_eof(ctx, lineno); + return 0; +} + +const char *toml_key_in(const toml_table_t *tab, int keyidx) { + if (keyidx < tab->nkval) + return tab->kval[keyidx]->key; + + keyidx -= tab->nkval; + if (keyidx < tab->narr) + return tab->arr[keyidx]->key; + + keyidx -= tab->narr; + if (keyidx < tab->ntab) + return tab->tab[keyidx]->key; + + return 0; +} + +int toml_key_exists(const toml_table_t *tab, const char *key) { + int i; + for (i = 0; i < tab->nkval; i++) { + if (0 == strcmp(key, tab->kval[i]->key)) + return 1; + } + for (i = 0; i < tab->narr; i++) { + if (0 == strcmp(key, tab->arr[i]->key)) + return 1; + } + for (i = 0; i < tab->ntab; i++) { + if (0 == strcmp(key, tab->tab[i]->key)) + return 1; + } + return 0; +} + +toml_raw_t toml_raw_in(const toml_table_t *tab, const char *key) { + int i; + for (i = 0; i < tab->nkval; i++) { + if (0 == strcmp(key, tab->kval[i]->key)) + return tab->kval[i]->val; + } + return 0; +} + +toml_array_t *toml_array_in(const toml_table_t *tab, const char *key) { + int i; + for (i = 0; i < tab->narr; i++) { + if (0 == strcmp(key, tab->arr[i]->key)) + return tab->arr[i]; + } + return 0; +} + +toml_table_t *toml_table_in(const toml_table_t *tab, const char *key) { + int i; + for (i = 0; i < tab->ntab; i++) { + if (0 == strcmp(key, tab->tab[i]->key)) + return tab->tab[i]; + } + return 0; +} + +toml_raw_t toml_raw_at(const toml_array_t *arr, int idx) { + return (0 <= idx && idx < arr->nitem) ? arr->item[idx].val : 0; +} + +char toml_array_kind(const toml_array_t *arr) { return arr->kind; } + +char toml_array_type(const toml_array_t *arr) { + if (arr->kind != 'v') + return 0; + + if (arr->nitem == 0) + return 0; + + return arr->type; +} + +int toml_array_nelem(const toml_array_t *arr) { return arr->nitem; } + +const char *toml_array_key(const toml_array_t *arr) { + return arr ? arr->key : (const char *)NULL; +} + +int toml_table_nkval(const toml_table_t *tab) { return tab->nkval; } + +int toml_table_narr(const toml_table_t *tab) { return tab->narr; } + +int toml_table_ntab(const toml_table_t *tab) { return tab->ntab; } + +const char *toml_table_key(const toml_table_t *tab) { + return tab ? tab->key : (const char *)NULL; +} + +toml_array_t *toml_array_at(const toml_array_t *arr, int idx) { + return (0 <= idx && idx < arr->nitem) ? arr->item[idx].arr : 0; +} + +toml_table_t *toml_table_at(const toml_array_t *arr, int idx) { + return (0 <= idx && idx < arr->nitem) ? arr->item[idx].tab : 0; +} + +static int parse_millisec(const char *p, const char **endp); + +int toml_rtots(toml_raw_t src_, toml_timestamp_t *ret) { + if (!src_) + return -1; + + const char *p = src_; + int must_parse_time = 0; + + memset(ret, 0, sizeof(*ret)); + + int *year = &ret->__buffer.year; + int *month = &ret->__buffer.month; + int *day = &ret->__buffer.day; + int *hour = &ret->__buffer.hour; + int *minute = &ret->__buffer.minute; + int *second = &ret->__buffer.second; + int *millisec = &ret->__buffer.millisec; + + /* parse date YYYY-MM-DD */ + if (0 == scan_date(p, year, month, day)) { + ret->year = year; + ret->month = month; + ret->day = day; + + p += 10; + if (*p) { + // parse the T or space separator + if (*p != 'T' && *p != ' ') + return -1; + must_parse_time = 1; + p++; + } + } + + /* parse time HH:MM:SS */ + if (0 == scan_time(p, hour, minute, second)) { + ret->hour = hour; + ret->minute = minute; + ret->second = second; + + /* optionally, parse millisec */ + p += 8; + if (*p == '.') { + p++; /* skip '.' */ + const char *qq; + *millisec = parse_millisec(p, &qq); + ret->millisec = millisec; + p = qq; + } + + if (*p) { + /* parse and copy Z */ + char *z = ret->__buffer.z; + ret->z = z; + if (*p == 'Z' || *p == 'z') { + *z++ = 'Z'; + p++; + *z = 0; + + } else if (*p == '+' || *p == '-') { + *z++ = *p++; + + if (!(isdigit(p[0]) && isdigit(p[1]))) + return -1; + *z++ = *p++; + *z++ = *p++; + + if (*p == ':') { + *z++ = *p++; + + if (!(isdigit(p[0]) && isdigit(p[1]))) + return -1; + *z++ = *p++; + *z++ = *p++; + } + + *z = 0; + } + } + } + if (*p != 0) + return -1; + + if (must_parse_time && !ret->hour) + return -1; + + return 0; +} + +/* Raw to boolean */ +int toml_rtob(toml_raw_t src, int *ret_) { + if (!src) + return -1; + int dummy; + int *ret = ret_ ? ret_ : &dummy; + + if (0 == strcmp(src, "true")) { + *ret = 1; + return 0; + } + if (0 == strcmp(src, "false")) { + *ret = 0; + return 0; + } + return -1; +} + +/* Raw to integer */ +int toml_rtoi(toml_raw_t src, int64_t *ret_) { + if (!src) + return -1; + + char buf[100]; + char *p = buf; + char *q = p + sizeof(buf); + const char *s = src; + int base = 0; + int64_t dummy; + int64_t *ret = ret_ ? ret_ : &dummy; + + /* allow +/- */ + if (s[0] == '+' || s[0] == '-') + *p++ = *s++; + + /* disallow +_100 */ + if (s[0] == '_') + return -1; + + /* if 0* ... */ + if ('0' == s[0]) { + switch (s[1]) { + case 'x': + base = 16; + s += 2; + break; + case 'o': + base = 8; + s += 2; + break; + case 'b': + base = 2; + s += 2; + break; + case '\0': + return *ret = 0, 0; + default: + /* ensure no other digits after it */ + if (s[1]) + return -1; + } + } + + /* just strip underscores and pass to strtoll */ + while (*s && p < q) { + int ch = *s++; + if (ch == '_') { + // disallow '__' + if (s[0] == '_') + return -1; + // numbers cannot end with '_' + if (s[0] == '\0') + return -1; + continue; /* skip _ */ + } + *p++ = ch; + } + + // if not at end-of-string or we ran out of buffer ... + if (*s || p == q) + return -1; + + /* cap with NUL */ + *p = 0; + + /* Run strtoll on buf to get the integer */ + char *endp; + errno = 0; + *ret = strtoll(buf, &endp, base); + return (errno || *endp) ? -1 : 0; +} + +int toml_rtod_ex(toml_raw_t src, double *ret_, char *buf, int buflen) { + if (!src) + return -1; + + char *p = buf; + char *q = p + buflen; + const char *s = src; + double dummy; + double *ret = ret_ ? ret_ : &dummy; + + /* allow +/- */ + if (s[0] == '+' || s[0] == '-') + *p++ = *s++; + + /* disallow +_1.00 */ + if (s[0] == '_') + return -1; + + /* decimal point, if used, must be surrounded by at least one digit on each + * side */ + { + char *dot = strchr(s, '.'); + if (dot) { + if (dot == s || !isdigit(dot[-1]) || !isdigit(dot[1])) + return -1; + } + } + + /* zero must be followed by . or 'e', or NUL */ + if (s[0] == '0' && s[1] && !strchr("eE.", s[1])) + return -1; + + /* just strip underscores and pass to strtod */ + while (*s && p < q) { + int ch = *s++; + if (ch == '_') { + // disallow '__' + if (s[0] == '_') + return -1; + // disallow last char '_' + if (s[0] == 0) + return -1; + continue; /* skip _ */ + } + *p++ = ch; + } + if (*s || p == q) + return -1; /* reached end of string or buffer is full? */ + + /* cap with NUL */ + *p = 0; + + /* Run strtod on buf to get the value */ + char *endp; + errno = 0; + *ret = strtod(buf, &endp); + return (errno || *endp) ? -1 : 0; +} + +int toml_rtod(toml_raw_t src, double *ret_) { + char buf[100]; + return toml_rtod_ex(src, ret_, buf, sizeof(buf)); +} + +int toml_rtos(toml_raw_t src, char **ret) { + int multiline = 0; + const char *sp; + const char *sq; + + *ret = 0; + if (!src) + return -1; + + int qchar = src[0]; + int srclen = strlen(src); + if (!(qchar == '\'' || qchar == '"')) { + return -1; + } + + // triple quotes? + if (qchar == src[1] && qchar == src[2]) { + multiline = 1; + sp = src + 3; + sq = src + srclen - 3; + /* last 3 chars in src must be qchar */ + if (!(sp <= sq && sq[0] == qchar && sq[1] == qchar && sq[2] == qchar)) + return -1; + + /* skip new line immediate after qchar */ + if (sp[0] == '\n') + sp++; + else if (sp[0] == '\r' && sp[1] == '\n') + sp += 2; + + } else { + sp = src + 1; + sq = src + srclen - 1; + /* last char in src must be qchar */ + if (!(sp <= sq && *sq == qchar)) + return -1; + } + + if (qchar == '\'') { + *ret = norm_lit_str(sp, sq - sp, multiline, 0, 0); + } else { + *ret = norm_basic_str(sp, sq - sp, multiline, 0, 0); + } + + return *ret ? 0 : -1; +} + +toml_datum_t toml_string_at(const toml_array_t *arr, int idx) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtos(toml_raw_at(arr, idx), &ret.u.s)); + return ret; +} + +toml_datum_t toml_bool_at(const toml_array_t *arr, int idx) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtob(toml_raw_at(arr, idx), &ret.u.b)); + return ret; +} + +toml_datum_t toml_int_at(const toml_array_t *arr, int idx) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtoi(toml_raw_at(arr, idx), &ret.u.i)); + return ret; +} + +toml_datum_t toml_double_at(const toml_array_t *arr, int idx) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtod(toml_raw_at(arr, idx), &ret.u.d)); + return ret; +} + +toml_datum_t toml_timestamp_at(const toml_array_t *arr, int idx) { + toml_timestamp_t ts; + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtots(toml_raw_at(arr, idx), &ts)); + if (ret.ok) { + ret.ok = !!(ret.u.ts = MALLOC(sizeof(*ret.u.ts))); + if (ret.ok) { + *ret.u.ts = ts; + if (ret.u.ts->year) + ret.u.ts->year = &ret.u.ts->__buffer.year; + if (ret.u.ts->month) + ret.u.ts->month = &ret.u.ts->__buffer.month; + if (ret.u.ts->day) + ret.u.ts->day = &ret.u.ts->__buffer.day; + if (ret.u.ts->hour) + ret.u.ts->hour = &ret.u.ts->__buffer.hour; + if (ret.u.ts->minute) + ret.u.ts->minute = &ret.u.ts->__buffer.minute; + if (ret.u.ts->second) + ret.u.ts->second = &ret.u.ts->__buffer.second; + if (ret.u.ts->millisec) + ret.u.ts->millisec = &ret.u.ts->__buffer.millisec; + if (ret.u.ts->z) + ret.u.ts->z = ret.u.ts->__buffer.z; + } + } + return ret; +} + +toml_datum_t toml_string_in(const toml_table_t *arr, const char *key) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + toml_raw_t raw = toml_raw_in(arr, key); + if (raw) { + ret.ok = (0 == toml_rtos(raw, &ret.u.s)); + } + return ret; +} + +toml_datum_t toml_bool_in(const toml_table_t *arr, const char *key) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtob(toml_raw_in(arr, key), &ret.u.b)); + return ret; +} + +toml_datum_t toml_int_in(const toml_table_t *arr, const char *key) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtoi(toml_raw_in(arr, key), &ret.u.i)); + return ret; +} + +toml_datum_t toml_double_in(const toml_table_t *arr, const char *key) { + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtod(toml_raw_in(arr, key), &ret.u.d)); + return ret; +} + +toml_datum_t toml_timestamp_in(const toml_table_t *arr, const char *key) { + toml_timestamp_t ts; + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtots(toml_raw_in(arr, key), &ts)); + if (ret.ok) { + ret.ok = !!(ret.u.ts = MALLOC(sizeof(*ret.u.ts))); + if (ret.ok) { + *ret.u.ts = ts; + if (ret.u.ts->year) + ret.u.ts->year = &ret.u.ts->__buffer.year; + if (ret.u.ts->month) + ret.u.ts->month = &ret.u.ts->__buffer.month; + if (ret.u.ts->day) + ret.u.ts->day = &ret.u.ts->__buffer.day; + if (ret.u.ts->hour) + ret.u.ts->hour = &ret.u.ts->__buffer.hour; + if (ret.u.ts->minute) + ret.u.ts->minute = &ret.u.ts->__buffer.minute; + if (ret.u.ts->second) + ret.u.ts->second = &ret.u.ts->__buffer.second; + if (ret.u.ts->millisec) + ret.u.ts->millisec = &ret.u.ts->__buffer.millisec; + if (ret.u.ts->z) + ret.u.ts->z = ret.u.ts->__buffer.z; + } + } + return ret; +} + +static int parse_millisec(const char *p, const char **endp) { + int ret = 0; + int unit = 100; /* unit in millisec */ + for (; '0' <= *p && *p <= '9'; p++, unit /= 10) { + ret += (*p - '0') * unit; + } + *endp = p; + return ret; +} diff --git a/deps/toml/toml.h b/deps/toml/toml.h new file mode 100644 index 0000000..19dc3d2 --- /dev/null +++ b/deps/toml/toml.h @@ -0,0 +1,175 @@ +/* + MIT License + + Copyright (c) CK Tan + https://github.com/cktan/tomlc99 + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +#ifndef TOML_H +#define TOML_H + +#ifdef _MSC_VER +#pragma warning(disable: 4996) +#endif + +#include <stdint.h> +#include <stdio.h> + +#ifdef __cplusplus +#define TOML_EXTERN extern "C" +#else +#define TOML_EXTERN extern +#endif + +typedef struct toml_timestamp_t toml_timestamp_t; +typedef struct toml_table_t toml_table_t; +typedef struct toml_array_t toml_array_t; +typedef struct toml_datum_t toml_datum_t; + +/* Parse a file. Return a table on success, or 0 otherwise. + * Caller must toml_free(the-return-value) after use. + */ +TOML_EXTERN toml_table_t *toml_parse_file(FILE *fp, char *errbuf, int errbufsz); + +/* Parse a string containing the full config. + * Return a table on success, or 0 otherwise. + * Caller must toml_free(the-return-value) after use. + */ +TOML_EXTERN toml_table_t *toml_parse(char *conf, /* NUL terminated, please. */ + char *errbuf, int errbufsz); + +/* Free the table returned by toml_parse() or toml_parse_file(). Once + * this function is called, any handles accessed through this tab + * directly or indirectly are no longer valid. + */ +TOML_EXTERN void toml_free(toml_table_t *tab); + +/* Timestamp types. The year, month, day, hour, minute, second, z + * fields may be NULL if they are not relevant. e.g. In a DATE + * type, the hour, minute, second and z fields will be NULLs. + */ +struct toml_timestamp_t { + struct { /* internal. do not use. */ + int year, month, day; + int hour, minute, second, millisec; + char z[10]; + } __buffer; + int *year, *month, *day; + int *hour, *minute, *second, *millisec; + char *z; +}; + +/*----------------------------------------------------------------- + * Enhanced access methods + */ +struct toml_datum_t { + int ok; + union { + toml_timestamp_t *ts; /* ts must be freed after use */ + char *s; /* string value. s must be freed after use */ + int b; /* bool value */ + int64_t i; /* int value */ + double d; /* double value */ + } u; +}; + +/* on arrays: */ +/* ... retrieve size of array. */ +TOML_EXTERN int toml_array_nelem(const toml_array_t *arr); +/* ... retrieve values using index. */ +TOML_EXTERN toml_datum_t toml_string_at(const toml_array_t *arr, int idx); +TOML_EXTERN toml_datum_t toml_bool_at(const toml_array_t *arr, int idx); +TOML_EXTERN toml_datum_t toml_int_at(const toml_array_t *arr, int idx); +TOML_EXTERN toml_datum_t toml_double_at(const toml_array_t *arr, int idx); +TOML_EXTERN toml_datum_t toml_timestamp_at(const toml_array_t *arr, int idx); +/* ... retrieve array or table using index. */ +TOML_EXTERN toml_array_t *toml_array_at(const toml_array_t *arr, int idx); +TOML_EXTERN toml_table_t *toml_table_at(const toml_array_t *arr, int idx); + +/* on tables: */ +/* ... retrieve the key in table at keyidx. Return 0 if out of range. */ +TOML_EXTERN const char *toml_key_in(const toml_table_t *tab, int keyidx); +/* ... returns 1 if key exists in tab, 0 otherwise */ +TOML_EXTERN int toml_key_exists(const toml_table_t *tab, const char *key); +/* ... retrieve values using key. */ +TOML_EXTERN toml_datum_t toml_string_in(const toml_table_t *arr, + const char *key); +TOML_EXTERN toml_datum_t toml_bool_in(const toml_table_t *arr, const char *key); +TOML_EXTERN toml_datum_t toml_int_in(const toml_table_t *arr, const char *key); +TOML_EXTERN toml_datum_t toml_double_in(const toml_table_t *arr, + const char *key); +TOML_EXTERN toml_datum_t toml_timestamp_in(const toml_table_t *arr, + const char *key); +/* .. retrieve array or table using key. */ +TOML_EXTERN toml_array_t *toml_array_in(const toml_table_t *tab, + const char *key); +TOML_EXTERN toml_table_t *toml_table_in(const toml_table_t *tab, + const char *key); + +/*----------------------------------------------------------------- + * lesser used + */ +/* Return the array kind: 't'able, 'a'rray, 'v'alue, 'm'ixed */ +TOML_EXTERN char toml_array_kind(const toml_array_t *arr); + +/* For array kind 'v'alue, return the type of values + i:int, d:double, b:bool, s:string, t:time, D:date, T:timestamp, 'm'ixed + 0 if unknown +*/ +TOML_EXTERN char toml_array_type(const toml_array_t *arr); + +/* Return the key of an array */ +TOML_EXTERN const char *toml_array_key(const toml_array_t *arr); + +/* Return the number of key-values in a table */ +TOML_EXTERN int toml_table_nkval(const toml_table_t *tab); + +/* Return the number of arrays in a table */ +TOML_EXTERN int toml_table_narr(const toml_table_t *tab); + +/* Return the number of sub-tables in a table */ +TOML_EXTERN int toml_table_ntab(const toml_table_t *tab); + +/* Return the key of a table*/ +TOML_EXTERN const char *toml_table_key(const toml_table_t *tab); + +/*-------------------------------------------------------------- + * misc + */ +TOML_EXTERN int toml_utf8_to_ucs(const char *orig, int len, int64_t *ret); +TOML_EXTERN int toml_ucs_to_utf8(int64_t code, char buf[6]); +TOML_EXTERN void toml_set_memutil(void *(*xxmalloc)(size_t), + void (*xxfree)(void *)); + +/*-------------------------------------------------------------- + * deprecated + */ +/* A raw value, must be processed by toml_rto* before using. */ +typedef const char *toml_raw_t; +TOML_EXTERN toml_raw_t toml_raw_in(const toml_table_t *tab, const char *key); +TOML_EXTERN toml_raw_t toml_raw_at(const toml_array_t *arr, int idx); +TOML_EXTERN int toml_rtos(toml_raw_t s, char **ret); +TOML_EXTERN int toml_rtob(toml_raw_t s, int *ret); +TOML_EXTERN int toml_rtoi(toml_raw_t s, int64_t *ret); +TOML_EXTERN int toml_rtod(toml_raw_t s, double *ret); +TOML_EXTERN int toml_rtod_ex(toml_raw_t s, double *ret, char *buf, int buflen); +TOML_EXTERN int toml_rtots(toml_raw_t s, toml_timestamp_t *ret); + +#endif /* TOML_H */ diff --git a/sdk/example/CMakeLists.txt b/sdk/example/CMakeLists.txt index a11a7e3..e45be02 100644 --- a/sdk/example/CMakeLists.txt +++ b/sdk/example/CMakeLists.txt @@ -1,12 +1,9 @@ - -add_definitions(-fPIC) - -add_library(custom_event_plugin +add_library(custom_event_plugin SHARED custom_event_plugin.cpp ) -set_target_properties(custom_event_plugin PROPERTIES PREFIX "") +set_target_properties(custom_event_plugin PROPERTIES PREFIX "") -add_library(http_event_plugin - http_event_plugin.cpp +add_library(http_event_plugin SHARED + http_event_plugin.cpp ) -set_target_properties(http_event_plugin PROPERTIES PREFIX "")
\ No newline at end of file +set_target_properties(http_event_plugin PROPERTIES PREFIX "")
\ No newline at end of file diff --git a/sdk/example/custom_event_plugin.cpp b/sdk/example/custom_event_plugin.cpp index d5b95e9..0d7f1c4 100644 --- a/sdk/example/custom_event_plugin.cpp +++ b/sdk/example/custom_event_plugin.cpp @@ -2,37 +2,57 @@ #include "packet.h" #include "plugin.h" -struct custom_session_event *_event = nullptr; +#include <stddef.h> +#include <stdlib.h> +#include <stdio.h> -void *custom_decode(const char *payload, uint32_t len, void **pme) +static char *g_handler = NULL; + +static void *custom_decode(const char *payload, uint16_t len, void **pme) { - return nullptr; + return NULL; } -int custom_plugin_entry(const struct stellar_session *s, int what, struct stellar_packet *p, const char *payload, uint32_t len, void **pme) +extern "C" void custom_plugin_tcp_entry(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) { - struct stellar_session_event_extras *info= (struct stellar_session_event_extras *)custom_decode(payload, len, pme); - struct stellar_session *new_session=session_manager_session_derive(s, "CUSTOM_A"); + char **per_session_pme = (char **)pme; + + printf("RUN custom_plugin_tcp_entry, event: %d\n", event); + + struct stellar_session_event_extras *info = (struct stellar_session_event_extras *)custom_decode(payload, len, pme); + struct stellar_session *new_session = session_manager_session_derive(s, "CUSTOM"); + session_manager_trigger_event(new_session, SESSION_EVENT_OPENING, info); session_manager_trigger_event(new_session, SESSION_EVENT_META, info); - return 0; - } -int custom_event_plugin_entry(const struct stellar_session *s, int what, struct stellar_packet *p, const char *payload, uint32_t len, void **pme) +extern "C" void custom_plugin_custom_entry(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) { - return 0; + char **per_session_pme = (char **)pme; + printf("RUN custom_plugin_custom_entry, event: %d\n", event); } -int custom_plugin_init() +extern "C" int custom_plugin_init(void) { - //plugin_manager_event_register("TCP", custom_plugin_entry, nullptr); - //plugin_manager_event_register("CUSTOM_A", custom_event_plugin_entry, nullptr); + printf("RUN custom_plugin_init\n"); + + if (g_handler == NULL) + { + g_handler = (char *)malloc(1024); + snprintf(g_handler, 1024, "222222"); + } + return 0; } -void custom_plugin_destroy() +extern "C" void custom_plugin_exit(void) { - return ; + printf("RUN custom_plugin_exit\n"); + + if (g_handler) + { + free(g_handler); + g_handler = NULL; + } }
\ No newline at end of file diff --git a/sdk/example/http_event_plugin.cpp b/sdk/example/http_event_plugin.cpp index 68dcf06..e41d8b6 100644 --- a/sdk/example/http_event_plugin.cpp +++ b/sdk/example/http_event_plugin.cpp @@ -1,22 +1,82 @@ #include "session.h" #include "packet.h" #include "plugin.h" -#include "http.h" +#include <stdlib.h> +#include <stdio.h> +static char *g_handler = NULL; -int http_event_plugin_entry(const struct stellar_session *s, int what, struct stellar_packet *p, const char *payload, uint32_t len, void **pme) +struct per_session_pme_info { - return 0; + int flag; + char data[16]; +}; + +extern "C" void http_event_plugin_entry(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) +{ + struct per_session_pme_info **per_session_pme = (struct per_session_pme_info **)pme; + + printf("RUN http_event_plugin_entry, event: %d\n", event); + + if (event & SESSION_EVENT_OPENING) + { + if (*per_session_pme == NULL) + { + struct per_session_pme_info *cur_ctx = (struct per_session_pme_info *)malloc(sizeof(struct per_session_pme_info)); + snprintf(cur_ctx->data, 6, "******"); + *per_session_pme = *&cur_ctx; + printf("http_event_plugin_entry->opening_handler\n"); + } + } + + if (event & SESSION_EVENT_RAWPKT) + { + printf("http_event_plugin_entry->rawpkt_handler\n"); + } + + if (event & SESSION_EVENT_ORDPKT) + { + printf("http_event_plugin_entry->ordpkt_handler\n"); + } + + if (event & SESSION_EVENT_META) + { + printf("http_event_plugin_entry->meta_handler\n"); + } + + if (event & SESSION_EVENT_CLOSING) + { + if (*per_session_pme) + { + printf("http_event_plugin_entry->closing_hanler\n"); + + free(*per_session_pme); + *per_session_pme = NULL; + } + } } -int http_event_plugin_init() +extern "C" int http_event_plugin_init(void) { - //plugin_manager_event_register("HTTP", http_event_plugin_entry, nullptr); + printf("RUN http_event_plugin_init\n"); + + if (g_handler == NULL) + { + g_handler = (char *)malloc(1024); + snprintf(g_handler, 1024, "111111"); + } + return 0; } -void http_event_plugin_destroy() +extern "C" void http_event_plugin_exit(void) { - return ; + printf("RUN http_event_plugin_exit\n"); + + if (g_handler) + { + free(g_handler); + g_handler = NULL; + } }
\ No newline at end of file diff --git a/sdk/example/plugins/custom_event_plugin/custom_event_plugin.inf b/sdk/example/plugins/custom_event_plugin/custom_event_plugin.inf index 479d474..c7d3fe3 100644 --- a/sdk/example/plugins/custom_event_plugin/custom_event_plugin.inf +++ b/sdk/example/plugins/custom_event_plugin/custom_event_plugin.inf @@ -1,16 +1,14 @@ [PLUGINFO] -INIT_FUNC=custom_plugin_init -EXIT_FUNC=custom_plugin_exit -LIBRARY_PATH=./plugins/custom_event_plugin/custom_event_plugin.so +INIT_FUNC="custom_plugin_init" +EXIT_FUNC="custom_plugin_exit" +LIBRARY_PATH="./plugins/custom_event_plugin/custom_event_plugin.so" +# Support SESSION_EVENT_TYPE: "SESSION_EVENT_OPENING", "SESSION_EVENT_RAWPKT", "SESSION_EVENT_ORDPKT", "SESSION_EVENT_META", "SESSION_EVENT_CLOSING", "SESSION_EVENT_ALL" -# Support SESSION_EVENT_TYPE -# OPENING,RAWPKT,ORDPKT,META,CLOSING,ALL +[SESSION_NAME.TCP] +SESSION_EVENT_TYPE=["SESSION_EVENT_ALL"] +SESSION_EVENT_CALLBACK="custom_plugin_tcp_entry" -[SESSION_TYPE.TCP] -SESSION_EVENT_TYPE=ALL -SESSION_EVENT_CALLBACK=custom_plugin_entry - -[SESSION_TYPE.CUSTOM_A] -SESSION_EVENT_TYPE=OPENING,ORDPKT,CLOSING -SESSION_EVENT_CALLBACK=custom_event_plugin_entry
\ No newline at end of file +[SESSION_NAME.CUSTOM] +SESSION_EVENT_TYPE=["SESSION_EVENT_OPENING","SESSION_EVENT_ORDPKT","SESSION_EVENT_CLOSING"] +SESSION_EVENT_CALLBACK="custom_plugin_custom_entry"
\ No newline at end of file diff --git a/sdk/example/plugins/http_event_plugin/http_event_plugin.inf b/sdk/example/plugins/http_event_plugin/http_event_plugin.inf index 4609300..a58a405 100644 --- a/sdk/example/plugins/http_event_plugin/http_event_plugin.inf +++ b/sdk/example/plugins/http_event_plugin/http_event_plugin.inf @@ -1,8 +1,10 @@ [PLUGINFO] -INIT_FUNC=http_event_plugin_init -EXIT_FUNC=http_event_plugin_exit -LIBRARY_PATH=./plugins/http_event_plugin/http_event_plugin.so +INIT_FUNC="http_event_plugin_init" +EXIT_FUNC="http_event_plugin_exit" +LIBRARY_PATH="./plugins/http_event_plugin/http_event_plugin.so" -[SESSION_TYPE.HTTP] -SESSION_EVENT_TYPE=ALL -SESSION_EVENT_CALLBACK=http_event_plugin_entry
\ No newline at end of file +# Support SESSION_EVENT_TYPE: "SESSION_EVENT_OPENING", "SESSION_EVENT_RAWPKT", "SESSION_EVENT_ORDPKT", "SESSION_EVENT_META", "SESSION_EVENT_CLOSING", "SESSION_EVENT_ALL" + +[SESSION_NAME.HTTP] +SESSION_EVENT_TYPE=["SESSION_EVENT_ALL"] +SESSION_EVENT_CALLBACK="http_event_plugin_entry"
\ No newline at end of file diff --git a/sdk/example/plugins/plugins.inf b/sdk/example/plugins/plugins.inf index 50e40af..ad3f27e 100644 --- a/sdk/example/plugins/plugins.inf +++ b/sdk/example/plugins/plugins.inf @@ -1,2 +1,4 @@ -./http_event_plugin/http_event_plugin.inf -./custom_event_plugin/custom_event_plugin.inf
\ No newline at end of file +# Relative path, relative to the installation path of stellar + +./plugins/http_event_plugin/http_event_plugin.inf +./plugins/custom_event_plugin/custom_event_plugin.inf
\ No newline at end of file diff --git a/sdk/include/http.h b/sdk/include/http.h index d7f3fbf..6250055 100644 --- a/sdk/include/http.h +++ b/sdk/include/http.h @@ -1,6 +1,5 @@ #pragma once -#include "packet.h" #include "session.h" -void http_decoder(const struct stellar_session *s, int what, struct stellar_packet *p, const char *payload, uint16_t len, void **pme);
\ No newline at end of file +void http_decoder(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme);
\ No newline at end of file diff --git a/sdk/include/plugin.h b/sdk/include/plugin.h index ac3b279..d213f7c 100644 --- a/sdk/include/plugin.h +++ b/sdk/include/plugin.h @@ -2,8 +2,14 @@ #include "session.h" -typedef int plugin_init_callback(void **pme); -typedef void plugin_exit_callback(void *pme); +typedef int plugin_init_callback(void); +typedef void plugin_exit_callback(void); -void plugin_remove_from_session_event(struct stellar_event *ev, - struct stellar_session *s);
\ No newline at end of file +void plugin_remove_from_session_event(struct stellar_event *ev, struct stellar_session *s); + +/****************************************************************************** + * Public API: between plugin and plugin_manager + ******************************************************************************/ + +// TODO +// TODO
\ No newline at end of file diff --git a/sdk/include/session.h b/sdk/include/session.h index b497fab..19bb566 100644 --- a/sdk/include/session.h +++ b/sdk/include/session.h @@ -25,6 +25,7 @@ enum stellar_session_type enum session_event_type { + SESSION_EVENT_UNKNOWN = (0x00), SESSION_EVENT_OPENING = (0x01 << 1), SESSION_EVENT_RAWPKT = (0x01 << 2), SESSION_EVENT_ORDPKT = (0x01 << 3), @@ -35,11 +36,7 @@ enum session_event_type struct stellar_session_event_extras; -typedef void (fn_session_event_callback)(const struct stellar_session *s, int what, struct stellar_packet *p, const char *payload, uint16_t len, void **pme); +typedef void(fn_session_event_callback)(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme); -void session_manager_trigger_event(struct stellar_session *s, - enum session_event_type type, - struct stellar_session_event_extras *info); - -struct stellar_session *session_manager_session_derive(const struct stellar_session *this_session, - const char *new_session_type_name);
\ No newline at end of file +void session_manager_trigger_event(struct stellar_session *s, enum session_event_type type, struct stellar_session_event_extras *info); +struct stellar_session *session_manager_session_derive(const struct stellar_session *this_session, const char *session_name);
\ No newline at end of file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index ede3dd3..6b4ad06 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,11 +1,9 @@ - include_directories(${CMAKE_SOURCE_DIR}/sdk/include) include_directories(${CMAKE_SOURCE_DIR}/deps/) include_directories(${CMAKE_SOURCE_DIR}/src/packet_io/) include_directories(${CMAKE_SOURCE_DIR}/src/session_manager/) include_directories(${CMAKE_SOURCE_DIR}/src/plugin_manager/) - enable_testing() add_subdirectory(packet_io) add_subdirectory(session_manager) @@ -16,4 +14,13 @@ add_executable(stellar main.cpp ) -target_link_libraries(stellar pthread packet_io plugin_manager session_manager http)
\ No newline at end of file +target_link_libraries( + stellar + pthread + packet_io + plugin_manager + session_manager + http + toml + dl +)
\ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 5071278..8d1655d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -59,11 +59,12 @@ int main(int argc, char ** argv) struct plugin_manager *plug_mgr = plugin_manager_create(); // register build-in plugin - plugin_manager_register(plug_mgr, "HTTP", http_decoder); + plugin_manager_register(plug_mgr, "HTTP", SESSION_EVENT_ALL, http_decoder); // load external plugins - char absolute_plugin_file[] = "/op/tsg/sapp/plug/plugins.inf"; - plugin_manager_load(plug_mgr, absolute_plugin_file); + char prefix_path[] = "/op/tsg/stellar/"; + char file_path[] = "./plugs/plugins.inf"; + plugin_manager_load(plug_mgr, prefix_path, file_path); //packet_io_init struct packet_io_device *dev = packet_io_init(1, "stellar", "cap0"); @@ -78,6 +79,7 @@ int main(int argc, char ** argv) usleep(1); } + plugin_manager_unload(plug_mgr); plugin_manager_destory(plug_mgr); return 0; diff --git a/src/plugin_manager/CMakeLists.txt b/src/plugin_manager/CMakeLists.txt index 5850d1f..1901671 100644 --- a/src/plugin_manager/CMakeLists.txt +++ b/src/plugin_manager/CMakeLists.txt @@ -1,4 +1,10 @@ -add_library(plugin_manager - plugin_manager.cpp +add_library(plugin_manager + plugin_manager_config.cpp + plugin_manager_module.cpp + plugin_manager_util.cpp + plugin_manager.cpp ) -target_include_directories(plugin_manager PUBLIC ${CMAKE_SOURCE_DIR})
\ No newline at end of file + +target_include_directories(plugin_manager PUBLIC ${CMAKE_SOURCE_DIR}) + +add_subdirectory(test)
\ No newline at end of file diff --git a/src/plugin_manager/plugin_manager.cpp b/src/plugin_manager/plugin_manager.cpp index 1755cc4..7b6492a 100644 --- a/src/plugin_manager/plugin_manager.cpp +++ b/src/plugin_manager/plugin_manager.cpp @@ -1,153 +1,453 @@ #include "deps/uthash/uthash.h" -#include "sdk/include/session.h" -#include "sdk/include/plugin.h" #include "session_manager.h" -#include "plugin_manager.h" +#include "plugin_manager_util.h" +#include "plugin_manager_config.h" +#include "plugin_manager_module.h" -#include <sys/queue.h> #include <assert.h> +#include <errno.h> /****************************************************************************** - * CallBack Static Hash Table (For Global) + * CallBack Runtime (For Per Session) ******************************************************************************/ -struct session_event_callback_static +struct eventcb_runtime { + int skip; + void *cb_args; + enum session_event_type event; - fn_session_event_callback *callback; + fn_session_event_callback *cb; }; -/* - * Hast table - * - * key: string -> session_type - * val: array -> event_cbs - */ -struct managed_session_event_callback -{ - char session_type[16]; - struct session_event_callback_static event_cbs[0]; // dynamic array - // Record the number of callback functions that want to process the current session - int event_cbs_num; - UT_hash_handle hh; +struct session_plugin_ctx +{ + int current_plugin_index; + int eventcb_num; + struct eventcb_runtime *eventcbs; }; /****************************************************************************** - * CallBack Runtime Array (For Per Session) + * CallBack Static (For Per Plugin Manager) ******************************************************************************/ -struct session_event_callback_runtime +struct eventcb_static { - int skip; // for skip this plugin callback - void *callback_args; - enum session_event_type event; - fn_session_event_callback *callback; + fn_session_event_callback *cb; }; -struct session_plugin_ctx +struct plugin_manager_eventcb { - int event_cbs_num; - struct session_event_callback_runtime event_cbs[0]; // dynamic array + char session_name[MAX_SESSION_NAME_LENGTH]; // key + + int eventcb_num; // val size + struct eventcb_static *eventcbs; // val: dynamic array + + UT_hash_handle hh; }; /****************************************************************************** - * struct plugin_manager + * Struct plugin_manager ******************************************************************************/ -/* - * Each plugin has an init_cb and an exit_cb, but may have multiple entry_cb. - * entry_cb is stored in the global_session_callback_ctx. - */ -struct plugin_ctx -{ - char *name; - char *library; - /* - * Stores the context generated by the plugin initialization, - * which is used to release resources when the plugin ends. - */ - void *pme; - plugin_init_callback *init_cb; - plugin_exit_callback *exit_cb; -}; - struct plugin_manager { - struct managed_session_event_callback *cb_table; - struct plugin_ctx plugins[MAX_PLUGIN_NUM]; + int used_module_num; + int used_config_num; + int used_evencb_num; // only plugin register eventcb numbers + + struct plugin_manager_module *modules[MAX_PLUGIN_NUM]; + struct plugin_manager_config *configs[MAX_PLUGIN_NUM]; + struct plugin_manager_eventcb *evcb_htable; }; /****************************************************************************** - * Private API + * Create/Destory plugin ctx (per session) ******************************************************************************/ -static void plugin_manager_handle_opening_event(struct plugin_manager *plug_mgr, struct stellar_event *event) +static struct session_plugin_ctx *plugin_manager_create_plugin_ctx(struct plugin_manager *plug_mgr, const char *session_name) { -} + if (session_name == NULL || strlen(session_name) == 0) + { + plugin_manager_log(ERROR, "invalid parameter, session name is empty"); + return NULL; + } -static void plugin_manager_handle_data_event(struct plugin_manager *plug_mgr, struct stellar_event *event) -{ + struct plugin_manager_eventcb *elem; + HASH_FIND_STR(plug_mgr->evcb_htable, session_name, elem); + if (elem == NULL) + { + plugin_manager_log(ERROR, "can't find event callback for session name '%s'", session_name); + return NULL; + } + else + { + struct session_plugin_ctx *plug_ctx = safe_alloc(struct session_plugin_ctx, 1); + plug_ctx->eventcb_num = elem->eventcb_num; + plug_ctx->eventcbs = safe_alloc(struct eventcb_runtime, plug_ctx->eventcb_num); + + for (int i = 0; i < plug_ctx->eventcb_num; i++) + { + plug_ctx->eventcbs[i].skip = 0; + plug_ctx->eventcbs[i].event = elem->eventcbs[i].event; + plug_ctx->eventcbs[i].cb = elem->eventcbs[i].cb; + plug_ctx->eventcbs[i].cb_args = NULL; + } + + return plug_ctx; + } } -static void plugin_manager_handle_closing_event(struct plugin_manager *plug_mgr, struct stellar_event *event) +static void plugin_manager_destory_plugin_ctx(struct session_plugin_ctx *plug_ctx) { + if (plug_ctx) + { + safe_free(plug_ctx->eventcbs); + safe_free(plug_ctx); + } } /****************************************************************************** - * Public API + * Tools for managing plugins ******************************************************************************/ -struct plugin_manager *plugin_manager_create() +static int plugin_manager_parse_plugins(struct plugin_manager *plug_mgr, const char *prefix, const char *file) { - struct plugin_manager *plug_mgr = NULL; + char plugin_inf[4096] = {0}; + char line_buffer[4096] = {0}; + if (strlen(prefix) <= 0) + { + plugin_manager_log(ERROR, "Invalid parameter, plugin config file prefix cannot be empty"); + return -1; + } + if (strlen(file) <= 0) + { + plugin_manager_log(ERROR, "Invalid parameter, plugin config file name cannot be empty"); + return -1; + } + strcat_prefix_and_file(prefix, file, plugin_inf, sizeof(plugin_inf)); - return plug_mgr; + FILE *fp = fopen(plugin_inf, "r"); + if (fp == NULL) + { + plugin_manager_log(ERROR, "can't open %s, %s", plugin_inf, strerror(errno)); + return -1; + } + + while (fgets(line_buffer, sizeof(line_buffer), fp)) + { + if ('#' == line_buffer[0] || '\n' == line_buffer[0]) + { + memset(line_buffer, 0, sizeof(line_buffer)); + continue; + } + + if (plug_mgr->used_config_num >= MAX_PLUGIN_NUM) + { + plugin_manager_log(ERROR, "the number of registered plugins exceeds the limit and cannot exceed %d", MAX_PLUGIN_NUM); + goto err; + } + + struct plugin_manager_config *config = plugin_mangager_config_create(); + if (plugin_mangager_config_parse(config, prefix, line_buffer) == -1) + { + plugin_mangager_config_destory(config); + goto err; + } + + plug_mgr->configs[plug_mgr->used_config_num] = config; + plug_mgr->used_config_num++; + memset(line_buffer, 0, sizeof(line_buffer)); + } + + fclose(fp); + + return 0; + +err: + + if (fp) + { + fclose(fp); + fp = NULL; + } + + return -1; } -void plugin_manager_destory(struct plugin_manager *plug_mgr) +static int plugin_manager_open_plugins(struct plugin_manager *plug_mgr) { - if (plug_mgr) + for (int i = 0; i < plug_mgr->used_config_num; i++) + { + struct plugin_manager_config *config = plug_mgr->configs[i]; + struct plugin_manager_module *module = plugin_manager_module_open(config); + if (module == NULL) + { + return -1; + } + plug_mgr->modules[plug_mgr->used_module_num] = module; + plug_mgr->used_module_num++; + } + + return 0; +} + +static int plugin_manager_register_plugins(struct plugin_manager *plug_mgr) +{ + for (int i = 0; i < plug_mgr->used_module_num; i++) + { + struct plugin_manager_module *module = plug_mgr->modules[i]; + if (plugin_manager_module_register(plug_mgr, module) == -1) + { + return -1; + } + plug_mgr->used_evencb_num++; + } + + return 0; +} + +static int plugin_manager_init_plugins(struct plugin_manager *plug_mgr) +{ + for (int i = 0; i < plug_mgr->used_module_num; i++) + { + struct plugin_manager_module *module = plug_mgr->modules[i]; + if (plugin_manager_module_init(module) == -1) + { + return -1; + } + double percentage = ((double)(i + 1)) / ((double)plug_mgr->used_module_num) * ((double)100); + plugin_manager_log(INFO, "Plugin initialization progress: [%.2f%]", percentage); + } + + return 0; +} + +static void plugin_manager_exit_plugins(struct plugin_manager *plug_mgr) +{ + if (plug_mgr && plug_mgr->used_module_num) + { + for (int i = 0; i < plug_mgr->used_module_num; i++) + { + struct plugin_manager_module *module = plug_mgr->modules[i]; + plugin_manager_module_exit(module); + } + } +} + +static void plugin_manager_close_plugins(struct plugin_manager *plug_mgr) +{ + if (plug_mgr && plug_mgr->used_module_num) + { + for (int i = 0; i < plug_mgr->used_module_num; i++) + { + struct plugin_manager_module *module = plug_mgr->modules[i]; + plugin_manager_module_close(module); + } + plug_mgr->used_module_num = 0; + } +} + +// deparse for destory parse +static void plugin_manager_deparse_plugins(struct plugin_manager *plug_mgr) +{ + if (plug_mgr && plug_mgr->used_config_num) { + for (int i = 0; i < plug_mgr->used_config_num; i++) + { + struct plugin_manager_config *config = plug_mgr->configs[i]; + plugin_mangager_config_destory(config); + } + plug_mgr->used_config_num = 0; } } -int plugin_manager_load(struct plugin_manager *plug_mgr, const char *plugin_file) +/****************************************************************************** + * Public API for managing plugins + ******************************************************************************/ + +int plugin_manager_load(struct plugin_manager *plug_mgr, const char *prefix, const char *file) { + if (plugin_manager_parse_plugins(plug_mgr, prefix, file) == -1) + { + return -1; + } + + if (plugin_manager_open_plugins(plug_mgr) == -1) + { + return -1; + } + + if (plugin_manager_register_plugins(plug_mgr) == -1) + { + return -1; + } + + if (plugin_manager_init_plugins(plug_mgr) == -1) + { + return -1; + } + return 0; } void plugin_manager_unload(struct plugin_manager *plug_mgr) { + plugin_manager_exit_plugins(plug_mgr); + plugin_manager_close_plugins(plug_mgr); + plugin_manager_deparse_plugins(plug_mgr); } -int plugin_manager_register(struct plugin_manager *plug_mgr, const char *session_type, fn_session_event_callback *callback) +struct plugin_manager *plugin_manager_create() +{ + struct plugin_manager *plug_mgr = safe_alloc(struct plugin_manager, 1); + + plug_mgr->used_module_num = 0; + plug_mgr->used_config_num = 0; + plug_mgr->used_evencb_num = 0; + + plug_mgr->evcb_htable = NULL; + + return plug_mgr; +} + +void plugin_manager_destory(struct plugin_manager *plug_mgr) { + if (plug_mgr) + { + if (plug_mgr->evcb_htable) + { + struct plugin_manager_eventcb *elem; + struct plugin_manager_eventcb *tmp; + HASH_ITER(hh, plug_mgr->evcb_htable, elem, tmp) + { + HASH_DEL(plug_mgr->evcb_htable, elem); + + safe_free(elem->eventcbs); + safe_free(elem); + } + + plug_mgr->evcb_htable = NULL; + plug_mgr->used_evencb_num = 0; + } + + plugin_manager_unload(plug_mgr); + safe_free(plug_mgr); + } +} + +int plugin_manager_register(struct plugin_manager *plug_mgr, const char *session_name, enum session_event_type event, fn_session_event_callback *cb) +{ + if (strlen(session_name) <= 0) + { + plugin_manager_log(ERROR, "invalid parameter, session name is empty"); + return -1; + } + + if (strlen(session_name) > MAX_SESSION_NAME_LENGTH) + { + plugin_manager_log(ERROR, "invalid parameter, session name '%s' is too long and exceeds '%d' bytes", session_name, MAX_SESSION_NAME_LENGTH); + return -1; + } + + if (cb == NULL) + { + plugin_manager_log(ERROR, "invalid parameter, the callback corresponding to the session name '%s' is null", session_name); + return -1; + } + + struct plugin_manager_eventcb *elem; + HASH_FIND_STR(plug_mgr->evcb_htable, session_name, elem); + // session_name exists, add a new cb to the end of the eventcbs dynamic array + if (elem) + { + elem->eventcbs = (struct eventcb_static *)realloc(elem->eventcbs, (elem->eventcb_num + 1) * sizeof(struct eventcb_static)); + + elem->eventcbs[elem->eventcb_num].event = event; + elem->eventcbs[elem->eventcb_num].cb = cb; + + elem->eventcb_num++; + } + // session_name does not exist, allocate a new node elem, and add elem to the hash table + else + { + elem = safe_alloc(struct plugin_manager_eventcb, 1); + memcpy(elem->session_name, session_name, strlen(session_name)); + + elem->eventcbs = (struct eventcb_static *)realloc(elem->eventcbs, (elem->eventcb_num + 1) * sizeof(struct eventcb_static)); + + elem->eventcbs[elem->eventcb_num].event = event; + elem->eventcbs[elem->eventcb_num].cb = cb; + + elem->eventcb_num++; + + HASH_ADD_STR(plug_mgr->evcb_htable, session_name, elem); + } + return 0; } void plugin_manager_dispatch(struct plugin_manager *plug_mgr, struct stellar_event *event) { - assert(event); - struct stellar_session_event_data *event_data = event->session_event_data; - assert(event_data); - session_event_type type = event_data->type; - - switch (type) - { - case SESSION_EVENT_OPENING: - plugin_manager_handle_opening_event(plug_mgr, event); - break; - case SESSION_EVENT_RAWPKT: /* fall through */ - case SESSION_EVENT_ORDPKT: /* fall through */ - case SESSION_EVENT_META: /* fall through */ - plugin_manager_handle_data_event(plug_mgr, event); - break; - case SESSION_EVENT_CLOSING: - plugin_manager_handle_closing_event(plug_mgr, event); - break; - default: - // TODO log error - break; - } -}
\ No newline at end of file + const struct stellar_session *seesion = stellar_event_get_session(event); + struct session_plugin_ctx *plug_ctx = stellar_event_get_plugin_ctx(event); + enum session_event_type event_type = stellar_event_get_type(event); + const char *session_name = stellar_event_get_session_name(event); + struct stellar_packet *packet = stellar_event_get_packet(event); + uint16_t payload_len = stellar_event_get_payload_length(event); + const char *payload = stellar_event_get_payload(event); + + assert(seesion); + assert(session_name); + + // the same session may trigger multi times opening events + if (event_type & SESSION_EVENT_OPENING) + { + if (plug_ctx == NULL) + { + plug_ctx = plugin_manager_create_plugin_ctx(plug_mgr, session_name); + if (plug_ctx == NULL) + { + plugin_manager_log(ERROR, "can't create runtime plugin ctx for session '%s', Please check whether the callback is registered in the current session"); + return; + } + stellar_event_set_plugin_ctx(event, plug_ctx); + } + } + + if (plug_ctx) + { + for (int i = 0; i < plug_ctx->eventcb_num; i++) + { + plug_ctx->current_plugin_index = i; + struct eventcb_runtime *runtime = &plug_ctx->eventcbs[i]; + if (runtime->skip) + { + continue; + } + + if (runtime->event & event_type) + { + runtime->cb(seesion, event_type, packet, payload, payload_len, &runtime->cb_args); + } + } + } + else + { + plugin_manager_log(ERROR, "session '%s' runtime plugin ctx is null when running event callback", session_name); + abort(); + } + + if (event_type & SESSION_EVENT_CLOSING) + { + plugin_manager_destory_plugin_ctx(plug_ctx); + stellar_event_set_plugin_ctx(event, NULL); + } +} + +/****************************************************************************** + * Suppport LUA plugins + ******************************************************************************/ + +// TODO
\ No newline at end of file diff --git a/src/plugin_manager/plugin_manager.h b/src/plugin_manager/plugin_manager.h index f6a12a3..4e96b06 100644 --- a/src/plugin_manager/plugin_manager.h +++ b/src/plugin_manager/plugin_manager.h @@ -1,11 +1,7 @@ - #pragma once #include "sdk/include/session.h" -#define MAX_PLUGIN_NUM 256 - -struct per_session_event_cbs; struct plugin_manager; struct plugin_manager *plugin_manager_create(); @@ -13,8 +9,8 @@ void plugin_manager_destory(struct plugin_manager *plug_mgr); // return 0: success // return -1: error -int plugin_manager_load(struct plugin_manager *plug_mgr, const char *plugin_file); +int plugin_manager_load(struct plugin_manager *plug_mgr, const char *prefix, const char *file); void plugin_manager_unload(struct plugin_manager *plug_mgr); -int plugin_manager_register(struct plugin_manager *plug_mgr, const char *session_type, fn_session_event_callback *callback); +int plugin_manager_register(struct plugin_manager *plug_mgr, const char *session_name, enum session_event_type event, fn_session_event_callback *callback); void plugin_manager_dispatch(struct plugin_manager *plug_mgr, struct stellar_event *event);
\ No newline at end of file diff --git a/src/plugin_manager/plugin_manager_config.cpp b/src/plugin_manager/plugin_manager_config.cpp new file mode 100644 index 0000000..f36512c --- /dev/null +++ b/src/plugin_manager/plugin_manager_config.cpp @@ -0,0 +1,358 @@ +#include <errno.h> +#include <stdlib.h> +#include <string.h> + +#include "toml/toml.h" +#include "sdk/include/session.h" +#include "plugin_manager_util.h" +#include "plugin_manager_config.h" + +struct event_type_map +{ + const char *type_str; + enum session_event_type type_int; +}; + +static struct event_type_map evtype_map[] = + { + {"SESSION_EVENT_OPENING", SESSION_EVENT_OPENING}, + {"SESSION_EVENT_RAWPKT", SESSION_EVENT_RAWPKT}, + {"SESSION_EVENT_ORDPKT", SESSION_EVENT_ORDPKT}, + {"SESSION_EVENT_META", SESSION_EVENT_META}, + {"SESSION_EVENT_CLOSING", SESSION_EVENT_CLOSING}, + {"SESSION_EVENT_ALL", SESSION_EVENT_ALL}, +}; + +/****************************************************************************** + * Private API (For Event Type) + ******************************************************************************/ + +static enum session_event_type event_type_str2int(const char *evtype_str) +{ + int num = sizeof(evtype_map) / sizeof(evtype_map[0]); + + for (int i = 0; i < num; i++) + { + if (strcmp(evtype_str, evtype_map[i].type_str) == 0) + { + return evtype_map[i].type_int; + } + } + + return SESSION_EVENT_UNKNOWN; +} + +static void event_type_int2str(enum session_event_type evtype_int, char *buffer, int size) +{ + int used = 0; + int num = sizeof(evtype_map) / sizeof(evtype_map[0]); + + for (int i = 0; i < num; i++) + { + if (evtype_map[i].type_int & evtype_int) + { + if (evtype_map[i].type_int == SESSION_EVENT_ALL && evtype_int != SESSION_EVENT_ALL) + { + continue; + } + used += snprintf(buffer + used, size - used, "%s ", evtype_map[i].type_str); + } + } +} + +/****************************************************************************** + * Private API (For Parse) + ******************************************************************************/ + +static int toml_parse_string(toml_table_t *table, const char *string_key, const char *file, char **out) +{ + toml_datum_t string_val = toml_string_in(table, string_key); + if (!string_val.ok) + { + plugin_manager_log(ERROR, "can't find '%s' configuration iterm in %s", string_key, file); + return -1; + } + + if (strlen(string_val.u.s) <= 0) + { + plugin_manager_log(ERROR, "invalid value for '%s' configuration item in %s", string_key, file); + safe_free(string_val.u.s); + return -1; + } + + *out = safe_dup(string_val.u.s); + safe_free(string_val.u.s); + + return 0; +} + +static int toml_parse_table(toml_table_t *table, const char *string_key, const char *file, toml_table_t **out) +{ + *out = toml_table_in(table, string_key); + if (*out == NULL) + { + plugin_manager_log(ERROR, "can't find '%s' section in %s", string_key, file); + return -1; + } + + return 0; +} + +static int toml_parse_plugin_section(toml_table_t *root, struct plugin_manager_config *config, const char *file) +{ + toml_table_t *plugin_section = NULL; + + if (toml_parse_table(root, "PLUGINFO", file, &plugin_section) == -1) + { + return -1; + } + + if (toml_parse_string(plugin_section, "INIT_FUNC", file, &config->plugin_section.init_func_name) == -1) + { + return -1; + } + + if (toml_parse_string(plugin_section, "EXIT_FUNC", file, &config->plugin_section.exit_func_name) == -1) + { + return -1; + } + + if (toml_parse_string(plugin_section, "LIBRARY_PATH", file, &config->plugin_section.lib_path) == -1) + { + return -1; + } + + return 0; +} + +static int toml_parse_session_section(toml_table_t *root, struct plugin_manager_config *config, const char *file) +{ + toml_table_t *session_section = NULL; + toml_table_t *sub_session_section = NULL; + const char *session_name = NULL; + toml_array_t *event_type_array = NULL; + toml_datum_t type_str; + enum session_event_type type_int; + + if (toml_parse_table(root, "SESSION_NAME", file, &session_section) == -1) + { + return -1; + } + + for (int i = 0; i < toml_table_ntab(session_section); i++) + { + session_name = NULL; + sub_session_section = NULL; + event_type_array = NULL; + + config->session_section = (struct session_section_config *)realloc(config->session_section, sizeof(struct session_section_config) * (config->session_section_num + 1)); + config->session_section[config->session_section_num].event = SESSION_EVENT_UNKNOWN; + config->session_section[config->session_section_num].cb_func_name = NULL; + memset(config->session_section[config->session_section_num].session_name, 0, MAX_SESSION_NAME_LENGTH); + + // parse session name + session_name = toml_key_in(session_section, i); + int session_name_len = strlen(session_name); + if (session_name_len <= 0) + { + plugin_manager_log(ERROR, "invalid value for 'SESSION_NAME' configuration item in %s", file); + return -1; + } + if (session_name_len > MAX_SESSION_NAME_LENGTH) + { + plugin_manager_log(ERROR, "invalid value for 'SESSION_NAME' configuration item in %s, '%s' is too long and exceeds %d bytes", file, session_name, MAX_SESSION_NAME_LENGTH); + return -1; + } + if (toml_parse_table(session_section, session_name, file, &sub_session_section) == -1) + { + return -1; + } + strncpy(config->session_section[config->session_section_num].session_name, session_name, session_name_len); + + // parse session event callback + if (toml_parse_string(sub_session_section, "SESSION_EVENT_CALLBACK", file, &config->session_section[config->session_section_num].cb_func_name) == -1) + { + return -1; + } + + event_type_array = toml_array_in(sub_session_section, "SESSION_EVENT_TYPE"); + if (event_type_array == NULL) + { + plugin_manager_log(ERROR, "can't find 'SESSION_EVENT_TYPE' configuration iterm in '[SESSION_NAME.%s]' section of %s", session_name, file); + return -1; + } + + for (int i = 0; i < toml_array_nelem(event_type_array); i++) + { + type_int = SESSION_EVENT_UNKNOWN; + + type_str = toml_string_at(event_type_array, i); + if (!type_str.ok) + { + plugin_manager_log(ERROR, "can't parse 'SESSION_EVENT_TYPE' configuration iterm in '[SESSION_NAME.%s]' section of %s", session_name, file); + return -1; + } + + type_int = event_type_str2int(type_str.u.s); + if (type_int == SESSION_EVENT_UNKNOWN) + { + plugin_manager_log(ERROR, "invalid value '%s' for 'SESSION_EVENT_TYPE' configuration item in '[SESSION_NAME.%s]' section of %s", type_str.u.s, session_name, file); + safe_free(type_str.u.s); + return -1; + } + + (config->session_section[config->session_section_num].event) = (enum session_event_type)((config->session_section[config->session_section_num].event) | type_int); + safe_free(type_str.u.s); + } + + config->session_section_num++; + } + + return 0; +} + +/****************************************************************************** + * Public API + ******************************************************************************/ + +struct plugin_manager_config *plugin_mangager_config_create() +{ + struct plugin_manager_config *config = safe_alloc(struct plugin_manager_config, 1); + + config->prefix_path = NULL; + config->file_path = NULL; + config->session_section_num = 0; + config->session_section = NULL; + config->plugin_section.init_func_name = NULL; + config->plugin_section.exit_func_name = NULL; + config->plugin_section.lib_path = NULL; + + return config; +} + +void plugin_mangager_config_destory(struct plugin_manager_config *config) +{ + if (config) + { + safe_free(config->prefix_path); + safe_free(config->file_path); + + safe_free(config->plugin_section.init_func_name); + safe_free(config->plugin_section.exit_func_name); + safe_free(config->plugin_section.lib_path); + + if (config->session_section) + { + for (int i = 0; i < config->session_section_num; i++) + { + struct session_section_config *temp = &config->session_section[i]; + safe_free(temp->cb_func_name); + } + config->session_section_num = 0; + safe_free(config->session_section); + } + + safe_free(config); + } +} + +void plugin_mangager_config_dump(struct plugin_manager_config *config) +{ + if (config) + { + plugin_manager_log(DEBUG, "[CONFIG_PREFIX] : %s", config->prefix_path); + plugin_manager_log(DEBUG, "[CONFIG_FILE] : %s", config->file_path); + plugin_manager_log(DEBUG, "[PLUGINFO]->INIT_FUNC : %s", config->plugin_section.init_func_name); + plugin_manager_log(DEBUG, "[PLUGINFO]->EXIT_FUNC : %s", config->plugin_section.exit_func_name); + plugin_manager_log(DEBUG, "[PLUGINFO]->LIBRARY_PATH : %s", config->plugin_section.lib_path); + + if (config->session_section) + { + for (int i = 0; i < config->session_section_num; i++) + { + char tmp_buffer[1024] = {0}; + struct session_section_config *temp = &config->session_section[i]; + event_type_int2str(temp->event, tmp_buffer, 1024); + plugin_manager_log(DEBUG, "[SESSION_NAME.%s]->SESSION_EVENT_TYPE : %d, %s", temp->session_name, temp->event, tmp_buffer); + plugin_manager_log(DEBUG, "[SESSION_NAME.%s]->SESSION_EVENT_CALLBACK : %s", temp->session_name, temp->cb_func_name); + } + } + } +} + +int plugin_mangager_config_parse(struct plugin_manager_config *config, const char *prefix, const char *file) +{ + FILE *fp = NULL; + toml_table_t *root = NULL; + char errbuf[200] = {0}; + char tmp_buffer[4096] = {0}; + + config->prefix_path = safe_dup(prefix); + config->file_path = safe_dup(file); + strcat_prefix_and_file(prefix, file, tmp_buffer, sizeof(tmp_buffer)); + + fp = fopen(tmp_buffer, "r"); + if (fp == NULL) + { + plugin_manager_log(ERROR, "can't open %s, %s", tmp_buffer, strerror(errno)); + return -1; + } + + root = toml_parse_file(fp, errbuf, sizeof(errbuf)); + if (root == NULL) + { + plugin_manager_log(ERROR, "toml parsing %s failed, %s", file, errbuf); + goto err; + } + + if (toml_parse_plugin_section(root, config, file) == -1) + { + goto err; + } + + if (toml_parse_session_section(root, config, file) == -1) + { + goto err; + } + + toml_free(root); + fclose(fp); + + return 0; + +err: + if (root) + { + toml_free(root); + } + + if (fp) + { + fclose(fp); + fp = NULL; + } + + return -1; +} + +/****************************************************************************** + * Test + ******************************************************************************/ + +#ifdef PLUGIN_MANAGER_TEST +int main(int argc, char *argv[]) +{ + struct plugin_manager_config *config = plugin_mangager_config_create(); + + if (plugin_mangager_config_parse(config, argv[1], argv[2]) == -1) + { + plugin_manager_log(ERROR, "can't parser %s %s", argv[1], argv[2]); + } + + plugin_mangager_config_dump(config); + + plugin_mangager_config_destory(config); + + return 0; +} +#endif
\ No newline at end of file diff --git a/src/plugin_manager/plugin_manager_config.h b/src/plugin_manager/plugin_manager_config.h new file mode 100644 index 0000000..fa9164d --- /dev/null +++ b/src/plugin_manager/plugin_manager_config.h @@ -0,0 +1,34 @@ +#pragma once + +#include "plugin_manager_util.h" +#include "sdk/include/session.h" + +struct session_section_config +{ + char session_name[MAX_SESSION_NAME_LENGTH]; + char *cb_func_name; + enum session_event_type event; +}; + +struct plugin_section_config +{ + char *init_func_name; + char *exit_func_name; + char *lib_path; +}; + +struct plugin_manager_config +{ + char *prefix_path; // absolute path to stellar installation + char *file_path; // relative path to stellar installation + + int session_section_num; + struct session_section_config *session_section; // array + struct plugin_section_config plugin_section; +}; + +struct plugin_manager_config *plugin_mangager_config_create(); +void plugin_mangager_config_destory(struct plugin_manager_config *config); + +int plugin_mangager_config_parse(struct plugin_manager_config *config, const char *prefix, const char *file); +void plugin_mangager_config_dump(struct plugin_manager_config *config);
\ No newline at end of file diff --git a/src/plugin_manager/plugin_manager_module.cpp b/src/plugin_manager/plugin_manager_module.cpp new file mode 100644 index 0000000..1e3011b --- /dev/null +++ b/src/plugin_manager/plugin_manager_module.cpp @@ -0,0 +1,168 @@ +#include <time.h> +#include <dlfcn.h> +#include <stdlib.h> +#include <string.h> + +#include "sdk/include/plugin.h" +#include "plugin_manager_util.h" +#include "plugin_manager_config.h" +#include "plugin_manager.h" + +struct plugin_manager_module_evcb +{ + char session_name[MAX_SESSION_NAME_LENGTH]; + fn_session_event_callback *event_cb_ptr; + enum session_event_type event; +}; + +struct plugin_manager_module +{ + char *prefix; + char *lib_path; + void *dl_handle; + + plugin_init_callback *init_cb_ptr; + plugin_exit_callback *exit_cb_ptr; + + struct plugin_manager_module_evcb *evcbs; + int evcbs_num; +}; + +void plugin_manager_module_close(struct plugin_manager_module *module) +{ + if (module) + { + if (module->exit_cb_ptr) + { + module->exit_cb_ptr(); + } + + if (module->dl_handle) + { + dlclose(module->dl_handle); + module->dl_handle = NULL; + } + + safe_free(module->prefix); + safe_free(module->lib_path); + safe_free(module->evcbs); + module->evcbs_num = 0; + + safe_free(module); + } +} + +struct plugin_manager_module *plugin_manager_module_open(struct plugin_manager_config *config) +{ + if (config == NULL) + { + return NULL; + } + + char dynamic_lib_path[4096] = {0}; + struct plugin_manager_module *module = safe_alloc(struct plugin_manager_module, 1); + + module->prefix = safe_dup(config->prefix_path); + module->lib_path = safe_dup(config->plugin_section.lib_path); + strcat_prefix_and_file(module->prefix, module->lib_path, dynamic_lib_path, sizeof(dynamic_lib_path)); + + module->evcbs_num = 0; + module->dl_handle = dlopen(dynamic_lib_path, RTLD_LAZY | RTLD_GLOBAL | RTLD_DEEPBIND); + if (module->dl_handle == NULL) + { + plugin_manager_log(ERROR, "can't dlopen %s, %s", dynamic_lib_path, dlerror()); + goto err; + } + + module->init_cb_ptr = (plugin_init_callback *)(dlsym(module->dl_handle, config->plugin_section.init_func_name)); + if (module->init_cb_ptr == NULL) + { + plugin_manager_log(ERROR, "can't find symbol name of '%s' in dynamic library %s, %s", + config->plugin_section.init_func_name, dynamic_lib_path, dlerror()); + goto err; + } + + module->exit_cb_ptr = (plugin_exit_callback *)(dlsym(module->dl_handle, config->plugin_section.exit_func_name)); + if (module->exit_cb_ptr == NULL) + { + plugin_manager_log(ERROR, "can't find symbol name of '%s' in dynamic library %s, %s", + config->plugin_section.exit_func_name, dynamic_lib_path, dlerror()); + goto err; + } + + if (config->session_section) + { + module->evcbs = safe_alloc(struct plugin_manager_module_evcb, config->session_section_num); + module->evcbs_num = config->session_section_num; + + for (int i = 0; i < config->session_section_num; i++) + { + struct session_section_config *session_config = &config->session_section[i]; + struct plugin_manager_module_evcb *event_cb = &module->evcbs[i]; + + strncpy(event_cb->session_name, session_config->session_name, strlen(session_config->session_name)); + event_cb->event = session_config->event; + event_cb->event_cb_ptr = (fn_session_event_callback *)(dlsym(module->dl_handle, session_config->cb_func_name)); + if (event_cb->event_cb_ptr == NULL) + { + plugin_manager_log(ERROR, "can't find symbol name of '%s' in dynamic library %s, %s", + session_config->cb_func_name, dynamic_lib_path, dlerror()); + goto err; + } + } + } + + return module; + +err: + plugin_manager_module_close(module); + + return NULL; +} + +int plugin_manager_module_register(struct plugin_manager *plug_mgr, struct plugin_manager_module *module) +{ + if (module && module->evcbs) + { + for (int i = 0; i < module->evcbs_num; i++) + { + struct plugin_manager_module_evcb *event_cb = &module->evcbs[i]; + + if (plugin_manager_register(plug_mgr, event_cb->session_name, event_cb->event, event_cb->event_cb_ptr) == -1) + { + plugin_manager_log(ERROR, "dynamic library '%s' failed to register the event callback function of session '%s'", module->lib_path, event_cb->session_name); + return -1; + } + } + } + + return 0; +} + +int plugin_manager_module_init(struct plugin_manager_module *module) +{ + struct timespec start; + struct timespec end; + + clock_gettime(CLOCK_MONOTONIC, &start); + int ret = module->init_cb_ptr(); + if (ret == -1) + { + plugin_manager_log(ERROR, "dynamic library '%s' initialization failed", module->lib_path); + return -1; + } + clock_gettime(CLOCK_MONOTONIC, &end); + + long elapsed = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000; + plugin_manager_log(INFO, "plugin '%s' init success, using '%lld' us", module->lib_path, elapsed); + + return 0; +} + +void plugin_manager_module_exit(struct plugin_manager_module *module) +{ + if (module && module->exit_cb_ptr) + { + module->exit_cb_ptr(); + } +} diff --git a/src/plugin_manager/plugin_manager_module.h b/src/plugin_manager/plugin_manager_module.h new file mode 100644 index 0000000..d765b4a --- /dev/null +++ b/src/plugin_manager/plugin_manager_module.h @@ -0,0 +1,12 @@ +#pragma once + +#include "plugin_manager_config.h" + +struct plugin_manager_module; + +struct plugin_manager_module *plugin_manager_module_open(struct plugin_manager_config *config); +int plugin_manager_module_register(struct plugin_manager *plug_mgr, struct plugin_manager_module *module); +int plugin_manager_module_init(struct plugin_manager_module *module); + +void plugin_manager_module_exit(struct plugin_manager_module *module); +void plugin_manager_module_close(struct plugin_manager_module *module);
\ No newline at end of file diff --git a/src/plugin_manager/plugin_manager_util.cpp b/src/plugin_manager/plugin_manager_util.cpp new file mode 100644 index 0000000..1c4337d --- /dev/null +++ b/src/plugin_manager/plugin_manager_util.cpp @@ -0,0 +1,40 @@ +#include <string.h> +#include <stdlib.h> + +#include "plugin_manager_util.h" + +char *safe_dup(const char *str) +{ + if (str == NULL) + { + return NULL; + } + + char *dup = safe_alloc(char, strlen(str) + 1); + memcpy(dup, str, strlen(str)); + + return dup; +} + +void strcat_prefix_and_file(const char *prefix, const char *file, char *buff, int size) +{ + char prefix_buffer[4096] = {0}; + char file_buffer[4096] = {0}; + char *ptr = NULL; + + memcpy(prefix_buffer, prefix, strlen(prefix)); + memcpy(file_buffer, file, strlen(file)); + + if (prefix_buffer[strlen(prefix_buffer) - 1] != '/') + { + prefix_buffer[strlen(prefix_buffer)] = '/'; + } + file_buffer[strcspn(file_buffer, "\r\n")] = 0; + + ptr = file_buffer; + if (file_buffer[0] == '.' && file_buffer[1] == '/') + { + ptr += 2; + } + snprintf(buff, size, "%s%s", prefix_buffer, ptr); +}
\ No newline at end of file diff --git a/src/plugin_manager/plugin_manager_util.h b/src/plugin_manager/plugin_manager_util.h new file mode 100644 index 0000000..9c6c0fb --- /dev/null +++ b/src/plugin_manager/plugin_manager_util.h @@ -0,0 +1,61 @@ +#pragma once + +#include <stdio.h> + +#define MAX_PLUGIN_NUM 512 +#define MAX_SESSION_NAME_LENGTH 32 + +/****************************************************************************** + * Malloc + ******************************************************************************/ + +#define safe_alloc(type, number) ((type *)calloc(number, sizeof(type))) + +#define safe_free(ptr) \ + { \ + if (ptr) \ + { \ + free(ptr); \ + ptr = NULL; \ + } \ + } + +char *safe_dup(const char *str); + +/****************************************************************************** + * Logger + ******************************************************************************/ + +enum plugin_manager_log_level +{ + DEBUG = 0x11, + INFO = 0x12, + ERROR = 0x13, +}; + +#ifndef plugin_manager_log +#define plugin_manager_log(level, format, ...) \ + { \ + switch (level) \ + { \ + case DEBUG: \ + fprintf(stdout, "PLUGIN_MANAGER [DEBUG] " format "\n", ##__VA_ARGS__); \ + fflush(stdout); \ + break; \ + case INFO: \ + fprintf(stdout, "PLUGIN_MANAGER [INFO] " format "\n", ##__VA_ARGS__); \ + fflush(stdout); \ + break; \ + case ERROR: \ + fprintf(stderr, "PLUGIN_MANAGER [ERROR] " format "\n", ##__VA_ARGS__); \ + fflush(stderr); \ + break; \ + } \ + } +#endif + +/****************************************************************************** + * Str + ******************************************************************************/ + +void strcat_prefix_and_file(const char *prefix, const char *file, char *buff, int size); diff --git a/src/plugin_manager/test/CMakeLists.txt b/src/plugin_manager/test/CMakeLists.txt new file mode 100644 index 0000000..7a1a880 --- /dev/null +++ b/src/plugin_manager/test/CMakeLists.txt @@ -0,0 +1,18 @@ +add_executable(gtest_plugin_manager + gtest_plugin_manager.cpp +) + +target_link_libraries( + gtest_plugin_manager + gtest_main + plugin_manager + session_manager + toml + dl +) + +include(GoogleTest) +gtest_discover_tests(gtest_plugin_manager) + +add_subdirectory(test_plugins/plugins_library) +file(COPY test_plugins/plugins_config DESTINATION ./)
\ No newline at end of file diff --git a/src/plugin_manager/test/gtest_plugin_manager.cpp b/src/plugin_manager/test/gtest_plugin_manager.cpp new file mode 100644 index 0000000..8107b41 --- /dev/null +++ b/src/plugin_manager/test/gtest_plugin_manager.cpp @@ -0,0 +1,159 @@ +#include <gtest/gtest.h> + +#include "../plugin_manager_config.h" +#include "../plugin_manager.h" +#include "session_manager.h" + +TEST(PLUGIN_MANAGER_TEST, plugin_manager_config_HTTP) +{ + char prefix_path[] = "./"; + char file_path[] = "./plugins_config/http_event_plugin/http_event_plugin.inf"; + + struct plugin_manager_config *config = plugin_mangager_config_create(); + EXPECT_TRUE(config != nullptr); + + EXPECT_TRUE(plugin_mangager_config_parse(config, prefix_path, file_path) == 0); + + EXPECT_STREQ(config->prefix_path, "./"); + EXPECT_STREQ(config->file_path, "./plugins_config/http_event_plugin/http_event_plugin.inf"); + EXPECT_STREQ(config->plugin_section.init_func_name, "http_event_plugin_init"); + EXPECT_STREQ(config->plugin_section.exit_func_name, "http_event_plugin_exit"); + EXPECT_STREQ(config->plugin_section.lib_path, "./test_plugins/plugins_library/http_event_plugin_test.so"); + + EXPECT_TRUE(config->session_section_num == 1); + EXPECT_STREQ(config->session_section[0].session_name, "HTTP"); + EXPECT_STREQ(config->session_section[0].cb_func_name, "http_event_plugin_entry"); + EXPECT_TRUE(config->session_section[0].event == (0x01 << 1 | 0x01 << 2 | 0x01 << 3 | 0x01 << 4 | 0x01 << 5)); + + plugin_mangager_config_dump(config); + plugin_mangager_config_destory(config); +} + +TEST(PLUGIN_MANAGER_TEST, plugin_manager_config_CUSTOM) +{ + char prefix_path[] = "./"; + char file_path[] = "./plugins_config/custom_event_plugin/custom_event_plugin.inf"; + + struct plugin_manager_config *config = plugin_mangager_config_create(); + EXPECT_TRUE(config != nullptr); + + EXPECT_TRUE(plugin_mangager_config_parse(config, prefix_path, file_path) == 0); + + EXPECT_STREQ(config->prefix_path, "./"); + EXPECT_STREQ(config->file_path, "./plugins_config/custom_event_plugin/custom_event_plugin.inf"); + EXPECT_STREQ(config->plugin_section.init_func_name, "custom_plugin_init"); + EXPECT_STREQ(config->plugin_section.exit_func_name, "custom_plugin_exit"); + EXPECT_STREQ(config->plugin_section.lib_path, "./test_plugins/plugins_library/custom_event_plugin_test.so"); + + EXPECT_TRUE(config->session_section_num == 2); + EXPECT_STREQ(config->session_section[0].session_name, "TCP"); + EXPECT_STREQ(config->session_section[0].cb_func_name, "custom_plugin_tcp_entry"); + EXPECT_TRUE(config->session_section[0].event == (0x01 << 1 | 0x01 << 2 | 0x01 << 3 | 0x01 << 4 | 0x01 << 5)); + EXPECT_STREQ(config->session_section[1].session_name, "CUSTOM"); + EXPECT_STREQ(config->session_section[1].cb_func_name, "custom_plugin_custom_entry"); + EXPECT_TRUE(config->session_section[1].event == (0x01 << 1) | (0x01 << 3) | (0x01 << 5)); + + plugin_mangager_config_dump(config); + plugin_mangager_config_destory(config); +} + +TEST(PLUGIN_MANAGER_TEST, plugin_manager_load) +{ + char prefix_path[] = "./"; + char file_path[] = "./plugins_config/plugins.inf"; + + struct plugin_manager *plug_mgr = plugin_manager_create(); + EXPECT_TRUE(plug_mgr != nullptr); + EXPECT_TRUE(plugin_manager_load(plug_mgr, prefix_path, file_path) == 0); + + plugin_manager_unload(plug_mgr); + plugin_manager_destory(plug_mgr); +} + +TEST(PLUGIN_MANAGER_TEST, plugin_manager_dispatch_HTTP) +{ + char prefix_path[] = "./"; + char file_path[] = "./plugins_config/plugins.inf"; + + const char *session_name = "HTTP"; + struct stellar_session session; + session.name = session_name; + struct stellar_session_event_data event_data; + event_data.s = &session; + event_data.plugin_ctx = NULL; // must be init to NULL + struct stellar_event event; + event.session_event_data = &event_data; + + struct plugin_manager *plug_mgr = plugin_manager_create(); + EXPECT_TRUE(plug_mgr != nullptr); + EXPECT_TRUE(plugin_manager_load(plug_mgr, prefix_path, file_path) == 0); + + event_data.type = SESSION_EVENT_OPENING; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_RAWPKT; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_ORDPKT; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_META; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_CLOSING; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_ALL; + plugin_manager_dispatch(plug_mgr, &event); + + plugin_manager_unload(plug_mgr); + plugin_manager_destory(plug_mgr); +} + +TEST(PLUGIN_MANAGER_TEST, plugin_manager_dispatch_CUSTOM) +{ + char prefix_path[] = "./"; + char file_path[] = "./plugins_config/plugins.inf"; + + const char *session_name = "CUSTOM"; + struct stellar_session session; + session.name = session_name; + struct stellar_session_event_data event_data; + event_data.s = &session; + event_data.plugin_ctx = NULL; // must be init to NULL + struct stellar_event event; + event.session_event_data = &event_data; + + struct plugin_manager *plug_mgr = plugin_manager_create(); + EXPECT_TRUE(plug_mgr != nullptr); + EXPECT_TRUE(plugin_manager_load(plug_mgr, prefix_path, file_path) == 0); + + event_data.type = SESSION_EVENT_OPENING; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_RAWPKT; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_ORDPKT; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_META; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_CLOSING; + plugin_manager_dispatch(plug_mgr, &event); + + event_data.type = SESSION_EVENT_ALL; + plugin_manager_dispatch(plug_mgr, &event); + + plugin_manager_unload(plug_mgr); + plugin_manager_destory(plug_mgr); +} + +int main(int argc, char **argv) +{ + ::testing::InitGoogleTest(&argc, argv); + int ret = RUN_ALL_TESTS(); + + return ret; +}
\ No newline at end of file diff --git a/src/plugin_manager/test/test_plugins/plugins_config/custom_event_plugin/custom_event_plugin.inf b/src/plugin_manager/test/test_plugins/plugins_config/custom_event_plugin/custom_event_plugin.inf new file mode 100644 index 0000000..26ba914 --- /dev/null +++ b/src/plugin_manager/test/test_plugins/plugins_config/custom_event_plugin/custom_event_plugin.inf @@ -0,0 +1,14 @@ +[PLUGINFO] +INIT_FUNC="custom_plugin_init" +EXIT_FUNC="custom_plugin_exit" +LIBRARY_PATH="./test_plugins/plugins_library/custom_event_plugin_test.so" + +# Support SESSION_EVENT_TYPE: "SESSION_EVENT_OPENING", "SESSION_EVENT_RAWPKT", "SESSION_EVENT_ORDPKT", "SESSION_EVENT_META", "SESSION_EVENT_CLOSING", "SESSION_EVENT_ALL" + +[SESSION_NAME.TCP] +SESSION_EVENT_TYPE=["SESSION_EVENT_ALL"] +SESSION_EVENT_CALLBACK="custom_plugin_tcp_entry" + +[SESSION_NAME.CUSTOM] +SESSION_EVENT_TYPE=["SESSION_EVENT_OPENING","SESSION_EVENT_ORDPKT","SESSION_EVENT_CLOSING"] +SESSION_EVENT_CALLBACK="custom_plugin_custom_entry"
\ No newline at end of file diff --git a/src/plugin_manager/test/test_plugins/plugins_config/http_event_plugin/http_event_plugin.inf b/src/plugin_manager/test/test_plugins/plugins_config/http_event_plugin/http_event_plugin.inf new file mode 100644 index 0000000..1dd124b --- /dev/null +++ b/src/plugin_manager/test/test_plugins/plugins_config/http_event_plugin/http_event_plugin.inf @@ -0,0 +1,10 @@ +[PLUGINFO] +INIT_FUNC="http_event_plugin_init" +EXIT_FUNC="http_event_plugin_exit" +LIBRARY_PATH="./test_plugins/plugins_library/http_event_plugin_test.so" + +# Support SESSION_EVENT_TYPE: "SESSION_EVENT_OPENING", "SESSION_EVENT_RAWPKT", "SESSION_EVENT_ORDPKT", "SESSION_EVENT_META", "SESSION_EVENT_CLOSING", "SESSION_EVENT_ALL" + +[SESSION_NAME.HTTP] +SESSION_EVENT_TYPE=["SESSION_EVENT_ALL"] +SESSION_EVENT_CALLBACK="http_event_plugin_entry"
\ No newline at end of file diff --git a/src/plugin_manager/test/test_plugins/plugins_config/plugins.inf b/src/plugin_manager/test/test_plugins/plugins_config/plugins.inf new file mode 100644 index 0000000..9382f91 --- /dev/null +++ b/src/plugin_manager/test/test_plugins/plugins_config/plugins.inf @@ -0,0 +1,4 @@ +# Relative path, relative to the installation path of stellar + +./plugins_config/http_event_plugin/http_event_plugin.inf +./plugins_config/custom_event_plugin/custom_event_plugin.inf
\ No newline at end of file diff --git a/src/plugin_manager/test/test_plugins/plugins_library/CMakeLists.txt b/src/plugin_manager/test/test_plugins/plugins_library/CMakeLists.txt new file mode 100644 index 0000000..df47c82 --- /dev/null +++ b/src/plugin_manager/test/test_plugins/plugins_library/CMakeLists.txt @@ -0,0 +1,9 @@ +add_library(custom_event_plugin_test SHARED + custom_event_plugin.cpp +) +set_target_properties(custom_event_plugin_test PROPERTIES PREFIX "") + +add_library(http_event_plugin_test SHARED + http_event_plugin.cpp +) +set_target_properties(http_event_plugin_test PROPERTIES PREFIX "")
\ No newline at end of file diff --git a/src/plugin_manager/test/test_plugins/plugins_library/custom_event_plugin.cpp b/src/plugin_manager/test/test_plugins/plugins_library/custom_event_plugin.cpp new file mode 100644 index 0000000..0d7f1c4 --- /dev/null +++ b/src/plugin_manager/test/test_plugins/plugins_library/custom_event_plugin.cpp @@ -0,0 +1,58 @@ +#include "session.h" +#include "packet.h" +#include "plugin.h" + +#include <stddef.h> +#include <stdlib.h> +#include <stdio.h> + +static char *g_handler = NULL; + +static void *custom_decode(const char *payload, uint16_t len, void **pme) +{ + return NULL; +} + +extern "C" void custom_plugin_tcp_entry(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) +{ + char **per_session_pme = (char **)pme; + + printf("RUN custom_plugin_tcp_entry, event: %d\n", event); + + struct stellar_session_event_extras *info = (struct stellar_session_event_extras *)custom_decode(payload, len, pme); + struct stellar_session *new_session = session_manager_session_derive(s, "CUSTOM"); + + session_manager_trigger_event(new_session, SESSION_EVENT_OPENING, info); + session_manager_trigger_event(new_session, SESSION_EVENT_META, info); +} + +extern "C" void custom_plugin_custom_entry(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) +{ + char **per_session_pme = (char **)pme; + + printf("RUN custom_plugin_custom_entry, event: %d\n", event); +} + +extern "C" int custom_plugin_init(void) +{ + printf("RUN custom_plugin_init\n"); + + if (g_handler == NULL) + { + g_handler = (char *)malloc(1024); + snprintf(g_handler, 1024, "222222"); + } + + return 0; +} + +extern "C" void custom_plugin_exit(void) +{ + printf("RUN custom_plugin_exit\n"); + + if (g_handler) + { + free(g_handler); + g_handler = NULL; + } +}
\ No newline at end of file diff --git a/src/plugin_manager/test/test_plugins/plugins_library/http_event_plugin.cpp b/src/plugin_manager/test/test_plugins/plugins_library/http_event_plugin.cpp new file mode 100644 index 0000000..e41d8b6 --- /dev/null +++ b/src/plugin_manager/test/test_plugins/plugins_library/http_event_plugin.cpp @@ -0,0 +1,82 @@ +#include "session.h" +#include "packet.h" +#include "plugin.h" + +#include <stdlib.h> +#include <stdio.h> + +static char *g_handler = NULL; + +struct per_session_pme_info +{ + int flag; + char data[16]; +}; + +extern "C" void http_event_plugin_entry(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) +{ + struct per_session_pme_info **per_session_pme = (struct per_session_pme_info **)pme; + + printf("RUN http_event_plugin_entry, event: %d\n", event); + + if (event & SESSION_EVENT_OPENING) + { + if (*per_session_pme == NULL) + { + struct per_session_pme_info *cur_ctx = (struct per_session_pme_info *)malloc(sizeof(struct per_session_pme_info)); + snprintf(cur_ctx->data, 6, "******"); + *per_session_pme = *&cur_ctx; + printf("http_event_plugin_entry->opening_handler\n"); + } + } + + if (event & SESSION_EVENT_RAWPKT) + { + printf("http_event_plugin_entry->rawpkt_handler\n"); + } + + if (event & SESSION_EVENT_ORDPKT) + { + printf("http_event_plugin_entry->ordpkt_handler\n"); + } + + if (event & SESSION_EVENT_META) + { + printf("http_event_plugin_entry->meta_handler\n"); + } + + if (event & SESSION_EVENT_CLOSING) + { + if (*per_session_pme) + { + printf("http_event_plugin_entry->closing_hanler\n"); + + free(*per_session_pme); + *per_session_pme = NULL; + } + } +} + +extern "C" int http_event_plugin_init(void) +{ + printf("RUN http_event_plugin_init\n"); + + if (g_handler == NULL) + { + g_handler = (char *)malloc(1024); + snprintf(g_handler, 1024, "111111"); + } + + return 0; +} + +extern "C" void http_event_plugin_exit(void) +{ + printf("RUN http_event_plugin_exit\n"); + + if (g_handler) + { + free(g_handler); + g_handler = NULL; + } +}
\ No newline at end of file diff --git a/src/protocol_decoder/http/http.cpp b/src/protocol_decoder/http/http.cpp index 408f149..b3a9205 100644 --- a/src/protocol_decoder/http/http.cpp +++ b/src/protocol_decoder/http/http.cpp @@ -1,15 +1,10 @@ -#include "http.h" -#include "session_manager.h" +#include "sdk/include/session.h" -void http_decoder(const struct stellar_session *s, int what, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) +void http_decoder(const struct stellar_session *s, enum session_event_type event, struct stellar_packet *p, const char *payload, uint16_t len, void **pme) { struct stellar_session_event_extras *info; - struct stellar_session *new_session=session_manager_session_derive(s, "HTTP"); + struct stellar_session *new_session = session_manager_session_derive(s, "HTTP"); + session_manager_trigger_event(new_session, SESSION_EVENT_OPENING, info); session_manager_trigger_event(new_session, SESSION_EVENT_META, info); -} - -int http_peek(const struct stellar_session *s, const char *payload, uint32_t len) -{ - return 0; }
\ No newline at end of file diff --git a/src/session_manager/session_manager.cpp b/src/session_manager/session_manager.cpp index ab70071..7ea5643 100644 --- a/src/session_manager/session_manager.cpp +++ b/src/session_manager/session_manager.cpp @@ -1,8 +1,12 @@ +#include <stddef.h> + +#include "sdk/include/session.h" #include "session_manager.h" struct session_manager { - struct stellar_session **tcp_table, **udp_table; + struct stellar_session **tcp_table; + struct stellar_session **udp_table; }; struct session_manager *session_manager_init() @@ -10,16 +14,12 @@ struct session_manager *session_manager_init() return nullptr; } - -void session_manager_trigger_event(struct stellar_session *s, - enum session_event_type type, - struct stellar_session_event_extras *info) +void session_manager_trigger_event(struct stellar_session *s, enum session_event_type type, struct stellar_session_event_extras *info) { return; } -struct stellar_session *session_manager_session_derive(const struct stellar_session *this_session, - const char *new_session_type_name) +struct stellar_session *session_manager_session_derive(const struct stellar_session *this_session, const char *session_name) { return nullptr; } @@ -29,8 +29,54 @@ struct stellar_event *session_manager_commit(struct session_manager *h, struct s return nullptr; }; - struct stellar_event *session_manager_fetch_event(struct session_manager *h) { return nullptr; } + +/****************************************************************************** + * API: between stellar_event and plugin_manager + ******************************************************************************/ + +struct session_plugin_ctx *stellar_event_get_plugin_ctx(struct stellar_event *event) +{ + return event->session_event_data->plugin_ctx; +} + +void stellar_event_set_plugin_ctx(struct stellar_event *event, struct session_plugin_ctx *plugin_ctx) +{ + event->session_event_data->plugin_ctx = plugin_ctx; +} + +enum session_event_type stellar_event_get_type(struct stellar_event *event) +{ + return event->session_event_data->type; +} + +const char *stellar_event_get_session_name(struct stellar_event *event) +{ + return event->session_event_data->s->name; +} + +const struct stellar_session *stellar_event_get_session(struct stellar_event *event) +{ + return event->session_event_data->s; +} + +// TODO +struct stellar_packet *stellar_event_get_packet(struct stellar_event *event) +{ + return NULL; +} + +// TODO +const char *stellar_event_get_payload(struct stellar_event *event) +{ + return NULL; +} + +// TODO +uint16_t stellar_event_get_payload_length(struct stellar_event *event) +{ + return 0; +} diff --git a/src/session_manager/session_manager.h b/src/session_manager/session_manager.h index 6d17e79..1bef25f 100644 --- a/src/session_manager/session_manager.h +++ b/src/session_manager/session_manager.h @@ -2,8 +2,6 @@ #include "sdk/include/session.h" -struct per_session_evcb_runtime_ctx; - struct stellar_session_event_data { struct stellar_session *s; @@ -18,10 +16,6 @@ struct session_manager *session_manager_init(); struct stellar_event *session_manager_commit(struct session_manager *session_mgr, struct stellar_packet *pkt); struct stellar_event *session_manager_fetch_event(struct session_manager *session_mgr); -// interfaces for data interaction between stellar event and plugin manager -struct session_plugin_ctx *stellar_event_get_plugin_ctx(struct stellar_event *event); -void stellar_event_set_plugin_ctx(struct stellar_event *event, struct session_plugin_ctx *plugin_ctx); - struct stellar_session { stellar_session_type type; @@ -29,3 +23,18 @@ struct stellar_session void *addr; void *data; }; + +/****************************************************************************** + * API: between stellar_event and plugin_manager + ******************************************************************************/ + +struct session_plugin_ctx *stellar_event_get_plugin_ctx(struct stellar_event *event); +void stellar_event_set_plugin_ctx(struct stellar_event *event, struct session_plugin_ctx *plugin_ctx); + +enum session_event_type stellar_event_get_type(struct stellar_event *event); +const char *stellar_event_get_session_name(struct stellar_event *event); +const struct stellar_session *stellar_event_get_session(struct stellar_event *event); +struct stellar_packet *stellar_event_get_packet(struct stellar_event *event); + +const char *stellar_event_get_payload(struct stellar_event *event); +uint16_t stellar_event_get_payload_length(struct stellar_event *event);
\ No newline at end of file |