SaveText.Ru

Без имени
  1. #include <sys/socket.h>  
  2.  #include <sys/types.h>  
  3.  #include <resolv.h>  
  4.  #include <string.h>  
  5.  #include <stdlib.h>  
  6.  #include <pthread.h>  
  7.  #include<unistd.h>  
  8.  #include<netdb.h> //hostent  
  9.  #include<arpa/inet.h>  
  10.  int hostname_to_ip(char * , char *);  
  11.  // client will connect to server using given IP and port  
  12.  struct serverInfo  
  13.  {  
  14.       int client_fd;  
  15.       char ip[100];  
  16.       char port[100];  
  17.  };  
  18.  // A thread function    
  19.  void *runSocket(void *vargp)  
  20.  {  
  21.    struct serverInfo *info = (struct serverInfo *)vargp;  
  22.    char buffer[65535];  
  23.    int bytes =0;  
  24.       printf("client:%dn",info->client_fd);  
  25.       fputs(info->ip,stdout);  
  26.       fputs(info->port,stdout);  
  27.       //code to connect to main server via this proxy server  
  28.       int server_fd =0;  
  29.       struct sockaddr_in server_sd;  
  30.       // create a socket  
  31.       server_fd = socket(AF_INET, SOCK_STREAM, 0);  
  32.       if(server_fd < 0)  
  33.       {  
  34.            printf("server socket not createdn");  
  35.       }  
  36.       printf("server socket createdn");      
  37.       memset(&server_sd, 0, sizeof(server_sd));  
  38.       // set socket variables  
  39.       server_sd.sin_family = AF_INET;  
  40.       server_sd.sin_port = htons(atoi(info->port));  
  41.       server_sd.sin_addr.s_addr = inet_addr(info->ip);  
  42.       //connect to main server from this proxy server  
  43.       if((connect(server_fd, (struct sockaddr *)&server_sd, sizeof(server_sd)))<0)  
  44.       {  
  45.            printf("server connection not established");  
  46.       }  
  47.       printf("server socket connectedn");  
  48.       while(1)  
  49.       {  
  50.            //receive data from client  
  51.            memset(&buffer, '', sizeof(buffer));  
  52.            bytes = read(info->client_fd, buffer, sizeof(buffer));  
  53.            if(bytes <= 0)  
  54.            {  
  55.            }  
  56.            else  
  57.            {  
  58.                 // send data to main server  
  59.                 write(server_fd, buffer, sizeof(buffer));  
  60.                 //printf("client fd is : %dn",c_fd);                    
  61.                 printf("From client :n");                    
  62.                 fputs(buffer,stdout);      
  63.                   fflush(stdout);  
  64.            }  
  65.            //recieve response from server  
  66.            memset(&buffer, '', sizeof(buffer));  
  67.            bytes = read(server_fd, buffer, sizeof(buffer));  
  68.            if(bytes <= 0)  
  69.            {  
  70.            }            
  71.            else  
  72.            {  
  73.                 // send response back to client  
  74.                 write(info->client_fd, buffer, sizeof(buffer));  
  75.                 printf("From server :n");                    
  76.                 fputs(buffer,stdout);            
  77.            }  
  78.       };      
  79.    return NULL;  
  80.  }  
  81.  // main entry point  
  82.  int main(int argc,char *argv[])  
  83.  {  
  84.      pthread_t tid;  
  85.      char port[100],ip[100];  
  86.      char *hostname = argv[1];  
  87.      char proxy_port[100];  
  88.         // accept arguments from terminal  
  89.         strcpy(ip,argv[1]); // server ip  
  90.         strcpy(port,argv[2]);  // server port  
  91.         strcpy(proxy_port,argv[3]); // proxy port  
  92.         //hostname_to_ip(hostname , ip);  
  93.         printf("server IP : %s and port %s" , ip,port);  
  94.         printf("proxy port is %s",proxy_port);        
  95.         printf("n");  
  96.       //socket variables  
  97.       int proxy_fd =0, client_fd=0;  
  98.       struct sockaddr_in proxy_sd;  
  99.  // add this line only if server exits when client exits  
  100.  signal(SIGPIPE,SIG_IGN);  
  101.       // create a socket  
  102.       if((proxy_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  103.       {  
  104.           printf("nFailed to create socket");  
  105.       }  
  106.       printf("Proxy createdn");  
  107.       memset(&proxy_sd, 0, sizeof(proxy_sd));  
  108.       // set socket variables  
  109.       proxy_sd.sin_family = AF_INET;  
  110.       proxy_sd.sin_port = htons(atoi(proxy_port));  
  111.       proxy_sd.sin_addr.s_addr = INADDR_ANY;  
  112.       // bind the socket  
  113.       if((bind(proxy_fd, (struct sockaddr*)&proxy_sd,sizeof(proxy_sd))) < 0)  
  114.       {  
  115.            printf("Failed to bind a socket");  
  116.       }  
  117.       // start listening to the port for new connections  
  118.       if((listen(proxy_fd, SOMAXCONN)) < 0)  
  119.       {  
  120.            printf("Failed to listen");  
  121.       }  
  122.       printf("waiting for connection..n");  
  123.       //accept all client connections continuously  
  124.       while(1)  
  125.       {  
  126.            client_fd = accept(proxy_fd, (struct sockaddr*)NULL ,NULL);  
  127.            printf("client no. %d connectedn",client_fd);  
  128.            if(client_fd > 0)  
  129.            {  
  130.                  //multithreading variables      
  131.                  struct serverInfo *item = malloc(sizeof(struct serverInfo));  
  132.                  item->client_fd = client_fd;  
  133.                  strcpy(item->ip,ip);  
  134.                  strcpy(item->port,port);  
  135.                  pthread_create(&tid, NULL, runSocket, (void *)item);  
  136.                  sleep(1);  
  137.            }  
  138.       }  
  139.       return 0;  
  140.  }  
  141.  int hostname_to_ip(char * hostname , char* ip)  
  142.  {  
  143.    struct hostent *he;  
  144.    struct in_addr **addr_list;  
  145.    int i;  
  146.    if ( (he = gethostbyname( hostname ) ) == NULL)  
  147.    {  
  148.      // get the host info  
  149.      herror("gethostbyname");  
  150.      return 1;  
  151.    }  
  152.    addr_list = (struct in_addr **) he->h_addr_list;  
  153.    for(i = 0; addr_list[i] != NULL; i++)  
  154.    {  
  155.      //Return the first one;  
  156.      strcpy(ip , inet_ntoa(*addr_list[i]) );  
  157.      return 0;  
  158.    }  
  159.    return 1;  
  160.  }  
  161.  

Share with your friends:

Print