winnet.cc

五行MMORPG引擎系统V1.0

//-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------


#include "platformWin32/platformWin32.h"
#include "platform/platform.h"
#include "platform/event.h"
#include <winsock.h>

#if !defined(USE_IPX) || defined(TORQUE_COMPILER_MINGW)
#  define NO_IPX_SUPPORT
#endif

#if !defined(NO_IPX_SUPPORT)
#  include <wsipx.h>
#else
   typedef void* SOCKADDR_IPX;
#endif

#include "console/console.h"
#include "platform/gameInterface.h"
#include "core/fileStream.h"

struct NameLookup
{
   U8 hostEntStruct[MAXGETHOSTSTRUCT];
   HANDLE lookupHandle;
   SOCKET socket;
   U16 port;
   NameLookup *nextLookup;
};

static NameLookup *lookupList = NULL;

#ifndef TGE_RPG
static Net::Error getLastError();
#endif

static S32 defaultPort = 28000;
static S32 netPort = 0;
static SOCKET ipxSocket = INVALID_SOCKET;
static SOCKET udpSocket = INVALID_SOCKET;

enum WinNetConstants {
   MaxConnections = 1024,  ///< Maximum allowed number of connections.
};

HWND winsockWindow = NULL;

static LRESULT PASCAL WinsockProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   U32 error;
   U32 bufLen;
   U32 event;
   SOCKET socket;
   Net::Error err;
   S32 bytesRead;

   static ConnectedNotifyEvent notifyEvent;
   static ConnectedReceiveEvent receiveEvent;
   static ConnectedAcceptEvent acceptEvent;

   switch(message)
   {
      case WM_USER:
         error = WSAGETSELECTERROR(lParam);
         event = WSAGETSELECTEVENT(lParam);
         socket = wParam;
         switch(event)
         {
            case FD_READ:
               err = Net::recv(socket, receiveEvent.data, MaxPacketDataSize, &bytesRead);
               if(err == Net::NoError && bytesRead != 0)
               {
                  receiveEvent.tag = socket;
                  receiveEvent.size = ConnectedReceiveEventHeaderSize + bytesRead;
                  Game->postEvent(receiveEvent);
               }
               break;
            case FD_CONNECT:
               notifyEvent.tag = socket;
               if(error)
                  notifyEvent.state = ConnectedNotifyEvent::ConnectFailed;
               else
                  notifyEvent.state = ConnectedNotifyEvent::Connected;
               Game->postEvent(notifyEvent);
               break;
            case FD_CLOSE:
               // see first if there is anything to read:
               for(;;)
               {
                  err = Net::recv(socket, receiveEvent.data, MaxPacketDataSize, &bytesRead);
                  if(err != Net::NoError || bytesRead == 0)
                     break;

                  receiveEvent.tag = socket;
                  receiveEvent.size = ConnectedReceiveEventHeaderSize + bytesRead;
                  Game->postEvent(receiveEvent);
               }
               notifyEvent.tag = socket;
               notifyEvent.state = ConnectedNotifyEvent::Disconnected;
               Game->postEvent(notifyEvent);
               break;
            case FD_ACCEPT:
               acceptEvent.portTag = socket;
               acceptEvent.connectionTag = Net::accept(socket, &acceptEvent.address);
               if(acceptEvent.connectionTag != InvalidSocket)
               {
                  Net::setBlocking(acceptEvent.connectionTag, false);
                  WSAAsyncSelect(acceptEvent.connectionTag, winsockWindow, WM_USER, FD_READ | FD_CONNECT | FD_CLOSE);
                  Game->postEvent(acceptEvent);
               }
               break;
         }
         break;
      case WM_USER + 1:
         error = WSAGETASYNCERROR(lParam);
         bufLen = WSAGETASYNCBUFLEN(lParam);
         HANDLE handle;
         handle = HANDLE(wParam);
         NameLookup **walk;
         for(walk = &lookupList; *walk; walk = &((*walk)->nextLookup))
         {
            if((*walk)->lookupHandle == handle)
            {
               NameLookup *temp = *walk;
               struct hostent *hp = (struct hostent *) temp->hostEntStruct;

               if(error)
               {
                  notifyEvent.state = ConnectedNotifyEvent::DNSFailed;
                  notifyEvent.tag = temp->socket;
                  ::closesocket(temp->socket);
               }
               else
               {
                  SOCKADDR_IN ipAddr;
                  memcpy(&ipAddr.sin_addr.s_addr, hp->h_addr, sizeof(IN_ADDR));
                  ipAddr.sin_port = temp->port;
                  ipAddr.sin_family = AF_INET;

                  notifyEvent.tag = temp->socket;

                  WSAAsyncSelect(temp->socket, winsockWindow, WM_USER, FD_READ | FD_CONNECT | FD_CLOSE);
                  bool wserr = ::connect(temp->socket, (PSOCKADDR) &ipAddr, sizeof(ipAddr)); // always errors out
                  if (wserr && WSAGetLastError() == WSAEWOULDBLOCK)
                     notifyEvent.state = ConnectedNotifyEvent::DNSResolved;
                  else {
                     Con::printf("Connect error: %d", WSAGetLastError());
                     ::closesocket(temp->socket);
                     notifyEvent.state = ConnectedNotifyEvent::ConnectFailed;
                  }
               }
               Game->postEvent(notifyEvent);

               *walk = temp->nextLookup;
               delete temp;
               break;
            }
         }
         break;
      default:
         return DefWindowProc( hWnd, message, wParam, lParam );
   }
   return 0;
}


static void InitNetWindow()
{
   WNDCLASS wc;
   dMemset(&wc, 0, sizeof(wc));

   wc.style         = 0;
   wc.lpfnWndProc   = WinsockProc;
   wc.cbClsExtra    = 0;
   wc.cbWndExtra    = 0;
   wc.hInstance     = winState.appInstance;
   wc.hIcon         = 0;
   wc.hCursor       = 0;
   wc.hbrBackground = 0;
   wc.lpszMenuName  = 0;
   wc.lpszClassName = dT("WinSockClass");
   RegisterClass( &wc );
   winsockWindow = CreateWindowEx(
      0,
      dT("WinSockClass"),
      dT(""),
      0,
      0, 0, 0, 0,
      NULL, NULL,
      winState.appInstance,
      NULL);
}

bool Net::init()
{
#ifdef TGE_RPG

	WSADATA wsaData;


	// Initialize Winsock 1.1
	if(WSAStartup(MAKEU16(1,1), &wsaData)!=0) 
		return false;

	if(LU8(wsaData.wVersion) != 1 || HU8(wsaData.wVersion) != 1) 
	{
		WSACleanup();
		return false;
	}

#	ifndef TGE_RPGSERVER
   InitNetWindow();
#	endif
	return true;


#else
   WSADATA stWSAData;
   InitNetWindow();
   return !WSAStartup(0x0101, &stWSAData);
#endif

}

void Net::shutdown()
{
   while(lookupList)
   {
      NameLookup *temp = lookupList;
      lookupList = temp->nextLookup;
      WSACancelAsyncRequest ( temp->lookupHandle );
      delete temp;
   }
   DestroyWindow(winsockWindow);
   closePort();
   WSACleanup();
}

static void netToIPSocketAddress(const NetAddress *address, SOCKADDR_IN *sockAddr)
{
   dMemset(sockAddr, 0, sizeof(SOCKADDR_IN));
   sockAddr->sin_family = AF_INET;
   sockAddr->sin_port = htons(address->port);
   sockAddr->sin_addr.s_net = address->netNum[0];
   sockAddr->sin_addr.s_host = address->netNum[1];
   sockAddr->sin_addr.s_lh = address->netNum[2];
   sockAddr->sin_addr.s_impno = address->netNum[3];
}

static void IPSocketToNetAddress(const SOCKADDR_IN *sockAddr, NetAddress *address)
{
   address->type = NetAddress::IPAddress;
   address->port = htons(sockAddr->sin_port);
   address->netNum[0] = sockAddr->sin_addr.s_net;
   address->netNum[1] = sockAddr->sin_addr.s_host;
   address->netNum[2] = sockAddr->sin_addr.s_lh;
   address->netNum[3] = sockAddr->sin_addr.s_impno;
}

static void netToIPXSocketAddress(const NetAddress *address, SOCKADDR_IPX *sockAddr)
{
#if !defined(NO_IPX_SUPPORT)
   dMemset(sockAddr, 0, sizeof(SOCKADDR_IPX));
   sockAddr->sa_family = AF_INET;
   sockAddr->sa_socket = htons(address->port);
   sockAddr->sa_netnum[0] = address->netNum[0];
   sockAddr->sa_netnum[1] = address->netNum[1];
   sockAddr->sa_netnum[2] = address->netNum[2];
   sockAddr->sa_netnum[3] = address->netNum[3];
   sockAddr->sa_nodenum[0] = address->nodeNum[0];
   sockAddr->sa_nodenum[1] = address->nodeNum[1];
   sockAddr->sa_nodenum[2] = address->nodeNum[2];
   sockAddr->sa_nodenum[3] = address->nodeNum[3];
   sockAddr->sa_nodenum[4] = address->nodeNum[4];
   sockAddr->sa_nodenum[5] = address->nodeNum[5];
#endif
}

static void IPXSocketToNetAddress(const SOCKADDR_IPX *sockAddr, NetAddress *address)
{
#if !defined(NO_IPX_SUPPORT)
   address->type = NetAddress::IPXAddress;
   address->port = htons(sockAddr->sa_socket);
   address->netNum[0]  = sockAddr->sa_netnum[0] ;
   address->netNum[1]  = sockAddr->sa_netnum[1] ;
   address->netNum[2]  = sockAddr->sa_netnum[2] ;
   address->netNum[3]  = sockAddr->sa_netnum[3] ;
   address->nodeNum[0] = sockAddr->sa_nodenum[0];
   address->nodeNum[1] = sockAddr->sa_nodenum[1];
   address->nodeNum[2] = sockAddr->sa_nodenum[2];
   address->nodeNum[3] = sockAddr->sa_nodenum[3];
   address->nodeNum[4] = sockAddr->sa_nodenum[4];
   address->nodeNum[5] = sockAddr->sa_nodenum[5];
#endif
}

NetSocket Net::openListenPort(U16 port)
{
   if(Game->isJournalReading())
   {
      U32 ret;
      Game->journalRead(&ret);
      return NetSocket(ret);
   }
   NetSocket sock = openSocket();
   bind(sock, port);
   listen(sock, 4);
   setBlocking(sock, false);
   if(WSAAsyncSelect ( sock, winsockWindow, WM_USER, FD_ACCEPT ))
      Con::printf("Connect error: %d", WSAGetLastError());
   if(Game->isJournalWriting())
      Game->journalWrite(U32(sock));
   return sock;
}

NetSocket Net::openConnectTo(const char *addressString)
{
   if(!dStrnicmp(addressString, "ipx:", 4))
      return InvalidSocket;
   if(!dStrnicmp(addressString, "ip:", 3))
      addressString += 3;  // eat off the ip:
   char remoteAddr[256];
   dStrcpy(remoteAddr, addressString);

   char *portString = dStrchr(remoteAddr, ':');

   U16 port;
   if(portString)
   {
      *portString++ = 0;
      port = htons(dAtoi(portString));
   }
   else
      port = htons(defaultPort);

   if(!dStricmp(remoteAddr, "broadcast"))
      return InvalidSocket;

   if(Game->isJournalReading())
   {
      U32 ret;
      Game->journalRead(&ret);
      return NetSocket(ret);
   }
   NetSocket sock = openSocket();
   setBlocking(sock, false);

   SOCKADDR_IN ipAddr;

   ipAddr.sin_addr.s_addr = inet_addr(remoteAddr);

   if(ipAddr.sin_addr.s_addr != INADDR_NONE)
   {
      ipAddr.sin_port = port;
      ipAddr.sin_family = AF_INET;
      WSAAsyncSelect(sock, winsockWindow, WM_USER, FD_READ | FD_CONNECT | FD_CLOSE);
      if(::connect(sock, (PSOCKADDR) &ipAddr, sizeof(ipAddr) ) )
      {
         if(WSAGetLastError() != WSAEWOULDBLOCK)
         {
            Con::printf("Connect error: %d", WSAGetLastError());
            ::closesocket(sock);
            sock = InvalidSocket;
         }
      }
   }
   else
   {
      NameLookup *lookup = new NameLookup;
      lookup->socket = sock;
      lookup->port = port;
      lookup->lookupHandle = WSAAsyncGetHostByName (winsockWindow, WM_USER + 1, remoteAddr, (char *) lookup->hostEntStruct, MAXGETHOSTSTRUCT );
      if(!lookup->lookupHandle)
      {
         delete lookup;
         ::closesocket(sock);
         sock = InvalidSocket;
      }
      else
      {
         lookup->nextLookup = lookupList;
         lookupList = lookup;
      }
   }
   if(Game->isJournalWriting())
      Game->journalWrite(U32(sock));
   return sock;
}

void Net::closeConnectTo(NetSocket sock)
{
   if(Game->isJournalReading())
      return;

   for(NameLookup **walk = &lookupList; *walk; walk = &((*walk)->nextLookup) )
   {
      NameLookup *lookup = *walk;
      if(lookup->socket == sock)
      {
         WSACancelAsyncRequest ( lookup->lookupHandle );
         closesocket(lookup->socket);
         *walk = lookup->nextLookup;
         delete lookup;
         return;
      }
   }
   closesocket(sock);
}

Net::Error Net::sendtoSocket(NetSocket socket, const U8 *buffer, S32 bufferSize)
{
   if(Game->isJournalReading())
   {
      U32 e;
      Game->journalRead(&e);

      return (Net::Error) e;
   }
   Net::Error e = send(socket, buffer, bufferSize);
   if(Game->isJournalWriting())
      Game->journalWrite(U32(e));
   return e;
}

bool Net::openPort(S32 port)
{
   if(udpSocket != INVALID_SOCKET)
      closesocket(udpSocket);
   if(ipxSocket != INVALID_SOCKET)
      closesocket(ipxSocket);

   udpSocket = socket(AF_INET, SOCK_DGRAM, 0);

#if !defined(NO_IPX_SUPPORT)
   ipxSocket = socket(AF_IPX, SOCK_DGRAM, NSPROTO_IPX);
#else
   ipxSocket = INVALID_SOCKET;
#endif

   if(udpSocket != INVALID_SOCKET)
   {
      Net::Error error;
      error = bind(udpSocket, port);
      if(error == NoError)
         error = setBufferSize(udpSocket, 32768);
      if(error == NoError)
         error = setBroadcast(udpSocket, true);
      if(error == NoError)
         error = setBlocking(udpSocket, false);
      if(error == NoError)
         Con::printf("UDP initialized on port %d", port);
      else
      {
         closesocket(udpSocket);
         udpSocket = INVALID_SOCKET;
         Con::printf("Unable to initialize UDP - error %d", error);
      }
   }

#if !defined(NO_IPX_SUPPORT)
   if(ipxSocket != INVALID_SOCKET)
   {
      Net::Error error = NoError;
      SOCKADDR_IPX ipxAddress;
   	memset((char *)&ipxAddress, 0, sizeof(ipxAddress));
	   ipxAddress.sa_family = AF_IPX;
	   ipxAddress.sa_socket = htons(port);
      S32 err = ::bind(ipxSocket, (PSOCKADDR) &ipxAddress, sizeof(ipxAddress));
      if(err)
         error = getLastError();
      if(error == NoError)
         error = setBufferSize(ipxSocket, 32768);
      if(error == NoError)
         error = setBroadcast(ipxSocket, true);
      if(error == NoError)
         error = setBlocking(ipxSocket, false);
      if(error == NoError)
         Con::printf("IPX initialized on port %d", port);
      else
      {
         closesocket(ipxSocket);
         ipxSocket = INVALID_SOCKET;
         Con::printf("Unable to initialize IPX - error %d", error);
      }
   }
#endif
   netPort = port;
   return ipxSocket != INVALID_SOCKET || udpSocket != INVALID_SOCKET;
}

void Net::closePort()
{
   if(ipxSocket != INVALID_SOCKET)
      closesocket(ipxSocket);
   if(udpSocket != INVALID_SOCKET)
      closesocket(udpSocket);
}

Net::Error Net::sendto(const NetAddress *address, const U8 *buffer, S32 bufferSize)
{