C/C++实现正反向端口映射

通常服务器是放在内网中，内部局域网中，并且分配了私有IP地址，而如果想要在外部直接访问内部服务器则需要端口映射，端口映射也叫做端口转发，或者叫做虚拟服务器，在渗透时当我们拿到目标机器权限以后，目标机器实在内网环境中，如果想要外部直接访问内部的特定机器的特定端口，则需要使用映射来实现，常用的映射工具是LCX，或者自己实现。

LCX实现的映射方法

Windows 版LCX源代码(魔改版)

#include <iostream>
#include <stdlib.h>
#include <errno.h>
#include <winsock2.h> 
#include <io.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#pragma comment(lib, "ws2_32.lib")
using namespace std;

typedef	struct{
	SOCKET	s1;
	SOCKET	s2;
}Stu_sock;

//函数声明
void version();
int param(int argc, char **argv);		//对命令行参数
void Funlisten(int port1, int port2);	//监听功能函数
bool bindAndFunlisten(SOCKET s, int port);//绑定socket的地址结构
void datatrans(LPVOID data);			//数据转发函数
void slave(char* hostIp, char * slaveIp, int destionPort, int slavePort);//slave函数
bool checkIP(char * str);
int client_connect(int sockfd, char* server, int port);//连接服务端

void main(int argc, char **argv)
{

	version();
	//参数判断
	WSADATA wsadata;
	WSAStartup(MAKEWORD(1, 1), &wsadata);
	char hostIp[20] = { 0 };
	char slaveIp[20] = { 0 };
	int ret = 1;
	ret = param(argc, argv);
	if (ret == 1)//Funlisten
	{
		Funlisten(atoi(argv[2]), atoi(argv[3]));
	}
	else if (ret == 2)
	{
		strcpy(hostIp, argv[2]);
		strcpy(slaveIp, argv[4]);
		slave(argv[2], argv[4], atoi(argv[3]), atoi(argv[5]));
	}

}

int param(int argc, char **argv)
{
	//stricmp==strcmp ignore case忽略大小写
	if (argc == 4 && stricmp(argv[1], "-listen") == 0)
	{
		//		cout<<"Funlisten"<<endl;
		return 1;
	}
	if (argc == 6 && stricmp(argv[1], "-slave") == 0 && checkIP(argv[2]) && checkIP(argv[4]))
	{
		return 2;
	}
	else
	{
		version();
		return -1;
	}
}
/************************************************************************/
/*                                                                      */
/*				listen 功能模块											*/
/************************************************************************/

void Funlisten(int port1, int port2)
{
	Stu_sock	stu_sock;

	//创建套接字
	SOCKET sock1 = socket(AF_INET, SOCK_STREAM, 0);
	SOCKET sock2 = socket(AF_INET, SOCK_STREAM, 0);
	if (sock1<0 || sock1<0)
	{
		cout << "[-] Create socket error" << endl;
		return;
	}

	//绑定端口到socket并监听
	if (!bindAndFunlisten(sock1, port1) || !bindAndFunlisten(sock2, port2))
	{
		return;
	}
	//都监听好了接下来……
	int SizeOfAddr = sizeof(sockaddr);
	while (true)
	{
		cout << "[+] Waiting for Client ......" << endl;
		sockaddr_in	remoteSockAddr;
		//sock1等待连接
		SOCKET	recvSock1 = accept(sock1, (sockaddr *)&remoteSockAddr, &SizeOfAddr);
		cout << recvSock1 << endl;
		if (recvSock1<0)
		{
			cout << "[-] Accept error." << endl;
			continue;
		}
		cout << "[+] Accept a Client on port " << port1 << "  from " << inet_ntoa(remoteSockAddr.sin_addr) << endl;
		cout << "[+] Waiting another Client on port:" << port2 << "...." << endl;

		SOCKET	recvSock2 = accept(sock2, (sockaddr *)&remoteSockAddr, &SizeOfAddr);
		cout << recvSock2 << endl;
		if (recvSock2<0)
		{
			cout << "[-] Accept error." << endl;
			continue;
		}
		cout << "[+] Accept a Client on port" << port1 << "  from " << inet_ntoa(remoteSockAddr.sin_addr) << endl;

		//两个都连上来了
		cout << "[+] Accept Connect OK!" << endl;


		stu_sock.s1 = recvSock1;		stu_sock.s2 = recvSock2;
		DWORD	dwThreadID;

		//创建一个转发数据的线程
		HANDLE	hThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)datatrans, (LPVOID)&stu_sock, 0, &dwThreadID);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;//线程错了直接退出
		}
		cout << "[+] CreateThread OK!" << endl;
		Sleep(800);//挂起当前线程
	}
}

bool bindAndFunlisten(SOCKET s, int port)
{
	//地址结构
	sockaddr_in	addr;
	memset(&addr, 0, sizeof(addr));
	addr.sin_port = htons(port);
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = htonl(INADDR_ANY);

	char on = 1;
	setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

	//绑定地址结构
	if (bind(s, (const sockaddr *)&addr, sizeof(sockaddr))<0)
	{
		cout << "[-] Socket bind error." << endl;
		return false;
	}

	//监听端口
	if (listen(s, 5)<0)
	{
		cout << "[-] Listen error." << endl;
		return false;
	}
	return true;
}

void datatrans(LPVOID data)
{
	char host_slave[20] = { 0 };
	char host_hacker[20] = { 0 };
	Stu_sock *stuSock = (Stu_sock *)data;
	SOCKET	s1 = stuSock->s1;	//接受的是slave的数据
	SOCKET	s2 = stuSock->s2;	//发送出去的socket
	int	sentacount1 = 0;

	sockaddr_in	addr = { 0 };
	int sizeofaddr = sizeof(sockaddr);

	if (getpeername(s1, (sockaddr *)&addr, &sizeofaddr))
	{

		strcpy(host_slave, inet_ntoa(addr.sin_addr));
		int port_slave = ntohs(addr.sin_port);
	}
	if (getpeername(s2, (sockaddr *)&addr, &sizeofaddr))
	{

		strcpy(host_hacker, inet_ntoa(addr.sin_addr));
		int port_hacker = ntohs(addr.sin_port);
	}
	cout << "[+] Start Transport (" << host_slave << "<-> " << host_hacker << ") ......" << endl;
	char RecvBuffer[20480];
	char SendBuffer[20480];


	fd_set	readfd; fd_set	writefd;
	timeval	timeset;
	timeset.tv_sec = 300;
	timeset.tv_usec = 0;
	int maxfd = max(s1, s2) + 1;
	bool flag = false;
	int readsize;
	while (TRUE)
	{
		readsize = 0;
		FD_ZERO(&readfd);
		FD_ZERO(&writefd);
		FD_SET((UINT)s1, &readfd);
		FD_SET((UINT)s2, &readfd);
		FD_SET((UINT)s1, &writefd);
		FD_SET((UINT)s2, &writefd);

		int result = select(maxfd, &readfd, &writefd, NULL, &timeset);
		if (result<0 && (errno != EINTR))
		{
			cout << "[-] Select error." << endl;
			break;
		}
		else if (result == 0)
		{
			cout << "[-] Socket time out." << endl;
			break;
		}

		//没出错，没超时
		if (FD_ISSET(s1, &readfd) && flag)
		{
			//		if (totalread1<20408)
			{
				readsize = recv(s1, RecvBuffer, 20480, 0);//接受host的请求。。
				if (readsize == -1)
				{
					break;
				}
				if (readsize == SOCKET_ERROR || readsize == 0)
				{
					cout << "!!!" << endl;
				}
				memcpy(SendBuffer, RecvBuffer, readsize);
				memset(RecvBuffer, 0, 20480);
				cout << " [+] Recv " << readsize << " bytes " << "from host." << endl;
			}
		}


		if (FD_ISSET(s1, &writefd) && flag && (readsize>0))
		{

			int sendsize = send(s2, SendBuffer, readsize, 0);//发给slave
			if (sendsize == 0)
			{
				break;
			}
			if (sendsize<0 && (errno != EINTR))
			{
				cout << "[-] Send to s2 unknow error." << endl;
				break;
			}

			memset(SendBuffer, 0, 20480);
			cout << " Send " << sendsize << " bytes " << endl;

		}
		if (FD_ISSET(s2, &readfd) && (!flag))
		{
			{
				readsize = recv(s2, RecvBuffer, 20480, 0);//接受slave返回数据
				memcpy(SendBuffer, RecvBuffer, readsize);
				cout << " [+] Recv " << readsize << " bytes " << "from host." << endl;
				//totalread1+=readsize;
				memset(RecvBuffer, 0, 20480);
			}
		}
		if (FD_ISSET(s1, &writefd) && (!flag) && (readsize>0))
		{
			readsize = send(s1, SendBuffer, readsize, 0);//发给host
			if (readsize == 0)
			{
				break;
			}
			if (readsize<0)
			{
				cout << "[-] Send to s2 unknow error." << endl;
				break;
			}
			cout << " Send " << readsize << " bytes " << endl;
			memset(SendBuffer, 0, 20480);

		}

		flag = !flag;

		Sleep(5);


	}
	closesocket(s1);
	closesocket(s2);
	cout << "[+] OK! I Closed The Two Socket." << endl;
}

/************************************************************************/
/*                                                                      */
/*				slave 功能模块											*/
/************************************************************************/
void slave(char* hostIp, char * slaveIp, int destionPort, int slavePort)
{

	//checkIP(hostIp);
	Stu_sock	stu_sock;
	fd_set		fd;
	char		buffer[20480];
	int			l;
	while (TRUE)
	{
		//创建套接字
		SOCKET sock1 = socket(AF_INET, SOCK_STREAM, 0);
		SOCKET sock2 = socket(AF_INET, SOCK_STREAM, 0);

		cout << "[+] Make a Connection to " << hostIp << "on port:" << slaveIp << "...." << endl;
		if (sock1<0 || sock1<0)
		{
			cout << "[-] Create socket error" << endl;
			return;
		}
		fflush(stdout);
		if (client_connect(sock1, hostIp, destionPort) == 0)
		{
			closesocket(sock1);
			closesocket(sock2);
			continue;/*跳过这次循环*/
		}

		memset(buffer, 0, 20480);
		while (1)
		{
			//把sock清零,加入set集
			FD_ZERO(&fd);
			FD_SET(sock1, &fd);

			//select事件	读 写 异常
			if (select(sock1 + 1, &fd, NULL, NULL, NULL) == SOCKET_ERROR)
			{
				if (errno == WSAEINTR) continue;
				break;
			}
			//FD_ISSET返回值>0 表示SET里的可读写
			if (FD_ISSET(sock1, &fd))
			{
				l = recv(sock1, buffer, 20480, 0);
				break;
			}
			Sleep(5);
		}

		if (l <= 0)
		{
			cout << "[-] There is a error...Create a new connection." << endl;
			continue;
		}
		while (1)
		{
			cout << "[+] Connect OK!    \n[+] xlcTeam congratulations!" << endl;
			cout << "[+] Make a Connection to " << hostIp << "on port:" << slaveIp << "...." << endl;
			fflush(stdout);
			if (client_connect(sock2, slaveIp, slavePort) == 0)
			{
				closesocket(sock1);
				closesocket(sock2);
				continue;
			}

			if (send(sock2, buffer, l, 0) == SOCKET_ERROR)
			{
				cout << "[-] Send failed." << endl;
				continue;
			}

			l = 0;
			memset(buffer, 0, 20480);
			break;
		}

		cout << "[+] All Connect OK!" << endl;
		stu_sock.s1 = sock1;
		stu_sock.s2 = sock2;

		HANDLE	hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)datatrans, (LPVOID)&stu_sock, 0, NULL);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;
		}
	}
}

//检查IP地址格式是否正确
bool checkIP(char * str)
{
	if (INADDR_NONE == inet_addr(str))
		return FALSE;
	return true;
}

int client_connect(int sockfd, char* server, int port)
{					/*sock*/		/*远程IP*/	/*远程端口*/
	struct sockaddr_in cliaddr;
	struct hostent *host;

	if (!(host = gethostbyname(server)))	//获得远程主机的IP
	{
		//   printf("[-] Gethostbyname(%s) error:%s\n",server,strerror(errno));
		return(0);
	}
	//给地址结构赋值
	memset(&cliaddr, 0, sizeof(struct sockaddr));
	cliaddr.sin_family = AF_INET;
	cliaddr.sin_port = htons(port);/*远程端口*/
	cliaddr.sin_addr = *((struct in_addr *)host->h_addr);//host ip

	//去连接远程正在listen的主机
	if (connect(sockfd, (struct sockaddr *)&cliaddr, sizeof(struct sockaddr))<0)
	{
		//        printf("[-] Connect error.\r\n");
		return(0);
	}
	return(1);
}

void version()
{

	cout << "options:" << endl;
	cout << "-slave  remoteIp remotePort1  localIp  localPort" << endl;
	cout << "-listen  remotePort1 remotePort2" << endl;
	cout << endl;
}

Linux 版LCX源代码

/*
Lcx: Port Data Transfer
Compile Environment: Windows / Linux / Mac OS / Android, Gcc
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <stdint.h>

#define BUF_LEN 8192

#ifdef WIN32  //WINDOWS COMPILE

#include <winsock2.h>
#include <windows.h>
#include <ws2tcpip.h>

#define SOCKET_INIT {WSADATA wsa;WSAStartup(MAKEWORD(2,2),&wsa);}

#define  ThreadReturn DWORD WINAPI

#define delay(x) Sleep(x)

#else  //LINUX COMPILE

#define PTW32_STATIC_LIB
#include <pthread.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/select.h>

#define SOCKET_INIT

typedef int SOCKET;
#define ThreadReturn void*

#define delay(x) usleep(x*1000)
#define closesocket(x) close(x)

#endif

typedef ThreadReturn (*Func)(void*);

FILE* lcx_log = NULL;
FILE* lcx_hex = NULL;
FILE* lcx_text = NULL;
int total_connect = 0;

int main_func(int argc,char**argv);

void ctrl_c(int32_t i)
{
  fprintf(stdout,"\n[-] Receive: Ctrl+C..I'll quit..\n");
  fprintf(stdout,"\n[+] Let me exit....\n");
  fprintf(stdout,"[+] All Right!\n\n");
  exit(0);
}


int in_createthread(Func run,void* data)
{
#ifdef WIN32
  HANDLE h = CreateThread(NULL,0,run,data,0,NULL);
  CloseHandle(h);
#else
  pthread_attr_t attr;
  pthread_attr_init (&attr);
  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
  pthread_t tt;
  pthread_create(&tt,&attr,run,data);
#endif
  delay(5);
  return 0;
}

ThreadReturn  in_data_tran(void* p)
{
  SOCKET t[2];
  t[0]=((int*)p)[0];
  t[1]=((int*)p)[1];

  struct sockaddr_in sa[2];
  const unsigned char* ip[2];
  unsigned short port[2];

  socklen_t len = sizeof(struct sockaddr_in);
  if(getpeername(t[0],(struct sockaddr*)sa,&len)==-1 || getpeername(t[1],(struct sockaddr*)(sa+1),&len)==-1)
  {
    fprintf(stdout,"\n[-] Get Remote Host Failed\n");
    if(lcx_log)fprintf(lcx_log,"\n[-] Get Remote Host Failed\n"),fflush(lcx_log);
    closesocket(t[0]);
    closesocket(t[1]);
    return 0;
  }

  ip[0] = (unsigned char*)&sa[0].sin_addr.s_addr;
  ip[1] = (unsigned char*)&sa[1].sin_addr.s_addr;
  port[0] = htons(sa[0].sin_port);
  port[1] = htons(sa[1].sin_port);

  fd_set fd_list,check_list;
  FD_ZERO(&fd_list);
  FD_SET(t[0],&fd_list);
  FD_SET(t[1],&fd_list);

  unsigned char buf[BUF_LEN];
  int OK = 1;
  int total_byte = 0;
  ++total_connect;
  while( OK && ( (check_list = fd_list),(select(FD_SETSIZE,&check_list,NULL,NULL,NULL)>0)) )
  {
    int i;
    for(i=0;i<2;++i)
    {
      if(FD_ISSET(t[i],&check_list))
      {
        int len = recv(t[i],buf,BUF_LEN,0);
        if(len>0 && send(t[i==0],buf,len,0)>0 )
        {
          total_byte += len;
          char out[100];
          sprintf(out,"\n[+]  Send <Total %d>: %d.%d.%d.%d:%d -> %d.%d.%d.%d:%d,  %d Bytes\n",
              total_connect,ip[i][0],ip[i][1],ip[i][2],ip[i][3],port[i],ip[i==0][0],ip[i==0][1],ip[i==0][2],ip[i==0][3],port[i==0],len);
          fprintf(stdout,"%s",out);fflush(stdout);
          if(lcx_log)fprintf(lcx_log,"%s",out),fflush(lcx_log);
          if(lcx_text)
          {
            fprintf(lcx_text,"\n%s\n",out);
            fwrite(buf,1,len,lcx_text);
            fflush(lcx_text);
          }
          if(lcx_hex)
          {
            fprintf(lcx_hex,"\n%s",out);
            int i;
            for(i=0;i<len;++i)
            {
              if(i%16==0)fprintf(lcx_hex,"\n");
              fprintf(lcx_hex,"%02X ",buf[i]);
            }
            fflush(lcx_hex);
          }
        }
        else
        {
          OK = 0;
          fprintf(stdout,"\n[+]  Connection <Total %d> Cutdown, Total : %d Bytes\n\n",total_connect,total_byte);fflush(stdout);
          if(lcx_log)fprintf(lcx_log,"\n[+]  Connection <Total %d> Cutdown, Total : %d Bytes\n\n",total_connect,total_byte),fflush(lcx_log);
          break;
        }
      }
    }
  }
  --total_connect;

  closesocket(t[0]);
  closesocket(t[1]);
#ifdef WIN32
  return 0;
#else
  return NULL;
#endif
}

long gethost(const char* name)
{
  if(name)
  {
    struct hostent *host = gethostbyname(name);
    long i;
    if(host&&host->h_addr)
    {
      i = *(long *)(host->h_addr);
      return i;
    }
  }
  fprintf(stdout,"\nERROR: %s: Wrong host address\n\n",name);
  return -1;
}

int lcx_slave(const char* ip1_str,unsigned short port1,const char* ip2_str,unsigned short port2)
{
  char out1[100],out2[100];
  while(1)
  {
    unsigned long ip1 = gethost(ip1_str);
    if(-1 == ip1)
    {
      fprintf(stdout,"\n[-]  Reslove Host %s Failed...\n",ip1_str),fflush(stdout);
      break;
    }
    unsigned long ip2 = gethost(ip2_str);
    if(-1 == ip2)
    {
      fprintf(stdout,"\n[-]  Reslove Host %s Failed...\n",ip2_str),fflush(stdout);
      break;
    }
    SOCKET s[2];
    s[0] = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    s[1] = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    struct sockaddr_in sa[2];
    sa[0].sin_family = AF_INET;
    sa[0].sin_port = htons(port1);
    sa[0].sin_addr.s_addr = (ip1);
    sa[1].sin_family = AF_INET;
    sa[1].sin_port = htons(port2);
    sa[1].sin_addr.s_addr = (ip2);
    unsigned char*ip[2];
    ip[0] = (unsigned char*)&ip1;
    ip[1] = (unsigned char*)&ip2;
    sprintf(out1,"%d.%d.%d.%d:%d",ip[0][0],ip[0][1],ip[0][2],ip[0][3],port1);
    sprintf(out2,"%d.%d.%d.%d:%d",ip[1][0],ip[1][1],ip[1][2],ip[1][3],port2);

    if(s[0]!=-1 && s[1]!=-1)
    {
      fprintf(stdout,"\n[+]  Connect %s, Please Wait\n",out1);fflush(stdout);
      if(lcx_log)fprintf(lcx_log,"\n[+]  Connect %s, Please Wait\n",out1),fflush(lcx_log);
      if(connect(s[0],(struct sockaddr*)&sa[0],sizeof(struct sockaddr))!=0)
      {
        fprintf(stdout,"\n[-]  Connect %s Failed,CutDown...\n",out2);
        if(lcx_log)fprintf(lcx_log,"\n[-]  Connect %s Failed,CutDown...\n",out2),fflush(lcx_log);
        closesocket(s[0]);
        closesocket(s[1]);
      }
      else
      {
        fprintf(stdout,"\n[+]  Connect %s Successed,Now Connect %s\n",out1,out2);fflush(stdout);
        if(lcx_log)fprintf(lcx_log,"\n[+]  Connect %s Successed,Now Connect %s\n",out1,out2),fflush(lcx_log);
        if(connect(s[1],(struct sockaddr*)&sa[1],sizeof(struct sockaddr))==0)
        {
          fprintf(stdout,"\n[+]  Connect %s Successed,Transfering...\n",out2);fflush(stdout);
          if(lcx_log)fprintf(lcx_log,"\n[+]  Connect %s Successed,Transfering...\n",out2),fflush(lcx_log);
          in_data_tran(s);
        }
        else
        {
          fprintf(stdout,"\n[-]  Connect %s Failed,CutDown...\n",out2);
          if(lcx_log)fprintf(lcx_log,"\n[-]  Connect %s Failed,CutDown...\n",out2),fflush(lcx_log);
          closesocket(s[0]);
          closesocket(s[1]);
        }
      }
    }
    else
    {
      fprintf(stdout,"\n[-]  Create Socket Failed\n");
      if(lcx_log)fprintf(lcx_log,"\n[-]  Create Socket Failed\n"),fflush(lcx_log);
      return -1;
    }
    delay(1000);
  }
  return 0;
}

int lcx_listen(unsigned short port1,unsigned short port2)
{
  SOCKET s[2]={-1,-1};
  unsigned short p[2];
  p[0]=port1;
  p[1]=port2;

  struct sockaddr_in sa;
  sa.sin_family = AF_INET;
  sa.sin_addr.s_addr = INADDR_ANY;
  int i;
  int OK = 0;
  for(i=0; i<2; ++i)
  {
    s[i] = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(s[i]!=-1)
    {
      fprintf(stdout,"\n[+]  Create Socket %d Successed\n",i+1);fflush(stdout);
      if(lcx_log)fprintf(lcx_log,"\n[+]  Create Socket %d Successed\n",i+1),fflush(lcx_log);
      sa.sin_port = htons(p[i]);

      int flag = 1;
      setsockopt(s[i], SOL_SOCKET, SO_REUSEADDR, (const void*)&flag, sizeof(flag));
      if(bind(s[i],(struct sockaddr*)&sa,sizeof(sa))==0)
      {
        fprintf(stdout,"\n[+]  Bind On Port %u Success\n",p[i]);fflush(stdout);
        if(lcx_log)fprintf(lcx_log,"\n[+]  Bind On Port %u Success\n",p[i]),fflush(lcx_log);
        if(listen(s[i],SOMAXCONN)==0)
        {
          fprintf(stdout,"\n[+]  Listen On Port %u Successed\n",p[i]);fflush(stdout);
          if(lcx_log)fprintf(lcx_log,"\n[+]  Listen On Port %u Successed\n",p[i]),fflush(lcx_log);
          OK =  1;
        }
        else
        {
          fprintf(stdout,"\n[-]  Listen On Port %u Failed\n",p[i]);
          if(lcx_log)fprintf(lcx_log,"\n[-]  Listen On Port %u Failed\n",p[i]),fflush(lcx_log);
          break;
        }
      }
      else
      {
        fprintf(stdout,"\n[-]  Bind On Port %u Failed\n",p[i]);
        if(lcx_log)fprintf(lcx_log,"\n[-]  Bind On Port %u Failed\n",p[i]),fflush(lcx_log);
        break;
      }
    }
    else
    {
      fprintf(stdout,"\n[-]  Create Socket %d Failed\n",i+1);
      if(lcx_log)fprintf(lcx_log,"\n[-]  Create Socket %d Failed\n",i+1),fflush(lcx_log);
      break;
    }
  }
  if(!OK)
  {
    closesocket(s[0]);
    closesocket(s[1]);
    return -1;
  }

  i = 0;
  SOCKET t[2];
  socklen_t sz = sizeof(sa);
  while(1)
  {
    fprintf(stdout,"\n[+]  Waiting Connect On Port %u\n",p[i]);fflush(stdout);
    if(lcx_log)fprintf(lcx_log,"\n[+]  Waiting Connect On Port %u\n",p[i]),fflush(lcx_log);
    t[i] = accept(s[i],(struct sockaddr*)&sa,&sz);
    const unsigned char *ip = (unsigned char*)&sa.sin_addr.s_addr;
    if(t[i]!=-1)
    {
      fprintf(stdout,"\n[+]  Connect From %d.%d.%d.%d:%d On Port %d\n",ip[0],ip[1],ip[2],ip[3],htons(sa.sin_port),p[i]);fflush(stdout);
      if(lcx_log)fprintf(lcx_log,"\n[+]  Connect From %d.%d.%d.%d:%d On Port %d\n",ip[0],ip[1],ip[2],ip[3],htons(sa.sin_port),p[i]),fflush(lcx_log);
      if(i==1)
      {
        in_createthread(in_data_tran,t);
      }
      i = (i==0);
    }
    else
    {
      fprintf(stdout,"\n[-]  Accept Failed On Port %d\n",p[i]);
      if(lcx_log)fprintf(lcx_log,"\n[-]  Accept Failed On Port %d\n",p[i]),fflush(lcx_log);
      i=0;
    }
  }
  return 0;
}

int lcx_tran(unsigned short port1,const char* ip2_str,unsigned short port2)
{
  SOCKET s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  struct sockaddr_in sa;
  sa.sin_family = AF_INET;
  sa.sin_port = htons(port1);
  sa.sin_addr.s_addr = INADDR_ANY;
  socklen_t ok =0;
  if(s!=-1)
  {
    int flag = 1;
    setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const void*)&flag, sizeof(flag));
    if(bind(s,(struct sockaddr*)&sa,sizeof(sa))==0)
    {
      if(listen(s,SOMAXCONN)==0)
      {
        ok = 1;
        fprintf(stdout,"\n[+]  Listening On Port %d...\n",port1);fflush(stdout);
        if(lcx_log)fprintf(lcx_log,"\n[+]  Listening On Port %d...\n",port1),fflush(lcx_log);
      }
      else
      {
        fprintf(stdout,"\n[-]  Listen Failed\n");
        if(lcx_log)fprintf(lcx_log,"\n[-]  Listen Failed\n"),fflush(lcx_log);
      }
    }
    else
    {
      fprintf(stdout,"\n[-]  Bind On Port %d Failed\n",port1);
      if(lcx_log)fprintf(lcx_log,"\n[-]  Bind On Port %d Failed\n",port1),fflush(lcx_log);
    }
  }
  else
  {
    fprintf(stdout,"\n[-]  Create Socket Failed\n");
    if(lcx_log)fprintf(lcx_log,"\n[-]  Create Socket Failed\n"),fflush(lcx_log);
  }
  if(!ok)
  {
    closesocket(s);
    return -1;
  }
  SOCKET tt[2];
  SOCKET ac=-1;
  ok = sizeof(sa);
  char out1[100],out2[100];
  while(1)
  {
    unsigned long ip2 = gethost(ip2_str);
    if(-1 == ip2)
    {
      fprintf(stdout,"\n[-]  Reslove Host %s Failed...\n",ip2_str),fflush(stdout);
      break;
    }
    fprintf(stdout,"\n[+]  Waiting Connect On Port %d...\n",port1);fflush(stdout);
    if(lcx_log)fprintf(lcx_log,"\n[+]  Waiting Connect On Port %d...\n",port1),fflush(lcx_log);
    if(ac=accept(s,(struct sockaddr*)&sa,&ok),ac==-1)
    {
      break;
    }
    unsigned char* ip =(unsigned char*)&sa.sin_addr.s_addr;
    sprintf(out1,"%d.%d.%d.%d:%d",ip[0],ip[1],ip[2],ip[3],htons(sa.sin_port));
    ip = (unsigned char*)&ip2;
    sprintf(out2,"%d.%d.%d.%d:%d",ip[0],ip[1],ip[2],ip[3],(port2));
    fprintf(stdout,"\n[+]  Connect From %s, Now Connect to %s\n",out1,out2);fflush(stdout);
    if(lcx_log)fprintf(lcx_log,"\n[+]  Connect From %s, Now Connect to %s\n",out1,out2),fflush(lcx_log);
    sa.sin_port = htons(port2);
    sa.sin_addr.s_addr = ip2;
    SOCKET s2 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(connect(s2,(struct sockaddr*)&sa,sizeof(sa))==0)
    {
      tt[0]=ac;
      tt[1]=s2;
      fprintf(stdout,"\n[+]  Connect %s Successed,Start Transfer...\n",out2);fflush(stdout);
      if(lcx_log)fprintf(lcx_log,"\n[+]  Connect %s Successed,Start Transfer...\n",out2),fflush(lcx_log);
      in_createthread(in_data_tran,tt);
    }
    else
    {
      fprintf(stdout,"\n[-]  Connect %s Failed...\n",out2),fflush(stdout);
      if(lcx_log)fprintf(lcx_log,"\n[-]  Connect %s Failed...\n",out2),fflush(lcx_log);
      closesocket(s2);
      closesocket(ac);
    }
  }
  closesocket(s);
  closesocket(ac);
  return 0;
}

void help(const char* name)
{
  fprintf(stdout,"\nUsage of Packet Transmit:\n");
  fprintf(stdout,"  %s -<listen|tran|slave> <option> [<-log|-hex|-text> file] \n",name);
  fprintf(stdout,"  %s -about\n\n",name);
  fprintf(stdout,"[options:]\n");
  fprintf(stdout,"  -listen <local port1>  <local port2>\n");
  fprintf(stdout,"  -tran   <local port>   <remote host>  <remote port>\n");
  fprintf(stdout,"  -slave  <remote host1> <remote port1> <remote host2> <remote port2>\n\n");
  fprintf(stdout,"  -hex   : hex mode data dump\n");
  fprintf(stdout,"  -text  : text mode data dump\n");
  fprintf(stdout,"  -log   : save transfer log\n\n");
}

void about()
{
#ifdef ANONYMOUS
  fprintf(stdout,"\nBy:     Anonymous\n");
#else
  fprintf(stdout,"\nBy:     XiaoBaWang\n");
  fprintf(stdout,"Email:  windworst@gmail.com\n\n");
#endif
}

long getport(const char *str)
{
  long port = EOF;
  port = atoi(str);
  if (port<=0||port>65535)
  {
    fprintf(stdout,"\nERROR: %s: Wrong port number\n\n",str);
  }
  return port;
}

void setfile(FILE** fp,const char*file)
{
  *fp = fopen(file,"w");
  if (*fp==NULL)
  {
    fprintf(stdout,"\nERROR: Can not Write to File: %s\n\n",file);
  }
}

int main_func(int argc,char**argv)
{
  if (argc<2)
  {
    help(argv[0]);
    return 0;
  }
  const char* command[] = {"-about","-listen","-slave","-tran"};
  int32_t i,s = sizeof(command)/sizeof(*command);
  for (i=0; i<s; i++)
  {
    if (strcmp(command[i],argv[1])==0)
      break;
  }
  int32_t n = 2;
  const char * addr1=NULL, *addr2=NULL;
  int32_t port1=0,port2=0;
  switch (i)
  {
    case 0:
      about();
      break;
    case 1:
      if (argc<4)
      {
        help(argv[0]);
        return 0;
      }
      else
      {
        port1 = getport(argv[n]);
        port2 = getport(argv[++n]);
      }
      break;
    case 2:
      if (argc<6)
      {
        help(argv[0]);
        return 0;
      }
      else
      {
        addr1 = argv[n];
        port1 = getport(argv[++n]);
        addr2 = argv[++n];
        port2 = getport(argv[++n]);
      }
      break;
    case 3:
      if (argc<5)
      {
        help(argv[0]);
        return 0;
      }
      else
      {
        port1 = getport(argv[n]);
        addr2 = argv[++n];
        port2 = getport(argv[++n]);
      }
      break;
    default:
      {
        help(argv[0]);
        return 0;
      }
      break;
  }
  if(port1==-1 || port2==-1 )return 0;
  const char* logpath=NULL,*hexpath=NULL,*textpath=NULL;
  while (++n<argc)
  {
    if (strcmp(argv[n],"-hex")==0)
    {
      if (argc-1<++n)
      {
        fprintf(stdout,"\n[-] ERROR: -hex Must supply file name.\n\n");
        return 0;
      }
      hexpath = argv[n];
    }
    else if (strcmp(argv[n],"-text")==0)
    {
      if (argc-1<++n)
      {
        fprintf(stdout,"\n[-] ERROR: -text Must supply file name.\n\n");
        return 0;
      }
      textpath = argv[n];
    }
    else if (strcmp(argv[n],"-log")==0)
    {
      if (argc-1<++n)
      {
        fprintf(stdout,"\n[-] ERROR: -log Must supply file name.\n\n");
        return 0;
      }
      logpath = argv[n];
    }
    else
    {
      fprintf(stdout,"\n[-] ERROR:  %s  Undefined.\n\n",argv[n]);
      return 0;
    }
  }

  if (logpath)
  {
    setfile(&lcx_log,logpath);
    if(lcx_log==NULL)return 0;
  }
  if (hexpath)
  {
    setfile(&lcx_hex,hexpath);
    if(lcx_hex==NULL)return 0;
  }
  if (textpath)
  {
    setfile(&lcx_text,textpath);
    if(lcx_text==NULL)return 0;
  }

  switch(i)
  {
    case 1:lcx_listen(port1,port2);break;
    case 2:lcx_slave(addr1,port1,addr2,port2);break;
    case 3:lcx_tran(port1,addr2,(uint16_t)port2);break;
    default:break;
  }
  return 0;
}

#define ARGC_MAXCOUNT 10

int main(int argc,char** argv)
{
  signal(SIGINT,ctrl_c);

  SOCKET_INIT

    int ret = main_func(argc,argv);
#ifdef COMMAND_MODE
  while(1)
  {
    char input_buf[BUF_LEN]={0};
    char *argv_list[ARGC_MAXCOUNT]={"lcx"};
    printf(">");
    int argc_count = 1;
    int flag = 0;
    int i;
    for(i=0;i<BUF_LEN;++i)
    {
      input_buf[i] = getchar();
      if(input_buf[i] == '\n' || input_buf[i] == -1 )
      {
        input_buf[i] = '\0';
      }
      if(input_buf[i]=='\0' || argc_count>=ARGC_MAXCOUNT-2)
      {
        break;
      }
      if(flag ==0 && input_buf[i]!=' ' && input_buf[i]!='\0' )
      {
        flag = 1;
        argv_list[argc_count] = input_buf+i;
        ++argc_count;
      }
      else if(flag ==1 && (input_buf[i]==' ' || input_buf[i]=='\0') )
      {
        flag = 0;
        input_buf[i] = '\0';
      }
    }
    argv_list[argc_count] = NULL;
    ret = main_func(argc_count,argv_list);
  }
#endif
  return ret;
}

Windows XP +VC6.0 原版

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <signal.h>
#include <errno.h>
#include <io.h> 
#pragma comment(lib, "ws2_32.lib")

#define VERSION "1.00"
#define TIMEOUT 300
#define MAXSIZE 20480
#define HOSTLEN 40
#define CONNECTNUM 5

// define 2 socket struct
struct transocket
{
	SOCKET fd1;
	SOCKET fd2;
};

// define function 
void ver();
void usage(char *prog);
void transmitdata(LPVOID data);
void getctrlc(int j);
void closeallfd();
void makelog(char *buffer, int length);
void proxy(int port);
void bind2bind(int port1, int port2);
void bind2conn(int port1, char *host, int port2);
void conn2conn(char *host1, int port1, char *host2, int port2);
int testifisvalue(char *str);
int create_socket();
int create_server(int sockfd, int port);
int client_connect(int sockfd, char* server, int port);

// define GLOBAL variable here
extern int errno;
FILE *fp;
int method = 0;
//int connectnum=0;

//************************************************************************************
// 
// function main 主要是处理用户参数输入的问题
//
//************************************************************************************
VOID main(int argc, char* argv[])
{
	char **p;
	char sConnectHost[HOSTLEN], sTransmitHost[HOSTLEN];
	int iConnectPort = 0, iTransmitPort = 0;
	char *logfile = NULL;

	ver();
	memset(sConnectHost, 0, HOSTLEN);
	memset(sTransmitHost, 0, HOSTLEN);

	p = argv;
	while (*p)
	{
		if (stricmp(*p, "-log") == 0)
		{
			if (testifisvalue(*(p + 1)))
			{
				logfile = *(++p);
			}
			else
			{
				printf("[-] ERROR: Must supply logfile name.\r\n");
				return;
			}
			p++;
			continue;
		}
		p++;
	}

	if (logfile != NULL)
	{
		fp = fopen(logfile, "a");
		if (fp == NULL)
		{
			printf("[-] ERROR: open logfile");
			return;
		}

		makelog("====== Start ======\r\n", 22);
	}


	// Win Start Winsock.
	WSADATA wsadata;
	WSAStartup(MAKEWORD(2, 2), &wsadata);

	signal(SIGINT, &getctrlc);

	if (argc > 2)
	{
		if (stricmp(argv[1], "-listen") == 0 && argc >= 4)
		{
			iConnectPort = atoi(argv[2]);
			iTransmitPort = atoi(argv[3]);
			method = 1;
		}
		else
			if (stricmp(argv[1], "-tran") == 0 && argc >= 5)
			{
				iConnectPort = atoi(argv[2]);
				strncpy(sTransmitHost, argv[3], HOSTLEN);
				iTransmitPort = atoi(argv[4]);
				method = 2;
			}
			else
				if (stricmp(argv[1], "-slave") == 0 && argc >= 6)
				{
					strncpy(sConnectHost, argv[2], HOSTLEN);
					iConnectPort = atoi(argv[3]);
					strncpy(sTransmitHost, argv[4], HOSTLEN);
					iTransmitPort = atoi(argv[5]);
					method = 3;
				}
	}

	switch (method)
	{
	case 1:
		bind2bind(iConnectPort, iTransmitPort);
		break;
	case 2:
		bind2conn(iConnectPort, sTransmitHost, iTransmitPort);
		break;
	case 3:
		conn2conn(sConnectHost, iConnectPort, sTransmitHost, iTransmitPort);
		break;
	default:
		usage(argv[0]);
		break;
	}

	if (method)
	{
		closeallfd();
	}

	WSACleanup();

	return;
}


//************************************************************************************
// 
// print version message
//
//************************************************************************************
VOID ver()
{
	printf("======================== HUC Packet Transmit Tool V%s =======================\r\n", VERSION);
	printf("=========== Code by lion & bkbll, Welcome to http://www.cnhonker.com==========\r\n\n");
}

//************************************************************************************
// 
// print usage message
//
//************************************************************************************
VOID usage(char* prog)
{
	printf("[Usage of Packet Transmit:]\r\n");
	printf(" %s - [-log logfile]\n\n", prog);
	printf("[option:]\n");
	printf(" -listen \n");
	printf(" -tran \n");
	printf(" -slave \n\n");
	return;
}

//************************************************************************************
// 
// test if is value 
//
//************************************************************************************
int testifisvalue(char *str)
{
	if (str == NULL) return(0);
	if (str[0] == '-') return(0);
	return(1);
}

//************************************************************************************
// 
// LocalHost:ConnectPort transmit to LocalHost:TransmitPort
//
//************************************************************************************
void bind2bind(int port1, int port2)
{
	SOCKET fd1, fd2, sockfd1, sockfd2;
	struct sockaddr_in client1, client2;
	int size1, size2;

	HANDLE hThread = NULL;
	transocket sock;
	DWORD dwThreadID;

	if ((fd1 = create_socket()) == 0) return;
	if ((fd2 = create_socket()) == 0) return;

	printf("[+] Listening port %d ......\r\n", port1);
	fflush(stdout);

	if (create_server(fd1, port1) == 0)
	{
		closesocket(fd1);
		return;
	}

	printf("[+] Listen OK!\r\n");
	printf("[+] Listening port %d ......\r\n", port2);
	fflush(stdout);
	if (create_server(fd2, port2) == 0)
	{
		closesocket(fd2);
		return;
	}

	printf("[+] Listen OK!\r\n");
	size1 = size2 = sizeof(struct sockaddr);
	while (1)
	{
		printf("[+] Waiting for Client on port:%d ......\r\n", port1);
		if ((sockfd1 = accept(fd1, (struct sockaddr *)&client1, &size1))<0)
		{
			printf("[-] Accept1 error.\r\n");
			continue;
		}

		printf("[+] Accept a Client on port %d from %s ......\r\n", port1, inet_ntoa(client1.sin_addr));
		printf("[+] Waiting another Client on port:%d....\r\n", port2);
		if ((sockfd2 = accept(fd2, (struct sockaddr *)&client2, &size2))<0)
		{
			printf("[-] Accept2 error.\r\n");
			closesocket(sockfd1);
			continue;
		}

		printf("[+] Accept a Client on port %d from %s\r\n", port2, inet_ntoa(client2.sin_addr));
		printf("[+] Accept Connect OK!\r\n");

		sock.fd1 = sockfd1;
		sock.fd2 = sockfd2;

		hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;
		}

		Sleep(1000);
		printf("[+] CreateThread OK!\r\n\n");
	}
}

//************************************************************************************
// 
// LocalHost:ConnectPort transmit to TransmitHost:TransmitPort
//
//************************************************************************************
void bind2conn(int port1, char *host, int port2)
{
	SOCKET sockfd, sockfd1, sockfd2;
	struct sockaddr_in remote;
	int size;
	char buffer[1024];

	HANDLE hThread = NULL;
	transocket sock;
	DWORD dwThreadID;

	if (port1 > 65535 || port1 < 1)
	{
		printf("[-] ConnectPort invalid.\r\n");
		return;
	}

	if (port2 > 65535 || port2 < 1)
	{
		printf("[-] TransmitPort invalid.\r\n");
		return;
	}

	memset(buffer, 0, 1024);
	if ((sockfd = create_socket()) == INVALID_SOCKET) return;

	if (create_server(sockfd, port1) == 0)
	{
		closesocket(sockfd);
		return;
	}

	size = sizeof(struct sockaddr);
	while (1)
	{
		printf("[+] Waiting for Client ......\r\n");
		if ((sockfd1 = accept(sockfd, (struct sockaddr *)&remote, &size))<0)
		{
			printf("[-] Accept error.\r\n");
			continue;
		}

		printf("[+] Accept a Client from %s:%d ......\r\n",
			inet_ntoa(remote.sin_addr), ntohs(remote.sin_port));
		if ((sockfd2 = create_socket()) == 0)
		{
			closesocket(sockfd1);
			continue;
		}
		printf("[+] Make a Connection to %s:%d ......\r\n", host, port2);
		fflush(stdout);

		if (client_connect(sockfd2, host, port2) == 0)
		{
			closesocket(sockfd2);
			sprintf(buffer, "[SERVER]connection to %s:%d error\r\n", host, port2);
			send(sockfd1, buffer, strlen(buffer), 0);
			memset(buffer, 0, 1024);
			closesocket(sockfd1);
			continue;
		}

		printf("[+] Connect OK!\r\n");

		sock.fd1 = sockfd1;
		sock.fd2 = sockfd2;

		hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;
		}

		Sleep(1000);
		printf("[+] CreateThread OK!\r\n\n");
	}
}

//************************************************************************************
// 
// ConnectHost:ConnectPort transmit to TransmitHost:TransmitPort
//
//************************************************************************************
void conn2conn(char *host1, int port1, char *host2, int port2)
{
	SOCKET sockfd1, sockfd2;

	HANDLE hThread = NULL;
	transocket sock;
	DWORD dwThreadID;
	fd_set fds;
	int l;
	char buffer[MAXSIZE];

	while (1)
	{

		if ((sockfd1 = create_socket()) == 0) return;
		if ((sockfd2 = create_socket()) == 0) return;

		printf("[+] Make a Connection to %s:%d....\r\n", host1, port1);
		fflush(stdout);
		if (client_connect(sockfd1, host1, port1) == 0)
		{
			closesocket(sockfd1);
			closesocket(sockfd2);
			continue;
		}

		// fix by bkbll 
		// if host1:port1 recved data, than connect to host2,port2
		l = 0;
		memset(buffer, 0, MAXSIZE);
		while (1)
		{
			FD_ZERO(&fds);
			FD_SET(sockfd1, &fds);
			if (select(sockfd1 + 1, &fds, NULL, NULL, NULL) == SOCKET_ERROR)
			{
				if (errno == WSAEINTR) continue;
				break;
			}
			if (FD_ISSET(sockfd1, &fds))
			{
				l = recv(sockfd1, buffer, MAXSIZE, 0);
				break;
			}
			Sleep(5);
		}

		if (l <= 0)
		{
			printf("[-] There is a error...Create a new connection.\r\n");
			continue;
		}
		while (1)
		{
			printf("[+] Connect OK!\r\n");
			printf("[+] Make a Connection to %s:%d....\r\n", host2, port2);
			fflush(stdout);
			if (client_connect(sockfd2, host2, port2) == 0)
			{
				closesocket(sockfd1);
				closesocket(sockfd2);
				continue;
			}

			if (send(sockfd2, buffer, l, 0) == SOCKET_ERROR)
			{
				printf("[-] Send failed.\r\n");
				continue;
			}

			l = 0;
			memset(buffer, 0, MAXSIZE);
			break;
		}

		printf("[+] All Connect OK!\r\n");

		sock.fd1 = sockfd1;
		sock.fd2 = sockfd2;

		hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;
		}

		// connectnum++;

		Sleep(1000);
		printf("[+] CreateThread OK!\r\n\n");
	}
}

//************************************************************************************
// 
// Socket Transmit to Socket
//
//************************************************************************************
void transmitdata(LPVOID data)
{
	SOCKET fd1, fd2;
	transocket *sock;
	struct timeval timeset;
	fd_set readfd, writefd;
	int result, i = 0;
	char read_in1[MAXSIZE], send_out1[MAXSIZE];
	char read_in2[MAXSIZE], send_out2[MAXSIZE];
	int read1 = 0, totalread1 = 0, send1 = 0;
	int read2 = 0, totalread2 = 0, send2 = 0;
	int sendcount1, sendcount2;
	int maxfd;
	struct sockaddr_in client1, client2;
	int structsize1, structsize2;
	char host1[20], host2[20];
	int port1 = 0, port2 = 0;
	char tmpbuf[100];

	sock = (transocket *)data;
	fd1 = sock->fd1;
	fd2 = sock->fd2;

	memset(host1, 0, 20);
	memset(host2, 0, 20);
	memset(tmpbuf, 0, 100);

	structsize1 = sizeof(struct sockaddr);
	structsize2 = sizeof(struct sockaddr);

	if (getpeername(fd1, (struct sockaddr *)&client1, &structsize1)<0)
	{
		strcpy(host1, "fd1");
	}
	else
	{
		// printf("[+]got, ip:%s, port:%d\r\n",inet_ntoa(client1.sin_addr),ntohs(client1.sin_port));
		strcpy(host1, inet_ntoa(client1.sin_addr));
		port1 = ntohs(client1.sin_port);
	}

	if (getpeername(fd2, (struct sockaddr *)&client2, &structsize2)<0)
	{
		strcpy(host2, "fd2");
	}
	else
	{
		// printf("[+]got, ip:%s, port:%d\r\n",inet_ntoa(client2.sin_addr),ntohs(client2.sin_port));
		strcpy(host2, inet_ntoa(client2.sin_addr));
		port2 = ntohs(client2.sin_port);
	}

	printf("[+] Start Transmit (%s:%d <-> %s:%d) ......\r\n\n", host1, port1, host2, port2);

	maxfd = max(fd1, fd2) + 1;
	memset(read_in1, 0, MAXSIZE);
	memset(read_in2, 0, MAXSIZE);
	memset(send_out1, 0, MAXSIZE);
	memset(send_out2, 0, MAXSIZE);

	timeset.tv_sec = TIMEOUT;
	timeset.tv_usec = 0;

	while (1)
	{
		FD_ZERO(&readfd);
		FD_ZERO(&writefd);

		FD_SET((UINT)fd1, &readfd);
		FD_SET((UINT)fd1, &writefd);
		FD_SET((UINT)fd2, &writefd);
		FD_SET((UINT)fd2, &readfd);

		result = select(maxfd, &readfd, &writefd, NULL, &timeset);
		if ((result<0) && (errno != EINTR))
		{
			printf("[-] Select error.\r\n");
			break;
		}
		else if (result == 0)
		{
			printf("[-] Socket time out.\r\n");
			break;
		}

		if (FD_ISSET(fd1, &readfd))
		{
			/* must < MAXSIZE-totalread1, otherwise send_out1 will flow */
			if (totalread1 < MAXSIZE

				) {
				read1 = recv(fd1, read_in1, MAXSIZE - totalread1, 0);
				if ((read1 == SOCKET_ERROR) || (read1 == 0))
				{
					printf("[-] Read fd1 data error,maybe close?\r\n");
					break;
				}

				memcpy(send_out1 + totalread1, read_in1, read1);
				sprintf(tmpbuf, "\r\nRecv %5d bytes from %s:%d\r\n", read1, host1, port1);
				printf(" Recv %5d bytes %16s:%d\r\n", read1, host1, port1);
				makelog(tmpbuf, strlen(tmpbuf));
				makelog(read_in1, read1);
				totalread1 += read1;
				memset(read_in1, 0, MAXSIZE);
			}
		}

		if (FD_ISSET(fd2, &writefd))
		{
			int err = 0;
			sendcount1 = 0;
			while (totalread1>0)
			{
				send1 = send(fd2, send_out1 + sendcount1, totalread1, 0);
				if (send1 == 0)break;
				if ((send1<0) && (errno != EINTR))
				{
					printf("[-] Send to fd2 unknow error.\r\n");
					err = 1;
					break;
				}

				if ((send1<0) && (errno == ENOSPC)) break;
				sendcount1 += send1;
				totalread1 -= send1;

				printf(" Send %5d bytes %16s:%d\r\n", send1, host2, port2);
			}

			if (err == 1) break;
			if ((totalread1>0) && (sendcount1>0))
			{
				/* move not sended data to start addr */
				memcpy(send_out1, send_out1 + sendcount1, totalread1);
				memset(send_out1 + totalread1, 0, MAXSIZE - totalread1);
			}
			else
				memset(send_out1, 0, MAXSIZE);
		}

		if (FD_ISSET(fd2, &readfd))
		{
			if (totalread2 < MAXSIZE

				) {
				read2 = recv(fd2, read_in2, MAXSIZE - totalread2, 0);
				if (read2 == 0)break;
				if ((read2<0) && (errno != EINTR))
				{
					printf("[-] Read fd2 data error,maybe close?\r\n\r\n");
					break;
				}

				memcpy(send_out2 + totalread2, read_in2, read2);
				sprintf(tmpbuf, "\r\nRecv %5d bytes from %s:%d\r\n", read2, host2, port2);
				printf(" Recv %5d bytes %16s:%d\r\n", read2, host2, port2);
				makelog(tmpbuf, strlen(tmpbuf));
				makelog(read_in2, read2);
				totalread2 += read2;
				memset(read_in2, 0, MAXSIZE);
			}
		}

		if (FD_ISSET(fd1, &writefd))
		{
			int err2 = 0;
			sendcount2 = 0;
			while (totalread2>0)
			{
				send2 = send(fd1, send_out2 + sendcount2, totalread2, 0);
				if (send2 == 0)break;
				if ((send2<0) && (errno != EINTR))
				{
					printf("[-] Send to fd1 unknow error.\r\n");
					err2 = 1;
					break;
				}
				if ((send2<0) && (errno == ENOSPC)) break;
				sendcount2 += send2;
				totalread2 -= send2;

				printf(" Send %5d bytes %16s:%d\r\n", send2, host1, port1);
			}
			if (err2 == 1) break;
			if ((totalread2>0) && (sendcount2 > 0))
			{
				/* move not sended data to start addr */
				memcpy(send_out2, send_out2 + sendcount2, totalread2);
				memset(send_out2 + totalread2, 0, MAXSIZE - totalread2);
			}
			else
				memset(send_out2, 0, MAXSIZE);
		}

		Sleep(5);
	}

	closesocket(fd1);
	closesocket(fd2);
	printf("\r\n[+] OK! I Closed The Two Socket.\r\n");
}

void getctrlc(int j)
{
	printf("\r\n[-] Received Ctrl+C\r\n");
	closeallfd();
	exit(0);
}

void closeallfd()
{
	int i;

	printf("[+] Let me exit ......\r\n");
	fflush(stdout);

	for (i = 3; i<256; i++)
	{
		closesocket(i);
	}

	if (fp != NULL)
	{
		fprintf(fp, "\r\n====== Exit ======\r\n");
		fclose(fp);
	}

	printf("[+] All Right!\r\n");
}

int create_socket()
{
	int sockfd;

	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd<0)
	{
		printf("[-] Create socket error.\r\n");
		return(0);
	}

	return(sockfd);
}

int create_server(int sockfd, int port)
{
	struct sockaddr_in srvaddr;
	int on = 1;

	memset(&srvaddr, 0, sizeof(struct sockaddr));

	srvaddr.sin_port = htons(port);
	srvaddr.sin_family = AF_INET;
	srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)); //so I can rebind the port

	if (bind(sockfd, (struct sockaddr *)&srvaddr, sizeof(struct sockaddr))<0)
	{
		printf("[-] Socket bind error.\r\n");
		return(0);
	}

	if (listen(sockfd, CONNECTNUM)<0)
	{
		printf("[-] Socket Listen error.\r\n");
		return(0);
	}

	return(1);
}

int client_connect(int sockfd, char* server, int port)
{
	struct sockaddr_in cliaddr;
	struct hostent *host;

	if (!(host = gethostbyname(server)))
	{
		printf("[-] Gethostbyname(%s) error:%s\n", server, strerror(errno));
		return(0);
	}

	memset(&cliaddr, 0, sizeof(struct sockaddr));
	cliaddr.sin_family = AF_INET;
	cliaddr.sin_port = htons(port);
	cliaddr.sin_addr = *((struct in_addr *)host->h_addr);

	if (connect(sockfd, (struct sockaddr *)&cliaddr, sizeof(struct sockaddr))<0)
	{
		printf("[-] Connect error.\r\n");
		return(0);
	}
	return(1);
}

void makelog(char *buffer, int length)
{
	if (fp != NULL)
	{
		write(fileno(fp), buffer, length);
	}
}

Windows7 64+VS2013 原版

#define _WINSOCK_DEPRECATED_NO_WARNINGS
#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <signal.h>
#include <errno.h>
#include <io.h> 
#pragma comment(lib, "ws2_32.lib")
#define VERSION "1.00"
#define TIMEOUT 300
#define MAXSIZE 20480
#define HOSTLEN 40
#define CONNECTNUM 5
// define 2 socket struct
struct transocket
{
	SOCKET fd1;
	SOCKET fd2;
};
// define function 
void ver();
void usage(char *prog);
void transmitdata(LPVOID data);
void getctrlc(int j);
void closeallfd();
void makelog(char *buffer, int length);
void proxy(int port);
void bind2bind(int port1, int port2);
void bind2conn(int port1, char *host, int port2);
void conn2conn(char *host1, int port1, char *host2, int port2);
int testifisvalue(char *str);
int create_socket();
int create_server(int sockfd, int port);
int client_connect(int sockfd, char* server, int port);
// define GLOBAL variable here
//int error;
FILE *fp;
int method = 0;
//int connectnum=0;
//************************************************************************************
// 
// function main 主要是处理用户参数输入的问题
//
//************************************************************************************
VOID main(int argc, char* argv[])
{
	char **p;
	char sConnectHost[HOSTLEN], sTransmitHost[HOSTLEN];
	int iConnectPort = 0, iTransmitPort = 0;
	char *logfile = NULL;
	errno_t err;
	ver();
	memset(sConnectHost, 0, HOSTLEN);
	memset(sTransmitHost, 0, HOSTLEN);
	p = argv;
	while (*p)
	{
		if (_stricmp(*p, "-log") == 0)
		{
			if (testifisvalue(*(p + 1)))
			{
				logfile = *(++p);
			}
			else
			{
				printf("[-] ERROR: Must supply logfile name.\r\n");
				return;
			}
			//p++;
			continue;
		}
		p++;
	}
	if (logfile != NULL)
	{
		//fp = fopen(logfile, "a");
		err = fopen_s(&fp, logfile, "a");
		if (fp == NULL)
		{
			printf("[-] ERROR: open logfile");
			return;
		}
		makelog("====== Start ======\r\n", 22);
	}
	// Win Start Winsock.
	WSADATA wsadata;
	WSAStartup(MAKEWORD(2, 2), &wsadata);
	signal(SIGINT, &getctrlc);
	if (argc > 2)
	{
		if (_stricmp(argv[1], "-listen") == 0 && argc >= 4)
		{
			iConnectPort = atoi(argv[2]);
			iTransmitPort = atoi(argv[3]);
			method = 1;
		}
		else
			if (_stricmp(argv[1], "-tran") == 0 && argc >= 5)
			{
				iConnectPort = atoi(argv[2]);
				strncpy_s(sTransmitHost, argv[3], HOSTLEN);
				iTransmitPort = atoi(argv[4]);
				method = 2;
			}
			else
				if (_stricmp(argv[1], "-slave") == 0 && argc >= 6)
				{
					strncpy_s(sConnectHost, argv[2], HOSTLEN);
					iConnectPort = atoi(argv[3]);
					strncpy_s(sTransmitHost, argv[4], HOSTLEN);
					iTransmitPort = atoi(argv[5]);
					method = 3;
				}
	}
	switch (method)
	{
	case 1:
		bind2bind(iConnectPort, iTransmitPort);
		break;
	case 2:
		bind2conn(iConnectPort, sTransmitHost, iTransmitPort);
		break;
	case 3:
		conn2conn(sConnectHost, iConnectPort, sTransmitHost, iTransmitPort);
		break;
	default:
		usage(argv[0]);
		break;
	}
	if (method)
	{
		closeallfd();
	}
	WSACleanup();
	return;
}
//************************************************************************************
// 
// print version message
//
//************************************************************************************
VOID ver()
{
	printf("======================== Port Forwarding Tool V%s =======================\r\n", VERSION);
	printf("========================== Improved by pandas ===========================\r\n\n");
}
//************************************************************************************
// 
// print usage message
//
//************************************************************************************
VOID usage(char* prog)
{
	printf("[Usage of Packet Transmit:]\r\n");
	printf(" %s - [-log logfile]\n\n", prog);
	printf("[option:]\n");
	printf(" -listen \n");
	printf(" -tran \n");
	printf(" -slave \n\n");
	return;
}
//************************************************************************************
// 
// test if is value 
//
//************************************************************************************
int testifisvalue(char *str)
{
	if (str == NULL) return(0);
	if (str[0] == '-') return(0);
	return(1);
}
//************************************************************************************
// 
// LocalHost:ConnectPort transmit to LocalHost:TransmitPort
//
//************************************************************************************
void bind2bind(int port1, int port2)
{
	SOCKET fd1, fd2, sockfd1, sockfd2;
	struct sockaddr_in client1, client2;
	int size1, size2;
	HANDLE hThread = NULL;
	transocket sock;
	DWORD dwThreadID;
	if ((fd1 = create_socket()) == 0) return;
	if ((fd2 = create_socket()) == 0) return;
	printf("[+] Listening port %d ......\r\n", port1);
	fflush(stdout);
	if (create_server(fd1, port1) == 0)
	{
		closesocket(fd1);
		return;
	}
	printf("[+] Listen OK!\r\n");
	printf("[+] Listening port %d ......\r\n", port2);
	fflush(stdout);
	if (create_server(fd2, port2) == 0)
	{
		closesocket(fd2);
		return;
	}
	printf("[+] Listen OK!\r\n");
	size1 = size2 = sizeof(struct sockaddr);
	while (1)
	{
		printf("[+] Waiting for Client on port:%d ......\r\n", port1);
		if ((sockfd1 = accept(fd1, (struct sockaddr *)&client1, &size1))<0)
		{
			printf("[-] Accept1 error.\r\n");
			continue;
		}
		printf("[+] Accept a Client on port %d from %s ......\r\n", port1, inet_ntoa(client1.sin_addr));
		printf("[+] Waiting another Client on port:%d....\r\n", port2);
		if ((sockfd2 = accept(fd2, (struct sockaddr *)&client2, &size2))<0)
		{
			printf("[-] Accept2 error.\r\n");
			closesocket(sockfd1);
			continue;
		}
		printf("[+] Accept a Client on port %d from %s\r\n", port2, inet_ntoa(client2.sin_addr));
		printf("[+] Accept Connect OK!\r\n");
		sock.fd1 = sockfd1;
		sock.fd2 = sockfd2;
		hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;
		}
		Sleep(1000);
		printf("[+] CreateThread OK!\r\n\n");
	}
}
//************************************************************************************
// 
// LocalHost:ConnectPort transmit to TransmitHost:TransmitPort
//
//************************************************************************************
void bind2conn(int port1, char *host, int port2)
{
	SOCKET sockfd, sockfd1, sockfd2;
	struct sockaddr_in remote;
	int size;
	char buffer[1024];
	HANDLE hThread = NULL;
	transocket sock;
	DWORD dwThreadID;
	if (port1 > 65535 || port1 < 1)
	{
		printf("[-] ConnectPort invalid.\r\n");
		return;
	}
	if (port2 > 65535 || port2 < 1)
	{
		printf("[-] TransmitPort invalid.\r\n");
		return;
	}
	memset(buffer, 0, 1024);
	if ((sockfd = create_socket()) == INVALID_SOCKET) return;
	if (create_server(sockfd, port1) == 0)
	{
		closesocket(sockfd);
		return;
	}
	size = sizeof(struct sockaddr);
	while (1)
	{
		printf("[+] Waiting for Client ......\r\n");
		if ((sockfd1 = accept(sockfd, (struct sockaddr *)&remote, &size))<0)
		{
			printf("[-] Accept error.\r\n");
			continue;
		}
		printf("[+] Accept a Client from %s:%d ......\r\n",
			inet_ntoa(remote.sin_addr), ntohs(remote.sin_port));
		if ((sockfd2 = create_socket()) == 0)
		{
			closesocket(sockfd1);
			continue;
		}
		printf("[+] Make a Connection to %s:%d ......\r\n", host, port2);
		fflush(stdout);
		if (client_connect(sockfd2, host, port2) == 0)
		{
			closesocket(sockfd2);
			sprintf_s(buffer, "[SERVER]connection to %s:%d error\r\n", host, port2);
			send(sockfd1, buffer, strlen(buffer), 0);
			memset(buffer, 0, 1024);
			closesocket(sockfd1);
			continue;
		}
		printf("[+] Connect OK!\r\n");
		sock.fd1 = sockfd1;
		sock.fd2 = sockfd2;
		hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;
		}
		Sleep(1000);
		printf("[+] CreateThread OK!\r\n\n");
	}
}
//************************************************************************************
// 
// ConnectHost:ConnectPort transmit to TransmitHost:TransmitPort
//
//************************************************************************************
void conn2conn(char *host1, int port1, char *host2, int port2)
{
	SOCKET sockfd1, sockfd2;
	HANDLE hThread = NULL;
	transocket sock;
	DWORD dwThreadID;
	fd_set fds;
	int l;
	char buffer[MAXSIZE];
	while (1)
	{
		/*
		while(connectnum)
		{
		if(connectnum < CONNECTNUM)
		{
		Sleep(10000);
		break;
		}
		else
		{
		Sleep(TIMEOUT*1000);
		continue;
		}
		}
		*/
		if ((sockfd1 = create_socket()) == 0) return;
		if ((sockfd2 = create_socket()) == 0) return;
		printf("[+] Make a Connection to %s:%d....\r\n", host1, port1);
		fflush(stdout);
		if (client_connect(sockfd1, host1, port1) == 0)
		{
			closesocket(sockfd1);
			closesocket(sockfd2);
			continue;
		}
		// fix by bkbll 
		// if host1:port1 recved data, than connect to host2,port2
		l = 0;
		memset(buffer, 0, MAXSIZE);
		while (1)
		{
			FD_ZERO(&fds);
			FD_SET(sockfd1, &fds);
			if (select(sockfd1 + 1, &fds, NULL, NULL, NULL) == SOCKET_ERROR)
			{
				if (errno == WSAEINTR) continue;
				break;
			}
			if (FD_ISSET(sockfd1, &fds))
			{
				l = recv(sockfd1, buffer, MAXSIZE, 0);
				break;
			}
			Sleep(5);
		}
		if (l <= 0)
		{
			printf("[-] There is a error...Create a new connection.\r\n");
			continue;
		}
		while (1)
		{
			printf("[+] Connect OK!\r\n");
			printf("[+] Make a Connection to %s:%d....\r\n", host2, port2);
			fflush(stdout);
			if (client_connect(sockfd2, host2, port2) == 0)
			{
				closesocket(sockfd1);
				closesocket(sockfd2);
				continue;
			}
			if (send(sockfd2, buffer, l, 0) == SOCKET_ERROR)
			{
				printf("[-] Send failed.\r\n");
				continue;
			}
			l = 0;
			memset(buffer, 0, MAXSIZE);
			break;
		}
		printf("[+] All Connect OK!\r\n");
		sock.fd1 = sockfd1;
		sock.fd2 = sockfd2;
		hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID);
		if (hThread == NULL)
		{
			TerminateThread(hThread, 0);
			return;
		}
		// connectnum++;
		Sleep(1000);
		printf("[+] CreateThread OK!\r\n\n");
	}
}
//************************************************************************************
// 
// Socket Transmit to Socket
//
//************************************************************************************
void transmitdata(LPVOID data)
{
	SOCKET fd1, fd2;
	transocket *sock;
	struct timeval timeset;
	fd_set readfd, writefd;
	int result, i = 0;
	char read_in1[MAXSIZE], send_out1[MAXSIZE];
	char read_in2[MAXSIZE], send_out2[MAXSIZE];
	int read1 = 0, totalread1 = 0, send1 = 0;
	int read2 = 0, totalread2 = 0, send2 = 0;
	int sendcount1, sendcount2;
	int maxfd;
	struct sockaddr_in client1, client2;
	int structsize1, structsize2;
	char host1[20], host2[20];
	int port1 = 0, port2 = 0;
	char tmpbuf[100];
	sock = (transocket *)data;
	fd1 = sock->fd1;
	fd2 = sock->fd2;
	memset(host1, 0, 20);
	memset(host2, 0, 20);
	memset(tmpbuf, 0, 100);
	structsize1 = sizeof(struct sockaddr);
	structsize2 = sizeof(struct sockaddr);
	if (getpeername(fd1, (struct sockaddr *)&client1, &structsize1)<0)
	{
		strcpy_s(host1, "fd1");
	}
	else
	{
		// printf("[+]got, ip:%s, port:%d\r\n",inet_ntoa(client1.sin_addr),ntohs(client1.sin_port));
		strcpy_s(host1, inet_ntoa(client1.sin_addr));
		port1 = ntohs(client1.sin_port);
	}
	if (getpeername(fd2, (struct sockaddr *)&client2, &structsize2)<0)
	{
		strcpy_s(host2, "fd2");
	}
	else
	{
		// printf("[+]got, ip:%s, port:%d\r\n",inet_ntoa(client2.sin_addr),ntohs(client2.sin_port));
		strcpy_s(host2, inet_ntoa(client2.sin_addr));
		port2 = ntohs(client2.sin_port);
	}
	printf("[+] Start Transmit (%s:%d <-> %s:%d) ......\r\n\n", host1, port1, host2, port2);
	maxfd = max(fd1, fd2) + 1;
	memset(read_in1, 0, MAXSIZE);
	memset(read_in2, 0, MAXSIZE);
	memset(send_out1, 0, MAXSIZE);
	memset(send_out2, 0, MAXSIZE);
	timeset.tv_sec = TIMEOUT;
	timeset.tv_usec = 0;
	while (1)
	{
		FD_ZERO(&readfd);
		FD_ZERO(&writefd);
		FD_SET((UINT)fd1, &readfd);
		FD_SET((UINT)fd1, &writefd);
		FD_SET((UINT)fd2, &writefd);
		FD_SET((UINT)fd2, &readfd);
		result = select(maxfd, &readfd, &writefd, NULL, &timeset);
		if ((result<0) && (errno != EINTR))
		{
			printf("[-] Select error.\r\n");
			break;
		}
		else if (result == 0)
		{
			printf("[-] Socket time out.\r\n");
			break;
		}
		if (FD_ISSET(fd1, &readfd))
		{
			/* must < MAXSIZE-totalread1, otherwise send_out1 will flow */
			if (totalread1 < MAXSIZE) {
				read1 = recv(fd1, read_in1, MAXSIZE - totalread1, 0);
				if ((read1 == SOCKET_ERROR) || (read1 == 0))
				{
					printf("[-] Read fd1 data error,maybe close?\r\n");
					break;
				}
				memcpy(send_out1 + totalread1, read_in1, read1);
				sprintf_s(tmpbuf, "\r\nRecv %5d bytes from %s:%d\r\n", read1, host1, port1);
				printf(" Recv %5d bytes %16s:%d\r\n", read1, host1, port1);
				makelog(tmpbuf, strlen(tmpbuf));
				makelog(read_in1, read1);
				totalread1 += read1;
				memset(read_in1, 0, MAXSIZE);
			}
		}
		if (FD_ISSET(fd2, &writefd))
		{
			int err = 0;
			sendcount1 = 0;
			while (totalread1>0)
			{
				send1 = send(fd2, send_out1 + sendcount1, totalread1, 0);
				if (send1 == 0)break;
				if ((send1<0) && (errno != EINTR))
				{
					printf("[-] Send to fd2 unknow error.\r\n");
					err = 1;
					break;
				}
				if ((send1<0) && (errno == ENOSPC)) break;
				sendcount1 += send1;
				totalread1 -= send1;
				printf(" Send %5d bytes %16s:%d\r\n", send1, host2, port2);
			}
			if (err == 1) break;
			if ((totalread1>0) && (sendcount1>0))
			{
				/* move not sended data to start addr */
				memcpy(send_out1, send_out1 + sendcount1, totalread1);
				memset(send_out1 + totalread1, 0, MAXSIZE - totalread1);
			}
			else
				memset(send_out1, 0, MAXSIZE);
		}
		if (FD_ISSET(fd2, &readfd))
		{
			if (totalread2 < MAXSIZE) {
				read2 = recv(fd2, read_in2, MAXSIZE - totalread2, 0);
				if (read2 == 0)break;
				if ((read2<0) && (errno != EINTR))
				{
					printf("[-] Read fd2 data error,maybe close?\r\n\r\n");
					break;
				}
				memcpy(send_out2 + totalread2, read_in2, read2);
				sprintf_s(tmpbuf, "\r\nRecv %5d bytes from %s:%d\r\n", read2, host2, port2);
				printf(" Recv %5d bytes %16s:%d\r\n", read2, host2, port2);
				makelog(tmpbuf, strlen(tmpbuf));
				makelog(read_in2, read2);
				totalread2 += read2;
				memset(read_in2, 0, MAXSIZE);
			}
		}
		if (FD_ISSET(fd1, &writefd))
		{
			int err2 = 0;
			sendcount2 = 0;
			while (totalread2>0)
			{
				send2 = send(fd1, send_out2 + sendcount2, totalread2, 0);
				if (send2 == 0)break;
				if ((send2<0) && (errno != EINTR))
				{
					printf("[-] Send to fd1 unknow error.\r\n");
					err2 = 1;
					break;
				}
				if ((send2<0) && (errno == ENOSPC)) break;
				sendcount2 += send2;
				totalread2 -= send2;
				printf(" Send %5d bytes %16s:%d\r\n", send2, host1, port1);
			}
			if (err2 == 1) break;
			if ((totalread2>0) && (sendcount2 > 0))
			{
				/* move not sended data to start addr */
				memcpy(send_out2, send_out2 + sendcount2, totalread2);
				memset(send_out2 + totalread2, 0, MAXSIZE - totalread2);
			}
			else
				memset(send_out2, 0, MAXSIZE);
		}
		Sleep(5);
	}
	closesocket(fd1);
	closesocket(fd2);
	// if(method == 3)
	// connectnum --;
	printf("\r\n[+] OK! I Closed The Two Socket.\r\n");
}
void getctrlc(int j)
{
	printf("\r\n[-] Received Ctrl+C\r\n");
	closeallfd();
	exit(0);
}
void closeallfd()
{
	int i;
	printf("[+] Let me exit ......\r\n");
	fflush(stdout);
	for (i = 3; i<256; i++)
	{
		closesocket(i);
	}
	if (fp != NULL)
	{
		fprintf(fp, "\r\n====== Exit ======\r\n");
		fclose(fp);
	}
	printf("[+] All Right!\r\n");
}
int create_socket()
{
	int sockfd;
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd<0)
	{
		printf("[-] Create socket error.\r\n");
		return(0);
	}
	return(sockfd);
}
int create_server(int sockfd, int port)
{
	struct sockaddr_in srvaddr;
	int on = 1;
	memset(&srvaddr, 0, sizeof(struct sockaddr));
	srvaddr.sin_port = htons(port);
	srvaddr.sin_family = AF_INET;
	srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)); //so I can rebind the port
	if (bind(sockfd, (struct sockaddr *)&srvaddr, sizeof(struct sockaddr))<0)
	{
		printf("[-] Socket bind error.\r\n");
		return(0);
	}
	if (listen(sockfd, CONNECTNUM)<0)
	{
		printf("[-] Socket Listen error.\r\n");
		return(0);
	}
	return(1);
}
int client_connect(int sockfd, char* server, int port)
{
	struct sockaddr_in cliaddr;
	struct hostent *host;
	if (!(host = gethostbyname(server)))
	{
		printf("[-] Gethostbyname(%s) error:%s\n", server, strerror(errno));
		return(0);
	}
	memset(&cliaddr, 0, sizeof(struct sockaddr));
	cliaddr.sin_family = AF_INET;
	cliaddr.sin_port = htons(port);
	cliaddr.sin_addr = *((struct in_addr *)host->h_addr);
	if (connect(sockfd, (struct sockaddr *)&cliaddr, sizeof(struct sockaddr))<0)
	{
		printf("[-] Connect error.\r\n");
		return(0);
	}
	return(1);
}
void makelog(char *buffer, int length)
{
	if (fp != NULL)
	{
		_write(_fileno(fp), buffer, length);
	}
}