CHttpProxyServer

最新推荐文章于 2022-04-17 09:49:54 发布
最新推荐文章于 2022-04-17 09:49:54 发布
阅读量1.8k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq125096885/article/details/51445301

HttpProxy.h

#ifndef  HTTPROXY_HEAD_FILE
#define HTTPROXY_HEAD_FILE
#pragma once
#include <windows.h>
#include <stdio.h>
#include <wininet.h>
#include <errno.h>
#include <tchar.h>
#include <assert.h>
#pragma comment(lib,"Ws2_32.lib")


//删除指针
#define SafeDelete(pData){if (pData) {free(pData);pData=NULL;}} 
//关闭句柄删除指针
#define SafeCloseHandleDelete(pData){if (pData){closesocket(pData[0]);closesocket(pData[1]);free(pData);pData=NULL;}}



//宏定义
#define					MAX_HOSTNAME								1024			//最大主机名称
#define					DEFAULTPORT											80			//默认主机端口
#define					LISTENPORT											8000			//代理服务器监听端口
#define					DEFLISNUM												500			//linsten最大队列
#define					HEADLEN														7			//http://头长度
#define					TIMEOUT												10000			//recv延时时间	
#define					MAXSIZE												20480			//缓冲大小
#define					GET_STYLE														1			//get请求类型			请求指定的页面信息，并返回实体主体
#define					HEAD_STYLE													2			//head请求类型			只请求页面的首部
#define					POST_STYLE													3			//post请求类型			请求服务器接受所指定的文档作为对所标识的URI的新的从属实体
#define					CONNECT_STYLE											4			//connect请求类型
#define					ErrorMsg	"HTTP/1.1 403 Forbidden\r\n\r\n<body><h1>403 Forbidden</h1></body>"
#define					ConnectionEstablished		"HTTP/1.0 200 OK\r\n\r\n"

//char ErrorMsg[]="HTTP/1.1 403 Forbidden\r\n\r\n<body><h1>403 Forbidden</h1></body>";			//SOCK错误消息
//char ConnectionEstablished[]="HTTP/1.0 200 OK\r\n\r\n";																					//HTTP成功


//HTTP代理服务器
class CHttpProxyServer
{
	//变量定义
public:
	SOCKET												m_ProxyServer;					//sock句柄
	UINT													m_nPort;								//监听端口

	//静态变量
protected:
	static CHttpProxyServer *			m_pHttpProxyServer;				//对象指针

	//函数定义
public:
	//构造函数
	CHttpProxyServer();
	//析构函数
	~CHttpProxyServer();

	//辅助函数
protected:
	// 地址解释
	DWORD TranslateAddr(char* pszServerAddr);

	//功能函数
public:
	//启动服务
	BOOL OnStart(int nPort=LISTENPORT);
	//发送请求
	static BOOL  SendRequest(SOCKET* CSsocket, char *SenderBuf, char *ReceiveBuf, int DataLen);
	//查询请求
	static int   CheckRequest(char *ReceiveBuf,int *MethodLength);
	//修改请求 
	static int   ModifyRequest(char *SenderBuf,char *ReceiveBuf,int DataLen,int MethodLength);
	//获取根目录节点
	static char  *GetURLRootPoint(char * ReceiveBuf,int DataLen,int *HostNaneLen);
	//获取主机名和端口
	static void  GetHostNameAndPort(char *ReceiveBuf,int datalen,char *HostName,UINT *RemotePort);
	//连接远程主机
	static BOOL  ConnectToRemoteHost(SOCKET *ServerSocket,char *HostName,const UINT RemotePort);
	//主机名解析IP地址
	static char  *DNS(char *HostName);


	//线程函数
protected:
	//启动服务线程
	static DWORD   StartThread( LPVOID lpParameter);
	//HTTP代理线程
	static DWORD   ZXHTTPProxyThread(LPVOID lpParameter);
	//信息传递线程 
	static DWORD  TransferData(LPVOID lpParameter);

	//静态函数
public:
	//获取对象
	static CHttpProxyServer * GetInstance() { return m_pHttpProxyServer; }
};



#endif


HttpProxy.cpp

#include "HttpProxy.h"

//////////////////////////////////////////////////////////////////////////////////

//静态变量
CHttpProxyServer *			CHttpProxyServer::m_pHttpProxyServer=NULL;					//对象指针

//////////////////////////////////////////////////////////////////////////////////

//构造函数
CHttpProxyServer::CHttpProxyServer()
{
	//设置对象
	assert(m_pHttpProxyServer==NULL);
	if (m_pHttpProxyServer==NULL)m_pHttpProxyServer=this;

	//初始化变量
	m_ProxyServer=INVALID_SOCKET;
	m_nPort=LISTENPORT;

	//初始化网络库
	WSADATA WSAData;
	WSAStartup(MAKEWORD(2,2), &WSAData);
}

//析构函数
CHttpProxyServer::~CHttpProxyServer()
{
	WSACleanup( );
}

//启动服务
BOOL CHttpProxyServer::OnStart(int nPort)
{
	//参数效验
	assert(m_ProxyServer==INVALID_SOCKET);
	assert(nPort>0 && nPort<65535);
	if (m_ProxyServer!=INVALID_SOCKET)return FALSE;
	if (nPort<0 || nPort>=65535)return FALSE;

	//创建socket
	m_ProxyServer= socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	assert(m_ProxyServer!=SOCKET_ERROR);
	if(m_ProxyServer == SOCKET_ERROR)return FALSE;

	//设置变量
	m_nPort=nPort;

	//创建线程启动服务
	HANDLE hThread=CreateThread(NULL,NULL,(LPTHREAD_START_ROUTINE)StartThread,this,NULL,NULL);
	CloseHandle(hThread);

	return TRUE;
}


//启动服务线程
DWORD   CHttpProxyServer::StartThread( LPVOID lpParameter)
{
	//设置变量
	CHttpProxyServer* pHttpProxyServer=(CHttpProxyServer*)lpParameter;
	assert(pHttpProxyServer!=NULL);
	if (pHttpProxyServer==NULL)return false;

	//绑定端口
	struct sockaddr_in Server={0};
	Server.sin_family = AF_INET;
	Server.sin_port = htons(pHttpProxyServer->m_nPort);
	Server.sin_addr.S_un.S_addr = INADDR_ANY;
	if(bind(pHttpProxyServer->m_ProxyServer, (LPSOCKADDR)&Server, sizeof(Server)) == SOCKET_ERROR) return FALSE;


	//监听连接
	if(listen(pHttpProxyServer->m_ProxyServer, DEFLISNUM) == SOCKET_ERROR)return FALSE;

	//定义变量
	SOCKET AcceptSocket = INVALID_SOCKET;
	SOCKET *CSsocket=NULL;
	while(true)
	{
		//接受客户端连接
		AcceptSocket = accept(pHttpProxyServer->m_ProxyServer, NULL, NULL);
		CSsocket = (SOCKET*)malloc(sizeof(SOCKET)*2);
		if (CSsocket == NULL)continue;

		//创建线程处理客户端连接请求
		CSsocket[0] = AcceptSocket;
		HANDLE hThread = CreateThread (NULL,0, (LPTHREAD_START_ROUTINE)ZXHTTPProxyThread,CSsocket,NULL,NULL); 
		if (hThread == NULL) Sleep(1000);
		else CloseHandle(hThread);
	}

	return true;
}

//HTTP代理线程
DWORD   CHttpProxyServer::ZXHTTPProxyThread(LPVOID lpParameter)
{
	//设置变量
	SOCKET* CSsocket=(SOCKET*)lpParameter;
	assert(CSsocket!=NULL);
	if (CSsocket==NULL)return false;

	//分配内存
	char *ReceiveBuf = (char*)malloc(sizeof(char)*MAXSIZE);
	char *SenderBuf  = (char*)malloc(sizeof(char)*MAXSIZE);
	memset(ReceiveBuf,0,MAXSIZE);
	memset( SenderBuf,0,MAXSIZE);

	//接受数据
	int DataLen = 0;
	DataLen = recv(CSsocket[0],ReceiveBuf,MAXSIZE,0);
	if(DataLen == SOCKET_ERROR || DataLen == 0)
	{
		SafeDelete(ReceiveBuf);
		SafeDelete(SenderBuf);
		SafeCloseHandleDelete(CSsocket);
		return 0;
	}

	//发送请求
	if(SendRequest(CSsocket, SenderBuf, ReceiveBuf, DataLen)==FALSE)
		send(CSsocket[0],ErrorMsg,strlen(ErrorMsg),0);


	//清理资源
	SafeDelete(ReceiveBuf);
	SafeDelete(SenderBuf);
	SafeCloseHandleDelete(CSsocket);
	return true;
}

//发送请求
BOOL  CHttpProxyServer::SendRequest(SOCKET* CSsocket, char *SenderBuf, char *ReceiveBuf, int DataLen)
{
	//参数效验
	assert(CSsocket!=NULL);
	assert(SenderBuf!=NULL);
	assert(ReceiveBuf!=NULL);
	assert(DataLen>0);
	if (CSsocket==NULL)return false;
	if (SenderBuf==NULL)return false;
	if (ReceiveBuf==NULL)return false;
	if (DataLen<0)return false;


	//CSsocket[0] ClientSocket			//客户端socket
	//CSsocket[1] ServerSocket			//服务端socket

	//定义变量
	char   HostName[MAX_HOSTNAME] = {0};
	UINT   RemotePort = 0;
	int Flag=0, MethodLength=0, SendLength=0;

	//查询请求
	Flag = CheckRequest(ReceiveBuf,&MethodLength);
	if(Flag==0) return 0;

	if(Flag==GET_STYLE || Flag==HEAD_STYLE || Flag==POST_STYLE)
	{
		//修改请求 
		SendLength=ModifyRequest(SenderBuf,ReceiveBuf,DataLen,MethodLength);
		if(SendLength==NULL)return 0;

		//获取主机名和端口
		GetHostNameAndPort(ReceiveBuf+MethodLength+HEADLEN,DataLen-MethodLength-HEADLEN,HostName,&RemotePort);

		//连接远程主机	//pc.qq.com 80
		if(ConnectToRemoteHost(&CSsocket[1],HostName,RemotePort)==FALSE)return 0;

		//发送数据		//这里是向服务器请求域名后面的页面，比如http://pc.qq.com/all.html  实际请求的是all.html
		if(send(CSsocket[1],SenderBuf,SendLength,0) == SOCKET_ERROR) return 0;
	}
	else if(Flag==CONNECT_STYLE)
	{
		//获取主机名和端口
		GetHostNameAndPort(ReceiveBuf+MethodLength,DataLen-MethodLength,HostName,&RemotePort);

		//连接远程主机
		if(ConnectToRemoteHost(&CSsocket[1],HostName,RemotePort)==FALSE) return 0;

		//发送数据
		send(CSsocket[0], ConnectionEstablished, strlen(ConnectionEstablished),0);
	}

	//转发线程
	if(CSsocket[0] && CSsocket[1])
	{
		//开启线程
		HANDLE ThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)TransferData,CSsocket,NULL,NULL);
		if (ThreadHandle != NULL)WaitForSingleObject(ThreadHandle, INFINITE);
		CloseHandle(ThreadHandle); 	
	}
	else	return FALSE;


	return TRUE;
}

//查询请求	返回请求的类型
int   CHttpProxyServer::CheckRequest(char *ReceiveBuf,int *MethodLength)
{
	//参数效验
	assert(ReceiveBuf!=NULL);
	assert(MethodLength!=NULL);
	if (ReceiveBuf==NULL)return NULL;
	if (MethodLength==NULL)return NULL;

	if(! _strnicmp(ReceiveBuf,"GET ",4))
	{
		*MethodLength = 4;
		return GET_STYLE;
	}
	else if(! _strnicmp(ReceiveBuf,"HEAD ",5)) //Looks like the same with GET
	{
		*MethodLength = 5;
		return HEAD_STYLE;
	}
	else if(! _strnicmp(ReceiveBuf,"POST ",5))
	{
		*MethodLength = 5;
		return POST_STYLE;
	}
	else if(! _strnicmp(ReceiveBuf,"CONNECT ",8))
	{
		*MethodLength = 8;
		return CONNECT_STYLE;
	}
	else
	{
		return 0;
	}

	return 0;
}

//修改请求    返回域名后面的路径
int   CHttpProxyServer::ModifyRequest(char *SenderBuf,char *ReceiveBuf,int DataLen,int MethodLength)
{
	//参数效验
	assert(SenderBuf!=NULL);
	assert(ReceiveBuf!=NULL);
	assert(DataLen>0);
	assert(MethodLength>0);
	if (SenderBuf==NULL)return NULL;
	if (ReceiveBuf==NULL)return NULL;
	if (DataLen<0)return NULL;
	if (MethodLength<0)return NULL;

	//设置变量
	strncpy(SenderBuf,ReceiveBuf,MethodLength);
	int HedLen = 0;

	//http头判断
	if(strncmp(ReceiveBuf+MethodLength,"http://",HEADLEN)) return 0;

	//获取域名后面的部分
	char * Getrootfp = GetURLRootPoint(ReceiveBuf+MethodLength+HEADLEN,DataLen
		-MethodLength-HEADLEN,&HedLen);
	if(Getrootfp == NULL)
		return 0;

	memcpy(SenderBuf+MethodLength,Getrootfp,DataLen-MethodLength-HEADLEN-HedLen);

	//返回长度
	return DataLen-HEADLEN-HedLen;
}

//获取根目录节点  获取域名后面的部分
char* CHttpProxyServer::GetURLRootPoint(char * ReceiveBuf,int DataLen,int *HostNaneLen)
{
	//参数效验
	assert(DataLen>0);
	assert(ReceiveBuf!=NULL);
	assert(HostNaneLen!=NULL);
	if (DataLen<0)return NULL;
	if (ReceiveBuf==NULL)return NULL;
	if (HostNaneLen==NULL)return NULL;


	//解析操作
	for(int i = 0;i < DataLen; i++)
	{
		if(ReceiveBuf[i] == '/')
		{
			*HostNaneLen = i;
			return &ReceiveBuf[i];
		}
	}
	return NULL;
}

//获取主机名和端口
void  CHttpProxyServer::GetHostNameAndPort(char *ReceiveBuf,int datalen,char *HostName,UINT *RemotePort)
{

	//参数效验
	assert(datalen>0);
	assert(RemotePort!=NULL);
	assert(HostName!=NULL);
	if (datalen<0)return;
	if (RemotePort==NULL)return;
	if (HostName==NULL)return;


	//解析主机端口
	char *fp = ReceiveBuf;
	for(int i = 0;i < datalen && *fp != ':' && *fp != '\0' && *fp != '\r' && *fp != '/';i++)
	{    
		//解析主机
		HostName[i]=*fp++;

		//解析端口
		if(*fp == ':') *RemotePort=atoi(fp+1);
		else *RemotePort=DEFAULTPORT;
	}

	return;
}

//连接远程主机
BOOL  CHttpProxyServer::ConnectToRemoteHost(SOCKET *ServerSocket,char *HostName,const UINT RemotePort)
{
	//参数效验
	assert(*ServerSocket!=SOCKET_ERROR);
	assert(HostName!=NULL);
	assert(RemotePort>0);
	if (*ServerSocket==SOCKET_ERROR)return false;
	if (*HostName==NULL)return false;
	if (RemotePort<0)return false;

	//地址信息
	sockaddr_in Server={0};
	Server.sin_family = AF_INET;
	Server.sin_port = htons(RemotePort);
	if (inet_addr(HostName) != INADDR_NONE)
	{
		Server.sin_addr.s_addr = inet_addr(HostName);
	}
	else
	{
		//解析主机地址
		if (DNS(HostName) != NULL)
		{
			Server.sin_addr.s_addr = inet_addr(DNS(HostName));
		}
		else
		{
			assert(FALSE);
			return FALSE;
		}
	}

	//创建socket
	*ServerSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if (*ServerSocket == INVALID_SOCKET) return FALSE;

	//设置socket接收的超时时间为10秒 
	UINT TimeOut = TIMEOUT;
	setsockopt(*ServerSocket,SOL_SOCKET,SO_RCVTIMEO,(char *)&TimeOut,sizeof(TimeOut));

	// 连接远程主机
	if (connect(*ServerSocket, (const SOCKADDR *)&Server,sizeof(Server)) == SOCKET_ERROR)
	{
		closesocket(*ServerSocket);
		return FALSE;
	}

	return TRUE;
}

//主机名解析IP地址
char* CHttpProxyServer::DNS(char *HostName)
{
	//参数效验
	assert(HostName);
	if (HostName==NULL)return NULL;

	//获取主机地址
	HOSTENT *hostent = NULL;
	IN_ADDR iaddr;
	hostent = gethostbyname(HostName);
	if (hostent == NULL)return NULL;

	iaddr = *((LPIN_ADDR)*hostent->h_addr_list);
	return inet_ntoa(iaddr);
}

//信息传递线程 
DWORD  CHttpProxyServer::TransferData(LPVOID lpParameter)
{
	//参数效验
	SOCKET* CSsocket=(SOCKET*)lpParameter;
	assert(CSsocket!=NULL);
	if (CSsocket==NULL)return false;


	//定义变量
	SOCKET ClientSocket = CSsocket[0];
	SOCKET ServerSocket = CSsocket[1];
	timeval timeset={0};			//超时时间
	fd_set readfd,writefd;
	int result,i=0;
	char read_in1[MAXSIZE]={0};
	char send_out1[MAXSIZE]={0};
	char read_in2[MAXSIZE]={0};
	char send_out2[MAXSIZE]={0};		//ServerSocket套接字接受数据
	char SenderBuf[MAXSIZE]={0};
	int read1=0;
	int Clienttotalread1=0;				//ClientSocket套接字接受长度
	int send1=0;
	int read2=0;
	int Servertotalread2=0;				//ServerSocket套接字接受长度
	int send2=0;
	int sendcount1=0;
	int sendcount2=0;
	int maxfd=0;						//最大套接字范围

	maxfd=max(ClientSocket,ServerSocket)+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(true)
	{
		//初始化为空集合
		FD_ZERO(&readfd);
		FD_ZERO(&writefd);

		//添加套接字到集合
		FD_SET((UINT)ClientSocket, &readfd);
		FD_SET((UINT)ClientSocket, &writefd);
		FD_SET((UINT)ServerSocket, &writefd);
		FD_SET((UINT)ServerSocket, &readfd);

		//查询事件
		result=select(maxfd,&readfd,&writefd,NULL,×et);
		if((result<0) && (errno!=EINTR)) break;
		else if(result==0) break;

		//1.接受远程服务端数据
		if(FD_ISSET(ServerSocket, &readfd))		//检查s是不是set的成员，如果是返回TRTUE  
		{
			//fx 2016年5月17日16:18:03
			//由于已近连接了远程服务器，所有会先收到服务器的数据
			//收到服务器返回http://pc.qq.com/all.html
			//最大长度判断
			if(Servertotalread2<MAXSIZE)
			{
				read2=recv(ServerSocket,read_in2,MAXSIZE-Servertotalread2, 0);
				if(read2==0)break;
				if((read2<0) && (errno!=EINTR)) break;

				memcpy(send_out2+Servertotalread2,read_in2,read2);
				Servertotalread2+=read2;
				memset(read_in2,0,MAXSIZE);
			}

		}

		//2.转发数据到客户端
		if(FD_ISSET(ClientSocket, &writefd))		//检查s是不是set的成员，如果是返回TRTUE  
		{
			//收到远程服务器的数据直接转发给客户端
			//1和2相当于是一套组合，收到远程服务器的数据转发到客户端
			//http://pc.qq.com/all.html发送到客户端
			int err2=0;
			sendcount2=0;
			while(Servertotalread2>0)		//接受长度
			{
				send2=send(ClientSocket, send_out2+sendcount2, Servertotalread2, 0);
				if(send2==0)break;
				if((send2<0) && (errno!=EINTR))
				{
					err2=1;
					break;
				}
				if((send2<0) && (errno==ENOSPC)) break;
				sendcount2+=send2;
				Servertotalread2-=send2;

			}
			if(err2==1) break;
			if((Servertotalread2>0) && (sendcount2 > 0))
			{
				/* move not sended data to start addr */
				memcpy(send_out2, send_out2+sendcount2, Servertotalread2);
				memset(send_out2+Servertotalread2, 0, MAXSIZE-Servertotalread2);
			}
			else	memset(send_out2,0,MAXSIZE);
		}

		//3.接受客户端请求
		if(FD_ISSET(ClientSocket, &readfd))			//检查s是不是set的成员，如果是返回TRTUE  
		{
			//是否收到客户端数据，如果有接受客户端发来的请求
			//客户端请求比如http://pc.qq.com/all.html
			if(Clienttotalread1<MAXSIZE)
			{
				read1=recv(ClientSocket, read_in1, MAXSIZE-Clienttotalread1, 0);
				if((read1==SOCKET_ERROR) || (read1==0)) break;

				memcpy(send_out1+Clienttotalread1,read_in1,read1);
				Clienttotalread1+=read1;
				memset(read_in1,0,MAXSIZE);
			}

			//发送请求  到远程服务器比如http://pc.qq.com/all.html
			if(SendRequest(CSsocket,SenderBuf,send_out1,Clienttotalread1))
				Clienttotalread1=0;
		}

		//2.收到客户端请求转发到服务器
		if(FD_ISSET(ServerSocket, &writefd))
		{
			//发送请求  到远程服务器比如http://pc.qq.com/all.html
			int err=0;
			sendcount1=0;
			while(Clienttotalread1>0)
			{
				send1=send(ServerSocket, send_out1+sendcount1, Clienttotalread1, 0);
				if(send1==0)break;
				if((send1<0) && (errno!=EINTR))
				{
					err=1;
					break;
				}

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

			if(err==1) break;
			if((Clienttotalread1>0) && (sendcount1>0))
			{
				memcpy(send_out1,send_out1+sendcount1,Clienttotalread1);
				memset(send_out1+Clienttotalread1,0,MAXSIZE-Clienttotalread1);
			}
			else
				memset(send_out1,0,MAXSIZE);
		}
		Sleep(5);
	}

	closesocket(ClientSocket);
	closesocket(ServerSocket);

	return true;
}

// 地址解释
DWORD CHttpProxyServer::TranslateAddr(char* pszServerAddr)
{
	// 转化地址
	DWORD dwServerIP = inet_addr(pszServerAddr);

	if (dwServerIP == INADDR_NONE)
	{
		LPHOSTENT lpHost = gethostbyname(pszServerAddr);
		if (lpHost == NULL) return INADDR_NONE;
		dwServerIP = ((LPIN_ADDR)lpHost->h_addr)->s_addr;
	}
	return dwServerIP;
}


main.cpp

#include "HttpProxy.h"

int main (void)
{
	CHttpProxyServer	httpProxyServer;
	httpProxyServer.OnStart();

	getchar();
	return 0;
}


Proxy Server-代理服务器
weixin_30336061的博客
09-16 1478
2017-09-16 22:44:01 一、什么是代理服务器 代理服务器英文全称是Proxy Server，其功能就是代理网络用户去取得网络信息。形象的说：它是网络信息的中转站。 代理位于Web客户端和Web服务器之间，扮演“中间人”的角色。HTTP的代理服务器即是Web服务器又是Web客户端。 二、代理服务器的作用 在一般情况下，我们使用网络浏览器直接去连接其他Intern...
代理服务器（Proxy Server）与网络地址转换（NAT）
zhu_931的博客
07-21 3950
1 代理服务器概念   一个终端通过代理与另一终端进行连接，提供代理的便是代理服务器。 2 代理服务器的原理   1) 客户端与代理服务器连接。   2) 客户端向代理服务器发送数据请求 。   3) 代理服务器向客户端返回数据（如果代理服务器里有需要的缓存数据，直接返回缓存数据，否则，代理服务器向目的服务器请求数据）。 3 常见的代理服务器   1) HTTP代理,采用http协议的
Http代理服务器（proxy Server ）
12-05
超轻量型 Http proxy Server，用来学习非常不错，实现GET/POST 的 Web 处理，可以帮助我们真正理解服务器程序的本质。
proxyServer
01-07
Console.cpp 主要函数 proxyServer 比较新的想法，但没有完全实现，仅供学习参考。
Proxy Server(代理服务器)
03-16
代理服务器的源程序，只是一个示范，可以了解Proxy原理 program: proxyd module: proxyd.c summary: provides proxy tcp service for a host on an isolated network. programmer: Carl Harris (ceharris@vt.edu) date: 22 Feb 94 description: This code implements a daemon process which listens for tcp connec- tions on a specified port number. When a connection is established, a child is forked to handle the new client. The child then estab- lishes a tcp connection to a port on the isolated host. The child then falls into a loop in which it writes data to the isolated host for the client and vice-versa. Once a child has been forked, the parent resumes listening for additional connections. The name of the isolated host and the port to serve as proxy for, as well as the port number the server listen on are specified as command line arguments.
HTTP Proxy Server
04-29 342
HTTP Proxy Server Simple HTTP Proxy Server Implementation, based on wcol - Projects - Michael Vorburger's Private HomepageHTTP Proxy ...
Proxy server
04-26 962
Proxy server Proxy server - Wikipedia, the free encyclopediaProxy server From Wikipedia, the free encyclopedia Jump to: navigation,...
PROXY SERVER 代理服务器
weixin_34088583的博客
01-07 1637
Proxy是什么呢，是代理。普通的因特网访问是一个典型的客户机与服务器结构：用户利用计算机上的客户端程序，如浏览器发出请求，远端WWW服务器程序响应请求并提供相应的数据。而Proxy处于客户机与服务器之间，对于服务器来说，Proxy是客户机，Proxy提出请求，服务器响应；对于客户机来说，Proxy是服务器，它接受客户机的请求，并将服务器上传来的数据转给客户机。它的作用很象现实生活中的代理服务商...
Proxy Server
SarahZuo的专栏
12-10 538
用户浏览器－－代理服务器－－服务器 代理服务器的作用： 对用户来说： 1、访问被限制的站点，比如youtube 2、缓存。缓存之前访问过的资源并且资源没有更新 3、隐藏ip 对代理服务器来说： 4、可以纪录用户的访问历史、站点、地址、时间等等。 参考： http://baike.baidu.com/view/751.htm
proxy server
vingo888的专栏
02-25 952
http://www.multiproxy.org/anon_proxy.htm
简单HTTP代理服务器-源码c++
08-26
一个简单的http代理服务器。 支持http 和https c/c++源码。 代码易阅读和修改。供参考 经过测试，基本没有问题。
什么是Proxy Server
2023年最新地推相关信息
04-17 8757
Proxy Server 指的是代理软件或代理服务器，也可以认为是一种网络访问方式。是一种重要的服务器安全功能，它的工作主要在开放系统互联(OSI)模型的会话层，从而起到防火墙的作用。代理服务器作为连接 Internet 与 Intranet 的桥梁，在实际应用中发挥着极其重要的作用。代理服务器最基本的功能是连接，大多被用来连接 Internet(国际互联网)和 Local Area Network(局域网)。此外还包括安全性、缓存、内容过滤、访问控制管理等功能。 Proxy Server 代理服务器
c语言 http proxy 源码,一个简单的C语言TCP Proxy实现
weixin_33103945的博客
05-21 1034
前几天项目中需要一个抓取并分析TCP包的工具，在网上倒腾了一阵子整理了一个工具，现在发布在这儿提供参考。这个工具是使用C语言开发的一个TCP Proxy，实现TCP转发的功能并dump出来数据包的内容。#include #include #include #include #include #include #define LOG_ERROR(...)#define LOG_INFO(...)#d...
http代理服务器
weixin_30245867的博客
10-09 839
代理服务器英文全称是Proxy Server，其功能就是代理网络用户去取得网络信息。形象的说：它是网络信息的中转站。 代理服务器是介于浏览器和Web服务器之间的一台服务器，有了它之后，浏览器不是直接到Web服务器去取回网页而是向代理服务器发出请求，Request信号会先送到代理服务器，由代理服务器来取回浏览器所需要的信息并传送给你的浏览器。 而且，大部分代理服务器都具有缓冲的功能，就好象一个大...
Proxy
cuanzhanyun3524的博客
10-29 128
1、Squid proxy log以龙潭厂为例，每日约 130-150MB，若再加上执行log分析程序所产生的报表档案，每日的数据量会将近300MB，因此将硬盘剩余空间全部切给 /var，以存放log及 sarg report...
创建Http Proxy
仰望星空的博客
11-15 2621
Squid 创建HTTP代理
代理服务器proxy server
ON THE ROAD
08-11 3828
<br /><br />　　代理服务器英文全称是Proxy Server，其功能就是代理网络用户去取得网络信息。形象的说：它是网络信息的中转站。在一般情况下，我们使用网络浏览器直接去连接其他Internet站点取得网络信息时，须送出Request信号来得到回答，然后对方再把信息以bit方式传送回来。代理服务器是介于浏览器和Web服务器之间的一台服务器，有了它之后，浏览器不是直接到Web服务器去取回网页而是向代理服务器发出请求，Request信号会先送到代理服务器，由代理服务器来取回浏览器所需要的信息并传送给
Proxy Server代理服务器
Sea
03-16 933
及以及INTERNET网络的迅速发展，学习网络和使用网络不再是那些有钱和有技术的人的专利，INTERNET网络已作为一种生活方式走进了寻常百姓家。越来越多的公司也纷纷将自己的公司局域网接入了INTERNET。当然接入因特网的方式是多样的。通常，对于个人用户来说，只要购买一个调制解调器通过一根电话线就能连上因特网了。公司由于计算机数量多，通信需求量大，一般都采用专线接入方式。然而专线费用太昂贵了，那
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值