zfxws.cpp

This is a book introduce some tech about Game Engine 3D

// File: ZFXWS.cpp

#include <windows.h>       // type definitions
#include "ZFXWS.h"         // class definition

bool g_bLF=false;
int  g_PkgSize=sizeof(ZFXPACKAGE);


/*-----------------------------------------------------------*/
/* DLL stuff implementation                                  *
/*-----------------------------------------------------------*/

/**
 * DLL Entry Point similar to WinMain()/main()
 */
BOOL WINAPI DllEntryPoint(HINSTANCE hDll,
                          DWORD     fdwReason,
                          LPVOID    lpvReserved) {
   switch(fdwReason) {
      // called when we attach to the DLL
      case DLL_PROCESS_ATTACH:
         /* dll init/setup stuff */
         break;
      case DLL_PROCESS_DETACH:
         /* dll shutdown/release stuff */
         break;
      default:
         break;
      };
   
   return TRUE;
   } // DllEntryPoint
/*----------------------------------------------------------------*/

/**
 * Exported create function: Creates a new ZFXNetworkDevice object.
 */
HRESULT CreateNetworkDevice(HINSTANCE hDLL, ZFXNetworkDevice **pDevice) {
   if(!*pDevice) {
      *pDevice = new ZFXWS(hDLL);
      return ZFX_OK;
      }
   return ZFX_FAIL;
   }
/*----------------------------------------------------------------*/

/**
 * Exported release function: Realeses the given ZFXNetworkDevice object.
 */
HRESULT ReleaseNetworkDevice(ZFXNetworkDevice **pDevice) {
   if(!*pDevice) {
      return ZFX_FAIL;
      }
   delete *pDevice;
   *pDevice = NULL;
   return ZFX_OK;
   }
/*----------------------------------------------------------------*/





/*-----------------------------------------------------------*/
/* ZFXWS class implementation                                *
/*-----------------------------------------------------------*/

/**
 * Constructor
 */
ZFXWS::ZFXWS(HINSTANCE hDLL) {
   m_hDLL         = hDLL;
   m_pLog         = NULL;
   m_pSockObj      = NULL;
   m_Buffer       = NULL;
   m_nPort        = 0;
   m_ClID         = 1;        // 0 reserved for server
   m_ClCount      = 0;
   m_ClMax        = 0;        // 0 = unlimited
   m_bRunning     = false;

   // open a new logfile
   m_pLog = fopen("Log_ZFXNetworkDevice.txt", "w");
   Log("online (waiting for initialization call)");
   }
/*----------------------------------------------------------------*/


/**
 * Destructor
 */ 
ZFXWS::~ZFXWS() {
   Release();
   }
/*----------------------------------------------------------------*/


/**
 * Release all stuff.
 */
void ZFXWS::Release() {
   Log("shutting down WinSock");

   if (m_Mode == NMD_SERVER) {
      for (int i=0; i<m_ClCount; i++) {
         shutdown(m_Clients[i].skToClient,0x02);
         closesocket(m_Clients[i].skToClient);
         m_Clients[i].skToClient = INVALID_SOCKET;
         }
      }

   if (m_pSockObj) {
      delete m_pSockObj;
      m_pSockObj = NULL;
      }

   if (m_Buffer) {
      delete [] m_Buffer;
      m_Buffer = NULL;
      }

   // clean up winsock
   WSACleanup();
   m_bRunning = false;
   Log("offline (ok)");
   fclose(m_pLog);
   }
/*----------------------------------------------------------------*/


/**
 * Initialize WInSock first, then the appropriate socketobjects.
 * -> IN: HWND       - handle to application main window
 *        ZFXNETMODE - put NMD_CLIENT or NMD_SERVER here
 *        int        - number of port to use
 *        char       - ip address needed for client construction
 *        UINT       - maximum size of one package
 *        UINT       - maximum number of clients for one server
 *        bool       - flush log at each write operation
 */
HRESULT ZFXWS::Init(HWND hWnd, ZFXNETMODE nmd, int nPort,
                    char *pIP, UINT nMaxPkgSize, 
                    UINT nMaxClients, bool bSaveLog) {
   WSADATA wsaData;
   UINT    nEvents=0;
   WORD    wVersion;
   int     nRes;

   Log("calling initialization");
   
   m_nMaxSize   = nMaxPkgSize;
   m_Buffer     = new char[m_nMaxSize+g_PkgSize];
   m_hWndMain   = hWnd;
   m_nPort      = nPort;
   m_Mode       = nmd;
   m_ClMax      = nMaxClients;
   g_bLF        = bSaveLog;

   if (pIP) sprintf(m_pIP, "%s", pIP);

   wVersion = MAKEWORD(2,0);

   // startup WinSock
   if ((nRes=WSAStartup(wVersion, &wsaData))!=0) {
      if (nRes==WSAEINPROGRESS)
         Log("error: blocking WinSock app is running");
      else if (nRes==WSAVERNOTSUPPORTED)
         Log("error: WinSock version not supported");
      else if (nRes==WSASYSNOTREADY)
         Log("error: network subsystem not ready");
      else if (nRes==WSAEPROCLIM)
         Log("error: WinSock too buisy for another task");
      return ZFX_FAIL;
      }
   Log("WinSock 2.0 initialized (NMD: %d)", m_Mode);

   // create SockectObject as server listening to port
   if (m_Mode==NMD_SERVER) { 
      if (FAILED(CreateServer(&m_pSockObj))) {
         Log("error: CreateServer(Port:%d) failed", m_nPort);
         return ZFX_FAIL;
         }
      }
   // create SocketObject as client sending data to IP::Port
   else if (m_Mode==NMD_CLIENT) {
      if (strcmp(m_pIP, "")==0)
         sprintf(m_pIP, "LOCALHOST");
      if (FAILED(CreateClient(&m_pSockObj))) {
         Log("error: CreateClient(Port:%d to Server-IP:%s) failed", m_nPort, m_pIP);
         return ZFX_FAIL;
         }
      }
   else
      return ZFX_INVALIDPARAM;

   Log("initialized (online and ready)");
   m_bRunning = true;
   return ZFX_OK;
   } // Init
/*----------------------------------------------------------------*/


/**
 * Create socketobject as client and make it ready for traffic. A
 * client needs to be connected to the server IP at the port the
 * server is listening to.
 */
HRESULT ZFXWS::CreateClient(ZFXSocketObject **ppSkObject) {
   UINT nEvents=0;

   Log("firing up client");
   (*ppSkObject) = new ZFXSocketObject(m_pLog);

   if (!(*ppSkObject)) {
      Log("error: ZFXSocketObject construction failed in ZFXWS::CreateClient");
      return ZFX_FAIL;
      }
   Log("ZFXSocketObject constructed");

   // 1. step: create a socket object
   if (FAILED( (*ppSkObject)->CreateSocket() ))
      return ZFX_FAIL;
   Log("socket created");


   if (m_pIP == NULL) {
      gethostname(m_pIP, 10);
      }
   
   // 2. step: try to connect to the server
   if (FAILED( (*ppSkObject)->Connect(m_pIP, m_nPort) ))
      return ZFX_FAIL;
   Log("ZFXSocketObject connected as client to port: %d", m_nPort);

   nEvents |= FD_READ | FD_CLOSE;

   // 3. step: notification from windows WM_ about incoming events
   if (WSAAsyncSelect( (*ppSkObject)->GetSocket(), m_hWndMain, 
                      WM_ZFXCLIENT, nEvents)==SOCKET_ERROR) {
      Log("error: WSAAsyncSelect(WM_ZFXCLIENT) failed");
      m_pSockObj->Disconnect();
      return ZFX_FAIL;
      }
   return ZFX_OK;
   } // Create Client
/*----------------------------------------------------------------*/


/**
 * Create socketobjects as server and make them ready for traffic.
 * The server just needs to listen to the port the client is sending
 * its data to.
 */
HRESULT ZFXWS::CreateServer(ZFXSocketObject **ppSkObject) {
   UINT nEvents=0;

   Log("firing up server");
   (*ppSkObject) = new ZFXSocketObject(m_pLog);
   
   if (!(*ppSkObject)) {
      Log("error: m_pSkObject construction failed in ZFXWS::CreateServer");
      return ZFX_FAIL;
      }
   Log("ZFXSocketObjects constructed");

   // 1. step: create a socket object
   if (FAILED( (*ppSkObject)->CreateSocket() ))
      return ZFX_FAIL;
   Log("socket created");
   
   // 2. step: name the socket cause it's a server
   if (FAILED( (*ppSkObject)->Bind(m_nPort) ))
      return ZFX_FAIL;
   Log("server bind to port: %d", m_nPort);

   // 3. step: listen for incoming connection requests
   if (FAILED( (*ppSkObject)->Listen() ))
      return ZFX_FAIL;
   Log("server is now listening for incoming connection...");

   nEvents |= FD_READ | FD_WRITE | FD_CONNECT | FD_ACCEPT | FD_CLOSE;

   // 4. step: notification from windows WM_ about incoming events
   if (WSAAsyncSelect((*ppSkObject)->GetSocket(), m_hWndMain, 
                      WM_ZFXSERVER, nEvents)==SOCKET_ERROR) {
      Log("error: WSAAsyncSelect(WM_ZFXSERVER) failed");
      m_pSockObj->Disconnect();