API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 19th, 2019
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.51 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!