API tools faq
paste
Guest User

Server.cpp

a guest
Dec 22nd, 2025
40
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.08 KB | None | 0 0
raw download clone embed print report
  1. #define DEBUG_EXCSERV 1
  2. #define BUFFLEN 1024
  3.  
  4. #define ADAPTER_NAME "ExCServTUNAdapter"
  5. #define ADAPTER_NAMEW L"ExCServTUNAdapter"
  6.  
  7. #ifndef WIN32_LEAN_AND_MEAN
  8. #define WIN32_LEAN_AND_MEAN
  9. #endif
  10. #include <windows.h>
  11. #include <winsock2.h>
  12. #include <ws2tcpip.h>
  13. #include <iphlpapi.h>
  14. #include <iostream>
  15. #include <map>
  16. #include <string>
  17. #include <thread>
  18. #include <vector>
  19. #include "md5.h"
  20. #include "wintun.h"
  21.  
  22. static WINTUN_CREATE_ADAPTER_FUNC* WintunCreateAdapter;
  23. static WINTUN_CLOSE_ADAPTER_FUNC* WintunCloseAdapter;
  24. static WINTUN_OPEN_ADAPTER_FUNC* WintunOpenAdapter;
  25. static WINTUN_GET_ADAPTER_LUID_FUNC* WintunGetAdapterLUID;
  26. static WINTUN_GET_RUNNING_DRIVER_VERSION_FUNC* WintunGetRunningDriverVersion;
  27. static WINTUN_DELETE_DRIVER_FUNC* WintunDeleteDriver;
  28. static WINTUN_SET_LOGGER_FUNC* WintunSetLogger;
  29. static WINTUN_START_SESSION_FUNC* WintunStartSession;
  30. static WINTUN_END_SESSION_FUNC* WintunEndSession;
  31. static WINTUN_GET_READ_WAIT_EVENT_FUNC* WintunGetReadWaitEvent;
  32. static WINTUN_RECEIVE_PACKET_FUNC* WintunReceivePacket;
  33. static WINTUN_RELEASE_RECEIVE_PACKET_FUNC* WintunReleaseReceivePacket;
  34. static WINTUN_ALLOCATE_SEND_PACKET_FUNC* WintunAllocateSendPacket;
  35. static WINTUN_SEND_PACKET_FUNC* WintunSendPacket;
  36.  
  37. #pragma comment(lib, "Ws2_32.lib")
  38. #pragma comment(lib, "iphlpapi.lib")
  39. #pragma warning(disable : 4996)
  40.  
  41. using std::cout, std::map, std::string, std::to_string, std::vector;
  42.  
  43. HMODULE
  44. InitializeWintun(void)
  45. {
  46.     HMODULE Wintun =
  47.         LoadLibraryExW(L"wintun.dll", NULL, LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32);
  48.     if (!Wintun)
  49.         return NULL;
  50. #define X(Name) ((*(FARPROC *)&Name = GetProcAddress(Wintun, #Name)) == NULL)
  51.     if (X(WintunCreateAdapter) || X(WintunCloseAdapter) || X(WintunOpenAdapter) || X(WintunGetAdapterLUID) ||
  52.         X(WintunGetRunningDriverVersion) || X(WintunDeleteDriver) || X(WintunSetLogger) || X(WintunStartSession) ||
  53.         X(WintunEndSession) || X(WintunGetReadWaitEvent) || X(WintunReceivePacket) || X(WintunReleaseReceivePacket) ||
  54.         X(WintunAllocateSendPacket) || X(WintunSendPacket))
  55. #undef X
  56.     {
  57.         DWORD LastError = GetLastError();
  58.         FreeLibrary(Wintun);
  59.         SetLastError(LastError);
  60.         return NULL;
  61.     }
  62.     return Wintun;
  63. }
  64. HMODULE Wintun;
  65. WINTUN_ADAPTER_HANDLE adapter;
  66. WINTUN_SESSION_HANDLE session;
  67. SOCKET sock;
  68. string curr_seckey;
  69.  
  70. inline bool cstrcmp(char* s1, char* s2, size_t len) {
  71.     for (size_t i = 0; i < len; i++) if (s1[i] != s2[i]) return false;
  72.     return true;
  73. }
  74.  
  75. template<typename S>
  76. inline void addstr(S dest, S src, size_t len, size_t offset = 0) {
  77.     if (!dest || !src || len == 0) return;
  78.     for (size_t i = 0; i < len; i++) {
  79.         dest[i + offset] = src[i];
  80.     }
  81. }
  82.  
  83. template<typename I>
  84. I strtoint(char* data, size_t len, bool u = false) {
  85.     using uI = typename std::make_unsigned<I>::type;
  86.     uI output = 0;
  87.     bool fbit = data[len - 1] == 1;
  88.     for (size_t i = 0; i < len - (u ? 0 : 1); i++) {
  89.         output |= ((uI)(BYTE)(data[i])) << (i * 8);
  90.     }
  91.     if (!u && fbit) return 0-((I)output);
  92.     return (I)output;
  93. }
  94.  
  95. template<typename I>
  96. char* inttostr(I data, size_t len, bool u = false) {
  97.     using uI = typename std::make_unsigned<I>::type;
  98.     uI d = (data < 0) ? 0 - ((uI)data) : data;
  99.     bool fbit = data < 0;
  100.     BYTE* str = new BYTE[len];
  101.     for (size_t c = 0; c < len - (u ? 0 : 1); c++) {
  102.         str[c] = (BYTE)(d % 256);
  103.         d = (d - str[c]) / 256;
  104.     }
  105.     if (!u) str[len - 1] = fbit;
  106.     return (char*)str;
  107. }
  108.  
  109. int recv_all(SOCKET sock, char** buff, size_t len) {
  110.     size_t c = len;
  111.     char* buf = new char[BUFFLEN];
  112.     *buff = new char[len];
  113.     while (c > 0) {
  114.         int res = recv(sock, buf, min(BUFFLEN, c), 0);
  115.         if (res == SOCKET_ERROR) return WSAGetLastError();
  116.         if (res == 0) return -1;
  117.         addstr(*buff, buf, res, len - c);
  118.         c -= res;
  119.     }
  120.     delete[] buf;
  121.     return 0;
  122. }
  123.  
  124. int recv_wrapper(SOCKET sock, char** buff, size_t* len) {
  125.     char* buf;
  126.     int res = recv_all(sock, &buf, 8);
  127.     if (res != 0) return res;
  128.     size_t c = strtoint<size_t>(buf, 8, true);
  129.     res = recv_all(sock, &buf, c);
  130.     if (res != 0) return res;
  131.     *buff = buf;
  132.     *len = c;
  133.     return 0;
  134. }
  135.  
  136. int send_wrapper(SOCKET sock, char* buff, size_t len) {
  137.     char* packetlen = inttostr(len, 8, true);
  138.     char* buf = new char[len + 8];
  139.     addstr(buf, packetlen, 8);
  140.     addstr(buf, buff, len, 8);
  141.     size_t sent = 0;
  142.     while (sent < len + 8) {
  143.         int n = send(sock, buf + sent, len + 8 - sent, 0);
  144.         if (n == SOCKET_ERROR) return WSAGetLastError();
  145.         sent += n;
  146.     }
  147.     delete[] packetlen;
  148.     delete[] buf;
  149.     return 0;
  150. }
  151.  
  152. typedef struct IPPort {
  153.     char* ip;
  154.     USHORT port;
  155.     uint32_t rip;
  156.     SOCKET sock;
  157.     bool operator==(const IPPort& o) const {
  158.         return ip == o.ip && port == o.port && rip == o.rip && sock == o.sock;
  159.     }
  160. } *PIPP, IPP;
  161.  
  162. class IPMap {
  163. public:
  164.     vector<PIPP> clients;
  165.     void add(PIPP o) {
  166.         clients.push_back(o);
  167.     }
  168.     PIPP find(uint32_t o, size_t* pos = NULL) {
  169.         size_t i = 0;
  170.         for (auto& p : clients) {
  171.             if (p->rip == o) {
  172.                 if (pos != NULL) *pos = i;
  173.                 return p;
  174.             }
  175.             i++;
  176.         }
  177.         return NULL;
  178.     }
  179.     PIPP find(char* o, size_t* pos = NULL) {
  180.         size_t i = 0;
  181.         for (auto& p : clients) {
  182.             if (p->ip == o) {
  183.                 if (pos != NULL) *pos = i;
  184.                 return p;
  185.             }
  186.             i++;
  187.         }
  188.         return NULL;
  189.     }
  190.     PIPP find(USHORT o, size_t* pos = NULL) {
  191.         size_t i = 0;
  192.         for (auto& p : clients) {
  193.             if (p->rip == o) {
  194.                 if (pos != NULL) *pos = i;
  195.                 return p;
  196.             }
  197.             i++;
  198.         }
  199.         return NULL;
  200.     }
  201.     PIPP find(SOCKET o, size_t* pos = NULL) {
  202.         size_t i = 0;
  203.         for (auto& p : clients) {
  204.             if (p->sock == o) {
  205.                 if (pos != NULL) *pos = i;
  206.                 return p;
  207.             }
  208.             i++;
  209.         }
  210.         return NULL;
  211.     }
  212.     size_t find(IPP o) {
  213.         size_t i = 0;
  214.         for (auto& p : clients) {
  215.             if (*p == o) return i;
  216.             i++;
  217.         }
  218.         return -1;
  219.     }
  220.     size_t find(PIPP o) {
  221.         size_t i = 0;
  222.         for (auto& p : clients) {
  223.             if (*p == *o) return i;
  224.             i++;
  225.         }
  226.         return -1;
  227.     }
  228.     bool remove(uint32_t o) {
  229.         size_t pos;
  230.         if (find(o, &pos) == NULL) return false;
  231.         clients.erase(clients.begin() + pos);
  232.         return true;
  233.     }
  234.     bool remove(char* o) {
  235.         size_t pos;
  236.         if (find(o, &pos) == NULL) return false;
  237.         clients.erase(clients.begin() + pos);
  238.         return true;
  239.     }
  240.     bool remove(USHORT o) {
  241.         size_t pos;
  242.         if (find(o, &pos) == NULL) return false;
  243.         clients.erase(clients.begin() + pos);
  244.         return true;
  245.     }
  246.     bool remove(SOCKET o) {
  247.         size_t pos;
  248.         if (find(o, &pos) == NULL) return false;
  249.         clients.erase(clients.begin() + pos);
  250.         return true;
  251.     }
  252.     bool remove(IPP o) {
  253.         size_t pos;
  254.         if ((pos = find(o)) == -1) return false;
  255.         clients.erase(clients.begin() + pos);
  256.         return true;
  257.     }
  258.     bool remove(PIPP o) {
  259.         size_t pos;
  260.         if ((pos = find(o)) == -1) return false;
  261.         clients.erase(clients.begin() + pos);
  262.         return true;
  263.     }
  264. };
  265. IPMap clients;
  266.  
  267. bool w = true, s = true;
  268.  
  269. inline bool waitForThreads() {
  270.     if (w) return false;
  271.     while (!clients.clients.empty() && !s) Sleep(50);
  272.     return true;
  273. }
  274.  
  275. size_t encrypt(BYTE* i, BYTE** o, size_t len) {
  276.     *o = i;
  277.     return len;
  278. }
  279.  
  280. size_t decrypt(BYTE* i, BYTE** o, size_t len) {
  281.     *o = i;
  282.     return len;
  283. }
  284.  
  285. void recv_thread(PIPP client) {
  286.     while (w) {
  287.         char* buff;
  288.         size_t len;
  289.         int res = recv_wrapper(client->sock, &buff, &len);
  290.         if(res == -1) {
  291.             cout << "F: Recv thread error (" << client->ip << ":" << client->port << "): connection closed\n";
  292.             break;
  293.         }
  294.         if (res > 0) {
  295.             cout << "F: Recv thread error (" << client->ip << ":" << client->port << "): " << res << "\n";
  296.             break;
  297.         }
  298.         if (len > 0) {
  299.             BYTE* p = WintunAllocateSendPacket(session, (DWORD)len);
  300.             if (p) {
  301.                 BYTE* data = (BYTE*)buff;
  302.                 len = decrypt(data, &data, len);
  303.                 addstr(p, data, len);
  304.                 delete[] data;
  305.                 WintunSendPacket(session, p);
  306.                 cout << "I: Recv " << len << "bytes\n";
  307.             }
  308.         }
  309.     }
  310.     closesocket(client->sock);
  311.     clients.remove(client);
  312. }
  313.  
  314. void send_thread() {
  315.     HANDLE ev = WintunGetReadWaitEvent(session);
  316.     while (w) {
  317.         DWORD psize;
  318.         BYTE* p = WintunReceivePacket(session, &psize);
  319.         if (p) {
  320.             // IP находится по смещению 16 в IPv4 пакете
  321.             if (psize >= 20) {
  322.                 uint32_t ip = *(uint32_t*)(p + 16);
  323.                 PIPP client;
  324.                 if ((client = clients.find(ip)) != NULL) {
  325.                     BYTE* data1 = new BYTE[psize];
  326.                     addstr(data1, p, psize);
  327.                     psize = encrypt(data1, &data1, psize);
  328.                     int res = send_wrapper(client->sock, (char*)data1, psize);
  329.                     delete[] data1;
  330.                     WintunReleaseReceivePacket(session, p);
  331.                     if (res == -1) {
  332.                         cout << "F: Send thread error: connection closed\n";
  333.                         break;
  334.                     }
  335.                     if (res > 0) {
  336.                         cout << "F: Send thread error: " << res << "\n";
  337.                         break;
  338.                     }
  339.                     cout << "I: Send " << psize << "bytes\n";
  340.                 }
  341. #if DEBUG_EXCSERV == 1
  342.                 else {
  343.                     in_addr d;
  344.                     d.S_un.S_addr = ip;
  345.                     cout << "W: No route to " << inet_ntoa(d) << "\n";
  346.                 }
  347. #endif
  348.             }
  349.             WintunReleaseReceivePacket(session, p);
  350.         }
  351.         else {
  352.             WaitForSingleObject(ev, INFINITE);
  353.         }
  354.     }
  355.     w = false;
  356.     s = false;
  357. }
  358.  
  359. static BOOL WINAPI
  360. CtrlHandler(_In_ DWORD CtrlType)
  361. {
  362.     switch (CtrlType)
  363.     {
  364.     case CTRL_C_EVENT:
  365.     case CTRL_BREAK_EVENT:
  366.     case CTRL_CLOSE_EVENT:
  367.     case CTRL_LOGOFF_EVENT:
  368.     case CTRL_SHUTDOWN_EVENT:
  369.         w = false;
  370.         cout << "I: Stopping...\n";
  371.         waitForThreads();
  372.         return TRUE;
  373.     }
  374.     return FALSE;
  375. }
  376.  
  377. const string secalphabet = "1234567890-qwertyuiopasdfghjklzxcvbnm_QWERTYUIOPASDFGHJKLZXCVBNM";
  378. const size_t salen = secalphabet.size();
  379. #define SECURE_KEY_LEN 32
  380.  
  381. inline void freep(USHORT stage = 5) {
  382.     if (stage > 4) {
  383.         WintunEndSession(session);
  384.     }
  385.     if (stage > 3) {
  386.         closesocket(sock);
  387.     }
  388.     if (stage > 2) {
  389.         WSACleanup();
  390.     }
  391.     if (stage > 1) {
  392.         WintunCloseAdapter(adapter);
  393.     }
  394.     if (stage > 0) {
  395.         FreeLibrary(Wintun);
  396.     }
  397.     SetConsoleCtrlHandler(CtrlHandler, FALSE);
  398. }
  399.  
  400. int main(int argc, char* argv[])
  401. {
  402.     int res;
  403.     SetConsoleCtrlHandler(CtrlHandler, TRUE);
  404.     map<string, string> args;
  405.     for (unsigned i = 1; i < argc; i++) {
  406.         string x = argv[i];
  407.         size_t pos = x.find_first_of("=");
  408.         if (pos == string::npos) {
  409.             args.insert(std::pair(x, ""));
  410.         }
  411.         args.insert(std::pair(x.substr(0, pos), x.substr(pos + 1, x.size() - pos - 1)));
  412.     }
  413. #if DEBUG_EXCSERV == 1
  414.     args.insert(std::pair("--seckey", "OlwCTg9KQa5Fbu1PzeVYh0LWs6Gni2Ax"));
  415. #endif
  416.     cout << "ExC Server\nArgs:\n";
  417.     if (args.empty())
  418.         cout << " - No args\n";
  419.     else for (auto& p : args) {
  420.         cout << " - \"" << p.first << "\"=\"" << p.second << "\"\n";
  421.     }
  422.     if (!args.contains("--seckey")) {
  423.         cout << "F: no secure key. Copy new secure key and add it in config\nKey: ";
  424.         time_t stmp = time(NULL);
  425.         string data = "";
  426.         size_t i = 0;
  427.         time_t tmp = 0;
  428.         while (data.size() < SECURE_KEY_LEN) {
  429.             tmp = stmp * i + i - 1;
  430.             while (tmp > 0) {
  431.                 if (data.size() > SECURE_KEY_LEN) break;
  432.                 data += secalphabet[tmp % salen];
  433.                 tmp = (tmp % salen) / salen;
  434.             }
  435.             i++;
  436.         }
  437.         cout << data << "\n";
  438.         freep(0);
  439.         return 1;
  440.     }
  441.     cout << "I: On first launch, run this command in PowerShell:\nSet-NetIPInterface -Forwarding Enabled\nIf packets stop being sent, please re-run the command, replacing \"Enabled\" with \"Disabled\"\n";
  442.     curr_seckey = MD5::hash(args["--seckey"]);
  443.     if ((Wintun = InitializeWintun()) == NULL) {
  444.         cout << "F: wintun can't be loaded. Check wintun.dll or it is corrupted: " << GetLastError() << "\n";
  445.         freep(0);
  446.         return 1;
  447.     }
  448.     int port = 80;
  449.     if (!args.contains("--port")) {
  450.         cout << "W: no port, using 80\n";
  451.     }
  452.     else {
  453.         try {
  454.             port = std::stoi(args["--port"]);
  455.             if (port < 1 && port > 1024 * 64) {
  456.                 cout << "W: invalid port (clamp), using 80\n";
  457.                 port = 80;
  458.             }
  459.         }
  460.         catch (...) {
  461.             cout << "W: invalid port (stoi), using 80\n";
  462.             port = 80;
  463.         }
  464.     }
  465.     GUID AdapterGuid = { 0xDEADDEAD, 0xFF12, 0xFF7F, { 0xA1, 0xB2, 0xC3, 0xD4, 0xF5, 0x6A, 0x7B, 0x8C } };
  466.     adapter = WintunCreateAdapter(ADAPTER_NAMEW, L"TUN", &AdapterGuid);
  467.     if (!adapter)
  468.     {
  469.         res = GetLastError();
  470.         if (res != ERROR_ALREADY_EXISTS) {
  471.             cout << "F: failed to create TUN adapter: " << res << "\n";
  472.             freep(1);
  473.             return 1;
  474.         }
  475.         adapter = WintunOpenAdapter(ADAPTER_NAMEW);
  476.         if (!adapter) {
  477.             cout << "F: failed to open TUN adapter: " << GetLastError() << "\n";
  478.             freep(1);
  479.             return 1;
  480.         }
  481.     }
  482.     cout << "I: TUN adapter:\nName=" << ADAPTER_NAME << "\nType=TUN\nGUID={" << std::hex << AdapterGuid.Data1 << "-"
  483.         << AdapterGuid.Data2 << "-" << AdapterGuid.Data3 << "-" << (short)AdapterGuid.Data4[0] << (short)AdapterGuid.Data4[1] << "-"
  484.         << (short)AdapterGuid.Data4[2] << (short)AdapterGuid.Data4[3] << (short)AdapterGuid.Data4[4] << (short)AdapterGuid.Data4[5]
  485.         << (short)AdapterGuid.Data4[6] << (short)AdapterGuid.Data4[7] << std::dec << "}\n";
  486.     MIB_UNICASTIPADDRESS_ROW AddressRow;
  487.     InitializeUnicastIpAddressEntry(&AddressRow);
  488.     WintunGetAdapterLUID(adapter, &AddressRow.InterfaceLuid);
  489.     AddressRow.Address.Ipv4.sin_family = AF_INET;
  490.     AddressRow.Address.Ipv4.sin_addr.S_un.S_addr = htonl((192 << 24) | (168 << 16) | (0x12 << 8) | (0x7F << 0));
  491.     AddressRow.OnLinkPrefixLength = 24;
  492.     AddressRow.DadState = IpDadStatePreferred;
  493.     res = CreateUnicastIpAddressEntry(&AddressRow);
  494.     if (res != ERROR_SUCCESS && res != ERROR_OBJECT_ALREADY_EXISTS)
  495.     {
  496.         cout << "F: failed to set IP address: " << res << "\n";
  497.         freep(2);
  498.         return 1;
  499.     }
  500.     cout << "I: local IP address: 192.168.18.127\n";
  501.     WSADATA wsad;
  502.     res = WSAStartup(MAKEWORD(2, 2), &wsad);
  503.     if (res != 0) {
  504.         cout << "F: WSAStartup failed: " << to_string(res) << "\n";
  505.         freep(2);
  506.         return 1;
  507.     }
  508.     addrinfo* result = NULL, hints;
  509.     ZeroMemory(&hints, sizeof(hints));
  510.     hints.ai_family = AF_INET;
  511.     hints.ai_socktype = SOCK_STREAM;
  512.     hints.ai_protocol = IPPROTO_TCP;
  513.     hints.ai_flags = AI_PASSIVE;
  514.     res = getaddrinfo(NULL, to_string(port).c_str(), &hints, &result);
  515.     if (res != 0) {
  516.         cout << "F: Getaddrinfo failed: " << to_string(res) << "\n";
  517.         freep(3);
  518.         return 1;
  519.     }
  520.     sock = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
  521.     if (sock == INVALID_SOCKET) {
  522.         cout << "F: error at socket(): " << to_string(WSAGetLastError()) << "\n";
  523.         freeaddrinfo(result);
  524.         freep(3);
  525.         return 1;
  526.     }
  527.     if (bind(sock, result->ai_addr, (int)result->ai_addrlen) == SOCKET_ERROR) {
  528.         cout << "F: bind failed with error: " << to_string(WSAGetLastError()) << "\n";
  529.         freeaddrinfo(result);
  530.         freep(4);
  531.         return 1;
  532.     }
  533.     cout << "I: bind on 127.0.0.1:" << to_string(port) << "\n";
  534.     freeaddrinfo(result);
  535.     session = WintunStartSession(adapter, 0x400000);
  536.     if (!session)
  537.     {
  538.         cout << "F: failed to start adapter session";
  539.         freep(4);
  540.         return 1;
  541.     }
  542.     std::thread sth{ send_thread };
  543.     sth.detach();
  544.     while (w) {
  545.         if (listen(sock, SOMAXCONN) == SOCKET_ERROR) {
  546.             cout << "F: listen failed with error: " << to_string(WSAGetLastError()) << "\n";
  547.             w = false;
  548.             waitForThreads();
  549.             freep();
  550.             return 1;
  551.         }
  552.         sockaddr_in saddr;
  553.         socklen_t csaddr = sizeof(saddr);
  554.         SOCKET csock = accept(sock, (sockaddr*)&saddr, &csaddr);
  555.         if (csock == INVALID_SOCKET) {
  556.             cout << "E: accept failed: " << to_string(WSAGetLastError()) << "\n";
  557.             continue;
  558.         }
  559.         char* addr = inet_ntoa(saddr.sin_addr);
  560.         USHORT port = saddr.sin_port;
  561.         PIPP c = new IPP;
  562.         c->ip = _strdup(addr);
  563.         c->port = port;
  564.         c->rip = saddr.sin_addr.S_un.S_addr;
  565.         c->sock = csock;
  566.         cout << "I: New connection thread (" << addr << ":" << to_string(port) << ")\n";
  567.  
  568.         char* buff;
  569.         size_t len;
  570.         int res = recv_wrapper(csock, &buff, &len);
  571.         if (res == -1) {
  572.             cout << "I: Connection closed (" << addr << ":" << to_string(port) << "): secure key\n";
  573.             continue;
  574.         }
  575.         else if (res > 0) {
  576.             cout << "E: Connection error (" << addr << ":" << to_string(port) << "): secure key recv " << res << "\n";
  577.             continue;
  578.         }
  579.         if (len != curr_seckey.size()) {
  580.             cout << "E: Connection error (" << addr << ":" << to_string(port) << "): secure key lenght" << curr_seckey.size() - len << "\n";
  581.             char* skresp = new char;
  582.             skresp[0] = 1;
  583.             send_wrapper(csock, skresp, 1);
  584.             closesocket(csock);
  585.             continue;
  586.         }
  587.         if (!cstrcmp(curr_seckey.data(), buff, len)) {
  588.             cout << "E: Connection error (" << addr << ":" << to_string(port) << "): secure key data\n";
  589.             char* skresp = new char;
  590.             skresp[0] = 2;
  591.             send_wrapper(csock, skresp, 1);
  592.             closesocket(csock);
  593.             continue;
  594.         }
  595.         cout << "I: Secure key is ok (" << addr << ":" << to_string(port) << ")\n";
  596.         char* skresp = new char;
  597.         skresp[0] = 0;
  598.         send_wrapper(csock, skresp, 1);
  599.         clients.add(c);
  600.         std::thread rth{ recv_thread, c };
  601.         rth.detach();
  602.     }
  603.     w = false;
  604.     waitForThreads();
  605.     freep();
  606. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!