#include <stdio.h>
#include <winsock2.h>

int CriaNovoSocket( SOCKET *L_SocketEntrada );

// porta em que estaremos escutando

int main (void)
{
   printf( "Servidor teste\n");
   printf( "--------------------------------------------------------------------------------\n");

   struct sockaddr_in L_EnderecoRemoto;

   //-----> Verificação da versão da winsock

   WORD L_Versao;
   WSADATA wsaData;
   
   L_Versao = MAKEWORD( 2, 2);
   
   int L_Erro = WSAStartup( L_Versao, &wsaData);
   if( L_Erro != 0 )
   {
      printf("Não foi possível encontrar a dll winsock!\n");
      return(-1);
   }
   if( LOBYTE( wsaData.wVersion) < 2 || HIBYTE( wsaData.wVersion) < 2)
   {
      printf("A dll winsock é muito antiga!\n");
      return(-1);
   }

   //-----> Criando socket


   SOCKET L_SocketEntrada;
   SOCKET L_SocketSaida;
   CriaNovoSocket( &L_SocketEntrada );

   int L_MaiorSocket = L_SocketEntrada;

   //-----> Inicia laço do monitor de serviços de comunicação

   printf("Monitor de servicos ativo...\n\n");


   struct timeval timeout;

   timeout.tv_sec =  1;
   timeout.tv_usec = 0;


   // Monta set para verificação de conexões inativas

   fd_set L_SetAtivos;
   fd_set L_SetAtivosTemp;
   
   FD_ZERO(&L_SetAtivos);
   FD_SET( L_SocketEntrada, &L_SetAtivos);

   int L_NumeroBytesRecebidos,
       L_NumeroBytesEnviados;
   do
   {
      // Verifica envio, recebimento e estatus da conexão

      FD_ZERO(&L_SetAtivosTemp);
      L_SetAtivosTemp = L_SetAtivos;

      if( select( L_MaiorSocket+1, &L_SetAtivosTemp, NULL, NULL, &timeout ) == -1 )
      {
         printf("Erro da funcao SELECT ! Pressione uma tecla para sair...\n\n");
         getchar();
         return(-1);
      }         
          
      int L_NumeroSockret;
      for( L_NumeroSockret = 0; L_NumeroSockret <= L_MaiorSocket; L_NumeroSockret++)
      {
         if( FD_ISSET( L_NumeroSockret, &L_SetAtivosTemp) != 0 )
         {
            if ( L_NumeroSockret == L_SocketEntrada )
            {
               // trata de nova entradas
            
               int addrlen = sizeof (L_EnderecoRemoto);
               if( ( L_SocketSaida = accept( L_SocketEntrada, (struct sockaddr*)&L_EnderecoRemoto, &addrlen)) == -1)
               {
                  printf("Erro ao aceitar a conexão!\n\n");
               }
               else
               {
                  FD_SET( L_SocketSaida, &L_SetAtivos);
                  if( L_SocketSaida > L_MaiorSocket )
                  {
                     L_MaiorSocket = L_SocketSaida;
                  }

                  printf ("Servidor : nova conexão de %s no socket %d\n",
                          inet_ntoa (L_EnderecoRemoto.sin_addr), L_SocketSaida);
               }
            }
            else
            {
               // trata do envio e recebimento de pacotes
   
               char L_Mensagem[1024];
               memset( L_Mensagem, '\0', 1024);
               L_NumeroBytesRecebidos = recv( L_NumeroSockret, L_Mensagem, 512, 0 );

               if( L_NumeroBytesRecebidos > 0 )
               {
                  printf("Recebeu: [%d]: %s \n", L_NumeroSockret, L_Mensagem);
                  
                  // Mensagem de retorno
                  
                  if( strlen(L_Mensagem) > 0 )
                  {
                     L_NumeroBytesEnviados = send( L_NumeroSockret, "OK", 2, 0 );
                     if( L_NumeroBytesEnviados != 2 )
                     {
                        printf("Erro ao retornar mensagem de verificacao do socket[%d]\n", L_NumeroSockret);
                     }
                  }
                  else
                  {
                     printf("Falha ao receber: [%d]: %s \n", L_NumeroSockret, L_Mensagem);
                  }
               }
               else
               {
                  printf("Fechou a conexão do socket [%d] \n", L_NumeroSockret);
                  closesocket(L_NumeroSockret);
                  FD_CLR( L_NumeroSockret, &L_SetAtivos);
                  break;
               }
            }
         }
      }
      
   } while(TRUE);
    

   return(0);
}

int CriaNovoSocket( SOCKET *L_SocketEntrada )
{
   struct sockaddr_in L_Endereco;

   L_Endereco.sin_family = AF_INET;
   L_Endereco.sin_addr.s_addr = INADDR_ANY;
   L_Endereco.sin_port = htons(27015);
   int i;
   for(i=0;i<8;i++)
   {
      L_Endereco.sin_zero[i] = 0;
   }
   if(( *L_SocketEntrada = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP)) <= 0)
   {
      printf("Erro ao criar o socket!\n");
      return(-1);
   }

   //char yes=1;  // necessário para função setsockopt() SO_REUSEADDR
   //if (setsockopt( *L_SocketEntrada, SOL_SOCKET, SO_REUSEADDR, &yes, 2) == -1)
   //{
   //  printf("Erro: setsockopt");
   //   exit (1);
   //}
      
   //-----> Escutando canal de comunicação

   if( bind( *L_SocketEntrada, (struct sockaddr*)&L_Endereco, sizeof(L_Endereco)) == SOCKET_ERROR)
   {
     printf("Erro de bind!");
   }

   //-----> Listando canal de comunicação

   if( listen( *L_SocketEntrada, 10 ) == SOCKET_ERROR)
   {
      printf("Erro de listen!\n");
   }
    
}

#include <stdio.h>
#include <winsock2.h>

// porta em que estaremos escutando

int main (void)
{
   printf( "Terminal teste\n");
   printf( "--------------------------------------------------------------------------------\n");

   struct sockaddr_in L_Endereco;

   L_Endereco.sin_family = AF_INET;
   L_Endereco.sin_addr.s_addr = inet_addr("192.168.200.60");
   //L_Endereco.sin_addr.s_addr = inet_addr("200.138.216.49");
   L_Endereco.sin_port = htons(27015);

   //-----> Verificação da versão da winsock

   WORD L_Versao;
   WSADATA wsaData;
   
   L_Versao = MAKEWORD( 2, 2);
   
   int L_Erro = WSAStartup( L_Versao, &wsaData);
   if( L_Erro != 0 )
   {
      printf("Não foi possível encontrar a dll winsock!\n");
      return(-1);
   }
   if( LOBYTE( wsaData.wVersion) < 2 || HIBYTE( wsaData.wVersion) < 2)
   {
      printf("A dll winsock é muito antiga!\n");
      return(-1);
   }

   //-----> Criando socket

   SOCKET L_Socket;
   if(( L_Socket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP)) <= 0)
   {
      printf("Erro ao criar o socket!\n");
      return(-1);
   }

   //----->Conectando-se

   printf("Conectando-se ao servidor...\n\n");
   if( connect( L_Socket, (struct sockaddr*)&L_Endereco, sizeof(L_Endereco)) == 0)
   {
      printf("terminal conectado ao servidor com sucesso!\n\n");
   }
   else
   {
      printf("Não foi possível conectar-se ao servidor!\n\n");
      return(-1);
   }

   //-----> Inicia laço do envio e recebimento

   printf("Monitor de envio e recebimento ativo...\n\n");

   //-----> adiciona a socket a lista de verificação

   fd_set L_Envio;
   fd_set L_EnvioTemp; 

   FD_ZERO(&L_Envio);
   FD_SET( L_Socket , &L_Envio);

   int L_ConMen = 0,
       L_QuaPerPac = 0;
       
   int L_NumeroBytesEnviados;
   int L_NumeroBytesRecebidos;

   struct timeval timeout;

   timeout.tv_sec =  10;
   timeout.tv_usec = 0;
   
   char L_Teste[11];
   char L_Mensagem[1024],   // Mensagem de envio
        L_ConRetorno[3];    // Mensagem de confirmação de retorno
   
   do
   {
            
      FD_ZERO(&L_EnvioTemp);
      L_EnvioTemp = L_Envio; 
      if( select( 0, NULL, &L_EnvioTemp, NULL, &timeout) != -1 )
      {
         memset( L_Mensagem, '\0', 1024);
         L_ConMen++;
         itoa( L_ConMen, L_Teste, 10);
         strcpy( L_Mensagem, L_Teste );
         int L_NumeroBytesEnviados = 0;

         do
         {
            
            L_NumeroBytesEnviados = send( L_Socket, L_Mensagem, 8, 0 );
            if( L_NumeroBytesEnviados == 8 )
            {
               printf("Envio %d , %s...", L_NumeroBytesEnviados, L_Teste);
               
               // Espera retorno para confirmação
               
               FD_ZERO(&L_EnvioTemp);
               L_EnvioTemp = L_Envio; 
      
               if( select( 0, &L_EnvioTemp, NULL, NULL, &timeout) != -1 )
               {
                  memset( L_ConRetorno, '\0', 3);
                  L_NumeroBytesRecebidos = recv( L_Socket, L_ConRetorno, 2, 0 );
                  if( L_NumeroBytesRecebidos > 0 && L_ConRetorno[0] == 'O' && L_ConRetorno[1] == 'K' )
                  {
                     printf("%s\n", L_ConRetorno);
                     break;
                  }
               }
               else
               {
                  printf("\nErro de envio %d , %s \n", L_NumeroBytesEnviados, L_Teste);
               }
            }
            else
            {
               L_QuaPerPac++;
               printf(" [%d] Perda de pacote! Pressione uma tecla..." , L_QuaPerPac);
               getchar();
            }
         } while(TRUE);
      }
      
      if( L_ConMen == 100 )
      {
          closesocket(L_Socket);
          break;
      }
                   
   } while(TRUE);

   printf("\n100 mensagens enviadas. Pressione uma tecla para sair...\n");
   getchar();
          
    
   return(0);
}

   char L_Teste[11];
   char L_Mensagem[1024],   // Mensagem de envio
        L_ConRetorno[3];    // Mensagem de confirmação de retorno
   
   do
   { 
      timeout.tv_sec =  1;
      timeout.tv_usec = 0;