trp/trp_rtable.c
trp/trp_upd.c
trp/trpc.c
- trp/trps.c include/tr_name_internal.h mon/tr_mon_req.c mon/tr_mon_req_encode.c mon/tr_mon_req_decode.c
- mon/tr_mon_resp.c mon/tr_mon.c mon/tr_mon_resp_encode.c)
+ trp/trps.c include/tr_name_internal.h mon/mon_req.c mon/mon_req_encode.c mon/mon_req_decode.c
+ mon/mon_resp.c mon/mon_common.c mon/mon_resp_encode.c)
# Does not actually build!
add_executable(trust_router ${SOURCE_FILES})
# Test build targets - for debugging
-add_executable(test_mon_req_encode mon/tr_mon.c mon/tr_mon_req.c mon/tests/test_mon_req_encode.c mon/tr_mon_req_encode.c)
+add_executable(test_mon_req_encode mon/mon_common.c mon/mon_req.c mon/tests/test_mon_req_encode.c mon/mon_req_encode.c)
target_link_libraries(test_mon_req_encode jansson talloc glib-2.0)
-add_executable(test_mon_req_decode mon/tr_mon.c mon/tr_mon_req.c mon/tests/test_mon_req_decode.c mon/tr_mon_req_decode.c)
+add_executable(test_mon_req_decode mon/mon_common.c mon/mon_req.c mon/tests/test_mon_req_decode.c mon/mon_req_decode.c)
target_link_libraries(test_mon_req_decode jansson talloc glib-2.0)
-add_executable(test_mon_resp_encode mon/tr_mon.c mon/tr_mon_req.c mon/tr_mon_resp.c mon/tr_mon_resp_encode.c common/tr_name.c mon/tests/test_mon_resp_encode.c)
+add_executable(test_mon_resp_encode mon/mon_common.c mon/mon_req.c mon/mon_resp.c mon/mon_resp_encode.c common/tr_name.c mon/tests/test_mon_resp_encode.c)
target_link_libraries(test_mon_resp_encode jansson talloc glib-2.0)
common/tr_mq.c
mon_srcs = \
- mon/tr_mon.c \
- mon/tr_mon_req.c \
- mon/tr_mon_req_encode.c \
- mon/tr_mon_req_decode.c \
- mon/tr_mon_resp.c \
- mon/tr_mon_resp_encode.c
+ mon/mon_common.c \
+ mon/mon_req.c \
+ mon/mon_req_encode.c \
+ mon/mon_req_decode.c \
+ mon/mon_resp.c \
+ mon/mon_resp_encode.c
check_PROGRAMS = common/t_constraint
TESTS = common/t_constraint
*/
-#ifndef TRUST_ROUTER_TR_MON_REQ_H
-#define TRUST_ROUTER_TR_MON_REQ_H
+#ifndef TRUST_ROUTER_MON_REQ_H
+#define TRUST_ROUTER_MON_REQ_H
#include <talloc.h>
#include <jansson.h>
#include <tr_name_internal.h>
/* Typedefs */
-typedef struct tr_mon_req TR_MON_REQ;
-typedef struct tr_mon_resp TR_MON_RESP;
+typedef struct mon_req MON_REQ;
+typedef struct mon_resp MON_RESP;
-typedef enum tr_mon_cmd TR_MON_CMD;
-typedef enum tr_mon_resp_code TR_MON_RESP_CODE;
+typedef enum mon_cmd MON_CMD;
+typedef enum mon_resp_code MON_RESP_CODE;
-typedef struct tr_mon_opt TR_MON_OPT;
-typedef enum tr_mon_opt_type TR_MON_OPT_TYPE;
+typedef struct mon_opt MON_OPT;
+typedef enum mon_opt_type MON_OPT_TYPE;
-typedef enum tr_mon_rc TR_MON_RC;
+typedef enum mon_rc MON_RC;
/* Struct and enum definitions */
-enum tr_mon_rc {
- TR_MON_SUCCESS=0,
- TR_MON_ERROR, /* generic error */
- TR_MON_BADARG, /* problem with the arguments */
- TR_MON_NOMEM, /* out of memory */
- TR_MON_NOPARSE, /* parsing failed */
+enum mon_rc {
+ MON_SUCCESS=0,
+ MON_ERROR, /* generic error */
+ MON_BADARG, /* problem with the arguments */
+ MON_NOMEM, /* out of memory */
+ MON_NOPARSE, /* parsing failed */
};
-enum tr_mon_cmd {
+enum mon_cmd {
MON_CMD_UNKNOWN=0,
MON_CMD_RECONFIGURE,
MON_CMD_SHOW
};
/* These should be explicitly numbered because they form part of the public API */
-enum tr_mon_resp_code {
+enum mon_resp_code {
MON_RESP_SUCCESS=0,
MON_RESP_ERROR=1, // generic error
};
-enum tr_mon_opt_type {
+enum mon_opt_type {
OPT_TYPE_UNKNOWN=0,
// System information
OPT_TYPE_SHOW_COMMUNITIES
};
-struct tr_mon_opt {
- TR_MON_OPT_TYPE type;
+struct mon_opt {
+ MON_OPT_TYPE type;
};
-struct tr_mon_req {
- TR_MON_CMD command;
+struct mon_req {
+ MON_CMD command;
GArray *options;
};
-struct tr_mon_resp {
- TR_MON_REQ *req; // request this responds to
- TR_MON_RESP_CODE code;
+struct mon_resp {
+ MON_REQ *req; // request this responds to
+ MON_RESP_CODE code;
TR_NAME *message;
json_t *payload;
};
/* Prototypes */
/* tr_mon.c */
-const char *cmd_to_string(TR_MON_CMD cmd);
-TR_MON_CMD cmd_from_string(const char *s);
-const char *opt_type_to_string(TR_MON_OPT_TYPE opt_type);
-TR_MON_OPT_TYPE opt_type_from_string(const char *s);
-
-/* tr_mon_req.c */
-TR_MON_REQ *tr_mon_req_new(TALLOC_CTX *mem_ctx, TR_MON_CMD cmd);
-void tr_mon_req_free(TR_MON_REQ *req);
-TR_MON_RC tr_mon_req_add_option(TR_MON_REQ *req, TR_MON_OPT_TYPE opt_type);
-size_t tr_mon_req_opt_count(TR_MON_REQ *req);
-TR_MON_OPT *tr_mon_req_opt_index(TR_MON_REQ *req, size_t index);
-
-/* tr_mon_req_encode.c */
-json_t *tr_mon_req_encode(TR_MON_REQ *req);
-
-/* tr_mon_req_decode.c */
-TR_MON_REQ *tr_mon_req_decode(TALLOC_CTX *mem_ctx, const char *req_json);
-
-/* tr_mon_resp.c */
-TR_MON_RESP *tr_mon_resp_new(TALLOC_CTX *mem_ctx,
- TR_MON_REQ *req,
- TR_MON_RESP_CODE code,
- const char *msg,
- json_t *payload);
-void tr_mon_resp_free(TR_MON_RESP *resp);
-
-/* tr_mon_resp_encode.c */
-json_t *tr_mon_resp_encode(TR_MON_RESP *resp);
-
-#endif //TRUST_ROUTER_TR_MON_REQ_H
+const char *mon_cmd_to_string(MON_CMD cmd);
+MON_CMD mon_cmd_from_string(const char *s);
+const char *mon_opt_type_to_string(MON_OPT_TYPE opt_type);
+MON_OPT_TYPE mon_opt_type_from_string(const char *s);
+
+/* mon_req.c */
+MON_REQ *mon_req_new(TALLOC_CTX *mem_ctx, MON_CMD cmd);
+void mon_req_free(MON_REQ *req);
+MON_RC mon_req_add_option(MON_REQ *req, MON_OPT_TYPE opt_type);
+size_t mon_req_opt_count(MON_REQ *req);
+MON_OPT *mon_req_opt_index(MON_REQ *req, size_t index);
+
+/* mon_req_encode.c */
+json_t *mon_req_encode(MON_REQ *req);
+
+/* mon_req_decode.c */
+MON_REQ *mon_req_decode(TALLOC_CTX *mem_ctx, const char *req_json);
+
+/* mon_resp.c */
+MON_RESP *mon_resp_new(TALLOC_CTX *mem_ctx,
+ MON_REQ *req,
+ MON_RESP_CODE code,
+ const char *msg,
+ json_t *payload);
+void mon_resp_free(MON_RESP *resp);
+
+/* mon_resp_encode.c */
+json_t *mon_resp_encode(MON_RESP *resp);
+
+#endif //TRUST_ROUTER_MON_REQ_H
#include <gmodule.h>
#include <string.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
// Monitoring common code
/**
* This method defines the command strings
*/
-const char *cmd_to_string(TR_MON_CMD cmd)
+const char *mon_cmd_to_string(MON_CMD cmd)
{
switch(cmd) {
case MON_CMD_UNKNOWN:
return NULL;
}
-// Helper macro for the cmd_from_string method
-#define return_if_matches(s, cmd) \
- do { \
- if (strcmp((s), cmd_to_string(cmd))==0) \
- return (cmd); \
+// Helper macro for the mon_cmd_from_string method
+#define return_if_matches(s, cmd) \
+ do { \
+ if (strcmp((s), mon_cmd_to_string(cmd))==0) \
+ return (cmd); \
} while(0)
-TR_MON_CMD cmd_from_string(const char *s)
+MON_CMD mon_cmd_from_string(const char *s)
{
return_if_matches(s, MON_CMD_RECONFIGURE);
return_if_matches(s, MON_CMD_SHOW);
/**
* This method defines the option type strings
*/
-const char *opt_type_to_string(TR_MON_OPT_TYPE opt_type)
+const char *mon_opt_type_to_string(MON_OPT_TYPE opt_type)
{
switch(opt_type) {
case OPT_TYPE_UNKNOWN:
return NULL;
}
-// Helper macro for the opt_type_from_string method
-#define return_if_matches(s, cmd) \
- do { \
- if (strcmp((s), opt_type_to_string(cmd))==0) \
- return (cmd); \
+// Helper macro for the mon_opt_type_from_string method
+#define return_if_matches(s, cmd) \
+ do { \
+ if (strcmp((s), mon_opt_type_to_string(cmd))==0) \
+ return (cmd); \
} while(0)
-TR_MON_OPT_TYPE opt_type_from_string(const char *s)
+MON_OPT_TYPE mon_opt_type_from_string(const char *s)
{
return_if_matches(s, OPT_TYPE_SHOW_VERSION);
return_if_matches(s, OPT_TYPE_SHOW_SERIAL);
#include <talloc.h>
#include <gmodule.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
// Monitoring request message common code
/**
* Destructor used by talloc to ensure proper cleanup
*/
-static int tr_mon_req_destructor(void *object)
+static int mon_req_destructor(void *object)
{
- TR_MON_REQ *req = talloc_get_type_abort(object, TR_MON_REQ);
+ MON_REQ *req = talloc_get_type_abort(object, MON_REQ);
if (req->options) {
g_array_unref(req->options);
}
* @param cmd command for the request
* @return newly allocated request, or null on error
*/
-TR_MON_REQ *tr_mon_req_new(TALLOC_CTX *mem_ctx, TR_MON_CMD cmd)
+MON_REQ *mon_req_new(TALLOC_CTX *mem_ctx, MON_CMD cmd)
{
- TR_MON_REQ *req=talloc(mem_ctx, TR_MON_REQ);
+ MON_REQ *req=talloc(mem_ctx, MON_REQ);
if (req) {
req->command = cmd;
- req->options = g_array_new(FALSE, FALSE, sizeof(TR_MON_OPT));
- talloc_set_destructor((void *)req, tr_mon_req_destructor);
+ req->options = g_array_new(FALSE, FALSE, sizeof(MON_OPT));
+ talloc_set_destructor((void *)req, mon_req_destructor);
}
return req;
}
*
* @param req request to free, must not be null
*/
-void tr_mon_req_free(TR_MON_REQ *req)
+void mon_req_free(MON_REQ *req)
{
talloc_free(req);
}
/**
- * Add an option to a TR_MON_REQ
+ * Add an option to a MON_REQ
* @param req request to operate on, not null
* @param opt_type type of option
- * @return TR_MON_SUCCESS on success, error code on error
+ * @return MON_SUCCESS on success, error code on error
*/
-TR_MON_RC tr_mon_req_add_option(TR_MON_REQ *req, TR_MON_OPT_TYPE opt_type)
+MON_RC mon_req_add_option(MON_REQ *req, MON_OPT_TYPE opt_type)
{
- TR_MON_OPT new_opt; // not a pointer
+ MON_OPT new_opt; // not a pointer
/* Validate parameters */
if ((req == NULL) || (opt_type == OPT_TYPE_UNKNOWN)) {
- return TR_MON_BADARG;
+ return MON_BADARG;
}
new_opt.type = opt_type;
/* Add the new option to the list */
g_array_append_val(req->options, new_opt);
- return TR_MON_SUCCESS;
+ return MON_SUCCESS;
}
-size_t tr_mon_req_opt_count(TR_MON_REQ *req)
+size_t mon_req_opt_count(MON_REQ *req)
{
return req->options->len;
}
-TR_MON_OPT *tr_mon_req_opt_index(TR_MON_REQ *req, size_t index)
+MON_OPT *mon_req_opt_index(MON_REQ *req, size_t index)
{
- TR_MON_OPT *result = &g_array_index(req->options, TR_MON_OPT, index);
+ MON_OPT *result = &g_array_index(req->options, MON_OPT, index);
return result;
}
#include <talloc.h>
#include <jansson.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
// Monitoring request decoders
*
* @param opt_json JSON object reference
* @param dest allocated memory for the result
- * @return TR_MON_SUCCESS on success, error on error
+ * @return MON_SUCCESS on success, error on error
*/
-static TR_MON_RC tr_mon_decode_one_opt(json_t *opt_json, TR_MON_OPT *dest)
+static MON_RC mon_decode_one_opt(json_t *opt_json, MON_OPT *dest)
{
json_t *jstr = NULL;
- TR_MON_OPT_TYPE opt_type = OPT_TYPE_UNKNOWN;
+ MON_OPT_TYPE opt_type = OPT_TYPE_UNKNOWN;
if ( (opt_json == NULL) || (dest == NULL))
- return TR_MON_BADARG;
+ return MON_BADARG;
if (! json_is_object(opt_json))
- return TR_MON_NOPARSE;
+ return MON_NOPARSE;
jstr = json_object_get(opt_json, "type");
if ( (jstr == NULL) || (! json_is_string(jstr)) )
- return TR_MON_NOPARSE;
+ return MON_NOPARSE;
- opt_type = opt_type_from_string(json_string_value(jstr));
+ opt_type = mon_opt_type_from_string(json_string_value(jstr));
if (opt_type == OPT_TYPE_UNKNOWN)
- return TR_MON_NOPARSE;
+ return MON_NOPARSE;
dest->type = opt_type;
- return TR_MON_SUCCESS;
+ return MON_SUCCESS;
}
/**
* [{option}, {option}, ...]
*
*/
-static TR_MON_RC tr_mon_options_decode(json_t *opts_json, TR_MON_REQ *req)
+static MON_RC mon_options_decode(json_t *opts_json, MON_REQ *req)
{
- TR_MON_OPT opt; // not a pointer
+ MON_OPT opt; // not a pointer
size_t n_opts=0;
size_t ii=0;
if ( (opts_json == NULL) || (req == NULL))
- return TR_MON_BADARG;
+ return MON_BADARG;
if (! json_is_array(opts_json))
- return TR_MON_NOPARSE;
+ return MON_NOPARSE;
n_opts = json_array_size(opts_json);
for (ii=0; ii < n_opts; ii++) {
- if (tr_mon_decode_one_opt(json_array_get(opts_json, ii),
- &opt) != TR_MON_SUCCESS) {
- return TR_MON_NOPARSE;
+ if (mon_decode_one_opt(json_array_get(opts_json, ii),
+ &opt) != MON_SUCCESS) {
+ return MON_NOPARSE;
}
- tr_mon_req_add_option(req, opt.type);
+ mon_req_add_option(req, opt.type);
}
- return TR_MON_SUCCESS;
+ return MON_SUCCESS;
}
/**
* Parse JSON for a request
*/
-static json_t *tr_mon_req_parse(const char *input)
+static json_t *mon_req_parse(const char *input)
{
json_t *parsed_json = NULL;
json_error_t json_error;
*
* (options are optional)
*
- * Caller must free the return value with tr_mon_req_free().
+ * Caller must free the return value with MON_REQ_free().
*
* @param mem_ctx talloc context for the returned struct
* @param req_json reference to JSON request object
* @return decoded request struct or NULL on failure
*/
-TR_MON_REQ *tr_mon_req_decode(TALLOC_CTX *mem_ctx, const char *req_str)
+MON_REQ *mon_req_decode(TALLOC_CTX *mem_ctx, const char *req_str)
{
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
- TR_MON_REQ *req = NULL;
+ MON_REQ *req = NULL;
json_t *req_json = NULL;
json_t *jval = NULL;
json_t *opts_json = NULL;
- TR_MON_CMD cmd = MON_CMD_UNKNOWN;
+ MON_CMD cmd = MON_CMD_UNKNOWN;
- req_json = tr_mon_req_parse(req_str); // TODO: Check errors
+ req_json = mon_req_parse(req_str); // TODO: Check errors
if (! json_is_object(req_json))
goto cleanup;
if (! json_is_string(jval))
goto cleanup;
- cmd = cmd_from_string(json_string_value(jval));
+ cmd = mon_cmd_from_string(json_string_value(jval));
if (cmd == MON_CMD_UNKNOWN)
goto cleanup;
/* Command is good. Allocate the request in the tmp context */
- req = tr_mon_req_new(tmp_ctx, cmd);
+ req = mon_req_new(tmp_ctx, cmd);
if (req == NULL)
goto cleanup;
/* Parse options if we have any */
opts_json = json_object_get(req_json, "options");
if (opts_json) {
- if (tr_mon_options_decode(opts_json, req) != TR_MON_SUCCESS) {
+ if (mon_options_decode(opts_json, req) != MON_SUCCESS) {
req = NULL; // memory still in tmp_ctx, so it will be cleaned up
goto cleanup;
}
#include <jansson.h>
#include <glib.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
// Monitoring request encoders
* @param opts array of options
* @return reference to a JSON array of options
*/
-static json_t *tr_mon_opts_decode(GArray *opts)
+static json_t *mon_opts_decode(GArray *opts)
{
json_t *array_json = json_array(); // the array of options
json_t *opt_json = NULL; // individual option JSON object
json_t *type_json = NULL;
guint ii = 0;
- TR_MON_OPT this_opt;
+ MON_OPT this_opt;
if (array_json == NULL)
return NULL; // failed
/* Iterate over the options */
for (ii=0; ii < opts->len; ii++) {
- this_opt = g_array_index(opts, TR_MON_OPT, ii);
+ this_opt = g_array_index(opts, MON_OPT, ii);
/* Create the JSON object for this option */
opt_json = json_object();
}
/* Create the type string for this option */
- type_json = json_string(opt_type_to_string(this_opt.type));
+ type_json = json_string(mon_opt_type_to_string(this_opt.type));
if (type_json == NULL) {
json_decref(array_json);
return NULL;
* Format:
* {
* "command": "some_command",
- * "options": [...see tr_mon_opts_to_json()...]
+ * "options": [...see mon_opts_to_json()...]
* }
*
* @param req request to encode
* @return reference to a JSON object
*/
-json_t *tr_mon_req_encode(TR_MON_REQ *req)
+json_t *mon_req_encode(MON_REQ *req)
{
json_t *req_json = NULL;
json_t *cmd_json = NULL;
return NULL;
/* Allocate the JSON string for the command */
- cmd_json = json_string(cmd_to_string(req->command));
+ cmd_json = json_string(mon_cmd_to_string(req->command));
if (cmd_json == NULL) {
json_decref(req_json);
return NULL;
/* If we have options, add them to the object */
if (req->options->len > 0) {
- opts_json = tr_mon_opts_decode(req->options);
+ opts_json = mon_opts_decode(req->options);
if (opts_json == NULL) {
json_decref(req_json);
return NULL;
#include <talloc.h>
#include <tr_name_internal.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
// Monitoring request message common code
/**
* Destructor used by talloc to ensure proper cleanup
*/
-static int tr_mon_resp_destructor(void *object)
+static int mon_resp_destructor(void *object)
{
- TR_MON_RESP *resp = talloc_get_type_abort(object, TR_MON_RESP);
+ MON_RESP *resp = talloc_get_type_abort(object, MON_RESP);
/* free the message */
if (resp->message) {
tr_free_name(resp->message);
/**
* Allocate a new monitoring response
*
- * Caller must free using tr_mon_resp_free().
+ * Caller must free using mon_resp_free().
*
* Makes its own copy of the message, so caller can dispose of
* that after allocating the response.
* calling this.
*
* @param mem_ctx talloc context for allocation
- * @param req TR_MON_REQ this response corresponds to
+ * @param req MON_REQ this response corresponds to
* @param code numeric response code
* @param msg string description of response code
* @param payload JSON object to be send as payload, or null for no payload
* @return response allocated in the requested talloc context, null on failure
*/
-TR_MON_RESP *tr_mon_resp_new(TALLOC_CTX *mem_ctx,
- TR_MON_REQ *req,
- TR_MON_RESP_CODE code,
- const char *msg,
- json_t *payload)
+MON_RESP *mon_resp_new(TALLOC_CTX *mem_ctx,
+ MON_REQ *req,
+ MON_RESP_CODE code,
+ const char *msg,
+ json_t *payload)
{
- TR_MON_RESP *resp = talloc(mem_ctx, TR_MON_RESP);
+ MON_RESP *resp = talloc(mem_ctx, MON_RESP);
if (resp) {
resp->req = req;
resp->code = code;
resp->message = tr_new_name(msg);
resp->payload = payload;
- talloc_set_destructor((void *)resp, tr_mon_resp_destructor);
+ talloc_set_destructor((void *)resp, mon_resp_destructor);
if (resp->message == NULL) {
talloc_free(resp); // destructor will be called
resp = NULL;
*
* @param resp request to free, must not be null
*/
-void tr_mon_resp_free(TR_MON_RESP *resp)
+void mon_resp_free(MON_RESP *resp)
{
talloc_free(resp);
}
#include <talloc.h>
#include <jansson.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
/* Helper for encoding. Adds a newly allocated JSON object to
* jobj. If the allocation or setting fails, returns NULL after
* @param resp response to encode
* @return response as a newly allocated JSON object
*/
-json_t *tr_mon_resp_encode(TR_MON_RESP *resp)
+json_t *mon_resp_encode(MON_RESP *resp)
{
json_t *resp_json = NULL;
json_t *jval = NULL;
/* If we have a payload, add it */
if (resp->payload) {
- cmd_str = cmd_to_string(resp->req->command); // key for the response payload
+ cmd_str = mon_cmd_to_string(resp->req->command); // key for the response payload
object_set_or_free_and_return(resp_json, jval, cmd_str, resp->payload);
}
#include <string.h>
#include <glib.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
/**
* @return reconfigure command
*/
-static TR_MON_REQ *reconfigure()
+static MON_REQ *reconfigure()
{
- TR_MON_REQ *req = tr_mon_req_new(NULL, MON_CMD_RECONFIGURE);
+ MON_REQ *req = mon_req_new(NULL, MON_CMD_RECONFIGURE);
assert(req);
return req;
}
/**
* @return show command with no options
*/
-static TR_MON_REQ *show_plain()
+static MON_REQ *show_plain()
{
- TR_MON_REQ *req = tr_mon_req_new(NULL, MON_CMD_SHOW);
+ MON_REQ *req = mon_req_new(NULL, MON_CMD_SHOW);
assert(req);
return req;
}
* @param opts array of option types, terminated with OPT_TYPE_UNKNOWN
* @return show command with the requested options, excluding the terminator
*/
-static TR_MON_REQ *show_options(const TR_MON_OPT_TYPE *opts)
+static MON_REQ *show_options(const MON_OPT_TYPE *opts)
{
- TR_MON_REQ *req = tr_mon_req_new(NULL, MON_CMD_SHOW);
+ MON_REQ *req = mon_req_new(NULL, MON_CMD_SHOW);
assert(req);
while (*opts != OPT_TYPE_UNKNOWN) {
- assert(TR_MON_SUCCESS == tr_mon_req_add_option(req, *opts));
+ assert(MON_SUCCESS == mon_req_add_option(req, *opts));
opts++;
}
return req;
/**
* @return show command with every option
*/
-static TR_MON_REQ *show_all_options()
+static MON_REQ *show_all_options()
{
- TR_MON_OPT_TYPE opts[] = {
+ MON_OPT_TYPE opts[] = {
OPT_TYPE_SHOW_SERIAL,
OPT_TYPE_SHOW_VERSION,
OPT_TYPE_SHOW_UPTIME,
return s;
}
-static int equal(TR_MON_REQ *r1, TR_MON_REQ *r2)
+static int equal(MON_REQ *r1, MON_REQ *r2)
{
size_t ii;
if (r1->command != r2->command)
return 0;
- if (tr_mon_req_opt_count(r1) != tr_mon_req_opt_count(r2))
+ if (mon_req_opt_count(r1) != mon_req_opt_count(r2))
return 0;
- for (ii=0; ii < tr_mon_req_opt_count(r1); ii++) {
- if (tr_mon_req_opt_index(r1, ii)->type != tr_mon_req_opt_index(r2, ii)->type)
+ for (ii=0; ii < mon_req_opt_count(r1); ii++) {
+ if (mon_req_opt_index(r1, ii)->type != mon_req_opt_index(r2, ii)->type)
return 0;
}
return 1;
}
-static int run_test(const char *filename, TR_MON_REQ *(generator)())
+static int run_test(const char *filename, MON_REQ *(generator)())
{
- TR_MON_REQ *req = NULL;
- TR_MON_REQ *expected = NULL;
+ MON_REQ *req = NULL;
+ MON_REQ *expected = NULL;
char *req_json_str = NULL;
expected = generator();
req_json_str = read_file(filename);
assert(req_json_str);
- req = tr_mon_req_decode(NULL, req_json_str);
+ req = mon_req_decode(NULL, req_json_str);
assert(req);
assert(equal(req, expected));
free(req_json_str);
- tr_mon_req_free(req);
- tr_mon_req_free(expected);
+ mon_req_free(req);
+ mon_req_free(expected);
return 1;
}
#include <string.h>
#include <glib.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
#define JSON_DUMP_OPTS 0
static char *reconfigure()
{
- TR_MON_REQ *req = tr_mon_req_new(NULL, MON_CMD_RECONFIGURE);
- json_t *req_json = tr_mon_req_encode(req);
+ MON_REQ *req = mon_req_new(NULL, MON_CMD_RECONFIGURE);
+ json_t *req_json = mon_req_encode(req);
char *result = json_dumps(req_json, JSON_DUMP_OPTS);
assert(req);
assert(req_json);
assert(result);
json_decref(req_json);
- tr_mon_req_free(req);
+ mon_req_free(req);
return result;
}
static char *show_plain()
{
- TR_MON_REQ *req = tr_mon_req_new(NULL, MON_CMD_SHOW);
- json_t *req_json = tr_mon_req_encode(req);
+ MON_REQ *req = mon_req_new(NULL, MON_CMD_SHOW);
+ json_t *req_json = mon_req_encode(req);
char *result = json_dumps(req_json, JSON_DUMP_OPTS);
assert(req);
assert(req_json);
assert(result);
json_decref(req_json);
- tr_mon_req_free(req);
+ mon_req_free(req);
return result;
}
-static char *show_options(const TR_MON_OPT_TYPE *opts)
+static char *show_options(const MON_OPT_TYPE *opts)
{
- TR_MON_REQ *req = tr_mon_req_new(NULL, MON_CMD_SHOW);
+ MON_REQ *req = mon_req_new(NULL, MON_CMD_SHOW);
json_t *req_json = NULL;
char *result = NULL;
assert(req);
while (*opts != OPT_TYPE_UNKNOWN) {
- assert(TR_MON_SUCCESS == tr_mon_req_add_option(req, *opts));
+ assert(MON_SUCCESS == mon_req_add_option(req, *opts));
opts++;
}
- req_json = tr_mon_req_encode(req);
+ req_json = mon_req_encode(req);
assert(req_json);
result = json_dumps(req_json, JSON_DUMP_OPTS);
assert(result);
json_decref(req_json);
- tr_mon_req_free(req);
+ mon_req_free(req);
return result;
}
int main(void)
{
char *s = NULL;
- TR_MON_OPT_TYPE opts[10];
+ MON_OPT_TYPE opts[10];
char *expected = NULL;
// Test reconfigure command
#include <assert.h>
#include <string.h>
-#include <tr_mon.h>
+#include <mon_internal.h>
#define JSON_DUMP_OPTS 0
-static char *reconfigure(TR_MON_RESP_CODE code, const char *message)
+static char *reconfigure(MON_RESP_CODE code, const char *message)
{
- TR_MON_REQ *req = NULL;
- TR_MON_RESP *resp = NULL;
+ MON_REQ *req = NULL;
+ MON_RESP *resp = NULL;
json_t *resp_json = NULL;
char *result = NULL;
- req = tr_mon_req_new(NULL, MON_CMD_RECONFIGURE);
+ req = mon_req_new(NULL, MON_CMD_RECONFIGURE);
assert(req);
- resp = tr_mon_resp_new(NULL, req, code, message, NULL);
+ resp = mon_resp_new(NULL, req, code, message, NULL);
assert(resp);
- resp_json = tr_mon_resp_encode(resp);
+ resp_json = mon_resp_encode(resp);
assert(resp_json);
result = json_dumps(resp_json, JSON_DUMP_OPTS);
assert(result);
json_decref(resp_json);
- tr_mon_resp_free(resp);
- tr_mon_req_free(req);
+ mon_resp_free(resp);
+ mon_req_free(req);
return result;
}
static char *show_success()
{
- TR_MON_REQ *req = NULL;
- TR_MON_RESP *resp = NULL;
+ MON_REQ *req = NULL;
+ MON_RESP *resp = NULL;
json_t *resp_json = NULL;
json_t *payload = NULL;
char *result = NULL;
- req = tr_mon_req_new(NULL, MON_CMD_SHOW);
+ req = mon_req_new(NULL, MON_CMD_SHOW);
// Only need the command to be set in req, don't actually need the options
assert(req);
payload = json_object();
assert(payload);
assert(! json_object_set_new(payload,
- opt_type_to_string(OPT_TYPE_SHOW_VERSION),
+ mon_opt_type_to_string(OPT_TYPE_SHOW_VERSION),
json_string("1.2.3-4")));
assert(! json_object_set_new(payload,
- opt_type_to_string(OPT_TYPE_SHOW_SERIAL),
+ mon_opt_type_to_string(OPT_TYPE_SHOW_SERIAL),
json_integer(1234567890)));
assert(! json_object_set_new(payload,
- opt_type_to_string(OPT_TYPE_SHOW_SERIAL),
+ mon_opt_type_to_string(OPT_TYPE_SHOW_SERIAL),
json_integer(86400)));
assert(! json_object_set_new(payload,
- opt_type_to_string(OPT_TYPE_SHOW_TID_REQ_PENDING),
+ mon_opt_type_to_string(OPT_TYPE_SHOW_TID_REQ_PENDING),
json_integer(13)));
assert(! json_object_set_new(payload,
- opt_type_to_string(OPT_TYPE_SHOW_TID_REQ_COUNT),
+ mon_opt_type_to_string(OPT_TYPE_SHOW_TID_REQ_COUNT),
json_integer(1432)));
- resp = tr_mon_resp_new(NULL, req, MON_RESP_SUCCESS, "success", payload);
+ resp = mon_resp_new(NULL, req, MON_RESP_SUCCESS, "success", payload);
assert(resp);
- resp_json = tr_mon_resp_encode(resp);
+ resp_json = mon_resp_encode(resp);
assert(resp_json);
result = json_dumps(resp_json, JSON_DUMP_OPTS);
assert(result);
json_decref(resp_json);
- tr_mon_resp_free(resp);
- tr_mon_req_free(req);
+ mon_resp_free(resp);
+ mon_req_free(req);
return result;
}
projects / trust_router.git / commitdiff