diff --git a/Makefile.dep b/Makefile.dep
index 50d2c5c5c58d93d99d0767d7268a2f352eb9b7a4..519285ee0806beda80b03653c76550e8f818b677 100644
--- a/Makefile.dep
+++ b/Makefile.dep
@@ -430,14 +430,17 @@ endif
ifneq (,$(filter lwip_sock_ip,$(USEMODULE)))
USEMODULE += lwip_raw
+ USEMODULE += sock_ip
endif
ifneq (,$(filter lwip_sock_tcp,$(USEMODULE)))
USEMODULE += lwip_tcp
+ USEMODULE += sock_tcp
endif
ifneq (,$(filter lwip_sock_udp,$(USEMODULE)))
USEMODULE += lwip_udp
+ USEMODULE += sock_udp
endif
ifneq (,$(filter lwip_%,$(USEMODULE)))
diff --git a/tests/lwip/Makefile b/tests/lwip/Makefile
index d0be909587433552004cb3d0a9270fec0e5dacb3..58753af2c2f7d83ebbde2a220c145b85699b7c8c 100644
--- a/tests/lwip/Makefile
+++ b/tests/lwip/Makefile
@@ -1,49 +1,30 @@
APPLICATION = lwip
-# overwrite board, do not set native as default
-BOARD ?= iotlab-m3
include ../Makefile.tests_common
-BOARD_BLACKLIST := arduino-mega2560 msb-430h telosb waspmote-pro z1 arduino-uno \
- arduino-duemilanove msb-430 wsn430-v1_4 wsn430-v1_3b
-BOARD_INSUFFICIENT_MEMORY := airfy-beacon arduino-mega2560 msb-430h nrf6310 \
- nucleo32-f031 nucleo32-f031 nucleo32-f042 nucleo32-f303 \
- nucleo32-l031 nucleo-f030 nucleo-f072 \
- nucleo-f302 nucleo-f334 nucleo-l053 pca10005 stm32f0discovery \
- telosb weio yunjia-nrf51822 z1
+# lwIP's memory management doesn't seem to work on non 32-bit platforms at the
+# moment.
+BOARD_BLACKLIST := arduino-uno arduino-duemilanove arduino-mega2560 chronos \
+ msb-430 msb-430h telosb waspmote-pro wsn430-v1_3b \
+ wsn430-v1_4 z1
+BOARD_INSUFFICIENT_MEMORY := airfy-beacon nrf6310 nucleo32-f031 nucleo32-f042 \
+ nucleo32-l031 nucleo-f030 nucleo-f334 nucleo-l053 \
+ pca10005 stm32f0discovery weio yunjia-nrf51822
# including lwip_ipv6_mld would currently break this test on at86rf2xx radios
-USEMODULE += lwip lwip_ipv6_autoconfig lwip_conn_ip lwip_netdev
-USEMODULE += lwip_udp lwip_conn_udp
+USEMODULE += lwip lwip_ipv6_autoconfig lwip_sock_ip lwip_netdev
+USEMODULE += lwip_udp lwip_sock_udp
+USEMODULE += lwip_tcp lwip_sock_tcp
USEMODULE += ipv6_addr
USEMODULE += shell
USEMODULE += shell_commands
USEMODULE += ps
USEMODULE += od
+USEMODULE += netdev_default
-# use the at86rf231 as fallback device
-DRIVER := at86rf231
-
-# define the driver to be used for selected boards
-ifneq (,$(filter samr21-xpro,$(BOARD)))
- DRIVER := at86rf233
-endif
-ifneq (,$(filter iotlab-m3 fox,$(BOARD)))
- DRIVER := at86rf231
-endif
-ifneq (,$(filter mulle,$(BOARD)))
- DRIVER := at86rf212b
-endif
-ifneq (,$(filter native,$(BOARD)))
- DRIVER := netdev_tap
+ifeq ($(BOARD),native)
USEMODULE += lwip_ethernet
endif
-ifneq (,$(filter at86rf2%,$(DRIVER)))
- FEATURES_REQUIRED = periph_spi periph_gpio
-endif
-
-USEMODULE += $(DRIVER)
-
include $(RIOTBASE)/Makefile.include
test:
diff --git a/tests/lwip/common.h b/tests/lwip/common.h
index 8dfb62951bddc56d7a5d82834b0961e7ecda3e4c..de2d4db240c0138affba8fc8357db581749b8580 100644
--- a/tests/lwip/common.h
+++ b/tests/lwip/common.h
@@ -29,7 +29,7 @@ extern "C" {
* @brief Application configuration
* @{
*/
-#define CONN_INBUF_SIZE (256)
+#define SOCK_INBUF_SIZE (256)
#define SERVER_MSG_QUEUE_SIZE (8)
#define SERVER_BUFFER_SIZE (64)
/**
@@ -47,7 +47,7 @@ extern "C" {
*/
size_t hex2ints(uint8_t *out, const char *in);
-#ifdef MODULE_CONN_IP
+#ifdef MODULE_SOCK_IP
/**
* @brief Raw IP shell command
*
@@ -60,7 +60,20 @@ size_t hex2ints(uint8_t *out, const char *in);
int ip_cmd(int argc, char **argv);
#endif
-#ifdef MODULE_CONN_UDP
+#ifdef MODULE_SOCK_TCP
+/**
+ * @brief TCP IP shell command
+ *
+ * @param[in] argc number of arguments
+ * @param[in] argv array of arguments
+ *
+ * @return 0 on success
+ * @return other on error
+ */
+int tcp_cmd(int argc, char **argv);
+#endif
+
+#ifdef MODULE_SOCK_UDP
/**
* @brief UDP IP shell command
*
diff --git a/tests/lwip/ip.c b/tests/lwip/ip.c
index dac3059e46368f78d1ea10a187c9d11b784d6f03..df7d3309f3c44b66fa5f65dbb327f75abcd43503 100644
--- a/tests/lwip/ip.c
+++ b/tests/lwip/ip.c
@@ -7,14 +7,12 @@
*/
/**
- * @ingroup examples
+ * @ingroup tests
* @{
*
* @file
- * @brief Demonstrating the sending and receiving of UDP data over POSIX sockets.
*
* @author Martine Lenders <mlenders@inf.fu-berlin.de>
- *
* @}
*/
@@ -25,44 +23,50 @@
#include "common.h"
#include "od.h"
#include "net/af.h"
-#include "net/conn/ip.h"
+#include "net/sock/ip.h"
#include "net/ipv6.h"
+#include "shell.h"
#include "thread.h"
#include "xtimer.h"
-#ifdef MODULE_CONN_IP
-static char conn_inbuf[CONN_INBUF_SIZE];
+#ifdef MODULE_SOCK_IP
+static char sock_inbuf[SOCK_INBUF_SIZE];
static bool server_running;
-static conn_ip_t server_conn;
+static sock_ip_t server_sock;
static char server_stack[THREAD_STACKSIZE_DEFAULT];
static msg_t server_msg_queue[SERVER_MSG_QUEUE_SIZE];
static void *_server_thread(void *args)
{
- ipv6_addr_t server_addr = IPV6_ADDR_UNSPECIFIED;
+ sock_ip_ep_t server_addr = SOCK_IPV6_EP_ANY;
uint8_t protocol;
msg_init_queue(server_msg_queue, SERVER_MSG_QUEUE_SIZE);
/* parse protocol */
- protocol = (uint8_t)atoi((char *)args);
- if (conn_ip_create(&server_conn, &server_addr, sizeof(server_addr), AF_INET6, protocol) < 0) {
+ protocol = atoi(args);
+ if (sock_ip_create(&server_sock, &server_addr, NULL, protocol, 0) < 0) {
return NULL;
}
server_running = true;
printf("Success: started IP server on protocol %u\n", protocol);
while (1) {
int res;
- ipv6_addr_t src;
- size_t src_len = sizeof(ipv6_addr_t);
- if ((res = conn_ip_recvfrom(&server_conn, conn_inbuf, sizeof(conn_inbuf), &src,
- &src_len)) < 0) {
+ sock_ip_ep_t src;
+
+ if ((res = sock_ip_recv(&server_sock, sock_inbuf, sizeof(sock_inbuf),
+ SOCK_NO_TIMEOUT, &src)) < 0) {
puts("Error on receive");
}
else if (res == 0) {
puts("No data received");
}
else {
- od_hex_dump(conn_inbuf, res, 0);
+ char addrstr[IPV6_ADDR_MAX_STR_LEN];
+
+ printf("Received IP data from [%s]:\n",
+ ipv6_addr_to_str(addrstr, (ipv6_addr_t *)&src.addr.ipv6,
+ sizeof(addrstr)));
+ od_hex_dump(sock_inbuf, res, 0);
}
}
return NULL;
@@ -71,26 +75,30 @@ static void *_server_thread(void *args)
static int ip_send(char *addr_str, char *port_str, char *data, unsigned int num,
unsigned int delay)
{
- ipv6_addr_t src = IPV6_ADDR_UNSPECIFIED, dst;
+ sock_ip_ep_t dst = SOCK_IPV6_EP_ANY;
uint8_t protocol;
- uint8_t byte_data[strlen(data) / 2];
+ uint8_t byte_data[SHELL_DEFAULT_BUFSIZE / 2];
size_t data_len;
/* parse destination address */
- if (ipv6_addr_from_str(&dst, addr_str) == NULL) {
+ if (ipv6_addr_from_str((ipv6_addr_t *)&dst.addr.ipv6, addr_str) == NULL) {
puts("Error: unable to parse destination address");
return 1;
}
/* parse protocol */
- protocol = (uint8_t)atoi(port_str);
+ protocol = atoi(port_str);
data_len = hex2ints(byte_data, data);
for (unsigned int i = 0; i < num; i++) {
- if (conn_ip_sendto(byte_data, data_len, &src, sizeof(src), (struct sockaddr *)&dst,
- sizeof(dst), AF_INET6, protocol) < 0) {
+ sock_ip_t *sock = NULL;
+
+ if (server_running) {
+ sock = &server_sock;
+ }
+ if (sock_ip_send(sock, byte_data, data_len, protocol, &dst) < 0) {
puts("could not send");
}
else {
- printf("Success: send %u byte to %s (next header: %u)\n",
+ printf("Success: send %u byte over IPv6 to %s (next header: %u)\n",
(unsigned)data_len, addr_str, protocol);
}
xtimer_usleep(delay);
@@ -124,10 +132,10 @@ int ip_cmd(int argc, char **argv)
return 1;
}
if (argc > 5) {
- num = (uint32_t)atoi(argv[5]);
+ num = atoi(argv[5]);
}
if (argc > 6) {
- delay = (uint32_t)atoi(argv[6]);
+ delay = atoi(argv[6]);
}
return ip_send(argv[2], argv[3], argv[4], num, delay);
}
diff --git a/tests/lwip/main.c b/tests/lwip/main.c
index 4a26afa2c3092af9d6245ef3683de6de84015466..a498fce89dffb656fdf5f7efdfb69acafcea716c 100644
--- a/tests/lwip/main.c
+++ b/tests/lwip/main.c
@@ -11,14 +11,11 @@
* @{
*
* @file
- * @brief Test for raw IPv6 connections
+ * @brief Test for lwIP
*
* @author Martine Lenders <mlenders@inf.fu-berlin.de>
*
- * This test application tests the gnrc_conn_ip module. If you select protocol 58 you can also
- * test if gnrc is able to deal with multiple subscribers to ICMPv6 (gnrc_icmpv6 and this
- * application).
- *
+ * This test application tests the lwIP package.
* @}
*/
@@ -52,10 +49,13 @@ static int ifconfig(int argc, char **argv)
}
static const shell_command_t shell_commands[] = {
-#ifdef MODULE_CONN_IP
+#ifdef MODULE_SOCK_IP
{ "ip", "Send IP packets and listen for packets of certain type", ip_cmd },
#endif
-#ifdef MODULE_CONN_UDP
+#ifdef MODULE_SOCK_TCP
+ { "tcp", "Send TCP messages and listen for messages on TCP port", tcp_cmd },
+#endif
+#ifdef MODULE_SOCK_UDP
{ "udp", "Send UDP messages and listen for messages on UDP port", udp_cmd },
#endif
{ "ifconfig", "Shows assigned IPv6 addresses", ifconfig },
@@ -63,8 +63,6 @@ static const shell_command_t shell_commands[] = {
};
static char line_buf[SHELL_DEFAULT_BUFSIZE];
-char conn_inbuf[CONN_INBUF_SIZE];
-
int main(void)
{
puts("RIOT lwip test application");
diff --git a/tests/lwip/tcp.c b/tests/lwip/tcp.c
new file mode 100644
index 0000000000000000000000000000000000000000..d921edc0bb899e2f71d7e27deb8e92d999fef9a6
--- /dev/null
+++ b/tests/lwip/tcp.c
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 Freie Universität Berlin
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @ingroup tests
+ * @{
+ *
+ * @file
+ *
+ * @author Martine Lenders <mlenders@inf.fu-berlin.de>
+ * @}
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "common.h"
+#include "od.h"
+#include "net/af.h"
+#include "net/sock/tcp.h"
+#include "net/ipv6.h"
+#include "shell.h"
+#include "thread.h"
+#include "xtimer.h"
+
+#ifdef MODULE_SOCK_TCP
+static char sock_inbuf[SOCK_INBUF_SIZE];
+static bool server_running = false, client_running = false;
+static sock_tcp_t server_sock, client_sock;
+static sock_tcp_queue_t server_queue;
+static char server_stack[THREAD_STACKSIZE_DEFAULT];
+static msg_t server_msg_queue[SERVER_MSG_QUEUE_SIZE];
+
+static void *_server_thread(void *args)
+{
+ sock_tcp_ep_t server_addr = SOCK_IPV6_EP_ANY;
+ int res;
+
+ msg_init_queue(server_msg_queue, SERVER_MSG_QUEUE_SIZE);
+ /* parse port */
+ server_addr.port = atoi(args);
+ if ((res = sock_tcp_listen(&server_queue, &server_addr, &server_sock, 1,
+ 0)) < 0) {
+ printf("Unable to open TCP server on port %" PRIu16 " (error code %d)\n",
+ server_addr.port, -res);
+ return NULL;
+ }
+ server_running = true;
+ printf("Success: started TCP server on port %" PRIu16 "\n",
+ server_addr.port);
+ while (1) {
+ char client_addr[IPV6_ADDR_MAX_STR_LEN];
+ sock_tcp_t *sock = NULL;
+ int res;
+ unsigned client_port;
+
+ if ((res = sock_tcp_accept(&server_queue, &sock, SOCK_NO_TIMEOUT)) < 0) {
+ puts("Error on TCP accept");
+ continue;
+ }
+ else {
+ sock_tcp_ep_t client;
+
+ sock_tcp_get_remote(sock, &client);
+ ipv6_addr_to_str(client_addr, (ipv6_addr_t *)&client.addr.ipv6,
+ sizeof(client_addr));
+ client_port = client.port;
+ printf("TCP client [%s]:%u connected\n",
+ client_addr, client_port);
+ }
+ /* we don't use timeouts so all errors should be related to a lost
+ * connection */
+ while ((res = sock_tcp_read(sock, sock_inbuf, sizeof(sock_inbuf),
+ SOCK_NO_TIMEOUT)) >= 0) {
+ printf("Received TCP data from client [%s]:%u:\n",
+ client_addr, client_port);
+ if (res > 0) {
+ od_hex_dump(sock_inbuf, res, 0);
+ }
+ else {
+ puts("(nul)");
+ }
+ }
+ printf("TCP connection to [%s]:%u reset, starting to accept again\n",
+ client_addr, client_port);
+ sock_tcp_disconnect(sock);
+ }
+ return NULL;
+}
+
+static int tcp_connect(char *addr_str, char *port_str, char *local_port_str)
+{
+ sock_tcp_ep_t dst = SOCK_IPV6_EP_ANY;
+ uint16_t local_port = 0;
+
+ if (client_running) {
+ puts("Cient already connected");
+ }
+
+ /* parse destination address */
+ if (ipv6_addr_from_str((ipv6_addr_t *)&dst.addr.ipv6, addr_str) == NULL) {
+ puts("Error: unable to parse destination address");
+ return 1;
+ }
+ /* parse port */
+ dst.port = atoi(port_str);
+ if (local_port_str != NULL) {
+ local_port = atoi(port_str);
+ }
+ if (sock_tcp_connect(&client_sock, &dst, local_port, 0) < 0) {
+ puts("Error: unable to connect");
+ return 1;
+ }
+ client_running = true;
+ return 0;
+}
+
+static int tcp_disconnect(void)
+{
+ sock_tcp_disconnect(&client_sock);
+ client_running = false;
+ return 0;
+}
+
+static int tcp_send(char *data, unsigned int num, unsigned int delay)
+{
+ uint8_t byte_data[SHELL_DEFAULT_BUFSIZE / 2];
+ size_t data_len;
+
+ data_len = hex2ints(byte_data, data);
+ for (unsigned int i = 0; i < num; i++) {
+ if (sock_tcp_write(&client_sock, byte_data, data_len) < 0) {
+ puts("could not send");
+ }
+ else {
+ printf("Success: send %u byte over TCP to server\n", (unsigned)data_len);
+ }
+ xtimer_usleep(delay);
+ }
+ return 0;
+}
+
+static int tcp_start_server(char *port_str)
+{
+ if (thread_create(server_stack, sizeof(server_stack), THREAD_PRIORITY_MAIN - 1,
+ THREAD_CREATE_STACKTEST, _server_thread, port_str,
+ "TCP server") <= KERNEL_PID_UNDEF) {
+ return 1;
+ }
+ return 0;
+}
+
+int tcp_cmd(int argc, char **argv)
+{
+ if (argc < 2) {
+ printf("usage: %s [connect|disconnect|send|server]\n", argv[0]);
+ return 1;
+ }
+
+ if (strcmp(argv[1], "connect") == 0) {
+ char *local_port = NULL;
+
+ if (argc < 4) {
+ printf("usage: %s connect <addr> <port> [local_port]\n",
+ argv[0]);
+ return 1;
+ }
+ if (argc > 4) {
+ local_port = argv[4];
+ }
+ return tcp_connect(argv[2], argv[3], local_port);
+ }
+ if (strcmp(argv[1], "disconnect") == 0) {
+ return tcp_disconnect();
+ }
+ else if (strcmp(argv[1], "send") == 0) {
+ uint32_t num = 1;
+ uint32_t delay = 1000000UL;
+ if (argc < 3) {
+ printf("usage: %s send <hex data> [<num> [<delay in us>]]\n",
+ argv[0]);
+ return 1;
+ }
+ if (argc > 3) {
+ num = atoi(argv[3]);
+ }
+ if (argc > 4) {
+ delay = atoi(argv[4]);
+ }
+ return tcp_send(argv[2], num, delay);
+ }
+ else if (strcmp(argv[1], "server") == 0) {
+ if (argc < 3) {
+ printf("usage: %s server [start|stop]\n", argv[0]);
+ return 1;
+ }
+ if (strcmp(argv[2], "start") == 0) {
+ if (argc < 4) {
+ printf("usage %s server start <port>\n", argv[0]);
+ return 1;
+ }
+ return tcp_start_server(argv[3]);
+ }
+ else {
+ puts("error: invalid command");
+ return 1;
+ }
+ }
+ else {
+ puts("error: invalid command");
+ return 1;
+ }
+}
+#else
+typedef int dont_be_pedantic;
+#endif
+
+/** @} */
diff --git a/tests/lwip/tests/01-run.py b/tests/lwip/tests/01-run.py
index 2490f502d1379da2cb154b07e04b2f4900e4d2f5..e48dd4b137541373d8dbc0f588d10273f35b3a8b 100755
--- a/tests/lwip/tests/01-run.py
+++ b/tests/lwip/tests/01-run.py
@@ -154,8 +154,8 @@ def default_test_case(board_group, application, env=None):
if env != None:
env.update(env)
env.update(board.to_env())
- with pexpect.spawn("make", ["-C", application, "term"], env=env,
- timeout=DEFAULT_TIMEOUT,
+ with pexpect.spawnu("make", ["-C", application, "term"], env=env,
+ timeout=DEFAULT_TIMEOUT,
logfile=sys.stdout) as spawn:
spawn.expect("TEST: SUCCESS")
@@ -173,7 +173,7 @@ class TestStrategy(ApplicationStrategy):
def get_ipv6_address(spawn):
spawn.sendline(u"ifconfig")
- spawn.expect(u"[A-Za-z0-9]{2}[0-9]+: inet6 (fe80::[0-9a-f:]+)")
+ spawn.expect(u"[A-Za-z0-9]{2}_[0-9]+: inet6 (fe80::[0-9a-f:]+)")
return spawn.match.group(1)
def test_ipv6_send(board_group, application, env=None):
@@ -185,22 +185,19 @@ def test_ipv6_send(board_group, application, env=None):
if env != None:
env_receiver.update(env)
env_receiver.update(board_group.boards[1].to_env())
- with pexpect.spawn("make", ["-C", application, "term"], env=env_sender,
- timeout=DEFAULT_TIMEOUT) as sender, \
- pexpect.spawn("make", ["-C", application, "term"], env=env_receiver,
- timeout=DEFAULT_TIMEOUT) as receiver:
+ with pexpect.spawnu("make", ["-C", application, "term"], env=env_sender,
+ timeout=DEFAULT_TIMEOUT) as sender, \
+ pexpect.spawnu("make", ["-C", application, "term"], env=env_receiver,
+ timeout=DEFAULT_TIMEOUT) as receiver:
ipprot = random.randint(0x00, 0xff)
receiver_ip = get_ipv6_address(receiver)
-
receiver.sendline(u"ip server start %d" % ipprot)
# wait for neighbor discovery to be done
time.sleep(5)
sender.sendline(u"ip send %s %d 01:23:45:67:89:ab:cd:ef" % (receiver_ip, ipprot))
- sender.expect_exact(u"Success: send 8 byte to %s (next header: %d)" %
+ sender.expect_exact(u"Success: send 8 byte over IPv6 to %s (next header: %d)" %
(receiver_ip, ipprot))
- receiver.expect(u"000000 60 00 00 00 00 08 %s ff fe 80 00 00 00 00 00 00" % hex(ipprot)[2:])
- receiver.expect(u"000010( [0-9a-f]{2}){8} fe 80 00 00 00 00 00 00")
- receiver.expect(u"000020( [0-9a-f]{2}){8} 01 23 45 67 89 ab cd ef")
+ receiver.expect(u"00000000 01 23 45 67 89 AB CD EF")
def test_udpv6_send(board_group, application, env=None):
env_sender = os.environ.copy()
@@ -211,10 +208,10 @@ def test_udpv6_send(board_group, application, env=None):
if env != None:
env_receiver.update(env)
env_receiver.update(board_group.boards[1].to_env())
- with pexpect.spawn("make", ["-C", application, "term"], env=env_sender,
- timeout=DEFAULT_TIMEOUT) as sender, \
- pexpect.spawn("make", ["-C", application, "term"], env=env_receiver,
- timeout=DEFAULT_TIMEOUT) as receiver:
+ with pexpect.spawnu("make", ["-C", application, "term"], env=env_sender,
+ timeout=DEFAULT_TIMEOUT) as sender, \
+ pexpect.spawnu("make", ["-C", application, "term"], env=env_receiver,
+ timeout=DEFAULT_TIMEOUT) as receiver:
port = random.randint(0x0000, 0xffff)
receiver_ip = get_ipv6_address(receiver)
@@ -222,11 +219,40 @@ def test_udpv6_send(board_group, application, env=None):
# wait for neighbor discovery to be done
time.sleep(5)
sender.sendline(u"udp send %s %d ab:cd:ef" % (receiver_ip, port))
- sender.expect_exact(u"Success: send 3 byte to [%s]:%d" %
+ sender.expect_exact(u"Success: send 3 byte over UDP to [%s]:%d" %
(receiver_ip, port))
- receiver.expect(u"000000 ab cd ef")
+ receiver.expect(u"00000000 AB CD EF")
+
+def test_tcpv6_send(board_group, application, env=None):
+ env_client = os.environ.copy()
+ if env != None:
+ env_client.update(env)
+ env_client.update(board_group.boards[0].to_env())
+ env_server = os.environ.copy()
+ if env != None:
+ env_server.update(env)
+ env_server.update(board_group.boards[1].to_env())
+ with pexpect.spawnu("make", ["-C", application, "term"], env=env_client,
+ timeout=DEFAULT_TIMEOUT) as client, \
+ pexpect.spawnu("make", ["-C", application, "term"], env=env_server,
+ timeout=DEFAULT_TIMEOUT) as server:
+ port = random.randint(0x0000, 0xffff)
+ server_ip = get_ipv6_address(server)
+ client_ip = get_ipv6_address(client)
-def test_dual_send(board_group, application, env=None):
+ server.sendline(u"tcp server start %d" % port)
+ # wait for neighbor discovery to be done
+ time.sleep(5)
+ client.sendline(u"tcp connect %s %d" % (server_ip, port))
+ server.expect(u"TCP client \\[%s\\]:[0-9]+ connected" % client_ip)
+ client.sendline(u"tcp send affe:abe")
+ client.expect_exact(u"Success: send 4 byte over TCP to server")
+ server.expect(u"00000000 AF FE AB E0")
+ client.sendline(u"tcp disconnect")
+ client.sendline(u"tcp send affe:abe")
+ client.expect_exact(u"could not send")
+
+def test_triple_send(board_group, application, env=None):
env_sender = os.environ.copy()
if env != None:
env_sender.update(env)
@@ -235,32 +261,39 @@ def test_dual_send(board_group, application, env=None):
if env != None:
env_receiver.update(env)
env_receiver.update(board_group.boards[1].to_env())
- with pexpect.spawn("make", ["-C", application, "term"], env=env_sender,
- timeout=DEFAULT_TIMEOUT) as sender, \
- pexpect.spawn("make", ["-C", application, "term"], env=env_receiver,
- timeout=DEFAULT_TIMEOUT) as receiver:
- port = random.randint(0x0000, 0xffff)
+ with pexpect.spawnu("make", ["-C", application, "term"], env=env_sender,
+ timeout=DEFAULT_TIMEOUT) as sender, \
+ pexpect.spawnu("make", ["-C", application, "term"], env=env_receiver,
+ timeout=DEFAULT_TIMEOUT) as receiver:
+ udp_port = random.randint(0x0000, 0xffff)
+ tcp_port = random.randint(0x0000, 0xffff)
ipprot = random.randint(0x00, 0xff)
receiver_ip = get_ipv6_address(receiver)
+ sender_ip = get_ipv6_address(sender)
receiver.sendline(u"ip server start %d" % ipprot)
- receiver.sendline(u"udp server start %d" % port)
+ receiver.sendline(u"udp server start %d" % udp_port)
+ receiver.sendline(u"tcp server start %d" % tcp_port)
# wait for neighbor discovery to be done
time.sleep(5)
- sender.sendline(u"udp send %s %d 01:23" % (receiver_ip, port))
- sender.expect_exact(u"Success: send 2 byte to [%s]:%d" %
- (receiver_ip, port))
- receiver.expect(u"000000 01 23")
+ sender.sendline(u"udp send %s %d 01:23" % (receiver_ip, udp_port))
+ sender.expect_exact(u"Success: send 2 byte over UDP to [%s]:%d" %
+ (receiver_ip, udp_port))
+ receiver.expect(u"00000000 01 23")
sender.sendline(u"ip send %s %d 01:02:03:04" % (receiver_ip, ipprot))
- sender.expect_exact(u"Success: send 4 byte to %s (next header: %d)" %
+ sender.expect_exact(u"Success: send 4 byte over IPv6 to %s (next header: %d)" %
(receiver_ip, ipprot))
- receiver.expect(u"000000 60 00 00 00 00 04 %s ff fe 80 00 00 00 00 00 00" % hex(ipprot)[2:])
- receiver.expect(u"000010( [0-9a-f]{2}){8} fe 80 00 00 00 00 00 00")
- receiver.expect(u"000020( [0-9a-f]{2}){8} 01 02 03 04")
+ receiver.expect(u"00000000 01 02 03 04")
+ sender.sendline(u"tcp connect %s %d" % (receiver_ip, tcp_port))
+ receiver.expect(u"TCP client \\[%s\\]:[0-9]+ connected" % sender_ip)
+ sender.sendline(u"tcp send dead:beef")
+ sender.expect_exact(u"Success: send 4 byte over TCP to server")
+ receiver.expect(u"00000000 DE AD BE EF")
if __name__ == "__main__":
del os.environ['TERMFLAGS']
TestStrategy().execute([BoardGroup((Board("native", "tap0"), \
Board("native", "tap1")))], \
- [test_ipv6_send, test_udpv6_send, test_dual_send])
+ [test_ipv6_send, test_udpv6_send, test_tcpv6_send,
+ test_triple_send])
diff --git a/tests/lwip/udp.c b/tests/lwip/udp.c
index 748110cc6eef71389d8f387fdc75283d10ec66e2..f78683f0f7e9554b3f9a87a59c78e20df856db71 100644
--- a/tests/lwip/udp.c
+++ b/tests/lwip/udp.c
@@ -7,14 +7,12 @@
*/
/**
- * @ingroup examples
+ * @ingroup tests
* @{
*
* @file
- * @brief Demonstrating the sending and receiving of UDP data over POSIX sockets.
*
* @author Martine Lenders <mlenders@inf.fu-berlin.de>
- *
* @}
*/
@@ -25,42 +23,41 @@
#include "common.h"
#include "od.h"
#include "net/af.h"
-#include "net/conn/udp.h"
+#include "net/sock/udp.h"
#include "net/ipv6.h"
+#include "shell.h"
#include "thread.h"
#include "xtimer.h"
-#ifdef MODULE_CONN_UDP
-static char conn_inbuf[CONN_INBUF_SIZE];
+#ifdef MODULE_SOCK_UDP
+static char sock_inbuf[SOCK_INBUF_SIZE];
static bool server_running;
-static conn_udp_t server_conn;
+static sock_udp_t server_sock;
static char server_stack[THREAD_STACKSIZE_DEFAULT];
static msg_t server_msg_queue[SERVER_MSG_QUEUE_SIZE];
static void *_server_thread(void *args)
{
- ipv6_addr_t server_addr = IPV6_ADDR_UNSPECIFIED;
- uint16_t port;
+ sock_udp_ep_t server_addr = SOCK_IPV6_EP_ANY;
int res;
msg_init_queue(server_msg_queue, SERVER_MSG_QUEUE_SIZE);
/* parse port */
- port = (uint16_t)atoi((char *)args);
- if ((res = conn_udp_create(&server_conn, &server_addr,
- sizeof(server_addr), AF_INET6, port)) < 0) {
+ server_addr.port = atoi(args);
+ if ((res = sock_udp_create(&server_sock, &server_addr, NULL, 0)) < 0) {
printf("Unable to open UDP server on port %" PRIu16 " (error code %d)\n",
- port, -res);
+ server_addr.port, -res);
return NULL;
}
server_running = true;
- printf("Success: started UDP server on port %" PRIu16 "\n", port);
+ printf("Success: started UDP server on port %" PRIu16 "\n",
+ server_addr.port);
while (1) {
+ sock_udp_ep_t src;
int res;
- ipv6_addr_t src;
- size_t src_len = sizeof(ipv6_addr_t);
- uint16_t sport;
- if ((res = conn_udp_recvfrom(&server_conn, conn_inbuf, sizeof(conn_inbuf), &src,
- &src_len, &sport)) < 0) {
+
+ if ((res = sock_udp_recv(&server_sock, sock_inbuf, sizeof(sock_inbuf),
+ SOCK_NO_TIMEOUT, &src)) < 0) {
puts("Error on receive");
}
else if (res == 0) {
@@ -68,9 +65,11 @@ static void *_server_thread(void *args)
}
else {
char addrstr[IPV6_ADDR_MAX_STR_LEN];
- printf("Received from [%s]:%" PRIu16 ":\n", ipv6_addr_to_str(addrstr, &src,
- sizeof(addrstr)), sport);
- od_hex_dump(conn_inbuf, res, 0);
+
+ printf("Received UDP data from [%s]:%" PRIu16 ":\n",
+ ipv6_addr_to_str(addrstr, (ipv6_addr_t *)&src.addr.ipv6,
+ sizeof(addrstr)), src.port);
+ od_hex_dump(sock_inbuf, res, 0);
}
}
return NULL;
@@ -79,27 +78,30 @@ static void *_server_thread(void *args)
static int udp_send(char *addr_str, char *port_str, char *data, unsigned int num,
unsigned int delay)
{
- ipv6_addr_t src = IPV6_ADDR_UNSPECIFIED, dst;
- uint16_t port;
- uint8_t byte_data[strlen(data) / 2];
+ sock_udp_ep_t dst = SOCK_IPV6_EP_ANY;
+ uint8_t byte_data[SHELL_DEFAULT_BUFSIZE / 2];
size_t data_len;
/* parse destination address */
- if (ipv6_addr_from_str(&dst, addr_str) == NULL) {
+ if (ipv6_addr_from_str((ipv6_addr_t *)&dst.addr.ipv6, addr_str) == NULL) {
puts("Error: unable to parse destination address");
return 1;
}
/* parse port */
- port = (uint16_t)atoi(port_str);
+ dst.port = atoi(port_str);
data_len = hex2ints(byte_data, data);
for (unsigned int i = 0; i < num; i++) {
- if (conn_udp_sendto(byte_data, data_len, &src, sizeof(src), (struct sockaddr *)&dst,
- sizeof(dst), AF_INET6, port, port) < 0) {
+ sock_udp_t *sock = NULL;
+
+ if (server_running) {
+ sock = &server_sock;
+ }
+ if (sock_udp_send(sock, byte_data, data_len, &dst) < 0) {
puts("could not send");
}
else {
- printf("Success: send %u byte to [%s]:%" PRIu16 ")\n",
- (unsigned)data_len, addr_str, port);
+ printf("Success: send %u byte over UDP to [%s]:%" PRIu16 "\n",
+ (unsigned)data_len, addr_str, dst.port);
}
xtimer_usleep(delay);
}
@@ -132,10 +134,10 @@ int udp_cmd(int argc, char **argv)
return 1;
}
if (argc > 5) {
- num = (uint32_t)atoi(argv[5]);
+ num = atoi(argv[5]);
}
if (argc > 6) {
- delay = (uint32_t)atoi(argv[6]);
+ delay = atoi(argv[6]);
}
return udp_send(argv[2], argv[3], argv[4], num, delay);
}