luo980/libuv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

include: uv_ip[46]_addr now takes sockaddr_in*

Browse Source 
Passing or returning structs as values makes life hard for people that
work with libuv through a foreign function interface. Switch to a
pointer-based approach.

Fixes #684.
This commit is contained in:
Ben Noordhuis 2013-08-31 03:00:34 +02:00
parent b7d027c3a8
commit 8184076879
44 changed files with 210 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/uv.h
View File

@ -1878,8 +1878,8 @@ UV_EXTERN int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle,
/* Utility */
/* Convert string ip addresses to binary structures */
UV_EXTERN struct sockaddr_in uv_ip4_addr(const char* ip, int port);
UV_EXTERN struct sockaddr_in6 uv_ip6_addr(const char* ip, int port);
UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr);
UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr);
/* Convert binary addresses to strings */
UV_EXTERN int uv_ip4_name(struct sockaddr_in* src, char* dst, size_t size);

37
src/uv-common.c
View File

@ -125,31 +125,26 @@ const char* uv_strerror(int err) {
#undef UV_STRERROR_GEN
struct sockaddr_in uv_ip4_addr(const char* ip, int port) {
struct sockaddr_in addr;
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip);
return addr;
int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr) {
memset(addr, 0, sizeof(*addr));
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
/* TODO(bnoordhuis) Don't use inet_addr(), no good way to detect errors. */
addr->sin_addr.s_addr = inet_addr(ip);
return 0;
}
struct sockaddr_in6 uv_ip6_addr(const char* ip, int port) {
struct sockaddr_in6 addr;
int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) {
#if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
char address_part[40];
size_t address_part_size;
const char* zone_index;
#endif
memset(&addr, 0, sizeof(struct sockaddr_in6));
addr.sin6_family = AF_INET6;
addr.sin6_port = htons(port);
memset(addr, 0, sizeof(*addr));
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(port);
#if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
zone_index = strchr(ip, '%');
@ -165,17 +160,17 @@ struct sockaddr_in6 uv_ip6_addr(const char* ip, int port) {
zone_index++; /* skip '%' */
/* NOTE: unknown interface (id=0) is silently ignored */
#ifdef _WIN32
addr.sin6_scope_id = atoi(zone_index);
addr->sin6_scope_id = atoi(zone_index);
#else
addr.sin6_scope_id = if_nametoindex(zone_index);
addr->sin6_scope_id = if_nametoindex(zone_index);
#endif
}
#endif
/* result code is ignored - we assume ip is a valid IPv6 address */
uv_inet_pton(AF_INET6, ip, &addr.sin6_addr);
/* TODO(bnoordhuis) Return an error when the address is bad. */
uv_inet_pton(AF_INET6, ip, &addr->sin6_addr);
return addr;
return 0;
}

10
src/win/winsock.c
View File

@ -20,6 +20,7 @@
*/
#include <assert.h>
#include <stdlib.h>
#include "uv.h"
#include "internal.h"
@ -92,8 +93,13 @@ void uv_winsock_init() {
}
/* Set implicit binding address used by connectEx */
uv_addr_ip4_any_ = uv_ip4_addr("0.0.0.0", 0);
uv_addr_ip6_any_ = uv_ip6_addr("::", 0);
if (uv_ip4_addr("0.0.0.0", 0, &uv_addr_ip4_any_)) {
abort();
}
if (uv_ip6_addr("::", 0, &uv_addr_ip6_any_)) {
abort();
}
/* Detect non-IFS LSPs */
dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

2
test/benchmark-multi-accept.c
View File

@ -359,7 +359,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
unsigned int i;
double time;
listen_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &listen_addr));
loop = uv_default_loop();
servers = calloc(num_servers, sizeof(servers[0]));

10
test/benchmark-ping-pongs.c
View File

@ -174,12 +174,14 @@ static void pinger_connect_cb(uv_connect_t* req, int status) {
static void pinger_new(void) {
int r;
struct sockaddr_in client_addr = uv_ip4_addr("0.0.0.0", 0);
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in client_addr;
struct sockaddr_in server_addr;
pinger_t *pinger;
int r;
pinger = (pinger_t*)malloc(sizeof(*pinger));
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;

2
test/benchmark-pound.c
View File

@ -199,7 +199,7 @@ static void tcp_make_connect(conn_rec* p) {
r = uv_tcp_init(loop, (uv_tcp_t*)&p->stream);
ASSERT(r == 0);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&((tcp_conn_rec*)p)->conn_req, (uv_tcp_t*)&p->stream, addr, connect_cb);
if (r) {

4
test/benchmark-pump.c
View File

@ -360,7 +360,7 @@ HELPER_IMPL(tcp_pump_server) {
type = TCP;
loop = uv_default_loop();
listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &listen_addr));
/* Server */
server = (uv_stream_t*)&tcpServer;
@ -406,7 +406,7 @@ static void tcp_pump(int n) {
loop = uv_default_loop();
connect_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr));
/* Start making connections */
maybe_connect_some();

2
test/benchmark-tcp-write-batch.c
View File

@ -112,7 +112,7 @@ BENCHMARK_IMPL(tcp_write_batch) {
}
loop = uv_default_loop();
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(loop, &tcp_client);
ASSERT(r == 0);

7
test/benchmark-udp-pummel.c
View File

@ -171,7 +171,8 @@ static int pummel(unsigned int n_senders,
for (i = 0; i < n_receivers; i++) {
struct receiver_state* s = receivers + i;
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", BASE_PORT + i);
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr));
ASSERT(0 == uv_udp_init(loop, &s->udp_handle));
ASSERT(0 == uv_udp_bind(&s->udp_handle, addr, 0));
ASSERT(0 == uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb));
@ -186,7 +187,9 @@ static int pummel(unsigned int n_senders,
for (i = 0; i < n_senders; i++) {
struct sender_state* s = senders + i;
s->addr = uv_ip4_addr("127.0.0.1", BASE_PORT + (i % n_receivers));
ASSERT(0 == uv_ip4_addr("127.0.0.1",
BASE_PORT + (i % n_receivers),
&s->addr));
ASSERT(0 == uv_udp_init(loop, &s->udp_handle));
ASSERT(0 == uv_udp_send(&s->send_req,
&s->udp_handle,

2
test/blackhole-server.c
View File

@ -103,7 +103,7 @@ HELPER_IMPL(tcp4_blackhole_server) {
int r;
loop = uv_default_loop();
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(loop, &tcp_server);
ASSERT(r == 0);

4
test/dns-server.c
View File

@ -293,9 +293,11 @@ static void on_connection(uv_stream_t* server, int status) {
static int dns_start(int port) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", port, &addr));
r = uv_tcp_init(loop, &server);
if (r) {
/* TODO: Error codes */

8
test/echo-server.c
View File

@ -214,9 +214,11 @@ static void on_send(uv_udp_send_t* req, int status) {
static int tcp4_echo_start(int port) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", port, &addr));
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
@ -246,9 +248,11 @@ static int tcp4_echo_start(int port) {
static int tcp6_echo_start(int port) {
struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port);
struct sockaddr_in6 addr6;
int r;
ASSERT(0 == uv_ip6_addr("::1", port, &addr6));
server = (uv_handle_t*)&tcpServer;
serverType = TCP;

4
test/test-callback-stack.c
View File

@ -171,7 +171,9 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(callback_stack) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
if (uv_tcp_init(uv_default_loop(), &client)) {
FATAL("uv_tcp_init failed");

4
test/test-connection-fail.c
View File

@ -90,10 +90,10 @@ static void connection_fail(uv_connect_cb connect_cb) {
struct sockaddr_in client_addr, server_addr;
int r;
client_addr = uv_ip4_addr("0.0.0.0", 0);
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));
/* There should be no servers listening on this port. */
server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
/* Try to connect to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(uv_default_loop(), &tcp);

6
test/test-delayed-accept.c
View File

@ -99,10 +99,11 @@ static void connection_cb(uv_stream_t* tcp, int status) {
static void start_server(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t* server = (uv_tcp_t*)malloc(sizeof *server);
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT(server != NULL);
r = uv_tcp_init(uv_default_loop(), server);
@ -150,11 +151,12 @@ static void connect_cb(uv_connect_t* req, int status) {
static void client_connect(void) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t* client = (uv_tcp_t*)malloc(sizeof *client);
uv_connect_t* connect_req = malloc(sizeof *connect_req);
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(client != NULL);
ASSERT(connect_req != NULL);

18
test/test-getsockname.c
View File

@ -79,10 +79,12 @@ static void after_read(uv_stream_t* handle,
static void check_sockname(struct sockaddr* addr, const char* compare_ip,
int compare_port, const char* context) {
struct sockaddr_in check_addr = *(struct sockaddr_in*) addr;
struct sockaddr_in compare_addr = uv_ip4_addr(compare_ip, compare_port);
struct sockaddr_in compare_addr;
char check_ip[17];
int r;
ASSERT(0 == uv_ip4_addr(compare_ip, compare_port, &compare_addr));
/* Both addresses should be ipv4 */
ASSERT(check_addr.sin_family == AF_INET);
ASSERT(compare_addr.sin_family == AF_INET);
@ -165,11 +167,13 @@ static void on_connect(uv_connect_t* req, int status) {
static int tcp_listener(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
struct sockaddr_in addr;
struct sockaddr sockname, peername;
int namelen;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
r = uv_tcp_init(loop, &tcpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
@ -205,10 +209,12 @@ static int tcp_listener(void) {
static void tcp_connector(void) {
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", server_port);
struct sockaddr_in server_addr;
struct sockaddr sockname;
int r, namelen;
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
r = uv_tcp_init(loop, &tcp);
tcp.data = &connect_req;
ASSERT(!r);
@ -260,11 +266,13 @@ static void udp_send(uv_udp_send_t* req, int status) {
static int udp_listener(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
struct sockaddr_in addr;
struct sockaddr sockname;
int namelen;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
r = uv_udp_init(loop, &udpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
@ -300,7 +308,7 @@ static void udp_sender(void) {
ASSERT(!r);
buf = uv_buf_init("PING", 4);
server_addr = uv_ip4_addr("127.0.0.1", server_port);
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
r = uv_udp_send(&send_req, &udp, &buf, 1, server_addr, udp_send);
ASSERT(!r);

2
test/test-ip6-addr.c
View File

@ -84,7 +84,7 @@ TEST_IMPL(ip6_addr_link_local) {
iface_index,
device_name);
addr = uv_ip6_addr(scoped_addr, TEST_PORT);
ASSERT(0 == uv_ip6_addr(scoped_addr, TEST_PORT, &addr));
LOGF("Got scope_id 0x%02x\n", addr.sin6_scope_id);
ASSERT(iface_index == addr.sin6_scope_id);
}

5
test/test-ipc-send-recv.c
View File

@ -135,14 +135,17 @@ TEST_IMPL(ipc_send_recv_pipe) {
TEST_IMPL(ipc_send_recv_tcp) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ctx.expected_type = UV_TCP;
r = uv_tcp_init(uv_default_loop(), &ctx.send.tcp);
ASSERT(r == 0);
r = uv_tcp_bind(&ctx.send.tcp, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(&ctx.send.tcp, addr);
ASSERT(r == 0);
r = run_test();

33
test/test-ipc.c
View File

@ -125,9 +125,12 @@ static void make_many_connections(void) {
r = uv_tcp_init(uv_default_loop(), &conn->conn);
ASSERT(r == 0);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&conn->conn_req, (uv_tcp_t*)&conn->conn, addr, connect_cb);
r = uv_tcp_connect(&conn->conn_req,
(uv_tcp_t*) &conn->conn,
addr,
connect_cb);
ASSERT(r == 0);
conn->conn.data = conn;
@ -365,7 +368,9 @@ TEST_IMPL(ipc_tcp_connection) {
TEST_IMPL(listen_with_simultaneous_accepts) {
uv_tcp_t server;
int r;
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@ -388,7 +393,9 @@ TEST_IMPL(listen_with_simultaneous_accepts) {
TEST_IMPL(listen_no_simultaneous_accepts) {
uv_tcp_t server;
int r;
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@ -540,11 +547,13 @@ int ipc_helper(int listen_after_write) {
* This is launched from test-ipc.c. stdin is a duplex channel that we
* over which a handle will be transmitted.
*/
struct sockaddr_in addr;
uv_write_t write_req;
int r;
uv_buf_t buf;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_pipe_init(uv_default_loop(), &channel, 1);
ASSERT(r == 0);
@ -557,7 +566,7 @@ int ipc_helper(int listen_after_write) {
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);
r = uv_tcp_bind(&tcp_server, uv_ip4_addr("0.0.0.0", TEST_PORT));
r = uv_tcp_bind(&tcp_server, addr);
ASSERT(r == 0);
if (!listen_after_write) {
@ -607,7 +616,9 @@ int ipc_helper_tcp_connection(void) {
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);
r = uv_tcp_bind(&tcp_server, uv_ip4_addr("0.0.0.0", TEST_PORT));
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_bind(&tcp_server, addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection_tcp_conn);
@ -617,8 +628,12 @@ int ipc_helper_tcp_connection(void) {
r = uv_tcp_init(uv_default_loop(), &conn.conn);
ASSERT(r == 0);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
r = uv_tcp_connect(&conn.conn_req, (uv_tcp_t*)&conn.conn, addr, connect_child_process_cb);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&conn.conn_req,
(uv_tcp_t*) &conn.conn,
addr,
connect_child_process_cb);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);

7
test/test-multiple-listen.c
View File

@ -45,9 +45,11 @@ static void connection_cb(uv_stream_t* tcp, int status) {
static void start_server(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@ -72,10 +74,11 @@ static void connect_cb(uv_connect_t* req, int status) {
static void client_connect(void) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_connect_t* connect_req = malloc(sizeof *connect_req);
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(connect_req != NULL);
r = uv_tcp_init(uv_default_loop(), &client);

10
test/test-ping-pong.c
View File

@ -148,10 +148,11 @@ static void pinger_on_connect(uv_connect_t *req, int status) {
/* same ping-pong test, but using IPv6 connection */
static void tcp_pinger_v6_new(void) {
int r;
struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);
struct sockaddr_in6 server_addr;
pinger_t *pinger;
pinger = (pinger_t*)malloc(sizeof(*pinger));
ASSERT(0 ==uv_ip6_addr("::1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;
@ -173,10 +174,11 @@ static void tcp_pinger_v6_new(void) {
static void tcp_pinger_new(void) {
int r;
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in server_addr;
pinger_t *pinger;
pinger = (pinger_t*)malloc(sizeof(*pinger));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;

14
test/test-poll.c
View File

@ -496,11 +496,13 @@ static void server_poll_cb(uv_poll_t* handle, int status, int events) {
static void start_server(void) {
uv_os_sock_t sock;
server_context_t* context;
struct sockaddr_in addr;
uv_os_sock_t sock;
int r;
sock = create_nonblocking_bound_socket(uv_ip4_addr("127.0.0.1", TEST_PORT));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
sock = create_nonblocking_bound_socket(addr);
context = create_server_context(sock);
r = listen(sock, 100);
@ -514,10 +516,14 @@ static void start_server(void) {
static void start_client(void) {
uv_os_sock_t sock;
connection_context_t* context;
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in server_addr;
struct sockaddr_in addr;
int r;
sock = create_nonblocking_bound_socket(uv_ip4_addr("0.0.0.0", 0));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr));
sock = create_nonblocking_bound_socket(addr);
context = create_connection_context(sock, 0);
context->events = UV_READABLE | UV_WRITABLE;

12
test/test-ref.c
View File

@ -254,8 +254,9 @@ TEST_IMPL(tcp_ref2b) {
TEST_IMPL(tcp_ref3) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_tcp_init(uv_default_loop(), &h);
uv_tcp_connect(&connect_req, &h, addr, connect_and_shutdown);
uv_unref((uv_handle_t*)&h);
@ -269,8 +270,9 @@ TEST_IMPL(tcp_ref3) {
TEST_IMPL(tcp_ref4) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_tcp_init(uv_default_loop(), &h);
uv_tcp_connect(&connect_req, &h, addr, connect_and_write);
uv_unref((uv_handle_t*)&h);
@ -296,8 +298,9 @@ TEST_IMPL(udp_ref) {
TEST_IMPL(udp_ref2) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_udp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_udp_init(uv_default_loop(), &h);
uv_udp_bind(&h, addr, 0);
uv_udp_recv_start(&h, (uv_alloc_cb)fail_cb, (uv_udp_recv_cb)fail_cb);
@ -310,11 +313,12 @@ TEST_IMPL(udp_ref2) {
TEST_IMPL(udp_ref3) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_buf_t buf = uv_buf_init("PING", 4);
uv_udp_send_t req;
uv_udp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_udp_init(uv_default_loop(), &h);
uv_udp_send(&req, &h, &buf, 1, addr, (uv_udp_send_cb)req_cb);
uv_unref((uv_handle_t*)&h);

3
test/test-shutdown-close.c
View File

@ -65,10 +65,11 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(shutdown_close_tcp) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &h);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &h, addr, connect_cb);

2
test/test-shutdown-eof.c
View File

@ -156,7 +156,7 @@ TEST_IMPL(shutdown_eof) {
uv_timer_start(&timer, timer_cb, 100, 0);
server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(!r);

23
test/test-tcp-bind-error.c
View File

@ -35,10 +35,11 @@ static void close_cb(uv_handle_t* handle) {
TEST_IMPL(tcp_bind_error_addrinuse) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server1, server2;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind(&server1, addr);
@ -67,10 +68,12 @@ TEST_IMPL(tcp_bind_error_addrinuse) {
TEST_IMPL(tcp_bind_error_addrnotavail_1) {
struct sockaddr_in addr = uv_ip4_addr("127.255.255.255", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("127.255.255.255", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@ -90,10 +93,12 @@ TEST_IMPL(tcp_bind_error_addrnotavail_1) {
TEST_IMPL(tcp_bind_error_addrnotavail_2) {
struct sockaddr_in addr = uv_ip4_addr("4.4.4.4", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("4.4.4.4", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
@ -136,11 +141,14 @@ TEST_IMPL(tcp_bind_error_fault) {
/* Notes: On Linux uv_bind(server, NULL) will segfault the program. */
TEST_IMPL(tcp_bind_error_inval) {
struct sockaddr_in addr1 = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr2 = uv_ip4_addr("0.0.0.0", TEST_PORT_2);
struct sockaddr_in addr1;
struct sockaddr_in addr2;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr1));
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT_2, &addr2));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr1);
@ -160,11 +168,12 @@ TEST_IMPL(tcp_bind_error_inval) {
TEST_IMPL(tcp_bind_localhost_ok) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);

20
test/test-tcp-bind6-error.c
View File

@ -35,10 +35,12 @@ static void close_cb(uv_handle_t* handle) {
TEST_IMPL(tcp_bind6_error_addrinuse) {
struct sockaddr_in6 addr = uv_ip6_addr("::", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server1, server2;
int r;
ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind6(&server1, addr);
@ -67,10 +69,12 @@ TEST_IMPL(tcp_bind6_error_addrinuse) {
TEST_IMPL(tcp_bind6_error_addrnotavail) {
struct sockaddr_in6 addr = uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);
@ -113,11 +117,14 @@ TEST_IMPL(tcp_bind6_error_fault) {
/* Notes: On Linux uv_bind6(server, NULL) will segfault the program. */
TEST_IMPL(tcp_bind6_error_inval) {
struct sockaddr_in6 addr1 = uv_ip6_addr("::", TEST_PORT);
struct sockaddr_in6 addr2 = uv_ip6_addr("::", TEST_PORT_2);
struct sockaddr_in6 addr1;
struct sockaddr_in6 addr2;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr1));
ASSERT(0 == uv_ip6_addr("::", TEST_PORT_2, &addr2));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr1);
@ -137,11 +144,12 @@ TEST_IMPL(tcp_bind6_error_inval) {
TEST_IMPL(tcp_bind6_localhost_ok) {
struct sockaddr_in6 addr = uv_ip6_addr("::1", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip6_addr("::1", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);

3
test/test-tcp-close-while-connecting.c
View File

@ -60,9 +60,8 @@ TEST_IMPL(tcp_close_while_connecting) {
struct sockaddr_in addr;
uv_loop_t* loop;
addr = uv_ip4_addr("1.2.3.4", TEST_PORT);
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("1.2.3.4", TEST_PORT, &addr));
ASSERT(0 == uv_tcp_init(loop, &tcp_handle));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));
ASSERT(0 == uv_timer_init(loop, &timer1_handle));

15
test/test-tcp-close.c
View File

@ -77,12 +77,15 @@ static void connection_cb(uv_stream_t* server, int status) {
static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(loop, handle);
ASSERT(r == 0);
r = uv_tcp_bind(handle, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(handle, addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)handle, 128, connection_cb);
@ -96,10 +99,13 @@ static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
* invoked when the handle is closed.
*/
TEST_IMPL(tcp_close) {
uv_loop_t* loop;
struct sockaddr_in addr;
uv_tcp_t tcp_server;
uv_loop_t* loop;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
/* We can't use the echo server, it doesn't handle ECONNRESET. */
@ -108,10 +114,7 @@ TEST_IMPL(tcp_close) {
r = uv_tcp_init(loop, &tcp_handle);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req,
&tcp_handle,
uv_ip4_addr("127.0.0.1", TEST_PORT),
connect_cb);
r = uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb);
ASSERT(r == 0);
ASSERT(write_cb_called == 0);

2
test/test-tcp-connect-error-after-write.c
View File

@ -68,7 +68,7 @@ TEST_IMPL(tcp_connect_error_after_write) {
return 0; /* windows slackers... */
#endif
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
buf = uv_buf_init("TEST", 4);
r = uv_tcp_init(uv_default_loop(), &conn);

2
test/test-tcp-connect-timeout.c
View File

@ -64,7 +64,7 @@ TEST_IMPL(tcp_connect_timeout) {
struct sockaddr_in addr;
int r;
addr = uv_ip4_addr("8.8.8.8", 9999);
ASSERT(0 == uv_ip4_addr("8.8.8.8", 9999, &addr));
r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);

4
test/test-tcp-open.c
View File

@ -148,11 +148,13 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(tcp_open) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t client;
uv_os_sock_t sock;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
startup();
sock = create_tcp_socket();

2
test/test-tcp-read-stop.c
View File

@ -62,7 +62,7 @@ TEST_IMPL(tcp_read_stop) {
uv_connect_t connect_req;
struct sockaddr_in addr;
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle));
ASSERT(0 == uv_tcp_init(uv_default_loop(), &tcp_handle));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));

2
test/test-tcp-shutdown-after-write.c
View File

@ -106,7 +106,7 @@ TEST_IMPL(tcp_shutdown_after_write) {
uv_loop_t* loop;
int r;
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
r = uv_timer_init(loop, &timer);

2
test/test-tcp-unexpected-read.c
View File

@ -88,7 +88,7 @@ TEST_IMPL(tcp_unexpected_read) {
struct sockaddr_in addr;
uv_loop_t* loop;
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
ASSERT(0 == uv_timer_init(loop, &timer_handle));

10
test/test-tcp-write-to-half-open-connection.c
View File

@ -103,16 +103,19 @@ static void write_cb(uv_write_t* req, int status) {
TEST_IMPL(tcp_write_to_half_open_connection) {
struct sockaddr_in addr;
uv_loop_t* loop;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
ASSERT(loop != NULL);
r = uv_tcp_init(loop, &tcp_server);
ASSERT(r == 0);
r = uv_tcp_bind(&tcp_server, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(&tcp_server, addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&tcp_server, 1, connection_cb);
@ -121,10 +124,7 @@ TEST_IMPL(tcp_write_to_half_open_connection) {
r = uv_tcp_init(loop, &tcp_client);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req,
&tcp_client,
uv_ip4_addr("127.0.0.1", TEST_PORT),
connect_cb);
r = uv_tcp_connect(&connect_req, &tcp_client, addr, connect_cb);
ASSERT(r == 0);
r = uv_run(loop, UV_RUN_DEFAULT);

4
test/test-tcp-writealot.c
View File

@ -141,10 +141,12 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(tcp_writealot) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t client;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
send_buffer = calloc(1, TOTAL_BYTES);
ASSERT(send_buffer != NULL);

2
test/test-udp-dgram-too-big.c
View File

@ -68,7 +68,7 @@ TEST_IMPL(udp_dgram_too_big) {
ASSERT(r == 0);
buf = uv_buf_init(dgram, sizeof dgram);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_udp_send(&req_, &handle_, &buf, 1, addr, send_cb);
ASSERT(r == 0);

4
test/test-udp-ipv6.c
View File

@ -103,7 +103,7 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
uv_buf_t buf;
int r;
addr6 = uv_ip6_addr("::0", TEST_PORT);
ASSERT(0 == uv_ip6_addr("::0", TEST_PORT, &addr6));
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@ -118,7 +118,7 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
ASSERT(r == 0);
buf = uv_buf_init("PING", 4);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_udp_send(&req_, &client, &buf, 1, addr, send_cb);
ASSERT(r == 0);

4
test/test-udp-multicast-join.c
View File

@ -100,7 +100,9 @@ TEST_IMPL(udp_multicast_join) {
int r;
uv_udp_send_t req;
uv_buf_t buf;
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);

6
test/test-udp-multicast-ttl.c
View File

@ -57,12 +57,13 @@ TEST_IMPL(udp_multicast_ttl) {
int r;
uv_udp_send_t req;
uv_buf_t buf;
struct sockaddr_in addr = uv_ip4_addr("239.255.0.1", TEST_PORT);
struct sockaddr_in addr;
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_udp_bind(&server, uv_ip4_addr("0.0.0.0", 0), 0);
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr));
r = uv_udp_bind(&server, addr, 0);
ASSERT(r == 0);
r = uv_udp_set_multicast_ttl(&server, 32);
@ -70,6 +71,7 @@ TEST_IMPL(udp_multicast_ttl) {
/* server sends "PING" */
buf = uv_buf_init("PING", 4);
ASSERT(0 == uv_ip4_addr("239.255.0.1", TEST_PORT, &addr));
r = uv_udp_send(&req, &server, &buf, 1, addr, sv_send_cb);
ASSERT(r == 0);

4
test/test-udp-open.c
View File

@ -123,12 +123,14 @@ static void send_cb(uv_udp_send_t* req, int status) {
TEST_IMPL(udp_open) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_buf_t buf = uv_buf_init("PING", 4);
uv_udp_t client;
uv_os_sock_t sock;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
startup();
sock = create_udp_socket();

5
test/test-udp-options.c
View File

@ -29,10 +29,13 @@
TEST_IMPL(udp_options) {
static int invalid_ttls[] = { -1, 0, 256 };
struct sockaddr_in addr;
uv_loop_t* loop;
uv_udp_t h;
int i, r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
loop = uv_default_loop();
r = uv_udp_init(loop, &h);
@ -40,7 +43,7 @@ TEST_IMPL(udp_options) {
uv_unref((uv_handle_t*)&h); /* don't keep the loop alive */
r = uv_udp_bind(&h, uv_ip4_addr("0.0.0.0", TEST_PORT), 0);
r = uv_udp_bind(&h, addr, 0);
ASSERT(r == 0);
r = uv_udp_set_broadcast(&h, 1);

4
test/test-udp-send-and-recv.c
View File

@ -170,7 +170,7 @@ TEST_IMPL(udp_send_and_recv) {
uv_buf_t buf;
int r;
addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@ -181,7 +181,7 @@ TEST_IMPL(udp_send_and_recv) {
r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb);
ASSERT(r == 0);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_udp_init(uv_default_loop(), &client);
ASSERT(r == 0);