Proxy-Forwarding

[keenlanas]

Salve povo do Darkers...

Tava tentando escrever um código de forwarding, uma coisa tipo um proxy.

O esquema era o seguinte:

Receber um pedido de conexão
Encaminhar pro servidor na net
Receber a resposta
Encaminhar pra quem fez o pedido

Esperar outro pedido de conexão.

Porém, comecei com Sockets faz poco tempo, tem umas coisas que eu não sei...

Tipo, no código que eu escrevi, o servidor não manda a página inteira pro cliente. Eh bem simples, o código.
Tá um poco bagunçado, pq foi mais um teste que fiz, pegando vários códigos de exemplos e montando pra ver se funcionava.

Se não tiver como fazer funcionar, queria pelo menos saber porque esses erros acontecem, por favor.

Segue o código, compilo em Borland C++ (Pq estou frustrado com Dev-C++, mas deve funcionar nele tb)

Código Selecionar Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <winsock2.h>
#include <windows.h>

#define BACKLOG_MAX 5
#define BUFFER_SIZE 1024*16

/* Exibe uma mensagem de erro e termina o programa */
void msg_err_exit(char *msg)
{
fprintf(stderr, msg);
system("PAUSE");
exit(EXIT_FAILURE);
}

int main(int argc, char **argv)
{
     //parte de servidor
     
     int local_socket = 0;
     int remote_socket = 0;
     int cont=0;
   
     int remote_length = 0;
     int message_length = 0;
   
     unsigned short local_port = 0;
     unsigned short remote_port = 0;
   
     char message[BUFFER_SIZE];
   
     struct sockaddr_in local_address;
     struct sockaddr_in remote_address;
   
     WSADATA wsa_data;

     // inicia o Winsock 2.0 (DLL), Only for Windows
     if (WSAStartup(MAKEWORD(2, 0), &wsa_data) != 0) msg_err_exit("WSAStartup() failed\n");
                       
     while(1)
     {
     // criando o socket local para o servidor
     local_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   
     if (local_socket == INVALID_SOCKET)
     {
          WSACleanup();
          msg_err_exit("socket() failed\n");
     }
   
     //digite a porta que servirá de serviço proxy
     //printf("Porta local: "); scanf("%d", &local_port);
     //fflush(stdin);
     local_port = 4001;

     // zera a estrutura local_address
     memset(&local_address, 0, sizeof(local_address));
   
     // internet address family
     local_address.sin_family = AF_INET;
   
     // porta local
     local_address.sin_port = htons(local_port);
   
     // endereco
     local_address.sin_addr.s_addr = htonl(INADDR_ANY); // inet_addr("127.0.0.1")
   
     // interligando o socket com o endereço (local)
     if (bind(local_socket, (struct sockaddr *) &local_address, sizeof(local_address)) == SOCKET_ERROR)
     {
          WSACleanup();
          closesocket(local_socket);
          msg_err_exit("bind() failed\n");
     }
   
     // coloca o socket para escutar as conexoes
     if (listen(local_socket, BACKLOG_MAX) == SOCKET_ERROR)
     {
          WSACleanup();
          closesocket(local_socket);
          msg_err_exit("listen() failed\n");
     }
   
     remote_length = sizeof(remote_address);
     printf("aguardando alguma conexao...\n");
     remote_socket = accept(local_socket, (struct sockaddr *) &remote_address, &remote_length);
     
     /*
     unsigned long valor = 1;
     ioctlsocket( remote_socket, FIONBIO, &valor );
     */
     
     if(remote_socket == INVALID_SOCKET)
     {
          WSACleanup();
          closesocket(local_socket);
          msg_err_exit("accept() failed\n");
     }
   
     printf("conexao estabelecida com %s\n", inet_ntoa(remote_address.sin_addr));
     
     // limpa o buffer
     memset(&message, 0, BUFFER_SIZE);
     //message_length=SOCKET_ERROR;
     
     // recebe a mensagem do cliente
     //while (message_length==SOCKET_ERROR)
      message_length = recv(remote_socket, message, BUFFER_SIZE, 0);
     
     
     printf("%s %d: \n\n%s\n\n", inet_ntoa(remote_address.sin_addr), message_length,message);
     
     //parte de cliente
     int socket_do_servidor = 0;
     unsigned short servidor_port = 0;
     struct hostent *host;
     char remote_ip[32];
     
     struct sockaddr_in servidor_remote_address;
   
     WSADATA wsa_data_servidor;
         
     char auxHost[] = "Host: ";
   
     if (WSAStartup(MAKEWORD(2, 0), &wsa_data_servidor) != 0) msg_err_exit("WSAStartup() failed\n");
   
     int aux=0;
     int i=0; 
     
     for(aux=0; aux<message_length; aux++)
     {           
          if(message[aux]==auxHost[i])
          {
           i++;
          }
          else i=0;
          if(i==strlen(auxHost)) break;
     }
     
     i=0;
     aux++;
     do
     {
          remote_ip[i] = message[aux+i];
          i++;
     }
     while(message[aux+i]!='\r');
     
     remote_ip[i]='\0';
     
     if ( (host = gethostbyname( remote_ip )) == NULL)
     {
          perror("gethostbyname");
          return 0;
     }
     
     servidor_port=80;
   
     socket_do_servidor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   
     if (socket_do_servidor == INVALID_SOCKET)
     {
          WSACleanup();
          msg_err_exit("socket() failed\n");
     }
   
     // preenchendo o remote_address (servidor)
     memset(&servidor_remote_address, 0, sizeof(servidor_remote_address));
     servidor_remote_address.sin_family = AF_INET;
     //servidor_remote_address.sin_addr.s_addr = inet_addr(remote_ip);
     memcpy(&(servidor_remote_address.sin_addr),host->h_addr,host->h_length);
     servidor_remote_address.sin_port = htons(servidor_port);
   
     printf("conectando ao servidor %s...\n", remote_ip);
     
     if (connect(socket_do_servidor, (struct sockaddr *) &servidor_remote_address, sizeof(servidor_remote_address)) == SOCKET_ERROR)
     {
          WSACleanup();
          msg_err_exit("connect() failed\n");
     }
     
     //iniciando troca de mensagens pelo proxy
     //o servidor proxy recebe a mensagem do cliente proxy e a repassa para o servidor externo
     
     //do
     {   
          //repassa para o servidor na internet
          printf("\n\nEnviando pro Servidor...\n\n");
          if (send(socket_do_servidor, message, message_length, 0) == SOCKET_ERROR)
          {
              WSACleanup();
              closesocket(socket_do_servidor);
              msg_err_exit("send() failed\n");
          } 
         
         
          // recebe a mensagem do servidor
          do
          {
              // limpa o buffer
              memset(&message, 0, BUFFER_SIZE);
           
              printf("\n\nRecebendo do Servidor...\n\n");
              message_length = recv(socket_do_servidor, message, BUFFER_SIZE, 0);
              //if(message_length == SOCKET_ERROR) msg_err_exit("recv() failed\n");                                   
             
              if(message_length!=SOCKET_ERROR)
              {
                  // exibe a mensagem na tela
                  printf("%s %d: \n\n%s \n\n", inet_ntoa(servidor_remote_address.sin_addr), message_length, message);

                  //repassa para o cliente na rede
                  printf("\n\nEnviando pro Cliente...\n\n");
                  if (send(remote_socket, message, message_length, 0) == SOCKET_ERROR)
                  {
                       WSACleanup();
                       closesocket(remote_socket);
                       msg_err_exit("send() failed\n");
                  }
              }
          }
          while(message_length==BUFFER_SIZE);
         
         
          if ((message_length == 0) || (message_length == WSAECONNRESET))
          {
              printf("Client: Connection Closed.\n");
              break;
          }   
           
          //recebe do cliente a proxima requisição 
          /*
          // limpa o buffer
          memset(&message, 0, BUFFER_SIZE);

          // recebe a mensagem do cliente
          printf("\n\nRecebendo do Cliente...\n\n");
         
          message_length = recv(remote_socket, message, BUFFER_SIZE, 0);
          printf("%s %d: \n\n%s \n\n", inet_ntoa(remote_address.sin_addr), message_length, message);    */
     }
     //while(1);

   
   
     //finalizando as conexões
     printf("encerrando\n");
     //WSACleanup();
     closesocket(local_socket);
     closesocket(socket_do_servidor);
     closesocket(remote_socket);
     }
     //system("PAUSE");
     return 0;
}

Valew o/

Qlqr ajuda eh bem vinda :D
Esse eh um código BACANA pra por num bom Trojan Horse e usar a máquina de algum otário como Proxy  ;D

Isso se eu não conseguir bolar um jeito de fazer uma REDE de proxys "não autorizados" legais.

Abraços