API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 19th, 2019
122
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.54 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.     pcMutex = new CMutex( "Socket Game" );
  244.     // Init socket data
  245.     *( UINT* )0x213358C = *( UINT* )0x0A17540;
  246.     BOOL bTestServer = FALSE;
  247.     char * ip = NULL;
  248.     ip = "190.2.131.139"; // official 137.74.4.97
  249.     //ip = "158.69.136.79";
  250.     //ip = "127.0.0.1";
  251.     SetIPPort( ip, PORT_GAME );
  252.     *( UINT* )0x2335020 = 0;
  253.     // Initialize criticals sections
  254.     InitializeCriticalSection( ( LPCRITICAL_SECTION )0x213321C );
  255.     InitializeCriticalSection( ( LPCRITICAL_SECTION )0x2334DB8 );
  256.     InitializeCriticalSection( ( LPCRITICAL_SECTION )0x2334D98 );
  257.     *( UINT* )0x2133D90 = 0;
  258.     // Define socket loop
  259.     UINT socketLoop = 0x2335050;
  260.     int iLoopVar = 0;
  261.     // Socket Loop
  262.     while ( socketLoop < 0x2444350 )
  263.     {
  264.         *( UINT* )( socketLoop + 4 ) = iLoopVar;
  265.         *( UINT* )( socketLoop + 8 ) = 0;
  266.         *( UINT* )( socketLoop ) = socketLoop;
  267.         *( UINT* )( socketLoop + 0x24 ) = socketLoop;
  268.         *( UINT* )( socketLoop + 0x2150 ) = socketLoop;
  269.         *( UINT* )( socketLoop + 0x427C ) = 0;
  270.         *( UINT* )( socketLoop + 0x4280 ) = 0;
  271.         iLoopVar += 1;
  272.         socketLoop += 0x43CC;
  273.     }
  274.     // Socket Loop
  275.     socketLoop = 0x2134598;
  276.     while ( socketLoop < 0x2334D98 )
  277.     {
  278.         *( UINT* )socketLoop = 0;
  279.         socketLoop += 0x2008;
  280.     }
  281.     /*if ( bTestServer )
  282.     {
  283.         PORT_GAME = 10010;
  284.     }*/
  285.     // PORT
  286.     *( UINT* )0x0CDE180 = PORT_GAME;
  287.     *( UINT* )0x0CDE15C = PORT_GAME;
  288.     *( UINT* )0x0CDE1A4 = PORT_GAME;
  289.     *( UINT* )0x0CDE1C8 = PORT_GAME;
  290.     bActive = TRUE;
  291.     iMaxConnections = 8; // Chaos EDIT default = 8 what is this for, no fing idea.
  292.     pcaSocketData = new SocketData[iMaxConnections];
  293.     for ( int i = 0; i < iMaxConnections; i++ )
  294.     {
  295.         SocketData * sd = pcaSocketData + i;
  296.         sd->pcThis        = sd;
  297.         sd->bInUse        = FALSE;
  298.         sd->Prepare( 500, 500 );
  299.         sd->hReceiveThread = CreateThread( NULL, KB16, (LPTHREAD_START_ROUTINE)&SocketGame::Receiver, sd, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL );
  300.         sd->hSendThread = CreateThread( NULL, KB16, (LPTHREAD_START_ROUTINE)&SocketGame::Sender, sd, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL );
  301.     }
  302.     bActive = TRUE;
  303. }
  304. BOOL WINAPI SocketGame::CheckConnection()
  305. {
  306.     static DWORD dwTimeCheckL = 0;
  307.     static DWORD dwTimeCheckG = 0;
  308.     //Login Server
  309.     if ( SOCKETGAME )
  310.     {
  311.         SocketData * sd = SOCKETL;
  312.         if ( sd )
  313.         {
  314.             if ( SOCKETGAME->szLoginIP[0] == 0 )
  315.             {
  316.                 STRINGCOPY( SOCKETGAME->szLoginIP, sd->szIP );
  317.                 SOCKETGAME->iLoginPort = sd->iPort;
  318.             }
  319.             if ( (sd->dwTimeLastPacketReceived + 20000) < TICKCOUNT )
  320.             {
  321.                 SOCKETGAME->bLoginServerReconnect = TRUE;
  322.             }
  323.         }
  324.         else
  325.             SOCKETGAME->bLoginServerReconnect = TRUE;
  326.     }
  327.     //Game Server
  328.     if ( SOCKETGAME )
  329.     {
  330.         SocketData * sd = SOCKETG;
  331.         if ( sd )
  332.         {
  333.             if ( SOCKETGAME->szGameIP[0] == 0 )
  334.             {
  335.                 STRINGCOPY( SOCKETGAME->szGameIP, sd->szIP );
  336.                 SOCKETGAME->iGameServerPort = sd->iPort;
  337.             }
  338.             if ( (sd->dwTimeLastPacketReceived + 20000) < TICKCOUNT )
  339.             {
  340.                 SOCKETGAME->bGameServerReconnect = TRUE;
  341.             }
  342.         }
  343.         else
  344.             SOCKETGAME->bGameServerReconnect = TRUE;
  345.     }
  346.     if ( SOCKETGAME->bLoginServerReconnect )
  347.     {
  348.         if ( dwTimeCheckL < TICKCOUNT )
  349.         {
  350.             if ( SOCKETL )
  351.             {
  352.                 if ( SOCKETL->bConnected )
  353.                     SOCKETGAME->SocketClose( SOCKETL );
  354.                 SOCKETL = NULL;
  355.             }
  356.             SOCKETGAME->iReconnectLCOUNT++;
  357.             if ( SOCKETGAME->iReconnectLCOUNT > 10 )
  358.             {
  359.                 DISCONNECT_TYPE = -1;
  360.                 DISCONNECT_TIME = TICKCOUNT;
  361.             }
  362.             else
  363.             {
  364.                 ChatGame::AddChatBoxTextEx( EChatColor::CHATCOLOR_Error, "> Reconnecting to Login Server (%d/10)", SOCKETGAME->iReconnectLCOUNT );
  365.                 SocketData * sd = SOCKETGAME->Connect( SOCKETGAME->szLoginIP, SOCKETGAME->iLoginPort );
  366.                 SOCKETL = sd;
  367.                 if ( sd )
  368.                 {
  369.                     //Send Reconnect Packet
  370.                     PacketReconnectUser s;
  371.                     s.iLength = sizeof( PacketReconnectUser );
  372.                     s.iHeader = PKTHDR_Reconnect;
  373.                     s.dwObjectID = UNITDATA->iID;
  374.                     s.iUnk = 0;
  375.                     STRINGCOPY( s.szUserID, (char*)0x39033E8 );
  376.                     SENDPACKETL( &s );
  377.                 }
  378.             }
  379.             dwTimeCheckL = TICKCOUNT + 5000;
  380.         }
  381.     }
  382.     if ( SOCKETGAME->bGameServerReconnect )
  383.     {
  384.         if ( dwTimeCheckG < TICKCOUNT )
  385.         {
  386.             if ( SOCKETG )
  387.             {
  388.                 if ( SOCKETG->bConnected )
  389.                     SOCKETGAME->SocketClose( SOCKETG );
  390.                 SOCKETG = NULL;
  391.             }
  392.             SOCKETGAME->iReconnectGCOUNT++;
  393.             if ( SOCKETGAME->iReconnectGCOUNT > 10 )
  394.             {
  395.                 DISCONNECT_TYPE = -1;
  396.                 DISCONNECT_TIME = TICKCOUNT;
  397.             }
  398.             else
  399.             {
  400.                 ChatGame::AddChatBoxTextEx( EChatColor::CHATCOLOR_Error, "> Reconnecting to Game Server (%d/10)", SOCKETGAME->iReconnectGCOUNT );
  401.                 SocketData * sd = SOCKETGAME->Connect( SOCKETGAME->szGameIP, SOCKETGAME->iGameServerPort );
  402.                 SOCKETG = sd;
  403.                 if ( sd )
  404.                 {
  405.                     //Send Reconnect Packet
  406.                     PacketReconnectUser s;
  407.                     s.iLength = sizeof( PacketReconnectUser );
  408.                     s.iHeader = PKTHDR_Reconnect;
  409.                     s.dwObjectID = UNITDATA->iID;
  410.                     s.iUnk = 0;
  411.                     STRINGCOPY( s.szUserID, (char*)0x39033E8 );
  412.                     SENDPACKETG( &s );
  413.                 }
  414.             }
  415.             dwTimeCheckG = TICKCOUNT + 5000;
  416.         }
  417.     }
  418.     return TRUE;
  419. }
  420. void SocketGame::Connected()
  421. {
  422.     bCanCheckConnection = TRUE;
  423. }
  424. void SocketGame::Loop()
  425. {
  426.     if ( Game::GetGameMode() == GAMEMODE_InGame )
  427.     {
  428.         static bool bFirst = false;
  429.         if ( !bFirst )
  430.         {
  431.             if ( SOCKETL && SOCKETG )
  432.             {
  433.                 ZeroMemory( (void*)0x03A46600, 0x8E * 4 );
  434.                 WRITEDWORD( 0x03A975F4, 0 );
  435.                 WRITEDWORD( 0x03A975F8, 0 );
  436.                 WRITEDWORD( 0x03A97648, 0 );
  437.                 WRITEDWORD( 0x03A97664, 0 );
  438.                 WRITEDWORD( 0x03A3E3BC, READDWORD( 0x00CF4824 ) );
  439.                 WRITEDWORD( 0x03A46844, 0 );
  440.                 WRITEDWORD( 0x00CF47C0, 0 );
  441.                 WRITEDWORD( 0x03A976E4, 0 );
  442.                 WRITEDWORD( 0x039C8710, 0 );
  443.                 WRITEDWORD( 0x00A1781C, 0 );
  444.                 WRITEDWORD( 0x03A975F8, -1 );
  445.                 ZeroMemory( (void*)0x039F0308, 0x80 * 4 );
  446.                 ZeroMemory( (void*)0x0397A708, 0x6 * 4 );
  447.                 ZeroMemory( (void*)0x03A46AA0, 0x6 * 4 );
  448.  
  449.                 UnitData * ud = UNITDATA;
  450.                 if ( ud )
  451.                 {
  452.                     PacketSelectCharacter s;
  453.                     s.iLength        = sizeof( PacketSelectCharacter );
  454.                     s.iHeader        = PKTHDR_SelectCharacter;
  455.                     s.dwReserved1    = 0;
  456.                     s.dwReserved2    = 0;
  457.                     s.dwReserved3    = 0;
  458.                     STRINGCOPY( s.szCharName, ud->sCharacterData.szName );
  459.                     SENDPACKETL( &s );
  460.                 }
  461.             }
  462.             bFirst = true;
  463.         }
  464.         else
  465.         {
  466.             CALL( 0x006335B8 ); //Update Character... 48470013
  467.  
  468.             if ( bCanCheckConnection )
  469.                 SOCKETGAME->CheckConnection();
  470.  
  471.  
  472.             PingConnections();
  473.  
  474.             if ( DISCONNECT_TYPE != (-2) )
  475.             {
  476.                 if ( SOCKETL == NULL )
  477.                 {
  478.                     if ( DISCONNECT_TYPE == -1 )
  479.                     {
  480.                         DISCONNECT_TYPE = 1;
  481.                         ChatGame::AddChatBoxTextEx( CHATCOLOR_Error, "Connection lost with %s", "Login Server" );
  482.                     }
  483.                 }
  484.                 else if ( SOCKETG == NULL )
  485.                 {
  486.                     if ( DISCONNECT_TYPE == -1 )
  487.                     {
  488.                         DISCONNECT_TYPE = 2;
  489.                         ChatGame::AddChatBoxTextEx( CHATCOLOR_Error, "Connection lost with %s", "Game Server" );
  490.                     }
  491.                 }
  492.             }
  493.         }
  494.  
  495.         CALL( 0x0061ECF0 );
  496.         CALL( 0x00408DF0 );
  497.     }
  498. }
  499. void SocketGame::Shutdown()
  500. {
  501.     bActive = FALSE;
  502. }
  503. void SocketGame::PingConnections()
  504. {
  505.     extern DWORD                dwLastTickLogin;
  506.     extern DWORD                dwLastTickGame;
  507.  
  508.     static int iCounter = 0;
  509.  
  510.     iCounter++;
  511.  
  512.     static DWORD dwTick = 0;
  513.  
  514.     for (int i = 0; i < iMaxConnections; i++)
  515.     {
  516.         SocketData * sd = pcaSocketData + i;
  517.  
  518.         if ((sd->bInUse) && (sd->bConnected))
  519.         {
  520.             if ((sd->bPing == false))
  521.             {
  522.                 if ((TICKCOUNT - dwTick) >= 1000) // changed chaos 150  default
  523.                 {
  524.                     if (SOCKETG)
  525.                     {
  526.                         PacketPing s;
  527.                         s.iLength = sizeof(PacketPing);
  528.                         s.iHeader = PKTHDR_Ping;
  529.                         dwLastTickGame = TICKCOUNT;
  530.                         SENDPACKETG(&s);
  531.                     }
  532.  
  533.                     if (SOCKETL)
  534.                     {
  535.                         PacketPing s;
  536.                         s.iLength = sizeof(PacketPing);
  537.                         s.iHeader = PKTHDR_Ping;
  538.                         dwLastTickLogin = TICKCOUNT;
  539.                         SENDPACKETL(&s);
  540.                     }
  541.                     else
  542.                     {
  543.                         //Reset Pinging if taking longer than 60 seconds
  544.                         if (sd->GetPing(TICKCOUNT) > 60000)
  545.                             sd->bPing = false;
  546.                     }
  547.  
  548.                     dwTick = TICKCOUNT;
  549.                 }
  550.             }
  551.         }
  552.     }
  553.     if (iCounter >= 100)
  554.         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.
  555. }
  556.  
  557. void SocketGame::SendPacket( UINT Socket, UINT packet, int size )
  558. {
  559.     send( *( UINT* )( Socket + 8 ), ( const char * )packet, size, 0 );
  560.     ANTICHEATHANDLER->CheckThread();
  561. }
  562.  
  563. void SocketGame::RecvPacket( UINT Socket )
  564. {
  565.     int SRecv = 0;
  566.     while ( true )
  567.     {
  568.         SRecv = recv( *( int* )( Socket + 4 ), ( char* )( Socket + 0x2C ), 0x2000, 0 );
  569.         if ( SRecv != SOCKET_ERROR )
  570.         {
  571.             *( int* )( Socket + 8 ) = *( int* )( Socket + 0x2C );
  572.             *( int* )( Socket + 12 ) = *( int* )( Socket + 0x2C + 4 );
  573.             RecvPacketRouter( Socket );
  574.         }
  575.     }
  576. }
  577. SocketGame::~SocketGame()
  578. {
  579.     for ( int i = 0; i < iMaxConnections; i++ )
  580.     {
  581.         SocketData * sd = pcaSocketData + i;
  582.         TerminateThread( sd->hReceiveThread, 0 );
  583.         TerminateThread( sd->hSendThread, 0 );
  584.     }
  585.     DELETA( pcaSocketData );
  586. }
  587. void __cdecl SendPacketHook( UINT Socket, UINT packet, int size )
  588. {
  589.     std::shared_ptr<SocketGame> pSocket = std::make_shared<SocketGame>( );
  590.     pSocket->SendPacket( Socket, packet, size );
  591. }
  592.  
  593. void __cdecl RecvDataHook( UINT Socket )
  594. {
  595.     std::shared_ptr<SocketGame> pSocket = std::make_shared<SocketGame>( );
  596.     pSocket->RecvPacket( Socket );
  597. }
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!