gfwleak/zhangyang-libzt
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update C API selftest

Browse Source
This commit is contained in:
Joseph Henry
2021-05-05 16:27:53 -07:00
parent 9151f4471c
commit 90c4744a3b
1 changed files with 138 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
test/selftest.c
View File

@@ -647,154 +647,154 @@ void api_value_arg_test(int tid, uint8_t num, int8_t i8, int16_t i16, int32_t i3
// break; // break;
// Socket // Socket
case 120: case 120:
assert(zts_socket(i32, i32, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_socket(i32, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 121: case 121:
assert(zts_connect(i32, null_addr, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_connect(i32, null_addr, i32) == ZTS_ERR_SERVICE);
break; break;
case 122: case 122:
assert(zts_simple_connect(i32, NULL, i32, i32) == ZTS_ERR_SERVICE); assert(zts_connect(i32, NULL, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 123: case 123:
assert(zts_bind(i32, null_addr, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_bind(i32, null_addr, i32) == ZTS_ERR_SERVICE);
break; break;
case 124: case 124:
assert(zts_simple_bind(i32, NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bind(i32, NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 125: case 125:
assert(zts_listen(i32, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_listen(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 126: case 126:
assert(zts_accept(i32, null_addr, NULL) == ZTS_ERR_SERVICE); assert(zts_bsd_accept(i32, null_addr, NULL) == ZTS_ERR_SERVICE);
break; break;
case 127: case 127:
assert(zts_simple_accept(i32, NULL, i32, NULL) == ZTS_ERR_SERVICE); assert(zts_accept(i32, NULL, i32, NULL) == ZTS_ERR_SERVICE);
break; break;
case 128: case 128:
assert(zts_setsockopt(i32, i32, i32, NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_setsockopt(i32, i32, i32, NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 129: case 129:
assert(zts_getsockopt(i32, i32, i32, NULL, NULL) == ZTS_ERR_SERVICE); assert(zts_bsd_getsockopt(i32, i32, i32, NULL, NULL) == ZTS_ERR_SERVICE);
break; break;
case 130: case 130:
assert(zts_getsockname(i32, null_addr, NULL) == ZTS_ERR_SERVICE); assert(zts_bsd_getsockname(i32, null_addr, NULL) == ZTS_ERR_SERVICE);
break; break;
case 131: case 131:
assert(zts_getpeername(i32, null_addr, NULL) == ZTS_ERR_SERVICE); assert(zts_bsd_getpeername(i32, null_addr, NULL) == ZTS_ERR_SERVICE);
break; break;
case 132: case 132:
assert(zts_close(i32) == ZTS_ERR_SERVICE); assert(zts_bsd_close(i32) == ZTS_ERR_SERVICE);
break; break;
case 133: case 133:
assert(zts_select(i32, NULL, NULL, NULL, NULL) == ZTS_ERR_SERVICE); assert(zts_bsd_select(i32, NULL, NULL, NULL, NULL) == ZTS_ERR_SERVICE);
break; break;
case 134: case 134:
assert(zts_fcntl(i32, i32, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_fcntl(i32, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 135: case 135:
assert(zts_poll(NULL, (zts_nfds_t)NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_poll(NULL, (zts_nfds_t)NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 136: case 136:
assert(zts_ioctl(i32, i64, NULL) == ZTS_ERR_SERVICE); assert(zts_bsd_ioctl(i32, i64, NULL) == ZTS_ERR_SERVICE);
break; break;
case 137: case 137:
assert(zts_send(i32, NULL, i32, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_send(i32, NULL, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 138: case 138:
assert(zts_sendto(i32, NULL, i32, i32, null_addr, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_sendto(i32, NULL, i32, i32, null_addr, i32) == ZTS_ERR_SERVICE);
break; break;
case 139: case 139:
assert(zts_sendmsg(i32, NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_sendmsg(i32, NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 140: case 140:
assert(zts_recv(i32, NULL, i32, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_recv(i32, NULL, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 141: case 141:
assert(zts_recvfrom(i32, NULL, i32, i32, null_addr, NULL) == ZTS_ERR_SERVICE); assert(zts_bsd_recvfrom(i32, NULL, i32, i32, null_addr, NULL) == ZTS_ERR_SERVICE);
break; break;
case 142: case 142:
assert(zts_recvmsg(i32, NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_recvmsg(i32, NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 143: case 143:
assert(zts_read(i32, NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_read(i32, NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 144: case 144:
assert(zts_readv(i32, NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_readv(i32, NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 145: case 145:
assert(zts_write(i32, NULL, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_write(i32, NULL, i32) == ZTS_ERR_SERVICE);
break; break;
case 146: case 146:
assert(zts_writev(i32, nullable, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_writev(i32, nullable, i32) == ZTS_ERR_SERVICE);
break; break;
case 147: case 147:
assert(zts_shutdown(i32, i32) == ZTS_ERR_SERVICE); assert(zts_bsd_shutdown(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 148: case 148:
assert(zts_simple_set_no_delay(i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_no_delay(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 149: case 149:
assert(zts_simple_get_no_delay(i32) == ZTS_ERR_SERVICE); assert(zts_get_no_delay(i32) == ZTS_ERR_SERVICE);
break; break;
case 150: case 150:
assert(zts_simple_set_linger(i32, i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_linger(i32, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 151: case 151:
assert(zts_simple_get_linger_value(i32) == ZTS_ERR_SERVICE); assert(zts_get_linger_value(i32) == ZTS_ERR_SERVICE);
break; break;
case 152: case 152:
assert(zts_simple_get_linger_value(i32) == ZTS_ERR_SERVICE); assert(zts_get_linger_value(i32) == ZTS_ERR_SERVICE);
break; break;
case 153: case 153:
assert(zts_simple_set_reuse_addr(i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_reuse_addr(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 154: case 154:
assert(zts_simple_get_reuse_addr(i32) == ZTS_ERR_SERVICE); assert(zts_get_reuse_addr(i32) == ZTS_ERR_SERVICE);
break; break;
case 155: case 155:
assert(zts_simple_set_recv_timeout(i32, i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_recv_timeout(i32, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 156: case 156:
assert(zts_simple_get_recv_timeout(i32) == ZTS_ERR_SERVICE); assert(zts_get_recv_timeout(i32) == ZTS_ERR_SERVICE);
break; break;
case 157: case 157:
assert(zts_simple_set_send_timeout(i32, i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_send_timeout(i32, i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 158: case 158:
assert(zts_simple_get_send_timeout(i32) == ZTS_ERR_SERVICE); assert(zts_get_send_timeout(i32) == ZTS_ERR_SERVICE);
break; break;
case 159: case 159:
assert(zts_simple_set_send_buf_size(i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_send_buf_size(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 160: case 160:
assert(zts_simple_get_send_buf_size(i32) == ZTS_ERR_SERVICE); assert(zts_get_send_buf_size(i32) == ZTS_ERR_SERVICE);
break; break;
case 161: case 161:
assert(zts_simple_set_recv_buf_size(i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_recv_buf_size(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 162: case 162:
assert(zts_simple_get_recv_buf_size(i32) == ZTS_ERR_SERVICE); assert(zts_get_recv_buf_size(i32) == ZTS_ERR_SERVICE);
break; break;
case 163: case 163:
assert(zts_simple_set_ttl(i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_ttl(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 164: case 164:
assert(zts_simple_get_ttl(i32) == ZTS_ERR_SERVICE); assert(zts_get_ttl(i32) == ZTS_ERR_SERVICE);
break; break;
case 165: case 165:
assert(zts_simple_set_blocking(i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_blocking(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 166: case 166:
assert(zts_simple_get_blocking(i32) == ZTS_ERR_SERVICE); assert(zts_get_blocking(i32) == ZTS_ERR_SERVICE);
break; break;
case 167: case 167:
assert(zts_simple_set_keepalive(i32, i32) == ZTS_ERR_SERVICE); assert(zts_set_keepalive(i32, i32) == ZTS_ERR_SERVICE);
break; break;
case 168: case 168:
assert(zts_simple_get_keepalive(i32) == ZTS_ERR_SERVICE); assert(zts_get_keepalive(i32) == ZTS_ERR_SERVICE);
break; break;
case 169: case 169:
assert(zts_gethostbyname(NULL) == NULL); assert(zts_bsd_gethostbyname(NULL) == NULL);
break; break;
case 170: case 170:
assert(zts_dns_set_server(i8, null_addr) == ZTS_ERR_SERVICE); assert(zts_dns_set_server(i8, null_addr) == ZTS_ERR_SERVICE);
@@ -922,133 +922,133 @@ void test_sockets()
// Test simplified API, proxy for setsockopt/getsockopt/ioctl etc. // Test simplified API, proxy for setsockopt/getsockopt/ioctl etc.
int s4 = zts_socket(ZTS_AF_INET6, ZTS_SOCK_STREAM, 0); int s4 = zts_bsd_socket(ZTS_AF_INET6, ZTS_SOCK_STREAM, 0);
assert(s4 >= 0); assert(s4 >= 0);
// TCP_NODELAY // TCP_NODELAY
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_no_delay(s4) == 0); assert(zts_get_no_delay(s4) == 0);
// Turn on // Turn on
assert(zts_simple_set_no_delay(s4, 1) == ZTS_ERR_OK); assert(zts_set_no_delay(s4, 1) == ZTS_ERR_OK);
// Should return value instead of error code // Should return value instead of error code
assert(zts_simple_get_no_delay(s4) == 1); assert(zts_get_no_delay(s4) == 1);
// Turn off // Turn off
assert(zts_simple_set_no_delay(s4, 0) == ZTS_ERR_OK); assert(zts_set_no_delay(s4, 0) == ZTS_ERR_OK);
assert(zts_simple_get_no_delay(s4) == ZTS_ERR_OK); assert(zts_get_no_delay(s4) == ZTS_ERR_OK);
// SO_LINGER // SO_LINGER
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_linger_enabled(s4) == 0); assert(zts_get_linger_enabled(s4) == 0);
assert(zts_simple_get_linger_value(s4) == 0); assert(zts_get_linger_value(s4) == 0);
// Turn on, set to 7 seconds // Turn on, set to 7 seconds
assert(zts_simple_set_linger(s4, 1, 7) == ZTS_ERR_OK); assert(zts_set_linger(s4, 1, 7) == ZTS_ERR_OK);
assert(zts_simple_get_linger_enabled(s4) == 1); assert(zts_get_linger_enabled(s4) == 1);
assert(zts_simple_get_linger_value(s4) == 7); assert(zts_get_linger_value(s4) == 7);
assert(zts_simple_set_linger(s4, 0, 0) == ZTS_ERR_OK); assert(zts_set_linger(s4, 0, 0) == ZTS_ERR_OK);
// Turn off // Turn off
assert(zts_simple_get_linger_enabled(s4) == 0); assert(zts_get_linger_enabled(s4) == 0);
assert(zts_simple_get_linger_value(s4) == 0); assert(zts_get_linger_value(s4) == 0);
// SO_REUSEADDR // SO_REUSEADDR
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_reuse_addr(s4) == 0); assert(zts_get_reuse_addr(s4) == 0);
// Turn on // Turn on
assert(zts_simple_set_reuse_addr(s4, 1) == ZTS_ERR_OK); assert(zts_set_reuse_addr(s4, 1) == ZTS_ERR_OK);
// Should return value instead of error code // Should return value instead of error code
assert(zts_simple_get_reuse_addr(s4) == 1); assert(zts_get_reuse_addr(s4) == 1);
// Turn off // Turn off
assert(zts_simple_set_reuse_addr(s4, 0) == ZTS_ERR_OK); assert(zts_set_reuse_addr(s4, 0) == ZTS_ERR_OK);
assert(zts_simple_get_reuse_addr(s4) == ZTS_ERR_OK); assert(zts_get_reuse_addr(s4) == ZTS_ERR_OK);
// SO_RCVTIMEO // SO_RCVTIMEO
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_recv_timeout(s4) == 0); assert(zts_get_recv_timeout(s4) == 0);
// Set to value // Set to value
assert(zts_simple_set_recv_timeout(s4, 3, 0) == ZTS_ERR_OK); assert(zts_set_recv_timeout(s4, 3, 0) == ZTS_ERR_OK);
assert(zts_simple_get_recv_timeout(s4) == 3); assert(zts_get_recv_timeout(s4) == 3);
assert(zts_simple_set_recv_timeout(s4, 0, 0) == ZTS_ERR_OK); assert(zts_set_recv_timeout(s4, 0, 0) == ZTS_ERR_OK);
// Set to zero // Set to zero
assert(zts_simple_get_recv_timeout(s4) == 0); assert(zts_get_recv_timeout(s4) == 0);
// SO_SNDTIMEO // SO_SNDTIMEO
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_send_timeout(s4) == 0); assert(zts_get_send_timeout(s4) == 0);
// Set to value // Set to value
assert(zts_simple_set_send_timeout(s4, 4, 0) == ZTS_ERR_OK); assert(zts_set_send_timeout(s4, 4, 0) == ZTS_ERR_OK);
assert(zts_simple_get_send_timeout(s4) == 4); assert(zts_get_send_timeout(s4) == 4);
assert(zts_simple_set_send_timeout(s4, 0, 0) == ZTS_ERR_OK); assert(zts_set_send_timeout(s4, 0, 0) == ZTS_ERR_OK);
// Set to zero // Set to zero
assert(zts_simple_get_send_timeout(s4) == 0); assert(zts_get_send_timeout(s4) == 0);
// SO_SNDBUF // SO_SNDBUF
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_send_buf_size(s4) == -1); // Unimplemented assert(zts_get_send_buf_size(s4) == -1); // Unimplemented
// Set to 7 seconds // Set to 7 seconds
assert(zts_simple_set_send_buf_size(s4, 1024) == ZTS_ERR_OK); assert(zts_set_send_buf_size(s4, 1024) == ZTS_ERR_OK);
assert(zts_simple_get_send_buf_size(s4) == -1); // Unimplemented assert(zts_get_send_buf_size(s4) == -1); // Unimplemented
assert(zts_simple_set_send_buf_size(s4, 0) == ZTS_ERR_OK); assert(zts_set_send_buf_size(s4, 0) == ZTS_ERR_OK);
// Set to zero // Set to zero
assert(zts_simple_get_send_buf_size(s4) == -1); // Unimplemented assert(zts_get_send_buf_size(s4) == -1); // Unimplemented
// SO_RCVBUF // SO_RCVBUF
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_recv_buf_size(s4) > 0); assert(zts_get_recv_buf_size(s4) > 0);
// Set to value // Set to value
assert(zts_simple_set_recv_buf_size(s4, 1024) == ZTS_ERR_OK); assert(zts_set_recv_buf_size(s4, 1024) == ZTS_ERR_OK);
assert(zts_simple_get_recv_buf_size(s4) == 1024); assert(zts_get_recv_buf_size(s4) == 1024);
assert(zts_simple_set_recv_buf_size(s4, 0) == ZTS_ERR_OK); assert(zts_set_recv_buf_size(s4, 0) == ZTS_ERR_OK);
// Set to zero // Set to zero
assert(zts_simple_get_recv_buf_size(s4) == 0); assert(zts_get_recv_buf_size(s4) == 0);
// IP_TTL // IP_TTL
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_ttl(s4) == 255); // Defaults to max assert(zts_get_ttl(s4) == 255); // Defaults to max
// Set to value // Set to value
assert(zts_simple_set_ttl(s4, 128) == ZTS_ERR_OK); assert(zts_set_ttl(s4, 128) == ZTS_ERR_OK);
assert(zts_simple_get_ttl(s4) == 128); assert(zts_get_ttl(s4) == 128);
assert(zts_simple_set_ttl(s4, 0) == ZTS_ERR_OK); assert(zts_set_ttl(s4, 0) == ZTS_ERR_OK);
// Set to zero // Set to zero
assert(zts_simple_get_ttl(s4) == 0); assert(zts_get_ttl(s4) == 0);
// O_NONBLOCK // O_NONBLOCK
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_blocking(s4) == 1); assert(zts_get_blocking(s4) == 1);
// Turn off (non-blocking) // Turn off (non-blocking)
assert(zts_simple_set_blocking(s4, 0) == ZTS_ERR_OK); assert(zts_set_blocking(s4, 0) == ZTS_ERR_OK);
// Should return value instead of error code // Should return value instead of error code
assert(zts_simple_get_blocking(s4) == 0); assert(zts_get_blocking(s4) == 0);
// Turn off // Turn off
assert(zts_simple_set_blocking(s4, 1) == ZTS_ERR_OK); assert(zts_set_blocking(s4, 1) == ZTS_ERR_OK);
assert(zts_simple_get_blocking(s4) == 1); assert(zts_get_blocking(s4) == 1);
// SO_KEEPALIVE // SO_KEEPALIVE
// Check value before doing anything // Check value before doing anything
assert(zts_simple_get_keepalive(s4) == 0); assert(zts_get_keepalive(s4) == 0);
// Turn on // Turn on
assert(zts_simple_set_keepalive(s4, 1) == ZTS_ERR_OK); assert(zts_set_keepalive(s4, 1) == ZTS_ERR_OK);
// Should return value instead of error code // Should return value instead of error code
assert(zts_simple_get_keepalive(s4) == 1); assert(zts_get_keepalive(s4) == 1);
// Turn off // Turn off
assert(zts_simple_set_keepalive(s4, 0) == ZTS_ERR_OK); assert(zts_set_keepalive(s4, 0) == ZTS_ERR_OK);
assert(zts_simple_get_keepalive(s4) == ZTS_ERR_OK); assert(zts_get_keepalive(s4) == ZTS_ERR_OK);
// TODO // TODO
// char peername[ZTS_INET6_ADDRSTRLEN] = { 0 }; // char peername[ZTS_INET6_ADDRSTRLEN] = { 0 };
// int port = 0; // int port = 0;
// int res = zts_simple_getpeername(accfd, peername, ZTS_INET6_ADDRSTRLEN, &port); // int res = zts_getpeername(accfd, peername, ZTS_INET6_ADDRSTRLEN, &port);
// printf("getpeername = %s : %d (%d)\n", peername, port, res); // printf("getpeername = %s : %d (%d)\n", peername, port, res);
// res = zts_simple_getsockname(accfd, peername, ZTS_INET6_ADDRSTRLEN, &port); // res = zts_getsockname(accfd, peername, ZTS_INET6_ADDRSTRLEN, &port);
// printf("getsockname = %s : %d (%d)\n", peername, port, res); // printf("getsockname = %s : %d (%d)\n", peername, port, res);
// Test DNS client functionality // Test DNS client functionality
@@ -1090,7 +1090,7 @@ void test_sockets()
// Test shutting down the service // Test shutting down the service
zts_node_stop(); zts_node_stop();
s4 = zts_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0); s4 = zts_bsd_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0);
assert(s4 == ZTS_ERR_SERVICE); assert(s4 == ZTS_ERR_SERVICE);
} }
@@ -1099,7 +1099,7 @@ void test_sockets()
//----------------------------------------------------------------------------// //----------------------------------------------------------------------------//
#define MAX_CONNECT_TIME 60 // outer re-attempt loop #define MAX_CONNECT_TIME 60 // outer re-attempt loop
#define CONNECT_TIMEOUT 30 // zts_simple_connect, ms #define CONNECT_TIMEOUT 30 // zts_connect, ms
#define BUFLEN 128 #define BUFLEN 128
char* msg = "welcome to the machine"; char* msg = "welcome to the machine";
@@ -1119,13 +1119,13 @@ void test_server_socket_usage(uint16_t port4, uint16_t port6)
// IPv4 test // IPv4 test
DEBUG_INFO("server4: will listen on: 0.0.0.0:%d", port4); DEBUG_INFO("server4: will listen on: 0.0.0.0:%d", port4);
int s4 = zts_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0); int s4 = zts_bsd_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0);
assert(s4 == 0 && zts_errno == 0); assert(s4 == 0 && zts_errno == 0);
err = zts_simple_bind(s4, "0.0.0.0", port4); err = zts_bind(s4, "0.0.0.0", port4);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
err = zts_listen(s4, 1); err = zts_bsd_listen(s4, 1);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
struct zts_sockaddr_in in4; struct zts_sockaddr_in in4;
@@ -1135,7 +1135,7 @@ void test_server_socket_usage(uint16_t port4, uint16_t port6)
clock_gettime(CLOCK_MONOTONIC, &start); clock_gettime(CLOCK_MONOTONIC, &start);
do { do {
DEBUG_INFO("server4: accepting..."); DEBUG_INFO("server4: accepting...");
acc4 = zts_accept(s4, &in4, &addrlen4); acc4 = zts_bsd_accept(s4, &in4, &addrlen4);
zts_util_delay(250); zts_util_delay(250);
clock_gettime(CLOCK_MONOTONIC, &now); clock_gettime(CLOCK_MONOTONIC, &now);
time_diff = (now.tv_sec - start.tv_sec); time_diff = (now.tv_sec - start.tv_sec);
@@ -1146,20 +1146,20 @@ void test_server_socket_usage(uint16_t port4, uint16_t port6)
// Read message // Read message
memset(dstbuf, 0, buflen); memset(dstbuf, 0, buflen);
bytes_read = zts_read(acc4, dstbuf, buflen); bytes_read = zts_bsd_read(acc4, dstbuf, buflen);
DEBUG_INFO("server4: read (%d) bytes", bytes_read); DEBUG_INFO("server4: read (%d) bytes", bytes_read);
assert(bytes_read == msglen && zts_errno == 0); assert(bytes_read == msglen && zts_errno == 0);
// Send message // Send message
bytes_sent = zts_write(acc4, msg, msglen); bytes_sent = zts_bsd_write(acc4, msg, msglen);
DEBUG_INFO("server4: wrote (%d) bytes", bytes_sent); DEBUG_INFO("server4: wrote (%d) bytes", bytes_sent);
assert(bytes_sent == msglen && zts_errno == 0); assert(bytes_sent == msglen && zts_errno == 0);
zts_close(s4); zts_bsd_close(s4);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
zts_close(acc4); zts_bsd_close(acc4);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
assert(bytes_sent == bytes_read); assert(bytes_sent == bytes_read);
@@ -1173,13 +1173,13 @@ void test_server_socket_usage(uint16_t port4, uint16_t port6)
// IPv6 test // IPv6 test
DEBUG_INFO("server6: will listen on: [::]:%d", port6); DEBUG_INFO("server6: will listen on: [::]:%d", port6);
int s6 = zts_socket(ZTS_AF_INET6, ZTS_SOCK_STREAM, 0); int s6 = zts_bsd_socket(ZTS_AF_INET6, ZTS_SOCK_STREAM, 0);
assert(s6 == 0 && zts_errno == 0); assert(s6 == 0 && zts_errno == 0);
err = zts_simple_bind(s6, "::", port6); err = zts_bind(s6, "::", port6);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
err = zts_listen(s6, 1); err = zts_bsd_listen(s6, 1);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
struct zts_sockaddr_in6 in6; struct zts_sockaddr_in6 in6;
@@ -1189,7 +1189,7 @@ void test_server_socket_usage(uint16_t port4, uint16_t port6)
clock_gettime(CLOCK_MONOTONIC, &start); clock_gettime(CLOCK_MONOTONIC, &start);
do { do {
DEBUG_INFO("server6: accepting..."); DEBUG_INFO("server6: accepting...");
acc6 = zts_accept(s6, &in6, &addrlen6); acc6 = zts_bsd_accept(s6, &in6, &addrlen6);
zts_util_delay(250); zts_util_delay(250);
clock_gettime(CLOCK_MONOTONIC, &now); clock_gettime(CLOCK_MONOTONIC, &now);
time_diff = (now.tv_sec - start.tv_sec); time_diff = (now.tv_sec - start.tv_sec);
@@ -1200,24 +1200,24 @@ void test_server_socket_usage(uint16_t port4, uint16_t port6)
// Read message // Read message
memset(dstbuf, 0, buflen); memset(dstbuf, 0, buflen);
bytes_read = zts_read(acc6, dstbuf, buflen); bytes_read = zts_bsd_read(acc6, dstbuf, buflen);
DEBUG_INFO("server6: read (%d) bytes", bytes_read); DEBUG_INFO("server6: read (%d) bytes", bytes_read);
assert(bytes_read == msglen && zts_errno == 0); assert(bytes_read == msglen && zts_errno == 0);
// Send message // Send message
bytes_sent = zts_write(acc6, msg, msglen); bytes_sent = zts_bsd_write(acc6, msg, msglen);
DEBUG_INFO("server6: wrote (%d) bytes", bytes_sent); DEBUG_INFO("server6: wrote (%d) bytes", bytes_sent);
assert(bytes_sent == msglen && zts_errno == 0); assert(bytes_sent == msglen && zts_errno == 0);
zts_close(s6); zts_bsd_close(s6);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
zts_close(acc6); zts_bsd_close(acc6);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
zts_node_stop(); zts_node_stop();
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
int s = zts_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0); int s = zts_bsd_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0);
assert(s == ZTS_ERR_SERVICE); assert(s == ZTS_ERR_SERVICE);
assert(bytes_sent == bytes_read); assert(bytes_sent == bytes_read);
@@ -1249,16 +1249,16 @@ void test_client_socket_usage(char* ip4, uint16_t port4, char* ip6, uint16_t por
// IPv4 test // IPv4 test
err = ZTS_ERR_OK; err = ZTS_ERR_OK;
int s4 = zts_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0); int s4 = zts_bsd_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
zts_simple_set_blocking(s4, 1); zts_set_blocking(s4, 1);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
clock_gettime(CLOCK_MONOTONIC, &start); clock_gettime(CLOCK_MONOTONIC, &start);
do { do {
DEBUG_INFO("client4: connecting to: %s:%d", ip4, port4); DEBUG_INFO("client4: connecting to: %s:%d", ip4, port4);
err = zts_simple_connect(s4, ip4, port4, CONNECT_TIMEOUT); err = zts_connect(s4, ip4, port4, CONNECT_TIMEOUT);
zts_util_delay(500); zts_util_delay(500);
clock_gettime(CLOCK_MONOTONIC, &now); clock_gettime(CLOCK_MONOTONIC, &now);
time_diff = (now.tv_sec - start.tv_sec); time_diff = (now.tv_sec - start.tv_sec);
@@ -1267,19 +1267,19 @@ void test_client_socket_usage(char* ip4, uint16_t port4, char* ip6, uint16_t por
DEBUG_INFO("client4: connected"); DEBUG_INFO("client4: connected");
// Send message // Send message
bytes_sent = zts_write(s4, msg, msglen); bytes_sent = zts_bsd_write(s4, msg, msglen);
DEBUG_INFO("client4: wrote (%d) bytes", bytes_sent); DEBUG_INFO("client4: wrote (%d) bytes", bytes_sent);
assert(bytes_sent == msglen && zts_errno == 0); assert(bytes_sent == msglen && zts_errno == 0);
// Read message // Read message
memset(dstbuf, 0, buflen); memset(dstbuf, 0, buflen);
bytes_read = zts_read(s4, dstbuf, buflen); bytes_read = zts_bsd_read(s4, dstbuf, buflen);
assert(bytes_read == msglen && zts_errno == 0); assert(bytes_read == msglen && zts_errno == 0);
DEBUG_INFO("client4: read (%d) bytes", bytes_read); DEBUG_INFO("client4: read (%d) bytes", bytes_read);
assert(bytes_sent == bytes_read && zts_errno == 0); assert(bytes_sent == bytes_read && zts_errno == 0);
zts_close(s4); zts_bsd_close(s4);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
assert(bytes_sent == bytes_read); assert(bytes_sent == bytes_read);
@@ -1293,16 +1293,16 @@ void test_client_socket_usage(char* ip4, uint16_t port4, char* ip6, uint16_t por
// IPv6 test // IPv6 test
err = ZTS_ERR_OK; err = ZTS_ERR_OK;
int s6 = zts_socket(ZTS_AF_INET6, ZTS_SOCK_STREAM, 0); int s6 = zts_bsd_socket(ZTS_AF_INET6, ZTS_SOCK_STREAM, 0);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
zts_simple_set_blocking(s6, 1); zts_set_blocking(s6, 1);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
clock_gettime(CLOCK_MONOTONIC, &start); clock_gettime(CLOCK_MONOTONIC, &start);
do { do {
DEBUG_INFO("client6: connecting to: %s:%d", ip6, port6); DEBUG_INFO("client6: connecting to: %s:%d", ip6, port6);
err = zts_simple_connect(s6, ip6, port6, CONNECT_TIMEOUT); err = zts_connect(s6, ip6, port6, CONNECT_TIMEOUT);
zts_util_delay(500); zts_util_delay(500);
clock_gettime(CLOCK_MONOTONIC, &now); clock_gettime(CLOCK_MONOTONIC, &now);
time_diff = (now.tv_sec - start.tv_sec); time_diff = (now.tv_sec - start.tv_sec);
@@ -1311,24 +1311,24 @@ void test_client_socket_usage(char* ip4, uint16_t port4, char* ip6, uint16_t por
DEBUG_INFO("client6: connected"); DEBUG_INFO("client6: connected");
// Send message // Send message
bytes_sent = zts_write(s6, msg, msglen); bytes_sent = zts_bsd_write(s6, msg, msglen);
DEBUG_INFO("client6: wrote (%d) bytes", bytes_sent); DEBUG_INFO("client6: wrote (%d) bytes", bytes_sent);
assert(bytes_sent == msglen && zts_errno == 0); assert(bytes_sent == msglen && zts_errno == 0);
// Read message // Read message
memset(dstbuf, 0, buflen); memset(dstbuf, 0, buflen);
bytes_read = zts_read(s6, dstbuf, buflen); bytes_read = zts_bsd_read(s6, dstbuf, buflen);
assert(bytes_read == msglen && zts_errno == 0); assert(bytes_read == msglen && zts_errno == 0);
DEBUG_INFO("client6: read (%d) bytes", bytes_read); DEBUG_INFO("client6: read (%d) bytes", bytes_read);
assert(bytes_sent == bytes_read && zts_errno == 0); assert(bytes_sent == bytes_read && zts_errno == 0);
zts_close(s6); zts_bsd_close(s6);
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
zts_node_stop(); zts_node_stop();
assert(err == ZTS_ERR_OK && zts_errno == 0); assert(err == ZTS_ERR_OK && zts_errno == 0);
int s = zts_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0); int s = zts_bsd_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0);
assert(s == ZTS_ERR_SERVICE); assert(s == ZTS_ERR_SERVICE);
assert(bytes_sent == bytes_read); assert(bytes_sent == bytes_read);