未编译的

 

  1. #include <sys/time.h> 
  2. #include <signal.h> 
  3. #include <stdlib.h> 
  4. #include <sys/types.h> 
  5. #include <sys/socket.h> 
  6. #include <string.h> 
  7. #include <netinet/in.h> 
  8.  
  9. #include <arpa/inet.h> 
  10. #include <unistd.h> 
  11. #include <stdio.h> 
  12. #include <errno.h> 
  13. #include <netdb.h> 
  14.  
  15. #define VERSION "2.2" 
  16. #define TIMEOUT 300 
  17. #define max(a,b) (a)>(b)?(a):(b) 
  18. #define MAXSIZE 10240 
  19. #define HOSTLEN 40 
  20. #define CONNECT_NUMBER 5 
  21.  
  22.  
  23. void usage(char *s); 
  24. void transdata(int fd1,int fd2); 
  25. void closeallfd(); 
  26. void makelog(char *buffer,int length); 
  27. int testifisvalue(char *str); 
  28. int bind2conn(int port1,char *host,int port2); 
  29. int bind2bind(int port1,int port2); 
  30. int conn2conn(char *host1,int port1,char *host2,int port2); 
  31. int create_socket(); 
  32. int create_serv(int sockfd,int port); 
  33. int client_connect(int sockfd,char* server,int port); 
  34.  
  35.  
  36. extern int errno; 
  37. FILE *fp; 
  38.  
  39. main(int argc,char **argv) 
  40. char **p; 
  41. char host1[HOSTLEN],host2[HOSTLEN]; 
  42. int port1=0,port2=0,method=0; 
  43. int length; 
  44. char *logfile=NULL; 
  45.  
  46. p=argv; 
  47. memset(host1,0,HOSTLEN); 
  48. memset(host2,0,HOSTLEN); 
  49. while(*p) 
  50. if(strcmp(*p,"-v")==0) 
  51. printf("Socket data transport tool.\r\nVersion:%s\r\n",VERSION); 
  52. p++; 
  53. continue
  54. if(strcmp(*p,"-h1")==0) 
  55. if(testifisvalue(*(p+1))==1) 
  56. length=(strlen(*(p+1))>HOSTLEN-1)?HOSTLEN-1:strlen(*(p+1)); 
  57. strncpy(host1,*(++p),length); 
  58. p++; 
  59. continue
  60. if(strcmp(*p,"-h2")==0) 
  61. if(testifisvalue(*(p+1))==1) 
  62. length=(strlen(*(p+1))>HOSTLEN-1)?HOSTLEN-1:strlen(*(p+1)); 
  63. strncpy(host2,*(++p),length); 
  64. p++; 
  65. continue
  66. if(strcmp(*p,"-p1")==0) 
  67. if(testifisvalue(*(p+1))==1) 
  68. port1=atoi(*(++p)); 
  69. p++; 
  70. continue
  71. if(strcmp(*p,"-p2")==0) 
  72. if(testifisvalue(*(p+1))==1) 
  73. port2=atoi(*(++p)); 
  74. p++; 
  75. continue
  76. if(strcmp(*p,"-m")==0) 
  77. if(testifisvalue(*(p+1))==1) 
  78. method=atoi(*(++p)); 
  79. p++; 
  80. continue
  81. if(strcmp(*p,"-log")==0) 
  82. if(testifisvalue(*(p+1))==1) 
  83. logfile=*(++p); 
  84. else 
  85. printf("[ERROR]:must supply logfile name\r\n"); 
  86. exit(0); 
  87. p++; 
  88. continue
  89. p++; 
  90. signal(SIGCLD,SIG_IGN); 
  91. signal(SIGINT,&closeallfd); 
  92. if(logfile !=NULL) 
  93. fp=fopen(logfile,"a"); 
  94. if(fp == NULL ) 
  95. perror("open logfile"); 
  96. exit(0); 
  97. makelog("######################## start ################\r\n",49); 
  98. switch(method) 
  99. case 0: 
  100. usage(argv[0]); 
  101. break
  102. case 1: 
  103. if((port1==0) || (port2==0)) 
  104. printf("[ERROR]:must supply PORT1 and PORT2.\r\n"); 
  105. break
  106. if(strlen(host2)==0) 
  107. printf("[ERROR]:must supply HOST2.\r\n"); 
  108. break
  109. bind2conn(port1,host2,port2); 
  110. break
  111. case 2: 
  112. if((port1==0) || (port2==0)) 
  113. printf("[ERROR]:must supply PORT1 and PORT2.\r\n"); 
  114. break
  115. bind2bind(port1,port2); 
  116. break
  117. case 3: 
  118. if((port1==0) || (port2==0)) 
  119. printf("[ERROR]:must supply PORT1 and PORT2.\r\n"); 
  120. break
  121. if(strlen(host1)==0) 
  122. printf("[ERROR]:must supply HOST1.\r\n"); 
  123. break
  124. if(strlen(host2)==0) 
  125. printf("[ERROR]:must supply HOST2.\r\n"); 
  126. break
  127. conn2conn(host1,port1,host2,port2); 
  128. break
  129. default
  130. usage(argv[0]); 
  131. closeallfd(); 
  132.  
  133. int testifisvalue(char *str) 
  134. if(str == NULL ) return(0); 
  135. if(str[0]=='-'return(0); 
  136. return(1); 
  137.  
  138. void usage(char *s) 
  139. printf("Socket data transport tool\r\n"); 
  140. printf("by bkbll(bkbll@cnhonker.net)\r\n\r\n"); 
  141. printf("Usage:%s -m method [-h1 host1] -p1 port1 [-h2 host2] -p2 port2 [-v] [-log filename]\r\n",s); 
  142. printf(" -v: version\r\n"); 
  143. printf(" -h1: host1\r\n"); 
  144. printf(" -h2: host2\r\n"); 
  145. printf(" -p1: port1\r\n"); 
  146. printf(" -p2: port2\r\n"); 
  147. printf(" -log: log the data\r\n"); 
  148. printf(" -m: the action method for this tool\r\n"); 
  149. printf(" 1: listen on PORT1 and connect to HOST2:PORT2\r\n"); 
  150. printf(" 2: listen on PORT1 and PORT2\r\n"); 
  151. printf(" 3: connect to HOST1:PORT1 and HOST2:PORT2\r\n"); 
  152.  
  153. closeallfd(); 
  154.  
  155. int bind2conn(int port1,char *host,int port2) 
  156. int sockfd,sockfd1,sockfd2; 
  157. struct sockaddr_in remote; 
  158. int size; 
  159. int pid; 
  160. char buffer[1024]; 
  161.  
  162. memset(buffer,0,1024); 
  163. if((sockfd=create_socket())==0) exit(0); 
  164. if(create_serv(sockfd,port1)==0) 
  165. close(sockfd1); 
  166. exit(0); 
  167. size=sizeof(struct sockaddr); 
  168. while(1) 
  169. printf("waiting for response.........\n"); 
  170. if((sockfd1=accept(sockfd,(struct sockaddr *)&remote,&size))<0){perror("accept error\n");continue;} 
  171. printf("accept a client from %s:%d\n",inet_ntoa(remote.sin_addr),ntohs(remote.sin_port)); 
  172. if((sockfd2=create_socket())==0) 
  173. close(sockfd1); 
  174. continue
  175. printf("make a connection to %s:%d....",host,port2); 
  176. fflush(stdout); 
  177. if(client_connect(sockfd2,host,port2)==0) 
  178. close(sockfd2); 
  179. sprintf(buffer,"[SERVER]connection to %s:%d error\r\n",host,port2); 
  180. write(sockfd1,buffer,strlen(buffer)); 
  181. memset(buffer,0,1024); 
  182. close(sockfd1); 
  183. continue
  184. printf("ok\r\n"); 
  185. pid=fork(); 
  186. if(pid==0) transdata(sockfd1,sockfd2); 
  187. // sleep(2); 
  188. close(sockfd1); 
  189. close(sockfd2); 
  190.  
  191.  
  192. int bind2bind(int port1,int port2) 
  193. int fd1,fd2,sockfd1,sockfd2; 
  194. struct sockaddr_in client1,client2; 
  195. int size1,size2; 
  196. int pid; 
  197.  
  198. if((fd1=create_socket())==0) exit(0); 
  199. if((fd2=create_socket())==0) exit(0); 
  200. printf("binding port %d......",port1); 
  201. fflush(stdout); 
  202. if(create_serv(fd1,port1)==0) 
  203. close(fd1); 
  204. exit(0); 
  205. printf("ok\r\n"); 
  206. printf("binding port %d......",port2); 
  207. fflush(stdout); 
  208. if(create_serv(fd2,port2)==0) 
  209. close(fd2); 
  210. exit(0); 
  211. printf("ok\r\n"); 
  212. size1=size2=sizeof(struct sockaddr); 
  213. while(1) 
  214. printf("waiting for response on port %d.........\n",port1); 
  215. if((sockfd1=accept(fd1,(struct sockaddr *)&client1,&size1))<0) 
  216. perror("accept1 error"); 
  217. continue
  218. printf("accept a client on port %d from %s,waiting another on port %d....\n",port1,inet_ntoa(client1.sin_addr),port2); 
  219. if((sockfd2=accept(fd2,(struct sockaddr *)&client2,&size2))<0) 
  220. perror("accept2 error"); 
  221. close(sockfd1); 
  222. continue
  223. printf("accept a client on port %d from %s\n",port2,inet_ntoa(client2.sin_addr)); 
  224. pid=fork(); 
  225. if(pid==0) transdata(sockfd1,sockfd2); 
  226. //sleep(2); 
  227. close(sockfd1); 
  228. close(sockfd2); 
  229.  
  230. int conn2conn(char *host1,int port1,char *host2,int port2) 
  231. int sockfd1,sockfd2; 
  232. int pid; 
  233.  
  234. while(1) 
  235. if((sockfd1=create_socket())==0) exit(0); 
  236. if((sockfd2=create_socket())==0) exit(0); 
  237. printf("make a connection to %s:%d....",host1,port1); 
  238. fflush(stdout); 
  239. if(client_connect(sockfd1,host1,port1)==0) 
  240. close(sockfd1); 
  241. close(sockfd2); 
  242. break
  243. printf("ok\r\n"); 
  244. printf("make a connection to %s:%d....",host2,port2); 
  245. fflush(stdout); 
  246. if(client_connect(sockfd2,host2,port2)==0) 
  247. close(sockfd1); 
  248. close(sockfd2); 
  249. break
  250. printf("ok\r\n"); 
  251. pid=fork(); 
  252. if(pid==0) transdata(sockfd1,sockfd2); 
  253. //sleep(2); 
  254. close(sockfd1); 
  255. close(sockfd2); 
  256.  
  257.  
  258. void transdata(int fd1,int fd2) 
  259. struct timeval timeset; 
  260. fd_set readfd,writefd; 
  261. int result,i=0; 
  262. char read_in1[MAXSIZE],send_out1[MAXSIZE]; 
  263. char read_in2[MAXSIZE],send_out2[MAXSIZE]; 
  264. int read1=0,totalread1=0,send1=0; 
  265. int read2=0,totalread2=0,send2=0; 
  266. int sendcount1,sendcount2; 
  267. int maxfd; 
  268. struct sockaddr_in client1,client2; 
  269. int structsize1,structsize2; 
  270. char host1[20],host2[20]; 
  271. int port1=0,port2=0; 
  272. char tmpbuf1[100],tmpbuf2[100]; 
  273.  
  274. memset(host1,0,20); 
  275. memset(host2,0,20); 
  276. memset(tmpbuf1,0,100); 
  277. memset(tmpbuf2,0,100); 
  278. if(fp!=NULL) 
  279. structsize1=sizeof(struct sockaddr); 
  280. structsize2=sizeof(struct sockaddr); 
  281. if(getpeername(fd1,(struct sockaddr *)&client1,&structsize1)<0) 
  282. strcpy(host1,"fd1"); 
  283. else 
  284. printf("got,ip:%s,port:%d\r\n",inet_ntoa(client1.sin_addr),ntohs(client1.sin_port)); 
  285. strcpy(host1,inet_ntoa(client1.sin_addr)); 
  286. port1=ntohs(client1.sin_port); 
  287. if(getpeername(fd2,(struct sockaddr *)&client2,&structsize2)<0) 
  288. strcpy(host2,"fd2"); 
  289. else 
  290. printf("got,ip:%s,port:%d\r\n",inet_ntoa(client2.sin_addr),ntohs(client2.sin_port)); 
  291. strcpy(host2,inet_ntoa(client2.sin_addr)); 
  292. port2=ntohs(client2.sin_port); 
  293. sprintf(tmpbuf1,"\r\n########### read from %s:%d ####################\r\n",host1,port1); 
  294. sprintf(tmpbuf2,"\r\n########### reply from %s:%d ####################\r\n",host2,port2); 
  295.  
  296. maxfd=max(fd1,fd2)+1; 
  297. memset(read_in1,0,MAXSIZE); 
  298. memset(read_in2,0,MAXSIZE); 
  299. memset(send_out1,0,MAXSIZE); 
  300. memset(send_out2,0,MAXSIZE); 
  301.  
  302. timeset.tv_sec=TIMEOUT; 
  303. timeset.tv_usec=0; 
  304. while(1) 
  305. FD_ZERO(&am - 
  306.  
  307. FD_ZERO(&writefd); 
  308.  
  309. FD_SET(fd1,&readfd); 
  310. FD_SET(fd1,&writefd); 
  311. FD_SET(fd2,&writefd); 
  312. FD_SET(fd2,&readfd); 
  313.  
  314. result=select(maxfd,&readfd,&writefd,NULL,&timeset); 
  315. if((result<0) && (errno!=EINTR)) 
  316. perror("select error"); 
  317. break
  318. else if(result==0) 
  319. printf("time out\n"); 
  320. break
  321. if(FD_ISSET(fd1,&readfd)) 
  322.  
  323. if(totalread1<MAXSIZE) 
  324. read1=read(fd1,read_in1,MAXSIZE-totalread1); 
  325. if(read1==0) break
  326. if((read1<0) && (errno!=EINTR)) 
  327. perror("read data error"); 
  328. break
  329. memcpy(send_out1+totalread1,read_in1,read1); 
  330. makelog(tmpbuf1,strlen(tmpbuf1)); 
  331. makelog(read_in1,read1); 
  332. totalread1+=read1; 
  333. memset(read_in1,0,MAXSIZE); 
  334. if(FD_ISSET(fd2,&writefd)) 
  335. int err=0; 
  336. sendcount1=0; 
  337. while(totalread1>0) 
  338. send1=write(fd2,send_out1+sendcount1,totalread1); 
  339. if(send1==0)break
  340. if((send1<0) && (errno!=EINTR)) 
  341. perror("unknow error"); 
  342. err=1; 
  343. break
  344. if((send1<0) && (errno==ENOSPC)) break
  345. sendcount1+=send1; 
  346. totalread1-=send1; 
  347. if(err==1) break
  348. if((totalread1>0) && (sendcount1>0)) 
  349.  
  350. memcpy(send_out1,send_out1+sendcount1,totalread1); 
  351. memset(send_out1+totalread1,0,MAXSIZE-totalread1); 
  352. else 
  353. memset(send_out1,0,MAXSIZE); 
  354. if(FD_ISSET(fd2,&readfd)) 
  355.  
  356. if(totalread2<MAXSIZE) 
  357. read2=read(fd2,read_in2,MAXSIZE-totalread2); 
  358. if(read2==0)break
  359. if((read2<0) && (errno!=EINTR)) 
  360. perror("read data error"); 
  361. break
  362. memcpy(send_out2+totalread2,read_in2,read2); 
  363. makelog(tmpbuf2,strlen(tmpbuf2)); 
  364. makelog(read_in2,read2); 
  365. totalread2+=read2; 
  366. memset(read_in2,0,MAXSIZE); 
  367. if(FD_ISSET(fd1,&writefd)) 
  368. int err2=0; 
  369. sendcount2=0; 
  370. while(totalread2>0) 
  371. send2=write(fd1,send_out2+sendcount2,totalread2); 
  372. if(send2==0)break
  373. if((send2<0) && (errno!=EINTR)) 
  374. perror("unknow error"); 
  375. err2=1; 
  376. break
  377. if((send2<0) && (errno==ENOSPC)) break
  378. sendcount2+=send2; 
  379. totalread2-=send2; 
  380. if(err2==1) break
  381. if((totalread2>0) && (sendcount2 > 0)) 
  382.  
  383. memcpy(send_out2,send_out2+sendcount2,totalread2); 
  384. memset(send_out2+totalread2,0,MAXSIZE-totalread2); 
  385. else 
  386. memset(send_out2,0,MAXSIZE); 
  387.  
  388. close(fd1); 
  389. close(fd2); 
  390. printf("ok,I closed the two fd\r\n"); 
  391. exit(0); 
  392.  
  393. void closeallfd() 
  394. int i; 
  395. printf("Let me exit..."); 
  396. fflush(stdout); 
  397. for(i=3;i<256;i++) 
  398. close(i); 
  399. if(fp != NULL) 
  400. fprintf(fp,"exited\r\n"); 
  401. fclose(fp); 
  402. printf("all overd\r\n"); 
  403. exit(0); 
  404. void makelog(char *buffer,int length) 
  405. if(fp !=NULL) 
  406. //fprintf(fp,"%s",buffer); 
  407. write(fileno(fp),buffer,length); 
  408. fflush(fp); 
  409.  
  410. int create_socket() 
  411. int sockfd; 
  412.  
  413. sockfd=socket(AF_INET,SOCK_STREAM,0); 
  414. if(sockfd<0) 
  415. perror("create socket error"); 
  416. return(0); 
  417. return(sockfd); 
  418.  
  419. int create_serv(int sockfd,int port) 
  420. struct sockaddr_in srvaddr; 
  421. int on=1; 
  422.  
  423. bzero(&srvaddr,sizeof(struct sockaddr)); 
  424. srvaddr.sin_port=htons(port); 
  425. srvaddr.sin_family=AF_INET; 
  426. srvaddr.sin_addr.s_addr=htonl(INADDR_ANY); 
  427.  
  428. setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)); //so I can rebind the port 
  429. if(bind(sockfd,(struct sockaddr *)&srvaddr,sizeof(struct sockaddr))<0){perror("error");return(0);} 
  430. if(listen(sockfd,CONNECT_NUMBER)<0){perror("listen error\n");return(0);} 
  431. return(1); 
  432.  
  433. int client_connect(int sockfd,char* server,int port) 
  434. struct sockaddr_in cliaddr; 
  435. struct hostent *host; 
  436.  
  437. if(!(host=gethostbyname(server))){printf("gethostbyname(%s) error:%s\n",server,strerror(errno));return(0);} 
  438.  
  439. bzero(&cliaddr,sizeof(struct sockaddr)); 
  440. cliaddr.sin_family=AF_INET; 
  441. cliaddr.sin_port=htons(port); 
  442. cliaddr.sin_addr=*((struct in_addr *)host->h_addr); 
  443.  
  444. if(connect(sockfd,(struct sockaddr *)&cliaddr,sizeof(struct sockaddr))<0){perror("error");return(0);} 
  445. return(1);