1. 首页
  2. 问答
  3. 如何在Linux中使用C程序映射两个端口

如何在Linux中使用C程序映射两个端口

2012-04-04 77 views
-1

我想用C程序映射两个端口（任何事物都转到端口x转到端口y，反之亦然），我写了这个程序，但它不起作用。 这是我的代码：如何在Linux中使用C程序映射两个端口

int recv_all_nonblock(int sockfd,char* buff,int buffersize) 
{ 
    int numbytes; 
    if ((numbytes = recv(sockfd, buff, buffersize-1, MSG_NOSIGNAL|MSG_DONTWAIT)) <= 0) 
    { 
    perror("recv"); 
    } 
    else if(numbytes>0) 
    { 
    buff[numbytes] = '\0'; 
    } 

    return numbytes; 
} 


int sendall(int sockfd, char *buf, int *len) 
{ 
    int total = 0;  // how many bytes we've sent 
    int bytesleft = *len; // how many we have left to send 
    int n=0; 
    while(total < *len) 
    { 
    n = send(sockfd, buf+total, bytesleft, MSG_NOSIGNAL|MSG_DONTWAIT); 
    if (n == -1) { break; } 
    total += n; 
    bytesleft -= n; 
    } 

    *len = total; // return number actually sent here 

    return n==-1?-1:0; // return -1 on failure, 0 on success 
} 


int Connect_To_Remote(char *Addr,char* PORT) 
{ 
    int sockfd; 
    struct addrinfo hints, *servinfo=NULL, *p=NULL; 
    int rv; 
    char s[INET6_ADDRSTRLEN]; 



    memset(&hints, 0, sizeof hints); 
    hints.ai_family = AF_UNSPEC; 
    hints.ai_socktype = SOCK_STREAM; 
    while (p==NULL) 
    { 
    sleep(5); 
    while((rv = getaddrinfo(Addr, PORT, &hints, &servinfo)) != 0) 
    { 
     fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); 
     sleep(5); 
    } 

    for(p = servinfo; p != NULL; p = p->ai_next) 
    { 
     if ((sockfd = socket(p->ai_family, p->ai_socktype,p->ai_protocol)) == -1) 
     { 
     perror("client: socket"); 
     continue; 
     } 

     if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) 
     { 
     close(sockfd); 
     perror("client: connect"); 
     continue; 
     } 

     break; 
    } 

    if (p == NULL) 
    { 
     fprintf(stderr, "client: failed to connect\n"); 
    } 
    } 

    inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),s, sizeof s); 
    printf("client: connecting to %s\n", s); 

    freeaddrinfo(servinfo); // all done with this structure 
    return sockfd; 

} 
int recv_all(int sockfd,char* buff,int buffersize) 
{ 
    int numbytes; 
    fd_set readfd_set; 
    struct timeval recvwait; 

    recvwait.tv_sec=10; 
    recvwait.tv_usec=0; 
    FD_ZERO(&readfd_set); 
    FD_SET(sockfd, &readfd_set); 
    if(select(sockfd+1, &readfd_set, NULL, NULL, &recvwait) <= 0) 
    { 
    perror("wait for recieve error:"); 
    } 
    else 
    { 
    if ((numbytes = recv(sockfd, buff, buffersize-1, MSG_NOSIGNAL|MSG_DONTWAIT)) == -1) 
    { 
     perror("recv"); 
    } 
    else if(numbytes>0) 
    { 
     buff[numbytes] = '\0'; 
    } 

    return numbytes; 
    } 

    return 0; 
} 

void *Port_Mapper() 
{ 
    int sockfd,newfd; // listen on sock_fd, new connection on new_fd 
    struct addrinfo hints, *servinfo, *tmpaddrinfo; 
    struct sockaddr_storage their_addr; // connector's address information 
    socklen_t sin_size; 
    int rv; 
    int yes=1; 
    int ret=0; 

    memset(&hints, 0, sizeof (hints)); 
    hints.ai_family = AF_UNSPEC; 
    hints.ai_socktype = SOCK_STREAM; 
    hints.ai_flags = AI_PASSIVE; // use my IP 

    while (1) 
    { 
    if ((rv = getaddrinfo(NULL, MapPort, &hints, &servinfo)) != 0) 
    { 
     fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); 
     sleep(2); 
    } 
    else 
    { 
     break; 
    } 
    } 

    while (1) 
    { 
    for(tmpaddrinfo = servinfo; tmpaddrinfo != NULL; tmpaddrinfo = tmpaddrinfo->ai_next) 
    { 
     if ((sockfd = socket(tmpaddrinfo->ai_family,tmpaddrinfo->ai_socktype,tmpaddrinfo->ai_protocol)) == -1) 
     { 
     perror("server: socket"); 
     continue; 
     } 
     if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,sizeof(int)) == -1) 
     { 
      perror("setsockopt"); 
      exit(1); 
     } 
     if (bind(sockfd, tmpaddrinfo->ai_addr, tmpaddrinfo->ai_addrlen) == -1) { 
     close(sockfd); 
     perror("server: bind"); 
     continue; 
     } 

     break; 
    } 
    if (tmpaddrinfo == NULL) 
    { 
     fprintf(stderr, "server: failed to bind\n"); 
     sleep(1); 
    } 
    else 
    { 
     break; 
    } 
    } 
    freeaddrinfo(servinfo); // all done with this structure 
    if (listen(sockfd, MAXLISTENQ) == -1) 
    { 
    perror("listen"); 
    exit(1); 
    } 
    int bufpoint=0; 
    printf("server: waiting for connections...\n"); 
    while(1) 
    { // main accept() loop 
    char buff[MAX_SOCK_BUFFER]; 
    char buff2[MAX_SOCK_BUFFER]; 
    ret=0; 
    int sockfdweb=0; 
    sin_size = sizeof (their_addr); 
    printf("mapping server: going to accept connections...\n"); 
    newfd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); 
    printf("\n\nmapping server: connections accepted:%d\n",newfd); 

    sockfdweb=Connect_To_Remote("192.168.1.10","80"); 
    if (sockfdweb<0) 
    { 
     printf("can not connect to %s\n","192.168.1.10"); 
     break; 
    } 
     while(1) 
    { 



     memset(buff,0,sizeof(buff)); 
     ret=recv_all_nonblock(newfd,buff,MAX_SOCK_BUFFER); 
printf("recved from client1,%d\n",ret); 
     if (ret<=0) 
     { 
     perror("recieve error from browser:"); 
     close(newfd); 
     sin_size = sizeof (their_addr); 
     printf("mapping server: going to accept connections...\n"); 
     newfd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); 
      ret=recv_all_nonblock(newfd,buff,MAX_SOCK_BUFFER); 
    printf("recved from client10,%d\n",ret); 
     if (ret<=0) 
     { 
      perror("recieve error from browser:"); 
      close(newfd); 
      sin_size = sizeof (their_addr); 
      printf("mapping server: going to accept connections...\n"); 
      newfd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); 
     } 
     else if(ret>0) 
     { 
    printf("recved from client0\n"); 
    printf("%s\n",buff); 
      if (sendall(sockfdweb,buff,&bufpoint)<0) 
      { 
      printf("can not send data to %s\n","192.168.1.10"); 
      } 
    printf("send to 80,0\n"); 

     } 

     } 
     else if(ret>0) 
     { 
printf("recved from client\n"); 
    printf("%s\n",buff); 
     if (sendall(sockfdweb,buff,&bufpoint)<0) 
     { 
      printf("can not send data to %s\n","192.168.1.10"); 
     } 
    printf("send to 80\n"); 

     } 

     memset(buff2,0,sizeof(buff2)); 
     ret=recv_all_nonblock(sockfdweb,buff2,MAX_SOCK_BUFFER); 
printf("recv from 80...%d\n",ret); 
     if (ret<=0) 
     { 
     close(sockfdweb); 
     sockfdweb=Connect_To_Remote("192.168.1.10","80"); 
     if (sockfdweb<0) 
     { 
      printf("can not connect to %s\n","192.168.1.10"); 
      break; 
     } 
     ret=recv_all_nonblock(sockfdweb,buff2,MAX_SOCK_BUFFER); 
    printf("recv from 80.9..%d\n",ret); 
     if (ret<=0) 
     { 
      close(sockfdweb); 
      sockfdweb=Connect_To_Remote("192.168.1.10","80"); 
      if (sockfdweb<0) 
      { 
      printf("can not connect to %s\n","192.168.1.10"); 
      break; 
      } 

     } 
     else if (ret>0) 
     { 
    printf("recved from 809\n"); 
      if (sendall(newfd,buff2,&ret)<0) 
      { 
      printf("can not send data to %s\n","192.168.1.10"); 
      } 
    printf("send to client9\n"); 

     } 

     } 
     else if (ret>0) 
     { 
printf("recved from 80\n"); 
     if (sendall(newfd,buff2,&ret)<0) 
     { 
      printf("can not send data to %s\n","192.168.1.10"); 
     } 
printf("send to client\n"); 

     } 


    } 

    } 
    return 0; 
} 

int main() 
{ 
. 
. 
. 
. 
    pthread_attr_init (&attr); 
    pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); 
    pthread_create(&portmapper_threadid,&attr,Port_Mapper,NULL); 
    pthread_attr_destroy (&attr); 
. 
. 
. 
. 
}

我的推杆在Port_Mapper功能有一定的“printf”，并做了一些改动，以跟踪，当我在我的浏览器请求的web这样会发生什么：

http://127.0.0.1:8090/

，并把浏览器的清爽两个三次节目出来是这样的：

映射服务器：连接接受：5
客户端：连接到192.168.1.10
从client1,360
recved从客户recved
GET/1/HTTP/1.1
主机：127.0.0.1:8090
用户代理：Mozilla/5.0（X11; Linux i686; rv：6.0.2）Gecko/20100101 Firefox/6.0.2
Accept：text/html，application/xhtml + xml，application/xml; q = 0.9,/; q = 0.8
Accept-Language：en -us，连接; q = 0.5
接受编码：gzip，放气
接收字符集：ISO-8859-1，utf-8; q = 0.7，*; q = 0.7
连接：保活
缓存控制：最大年龄= 0

发送到80
的recv：资源暂时不可
的recv从80 ...- 1
客户端：连接到192.168.1.10
的recv：资源暂时不可
从80.9 ..- 1个
客户端的recv：连接到192.168.1.10
的recv：资源暂时不可
从recved客户端1，-1
从浏览器收到错误::资源暂时不可用
映射服务器：要接受连接...
从client10,360
从client0
recved recvedGET/1/HTTP/1.1
Host：127.0.0.1:8090
User-Agent：Mozilla/5.0（X11; Linux i686; rv：6.0.2）Gecko/20100101 Firefox/6.0.2
Accept：text/html，application/xhtml + xml，application/xml; q = 0.9,/; q = 0.8
Accept-Language：en -us，en; q = 0.5
Accept-Encoding：gzip，deflate
Accept-Charset：ISO-8859-1，utf-8; q = 0.7，*; q = 0。7
连接：保持活跃
缓存控制：最大年龄= 0

发送到80,0
的recv：资源暂时不可用80
的recv ... 0
客户端：连接到192.168.1.10
的recv：资源暂时不可从80.9 ..- 1
客户
的recv：连接到192.168.1.10
的recv：资源暂时不可用
从客户端1 recved，-1
从浏览器收到错误::资源暂时不可用
映射服务器：要接受连接...
的recv：从资源暂时不可用
从client10 recved，-1
收到错误浏览器::资源暂时不可用
映射服务器：要接受连接...
的recv：资源暂时不可用80
的recv ... 0
客户端：连接到192.168.1.10
的recv：从80.9 ..- 1
客户资源暂时不可
的recv：连接到192.168.1.10
从client1,332
recved从客户recved
GET/HTTP/1.1
主机：127.0.0.1 ：8090
User-Agent：Mozilla/5.0（X11; Linux i686; RV：6.0.2）壁虎/ 20100101火狐/ 6.0.2
接受：text/html的，应用/ XHTML + xml的，应用/ XML; Q = 0.9，/; Q = 0.8
接受语言：EN -us，连接; q = 0.5
接受编码：gzip，放气
接收字符集：ISO-8859-1，utf-8; q = 0.7，*; q = 0.7
连接：保活

发送到80
的recv：资源暂时不可
的recv从80 ...- 1
客户端：连接为192.168.1.10
的recv：资源暂时不可
从80.9 ..- 1个
客户端的recv：连接到192.168.1.10
的recv：资源暂时不可
从客户端1 recved，-1
从浏览器收到错误::资源暂时不可用
映射服务器：正在接受连接...

，你可以看到程序从浏览器正确地接收数据，但是当它发送到web服务器的数据，并希望接收来自Web服务器的数据总是得到错误，并且没有收到来自Web服务器的任何数据：

发送到80
的recv：资源暂时不可用
的recv从80 ...- 1

我不得不说，网络服务器工作正常 没问题。
任何机构可以告诉我什么是我的问题？

来源

2012-04-04 golden_boy615

+1

你能缩短你的代码吗？这是通过浏览很多方法。见http://sscce.org/ – 2012-04-04 11:17:40

回答

0

对于如此简单的任务，您的代码非常复杂。它可以简化引用了很多，看到这个（伪）代码：[其余的我留下作为一个练习]

void mapper() 
{ 
    int server_socket = create_server_socket(); 

    for (;;) 
    { 
     int incomming_socket = accept(server_socket); 

     int web_server_socket = connect_to_webserver(); 

     make_socket_nonblocking(incomming_socket); 
     make_socket_nonblocking(web_server_socket); 

     for (;;) 
     { 
      int disconnected = 0; 

      FD_ZERO(&read_set); 

      FD_SET(incomming_socket, &read_set); 
      FD_SET(web_server_socket, &read_set); 

      select(max_socket + 1, &read_set, NULL, NULL, NULL); 

      if (FD_ISSET(incomming_socket, &read_set)) 
      { 
       disonnected = recv_and_send(incomming_socket, web_server_socket); 
      } 
      if (!disconnected && FD_ISSET(web_server_socket, &read_set)) 
      { 
       disconnected = recv_and_send(web_server_socket, incomming_socket); 
      } 

      if (disconnected) 
       break; 
     } 

     close(web_server_socket); 
     close(incomming_socket); 
    } 
} 

int recv_and_send(from_socket, to_socket) 
{ 
    char buffer[1024]; 

    for (;;) 
    { 
     len = recv_all(from_socket, buffer, sizeof(buffer)); 
     if (len < 0) 
      return 1; /* Disconnect */ 
     if (len == 0) 
      break; /* No more to read for now */ 

     if (send_all(to_socket, buffer, len) < 0) 
      return 1; /* Disconnect */ 
    } 

    return 0; 
} 

int recv_all(socket_fd, char *buffer, const size_t buflen) 
{ 
    size_t total_recv = 0; 
    size_t remaining_len = buflen; 

    while (remaining_len > 0) 
    { 
     ssize_t len = recv(socket_fd, buffer + total_recv, remaining_len); 
     if (len < 0) 
     { 
      if (errno == EWOULDBLOCK) 
       break; /* No more to read at the moment */ 
      return -1; /* An error */ 
     } 
     if (len == 0) 
      break; /* Connection closed */ 

     total_recv += len; 
     remaining_len -= len; 
    } 

    return total_recv; 
}

与您的代码的主要区别是，在主循环很多更简单。您不需要多个accept调用（您为什么需要它？）或几种不同的读写功能。我的代码部分可以进一步简化，如recv_all函数。

还应当指出的是，我上面的代码只处理一次一个连接。解决此问题的一种方法是为每个传入连接创建一个新线程，或者使用更先进的方法使用连接和缓冲区列表，并在它们与侦听套接字之间进行多路复用。

来源

2012-04-04 11:50:41

+0

非常感谢它的工作 – 2012-04-08 08:22:29

相关问题

 相关问题