Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Apr 1st, 2011  |  syntax: C  |  size: 4.83 KB  |  views: 211  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. /* gcc -g -Wall -o client.exe client2.c */
  2.  
  3. #include <stdio.h>
  4. #include <string.h>
  5.  
  6. #include <windows.h>
  7.  
  8. void print_last_error(const char *fct)
  9. {
  10.   char *buf;
  11.   DWORD dw = GetLastError();
  12.  
  13.   FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
  14.                 FORMAT_MESSAGE_FROM_SYSTEM |
  15.                 FORMAT_MESSAGE_IGNORE_INSERTS,
  16.                 NULL,
  17.                 dw,
  18.                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  19.                 (LPTSTR) &buf,
  20.                 0, NULL );
  21.  
  22.     // Display the error message and exit the process
  23.  
  24.   printf("%s failed with error %ld: %s\n", fct, dw, buf);
  25.   LocalFree(buf);
  26. }
  27.  
  28.  
  29. typedef struct
  30. {
  31.   HANDLE pipe;
  32.   OVERLAPPED ol;
  33.  
  34.   /* in normal struct */
  35.   void *data;
  36.   int size;
  37. } Server;
  38.  
  39. Server *
  40. server_new(const char *name)
  41. {
  42.   char buf[256];
  43.   Server *svr;
  44.  
  45.   if (!name)
  46.     return NULL;
  47.  
  48.   printf("connecting to server...");
  49.  
  50.   snprintf(buf, sizeof(buf), "\\\\.\\pipe\\%s", name);
  51.  
  52.   svr = (Server *)calloc(1, sizeof(Server));
  53.   if (!svr)
  54.     return NULL;
  55.  
  56.   while (1)
  57.     {
  58.       svr->pipe = CreateFile(buf,
  59.                              GENERIC_READ | GENERIC_WRITE,
  60.                              FILE_SHARE_READ | FILE_SHARE_WRITE,
  61.                              NULL,
  62.                              OPEN_EXISTING,
  63.                              0,
  64.                              NULL);
  65.       if (svr->pipe != INVALID_HANDLE_VALUE)
  66.         break;
  67.  
  68.       /* if pipe not busy, we exit */
  69.       if (GetLastError() != ERROR_PIPE_BUSY)
  70.         {
  71.           print_last_error("CreateFile");
  72.           goto free_svr;
  73.         }
  74.  
  75.       /* pipe busy, so we wait for it */
  76.       if (!WaitNamedPipe(buf, NMPWAIT_WAIT_FOREVER))
  77.         {
  78.           print_last_error("WaitNamedPipe");
  79.           goto close_pipe;
  80.         }
  81.     }
  82.  
  83.   printf(" done\n");
  84.  
  85.   return svr;
  86.  
  87.  close_pipe:
  88.   CloseHandle(svr->pipe);
  89.  free_svr:
  90.   free(svr);
  91.  
  92.   printf(" failed\n");
  93.   return NULL;
  94. }
  95.  
  96. void
  97. server_del(Server *svr)
  98. {
  99.   if (!svr)
  100.     return;
  101.  
  102.   CloseHandle(svr->pipe);
  103.   free(svr);
  104. }
  105.  
  106. void
  107. server_data_send(Server *svr, const void *data, int size)
  108. {
  109.   DWORD to_write;
  110.   DWORD written;
  111.  
  112.   if (!svr || !data || (size <= 0))
  113.     return;
  114.  
  115.   while (size > 0)
  116.     {
  117.       if (size <= 65535)
  118.         {
  119.           to_write = size;
  120.           size = 0;
  121.         }
  122.       else
  123.         {
  124.           to_write = 65535;
  125.           size -= 65535;
  126.         }
  127.  
  128.       if (!WriteFile(svr->pipe, data, to_write, &written, NULL))
  129.         {
  130.           print_last_error("WriteFile");
  131.           break;
  132.         }
  133.  
  134.       data += to_write;
  135.  
  136.       /* should never happen */
  137.       if (written < to_write)
  138.         {
  139.           printf("WriteFile: insufficient buffer space\n");
  140.         }
  141.     }
  142. }
  143.  
  144. void
  145. server_data_get(Server *svr)
  146. {
  147. #define BUFSIZE 5
  148.   char buf[BUFSIZE];
  149.   void *data = NULL;
  150.   DWORD nbr_bytes_read;
  151.   int size = 0;
  152.   BOOL res;
  153.  
  154.   if (!svr)
  155.     return;
  156.  
  157.   do
  158.     {
  159.       res = ReadFile(svr->pipe, buf, sizeof(buf), &nbr_bytes_read, NULL);
  160.       if (!res)
  161.         {
  162.           if (GetLastError() == ERROR_MORE_DATA)
  163.             {
  164.               printf("more data\n");
  165.               continue;
  166.             }
  167.           else
  168.             {
  169.               print_last_error("ReadFile");
  170.               /* we keep current read data ? (i.e. no free(data) ? ) */
  171.               break;
  172.             }
  173.         }
  174.       if (res) printf("nbr : %ld\n", nbr_bytes_read);
  175.       if (res && (nbr_bytes_read > 0))
  176.         {
  177.           if (!data)
  178.             {
  179.               data = malloc(nbr_bytes_read);
  180.               if (!data)
  181.                 break;
  182.               memcpy(data, buf, nbr_bytes_read);
  183.               size = nbr_bytes_read;
  184.             }
  185.           else
  186.             {
  187.               data = realloc(data, size + nbr_bytes_read);
  188.               if (!data)
  189.                 {
  190.                   size = 0;
  191.                   break;
  192.                 }
  193.               memcpy(data + size, buf, nbr_bytes_read);
  194.               size += nbr_bytes_read;
  195.             }
  196.         }
  197.     }
  198.   while (!res);
  199.  
  200.   svr->data = data;
  201.   svr->size = size;
  202. }
  203.  
  204. int main(void)
  205. {
  206.   Server *svr;
  207.  
  208.   svr = server_new("toto");
  209.   if (!svr)
  210.     return -1;
  211.  
  212.   server_data_send(svr, "salut, c'est le client !", strlen("salut, c'est le client !"));
  213.  
  214.   while (1)
  215.     {
  216.       server_data_get(svr);
  217.       if (svr->data)
  218.         {
  219.           char *buf;
  220.           buf = malloc(svr->size + 1);
  221.           memcpy(buf, svr->data, svr->size);
  222.           buf[svr->size] = '\0';
  223.           printf("client (%d) : %s\n", svr->size, buf);
  224.           free(svr->data);
  225.           svr->data = NULL;
  226.           Sleep(3000);
  227.           server_data_send(svr, "encore des donnees", strlen("encore des donnees"));
  228.           Sleep(2000);
  229.           break;
  230.         }
  231.     }
  232.  
  233.   server_del(svr);
  234.  
  235.   return 0;
  236. }