/****************************************************************************** * * $Id$ * * Copyright (c) Transmission authors and contributors * * 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 #include #include #include #ifdef WIN32 #define _WIN32_WINNT 0x0501 #include #else #include /* TCP_CONGESTION */ #endif #include #include #include "transmission.h" #include "fdlimit.h" /* tr_fdSocketClose () */ #include "net.h" #include "peer-io.h" /* tr_peerIoAddrStr () FIXME this should be moved to net.h */ #include "session.h" /* tr_sessionGetPublicAddress () */ #include "tr-utp.h" /* tr_utpSendTo () */ #include "log.h" #include "utils.h" /* tr_time (), tr_logAddDebug () */ #ifndef IN_MULTICAST #define IN_MULTICAST(a) (((a) & 0xf0000000) == 0xe0000000) #endif const tr_address tr_in6addr_any = { TR_AF_INET6, { IN6ADDR_ANY_INIT } }; const tr_address tr_inaddr_any = { TR_AF_INET, { { { { INADDR_ANY, 0x00, 0x00, 0x00 } } } } }; void tr_netInit (void) { static int initialized = false; if (!initialized) { #ifdef WIN32 WSADATA wsaData; WSAStartup (MAKEWORD (2, 2), &wsaData); #endif initialized = true; } } char * tr_net_strerror (char * buf, size_t buflen, int err) { *buf = '\0'; #ifdef WIN32 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, buflen, NULL); #else tr_strlcpy (buf, tr_strerror (err), buflen); #endif return buf; } const char * tr_address_to_string_with_buf (const tr_address * addr, char * buf, size_t buflen) { assert (tr_address_is_valid (addr)); if (addr->type == TR_AF_INET) return evutil_inet_ntop (AF_INET, &addr->addr, buf, buflen); else return evutil_inet_ntop (AF_INET6, &addr->addr, buf, buflen); } /* * Non-threadsafe version of tr_address_to_string_with_buf () * and uses a static memory area for a buffer. * This function is suitable to be called from libTransmission's networking code, * which is single-threaded. */ const char * tr_address_to_string (const tr_address * addr) { static char buf[INET6_ADDRSTRLEN]; return tr_address_to_string_with_buf (addr, buf, sizeof (buf)); } bool tr_address_from_string (tr_address * dst, const char * src) { bool ok; if ((ok = evutil_inet_pton (AF_INET, src, &dst->addr) == 1)) dst->type = TR_AF_INET; if (!ok) /* try IPv6 */ if ((ok = evutil_inet_pton (AF_INET6, src, &dst->addr) == 1)) dst->type = TR_AF_INET6; return ok; } /* * Compare two tr_address structures. * Returns: * <0 if a < b * >0 if a > b * 0 if a == b */ int tr_address_compare (const tr_address * a, const tr_address * b) { static const int sizes[2] = { sizeof (struct in_addr), sizeof (struct in6_addr) }; /* IPv6 addresses are always "greater than" IPv4 */ if (a->type != b->type) return a->type == TR_AF_INET ? 1 : -1; return memcmp (&a->addr, &b->addr, sizes[a->type]); } /*********************************************************************** * TCP sockets **********************************************************************/ int tr_netSetTOS (int s, int tos) { #ifdef IP_TOS return setsockopt (s, IPPROTO_IP, IP_TOS, (char*)&tos, sizeof (tos)); #else return 0; #endif } int tr_netSetCongestionControl (int s UNUSED, const char *algorithm UNUSED) { #ifdef TCP_CONGESTION return setsockopt (s, IPPROTO_TCP, TCP_CONGESTION, algorithm, strlen (algorithm) + 1); #else errno = ENOSYS; return -1; #endif } bool tr_address_from_sockaddr_storage (tr_address * setme_addr, tr_port * setme_port, const struct sockaddr_storage * from) { if (from->ss_family == AF_INET) { struct sockaddr_in * sin = (struct sockaddr_in *)from; setme_addr->type = TR_AF_INET; setme_addr->addr.addr4.s_addr = sin->sin_addr.s_addr; *setme_port = sin->sin_port; return true; } if (from->ss_family == AF_INET6) { struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) from; setme_addr->type = TR_AF_INET6; setme_addr->addr.addr6 = sin6->sin6_addr; *setme_port = sin6->sin6_port; return true; } return false; } static socklen_t setup_sockaddr (const tr_address * addr, tr_port port, struct sockaddr_storage * sockaddr) { assert (tr_address_is_valid (addr)); if (addr->type == TR_AF_INET) { struct sockaddr_in sock4; memset (&sock4, 0, sizeof (sock4)); sock4.sin_family = AF_INET; sock4.sin_addr.s_addr = addr->addr.addr4.s_addr; sock4.sin_port = port; memcpy (sockaddr, &sock4, sizeof (sock4)); return sizeof (struct sockaddr_in); } else { struct sockaddr_in6 sock6; memset (&sock6, 0, sizeof (sock6)); sock6.sin6_family = AF_INET6; sock6.sin6_port = port; sock6.sin6_flowinfo = 0; sock6.sin6_addr = addr->addr.addr6; memcpy (sockaddr, &sock6, sizeof (sock6)); return sizeof (struct sockaddr_in6); } } int tr_netOpenPeerSocket (tr_session * session, const tr_address * addr, tr_port port, bool clientIsSeed) { static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 }; int s; struct sockaddr_storage sock; socklen_t addrlen; const tr_address * source_addr; socklen_t sourcelen; struct sockaddr_storage source_sock; assert (tr_address_is_valid (addr)); if (!tr_address_is_valid_for_peers (addr, port)) return -EINVAL; s = tr_fdSocketCreate (session, domains[addr->type], SOCK_STREAM); if (s < 0) return -1; /* seeds don't need much of a read buffer... */ if (clientIsSeed) { int n = 8192; if (setsockopt (s, SOL_SOCKET, SO_RCVBUF, &n, sizeof (n))) tr_logAddInfo ("Unable to set SO_RCVBUF on socket %d: %s", s, tr_strerror (sockerrno)); } if (evutil_make_socket_nonblocking (s) < 0) { tr_netClose (session, s); return -1; } addrlen = setup_sockaddr (addr, port, &sock); /* set source address */ source_addr = tr_sessionGetPublicAddress (session, addr->type, NULL); assert (source_addr); sourcelen = setup_sockaddr (source_addr, 0, &source_sock); if (bind (s, (struct sockaddr *) &source_sock, sourcelen)) { tr_logAddError (_("Couldn't set source address %s on %d: %s"), tr_address_to_string (source_addr), s, tr_strerror (errno)); return -errno; } if ((connect (s, (struct sockaddr *) &sock, addrlen) < 0) #ifdef WIN32 && (sockerrno != WSAEWOULDBLOCK) #endif && (sockerrno != EINPROGRESS)) { int tmperrno; tmperrno = sockerrno; if ((tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH) || addr->type == TR_AF_INET) tr_logAddError (_("Couldn't connect socket %d to %s, port %d (errno %d - %s)"), s, tr_address_to_string (addr), (int)ntohs (port), tmperrno, tr_strerror (tmperrno)); tr_netClose (session, s); s = -tmperrno; } tr_logAddDeep (__FILE__, __LINE__, NULL, "New OUTGOING connection %d (%s)", s, tr_peerIoAddrStr (addr, port)); return s; } struct UTPSocket * tr_netOpenPeerUTPSocket (tr_session * session, const tr_address * addr, tr_port port, bool clientIsSeed UNUSED) { struct UTPSocket * ret = NULL; if (tr_address_is_valid_for_peers (addr, port)) { struct sockaddr_storage ss; const socklen_t sslen = setup_sockaddr (addr, port, &ss); ret = UTP_Create (tr_utpSendTo, session, (struct sockaddr*)&ss, sslen); } return ret; } static int tr_netBindTCPImpl (const tr_address * addr, tr_port port, bool suppressMsgs, int * errOut) { static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 }; struct sockaddr_storage sock; int fd; int addrlen; int optval; assert (tr_address_is_valid (addr)); fd = socket (domains[addr->type], SOCK_STREAM, 0); if (fd < 0) { *errOut = sockerrno; return -1; } if (evutil_make_socket_nonblocking (fd) < 0) { *errOut = sockerrno; tr_netCloseSocket (fd); return -1; } optval = 1; setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof (optval)); setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof (optval)); #ifdef IPV6_V6ONLY if (addr->type == TR_AF_INET6) if (setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof (optval)) == -1) if (sockerrno != ENOPROTOOPT) { /* if the kernel doesn't support it, ignore it */ *errOut = sockerrno; return -1; } #endif addrlen = setup_sockaddr (addr, htons (port), &sock); if (bind (fd, (struct sockaddr *) &sock, addrlen)) { const int err = sockerrno; if (!suppressMsgs) { const char * fmt; const char * hint; 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_strerror (err), hint); } tr_netCloseSocket (fd); *errOut = err; return -1; } if (!suppressMsgs) tr_logAddDebug ("Bound socket %d to port %d on %s", fd, port, tr_address_to_string (addr)); if (listen (fd, 128) == -1) { *errOut = sockerrno; tr_netCloseSocket (fd); return -1; } return fd; } int tr_netBindTCP (const tr_address * addr, tr_port port, bool suppressMsgs) { int unused; return tr_netBindTCPImpl (addr, port, suppressMsgs, &unused); } bool tr_net_hasIPv6 (tr_port port) { static bool result = false; static bool alreadyDone = false; if (!alreadyDone) { int err; int fd = tr_netBindTCPImpl (&tr_in6addr_any, port, true, &err); if (fd >= 0 || err != EAFNOSUPPORT) /* we support ipv6 */ result = true; if (fd >= 0) tr_netCloseSocket (fd); alreadyDone = true; } return result; } int tr_netAccept (tr_session * session, int b, tr_address * addr, tr_port * port) { int fd = tr_fdSocketAccept (session, b, addr, port); if (fd>=0 && evutil_make_socket_nonblocking (fd)<0) { tr_netClose (session, fd); fd = -1; } return fd; } void tr_netCloseSocket (int fd) { evutil_closesocket (fd); } void tr_netClose (tr_session * session, int s) { tr_fdSocketClose (session, s); } /* get_source_address () and global_unicast_address () were written by Juliusz Chroboczek, and are covered under the same license as dht.c. Please feel free to copy them into your software if it can help unbreaking the double-stack Internet. */ /* Get the source address used for a given destination address. Since there is no official interface to get this information, we create a connected UDP socket (connected UDP... hmm...) and check its source address. */ static int get_source_address (const struct sockaddr * dst, socklen_t dst_len, struct sockaddr * src, socklen_t * src_len) { int s, rc, save; s = socket (dst->sa_family, SOCK_DGRAM, 0); if (s < 0) goto fail; /* Since it's a UDP socket, this doesn't actually send any packets. */ rc = connect (s, dst, dst_len); if (rc < 0) goto fail; rc = getsockname (s, src, src_len); if (rc < 0) goto fail; evutil_closesocket (s); return rc; fail: save = errno; evutil_closesocket (s); errno = save; return -1; } /* We all hate NATs. */ static int global_unicast_address (struct sockaddr *sa) { if (sa->sa_family == AF_INET) { const unsigned char *a = (unsigned char*)& ((struct sockaddr_in*)sa)->sin_addr; if (a[0] == 0 || a[0] == 127 || a[0] >= 224 || a[0] == 10 || (a[0] == 172 && a[1] >= 16 && a[1] <= 31) || (a[0] == 192 && a[1] == 168)) return 0; return 1; } else if (sa->sa_family == AF_INET6) { const unsigned char *a = (unsigned char*)& ((struct sockaddr_in6*)sa)->sin6_addr; /* 2000::/3 */ return (a[0] & 0xE0) == 0x20; } else { errno = EAFNOSUPPORT; return -1; } } static int tr_globalAddress (int af, void *addr, int *addr_len) { struct sockaddr_storage ss; socklen_t sslen = sizeof (ss); struct sockaddr_in sin; struct sockaddr_in6 sin6; struct sockaddr *sa; socklen_t salen; int rc; switch (af) { case AF_INET: memset (&sin, 0, sizeof (sin)); sin.sin_family = AF_INET; evutil_inet_pton (AF_INET, "91.121.74.28", &sin.sin_addr); sin.sin_port = htons (6969); sa = (struct sockaddr*)&sin; salen = sizeof (sin); break; case AF_INET6: memset (&sin6, 0, sizeof (sin6)); sin6.sin6_family = AF_INET6; /* In order for address selection to work right, this should be a native IPv6 address, not Teredo or 6to4. */ evutil_inet_pton (AF_INET6, "2001:1890:1112:1::20", &sin6.sin6_addr); sin6.sin6_port = htons (6969); sa = (struct sockaddr*)&sin6; salen = sizeof (sin6); break; default: return -1; } rc = get_source_address (sa, salen, (struct sockaddr*)&ss, &sslen); if (rc < 0) return -1; if (!global_unicast_address ((struct sockaddr*)&ss)) return -1; switch (af) { case AF_INET: if (*addr_len < 4) return -1; memcpy (addr, & ((struct sockaddr_in*)&ss)->sin_addr, 4); *addr_len = 4; return 1; case AF_INET6: if (*addr_len < 16) return -1; memcpy (addr, & ((struct sockaddr_in6*)&ss)->sin6_addr, 16); *addr_len = 16; return 1; default: return -1; } } /* Return our global IPv6 address, with caching. */ const unsigned char * tr_globalIPv6 (void) { static unsigned char ipv6[16]; static time_t last_time = 0; static int have_ipv6 = 0; const time_t now = tr_time (); /* Re-check every half hour */ if (last_time < now - 1800) { int addrlen = 16; const int rc = tr_globalAddress (AF_INET6, ipv6, &addrlen); have_ipv6 = (rc >= 0) && (addrlen == 16); last_time = now; } return have_ipv6 ? ipv6 : NULL; } /*** **** **** ***/ static bool isIPv4MappedAddress (const tr_address * addr) { return (addr->type == TR_AF_INET6) && IN6_IS_ADDR_V4MAPPED (&addr->addr.addr6); } static bool isIPv6LinkLocalAddress (const tr_address * addr) { return ((addr->type == TR_AF_INET6) && IN6_IS_ADDR_LINKLOCAL (&addr->addr.addr6)); } /* isMartianAddr was written by Juliusz Chroboczek, and is covered under the same license as third-party/dht/dht.c. */ static bool isMartianAddr (const struct tr_address * a) { static const unsigned char zeroes[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; assert (tr_address_is_valid (a)); switch (a->type) { case TR_AF_INET: { const unsigned char * address = (const unsigned char*)&a->addr.addr4; return (address[0] == 0) || (address[0] == 127) || ((address[0] & 0xE0) == 0xE0); break; } case TR_AF_INET6: { const unsigned char * address = (const unsigned char*)&a->addr.addr6; return (address[0] == 0xFF) || (memcmp (address, zeroes, 15) == 0 && (address[15] == 0 || address[15] == 1)) || /* Addresses outside of 2000::/3 are currently reserved, but might be allocated at some future time. Since there are a lot of buggy peers pushing around such addresses over PEX, we reject them until the end of the 13th Baktun. */ (tr_time () < 1356130800 && (address[0] & 0xE0) != 0x20); break; } default: return true; } } bool tr_address_is_valid_for_peers (const tr_address * addr, tr_port port) { return (port != 0) && (tr_address_is_valid (addr)) && (!isIPv6LinkLocalAddress (addr)) && (!isIPv4MappedAddress (addr)) && (!isMartianAddr (addr)); }