SHARE
TWEET

Untitled

a guest May 19th, 2019 66 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "stdafx.h"
  2. #include "SocketGame.h"
  3. #include <winsock2.h>
  4. #include <ws2tcpip.h>
  5. #pragma comment (lib, "Ws2_32.lib")
  6. DWORD dwReconnectLoginServerCount = 0;
  7. DWORD dwTimePacket = 0;
  8. BOOL bCanCheckConnection = FALSE;
  9. extern int                    iLoginServerPingID;
  10. extern int                    iGameServerPingID;
  11. struct PacketReceiving * SocketGame::psaPacketReceiving[100];
  12. int SocketGame::iNextReceiver;
  13. typedef void( __cdecl *t_RecvPacketRouter ) ( UINT Socket );
  14. t_RecvPacketRouter RecvPacketRouter = ( t_RecvPacketRouter )0x00632A50;
  15.  
  16. void SocketGame::SendLoginServer( void * pData, BOOL bEncrypt )
  17. {
  18.     SocketData * sdl = SOCKETL;
  19.     SocketData * sdg = SOCKETG;
  20.     if ( SOCKETL )
  21.         SOCKETL->SendPacket( (Packet*)pData, bEncrypt );
  22. }
  23.  
  24. void SocketGame::SendGameServer( void * pData, BOOL bEncrypt )
  25. {
  26.     if ( SOCKETG )
  27.         SOCKETG->SendPacket( (Packet*)pData, bEncrypt );
  28. }
  29.  
  30. void SocketGame::SetIPPort( const char * pszIP, int iPort )
  31. {
  32.     char * ip = (char*)pszIP;
  33.     if ( (pszIP[0] < '0') || (pszIP[0] > '9') )
  34.     {
  35.         hostent * record = gethostbyname( pszIP );
  36.         in_addr * address = (in_addr *)record->h_addr;
  37.         ip = inet_ntoa( *address );
  38.     }
  39.     // IP
  40.     STRINGCOPYLEN( (char*)0x0CDE160, 16, ip );
  41.     STRINGCOPYLEN( (char*)0x0CDE13C, 16, ip );
  42.     STRINGCOPYLEN( (char*)0x0CDE1A8, 16, ip );
  43.     STRINGCOPYLEN( (char*)0x0CDE184, 16, ip );
  44.     PORT_GAME = iPort;
  45.     // PORT
  46.     *(UINT*)0x0CDE180 = PORT_GAME;
  47.     *(UINT*)0x0CDE15C = PORT_GAME;
  48.     *(UINT*)0x0CDE1A4 = PORT_GAME;
  49.     *(UINT*)0x0CDE1C8 = PORT_GAME;
  50. }
  51.  
  52. int SocketGame::GetNumFreeSlots()
  53. {
  54.     int iFreeSlots = 0;
  55.     for( int i = 0; i < iMaxConnections; i++ )
  56.     {
  57.         SocketData * sd = pcaSocketData + i;
  58.         if( !sd->bInUse )
  59.             iFreeSlots++;
  60.     }
  61.     return iFreeSlots;
  62. }
  63.  
  64. SocketData * SocketGame::GetFreeSocketData()
  65. {
  66.     SocketData * r = NULL;
  67.     for ( int i = 0; i < iMaxConnections; i++ )
  68.     {
  69.         SocketData * sd = pcaSocketData + i;
  70.         if ( !sd->bInUse )
  71.         {
  72.             sd->Init();
  73.             r = sd;
  74.             break;
  75.         }
  76.     }
  77.     return r;
  78. }
  79.  
  80. SocketData * SocketGame::GetSocketData( const char * pszIP, int iPort )
  81. {
  82.     for ( int i = 0; i < iMaxConnections; i++ )
  83.     {
  84.         SocketData * sd = pcaSocketData + i;
  85.         if ( sd->bInUse && STRINGCOMPARE( sd->szIP, pszIP ) && sd->iPort == iPort )
  86.         {
  87.             return sd;
  88.         }
  89.     }
  90.     return NULL;
  91. }
  92. void SocketGame::DisconnectOldSocket()
  93. {
  94.     for ( int i = 0; i < iMaxConnections; i++ )
  95.     {
  96.         SocketData * sd = pcaSocketData + i;
  97.         if ( !sd->bInUse && sd->bConnected )
  98.         {
  99.             SOCKETGAME->SocketClose( sd );
  100.         }
  101.     }
  102. }
  103.  
  104. SocketData * SocketGame::Connect( const char * pszIP, int iPort )
  105. {
  106.     SocketData * sd = NULL;
  107.     if ( (sd = SOCKETGAME->GetSocketData( pszIP, iPort )) == NULL )
  108.     {
  109.         sd = SOCKETGAME->GetFreeSocketData();
  110.         if ( sd )
  111.         {
  112.             if ( !sd->Connect( pszIP, iPort ) )
  113.             {
  114.                 sd->UnInit();
  115.                 return NULL;
  116.             }
  117.         }
  118.     }
  119.     else
  120.     {
  121.         PacketReceiving * p = new PacketReceiving;
  122.         p->bInUse = TRUE;
  123.         p->bDelete = TRUE;
  124.         //Connection already Confirmed
  125.         PacketVersion sPacket;
  126.         sPacket.iLength = sizeof( PacketVersion );
  127.         sPacket.iHeader = PKTHDR_Version; // edit chaos
  128.         sPacket.bServerFull = FALSE;
  129.         sPacket.iUnk2 = 0;
  130.         sPacket.iVersion = READDWORD( 0x04AF7FFC );
  131.         CopyMemory( p->baPacket, &sPacket, sizeof( PacketVersion ) );
  132.         SOCKETGAME->SocketPacket( sd, p );
  133.     }
  134.     return sd;
  135. }
  136. void SocketGame::SocketClose( SocketData * sd )
  137. {
  138.     if ( (sd) && (sd->bInUse) )
  139.     {
  140.         if ( sd == SOCKETL )
  141.             SOCKETL = NULL;
  142.         if ( sd == SOCKETG )
  143.             SOCKETL = NULL;
  144.         while ( sd->bConnecting )
  145.             Sleep( 2500 );
  146.         sd->Close();
  147.         sd->UnInit();
  148.     }
  149. }
  150. void SocketGame::SocketPacket( SocketData * sd, PacketReceiving * p )
  151. {
  152.     //pcMutex->Lock( 5000 );
  153.     Packet * psPacket = (Packet*)p->baPacket;
  154.     int len = psPacket->iLength;
  155.     if ( len > 0x2000 )
  156.         return;
  157.     PACKETHANDLER->AnalyzePacket( sd, psPacket );
  158.     /* TEMPORARILY */
  159.     static char * packettemp = NULL;
  160.     if ( packettemp == NULL )
  161.         packettemp = new char[0x202C];
  162.     char * pointertotmp = packettemp;
  163.     memcpy( packettemp + 0x2C, psPacket, len );
  164.     WRITEDWORD( pointertotmp, sd );
  165.     if ( psPacket->iHeader == PKTHDR_KeySet )
  166.     {
  167.     //    sd->KeyObfuscatorSet( ((PacketSendKey*)&p->sPacket)->bKey );
  168.     }
  169.     else
  170.     {
  171.         __asm
  172.         {
  173.             PUSHAD;
  174.             MOV EAX, packettemp;
  175.             PUSH EAX;
  176.             MOV EAX, 0x00632A50;
  177.             CALL EAX;
  178.             ADD ESP, 4;
  179.             POPAD;
  180.         }
  181.     }
  182.     sd->dwTimeLastPacketReceived = TICKCOUNT;
  183.     sd->FreePacketReceiving( p );
  184.     //pcMutex->Unlock();
  185. }
  186. DWORD WINAPI SocketGame::ReceiveThread()
  187. {
  188.     return TRUE;
  189. }
  190. DWORD WINAPI SocketGame::Receiver( SocketData * sd )
  191. {
  192.     SocketGame * m = SOCKETGAME;
  193.     HWND hWnd = m->GetHWND();
  194.     PacketReceiving * p;
  195.     do
  196.     {
  197.         WaitForSingleObject( sd->hReceiveThreadSignal, INFINITE );
  198.         if( !m->IsActive() )
  199.             break;
  200.         while( (p = sd->ReceivePacket()) != NULL )
  201.         {
  202.             PostMessageA( hWnd, WM_SOCKETPACKET, (WPARAM)sd, (LPARAM)p );
  203.         }
  204.         sd->bBlockSend = TRUE;
  205.         if ( m->IsActive() )
  206.         {
  207.             if ( sd->bConnected )
  208.             {
  209.                 WNDPROC_SOCKETCLOSE( hWnd, sd );
  210.             }
  211.         }
  212.     } while( m->IsActive() );
  213.     return TRUE;
  214. }
  215.  
  216. DWORD WINAPI SocketGame::Sender( SocketData * sd )
  217. {
  218.     SocketGame * m = SOCKETGAME;
  219.     HWND hWnd = m->GetHWND();
  220.     PacketSending * p;
  221.     do
  222.     {
  223.         WaitForSingleObject( sd->hSendThreadSignal, INFINITE );
  224.         if( !m->IsActive() )
  225.             break;
  226.         while( (p = sd->NextPacketSending()) != NULL )
  227.         {
  228.             //Post Packet Message
  229.             if ( !sd->Send( p ) )
  230.             {
  231.                 sd->FreePacketSending( p );
  232.                 break;
  233.             }
  234.             sd->FreePacketSending( p );
  235.         }
  236.     } while( m->IsActive() );
  237.     return TRUE;
  238. }
  239.  
  240. void SocketGame::Init( HWND hwnd )
  241. {
  242.     hWnd = hwnd;
  243.     bActive = TRUE;
  244.  
  245.     int iMaxSendPacket = 500;
  246.     int iMaxReceivePacket = 500;
  247.  
  248.     pcMutex = new CMutex( "Socket Game" );
  249.  
  250.     // Init socket data
  251.     *( UINT* )0x213358C = *( UINT* )0x0A17540;
  252.    
  253.     BOOL bTestServer = FALSE;
  254.  
  255.     char * ip = NULL;
  256.     ip = "190.2.131.139";
  257.  
  258.     SetIPPort( ip, PORT_GAME );
  259.     *( UINT* )0x2335020 = 0;
  260.  
  261.     // Initialize criticals sections
  262.     InitializeCriticalSection( ( LPCRITICAL_SECTION )0x213321C );
  263.     InitializeCriticalSection( ( LPCRITICAL_SECTION )0x2334DB8 );
  264.     InitializeCriticalSection( ( LPCRITICAL_SECTION )0x2334D98 );
  265.     *( UINT* )0x2133D90 = 0;
  266.  
  267.     // Define socket loop
  268.     UINT socketLoop = 0x2335050;
  269.     int iLoopVar = 0;
  270.  
  271.     // Socket Loop
  272.     while ( socketLoop < 0x2444350 )
  273.     {
  274.         *( UINT* )( socketLoop + 4 ) = iLoopVar;
  275.         *( UINT* )( socketLoop + 8 ) = 0;
  276.         *( UINT* )( socketLoop ) = socketLoop;
  277.         *( UINT* )( socketLoop + 0x24 ) = socketLoop;
  278.         *( UINT* )( socketLoop + 0x2150 ) = socketLoop;
  279.         *( UINT* )( socketLoop + 0x427C ) = 0;
  280.         *( UINT* )( socketLoop + 0x4280 ) = 0;
  281.         iLoopVar += 1;
  282.         socketLoop += 0x43CC;
  283.     }
  284.  
  285.     // Socket Loop
  286.     socketLoop = 0x2134598;
  287.     while ( socketLoop < 0x2334D98 )
  288.     {
  289.         *( UINT* )socketLoop = 0;
  290.         socketLoop += 0x2008;
  291.     }
  292.  
  293.     // PORT
  294.     *( UINT* )0x0CDE180 = PORT_GAME;
  295.     *( UINT* )0x0CDE15C = PORT_GAME;
  296.     *( UINT* )0x0CDE1A4 = PORT_GAME;
  297.     *( UINT* )0x0CDE1C8 = PORT_GAME;
  298.  
  299.  
  300.     iMaxConnections = 2; // Chaos EDIT default = 8 what is this for, no fing idea.
  301.     pcaSocketData = new SocketData[iMaxConnections];
  302.     for ( int i = 0; i < iMaxConnections; i++ )
  303.     {
  304.         SocketData * sd = pcaSocketData + i;
  305.         sd->pcThis        = sd;
  306.         sd->bInUse        = FALSE;
  307.         sd->Prepare( iMaxSendPacket, iMaxReceivePacket );
  308.         sd->hReceiveThread = CreateThread( NULL, KB16, (LPTHREAD_START_ROUTINE)&SocketGame::Receiver, sd, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL );
  309.         sd->hSendThread = CreateThread( NULL, KB16, (LPTHREAD_START_ROUTINE)&SocketGame::Sender, sd, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL );
  310.     }
  311. }
  312.  
  313.  
  314. BOOL WINAPI SocketGame::CheckConnection()
  315. {
  316.     static DWORD dwTimeCheckL = 0;
  317.     static DWORD dwTimeCheckG = 0;
  318.     //Login Server
  319.     if ( SOCKETGAME )
  320.     {
  321.         SocketData * sd = SOCKETL;
  322.         if ( sd )
  323.         {
  324.             if ( SOCKETGAME->szLoginIP[0] == 0 )
  325.             {
  326.                 STRINGCOPY( SOCKETGAME->szLoginIP, sd->szIP );
  327.                 SOCKETGAME->iLoginPort = sd->iPort;
  328.             }
  329.             if ( (sd->dwTimeLastPacketReceived + 5000) < TICKCOUNT )
  330.             {
  331.                 SOCKETGAME->bLoginServerReconnect = TRUE;
  332.             }
  333.         }
  334.         else
  335.             SOCKETGAME->bLoginServerReconnect = TRUE;
  336.     }
  337.     //Game Server
  338.     if ( SOCKETGAME )
  339.     {
  340.         SocketData * sd = SOCKETG;
  341.         if ( sd )
  342.         {
  343.             if ( SOCKETGAME->szGameIP[0] == 0 )
  344.             {
  345.                 STRINGCOPY( SOCKETGAME->szGameIP, sd->szIP );
  346.                 SOCKETGAME->iGameServerPort = sd->iPort;
  347.             }
  348.             if ( (sd->dwTimeLastPacketReceived + 5000) < TICKCOUNT )
  349.             {
  350.                 SOCKETGAME->bGameServerReconnect = TRUE;
  351.             }
  352.         }
  353.         else
  354.             SOCKETGAME->bGameServerReconnect = TRUE;
  355.     }
  356.     if ( SOCKETGAME->bLoginServerReconnect )
  357.     {
  358.         if ( dwTimeCheckL < TICKCOUNT )
  359.         {
  360.             if ( SOCKETL )
  361.             {
  362.                 if ( SOCKETL->bConnected )
  363.                     SOCKETGAME->SocketClose( SOCKETL );
  364.                 SOCKETL = NULL;
  365.             }
  366.             SOCKETGAME->iReconnectLCOUNT++;
  367.             if ( SOCKETGAME->iReconnectLCOUNT > 10 )
  368.             {
  369.                 DISCONNECT_TYPE = -1;
  370.                 DISCONNECT_TIME = TICKCOUNT;
  371.             }
  372.             else
  373.             {
  374.                 ChatGame::AddChatBoxTextEx( EChatColor::CHATCOLOR_Error, "> Reconnecting to Login Server (%d/10)", SOCKETGAME->iReconnectLCOUNT );
  375.                 SocketData * sd = SOCKETGAME->Connect( SOCKETGAME->szLoginIP, SOCKETGAME->iLoginPort );
  376.                 SOCKETL = sd;
  377.                 if ( sd )
  378.                 {
  379.                     //Send Reconnect Packet
  380.                     PacketReconnectUser s;
  381.                     s.iLength = sizeof( PacketReconnectUser );
  382.                     s.iHeader = PKTHDR_Reconnect;
  383.                     s.dwObjectID = UNITDATA->iID;
  384.                     s.iUnk = 0;
  385.                     STRINGCOPY( s.szUserID, (char*)0x39033E8 );
  386.                     SENDPACKETL( &s );
  387.                 }
  388.             }
  389.             dwTimeCheckL = TICKCOUNT + 5000;
  390.         }
  391.     }
  392.     if ( SOCKETGAME->bGameServerReconnect )
  393.     {
  394.         if ( dwTimeCheckG < TICKCOUNT )
  395.         {
  396.             if ( SOCKETG )
  397.             {
  398.                 if ( SOCKETG->bConnected )
  399.                     SOCKETGAME->SocketClose( SOCKETG );
  400.                 SOCKETG = NULL;
  401.             }
  402.             SOCKETGAME->iReconnectGCOUNT++;
  403.             if ( SOCKETGAME->iReconnectGCOUNT > 10 )
  404.             {
  405.                 DISCONNECT_TYPE = -1;
  406.                 DISCONNECT_TIME = TICKCOUNT;
  407.             }
  408.             else
  409.             {
  410.                 ChatGame::AddChatBoxTextEx( EChatColor::CHATCOLOR_Error, "> Reconnecting to Game Server (%d/10)", SOCKETGAME->iReconnectGCOUNT );
  411.                 SocketData * sd = SOCKETGAME->Connect( SOCKETGAME->szGameIP, SOCKETGAME->iGameServerPort );
  412.                 SOCKETG = sd;
  413.                 if ( sd )
  414.                 {
  415.                     //Send Reconnect Packet
  416.                     PacketReconnectUser s;
  417.                     s.iLength = sizeof( PacketReconnectUser );
  418.                     s.iHeader = PKTHDR_Reconnect;
  419.                     s.dwObjectID = UNITDATA->iID;
  420.                     s.iUnk = 0;
  421.                     STRINGCOPY( s.szUserID, (char*)0x39033E8 );
  422.                     SENDPACKETG( &s );
  423.                 }
  424.             }
  425.             dwTimeCheckG = TICKCOUNT + 5000;
  426.         }
  427.     }
  428.     return TRUE;
  429. }
  430. void SocketGame::Connected()
  431. {
  432.     bCanCheckConnection = TRUE;
  433. }
  434. void SocketGame::Loop()
  435. {
  436.     if ( Game::GetGameMode() == GAMEMODE_InGame )
  437.     {
  438.         static bool bFirst = false;
  439.         if ( !bFirst )
  440.         {
  441.             if ( SOCKETL && SOCKETG )
  442.             {
  443.                 ZeroMemory( (void*)0x03A46600, 0x8E * 4 );
  444.                 WRITEDWORD( 0x03A975F4, 0 );
  445.                 WRITEDWORD( 0x03A975F8, 0 );
  446.                 WRITEDWORD( 0x03A97648, 0 );
  447.                 WRITEDWORD( 0x03A97664, 0 );
  448.                 WRITEDWORD( 0x03A3E3BC, READDWORD( 0x00CF4824 ) );
  449.                 WRITEDWORD( 0x03A46844, 0 );
  450.                 WRITEDWORD( 0x00CF47C0, 0 );
  451.                 WRITEDWORD( 0x03A976E4, 0 );
  452.                 WRITEDWORD( 0x039C8710, 0 );
  453.                 WRITEDWORD( 0x00A1781C, 0 );
  454.                 WRITEDWORD( 0x03A975F8, -1 );
  455.                 ZeroMemory( (void*)0x039F0308, 0x80 * 4 );
  456.                 ZeroMemory( (void*)0x0397A708, 0x6 * 4 );
  457.                 ZeroMemory( (void*)0x03A46AA0, 0x6 * 4 );
  458.  
  459.                 UnitData * ud = UNITDATA;
  460.                 if ( ud )
  461.                 {
  462.                     PacketSelectCharacter s;
  463.                     s.iLength        = sizeof( PacketSelectCharacter );
  464.                     s.iHeader        = PKTHDR_SelectCharacter;
  465.                     s.dwReserved1    = 0;
  466.                     s.dwReserved2    = 0;
  467.                     s.dwReserved3    = 0;
  468.                     STRINGCOPY( s.szCharName, ud->sCharacterData.szName );
  469.                     SENDPACKETL( &s );
  470.                 }
  471.             }
  472.             bFirst = true;
  473.         }
  474.         else
  475.         {
  476.             CALL( 0x006335B8 ); //Update Character... 48470013
  477.  
  478.             if ( bCanCheckConnection )
  479.                 SOCKETGAME->CheckConnection();
  480.  
  481.  
  482.             PingConnections();
  483.  
  484.             if ( DISCONNECT_TYPE != (-2) )
  485.             {
  486.                 if ( SOCKETL == NULL )
  487.                 {
  488.                     if ( DISCONNECT_TYPE == -1 )
  489.                     {
  490.                         DISCONNECT_TYPE = 1;
  491.                         ChatGame::AddChatBoxTextEx( CHATCOLOR_Error, "Connection lost with %s", "Login Server" );
  492.                     }
  493.                 }
  494.                 else if ( SOCKETG == NULL )
  495.                 {
  496.                     if ( DISCONNECT_TYPE == -1 )
  497.                     {
  498.                         DISCONNECT_TYPE = 2;
  499.                         ChatGame::AddChatBoxTextEx( CHATCOLOR_Error, "Connection lost with %s", "Game Server" );
  500.                     }
  501.                 }
  502.             }
  503.         }
  504.  
  505.         CALL( 0x0061ECF0 );
  506.         CALL( 0x00408DF0 );
  507.     }
  508. }
  509. void SocketGame::Shutdown()
  510. {
  511.     bActive = FALSE;
  512. }
  513. void SocketGame::PingConnections()
  514. {
  515.     extern DWORD                dwLastTickLogin;
  516.     extern DWORD                dwLastTickGame;
  517.  
  518.     static int iCounter = 0;
  519.  
  520.     iCounter++;
  521.  
  522.     static DWORD dwTick = 0;
  523.  
  524.     for (int i = 0; i < iMaxConnections; i++)
  525.     {
  526.         SocketData * sd = pcaSocketData + i;
  527.  
  528.         if ((sd->bInUse) && (sd->bConnected))
  529.         {
  530.             if ((sd->bPing == false))
  531.             {
  532.                 if ((TICKCOUNT - dwTick) >= 2500) // changed chaos 150  default
  533.                 {
  534.                     if (SOCKETG)
  535.                     {
  536.                         PacketPing s;
  537.                         s.iLength = sizeof(PacketPing);
  538.                         s.iHeader = PKTHDR_Ping;
  539.                         dwLastTickGame = TICKCOUNT;
  540.                         SENDPACKETG(&s);
  541.                     }
  542.  
  543.                     else if ( iCounter >= 100 && SOCKETL)
  544.                     {
  545.                         PacketPing s;
  546.                         s.iLength = sizeof(PacketPing);
  547.                         s.iHeader = PKTHDR_Ping;
  548.                         dwLastTickLogin = TICKCOUNT;
  549.                         SENDPACKETL(&s);
  550.                     }
  551.                     else
  552.                     {
  553.                         //Reset Pinging if taking longer than 60 seconds
  554.                         if (sd->GetPing(TICKCOUNT) > 60000)
  555.                             sd->bPing = false;
  556.                     }
  557.  
  558.                     dwTick = TICKCOUNT;
  559.                 }
  560.             }
  561.         }
  562.     }
  563.     if (iCounter >= 100)
  564.         iCounter = 0; // users always had DC3, and this part of the code is doing the 10 checks to reconnect to gameserver ( which i added ) when we had the issue.
  565. }
  566.  
  567. void SocketGame::SendPacket( UINT Socket, UINT packet, int size )
  568. {
  569.     send( *( UINT* )( Socket + 8 ), ( const char * )packet, size, 0 );
  570.     ANTICHEATHANDLER->CheckThread();
  571. }
  572.  
  573. void SocketGame::RecvPacket( UINT Socket )
  574. {
  575.     int SRecv = 0;
  576.     while ( true )
  577.     {
  578.         SRecv = recv( *( int* )( Socket + 4 ), ( char* )( Socket + 0x2C ), 0x2000, 0 );
  579.         if ( SRecv != SOCKET_ERROR )
  580.         {
  581.             *( int* )( Socket + 8 ) = *( int* )( Socket + 0x2C );
  582.             *( int* )( Socket + 12 ) = *( int* )( Socket + 0x2C + 4 );
  583.             RecvPacketRouter( Socket );
  584.         }
  585.     }
  586. }
  587. SocketGame::~SocketGame()
  588. {
  589.     for ( int i = 0; i < iMaxConnections; i++ )
  590.     {
  591.         SocketData * sd = pcaSocketData + i;
  592.         TerminateThread( sd->hReceiveThread, 0 );
  593.         TerminateThread( sd->hSendThread, 0 );
  594.     }
  595.     DELETA( pcaSocketData );
  596. }
  597. void __cdecl SendPacketHook( UINT Socket, UINT packet, int size )
  598. {
  599.     std::shared_ptr<SocketGame> pSocket = std::make_shared<SocketGame>( );
  600.     pSocket->SendPacket( Socket, packet, size );
  601. }
  602.  
  603. void __cdecl RecvDataHook( UINT Socket )
  604. {
  605.     std::shared_ptr<SocketGame> pSocket = std::make_shared<SocketGame>( );
  606.     pSocket->RecvPacket( Socket );
  607. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top