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