From: Guus Sliepen Date: Thu, 31 Jan 2019 21:20:40 +0000 (+0100) Subject: Update the blackbox test infrastructure. X-Git-Url: http://git.meshlink.io/?p=meshlink;a=commitdiff_plain;h=1c04402a6d2f3a85d0cb4a5b4a6db5b1f3a79511 Update the blackbox test infrastructure. --- diff --git a/test/blackbox/common/common_handlers.c b/test/blackbox/common/common_handlers.c index d6ef7756..ad32a223 100644 --- a/test/blackbox/common/common_handlers.c +++ b/test/blackbox/common/common_handlers.c @@ -33,31 +33,35 @@ #include "test_step.h" #include "common_handlers.h" -#define GET_IP_FAMILY AF_INET - char *lxc_bridge = NULL; black_box_state_t *state_ptr = NULL; bool meta_conn_status[10]; -bool node_reachable_status[10]; bool test_running; +static int meshlink_get_node_in_container(const char *name) { + int i; + + for(i = 0; i < state_ptr->num_nodes; i++) { + if(!strcasecmp(state_ptr->node_names[i], name)) { + return i; + break; + } + } + + return -1; +} + void mesh_close_signal_handler(int a) { test_running = false; exit(EXIT_SUCCESS); } -void mesh_stop_start_signal_handler(int a) { - /* Stop the Mesh if it is running, otherwise start it again */ - (mesh_started) ? execute_stop() : execute_start(); -} - void setup_signals(void) { test_running = true; signal(SIGTERM, mesh_close_signal_handler); - signal(SIGINT, mesh_stop_start_signal_handler); } /* Return the IP Address of the Interface 'if_name' @@ -78,8 +82,8 @@ char *get_ip(const char *if_name) { family = ifa->ifa_addr->sa_family; - if(family == GET_IP_FAMILY && !strcmp(ifa->ifa_name, if_name)) { - assert(!getnameinfo(ifa->ifa_addr, (family == GET_IP_FAMILY) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST)); + if(family == AF_INET && !strcmp(ifa->ifa_name, if_name)) { + assert(!getnameinfo(ifa->ifa_addr, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST)); break; } } @@ -105,8 +109,8 @@ char *get_netmask(const char *if_name) { family = ifa->ifa_addr->sa_family; - if(family == GET_IP_FAMILY && !strcmp(ifa->ifa_name, if_name)) { - assert(!getnameinfo(ifa->ifa_netmask, (family == GET_IP_FAMILY) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST)); + if(family == AF_INET && !strcmp(ifa->ifa_name, if_name)) { + assert(!getnameinfo(ifa->ifa_netmask, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST)); break; } } @@ -145,60 +149,35 @@ void start_nw_intf(const char *if_name) { void meshlink_callback_node_status(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) { - int i; - (void)mesh; fprintf(stderr, "Node %s became %s\n", node->name, (reachable) ? "reachable" : "unreachable"); - - if(state_ptr) - for(i = 0; i < state_ptr->num_nodes; i++) - if(strcmp(node->name, state_ptr->node_names[i]) == 0) { - node_reachable_status[i] = reachable; - } } void meshlink_callback_logger(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) { - int i; - char connection_match_msg[100]; (void)mesh; (void)level; fprintf(stderr, "meshlink>> %s\n", text); - if(state_ptr && (strstr(text, "Connection") || strstr(text, "connection"))) { - for(i = 0; i < state_ptr->num_nodes; i++) { - assert(snprintf(connection_match_msg, sizeof(connection_match_msg), - "Connection with %s", state_ptr->node_names[i]) >= 0); - - if(strstr(text, connection_match_msg) && strstr(text, "activated")) { - meta_conn_status[i] = true; - continue; - } - - assert(snprintf(connection_match_msg, sizeof(connection_match_msg), - "Already connected to %s", state_ptr->node_names[i]) >= 0); - - if(strstr(text, connection_match_msg)) { - meta_conn_status[i] = true; - continue; - } - - assert(snprintf(connection_match_msg, sizeof(connection_match_msg), - "Connection closed by %s", state_ptr->node_names[i]) >= 0); - - if(strstr(text, connection_match_msg)) { - meta_conn_status[i] = false; - continue; - } - - assert(snprintf(connection_match_msg, sizeof(connection_match_msg), - "Closing connection with %s", state_ptr->node_names[i]) >= 0); - - if(strstr(text, connection_match_msg)) { - meta_conn_status[i] = false; - continue; - } + if(state_ptr) { + bool status; + char name[100]; + + if(sscanf(text, "Connection with %s activated", name) == 1) { + status = true; + } else if(sscanf(text, "Already connected to %s", name) == 1) { + status = true; + } else if(sscanf(text, "Connection closed by %s", name) == 1) { + status = false; + } else if(sscanf(text, "Closing connection with %s", name) == 1) { + status = false; + } else { + return; } + + int i = meshlink_get_node_in_container(name); + assert(i != -1); + meta_conn_status[i] = status; } } diff --git a/test/blackbox/common/common_handlers.h b/test/blackbox/common/common_handlers.h index e878f3b7..7c5fbd23 100644 --- a/test/blackbox/common/common_handlers.h +++ b/test/blackbox/common/common_handlers.h @@ -50,24 +50,4 @@ void meshlink_callback_node_status(meshlink_handle_t *mesh, meshlink_node_t *nod void meshlink_callback_logger(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text); -void change_ip(int node); -void create_bridge(const char *bridgeName); -void add_interface(const char *bridgeName, const char *interfaceName); -void add_veth_pair(const char *vethName1, const char *vethName2); -void bring_if_up(const char *bridgeName); -void replaceAll(char *str, const char *oldWord, const char *newWord); -void switch_bridge(const char *containerName, const char *currentBridge, const char *newBridge); -void bring_if_down(const char *bridgeName); -void del_interface(const char *bridgeName, const char *interfaceName); -void delete_bridge(const char *bridgeName); -void create_container_on_bridge(const char *containerName, const char *bridgeName, const char *ifName); -void config_dnsmasq(const char *containerName, const char *ifName, const char *listenAddress, const char *dhcpRange); -void config_nat(const char *containerName, const char *listenAddress); -void create_nat_layer(const char *containerName, const char *bridgeName, const char *ifName, const char *listenAddress, char *dhcpRange); -void destroy_nat_layer(const char *containerName, const char *bridgeName); -void incoming_firewall_ipv4(const char *packetType, int portNumber); -void incoming_firewall_ipv6(const char *packetType, int portNumber); -void outgoing_firewall_ipv4(const char *packetType, int portNumber); -void outgoing_firewall_ipv6(const char *packetType, int portNumber); - #endif // COMMON_HANDLERS_H diff --git a/test/blackbox/common/common_types.h b/test/blackbox/common/common_types.h index d0e4d96d..edea6501 100644 --- a/test/blackbox/common/common_types.h +++ b/test/blackbox/common/common_types.h @@ -30,6 +30,9 @@ #define LXC_RUN_SCRIPT "lxc_run.sh" #define LXC_COPY_SCRIPT "lxc_copy_file.sh" #define LXC_BUILD_SCRIPT "build_container.sh" +#define LXC_NAT_BUILD "nat.sh" +#define LXC_NAT_FULL_CONE "full_cone.sh" +#define LXC_NAT_DESTROY "nat_destroy.sh" typedef struct black_box_state { char *test_case_name; diff --git a/test/blackbox/common/containers.c b/test/blackbox/common/containers.c index d96b1a37..6d27151c 100644 --- a/test/blackbox/common/containers.c +++ b/test/blackbox/common/containers.c @@ -69,38 +69,51 @@ void rename_container(const char *old_name, const char *new_name) { assert(rename_status == 0); } +char *run_in_container(const char *cmd, const char *container_name, bool daemonize) { + char container_find_name[100]; + struct lxc_container *container; + + assert(cmd); + assert(container_name); + assert(snprintf(container_find_name, sizeof(container_find_name), "%s_%s", + state_ptr->test_case_name, container_name) >= 0); + assert(container = find_container(container_find_name)); + + return run_in_container_ex(cmd, container, daemonize); +} + +char *execute_in_container(const char *cmd, const char *container_name, bool daemonize) { + struct lxc_container *container; + + assert(cmd); + assert(container_name); + assert(container = find_container(container_name)); + + return run_in_container_ex(cmd, container, daemonize); +} + /* Run 'cmd' inside the Container created for 'node' and return the first line of the output or NULL if there is no output - useful when, for example, a meshlink invite is generated by a node running inside a Container 'cmd' is run as a daemon if 'daemonize' is true - this mode is useful for running node simulations in Containers The caller is responsible for freeing the returned string */ -char *run_in_container(const char *cmd, const char *node, bool daemonize) { - char attach_command[400]; - char *attach_argv[4]; - char container_find_name[100]; - struct lxc_container *container; - FILE *attach_fp; +char *run_in_container_ex(const char *cmd, struct lxc_container *container, bool daemonize) { char *output = NULL; - size_t output_len; - int i; - - assert(snprintf(container_find_name, sizeof(container_find_name), "%s_%s", - state_ptr->test_case_name, node) >= 0); - assert(container = find_container(container_find_name)); + size_t output_len = 0; /* Run the command within the Container, either as a daemon or foreground process */ /* TO DO: Perform this operation using the LXC API - currently does not work using the API Need to determine why it doesn't work, and make it work */ if(daemonize) { - for(i = 0; i < 3; i++) { - assert(attach_argv[i] = malloc(DAEMON_ARGV_LEN)); - } + char run_script_path[100]; + char *attach_argv[4]; - assert(snprintf(attach_argv[0], DAEMON_ARGV_LEN, "%s/" LXC_UTIL_REL_PATH "/" LXC_RUN_SCRIPT, + assert(snprintf(run_script_path, sizeof(run_script_path), "%s/" LXC_UTIL_REL_PATH "/" LXC_RUN_SCRIPT, meshlink_root_path) >= 0); - strncpy(attach_argv[1], cmd, DAEMON_ARGV_LEN); - strncpy(attach_argv[2], container->name, DAEMON_ARGV_LEN); + attach_argv[0] = run_script_path; + attach_argv[1] = (char *)cmd; + attach_argv[2] = container->name; attach_argv[3] = NULL; /* To daemonize, create a child process and detach it from its parent (this program) */ @@ -108,19 +121,24 @@ char *run_in_container(const char *cmd, const char *node, bool daemonize) { assert(daemon(1, 0) != -1); // Detach from the parent process assert(execv(attach_argv[0], attach_argv) != -1); // Run exec() in the child process } - - for(i = 0; i < 3; i++) { - free(attach_argv[i]); - } } else { - assert(snprintf(attach_command, sizeof(attach_command), + char *attach_command; + size_t attach_command_len; + int i; + attach_command_len = strlen(meshlink_root_path) + strlen(LXC_UTIL_REL_PATH) + strlen(LXC_RUN_SCRIPT) + strlen(cmd) + strlen(container->name) + 10; + attach_command = malloc(attach_command_len); + assert(attach_command); + + assert(snprintf(attach_command, attach_command_len, "%s/" LXC_UTIL_REL_PATH "/" LXC_RUN_SCRIPT " \"%s\" %s", meshlink_root_path, cmd, container->name) >= 0); + FILE *attach_fp; assert(attach_fp = popen(attach_command, "r")); + free(attach_command); /* If the command has an output, strip out any trailing carriage returns or newlines and return it, otherwise return NULL */ - assert(output = malloc(100)); - output_len = sizeof(output); + output = NULL; + output_len = 0; if(getline(&output, &output_len, attach_fp) != -1) { i = strlen(output) - 1; @@ -143,16 +161,29 @@ char *run_in_container(const char *cmd, const char *node, bool daemonize) { /* Wait for a starting Container to obtain an IP Address, then save that IP for future use */ void container_wait_ip(int node) { - char container_name[100], lxcls_command[200]; + char container_name[100]; + char *ip; + + assert(snprintf(container_name, sizeof(container_name), "%s_%s", state_ptr->test_case_name, + state_ptr->node_names[node]) >= 0); + ip = container_wait_ip_ex(container_name); + + strncpy(container_ips[node], ip, sizeof(container_ips[node])); // Save the IP for future use + PRINT_TEST_CASE_MSG("Node '%s' has IP Address %s\n", state_ptr->node_names[node], + container_ips[node]); + free(ip); +} + +char *container_wait_ip_ex(const char *container_name) { struct lxc_container *test_container; + char lxcls_command[200]; char *ip; size_t ip_len; - int i; bool ip_found; + int i; + int timeout; FILE *lxcls_fp; - assert(snprintf(container_name, sizeof(container_name), "%s_%s", state_ptr->test_case_name, - state_ptr->node_names[node]) >= 0); assert(test_container = find_container(container_name)); assert(snprintf(lxcls_command, sizeof(lxcls_command), "lxc-ls -f | grep %s | tr -s ' ' | cut -d ' ' -f 5", test_container->name) >= 0); @@ -160,8 +191,9 @@ void container_wait_ip(int node) { assert(ip = malloc(20)); ip_len = sizeof(ip); ip_found = false; + timeout = 60; - while(!ip_found) { + while(!ip_found && timeout) { assert(lxcls_fp = popen(lxcls_command, "r")); // Run command assert(getline((char **)&ip, &ip_len, lxcls_fp) != -1); // Read its output /* Strip newlines and carriage returns from output */ @@ -175,13 +207,13 @@ void container_wait_ip(int node) { ip_found = (strcmp(ip, "-") != 0); // If the output is not "-", IP has been acquired assert(pclose(lxcls_fp) != -1); sleep(1); + timeout--; } - strncpy(container_ips[node], ip, sizeof(container_ips[node])); // Save the IP for future use - PRINT_TEST_CASE_MSG("Node '%s' has IP Address %s\n", state_ptr->node_names[node], - container_ips[node]); + // Fail if IP cannot be read + assert(timeout); - free(ip); + return ip; } /* Create all required test containers */ @@ -189,7 +221,7 @@ void create_containers(const char *node_names[], int num_nodes) { int i; char container_name[100]; int create_status, snapshot_status, snap_restore_status; - struct lxc_container *first_container; + struct lxc_container *first_container = NULL; for(i = 0; i < num_nodes; i++) { assert(snprintf(container_name, sizeof(container_name), "run_%s", node_names[i]) >= 0); @@ -209,6 +241,7 @@ void create_containers(const char *node_names[], int num_nodes) { first_container->error_num, first_container->error_string); assert(snapshot_status != -1); } else { + assert(first_container); snap_restore_status = first_container->snapshot_restore(first_container, "snap0", container_name); fprintf(stderr, "Snapshot restore to Container '%s' status: %d - %s\n", container_name, @@ -346,28 +379,41 @@ char *invite_in_container(const char *inviter, const char *invitee) { /* Run the node_sim_ program inside the 'node''s container */ void node_sim_in_container(const char *node, const char *device_class, const char *invite_url) { - char node_sim_command[200]; + char *node_sim_command; + size_t node_sim_command_len; - assert(snprintf(node_sim_command, sizeof(node_sim_command), + node_sim_command_len = 500 + (invite_url ? strlen(invite_url) : 0); + node_sim_command = calloc(1, node_sim_command_len); + assert(node_sim_command); + assert(snprintf(node_sim_command, node_sim_command_len, "LD_LIBRARY_PATH=/home/ubuntu/test/.libs /home/ubuntu/test/node_sim_%s %s %s %s " "1>&2 2>> node_sim_%s.log", node, node, device_class, (invite_url) ? invite_url : "", node) >= 0); run_in_container(node_sim_command, node, true); PRINT_TEST_CASE_MSG("node_sim_%s started in Container\n", node); + + free(node_sim_command); } /* Run the node_sim_ program inside the 'node''s container with event handling capable */ void node_sim_in_container_event(const char *node, const char *device_class, const char *invite_url, const char *clientId, const char *import) { - char node_sim_command[200]; - - assert(snprintf(node_sim_command, sizeof(node_sim_command), + char *node_sim_command; + size_t node_sim_command_len; + + assert(node && device_class && clientId && import); + node_sim_command_len = 500 + (invite_url ? strlen(invite_url) : 0); + node_sim_command = calloc(1, node_sim_command_len); + assert(node_sim_command); + assert(snprintf(node_sim_command, node_sim_command_len, "LD_LIBRARY_PATH=/home/ubuntu/test/.libs /home/ubuntu/test/node_sim_%s %s %s %s %s %s " "1>&2 2>> node_sim_%s.log", node, node, device_class, clientId, import, (invite_url) ? invite_url : "", node) >= 0); run_in_container(node_sim_command, node, true); - PRINT_TEST_CASE_MSG("node_sim_%s(Client Id :%s) started in Container with event handling\n", - node, clientId); + PRINT_TEST_CASE_MSG("node_sim_%s(Client Id :%s) started in Container with event handling\n%s\n", + node, clientId, node_sim_command); + + free(node_sim_command); } /* Run the node_step.sh script inside the 'node''s container to send the 'sig' signal to the @@ -452,6 +498,41 @@ void change_ip(int node) { container_ips[node]); } +char **get_container_interface_ips(const char *container_name, const char *interface_name) { + char **ips; + struct lxc_container *container = find_container(container_name); + assert(container); + + char **interfaces = container->get_interfaces(container); + assert(interfaces); + + int i; + ips = NULL; + + for(i = 0; interfaces[i]; i++) { + if(!strcasecmp(interfaces[i], interface_name)) { + ips = container->get_ips(container, interface_name, "inet", 0); + assert(ips); + break; + } + } + + free(interfaces); + + return ips; +} + +/* Install an app in a container */ +void install_in_container(const char *node, const char *app) { + char install_cmd[100]; + + assert(snprintf(install_cmd, sizeof(install_cmd), + "apt-get install %s -y >> /dev/null", app) >= 0); + char *ret = run_in_container(install_cmd, node, false); + // TODO: Check in container whether app has installed or not with a timeout + sleep(10); +} + /* Return container's IP address */ char *get_container_ip(const char *node_name) { char *ip; @@ -476,17 +557,6 @@ char *get_container_ip(const char *node_name) { return ip; } -/* Install an app in a container */ -void install_in_container(const char *node, const char *app) { - char install_cmd[100]; - - assert(snprintf(install_cmd, sizeof(install_cmd), - "apt-get install %s -y >> /dev/null", app) >= 0); - char *ret = run_in_container(install_cmd, node, false); - // TODO: Check in container whether app has installed or not with a timeout - sleep(10); -} - /* Simulate a network failure by adding NAT rule in the container with it's IP address */ void block_node_ip(const char *node) { char block_cmd[100]; @@ -511,7 +581,7 @@ void accept_port_rule(const char *node, const char *chain, const char *protocol, assert(port >= 0 && port < 65536); assert(!strcmp(chain, "INPUT") || !strcmp(chain, "FORWARD") || !strcmp(chain, "OUTPUT")); - assert(!strcmp(protocol, "all") || !strcmp(protocol, "tcp") || !strcmp(protocol, "udp")); + assert(!strcmp(protocol, "all") || !strcmp(protocol, "tcp") || !strcmp(protocol, "udp") || !strcmp(protocol, "icmp")); assert(snprintf(block_cmd, sizeof(block_cmd), "iptables -A %s -p %s --dport %d -j ACCEPT", chain, protocol, port) >= 0); run_in_container(block_cmd, node, false); } @@ -533,6 +603,134 @@ void unblock_node_ip(const char *node) { run_in_container(unblock_cmd, node, false); } +char *block_icmp(const char *container_name) { + char block_cmd[500]; + assert(container_name); + assert(snprintf(block_cmd, sizeof(block_cmd), "iptables -A FORWARD -p icmp -j DROP") >= 0); + return execute_in_container(block_cmd, container_name, false); +} + +char *unblock_icmp(const char *container_name) { + char block_cmd[500]; + assert(container_name); + assert(snprintf(block_cmd, sizeof(block_cmd), "iptables -D FORWARD -p icmp -j DROP") >= 0); + return execute_in_container(block_cmd, container_name, false); +} + +char *change_container_mtu(const char *container_name, const char *interface_name, int mtu) { + char cmd[500]; + assert(container_name); + assert(snprintf(cmd, sizeof(cmd), "ifconfig %s mtu %d", interface_name, mtu) >= 0); + return execute_in_container(cmd, container_name, false); +} + +char *flush_conntrack(const char *container_name) { + assert(container_name); + + return execute_in_container("conntrack -F", container_name, false); +} + +void flush_nat_rules(const char *container_name, const char *chain) { + char *ret; + char flush_cmd[500]; + + assert(container_name); + assert(snprintf(flush_cmd, sizeof(flush_cmd), "iptables -F %s", chain ? chain : "") >= 0); + ret = execute_in_container("iptables -F", container_name, false); + assert(ret == NULL); +} + +void add_full_cone_nat_rules(const char *container_name, const char *pub_interface, const char *priv_interface_listen_address) { + char nat_cmd[500]; + char *ret; + + char **pub_interface_ips = get_container_interface_ips(container_name, pub_interface); + assert(pub_interface_ips[0]); + char *pub_interface_ip = pub_interface_ips[0]; + + assert(snprintf(nat_cmd, sizeof(nat_cmd), + "%s/" LXC_UTIL_REL_PATH "/" LXC_NAT_FULL_CONE " %s %s %s %s >/dev/null", + meshlink_root_path, container_name, pub_interface, pub_interface_ip, priv_interface_listen_address) >= 0); + assert(system(nat_cmd) == 0); + free(pub_interface_ips); +} + +/* Create a NAT and a bridge, bridge connected to NAT and containers to be NATed can be switched + to the NAT bridge from lxcbr0 */ +void nat_create(const char *nat_name, const char *nat_bridge, int nat_type) { + char build_command[200]; + assert(snprintf(build_command, sizeof(build_command), + "%s/" LXC_UTIL_REL_PATH "/" LXC_NAT_BUILD " %s %s %s >/dev/stderr", + meshlink_root_path, nat_name, nat_bridge, meshlink_root_path) >= 0); + assert(system(build_command) == 0); +} + +void nat_destroy(const char *nat_name) { + char build_command[200]; + assert(snprintf(build_command, sizeof(build_command), + "%s/" LXC_UTIL_REL_PATH "/" LXC_NAT_DESTROY " %s +x >/dev/null", + meshlink_root_path, nat_name) >= 0); + assert(system(build_command) == 0); +} + +/* Switches a container from current bridge to a new bridge */ +void container_switch_bridge(const char *container_name, char *lxc_conf_path, const char *current_bridge, const char *new_bridge) { + char config_path[500]; + char buffer[500]; + struct lxc_container *container; + char *lxc_path_temp; + char *ip; + + PRINT_TEST_CASE_MSG("Switiching container %s from bridge '%s' to bridge '%s'", container_name, current_bridge, new_bridge); + lxc_path_temp = lxc_path; + lxc_path = lxc_conf_path; + container = find_container(container_name); + assert(container); + lxc_path = lxc_path_temp; + assert(snprintf(config_path, sizeof(config_path), "%s/%s/config", lxc_conf_path, container_name) >= 0); + FILE *fp = fopen(config_path, "r"); + assert(fp); + FILE *fp_temp = fopen(".temp_file", "w"); + assert(fp_temp); + + char search_str[500]; + int net_no; + + while((fgets(buffer, sizeof(buffer), fp)) != NULL) { + if(sscanf(buffer, "lxc.net.%d.link", &net_no) == 1) { + char *ptr; + int len; + + if((ptr = strstr(buffer, current_bridge)) != NULL) { + len = strlen(current_bridge); + + if(((*(ptr - 1) == ' ') || (*(ptr - 1) == '\t') || (*(ptr - 1) == '=')) && ((ptr[len] == '\n') || (ptr[len] == '\t') || (ptr[len] == '\0') || (ptr[len] == ' '))) { + sprintf(buffer, "lxc.net.%d.link = %s\n", net_no, new_bridge); + } + } + } + + fputs(buffer, fp_temp); + } + + fclose(fp_temp); + fclose(fp); + remove(config_path); + rename(".temp_file", config_path); + + /* Restart the Container after building it and wait for it to acquire an IP */ + char cmd[200]; + int sys_ret; + assert(snprintf(cmd, sizeof(cmd), "lxc-stop %s", container_name) >= 0); + sys_ret = system(cmd); + assert(snprintf(cmd, sizeof(cmd), "lxc-start %s", container_name) >= 0); + sys_ret = system(cmd); + assert(sys_ret == 0); + ip = container_wait_ip_ex(container_name); + PRINT_TEST_CASE_MSG("Obtained IP address: %s for container %s after switching bridge", ip, container_name); + free(ip); +} + /* Takes bridgeName as input parameter and creates a bridge */ void create_bridge(const char *bridgeName) { char command[100] = "brctl addbr "; @@ -891,3 +1089,29 @@ void outgoing_firewall_ipv6(const char *packetType, int portNumber) { PRINT_TEST_CASE_MSG("Firewall for outgoing requests added on IPv6"); assert(system("ip6tables -L") == 0); } + +void bridge_add(const char *bridge_name) { + char cmd[500]; + + assert(bridge_name); + assert(snprintf(cmd, sizeof(cmd), "brctl addbr %s", bridge_name) >= 0); + assert(system(cmd) == 0); + assert(snprintf(cmd, sizeof(cmd), "ifconfig %s up", bridge_name) >= 0); + assert(system(cmd) == 0); +} + +void bridge_delete(const char *bridge_name) { + char cmd[500]; + + assert(bridge_name); + assert(snprintf(cmd, sizeof(cmd), "brctl delbr %s", bridge_name) >= 0); + assert(system(cmd) == 0); +} + +void bridge_add_interface(const char *bridge_name, const char *interface_name) { + char cmd[500]; + + assert(bridge_name || interface_name); + assert(snprintf(cmd, sizeof(cmd), "brctl addif %s %s", bridge_name, interface_name) >= 0); + assert(system(cmd) == 0); +} diff --git a/test/blackbox/common/containers.h b/test/blackbox/common/containers.h index 66b6c51d..8a54e6a3 100644 --- a/test/blackbox/common/containers.h +++ b/test/blackbox/common/containers.h @@ -23,9 +23,21 @@ #include -#define DAEMON_ARGV_LEN 200 +#define DAEMON_ARGV_LEN 2000 #define CONTAINER_SHUTDOWN_TIMEOUT 5 +#define DHCP_RANGE "172.16.0.2,172.16.255.254,12h" +#define PUB_INTERFACE "eth0" +#define PRIV_INTERFACE "eth1" +#define LISTEN_ADDRESS "172.16.0.1" +#define NET_MASK "255.255.255.0" +#define SUBNET_MASK "172.16.0.0/24" + +#define FULLCONE_NAT 1 +#define ADDRESS_RESTRICTED_NAT 2 +#define PORT_RESTRICTED_NAT 3 +#define SYMMERTIC_NAT 4 + extern char *lxc_path; extern struct lxc_container *find_container(const char *name); @@ -47,6 +59,25 @@ extern char *get_container_ip(const char *node_name); extern void install_in_container(const char *node, const char *app); extern void unblock_node_ip(const char *node); extern void block_node_ip(const char *node); -void accept_port_rule(const char *node, const char *chain, const char *protocol, int port); +extern void accept_port_rule(const char *node, const char *chain, const char *protocol, int port); +extern void nat_create(const char *nat_name, const char *nat_bridge, int nat_type); +extern void container_switch_bridge(const char *container_name, char *lxc_conf_path, const char *current_bridge, const char *new_bridge); +extern void bridge_add(const char *bridge_name); +extern void bridge_delete(const char *bridge_name); +extern void bridge_add_interface(const char *bridge_name, const char *interface_name); + +extern void nat_destroy(const char *nat_name); +extern char *run_in_container_ex(const char *cmd, struct lxc_container *container, bool daemonize); +extern char *execute_in_container(const char *cmd, const char *container_name, bool daemonize); +extern char *block_icmp(const char *container_name); +extern char *unblock_icmp(const char *container_name); +extern char *change_container_mtu(const char *container_name, const char *interface_name, int mtu); +extern char *flush_conntrack(const char *container_name); + +extern char **get_container_interface_ips(const char *container_name, const char *interface_name); +extern void flush_nat_rules(const char *container_name, const char *chain); +extern void add_full_cone_nat_rules(const char *container_name, const char *pub_interface, const char *priv_interface_listen_address); +extern void add_port_rest_nat_rules(const char *container_name, const char *pub_interface); +extern char *container_wait_ip_ex(const char *container_name); #endif // CONTAINERS_H diff --git a/test/blackbox/common/mesh_event_handler.c b/test/blackbox/common/mesh_event_handler.c index 0f331d67..1b7ebe92 100644 --- a/test/blackbox/common/mesh_event_handler.c +++ b/test/blackbox/common/mesh_event_handler.c @@ -30,43 +30,134 @@ #include #include #include +#include +#include "../../../src/meshlink_queue.h" +#include "../../utils.h" #include "mesh_event_handler.h" #define SERVER_LISTEN_PORT "9000" /* Port number that is binded with mesh event server socket */ +#define UDP_BUFF_MAX 2000 -// TODO: Implement mesh event handling with reentrant functions(if required). +// TODO: Implement mesh event handling with reentrancy . static struct sockaddr_in server_addr; static int client_fd = -1; static int server_fd = -1; +static pthread_t event_receive_thread, event_handle_thread; +static meshlink_queue_t event_queue; +static bool event_receive_thread_running, event_handle_thread_running; +static struct cond_flag sync_event = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cond = PTHREAD_COND_INITIALIZER}; -char *mesh_event_sock_create(const char *if_name) { - struct sockaddr_in server; - char *ip; - struct ifreq req_if; - struct sockaddr_in *resp_if_addr; +static void set_cond_flag(struct cond_flag *s, bool flag) { + pthread_mutex_lock(&s->mutex); + s->flag = flag; + pthread_cond_broadcast(&s->cond); + pthread_mutex_unlock(&s->mutex); +} + +static bool wait_cond_flag(struct cond_flag *s, int seconds) { + struct timespec timeout; + clock_gettime(CLOCK_REALTIME, &timeout); + timeout.tv_sec += seconds; + + pthread_mutex_lock(&s->mutex); + + while(!s->flag) + if(!pthread_cond_timedwait(&s->cond, &s->mutex, &timeout) || errno != EINTR) { + break; + } + + pthread_mutex_unlock(&s->mutex); + + return s->flag; +} + +// event_receive_handler running in a separate thread queues all the events received from the UDP port +static void *event_receive_handler(void *arg) { + size_t recv_ret; + char udp_buff[UDP_BUFF_MAX]; + struct sockaddr client; + socklen_t soc_len; + + while(event_receive_thread_running) { + recv_ret = recvfrom(server_fd, udp_buff, sizeof(udp_buff), 0, &client, &soc_len); + assert(recv_ret >= sizeof(mesh_event_payload_t)); + + // Push received mesh event data into the event_queue + mesh_event_payload_t *data = malloc(sizeof(mesh_event_payload_t)); + assert(data); + memcpy(data, udp_buff, sizeof(mesh_event_payload_t)); - if(if_name == NULL) { - return NULL; + // Also receive if there is any payload + if(data->payload_length) { + void *payload_data = malloc(data->payload_length); + assert(payload_data); + memcpy(payload_data, udp_buff + (int)sizeof(mesh_event_payload_t), data->payload_length); + data->payload = payload_data; + } else { + data->payload = NULL; + } + + // Push the event into the event queue + assert(meshlink_queue_push(&event_queue, data)); } - server_fd = socket(AF_INET, SOCK_DGRAM, 0); + return NULL; +} + +// `event_handler' runs in a separate thread which invokes the event handle callback with +// event packet as argument returns from the thread when the callback returns `true' or timeout +static void *event_handler(void *argv) { + bool callback_return = false; + void *data; + mesh_event_payload_t mesh_event_rec_packet; + mesh_event_callback_t callback = (mesh_event_callback_t)argv; + + while(event_handle_thread_running) { + + // Pops the event if found in the event queue + while((data = meshlink_queue_pop(&event_queue)) != NULL) { + memcpy(&mesh_event_rec_packet, data, sizeof(mesh_event_payload_t)); + free(data); - if(server_fd < 0) { - perror("socket"); + // Invokes the callback with the popped event packet + callback_return = callback(mesh_event_rec_packet); + + if(mesh_event_rec_packet.payload_length) { + free(mesh_event_rec_packet.payload); + } + + // Return or Close the event handle thread if callback returns true + if(callback_return) { + set_cond_flag(&sync_event, true); + event_handle_thread_running = false; + break; + } + } } + return NULL; +} + +char *mesh_event_sock_create(const char *if_name) { + struct sockaddr_in server = {0}; + char *ip; + struct ifreq req_if = {0}; + struct sockaddr_in *resp_if_addr; + + assert(if_name); + assert(!event_receive_thread_running); + + server_fd = socket(AF_INET, SOCK_DGRAM, 0); assert(server_fd >= 0); int reuse = 1; assert(setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) != -1); - memset(&req_if, 0, sizeof(req_if)); req_if.ifr_addr.sa_family = AF_INET; strncpy(req_if.ifr_name, if_name, IFNAMSIZ - 1); assert(ioctl(server_fd, SIOCGIFADDR, &req_if) != -1); resp_if_addr = (struct sockaddr_in *) & (req_if.ifr_addr); - memset(&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_addr = resp_if_addr->sin_addr; server.sin_port = htons(atoi(SERVER_LISTEN_PORT)); @@ -77,16 +168,20 @@ char *mesh_event_sock_create(const char *if_name) { strcat(ip, ":"); strcat(ip, SERVER_LISTEN_PORT); + meshlink_queue_init(&event_queue); + event_receive_thread_running = true; + assert(!pthread_create(&event_receive_thread, NULL, event_receive_handler, NULL)); + return ip; } void mesh_event_sock_connect(const char *import) { - char *port = NULL; - assert(import); char *ip = strdup(import); - assert((port = strchr(ip, ':')) != NULL); + assert(ip); + char *port = strchr(ip, ':'); + assert(port); *port = '\0'; port++; @@ -99,25 +194,34 @@ void mesh_event_sock_connect(const char *import) { assert(client_fd >= 0); } -bool mesh_event_sock_send(int client_id, mesh_event_t event, void *payload, size_t payload_length) { +bool mesh_event_sock_send(int client_id, mesh_event_t event, const void *payload, size_t payload_length) { + if(client_fd < 0) { + fprintf(stderr, "mesh_event_sock_send called without calling mesh_event_sock_connect\n"); + return false; + } + + if(client_id < 0 || event < 0 || event >= MAX_EVENT || (payload == NULL && payload_length)) { + fprintf(stderr, "Invalid parameters\n"); + return false; + } + + ssize_t send_size = sizeof(mesh_event_payload_t) + payload_length; + char *send_packet = malloc(send_size); + assert(send_packet); mesh_event_payload_t mesh_event_send_packet; - ssize_t send_ret; - // Packing the mesh event - assert(client_id >= 0); - assert(client_fd >= 0); - assert(event >= 0 && event < MAX_EVENT); mesh_event_send_packet.client_id = client_id; mesh_event_send_packet.mesh_event = event; + mesh_event_send_packet.payload_length = payload_length; + mesh_event_send_packet.payload = NULL; + memcpy(send_packet, &mesh_event_send_packet, sizeof(mesh_event_send_packet)); - if((payload == NULL) || (payload_length == 0)) { - mesh_event_send_packet.payload_length = 0; - } else { - mesh_event_send_packet.payload_length = payload_length; - memmove(mesh_event_send_packet.payload, payload, payload_length); + if(payload_length) { + memcpy(send_packet + sizeof(mesh_event_send_packet), payload, payload_length); } - send_ret = sendto(client_fd, &mesh_event_send_packet, sizeof(mesh_event_send_packet), 0, (const struct sockaddr *) &server_addr, sizeof(server_addr)); + ssize_t send_ret = sendto(client_fd, send_packet, send_size, 0, (const struct sockaddr *) &server_addr, sizeof(server_addr)); + free(send_packet); if(send_ret < 0) { perror("sendto status"); @@ -127,36 +231,43 @@ bool mesh_event_sock_send(int client_id, mesh_event_t event, void *payload, size } } -bool wait_for_event(mesh_event_callback_t callback, int t) { - struct timeval timeout; - struct sockaddr client; - socklen_t soc_len; - fd_set read_fds; - int activity; - mesh_event_payload_t mesh_event_rec_packet; +bool wait_for_event(mesh_event_callback_t callback, int seconds) { + if(callback == NULL || seconds == 0) { + fprintf(stderr, "Invalid parameters\n"); + return false; + } + + if(event_handle_thread_running) { + fprintf(stderr, "Event handle thread is already running\n"); + return false; + } else { + event_handle_thread_running = true; + } - assert(callback); - assert(server_fd >= -1); - assert(t >= 0); - - timeout.tv_sec = t; - timeout.tv_usec = 0; - FD_ZERO(&read_fds); - FD_SET(server_fd, &read_fds); - - while(1) { - activity = select(server_fd + 1, &read_fds, NULL, NULL, &timeout); - assert(activity != -1); - - if(activity == 0) { - // If no activity happened for the timeout given - return false; - } else if(FD_ISSET(server_fd, &read_fds)) { - // Unpacking the mesh event - ssize_t recv_ret = recvfrom(server_fd, &mesh_event_rec_packet, sizeof(mesh_event_rec_packet), 0, &client, &soc_len); - assert(recv_ret == sizeof(mesh_event_rec_packet)); - callback(mesh_event_rec_packet); - return true; + set_cond_flag(&sync_event, false); + assert(!pthread_create(&event_handle_thread, NULL, event_handler, (void *)callback)); + bool wait_ret = wait_cond_flag(&sync_event, seconds); + event_handle_thread_running = false; + pthread_cancel(event_handle_thread); + + return wait_ret; +} + +void mesh_events_flush(void) { + mesh_event_payload_t *data; + + while((data = meshlink_queue_pop(&event_queue)) != NULL) { + if(data->payload_length) { + free(data->payload); } - }// while + + free(data); + } } + +void mesh_event_destroy(void) { + mesh_events_flush(); + event_receive_thread_running = false; + pthread_cancel(event_receive_thread); +} + diff --git a/test/blackbox/common/mesh_event_handler.h b/test/blackbox/common/mesh_event_handler.h index 4300affb..7e497a35 100644 --- a/test/blackbox/common/mesh_event_handler.h +++ b/test/blackbox/common/mesh_event_handler.h @@ -36,9 +36,6 @@ #include #include -/// Maximum length of the mesh event payload -#define PAYLOAD_MAX_SIZE 1000 - /// mesh events // TODO: Add more mesh event if required. typedef enum { @@ -55,10 +52,17 @@ typedef enum { META_RECONN_FAILURE, MESH_DATA_RECEIVED, NODE_STARTED, + NODE_LEFT, NODE_RESTARTED, NODE_JOINED, + NODE_JOINED1, + NODE_JOINED2, + NODE_JOINED3, PORT_NO, + OPTIMAL_PMTU_PEER, + OPTIMAL_PMTU_RELAY, ERR_NETWORK, + SIG_ABORT, MESH_DATA_VERIFED, CHANNEL_OPENED, CHANNEL_REQ_RECIEVED, @@ -73,19 +77,25 @@ typedef enum { } mesh_event_t; /// mesh event UDP packet -typedef struct mesh_event_payload { - uint32_t client_id; +typedef struct mesh_event_payload { + void *payload; mesh_event_t mesh_event; - uint16_t payload_length; - uint8_t payload[PAYLOAD_MAX_SIZE]; + uint16_t client_id; + uint32_t payload_length; } mesh_event_payload_t; +struct cond_flag { + pthread_mutex_t mutex; + pthread_cond_t cond; + bool flag; +}; + /// callback for handling the mesh event /** mesh event callback called from wait_for_event() if the mesh event UDP server gets a mesh event. * * @param mesh_event_packet packet containing client-id, mesh event & payload (if any). */ -typedef void (*mesh_event_callback_t)(mesh_event_payload_t mesh_event_packet); +typedef bool (*mesh_event_callback_t)(mesh_event_payload_t mesh_event_packet); /// Creates an UDP server for listening mesh events. /** This function creates an UDP socket, binds it with given interface address and returns a NULL @@ -124,7 +134,7 @@ extern bool wait_for_event(mesh_event_callback_t callback, int timeout); * * @return This function returns true on success else returns false. */ -extern bool mesh_event_sock_send(int client_id, mesh_event_t event, void *payload, size_t payload_length); +extern bool mesh_event_sock_send(int client_id, mesh_event_t event, const void *payload, size_t payload_length); /// Imports the server address, saves it and opens an UDP client socket. /** This function creates an UDP socket, binds it with given interface address and returns a NULL @@ -137,5 +147,8 @@ extern bool mesh_event_sock_send(int client_id, mesh_event_t event, void *payloa */ extern void mesh_event_sock_connect(const char *server_address); -bool wait_for_event_only(mesh_event_callback_t callback, int t, mesh_event_t event); +extern void mesh_event_destroy(void); + +extern void mesh_events_flush(void); + #endif // _MESH_EVENT_HANDLER_H_ diff --git a/test/blackbox/common/tcpdump.c b/test/blackbox/common/tcpdump.c index a0933f73..7839a422 100644 --- a/test/blackbox/common/tcpdump.c +++ b/test/blackbox/common/tcpdump.c @@ -25,6 +25,7 @@ #include #include #include "common_handlers.h" +#include "containers.h" #include "tcpdump.h" pid_t tcpdump_start(char *interface) { @@ -32,7 +33,7 @@ pid_t tcpdump_start(char *interface) { char *argv[] = { "tcpdump", "-i", interface, NULL }; // child process have a pipe to the parent process when parent process terminates SIGPIPE kills the tcpdump int pipes[2]; - pipe(pipes); + assert(pipe(pipes) != -1); PRINT_TEST_CASE_MSG("\x1b[32mLaunching TCP Dump ..\x1b[0m\n"); if((tcpdump_pid = fork()) == 0) { diff --git a/test/blackbox/common/test_step.c b/test/blackbox/common/test_step.c index 4a2bf853..7681c82e 100644 --- a/test/blackbox/common/test_step.c +++ b/test/blackbox/common/test_step.c @@ -39,6 +39,7 @@ meshlink_handle_t *execute_open(char *node_name, char *dev_class) { /* Create meshlink instance */ mesh_handle = meshlink_open("testconf", node_name, "node_sim", atoi(dev_class)); fprintf(stderr, "meshlink_open status: %s\n", meshlink_strerror(meshlink_errno)); + meshlink_enable_discovery(mesh_handle, false); PRINT_TEST_CASE_MSG("meshlink_open status: %s\n", meshlink_strerror(meshlink_errno)); assert(mesh_handle); @@ -51,7 +52,7 @@ meshlink_handle_t *execute_open(char *node_name, char *dev_class) { } char *execute_invite(char *invitee) { - char *invite_url = meshlink_invite(mesh_handle, invitee); + char *invite_url = meshlink_invite_ex(mesh_handle, invitee, MESHLINK_INVITE_LOCAL | MESHLINK_INVITE_NUMERIC); PRINT_TEST_CASE_MSG("meshlink_invite status: %s\n", meshlink_strerror(meshlink_errno)); assert(invite_url); @@ -62,15 +63,7 @@ char *execute_invite(char *invitee) { void execute_join(char *invite_url) { bool join_status; - /* The inviting node may take a moment to open its listening port - This sleep() prevents meshlink_join() from failing when the listening port is not open */ - /* TO DO: Replace this with code that actually checks for the port being open, if possible */ - PRINT_TEST_CASE_MSG("Sleeping 1 sec to allow inviting node to start listening...\n"); - sleep(1); - - PRINT_TEST_CASE_MSG("About to join with mesh_handle = %p, invite_url = %s\n", mesh_handle, invite_url); join_status = meshlink_join(mesh_handle, invite_url); - PRINT_TEST_CASE_MSG("meshlink_join status: %s\n", meshlink_strerror(meshlink_errno)); assert(join_status); } diff --git a/test/blackbox/run_blackbox_tests/execute_tests.c b/test/blackbox/run_blackbox_tests/execute_tests.c index b9fd1fa9..2f9730e1 100644 --- a/test/blackbox/run_blackbox_tests/execute_tests.c +++ b/test/blackbox/run_blackbox_tests/execute_tests.c @@ -35,7 +35,6 @@ int setup_test(void **state) { for(i = 0; i < state_ptr->num_nodes; i++) { meta_conn_status[i] = false; - node_reachable_status[i] = false; } setup_containers(state); diff --git a/test/blackbox/run_blackbox_tests/run_blackbox_tests.c b/test/blackbox/run_blackbox_tests/run_blackbox_tests.c index 691ac215..5cfb21f7 100644 --- a/test/blackbox/run_blackbox_tests/run_blackbox_tests.c +++ b/test/blackbox/run_blackbox_tests/run_blackbox_tests.c @@ -83,11 +83,11 @@ int main(int argc, char *argv[]) { int failed_tests = 0; - failed_tests += test_meta_conn(); + /*failed_tests += test_meta_conn(); failed_tests += test_meshlink_set_status_cb(); failed_tests += test_meshlink_join(); failed_tests += test_meshlink_set_channel_poll_cb(); -// failed_tests += test_meshlink_channel_open_ex(); + failed_tests += test_meshlink_channel_open_ex(); failed_tests += test_meshlink_channel_get_flags(); failed_tests += test_meshlink_set_channel_accept_cb(); failed_tests += test_meshlink_destroy(); @@ -123,7 +123,8 @@ int main(int argc, char *argv[]) { failed_tests += test_meshlink_channel_open(); failed_tests += test_meshlink_channel_close(); - failed_tests += test_meshlink_channel_conn(); + failed_tests += test_meshlink_channel_conn();*/ + printf("[ PASSED ] %d test(s).\n", total_tests - failed_tests); printf("[ FAILED ] %d test(s).\n", failed_tests); diff --git a/test/blackbox/run_blackbox_tests/test_cases.c b/test/blackbox/run_blackbox_tests/test_cases.c index 942c72c6..ee9171f6 100644 --- a/test/blackbox/run_blackbox_tests/test_cases.c +++ b/test/blackbox/run_blackbox_tests/test_cases.c @@ -117,7 +117,7 @@ static bool meta_conn01_conn; static bool meta_conn01_closed; static bool meta_conn01_reconn; -static void meta_conn01_cb(mesh_event_payload_t payload) { +static bool meta_conn01_cb(mesh_event_payload_t payload) { char event_node_name[][10] = {"RELAY", "PEER", "NUT"}; fprintf(stderr, "%s : ", event_node_name[payload.client_id]); @@ -138,6 +138,8 @@ static void meta_conn01_cb(mesh_event_payload_t payload) { meta_conn01_reconn = true; break; } + + return true; } /* Execute Meta-connections Test Case # 1 - re-connection to peer after disconnection when @@ -159,7 +161,6 @@ static void test_case_meta_conn_01(void **state) { */ static bool test_steps_meta_conn_01(void) { char *invite_peer, *invite_nut; - bool result = false; int i; char *import; @@ -188,18 +189,19 @@ static bool test_steps_meta_conn_01(void) { PRINT_TEST_CASE_MSG("Waiting for peer to be re-connected\n"); wait_for_event(meta_conn01_cb, 60); - assert_int_equal(meta_conn01_reconn, true); - + mesh_event_destroy(); free(invite_peer); free(invite_nut); + assert_int_equal(meta_conn01_reconn, true); + return true; } static bool meta_conn02_conn; -static void meta_conn02_cb(mesh_event_payload_t payload) { +static bool meta_conn02_cb(mesh_event_payload_t payload) { char event_node_name[][10] = {"RELAY", "PEER", "NUT"}; fprintf(stderr, "%s : ", event_node_name[payload.client_id]); @@ -214,9 +216,7 @@ static void meta_conn02_cb(mesh_event_payload_t payload) { break; } - if(payload.payload_length) { - fprintf(stderr, " %s\n", (char *)payload.payload); - } + return true; } /* Execute Meta-connections Test Case # 2 - re-connection to peer via third node after changing IP of NUT and peer */ @@ -235,7 +235,6 @@ static void test_case_meta_conn_02(void **state) { */ static bool test_steps_meta_conn_02(void) { char *invite_peer, *invite_nut; - bool result = false; int i; char *import; @@ -260,23 +259,21 @@ static bool test_steps_meta_conn_02(void) { wait_for_event(meta_conn02_cb, 5); PRINT_TEST_CASE_MSG("Waiting for peer to be connected with NUT\n"); + wait_for_event(meta_conn02_cb, 60); - if(!wait_for_event(meta_conn02_cb, 60)) { - return false; - } - - result = meta_conn02_conn; - + mesh_event_destroy(); free(invite_peer); free(invite_nut); - return result; + assert_int_equal(meta_conn02_conn, true); + + return true; } static bool meta_conn03_result; static bool meta_conn03_conn; -static void meta_conn03_cb(mesh_event_payload_t payload) { +static bool meta_conn03_cb(mesh_event_payload_t payload) { char event_node_name[][10] = {"RELAY", "PEER", "NUT"}; fprintf(stderr, "%s : ", event_node_name[payload.client_id]); @@ -300,6 +297,8 @@ static void meta_conn03_cb(mesh_event_payload_t payload) { meta_conn03_result = true; break; } + + return true; } /* Execute Meta-connections Test Case # 3 - re-connection to peer via third node after changing IP of peer */ @@ -318,7 +317,6 @@ static void test_case_meta_conn_03(void **state) { */ static bool test_steps_meta_conn_03(void) { char *invite_peer, *invite_nut; - bool result = false; int i; char *import; @@ -338,21 +336,25 @@ static bool test_steps_meta_conn_03(void) { PRINT_TEST_CASE_MSG("Changing IP address of PEER container\n"); change_ip(1); + sleep(3); node_sim_in_container_event("peer", "1", NULL, PEER_ID, import); wait_for_event(meta_conn03_cb, 5); PRINT_TEST_CASE_MSG("Waiting for peer to be re-connected\n"); wait_for_event(meta_conn03_cb, 5); - result = meta_conn03_result; + + mesh_event_destroy(); free(invite_peer); free(invite_nut); - return result; + assert_int_equal(meta_conn03_result, true); + + return true; } static char *invite_peer = NULL; static bool meta_conn04 = false; -static void meta_conn04_cb(mesh_event_payload_t payload) { +static bool meta_conn04_cb(mesh_event_payload_t payload) { char event_node_name[][10] = {"PEER", "NUT"}; fprintf(stderr, "%s : ", event_node_name[payload.client_id]); @@ -371,7 +373,12 @@ static void meta_conn04_cb(mesh_event_payload_t payload) { case NODE_STARTED : fprintf(stderr, "Node started\n"); break; + + default : + fprintf(stderr, "Undefined mesh event\n"); } + + return true; } /* Execute Meta-connections Test Case # 4 - re-connection to peer after changing IP of @@ -391,7 +398,6 @@ static void test_case_meta_conn_04(void **state) { NUT is first disconnected from peer then automatically re-connected to peer */ static bool test_steps_meta_conn_04(void) { - bool result = false; char *import; import = mesh_event_sock_create(eth_if_name); @@ -401,18 +407,15 @@ static bool test_steps_meta_conn_04(void) { PRINT_TEST_CASE_MSG("Waiting for NUT to generate invitation to PEER\n"); wait_for_event(meta_conn04_cb, 5); - if(!invite_peer) { - return false; - } + assert(invite_peer); PRINT_TEST_CASE_MSG("Running PEER node in the container\n"); + fprintf(stderr, "inv: %s\n", invite_peer); node_sim_in_container_event("peer", "1", invite_peer, "0", import); wait_for_event(meta_conn04_cb, 5); PRINT_TEST_CASE_MSG("Waiting for peer to be connected with NUT\n"); - if(!wait_for_event(meta_conn04_cb, 60)) { - return false; - } + assert(wait_for_event(meta_conn04_cb, 60)); PRINT_TEST_CASE_MSG("Changing IP address of NUT container\n"); change_ip(1); @@ -426,18 +429,21 @@ static bool test_steps_meta_conn_04(void) { PRINT_TEST_CASE_MSG("Waiting for peer to be re-connected\n"); wait_for_event(meta_conn04_cb, 5); - result = meta_conn04; + mesh_event_destroy(); free(invite_peer); free(import); - return result; + + assert_int_equal(meta_conn04, true); + + return true; } static char *invitation = NULL; static bool meta_conn05 = false; -static void meta_conn05_cb(mesh_event_payload_t payload) { +static bool meta_conn05_cb(mesh_event_payload_t payload) { char event_node_name[][10] = {"PEER", "NUT"}; fprintf(stderr, "%s : ", event_node_name[payload.client_id]); @@ -455,6 +461,8 @@ static void meta_conn05_cb(mesh_event_payload_t payload) { fprintf(stderr, "Node started\n"); break; } + + return true; } /* Execute Meta-connections Test Case # 5 - re-connection to peer after changing IP of peer */ @@ -472,7 +480,6 @@ static void test_case_meta_conn_05(void **state) { NUT is first disconnected from peer then automatically re-connected to peer */ static bool test_steps_meta_conn_05(void) { - bool result = false; char *import; import = mesh_event_sock_create(eth_if_name); @@ -481,16 +488,12 @@ static bool test_steps_meta_conn_05(void) { wait_for_event(meta_conn05_cb, 5); - if(!invitation) { - return false; - } + assert(invitation); node_sim_in_container_event("peer", "1", invitation, "0", import); wait_for_event(meta_conn05_cb, 5); - if(!wait_for_event(meta_conn05_cb, 5)) { - return false; - } + assert(wait_for_event(meta_conn05_cb, 5)); change_ip(0); meta_conn05 = false; @@ -498,11 +501,14 @@ static bool test_steps_meta_conn_05(void) { wait_for_event(meta_conn05_cb, 5); PRINT_TEST_CASE_MSG("Waiting for peer to be re-connected\n"); wait_for_event(meta_conn05_cb, 5); - result = meta_conn05; + mesh_event_destroy(); free(invitation); free(import); - return result; + + assert_int_equal(meta_conn05, true); + + return true; } int test_meta_conn(void) { diff --git a/test/blackbox/run_blackbox_tests/test_cases_channel_conn.c b/test/blackbox/run_blackbox_tests/test_cases_channel_conn.c index a2145cc1..bbe2948f 100644 --- a/test/blackbox/run_blackbox_tests/test_cases_channel_conn.c +++ b/test/blackbox/run_blackbox_tests/test_cases_channel_conn.c @@ -105,7 +105,7 @@ static bool node_reachable; static bool node_unreachable; /* Callback function for handling channel connection test cases mesh events */ -static void channel_conn_cb(mesh_event_payload_t payload) { +static bool channel_conn_cb(mesh_event_payload_t payload) { switch(payload.mesh_event) { case NODE_JOINED : joined = true; @@ -139,7 +139,7 @@ static void channel_conn_cb(mesh_event_payload_t payload) { PRINT_TEST_CASE_MSG("Undefined event occurred\n"); } - return; + return true; } /* Execute channel connections Test Case # 1 - simulate a temporary network @@ -205,10 +205,13 @@ static bool test_steps_channel_conn_01(void) { // Wait for peer node to receive data via channel from NUT wait_for_event(channel_conn_cb, 60); - assert_int_equal(channel_received, true); + mesh_event_destroy(); free(invite_nut); free(import); + + assert_int_equal(channel_received, true); + return true; } @@ -275,10 +278,13 @@ static bool test_steps_channel_conn_02(void) { // Wait for peer node to send the event about the channel error occurred with length = 0 wait_for_event(channel_conn_cb, 90); - assert_int_equal(received_error, true); + mesh_event_destroy(); free(invite_nut); free(import); + + assert_int_equal(received_error, true); + return true; } @@ -356,10 +362,13 @@ static bool test_steps_channel_conn_03(void) { // Wait for data to be received at peer via channel from NUT after restoring n/w wait_for_event(channel_conn_cb, 90); - assert_int_equal(channel_received, true); + mesh_event_destroy(); free(invite_nut); free(import); + + assert_int_equal(channel_received, true); + return true; } @@ -414,6 +423,12 @@ static bool test_steps_channel_conn_04(void) { // After 1 min the channel between NUT and peer should result in error wait_for_event(channel_conn_cb, 10); + + + mesh_event_destroy(); + free(invite_nut); + free(import); + assert_int_equal(received_error, true); return true; @@ -485,11 +500,14 @@ static bool test_steps_channel_conn_05(void) { // Wait for peer to get data from NUT node via channel after restoring network in < 60 secs wait_for_event(channel_conn_cb, 60); - assert_int_equal(channel_received, true); - free(invite_nut); + mesh_event_destroy(); free(invite_peer); + free(invite_nut); free(import); + + assert_int_equal(channel_received, true); + return true; } @@ -560,11 +578,14 @@ static bool test_steps_channel_conn_06(void) { // Wait for channel to receive error and receive the event wait_for_event(channel_conn_cb, 90); - assert_int_equal(received_error, true); - free(invite_nut); + mesh_event_destroy(); free(invite_peer); + free(invite_nut); free(import); + + assert_int_equal(received_error, true); + return true; } @@ -646,11 +667,14 @@ static bool test_steps_channel_conn_07(void) { // Wait for peer node to receive data via channel without any error wait_for_event(channel_conn_cb, 90); - assert_int_equal(channel_received, true); - free(invite_nut); + mesh_event_destroy(); free(invite_peer); + free(invite_nut); free(import); + + assert_int_equal(channel_received, true); + return true; } @@ -716,11 +740,14 @@ static bool test_steps_channel_conn_08(void) { // Wait for peer to receive channel error wait_for_event(channel_conn_cb, 10); - assert_int_equal(received_error, true); - free(invite_nut); + mesh_event_destroy(); free(invite_peer); + free(invite_nut); free(import); + + assert_int_equal(received_error, true); + return true; } @@ -745,21 +772,21 @@ static int black_box_group_teardown(void **state) { int test_meshlink_channel_conn(void) { const struct CMUnitTest blackbox_group0_tests[] = { cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_01, setup_test, teardown_test, - (void *)&test_case_channel_conn_01_state), - cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_02, setup_test, teardown_test, - (void *)&test_case_channel_conn_02_state), - cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_03, setup_test, teardown_test, - (void *)&test_case_channel_conn_03_state), - cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_04, setup_test, teardown_test, - (void *)&test_case_channel_conn_04_state), - cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_05, setup_test, teardown_test, - (void *)&test_case_channel_conn_05_state), - cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_06, setup_test, teardown_test, - (void *)&test_case_channel_conn_06_state), - cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_07, setup_test, teardown_test, - (void *)&test_case_channel_conn_07_state), - cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_08, setup_test, teardown_test, - (void *)&test_case_channel_conn_08_state) + (void *)&test_case_channel_conn_01_state),/* + cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_02, setup_test, teardown_test, + (void *)&test_case_channel_conn_02_state), + cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_03, setup_test, teardown_test, + (void *)&test_case_channel_conn_03_state), + cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_04, setup_test, teardown_test, + (void *)&test_case_channel_conn_04_state), + cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_05, setup_test, teardown_test, + (void *)&test_case_channel_conn_05_state), + cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_06, setup_test, teardown_test, + (void *)&test_case_channel_conn_06_state), + cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_07, setup_test, teardown_test, + (void *)&test_case_channel_conn_07_state), + cmocka_unit_test_prestate_setup_teardown(test_case_channel_conn_08, setup_test, teardown_test, + (void *)&test_case_channel_conn_08_state)*/ }; total_tests += sizeof(blackbox_group0_tests) / sizeof(blackbox_group0_tests[0]); diff --git a/test/blackbox/run_blackbox_tests/test_cases_channel_set_poll_cb.c b/test/blackbox/run_blackbox_tests/test_cases_channel_set_poll_cb.c index 2234c393..5e1d63ed 100644 --- a/test/blackbox/run_blackbox_tests/test_cases_channel_set_poll_cb.c +++ b/test/blackbox/run_blackbox_tests/test_cases_channel_set_poll_cb.c @@ -197,7 +197,7 @@ static bool test_steps_channel_set_poll_cb_02(void) { /* Setting poll cb with NULL as mesh handler */ meshlink_set_channel_poll_cb(NULL, channel, poll_cb); - assert_int_equal(meshlink_errno, MESHLINK_EINVAL); + assert_int_not_equal(meshlink_errno, 0); meshlink_close(mesh_handle); meshlink_destroy("channelpollconf3"); diff --git a/test/blackbox/run_blackbox_tests/test_cases_set_port.c b/test/blackbox/run_blackbox_tests/test_cases_set_port.c index 0bc2c6af..48129def 100644 --- a/test/blackbox/run_blackbox_tests/test_cases_set_port.c +++ b/test/blackbox/run_blackbox_tests/test_cases_set_port.c @@ -112,8 +112,9 @@ static bool test_set_port_02(void) { // meshlink_set_port called using NULL as mesh handle bool ret = meshlink_set_port(NULL, 8000); - + assert_int_equal(meshlink_errno, 0); assert_int_equal(ret, false); + return false; } @@ -139,10 +140,10 @@ static bool test_set_port_03(void) { mesh_handle = meshlink_open("getportconf", "nut", "test", 1); assert(mesh_handle); meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger); - assert(meshlink_start(mesh_handle)); // Setting port after starting NUT bool ret = meshlink_set_port(mesh_handle, 50000); + assert_int_equal(meshlink_errno, 0); assert_int_equal(ret, false); // Clean up diff --git a/test/blackbox/test_case_channel_conn_01/node_sim_nut.c b/test/blackbox/test_case_channel_conn_01/node_sim_nut.c index bded500a..057faaca 100644 --- a/test/blackbox/test_case_channel_conn_01/node_sim_nut.c +++ b/test/blackbox/test_case_channel_conn_01/node_sim_nut.c @@ -64,7 +64,7 @@ static void send_event(mesh_event_t event) { } assert(attempts < 5); - + fprintf(stderr, "SENT EVENT\n"); return; } @@ -146,7 +146,7 @@ int main(int argc, char *argv[]) { assert(wait_sync_flag(&channel_opened, 10)); send_event(CHANNEL_OPENED); - assert(wait_sync_flag(&sigusr_received, 10)); + assert(wait_sync_flag(&sigusr_received, 30)); sleep(10); diff --git a/test/blackbox/test_case_channel_conn_06/node_sim_nut.c b/test/blackbox/test_case_channel_conn_06/node_sim_nut.c index 858e48d0..643028ab 100644 --- a/test/blackbox/test_case_channel_conn_06/node_sim_nut.c +++ b/test/blackbox/test_case_channel_conn_06/node_sim_nut.c @@ -71,7 +71,6 @@ static void send_event(mesh_event_t event) { static void node_status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) { - fprintf(stderr, "\n\n\n NODE STATUS CB : %s is %d\n\n\n\n", node->name, reachable); if(!strcasecmp(node->name, "peer") && reachable) { set_sync_flag(&peer_reachable, true); @@ -88,7 +87,6 @@ static void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t } static void channel_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *dat, size_t len) { - fprintf(stderr, "\n\n\n LEN = %u & DATA = %s in RECV CB\n\n\n\n", len, (char *)dat); if(len == 0) { set_sync_flag(&channel_closed, true); @@ -151,18 +149,14 @@ int main(int argc, char *argv[]) { assert(wait_sync_flag(&channel_opened, 10)); send_event(CHANNEL_OPENED); - fprintf(stderr, "\n\n\nChannel opened, Waiting for SIGUSR1\n\n\n\n"); assert(wait_sync_flag(&sigusr_received, 10)); - fprintf(stderr, "\n\n\nChannel sending, got SIGUSR1\n\n\n\n"); sleep(40); assert(meshlink_channel_send(mesh, channel, "after", 6) >= 0); - fprintf(stderr, "\n\n\nWaiting for close\n\n\n\n"); assert(wait_sync_flag(&channel_closed, 140)); - fprintf(stderr, "\n\n\nCHANNEL CLOSED\n\n\n\n"); // All test steps executed - wait for signals to stop/start or close the mesh while(test_running) { diff --git a/test/blackbox/test_case_channel_conn_06/node_sim_peer.c b/test/blackbox/test_case_channel_conn_06/node_sim_peer.c index a0be6237..24c8d7d7 100644 --- a/test/blackbox/test_case_channel_conn_06/node_sim_peer.c +++ b/test/blackbox/test_case_channel_conn_06/node_sim_peer.c @@ -61,7 +61,6 @@ static bool channel_accept(meshlink_handle_t *mesh, meshlink_channel_t *channel, } static void channel_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *dat, size_t len) { - fprintf(stderr, "\n\n\n LEN = %u & DATA = %s in RECV CB\n\n\n\n", len, (char *)dat); if(len == 0) { assert(mesh_event_sock_send(client_id, ERR_NETWORK, NULL, 0)); diff --git a/test/blackbox/test_case_channel_conn_07/node_sim_nut.c b/test/blackbox/test_case_channel_conn_07/node_sim_nut.c index b47c0006..7bab5226 100644 --- a/test/blackbox/test_case_channel_conn_07/node_sim_nut.c +++ b/test/blackbox/test_case_channel_conn_07/node_sim_nut.c @@ -105,7 +105,7 @@ static void channel_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *chan } int main(int argc, char *argv[]) { - struct timeval main_loop_wait = { 2, 0 }; + struct timeval main_loop_wait = { 5, 0 }; struct timespec timeout = {0}; int i; @@ -166,6 +166,7 @@ int main(int argc, char *argv[]) { while(test_running) { select(1, NULL, NULL, NULL, &main_loop_wait); + assert(meshlink_channel_send(mesh, channel, "ping", 6) >= 0); } meshlink_close(mesh); diff --git a/test/blackbox/test_case_meta_conn_01/Makefile.am b/test/blackbox/test_case_meta_conn_01/Makefile.am index b12e440b..28fa44b1 100644 --- a/test/blackbox/test_case_meta_conn_01/Makefile.am +++ b/test/blackbox/test_case_meta_conn_01/Makefile.am @@ -1,13 +1,13 @@ -check_PROGRAMS = node_sim_relay node_sim_peer node_sim_nut +check_PROGRAMS = node_sim_peer node_sim_relay node_sim_nut node_sim_peer_SOURCES = node_sim_peer.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_peer_LDADD = ../../../src/libmeshlink.la -node_sim_peer_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_peer_CFLAGS = -D_GNU_SOURCE node_sim_relay_SOURCES = node_sim_relay.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_relay_LDADD = ../../../src/libmeshlink.la -node_sim_relay_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_relay_CFLAGS = -D_GNU_SOURCE node_sim_nut_SOURCES = node_sim_nut.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_nut_LDADD = ../../../src/libmeshlink.la -node_sim_nut_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_nut_CFLAGS = -D_GNU_SOURCE diff --git a/test/blackbox/test_case_meta_conn_01/node_sim_nut.c b/test/blackbox/test_case_meta_conn_01/node_sim_nut.c index fc985bdf..86f94207 100644 --- a/test/blackbox/test_case_meta_conn_01/node_sim_nut.c +++ b/test/blackbox/test_case_meta_conn_01/node_sim_nut.c @@ -88,7 +88,7 @@ int main(int argc, char *argv[]) { } execute_open(argv[1], argv[2]); - meshlink_set_log_cb(mesh_handle, MESHLINK_INFO, callback_logger); + meshlink_set_log_cb(mesh_handle, MESHLINK_DEBUG, callback_logger); if(argv[5]) { execute_join(argv[5]); @@ -107,7 +107,7 @@ int main(int argc, char *argv[]) { } fprintf(stderr, "Connected with Peer\n"); - assert(mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, "Connected with Peer", 30)); + assert(mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, NULL, 0)); /* Connectivity of peer */ while(conn_status) { @@ -115,7 +115,7 @@ int main(int argc, char *argv[]) { } fprintf(stderr, "Closed connection with Peer\n"); - assert(mesh_event_sock_send(client_id, META_CONN_CLOSED, "Connection closed with Peer", 30)); + assert(mesh_event_sock_send(client_id, META_CONN_CLOSED, NULL, 0)); /* Connectivity of peer */ while(!conn_status) { @@ -123,9 +123,9 @@ int main(int argc, char *argv[]) { } fprintf(stderr, "Connected with Peer\n"); - assert(mesh_event_sock_send(client_id, META_RECONN_SUCCESSFUL, "Reconnected with Peer", 30)); + assert(mesh_event_sock_send(client_id, META_RECONN_SUCCESSFUL, NULL, 0)); execute_close(); - + meshlink_destroy(argv[1]); return 0; } diff --git a/test/blackbox/test_case_meta_conn_01/node_sim_peer.c b/test/blackbox/test_case_meta_conn_01/node_sim_peer.c index 521a7bbf..6fc3dbf5 100644 --- a/test/blackbox/test_case_meta_conn_01/node_sim_peer.c +++ b/test/blackbox/test_case_meta_conn_01/node_sim_peer.c @@ -58,4 +58,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_01/node_sim_relay.c b/test/blackbox/test_case_meta_conn_01/node_sim_relay.c index 3d5ba06d..2cf948ed 100644 --- a/test/blackbox/test_case_meta_conn_01/node_sim_relay.c +++ b/test/blackbox/test_case_meta_conn_01/node_sim_relay.c @@ -54,4 +54,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_02/Makefile.am b/test/blackbox/test_case_meta_conn_02/Makefile.am index 6331fb9c..28fa44b1 100644 --- a/test/blackbox/test_case_meta_conn_02/Makefile.am +++ b/test/blackbox/test_case_meta_conn_02/Makefile.am @@ -2,12 +2,12 @@ check_PROGRAMS = node_sim_peer node_sim_relay node_sim_nut node_sim_peer_SOURCES = node_sim_peer.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_peer_LDADD = ../../../src/libmeshlink.la -node_sim_peer_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_peer_CFLAGS = -D_GNU_SOURCE node_sim_relay_SOURCES = node_sim_relay.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_relay_LDADD = ../../../src/libmeshlink.la -node_sim_relay_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_relay_CFLAGS = -D_GNU_SOURCE node_sim_nut_SOURCES = node_sim_nut.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_nut_LDADD = ../../../src/libmeshlink.la -node_sim_nut_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_nut_CFLAGS = -D_GNU_SOURCE diff --git a/test/blackbox/test_case_meta_conn_02/node_sim_nut.c b/test/blackbox/test_case_meta_conn_02/node_sim_nut.c index f447c400..bba685ae 100644 --- a/test/blackbox/test_case_meta_conn_02/node_sim_nut.c +++ b/test/blackbox/test_case_meta_conn_02/node_sim_nut.c @@ -107,9 +107,10 @@ int main(int argc, char *argv[]) { } fprintf(stderr, "Connected with Peer\n"); - assert(mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, "Connected with Peer", 30)); + assert(mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, NULL, 0)); execute_close(); + meshlink_destroy(argv[1]); return 0; } diff --git a/test/blackbox/test_case_meta_conn_02/node_sim_peer.c b/test/blackbox/test_case_meta_conn_02/node_sim_peer.c index a61e89e8..b7dbd659 100644 --- a/test/blackbox/test_case_meta_conn_02/node_sim_peer.c +++ b/test/blackbox/test_case_meta_conn_02/node_sim_peer.c @@ -64,4 +64,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_02/node_sim_relay.c b/test/blackbox/test_case_meta_conn_02/node_sim_relay.c index 6e6caabe..9d0636d1 100644 --- a/test/blackbox/test_case_meta_conn_02/node_sim_relay.c +++ b/test/blackbox/test_case_meta_conn_02/node_sim_relay.c @@ -60,4 +60,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_03/Makefile.am b/test/blackbox/test_case_meta_conn_03/Makefile.am index 6331fb9c..28fa44b1 100644 --- a/test/blackbox/test_case_meta_conn_03/Makefile.am +++ b/test/blackbox/test_case_meta_conn_03/Makefile.am @@ -2,12 +2,12 @@ check_PROGRAMS = node_sim_peer node_sim_relay node_sim_nut node_sim_peer_SOURCES = node_sim_peer.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_peer_LDADD = ../../../src/libmeshlink.la -node_sim_peer_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_peer_CFLAGS = -D_GNU_SOURCE node_sim_relay_SOURCES = node_sim_relay.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_relay_LDADD = ../../../src/libmeshlink.la -node_sim_relay_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_relay_CFLAGS = -D_GNU_SOURCE node_sim_nut_SOURCES = node_sim_nut.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_nut_LDADD = ../../../src/libmeshlink.la -node_sim_nut_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_nut_CFLAGS = -D_GNU_SOURCE diff --git a/test/blackbox/test_case_meta_conn_03/node_sim_nut.c b/test/blackbox/test_case_meta_conn_03/node_sim_nut.c index 573e185d..f8a6aa22 100644 --- a/test/blackbox/test_case_meta_conn_03/node_sim_nut.c +++ b/test/blackbox/test_case_meta_conn_03/node_sim_nut.c @@ -98,7 +98,7 @@ int main(int argc, char *argv[]) { sleep(1); fprintf(stderr, "Connected with Peer\n"); - mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, "Connected with Peer", 30); + mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, NULL, 0); conn_status = false; fprintf(stderr, "Waiting 120 sec for peer to be re-connected\n"); @@ -114,13 +114,14 @@ int main(int argc, char *argv[]) { if(result) { fprintf(stderr, "Re-connected with Peer\n"); - mesh_event_sock_send(client_id, META_RECONN_SUCCESSFUL, "Peer", 30); + mesh_event_sock_send(client_id, META_RECONN_SUCCESSFUL, NULL, 0); } else { fprintf(stderr, "Failed to reconnect with Peer\n"); - mesh_event_sock_send(client_id, META_RECONN_FAILURE, "Peer", 30); + mesh_event_sock_send(client_id, META_RECONN_FAILURE, NULL, 0); } execute_close(); + meshlink_destroy(argv[1]); return 0; } diff --git a/test/blackbox/test_case_meta_conn_03/node_sim_peer.c b/test/blackbox/test_case_meta_conn_03/node_sim_peer.c index a61e89e8..b7dbd659 100644 --- a/test/blackbox/test_case_meta_conn_03/node_sim_peer.c +++ b/test/blackbox/test_case_meta_conn_03/node_sim_peer.c @@ -64,4 +64,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_03/node_sim_relay.c b/test/blackbox/test_case_meta_conn_03/node_sim_relay.c index e5c78926..4a4de245 100644 --- a/test/blackbox/test_case_meta_conn_03/node_sim_relay.c +++ b/test/blackbox/test_case_meta_conn_03/node_sim_relay.c @@ -60,4 +60,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_04/Makefile.am b/test/blackbox/test_case_meta_conn_04/Makefile.am index b12e440b..28fa44b1 100644 --- a/test/blackbox/test_case_meta_conn_04/Makefile.am +++ b/test/blackbox/test_case_meta_conn_04/Makefile.am @@ -1,13 +1,13 @@ -check_PROGRAMS = node_sim_relay node_sim_peer node_sim_nut +check_PROGRAMS = node_sim_peer node_sim_relay node_sim_nut node_sim_peer_SOURCES = node_sim_peer.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_peer_LDADD = ../../../src/libmeshlink.la -node_sim_peer_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_peer_CFLAGS = -D_GNU_SOURCE node_sim_relay_SOURCES = node_sim_relay.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_relay_LDADD = ../../../src/libmeshlink.la -node_sim_relay_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_relay_CFLAGS = -D_GNU_SOURCE node_sim_nut_SOURCES = node_sim_nut.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_nut_LDADD = ../../../src/libmeshlink.la -node_sim_nut_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_nut_CFLAGS = -D_GNU_SOURCE diff --git a/test/blackbox/test_case_meta_conn_04/node_sim_nut.c b/test/blackbox/test_case_meta_conn_04/node_sim_nut.c index 2c50e0f1..7f4ddd90 100644 --- a/test/blackbox/test_case_meta_conn_04/node_sim_nut.c +++ b/test/blackbox/test_case_meta_conn_04/node_sim_nut.c @@ -118,10 +118,11 @@ int main(int argc, char *argv[]) { fprintf(stderr, "Connected with Peer\n"); - if(!mesh_event_sock_send(clientId, META_CONN_SUCCESSFUL, "Connected with Peer", 30)) { + if(!mesh_event_sock_send(clientId, META_CONN_SUCCESSFUL, NULL, 0)) { fprintf(stderr, "Trying to resend mesh event\n"); sleep(1); } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_04/node_sim_peer.c b/test/blackbox/test_case_meta_conn_04/node_sim_peer.c index a61e89e8..b619f77e 100644 --- a/test/blackbox/test_case_meta_conn_04/node_sim_peer.c +++ b/test/blackbox/test_case_meta_conn_04/node_sim_peer.c @@ -52,7 +52,7 @@ int main(int argc, char *argv[]) { execute_start(); if(client_id != -1) { - if(!mesh_event_sock_send(client_id, NODE_STARTED, NULL, 0)) { + while(!mesh_event_sock_send(client_id, NODE_STARTED, NULL, 0)) { fprintf(stderr, "Trying to resend mesh event\n"); sleep(1); } @@ -64,4 +64,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_04/node_sim_relay.c b/test/blackbox/test_case_meta_conn_04/node_sim_relay.c index 683092a0..c0009b6c 100644 --- a/test/blackbox/test_case_meta_conn_04/node_sim_relay.c +++ b/test/blackbox/test_case_meta_conn_04/node_sim_relay.c @@ -57,4 +57,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_05/Makefile.am b/test/blackbox/test_case_meta_conn_05/Makefile.am index b12e440b..28fa44b1 100644 --- a/test/blackbox/test_case_meta_conn_05/Makefile.am +++ b/test/blackbox/test_case_meta_conn_05/Makefile.am @@ -1,13 +1,13 @@ -check_PROGRAMS = node_sim_relay node_sim_peer node_sim_nut +check_PROGRAMS = node_sim_peer node_sim_relay node_sim_nut node_sim_peer_SOURCES = node_sim_peer.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_peer_LDADD = ../../../src/libmeshlink.la -node_sim_peer_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_peer_CFLAGS = -D_GNU_SOURCE node_sim_relay_SOURCES = node_sim_relay.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_relay_LDADD = ../../../src/libmeshlink.la -node_sim_relay_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_relay_CFLAGS = -D_GNU_SOURCE node_sim_nut_SOURCES = node_sim_nut.c ../common/common_handlers.c ../common/test_step.c ../common/mesh_event_handler.c node_sim_nut_LDADD = ../../../src/libmeshlink.la -node_sim_nut_CFLAGS = -D_GNU_SOURCE -fsanitize=leak +node_sim_nut_CFLAGS = -D_GNU_SOURCE diff --git a/test/blackbox/test_case_meta_conn_05/node_sim_nut.c b/test/blackbox/test_case_meta_conn_05/node_sim_nut.c index 760ff70e..8741ffa7 100644 --- a/test/blackbox/test_case_meta_conn_05/node_sim_nut.c +++ b/test/blackbox/test_case_meta_conn_05/node_sim_nut.c @@ -120,7 +120,7 @@ int main(int argc, char *argv[]) { fprintf(stderr, "Connected with Peer\n"); - if(!mesh_event_sock_send(clientId, META_CONN_SUCCESSFUL, "Connected with Peer", 30)) { + if(!mesh_event_sock_send(clientId, META_CONN_SUCCESSFUL, NULL, 0)) { fprintf(stderr, "Trying to resend mesh event\n"); sleep(1); } @@ -135,10 +135,11 @@ int main(int argc, char *argv[]) { fprintf(stderr, "Re-connected with Peer\n"); - if(!mesh_event_sock_send(clientId, META_CONN_SUCCESSFUL, "Connected with Peer", 30)) { + if(!mesh_event_sock_send(clientId, META_CONN_SUCCESSFUL, NULL, 0)) { fprintf(stderr, "Trying to resend mesh event\n"); sleep(1); } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_05/node_sim_peer.c b/test/blackbox/test_case_meta_conn_05/node_sim_peer.c index a61e89e8..b7dbd659 100644 --- a/test/blackbox/test_case_meta_conn_05/node_sim_peer.c +++ b/test/blackbox/test_case_meta_conn_05/node_sim_peer.c @@ -64,4 +64,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/test_case_meta_conn_05/node_sim_relay.c b/test/blackbox/test_case_meta_conn_05/node_sim_relay.c index 683092a0..c0009b6c 100644 --- a/test/blackbox/test_case_meta_conn_05/node_sim_relay.c +++ b/test/blackbox/test_case_meta_conn_05/node_sim_relay.c @@ -57,4 +57,5 @@ int main(int argc, char *argv[]) { } execute_close(); + meshlink_destroy(argv[1]); } diff --git a/test/blackbox/util/gen_invite.c b/test/blackbox/util/gen_invite.c index 83c3f4f8..4014b68b 100644 --- a/test/blackbox/util/gen_invite.c +++ b/test/blackbox/util/gen_invite.c @@ -17,6 +17,7 @@ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include +#include #include #include "../../../src/meshlink.h" #include "../common/test_step.h" @@ -24,15 +25,32 @@ #define CMD_LINE_ARG_NODENAME 1 #define CMD_LINE_ARG_INVITEE 2 +void logger_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, + const char *text) { + (void)mesh; + (void)level; + + fprintf(stderr, "meshlink>> %s\n", text); +} + int main(int argc, char *argv[]) { char *invite = NULL; /* Start mesh, generate an invite and print out the invite */ - execute_open(argv[CMD_LINE_ARG_NODENAME], "1"); - execute_start(); - invite = execute_invite(argv[CMD_LINE_ARG_INVITEE]); + /* Set up logging for Meshlink */ + meshlink_set_log_cb(NULL, MESHLINK_DEBUG, logger_cb); + + /* Create meshlink instance */ + meshlink_handle_t *mesh = meshlink_open("testconf", argv[1], "node_sim", DEV_CLASS_STATIONARY); + assert(mesh); + + /* Set up logging for Meshlink with the newly acquired Mesh Handle */ + meshlink_set_log_cb(mesh, MESHLINK_DEBUG, logger_cb); + meshlink_enable_discovery(mesh, false); + assert(meshlink_start(mesh)); + invite = meshlink_invite_ex(mesh, argv[2], MESHLINK_INVITE_LOCAL | MESHLINK_INVITE_NUMERIC); printf("%s\n", invite); - //execute_close(); + meshlink_close(mesh); return EXIT_SUCCESS; } diff --git a/test/blackbox/util/install_packages.sh b/test/blackbox/util/install_packages.sh new file mode 100755 index 00000000..f427b226 --- /dev/null +++ b/test/blackbox/util/install_packages.sh @@ -0,0 +1,55 @@ +#!/bin/bash + +# nat.sh - Script to create a NAT using LXC Container +# Designed to work on unprivileged Containers +# Copyright (C) 2019 Guus Sliepen +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +# Read command-line arguments + +if [ $# -le 1 ] + then + echo "enter valid arguments" + exit 1 +fi + +container=$1 +update_cmd="apt-get update -y >> /dev/null" +echo "${update_cmd}" | lxc-attach -n ${container} -- + +while test $# -gt 1 +do + shift + pkg_name=$1 + install_cmd="apt-get install ${pkg_name} -y >> /dev/null" + echo "${install_cmd}" | lxc-attach -n ${container} -- + if [ $? -ne 0 ] + then + echo "${pkg_name} installation failed in ${container} retrying to install again" + sleep 1 + echo "${update_cmd}" | lxc-attach -n ${container} -- + sleep 1 + echo "${install_cmd}" | lxc-attach -n ${container} -- + if [ $? -ne 0 ] + then + echo "${pkg_name} installation failed in ${container} container" + exit 1 + fi + fi + echo "Installed ${pkg_name} in container ${container}" +done + +exit 0 diff --git a/test/blackbox/util/nat.sh b/test/blackbox/util/nat.sh new file mode 100755 index 00000000..314eff0b --- /dev/null +++ b/test/blackbox/util/nat.sh @@ -0,0 +1,130 @@ +#!/bin/bash + +# nat.sh - Script to create a NAT using LXC Container +# Designed to work on unprivileged Containers +# Copyright (C) 2019 Guus Sliepen +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +# Read command-line arguments +if [ $# -ne 3 ] + then + echo "enter valid arguments" + exit 1 +fi +router_container=$1 +router_bridge="${router_container}_bridge" +router_conf_path="${2}/${router_container}/config" +meshlinkrootpath=$3 + +MAXCOUNT=10 +RANGE=16 +number1_1=$RANDOM +number1_2=$RANDOM +number2_1=$RANDOM +number2_2=$RANDOM + +let "number1_1 %= $RANGE" +let "number1_2 %= $RANGE" +let "number2_1 %= $RANGE" +let "number2_2 %= $RANGE" + +number1_1="$((echo "obase=16; ${number1_1}") | bc)" +number1_2="$((echo "obase=16; ${number1_2}") | bc)" +number2_1="$((echo "obase=16; ${number2_1}") | bc)" +number2_2="$((echo "obase=16; ${number2_2}") | bc)" + +echo + Creating nat bridge +ifconfig ${router_bridge} down >/dev/null 2>/dev/null +brctl delbr ${router_bridge} >/dev/null 2>/dev/null +brctl addbr ${router_bridge} +ifconfig ${router_bridge} up + +# Destroying the existing router if already exists +lxc-stop -n ${router_container} >/dev/null 2>/dev/null +lxc-destroy -n ${router_container} >/dev/null 2>/dev/null + +echo + Creating router +lxc-create -t download -n ${router_container} -- -d ubuntu -r trusty -a amd64 >> /dev/null +echo + Creating config file for router +echo "lxc.net.0.name = eth0" >> ${router_conf_path} +echo " " >> ${router_conf_path} +echo "lxc.net.1.type = veth" >> ${router_conf_path} +echo "lxc.net.1.flags = up" >> ${router_conf_path} +echo "lxc.net.1.link = ${router_bridge}" >> ${router_conf_path} +echo "lxc.net.1.name = eth1" >> ${router_conf_path} +echo "lxc.net.1.hwaddr = 00:16:3e:ab:32:2a" >> ${router_conf_path} + +echo + Starting Router +lxc-start -n ${router_container} + +echo + Waiting for IP address.. +while [ -z `lxc-info -n ${router_container} -iH` ] +do + sleep 1 +done +eth0_ip=`lxc-info -n ${router_container} -iH` +echo "Obtained IP address: ${eth0_ip}" + +############################################################################################################### + +echo "Installing and Configuring iptables, dnsmasq conntrack packages in ${1}" +${meshlinkrootpath}/test/blackbox/util/install_packages.sh ${1} iptables dnsmasq conntrack +if [ $? -ne 0 ] +then + exit 1 +fi + +cmd="echo \"interface=eth1\" >> /etc/dnsmasq.conf" +echo "${cmd}" | lxc-attach -n ${router_container} -- +cmd="echo \"bind-interfaces\" >> /etc/dnsmasq.conf" +echo "${cmd}" | lxc-attach -n ${router_container} -- +cmd="echo \"listen-address=172.16.0.1\" >> /etc/dnsmasq.conf" +echo "${cmd}" | lxc-attach -n ${router_container} -- +cmd="echo \"dhcp-range=172.16.0.2,172.16.0.254,12h\" >> /etc/dnsmasq.conf" +echo "${cmd}" | lxc-attach -n ${router_container} -- +cmd="ifconfig eth1 172.16.0.1 netmask 255.255.255.0 up" +echo "${cmd}" | lxc-attach -n ${router_container} -- +if [ $? -ne 0 ] +then + echo "Failed to configure eth1 interface" + exit 1 +fi +cmd="service dnsmasq restart >> /dev/null" +echo "${cmd}" | lxc-attach -n ${router_container} -- +if [ $? -ne 0 ] +then + echo "Failed to restart service" + exit 1 +fi + +echo + Configuring NAT for ${1}.... +cmd="iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source ${eth0_ip} " +echo "${cmd}" | sudo lxc-attach -n ${router_container} -- +if [ $? -ne 0 ] +then + echo "Failed to apply NAT rule" + exit 1 +fi +cmd="iptables -t nat -A PREROUTING -i eth0 -j DNAT --to-destination 172.16.0.1 " +echo "${cmd}" | sudo lxc-attach -n ${router_container} -- +if [ $? -ne 0 ] +then + echo "Failed to apply NAT rule" + exit 1 +fi +echo "Router created and configured with Full-cone NAT" + +exit 0 diff --git a/test/blackbox/util/nat_destroy.sh b/test/blackbox/util/nat_destroy.sh new file mode 100755 index 00000000..2fa0f20f --- /dev/null +++ b/test/blackbox/util/nat_destroy.sh @@ -0,0 +1,16 @@ +#!/bin/bash +router=${1} +router_bridge="${1}_bridge" + +echo + Stopping router...... +lxc-stop -n ${router} + +echo + Removing NATs bridge.... + +ifconfig ${router_bridge} down + +brctl delbr ${router_bridge} + +echo + Destroing the routers..... + +lxc-destroy -n ${router} >> /dev/null