christoph/wamr
1
Fork 0
Code Releases Activity

Merge dev/socket into main (#1393)

Browse Source 
Implement more socket APIs, refer to #1336 and below PRs:
- Implement wasi_addr_resolve function (#1319)
- Fix socket-api byte order issue when host/network order are the same (#1327)
- Enhance sock_addr_local syscall (#1320)
- Implement sock_addr_remote syscall (#1360)
- Add support for IPv6 in WAMR (#1411)
- Implement ns lookup allowlist (#1420)
- Implement sock_send_to and sock_recv_from system calls (#1457)
- Added http downloader and multicast socket options (#1467)
- Fix `bind()` calls to receive the correct size of `sockaddr` structure (#1490)
- Assert on correct parameters (#1505)
- Copy only received bytes from socket recv buffer into the app buffer (#1497)

Co-authored-by: Marcin Kolny <mkolny@amazon.com>
Co-authored-by: Marcin Kolny <marcin.kolny@gmail.com>
Co-authored-by: Callum Macmillan <callumimacmillan@gmail.com>
This commit is contained in:
Wenyong Huang
2022-09-22 21:46:14 +08:00
committed by GitHub
parent 32d2d16908
commit 78b5c5b484
31 changed files with 6345 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
samples/socket-api/CMakeLists.txt
View File

@ -90,6 +90,9 @@ ExternalProject_Add(wasm-app
tcp_client.wasm ${CMAKE_BINARY_DIR}
tcp_server.wasm ${CMAKE_BINARY_DIR}
send_recv.wasm ${CMAKE_BINARY_DIR}
socket_opts.wasm ${CMAKE_BINARY_DIR}
udp_client.wasm ${CMAKE_BINARY_DIR}
udp_server.wasm ${CMAKE_BINARY_DIR}
)
add_executable(tcp_server ${CMAKE_CURRENT_SOURCE_DIR}/wasm-src/tcp_server.c)
@ -100,6 +103,14 @@ add_executable(tcp_client ${CMAKE_CURRENT_SOURCE_DIR}/wasm-src/tcp_client.c)
add_executable(send_recv ${CMAKE_CURRENT_SOURCE_DIR}/wasm-src/send_recv.c)
target_link_libraries(send_recv pthread)
add_executable(addr_resolve ${CMAKE_CURRENT_SOURCE_DIR}/wasm-src/addr_resolve.c)
add_executable(socket_opts ${CMAKE_CURRENT_SOURCE_DIR}/wasm-src/socket_opts.c)
add_executable(udp_client ${CMAKE_CURRENT_SOURCE_DIR}/wasm-src/udp_client.c)
add_executable(udp_server ${CMAKE_CURRENT_SOURCE_DIR}/wasm-src/udp_server.c)
############################################
## Build iwasm with wasi and pthread support
############################################

16
samples/socket-api/README.md
View File

@ -82,4 +82,20 @@ Data:
And mourns for us
```
`socket_opts.wasm` shows an example of getting and setting various supported socket options
```bash
$ ./iwasm ./socket_opts.wasm
```
The output describes the different socket options that are set & retrieved, like so:
```bash
[Client] Create TCP socket
[Client] Create UDP socket
[Client] Create UDP IPv6 socket
SO_RCVTIMEO tv_sec is expected
SO_RCVTIMEO tv_usec is expected
...
[Client] Close sockets
```
Refer to [socket api document](../../doc/socket_api.md) for more details.

4
samples/socket-api/wasm-src/CMakeLists.txt
View File

@ -79,3 +79,7 @@ endfunction()
compile_with_clang(tcp_server.c)
compile_with_clang(tcp_client.c)
compile_with_clang(send_recv.c)
compile_with_clang(addr_resolve.c)
compile_with_clang(socket_opts.c)
compile_with_clang(udp_client.c)
compile_with_clang(udp_server.c)

69
samples/socket-api/wasm-src/addr_resolve.c Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef __wasi__
#include <wasi_socket_ext.h>
#else
#include <netdb.h>
#endif
int
lookup_host(const char *host)
{
struct addrinfo hints, *res, *result;
int errcode;
char addrstr[100];
void *ptr;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
errcode = getaddrinfo(host, NULL, &hints, &result);
if (errcode != 0) {
perror("getaddrinfo");
return -1;
}
res = result;
printf("Host: %s\n", host);
while (res) {
switch (res->ai_family) {
case AF_INET:
ptr = &((struct sockaddr_in *)res->ai_addr)->sin_addr;
break;
case AF_INET6:
ptr = &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
break;
default:
printf("Unsupported address family: %d\n", res->ai_family);
continue;
}
inet_ntop(res->ai_family, ptr, addrstr, 100);
printf("IPv%d address: %s (%s)\n", res->ai_family == AF_INET6 ? 6 : 4,
addrstr, res->ai_socktype == SOCK_STREAM ? "TCP" : "UDP");
res = res->ai_next;
}
freeaddrinfo(result);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
if (argc < 2) {
printf("Usage: %s DOMAIN\n", argv[0]);
return EXIT_FAILURE;
}
return lookup_host(argv[1]);
}

262
samples/socket-api/wasm-src/socket_opts.c Normal file
View File

@ -0,0 +1,262 @@
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/tcp.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#ifdef __wasi__
#include <wasi_socket_ext.h>
#endif
#define OPTION_ASSERT(A, B, OPTION) \
if (A == B) { \
printf("%s is expected\n", OPTION); \
} \
else { \
printf("%s is unexpected\n", OPTION); \
perror("assertion failed"); \
return EXIT_FAILURE; \
}
struct timeval
to_timeval(time_t tv_sec, suseconds_t tv_usec)
{
struct timeval tv = { tv_sec, tv_usec };
return tv;
}
int
set_and_get_bool_opt(int socket_fd, int level, int optname, int val)
{
int bool_opt = val;
socklen_t opt_len = sizeof(bool_opt);
setsockopt(socket_fd, level, optname, &bool_opt, sizeof(bool_opt));
bool_opt = !bool_opt;
getsockopt(socket_fd, level, optname, &bool_opt, &opt_len);
return bool_opt;
}
int
main(int argc, char *argv[])
{
int tcp_socket_fd = 0;
int udp_socket_fd = 0;
int udp_ipv6_socket_fd = 0;
struct timeval tv;
socklen_t opt_len;
int buf_len;
int result;
struct linger linger_opt;
uint32_t time_s;
struct ip_mreq mcast;
struct ipv6_mreq mcast_ipv6;
unsigned char ttl;
printf("[Client] Create TCP socket\n");
tcp_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (tcp_socket_fd == -1) {
perror("Create socket failed");
return EXIT_FAILURE;
}
printf("[Client] Create UDP socket\n");
udp_socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
if (udp_socket_fd == -1) {
perror("Create socket failed");
return EXIT_FAILURE;
}
printf("[Client] Create UDP IPv6 socket\n");
udp_ipv6_socket_fd = socket(AF_INET6, SOCK_DGRAM, 0);
if (udp_ipv6_socket_fd == -1) {
perror("Create socket failed");
return EXIT_FAILURE;
}
// SO_RCVTIMEO
tv = to_timeval(123, 1000);
setsockopt(tcp_socket_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
tv = to_timeval(0, 0);
opt_len = sizeof(tv);
getsockopt(tcp_socket_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, &opt_len);
OPTION_ASSERT(tv.tv_sec, 123, "SO_RCVTIMEO tv_sec");
OPTION_ASSERT(tv.tv_usec, 1000, "SO_RCVTIMEO tv_usec");
// SO_SNDTIMEO
tv = to_timeval(456, 2000);
setsockopt(tcp_socket_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
tv = to_timeval(0, 0);
opt_len = sizeof(tv);
getsockopt(tcp_socket_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, &opt_len);
OPTION_ASSERT(tv.tv_sec, 456, "SO_SNDTIMEO tv_sec");
OPTION_ASSERT(tv.tv_usec, 2000, "SO_SNDTIMEO tv_usec");
// SO_SNDBUF
buf_len = 8192;
setsockopt(tcp_socket_fd, SOL_SOCKET, SO_SNDBUF, &buf_len, sizeof(buf_len));
buf_len = 0;
opt_len = sizeof(buf_len);
getsockopt(tcp_socket_fd, SOL_SOCKET, SO_SNDBUF, &buf_len, &opt_len);
OPTION_ASSERT(buf_len, 16384, "SO_SNDBUF buf_len");
// SO_RCVBUF
buf_len = 4096;
setsockopt(tcp_socket_fd, SOL_SOCKET, SO_RCVBUF, &buf_len, sizeof(buf_len));
buf_len = 0;
opt_len = sizeof(buf_len);
getsockopt(tcp_socket_fd, SOL_SOCKET, SO_RCVBUF, &buf_len, &opt_len);
OPTION_ASSERT(buf_len, 8192, "SO_RCVBUF buf_len");
// SO_KEEPALIVE
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, SOL_SOCKET, SO_KEEPALIVE, 1), 1,
"SO_KEEPALIVE enabled");
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, SOL_SOCKET, SO_KEEPALIVE, 0), 0,
"SO_KEEPALIVE disabled");
// SO_REUSEADDR
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, SOL_SOCKET, SO_REUSEADDR, 1), 1,
"SO_REUSEADDR enabled");
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, SOL_SOCKET, SO_REUSEADDR, 0), 0,
"SO_REUSEADDR disabled");
// SO_REUSEPORT
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, SOL_SOCKET, SO_REUSEPORT, 1), 1,
"SO_REUSEPORT enabled");
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, SOL_SOCKET, SO_REUSEPORT, 0), 0,
"SO_REUSEPORT disabled");
// SO_LINGER
linger_opt.l_onoff = 1;
linger_opt.l_linger = 10;
setsockopt(tcp_socket_fd, SOL_SOCKET, SO_LINGER, &linger_opt,
sizeof(linger_opt));
linger_opt.l_onoff = 0;
linger_opt.l_linger = 0;
opt_len = sizeof(linger_opt);
getsockopt(tcp_socket_fd, SOL_SOCKET, SO_LINGER, &linger_opt, &opt_len);
OPTION_ASSERT(linger_opt.l_onoff, 1, "SO_LINGER l_onoff");
OPTION_ASSERT(linger_opt.l_linger, 10, "SO_LINGER l_linger");
// SO_BROADCAST
OPTION_ASSERT(
set_and_get_bool_opt(udp_socket_fd, SOL_SOCKET, SO_BROADCAST, 1), 1,
"SO_BROADCAST enabled");
OPTION_ASSERT(
set_and_get_bool_opt(udp_socket_fd, SOL_SOCKET, SO_BROADCAST, 0), 0,
"SO_BROADCAST disabled");
// TCP_KEEPIDLE
time_s = 16;
setsockopt(tcp_socket_fd, IPPROTO_TCP, TCP_KEEPIDLE, &time_s,
sizeof(time_s));
time_s = 0;
opt_len = sizeof(time_s);
getsockopt(tcp_socket_fd, IPPROTO_TCP, TCP_KEEPIDLE, &time_s, &opt_len);
OPTION_ASSERT(time_s, 16, "TCP_KEEPIDLE");
// TCP_KEEPINTVL
time_s = 8;
setsockopt(tcp_socket_fd, IPPROTO_TCP, TCP_KEEPINTVL, &time_s,
sizeof(time_s));
time_s = 0;
opt_len = sizeof(time_s);
getsockopt(tcp_socket_fd, IPPROTO_TCP, TCP_KEEPINTVL, &time_s, &opt_len);
OPTION_ASSERT(time_s, 8, "TCP_KEEPINTVL");
// TCP_FASTOPEN_CONNECT
OPTION_ASSERT(set_and_get_bool_opt(tcp_socket_fd, IPPROTO_TCP,
TCP_FASTOPEN_CONNECT, 1),
1, "TCP_FASTOPEN_CONNECT enabled");
OPTION_ASSERT(set_and_get_bool_opt(tcp_socket_fd, IPPROTO_TCP,
TCP_FASTOPEN_CONNECT, 0),
0, "TCP_FASTOPEN_CONNECT disabled");
// TCP_NODELAY
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, IPPROTO_TCP, TCP_NODELAY, 1), 1,
"TCP_NODELAY enabled");
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, IPPROTO_TCP, TCP_NODELAY, 0), 0,
"TCP_NODELAY disabled");
// TCP_QUICKACK
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, IPPROTO_TCP, TCP_QUICKACK, 1), 1,
"TCP_QUICKACK enabled");
OPTION_ASSERT(
set_and_get_bool_opt(tcp_socket_fd, IPPROTO_TCP, TCP_QUICKACK, 0), 0,
"TCP_QUICKACK disabled");
// IP_TTL
ttl = 8;
setsockopt(tcp_socket_fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
ttl = 0;
opt_len = sizeof(ttl);
getsockopt(tcp_socket_fd, IPPROTO_IP, IP_TTL, &ttl, &opt_len);
OPTION_ASSERT(ttl, 8, "IP_TTL");
// IPV6_V6ONLY
OPTION_ASSERT(
set_and_get_bool_opt(udp_ipv6_socket_fd, IPPROTO_IPV6, IPV6_V6ONLY, 1),
1, "IPV6_V6ONLY enabled");
OPTION_ASSERT(
set_and_get_bool_opt(udp_ipv6_socket_fd, IPPROTO_IPV6, IPV6_V6ONLY, 0),
0, "IPV6_V6ONLY disabled");
// IP_MULTICAST_LOOP
OPTION_ASSERT(
set_and_get_bool_opt(udp_socket_fd, IPPROTO_IP, IP_MULTICAST_LOOP, 1),
1, "IP_MULTICAST_LOOP enabled");
OPTION_ASSERT(
set_and_get_bool_opt(udp_socket_fd, IPPROTO_IP, IP_MULTICAST_LOOP, 0),
0, "IP_MULTICAST_LOOP disabled");
// IP_ADD_MEMBERSHIP
mcast.imr_multiaddr.s_addr = 16777440;
mcast.imr_interface.s_addr = htonl(INADDR_ANY);
result = setsockopt(udp_socket_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mcast,
sizeof(mcast));
OPTION_ASSERT(result, 0, "IP_ADD_MEMBERSHIP");
// IP_DROP_MEMBERSHIP
result = setsockopt(udp_socket_fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mcast,
sizeof(mcast));
OPTION_ASSERT(result, 0, "IP_DROP_MEMBERSHIP");
// IP_MULTICAST_TTL
ttl = 8;
setsockopt(udp_socket_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
ttl = 0;
opt_len = sizeof(ttl);
getsockopt(udp_socket_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, &opt_len);
OPTION_ASSERT(ttl, 8, "IP_MULTICAST_TTL");
// IPV6_MULTICAST_LOOP
OPTION_ASSERT(set_and_get_bool_opt(udp_ipv6_socket_fd, IPPROTO_IPV6,
IPV6_MULTICAST_LOOP, 1),
1, "IPV6_MULTICAST_LOOP enabled");
OPTION_ASSERT(set_and_get_bool_opt(udp_ipv6_socket_fd, IPPROTO_IPV6,
IPV6_MULTICAST_LOOP, 0),
0, "IPV6_MULTICAST_LOOP disabled");
// IPV6_JOIN_GROUP
setsockopt(udp_ipv6_socket_fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mcast_ipv6,
sizeof(mcast_ipv6));
// IPV6_LEAVE_GROUP
setsockopt(udp_ipv6_socket_fd, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mcast_ipv6,
sizeof(mcast_ipv6));
printf("[Client] Close sockets\n");
close(tcp_socket_fd);
close(udp_socket_fd);
return EXIT_SUCCESS;
}

48
samples/socket-api/wasm-src/socket_utils.h Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (C) 2022 Amazon.com Inc. or its affiliates. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef TCP_UTILS_H
#define TCP_UTILS_H
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
int
sockaddr_to_string(struct sockaddr *addr, char *str, size_t len)
{
uint16_t port;
char ip_string[64];
void *addr_buf;
int ret;
switch (addr->sa_family) {
case AF_INET:
{
struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
port = addr_in->sin_port;
addr_buf = &addr_in->sin_addr;
break;
}
case AF_INET6:
{
struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr;
port = addr_in6->sin6_port;
addr_buf = &addr_in6->sin6_addr;
break;
}
default:
return -1;
}
inet_ntop(addr->sa_family, addr_buf, ip_string,
sizeof(ip_string) / sizeof(ip_string[0]));
ret = snprintf(str, len, "%s:%d", ip_string, ntohs(port));
return ret > 0 && (size_t)ret < len ? 0 : -1;
}
#endif /* TCP_UTILS_H */

66
samples/socket-api/wasm-src/tcp_client.c
View File

@ -2,6 +2,7 @@
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "socket_utils.h"
#include <arpa/inet.h>
#include <netinet/in.h>
@ -14,34 +15,77 @@
#include <wasi_socket_ext.h>
#endif
static void
init_sockaddr_inet(struct sockaddr_in *addr)
{
/* 127.0.0.1:1234 */
addr->sin_family = AF_INET;
addr->sin_port = htons(1234);
addr->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
}
static void
init_sockaddr_inet6(struct sockaddr_in6 *addr)
{
/* [::1]:1234 */
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(1234);
addr->sin6_addr = in6addr_loopback;
}
int
main(int argc, char *argv[])
{
int socket_fd, ret, total_size = 0;
int socket_fd, ret, total_size = 0, af;
char buffer[1024] = { 0 };
struct sockaddr_in server_address = { 0 };
char ip_string[64] = { 0 };
socklen_t len;
struct sockaddr_storage server_address = { 0 };
struct sockaddr_storage local_address = { 0 };
if (argc > 1 && strcmp(argv[1], "inet6") == 0) {
af = AF_INET6;
len = sizeof(struct sockaddr_in6);
init_sockaddr_inet6((struct sockaddr_in6 *)&server_address);
}
else {
af = AF_INET;
len = sizeof(struct sockaddr_in);
init_sockaddr_inet((struct sockaddr_in *)&server_address);
}
printf("[Client] Create socket\n");
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
socket_fd = socket(af, SOCK_STREAM, 0);
if (socket_fd == -1) {
perror("Create socket failed");
return EXIT_FAILURE;
}
/* 127.0.0.1:1234 */
server_address.sin_family = AF_INET;
server_address.sin_port = htons(1234);
server_address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
printf("[Client] Connect socket\n");
if (connect(socket_fd, (struct sockaddr *)&server_address,
sizeof(server_address))
== -1) {
if (connect(socket_fd, (struct sockaddr *)&server_address, len) == -1) {
perror("Connect failed");
close(socket_fd);
return EXIT_FAILURE;
}
len = sizeof(local_address);
ret = getsockname(socket_fd, (struct sockaddr *)&local_address, &len);
if (ret == -1) {
perror("Failed to retrieve socket address");
close(socket_fd);
return EXIT_FAILURE;
}
if (sockaddr_to_string((struct sockaddr *)&local_address, ip_string,
sizeof(ip_string) / sizeof(ip_string[0]))
!= 0) {
printf("[Client] failed to parse local address\n");
close(socket_fd);
return EXIT_FAILURE;
}
printf("[Client] Local address is: %s\n", ip_string);
printf("[Client] Client receive\n");
while (1) {
ret = recv(socket_fd, buffer + total_size, sizeof(buffer) - total_size,

54
samples/socket-api/wasm-src/tcp_server.c
View File

@ -2,6 +2,8 @@
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "socket_utils.h"
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
@ -41,29 +43,53 @@ run(void *arg)
return NULL;
}
static void
init_sockaddr_inet(struct sockaddr_in *addr)
{
/* 0.0.0.0:1234 */
addr->sin_family = AF_INET;
addr->sin_port = htons(1234);
addr->sin_addr.s_addr = htonl(INADDR_ANY);
}
static void
init_sockaddr_inet6(struct sockaddr_in6 *addr)
{
/* [::]:1234 */
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(1234);
addr->sin6_addr = in6addr_any;
}
int
main(int argc, char *argv[])
{
int socket_fd = -1, addrlen = 0;
struct sockaddr_in addr = { 0 };
int socket_fd = -1, addrlen = 0, af;
struct sockaddr_storage addr = { 0 };
unsigned connections = 0;
pthread_t workers[WORKER_NUM] = { 0 };
int client_sock_fds[WORKER_NUM] = { 0 };
char ip_string[64];
if (argc > 1 && strcmp(argv[1], "inet6") == 0) {
af = AF_INET6;
addrlen = sizeof(struct sockaddr_in6);
init_sockaddr_inet6((struct sockaddr_in6 *)&addr);
}
else {
af = AF_INET;
addrlen = sizeof(struct sockaddr_in6);
init_sockaddr_inet((struct sockaddr_in *)&addr);
}
printf("[Server] Create socket\n");
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
socket_fd = socket(af, SOCK_STREAM, 0);
if (socket_fd < 0) {
perror("Create socket failed");
goto fail;
}
/* 0.0.0.0:1234 */
addr.sin_family = AF_INET;
addr.sin_port = htons(1234);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
printf("[Server] Bind socket\n");
addrlen = sizeof(addr);
if (bind(socket_fd, (struct sockaddr *)&addr, addrlen) < 0) {
perror("Bind failed");
goto fail;
@ -77,6 +103,7 @@ main(int argc, char *argv[])
printf("[Server] Wait for clients to connect ..\n");
while (connections < WORKER_NUM) {
addrlen = sizeof(struct sockaddr);
client_sock_fds[connections] =
accept(socket_fd, (struct sockaddr *)&addr, (socklen_t *)&addrlen);
if (client_sock_fds[connections] < 0) {
@ -84,7 +111,14 @@ main(int argc, char *argv[])
break;
}
printf("[Server] Client connected\n");
if (sockaddr_to_string((struct sockaddr *)&addr, ip_string,
sizeof(ip_string) / sizeof(ip_string[0]))
!= 0) {
printf("[Server] failed to parse client address\n");
goto fail;
}
printf("[Server] Client connected (%s)\n", ip_string);
if (pthread_create(&workers[connections], NULL, run,
&client_sock_fds[connections])) {
perror("Create a worker thread failed");

82
samples/socket-api/wasm-src/udp_client.c Normal file
View File

@ -0,0 +1,82 @@
/*
* Copyright (C) 2022 Amazon.com Inc. or its affiliates. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
#ifdef __wasi__
#include <wasi_socket_ext.h>
#endif
static void
init_sockaddr_inet(struct sockaddr_in *addr)
{
/* 127.0.0.1:1234 */
addr->sin_family = AF_INET;
addr->sin_port = htons(1234);
addr->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
}
static void
init_sockaddr_inet6(struct sockaddr_in6 *addr)
{
/* [::1]:1234 */
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(1234);
addr->sin6_addr = in6addr_loopback;
}
int
main(int argc, char *argv[])
{
int socket_fd, ret, af;
char buffer[1024] = { 0 };
socklen_t serverlen;
struct sockaddr_storage server_address = { 0 };
const char *message = "Hello from client";
if (argc > 1 && strcmp(argv[1], "inet6") == 0) {
af = AF_INET6;
init_sockaddr_inet6((struct sockaddr_in6 *)&server_address);
serverlen = sizeof(struct sockaddr_in6);
}
else {
af = AF_INET;
init_sockaddr_inet((struct sockaddr_in *)&server_address);
serverlen = sizeof(struct sockaddr_in);
}
printf("[Client] Create socket\n");
socket_fd = socket(af, SOCK_DGRAM, 0);
if (socket_fd == -1) {
perror("Create socket failed");
return EXIT_FAILURE;
}
printf("[Client] Client send\n");
ret = sendto(socket_fd, message, strlen(message), 0,
(struct sockaddr *)&server_address, serverlen);
if (ret < 0) {
close(socket_fd);
perror("Send failed");
return EXIT_FAILURE;
}
printf("[Client] Client receive\n");
serverlen = sizeof(server_address);
ret = recvfrom(socket_fd, buffer, sizeof(buffer), 0,
(struct sockaddr *)&server_address, &serverlen);
if (ret > 0) {
printf("[Client] Buffer recieved: %s\n", buffer);
}
close(socket_fd);
printf("[Client] BYE \n");
return EXIT_SUCCESS;
}

120
samples/socket-api/wasm-src/udp_server.c Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright (C) 2022 Amazon.com Inc. or its affiliates. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "socket_utils.h"
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
#ifdef __wasi__
#include <wasi_socket_ext.h>
#endif
#define MAX_CONNECTIONS_COUNT 5
static void
init_sockaddr_inet(struct sockaddr_in *addr)
{
/* 0.0.0.0:1234 */
addr->sin_family = AF_INET;
addr->sin_port = htons(1234);
addr->sin_addr.s_addr = htonl(INADDR_ANY);
}
static void
init_sockaddr_inet6(struct sockaddr_in6 *addr)
{
/* [::]:1234 */
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(1234);
addr->sin6_addr = in6addr_any;
}
int
main(int argc, char *argv[])
{
int socket_fd = -1, af;
socklen_t addrlen = 0;
struct sockaddr_storage addr = { 0 };
char *reply_message = "Hello from server";
unsigned connections = 0;
char ip_string[64];
char buffer[1024];
if (argc > 1 && strcmp(argv[1], "inet6") == 0) {
af = AF_INET6;
addrlen = sizeof(struct sockaddr_in6);
init_sockaddr_inet6((struct sockaddr_in6 *)&addr);
}
else {
af = AF_INET;
addrlen = sizeof(struct sockaddr_in);
init_sockaddr_inet((struct sockaddr_in *)&addr);
}
printf("[Server] Create socket\n");
socket_fd = socket(af, SOCK_DGRAM, 0);
if (socket_fd < 0) {
perror("Create socket failed");
goto fail;
}
printf("[Server] Bind socket\n");
if (bind(socket_fd, (struct sockaddr *)&addr, addrlen) < 0) {
perror("Bind failed");
goto fail;
}
printf("[Server] Wait for clients to connect ..\n");
while (connections < MAX_CONNECTIONS_COUNT) {
addrlen = sizeof(addr);
int ret = recvfrom(socket_fd, buffer, sizeof(buffer), 0,
(struct sockaddr *)&addr, &addrlen);
if (ret < 0) {
perror("Read failed");
goto fail;
}
if (sockaddr_to_string((struct sockaddr *)&addr, ip_string,
sizeof(ip_string) / sizeof(ip_string[0]))
!= 0) {
printf("[Server] failed to parse client address\n");
goto fail;
}
printf("[Server] received %d bytes from %s: %s\n", ret, ip_string,
buffer);
if (sendto(socket_fd, reply_message, strlen(reply_message), 0,
(struct sockaddr *)&addr, addrlen)
< 0) {
perror("Send failed");
break;
}
connections++;
}
if (connections == MAX_CONNECTIONS_COUNT) {
printf("[Server] Achieve maximum amount of connections\n");
}
printf("[Server] Shuting down ..\n");
shutdown(socket_fd, SHUT_RDWR);
close(socket_fd);
sleep(3);
printf("[Server] BYE \n");
return EXIT_SUCCESS;
fail:
printf("[Server] Shuting down ..\n");
if (socket_fd >= 0)
close(socket_fd);
sleep(3);
return EXIT_FAILURE;
}