diff options
27 files changed, 609 insertions, 530 deletions
diff --git a/.gitignore b/.gitignore index 52ecb4eba..869c74668 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ build* .ccls-cache/ compile_commands.json +.vscode
\ No newline at end of file diff --git a/cmake/Modules/GTestImport.cmake b/cmake/Modules/GTestImport.cmake index 938dec786..cdca922d6 100644 --- a/cmake/Modules/GTestImport.cmake +++ b/cmake/Modules/GTestImport.cmake @@ -19,6 +19,12 @@ ExternalProject_Add(gtest URL https://github.com/google/googletest/archive/v1.10.x.zip PREFIX ${CMAKE_BINARY_DIR}/gtest INSTALL_COMMAND "" + + # Necessary to build using ninja + BUILD_BYPRODUCTS "${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgmock.a" + BUILD_BYPRODUCTS "${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgmock_main.a" + BUILD_BYPRODUCTS "${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgtest_main.a" + BUILD_BYPRODUCTS "${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgtest.a" ) ExternalProject_Get_Property(gtest source_dir binary_dir) diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl/commands.h b/ctrl/libhicnctrl/includes/hicn/ctrl/commands.h index d8e5329b3..767ef98a3 100644 --- a/ctrl/libhicnctrl/includes/hicn/ctrl/commands.h +++ b/ctrl/libhicnctrl/includes/hicn/ctrl/commands.h @@ -43,47 +43,6 @@ typedef struct in6_addr ipv6_addr_t; typedef uint32_t ipv4_addr_t; typedef enum { - REQUEST_LIGHT = 0xc0, // this is a command - RESPONSE_LIGHT, - ACK_LIGHT, - NACK_LIGHT, - LAST_MSG_TYPE_VALUE -} message_type; - -typedef enum { - ADD_LISTENER = 0, - ADD_CONNECTION, - LIST_CONNECTIONS, - ADD_ROUTE, - LIST_ROUTES, - REMOVE_CONNECTION, - REMOVE_LISTENER, - REMOVE_ROUTE, - CACHE_STORE, - CACHE_SERVE, - CACHE_CLEAR, - SET_STRATEGY, - SET_WLDR, - ADD_PUNTING, - LIST_LISTENERS, - MAPME_ENABLE, - MAPME_DISCOVERY, - MAPME_TIMESCALE, - MAPME_RETX, - MAPME_SEND_UPDATE, - CONNECTION_SET_ADMIN_STATE, -#ifdef WITH_POLICY - ADD_POLICY, - LIST_POLICIES, - REMOVE_POLICY, - UPDATE_CONNECTION, - CONNECTION_SET_PRIORITY, - CONNECTION_SET_TAGS, -#endif /* WITH_POLICY */ - LAST_COMMAND_VALUE -} command_id; - -typedef enum { ADDR_INET = 1, ADDR_INET6, ADDR_LINK, @@ -98,58 +57,144 @@ typedef enum { HICN_CONN } connection_type; -typedef enum { ACTIVATE_ON, ACTIVATE_OFF } activate_type; +typedef struct in6_addr ipv6_addr_t; +typedef uint32_t ipv4_addr_t; -//========== HEADER ========== +typedef enum { + MESSAGE_COMMAND_SUBTYPE_UNDEFINED, + REQUEST_LIGHT = 0xc0, // this is a command + RESPONSE_LIGHT, + ACK_LIGHT, + NACK_LIGHT, + MESSAGE_COMMAND_SUBTYPE_N +} message_command_subtype_t; + +#define message_type_is_valid(message_type) \ + ((message_type != MESSAGE_TYPE_UNDEFINED) && (message_type != MESSAGE_COMMAND_SUBTYPE_N)) + +#define message_type_from_uchar(x) \ + (((x) < REQUEST_LIGHT) || (((x) >= MESSAGE_COMMAND_SUBTYPE_N)) ? MESSAGE_COMMAND_SUBTYPE_N : (message_command_subtype_t)(x)) + +#define foreach_command_type \ + _(listener_add, LISTENER_ADD) \ + _(listener_remove, LISTENER_REMOVE) \ + _(listener_list, LISTENER_LIST) \ + _(connection_add, CONNECTION_ADD) \ + _(connection_remove, CONNECTION_REMOVE) \ + _(connection_list, CONNECTION_LIST) \ + _(connection_set_admin_state, CONNECTION_SET_ADMIN_STATE) \ + _(connection_update, CONNECTION_UPDATE) \ + _(connection_set_priority, CONNECTION_SET_PRIORITY) \ + _(connection_set_tags, CONNECTION_SET_TAGS) \ + _(route_add, ROUTE_ADD) \ + _(route_remove, ROUTE_REMOVE) \ + _(route_list, ROUTE_LIST) \ + _(cache_set_store, CACHE_SET_STORE) \ + _(cache_set_serve, CACHE_SET_SERVE) \ + _(cache_clear, CACHE_CLEAR) \ + _(strategy_set, STRATEGY_SET) \ + _(wldr_set, WLDR_SET) \ + _(punting_add, PUNTING_ADD) \ + _(mapme_enable, MAPME_ENABLE) \ + _(mapme_set_discovery, MAPME_SET_DISCOVERY) \ + _(mapme_set_timescale, MAPME_SET_TIMESCALE) \ + _(mapme_set_retx, MAPME_SET_RETX) \ + _(mapme_send_update, MAPME_SEND_UPDATE) \ + _(policy_add, POLICY_ADD) \ + _(policy_remove, POLICY_REMOVE) \ + _(policy_list, POLICY_LIST) \ + +typedef enum { + COMMAND_TYPE_UNDEFINED, +#define _(l, u) COMMAND_TYPE_ ## u, + foreach_command_type +#undef _ + COMMAND_TYPE_N, +} command_type_t; + +#define command_type_is_valid(command_type) \ + ((command_type != COMMAND_TYPE_UNDEFINED) && (command_type != COMMAND_TYPE_N)) +#define command_type_from_uchar(x) \ + (((x) >= COMMAND_TYPE_N) ? COMMAND_TYPE_N : (command_type_t)(x)) + +/* Header */ + +/* Should be at least 8 bytes */ typedef struct { - uint8_t messageType; - uint8_t commandID; - uint16_t length; // tells the number of structures in the payload - uint32_t seqNum; -} header_control_message; -// for the moment has to be at least 8 bytes + uint8_t messageType; + uint8_t commandID ; + uint16_t length; /* Number of structures in the payload */ + uint32_t seqNum; +} cmd_header_t; -// SIZE=8 +typedef struct { + cmd_header_t header; +} msg_header_t; -//========== [00] ADD LISTENER ========== +/* Listener */ typedef enum { ETHER_MODE, IP_MODE, HICN_MODE } listener_mode; typedef struct { - char symbolic[SYMBOLIC_NAME_LEN]; - char interfaceName[SYMBOLIC_NAME_LEN]; - ip_address_t address; - uint16_t port; - // uint16_t etherType; - uint8_t addressType; - uint8_t listenerMode; - uint8_t connectionType; -} add_listener_command; - -// SIZE=56 - -//========== [01] ADD CONNECTION ========== - -typedef struct { - char symbolic[SYMBOLIC_NAME_LEN]; - //char interfaceName[SYMBOLIC_NAME_LEN]; - ip_address_t remoteIp; - ip_address_t localIp; - uint16_t remotePort; - uint16_t localPort; - uint8_t ipType; - uint8_t connectionType; - uint8_t admin_state; + char symbolic[SYMBOLIC_NAME_LEN]; + char interfaceName[SYMBOLIC_NAME_LEN]; + ip_address_t address; + uint16_t port; + // uint16_t etherType; + uint8_t addressType; + uint8_t listenerMode; + uint8_t connectionType; + uint8_t family; + uint8_t listenerType; +} cmd_listener_add_t; + +typedef struct { + char symbolicOrListenerid[SYMBOLIC_NAME_LEN]; +} cmd_listener_remove_t; + +typedef struct { + ip_address_t address; + char listenerName[SYMBOLIC_NAME_LEN]; + char interfaceName[SYMBOLIC_NAME_LEN]; + uint32_t connid; + uint16_t port; + uint8_t addressType; + uint8_t encapType; +} cmd_listener_list_t; + +typedef struct { + ip_address_t address; + char name[SYMBOLIC_NAME_LEN]; + char interface_name[SYMBOLIC_NAME_LEN]; + uint32_t id; + uint16_t port; + uint8_t family; + uint8_t type; +} cmd_listener_list_item_t; + +/* Connection */ + +typedef struct { + char symbolic[SYMBOLIC_NAME_LEN]; + //char interface_name[SYMBOLIC_NAME_LEN]; + ip_address_t remote_ip; + ip_address_t local_ip; + uint16_t remote_port; + uint16_t local_port; + uint8_t family; + uint8_t type; + uint8_t connection_type; + uint8_t admin_state; #ifdef WITH_POLICY - uint32_t priority; - policy_tags_t tags; + uint32_t priority; + policy_tags_t tags; #endif /* WITH_POLICY */ -} add_connection_command; +} cmd_connection_add_t; -// SIZE=56 - -//========== [02] LIST CONNECTIONS ========== +typedef struct { + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; +} cmd_connection_remove_t; typedef enum { CONN_GRE, @@ -167,268 +212,238 @@ typedef enum { } connection_state; typedef struct { - add_connection_command connectionData; + cmd_connection_add_t connectionData; uint32_t connid; uint8_t state; char interfaceName[SYMBOLIC_NAME_LEN]; char connectionName[SYMBOLIC_NAME_LEN]; -} list_connections_command; - -// SIZE=80 - -//========== [03] ADD ROUTE ========== +} cmd_connection_list_t; typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - ip_address_t address; - uint16_t cost; - uint8_t addressType; - uint8_t len; -} add_route_command; - -// SIZE=36 - -//========== [04] LIST ROUTE ========== + char symbolic[SYMBOLIC_NAME_LEN]; + //char interface_name[SYMBOLIC_NAME_LEN]; + ip_address_t remote_ip; + ip_address_t local_ip; + uint16_t remote_port; + uint16_t local_port; + uint8_t family; + uint8_t type; + uint8_t admin_state; +#ifdef WITH_POLICY + uint32_t priority; + policy_tags_t tags; +#endif /* WITH_POLICY */ + uint32_t id; + uint8_t state; + char interface_name[SYMBOLIC_NAME_LEN]; + char name[SYMBOLIC_NAME_LEN]; +} cmd_connection_list_item_t; typedef struct { - ip_address_t address; - uint32_t connid; - uint16_t cost; - uint8_t addressType; - uint8_t len; -} list_routes_command; + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + uint8_t admin_state; + uint8_t pad8[3]; +} cmd_connection_set_admin_state_t; -// SIZE=24 - -//========== [05] REMOVE CONNECTION ========== typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; -} remove_connection_command; + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + uint8_t admin_state; + uint32_t priority; + policy_tags_t tags; +} cmd_connection_update_t; -//========== [06] REMOVE LISTENER ========== typedef struct { - char symbolicOrListenerid[SYMBOLIC_NAME_LEN]; -} remove_listener_command; - -// SIZE=16 - -//========== [07] REMOVE ROUTE ========== + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + uint32_t priority; +} cmd_connection_set_priority_t; typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - ip_address_t address; - uint8_t addressType; - uint8_t len; -} remove_route_command; - -// SIZE=36 + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + policy_tags_t tags; +} cmd_connection_set_tags_t; -//========== [08] CACHE STORE ========== +/* Route */ typedef struct { - uint8_t activate; -} cache_store_command; + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + ip_address_t address; + uint16_t cost; + uint8_t addressType; + uint8_t family; + uint8_t len; +} cmd_route_add_t; -// SIZE=1 - -//========== [09] CACHE SERVE ========== +typedef struct { + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + ip_address_t address; + uint8_t addressType; + uint8_t family; + uint8_t len; +} cmd_route_remove_t; typedef struct { - uint8_t activate; -} cache_serve_command; + ip_address_t address; + uint32_t connid; + uint16_t cost; + uint8_t addressType; + uint8_t len; +} cmd_route_list_t; -// SIZE=1 +typedef struct { + ip_address_t address; + uint32_t connection_id; + uint16_t cost; + uint8_t family; + uint8_t len; +} cmd_route_list_item_t; -//========== [10] SET STRATEGY ========== +/* Cache */ -typedef enum { - SET_STRATEGY_LOADBALANCER, - SET_STRATEGY_RANDOM, - SET_STRATEGY_LOW_LATENCY, - LAST_STRATEGY_VALUE -} strategy_type; +typedef struct { + uint8_t activate; +} cmd_cache_set_store_t; typedef struct { - ip_address_t address; - uint8_t strategyType; - uint8_t addressType; - uint8_t len; - uint8_t related_prefixes; - ip_address_t addresses[MAX_FWD_STRATEGY_RELATED_PREFIXES]; - uint8_t lens[MAX_FWD_STRATEGY_RELATED_PREFIXES]; - uint8_t addresses_type[MAX_FWD_STRATEGY_RELATED_PREFIXES]; -} set_strategy_command; + uint8_t activate; +} cmd_cache_set_serve_t; -// SIZE=208 +typedef struct { +} cmd_cache_clear_t; -//========== [11] SET WLDR ========== +/* WLDR */ typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - uint8_t activate; -} set_wldr_command; - -// SIZE=17 + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + uint8_t activate; +} cmd_wldr_set_t; -//========== [12] ADD PUNTING ========== +/* Strategy */ typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - ip_address_t address; - uint8_t addressType; - uint8_t len; -} add_punting_command; + ip_address_t address; + uint8_t strategy_type; + uint8_t address_type; + uint8_t family; + uint8_t len; + uint8_t related_prefixes; + union { + struct { + ip_address_t addresses[MAX_FWD_STRATEGY_RELATED_PREFIXES]; + uint8_t lens[MAX_FWD_STRATEGY_RELATED_PREFIXES]; + uint8_t families[MAX_FWD_STRATEGY_RELATED_PREFIXES]; + } low_latency; + }; +} cmd_strategy_set_t; + +/* Punting */ -// SIZE=36 +typedef struct { + char symbolicOrConnid[SYMBOLIC_NAME_LEN]; + ip_address_t address; + uint8_t addressType; + uint8_t family; + uint8_t len; +} cmd_punting_add_t; -//========== [13] LIST LISTENER ========== +/* MAP-Me */ typedef struct { - ip_address_t address; - char listenerName[SYMBOLIC_NAME_LEN]; - char interfaceName[SYMBOLIC_NAME_LEN]; - uint32_t connid; - uint16_t port; - uint8_t addressType; - uint8_t encapType; -} list_listeners_command; + uint8_t activate; +} cmd_mapme_activator_t; -// SIZE=56 +typedef cmd_mapme_activator_t cmd_mapme_enable_t; +typedef cmd_mapme_activator_t cmd_mapme_set_discovery_t; -//========== [14] MAPME ========== +typedef struct { + uint32_t timePeriod; +} cmd_mapme_timing_t; -// (enable/discovery/timescale/retx) +typedef cmd_mapme_timing_t cmd_mapme_set_timescale_t; +typedef cmd_mapme_timing_t cmd_mapme_set_retx_t; typedef struct { - uint8_t activate; -} mapme_activator_command; + ip_address_t address; + uint8_t family; + uint8_t len; +} cmd_mapme_send_update_t; -// SIZE=1 +#ifdef WITH_POLICY +/* Policy */ typedef struct { - uint32_t timePeriod; -} mapme_timing_command; + ip_address_t address; + uint8_t addressType; + uint8_t family; + uint8_t len; + policy_t policy; +} cmd_policy_add_t; typedef struct { - ip_address_t address; - uint8_t addressType; - uint8_t len; -} mapme_send_update_command; + ip_address_t address; + uint8_t addressType; + uint8_t family; + uint8_t len; +} cmd_policy_remove_t; -// SIZE=1 +typedef struct { + ip_address_t address; + uint8_t addressType; + uint8_t len; + policy_t policy; +} cmd_policy_list_t; typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - uint8_t admin_state; - uint8_t pad8[3]; -} connection_set_admin_state_command; + ip_address_t address; + uint8_t family; + uint8_t len; + policy_t policy; +} cmd_policy_list_item_t; -#ifdef WITH_POLICY +#endif /* WITH_POLICY */ -typedef struct { - ip_address_t address; - uint8_t addressType; - uint8_t len; - policy_t policy; -} add_policy_command; +/* Full messages */ -typedef struct { - ip_address_t address; - uint8_t addressType; - uint8_t len; - policy_t policy; -} list_policies_command; +#define _(l, u) \ +typedef struct { \ + cmd_header_t header; \ + cmd_ ## l ## _t payload; \ +} msg_ ## l ## _t; + foreach_command_type +#undef _ typedef struct { - ip_address_t address; - uint8_t addressType; - uint8_t len; -} remove_policy_command; + cmd_header_t header; + cmd_listener_list_item_t payload; +} msg_listener_list_reply_t; typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - uint8_t admin_state; - uint32_t priority; - policy_tags_t tags; -} update_connection_command; + cmd_header_t header; + cmd_connection_list_item_t payload; +} msg_connection_list_reply_t; typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - uint32_t priority; -} connection_set_priority_command; + cmd_header_t header; + cmd_route_list_item_t payload; +} msg_route_list_reply_t; typedef struct { - char symbolicOrConnid[SYMBOLIC_NAME_LEN]; - policy_tags_t tags; -} connection_set_tags_command; - -#endif /* WITH_POLICY */ + cmd_header_t header; + cmd_policy_list_item_t payload; +} msg_policy_list_reply_t; //===== size of commands ====== // REMINDER: when a new_command is added, the following switch has to be // updated. -static inline int payloadLengthDaemon(command_id id) { - switch (id) { - case ADD_LISTENER: - return sizeof(add_listener_command); - case ADD_CONNECTION: - return sizeof(add_connection_command); - case LIST_CONNECTIONS: - return 0; // list connections: payload always 0 - case ADD_ROUTE: - return sizeof(add_route_command); - case LIST_ROUTES: - return 0; // list routes: payload always 0 - case REMOVE_CONNECTION: - return sizeof(remove_connection_command); - case REMOVE_LISTENER: - return sizeof(remove_listener_command); - case REMOVE_ROUTE: - return sizeof(remove_route_command); - case CACHE_STORE: - return sizeof(cache_store_command); - case CACHE_SERVE: - return sizeof(cache_serve_command); - case CACHE_CLEAR: - return 0; // cache clear - case SET_STRATEGY: - return sizeof(set_strategy_command); - case SET_WLDR: - return sizeof(set_wldr_command); - case ADD_PUNTING: - return sizeof(add_punting_command); - case LIST_LISTENERS: - return 0; // list listeners: payload always 0 - case MAPME_ENABLE: - return sizeof(mapme_activator_command); - case MAPME_DISCOVERY: - return sizeof(mapme_activator_command); - case MAPME_TIMESCALE: - return sizeof(mapme_timing_command); - case MAPME_RETX: - return sizeof(mapme_timing_command); - case MAPME_SEND_UPDATE: - return sizeof(mapme_send_update_command); - case CONNECTION_SET_ADMIN_STATE: - return sizeof(connection_set_admin_state_command); -#ifdef WITH_POLICY - case ADD_POLICY: - return sizeof(add_policy_command); - case LIST_POLICIES: - return 0; // list policies: payload always 0 - case REMOVE_POLICY: - return sizeof(remove_policy_command); - case UPDATE_CONNECTION: - return sizeof(update_connection_command); - case CONNECTION_SET_PRIORITY: - return sizeof(connection_set_priority_command); - case CONNECTION_SET_TAGS: - return sizeof(connection_set_tags_command); -#endif /* WITH_POLICY */ - case LAST_COMMAND_VALUE: - return 0; - default: - return 0; - } +static inline int command_get_payload_len(command_type_t command_type) { + switch (command_type) { +#define _(l, u) \ + case COMMAND_TYPE_ ## u: \ + return sizeof(cmd_## l ## _t); + foreach_command_type +#undef _ + case COMMAND_TYPE_UNDEFINED: + case COMMAND_TYPE_N: + return 0; + } } #endif diff --git a/ctrl/libhicnctrl/src/api.c b/ctrl/libhicnctrl/src/api.c index 080b6541a..ef9f4af65 100644 --- a/ctrl/libhicnctrl/src/api.c +++ b/ctrl/libhicnctrl/src/api.c @@ -57,7 +57,7 @@ typedef struct { /** * Messages to the forwarder might be multiplexed thanks to the seqNum fields in - * the header_control_message structure. The forwarder simply answers back the + * the cmd_header_t structure. The forwarder simply answers back the * original sequence number. We maintain a map of such sequence number to * outgoing queries so that replied can be demultiplexed and treated * appropriately. @@ -272,28 +272,28 @@ static const address_type map_to_addr_type[] = { ******************************************************************************/ #define foreach_hc_command \ - _(add_connection) \ - _(remove_connection) \ - _(list_connections) \ - _(add_listener) \ - _(remove_listener) \ - _(list_listeners) \ - _(add_route) \ - _(remove_route) \ - _(list_routes) \ - _(cache_store) \ - _(cache_serve) \ + _(connection_add) \ + _(connection_remove) \ + _(connection_list) \ + _(listener_add) \ + _(listener_remove) \ + _(listener_list) \ + _(route_add) \ + _(route_remove) \ + _(route_list) \ + _(cache_set_store) \ + _(cache_set_serve) \ /*_(cache_clear) */ \ - _(set_strategy) \ - _(set_wldr) \ - _(add_punting) \ + _(strategy_set) \ + _(wldr_set) \ + _(punting_add) \ _(mapme_activator) \ _(mapme_timing) -typedef header_control_message hc_msg_header_t; +typedef cmd_header_t hc_msg_header_t; typedef union { -#define _(x) x ## _command x; +#define _(x) cmd_ ## x ## _t x; foreach_hc_command #undef _ } hc_msg_payload_t; @@ -486,7 +486,7 @@ hc_sock_create_url(const char * url) s->url = url ? strdup(url) : NULL; - s->fd = socket(AF_INET, SOCK_STREAM, 0); + s->fd = socket(AF_INET, SOCK_DGRAM, 0); if (s->fd < 0) goto ERR_SOCKET; @@ -526,7 +526,7 @@ hc_sock_free(hc_sock_t * s) hc_sock_request_t ** request_array = NULL; int n = hc_sock_map_get_value_array(s->map, &request_array); if (n < 0) { - ERROR("Could not retrieve pending request array for freeing up resources"); + ERROR("Could not retrieve pending request array for freeing up resources"); } else { for (unsigned i = 0; i < n; i++) { hc_sock_request_t * request = request_array[i]; @@ -620,7 +620,7 @@ hc_sock_recv(hc_sock_t * s) rc = (int)recv(s->fd, s->buf + s->woff, RECV_BUFLEN - s->woff, 0); if (rc == 0) { /* Connection has been closed */ - return 0; + return 0; } if (rc < 0) { /* @@ -649,15 +649,15 @@ hc_sock_process(hc_sock_t * s, hc_data_t ** data) while(available > 0) { if (!s->cur_request) { // No message being parsed, alternatively (remaining == 0) - hc_msg_t * msg = (hc_msg_t*)(s->buf + s->roff); + cmd_header_t hdr = ((msg_header_t *) (s->buf + s->roff))->header; /* We expect a message header */ - if (available < sizeof(hc_msg_header_t)) { + if (available < sizeof(cmd_header_t)) { break; } hc_sock_request_t * request = NULL; - if (hc_sock_map_get(s->map, msg->hdr.seqNum, &request) < 0) { + if (hc_sock_map_get(s->map, hdr.seqNum, &request) < 0) { ERROR("[hc_sock_process] Error searching for matching request"); return -99; } @@ -666,19 +666,23 @@ hc_sock_process(hc_sock_t * s, hc_data_t ** data) return -99; } - s->remaining = msg->hdr.length; - switch(msg->hdr.messageType) { + s->remaining = hdr.length; + switch(hdr.messageType) { case ACK_LIGHT: + DEBUG("ack received"); assert(s->remaining == 1); assert(!data); s->cur_request = request; + hc_data_set_complete(request->data); break; case NACK_LIGHT: + DEBUG("nack received"); assert(s->remaining == 1); assert(!data); hc_data_set_error(request->data); s->cur_request = request; err = -1; + hc_data_set_complete(request->data); break; case RESPONSE_LIGHT: assert(data); @@ -697,9 +701,8 @@ hc_sock_process(hc_sock_t * s, hc_data_t ** data) ERROR("[hc_sock_process] Invalid response received"); return -99; } - - available -= sizeof(hc_msg_header_t); - s->roff += sizeof(hc_msg_header_t); + available -= sizeof(cmd_header_t); + s->roff += sizeof(cmd_header_t); } else { /* We expect the complete payload, or at least a chunk of it */ size_t num_chunks = available / s->cur_request->data->in_element_size; @@ -824,7 +827,7 @@ typedef int (*HC_PARSE)(const u8 *, u8 *); typedef struct { hc_action_t cmd; - command_id cmd_id; + command_type_t cmd_id; size_t size_in; size_t size_out; HC_PARSE parse; @@ -966,13 +969,10 @@ _hc_listener_create(hc_sock_t * s, hc_listener_t * listener, bool async) if (!IS_VALID_CONNECTION_TYPE(listener->type)) return -1; - struct { - header_control_message hdr; - add_listener_command payload; - } msg = { - .hdr = { + msg_listener_add_t msg = { + .header = { .messageType = REQUEST_LIGHT, - .commandID = ADD_LISTENER, + .commandID = COMMAND_TYPE_LISTENER_ADD, .length = 1, .seqNum = 0, }, @@ -982,6 +982,8 @@ _hc_listener_create(hc_sock_t * s, hc_listener_t * listener, bool async) .addressType = (u8)map_to_addr_type[listener->family], .listenerMode = (u8)map_to_listener_mode[listener->type], .connectionType = (u8)map_to_connection_type[listener->type], + .family = listener->family, + .listenerType = listener->type, } }; @@ -995,8 +997,8 @@ _hc_listener_create(hc_sock_t * s, hc_listener_t * listener, bool async) hc_command_params_t params = { .cmd = ACTION_CREATE, - .cmd_id = ADD_LISTENER, - .size_in = sizeof(add_listener_command), + .cmd_id = COMMAND_TYPE_LISTENER_ADD, + .size_in = sizeof(cmd_listener_add_t), .size_out = 0, .parse = NULL, }; @@ -1068,12 +1070,12 @@ _hc_listener_delete(hc_sock_t * s, hc_listener_t * listener, bool async) BOOLSTR(async)); struct { - header_control_message hdr; - remove_listener_command payload; + cmd_header_t hdr; + cmd_listener_remove_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = REMOVE_LISTENER, + .commandID = COMMAND_TYPE_LISTENER_REMOVE, .length = 1, .seqNum = 0, }, @@ -1101,8 +1103,8 @@ _hc_listener_delete(hc_sock_t * s, hc_listener_t * listener, bool async) hc_command_params_t params = { .cmd = ACTION_DELETE, - .cmd_id = REMOVE_LISTENER, - .size_in = sizeof(remove_listener_command), + .cmd_id = COMMAND_TYPE_LISTENER_REMOVE, + .size_in = sizeof(cmd_listener_remove_t), .size_out = 0, .parse = NULL, }; @@ -1131,11 +1133,11 @@ _hc_listener_list(hc_sock_t * s, hc_data_t ** pdata, bool async) DEBUG("[hc_listener_list] async=%s", BOOLSTR(async)); struct { - header_control_message hdr; + cmd_header_t hdr; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = LIST_LISTENERS, + .commandID = COMMAND_TYPE_LISTENER_LIST, .length = 0, .seqNum = 0, }, @@ -1143,8 +1145,8 @@ _hc_listener_list(hc_sock_t * s, hc_data_t ** pdata, bool async) hc_command_params_t params = { .cmd = ACTION_LIST, - .cmd_id = LIST_LISTENERS, - .size_in = sizeof(list_listeners_command), + .cmd_id = COMMAND_TYPE_LISTENER_LIST, + .size_in = sizeof(cmd_listener_list_t), .size_out = sizeof(hc_listener_t), .parse = (HC_PARSE)hc_listener_parse, }; @@ -1215,7 +1217,7 @@ hc_listener_parse(void * in, hc_listener_t * listener) { int rc; - list_listeners_command * cmd = (list_listeners_command *)in; + cmd_listener_list_t * cmd = (cmd_listener_list_t *)in; if (!IS_VALID_LIST_LISTENERS_TYPE(cmd->encapType)) return -1; @@ -1287,22 +1289,22 @@ _hc_connection_create(hc_sock_t * s, hc_connection_t * connection, bool async) return -1; struct { - header_control_message hdr; - add_connection_command payload; + cmd_header_t hdr; + cmd_connection_add_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = ADD_CONNECTION, + .commandID = COMMAND_TYPE_CONNECTION_ADD, .length = 1, .seqNum = 0, }, .payload = { - .remoteIp = connection->remote_addr, - .localIp = connection->local_addr, - .remotePort = htons(connection->remote_port), - .localPort = htons(connection->local_port), - .ipType = (u8)map_to_addr_type[connection->family], - .connectionType = (u8)map_to_connection_type[connection->type], + .remote_ip = connection->remote_addr, + .local_ip = connection->local_addr, + .remote_port = htons(connection->remote_port), + .local_port = htons(connection->local_port), + .type = (u8)map_to_addr_type[connection->family], + .connection_type = (u8)map_to_connection_type[connection->type], .admin_state = connection->admin_state, #ifdef WITH_POLICY .priority = connection->priority, @@ -1317,8 +1319,8 @@ _hc_connection_create(hc_sock_t * s, hc_connection_t * connection, bool async) hc_command_params_t params = { .cmd = ACTION_CREATE, - .cmd_id = ADD_CONNECTION, - .size_in = sizeof(add_connection_command), + .cmd_id = COMMAND_TYPE_CONNECTION_ADD, + .size_in = sizeof(cmd_connection_add_t), .size_out = 0, .parse = NULL, }; @@ -1389,12 +1391,12 @@ _hc_connection_delete(hc_sock_t * s, hc_connection_t * connection, bool async) DEBUG("[_hc_connection_delete] connection=%s async=%s", connection_s, BOOLSTR(async)); struct { - header_control_message hdr; - remove_connection_command payload; + cmd_header_t hdr; + cmd_connection_remove_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = REMOVE_CONNECTION, + .commandID = COMMAND_TYPE_CONNECTION_REMOVE, .length = 1, .seqNum = 0, }, @@ -1422,8 +1424,8 @@ _hc_connection_delete(hc_sock_t * s, hc_connection_t * connection, bool async) hc_command_params_t params = { .cmd = ACTION_DELETE, - .cmd_id = REMOVE_CONNECTION, - .size_in = sizeof(remove_connection_command), + .cmd_id = COMMAND_TYPE_CONNECTION_REMOVE, + .size_in = sizeof(cmd_connection_remove_t), .size_out = 0, .parse = NULL, }; @@ -1451,11 +1453,11 @@ _hc_connection_list(hc_sock_t * s, hc_data_t ** pdata, bool async) DEBUG("[hc_connection_list] async=%s", BOOLSTR(async)); struct { - header_control_message hdr; + cmd_header_t hdr; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = LIST_CONNECTIONS, + .commandID = COMMAND_TYPE_CONNECTION_LIST, .length = 0, .seqNum = 0, }, @@ -1463,8 +1465,8 @@ _hc_connection_list(hc_sock_t * s, hc_data_t ** pdata, bool async) hc_command_params_t params = { .cmd = ACTION_LIST, - .cmd_id = LIST_CONNECTIONS, - .size_in = sizeof(list_connections_command), + .cmd_id = COMMAND_TYPE_CONNECTION_LIST, + .size_in = sizeof(cmd_connection_list_t), .size_out = sizeof(hc_connection_t), .parse = (HC_PARSE)hc_connection_parse, }; @@ -1548,12 +1550,12 @@ int hc_connection_parse(void * in, hc_connection_t * connection) { int rc; - list_connections_command * cmd = (list_connections_command *)in; + cmd_connection_list_t * cmd = (cmd_connection_list_t *)in; - if (!IS_VALID_LIST_CONNECTIONS_TYPE(cmd->connectionData.connectionType)) + if (!IS_VALID_LIST_CONNECTIONS_TYPE(cmd->connectionData.connection_type)) return -1; - hc_connection_type_t type = map_from_list_connections_type[cmd->connectionData.connectionType]; + hc_connection_type_t type = map_from_list_connections_type[cmd->connectionData.connection_type]; if (type == CONNECTION_TYPE_UNDEFINED) return -1; @@ -1564,10 +1566,10 @@ hc_connection_parse(void * in, hc_connection_t * connection) if (state == HC_CONNECTION_STATE_UNDEFINED) return -1; - if (!IS_VALID_ADDR_TYPE(cmd->connectionData.ipType)) + if (!IS_VALID_ADDR_TYPE(cmd->connectionData.type)) return -1; - int family = map_from_addr_type[cmd->connectionData.ipType]; + int family = map_from_addr_type[cmd->connectionData.type]; if (!IS_VALID_FAMILY(family)) return -1; @@ -1575,12 +1577,12 @@ hc_connection_parse(void * in, hc_connection_t * connection) .id = cmd->connid, .type = type, .family = family, - .local_addr = cmd->connectionData.localIp, + .local_addr = cmd->connectionData.local_ip, //.local_addr = UNION_CAST(cmd->connectionData.localIp, ip_address_t), - .local_port = ntohs(cmd->connectionData.localPort), - .remote_addr = cmd->connectionData.remoteIp, + .local_port = ntohs(cmd->connectionData.local_port), + .remote_addr = cmd->connectionData.remote_ip, //.remote_addr = UNION_CAST(cmd->connectionData.remoteIp, ip_address_t), - .remote_port = ntohs(cmd->connectionData.remotePort), + .remote_port = ntohs(cmd->connectionData.remote_port), .admin_state = cmd->connectionData.admin_state, #ifdef WITH_POLICY .priority = cmd->connectionData.priority, @@ -1642,12 +1644,12 @@ _hc_connection_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, DEBUG("[hc_connection_set_admin_state] connection_id/name=%s admin_state=%s async=%s", conn_id_or_name, face_state_str(state), BOOLSTR(async)); struct { - header_control_message hdr; - connection_set_admin_state_command payload; + cmd_header_t hdr; + cmd_connection_set_admin_state_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = CONNECTION_SET_ADMIN_STATE, + .commandID = COMMAND_TYPE_CONNECTION_SET_ADMIN_STATE, .length = 1, .seqNum = 0, }, @@ -1661,8 +1663,8 @@ _hc_connection_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, hc_command_params_t params = { .cmd = ACTION_SET, - .cmd_id = CONNECTION_SET_ADMIN_STATE, - .size_in = sizeof(connection_set_admin_state_command), + .cmd_id = COMMAND_TYPE_CONNECTION_SET_ADMIN_STATE, + .size_in = sizeof(cmd_connection_set_admin_state_t), .size_out = 0, .parse = NULL, }; @@ -1692,12 +1694,12 @@ _hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name, DEBUG("[hc_connection_set_priority] connection_id/name=%s priority=%d async=%s", conn_id_or_name, priority, BOOLSTR(async)); struct { - header_control_message hdr; - connection_set_priority_command payload; + cmd_header_t hdr; + cmd_connection_set_priority_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = CONNECTION_SET_PRIORITY, + .commandID = COMMAND_TYPE_CONNECTION_SET_PRIORITY, .length = 1, .seqNum = 0, }, @@ -1711,8 +1713,8 @@ _hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name, hc_command_params_t params = { .cmd = ACTION_SET, - .cmd_id = CONNECTION_SET_PRIORITY, - .size_in = sizeof(connection_set_priority_command), + .cmd_id = COMMAND_TYPE_CONNECTION_SET_PRIORITY, + .size_in = sizeof(cmd_connection_set_priority_t), .size_out = 0, .parse = NULL, }; @@ -1742,12 +1744,12 @@ _hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name, DEBUG("[hc_connection_set_tags] connection_id/name=%s tags=%d async=%s", conn_id_or_name, tags, BOOLSTR(async)); struct { - header_control_message hdr; - connection_set_tags_command payload; + cmd_header_t hdr; + cmd_connection_set_tags_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = CONNECTION_SET_TAGS, + .commandID = COMMAND_TYPE_CONNECTION_SET_TAGS, .length = 1, .seqNum = 0, }, @@ -1761,8 +1763,8 @@ _hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name, hc_command_params_t params = { .cmd = ACTION_SET, - .cmd_id = CONNECTION_SET_TAGS, - .size_in = sizeof(connection_set_tags_command), + .cmd_id = COMMAND_TYPE_CONNECTION_SET_TAGS, + .size_in = sizeof(cmd_connection_set_tags_t), .size_out = 0, .parse = NULL, }; @@ -1806,12 +1808,12 @@ _hc_route_create(hc_sock_t * s, hc_route_t * route, bool async) return -1; struct { - header_control_message hdr; - add_route_command payload; + cmd_header_t hdr; + cmd_route_add_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = ADD_ROUTE, + .commandID = COMMAND_TYPE_ROUTE_ADD, .length = 1, .seqNum = 0, }, @@ -1833,8 +1835,8 @@ _hc_route_create(hc_sock_t * s, hc_route_t * route, bool async) hc_command_params_t params = { .cmd = ACTION_CREATE, - .cmd_id = ADD_ROUTE, - .size_in = sizeof(add_route_command), + .cmd_id = COMMAND_TYPE_ROUTE_ADD, + .size_in = sizeof(cmd_route_add_t), .size_out = 0, .parse = NULL, }; @@ -1869,12 +1871,12 @@ _hc_route_delete(hc_sock_t * s, hc_route_t * route, bool async) return -1; struct { - header_control_message hdr; - remove_route_command payload; + cmd_header_t hdr; + cmd_route_remove_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = REMOVE_ROUTE, + .commandID = COMMAND_TYPE_ROUTE_REMOVE, .length = 1, .seqNum = 0, }, @@ -1893,8 +1895,8 @@ _hc_route_delete(hc_sock_t * s, hc_route_t * route, bool async) hc_command_params_t params = { .cmd = ACTION_DELETE, - .cmd_id = REMOVE_ROUTE, - .size_in = sizeof(remove_route_command), + .cmd_id = COMMAND_TYPE_ROUTE_REMOVE, + .size_in = sizeof(cmd_route_remove_t), .size_out = 0, .parse = NULL, }; @@ -1922,11 +1924,11 @@ _hc_route_list(hc_sock_t * s, hc_data_t ** pdata, bool async) //DEBUG("[hc_route_list] async=%s", BOOLSTR(async)); struct { - header_control_message hdr; + cmd_header_t hdr; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = LIST_ROUTES, + .commandID = COMMAND_TYPE_ROUTE_LIST, .length = 0, .seqNum = 0, }, @@ -1934,8 +1936,8 @@ _hc_route_list(hc_sock_t * s, hc_data_t ** pdata, bool async) hc_command_params_t params = { .cmd = ACTION_LIST, - .cmd_id = LIST_ROUTES, - .size_in = sizeof(list_routes_command), + .cmd_id = COMMAND_TYPE_ROUTE_LIST, + .size_in = sizeof(cmd_route_list_t), .size_out = sizeof(hc_route_t), .parse = (HC_PARSE)hc_route_parse, }; @@ -1960,7 +1962,7 @@ hc_route_list_async(hc_sock_t * s) int hc_route_parse(void * in, hc_route_t * route) { - list_routes_command * cmd = (list_routes_command *) in; + cmd_route_list_t * cmd = (cmd_route_list_t *) in; if (!IS_VALID_ADDR_TYPE(cmd->addressType)) { ERROR("[hc_route_parse] Invalid address type"); @@ -2516,11 +2518,11 @@ int hc_face_list_async(hc_sock_t * s) { struct { - header_control_message hdr; + cmd_header_t hdr; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = LIST_CONNECTIONS, + COMMAND_TYPE_CONNECTION_LIST, .length = 0, .seqNum = 0, }, @@ -2528,8 +2530,8 @@ hc_face_list_async(hc_sock_t * s) hc_command_params_t params = { .cmd = ACTION_LIST, - .cmd_id = LIST_CONNECTIONS, - .size_in = sizeof(list_connections_command), + .cmd_id = COMMAND_TYPE_CONNECTION_LIST, + .size_in = sizeof(cmd_connection_list_t), .size_out = sizeof(hc_face_t), .parse = (HC_PARSE)hc_connection_parse_to_face, }; @@ -2656,12 +2658,12 @@ _hc_punting_create(hc_sock_t * s, hc_punting_t * punting, bool async) return -1; struct { - header_control_message hdr; - add_punting_command payload; + cmd_header_t hdr; + cmd_punting_add_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = ADD_PUNTING, + .commandID = COMMAND_TYPE_PUNTING_ADD, .length = 1, .seqNum = 0, }, @@ -2677,8 +2679,8 @@ _hc_punting_create(hc_sock_t * s, hc_punting_t * punting, bool async) hc_command_params_t params = { .cmd = ACTION_CREATE, - .cmd_id = ADD_PUNTING, - .size_in = sizeof(add_punting_command), + .cmd_id = COMMAND_TYPE_PUNTING_ADD, + .size_in = sizeof(cmd_punting_add_t), .size_out = 0, .parse = NULL, }; @@ -2777,12 +2779,12 @@ int _hc_cache_set_store(hc_sock_t * s, int enabled, bool async) { struct { - header_control_message hdr; - cache_store_command payload; + cmd_header_t hdr; + cmd_cache_set_store_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = CACHE_STORE, + .commandID = COMMAND_TYPE_CACHE_SET_STORE, .length = 1, .seqNum = 0, }, @@ -2793,8 +2795,8 @@ _hc_cache_set_store(hc_sock_t * s, int enabled, bool async) hc_command_params_t params = { .cmd = ACTION_SET, - .cmd_id = CACHE_STORE, - .size_in = sizeof(cache_store_command), + .cmd_id = COMMAND_TYPE_CACHE_SET_STORE, + .size_in = sizeof(cmd_cache_set_store_t), .size_out = 0, .parse = NULL, }; @@ -2818,12 +2820,12 @@ int _hc_cache_set_serve(hc_sock_t * s, int enabled, bool async) { struct { - header_control_message hdr; - cache_serve_command payload; + cmd_header_t hdr; + cmd_cache_set_serve_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = CACHE_SERVE, + .commandID = COMMAND_TYPE_CACHE_SET_SERVE, .length = 1, .seqNum = 0, }, @@ -2834,8 +2836,8 @@ _hc_cache_set_serve(hc_sock_t * s, int enabled, bool async) hc_command_params_t params = { .cmd = ACTION_SET, - .cmd_id = CACHE_SERVE, - .size_in = sizeof(cache_serve_command), + .cmd_id = COMMAND_TYPE_CACHE_SET_SERVE, + .size_in = sizeof(cmd_cache_set_serve_t), .size_out = 0, .parse = NULL, }; @@ -2955,12 +2957,12 @@ _hc_policy_create(hc_sock_t * s, hc_policy_t * policy, bool async) return -1; struct { - header_control_message hdr; - add_policy_command payload; + cmd_header_t hdr; + cmd_policy_add_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = ADD_POLICY, + COMMAND_TYPE_POLICY_ADD, .length = 1, .seqNum = 0, }, @@ -2974,8 +2976,8 @@ _hc_policy_create(hc_sock_t * s, hc_policy_t * policy, bool async) hc_command_params_t params = { .cmd = ACTION_CREATE, - .cmd_id = ADD_POLICY, - .size_in = sizeof(add_policy_command), + .cmd_id = COMMAND_TYPE_POLICY_ADD, + .size_in = sizeof(cmd_policy_add_t), .size_out = 0, .parse = NULL, }; @@ -3004,12 +3006,12 @@ _hc_policy_delete(hc_sock_t * s, hc_policy_t * policy, bool async) return -1; struct { - header_control_message hdr; - remove_policy_command payload; + cmd_header_t hdr; + cmd_policy_remove_t payload; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = REMOVE_POLICY, + .commandID = COMMAND_TYPE_POLICY_REMOVE, .length = 1, .seqNum = 0, }, @@ -3022,8 +3024,8 @@ _hc_policy_delete(hc_sock_t * s, hc_policy_t * policy, bool async) hc_command_params_t params = { .cmd = ACTION_DELETE, - .cmd_id = REMOVE_POLICY, - .size_in = sizeof(remove_policy_command), + .cmd_id = COMMAND_TYPE_POLICY_REMOVE, + .size_in = sizeof(cmd_policy_remove_t), .size_out = 0, .parse = NULL, }; @@ -3049,11 +3051,11 @@ int _hc_policy_list(hc_sock_t * s, hc_data_t ** pdata, bool async) { struct { - header_control_message hdr; + cmd_header_t hdr; } msg = { .hdr = { .messageType = REQUEST_LIGHT, - .commandID = LIST_POLICIES, + .commandID = COMMAND_TYPE_POLICY_LIST, .length = 0, .seqNum = 0, }, @@ -3061,8 +3063,8 @@ _hc_policy_list(hc_sock_t * s, hc_data_t ** pdata, bool async) hc_command_params_t params = { .cmd = ACTION_LIST, - .cmd_id = LIST_POLICIES, - .size_in = sizeof(list_policies_command), + .cmd_id = COMMAND_TYPE_POLICY_LIST, + .size_in = sizeof(cmd_policy_list_t), .size_out = sizeof(hc_policy_t), .parse = (HC_PARSE)hc_policy_parse, }; @@ -3087,7 +3089,7 @@ hc_policy_list_async(hc_sock_t * s, hc_data_t ** pdata) int hc_policy_parse(void * in, hc_policy_t * policy) { - list_policies_command * cmd = (list_policies_command *) in; + cmd_policy_list_t * cmd = (cmd_policy_list_t *) in; if (!IS_VALID_ADDR_TYPE(cmd->addressType)) return -1; diff --git a/ctrl/libhicnctrl/src/hicn_plugin_api.c b/ctrl/libhicnctrl/src/hicn_plugin_api.c index 406f43404..04d01e2a6 100644 --- a/ctrl/libhicnctrl/src/hicn_plugin_api.c +++ b/ctrl/libhicnctrl/src/hicn_plugin_api.c @@ -61,7 +61,7 @@ vapi_skc_ctx_t vapi_skc = { /** * Messages to the forwarder might be multiplexed thanks to the seqNum fields in - * the header_control_message structure. The forwarder simply answers back the + * the cmd_header_t structure. The forwarder simply answers back the * original sequence number. We maintain a map of such sequence number to * outgoing queries so that replied can be demultiplexed and treated * appropriately. diff --git a/hicn-light/src/hicn/cli/hicnc.c b/hicn-light/src/hicn/cli/hicnc.c index d6c7c4180..2c1c3500e 100644 --- a/hicn-light/src/hicn/cli/hicnc.c +++ b/hicn-light/src/hicn/cli/hicnc.c @@ -123,9 +123,6 @@ main(int argc, char * const * argv) goto ERR_PARSE; } - - hc_data_t * data; - hc_sock_t * s; if (server_ip) { if (server_port == 0) @@ -147,28 +144,13 @@ main(int argc, char * const * argv) goto ERR_CONNECT; } - /* XXX connection list */ - if (hc_connection_list(s, &data) < 0) { - fprintf(stderr, "Error running command"); - goto ERR_CMD; - } - - char buf[MAXSZ_HC_CONNECTION]; // XXX - foreach_connection(c, data) { - /* XXX connection print */ - int rc = hc_connection_snprintf(buf, MAXSZ_HC_CONNECTION, c); - if (rc < 0) { - strncpy(buf, "(Error)", MAXSZ_HC_CONNECTION); - } else if (rc >= MAXSZ_HC_CONNECTION) { - buf[MAXSZ_HC_CONNECTION-1] = '\0'; - buf[MAXSZ_HC_CONNECTION-2] = '.'; - buf[MAXSZ_HC_CONNECTION-3] = '.'; - buf[MAXSZ_HC_CONNECTION-4] = '.'; + // TODO: handle all commands + if (command.action == ACTION_CREATE && command.object.type == OBJECT_LISTENER) { + if (hc_listener_create(s, &command.object.listener) < 0) { + fprintf(stderr, "Error running command"); + goto ERR_CMD; } - printf("%s\n", buf); } - - hc_data_free(data); exit(EXIT_SUCCESS); ERR_CMD: diff --git a/hicn-light/src/hicn/config/configuration.c b/hicn-light/src/hicn/config/configuration.c index fed9d95ed..f5ed231b2 100644 --- a/hicn-light/src/hicn/config/configuration.c +++ b/hicn-light/src/hicn/config/configuration.c @@ -21,6 +21,8 @@ * @endcode */ +#include <hicn/ctrl/commands.h> + #ifndef _WIN32 #include <arpa/inet.h> #include <unistd.h> @@ -41,7 +43,7 @@ #include <hicn/core/listener.h> //the listener list #include <hicn/core/listener_table.h> -#include <hicn/utils/commands.h> +#include <hicn/ctrl/commands.h> #include <hicn/utils/utils.h> #include <hicn/utils/punting.h> #include <hicn/util/log.h> @@ -210,13 +212,11 @@ configuration_on_listener_add(configuration_t * config, uint8_t * packet, } // NOTE: interface_name is expected NULL for hICN listener - face_type_t face_type; - if (!face_type_is_defined(control->listener_type)) + face_type_t face_type = get_face_type_from_listener_type((hc_connection_type_t) control->listenerType); + if (!face_type_is_defined(face_type)) goto NACK; - face_type = (face_type_t)control->listener_type; - - listener = listener_create(face_type, &address, control->interface_name, control->symbolic, forwarder); + listener = listener_create(face_type, &address, control->interfaceName, control->symbolic, forwarder); if (!listener) goto NACK; @@ -1061,10 +1061,11 @@ uint8_t * configuration_on_punting_add(configuration_t * config, uint8_t * packet, unsigned ingress_id) { -#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING) +// #if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING) msg_punting_add_t * msg = (msg_punting_add_t *)packet; - cmd_punting_add_t * control = &msg->payload; +#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING) + cmd_punting_add_t * control = &msg->payload; if (ip_address_empty(&control->address)) goto NACK; @@ -1409,9 +1410,11 @@ configuration_receive_command(configuration_t * config, msgbuf_t * msgbuf) break; } - connection_table_t * table = forwarder_get_connection_table(config->forwarder); - const connection_t *connection = connection_table_at(table, ingress_id); - connection_send_packet(connection, reply, false); + if (connection_id_is_valid(msgbuf->connection_id)) { + connection_table_t * table = forwarder_get_connection_table(config->forwarder); + const connection_t *connection = connection_table_at(table, ingress_id); + connection_send_packet(connection, reply, sizeof(cmd_header_t)); + } switch (msgbuf->command.type) { case COMMAND_TYPE_LISTENER_LIST: @@ -1429,3 +1432,22 @@ configuration_receive_command(configuration_t * config, msgbuf_t * msgbuf) // XXX only if we consumed the whole packet. return (ssize_t)msgbuf_get_len(msgbuf); } + +face_type_t get_face_type_from_listener_type(hc_connection_type_t listener_type) { + face_type_t face_type; + switch (listener_type) { + case CONNECTION_TYPE_TCP: + face_type = FACE_TYPE_TCP_LISTENER; + break; + case CONNECTION_TYPE_UDP: + face_type = FACE_TYPE_UDP_LISTENER; + break; + case CONNECTION_TYPE_HICN: + face_type = FACE_TYPE_HICN_LISTENER; + break; + default: + face_type = FACE_TYPE_UNDEFINED; + } + return face_type; +} + diff --git a/hicn-light/src/hicn/config/configuration.h b/hicn-light/src/hicn/config/configuration.h index fa1b0410c..1cf772b42 100644 --- a/hicn-light/src/hicn/config/configuration.h +++ b/hicn-light/src/hicn/config/configuration.h @@ -27,7 +27,8 @@ #define configuration_h #include "../core/msgbuf.h" -#include "../utils/commands.h" +#include "../core/strategy.h" +#include <hicn/ctrl/api.h> typedef struct configuration_s configuration_t; @@ -126,4 +127,6 @@ uint8_t * configuration_dispatch_command(configuration_t * config, command_type_t command_type, uint8_t * packet, unsigned ingress_id); +face_type_t get_face_type_from_listener_type(hc_connection_type_t listener_type); + #endif // configuration_h diff --git a/hicn-light/src/hicn/config/controlListConnections.c b/hicn-light/src/hicn/config/controlListConnections.c index c47431726..fedc99868 100644 --- a/hicn-light/src/hicn/config/controlListConnections.c +++ b/hicn-light/src/hicn/config/controlListConnections.c @@ -98,8 +98,8 @@ static CommandReturn _controlListConnections_Execute(CommandParser *parser, } // Process/Print message - header_control_message *receivedHeader = - (header_control_message *)response[0].iov_base; + cmd_header_t *receivedHeader = + (cmd_header_t *)response[0].iov_base; uint8_t *receivedPayload = (uint8_t *)response[1].iov_base; char *sourceString = NULL; diff --git a/hicn-light/src/hicn/config/controlListListeners.c b/hicn-light/src/hicn/config/controlListListeners.c index f0ab820f5..e8909fc7c 100644 --- a/hicn-light/src/hicn/config/controlListListeners.c +++ b/hicn-light/src/hicn/config/controlListListeners.c @@ -79,8 +79,8 @@ static CommandReturn _controlListListeners_Execute(CommandParser *parser, } // Process/Print message - header_control_message *receivedHeader = - (header_control_message *)response[0].iov_base; + cmd_header_t *receivedHeader = + (cmd_header_t *)response[0].iov_base; uint8_t *receivedPayload = (uint8_t *)response[1].iov_base; // Allocate output to pass to the main function if the call is not interactive diff --git a/hicn-light/src/hicn/config/controlListPolicies.c b/hicn-light/src/hicn/config/controlListPolicies.c index 9ea3bae75..424893a3d 100644 --- a/hicn-light/src/hicn/config/controlListPolicies.c +++ b/hicn-light/src/hicn/config/controlListPolicies.c @@ -92,8 +92,8 @@ static CommandReturn _controlListPolicies_Execute(CommandParser *parser, } // Process/Print message - header_control_message *receivedHeader = - (header_control_message *)response[0].iov_base; + cmd_header_t *receivedHeader = + (cmd_header_t *)response[0].iov_base; uint8_t *receivedPayload = (uint8_t *)response[1].iov_base; if (!receivedPayload) { printf("No payload!\n"); diff --git a/hicn-light/src/hicn/config/controlListRoutes.c b/hicn-light/src/hicn/config/controlListRoutes.c index 33a1ac6f5..df1c24334 100644 --- a/hicn-light/src/hicn/config/controlListRoutes.c +++ b/hicn-light/src/hicn/config/controlListRoutes.c @@ -91,8 +91,8 @@ static CommandReturn _controlListRoutes_Execute(CommandParser *parser, } // Process/Print message - header_control_message *receivedHeader = - (header_control_message *)response[0].iov_base; + cmd_header_t *receivedHeader = + (cmd_header_t *)response[0].iov_base; uint8_t *receivedPayload = (uint8_t *)response[1].iov_base; // Allocate output to pass to the main function if the call is not interactive diff --git a/hicn-light/src/hicn/core/connection.c b/hicn-light/src/hicn/core/connection.c index 680e82b9b..3921eb582 100644 --- a/hicn-light/src/hicn/core/connection.c +++ b/hicn-light/src/hicn/core/connection.c @@ -233,7 +233,7 @@ connection_initialize(connection_t * connection, face_type_t type, const char * assert(connection); /* Interface name can be NULL eg always for TCP connnections */ assert(pair); - assert(address_pair_is_valid(pair)); + // assert(address_pair_is_valid(pair)); TODO: local addr in the pair is not initialized for now *connection = (connection_t) { .id = connection_id, @@ -259,13 +259,13 @@ connection_initialize(connection_t * connection, face_type_t type, const char * .wldr_autostart = true, }; - connection->data = malloc(connection_vft[connection->type]->data_size); + connection->data = malloc(connection_vft[get_protocol(connection->type)]->data_size); if (!connection->data) goto ERR_DATA; assert(connection_has_valid_id(connection)); - rc = connection_vft[connection->type]->initialize(connection); + rc = connection_vft[get_protocol(connection->type)]->initialize(connection); if (rc < 0) { goto ERR_VFT; } @@ -273,7 +273,7 @@ connection_initialize(connection_t * connection, face_type_t type, const char * // XXX uncertain as fd is created by the listener !! // XXX check whether it is registered ! #if 0 - connection->fd = connection_vft[connection->type]->get_socket(connection, address, NULL, interface_name); + connection->fd = connection_vft[get_protocol(connection->type)]->get_socket(connection, address, NULL, interface_name); if (connection->fd < 0) { ERROR("Error creating connection fd: (%d) %s", errno, strerror(errno)); goto ERR_FD; @@ -282,7 +282,7 @@ connection_initialize(connection_t * connection, face_type_t type, const char * // XXX data should be pre-allocated here if (loop_register_fd(MAIN_LOOP, connection->fd, connection, - connection_vft[connection->type]->read_callback, NULL) < 0) + connection_vft[get_protocol(connection->type)]->read_callback, NULL) < 0) goto ERR_REGISTER_FD; #endif @@ -320,7 +320,7 @@ connection_finalize(connection_t * connection) if (connection->wldr) wldr_free(connection->wldr); - connection_vft[connection->type]->finalize(connection); + connection_vft[get_protocol(connection->type)]->finalize(connection); free(connection->interface_name); free(connection); @@ -338,7 +338,7 @@ command_type_t _isACommand(PARCEventBuffer *input) { size_t bytesAvailable = parcEventBuffer_GetLength(input); - parcAssertTrue(bytesAvailable >= sizeof(header_control_message), + parcAssertTrue(bytesAvailable >= sizeof(cmd_header_t), "Called with too short an input: %zu", bytesAvailable); uint8_t *msg = parcEventBuffer_Pullup(input, bytesAvailable); @@ -367,7 +367,7 @@ connection_process_buffer(connection_t * connection, const uint8_t * buffer, siz /* Too small a packet is not useful to decide between a control message and * an hICN packet, the size of a control message is enough to test for both * pakcet types */ - if (size < sizeof(header_control_message)) + if (size < sizeof(cmd_header_t)) return 0; /* We expect complete packets most of the time, so don't bother with state */ @@ -376,7 +376,7 @@ connection_process_buffer(connection_t * connection, const uint8_t * buffer, siz command_type_t command_type = command_type_from_uchar(msg[1]); if (!command_type_is_valid(command_type)) break; - expected = sizeof(header_control_message) + + expected = sizeof(cmd_header_t) + command_get_payload_len(command_type); if (size < expected) return 0; @@ -423,7 +423,7 @@ connection_read_message(connection_t * connection, msgbuf_t * msgbuf) assert(face_type_is_valid(connection->type)); assert(msgbuf); - return connection_vft[connection->type]->read_message(connection, msgbuf); + return connection_vft[get_protocol(connection->type)]->read_message(connection, msgbuf); } uint8_t * @@ -432,7 +432,7 @@ connection_read_packet(connection_t * connection) assert(connection); assert(face_type_is_valid(connection->type)); - return connection_vft[connection->type]->read_packet(connection); + return connection_vft[get_protocol(connection->type)]->read_packet(connection); } #endif @@ -444,7 +444,7 @@ connection_send_packet(const connection_t * connection, const uint8_t * packet, assert(face_type_is_valid(connection->type)); assert(packet); - return connection_vft[connection->type]->send_packet(connection, packet, size); + return connection_vft[get_protocol(connection->type)]->send_packet(connection, packet, size); } // ALL DEPRECATED CODE HERE TO BE UPDATED @@ -453,7 +453,7 @@ connection_send_packet(const connection_t * connection, const uint8_t * packet, bool _connection_send(const connection_t * connection, msgbuf_t * msgbuf, bool queue) { - return connection_vft[connection->type]->send(connection, msgbuf, queue); + return connection_vft[get_protocol(connection->type)]->send(connection, msgbuf, queue); } bool diff --git a/hicn-light/src/hicn/core/connection_vft.c b/hicn-light/src/hicn/core/connection_vft.c index 9efdd0107..d740a52f0 100644 --- a/hicn-light/src/hicn/core/connection_vft.c +++ b/hicn-light/src/hicn/core/connection_vft.c @@ -25,7 +25,7 @@ extern connection_ops_t connection_tcp; extern connection_ops_t connection_udp; const connection_ops_t * connection_vft[] = { - [FACE_TYPE_HICN] = &connection_hicn, - [FACE_TYPE_TCP] = &connection_tcp, - [FACE_TYPE_UDP] = &connection_udp, + [FACE_PROTOCOL_HICN] = &connection_hicn, + [FACE_PROTOCOL_TCP] = &connection_tcp, + [FACE_PROTOCOL_UDP] = &connection_udp, }; diff --git a/hicn-light/src/hicn/core/forwarder.c b/hicn-light/src/hicn/core/forwarder.c index 4a31075f6..9954ecd0a 100644 --- a/hicn-light/src/hicn/core/forwarder.c +++ b/hicn-light/src/hicn/core/forwarder.c @@ -1130,7 +1130,11 @@ forwarder_receive(forwarder_t * forwarder, listener_t * listener, uint8_t * packet = msgbuf_get_packet(msgbuf); size_t size = msgbuf_get_len(msgbuf); - assert(messageHandler_GetTotalPacketLength(packet) == size); // XXX confirm ? + + // TODO: the assert fails + // size_t tmp = messageHandler_GetTotalPacketLength(packet); + // (void) tmp; + // assert(messageHandler_GetTotalPacketLength(packet) == size); // XXX confirm ? /* Connection lookup */ const connection_table_t * table = forwarder_get_connection_table(listener->forwarder); @@ -1179,11 +1183,13 @@ forwarder_receive(forwarder_t * forwarder, listener_t * listener, return msgbuf_get_len(msgbuf); case MSGBUF_TYPE_COMMAND: - // XXX before it used to create the connection + // Create the connection to send the ack back if (!connection_id_is_valid(msgbuf->connection_id)) - return forwarder_drop(forwarder, msgbuf_id); - msgbuf->command.type = *(packet + 1); // XXX use header - if (msgbuf->command.type >= COMMAND_TYPE_N) { + msgbuf->connection_id = listener_create_connection(listener, pair); + + msg_header_t * msg = (msg_header_t*) packet; + msgbuf->command.type = msg->header.commandID; + if (msgbuf->command.type >= COMMAND_TYPE_N || msgbuf->command.type == COMMAND_TYPE_UNDEFINED) { ERROR("Invalid command"); return -msgbuf_get_len(msgbuf); } diff --git a/hicn-light/src/hicn/core/listener.c b/hicn-light/src/hicn/core/listener.c index de078b889..66b5c09ee 100644 --- a/hicn-light/src/hicn/core/listener.c +++ b/hicn-light/src/hicn/core/listener.c @@ -69,17 +69,21 @@ listener_initialize(listener_t * listener, face_type_t type, const char * name, .forwarder = forwarder, }; - listener->data = malloc(listener_vft[listener->type]->data_size); + face_protocol_t face_protocol = get_protocol(listener->type); + if (face_protocol == FACE_PROTOCOL_UNKNOWN) + goto ERR_VFT; + + listener->data = malloc(listener_vft[face_protocol]->data_size); if (!listener->data) goto ERR_DATA; assert(listener_has_valid_type(listener)); - rc = listener_vft[listener->type]->initialize(listener); + rc = listener_vft[face_protocol]->initialize(listener); if (rc < 0) goto ERR_VFT; - listener->fd = listener_vft[listener->type]->get_socket(listener, address, NULL, interface_name); + listener->fd = listener_vft[face_protocol]->get_socket(listener, address, NULL, interface_name); if (listener->fd < 0) { ERROR("Error creating listener fd: (%d) %s", errno, strerror(errno)); goto ERR_FD; @@ -136,7 +140,7 @@ listener_finalize(listener_t * listener) closesocket(listener->fd); #endif - listener_vft[listener->type]->finalize(listener); + listener_vft[get_protocol(listener->type)]->finalize(listener); free(listener->data); free(listener->interface_name); @@ -152,13 +156,12 @@ int listener_get_socket(const listener_t * listener, const address_t * local, assert(listener); assert(listener_has_valid_type(listener)); assert(local); - assert(remote); + // assert(remote); TODO: can it be null? - return listener_vft[listener->type]->get_socket(listener, local, remote, + return listener_vft[get_protocol(listener->type)]->get_socket(listener, local, remote, interface_name); } -// XXX CHANGE : we now get the fd directly from the listener unsigned listener_create_connection(const listener_t * listener, const address_pair_t * pair) { @@ -167,22 +170,17 @@ unsigned listener_create_connection(const listener_t * listener, assert(pair); // XXX TODO This code is likely common with connection creation code - const char * name = NULL; connection_table_t * table = forwarder_get_connection_table(listener->forwarder); connection_t * connection; - connection_table_allocate(table, connection, pair, name); + connection_table_allocate(table, connection, pair, listener->name); unsigned connid = connection_table_get_connection_id(table, connection); bool local = address_is_local(address_pair_get_local(pair)); - int fd = listener_get_socket(listener, address_pair_get_local(pair), - address_pair_get_remote(pair), NULL); // XXX interfacename was not specified - - // XXX here we use the same interface name as the listener - int rc = connection_initialize(connection, listener->type, name, - listener->interface_name, fd, pair, local, connid, listener->forwarder); + int rc = connection_initialize(connection, listener->type, listener->name, + listener->interface_name, listener->fd, pair, local, connid, listener->forwarder); if (rc < 0) return ~0; // XXX how to return an error @@ -199,7 +197,7 @@ listener_punt(const listener_t * listener, const char * prefix_s) assert(listener_get_type(listener) == FACE_TYPE_HICN); assert(prefix_s); - return listener_vft[listener_get_type(listener)]->punt(listener, prefix_s); + return listener_vft[get_protocol(listener->type)]->punt(listener, prefix_s); } @@ -223,7 +221,7 @@ listener_read_single(listener_t * listener) address_pair_t pair; pair.local = *listener_get_address(listener); - ssize_t n = listener_vft[listener->type]->read_single(listener->fd, msgbuf, + ssize_t n = listener_vft[get_protocol(listener->type)]->read_single(listener->fd, msgbuf, address_pair_get_remote(&pair)); if (n < 1) return 0; @@ -262,7 +260,7 @@ listener_read_batch(listener_t * listener) do { /* Prepare the msgbuf and address pair arrays */ msgbuf_t * msgbuf[MAX_MSG]; - if (!msgbuf_pool_getn(msgbuf_pool, msgbuf, MAX_MSG)) + if (msgbuf_pool_getn(msgbuf_pool, msgbuf, MAX_MSG) < 0) break; address_pair_t pair[MAX_MSG]; @@ -270,7 +268,7 @@ listener_read_batch(listener_t * listener) for (unsigned i = 0; i < MAX_MSG; i++) address_remote[i] = address_pair_get_remote(&pair[i]); - ssize_t n = listener_vft[listener->type]->read_batch(listener->fd, + ssize_t n = listener_vft[get_protocol(listener->type)]->read_batch(listener->fd, msgbuf, address_remote, MAX_MSG); // XXX error check @@ -303,7 +301,7 @@ listener_read_callback(listener_t * listener, int fd, void * user_data) assert(listener); assert(fd == listener->fd); - if (listener_vft[listener->type]->read_batch) + if (listener_vft[get_protocol(listener->type)]->read_batch) return listener_read_batch(listener); return listener_read_single(listener); @@ -375,7 +373,7 @@ listener_setup_all(const forwarder_t * forwarder, uint16_t port, const char *loc // XXX TODO void -listener_setup_local_ipv4(const forwarder_t * forwarder, uint16_t port) +listener_setup_local_ipv4(forwarder_t * forwarder, uint16_t port) { #if 0 // XXX memset @@ -384,4 +382,10 @@ listener_setup_local_ipv4(const forwarder_t * forwarder, uint16_t port) _setupUdpListener(forwarder, "lo_udp", &address, "lo"); _setupTcpListener(forwarder, "lo_tcp", &address, "lo"); #endif + address_t address; + memset(&address, 0, sizeof(address_t)); + address = ADDRESS4_LOCALHOST(port); + + listener_create(FACE_TYPE_UDP_LISTENER, &address, "lo", "lo_udp", forwarder); + // listener_create(FACE_TYPE_TCP_LISTENER, &address, "lo", "lo_tcp", forwarder); } diff --git a/hicn-light/src/hicn/core/listener.h b/hicn-light/src/hicn/core/listener.h index 79aefef51..b55074967 100644 --- a/hicn-light/src/hicn/core/listener.h +++ b/hicn-light/src/hicn/core/listener.h @@ -85,7 +85,7 @@ unsigned listener_create_connection(const listener_t * listener, void listener_setup_all(const struct forwarder_s * forwarder, uint16_t port, const char *localPath); -void listener_setup_local_ipv4(const struct forwarder_s * forwarder, uint16_t port); +void listener_setup_local_ipv4(struct forwarder_s * forwarder, uint16_t port); void listener_process_packet(const listener_t * listener, const uint8_t * packet, size_t size); diff --git a/hicn-light/src/hicn/core/listener_vft.c b/hicn-light/src/hicn/core/listener_vft.c index edaa0c264..4f15fdda2 100644 --- a/hicn-light/src/hicn/core/listener_vft.c +++ b/hicn-light/src/hicn/core/listener_vft.c @@ -25,7 +25,7 @@ extern listener_ops_t listener_tcp; extern listener_ops_t listener_udp; const listener_ops_t * listener_vft[] = { - [FACE_TYPE_HICN] = &listener_hicn, - [FACE_TYPE_TCP] = &listener_tcp, - [FACE_TYPE_UDP] = &listener_udp, + [FACE_PROTOCOL_HICN] = &listener_hicn, + [FACE_PROTOCOL_TCP] = &listener_tcp, + [FACE_PROTOCOL_UDP] = &listener_udp, }; diff --git a/hicn-light/src/hicn/core/msgbuf.h b/hicn-light/src/hicn/core/msgbuf.h index 72480b535..a52e6b298 100644 --- a/hicn-light/src/hicn/core/msgbuf.h +++ b/hicn-light/src/hicn/core/msgbuf.h @@ -47,6 +47,7 @@ typedef enum { foreach_type #undef _ } msgbuf_type_t; +#undef foreach_type typedef struct { unsigned length; diff --git a/hicn-light/src/hicn/core/test/test-msgbuf_pool.cc b/hicn-light/src/hicn/core/test/test-msgbuf_pool.cc index 027f16ac9..9a79aef6c 100644 --- a/hicn-light/src/hicn/core/test/test-msgbuf_pool.cc +++ b/hicn-light/src/hicn/core/test/test-msgbuf_pool.cc @@ -26,7 +26,7 @@ extern "C" { #define WITH_TESTS #include <hicn/core/msgbuf_pool.h> -#include <hicn/base/pool.h> // TODO: remove this line +#include <hicn/base/pool.h> } #define PACKET_POOL_DEFAULT_INIT_SIZE 1024 diff --git a/hicn-light/src/hicn/io/base.c b/hicn-light/src/hicn/io/base.c index 35d8915a8..bd5904ccb 100644 --- a/hicn-light/src/hicn/io/base.c +++ b/hicn-light/src/hicn/io/base.c @@ -115,11 +115,16 @@ ssize_t io_read_batch_socket(int fd, msgbuf_t ** msgbuf, } /* Assign size to msgbuf, and build address pair */ + // TODO: local (in pair) is not initialized for (int i = 0; i < n; i++) { struct mmsghdr *msg = &msghdr[i]; msgbuf[i]->length = msg->msg_hdr.msg_iovlen; **address = *(address_t*)msg->msg_hdr.msg_name; + + struct sockaddr_in *src = msghdr[i].msg_hdr.msg_name; + DEBUG("msg received from port %u", ntohs(src->sin_port)); } + break; } return n; diff --git a/hicn-light/src/hicn/io/tcp.c b/hicn-light/src/hicn/io/tcp.c index e4e2b06af..e4f5d196f 100644 --- a/hicn-light/src/hicn/io/tcp.c +++ b/hicn-light/src/hicn/io/tcp.c @@ -391,14 +391,14 @@ connection_tcp_read_message(connection_t * connection, msgbuf_t * msgbuf) size_t n = evbuffer_get_length(data->evbuffer); // XXX this check was wrong - // parcAssertTrue(n >= sizeof(header_control_message), + // parcAssertTrue(n >= sizeof(cmd_header_t), "Called with too short an input: %zu", n); // XXX WTF if (stream->next_len == 0) { // this linearizes the first messageHandler_GetIPv6HeaderLength() bytes of the // input buffer's iovecs and returns a pointer to it. - uint8_t *fh = parcEventBuffer_Pullup(data->evbuffer, sizeof(header_control_message)); + uint8_t *fh = parcEventBuffer_Pullup(data->evbuffer, sizeof(cmd_header_t)); // Calculate the total message size based on the fixed header stream->next_len = messageHandler_GetTotalPacketLength(fh); diff --git a/hicn-light/src/hicn/io/udp.c b/hicn-light/src/hicn/io/udp.c index 38d643838..edff902de 100644 --- a/hicn-light/src/hicn/io/udp.c +++ b/hicn-light/src/hicn/io/udp.c @@ -215,15 +215,6 @@ listener_udp_initialize(listener_t * listener) listener_udp_data_t * data = listener->data; assert(data); #endif - - // XXX Socket creation should be a function per-se and not be called in - // initialize ! - listener->fd = listener_get_socket(listener, &listener->address, NULL, - listener->interface_name); - if (listener->fd < 0) { - ERROR("Error creating UDP socket: (%d) %s", errno, strerror(errno)); - return -1; - } return 0; } @@ -249,7 +240,7 @@ int listener_udp_get_socket(const listener_t * listener, const address_t * local, const address_t * remote, const char * interface_name) { - int fd = socket(address_family(remote), SOCK_DGRAM, 0); + int fd = socket(address_family(local), SOCK_DGRAM, 0); if (fd < 0) goto ERR_SOCKET; @@ -257,7 +248,7 @@ listener_udp_get_socket(const listener_t * listener, const address_t * local, goto ERR; } - if (bind(fd, address_sa(local), address_socklen(remote)) < 0) { + if (bind(fd, address_sa(local), address_socklen(local)) < 0) { perror("bind"); goto ERR; } @@ -313,7 +304,7 @@ connection_udp_initialize(connection_t * connection) { assert(connection); - assert(connection->type == FACE_TYPE_UDP); + assert(connection->type == FACE_TYPE_UDP || connection->type == FACE_TYPE_UDP_LISTENER); assert(connection->interface_name); connection_udp_data_t * data = connection->data; diff --git a/hicn-light/src/hicn/utils/utils.c b/hicn-light/src/hicn/utils/utils.c index 42bcb7f87..2bfd8dc94 100644 --- a/hicn-light/src/hicn/utils/utils.c +++ b/hicn-light/src/hicn/utils/utils.c @@ -128,8 +128,8 @@ bool utils_IsNumber(const char *string) { //uint32_t currentSeqNum = utils_GetNextSequenceNumber(); // //// Allocate and fill the header -//header_control_message *headerControlMessage = -// parcMemory_AllocateAndClear(sizeof(header_control_message)); +//cmd_header_t *headerControlMessage = +// parcMemory_AllocateAndClear(sizeof(cmd_header_t)); //headerControlMessage->messageType = REQUEST_LIGHT; //headerControlMessage->commandID = command; //headerControlMessage->seqNum = currentSeqNum; @@ -139,14 +139,14 @@ bool utils_IsNumber(const char *string) { // //struct iovec msg[2]; //msg[0].iov_base = headerControlMessage; -//msg[0].iov_len = sizeof(header_control_message); +//msg[0].iov_len = sizeof(cmd_header_t); //msg[1].iov_base = payload; //msg[1].iov_len = payloadLen; // //struct iovec *response = controlState_WriteRead(state, msg); // -//header_control_message *receivedHeader = -// (header_control_message *)response[0].iov_base; +//cmd_header_t *receivedHeader = +// (cmd_header_t *)response[0].iov_base; //if (receivedHeader->seqNum != currentSeqNum) { //printf("Seq number is NOT correct: expected %d got %d \n", currentSeqNum, // receivedHeader->seqNum); diff --git a/lib/includes/hicn/face.h b/lib/includes/hicn/face.h index 45a1b97da..0d116b64b 100644 --- a/lib/includes/hicn/face.h +++ b/lib/includes/hicn/face.h @@ -138,6 +138,13 @@ foreach_face_type #undef _ } face_type_t; +typedef enum { + FACE_PROTOCOL_HICN, + FACE_PROTOCOL_UDP, + FACE_PROTOCOL_TCP, + FACE_PROTOCOL_UNKNOWN, +} face_protocol_t; + #define face_type_is_valid(face_type) \ (((face_type) >= FACE_TYPE_UNDEFINED) && (face_type < FACE_TYPE_N)) #define face_type_is_defined(face_type) \ @@ -209,5 +216,7 @@ face_snprintf(char * s, size_t size, const face_t * face); policy_tags_t face_get_tags(const face_t * face); int face_set_tags(face_t * face, policy_tags_t tags); +face_protocol_t get_protocol(face_type_t face_type); + #endif /* HICN_FACE_H */ diff --git a/lib/includes/hicn/util/ip_address.h b/lib/includes/hicn/util/ip_address.h index 27880047c..a43f16754 100644 --- a/lib/includes/hicn/util/ip_address.h +++ b/lib/includes/hicn/util/ip_address.h @@ -135,6 +135,17 @@ const u8 * ip_address_get_buffer(const ip_address_t * ip_address, int family); int ip_address_ntop (const ip_address_t * ip_address, char *dst, const size_t len, int family); int ip_address_pton (const char *ip_address_str, ip_address_t * ip_address); + +/** + * @brief Return the ip_address provided as parameter in string format. + * E.g. (for ipv4): "0.0.0.0" + * + * @param[in, out] s String to store the parsed address + * @param[in] size Size of the string @p s + * @param[in] ip_address Address to parse to string + * @param[in] family Address family (e.g. AF_INET, AF_INET6) + * @return int Length of the string generated parsing the addr + */ int ip_address_snprintf(char * s, size_t size, const ip_address_t * ip_address, int family); int ip_address_to_sockaddr(const ip_address_t * ip_address, struct sockaddr *sa, diff --git a/lib/src/face.c b/lib/src/face.c index 6d0d9c486..7b3bbe3c3 100644 --- a/lib/src/face.c +++ b/lib/src/face.c @@ -420,3 +420,24 @@ face_set_tags(face_t * face, policy_tags_t tags) face->tags = tags; return 1; } + +face_protocol_t +get_protocol(face_type_t face_type) { + switch (face_type) { + case FACE_TYPE_HICN: + case FACE_TYPE_HICN_LISTENER: + return FACE_PROTOCOL_HICN; + + case FACE_TYPE_TCP: + case FACE_TYPE_TCP_LISTENER: + return FACE_PROTOCOL_TCP; + + case FACE_TYPE_UDP: + case FACE_TYPE_UDP_LISTENER: + return FACE_PROTOCOL_UDP; + break; + + default: + return FACE_PROTOCOL_UNKNOWN; + } +} |