src/socket.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "socket.h"
  21
  22 #include <stdio.h>
  23 #include <iostream>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <sstream>
  28 #include <iomanip>
  29 #include "util/string.h"
  30 #include "util/numeric.h"
  31 #include "constants.h"
  32 #include "debug.h"
  33 #include "settings.h"
  34 #include "log.h"
  35
  36 #ifdef _WIN32
  37         #ifndef WIN32_LEAN_AND_MEAN
  38                 #define WIN32_LEAN_AND_MEAN
  39         #endif
  40         // Without this some of the network functions are not found on mingw
  41         #ifndef _WIN32_WINNT
  42                 #define _WIN32_WINNT 0x0501
  43         #endif
  44         #include <windows.h>
  45         #include <winsock2.h>
  46         #include <ws2tcpip.h>
  47 typedef SOCKET socket_t;
  48 typedef int socklen_t;
  49 #else
  50         #include <sys/types.h>
  51         #include <sys/socket.h>
  52         #include <netinet/in.h>
  53         #include <fcntl.h>
  54         #include <netdb.h>
  55         #include <unistd.h>
  56         #include <arpa/inet.h>
  57 typedef int socket_t;
  58 #endif
  59
  60 // Set to true to enable verbose debug output
  61 bool socket_enable_debug_output = false;        // yuck
  62
  63 static bool g_sockets_initialized = false;
  64
  65 // Initialize sockets
  66 void sockets_init()
  67 {
  68 #ifdef _WIN32
  69         // Windows needs sockets to be initialized before use
  70         WSADATA WsaData;
  71         if(WSAStartup( MAKEWORD(2,2), &WsaData ) != NO_ERROR)
  72                 throw SocketException("WSAStartup failed");
  73 #endif
  74         g_sockets_initialized = true;
  75 }
  76
  77 void sockets_cleanup()
  78 {
  79 #ifdef _WIN32
  80         // On Windows, cleanup sockets after use
  81         WSACleanup();
  82 #endif
  83 }
  84
  85 /*
  86         Address
  87 */
  88
  89 Address::Address()
  90 {
  91         m_addr_family = 0;
  92         memset(&m_address, 0, sizeof(m_address));
  93         m_port = 0;
  94 }
  95
  96 Address::Address(u32 address, u16 port)
  97 {
  98         memset(&m_address, 0, sizeof(m_address));
  99         setAddress(address);
 100         setPort(port);
 101 }
 102
 103 Address::Address(u8 a, u8 b, u8 c, u8 d, u16 port)
 104 {
 105         memset(&m_address, 0, sizeof(m_address));
 106         setAddress(a, b, c, d);
 107         setPort(port);
 108 }
 109
 110 Address::Address(const IPv6AddressBytes *ipv6_bytes, u16 port)
 111 {
 112         memset(&m_address, 0, sizeof(m_address));
 113         setAddress(ipv6_bytes);
 114         setPort(port);
 115 }
 116
 117 // Equality (address family, address and port must be equal)
 118 bool Address::operator==(const Address &address)
 119 {
 120         if(address.m_addr_family != m_addr_family || address.m_port != m_port)
 121                 return false;
 122         else if(m_addr_family == AF_INET)
 123         {
 124                 return m_address.ipv4.sin_addr.s_addr ==
 125                        address.m_address.ipv4.sin_addr.s_addr;
 126         }
 127         else if(m_addr_family == AF_INET6)
 128         {
 129                 return memcmp(m_address.ipv6.sin6_addr.s6_addr,
 130                               address.m_address.ipv6.sin6_addr.s6_addr, 16) == 0;
 131         }
 132         else
 133                 return false;
 134 }
 135
 136 bool Address::operator!=(const Address &address)
 137 {
 138         return !(*this == address);
 139 }
 140
 141 void Address::Resolve(const char *name)
 142 {
 143         if (!name || name[0] == 0) {
 144                 if (m_addr_family == AF_INET) {
 145                         setAddress((u32) 0);
 146                 } else if (m_addr_family == AF_INET6) {
 147                         setAddress((IPv6AddressBytes*) 0);
 148                 }
 149                 return;
 150         }
 151
 152         struct addrinfo *resolved, hints;
 153         memset(&hints, 0, sizeof(hints));
 154
 155         // Setup hints
 156         hints.ai_socktype = 0;
 157         hints.ai_protocol = 0;
 158         hints.ai_flags    = 0;
 159         if(g_settings->getBool("enable_ipv6"))
 160         {
 161                 // AF_UNSPEC allows both IPv6 and IPv4 addresses to be returned
 162                 hints.ai_family = AF_UNSPEC;
 163         }
 164         else
 165         {
 166                 hints.ai_family = AF_INET;
 167         }
 168
 169         // Do getaddrinfo()
 170         int e = getaddrinfo(name, NULL, &hints, &resolved);
 171         if(e != 0)
 172                 throw ResolveError(gai_strerror(e));
 173
 174         // Copy data
 175         if(resolved->ai_family == AF_INET)
 176         {
 177                 struct sockaddr_in *t = (struct sockaddr_in *) resolved->ai_addr;
 178                 m_addr_family = AF_INET;
 179                 m_address.ipv4 = *t;
 180         }
 181         else if(resolved->ai_family == AF_INET6)
 182         {
 183                 struct sockaddr_in6 *t = (struct sockaddr_in6 *) resolved->ai_addr;
 184                 m_addr_family = AF_INET6;
 185                 m_address.ipv6 = *t;
 186         }
 187         else
 188         {
 189                 freeaddrinfo(resolved);
 190                 throw ResolveError("");
 191         }
 192         freeaddrinfo(resolved);
 193 }
 194
 195 // IP address -> textual representation
 196 std::string Address::serializeString() const
 197 {
 198 // windows XP doesnt have inet_ntop, maybe use better func
 199 #ifdef _WIN32
 200         if(m_addr_family == AF_INET)
 201         {
 202                 u8 a, b, c, d;
 203                 u32 addr;
 204                 addr = ntohl(m_address.ipv4.sin_addr.s_addr);
 205                 a = (addr & 0xFF000000) >> 24;
 206                 b = (addr & 0x00FF0000) >> 16;
 207                 c = (addr & 0x0000FF00) >> 8;
 208                 d = (addr & 0x000000FF);
 209                 return itos(a) + "." + itos(b) + "." + itos(c) + "." + itos(d);
 210         }
 211         else if(m_addr_family == AF_INET6)
 212         {
 213                 std::ostringstream os;
 214                 for(int i = 0; i < 16; i += 2)
 215                 {
 216                         u16 section =
 217                         (m_address.ipv6.sin6_addr.s6_addr[i] << 8) |
 218                         (m_address.ipv6.sin6_addr.s6_addr[i + 1]);
 219                         os << std::hex << section;
 220                         if(i < 14)
 221                                 os << ":";
 222                 }
 223                 return os.str();
 224         }
 225         else
 226                 return std::string("");
 227 #else
 228         char str[INET6_ADDRSTRLEN];
 229         if (inet_ntop(m_addr_family, (m_addr_family == AF_INET) ? (void*)&(m_address.ipv4.sin_addr) : (void*)&(m_address.ipv6.sin6_addr), str, INET6_ADDRSTRLEN) == NULL) {
 230                 return std::string("");
 231         }
 232         return std::string(str);
 233 #endif
 234 }
 235
 236 struct sockaddr_in Address::getAddress() const
 237 {
 238         return m_address.ipv4; // NOTE: NO PORT INCLUDED, use getPort()
 239 }
 240
 241 struct sockaddr_in6 Address::getAddress6() const
 242 {
 243         return m_address.ipv6; // NOTE: NO PORT INCLUDED, use getPort()
 244 }
 245
 246 u16 Address::getPort() const
 247 {
 248         return m_port;
 249 }
 250
 251 int Address::getFamily() const
 252 {
 253         return m_addr_family;
 254 }
 255
 256 bool Address::isIPv6() const
 257 {
 258         return m_addr_family == AF_INET6;
 259 }
 260
 261 bool Address::isZero() const
 262 {
 263         if (m_addr_family == AF_INET) {
 264                 return m_address.ipv4.sin_addr.s_addr == 0;
 265         } else if (m_addr_family == AF_INET6) {
 266                 static const char zero[16] = {0};
 267                 return memcmp(m_address.ipv6.sin6_addr.s6_addr,
 268                               zero, 16) == 0;
 269         }
 270         return false;
 271 }
 272
 273 void Address::setAddress(u32 address)
 274 {
 275         m_addr_family = AF_INET;
 276         m_address.ipv4.sin_family = AF_INET;
 277         m_address.ipv4.sin_addr.s_addr = htonl(address);
 278 }
 279
 280 void Address::setAddress(u8 a, u8 b, u8 c, u8 d)
 281 {
 282         m_addr_family = AF_INET;
 283         m_address.ipv4.sin_family = AF_INET;
 284         u32 addr = htonl((a << 24) | (b << 16) | (c << 8) | d);
 285         m_address.ipv4.sin_addr.s_addr = addr;
 286 }
 287
 288 void Address::setAddress(const IPv6AddressBytes *ipv6_bytes)
 289 {
 290         m_addr_family = AF_INET6;
 291         m_address.ipv6.sin6_family = AF_INET6;
 292         if (ipv6_bytes)
 293                 memcpy(m_address.ipv6.sin6_addr.s6_addr, ipv6_bytes->bytes, 16);
 294         else
 295                 memset(m_address.ipv6.sin6_addr.s6_addr, 0, 16);
 296 }
 297
 298 void Address::setPort(u16 port)
 299 {
 300         m_port = port;
 301 }
 302
 303 void Address::print(std::ostream *s) const
 304 {
 305         if(m_addr_family == AF_INET6)
 306                 *s << "[" << serializeString() << "]:" << m_port;
 307         else
 308                 *s << serializeString() << ":" << m_port;
 309 }
 310
 311 /*
 312         UDPSocket
 313 */
 314
 315 UDPSocket::UDPSocket(bool ipv6)
 316 {
 317         init(ipv6, false);
 318 }
 319
 320 bool UDPSocket::init(bool ipv6, bool noExceptions)
 321 {
 322         if (g_sockets_initialized == false) {
 323                 dstream << "Sockets not initialized" << std::endl;
 324                 return false;
 325         }
 326
 327         // Use IPv6 if specified
 328         m_addr_family = ipv6 ? AF_INET6 : AF_INET;
 329         m_handle = socket(m_addr_family, SOCK_DGRAM, IPPROTO_UDP);
 330
 331         if (socket_enable_debug_output) {
 332                 dstream << "UDPSocket(" << (int) m_handle
 333                         << ")::UDPSocket(): ipv6 = "
 334                         << (ipv6 ? "true" : "false")
 335                         << std::endl;
 336         }
 337
 338         if (m_handle <= 0) {
 339                 if (noExceptions) {
 340                         return false;
 341                 } else {
 342                         throw SocketException("Failed to create socket");
 343                 }
 344         }
 345
 346         setTimeoutMs(0);
 347
 348         return true;
 349 }
 350
 351
 352 UDPSocket::~UDPSocket()
 353 {
 354         if (socket_enable_debug_output) {
 355                 dstream << "UDPSocket( " << (int) m_handle << ")::~UDPSocket()"
 356                         << std::endl;
 357         }
 358
 359 #ifdef _WIN32
 360         closesocket(m_handle);
 361 #else
 362         close(m_handle);
 363 #endif
 364 }
 365
 366 void UDPSocket::Bind(Address addr)
 367 {
 368         if(socket_enable_debug_output) {
 369                 dstream << "UDPSocket(" << (int) m_handle << ")::Bind(): "
 370                         << addr.serializeString() << ":"
 371                         << addr.getPort() << std::endl;
 372         }
 373
 374         if (addr.getFamily() != m_addr_family) {
 375                 static const char *errmsg = "Socket and bind address families do not match";
 376                 errorstream << "Bind failed: " << errmsg << std::endl;
 377                 throw SocketException(errmsg);
 378         }
 379
 380         if(m_addr_family == AF_INET6) {
 381                 struct sockaddr_in6 address;
 382                 memset(&address, 0, sizeof(address));
 383
 384                 address             = addr.getAddress6();
 385                 address.sin6_family = AF_INET6;
 386                 address.sin6_port   = htons(addr.getPort());
 387
 388                 if(bind(m_handle, (const struct sockaddr *) &address,
 389                                 sizeof(struct sockaddr_in6)) < 0) {
 390                         dstream << (int) m_handle << ": Bind failed: "
 391                                 << strerror(errno) << std::endl;
 392                         throw SocketException("Failed to bind socket");
 393                 }
 394         } else {
 395                 struct sockaddr_in address;
 396                 memset(&address, 0, sizeof(address));
 397
 398                 address                 = addr.getAddress();
 399                 address.sin_family      = AF_INET;
 400                 address.sin_port        = htons(addr.getPort());
 401
 402                 if (bind(m_handle, (const struct sockaddr *) &address,
 403                                 sizeof(struct sockaddr_in)) < 0) {
 404                         dstream << (int)m_handle << ": Bind failed: "
 405                                 << strerror(errno) << std::endl;
 406                         throw SocketException("Failed to bind socket");
 407                 }
 408         }
 409 }
 410
 411 void UDPSocket::Send(const Address & destination, const void * data, int size)
 412 {
 413         bool dumping_packet = false; // for INTERNET_SIMULATOR
 414
 415         if(INTERNET_SIMULATOR)
 416                 dumping_packet = myrand() % INTERNET_SIMULATOR_PACKET_LOSS == 0;
 417
 418         if(socket_enable_debug_output) {
 419                 // Print packet destination and size
 420                 dstream << (int)m_handle << " -> ";
 421                 destination.print(&dstream);
 422                 dstream << ", size=" << size;
 423
 424                 // Print packet contents
 425                 dstream << ", data=";
 426                 for(int i = 0; i < size && i < 20; i++) {
 427                         if(i % 2 == 0)
 428                                 dstream << " ";
 429                         unsigned int a = ((const unsigned char *)data)[i];
 430                         dstream << std::hex << std::setw(2) << std::setfill('0') << a;
 431                 }
 432
 433                 if(size > 20)
 434                         dstream << "...";
 435
 436                 if(dumping_packet)
 437                         dstream << " (DUMPED BY INTERNET_SIMULATOR)";
 438
 439                 dstream << std::endl;
 440         }
 441
 442         if(dumping_packet) {
 443                 // Lol let's forget it
 444                 dstream << "UDPSocket::Send(): INTERNET_SIMULATOR: dumping packet."
 445                                 << std::endl;
 446                 return;
 447         }
 448
 449         if(destination.getFamily() != m_addr_family)
 450                 throw SendFailedException("Address family mismatch");
 451
 452         int sent;
 453         if(m_addr_family == AF_INET6) {
 454                 struct sockaddr_in6 address = destination.getAddress6();
 455                 address.sin6_port = htons(destination.getPort());
 456                 sent = sendto(m_handle, (const char *)data, size,
 457                                 0, (struct sockaddr *)&address, sizeof(struct sockaddr_in6));
 458         } else {
 459                 struct sockaddr_in address = destination.getAddress();
 460                 address.sin_port = htons(destination.getPort());
 461                 sent = sendto(m_handle, (const char *)data, size,
 462                                 0, (struct sockaddr *)&address, sizeof(struct sockaddr_in));
 463         }
 464
 465         if(sent != size)
 466                 throw SendFailedException("Failed to send packet");
 467 }
 468
 469 int UDPSocket::Receive(Address & sender, void *data, int size)
 470 {
 471         // Return on timeout
 472         if(WaitData(m_timeout_ms) == false)
 473                 return -1;
 474
 475         int received;
 476         if (m_addr_family == AF_INET6) {
 477                 struct sockaddr_in6 address;
 478                 memset(&address, 0, sizeof(address));
 479                 socklen_t address_len = sizeof(address);
 480
 481                 received = recvfrom(m_handle, (char *) data,
 482                                 size, 0, (struct sockaddr *) &address, &address_len);
 483
 484                 if(received < 0)
 485                         return -1;
 486
 487                 u16 address_port = ntohs(address.sin6_port);
 488                 IPv6AddressBytes bytes;
 489                 memcpy(bytes.bytes, address.sin6_addr.s6_addr, 16);
 490                 sender = Address(&bytes, address_port);
 491         } else {
 492                 struct sockaddr_in address;
 493                 memset(&address, 0, sizeof(address));
 494
 495                 socklen_t address_len = sizeof(address);
 496
 497                 received = recvfrom(m_handle, (char *)data,
 498                                 size, 0, (struct sockaddr *)&address, &address_len);
 499
 500                 if(received < 0)
 501                         return -1;
 502
 503                 u32 address_ip = ntohl(address.sin_addr.s_addr);
 504                 u16 address_port = ntohs(address.sin_port);
 505
 506                 sender = Address(address_ip, address_port);
 507         }
 508
 509         if (socket_enable_debug_output) {
 510                 // Print packet sender and size
 511                 dstream << (int) m_handle << " <- ";
 512                 sender.print(&dstream);
 513                 dstream << ", size=" << received;
 514
 515                 // Print packet contents
 516                 dstream << ", data=";
 517                 for(int i = 0; i < received && i < 20; i++) {
 518                         if(i % 2 == 0)
 519                                 dstream << " ";
 520                         unsigned int a = ((const unsigned char *) data)[i];
 521                         dstream << std::hex << std::setw(2) << std::setfill('0') << a;
 522                 }
 523                 if(received > 20)
 524                         dstream << "...";
 525
 526                 dstream << std::endl;
 527         }
 528
 529         return received;
 530 }
 531
 532 int UDPSocket::GetHandle()
 533 {
 534         return m_handle;
 535 }
 536
 537 void UDPSocket::setTimeoutMs(int timeout_ms)
 538 {
 539         m_timeout_ms = timeout_ms;
 540 }
 541
 542 bool UDPSocket::WaitData(int timeout_ms)
 543 {
 544         fd_set readset;
 545         int result;
 546
 547         // Initialize the set
 548         FD_ZERO(&readset);
 549         FD_SET(m_handle, &readset);
 550
 551         // Initialize time out struct
 552         struct timeval tv;
 553         tv.tv_sec = 0;
 554         tv.tv_usec = timeout_ms * 1000;
 555
 556         // select()
 557         result = select(m_handle+1, &readset, NULL, NULL, &tv);
 558
 559         if (result == 0)
 560                 return false;
 561         else if (result < 0 && (errno == EINTR || errno == EBADF)) {
 562                 // N.B. select() fails when sockets are destroyed on Connection's dtor
 563                 // with EBADF.  Instead of doing tricky synchronization, allow this
 564                 // thread to exit but don't throw an exception.
 565                 return false;
 566         } else if (result < 0) {
 567                 dstream << (int) m_handle << ": Select failed: "
 568                         << strerror(errno) << std::endl;
 569
 570 #ifdef _WIN32
 571                 int e = WSAGetLastError();
 572                 dstream << (int) m_handle << ": WSAGetLastError()="
 573                         << e << std::endl;
 574                 if(e == 10004 /* = WSAEINTR */ || e == 10009 /*WSAEBADF*/)
 575                 {
 576                         dstream << "WARNING: Ignoring WSAEINTR/WSAEBADF." << std::endl;
 577                         return false;
 578                 }
 579 #endif
 580
 581                 throw SocketException("Select failed");
 582         } else if(FD_ISSET(m_handle, &readset) == false) {
 583                 // No data
 584                 return false;
 585         }
 586
 587         // There is data
 588         return true;
 589 }