#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'
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;
}
}
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;
}
}
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;
}
}
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
#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;
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) */
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;
/* 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);
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 */
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 */
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);
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,
/* Run the node_sim_<nodename> 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_<nodename> 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
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;
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];
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);
}
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 ";
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);
+}
#include <lxc/lxccontainer.h>
-#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);
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
#include <assert.h>
#include <fcntl.h>
#include <time.h>
+#include <pthread.h>
+#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));
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++;
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");
}
}
-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);
+}
+
#include <time.h>
#include <stdint.h>
-/// Maximum length of the mesh event payload
-#define PAYLOAD_MAX_SIZE 1000
-
/// mesh events
// TODO: Add more mesh event if required.
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,
} 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
*
* @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
*/
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_
#include <signal.h>
#include <sys/types.h>
#include "common_handlers.h"
+#include "containers.h"
#include "tcpdump.h"
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) {
/* 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);
}
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);
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);
}
for(i = 0; i < state_ptr->num_nodes; i++) {
meta_conn_status[i] = false;
- node_reachable_status[i] = false;
}
setup_containers(state);
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();
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);
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]);
meta_conn01_reconn = true;
break;
}
+
+ return true;
}
/* Execute Meta-connections Test Case # 1 - re-connection to peer after disconnection when
*/
static bool test_steps_meta_conn_01(void) {
char *invite_peer, *invite_nut;
- bool result = false;
int i;
char *import;
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]);
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 */
*/
static bool test_steps_meta_conn_02(void) {
char *invite_peer, *invite_nut;
- bool result = false;
int i;
char *import;
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]);
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 */
*/
static bool test_steps_meta_conn_03(void) {
char *invite_peer, *invite_nut;
- bool result = false;
int i;
char *import;
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]);
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
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);
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);
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]);
fprintf(stderr, "Node started\n");
break;
}
+
+ return true;
}
/* Execute Meta-connections Test Case # 5 - re-connection to peer after changing IP of peer */
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);
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;
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) {
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;
PRINT_TEST_CASE_MSG("Undefined event occurred\n");
}
- return;
+ return true;
}
/* Execute channel connections Test Case # 1 - simulate a temporary network
// 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;
}
// 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;
}
// 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;
}
// 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;
// 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;
}
// 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;
}
// 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;
}
// 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;
}
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]);
/* 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");
// 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;
}
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
}
assert(attempts < 5);
-
+ fprintf(stderr, "SENT EVENT\n");
return;
}
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);
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);
}
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);
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) {
}
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));
}
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;
while(test_running) {
select(1, NULL, NULL, NULL, &main_loop_wait);
+ assert(meshlink_channel_send(mesh, channel, "ping", 6) >= 0);
}
meshlink_close(mesh);
-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
}
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]);
}
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) {
}
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) {
}
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;
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
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
}
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;
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
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
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");
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;
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
-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
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]);
}
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);
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
-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
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);
}
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]);
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
}
execute_close();
+ meshlink_destroy(argv[1]);
}
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
+#include <assert.h>
#include <stdlib.h>
#include "../../../src/meshlink.h"
#include "../common/test_step.h"
#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;
}
--- /dev/null
+#!/bin/bash
+
+# nat.sh - Script to create a NAT using LXC Container
+# Designed to work on unprivileged Containers
+# Copyright (C) 2019 Guus Sliepen <guus@meshlink.io>
+#
+# 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
--- /dev/null
+#!/bin/bash
+
+# nat.sh - Script to create a NAT using LXC Container
+# Designed to work on unprivileged Containers
+# Copyright (C) 2019 Guus Sliepen <guus@meshlink.io>
+#
+# 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
--- /dev/null
+#!/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
projects / meshlink / commitdiff