├── .gitignore
├── README.md
├── Unix-like_Version
    └── HTran.c
└── Windows_Version
    └── HTran.cpp


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Compiled Dynamic libraries
12 | *.so
13 | *.dylib
14 | *.dll
15 | 
16 | # Fortran module files
17 | *.mod
18 | 
19 | # Compiled Static libraries
20 | *.lai
21 | *.la
22 | *.a
23 | *.lib
24 | 
25 | # Executables
26 | *.exe
27 | *.out
28 | *.app
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # HTran
 2 |    HTran is a connection bouncer, a kind of proxy server. A “listener” program is hacked stealthily onto an unsuspecting host anywhere on the Internet. When it receives signals from the actual target system, it redirects it to the hacker’s server.
 3 |    HTran have two platform version: Windows and Unix-like(Linux、Unix、etc...)
 4 |    HTran 's Windows version code by lion and bkbll.
 5 |             Ported to Linux/Unix by Hwin.
 6 |        
 7 | ```
 8 |  *       :Plesae open README.md to read complete HTran usage
 9 |  *
10 |  *       : [Usage of Packet Transmit:]
11 |  *       :   HTran -<listen|tran|slave> <option> [-log logfile]
12 |  *       :
13 |  *       : [option:]
14 |  *       :   -listen <ConnectPort> <TransmitPort>
15 |  *       :   -tran   <ConnectPort> <TransmitHost> <TransmitPort>
16 |  *       :   -slave <ConnectHost> <ConnectPort> <TransmitHost> <TransmitPort>
17 | 
18 | Welcome to http://www.cnhonker.com
19 | ```
20 | 
21 | 
22 | `PS: The project is no longer maintained.`
23 | 


--------------------------------------------------------------------------------
/Unix-like_Version/HTran.c:
--------------------------------------------------------------------------------
  1 | /*************************************************************************************
  2 |  *
  3 |  * HTran.cpp - HUC Packet Transmit Tool.
  4 |  *
  5 |  * Copyright (C) 2000-2004 HUC All Rights Reserved.
  6 |  *
  7 |  * Author: lion
  8 |  *       : lion#cnhonker.com
  9 |  *       : http://www.cnhonker.com
 10 |  *       :
 11 |  * Notice: Thx to bkbll (bkbll#cnhonker.com)
 12 |  *       :
 13 |  * Date  : 2003-10-20
 14 |  *       :
 15 |  * Complie : cl HTran.cpp
 16 |  *       :
 17 |  * Usage : E:\>HTran
 18 |  *       : ======================== HUC Packet Transmit Tool V1.00 =======================
 19 |  *       : =========== Code by lion & bkbll, Welcome to http://www.cnhonker.com ==========
 20 |  *       :
 21 |  *       : [Usage of Packet Transmit:]
 22 |  *       :   HTran -<listen|tran|slave> <option> [-log logfile]
 23 |  *       :
 24 |  *       : [option:]
 25 |  *       :   -listen <ConnectPort> <TransmitPort>
 26 |  *       :   -tran   <ConnectPort> <TransmitHost> <TransmitPort>
 27 |  *       :   -slave <ConnectHost> <ConnectPort> <TransmitHost> <TransmitPort>
 28 |  *
 29 |  *************************************************************************************/
 30 | /*
 31 |  * Author: 三只小潴
 32 |  * Date  : 2015-12-3
 33 |  * Modify: Ported to Linux/Unix
 34 |  *
 35 |  *************************************************************************************/
 36 | 
 37 | #include <stdio.h>
 38 | #include <stdlib.h>
 39 | #include <unistd.h>
 40 | #include <string.h>
 41 | #include <errno.h>
 42 | #include <sys/socket.h>
 43 | #include <signal.h>
 44 | #include  <netinet/in.h>
 45 | #include  <arpa/inet.h>
 46 | #include <pthread.h>
 47 | #include <netdb.h>
 48 | 
 49 | 
 50 | #define VERSION                        "1.00"
 51 | #define TIMEOUT                        300
 52 | #define MAXSIZE                        20480
 53 | #define HOSTLEN                        40
 54 | #define CONNECTNUM                     5
 55 | 
 56 | //The following macro increased to modify,but i can't ensure they are correct. by:三只小潴
 57 | #define INVALID_SOCKET                 -1
 58 | #define SOCKET_ERROR                   -1
 59 | typedef unsigned int UINT;
 60 | //------------------------------------------------------------------------------------//
 61 | 
 62 | // define 2 socket struct
 63 | struct transocket
 64 | {
 65 |     int fd1;
 66 |     int fd2;
 67 | };
 68 | 
 69 | // define function
 70 | void ver();
 71 | void usage(char *prog);
 72 | void transmitdata(void *data);
 73 | void getctrlc(int j);
 74 | void closeallfd();
 75 | void makelog(char *buffer, unsigned long length);
 76 | void bind2bind(int port1, int port2);
 77 | void bind2conn(int port1, char *host, int port2);
 78 | void conn2conn(char *host1, int port1, char *host2, int port2);
 79 | int testifisvalue(char *str);
 80 | int create_socket();
 81 | int create_server(int sockfd, int port);
 82 | int client_connect(int sockfd, char* server, int port);
 83 | 
 84 | // define GLOBAL variable here
 85 | extern int errno;
 86 | FILE *fp;
 87 | int method=0;
 88 | //int connectnum=0;
 89 | 
 90 | //************************************************************************************
 91 | //
 92 | // function main
 93 | //
 94 | //************************************************************************************
 95 | int main(int argc, char* argv[])
 96 | {
 97 |     char **p;
 98 |     char sConnectHost[HOSTLEN], sTransmitHost[HOSTLEN];
 99 |     int iConnectPort=0, iTransmitPort=0;
100 |     char *logfile=NULL;
101 |     
102 |     ver();
103 |     memset(sConnectHost, 0, HOSTLEN);
104 |     memset(sTransmitHost, 0, HOSTLEN);
105 |     
106 |     p=argv;
107 |     while(*p)
108 |     {
109 |         if(strcasecmp(*p, "-log") == 0)
110 |         {
111 |             if(testifisvalue(*(p+1)))
112 |             {
113 |                 logfile = *(++p);
114 |             }
115 |             else
116 |             {
117 |                 printf("[-] ERROR: Must supply logfile name.\n\n");
118 |                 return 0;
119 |             }
120 |             p++;
121 |             continue;
122 |         }
123 |         
124 |         p++;
125 |     }
126 |     
127 |     if(logfile !=NULL)
128 |     {
129 |         fp=fopen(logfile,"a");
130 |         if(fp == NULL )
131 |         {
132 |             printf("[-] ERROR: open logfile");
133 |             return 0;
134 |         }
135 |         char temp[22]="====== Start ======\n\n";
136 |         makelog(temp, 22); //C11不允许直接传字符串
137 |     }
138 |     
139 |     /*
140 |      // Win Start Winsock.
141 |      WSADATA wsadata;
142 |      WSAStartup(MAKEWORD(1, 1), &wsadata);
143 |      */
144 |     
145 |     signal(SIGINT, &getctrlc);
146 |     
147 |     if(argc > 2)
148 |     {
149 |         if(strcasecmp(argv[1], "-listen") == 0 && argc >= 4)
150 |         {
151 |             iConnectPort = atoi(argv[2]);
152 |             iTransmitPort = atoi(argv[3]);
153 |             method = 1;
154 |         }
155 |         else
156 |             if(strcasecmp(argv[1], "-tran") == 0 && argc >= 5)
157 |             {
158 |                 iConnectPort = atoi(argv[2]);
159 |                 strncpy(sTransmitHost, argv[3], HOSTLEN);
160 |                 iTransmitPort = atoi(argv[4]);
161 |                 method = 2;
162 |             }
163 |             else
164 |                 if(strcasecmp(argv[1], "-slave") == 0 && argc >= 6)
165 |                 {
166 |                     strncpy(sConnectHost, argv[2], HOSTLEN);
167 |                     iConnectPort = atoi(argv[3]);
168 |                     strncpy(sTransmitHost, argv[4], HOSTLEN);
169 |                     iTransmitPort = atoi(argv[5]);
170 |                     method = 3;
171 |                 }
172 |     }
173 |     
174 |     switch(method)
175 |     {
176 |         case 1:
177 |             bind2bind(iConnectPort, iTransmitPort);
178 |             break;
179 |         case 2:
180 |             bind2conn(iConnectPort, sTransmitHost, iTransmitPort);
181 |             break;
182 |         case 3:
183 |             conn2conn(sConnectHost, iConnectPort, sTransmitHost, iTransmitPort);
184 |             break;
185 |         default:
186 |             usage(argv[0]);
187 |             break;
188 |     }
189 |     
190 |     if(method)
191 |     {
192 |         closeallfd();
193 |     }
194 |     
195 |     //WSACleanup();
196 |     
197 |     return 0;
198 | }
199 | 
200 | 
201 | //************************************************************************************
202 | //
203 | // print version message
204 | //
205 | //************************************************************************************
206 | void ver()
207 | {
208 |     printf("======================== HUC Packet Transmit Tool V%s =======================\n\n", VERSION);
209 |     printf("=========== Code by lion & bkbll, Welcome to http://www.cnhonker.com ==========\n\n");
210 |     printf("======================== Ported to Linux/Unix by 三只小潴 ======================\n\n\n");
211 | }
212 | 
213 | //************************************************************************************
214 | //
215 | // print usage message
216 | //
217 | //************************************************************************************
218 | void usage(char* prog)
219 | {
220 |     printf("[Usage of Packet Transmit:]\n\n");
221 |     printf(" %s -<listen|tran|slave> <option> [-log logfile]\n\n", prog);
222 |     printf("[option:]\n");
223 |     printf(" -listen <ConnectPort> <TransmitPort>\n");
224 |     printf(" -tran   <ConnectPort> <TransmitHost> <TransmitPort>\n");
225 |     printf(" -slave <ConnectHost> <ConnectPort> <TransmitHost> <TransmitPort>\n\n");
226 |     return;
227 | }
228 | 
229 | //************************************************************************************
230 | //
231 | // test if is value
232 | //
233 | //************************************************************************************
234 | int testifisvalue(char *str)
235 | {
236 |     if(str == NULL ) return(0);
237 |     if(str[0]=='-') return(0);
238 |     return(1);
239 | }
240 | 
241 | //************************************************************************************
242 | //
243 | // LocalHost:ConnectPort transmit to LocalHost:TransmitPort
244 | //
245 | //************************************************************************************
246 | void bind2bind(int port1, int port2)
247 | {
248 |     int fd1,fd2, sockfd1, sockfd2;
249 |     struct sockaddr_in client1,client2;
250 |     socklen_t size1,size2;
251 |     
252 |     pthread_t hThread=NULL;
253 |     struct transocket sock;
254 |     //DWORD dwThreadID;
255 |     
256 |     if((fd1=create_socket())==0) return;
257 |     if((fd2=create_socket())==0) return;
258 |     
259 |     printf("[+] Listening port %d ......\n\n",port1);
260 |     fflush(stdout);
261 |     
262 |     if(create_server(fd1, port1)==0)
263 |     {
264 |         close(fd1);
265 |         return;
266 |     }
267 |     
268 |     printf("[+] Listen OK!\n\n");
269 |     printf("[+] Listening port %d ......\n\n",port2);
270 |     fflush(stdout);
271 |     if(create_server(fd2, port2)==0)
272 |     {
273 |         close(fd2);
274 |         return;
275 |     }
276 |     
277 |     printf("[+] Listen OK!\n\n");
278 |     size1=size2=sizeof(struct sockaddr);
279 |     while(1)
280 |     {
281 |         printf("[+] Waiting for Client on port:%d ......\n\n",port1);
282 |         if((sockfd1 = accept(fd1,(struct sockaddr *)&client1,&size1))<0)
283 |         {
284 |             printf("[-] Accept1 error.\n\n");
285 |             continue;
286 |         }
287 |         
288 |         printf("[+] Accept a Client on port %d from %s ......\n\n", port1, inet_ntoa(client1.sin_addr));
289 |         printf("[+] Waiting another Client on port:%d....\n\n", port2);
290 |         if((sockfd2 = accept(fd2, (struct sockaddr *)&client2, &size2))<0)
291 |         {
292 |             printf("[-] Accept2 error.\n\n");
293 |             close(sockfd1);
294 |             continue;
295 |         }
296 |         
297 |         printf("[+] Accept a Client on port %d from %s\n\n",port2, inet_ntoa(client2.sin_addr));
298 |         printf("[+] Accept Connect OK!\n\n");
299 |         
300 |         sock.fd1 = sockfd1;
301 |         sock.fd2 = sockfd2;
302 |         
303 |         //hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
304 |         pthread_create(&hThread, NULL, (void *)&transmitdata, (void *)&sock);
305 |         if(hThread == NULL)
306 |         {
307 |             pthread_cancel(hThread);
308 |             return;
309 |         }
310 |         
311 |         sleep(0);
312 |         printf("[+] CreateThread OK!\n\n\n");
313 |     }
314 | }
315 | 
316 | //************************************************************************************
317 | //
318 | // LocalHost:ConnectPort transmit to TransmitHost:TransmitPort
319 | //
320 | //************************************************************************************
321 | void bind2conn(int port1, char *host, int port2)
322 | {
323 |     int sockfd,sockfd1,sockfd2;
324 |     struct sockaddr_in remote;
325 |     socklen_t size;
326 |     char buffer[1024];
327 |     
328 |     pthread_t hThread=NULL;
329 |     struct transocket sock;
330 |     //DWORD dwThreadID;
331 |     
332 |     if (port1 > 65535 || port1 < 1)
333 |     {
334 |         printf("[-] ConnectPort invalid.\n\n");
335 |         return;
336 |     }
337 |     
338 |     if (port2 > 65535 || port2 < 1)
339 |     {
340 |         printf("[-] TransmitPort invalid.\n\n");
341 |         return;
342 |     }
343 |     
344 |     memset(buffer,0,1024);
345 |     
346 |     if((sockfd=create_socket()) == INVALID_SOCKET) return;
347 |     
348 |     if(create_server(sockfd, port1) == 0)
349 |     {
350 |         close(sockfd);
351 |         return;
352 |     }
353 |     
354 |     size=sizeof(struct sockaddr);
355 |     while(1)
356 |     {
357 |         printf("[+] Waiting for Client ......\n\n");
358 |         if((sockfd1=accept(sockfd,(struct sockaddr *)&remote,&size))<0)
359 |         {
360 |             printf("[-] Accept error.\n\n");
361 |             continue;
362 |         }
363 |         
364 |         printf("[+] Accept a Client from %s:%d ......\n\n",
365 |                inet_ntoa(remote.sin_addr), ntohs(remote.sin_port));
366 |         if((sockfd2=create_socket())==0)
367 |         {
368 |             close(sockfd1);
369 |             continue;
370 |         }
371 |         printf("[+] Make a Connection to %s:%d ......\n\n",host,port2);
372 |         fflush(stdout);
373 |         
374 |         if(client_connect(sockfd2,host,port2)==0)
375 |         {
376 |             close(sockfd2);
377 |             sprintf(buffer,"[SERVER]connection to %s:%d error\n\n", host, port2);
378 |             send(sockfd1,buffer,strlen(buffer),0);
379 |             memset(buffer, 0, 1024);
380 |             close(sockfd1);
381 |             continue;
382 |         }
383 |         
384 |         printf("[+] Connect OK!\n\n");
385 |         
386 |         sock.fd1 = sockfd1;
387 |         sock.fd2 = sockfd2;
388 |         
389 |         //hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
390 |         pthread_create(&hThread, NULL, (void *)&transmitdata, (void *)&sock);
391 |         if(hThread == NULL)
392 |         {
393 |             pthread_cancel(hThread);
394 |             return;
395 |         }
396 |         
397 |         sleep(0);
398 |         printf("[+] CreateThread OK!\n\n\n");
399 |     }
400 | }
401 | 
402 | //************************************************************************************
403 | //
404 | // ConnectHost:ConnectPort transmit to TransmitHost:TransmitPort
405 | //
406 | //************************************************************************************
407 | void conn2conn(char *host1,int port1,char *host2,int port2)
408 | {
409 |     int sockfd1,sockfd2;
410 |     
411 |     pthread_t hThread=NULL;
412 |     struct transocket sock;
413 |     //DWORD dwThreadID;
414 |     fd_set fds;
415 |     long l;
416 |     char buffer[MAXSIZE];
417 |     
418 |     while(1)
419 |     {
420 |         /*
421 |          while(connectnum)
422 |          {
423 |          if(connectnum < CONNECTNUM)
424 |          {
425 |          Sleep(10000);
426 |          break;
427 |          }
428 |          else
429 |          {
430 |          Sleep(TIMEOUT*1000);
431 |          continue;
432 |          }
433 |          }
434 |          */
435 |         
436 |         if((sockfd1=create_socket())==0) return;
437 |         if((sockfd2=create_socket())==0) return;
438 |         
439 |         printf("[+] Make a Connection to %s:%d....\n\n",host1,port1);
440 |         fflush(stdout);
441 |         if(client_connect(sockfd1,host1,port1)==0)
442 |         {
443 |             close(sockfd1);
444 |             close(sockfd2);
445 |             continue;
446 |         }
447 |         
448 |         // fix by bkbll
449 |         // if host1:port1 recved data, than connect to host2,port2
450 |         l=0;
451 |         memset(buffer,0,MAXSIZE);
452 |         while(1)
453 |         {
454 |             FD_ZERO(&fds);
455 |             FD_SET(sockfd1, &fds);
456 |             
457 |             if (select(sockfd1+1, &fds, NULL, NULL, NULL) == INVALID_SOCKET)
458 |             {
459 |                 if (errno == EINTR) continue; //replace WSAEINTR to EINTR
460 |                 break;
461 |             }
462 |             if (FD_ISSET(sockfd1, &fds))
463 |             {
464 |                 l=recv(sockfd1, buffer, MAXSIZE, 0);
465 |                 break;
466 |             }
467 |             sleep(0);
468 |         }
469 |         
470 |         if(l<=0)
471 |         {
472 |             printf("[-] There is a error...Create a new connection.\n\n");
473 |             continue;
474 |         }
475 |         while(1)
476 |         {
477 |             printf("[+] Connect OK!\n\n");
478 |             printf("[+] Make a Connection to %s:%d....\n\n", host2,port2);
479 |             fflush(stdout);
480 |             if(client_connect(sockfd2,host2,port2)==0)
481 |             {
482 |                 close(sockfd1);
483 |                 close(sockfd2);
484 |                 continue;
485 |             }
486 |             
487 |             if(send(sockfd2,buffer,l,0)==SOCKET_ERROR)
488 |             {
489 |                 printf("[-] Send failed.\n\n");
490 |                 continue;
491 |             }
492 |             
493 |             l=0;
494 |             memset(buffer,0,MAXSIZE);
495 |             break;
496 |         }
497 |         
498 |         printf("[+] All Connect OK!\n\n");
499 |         
500 |         sock.fd1 = sockfd1;
501 |         sock.fd2 = sockfd2;
502 |         
503 |         //hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
504 |         pthread_create(&hThread, NULL, (void *)&transmitdata, (void *)&sock);
505 |         if(hThread == NULL)
506 |         {
507 |             pthread_cancel(hThread);
508 |             return;
509 |         }
510 |         
511 |         //            connectnum++;
512 |         
513 |         sleep(0);
514 |         printf("[+] CreateThread OK!\n\n\n");
515 |     }
516 | }
517 | 
518 | //************************************************************************************
519 | //
520 | // Socket Transmit to Socket
521 | //
522 | //************************************************************************************
523 | void transmitdata(void *data)
524 | {
525 |     int fd1, fd2;
526 |     struct transocket *sock;
527 |     struct timeval timeset;
528 |     fd_set readfd,writefd;
529 |     int result;
530 |     char read_in1[MAXSIZE],send_out1[MAXSIZE];
531 |     char read_in2[MAXSIZE],send_out2[MAXSIZE];
532 |     int read1=0,send1=0;
533 |     int read2=0,send2=0;
534 |     size_t totalread1=0,totalread2=0;
535 |     int sendcount1,sendcount2;
536 |     int maxfd;
537 |     struct sockaddr_in client1,client2;
538 |     socklen_t structsize1,structsize2;
539 |     char host1[20],host2[20];
540 |     int port1=0,port2=0;
541 |     char tmpbuf[100];
542 |     
543 |     sock = (struct transocket *)data;
544 |     fd1 = sock->fd1;
545 |     fd2 = sock->fd2;
546 |     
547 |     memset(host1,0,20);
548 |     memset(host2,0,20);
549 |     memset(tmpbuf,0,100);
550 |     
551 |     structsize1=sizeof(struct sockaddr);
552 |     structsize2=sizeof(struct sockaddr);
553 |     
554 |     if(getpeername(fd1,(struct sockaddr *)&client1,&structsize1)<0)
555 |     {
556 |         strcpy(host1, "fd1");
557 |     }
558 |     else
559 |     {
560 |         //            printf("[+]got, ip:%s, port:%d\n\n",inet_ntoa(client1.sin_addr),ntohs(client1.sin_port));
561 |         strcpy(host1, inet_ntoa(client1.sin_addr));
562 |         port1=ntohs(client1.sin_port);
563 |     }
564 |     
565 |     if(getpeername(fd2,(struct sockaddr *)&client2,&structsize2)<0)
566 |     {
567 |         strcpy(host2,"fd2");
568 |     }
569 |     else
570 |     {
571 |         //            printf("[+]got, ip:%s, port:%d\n\n",inet_ntoa(client2.sin_addr),ntohs(client2.sin_port));
572 |         strcpy(host2, inet_ntoa(client2.sin_addr));
573 |         port2=ntohs(client2.sin_port);
574 |     }
575 |     
576 |     printf("[+] Start Transmit (%s:%d <-> %s:%d) ......\n\n\n", host1, port1, host2, port2);
577 |     
578 |     maxfd=fd1>fd2?fd1+1:fd2+1;
579 |     //maxfd=max(fd1,fd2)+1;
580 |     memset(read_in1,0,MAXSIZE);
581 |     memset(read_in2,0,MAXSIZE);
582 |     memset(send_out1,0,MAXSIZE);
583 |     memset(send_out2,0,MAXSIZE);
584 |     
585 |     timeset.tv_sec=TIMEOUT;
586 |     timeset.tv_usec=0;
587 |     
588 |     while(1)
589 |     {
590 |         FD_ZERO(&readfd);
591 |         FD_ZERO(&writefd);
592 |         
593 |         FD_SET((UINT)fd1, &readfd);
594 |         FD_SET((UINT)fd1, &writefd);
595 |         FD_SET((UINT)fd2, &writefd);
596 |         FD_SET((UINT)fd2, &readfd);
597 |         
598 |         result=select(maxfd,&readfd,&writefd,NULL,&timeset);
599 |         if((result<0) && (errno!=EINTR))
600 |         {
601 |             printf("[-] Select error.\n\n");
602 |             break;
603 |         }
604 |         else if(result==0)
605 |         {
606 |             printf("[-] Socket time out.\n\n");
607 |             break;
608 |         }
609 |         
610 |         if(FD_ISSET(fd1, &readfd))
611 |         {
612 |             /* must < MAXSIZE-totalread1, otherwise send_out1 will flow */
613 |             if(totalread1<MAXSIZE)
614 |             {
615 |                 read1=recv(fd1, read_in1, MAXSIZE-totalread1, 0);
616 |                 if((read1==SOCKET_ERROR) || (read1==0))
617 |                 {
618 |                     printf("[-] Read fd1 data error,maybe close?\n\n");
619 |                     break;
620 |                 }
621 |                 
622 |                 memcpy(send_out1+totalread1,read_in1,read1);
623 |                 sprintf(tmpbuf,"\n\nRecv %5d bytes from %s:%d\n\n", read1, host1, port1);
624 |                 printf(" Recv %5d bytes %16s:%d\n\n", read1, host1, port1);
625 |                 makelog(tmpbuf,strlen(tmpbuf));
626 |                 makelog(read_in1,read1);
627 |                 totalread1+=read1;
628 |                 memset(read_in1,0,MAXSIZE);
629 |             }
630 |         }
631 |         
632 |         if(FD_ISSET(fd2, &writefd))
633 |         {
634 |             int err=0;
635 |             sendcount1=0;
636 |             while(totalread1>0)
637 |             {
638 |                 send1=send(fd2, send_out1+sendcount1, totalread1, 0);
639 |                 if(send1==0)break;
640 |                 if((send1<0) && (errno!=EINTR))
641 |                 {
642 |                     printf("[-] Send to fd2 unknow error.\n\n");
643 |                     err=1;
644 |                     break;
645 |                 }
646 |                 
647 |                 if((send1<0) && (errno==ENOSPC)) break;
648 |                 sendcount1+=send1;
649 |                 totalread1-=send1;
650 |                 
651 |                 printf(" Send %5d bytes %16s:%d\n\n", send1, host2, port2);
652 |             }
653 |             
654 |             if(err==1) break;
655 |             if((totalread1>0) && (sendcount1>0))
656 |             {
657 |                 /* move not sended data to start addr */
658 |                 memcpy(send_out1,send_out1+sendcount1,totalread1);
659 |                 memset(send_out1+totalread1,0,MAXSIZE-totalread1);
660 |             }
661 |             else
662 |                 memset(send_out1,0,MAXSIZE);
663 |         }
664 |         
665 |         if(FD_ISSET(fd2, &readfd))
666 |         {
667 |             if(totalread2<MAXSIZE)
668 |             {
669 |                 read2=recv(fd2,read_in2,MAXSIZE-totalread2, 0);
670 |                 if(read2==0)break;
671 |                 if((read2<0) && (errno!=EINTR))
672 |                 {
673 |                     printf("[-] Read fd2 data error,maybe close?\n\n\n\n");
674 |                     break;
675 |                 }
676 |                 
677 |                 memcpy(send_out2+totalread2,read_in2,read2);
678 |                 sprintf(tmpbuf, "\n\nRecv %5d bytes from %s:%d\n\n", read2, host2, port2);
679 |                 printf(" Recv %5d bytes %16s:%d\n\n", read2, host2, port2);
680 |                 makelog(tmpbuf,strlen(tmpbuf));
681 |                 makelog(read_in2,read2);
682 |                 totalread2+=read2;
683 |                 memset(read_in2,0,MAXSIZE);
684 |             }
685 |         }
686 |         
687 |         if(FD_ISSET(fd1, &writefd))
688 |         {
689 |             int err2=0;
690 |             sendcount2=0;
691 |             while(totalread2>0)
692 |             {
693 |                 send2=send(fd1, send_out2+sendcount2, totalread2, 0);
694 |                 if(send2==0)break;
695 |                 if((send2<0) && (errno!=EINTR))
696 |                 {
697 |                     printf("[-] Send to fd1 unknow error.\n\n");
698 |                     err2=1;
699 |                     break;
700 |                 }
701 |                 if((send2<0) && (errno==ENOSPC)) break;
702 |                 sendcount2+=send2;
703 |                 totalread2-=send2;
704 |                 
705 |                 printf(" Send %5d bytes %16s:%d\n\n", send2, host1, port1);
706 |             }
707 |             if(err2==1) break;
708 |             if((totalread2>0) && (sendcount2 > 0))
709 |             {
710 |                 /* move not sended data to start addr */
711 |                 memcpy(send_out2, send_out2+sendcount2, totalread2);
712 |                 memset(send_out2+totalread2, 0, MAXSIZE-totalread2);
713 |             }
714 |             else
715 |                 memset(send_out2,0,MAXSIZE);
716 |         }
717 |         
718 |         sleep(0);
719 |     }
720 |     
721 |     close(fd1);
722 |     close(fd2);
723 |     //      if(method == 3)
724 |     //            connectnum --;
725 |     
726 |     printf("\n\n[+] OK! I Closed The Two Socket.\n\n");
727 | }
728 | 
729 | void getctrlc(int j)
730 | {
731 |     printf("\n\n[-] Received Ctrl+C\n\n");
732 |     closeallfd();
733 |     exit(0);
734 | }
735 | 
736 | void closeallfd()
737 | {
738 |     int i;
739 |     
740 |     printf("[+] Let me exit ......\n\n");
741 |     fflush(stdout);
742 |     
743 |     for(i=3; i<256; i++)
744 |     {
745 |         close(i);
746 |     }
747 |     
748 |     if(fp != NULL)
749 |     {
750 |         fprintf(fp,"\n\n====== Exit ======\n\n");
751 |         fclose(fp);
752 |     }
753 |     
754 |     printf("[+] All Right!\n\n");
755 | }
756 | 
757 | int create_socket()
758 | {
759 |     int sockfd;
760 |     sockfd=socket(AF_INET,SOCK_STREAM,0);
761 |     if(sockfd<0)
762 |     {
763 |         printf("[-] Create socket error.\n\n");
764 |         return(0);
765 |     }
766 |     
767 |     return(sockfd);
768 | }
769 | 
770 | int create_server(int sockfd,int port)
771 | {
772 |     struct sockaddr_in srvaddr;
773 |     int on=1;
774 |     
775 |     memset(&srvaddr, 0, sizeof(struct sockaddr));
776 |     
777 |     srvaddr.sin_port=htons(port);
778 |     srvaddr.sin_family=AF_INET;
779 |     srvaddr.sin_addr.s_addr=htonl(INADDR_ANY);
780 |     
781 |     setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR, (char*)&on,sizeof(on)); //so I can rebind the port
782 |     
783 |     if(bind(sockfd,(struct sockaddr *)&srvaddr,sizeof(struct sockaddr))<0)
784 |     {
785 |         printf("[-] Socket bind error.\n\n");
786 |         return(0);
787 |     }
788 |     
789 |     if(listen(sockfd,CONNECTNUM)<0)
790 |     {
791 |         printf("[-] Socket Listen error.\n\n");
792 |         return(0);
793 |     }
794 |     
795 |     return(1);
796 | }
797 | 
798 | int client_connect(int sockfd,char* server,int port)
799 | {
800 |     struct sockaddr_in cliaddr;
801 |     struct hostent *host;
802 |     
803 |     if(!(host=gethostbyname(server)))
804 |     {
805 |         printf("[-] Gethostbyname(%s) error:%s\n",server,strerror(errno));
806 |         return(0);
807 |     }
808 |     
809 |     memset(&cliaddr, 0, sizeof(struct sockaddr));
810 |     cliaddr.sin_family=AF_INET;
811 |     cliaddr.sin_port=htons(port);
812 |     cliaddr.sin_addr=*((struct in_addr *)host->h_addr);
813 |     
814 |     if(connect(sockfd,(struct sockaddr *)&cliaddr,sizeof(struct sockaddr))<0)
815 |     {
816 |         printf("[-] Connect error.\n\n");
817 |         return(0);
818 |     }
819 |     return(1);
820 | }
821 | 
822 | void makelog(char *buffer,unsigned long length)
823 | {
824 |     if(fp !=NULL)
825 |     {
826 |         //            fprintf(fp, "%s", buffer);
827 |         //            printf("%s",buffer);
828 |         write(fileno(fp),buffer,length);
829 |         //            fflush(fp);
830 |     }
831 | }
832 | 


--------------------------------------------------------------------------------
/Windows_Version/HTran.cpp:
--------------------------------------------------------------------------------
  1 | /*************************************************************************************
  2 | *
  3 | * HTran.cpp - HUC Packet Transmit Tool.
  4 | *
  5 | * Copyright (C) 2000-2004 HUC All Rights Reserved.
  6 | *
  7 | * Author   : lion
  8 | *       : lion#cnhonker.net
  9 | *       : http://www.cnhonker.com
 10 | *       :
 11 | * Notice   : Thx to bkbll (bkbll#cnhonker.net)
 12 | *       :
 13 | * Date   : 2003-10-20
 14 | *       :
 15 | * Complie : cl HTran.cpp
 16 | *       :
 17 | * Usage   : E:\>HTran
 18 | *       : ======================== HUC Packet Transmit Tool V1.00 =======================
 19 | *       : =========== Code by lion & bkbll, Welcome to http://www.cnhonker.com ==========
 20 | *       :
 21 | *       : [Usage of Packet Transmit:]
 22 | *       :   HTran -<listen|tran|slave> <option> [-log logfile]
 23 | *       :
 24 | *       : [option:]
 25 | *       :   -listen <ConnectPort> <TransmitPort>
 26 | *       :   -tran   <ConnectPort> <TransmitHost> <TransmitPort>
 27 | *       :   -slave <ConnectHost> <ConnectPort> <TransmitHost> <TransmitPort>
 28 | *
 29 | *************************************************************************************/
 30 | 
 31 | #include <stdio.h>
 32 | #include <stdlib.h>
 33 | #include <errno.h>
 34 | #include <winsock2.h>
 35 | #include <io.h>
 36 | #include <signal.h>
 37 | 
 38 | #pragma comment(lib, "ws2_32.lib")
 39 | 
 40 | #define VERSION                        "1.00"
 41 | #define TIMEOUT                        300
 42 | #define MAXSIZE                        20480
 43 | #define HOSTLEN                        40
 44 | #define CONNECTNUM                  5
 45 | 
 46 | // define 2 socket struct
 47 | struct transocket
 48 | {
 49 |      SOCKET fd1;
 50 |      SOCKET fd2;
 51 | };
 52 | 
 53 | // define function
 54 | void ver();
 55 | void usage(char *prog);
 56 | void transmitdata(LPVOID data);
 57 | void getctrlc(int j);
 58 | void closeallfd();
 59 | void makelog(char *buffer, int length);
 60 | void proxy(int port);
 61 | void bind2bind(int port1, int port2);
 62 | void bind2conn(int port1, char *host, int port2);
 63 | void conn2conn(char *host1, int port1, char *host2, int port2);
 64 | int testifisvalue(char *str);
 65 | int create_socket();
 66 | int create_server(int sockfd, int port);
 67 | int client_connect(int sockfd, char* server, int port);
 68 | 
 69 | // define GLOBAL variable here
 70 | extern int errno;
 71 | FILE *fp;
 72 | int method=0;
 73 | //int connectnum=0;
 74 | 
 75 | //************************************************************************************
 76 | //
 77 | // function main
 78 | //
 79 | //************************************************************************************
 80 | VOID main(int argc, char* argv[])
 81 | {
 82 |      char **p;
 83 |      char sConnectHost[HOSTLEN], sTransmitHost[HOSTLEN];
 84 |      int iConnectPort=0, iTransmitPort=0;
 85 |      char *logfile=NULL;
 86 | 
 87 |      ver();
 88 |      memset(sConnectHost, 0, HOSTLEN);
 89 |      memset(sTransmitHost, 0, HOSTLEN);
 90 | 
 91 |      p=argv;
 92 |      while(*p)
 93 |      {
 94 |            if(stricmp(*p, "-log") == 0)
 95 |            {
 96 |                  if(testifisvalue(*(p+1)))
 97 |                  {
 98 |                        logfile = *(++p);
 99 |                  }      
100 |                  else
101 |                  {
102 |                        printf("[-] ERROR: Must supply logfile name.\r\n");
103 |                        return;
104 |                  }
105 |                  p++;
106 |                  continue;
107 |            }
108 |            
109 |            p++;
110 |      }
111 | 
112 |      if(logfile !=NULL)
113 |      {
114 |            fp=fopen(logfile,"a");
115 |            if(fp == NULL )
116 |            {
117 |                  printf("[-] ERROR: open logfile");
118 |                  return;
119 |            }
120 | 
121 |            makelog("====== Start ======\r\n", 22);
122 |      }
123 | 
124 | 
125 |      // Win Start Winsock.
126 |      WSADATA wsadata;
127 |      WSAStartup(MAKEWORD(1, 1), &wsadata);
128 | 
129 |      signal(SIGINT, &getctrlc);
130 | 
131 |      if(argc > 2)
132 |      {
133 |            if(stricmp(argv[1], "-listen") == 0 && argc >= 4)
134 |            {
135 |                  iConnectPort = atoi(argv[2]);
136 |                  iTransmitPort = atoi(argv[3]);
137 |                  method = 1;
138 |            }
139 |            else
140 |            if(stricmp(argv[1], "-tran") == 0 && argc >= 5)
141 |            {
142 |                  iConnectPort = atoi(argv[2]);
143 |                  strncpy(sTransmitHost, argv[3], HOSTLEN);
144 |                  iTransmitPort = atoi(argv[4]);
145 |                  method = 2;
146 |            }
147 |            else
148 |            if(stricmp(argv[1], "-slave") == 0 && argc >= 6)
149 |            {
150 |                  strncpy(sConnectHost, argv[2], HOSTLEN);
151 |                  iConnectPort = atoi(argv[3]);
152 |                  strncpy(sTransmitHost, argv[4], HOSTLEN);
153 |                  iTransmitPort = atoi(argv[5]);
154 |                  method = 3;
155 |            }
156 |      }
157 | 
158 |      switch(method)
159 |      {
160 |      case 1:
161 |            bind2bind(iConnectPort, iTransmitPort);
162 |            break;
163 |      case 2:
164 |            bind2conn(iConnectPort, sTransmitHost, iTransmitPort);
165 |            break;
166 |      case 3:
167 |            conn2conn(sConnectHost, iConnectPort, sTransmitHost, iTransmitPort);
168 |            break;
169 |      default:
170 |            usage(argv[0]);
171 |            break;
172 |      }
173 |      
174 |      if(method)
175 |      {
176 |            closeallfd();
177 |      }
178 | 
179 |      WSACleanup();
180 | 
181 |      return;
182 | }
183 | 
184 | 
185 | //************************************************************************************
186 | //
187 | // print version message
188 | //
189 | //************************************************************************************
190 | VOID ver()
191 | {      
192 |      printf("======================== HUC Packet Transmit Tool V%s =======================\r\n", VERSION);
193 |      printf("=========== Code by lion & bkbll, Welcome to http://www.cnhonker.com ==========\r\n\n");
194 | }
195 | 
196 | //************************************************************************************
197 | //
198 | // print usage message
199 | //
200 | //************************************************************************************
201 | VOID usage(char* prog)
202 | {      
203 |      printf("[Usage of Packet Transmit:]\r\n");
204 |      printf(" %s -<listen|tran|slave> <option> [-log logfile]\n\n", prog);
205 |      printf("[option:]\n");
206 |      printf(" -listen <ConnectPort> <TransmitPort>\n");
207 |      printf(" -tran   <ConnectPort> <TransmitHost> <TransmitPort>\n");
208 |      printf(" -slave <ConnectHost> <ConnectPort> <TransmitHost> <TransmitPort>\n\n");
209 |      return;
210 | }
211 | 
212 | //************************************************************************************
213 | //
214 | // test if is value
215 | //
216 | //************************************************************************************
217 | int testifisvalue(char *str)
218 | {
219 |      if(str == NULL ) return(0);
220 |      if(str[0]=='-') return(0);
221 |      return(1);
222 | }
223 | 
224 | //************************************************************************************
225 | //
226 | // LocalHost:ConnectPort transmit to LocalHost:TransmitPort
227 | //
228 | //************************************************************************************
229 | void bind2bind(int port1, int port2)
230 | {
231 |      SOCKET fd1,fd2, sockfd1, sockfd2;
232 |      struct sockaddr_in client1,client2;
233 |      int size1,size2;
234 | 
235 |      HANDLE hThread=NULL;
236 |      transocket sock;
237 |      DWORD dwThreadID;
238 |            
239 |      if((fd1=create_socket())==0) return;
240 |      if((fd2=create_socket())==0) return;
241 | 
242 |      printf("[+] Listening port %d ......\r\n",port1);
243 |      fflush(stdout);
244 | 
245 |      if(create_server(fd1, port1)==0)
246 |      {
247 |            closesocket(fd1);
248 |            return;
249 |      }
250 | 
251 |      printf("[+] Listen OK!\r\n");
252 |      printf("[+] Listening port %d ......\r\n",port2);
253 |      fflush(stdout);
254 |      if(create_server(fd2, port2)==0)
255 |      {
256 |            closesocket(fd2);
257 |            return;
258 |      }
259 | 
260 |      printf("[+] Listen OK!\r\n");
261 |      size1=size2=sizeof(struct sockaddr);
262 |      while(1)
263 |      {
264 |            printf("[+] Waiting for Client on port:%d ......\r\n",port1);
265 |            if((sockfd1 = accept(fd1,(struct sockaddr *)&client1,&size1))<0)
266 |            {
267 |                  printf("[-] Accept1 error.\r\n");
268 |                  continue;
269 |            }
270 | 
271 |            printf("[+] Accept a Client on port %d from %s ......\r\n", port1, inet_ntoa(client1.sin_addr));
272 |            printf("[+] Waiting another Client on port:%d....\r\n", port2);
273 |              if((sockfd2 = accept(fd2, (struct sockaddr *)&client2, &size2))<0)
274 |              {
275 |                    printf("[-] Accept2 error.\r\n");
276 |                    closesocket(sockfd1);
277 |                    continue;
278 |              }
279 | 
280 |            printf("[+] Accept a Client on port %d from %s\r\n",port2, inet_ntoa(client2.sin_addr));
281 |            printf("[+] Accept Connect OK!\r\n");
282 | 
283 |            sock.fd1 = sockfd1;
284 |            sock.fd2 = sockfd2;
285 | 
286 |            hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
287 |            if(hThread == NULL)
288 |            {
289 |                  TerminateThread(hThread, 0);
290 |                  return;
291 |            }
292 | 
293 |            Sleep(1000);
294 |            printf("[+] CreateThread OK!\r\n\n");
295 |       }
296 | }
297 | 
298 | //************************************************************************************
299 | //
300 | // LocalHost:ConnectPort transmit to TransmitHost:TransmitPort
301 | //
302 | //************************************************************************************
303 | void bind2conn(int port1, char *host, int port2)
304 | {
305 |      SOCKET sockfd,sockfd1,sockfd2;
306 |      struct sockaddr_in remote;
307 |      int size;
308 |      char buffer[1024];
309 | 
310 |      HANDLE hThread=NULL;
311 |      transocket sock;
312 |      DWORD dwThreadID;
313 | 
314 |      if (port1 > 65535 || port1 < 1)
315 |      {
316 |            printf("[-] ConnectPort invalid.\r\n");
317 |            return;
318 |      }
319 | 
320 |      if (port2 > 65535 || port2 < 1)
321 |      {
322 |            printf("[-] TransmitPort invalid.\r\n");
323 |            return;
324 |      }
325 |      
326 |      memset(buffer,0,1024);
327 | 
328 |      if((sockfd=create_socket()) == INVALID_SOCKET) return;
329 | 
330 |      if(create_server(sockfd, port1) == 0)
331 |      {
332 |            closesocket(sockfd);
333 |            return;
334 |      }
335 |      
336 |      size=sizeof(struct sockaddr);
337 |      while(1)
338 |      {
339 |            printf("[+] Waiting for Client ......\r\n");      
340 |            if((sockfd1=accept(sockfd,(struct sockaddr *)&remote,&size))<0)
341 |            {
342 |                  printf("[-] Accept error.\r\n");
343 |                  continue;
344 |            }
345 | 
346 |            printf("[+] Accept a Client from %s:%d ......\r\n",
347 |            inet_ntoa(remote.sin_addr), ntohs(remote.sin_port));
348 |              if((sockfd2=create_socket())==0)
349 |              {
350 |                    closesocket(sockfd1);
351 |                    continue;      
352 |              }
353 |              printf("[+] Make a Connection to %s:%d ......\r\n",host,port2);
354 |              fflush(stdout);
355 | 
356 |            if(client_connect(sockfd2,host,port2)==0)
357 |            {
358 |                  closesocket(sockfd2);
359 |                  sprintf(buffer,"[SERVER]connection to %s:%d error\r\n", host, port2);
360 |                  send(sockfd1,buffer,strlen(buffer),0);
361 |                  memset(buffer, 0, 1024);
362 |                  closesocket(sockfd1);
363 |                  continue;
364 |            }
365 |            
366 |            printf("[+] Connect OK!\r\n");
367 | 
368 |            sock.fd1 = sockfd1;
369 |            sock.fd2 = sockfd2;
370 | 
371 |            hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
372 |            if(hThread == NULL)
373 |            {
374 |                  TerminateThread(hThread, 0);
375 |                  return;
376 |            }
377 | 
378 |            Sleep(1000);
379 |            printf("[+] CreateThread OK!\r\n\n");
380 |      }
381 | }
382 | 
383 | //************************************************************************************
384 | //
385 | // ConnectHost:ConnectPort transmit to TransmitHost:TransmitPort
386 | //
387 | //************************************************************************************
388 | void conn2conn(char *host1,int port1,char *host2,int port2)
389 | {
390 |      SOCKET sockfd1,sockfd2;
391 |      
392 |      HANDLE hThread=NULL;
393 |      transocket sock;
394 |      DWORD dwThreadID;
395 |      fd_set fds;
396 |      int l;
397 |      char buffer[MAXSIZE];
398 | 
399 |      while(1)
400 |      {
401 | /*
402 |            while(connectnum)
403 |            {
404 |                  if(connectnum < CONNECTNUM)
405 |                  {
406 |                        Sleep(10000);
407 |                        break;
408 |                  }
409 |                  else
410 |                  {
411 |                        Sleep(TIMEOUT*1000);
412 |                        continue;
413 |                  }            
414 |            }
415 | */
416 |            
417 |            if((sockfd1=create_socket())==0) return;
418 |            if((sockfd2=create_socket())==0) return;
419 | 
420 |            printf("[+] Make a Connection to %s:%d....\r\n",host1,port1);
421 |            fflush(stdout);
422 |            if(client_connect(sockfd1,host1,port1)==0)
423 |            {
424 |                  closesocket(sockfd1);
425 |                  closesocket(sockfd2);
426 |                  continue;
427 |            }
428 |            
429 |            // fix by bkbll
430 |            // if host1:port1 recved data, than connect to host2,port2
431 |            l=0;
432 |            memset(buffer,0,MAXSIZE);
433 |            while(1)
434 |            {
435 |                  FD_ZERO(&fds);
436 |                  FD_SET(sockfd1, &fds);
437 |                  
438 |                  if (select(sockfd1+1, &fds, NULL, NULL, NULL) == SOCKET_ERROR)
439 |                  {
440 |                        if (errno == WSAEINTR) continue;
441 |                        break;
442 |                  }
443 |                  if (FD_ISSET(sockfd1, &fds))
444 |                  {
445 |                        l=recv(sockfd1, buffer, MAXSIZE, 0);
446 |                        break;
447 |                  }
448 |                  Sleep(5);
449 |            }
450 | 
451 |            if(l<=0)
452 |            {      
453 |                  printf("[-] There is a error...Create a new connection.\r\n");
454 |                  continue;
455 |            }
456 |            while(1)
457 |            {
458 |                  printf("[+] Connect OK!\r\n");
459 |                  printf("[+] Make a Connection to %s:%d....\r\n", host2,port2);
460 |                  fflush(stdout);
461 |                  if(client_connect(sockfd2,host2,port2)==0)
462 |                  {
463 |                        closesocket(sockfd1);
464 |                        closesocket(sockfd2);
465 |                        continue;
466 |                  }
467 | 
468 |                  if(send(sockfd2,buffer,l,0)==SOCKET_ERROR)
469 |                  {      
470 |                        printf("[-] Send failed.\r\n");
471 |                        continue;
472 |                  }
473 | 
474 |                  l=0;
475 |                  memset(buffer,0,MAXSIZE);
476 |                  break;
477 |            }
478 |      
479 |            printf("[+] All Connect OK!\r\n");
480 | 
481 |            sock.fd1 = sockfd1;
482 |            sock.fd2 = sockfd2;
483 | 
484 |            hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
485 |            if(hThread == NULL)
486 |            {
487 |                  TerminateThread(hThread, 0);
488 |                  return;
489 |            }
490 | 
491 | //            connectnum++;
492 | 
493 |            Sleep(1000);
494 |            printf("[+] CreateThread OK!\r\n\n");
495 |      }
496 | }
497 | 
498 | //************************************************************************************
499 | //
500 | // Socket Transmit to Socket
501 | //
502 | //************************************************************************************
503 | void transmitdata(LPVOID data)
504 | {
505 |      SOCKET fd1, fd2;
506 |      transocket *sock;
507 |      struct timeval timeset;
508 |      fd_set readfd,writefd;
509 |      int result,i=0;
510 |      char read_in1[MAXSIZE],send_out1[MAXSIZE];
511 |      char read_in2[MAXSIZE],send_out2[MAXSIZE];
512 |      int read1=0,totalread1=0,send1=0;
513 |      int read2=0,totalread2=0,send2=0;
514 |      int sendcount1,sendcount2;
515 |      int maxfd;
516 |      struct sockaddr_in client1,client2;
517 |      int structsize1,structsize2;
518 |      char host1[20],host2[20];
519 |      int port1=0,port2=0;
520 |      char tmpbuf[100];
521 | 
522 |      sock = (transocket *)data;
523 |      fd1 = sock->fd1;
524 |      fd2 = sock->fd2;
525 | 
526 |      memset(host1,0,20);
527 |      memset(host2,0,20);
528 |      memset(tmpbuf,0,100);
529 | 
530 |      structsize1=sizeof(struct sockaddr);
531 |      structsize2=sizeof(struct sockaddr);
532 |      
533 |      if(getpeername(fd1,(struct sockaddr *)&client1,&structsize1)<0)
534 |      {
535 |            strcpy(host1, "fd1");
536 |      }
537 |      else
538 |      {      
539 | //            printf("[+]got, ip:%s, port:%d\r\n",inet_ntoa(client1.sin_addr),ntohs(client1.sin_port));
540 |            strcpy(host1, inet_ntoa(client1.sin_addr));
541 |            port1=ntohs(client1.sin_port);
542 |      }
543 | 
544 |      if(getpeername(fd2,(struct sockaddr *)&client2,&structsize2)<0)
545 |      {
546 |            strcpy(host2,"fd2");
547 |      }
548 |      else
549 |      {      
550 | //            printf("[+]got, ip:%s, port:%d\r\n",inet_ntoa(client2.sin_addr),ntohs(client2.sin_port));
551 |            strcpy(host2, inet_ntoa(client2.sin_addr));
552 |            port2=ntohs(client2.sin_port);
553 |      }
554 | 
555 |      printf("[+] Start Transmit (%s:%d <-> %s:%d) ......\r\n\n", host1, port1, host2, port2);
556 |  
557 |      maxfd=max(fd1,fd2)+1;
558 |      memset(read_in1,0,MAXSIZE);
559 |      memset(read_in2,0,MAXSIZE);
560 |      memset(send_out1,0,MAXSIZE);
561 |      memset(send_out2,0,MAXSIZE);
562 |  
563 |      timeset.tv_sec=TIMEOUT;
564 |      timeset.tv_usec=0;
565 | 
566 |      while(1)
567 |      {
568 |            FD_ZERO(&readfd);
569 |            FD_ZERO(&writefd);
570 |        
571 |            FD_SET((UINT)fd1, &readfd);
572 |            FD_SET((UINT)fd1, &writefd);
573 |            FD_SET((UINT)fd2, &writefd);
574 |            FD_SET((UINT)fd2, &readfd);
575 |        
576 |            result=select(maxfd,&readfd,&writefd,NULL,&timeset);
577 |            if((result<0) && (errno!=EINTR))
578 |            {
579 |                  printf("[-] Select error.\r\n");
580 |                  break;
581 |            }
582 |            else if(result==0)
583 |            {
584 |                  printf("[-] Socket time out.\r\n");
585 |                  break;
586 |            }
587 |            
588 |            if(FD_ISSET(fd1, &readfd))
589 |            {
590 |                  /* must < MAXSIZE-totalread1, otherwise send_out1 will flow */
591 |                  if(totalread1<MAXSIZE)
592 |                {
593 |                        read1=recv(fd1, read_in1, MAXSIZE-totalread1, 0);
594 |                        if((read1==SOCKET_ERROR) || (read1==0))
595 |                        {
596 |                              printf("[-] Read fd1 data error,maybe close?\r\n");
597 |                              break;
598 |                        }
599 |                  
600 |                        memcpy(send_out1+totalread1,read_in1,read1);
601 |                        sprintf(tmpbuf,"\r\nRecv %5d bytes from %s:%d\r\n", read1, host1, port1);
602 |                        printf(" Recv %5d bytes %16s:%d\r\n", read1, host1, port1);
603 |                        makelog(tmpbuf,strlen(tmpbuf));
604 |                        makelog(read_in1,read1);
605 |                        totalread1+=read1;
606 |                        memset(read_in1,0,MAXSIZE);
607 |                  }
608 |            }
609 | 
610 |            if(FD_ISSET(fd2, &writefd))
611 |            {
612 |                  int err=0;
613 |                  sendcount1=0;
614 |                  while(totalread1>0)
615 |                  {
616 |                        send1=send(fd2, send_out1+sendcount1, totalread1, 0);
617 |                        if(send1==0)break;
618 |                        if((send1<0) && (errno!=EINTR))
619 |                        {
620 |                              printf("[-] Send to fd2 unknow error.\r\n");
621 |                              err=1;
622 |                              break;
623 |                        }
624 |                        
625 |                        if((send1<0) && (errno==ENOSPC)) break;
626 |                        sendcount1+=send1;
627 |                        totalread1-=send1;
628 | 
629 |                        printf(" Send %5d bytes %16s:%d\r\n", send1, host2, port2);
630 |                  }
631 |                
632 |                  if(err==1) break;
633 |                  if((totalread1>0) && (sendcount1>0))
634 |                  {
635 |                        /* move not sended data to start addr */
636 |                        memcpy(send_out1,send_out1+sendcount1,totalread1);
637 |                        memset(send_out1+totalread1,0,MAXSIZE-totalread1);
638 |                  }
639 |                  else
640 |                  memset(send_out1,0,MAXSIZE);
641 |            }
642 |            
643 |            if(FD_ISSET(fd2, &readfd))
644 |            {
645 |                  if(totalread2<MAXSIZE)
646 |                  {
647 |                        read2=recv(fd2,read_in2,MAXSIZE-totalread2, 0);
648 |                        if(read2==0)break;
649 |                        if((read2<0) && (errno!=EINTR))
650 |                        {
651 |                              printf("[-] Read fd2 data error,maybe close?\r\n\r\n");
652 |                              break;
653 |                        }
654 | 
655 |                        memcpy(send_out2+totalread2,read_in2,read2);
656 |                        sprintf(tmpbuf, "\r\nRecv %5d bytes from %s:%d\r\n", read2, host2, port2);
657 |                        printf(" Recv %5d bytes %16s:%d\r\n", read2, host2, port2);
658 |                        makelog(tmpbuf,strlen(tmpbuf));
659 |                  makelog(read_in2,read2);
660 |                  totalread2+=read2;
661 |                  memset(read_in2,0,MAXSIZE);
662 |                  }
663 |            }
664 | 
665 |            if(FD_ISSET(fd1, &writefd))
666 |            {
667 |                  int err2=0;
668 |                sendcount2=0;
669 |                while(totalread2>0)
670 |                {
671 |                      send2=send(fd1, send_out2+sendcount2, totalread2, 0);
672 |                      if(send2==0)break;
673 |                      if((send2<0) && (errno!=EINTR))
674 |                      {
675 |                            printf("[-] Send to fd1 unknow error.\r\n");
676 |                              err2=1;
677 |                            break;
678 |                      }
679 |                      if((send2<0) && (errno==ENOSPC)) break;
680 |                      sendcount2+=send2;
681 |                      totalread2-=send2;
682 |                        
683 |                        printf(" Send %5d bytes %16s:%d\r\n", send2, host1, port1);
684 |                }
685 |                  if(err2==1) break;
686 |              if((totalread2>0) && (sendcount2 > 0))
687 |                  {
688 |                        /* move not sended data to start addr */
689 |                        memcpy(send_out2, send_out2+sendcount2, totalread2);
690 |                        memset(send_out2+totalread2, 0, MAXSIZE-totalread2);
691 |                  }
692 |                  else
693 |                        memset(send_out2,0,MAXSIZE);
694 |            }
695 | 
696 |            Sleep(5);
697 |      }
698 |  
699 |      closesocket(fd1);
700 |      closesocket(fd2);
701 | //      if(method == 3)
702 | //            connectnum --;
703 |      
704 |      printf("\r\n[+] OK! I Closed The Two Socket.\r\n");
705 | }
706 | 
707 | void getctrlc(int j)
708 | {
709 |      printf("\r\n[-] Received Ctrl+C\r\n");
710 |      closeallfd();
711 |      exit(0);
712 | }
713 | 
714 | void closeallfd()
715 | {
716 |      int i;
717 | 
718 |      printf("[+] Let me exit ......\r\n");
719 |      fflush(stdout);
720 | 
721 |      for(i=3; i<256; i++)
722 |      {
723 |            closesocket(i);      
724 |      }
725 | 
726 |      if(fp != NULL)
727 |      {
728 |            fprintf(fp,"\r\n====== Exit ======\r\n");
729 |            fclose(fp);
730 |      }
731 | 
732 |      printf("[+] All Right!\r\n");
733 | }
734 | 
735 | int create_socket()
736 | {
737 |      int sockfd;
738 |      sockfd=socket(AF_INET,SOCK_STREAM,0);
739 |      if(sockfd<0)
740 |      {
741 |            printf("[-] Create socket error.\r\n");
742 |            return(0);
743 |      }
744 |      
745 |      return(sockfd);      
746 | }
747 | 
748 | int create_server(int sockfd,int port)
749 | {
750 |      struct sockaddr_in srvaddr;
751 |      int on=1;
752 |    
753 |      memset(&srvaddr, 0, sizeof(struct sockaddr));
754 | 
755 |      srvaddr.sin_port=htons(port);
756 |      srvaddr.sin_family=AF_INET;
757 |      srvaddr.sin_addr.s_addr=htonl(INADDR_ANY);
758 |  
759 |      setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR, (char*)&on,sizeof(on)); //so I can rebind the port
760 | 
761 |      if(bind(sockfd,(struct sockaddr *)&srvaddr,sizeof(struct sockaddr))<0)
762 |      {
763 |            printf("[-] Socket bind error.\r\n");
764 |            return(0);
765 |      }
766 | 
767 |      if(listen(sockfd,CONNECTNUM)<0)
768 |      {
769 |            printf("[-] Socket Listen error.\r\n");
770 |            return(0);
771 |      }
772 |      
773 |      return(1);
774 | }
775 | 
776 | int client_connect(int sockfd,char* server,int port)
777 | {
778 |   struct sockaddr_in cliaddr;
779 |   struct hostent *host;
780 | 
781 |   if(!(host=gethostbyname(server)))
782 |   {
783 |         printf("[-] Gethostbyname(%s) error:%s\n",server,strerror(errno));
784 |         return(0);
785 |   }      
786 |  
787 |   memset(&cliaddr, 0, sizeof(struct sockaddr));
788 |   cliaddr.sin_family=AF_INET;
789 |   cliaddr.sin_port=htons(port);
790 |   cliaddr.sin_addr=*((struct in_addr *)host->h_addr);
791 |  
792 |   if(connect(sockfd,(struct sockaddr *)&cliaddr,sizeof(struct sockaddr))<0)
793 |   {
794 |         printf("[-] Connect error.\r\n");
795 |         return(0);
796 |   }
797 |   return(1);
798 | }
799 | 
800 | void makelog(char *buffer,int length)
801 | {
802 |      if(fp !=NULL)
803 |      {
804 | //            fprintf(fp, "%s", buffer);
805 | //            printf("%s",buffer);
806 |            write(fileno(fp),buffer,length);
807 | //            fflush(fp);
808 |      }
809 | }
810 | 


--------------------------------------------------------------------------------