每一刻都是一个崭新的开始。

htran.cpp源代码

Submitted by 可酷可乐 on 2010, January 27, 11:30 AM. 软件程序

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

Tags: htran, 源码

« 上一篇 | 下一篇 »

Trackbacks

点击获得Trackback地址,Encode: UTF-8 点击获得Trackback地址,Encode: GB2312 or GBK 点击获得Trackback地址,Encode: BIG5

发表评论

评论内容 (必填):