httpproxy.cpp

httpproxy,采用vc++实现的

// HTTPPROXY.cpp: implementation of the CHTTPPROXY class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "HttpProxyServer.h"
#include "HTTPPROXY.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

int HttpListenPort; //http代理服务器监听端口
SOCKET HttpListenSock;  //http代理服务器监听socket
CLIENTINFO HttpClientInfo;
SOCKINFO httpsockinfo;


long GetSocketEventId(SOCKET remotesock) //得到remoteSock的各种网络事件
{
  return 0;
  /**
  long EventId;
  HANDLE hevent;
  hevent=CreateEvent(NULL,0,0,0);
  WSANETWORKEVENTS socket_events;
  EventId=FD_NOEVENT;
  if(WSAEventSelect(remotesock,hevent,FD_ACCEPT|FD_CONNECT|FD_READ|FD_WRITE|FD_CLOSE)==SOCKET_ERROR)
    return EventId;
  WSAEnumNetworkEvents(remotesock,hevent,&socket_events);
  if(socket_events.lNetworkEvents!=0){
    switch(socket_events.lNetworkEvents){
      case FD_ACCEPT:
	    EventId=FD_ACCEPT;
	    break;
      case FD_CONNECT:
	    EventId=FD_CONNECT;
	    break;
      case FD_READ:
	    EventId=FD_READ;
	    break;
      case FD_WRITE:
	    EventId=FD_WRITE;
	    break;
      case FD_CLOSE:
	    EventId=FD_CLOSE;
	    break;
      case FD_OOB:
	    EventId=FD_OOB;
	    break;
      default:
	    EventId=FD_NOEVENT;
	    break;
	}
  } else {
    EventId=FD_NOEVENT;
  }
  return EventId;**/
}

unsigned long GetLocalIp()
{
  char IP[MAX_PATH],*ip;
  char pc_name[80];
  struct in_addr in;
  struct hostent *host;
  WORD wVersionRequested;
  WSADATA wsaData;
  wVersionRequested=MAKEWORD(2,0);
  ip=IP;
  strcpy(ip,"Ip not get!");
  if(WSAStartup(wVersionRequested,&wsaData)) return 0;
  if(gethostname(pc_name,80)==SOCKET_ERROR){
    WSACleanup();
    return 0;
  }
  if(!(host=gethostbyname(pc_name))){
   WSACleanup();
   return 0;
  }
  in.s_addr=*((unsigned long *)host->h_addr_list[0]);
  strcpy(ip,inet_ntoa(in));
  WSACleanup();
  return in.s_addr;
}


unsigned long GetDomainIp(char domainname[250])
{
  char IP[MAX_PATH],*ip;
  struct in_addr in;
  struct hostent *host;
  WORD wVersionRequested;
  WSADATA wsaData;
  wVersionRequested=MAKEWORD(2,0);
  ip=IP;
  strcpy(ip,"Ip not get!");
  if(WSAStartup(wVersionRequested,&wsaData)) return 0;
  if(!(host=gethostbyname(domainname))){
    WSACleanup();
    return 0;
  }
  in.s_addr=*((unsigned long *)host->h_addr_list[0]);
  strcpy(ip,inet_ntoa(in));
  WSACleanup();
  return in.s_addr;
}


UINT HttpReciveThread(LPVOID info)  //接受源主机请求包并转发给目标主机
{ 
  LPSOCKINFO psockinfo; 
  SOCKET sourcesock,destsock;
  char data[MAXDATALEN];
  long eventid;
  int datalen;
  psockinfo=(LPSOCKINFO)info;
  sourcesock=psockinfo->sourcesock;
  destsock=psockinfo->destsock;
  TRACE("deail recive thread ok!\r\n");
  while(true){
    eventid=GetSocketEventId(sourcesock);
    switch(eventid){
      case FD_CLOSE:
        TRACE("s fdclosed\r\n");
        closesocket(destsock);
        return 1;
        break;
      default:break;
	}
    eventid=GetSocketEventId(destsock);
    switch(eventid){
      case FD_CLOSE:
      closesocket(sourcesock);
      TRACE("d fdclosed\r\n");
      return 1;
      break;
      default:break;
	}
    datalen=recv(sourcesock,data,sizeof(data),0);
    if(datalen==0){
      closesocket(sourcesock);
      closesocket(destsock);
      TRACE("s fdclosed\r\n");
      break;
	}
    if(datalen>0){
      while(!send(destsock,data,datalen,0));
	}
    Sleep(1);
  }
  return 1;
}


UINT HttpSendThread(LPVOID info) //接受远程主机响应包并返回给源主机
{ 
  LPSOCKINFO psockinfo;
  SOCKET sourcesock,destsock;
  char data[MAXDATALEN];
  long eventid;
  int datalen;
  psockinfo=(LPSOCKINFO)info;
  sourcesock=psockinfo->sourcesock;
  destsock=psockinfo->destsock;
  TRACE("deail send thread ok!\r\n");
  while(true){
    eventid=GetSocketEventId(sourcesock);
    switch(eventid){
      case FD_CLOSE:
        TRACE("s fdclosed\r\n");
        closesocket(destsock);
        return 1;
        break;
      default:break;
	}
    eventid=GetSocketEventId(destsock);
    switch(eventid){
      case FD_CLOSE:
        closesocket(sourcesock);
        TRACE("d fdclosed\r\n");
        return 1;
        break;
      default:break;
	}
    datalen=recv(destsock,data,sizeof(data),0);
    if(datalen==0){
      closesocket(sourcesock);
      closesocket(destsock);
      TRACE("d fdclosed\r\n");
      break;
	}
    if(datalen>0){
      while(!send(sourcesock,data,datalen,0));
	}
    Sleep(1);
  }
  return 1;
}


UINT HttpProxyServerThread(LPVOID info) //针对一次请求的服务线程
{ 
  LPCLIENTINFO pclientinfo;     //定义客户端结构体指针
  SOCKET connectsock,clientsock;
  sockaddr_in remotesock_addr;
  char data[MAXDATALEN],url[250],temp[250],httpurl[250],portnum[10];
  int datalen,index_start,index_end,port;//,i;
  CString HttpString,UrlString,PortString;
  pclientinfo=(LPCLIENTINFO)info; //pclientinfo指针指向客户端结构体地址
  clientsock=pclientinfo->clientsock; //获得客户端的socket
  ZeroMemory((void *)data,sizeof(data));
  datalen=recv(clientsock,data,sizeof(data),0); //获得客户端的请求信息
  if(datalen<=0){
    closesocket(clientsock);
    return 0;
  }
  HttpString.Format("%s",data);
  UrlString=HttpString; //得到http协议请求字符串
  TRACE("get http string:\r\n");
  TRACE(HttpString);
  index_start=HttpString.Find("Host: ",0); //寻找主机标记
  if(index_start<=0){ //没找到退出
    closesocket(clientsock);
    return 0;
  }
  index_end=HttpString.Find("\r\n",index_start);
  if(index_end<=0){
    closesocket(clientsock);
    return 0;
  }
  UrlString=HttpString.Mid(index_start+6,index_end-index_start-6); //读取主机字符串
  TRACE("\r\n get url:");
  TRACE(UrlString);
  wsprintf(url,"%s",UrlString);
  strcpy(temp,url);
  strcat(temp,":");
  datalen=strlen(temp);
  if(HttpString.Find("GET",0)==0){ //判断get命令，并处理
    index_start=HttpString.Find(temp,0);
    strcpy(httpurl,"http://");
    if(index_start>0){
      index_end=HttpString.Find("/",index_start);
      if(index_end<=0){
        closesocket(clientsock);
        return 0;
	  }
      PortString=HttpString.Mid(index_start+datalen,index_end-index_start-datalen);
      port=atoi(PortString);
      strcat(httpurl,temp);
      itoa(port,portnum,sizeof(portnum));
      strcat(httpurl,portnum);
      strcat(httpurl,"/"); 
	}
    else{
      port=80;
      strcat(httpurl,url);
      strcat(httpurl,"/");
	}
    TRACE("get http url:%s\r\n",httpurl);
    HttpString.Replace(httpurl,"/");
    HttpString.Replace("Proxy-","");
    HttpString.Replace("HTTP/1.0","HTTP/1.1");
  }
  else if(HttpString.Find("CONNECT",0)==0){ //判断connect命令并处理
    index_start=HttpString.Find(temp,0);
    if(index_start>0){
      index_end=HttpString.Find(" ",index_start);
      if(index_end<=0){
        closesocket(clientsock);
        return 0;
	  }
      PortString=HttpString.Mid(index_start+datalen,index_end-index_start-datalen);
      port=atoi(PortString);
	}
    else{
      closesocket(clientsock);
      return 0;
    }
  }
  TRACE("get new http string:\r\n");
  TRACE(HttpString);
  remotesock_addr.sin_family=AF_INET;
  remotesock_addr.sin_port=htons(port);
  remotesock_addr.sin_addr.S_un.S_addr=GetDomainIp(url);
  connectsock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  if(connect(connectsock,(const sockaddr *)&remotesock_addr,sizeof(remotesock_addr))==INVALID_SOCKET){ //连接远程主机
    closesocket(clientsock);
    return 0;
  }
  TRACE("\r\nconnect to remote ip ok\r\n"); 
  ZeroMemory((void *)data,sizeof(data));
  wsprintf(data,"%s",HttpString);
  datalen=strlen(data);
  if(HttpString.Find("CONNECT",0)<0) while(!send(connectsock,data,datalen,0));
  else{
    strcpy(data,"HTTP/1.0 200 Connection established\r\nProxy-agent: CHTTPPROXY V1.0 powered by shadow\r\n\r\n");
    datalen=strlen(data);
    while(!send(clientsock,data,datalen,0));
  }
  httpsockinfo.sourcesock=clientsock;
  httpsockinfo.destsock=connectsock;
  AfxBeginThread(HttpReciveThread,(LPVOID)&httpsockinfo); //抛出处理线程 
  AfxBeginThread(HttpSendThread,(LPVOID)&httpsockinfo); //
  Sleep(100);
  return 1;
}



UINT StartHttpProxy(LPVOID info) //端口监听线程
{ 
  SOCKET NewSock;     //保存监听到的远程客户端socket
  int socklen;
  sockaddr_in serversock,remotesock_addr;
  serversock.sin_family=AF_INET;
  serversock.sin_addr.S_un.S_addr=INADDR_ANY;
  serversock.sin_port=htons(HttpListenPort);
  HttpListenSock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); //建立监听套接字
  if(HttpListenSock==INVALID_SOCKET) return 0;
  if(bind(HttpListenSock,(const sockaddr *)&serversock,sizeof(serversock))==SOCKET_ERROR) 
	return 0;
  listen(HttpListenSock,BACKUP);                          //开始监听
  socklen=sizeof(remotesock_addr);
  TRACE("start http proxy thread while\r\n");
  while(true){                                            //无限循环监听客户连接
    NewSock=accept(HttpListenSock,(sockaddr *)&remotesock_addr,&socklen);
    TRACE("waitting ok...\r\n");
    if(NewSock==INVALID_SOCKET){
      Sleep(1);
      continue;
	}
    ZeroMemory((void *)&HttpClientInfo,sizeof(CLIENTINFO)); //清空HttpClientInfo结构
    HttpClientInfo.clientsock=NewSock;   //监听到请求客户端的socket
    HttpClientInfo.clientsock_addr=remotesock_addr; //保存请求客户端的信息
    TRACE("start proxy thread\r\n");
    AfxBeginThread(HttpProxyServerThread,(LPVOID)&HttpClientInfo); //启动代理服务线程
    Sleep(100);
  }
  return 1;
}


int CHTTPPROXY::StartProxy(int listenport)
{
  HttpListenPort=listenport;
  AfxBeginThread(StartHttpProxy,(LPVOID)NULL);
  return 1;
}

CHTTPPROXY::CHTTPPROXY()
{
  WSADATA WsaData;
  WORD wsaVer;
  wsaVer=MAKEWORD(2,0);
  WsaStartupOk=false;
  if(WSAStartup(wsaVer,&WsaData)!=SOCKET_ERROR) WsaStartupOk=true;
}
CHTTPPROXY::~CHTTPPROXY()
{
  if(WsaStartupOk){
    WSACleanup();
  }
}