static int
tr_peerIoTryWrite( tr_peerIo * io, size_t howmuch )
{
int n = 0;
if(( howmuch = tr_bandwidthClamp( &io->bandwidth, TR_UP, howmuch )))
{
int e;
EVUTIL_SET_SOCKET_ERROR( 0 );
n = tr_evbuffer_write( io, io->socket, howmuch );
e = EVUTIL_SOCKET_ERROR( );
if( n > 0 )
didWriteWrapper( io, n );
if( ( n < 0 ) && ( io->gotError ) && ( e != EPIPE ) && ( e != EAGAIN ) && ( e != EINTR ) && ( e != EINPROGRESS ) )
{
char errstr[512];
const short what = EVBUFFER_WRITE | EVBUFFER_ERROR;
tr_net_strerror( errstr, sizeof( errstr ), e );
dbgmsg( io, "tr_peerIoTryWrite got an error. res is %d, what is %hd, errno is %d (%s)", n, what, e, errstr );
if( io->gotError != NULL )
io->gotError( io, what, io->userData );
}
}
return n;
}
static int
tr_peerIoTryRead( tr_peerIo * io, size_t howmuch )
{
int res = 0;
if(( howmuch = tr_bandwidthClamp( &io->bandwidth, TR_DOWN, howmuch )))
{
int e;
EVUTIL_SET_SOCKET_ERROR( 0 );
res = evbuffer_read( io->inbuf, io->socket, (int)howmuch );
e = EVUTIL_SOCKET_ERROR( );
dbgmsg( io, "read %d from peer (%s)", res, (res==-1?strerror(e):"") );
if( EVBUFFER_LENGTH( io->inbuf ) )
canReadWrapper( io );
if( ( res <= 0 ) && ( io->gotError ) && ( e != EAGAIN ) && ( e != EINTR ) && ( e != EINPROGRESS ) )
{
char errstr[512];
short what = EVBUFFER_READ | EVBUFFER_ERROR;
if( res == 0 )
what |= EVBUFFER_EOF;
tr_net_strerror( errstr, sizeof( errstr ), e );
dbgmsg( io, "tr_peerIoTryRead got an error. res is %d, what is %hd, errno is %d (%s)", res, what, e, errstr );
io->gotError( io, what, io->userData );
}
}
return res;
}
static int
tr_evbuffer_write( tr_peerIo * io, int fd, size_t howmuch )
{
int e;
int n;
char errstr[256];
struct evbuffer * buffer = io->outbuf;
howmuch = MIN( EVBUFFER_LENGTH( buffer ), howmuch );
EVUTIL_SET_SOCKET_ERROR( 0 );
#ifdef WIN32
n = (int) send(fd, buffer->buffer, howmuch, 0 );
#else
n = (int) write(fd, buffer->buffer, howmuch );
#endif
e = EVUTIL_SOCKET_ERROR( );
dbgmsg( io, "wrote %d to peer (%s)", n, (n==-1?tr_net_strerror(errstr,sizeof(errstr),e):"") );
if( n > 0 )
evbuffer_drain( buffer, (size_t)n );
/* keep the iobuf's excess capacity from growing too large */
if( EVBUFFER_LENGTH( io->outbuf ) == 0 ) {
evbuffer_free( io->outbuf );
io->outbuf = evbuffer_new( );
}
return n;
}
void tr_netSetTOS(tr_socket_t s, int tos)
{
#if defined(IP_TOS) && !defined(_WIN32)
if (setsockopt(s, IPPROTO_IP, IP_TOS, (void const*)&tos, sizeof(tos)) == -1)
{
char err_buf[512];
tr_logAddNamedInfo("Net", "Can't set TOS '%d': %s", tos, tr_net_strerror(err_buf, sizeof(err_buf), sockerrno));
}
#else
(void)s;
(void)tos;
#endif
}
/**
* Portability wrapper for select().
*
* http://msdn.microsoft.com/en-us/library/ms740141%28VS.85%29.aspx
* On win32, any two of the parameters, readfds, writefds, or exceptfds,
* can be given as null. At least one must be non-null, and any non-null
* descriptor set must contain at least one handle to a socket.
*/
static void
tr_select( int nfds,
fd_set * r_fd_set, fd_set * w_fd_set, fd_set * c_fd_set,
struct timeval * t )
{
#ifdef WIN32
if( !r_fd_set->fd_count && !w_fd_set->fd_count && !c_fd_set->fd_count )
{
const long int msec = t->tv_sec*1000 + t->tv_usec/1000;
tr_wait_msec( msec );
}
else if( select( 0, r_fd_set->fd_count ? r_fd_set : NULL,
w_fd_set->fd_count ? w_fd_set : NULL,
c_fd_set->fd_count ? c_fd_set : NULL, t ) < 0 )
{
char errstr[512];
const int e = EVUTIL_SOCKET_ERROR( );
tr_net_strerror( errstr, sizeof( errstr ), e );
dbgmsg( "Error: select (%d) %s", e, errstr );
}
#else
select( nfds, r_fd_set, w_fd_set, c_fd_set, t );
#endif
}
static tr_socket_t tr_netBindTCPImpl(tr_address const* addr, tr_port port, bool suppressMsgs, int* errOut)
{
TR_ASSERT(tr_address_is_valid(addr));
static int const domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
struct sockaddr_storage sock;
tr_socket_t fd;
int addrlen;
int optval;
fd = socket(domains[addr->type], SOCK_STREAM, 0);
if (fd == TR_BAD_SOCKET)
{
*errOut = sockerrno;
return TR_BAD_SOCKET;
}
if (evutil_make_socket_nonblocking(fd) == -1)
{
*errOut = sockerrno;
tr_netCloseSocket(fd);
return TR_BAD_SOCKET;
}
optval = 1;
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void const*)&optval, sizeof(optval));
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void const*)&optval, sizeof(optval));
#ifdef IPV6_V6ONLY
if (addr->type == TR_AF_INET6)
{
if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (void const*)&optval, sizeof(optval)) == -1)
{
if (sockerrno != ENOPROTOOPT) /* if the kernel doesn't support it, ignore it */
{
*errOut = sockerrno;
tr_netCloseSocket(fd);
return TR_BAD_SOCKET;
}
}
}
#endif
addrlen = setup_sockaddr(addr, htons(port), &sock);
if (bind(fd, (struct sockaddr*)&sock, addrlen) == -1)
{
int const err = sockerrno;
if (!suppressMsgs)
{
char const* fmt;
char const* hint;
char err_buf[512];
if (err == EADDRINUSE)
{
hint = _("Is another copy of Transmission already running?");
}
else
{
hint = NULL;
}
if (hint == NULL)
{
fmt = _("Couldn't bind port %d on %s: %s");
}
else
{
fmt = _("Couldn't bind port %d on %s: %s (%s)");
}
tr_logAddError(fmt, port, tr_address_to_string(addr), tr_net_strerror(err_buf, sizeof(err_buf), err), hint);
}
tr_netCloseSocket(fd);
*errOut = err;
return TR_BAD_SOCKET;
}
if (!suppressMsgs)
{
tr_logAddDebug("Bound socket %" PRIdMAX " to port %d on %s", (intmax_t)fd, port, tr_address_to_string(addr));
}
#ifdef TCP_FASTOPEN
#ifndef SOL_TCP
#define SOL_TCP IPPROTO_TCP
#endif
optval = 5;
setsockopt(fd, SOL_TCP, TCP_FASTOPEN, (void const*)&optval, sizeof(optval));
#endif
if (listen(fd, 128) == -1)
{
*errOut = sockerrno;
tr_netCloseSocket(fd);
return TR_BAD_SOCKET;
}
return fd;
}
struct tr_peer_socket tr_netOpenPeerSocket(tr_session* session, tr_address const* addr, tr_port port, bool clientIsSeed)
{
TR_ASSERT(tr_address_is_valid(addr));
struct tr_peer_socket ret = TR_PEER_SOCKET_INIT;
static int const domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
tr_socket_t s;
struct sockaddr_storage sock;
socklen_t addrlen;
tr_address const* source_addr;
socklen_t sourcelen;
struct sockaddr_storage source_sock;
char err_buf[512];
if (!tr_address_is_valid_for_peers(addr, port))
{
return ret;
}
s = tr_fdSocketCreate(session, domains[addr->type], SOCK_STREAM);
if (s == TR_BAD_SOCKET)
{
return ret;
}
/* seeds don't need much of a read buffer... */
if (clientIsSeed)
{
int n = 8192;
if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, (void const*)&n, sizeof(n)) == -1)
{
tr_logAddInfo("Unable to set SO_RCVBUF on socket %" PRIdMAX ": %s", (intmax_t)s,
tr_net_strerror(err_buf, sizeof(err_buf), sockerrno));
}
}
if (evutil_make_socket_nonblocking(s) == -1)
{
tr_netClose(session, s);
return ret;
}
addrlen = setup_sockaddr(addr, port, &sock);
/* set source address */
source_addr = tr_sessionGetPublicAddress(session, addr->type, NULL);
TR_ASSERT(source_addr != NULL);
sourcelen = setup_sockaddr(source_addr, 0, &source_sock);
if (bind(s, (struct sockaddr*)&source_sock, sourcelen) == -1)
{
tr_logAddError(_("Couldn't set source address %s on %" PRIdMAX ": %s"), tr_address_to_string(source_addr), (intmax_t)s,
tr_net_strerror(err_buf, sizeof(err_buf), sockerrno));
tr_netClose(session, s);
return ret;
}
if (connect(s, (struct sockaddr*)&sock, addrlen) == -1 &&
#ifdef _WIN32
sockerrno != WSAEWOULDBLOCK &&
#endif
sockerrno != EINPROGRESS)
{
int const tmperrno = sockerrno;
if ((tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH) || addr->type == TR_AF_INET)
{
tr_logAddError(_("Couldn't connect socket %" PRIdMAX " to %s, port %d (errno %d - %s)"), (intmax_t)s,
tr_address_to_string(addr), (int)ntohs(port), tmperrno, tr_net_strerror(err_buf, sizeof(err_buf), tmperrno));
}
tr_netClose(session, s);
}
else
{
ret = tr_peer_socket_tcp_create(s);
}
tr_logAddDeep(__FILE__, __LINE__, NULL, "New OUTGOING connection %" PRIdMAX " (%s)", (intmax_t)s,
tr_peerIoAddrStr(addr, port));
return ret;
}
void tr_netSetCongestionControl(tr_socket_t s, char const* algorithm)
{
#ifdef TCP_CONGESTION
if (setsockopt(s, IPPROTO_TCP, TCP_CONGESTION, (void const*)algorithm, strlen(algorithm) + 1) == -1)
{
char err_buf[512];
tr_logAddNamedInfo("Net", "Can't set congestion control algorithm '%s': %s", algorithm, tr_net_strerror(err_buf,
sizeof(err_buf), sockerrno));
}
#else
(void)s;
(void)algorithm;
#endif
}
static void
event_read_cb( int fd, short event UNUSED, void * vio )
{
int res;
int e;
tr_peerIo * io = vio;
/* Limit the input buffer to 256K, so it doesn't grow too large */
unsigned int howmuch;
unsigned int curlen;
const tr_direction dir = TR_DOWN;
const unsigned int max = 256 * 1024;
assert( tr_isPeerIo( io ) );
io->hasFinishedConnecting = TRUE;
io->pendingEvents &= ~EV_READ;
curlen = EVBUFFER_LENGTH( io->inbuf );
howmuch = curlen >= max ? 0 : max - curlen;
howmuch = tr_bandwidthClamp( &io->bandwidth, TR_DOWN, howmuch );
dbgmsg( io, "libevent says this peer is ready to read" );
/* if we don't have any bandwidth left, stop reading */
if( howmuch < 1 ) {
tr_peerIoSetEnabled( io, dir, FALSE );
return;
}
EVUTIL_SET_SOCKET_ERROR( 0 );
res = evbuffer_read( io->inbuf, fd, (int)howmuch );
e = EVUTIL_SOCKET_ERROR( );
if( res > 0 )
{
tr_peerIoSetEnabled( io, dir, TRUE );
/* Invoke the user callback - must always be called last */
canReadWrapper( io );
}
else
{
char errstr[512];
short what = EVBUFFER_READ;
if( res == 0 ) /* EOF */
what |= EVBUFFER_EOF;
else if( res == -1 ) {
if( e == EAGAIN || e == EINTR ) {
tr_peerIoSetEnabled( io, dir, TRUE );
return;
}
what |= EVBUFFER_ERROR;
}
tr_net_strerror( errstr, sizeof( errstr ), e );
dbgmsg( io, "event_read_cb got an error. res is %d, what is %hd, errno is %d (%s)", res, what, e, errstr );
if( io->gotError != NULL )
io->gotError( io, what, io->userData );
}
}