Chinaunix首页 | 论坛 | 博客

Twi1ight\'s blogtwi1ight.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

7wi1ight

  • 博客访问： 57198
  • 博文数量： 12
  • 博客积分： 331
  • 博客等级： 一等列兵
  • 技术积分： 155
  • 用 户 组： 普通用户
  • 注册时间： 2012-02-17 10:53
文章分类

全部博文（12）

文章存档

2012年（12）

我的朋友
最近访客
推荐博文
相关博文
Linux 下的lcx源代码<修改无错版>

分类： LINUX

2012-09-11 22:57:45

由于要在linux下面用到类似lcx的程序，百度找到了几份源代码，但是在BT5 R3里面编译都错误，就仔细看了看，改了下，主要修改的地方有2个，第一个是void closeallfd()改成了void closeallfd(int);另一个地方是accept函数的第三个参数加上了强制类型转换(socklen_t *)，修改后代码如下：


点击(此处)折叠或打开

  1. /* Socket data transport tool
  2. * by bkbll(bkbll@cnhonker.net)
  3. * [bkbll@mobile socket]$ uname -a
  4. * Linux mobile 2.4.18-14 #1 Wed Sep 4 13:35:50 EDT 2002 i686 i686 i386 GNU/Linux
  5. * [bkbll@mobile socket]$ gcc -o trtool trtool.c
  6. * [bkbll@mobile socket]$ ./trtool
  7. * Socket data transport tool
  8. * by bkbll(bkbll@cnhonker.net)
  9. * Usage:./trtool -m method [-h1 host1] -p1 port1 [-h2 host2] -p2 port2 [-v] [-log filename]
  10. * -v: version
  11. * -h1: host1
  12. * -h2: host2
  13. * -p1: port1
  14. * -p2: port2
  15. * -log: log the data
  16. * -m: the action method for this tool
  17. * 1: listen on PORT1 and connect to HOST2:PORT2
  18. * 2: listen on PORT1 and PORT2
  19. * 3: connect to HOST1:PORT1 and HOST2:PORT2
  20. */
  21. #include <sys/time.h>
  22. #include <signal.h>
  23. #include <stdlib.h>
  24. #include <sys/types.h>
  25. #include <sys/socket.h>
  26. #include <string.h>
  27. #include <netinet/in.h>
  28. #include <arpa/inet.h>
  29. #include <unistd.h>
  30. #include <stdio.h>
  31. #include <errno.h>
  32. #include <netdb.h>

  34. #define VERSION "2.2"
  35. #define TIMEOUT 300
  36. #define max(a,b) (a)>(b)?(a):(b)
  37. #define MAXSIZE 10240
  38. #define HOSTLEN 40
  39. #define CONNECT_NUMBER 5

  41. /* define function here */
  42. void usage(char *s);
  43. void transdata(int fd1,int fd2);
  44. void closeallfd(int);
  45. void makelog(char *buffer,int length);
  46. int testifisvalue(char *str);
  47. int bind2conn(int port1,char *host,int port2);
  48. int bind2bind(int port1,int port2);
  49. int conn2conn(char *host1,int port1,char *host2,int port2);
  50. int create_socket();
  51. int create_serv(int sockfd,int port);
  52. int client_connect(int sockfd,char* server,int port);

  54. /* define GLOBAL varible here */
  55. extern int errno;
  56. FILE *fp;

  58. main(int argc,char **argv)
  59. {
  60.     char **p;
  61.     char host1[HOSTLEN],host2[HOSTLEN];
  62.     int port1=0,port2=0,method=0;
  63.     int length;
  64.     char *logfile=NULL;

  66.     p=argv;
  67.     memset(host1,0,HOSTLEN);
  68.     memset(host2,0,HOSTLEN);
  69.     while(*p)
  70.     {
  71.         if(strcmp(*p,"-v")==0)
  72.         {
  73.             printf("Socket data transport tool.\r\nVersion:%s\r\n",VERSION);
  74.             p++;
  75.             continue;
  76.         }
  77.         if(strcmp(*p,"-h1")==0)
  78.         {
  79.             if(testifisvalue(*(p+1))==1)
  80.             {
  81.                 length=(strlen(*(p+1))>HOSTLEN-1)?HOSTLEN-1:strlen(*(p+1));
  82.                 strncpy(host1,*(++p),length);
  83.             }
  84.             p++;
  85.             continue;
  86.         }
  87.         if(strcmp(*p,"-h2")==0)
  88.         {
  89.             if(testifisvalue(*(p+1))==1)
  90.             {
  91.                 length=(strlen(*(p+1))>HOSTLEN-1)?HOSTLEN-1:strlen(*(p+1));
  92.                 strncpy(host2,*(++p),length);
  93.             }
  94.             p++;
  95.             continue;
  96.         }
  97.         if(strcmp(*p,"-p1")==0)
  98.         {
  99.             if(testifisvalue(*(p+1))==1)
  100.                 port1=atoi(*(++p));
  101.             p++;
  102.             continue;
  103.         }
  104.         if(strcmp(*p,"-p2")==0)
  105.         {
  106.             if(testifisvalue(*(p+1))==1)
  107.                 port2=atoi(*(++p));
  108.             p++;
  109.             continue;
  110.         }
  111.         if(strcmp(*p,"-m")==0)
  112.         {
  113.             if(testifisvalue(*(p+1))==1)
  114.                 method=atoi(*(++p));
  115.             p++;
  116.             continue;
  117.         }
  118.         if(strcmp(*p,"-log")==0)
  119.         {
  120.             if(testifisvalue(*(p+1))==1)
  121.                 logfile=*(++p);
  122.             else
  123.             {
  124.                 printf("[ERROR]:must supply logfile name\r\n");
  125.                 exit(0);
  126.             }
  127.             p++;
  128.             continue;
  129.         }
  130.         p++;
  131.     }
  132.     signal(SIGCLD,SIG_IGN);
  133.     signal(SIGINT,&closeallfd);
  134.     if(logfile !=NULL)
  135.     {
  136.         fp=fopen(logfile,"a");
  137.         if(fp == NULL )
  138.         {
  139.             perror("open logfile");
  140.             exit(0);
  141.         }
  142.     }
  143.     makelog("######################## start ################\r\n",49);
  144.     switch(method)
  145.     {
  146.     case 0:
  147.         usage(argv[0]);
  148.         break;
  149.     case 1:
  150.         if((port1==0) || (port2==0))
  151.         {
  152.             printf("[ERROR]:must supply PORT1 and PORT2.\r\n");
  153.             break;
  154.         }
  155.         if(strlen(host2)==0)
  156.         {
  157.             printf("[ERROR]:must supply HOST2.\r\n");
  158.             break;
  159.         }
  160.         bind2conn(port1,host2,port2);
  161.         break;
  162.     case 2:
  163.         if((port1==0) || (port2==0))
  164.         {
  165.             printf("[ERROR]:must supply PORT1 and PORT2.\r\n");
  166.             break;
  167.         }
  168.         bind2bind(port1,port2);
  169.         break;
  170.     case 3:
  171.         if((port1==0) || (port2==0))
  172.         {
  173.             printf("[ERROR]:must supply PORT1 and PORT2.\r\n");
  174.             break;
  175.         }
  176.         if(strlen(host1)==0)
  177.         {
  178.             printf("[ERROR]:must supply HOST1.\r\n");
  179.             break;
  180.         }
  181.         if(strlen(host2)==0)
  182.         {
  183.             printf("[ERROR]:must supply HOST2.\r\n");
  184.             break;
  185.         }
  186.         conn2conn(host1,port1,host2,port2);
  187.         break;
  188.     default:
  189.         usage(argv[0]);
  190.     }
  191.     closeallfd(0);
  192. }

  194. int testifisvalue(char *str)
  195. {
  196.     if(str == NULL ) return(0);
  197.     if(str[0]=='-') return(0);
  198.     return(1);
  199. }

  201. void usage(char *s)
  202. {
  203.     printf("Socket data transport tool\r\n");
  204.     printf("by bkbll(bkbll@cnhonker.net)\r\n\r\n");
  205.     printf("Usage:%s -m method [-h1 host1] -p1 port1 [-h2 host2] -p2 port2 [-v] [-log filename]\r\n",s);
  206.     printf(" -v: version\r\n");
  207.     printf(" -h1: host1\r\n");
  208.     printf(" -h2: host2\r\n");
  209.     printf(" -p1: port1\r\n");
  210.     printf(" -p2: port2\r\n");
  211.     printf(" -log: log the data\r\n");
  212.     printf(" -m: the action method for this tool\r\n");
  213.     printf(" 1: listen on PORT1 and connect to HOST2:PORT2\r\n");
  214.     printf(" 2: listen on PORT1 and PORT2\r\n");
  215.     printf(" 3: connect to HOST1:PORT1 and HOST2:PORT2\r\n");

  217.     closeallfd(0);
  218. }

  220. int bind2conn(int port1,char *host,int port2)
  221. {
  222.     int sockfd,sockfd1,sockfd2;
  223.     struct sockaddr_in remote;
  224.     int size;
  225.     int pid;
  226.     char buffer[1024];

  228.     memset(buffer,0,1024);
  229.     if((sockfd=create_socket())==0) exit(0);
  230.     if(create_serv(sockfd,port1)==0)
  231.     {
  232.         close(sockfd1);
  233.         exit(0);
  234.     }
  235.     size=sizeof(struct sockaddr);
  236.     while(1)
  237.     {
  238.         printf("waiting for response.........\n");
  239.         if((sockfd1=accept(sockfd,(struct sockaddr *)&remote,(socklen_t *)&size))<0)
  240.         {
  241.             perror("accept error\n");
  242.             continue;
  243.         }
  244.         printf("accept a client from %s:%d\n",inet_ntoa(remote.sin_addr),ntohs(remote.sin_port));
  245.         if((sockfd2=create_socket())==0)
  246.         {
  247.             close(sockfd1);
  248.             continue;
  249.         }
  250.         printf("make a connection to %s:%d....",host,port2);
  251.         fflush(stdout);
  252.         if(client_connect(sockfd2,host,port2)==0)
  253.         {
  254.             close(sockfd2);
  255.             sprintf(buffer,"[SERVER]connection to %s:%d error\r\n",host,port2);
  256.             write(sockfd1,buffer,strlen(buffer));
  257.             memset(buffer,0,1024);
  258.             close(sockfd1);
  259.             continue;
  260.         }
  261.         printf("ok\r\n");
  262.         pid=fork();
  263.         if(pid==0) transdata(sockfd1,sockfd2);
  264.         // sleep(2);
  265.         close(sockfd1);
  266.         close(sockfd2);
  267.     }

  269. }

  271. int bind2bind(int port1,int port2)
  272. {
  273.     int fd1,fd2,sockfd1,sockfd2;
  274.     struct sockaddr_in client1,client2;
  275.     int size1,size2;
  276.     int pid;

  278.     if((fd1=create_socket())==0) exit(0);
  279.     if((fd2=create_socket())==0) exit(0);
  280.     printf("binding port %d......",port1);
  281.     fflush(stdout);
  282.     if(create_serv(fd1,port1)==0)
  283.     {
  284.         close(fd1);
  285.         exit(0);
  286.     }
  287.     printf("ok\r\n");
  288.     printf("binding port %d......",port2);
  289.     fflush(stdout);
  290.     if(create_serv(fd2,port2)==0)
  291.     {
  292.         close(fd2);
  293.         exit(0);
  294.     }
  295.     printf("ok\r\n");
  296.     size1=size2=sizeof(struct sockaddr);
  297.     while(1)
  298.     {
  299.         printf("waiting for response on port %d.........\n",port1);
  300.         if((sockfd1=accept(fd1,(struct sockaddr *)&client1,(socklen_t *)&size1))<0)
  301.         {
  302.             perror("accept1 error");
  303.             continue;
  304.         }
  305.         printf("accept a client on port %d from %s,waiting another on port %d....\n",port1,inet_ntoa(client1.sin_addr),port2);
  306.         if((sockfd2=accept(fd2,(struct sockaddr *)&client2,(socklen_t *)&size2))<0)
  307.         {
  308.             perror("accept2 error");
  309.             close(sockfd1);
  310.             continue;
  311.         }
  312.         printf("accept a client on port %d from %s\n",port2,inet_ntoa(client2.sin_addr));
  313.         pid=fork();
  314.         if(pid==0) transdata(sockfd1,sockfd2);
  315.         //sleep(2);
  316.         close(sockfd1);
  317.         close(sockfd2);
  318.     }
  319. }

  321. int conn2conn(char *host1,int port1,char *host2,int port2)
  322. {
  323.     int sockfd1,sockfd2;
  324.     int pid;

  326.     while(1)
  327.     {
  328.         if((sockfd1=create_socket())==0) exit(0);
  329.         if((sockfd2=create_socket())==0) exit(0);
  330.         printf("make a connection to %s:%d....",host1,port1);
  331.         fflush(stdout);
  332.         if(client_connect(sockfd1,host1,port1)==0)
  333.         {
  334.             close(sockfd1);
  335.             close(sockfd2);
  336.             break;
  337.         }
  338.         printf("ok\r\n");
  339.         printf("make a connection to %s:%d....",host2,port2);
  340.         fflush(stdout);
  341.         if(client_connect(sockfd2,host2,port2)==0)
  342.         {
  343.             close(sockfd1);
  344.             close(sockfd2);
  345.             break;
  346.         }
  347.         printf("ok\r\n");
  348.         pid=fork();
  349.         if(pid==0) transdata(sockfd1,sockfd2);
  350.         //sleep(2);
  351.         close(sockfd1);
  352.         close(sockfd2);

  354.     }
  355. }

  357. void transdata(int fd1,int fd2)
  358. {
  359.     struct timeval timeset;
  360.     fd_set readfd,writefd;
  361.     int result,i=0;
  362.     char read_in1[MAXSIZE],send_out1[MAXSIZE];
  363.     char read_in2[MAXSIZE],send_out2[MAXSIZE];
  364.     int read1=0,totalread1=0,send1=0;
  365.     int read2=0,totalread2=0,send2=0;
  366.     int sendcount1,sendcount2;
  367.     int maxfd;
  368.     struct sockaddr_in client1,client2;
  369.     int structsize1,structsize2;
  370.     char host1[20],host2[20];
  371.     int port1=0,port2=0;
  372.     char tmpbuf1[100],tmpbuf2[100];

  374.     memset(host1,0,20);
  375.     memset(host2,0,20);
  376.     memset(tmpbuf1,0,100);
  377.     memset(tmpbuf2,0,100);
  378.     if(fp!=NULL)
  379.     {
  380.         structsize1=sizeof(struct sockaddr);
  381.         structsize2=sizeof(struct sockaddr);
  382.         if(getpeername(fd1,(struct sockaddr *)&client1,(socklen_t *)&structsize1)<0)
  383.         {
  384.             strcpy(host1,"fd1");
  385.         }
  386.         else
  387.         {
  388.             printf("got,ip:%s,port:%d\r\n",inet_ntoa(client1.sin_addr),ntohs(client1.sin_port));
  389.             strcpy(host1,inet_ntoa(client1.sin_addr));
  390.             port1=ntohs(client1.sin_port);
  391.         }
  392.         if(getpeername(fd2,(struct sockaddr *)&client2,(socklen_t *)&structsize2)<0)
  393.         {
  394.             strcpy(host2,"fd2");
  395.         }
  396.         else
  397.         {
  398.             printf("got,ip:%s,port:%d\r\n",inet_ntoa(client2.sin_addr),ntohs(client2.sin_port));
  399.             strcpy(host2,inet_ntoa(client2.sin_addr));
  400.             port2=ntohs(client2.sin_port);
  401.         }
  402.         sprintf(tmpbuf1,"\r\n########### read from %s:%d ####################\r\n",host1,port1);
  403.         sprintf(tmpbuf2,"\r\n########### reply from %s:%d ####################\r\n",host2,port2);
  404.     }

  406.     maxfd=max(fd1,fd2)+1;
  407.     memset(read_in1,0,MAXSIZE);
  408.     memset(read_in2,0,MAXSIZE);
  409.     memset(send_out1,0,MAXSIZE);
  410.     memset(send_out2,0,MAXSIZE);

  412.     timeset.tv_sec=TIMEOUT;
  413.     timeset.tv_usec=0;
  414.     while(1)
  415.     {
  416.         FD_ZERO(&readfd);
  417.         FD_ZERO(&writefd);

  419.         FD_SET(fd1,&readfd);
  420.         FD_SET(fd1,&writefd);
  421.         FD_SET(fd2,&writefd);
  422.         FD_SET(fd2,&readfd);

  424.         result=select(maxfd,&readfd,&writefd,NULL,&timeset);
  425.         if((result<0) && (errno!=EINTR))
  426.         {
  427.             perror("select error");
  428.             break;
  429.         }
  430.         else if(result==0)
  431.         {
  432.             printf("time out\n");
  433.             break;
  434.         }
  435.         if(FD_ISSET(fd1,&readfd))
  436.         {
  437.             /* 不能超过MAXSIZE-totalread1,不然send_out1会溢出 */
  438.             if(totalread1<MAXSIZE)
  439.             {
  440.                 read1=read(fd1,read_in1,MAXSIZE-totalread1);
  441.                 if(read1==0) break;
  442.                 if((read1<0) && (errno!=EINTR))
  443.                 {
  444.                     perror("read data error");
  445.                     break;
  446.                 }
  447.                 memcpy(send_out1+totalread1,read_in1,read1);
  448.                 makelog(tmpbuf1,strlen(tmpbuf1));
  449.                 makelog(read_in1,read1);
  450.                 totalread1+=read1;
  451.                 memset(read_in1,0,MAXSIZE);
  452.             }
  453.         }
  454.         if(FD_ISSET(fd2,&writefd))
  455.         {
  456.             int err=0;
  457.             sendcount1=0;
  458.             while(totalread1>0)
  459.             {
  460.                 send1=write(fd2,send_out1+sendcount1,totalread1);
  461.                 if(send1==0)break;
  462.                 if((send1<0) && (errno!=EINTR))
  463.                 {
  464.                     perror("unknow error");
  465.                     err=1;
  466.                     break;
  467.                 }
  468.                 if((send1<0) && (errno==ENOSPC)) break;
  469.                 sendcount1+=send1;
  470.                 totalread1-=send1;
  471.             }
  472.             if(err==1) break;
  473.             if((totalread1>0) && (sendcount1>0))
  474.             {
  475.                 /* 移动未发送完的数据到开始 */
  476.                 memcpy(send_out1,send_out1+sendcount1,totalread1);
  477.                 memset(send_out1+totalread1,0,MAXSIZE-totalread1);
  478.             }
  479.             else
  480.                 memset(send_out1,0,MAXSIZE);
  481.         }
  482.         if(FD_ISSET(fd2,&readfd))
  483.         {

  485.             if(totalread2<MAXSIZE)
  486.             {
  487.                 read2=read(fd2,read_in2,MAXSIZE-totalread2);
  488.                 if(read2==0)break;
  489.                 if((read2<0) && (errno!=EINTR))
  490.                 {
  491.                     perror("read data error");
  492.                     break;
  493.                 }
  494.                 memcpy(send_out2+totalread2,read_in2,read2);
  495.                 makelog(tmpbuf2,strlen(tmpbuf2));
  496.                 makelog(read_in2,read2);
  497.                 totalread2+=read2;
  498.                 memset(read_in2,0,MAXSIZE);
  499.             }
  500.         }
  501.         if(FD_ISSET(fd1,&writefd))
  502.         {
  503.             int err2=0;
  504.             sendcount2=0;
  505.             while(totalread2>0)
  506.             {
  507.                 send2=write(fd1,send_out2+sendcount2,totalread2);
  508.                 if(send2==0)break;
  509.                 if((send2<0) && (errno!=EINTR))
  510.                 {
  511.                     perror("unknow error");
  512.                     err2=1;
  513.                     break;
  514.                 }
  515.                 if((send2<0) && (errno==ENOSPC)) break;
  516.                 sendcount2+=send2;
  517.                 totalread2-=send2;
  518.             }
  519.             if(err2==1) break;
  520.             if((totalread2>0) && (sendcount2 > 0))
  521.             {
  522.                 /* 移动未发送完的数据到开始 */
  523.                 memcpy(send_out2,send_out2+sendcount2,totalread2);
  524.                 memset(send_out2+totalread2,0,MAXSIZE-totalread2);
  525.             }
  526.             else
  527.                 memset(send_out2,0,MAXSIZE);
  528.         }
  529.     }

  531.     close(fd1);
  532.     close(fd2);
  533.     printf("ok,I closed the two fd\r\n");
  534.     exit(0);
  535. }

  537. void closeallfd(int n)
  538. {
  539.     int i;
  540.     printf("Let me exit...");
  541.     fflush(stdout);
  542.     for(i=3;i<256;i++)
  543.     {
  544.         close(i);
  545.     }
  546.     if(fp != NULL)
  547.     {
  548.         fprintf(fp,"exited\r\n");
  549.         fclose(fp);
  550.     }
  551.     printf("all overd\r\n");
  552.     exit(0);
  553. }
  554. void makelog(char *buffer,int length)
  555. {
  556.     if(fp !=NULL)
  557.     {
  558.         //fprintf(fp,"%s",buffer);
  559.         write(fileno(fp),buffer,length);
  560.         fflush(fp);
  561.     }
  562. }

  564. int create_socket()
  565. {
  566.     int sockfd;

  568.     sockfd=socket(AF_INET,SOCK_STREAM,0);
  569.     if(sockfd<0)
  570.     {
  571.         perror("create socket error");
  572.         return(0);
  573.     }
  574.     return(sockfd);
  575. }

  577. int create_serv(int sockfd,int port)
  578. {
  579.     struct sockaddr_in srvaddr;
  580.     int on=1;

  582.     bzero(&srvaddr,sizeof(struct sockaddr));
  583.     srvaddr.sin_port=htons(port);
  584.     srvaddr.sin_family=AF_INET;
  585.     srvaddr.sin_addr.s_addr=htonl(INADDR_ANY);

  587.     setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)); //so I can rebind the port
  588.     if(bind(sockfd,(struct sockaddr *)&srvaddr,sizeof(struct sockaddr))<0)
  589.     {
  590.         perror("error");
  591.         return(0);
  592.     }
  593.     if(listen(sockfd,CONNECT_NUMBER)<0)
  594.     {
  595.         perror("listen error\n");
  596.         return(0);
  597.     }
  598.     return(1);
  599. }

  601. int client_connect(int sockfd,char* server,int port)
  602. {
  603.     struct sockaddr_in cliaddr;
  604.     struct hostent *host;

  606.     if(!(host=gethostbyname(server)))
  607.     {
  608.         printf("gethostbyname(%s) error:%s\n",server,strerror(errno));
  609.         return(0);
  610.     }

  612.     bzero(&cliaddr,sizeof(struct sockaddr));
  613.     cliaddr.sin_family=AF_INET;
  614.     cliaddr.sin_port=htons(port);
  615.     cliaddr.sin_addr=*((struct in_addr *)host->h_addr);

  617.     if(connect(sockfd,(struct sockaddr *)&cliaddr,sizeof(struct sockaddr))<0)
  618.     {
  619.         perror("error");
  620.         return(0);
  621.     }
  622.     return(1);
  623. }


阅读(2133) | 评论(0) | 转发(0) |
0

上一篇：BT5 破解无线密码小记

下一篇：Mysql 服务启动失败 1067进程意外终止解决办法

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6