Engine/source/platform/platformNet.cpp

   1 //-----------------------------------------------------------------------------
   2 // Copyright (c) 2012 GarageGames, LLC
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining a copy
   5 // of this software and associated documentation files (the "Software"), to
   6 // deal in the Software without restriction, including without limitation the
   7 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   8 // sell copies of the Software, and to permit persons to whom the Software is
   9 // furnished to do so, subject to the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be included in
  12 // all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  20 // IN THE SOFTWARE.
  21 //-----------------------------------------------------------------------------
  22
  23 #include "platform/platformNet.h"
  24 #include "platform/threads/mutex.h"
  25 #include "core/strings/stringFunctions.h"
  26 #include "core/util/hashFunction.h"
  27 #include "console/consoleTypes.h"
  28
  29 // jamesu - debug DNS
  30 //#define TORQUE_DEBUG_LOOKUPS
  31
  32
  33 #if defined (TORQUE_OS_WIN)
  34 #define TORQUE_USE_WINSOCK
  35 #include <errno.h>
  36 #include <ws2tcpip.h>
  37
  38 #ifndef EINPROGRESS
  39 #define EINPROGRESS             WSAEINPROGRESS
  40 #endif // EINPROGRESS
  41
  42 #define ioctl ioctlsocket
  43
  44 typedef S32 socklen_t;
  45
  46 #elif defined ( TORQUE_OS_MAC )
  47
  48 #include <unistd.h>
  49 #include <sys/types.h>
  50 #include <sys/socket.h>
  51 #include <sys/poll.h>
  52 #include <arpa/inet.h>
  53 #include <netdb.h>
  54 #include <netinet/in.h>
  55 #include <errno.h>
  56 #include <sys/ioctl.h>
  57 #include <net/if.h>
  58
  59 typedef sockaddr_in SOCKADDR_IN;
  60 typedef sockaddr * PSOCKADDR;
  61 typedef sockaddr SOCKADDR;
  62 typedef in_addr IN_ADDR;
  63 typedef int SOCKET;
  64
  65 #define INVALID_SOCKET -1
  66 #define SOCKET_ERROR   -1
  67
  68 #define closesocket close
  69
  70 #elif defined( TORQUE_OS_LINUX )
  71
  72 #include <unistd.h>
  73 #include <sys/types.h>
  74 #include <sys/socket.h>
  75 #include <sys/poll.h>
  76 #include <arpa/inet.h>
  77 #include <netdb.h>
  78 #include <netinet/in.h>
  79 #include <errno.h>
  80 #include <sys/ioctl.h>
  81 #include <net/if.h>
  82
  83 typedef sockaddr_in SOCKADDR_IN;
  84 typedef sockaddr_in6 SOCKADDR_IN6;
  85 typedef sockaddr * PSOCKADDR;
  86 typedef sockaddr SOCKADDR;
  87 typedef in_addr IN_ADDR;
  88 typedef in6_addr IN6_ADDR;
  89 typedef int SOCKET;
  90
  91 #define INVALID_SOCKET -1
  92 #define SOCKET_ERROR   -1
  93
  94 #define closesocket close
  95
  96 #elif defined( TORQUE_OS_XENON )
  97
  98 #include <Xtl.h>
  99 #include <string>
 100
 101 #define TORQUE_USE_WINSOCK
 102 #define EINPROGRESS WSAEINPROGRESS
 103 #define ioctl ioctlsocket
 104 typedef S32 socklen_t;
 105
 106 DWORD _getLastErrorAndClear()
 107 {
 108    DWORD err = WSAGetLastError();
 109    WSASetLastError( 0 );
 110
 111    return err;
 112 }
 113
 114 #else
 115
 116 #endif
 117
 118 #if defined(TORQUE_USE_WINSOCK)
 119 static const char* strerror_wsa( S32 code )
 120 {
 121    switch( code )
 122    {
 123 #define E( name ) case name: return #name;
 124       E( WSANOTINITIALISED );
 125       E( WSAENETDOWN );
 126       E( WSAEADDRINUSE );
 127       E( WSAEINPROGRESS );
 128       E( WSAEALREADY );
 129       E( WSAEADDRNOTAVAIL );
 130       E( WSAEAFNOSUPPORT );
 131       E( WSAEFAULT );
 132       E( WSAEINVAL );
 133       E( WSAEISCONN );
 134       E( WSAENETUNREACH );
 135       E( WSAEHOSTUNREACH );
 136       E( WSAENOBUFS );
 137       E( WSAENOTSOCK );
 138       E( WSAETIMEDOUT );
 139       E( WSAEWOULDBLOCK );
 140       E( WSAEACCES );
 141 #undef E
 142       default:
 143          return "Unknown";
 144    }
 145 }
 146 #endif
 147
 148 #include "core/util/tVector.h"
 149 #include "platform/platformNetAsync.h"
 150 #include "console/console.h"
 151 #include "core/util/journal/process.h"
 152 #include "core/util/journal/journal.h"
 153
 154
 155 NetSocket NetSocket::INVALID = NetSocket::fromHandle(-1);
 156
 157 template<class T> class ReservedSocketList
 158 {
 159 public:
 160    struct EntryType
 161    {
 162       T value;
 163       bool used;
 164
 165       EntryType() : value(-1), used(false) { ; }
 166
 167       bool operator==(const EntryType &e1)
 168       {
 169          return value == e1.value && used == e1.used;
 170       }
 171
 172       bool operator!=(const EntryType &e1)
 173       {
 174          return !(value == e1.value && used == e1.used);
 175       }
 176    };
 177
 178    Vector<EntryType> mSocketList;
 179    Mutex *mMutex;
 180
 181    ReservedSocketList()
 182    {
 183       mMutex = new Mutex;
 184    }
 185
 186    ~ReservedSocketList()
 187    {
 188       delete mMutex;
 189    }
 190
 191    inline void modify() { Mutex::lockMutex(mMutex); }
 192    inline void endModify() { Mutex::unlockMutex(mMutex); }
 193
 194    NetSocket reserve(SOCKET reserveId = -1, bool doLock = true);
 195    void remove(NetSocket socketToRemove, bool doLock = true);
 196
 197    T activate(NetSocket socketToActivate, int family, bool useUDP, bool clearOnFail = false);
 198    T resolve(NetSocket socketToResolve);
 199 };
 200
 201 const SOCKET InvalidSocketHandle = -1;
 202
 203 static void IPSocketToNetAddress(const struct sockaddr_in *sockAddr, NetAddress *address);
 204 static void IPSocket6ToNetAddress(const struct sockaddr_in6 *sockAddr, NetAddress *address);
 205
 206 namespace PlatformNetState
 207 {
 208    static S32 initCount = 0;
 209
 210    static const S32 defaultPort = 28000;
 211    static S32 netPort = 0;
 212
 213    static NetSocket udpSocket = NetSocket::INVALID;
 214    static NetSocket udp6Socket = NetSocket::INVALID;
 215    static NetSocket multicast6Socket = NetSocket::INVALID;
 216
 217    static ipv6_mreq multicast6Group;
 218
 219    static ReservedSocketList<SOCKET> smReservedSocketList;
 220
 221    Net::Error getLastError()
 222    {
 223 #if defined(TORQUE_USE_WINSOCK)
 224       S32 err = WSAGetLastError();
 225       switch (err)
 226       {
 227       case 0:
 228          return Net::NoError;
 229       case WSAEWOULDBLOCK:
 230          return Net::WouldBlock;
 231       default:
 232          return Net::UnknownError;
 233       }
 234 #else
 235       int theError = errno;
 236       if (errno == EAGAIN)
 237          return Net::WouldBlock;
 238       if (errno == 0)
 239          return Net::NoError;
 240       if (errno == EINPROGRESS)
 241          return Net::WouldBlock;
 242
 243       return Net::UnknownError;
 244 #endif
 245    }
 246
 247    S32 getDefaultGameProtocol()
 248    {
 249       // we turn off VDP in non-release builds because VDP does not support broadcast packets
 250       // which are required for LAN queries (PC->Xbox connectivity).  The wire protocol still
 251       // uses the VDP packet structure, though.
 252       S32 protocol = IPPROTO_UDP;
 253       bool useVDP = false;
 254 #ifdef TORQUE_DISABLE_PC_CONNECTIVITY
 255       // Xbox uses a VDP (voice/data protocol) socket for networking
 256       protocol = IPPROTO_VDP;
 257       useVDP = true;
 258 #endif
 259
 260       return protocol;
 261    }
 262
 263    struct addrinfo* pickAddressByProtocol(struct addrinfo* addr, int protocol)
 264    {
 265       for (addr; addr != NULL; addr = addr->ai_next)
 266       {
 267          if (addr->ai_family == protocol)
 268             return addr;
 269       }
 270
 271       return NULL;
 272    }
 273
 274    /// Extracts core address parts from an address string. Returns false if it's malformed.
 275    bool extractAddressParts(const char *addressString, char outAddress[256], int &outPort, int &outFamily)
 276    {
 277       outPort = 0;
 278       outFamily = AF_UNSPEC;
 279
 280       if (!dStrnicmp(addressString, "ipx:", 4))
 281          // ipx support deprecated
 282          return false;
 283
 284       if (!dStrnicmp(addressString, "ip:", 3))
 285       {
 286          addressString += 3;  // eat off the ip:
 287          outFamily = AF_INET;
 288       }
 289       else if (!dStrnicmp(addressString, "ip6:", 4))
 290       {
 291          addressString += 4;  // eat off the ip6:
 292          outFamily = AF_INET6;
 293       }
 294
 295       if (strlen(addressString) > 255)
 296          return false;
 297
 298       char *portString = NULL;
 299
 300       if (addressString[0] == '[')
 301       {
 302          // Must be ipv6 notation
 303          dStrcpy(outAddress, addressString+1);
 304          addressString = outAddress;
 305
 306          portString = dStrchr(outAddress, ']');
 307          if (portString)
 308          {
 309             // Sort out the :port after the ]
 310             *portString++ = '\0';
 311             if (*portString != ':')
 312             {
 313                portString = NULL;
 314             }
 315             else
 316             {
 317                *portString++ = '\0';
 318             }
 319          }
 320
 321          if (outFamily == AF_UNSPEC)
 322          {
 323             outFamily = AF_INET6;
 324          }
 325       }
 326       else
 327       {
 328          dStrcpy(outAddress, addressString);
 329          addressString = outAddress;
 330
 331          // Check to see if we have multiple ":" which would indicate this is an ipv6 address
 332          char* scan = outAddress;
 333          int colonCount = 0;
 334          while (*scan != '\0' && colonCount < 2)
 335          {
 336             if (*scan++ == ':')
 337                colonCount++;
 338          }
 339          if (colonCount <= 1)
 340          {
 341             // either ipv4 or host
 342             portString = dStrchr(outAddress, ':');
 343
 344             if (portString)
 345             {
 346                *portString++ = '\0';
 347             }
 348          }
 349          else if (outFamily == AF_UNSPEC)
 350          {
 351             // Must be ipv6
 352             outFamily = AF_INET6;
 353          }
 354       }
 355
 356       if (portString)
 357       {
 358          outPort = dAtoi(portString);
 359       }
 360
 361       return true;
 362    }
 363
 364    Net::Error getSocketAddress(SOCKET socketFd, int requiredFamily, NetAddress *outAddress)
 365    {
 366       Net::Error error = Net::UnknownError;
 367
 368       if (requiredFamily == AF_INET)
 369       {
 370          sockaddr_in ipAddr;
 371          int len = sizeof(ipAddr);
 372          if (getsockname(socketFd, (struct sockaddr*)&ipAddr, &len) >= 0)
 373          {
 374             IPSocketToNetAddress(&ipAddr, outAddress);
 375             error = Net::NoError;
 376          }
 377          else
 378          {
 379             error = getLastError();
 380          }
 381       }
 382       else if (requiredFamily == AF_INET6)
 383       {
 384          sockaddr_in6 ipAddr;
 385          int len = sizeof(ipAddr);
 386          if (getsockname(socketFd, (struct sockaddr*)&ipAddr, &len) >= 0)
 387          {
 388             IPSocket6ToNetAddress(&ipAddr, outAddress);
 389             error = Net::NoError;
 390          }
 391          else
 392          {
 393             error = getLastError();
 394          }
 395       }
 396
 397       return error;
 398    }
 399 };
 400
 401
 402
 403 template<class T> NetSocket ReservedSocketList<T>::reserve(SOCKET reserveId, bool doLock)
 404 {
 405    MutexHandle handle;
 406    if (doLock)
 407    {
 408       handle.lock(mMutex, true);
 409    }
 410
 411    S32 idx = mSocketList.find_next(EntryType());
 412    if (idx == -1)
 413    {
 414       EntryType entry;
 415       entry.value = reserveId;
 416       entry.used = true;
 417       mSocketList.push_back(entry);
 418       return NetSocket::fromHandle(mSocketList.size() - 1);
 419    }
 420    else
 421    {
 422       EntryType &entry = mSocketList[idx];
 423       entry.used = true;
 424       entry.value = reserveId;
 425    }
 426
 427    return NetSocket::fromHandle(idx);
 428 }
 429
 430 template<class T> void ReservedSocketList<T>::remove(NetSocket socketToRemove, bool doLock)
 431 {
 432    MutexHandle handle;
 433    if (doLock)
 434    {
 435       handle.lock(mMutex, true);
 436    }
 437
 438    if ((U32)socketToRemove.getHandle() >= (U32)mSocketList.size())
 439       return;
 440
 441    mSocketList[socketToRemove.getHandle()] = EntryType();
 442 }
 443
 444 template<class T> T ReservedSocketList<T>::activate(NetSocket socketToActivate, int family, bool useUDP, bool clearOnFail)
 445 {
 446    MutexHandle h;
 447    h.lock(mMutex, true);
 448
 449    int typeID = useUDP ? SOCK_DGRAM : SOCK_STREAM;
 450    int protocol = useUDP ? PlatformNetState::getDefaultGameProtocol() : 0;
 451
 452    if ((U32)socketToActivate.getHandle() >= (U32)mSocketList.size())
 453       return -1;
 454
 455    EntryType &entry = mSocketList[socketToActivate.getHandle()];
 456    if (!entry.used)
 457       return -1;
 458
 459    T socketFd = entry.value;
 460    if (socketFd == -1)
 461    {
 462       socketFd = ::socket(family, typeID, protocol);
 463
 464       if (socketFd == InvalidSocketHandle)
 465       {
 466          if (clearOnFail)
 467          {
 468             remove(socketToActivate, false);
 469          }
 470          return InvalidSocketHandle;
 471       }
 472       else
 473       {
 474          entry.used = true;
 475          entry.value = socketFd;
 476          return socketFd;
 477       }
 478    }
 479
 480    return socketFd;
 481 }
 482
 483 template<class T> T ReservedSocketList<T>::resolve(NetSocket socketToResolve)
 484 {
 485    MutexHandle h;
 486    h.lock(mMutex, true);
 487
 488    if ((U32)socketToResolve.getHandle() >= (U32)mSocketList.size())
 489       return -1;
 490
 491    EntryType &entry = mSocketList[socketToResolve.getHandle()];
 492    return entry.used ? entry.value : -1;
 493 }
 494
 495 static ConnectionNotifyEvent*   smConnectionNotify = NULL;
 496 static ConnectionAcceptedEvent* smConnectionAccept = NULL;
 497 static ConnectionReceiveEvent*  smConnectionReceive = NULL;
 498 static PacketReceiveEvent*      smPacketReceive = NULL;
 499
 500 ConnectionNotifyEvent& Net::getConnectionNotifyEvent()
 501 {
 502    return *smConnectionNotify;
 503 }
 504
 505 ConnectionAcceptedEvent& Net::getConnectionAcceptedEvent()
 506 {
 507    return *smConnectionAccept;
 508 }
 509
 510 ConnectionReceiveEvent& Net::getConnectionReceiveEvent()
 511 {
 512    return *smConnectionReceive;
 513 }
 514
 515 PacketReceiveEvent& Net::getPacketReceiveEvent()
 516 {
 517    return *smPacketReceive;
 518 }
 519
 520 // Multicast stuff
 521 bool Net::smMulticastEnabled = true;
 522 //
 523 // Protocol Stuff
 524 bool Net::smIpv4Enabled = true;
 525 bool Net::smIpv6Enabled = false;
 526 //
 527
 528 // the Socket structure helps us keep track of the
 529 // above states
 530 struct PolledSocket
 531 {
 532    // local enum for socket states for polled sockets
 533    enum SocketState
 534    {
 535       InvalidState,
 536       Connected,
 537       ConnectionPending,
 538       Listening,
 539       NameLookupRequired
 540    };
 541
 542    PolledSocket()
 543    {
 544       fd = -1;
 545       handleFd = NetSocket::INVALID;
 546       state = InvalidState;
 547       remoteAddr[0] = 0;
 548       remotePort = -1;
 549    }
 550
 551    SOCKET fd;
 552    NetSocket handleFd;
 553    S32 state;
 554    char remoteAddr[256];
 555    S32 remotePort;
 556 };
 557
 558 // list of polled sockets
 559 static Vector<PolledSocket*> gPolledSockets( __FILE__, __LINE__ );
 560
 561 static PolledSocket* addPolledSocket(NetSocket handleFd, SOCKET fd, S32 state,
 562                                char* remoteAddr = NULL, S32 port = -1)
 563 {
 564    PolledSocket* sock = new PolledSocket();
 565    sock->fd = fd;
 566    sock->handleFd = handleFd;
 567    sock->state = state;
 568    if (remoteAddr)
 569       dStrcpy(sock->remoteAddr, remoteAddr);
 570    if (port != -1)
 571       sock->remotePort = port;
 572    gPolledSockets.push_back(sock);
 573    return sock;
 574 }
 575
 576 bool netSocketWaitForWritable(NetSocket handleFd, S32 timeoutMs)
 577 {
 578    fd_set writefds;
 579    timeval timeout;
 580    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
 581
 582    FD_ZERO( &writefds );
 583    FD_SET( socketFd, &writefds );
 584
 585    timeout.tv_sec = timeoutMs / 1000;
 586    timeout.tv_usec = ( timeoutMs % 1000 ) * 1000;
 587
 588    if( select(socketFd + 1, NULL, &writefds, NULL, &timeout) > 0 )
 589       return true;
 590
 591    return false;
 592 }
 593
 594 bool Net::init()
 595 {
 596 #if defined(TORQUE_USE_WINSOCK)
 597    if(!PlatformNetState::initCount)
 598    {
 599 #ifdef TORQUE_OS_XENON
 600       // Configure startup parameters
 601       XNetStartupParams xnsp;
 602       memset( &xnsp, 0, sizeof( xnsp ) );
 603       xnsp.cfgSizeOfStruct = sizeof( XNetStartupParams );
 604
 605 #ifndef TORQUE_DISABLE_PC_CONNECTIVITY
 606       xnsp.cfgFlags = XNET_STARTUP_BYPASS_SECURITY;
 607       Con::warnf("XNET_STARTUP_BYPASS_SECURITY enabled! This build can talk to PCs!");
 608 #endif
 609
 610       AssertISV( !XNetStartup( &xnsp ), "Net::init - failed to init XNet" );
 611 #endif
 612
 613       WSADATA stWSAData;
 614       AssertISV( !WSAStartup( 0x0101, &stWSAData ), "Net::init - failed to init WinSock!" );
 615
 616       //logprintf("Winsock initialization %s", success ? "succeeded." : "failed!");
 617    }
 618 #endif
 619    PlatformNetState::initCount++;
 620
 621    smConnectionNotify = new ConnectionNotifyEvent();
 622    smConnectionAccept = new ConnectionAcceptedEvent();
 623    smConnectionReceive = new ConnectionReceiveEvent();
 624    smPacketReceive = new PacketReceiveEvent();
 625
 626
 627    Process::notify(&Net::process, PROCESS_NET_ORDER);
 628
 629    return(true);
 630 }
 631
 632 void Net::shutdown()
 633 {
 634    Process::remove(&Net::process);
 635
 636    while (gPolledSockets.size() > 0)
 637    {
 638       if (gPolledSockets[0] == NULL)
 639          gPolledSockets.erase(gPolledSockets.begin());
 640       else
 641          closeConnectTo(gPolledSockets[0]->handleFd);
 642    }
 643
 644    closePort();
 645    PlatformNetState::initCount--;
 646
 647    // Destroy event handlers
 648    delete smConnectionNotify;
 649    delete smConnectionAccept;
 650    delete smConnectionReceive;
 651    delete smPacketReceive;
 652
 653 #if defined(TORQUE_USE_WINSOCK)
 654    if(!PlatformNetState::initCount)
 655    {
 656       WSACleanup();
 657
 658 #ifdef TORQUE_OS_XENON
 659       XNetCleanup();
 660 #endif
 661    }
 662 #endif
 663 }
 664
 665 // ipv4 version of name routines
 666
 667 static void NetAddressToIPSocket(const NetAddress *address, struct sockaddr_in *sockAddr)
 668 {
 669    dMemset(sockAddr, 0, sizeof(struct sockaddr_in));
 670    sockAddr->sin_family = AF_INET;
 671    sockAddr->sin_port = htons(address->port);
 672    #if defined(TORQUE_OS_BSD) || defined(TORQUE_OS_MAC)
 673    sockAddr->sin_len = sizeof(struct sockaddr_in);
 674    #endif
 675    if (address->type == NetAddress::IPBroadcastAddress)
 676    {
 677       sockAddr->sin_addr.s_addr = htonl(INADDR_BROADCAST);
 678    }
 679    else
 680    {
 681       dMemcpy(&sockAddr->sin_addr, &address->address.ipv4.netNum[0], 4);
 682    }
 683 }
 684
 685 static void IPSocketToNetAddress(const struct sockaddr_in *sockAddr, NetAddress *address)
 686 {
 687    address->type = NetAddress::IPAddress;
 688    address->port = ntohs(sockAddr->sin_port);
 689    dMemcpy(&address->address.ipv4.netNum[0], &sockAddr->sin_addr, 4);
 690 }
 691
 692 // ipv6 version of name routines
 693
 694 static void NetAddressToIPSocket6(const NetAddress *address, struct sockaddr_in6 *sockAddr)
 695 {
 696    dMemset(sockAddr, 0, sizeof(struct sockaddr_in6));
 697 #ifdef SIN6_LEN
 698    sockAddr->sin6_len = sizeof(struct sockaddr_in6);
 699 #endif
 700    sockAddr->sin6_family = AF_INET6;
 701    sockAddr->sin6_port = ntohs(address->port);
 702
 703    if (address->type == NetAddress::IPV6MulticastAddress)
 704    {
 705       sockAddr->sin6_addr = PlatformNetState::multicast6Group.ipv6mr_multiaddr;
 706       sockAddr->sin6_scope_id = PlatformNetState::multicast6Group.ipv6mr_interface;
 707    }
 708    else
 709    {
 710       sockAddr->sin6_flowinfo = address->address.ipv6.netFlow;
 711       sockAddr->sin6_scope_id = address->address.ipv6.netScope;
 712       dMemcpy(&sockAddr->sin6_addr, address->address.ipv6.netNum, sizeof(address->address.ipv6.netNum));
 713    }
 714 }
 715
 716 static void IPSocket6ToNetAddress(const struct sockaddr_in6 *sockAddr, NetAddress *address)
 717 {
 718    address->type = NetAddress::IPV6Address;
 719    address->port = ntohs(sockAddr->sin6_port);
 720    dMemcpy(address->address.ipv6.netNum, &sockAddr->sin6_addr, sizeof(address->address.ipv6.netNum));
 721    address->address.ipv6.netFlow = sockAddr->sin6_flowinfo;
 722    address->address.ipv6.netScope = sockAddr->sin6_scope_id;
 723 }
 724
 725 //
 726
 727 NetSocket Net::openListenPort(U16 port, NetAddress::Type addressType)
 728 {
 729    if(Journal::IsPlaying())
 730    {
 731       U32 ret;
 732       Journal::Read(&ret);
 733       return NetSocket::fromHandle(ret);
 734    }
 735
 736    Net::Error error = NoError;
 737    NetAddress address;
 738    if (Net::getListenAddress(addressType, &address) != Net::NoError)
 739       error = Net::WrongProtocolType;
 740
 741    NetSocket handleFd = NetSocket::INVALID;
 742    SOCKET sockId = InvalidSocketHandle;
 743
 744    if (error == NoError)
 745    {
 746       handleFd = openSocket();
 747       sockId = PlatformNetState::smReservedSocketList.activate(handleFd, address.type == NetAddress::IPAddress ? AF_INET : AF_INET6, false, true);
 748    }
 749
 750    if (error == NoError && (handleFd == NetSocket::INVALID || sockId == InvalidSocketHandle))
 751    {
 752       Con::errorf("Unable to open listen socket: %s", strerror(errno));
 753       error = NotASocket;
 754       handleFd = NetSocket::INVALID;
 755    }
 756
 757    if (error == NoError)
 758    {
 759       address.port = port;
 760       error = bindAddress(address, handleFd, false);
 761       if (error != NoError)
 762       {
 763          Con::errorf("Unable to bind port %d: %s", port, strerror(errno));
 764          closeSocket(handleFd);
 765          handleFd = NetSocket::INVALID;
 766       }
 767    }
 768
 769    if (error == NoError)
 770    {
 771       error = listen(handleFd, 4);
 772       if (error != NoError)
 773       {
 774          Con::errorf("Unable to listen on port %d: %s", port, strerror(errno));
 775          closeSocket(handleFd);
 776          handleFd = NetSocket::INVALID;
 777       }
 778    }
 779
 780    if (error == NoError)
 781    {
 782       setBlocking(handleFd, false);
 783       addPolledSocket(handleFd, sockId, PolledSocket::Listening);
 784    }
 785
 786    if(Journal::IsRecording())
 787       Journal::Write(U32(handleFd.getHandle()));
 788
 789    return handleFd;
 790 }
 791
 792 NetSocket Net::openConnectTo(const char *addressString)
 793 {
 794    if (Journal::IsPlaying())
 795    {
 796       U32 ret;
 797       Journal::Read(&ret);
 798       return NetSocket::fromHandle(ret);
 799    }
 800
 801    NetAddress address;
 802    NetSocket handleFd = NetSocket::INVALID;
 803    Net::Error error = NoError;
 804
 805    error = Net::stringToAddress(addressString, &address, false);
 806
 807    if (error == NoError && address.type != NetAddress::IPAddress && address.type != NetAddress::IPV6Address)
 808    {
 809       error = Net::WrongProtocolType;
 810    }
 811
 812    if (error != NoError || error == NeedHostLookup)
 813    {
 814       handleFd = openSocket();
 815    }
 816
 817    // Attempt to connect or queue a lookup
 818    if (error == NoError && address.type == NetAddress::IPAddress)
 819    {
 820       sockaddr_in ipAddr;
 821       NetAddressToIPSocket(&address, &ipAddr);
 822       SOCKET socketFd = PlatformNetState::smReservedSocketList.activate(handleFd, AF_INET, false, true);
 823       if (socketFd != InvalidSocketHandle)
 824       {
 825          setBlocking(handleFd, false);
 826          if (::connect(socketFd, (struct sockaddr *)&ipAddr, sizeof(ipAddr)) == -1 &&
 827             errno != EINPROGRESS)
 828          {
 829             Con::errorf("Error connecting %s: %s",
 830                addressString, strerror(errno));
 831             closeSocket(handleFd);
 832             handleFd = NetSocket::INVALID;
 833          }
 834       }
 835       else
 836       {
 837          PlatformNetState::smReservedSocketList.remove(handleFd);
 838          handleFd = NetSocket::INVALID;
 839       }
 840
 841       if (handleFd != NetSocket::INVALID)
 842       {
 843          // add this socket to our list of polled sockets
 844          addPolledSocket(handleFd, socketFd, PolledSocket::ConnectionPending);
 845       }
 846    }
 847    else if (error == NoError && address.type == NetAddress::IPV6Address)
 848    {
 849       sockaddr_in6 ipAddr6;
 850       NetAddressToIPSocket6(&address, &ipAddr6);
 851       SOCKET socketFd = PlatformNetState::smReservedSocketList.activate(handleFd, AF_INET6, false, true);
 852       if (::connect(socketFd, (struct sockaddr *)&ipAddr6, sizeof(ipAddr6)) == -1 &&
 853          errno != EINPROGRESS)
 854       {
 855          setBlocking(handleFd, false);
 856          Con::errorf("Error connecting %s: %s",
 857             addressString, strerror(errno));
 858          closeSocket(handleFd);
 859          handleFd = NetSocket::INVALID;
 860       }
 861       else
 862       {
 863          PlatformNetState::smReservedSocketList.remove(handleFd);
 864          handleFd = NetSocket::INVALID;
 865       }
 866
 867       if (handleFd != NetSocket::INVALID)
 868       {
 869          // add this socket to our list of polled sockets
 870          addPolledSocket(handleFd, socketFd, PolledSocket::ConnectionPending);
 871       }
 872    }
 873    else if (error == Net::NeedHostLookup)
 874    {
 875       // need to do an asynchronous name lookup.  first, add the socket
 876       // to the polled list
 877       char addr[256];
 878       int port = 0;
 879       int actualFamily = AF_UNSPEC;
 880       if (PlatformNetState::extractAddressParts(addressString, addr, port, actualFamily))
 881       {
 882          addPolledSocket(handleFd, InvalidSocketHandle, PolledSocket::NameLookupRequired, addr, port);
 883          // queue the lookup
 884          gNetAsync.queueLookup(addressString, handleFd);
 885       }
 886       else
 887       {
 888          closeSocket(handleFd);
 889          handleFd = NetSocket::INVALID;
 890       }
 891    }
 892    else
 893    {
 894       closeSocket(handleFd);
 895       handleFd = NetSocket::INVALID;
 896    }
 897
 898    if (Journal::IsRecording())
 899       Journal::Write(U32(handleFd.getHandle()));
 900    return handleFd;
 901 }
 902
 903 void Net::closeConnectTo(NetSocket handleFd)
 904 {
 905    if(Journal::IsPlaying())
 906       return;
 907
 908    // if this socket is in the list of polled sockets, remove it
 909    for (S32 i = 0; i < gPolledSockets.size(); ++i)
 910    {
 911       if (gPolledSockets[i] && gPolledSockets[i]->handleFd == handleFd)
 912       {
 913          delete gPolledSockets[i];
 914          gPolledSockets[i] = NULL;
 915          break;
 916       }
 917    }
 918
 919    closeSocket(handleFd);
 920 }
 921
 922 Net::Error Net::sendtoSocket(NetSocket handleFd, const U8 *buffer, S32  bufferSize, S32 *outBufferWritten)
 923 {
 924    if(Journal::IsPlaying())
 925    {
 926       U32 e;
 927       S32 outBytes;
 928       Journal::Read(&e);
 929       Journal::Read(&outBytes);
 930       if (outBufferWritten)
 931          *outBufferWritten = outBytes;
 932
 933       return (Net::Error) e;
 934    }
 935
 936    S32 outBytes = 0;
 937    Net::Error e = send(handleFd, buffer, bufferSize, &outBytes);
 938
 939    if (Journal::IsRecording())
 940    {
 941       Journal::Write(U32(e));
 942       Journal::Write(outBytes);
 943    }
 944
 945    if (outBufferWritten)
 946       *outBufferWritten = outBytes;
 947
 948    return e;
 949 }
 950
 951 bool Net::openPort(S32 port, bool doBind)
 952 {
 953    if (PlatformNetState::udpSocket != NetSocket::INVALID)
 954    {
 955       closeSocket(PlatformNetState::udpSocket);
 956       PlatformNetState::udpSocket = NetSocket::INVALID;
 957    }
 958    if (PlatformNetState::udp6Socket != NetSocket::INVALID)
 959    {
 960       closeSocket(PlatformNetState::udp6Socket);
 961       PlatformNetState::udp6Socket = NetSocket::INVALID;
 962    }
 963
 964    // Update prefs
 965    Net::smMulticastEnabled = Con::getBoolVariable("pref::Net::Multicast6Enabled", true);
 966    Net::smIpv4Enabled = Con::getBoolVariable("pref::Net::IPV4Enabled", true);
 967    Net::smIpv6Enabled = Con::getBoolVariable("pref::Net::IPV6Enabled", false);
 968
 969    // we turn off VDP in non-release builds because VDP does not support broadcast packets
 970    // which are required for LAN queries (PC->Xbox connectivity).  The wire protocol still
 971    // uses the VDP packet structure, though.
 972    S32 protocol = PlatformNetState::getDefaultGameProtocol();
 973
 974    SOCKET socketFd = InvalidSocketHandle;
 975    NetAddress address;
 976    NetAddress listenAddress;
 977    char listenAddressStr[256];
 978
 979    if (Net::smIpv4Enabled)
 980    {
 981       if (Net::getListenAddress(NetAddress::IPAddress, &address) == Net::NoError)
 982       {
 983          address.port = port;
 984          socketFd = ::socket(AF_INET, SOCK_DGRAM, protocol);
 985
 986          if (socketFd != InvalidSocketHandle)
 987          {
 988             PlatformNetState::udpSocket = PlatformNetState::smReservedSocketList.reserve(socketFd);
 989             Net::Error error = NoError;
 990             if (doBind)
 991             {
 992                error = bindAddress(address, PlatformNetState::udpSocket, true);
 993             }
 994
 995             if (error == NoError)
 996                error = setBufferSize(PlatformNetState::udpSocket, 32768 * 8);
 997
 998 #ifndef TORQUE_DISABLE_PC_CONNECTIVITY
 999             if (error == NoError)
1000                error = setBroadcast(PlatformNetState::udpSocket, true);
1001 #endif
1002
1003             if (error == NoError)
1004                error = setBlocking(PlatformNetState::udpSocket, false);
1005
1006             if (error == NoError)
1007             {
1008                error = PlatformNetState::getSocketAddress(socketFd, AF_INET, &listenAddress);
1009                if (error == NoError)
1010                {
1011                   Net::addressToString(&listenAddress, listenAddressStr);
1012                   Con::printf("UDP initialized on ipv4 %s", listenAddressStr);
1013                }
1014             }
1015
1016             if (error != NoError)
1017             {
1018                closeSocket(PlatformNetState::udpSocket);
1019                PlatformNetState::udpSocket = NetSocket::INVALID;
1020                Con::printf("Unable to initialize UDP on ipv4 - error %d", error);
1021             }
1022          }
1023       }
1024       else
1025       {
1026          Con::errorf("Unable to initialize UDP on ipv4 - invalid address.");
1027          PlatformNetState::udpSocket = NetSocket::INVALID;
1028       }
1029    }
1030
1031    if (Net::smIpv6Enabled)
1032    {
1033       if (Net::getListenAddress(NetAddress::IPV6Address, &address) == Net::NoError)
1034       {
1035          address.port = port;
1036          socketFd = ::socket(AF_INET6, SOCK_DGRAM, protocol);
1037
1038          if (socketFd != InvalidSocketHandle)
1039          {
1040             PlatformNetState::udp6Socket = PlatformNetState::smReservedSocketList.reserve(socketFd);
1041
1042             Net::Error error = NoError;
1043
1044             int v = 1;
1045             setsockopt(socketFd, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&v, sizeof(v));
1046             PlatformNetState::getLastError();
1047
1048             if (doBind)
1049             {
1050                error = bindAddress(address, PlatformNetState::udp6Socket, true);
1051             }
1052
1053             if (error == NoError)
1054                error = setBufferSize(PlatformNetState::udp6Socket, 32768 * 8);
1055
1056             if (error == NoError)
1057                error = setBlocking(PlatformNetState::udp6Socket, false);
1058
1059             if (error == NoError)
1060             {
1061                error = PlatformNetState::getSocketAddress(socketFd, AF_INET6, &listenAddress);
1062                if (error == NoError)
1063                {
1064                   Net::addressToString(&listenAddress, listenAddressStr);
1065                   Con::printf("UDP initialized on ipv6 %s", listenAddressStr);
1066                }
1067             }
1068
1069             if (error != NoError)
1070             {
1071                closeSocket(PlatformNetState::udp6Socket);
1072                PlatformNetState::udp6Socket = NetSocket::INVALID;
1073                Con::printf("Unable to initialize UDP on ipv6 - error %d", error);
1074             }
1075
1076             if (Net::smMulticastEnabled && doBind)
1077             {
1078                Net::enableMulticast();
1079             }
1080             else
1081             {
1082                Net::disableMulticast();
1083             }
1084          }
1085       }
1086    }
1087
1088    PlatformNetState::netPort = port;
1089
1090    return PlatformNetState::udpSocket != NetSocket::INVALID || PlatformNetState::udp6Socket != NetSocket::INVALID;
1091 }
1092
1093 NetSocket Net::getPort()
1094 {
1095    return PlatformNetState::udpSocket;
1096 }
1097
1098 void Net::closePort()
1099 {
1100    if (PlatformNetState::udpSocket != NetSocket::INVALID)
1101       closeSocket(PlatformNetState::udpSocket);
1102    if (PlatformNetState::udp6Socket != NetSocket::INVALID)
1103       closeSocket(PlatformNetState::udp6Socket);
1104 }
1105
1106 Net::Error Net::sendto(const NetAddress *address, const U8 *buffer, S32  bufferSize)
1107 {
1108    if(Journal::IsPlaying())
1109       return NoError;
1110
1111    SOCKET socketFd;
1112
1113    if(address->type == NetAddress::IPAddress || address->type == NetAddress::IPBroadcastAddress)
1114    {
1115       socketFd = PlatformNetState::smReservedSocketList.resolve(PlatformNetState::udpSocket);
1116       if (socketFd != InvalidSocketHandle)
1117       {
1118          sockaddr_in ipAddr;
1119          NetAddressToIPSocket(address, &ipAddr);
1120
1121          if (::sendto(socketFd, (const char*)buffer, bufferSize, 0,
1122             (sockaddr *)&ipAddr, sizeof(sockaddr_in)) == SOCKET_ERROR)
1123             return PlatformNetState::getLastError();
1124          else
1125             return NoError;
1126       }
1127       else
1128       {
1129          return NotASocket;
1130       }
1131    }
1132    else if (address->type == NetAddress::IPV6Address || address->type == NetAddress::IPV6MulticastAddress)
1133    {
1134       socketFd = PlatformNetState::smReservedSocketList.resolve(address->type == NetAddress::IPV6MulticastAddress ? PlatformNetState::multicast6Socket : PlatformNetState::udp6Socket);
1135
1136       if (socketFd != InvalidSocketHandle)
1137       {
1138          sockaddr_in6 ipAddr;
1139          NetAddressToIPSocket6(address, &ipAddr);
1140          if (::sendto(socketFd, (const char*)buffer, bufferSize, 0,
1141           (struct sockaddr *) &ipAddr, sizeof(sockaddr_in6)) == SOCKET_ERROR)
1142             return PlatformNetState::getLastError();
1143          else
1144             return NoError;
1145       }
1146       else
1147       {
1148          return NotASocket;
1149       }
1150    }
1151
1152    return WrongProtocolType;
1153 }
1154
1155 void Net::process()
1156 {
1157    // Process listening sockets
1158    processListenSocket(PlatformNetState::udpSocket);
1159    processListenSocket(PlatformNetState::udp6Socket);
1160
1161    // process the polled sockets.  This blob of code performs functions
1162    // similar to WinsockProc in winNet.cc
1163
1164    if (gPolledSockets.size() == 0)
1165       return;
1166
1167    S32 optval;
1168    socklen_t optlen = sizeof(S32);
1169    S32 bytesRead;
1170    Net::Error err;
1171    bool removeSock = false;
1172    PolledSocket *currentSock = NULL;
1173    NetSocket incomingHandleFd = NetSocket::INVALID;
1174    NetAddress out_h_addr;
1175    S32 out_h_length = 0;
1176    RawData readBuff;
1177    NetSocket removeSockHandle;
1178
1179    for (S32 i = 0; i < gPolledSockets.size();
1180       /* no increment, this is done at end of loop body */)
1181    {
1182       removeSock = false;
1183       currentSock = gPolledSockets[i];
1184
1185       // Cleanup if we've removed it
1186       if (currentSock == NULL)
1187       {
1188          gPolledSockets.erase(i);
1189          continue;
1190       }
1191
1192       switch (currentSock->state)
1193       {
1194       case PolledSocket::InvalidState:
1195          Con::errorf("Error, InvalidState socket in polled sockets  list");
1196          break;
1197       case PolledSocket::ConnectionPending:
1198          // see if it is now connected
1199 #ifdef TORQUE_OS_XENON
1200          // WSASetLastError has no return value, however part of the SO_ERROR behavior
1201          // is to clear the last error, so this needs to be done here.
1202          if( ( optval = _getLastErrorAndClear() ) == -1 )
1203 #else
1204          if (getsockopt(currentSock->fd, SOL_SOCKET, SO_ERROR,
1205             (char*)&optval, &optlen) == -1)
1206 #endif
1207          {
1208             Con::errorf("Error getting socket options: %s",  strerror(errno));
1209
1210             removeSock = true;
1211             removeSockHandle = currentSock->handleFd;
1212
1213             smConnectionNotify->trigger(currentSock->handleFd, Net::ConnectFailed);
1214          }
1215          else
1216          {
1217             if (optval == EINPROGRESS)
1218                // still connecting...
1219                break;
1220
1221             if (optval == 0)
1222             {
1223                // poll for writable status to be sure we're connected.
1224                bool ready = netSocketWaitForWritable(currentSock->handleFd,0);
1225                if(!ready)
1226                   break;
1227
1228                currentSock->state = PolledSocket::Connected;
1229                smConnectionNotify->trigger(currentSock->handleFd, Net::Connected);
1230             }
1231             else
1232             {
1233                // some kind of error
1234                Con::errorf("Error connecting: %s", strerror(errno));
1235
1236                removeSock = true;
1237                removeSockHandle = currentSock->handleFd;
1238
1239                smConnectionNotify->trigger(currentSock->handleFd, Net::ConnectFailed);
1240             }
1241          }
1242          break;
1243       case PolledSocket::Connected:
1244
1245          // try to get some data
1246          bytesRead = 0;
1247          readBuff.alloc(MaxPacketDataSize);
1248          err = Net::recv(currentSock->handleFd, (U8*)readBuff.data, MaxPacketDataSize, &bytesRead);
1249          if(err == Net::NoError)
1250          {
1251             if (bytesRead > 0)
1252             {
1253                // got some data, post it
1254                readBuff.size = bytesRead;
1255                smConnectionReceive->trigger(currentSock->handleFd, readBuff);
1256             }
1257             else
1258             {
1259                // ack! this shouldn't happen
1260                if (bytesRead < 0)
1261                   Con::errorf("Unexpected error on socket: %s", strerror(errno));
1262
1263                removeSock = true;
1264                removeSockHandle = currentSock->handleFd;
1265
1266                // zero bytes read means EOF
1267                smConnectionNotify->trigger(currentSock->handleFd, Net::Disconnected);
1268             }
1269          }
1270          else if (err != Net::NoError && err != Net::WouldBlock)
1271          {
1272             Con::errorf("Error reading from socket: %s",  strerror(errno));
1273
1274             removeSock = true;
1275             removeSockHandle = currentSock->handleFd;
1276
1277             smConnectionNotify->trigger(currentSock->handleFd, Net::Disconnected);
1278          }
1279          break;
1280       case PolledSocket::NameLookupRequired:
1281          U32 newState;
1282
1283          // is the lookup complete?
1284          if (!gNetAsync.checkLookup(
1285             currentSock->handleFd, &out_h_addr, &out_h_length,
1286             sizeof(out_h_addr)))
1287             break;
1288
1289          if (out_h_length == -1)
1290          {
1291             Con::errorf("DNS lookup failed: %s", currentSock->remoteAddr);
1292             newState = Net::DNSFailed;
1293             removeSock = true;
1294             removeSockHandle = currentSock->handleFd;
1295          }
1296          else
1297          {
1298             // try to connect
1299             out_h_addr.port = currentSock->remotePort;
1300             const sockaddr *ai_addr = NULL;
1301             int ai_addrlen = 0;
1302             sockaddr_in socketAddress;
1303             sockaddr_in6 socketAddress6;
1304
1305             if (out_h_addr.type == NetAddress::IPAddress)
1306             {
1307                ai_addr = (const sockaddr*)&socketAddress;
1308                ai_addrlen = sizeof(socketAddress);
1309                NetAddressToIPSocket(&out_h_addr, &socketAddress);
1310
1311                currentSock->fd = PlatformNetState::smReservedSocketList.activate(currentSock->handleFd, AF_INET, false);
1312                setBlocking(currentSock->handleFd, false);
1313
1314 #ifdef TORQUE_DEBUG_LOOKUPS
1315                char addrString[256];
1316                NetAddress addr;
1317                IPSocketToNetAddress(&socketAddress, &addr);
1318                Net::addressToString(&addr, addrString);
1319                Con::printf("DNS: lookup resolved to %s", addrString);
1320 #endif
1321             }
1322             else if (out_h_addr.type == NetAddress::IPV6Address)
1323             {
1324                ai_addr = (const sockaddr*)&socketAddress6;
1325                ai_addrlen = sizeof(socketAddress6);
1326                NetAddressToIPSocket6(&out_h_addr, &socketAddress6);
1327
1328                currentSock->fd = PlatformNetState::smReservedSocketList.activate(currentSock->handleFd, AF_INET6, false);
1329                setBlocking(currentSock->handleFd, false);
1330
1331 #ifdef TORQUE_DEBUG_LOOKUPS
1332                char addrString[256];
1333                NetAddress addr;
1334                IPSocket6ToNetAddress(&socketAddress6, &addr);
1335                Net::addressToString(&addr, addrString);
1336                Con::printf("DNS: lookup resolved to %s", addrString);
1337 #endif
1338             }
1339             else
1340             {
1341                Con::errorf("Error connecting to %s: Invalid Protocol",
1342                currentSock->remoteAddr);
1343                newState = Net::ConnectFailed;
1344                removeSock = true;
1345                removeSockHandle = currentSock->handleFd;
1346             }
1347
1348             if (ai_addr)
1349             {
1350                if (::connect(currentSock->fd, ai_addr,
1351                   ai_addrlen) == -1)
1352                {
1353                   err = PlatformNetState::getLastError();
1354                   if (err != Net::WouldBlock)
1355                   {
1356                      Con::errorf("Error connecting to %s: %u",
1357                      currentSock->remoteAddr, err);
1358                      newState = Net::ConnectFailed;
1359                      removeSock = true;
1360                      removeSockHandle = currentSock->handleFd;
1361                   }
1362                   else
1363                   {
1364                      newState = Net::DNSResolved;
1365                      currentSock->state = PolledSocket::ConnectionPending;
1366                   }
1367                }
1368                else
1369                {
1370                   newState = Net::Connected;
1371                   currentSock->state = Connected;
1372                }
1373             }
1374          }
1375
1376          smConnectionNotify->trigger(currentSock->handleFd, newState);
1377          break;
1378       case PolledSocket::Listening:
1379          NetAddress incomingAddy;
1380
1381          incomingHandleFd = Net::accept(currentSock->handleFd, &incomingAddy);
1382          if(incomingHandleFd != NetSocket::INVALID)
1383          {
1384             setBlocking(incomingHandleFd, false);
1385             addPolledSocket(incomingHandleFd, PlatformNetState::smReservedSocketList.resolve(incomingHandleFd), Connected);
1386             smConnectionAccept->trigger(currentSock->handleFd, incomingHandleFd, incomingAddy);
1387          }
1388          break;
1389       }
1390
1391       // only increment index if we're not removing the connection,  since
1392       // the removal will shift the indices down by one
1393       if (removeSock)
1394          closeConnectTo(removeSockHandle);
1395       else
1396          i++;
1397    }
1398 }
1399
1400 void Net::processListenSocket(NetSocket socketHandle)
1401 {
1402    if (socketHandle == NetSocket::INVALID)
1403       return;
1404
1405    sockaddr_storage sa;
1406    sa.ss_family = AF_UNSPEC;
1407    NetAddress srcAddress;
1408    RawData tmpBuffer;
1409    tmpBuffer.alloc(Net::MaxPacketDataSize);
1410
1411    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(socketHandle);
1412
1413    for (;;)
1414    {
1415       socklen_t addrLen = sizeof(sa);
1416       S32 bytesRead = -1;
1417
1418       if (socketHandle != NetSocket::INVALID)
1419          bytesRead = ::recvfrom(socketFd, (char *)tmpBuffer.data, Net::MaxPacketDataSize, 0, (struct sockaddr*)&sa, &addrLen);
1420
1421       if (bytesRead == -1)
1422          break;
1423
1424       if (sa.ss_family == AF_INET)
1425          IPSocketToNetAddress((sockaddr_in *)&sa, &srcAddress);
1426       else if (sa.ss_family == AF_INET6)
1427         IPSocket6ToNetAddress((sockaddr_in6 *)&sa, &srcAddress);
1428      else
1429          continue;
1430
1431       if (bytesRead <= 0)
1432          continue;
1433
1434       if (srcAddress.type == NetAddress::IPAddress &&
1435          srcAddress.address.ipv4.netNum[0] == 127 &&
1436          srcAddress.address.ipv4.netNum[1] == 0 &&
1437          srcAddress.address.ipv4.netNum[2] == 0 &&
1438          srcAddress.address.ipv4.netNum[3] == 1 &&
1439          srcAddress.port == PlatformNetState::netPort)
1440          continue;
1441
1442       tmpBuffer.size = bytesRead;
1443
1444       smPacketReceive->trigger(srcAddress, tmpBuffer);
1445    }
1446 }
1447
1448 NetSocket Net::openSocket()
1449 {
1450    return PlatformNetState::smReservedSocketList.reserve();
1451 }
1452
1453 Net::Error Net::closeSocket(NetSocket handleFd)
1454 {
1455    if(handleFd != NetSocket::INVALID)
1456    {
1457       SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1458      PlatformNetState::smReservedSocketList.remove(handleFd);
1459
1460       if(!::closesocket(socketFd))
1461          return NoError;
1462       else
1463          return PlatformNetState::getLastError();
1464    }
1465    else
1466       return NotASocket;
1467 }
1468
1469 Net::Error Net::connect(NetSocket handleFd, const NetAddress *address)
1470 {
1471    if(!(address->type == NetAddress::IPAddress || address->type == NetAddress::IPV6Address))
1472       return WrongProtocolType;
1473
1474    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1475
1476    if (address->type == NetAddress::IPAddress)
1477    {
1478       sockaddr_in socketAddress;
1479       NetAddressToIPSocket(address, &socketAddress);
1480
1481       if (socketFd == InvalidSocketHandle)
1482       {
1483          socketFd = PlatformNetState::smReservedSocketList.activate(handleFd, AF_INET, false);
1484       }
1485
1486       if (!::connect(socketFd, (struct sockaddr *) &socketAddress, sizeof(socketAddress)))
1487          return NoError;
1488    }
1489    else if (address->type == NetAddress::IPV6Address)
1490    {
1491       sockaddr_in6 socketAddress;
1492       NetAddressToIPSocket6(address, &socketAddress);
1493
1494       if (socketFd == InvalidSocketHandle)
1495       {
1496          socketFd = PlatformNetState::smReservedSocketList.activate(handleFd, AF_INET6, false);
1497       }
1498
1499       if (!::connect(socketFd, (struct sockaddr *) &socketAddress, sizeof(socketAddress)))
1500          return NoError;
1501    }
1502
1503    return PlatformNetState::getLastError();
1504 }
1505
1506 Net::Error Net::listen(NetSocket handleFd, S32 backlog)
1507 {
1508    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1509    if (socketFd == InvalidSocketHandle)
1510       return NotASocket;
1511
1512    if(!::listen(socketFd, backlog))
1513       return NoError;
1514    return PlatformNetState::getLastError();
1515 }
1516
1517 NetSocket Net::accept(NetSocket handleFd, NetAddress *remoteAddress)
1518 {
1519    sockaddr_storage addr;
1520    socklen_t addrLen = sizeof(addr);
1521
1522    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1523    if (socketFd == InvalidSocketHandle)
1524       return NetSocket::INVALID;
1525
1526    SOCKET acceptedSocketFd = ::accept(socketFd, (sockaddr *)&addr, &addrLen);
1527    if (acceptedSocketFd != InvalidSocketHandle)
1528    {
1529       if (addr.ss_family == AF_INET)
1530       {
1531          // ipv4
1532          IPSocketToNetAddress(((struct sockaddr_in*)&addr), remoteAddress);
1533       }
1534       else if (addr.ss_family == AF_INET6)
1535       {
1536          // ipv6
1537          IPSocket6ToNetAddress(((struct sockaddr_in6*)&addr), remoteAddress);
1538       }
1539
1540       NetSocket newHandleFd = PlatformNetState::smReservedSocketList.reserve(acceptedSocketFd);
1541       return newHandleFd;
1542    }
1543
1544    return NetSocket::INVALID;
1545 }
1546
1547 Net::Error Net::bindAddress(const NetAddress &address, NetSocket handleFd, bool useUDP)
1548 {
1549    int error = 0;
1550    sockaddr_storage socketAddress;
1551
1552    dMemset(&socketAddress, '\0', sizeof(socketAddress));
1553
1554    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1555    if (socketFd == InvalidSocketHandle)
1556    {
1557       if (handleFd.getHandle() == -1)
1558          return NotASocket;
1559    }
1560
1561    if (address.type == NetAddress::IPAddress)
1562    {
1563       socketFd = PlatformNetState::smReservedSocketList.activate(handleFd, AF_INET, useUDP);
1564       NetAddressToIPSocket(&address, (struct sockaddr_in*)&socketAddress);
1565       error = ::bind(socketFd, (struct sockaddr*)&socketAddress, sizeof(sockaddr_in));
1566    }
1567    else if (address.type == NetAddress::IPV6Address)
1568    {
1569       socketFd = PlatformNetState::smReservedSocketList.activate(handleFd, AF_INET6, useUDP);
1570       NetAddressToIPSocket6(&address, (struct sockaddr_in6*)&socketAddress);
1571       error = ::bind(socketFd, (struct sockaddr*)&socketAddress, sizeof(sockaddr_in6));
1572    }
1573
1574    if (!error)
1575       return NoError;
1576    return PlatformNetState::getLastError();
1577 }
1578
1579 Net::Error Net::setBufferSize(NetSocket handleFd, S32 bufferSize)
1580 {
1581    S32 error;
1582    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1583    if (socketFd == InvalidSocketHandle)
1584       return NotASocket;
1585
1586    error = ::setsockopt(socketFd, SOL_SOCKET, SO_RCVBUF, (char *)  &bufferSize, sizeof(bufferSize));
1587    if(!error)
1588       error = ::setsockopt(socketFd, SOL_SOCKET, SO_SNDBUF, (char *)  &bufferSize, sizeof(bufferSize));
1589    if(!error)
1590       return NoError;
1591    return PlatformNetState::getLastError();
1592 }
1593
1594 Net::Error Net::setBroadcast(NetSocket handleFd, bool broadcast)
1595 {
1596    S32 bc = broadcast;
1597    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1598    if (socketFd == InvalidSocketHandle)
1599       return NotASocket;
1600    S32 error = ::setsockopt(socketFd, SOL_SOCKET, SO_BROADCAST, (char*)&bc,  sizeof(bc));
1601    if(!error)
1602       return NoError;
1603    return PlatformNetState::getLastError();
1604 }
1605
1606 Net::Error Net::setBlocking(NetSocket handleFd, bool blockingIO)
1607 {
1608    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1609    if (socketFd == InvalidSocketHandle)
1610       return NotASocket;
1611
1612    unsigned long notblock = !blockingIO;
1613    S32 error = ioctl(socketFd, FIONBIO, &notblock);
1614    if(!error)
1615       return NoError;
1616    return PlatformNetState::getLastError();
1617 }
1618
1619 Net::Error Net::getListenAddress(const NetAddress::Type type, NetAddress *address, bool forceDefaults)
1620 {
1621    if (type == NetAddress::IPAddress)
1622    {
1623       const char* serverIP = forceDefaults ? NULL : Con::getVariable("pref::Net::BindAddress");
1624       if (!serverIP || serverIP[0] == '\0')
1625       {
1626          address->type = type;
1627          address->port = 0;
1628          *((U32*)address->address.ipv4.netNum) = INADDR_ANY;
1629          return Net::NoError;
1630       }
1631       else
1632       {
1633          return Net::stringToAddress(serverIP, address, false);
1634       }
1635    }
1636    else if (type == NetAddress::IPBroadcastAddress)
1637    {
1638       address->type = type;
1639       address->port = 0;
1640       *((U32*)address->address.ipv4.netNum) = INADDR_BROADCAST;
1641       return Net::NoError;
1642    }
1643    else if (type == NetAddress::IPV6Address)
1644    {
1645       const char* serverIP6 = forceDefaults ? NULL : Con::getVariable("pref::Net::BindAddress6");
1646       if (!serverIP6 || serverIP6[0] == '\0')
1647       {
1648          sockaddr_in6 addr;
1649          dMemset(&addr, '\0', sizeof(addr));
1650
1651          addr.sin6_port = 0;
1652          addr.sin6_addr = in6addr_any;
1653
1654          IPSocket6ToNetAddress(&addr, address);
1655          return Net::NoError;
1656       }
1657       else
1658       {
1659          return Net::stringToAddress(serverIP6, address, false);
1660       }
1661    }
1662    else if (type == NetAddress::IPV6MulticastAddress)
1663    {
1664       const char* multicastAddressValue = forceDefaults ? NULL : Con::getVariable("pref::Net::Multicast6Address");
1665       if (!multicastAddressValue || multicastAddressValue[0] == '\0')
1666       {
1667          multicastAddressValue = TORQUE_NET_DEFAULT_MULTICAST_ADDRESS;
1668       }
1669
1670       return Net::stringToAddress(multicastAddressValue, address, false);
1671    }
1672    else
1673    {
1674       return Net::WrongProtocolType;
1675    }
1676 }
1677
1678 void Net::getIdealListenAddress(NetAddress *address)
1679 {
1680    dMemset(address, '\0', sizeof(NetAddress));
1681
1682    if (Net::smIpv6Enabled)
1683    {
1684       if (Net::getListenAddress(NetAddress::IPV6Address, address) == NeedHostLookup)
1685       {
1686          Net::getListenAddress(NetAddress::IPV6Address, address, true);
1687       }
1688    }
1689    else
1690    {
1691       if (Net::getListenAddress(NetAddress::IPAddress, address) == NeedHostLookup)
1692       {
1693          Net::getListenAddress(NetAddress::IPAddress, address, true);
1694       }
1695    }
1696 }
1697
1698 Net::Error Net::send(NetSocket handleFd, const U8 *buffer, S32 bufferSize, S32 *outBytesWritten)
1699 {
1700    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1701    if (socketFd == InvalidSocketHandle)
1702       return NotASocket;
1703
1704    errno = 0;
1705    S32 bytesWritten = ::send(socketFd, (const char*)buffer, bufferSize, 0);
1706
1707    if (outBytesWritten)
1708    {
1709       *outBytesWritten = outBytesWritten < 0 ? 0 : bytesWritten;
1710    }
1711
1712    return PlatformNetState::getLastError();
1713 }
1714
1715 Net::Error Net::recv(NetSocket handleFd, U8 *buffer, S32 bufferSize, S32  *bytesRead)
1716 {
1717    SOCKET socketFd = PlatformNetState::smReservedSocketList.resolve(handleFd);
1718    if (socketFd == InvalidSocketHandle)
1719       return NotASocket;
1720
1721    *bytesRead = ::recv(socketFd, (char*)buffer, bufferSize, 0);
1722    if(*bytesRead == -1)
1723       return PlatformNetState::getLastError();
1724    return NoError;
1725 }
1726
1727 bool Net::compareAddresses(const NetAddress *a1, const NetAddress *a2)
1728 {
1729    return a1->isSameAddressAndPort(*a2);
1730 }
1731
1732 Net::Error Net::stringToAddress(const char *addressString, NetAddress  *address, bool hostLookup, int requiredFamily)
1733 {
1734    char addr[256];
1735    int port = 0;
1736    int actualFamily = AF_UNSPEC;
1737    if (!PlatformNetState::extractAddressParts(addressString, addr, port, actualFamily))
1738    {
1739       return WrongProtocolType;
1740    }
1741
1742    // Make sure family matches (in cast we have IP: stuff in address)
1743    if (requiredFamily != AF_UNSPEC && actualFamily != AF_UNSPEC && (actualFamily != requiredFamily))
1744    {
1745       return WrongProtocolType;
1746    }
1747
1748    if (actualFamily == AF_UNSPEC)
1749    {
1750       actualFamily = requiredFamily;
1751    }
1752
1753    addressString = addr;
1754    dMemset(address, '\0', sizeof(NetAddress));
1755
1756    if (!dStricmp(addressString, "broadcast"))
1757    {
1758       address->type = NetAddress::IPBroadcastAddress;
1759       if (!(actualFamily == AF_UNSPEC || actualFamily == AF_INET))
1760          return WrongProtocolType;
1761
1762       if (port != 0)
1763          address->port = port;
1764       else
1765          address->port = PlatformNetState::defaultPort;
1766    }
1767    else if (!dStricmp(addressString, "multicast"))
1768    {
1769       address->type = NetAddress::IPV6MulticastAddress;
1770       if (!(actualFamily == AF_UNSPEC || actualFamily == AF_INET6))
1771          return WrongProtocolType;
1772
1773       if (port != 0)
1774          address->port = port;
1775       else
1776          address->port = PlatformNetState::defaultPort;
1777    }
1778    else
1779    {
1780       sockaddr_in ipAddr;
1781       sockaddr_in6 ipAddr6;
1782
1783       dMemset(&ipAddr, 0, sizeof(ipAddr));
1784       dMemset(&ipAddr6, 0, sizeof(ipAddr6));
1785
1786       bool hasInterface = dStrchr(addressString, '%') != NULL; // if we have an interface, best use getaddrinfo to parse
1787
1788       // Check if we've got a simple ipv4 / ipv6
1789
1790       if (inet_pton(AF_INET, addressString, &ipAddr.sin_addr) == 1)
1791       {
1792          if (!(actualFamily == AF_UNSPEC || actualFamily == AF_INET))
1793             return WrongProtocolType;
1794          IPSocketToNetAddress(((struct sockaddr_in*)&ipAddr), address);
1795
1796          if (port != 0)
1797             address->port = port;
1798          else
1799             address->port = PlatformNetState::defaultPort;
1800
1801          return NoError;
1802       }
1803       else if (!hasInterface && inet_pton(AF_INET6, addressString, &ipAddr6.sin6_addr) == 1)
1804       {
1805          if (!(actualFamily == AF_UNSPEC || actualFamily == AF_INET6))
1806             return WrongProtocolType;
1807          IPSocket6ToNetAddress(((struct sockaddr_in6*)&ipAddr6), address);
1808
1809          if (port != 0)
1810             address->port = port;
1811          else
1812             address->port = PlatformNetState::defaultPort;
1813
1814          return NoError;
1815       }
1816       else
1817       {
1818          if (!hostLookup && !hasInterface)
1819             return NeedHostLookup;
1820
1821          struct addrinfo hint, *res = NULL;
1822          dMemset(&hint, 0, sizeof(hint));
1823          hint.ai_family = actualFamily;
1824          hint.ai_flags = hostLookup ? 0 : AI_NUMERICHOST;
1825
1826          if (getaddrinfo(addressString, NULL, &hint, &res) == 0)
1827          {
1828             if (actualFamily != AF_UNSPEC)
1829             {
1830                // Prefer desired protocol
1831                res = PlatformNetState::pickAddressByProtocol(res, actualFamily);
1832             }
1833
1834             if (res && res->ai_family == AF_INET)
1835             {
1836                // ipv4
1837                IPSocketToNetAddress(((struct sockaddr_in*)res->ai_addr), address);
1838             }
1839             else if (res && res->ai_family == AF_INET6)
1840             {
1841                // ipv6
1842                IPSocket6ToNetAddress(((struct sockaddr_in6*)res->ai_addr), address);
1843             }
1844             else
1845             {
1846                // unknown
1847                return UnknownError;
1848             }
1849
1850             if (port != 0)
1851                address->port = port;
1852             else
1853                address->port = PlatformNetState::defaultPort;
1854          }
1855       }
1856    }
1857
1858    return NoError;
1859 }
1860
1861 void Net::addressToString(const NetAddress *address, char  addressString[256])
1862 {
1863    if(address->type == NetAddress::IPAddress || address->type == NetAddress::IPBroadcastAddress)
1864    {
1865       sockaddr_in ipAddr;
1866       NetAddressToIPSocket(address, &ipAddr);
1867
1868       if (ipAddr.sin_addr.s_addr == htonl(INADDR_BROADCAST) || address->type == NetAddress::IPBroadcastAddress)
1869       {
1870          if (ipAddr.sin_port == 0)
1871             dSprintf(addressString, 256, "IP:Broadcast");
1872          else
1873             dSprintf(addressString, 256, "IP:Broadcast:%d", ntohs(ipAddr.sin_port));
1874       }
1875       else
1876       {
1877          char buffer[256];
1878          buffer[0] = '\0';
1879          sockaddr_in ipAddr;
1880          NetAddressToIPSocket(address, &ipAddr);
1881          inet_ntop(AF_INET, &(ipAddr.sin_addr), buffer, sizeof(buffer));
1882          if (ipAddr.sin_port == 0)
1883             dSprintf(addressString, 256, "IP:%s", buffer);
1884          else
1885             dSprintf(addressString, 256, "IP:%s:%i", buffer, ntohs(ipAddr.sin_port));
1886       }
1887    }
1888    else if (address->type == NetAddress::IPV6Address)
1889    {
1890       char buffer[256];
1891       buffer[0] = '\0';
1892       sockaddr_in6 ipAddr;
1893       NetAddressToIPSocket6(address, &ipAddr);
1894       inet_ntop(AF_INET6, &(ipAddr.sin6_addr), buffer, sizeof(buffer));
1895       if (ipAddr.sin6_port == 0)
1896          dSprintf(addressString, 256, "IP6:%s", buffer);
1897       else
1898          dSprintf(addressString, 256, "IP6:[%s]:%i", buffer, ntohs(ipAddr.sin6_port));
1899    }
1900    else if (address->type == NetAddress::IPV6MulticastAddress)
1901    {
1902       if (address->port == 0)
1903          dSprintf(addressString, 256, "IP6:Multicast");
1904       else
1905          dSprintf(addressString, 256, "IP6:Multicast:%d", address->port);
1906    }
1907    else
1908    {
1909       *addressString = 0;
1910       return;
1911    }
1912 }
1913
1914 void Net::enableMulticast()
1915 {
1916    SOCKET socketFd;
1917
1918    if (Net::smIpv6Enabled)
1919    {
1920       socketFd = PlatformNetState::smReservedSocketList.resolve(PlatformNetState::udp6Socket);
1921
1922       if (socketFd != InvalidSocketHandle)
1923       {
1924          PlatformNetState::multicast6Socket = PlatformNetState::udp6Socket;
1925
1926          Net::Error error = NoError;
1927
1928          if (error == NoError)
1929          {
1930             unsigned long multicastTTL = 1;
1931
1932             if (setsockopt(socketFd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
1933                (char*)&multicastTTL, sizeof(multicastTTL)) < 0)
1934             {
1935                error = PlatformNetState::getLastError();
1936             }
1937          }
1938
1939          // Find multicast to bind to...
1940
1941          NetAddress multicastAddress;
1942          sockaddr_in6 multicastSocketAddress;
1943
1944          const char *multicastAddressValue = Con::getVariable("pref::Net::Multicast6Address");
1945          if (!multicastAddressValue || multicastAddressValue[0] == '\0')
1946          {
1947             multicastAddressValue = TORQUE_NET_DEFAULT_MULTICAST_ADDRESS;
1948          }
1949
1950          error = Net::stringToAddress(multicastAddressValue, &multicastAddress, false);
1951
1952          if (error == NoError)
1953          {
1954             dMemset(&PlatformNetState::multicast6Group, '\0', sizeof(&PlatformNetState::multicast6Group));
1955             NetAddressToIPSocket6(&multicastAddress, &multicastSocketAddress);
1956             dMemcpy(&PlatformNetState::multicast6Group.ipv6mr_multiaddr, &multicastSocketAddress.sin6_addr, sizeof(PlatformNetState::multicast6Group.ipv6mr_multiaddr));
1957          }
1958
1959          // Setup group
1960
1961          if (error == NoError)
1962          {
1963             const char *multicastInterface = Con::getVariable("pref::Net::Multicast6Interface");
1964
1965             if (multicastInterface && multicastInterface[0] != '\0')
1966             {
1967 #ifdef TORQUE_USE_WINSOCK
1968                PlatformNetState::multicast6Group.ipv6mr_interface = dAtoi(multicastInterface);
1969 #else
1970                PlatformNetState::multicast6Group.ipv6mr_interface = if_nametoindex(multicastInterface);
1971 #endif
1972             }
1973             else
1974             {
1975                PlatformNetState::multicast6Group.ipv6mr_interface = 0; // 0 == accept from any interface
1976             }
1977
1978             if (PlatformNetState::multicast6Group.ipv6mr_interface && error == NoError)
1979             {
1980                if (setsockopt(socketFd, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char *)&PlatformNetState::multicast6Group.ipv6mr_interface, sizeof(PlatformNetState::multicast6Group.ipv6mr_interface)) < 0)
1981                {
1982                   error = PlatformNetState::getLastError();
1983                }
1984             }
1985
1986             if (error == NoError && setsockopt(socketFd, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char*)&PlatformNetState::multicast6Group, sizeof(PlatformNetState::multicast6Group)) < 0)
1987             {
1988                error = PlatformNetState::getLastError();
1989             }
1990          }
1991
1992
1993          if (error == NoError)
1994          {
1995             NetAddress listenAddress;
1996             char listenAddressStr[256];
1997             Net::addressToString(&multicastAddress, listenAddressStr);
1998             Con::printf("Multicast initialized on %s", listenAddressStr);
1999          }
2000
2001           if (error != NoError)
2002          {
2003             PlatformNetState::multicast6Socket = NetSocket::INVALID;
2004             Con::printf("Unable to multicast UDP - error %d", error);
2005          }
2006       }
2007    }
2008 }
2009
2010 void Net::disableMulticast()
2011 {
2012    if (PlatformNetState::multicast6Socket != NetSocket::INVALID)
2013    {
2014       PlatformNetState::multicast6Socket = NetSocket::INVALID;
2015    }
2016 }
2017
2018 bool Net::isMulticastEnabled()
2019 {
2020    return PlatformNetState::multicast6Socket != NetSocket::INVALID;
2021 }
2022
2023 U32 NetAddress::getHash() const
2024 {
2025    U32 value = 0;
2026    switch (type)
2027    {
2028    case NetAddress::IPAddress:
2029       value = Torque::hash((const U8*)&address.ipv4.netNum, sizeof(address.ipv4.netNum), 0);
2030       break;
2031    case NetAddress::IPV6Address:
2032       value = Torque::hash((const U8*)address.ipv6.netNum, sizeof(address.ipv6.netNum), 0);
2033       break;
2034    default:
2035       value = 0;
2036       break;
2037    }
2038    return value;
2039 }
2040
2041 bool Net::isAddressTypeAvailable(NetAddress::Type addressType)
2042 {
2043    switch (addressType)
2044    {
2045    case NetAddress::IPAddress:
2046       return PlatformNetState::udpSocket != NetSocket::INVALID;
2047    case NetAddress::IPV6Address:
2048       return PlatformNetState::udp6Socket != NetSocket::INVALID;
2049    case NetAddress::IPBroadcastAddress:
2050       return PlatformNetState::udpSocket != NetSocket::INVALID;
2051    case NetAddress::IPV6MulticastAddress:
2052       return PlatformNetState::multicast6Socket != NetSocket::INVALID;
2053    default:
2054       return false;
2055    }
2056 }