/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to

* deal in the Software without restriction, including without limitation the

* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

* sell copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

* IN THE SOFTWARE.

*/

#include "uv.h"

#include "internal.h"

#include <stdlib.h>

#include <unistd.h>

#include <assert.h>

#include <errno.h>

int uv_tcp_init(uv_loop_t* loop, uv_tcp_t* tcp) {

uv__stream_init(loop, (uv_stream_t*)tcp, UV_TCP);

return 0;

}

static int maybe_new_socket(uv_tcp_t* handle, int domain, int flags) {

int sockfd;

int err;

if (uv__stream_fd(handle) != -1)

return 0;

err = uv__socket(domain, SOCK_STREAM, 0);

if (err < 0)

return err;

sockfd = err;

err = uv__stream_open((uv_stream_t*) handle, sockfd, flags);

if (err) {

uv__close(sockfd);

return err;

}

return 0;

}

int uv__tcp_bind(uv_tcp_t* tcp,

const struct sockaddr* addr,

unsigned int addrlen,

unsigned int flags) {

int err;

int on;

/* Cannot set IPv6-only mode on non-IPv6 socket. */

if ((flags & UV_TCP_IPV6ONLY) && addr->sa_family != AF_INET6)

return -EINVAL;

err = maybe_new_socket(tcp,

addr->sa_family,

UV_STREAM_READABLE | UV_STREAM_WRITABLE);

if (err)

return err;

on = 1;

if (setsockopt(tcp->io_watcher.fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))

return -errno;

#ifdef IPV6_V6ONLY

if (addr->sa_family == AF_INET6) {

on = (flags & UV_TCP_IPV6ONLY) != 0;

if (setsockopt(tcp->io_watcher.fd,

IPPROTO_IPV6,

IPV6_V6ONLY,

&on,

sizeof on) == -1) {

return -errno;

}

}

#endif

errno = 0;

if (bind(tcp->io_watcher.fd, addr, addrlen) && errno != EADDRINUSE)

return -errno;

tcp->delayed_error = -errno;

if (addr->sa_family == AF_INET6)

tcp->flags |= UV_HANDLE_IPV6;

return 0;

}

int uv__tcp_connect(uv_connect_t* req,

uv_tcp_t* handle,

const struct sockaddr* addr,

unsigned int addrlen,

uv_connect_cb cb) {

int err;

int r;

assert(handle->type == UV_TCP);

if (handle->connect_req != NULL)

return -EALREADY; /* FIXME(bnoordhuis) -EINVAL or maybe -EBUSY. */

err = maybe_new_socket(handle,

addr->sa_family,

UV_STREAM_READABLE | UV_STREAM_WRITABLE);

if (err)

return err;

handle->delayed_error = 0;

do

r = connect(uv__stream_fd(handle), addr, addrlen);

while (r == -1 && errno == EINTR);

if (r == -1) {

if (errno == EINPROGRESS)

; /* not an error */

else if (errno == ECONNREFUSED)

/* If we get a ECONNREFUSED wait until the next tick to report the

* error. Solaris wants to report immediately--other unixes want to

* wait.

*/

handle->delayed_error = -errno;

else

return -errno;

}

uv__req_init(handle->loop, req, UV_CONNECT);

req->cb = cb;

req->handle = (uv_stream_t*) handle;

QUEUE_INIT(&req->queue);

handle->connect_req = req;

uv__io_start(handle->loop, &handle->io_watcher, UV__POLLOUT);

if (handle->delayed_error)

uv__io_feed(handle->loop, &handle->io_watcher);

return 0;

}

int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {

int err;

err = uv__nonblock(sock, 1);

if (err)

return err;

return uv__stream_open((uv_stream_t*)handle,

sock,

UV_STREAM_READABLE | UV_STREAM_WRITABLE);

}

int uv_tcp_getsockname(const uv_tcp_t* handle,

struct sockaddr* name,

int* namelen) {

socklen_t socklen;

if (handle->delayed_error)

return handle->delayed_error;

if (uv__stream_fd(handle) < 0)

return -EINVAL; /* FIXME(bnoordhuis) -EBADF */

/* sizeof(socklen_t) != sizeof(int) on some systems. */

socklen = (socklen_t) *namelen;

if (getsockname(uv__stream_fd(handle), name, &socklen))

return -errno;

*namelen = (int) socklen;

return 0;

}

int uv_tcp_getpeername(const uv_tcp_t* handle,

struct sockaddr* name,

int* namelen) {

socklen_t socklen;

if (handle->delayed_error)

return handle->delayed_error;

if (uv__stream_fd(handle) < 0)

return -EINVAL; /* FIXME(bnoordhuis) -EBADF */

/* sizeof(socklen_t) != sizeof(int) on some systems. */

socklen = (socklen_t) *namelen;

if (getpeername(uv__stream_fd(handle), name, &socklen))

return -errno;

*namelen = (int) socklen;

return 0;

}

int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {

static int single_accept = -1;

int err;

if (tcp->delayed_error)

return tcp->delayed_error;

if (single_accept == -1) {

const char* val = getenv("UV_TCP_SINGLE_ACCEPT");

single_accept = (val != NULL && atoi(val) != 0); /* Off by default. */

}

if (single_accept)

tcp->flags |= UV_TCP_SINGLE_ACCEPT;

err = maybe_new_socket(tcp, AF_INET, UV_STREAM_READABLE);

if (err)

return err;

if (listen(tcp->io_watcher.fd, backlog))

return -errno;

tcp->connection_cb = cb;

/* Start listening for connections. */

tcp->io_watcher.cb = uv__server_io;

uv__io_start(tcp->loop, &tcp->io_watcher, UV__POLLIN);

return 0;

}

int uv__tcp_nodelay(int fd, int on) {

if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)))

return -errno;

return 0;

}

int uv__tcp_keepalive(int fd, int on, unsigned int delay) {

if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)))

return -errno;

#ifdef TCP_KEEPIDLE

if (on && setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &delay, sizeof(delay)))

return -errno;

#endif

/* Solaris/SmartOS, if you don't support keep-alive,

* then don't advertise it in your system headers...

*/

/* FIXME(bnoordhuis) That's possibly because sizeof(delay) should be 1. */

#if defined(TCP_KEEPALIVE) && !defined(__sun)

if (on && setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &delay, sizeof(delay)))

return -errno;

#endif

return 0;

}

int uv_tcp_nodelay(uv_tcp_t* handle, int on) {

int err;

if (uv__stream_fd(handle) != -1) {

err = uv__tcp_nodelay(uv__stream_fd(handle), on);

if (err)

return err;

}

if (on)

handle->flags |= UV_TCP_NODELAY;

else

handle->flags &= ~UV_TCP_NODELAY;

return 0;

}

int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {

int err;

if (uv__stream_fd(handle) != -1) {

err =uv__tcp_keepalive(uv__stream_fd(handle), on, delay);

if (err)

return err;

}

if (on)

handle->flags |= UV_TCP_KEEPALIVE;

else

handle->flags &= ~UV_TCP_KEEPALIVE;

/* TODO Store delay if uv__stream_fd(handle) == -1 but don't want to enlarge

* uv_tcp_t with an int that's almost never used...

*/

return 0;

}

int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) {

if (enable)

handle->flags &= ~UV_TCP_SINGLE_ACCEPT;

else

handle->flags |= UV_TCP_SINGLE_ACCEPT;

return 0;

}

void uv__tcp_close(uv_tcp_t* handle) {

uv__stream_close((uv_stream_t*)handle);

}