From: Jennifer Richards Date: Wed, 11 Apr 2018 21:29:48 +0000 (-0400) Subject: Change tr_mon_ prefix to mon_, no functional changes X-Git-Tag: 3.4.0~1^2~50^2 X-Git-Url: http://www.project-moonshot.org/gitweb/?p=trust_router.git;a=commitdiff_plain;h=34a48da22180b477dccb83cd5baa844f754ba9b9 Change tr_mon_ prefix to mon_, no functional changes This better matches other protocol submodule naming (tid_, trp_, gss_) --- diff --git a/CMakeLists.txt b/CMakeLists.txt index a0c2ff6..5d30c36 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -90,18 +90,18 @@ set(SOURCE_FILES 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) diff --git a/Makefile.am b/Makefile.am index ddfd8d2..845ce17 100644 --- a/Makefile.am +++ b/Makefile.am @@ -38,12 +38,12 @@ common/tr_config.c \ 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 diff --git a/include/tr_mon.h b/include/mon_internal.h similarity index 55% rename from include/tr_mon.h rename to include/mon_internal.h index dc255ba..58cfdee 100644 --- a/include/tr_mon.h +++ b/include/mon_internal.h @@ -33,8 +33,8 @@ */ -#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 #include @@ -42,40 +42,40 @@ #include /* 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 @@ -92,51 +92,51 @@ enum tr_mon_opt_type { 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 diff --git a/mon/tr_mon.c b/mon/mon_common.c similarity index 80% rename from mon/tr_mon.c rename to mon/mon_common.c index 6c613c9..d0317f7 100644 --- a/mon/tr_mon.c +++ b/mon/mon_common.c @@ -37,14 +37,14 @@ #include #include -#include +#include // 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: @@ -59,14 +59,14 @@ const char *cmd_to_string(TR_MON_CMD cmd) 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); @@ -77,7 +77,7 @@ TR_MON_CMD cmd_from_string(const char *s) /** * 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: @@ -107,14 +107,14 @@ const char *opt_type_to_string(TR_MON_OPT_TYPE opt_type) 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); diff --git a/mon/tr_mon_req.c b/mon/mon_req.c similarity index 74% rename from mon/tr_mon_req.c rename to mon/mon_req.c index 1660ca4..dd9de4d 100644 --- a/mon/tr_mon_req.c +++ b/mon/mon_req.c @@ -36,16 +36,16 @@ #include #include -#include +#include // 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); } @@ -59,13 +59,13 @@ static int tr_mon_req_destructor(void *object) * @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; } @@ -75,40 +75,40 @@ TR_MON_REQ *tr_mon_req_new(TALLOC_CTX *mem_ctx, TR_MON_CMD cmd) * * @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; } diff --git a/mon/tr_mon_req_decode.c b/mon/mon_req_decode.c similarity index 75% rename from mon/tr_mon_req_decode.c rename to mon/mon_req_decode.c index ed97a24..c1eeed1 100644 --- a/mon/tr_mon_req_decode.c +++ b/mon/mon_req_decode.c @@ -36,7 +36,7 @@ #include #include -#include +#include // Monitoring request decoders @@ -48,29 +48,29 @@ * * @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; } /** @@ -80,33 +80,33 @@ static TR_MON_RC tr_mon_decode_one_opt(json_t *opt_json, TR_MON_OPT *dest) * [{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; @@ -126,22 +126,22 @@ static json_t *tr_mon_req_parse(const char *input) * * (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; @@ -151,19 +151,19 @@ TR_MON_REQ *tr_mon_req_decode(TALLOC_CTX *mem_ctx, const char *req_str) 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; } diff --git a/mon/tr_mon_req_encode.c b/mon/mon_req_encode.c similarity index 91% rename from mon/tr_mon_req_encode.c rename to mon/mon_req_encode.c index 4239b12..5bcf8b2 100644 --- a/mon/tr_mon_req_encode.c +++ b/mon/mon_req_encode.c @@ -37,7 +37,7 @@ #include #include -#include +#include // Monitoring request encoders @@ -54,20 +54,20 @@ * @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(); @@ -83,7 +83,7 @@ static json_t *tr_mon_opts_decode(GArray *opts) } /* 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; @@ -108,13 +108,13 @@ static json_t *tr_mon_opts_decode(GArray *opts) * 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; @@ -126,7 +126,7 @@ json_t *tr_mon_req_encode(TR_MON_REQ *req) 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; @@ -142,7 +142,7 @@ json_t *tr_mon_req_encode(TR_MON_REQ *req) /* 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; diff --git a/mon/tr_mon_resp.c b/mon/mon_resp.c similarity index 82% rename from mon/tr_mon_resp.c rename to mon/mon_resp.c index a8c8f9d..e1f0761 100644 --- a/mon/tr_mon_resp.c +++ b/mon/mon_resp.c @@ -36,16 +36,16 @@ #include #include -#include +#include // 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); @@ -60,7 +60,7 @@ static int tr_mon_resp_destructor(void *object) /** * 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. @@ -72,25 +72,25 @@ static int tr_mon_resp_destructor(void *object) * 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; @@ -104,7 +104,7 @@ TR_MON_RESP *tr_mon_resp_new(TALLOC_CTX *mem_ctx, * * @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); } diff --git a/mon/tr_mon_resp_encode.c b/mon/mon_resp_encode.c similarity index 95% rename from mon/tr_mon_resp_encode.c rename to mon/mon_resp_encode.c index 19af8c0..2a6e5fe 100644 --- a/mon/tr_mon_resp_encode.c +++ b/mon/mon_resp_encode.c @@ -35,7 +35,7 @@ #include #include -#include +#include /* Helper for encoding. Adds a newly allocated JSON object to * jobj. If the allocation or setting fails, returns NULL after @@ -62,7 +62,7 @@ * @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; @@ -79,7 +79,7 @@ json_t *tr_mon_resp_encode(TR_MON_RESP *resp) /* 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); } diff --git a/mon/tests/test_mon_req_decode.c b/mon/tests/test_mon_req_decode.c index 38ee66f..63570b9 100644 --- a/mon/tests/test_mon_req_decode.c +++ b/mon/tests/test_mon_req_decode.c @@ -8,14 +8,14 @@ #include #include -#include +#include /** * @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; } @@ -23,9 +23,9 @@ static TR_MON_REQ *reconfigure() /** * @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; } @@ -34,13 +34,13 @@ static TR_MON_REQ *show_plain() * @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; @@ -49,9 +49,9 @@ static TR_MON_REQ *show_options(const TR_MON_OPT_TYPE *opts) /** * @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, @@ -80,28 +80,28 @@ static char *read_file(const char *filename) 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(); @@ -110,13 +110,13 @@ static int run_test(const char *filename, TR_MON_REQ *(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; } diff --git a/mon/tests/test_mon_req_encode.c b/mon/tests/test_mon_req_encode.c index 60fe9ca..80811fd 100644 --- a/mon/tests/test_mon_req_encode.c +++ b/mon/tests/test_mon_req_encode.c @@ -8,57 +8,57 @@ #include #include -#include +#include #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; } @@ -78,7 +78,7 @@ static char *read_file(const char *filename) int main(void) { char *s = NULL; - TR_MON_OPT_TYPE opts[10]; + MON_OPT_TYPE opts[10]; char *expected = NULL; // Test reconfigure command diff --git a/mon/tests/test_mon_resp_encode.c b/mon/tests/test_mon_resp_encode.c index 9f9a3bb..b4ecdfe 100644 --- a/mon/tests/test_mon_resp_encode.c +++ b/mon/tests/test_mon_resp_encode.c @@ -7,32 +7,32 @@ #include #include -#include +#include #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; } @@ -48,46 +48,46 @@ static char *reconfigure_error() 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; }