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

include: merge uv_tcp_connect and uv_tcp_connect6

Browse Source 
Merge uv_tcp_connect6() into uv_tcp_connect().  uv_tcp_connect() now
takes a const struct sockaddr*.
This commit is contained in:
Ben Noordhuis 2013-09-03 23:12:07 +02:00
parent 5fceccc535
commit 5c675c4a4e
29 changed files with 125 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/uv.h
View File

@ -778,21 +778,18 @@ UV_EXTERN int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
int* namelen);
/*
* uv_tcp_connect, uv_tcp_connect6
* These functions establish IPv4 and IPv6 TCP connections. Provide an
* initialized TCP handle and an uninitialized uv_connect_t*. The callback
* will be made when the connection is established.
* Establish an IPv4 or IPv6 TCP connection. Provide an initialized TCP handle
* and an uninitialized uv_connect_t*. `addr` should point to an initialized
* struct sockaddr_in or struct sockaddr_in6.
*
* The callback is made when the connection has been established or when a
* connection error happened.
*/
UV_EXTERN int uv_tcp_connect(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr_in* addr,
const struct sockaddr* addr,
uv_connect_cb cb);
UV_EXTERN int uv_tcp_connect6(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr_in6* addr,
uv_connect_cb cb);
/* uv_connect_t is a subclass of uv_req_t */
struct uv_connect_s {
UV_REQ_FIELDS

34
src/uv-common.c
View File

@ -236,31 +236,21 @@ int uv_udp_bind6(uv_udp_t* handle,
int uv_tcp_connect(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr_in* addr,
const struct sockaddr* addr,
uv_connect_cb cb) {
if (handle->type == UV_TCP && addr->sin_family == AF_INET) {
return uv__tcp_connect(req,
handle,
(const struct sockaddr*) addr,
sizeof(*addr),
cb);
}
return UV_EINVAL;
}
unsigned int addrlen;
if (handle->type != UV_TCP)
return UV_EINVAL;
int uv_tcp_connect6(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr_in6* addr,
uv_connect_cb cb) {
if (handle->type == UV_TCP && addr->sin6_family == AF_INET6) {
return uv__tcp_connect(req,
handle,
(const struct sockaddr*) addr,
sizeof(*addr),
cb);
}
return UV_EINVAL;
if (addr->sa_family == AF_INET)
addrlen = sizeof(struct sockaddr_in);
else if (addr->sa_family == AF_INET6)
addrlen = sizeof(struct sockaddr_in6);
else
return UV_EINVAL;
return uv__tcp_connect(req, handle, addr, addrlen, cb);
}

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

@ -347,7 +347,7 @@ static void cl_close_cb(uv_handle_t* handle) {
ASSERT(0 == uv_tcp_init(handle->loop, (uv_tcp_t*) &ctx->client_handle));
ASSERT(0 == uv_tcp_connect(&ctx->connect_req,
(uv_tcp_t*) &ctx->client_handle,
&listen_addr,
(const struct sockaddr*) &listen_addr,
cl_connect_cb));
}
@ -388,7 +388,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
ASSERT(0 == uv_tcp_init(loop, handle));
ASSERT(0 == uv_tcp_connect(&ctx->connect_req,
handle,
&listen_addr,
(const struct sockaddr*) &listen_addr,
cl_connect_cb));
ASSERT(0 == uv_idle_init(loop, &ctx->idle_handle));
}

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

@ -195,7 +195,7 @@ static void pinger_new(void) {
r = uv_tcp_connect(&pinger->connect_req,
&pinger->tcp,
&server_addr,
(const struct sockaddr*) &server_addr,
pinger_connect_cb);
ASSERT(!r);
}

5
test/benchmark-pound.c
View File

@ -204,7 +204,10 @@ static void tcp_make_connect(conn_rec* p) {
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&tp->conn_req, (uv_tcp_t*) &p->stream, &addr, connect_cb);
r = uv_tcp_connect(&tp->conn_req,
(uv_tcp_t*) &p->stream,
(const struct sockaddr*) &addr,
connect_cb);
if (r) {
fprintf(stderr, "uv_tcp_connect error %s\n", uv_err_name(r));
ASSERT(0);

5
test/benchmark-pump.c
View File

@ -240,7 +240,10 @@ static void maybe_connect_some(void) {
ASSERT(r == 0);
req = (uv_connect_t*) req_alloc();
r = uv_tcp_connect(req, tcp, &connect_addr, connect_cb);
r = uv_tcp_connect(req,
tcp,
(const struct sockaddr*) &connect_addr,
connect_cb);
ASSERT(r == 0);
} else {
pipe = &pipe_write_handles[max_connect_socket++];

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

@ -117,7 +117,10 @@ BENCHMARK_IMPL(tcp_write_batch) {
r = uv_tcp_init(loop, &tcp_client);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &tcp_client, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&tcp_client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
start = uv_hrtime();

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

@ -183,7 +183,10 @@ TEST_IMPL(callback_stack) {
nested++;
if (uv_tcp_connect(&connect_req, &client, &addr, connect_cb)) {
if (uv_tcp_connect(&connect_req,
&client,
(const struct sockaddr*) &addr,
connect_cb)) {
FATAL("uv_tcp_connect failed");
}
nested--;

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

@ -103,7 +103,10 @@ static void connection_fail(uv_connect_cb connect_cb) {
/* so these handles can be pre-initialized. */
ASSERT(0 == uv_tcp_bind(&tcp, (const struct sockaddr*) &client_addr));
r = uv_tcp_connect(&req, &tcp, &server_addr, connect_cb);
r = uv_tcp_connect(&req,
&tcp,
(const struct sockaddr*) &server_addr,
connect_cb);
ASSERT(!r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

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

@ -163,7 +163,10 @@ static void client_connect(void) {
r = uv_tcp_init(uv_default_loop(), client);
ASSERT(r == 0);
r = uv_tcp_connect(connect_req, client, &addr, connect_cb);
r = uv_tcp_connect(connect_req,
client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
}

5
test/test-getsockname.c
View File

@ -219,7 +219,10 @@ static void tcp_connector(void) {
tcp.data = &connect_req;
ASSERT(!r);
r = uv_tcp_connect(&connect_req, &tcp, &server_addr, on_connect);
r = uv_tcp_connect(&connect_req,
&tcp,
(const struct sockaddr*) &server_addr,
on_connect);
ASSERT(!r);
/* Fetch the actual port used by the connecting socket. */

4
test/test-ipc.c
View File

@ -129,7 +129,7 @@ static void make_many_connections(void) {
r = uv_tcp_connect(&conn->conn_req,
(uv_tcp_t*) &conn->conn,
&addr,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
@ -632,7 +632,7 @@ int ipc_helper_tcp_connection(void) {
r = uv_tcp_connect(&conn.conn_req,
(uv_tcp_t*) &conn.conn,
&addr,
(const struct sockaddr*) &addr,
connect_child_process_cb);
ASSERT(r == 0);

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

@ -84,7 +84,10 @@ static void client_connect(void) {
r = uv_tcp_init(uv_default_loop(), &client);
ASSERT(r == 0);
r = uv_tcp_connect(connect_req, &client, &addr, connect_cb);
r = uv_tcp_connect(connect_req,
&client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
}

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

@ -163,10 +163,10 @@ static void tcp_pinger_v6_new(void) {
/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
r = uv_tcp_connect6(&pinger->connect_req,
&pinger->stream.tcp,
&server_addr,
pinger_on_connect);
r = uv_tcp_connect(&pinger->connect_req,
&pinger->stream.tcp,
(const struct sockaddr*) &server_addr,
pinger_on_connect);
ASSERT(!r);
/* Synchronous connect callbacks are not allowed. */
@ -193,7 +193,7 @@ static void tcp_pinger_new(void) {
/* so these handles can be pre-initialized. */
r = uv_tcp_connect(&pinger->connect_req,
&pinger->stream.tcp,
&server_addr,
(const struct sockaddr*) &server_addr,
pinger_on_connect);
ASSERT(!r);

10
test/test-ref.c
View File

@ -258,7 +258,10 @@ TEST_IMPL(tcp_ref3) {
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_tcp_connect(&connect_req,
&h,
(const struct sockaddr*) &addr,
connect_and_shutdown);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connect_cb_called == 1);
@ -274,7 +277,10 @@ TEST_IMPL(tcp_ref4) {
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_tcp_connect(&connect_req,
&h,
(const struct sockaddr*) &addr,
connect_and_write);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connect_cb_called == 1);

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

@ -72,7 +72,10 @@ TEST_IMPL(shutdown_close_tcp) {
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);
r = uv_tcp_connect(&connect_req,
&h,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);

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

@ -160,7 +160,10 @@ TEST_IMPL(shutdown_eof) {
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(!r);
r = uv_tcp_connect(&connect_req, &tcp, &server_addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&tcp,
(const struct sockaddr*) &server_addr,
connect_cb);
ASSERT(!r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

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

@ -63,7 +63,10 @@ TEST_IMPL(tcp_close_while_connecting) {
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_tcp_connect(&connect_req,
&tcp_handle,
(const struct sockaddr*) &addr,
connect_cb));
ASSERT(0 == uv_timer_init(loop, &timer1_handle));
ASSERT(0 == uv_timer_start(&timer1_handle, timer1_cb, 50, 0));
ASSERT(0 == uv_timer_init(loop, &timer2_handle));

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

@ -114,7 +114,10 @@ TEST_IMPL(tcp_close) {
r = uv_tcp_init(loop, &tcp_handle);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&tcp_handle,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
ASSERT(write_cb_called == 0);

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

@ -77,7 +77,10 @@ TEST_IMPL(tcp_connect_error_after_write) {
r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);
ASSERT(r == UV_EBADF);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&conn,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);

5
test/test-tcp-connect-error.c
View File

@ -55,7 +55,10 @@ TEST_IMPL(tcp_connect_error_fault) {
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_connect(&req, &server, garbage_addr, connect_cb);
r = uv_tcp_connect(&req,
&server,
(const struct sockaddr*) garbage_addr,
connect_cb);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);

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

@ -75,7 +75,10 @@ TEST_IMPL(tcp_connect_timeout) {
r = uv_tcp_init(uv_default_loop(), &conn);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&conn,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);

5
test/test-tcp-connect6-error.c
View File

@ -53,7 +53,10 @@ TEST_IMPL(tcp_connect6_error_fault) {
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_connect6(&req, &server, garbage_addr, connect_cb);
r = uv_tcp_connect(&req,
&server,
(const struct sockaddr*) garbage_addr,
connect_cb);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);

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

@ -164,7 +164,10 @@ TEST_IMPL(tcp_open) {
r = uv_tcp_open(&client, sock);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

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

@ -65,7 +65,10 @@ TEST_IMPL(tcp_read_stop) {
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));
ASSERT(0 == uv_tcp_connect(&connect_req,
&tcp_handle,
(const struct sockaddr*) &addr,
connect_cb));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
MAKE_VALGRIND_HAPPY();

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

@ -118,7 +118,10 @@ TEST_IMPL(tcp_shutdown_after_write) {
r = uv_tcp_init(loop, &conn);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&conn,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
r = uv_run(loop, UV_RUN_DEFAULT);

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

@ -100,7 +100,10 @@ TEST_IMPL(tcp_unexpected_read) {
ASSERT(0 == uv_tcp_init(loop, &peer_handle));
ASSERT(0 == uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr));
ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &client_handle, &addr, connect_cb));
ASSERT(0 == uv_tcp_connect(&connect_req,
&client_handle,
(const struct sockaddr*) &addr,
connect_cb));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
/* This is somewhat inexact but the idea is that the event loop should not

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

@ -124,7 +124,10 @@ 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, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&tcp_client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
r = uv_run(loop, UV_RUN_DEFAULT);

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

@ -153,7 +153,10 @@ TEST_IMPL(tcp_writealot) {
r = uv_tcp_init(uv_default_loop(), &client);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
r = uv_tcp_connect(&connect_req,
&client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);