API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 20th, 2017
62
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.26 KB | None | 0 0
raw download clone embed print report
  1. #include <fstream>
  2. #include <iostream>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <WinSock2.h>
  7. #include <thread>
  8. #include <ctime>
  9. #include "Packet.h"
  10.  
  11. #define POLY 0x8408
  12. #define MSSG_LEN 20000
  13. #pragma comment(lib,"ws2_32.lib")
  14.  
  15. typedef struct sockaddr_in SADDRIN;
  16. typedef struct sockaddr SADDR;
  17. typedef struct message {
  18.     unsigned short crc;
  19.     short flag;
  20.     int length;
  21.     int numOfFrags;
  22.     int kolkaty;
  23. }MESS;
  24.  
  25. bool LOCK = TRUE;
  26.  
  27. /*
  28. FLAGS:
  29. 1 - SYN
  30. 2 - SYNACK
  31. 3 - ACK
  32. 5 - TXT sprava
  33. 6 - Keep alive signal
  34. 7 - Paket prisiel poskodeny
  35. 10 - FIN
  36. 11 - FINACK
  37. 20 - prve upozornenie o subore, v datach je jeho meno
  38. 21 - data suboru
  39. 22 - koniec suboru
  40. 100 - Umyselne vlozena chyba
  41. */
  42.  
  43. //using namespace std;
  44.  
  45. void client_startup(int port, char* server_ip, int FRAGMAX);
  46. void server_startup(int port);
  47. unsigned short getCRC(char *data_p, unsigned short length);
  48. void vypisPaket(MESS *received, char *start_data);
  49. void clear_field(char *field, int len);
  50. bool check_packet(MESS *packet);
  51. void concurent_alive(SOCKET st, SADDRIN client, int size_mssg);
  52.  
  53. int main() {
  54.  
  55.     char serv_ip[20];
  56.     std::cout << "Dobry den, zvolte cislo pre vybranie strany spojenia:" << std::endl << "\t1: klient - odosiela data" << std::endl << "\t2: server - prijima data" << std::endl;
  57.     int option, fragmax = 10, port = 27500;
  58.     std::cin >> option;
  59.     switch (option) {
  60.     case 1:
  61.         std::cout << "Zadaj ip, na ktoru chces posielat spravy" << std::endl;
  62.         std::cin >> serv_ip;
  63.         std::cin.ignore();
  64.         if (serv_ip[0] == 'l')
  65.             strcpy(serv_ip, "127.0.0.1");
  66.        
  67.         std::cout << "Zadaj maximalnu velkost fragmentu" << std::endl;
  68.         std::cin >> fragmax;
  69.         std::cin.ignore();
  70.         std::cout << "Teraz zadaj cislo portu" << std::endl;
  71.         std::cin >> port;
  72.         std::cin.ignore();
  73.         client_startup(port, serv_ip, fragmax);
  74.         break;
  75.     case 2:
  76.         std::cout << "Teraz zadaj cislo portu" << std::endl;
  77.         std::cin >> port;
  78.         std::cin.ignore();
  79.         server_startup(port);
  80.         break;
  81.     default:
  82.         std::cout << "Zle cislo!" << std::endl;
  83.         break;
  84.     }
  85.     return 0;
  86. }
  87.  
  88. void concurent_alive(SOCKET st, SADDRIN client, int size_mssg) {
  89.     //najskor 100 krat zmeria cas, potom ho spriemeruje a nasledne posiela podla toho keep alive signaly a flagom 6
  90.     int recv_mssg_len, from_mssg_len = sizeof(client);
  91.     char *signal = (char*)malloc(sizeof(MESS) * sizeof(char));
  92.     clear_field(signal, sizeof(MESS));
  93.  
  94.     MESS *head = (MESS*)signal;
  95.     head->flag = 6;
  96.     head->crc = getCRC((char*)head + sizeof(short), sizeof(MESS) + head->length - sizeof(short));
  97.  
  98.     //zmeriam si ako dlho trva pokial pride paket na server(tam sa spracuje) a spat - "round trip time"
  99.     clock_t start = clock();
  100.     if (sendto(st, signal, sizeof(MESS), 0, (SADDR*)&client, size_mssg) == SOCKET_ERROR) {
  101.         std::cout << "Odosielanie zlyhalo, error: " << WSAGetLastError << std::endl;
  102.         exit(EXIT_FAILURE);
  103.     }
  104.     if ((recv_mssg_len = recvfrom(st, signal, sizeof(MESS), 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  105.         std::cout << "Prijem SYNACK zlyhal, error: " << WSAGetLastError << std::endl;
  106.         exit(EXIT_FAILURE);
  107.     }
  108.     clock_t finish = clock();
  109.     int roundTT = 1000 * (double(finish - start) / CLOCKS_PER_SEC);
  110.     //podla zisteneho round trip timu teraz posielam keep alive signaly
  111.     while (LOCK) {
  112.         head->flag = 6;
  113.         head->crc = getCRC((char*)head + sizeof(short), sizeof(MESS) + head->length - sizeof(short));
  114.         if (sendto(st, signal, sizeof(MESS), 0, (SADDR*)&client, size_mssg) == SOCKET_ERROR) {
  115.             std::cout << "Odosielanie zlyhalo, error: " << WSAGetLastError << std::endl;
  116.             exit(EXIT_FAILURE);
  117.         }
  118.         if ((recv_mssg_len = recvfrom(st, signal, sizeof(MESS), 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  119.             std::cout << "Prijem SYNACK zlyhal, error: " << WSAGetLastError << std::endl;
  120.             exit(EXIT_FAILURE);
  121.         }
  122.         std::this_thread::sleep_for(std::chrono::milliseconds(roundTT + 50000));
  123.     }
  124. }
  125.  
  126. unsigned short getCRC(char *data_p, unsigned short length) {
  127.     unsigned char i;
  128.     unsigned int data;
  129.     unsigned int crc = 0xffff;
  130.  
  131.     if (length == 0)
  132.         return (~crc);
  133.  
  134.     do
  135.     {
  136.         for (i = 0, data = (unsigned int)0xff & *data_p++;
  137.             i < 8;
  138.             i++, data >>= 1)
  139.         {
  140.             if ((crc & 0x0001) ^ (data & 0x0001))
  141.                 crc = (crc >> 1) ^ POLY;
  142.             else  crc >>= 1;
  143.         }
  144.     } while (--length);
  145.  
  146.     crc = ~crc;
  147.     data = crc;
  148.     crc = (crc << 8) | (data >> 8 & 0xff);
  149.  
  150.     return (crc);
  151. }
  152.  
  153. void vypisPaket(MESS *received, char *start_data) {
  154.     std::cout << "CRC:" << received->crc << ": " << start_data << std::endl;
  155.     std::cout << "Velkost fragmentu: " << received->length;
  156.     std::cout << " poradie: " << received->kolkaty << "/" << received->numOfFrags << std::endl;
  157.     std::cout << "Flag: " << received->flag << std::endl << "--------------------------------------------" << std::endl;
  158. }
  159.  
  160. void clear_field(char *field, int len) {
  161.     for (int i = 0; i < len; i++) {
  162.         field[i] = 0;
  163.     }
  164. }
  165.  
  166. bool check_packet(MESS *packet) {
  167.     if (packet->crc != getCRC((char*)packet + sizeof(short), sizeof(MESS) + packet->length - sizeof(short))) {
  168.         std::cout << "CRC sa nezhoduje, vyratane:" << getCRC((char*)packet + sizeof(short), sizeof(MESS) + packet->length - sizeof(short)) << std::endl;
  169.         return FALSE;
  170.     }
  171.     else
  172.         std::cout << "CRC ok" << std::endl;
  173.  
  174.     return TRUE;
  175. }
  176.  
  177. void server_startup(int port) {
  178.     int from_mssg_len, recv_mssg_len;
  179.     int FRAGMAX = 0;
  180.     bool connection_established = FALSE;
  181.     WSADATA socketStruct;
  182.     if (WSAStartup(MAKEWORD(2, 2), &socketStruct)) {
  183.         std::cout << "Nepodarilo sa spustit WSADATA, error: " << WSAGetLastError << std::endl;
  184.         exit(EXIT_FAILURE);
  185.     }
  186.  
  187.     //otvorenie socketu, AF_INET - IPv4 adresy, SOCK_DGRAM - UDPcko
  188.     SOCKET sd = socket(AF_INET, SOCK_DGRAM, 0);
  189.     if (sd == INVALID_SOCKET) {
  190.         std::cout << "Socket nemohol byt otvoreny, error: " << WSAGetLastError << std::endl;
  191.         exit(EXIT_FAILURE);
  192.     }
  193.     SADDRIN server, client;
  194.     server.sin_family = AF_INET; //IPv4 adresy
  195.     server.sin_addr.s_addr = INADDR_ANY;
  196.     server.sin_port = htons(port);
  197.     from_mssg_len = sizeof(client);
  198.  
  199.     //bindnutie socketu
  200.     if (bind(sd, (SADDR*)&server, sizeof(server)) == SOCKET_ERROR) {
  201.         std::cout << "Nepodarilo sa nabindovat socket, error: " << WSAGetLastError << std::endl;
  202.         exit(EXIT_FAILURE);
  203.     }
  204.     std::cout << "Spusta sa server.." << std::endl;
  205.     MESS *received, *send;
  206.  
  207.     char *start_data, *mssg = (char*)malloc(sizeof(MESS) * sizeof(char) + MSSG_LEN);
  208.     char *send_flag = (char*)malloc(sizeof(MESS) * sizeof(char));
  209.     clear_field(mssg, sizeof(MESS) * sizeof(char) + MSSG_LEN);
  210.     clear_field(send_flag, sizeof(MESS) * sizeof(char));
  211.     char **entire_message = NULL;
  212.     //4-way handshake vlastna
  213.     if ((recv_mssg_len = recvfrom(sd, mssg, sizeof(MESS) * sizeof(char) + MSSG_LEN, 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  214.         std::cout << "Prijem SYN zlyhal, error: " << WSAGetLastError << std::endl;
  215.         exit(EXIT_FAILURE);
  216.     }
  217.     received = (MESS*)mssg;
  218.     //prijal som SYN
  219.     if (received->flag == 1) {
  220.         //odosielam SYNACK
  221.         send = (MESS*)send_flag;
  222.         send->flag = 2;
  223.         if (sendto(sd, send_flag, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, from_mssg_len) == SOCKET_ERROR) {
  224.             std::cout << "Odosielanie SYNACK zlyhalo, error: " << WSAGetLastError << std::endl;
  225.             exit(EXIT_FAILURE);
  226.         }
  227.         clear_field(mssg, sizeof(MESS) * sizeof(char) + MSSG_LEN);
  228.         //prijimam ACK
  229.         if ((recv_mssg_len = recvfrom(sd, mssg, sizeof(MESS) * sizeof(char) + MSSG_LEN, 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  230.             std::cout << "Prijimanie ACK zlyhalo, error:" << WSAGetLastError << std::endl;
  231.             exit(EXIT_FAILURE);
  232.         }
  233.         received = (MESS*)mssg;
  234.         if (received->flag == 3) {
  235.             //nastavit FRAGMAX
  236.             FRAGMAX = received->length;
  237.             //posielam ACK
  238.             send->flag = 3;
  239.             if (sendto(sd, send_flag, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, from_mssg_len) == SOCKET_ERROR) {
  240.                 std::cout << "Odosielanie ACK zlyhalo, error: " << WSAGetLastError << std::endl;
  241.                 exit(EXIT_FAILURE);
  242.             }
  243.             std::cout << "Prebehla 4-way autorizacia\n";
  244.             connection_established = TRUE;
  245.         }
  246.     }
  247.  
  248.     //pocuvam na sockete
  249.     std::cout << "Pripraveny na prijem dat\n" << std::endl;
  250.     while (connection_established) {
  251.         fflush(stdout);
  252.         memset(mssg, '\0', sizeof(MESS) * sizeof(char) + MSSG_LEN);
  253.  
  254.         if ((recv_mssg_len = recvfrom(sd, mssg, sizeof(MESS) * sizeof(char) + MSSG_LEN, 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  255.             std::cout << "Prijem dat zlyhal, error: " << WSAGetLastError << std::endl;
  256.             exit(EXIT_FAILURE);
  257.         }
  258.         received = (MESS*)mssg;
  259.         start_data = mssg + sizeof(MESS);
  260.  
  261.         if (check_packet(received) == FALSE) {
  262.             //paket prisiel poskodeny, znovu vyziadaj paket
  263.             send = (MESS*)send_flag;
  264.             send->flag = 7;
  265.             std::cout << "Paket prisiel poskodeny, vyzadujem znovuzaslanie\n" << "-------" << std::endl;
  266.             if (sendto(sd, send_flag, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, from_mssg_len) == SOCKET_ERROR) {
  267.                 std::cout << "Odosielanie Znovuvyziadania zlyhalo, error: " << WSAGetLastError << std::endl;
  268.                 exit(EXIT_FAILURE);
  269.             }
  270.             continue;
  271.         }
  272.  
  273.         if (received->flag == 6) {
  274.             //ak ide iba o ping, resp. keep alive signal; odpovedz ACK
  275.             send = (MESS*)send_flag;
  276.             send->flag = 3;
  277.             if (sendto(sd, send_flag, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, from_mssg_len) == SOCKET_ERROR) {
  278.                 std::cout << "Odosielanie Znovuvyziadania zlyhalo, error: " << WSAGetLastError << std::endl;
  279.                 exit(EXIT_FAILURE);
  280.             }
  281.             std::cout << "Dorazil keep alive signal\n" << "--------------------------------------------" << std::endl;
  282.             continue;
  283.         }
  284.  
  285.         if (received->numOfFrags > 1) {
  286.             //ideme spajat fragmenty
  287.  
  288.             //ak idem spravit novy zaznam
  289.             if (entire_message == NULL) {
  290.                 entire_message = (char**)malloc(received->numOfFrags * sizeof(char*));
  291.                 for (int i = 0; i < received->numOfFrags; i++) {
  292.                     entire_message[i] = (char*)malloc(FRAGMAX * sizeof(char));
  293.                 }
  294.             }
  295.  
  296.             //spracovavam spravu
  297.             strcpy(entire_message[received->kolkaty - 1], start_data);
  298.         }
  299.  
  300.         if (received->flag == 5) {
  301.             //potvrd ze paket prisiel v poriadku, ak ide o textovu spravu
  302.             clear_field(send_flag, sizeof(MESS));
  303.             send = (MESS*)send_flag;
  304.             send->flag = 3;
  305.             if (sendto(sd, send_flag, sizeof(MESS), 0, (SADDR*)&client, from_mssg_len) == SOCKET_ERROR) {
  306.                 std::cout << "Odosielanie Znovuvyziadania zlyhalo, error: " << WSAGetLastError << std::endl;
  307.                 exit(EXIT_FAILURE);
  308.             }
  309.         }
  310.  
  311.         if (strstr(start_data, "stop") != NULL) {
  312.             std::cout << "Server je ukonceny" << std::endl;
  313.             //poslat ack na client ze sa moze vypnut
  314.             break;
  315.         }
  316.  
  317.         vypisPaket(received, start_data);
  318.  
  319.         //ak mam uz posledny paket, vypisem cele pole a uvolnim ho
  320.         if (entire_message != NULL && received->kolkaty == received->numOfFrags) {
  321.             std::cout << "Cela sprava: ";
  322.             for (int i = 0; i < received->numOfFrags; i++) {
  323.                 printf("%s", entire_message[i]);
  324.             }
  325.             std::cout << std::endl << std::endl;
  326.             entire_message = NULL;
  327.         }
  328.  
  329.         std::cout << std::endl;
  330.     }
  331.  
  332.     closesocket(sd);
  333.     WSACleanup();
  334. }
  335.  
  336. void client_startup(int port, char* server_ip, int FRAGMAX) {
  337.     WSADATA socketStruct;
  338.     bool connection_established = FALSE;
  339.     char *file_name;
  340.     if (WSAStartup(MAKEWORD(2, 2), &socketStruct) != 0) {
  341.         std::cout << "Neinicializovala sa struktura socketu!";
  342.         exit(EXIT_FAILURE);
  343.     }
  344.  
  345.     SOCKET st = socket(AF_INET, SOCK_DGRAM, 0);
  346.     if (st == INVALID_SOCKET) {
  347.         std::cout << "Socket nemohol byt otvoreny, error: " << WSAGetLastError << std::endl;
  348.         exit(EXIT_FAILURE);
  349.     }
  350.  
  351.     SADDRIN client;
  352.     int recv_mssg_len, from_mssg_len = sizeof(client);
  353.     memset((char *)&client, 0, sizeof(client));
  354.     client.sin_family = AF_INET;
  355.     client.sin_port = htons(port);
  356.     client.sin_addr.S_un.S_addr = inet_addr(server_ip);
  357.  
  358.     int size_mssg = sizeof(client);
  359.     std::cout << "Spustil sa klient" << std::endl;
  360.  
  361.     char vstup[MSSG_LEN];
  362.     char *mssg = (char*)malloc(sizeof(char)), *input;
  363.     int pocet_fragmentov;
  364.  
  365.     //moja 4-way handshake
  366.     mssg = (char*)realloc(mssg, sizeof(MESS) * sizeof(char));
  367.     MESS *syn = (MESS*)mssg;
  368.     syn->flag = 1;
  369.     syn->length = FRAGMAX;
  370.     //posli SYN
  371.     if (sendto(st, mssg, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, size_mssg) == SOCKET_ERROR) {
  372.         std::cout << "Odosielanie SYN zlyhalo, error: " << WSAGetLastError << std::endl;
  373.         exit(EXIT_FAILURE);
  374.     }
  375.     //prijimam SYNACK
  376.     char recv_flag[sizeof(MESS)];
  377.     if ((recv_mssg_len = recvfrom(st, recv_flag, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  378.         std::cout << "Prijem SYNACK zlyhal, error: " << WSAGetLastError << std::endl;
  379.         exit(EXIT_FAILURE);
  380.     }
  381.     syn = (MESS*)recv_flag;
  382.     if (syn->flag == 2) {
  383.         //posli ACK 3
  384.         syn = (MESS*)mssg;
  385.         syn->flag = 3;
  386.         syn->length = FRAGMAX;
  387.         if (sendto(st, mssg, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, size_mssg) == SOCKET_ERROR) {
  388.             std::cout << "Odosielanie ACK pri SYN zlyhalo, error: " << WSAGetLastError << std::endl;
  389.             exit(EXIT_FAILURE);
  390.         }
  391.         memset(recv_flag, '\0', sizeof(MESS));
  392.         if ((recv_mssg_len = recvfrom(st, recv_flag, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  393.             std::cout << "Prijem ACK zlyhal, error: " << WSAGetLastError << std::endl;
  394.             exit(EXIT_FAILURE);
  395.         }
  396.         syn = (MESS*)recv_flag;
  397.         if (syn->flag == 3) {
  398.             //ak som prijal ACK, handshake prebehol uspesne
  399.             std::cout << "Prebehol 4way handshake - uspesne." << std::endl;
  400.             std::cout << "Klient pripraveny na posielanie sprav" << std::endl;
  401.             connection_established = TRUE;
  402.         }
  403.     }
  404.  
  405.     std::cout << "Program vyuziva klucove slova, ktore staci zadat do textu spravy, su to\n\tbad +text- do textu zamerne vnesie chybu a odosle chybny ramec\n\t";
  406.     std::cout << "stop - ukonci komunikaciu na oboch stranach (server aj klient)\n\tfile - prenesie textovy dokument, po zadani bude treba uviest nazov suboru.\n\n";
  407.  
  408.     //spustenie threade na keep alive signaly
  409.     std::thread alive(concurent_alive, st, client, size_mssg);
  410.     alive.detach();
  411.  
  412.     while (connection_established) {
  413.         clear_field(vstup, MSSG_LEN);
  414.         std::cout << "\nZadaj spravu: ";
  415.         std::cin.getline(vstup, MSSG_LEN);
  416.  
  417.         if (strstr(vstup, "file") != NULL) {
  418.             std::cout << "Funkcionalita zatial nie je implementovana\n";
  419.         }
  420.  
  421.         int input_len = strlen(vstup), frag_len = 0;
  422.         pocet_fragmentov = (strlen(vstup) / FRAGMAX) + 1;
  423.  
  424.         for (int i = 0; i < pocet_fragmentov; i++) {
  425.             if (input_len - FRAGMAX >= 0) {
  426.                 input_len -= FRAGMAX;
  427.                 frag_len = FRAGMAX;
  428.             }
  429.             else {
  430.                 frag_len = input_len;
  431.             }
  432.  
  433.             mssg = (char*)realloc(mssg, sizeof(MESS) * sizeof(char) + frag_len);
  434.             memset(mssg, '\0', sizeof(MESS) * sizeof(char) + frag_len);
  435.  
  436.             MESS *send = (MESS*)mssg;
  437.             input = mssg + sizeof(MESS);
  438.  
  439.             strncpy(input, vstup + i*FRAGMAX, frag_len);
  440.  
  441.             send->length = frag_len;
  442.             send->kolkaty = i + 1;
  443.             send->numOfFrags = pocet_fragmentov;
  444.             send->flag = 5;
  445.             send->crc = getCRC((char*)send + sizeof(short), sizeof(MESS) + send->length - sizeof(short));
  446.  
  447.             if (strstr(vstup, "bad") != NULL) {
  448.                 //vnasam chybu
  449.                 send->flag = 100;
  450.             }
  451.  
  452.             std::cout << "#" << i << ". fragment ";
  453.             for (int j = 0; j < frag_len; j++) {
  454.                 printf("%c", input[j]);
  455.             }
  456.             std::cout << std::endl;
  457.  
  458.             if (sendto(st, mssg, sizeof(MESS) * sizeof(char) + frag_len, 0, (SADDR*)&client, size_mssg) == SOCKET_ERROR) {
  459.                 std::cout << "Odosielanie zlyhalo, error: " << WSAGetLastError << std::endl;
  460.                 exit(EXIT_FAILURE);
  461.             }
  462.             memset(recv_flag, '\0', sizeof(MESS));
  463.  
  464.             while (1) {
  465.                 if ((recv_mssg_len = recvfrom(st, recv_flag, sizeof(MESS) * sizeof(char), 0, (SADDR*)&client, &from_mssg_len)) == SOCKET_ERROR) {
  466.                     std::cout << "Prijem ACK zlyhal, error: " << WSAGetLastError << std::endl;
  467.                     exit(EXIT_FAILURE);
  468.                 }
  469.                 syn = (MESS*)recv_flag;
  470.                 if (syn->flag == 3) {
  471.                     break;
  472.                 }
  473.                 else {
  474.                     //paket prisiel poskodeny, posielam ho znovu, opraveny
  475.                     send->flag = 5;
  476.                     send->crc = getCRC((char*)send + sizeof(short), sizeof(MESS) + send->length - sizeof(short));
  477.                     if (sendto(st, mssg, sizeof(MESS) * sizeof(char) + frag_len, 0, (SADDR*)&client, size_mssg) == SOCKET_ERROR) {
  478.                         std::cout << "Odosielanie nahradneho paketu zlyhalo, error: " << WSAGetLastError << std::endl;
  479.                         exit(EXIT_FAILURE);
  480.                     }
  481.                 }
  482.             }
  483.         }
  484.         if (strstr(vstup, "stop") != NULL) {
  485.             std::cout << "Klient je ukonceny" << std::endl;
  486.             LOCK = FALSE;
  487.             //poslat fin flag na server ze sa moze vypnut
  488.             break;
  489.         }
  490.     }
  491.  
  492.     closesocket(st);
  493.     WSACleanup();
  494. }
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!