C++博客-Dark Angle-最新评论

re: Mysql日期和时间函数不求人[未登录]

王博炜 — Thu, 27 Nov 2008 03:04:00 GMT

好

王博炜 2008-11-27 11:04 发表评论

re: DirectX与OpenGL方面的经典电子书下载

聂文龙 — Fri, 21 Nov 2008 03:17:00 GMT

联系：QQ513306007，说清楚要用这本书，呵呵... ...
附其他的相关资料：
Game Developer Magazine 1994 - 2000年，共7年的游戏开发者杂志电子版（含源码）
Graphics Programming Black Book (by Michael Abrash).zip，图形编程黑书，Id software的Michael Abrash编著
Game Programming Gems I.rar ，游戏编程精粹I、II（含源码）
Game Programming Gems II.rar
Graphics Gems I.rar ，图形学精粹I、II、III、IV、V
Graphics Gems II.rar
Graphics Gems III IBM.rar
Graphics Gems IV IBM.rar
Graphics Gems V.rar
Computer Graphics, C Version (2nd Ed.).rar ，计算机图形学C版（第二版）
half_life2_engine.zip ，半条命2游戏引擎源代码
D3DTutorial10_Half-Life2_Shading.pdf ，半条命2游戏引擎光照分析
Course.PTR.3D.Game.Engine.Programming.eBook-LinG.rar ，3D游戏引擎编程
3D Game Engine Design.rar ，3D游戏引擎设计
3D Game Engine Design source code.rar ，3D游戏引擎设计源代码
3D.Game.Programming.All.In.One.zip ，3D游戏编程大全
Game Design - Theory and Practice.rar ，游戏设计 - 理论与实践
game.programming.all.in.one.zip ，游戏编程大全
The Cg Tutorial - The Definitive Guide to Programmable Real-Time Graphics.rar ，CG指导 - 可编程实时图形权威指南
Tricks Of The 3D Game Programming Gurus - Advanced 3D Graphics And Rasterization.rar ，3D游戏编程大师技巧 - 高级3D图形和光栅化
Ultimate Game Design Building Game Worlds.rar ，终极游戏设计 - 创建游戏世界
Core.Techniques.And.Algorithms.In.Game.Programming.rar ，核心技术和算法在游戏编程
Simulating Humans.rar ，仿真人类

3D Lighting - History, Concepts, and Techniques.rar ，3D光照 - 历史，概念和技术
Lighting.Techniques.For.Real-Time.3D.Rendering.rar ，光照技术For实时3D渲染
Vector.Game.Math.Processors.zip ，向量游戏数学处理器
AI for Computer Games and Animation - A Cognitive Modeling Approach.rar ，AI（人工智能）for计算机游戏和动画 - 一个认知建模方案
AI.Game.Development.Synthetic.Creatures.With.Learning.And.Reactive.Behaviors.rar ，AI游戏开发 - 合成生物With学习和反应举止
AI.Techniques.for.Game.Programming.rar ，AI技术for游戏编程（含源码）
Ai.Game.Programming.Wisdom.rar ，AI游戏编程（代码）
Real_Time_Rendering.rar ，实时渲染
special.effects.game.programming.rar ，特效（特殊效果）游戏编程（含源码）
Shaders.for.Game.Programmers.and.Artists.zip ，着色器for游戏开发者和艺术家
Real-Time Shader Programming.rar ，实时着色器编程
Wordware.Publishing.Advanced.Lighting.and.Materials.With.Shaders.rar ，高级光照和材质with着色器
OReilly - Physics for Game Developers.rar ，物理for游戏开发者

GPU Programming Guide.rar ，GPU编程指南
Collision.Detection.pdf.rar ，碰撞检测
Collision.Detection.-.Algorithms.and.Applications.rar ，碰撞检测 - 算法与应用
focus.on.3D.terrain.zip ，游戏3D地形编程
Focus.On.3D.Models.zip ，游戏3D模型编程
Focus.On.2D.in.Direct3D.-.fly.pdf ，集中于Direct3D中的2D
Beginning.Game.Audio.Programming.rar ，开始游戏音频编程（含源码）
Internetworked.3D.Computer.Graphics.rar ，互连网间的3D计算机图形学

Beginning.Math.and.Physics.For.Game.Programmers.zip ，开始数学和物理for游戏编程者（PDF版）
Beginning Math and Physics for Game Programmers[CHM].rar ，开始数学和物理for游戏编程者（CHM版）
3D.Math.Primer.for.graphics.and.game.development.zip ，3D数学初步for图形和游戏开发
The art of computer game design.rar ，计算机游戏设计艺术
Sams.Beginning.3D.Game.Programming.eBook-LiB.rar ，3D游戏编程入门
MIT.Press.Rules.of.Play.Game.Design.Fundamentals.rar ，游戏设计基础
design a pc game engine.rar ，设计一个PC游戏引擎

Advanced Graphics Programming Techniques Using Opengl.rar ，高级图形编程技术用OpenGL
Real-time.Rendering.Tricks.and.Techniques.in.DirectX.rar ，DirectX实时渲染技巧与技术
Real-Time Rendering Tricks and Techniques in DirectX(src).ZIP ，DirectX实时渲染技巧与技术（源代码）
Real Time 3D Terrain Engines Using C++ And Dx9.rar ，实时3D地形引擎用C++和Dx9
MS.Press.-.Microsoft.DirectX.9.Programmable.Graphics.Pipeline.rar ，Microsoft DirectX9可编程图形管线
Wordware.Publishing.OpenGL.Game.Development.eBook-YYePG.rar ，OpenGL游戏开发
Beginning.OpenGL.Game.Programming.ebook.zip ，OpenGL游戏编程入门
OpenGL.Programming.Guide.rar ，OpenGL编程指南
Addison.Wesley.-.OpenGL.Programming.Guide.2nd.Edition.rar ，OpenGL编程指南（第二版）
Addison-Wesley,.OpenGL.Shading.Language.(2004).DDU.ShareConnector.rar ，OpenGL着色语言（2004）
Learn Vertex and Pixel Shader Programming With Directx 9.rar ，学习顶点和像素着色器编程用DirectX9
Shaderx2 - Shader Programming Tips & Tricks With Directx 9.rar ，Shaderx2 - 着色器编程提示与技巧With DirectX9
ShaderX2 Introductions and Tutorials with DirectX9.rar ，ShaderX2介绍和指导With DirectX9
Direct3D.ShaderX.-.Vertex.and.Pixel.Shader.Tips.and.Tricks.rar ，Direct3D.ShaderX - 顶点和像素着色器提示和技巧
Advanced 3D Game Programming with DirectX 9.rar ，高级3D游戏编程用DirectX 9.0（含源码，CHM版）
Advanced 3D Game Programming with DirectX 9[PDF].rar ，高级3D游戏编程用DirectX 9.0（PDF版）
DirectX 3D Graphics Programming Bible.rar ，DirectX 3D图形编程宝典
Introduction to 3D Game Programming with DirectX 9.0.rar ，介绍对3D游戏编程用DirectX9.0（含部分源代码）
Beginning.Direct3D.Game.Programming.rar ，Direct3D游戏编程入门
Beginning.DirectX9.zip ，DirectX9入门
Cutting Edge Direct 3D Programming.rar ，Cutting Edge（刀刃）Direct 3D编程
Game.Scripting.Mastery.zip ，游戏描述语言掌握
Data.Structures.for.Game.Programmers.rar ，数据结构for游戏编程者（含源码）
2_OpenGL.Extensions.-.Nvidia.rar ，OpenGL扩展（Nvidia）
Managed.DX.9.Kick.Start.Graphics.And.Game.Programming.rar ，DirectX9图形和游戏编程
OpenGL.Reference.Manual.rar ，OpenGL参考手册
OpenGL.Super.Bible.rar ，OpenGL超级宝典

Tricks of the Windows Game Programming Gurus.rar ，Windows游戏编程大师技巧
Tricks of Win Game Programming Gurus 2ed.rar ，Windows游戏编程大师技巧(第二版)
Game.Programming.Beginners.Guide.rar ，游戏编程初学者指南
Chris_Crawford_on_Game_Design.rar ，Chris Crawford写的游戏设计书

Advanced.Animation.with.DirectX.rar ，高级动画with DirectX（含源码）
Inside Direct3D.rar ，深入Direct3D
Direct3D_9_Basics.rar ，Direct3D 9基础
Sams Teach Yourself DirectX 7 in 24 Hours.rar ，教你自己DirectX7在24小时
Programming.Role.Playing.Games.with.DirectX.rar ，用DirectX编程RPG游戏（含源码）
Programming Multiplayer Games.rar ，编程多玩家游戏
Net Game Programming With Directx 9.0.rar ，网络游戏编程with Directx 9.0
Programming Linux Games.rar ，编程Linux游戏
Developing Online Games - An Insiders Guide.rar ，开发在线游戏 - 一个权威人士的指导
Game Coding Complete.rar ，游戏编码完全
Strategy Game Programming with DirectX 9.0.rar ，策略游戏编程用DirectX9.0
Strategy Game Programming with DirectX 9.0 Source Code.zip ，策略游戏编程用DirectX9.0（源代码）
Addison-Wesley - Software Engineering and Computer Games.rar ，软件工程和计算机游戏
Artificial Intelligence and Software Engineering.rar ，AI和软件工程
Game-Programming-OpenGL-C++.rar ，有关OpenGl和C++的一些资料

GBA Programming Game Boy Advance The Unofficial Guide.rar ，GBA编程非官方指南
Palm.OS.Game.Programming.zip ，Palm掌上操作系统游戏编程
Mac.Game.Programming.pdf ，苹果机游戏编程
Premier.Press.J2ME.Game.Programming.rar ，J2ME游戏编程
J2ME Game Development with MIDP2.rar ，J2ME游戏开发with MIDP2
PHP.Game.Programming.zip ，PHP语言游戏编程
Game.Programming.with.Python.Lua.And.Ruby.zip ，游戏编程用Python,Lua和Ruby语言
Apress.dot.NET.Game.Programming.with.DirectX.9.0.eBook-KB.rar ，点NET游戏编程用DirectX9
Wordware.Wireless.Game.Development.In.C.Cpp.With.BREW.chm ，无线游戏开发用C、C++ With BREW

DirectX9 User Interfaces Design and Implementation.rar ，DirectX9用户接口设计和实现
Game.Interface.Design.rar ，游戏接口设计

SAMS Teach Yourself Game Programming in 24 Hours.rar ，教你自己游戏编程在24小时
C.Game.Programming.For.Dummies.2.rar ，C游戏编程傻瓜书2
Beginners Guide to DarkBASIC Game Programming.rar ，初学者指南对DarkBASIC游戏编程
Windows Graphics Programming Win32 GDI and DirectDraw.rar ，Windows图形编程 - Win32 GDI 和 DirectDraw
Game Programming Genesis.rar ，游戏编程起步

2D.Artwork.and.3D.Modeling.for.Game.Artists.zip ，2D艺术品和3D建模for游戏艺术家
Game.Art.for.Teens.pdf ，游戏艺术for青年人

Game Development and Production.rar ，游戏开发和产品
Game.Developers.Market.Guide.rar ，游戏开发者市场指南

MIT.Press.A.History.Of.Modern.Computing.eBook-LiB.rar ，现代计算历史
The C++ Programming Language NO.3 Edition.rar ，C++编程语言（第三版）
Computer Systems A Programmers Perspective.rar ，计算机系统 - 一个编程者的透视
Intel Architecture Software Developer Manual.zip ，Intel架构软件开发者手册
Intel Itanium Assembly Language Reference.rar ，Intel Itanium架构汇编语言参考
Agile Software Development.rar ，灵活的软件开发
Code Reading The Open Source Perspective.rar ，代码阅读与开放源透视

ps2DevEnvironment.exe ，PS2开发环境
doxygen-1.3.9.1-setup.exe ，一种文档自动生成软件
wolf_source.exe ，wolf游戏（id software）源代码
doom_src.zip ，doom游戏（id software）源代码
q2src320.exe ，Quake2游戏（id software）源代码
Q3A_TA_GameSource_127.exe ，QuakeIII（id software）游戏源代码
Q3A_ToolSource.exe ，QuakeIII（id software）工具源代码

聂文龙 2008-11-21 11:17 发表评论

re: http://evaphone.com/

wenwen — Thu, 20 Nov 2008 00:50:00 GMT

hao

wenwen 2008-11-20 08:50 发表评论

re: vc模拟鼠标键盘操作实用类

逍遥行 — Sat, 15 Nov 2008 05:58:00 GMT

你好，能不能给我个demo，我是个初学者，不是很专业。

我的email：erej@163.com

逍遥行 2008-11-15 13:58 发表评论

re: 为SQLite数据库添加加密功能[未登录]

Mon, 03 Nov 2008 09:14:00 GMT

楼主你是个好人中的好人

我 2008-11-03 17:14 发表评论

re: 代理服务器代码

聂文龙 — Tue, 21 Oct 2008 03:35:00 GMT

[转载]C语言写的Linux平台socks5代理程序
C语言写的Linux平台socks5代理程序

信息来源：邪恶八进制信息安全团队（www.eviloctal.com）

前几天MSN老上不去，我还以为是公司做了防火墙限制。于是把去年这个时候写得一个代理程序改了改，拿出来用。结果发现MSN是因为微软的问题，鄙视啊……
因为写得比较急，这个只支持TCP代理，UDP的我没写，因为MSN用不上。这个代码可以随意修改分发，不过最好能给我一份。

这是头文件：
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Socks5代理头文件，定义协议相关数据包结构
// 版本 0.1，作者云舒
// 2007年1月9日凌晨1点15分，GF回家已经11天了。
// 2008年1月25日修改，今年GF一直在我身边，哈哈
//
// 参考：
// http://www.rfc-editor.org/rfc/rfc1928.txt">http://www.rfc-editor.org/rfc/rfc1928.txt
// http://www.rfc-editor.org/rfc/rfc1929.txt">http://www.rfc-editor.org/rfc/rfc1929.txt
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef SOCKS5_H
#define SOCKS5_H

#define VERSION 0x05
#define CONNECT 0x01
#define IPV4 0x01
#define DOMAIN 0x03
#define IPV6 0x04

typedef struct _method_select_response // 协商方法服务器响应
{
char version; // 服务器支持的Socks版本，0x04或者0x05
char select_method;// 服务器选择的方法，0x00为匿名，0x02为密码认证
} METHOD_SELECT_RESPONSE;

typedef struct _method_select_request // 协商方法服务端请求
{
char version; // 客户端支持的版本，0x04或者0x05
char number_methods; // 客户端支持的方法的数量
char methods[255]; // 客户端支持的方法类型，最多255个，0x00为匿名，0x02为密码认证
} METHOD_SELECT_REQUEST;

typedef struct _AUTH_RESPONSE // 用户密码认证服务端响应
{
char version;// 版本，此处恒定为0x01
char result;// 服务端认证结果，0x00为成功，其他均为失败
} AUTH_RESPONSE;

typedef struct _AUTH_REQUEST //用户密码认证客户端请求
{
char version; // 版本，此处恒定为0x01
char name_len; // 第三个字段用户名的长度，一个字节，最长为0xff
char name[255]; // 用户名
char pwd_len;// 第四个字段密码的长度，一个字节，最长为0xff
char pwd[255]; // 密码
} AUTH_REQUEST;

typedef struct _SOCKS5_RESPONSE // 连接真实主机，Socks代理服务器响应
{
char version; // 服务器支持的Socks版本，0x04或者0x05
char reply; // 代理服务器连接真实主机的结果，0x00成功
char reserved; // 保留位，恒定位0x00
char address_type; // Socks代理服务器绑定的地址类型，IP V4为0x01,IP V6为0x04，域名为0x03
char address_port[1]; // 如果address_type为域名，此处第一字节为域名长度，其后为域名本身，无0字符结尾,域名后为Socks代理服务器绑定端口
}SOCKS5_RESPONSE;

typedef struct _SOCKS5_REQUEST // 客户端请求连接真实主机
{
char version; // 客户端支持的Socks版本，0x04或者0x05
char cmd; // 客户端命令，CONNECT为0x01，BIND为0x02，UDP为0x03，一般为0x01
char reserved; // 保留位，恒定位0x00
char address_type; // 客户端请求的真实主机的地址类型，IP V4为0x00,IP V6为0x04，域名为 0x03 char address_port[1]; // 如果address_type为域名，此处第一字节为域名长度，其后为域名本身，无0字符结尾,域名后为真实主机绑定端口

}SOCKS5_REQUEST;
#endif
主程序来了：
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Socks5程序，只支持TCP代理
// 版本 0.1，作者云舒
// 2007年1月9日凌晨1点15分，GF回家已经11天了。
// 2008年1月25日修改，今年GF一直在我身边，哈哈
//
// 参考：
// http://www.rfc-editor.org/rfc/rfc1928.txt">http://www.rfc-editor.org/rfc/rfc1928.txt
// http://www.rfc-editor.org/rfc/rfc1929.txt">http://www.rfc-editor.org/rfc/rfc1929.txt
//编译：
// gcc -o socks5 -O2 Socks5.c -lpthread( RedHat AS5测试）
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include "Socks5.h"

#define MAX_USER 10
#define BUFF_SIZE 1024

#define AUTH_CODE 0x02

#define TIME_OUT 6000000

#define USER_NAME "yunshu"
#define PASS_WORD "ph4nt0m"

// Select auth method, return 0 if success, -1 if failed
int SelectMethod( int sock )
{
char recv_buffer[BUFF_SIZE] = { 0 };
char reply_buffer[2] = { 0 };

METHOD_SELECT_REQUEST *method_request;
METHOD_SELECT_RESPONSE *method_response;

// recv METHOD_SELECT_REQUEST
int ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
if( ret <= 0 )
{
perror( "recv error" );
close( sock );

return -1;
}

//printf( "SelectMethod: recv %d bytes\n", ret );

// if client request a wrong version or a wrong number_method
method_request = (METHOD_SELECT_REQUEST *)recv_buffer;
method_response = (METHOD_SELECT_RESPONSE *)reply_buffer;

method_response->version = VERSION;

// if not socks5
if( (int)method_request->version != VERSION )
{
method_response->select_method = 0xff;

send( sock, method_response, sizeof(METHOD_SELECT_RESPONSE), 0 );
close( sock );

return -1;
}

method_response->select_method = AUTH_CODE;
if( -1 == send( sock, method_response, sizeof(METHOD_SELECT_RESPONSE), 0 ) )
{
close( sock );
return -1;
}

return 0;
}

// test password, return 0 for success.
int AuthPassword( int sock )
{
char recv_buffer[BUFF_SIZE] = { 0 };
char reply_buffer[BUFF_SIZE] = { 0 };

AUTH_REQUEST *auth_request;
AUTH_RESPONSE *auth_response;

// auth username and password
int ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
if( ret <= 0 )
{
perror( "recv username and password error" );
close( sock );
return -1;
}
//printf( "AuthPass: recv %d bytes\n", ret );

auth_request = (AUTH_REQUEST *)recv_buffer;

memset( reply_buffer, 0, BUFF_SIZE );
auth_response = (AUTH_RESPONSE *)reply_buffer;
auth_response->version = 0x01;

char recv_name[256] = { 0 };
char recv_pass[256] = { 0 };

// auth_request->name_len is a char, max number is 0xff
char pwd_str[2] = { 0 };
strncpy( pwd_str, auth_request->name + auth_request->name_len, 1 );
int pwd_len = (int)pwd_str[0];

strncpy( recv_name, auth_request->name, auth_request->name_len );
strncpy( recv_pass, auth_request->name + auth_request->name_len + sizeof(auth_request->pwd_len), pwd_len );

//printf( "username: %s\npassword: %s\n", recv_name, recv_pass );
// check username and password
if( (strncmp( recv_name, USER_NAME, strlen(USER_NAME) ) == 0) &&
(strncmp( recv_pass, PASS_WORD, strlen(PASS_WORD) ) == 0)
)
{
auth_response->result = 0x00;
if( -1 == send( sock, auth_response, sizeof(AUTH_RESPONSE), 0 ) )
{
close( sock );
return -1;
}
else
{
return 0;
}
}
else
{
auth_response->result = 0x01;
send( sock, auth_response, sizeof(AUTH_RESPONSE), 0 );

close( sock );
return -1;
}
}

// parse command, and try to connect real server.
// return socket for success, -1 for failed.
int ParseCommand( int sock )
{
char recv_buffer[BUFF_SIZE] = { 0 };
char reply_buffer[BUFF_SIZE] = { 0 };

SOCKS5_REQUEST *socks5_request;
SOCKS5_RESPONSE *socks5_response;

// recv command
int ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
if( ret <= 0 )
{
perror( "recv connect command error" );

close( sock );
return -1;
}

socks5_request = (SOCKS5_REQUEST *)recv_buffer;
if( (socks5_request->version != VERSION) || (socks5_request->cmd != CONNECT) ||
(socks5_request->address_type == IPV6) )
{
//printf( "connect command error.\n" );
close( sock );
return -1;
}

// begain process connect request
struct sockaddr_in sin;

memset( (void *)&sin, 0, sizeof(struct sockaddr_in) );
sin.sin_family = AF_INET;

// get real server's ip address
if( socks5_request->address_type == IPV4 )
{
memcpy( &sin.sin_addr.s_addr, &socks5_request->address_type + sizeof(socks5_request->address_type) , 4 );
memcpy( &sin.sin_port, &socks5_request->address_type + sizeof(socks5_request->address_type) + 4, 2 );

//printf( "Real Server: %s %d\n", inet_ntoa( sin.sin_addr ), ntohs( sin.sin_port ) );
}
else if( socks5_request->address_type == DOMAIN )
{
char domain_length = *(&socks5_request->address_type + sizeof(socks5_request->address_type));
char target_domain[ 256] = { 0 };

strncpy( target_domain, &socks5_request->address_type + 2, (unsigned int)domain_length );

//printf( "target: %s\n", target_domain );

struct hostent *phost = gethostbyname( target_domain );
if( phost == NULL )
{
//printf( "Resolve %s error!\n" , target_domain );

close( sock );
return -1;
}
memcpy( &sin.sin_addr , phost->h_addr_list[0] , phost->h_length );

memcpy( &sin.sin_port, &socks5_request->address_type + sizeof(socks5_request->address_type) +
sizeof(domain_length) + domain_length, 2 );
}

// try to connect to real server
int real_server_sock = socket( AF_INET, SOCK_STREAM, 0 );
if( real_server_sock < 0 )
{
perror( "Socket creation failed\n");

close( sock );
return -1;
}

memset( reply_buffer, 0, sizeof(BUFF_SIZE) );

socks5_response = (SOCKS5_RESPONSE *)reply_buffer;

socks5_response->version = VERSION;
socks5_response->reserved = 0x00;
socks5_response->address_type = 0x01;
memset( socks5_response + 4, 0 , 6 );

ret = connect( real_server_sock, (struct sockaddr *)&sin, sizeof(struct sockaddr_in) );
if( ret == 0 )
{
socks5_response->reply = 0x00;
if( -1 == send( sock, socks5_response, 10, 0 ) )
{
close( sock );

return -1;
}
}
else
{
perror( "Connect to real server error" );
socks5_response->reply = 0x01;
send( sock, socks5_response, 10, 0 );

close( sock );
return -1;
}

return real_server_sock;
}

int ForwardData( int sock, int real_server_sock )
{
char recv_buffer[BUFF_SIZE] = { 0 };

fd_set fd_read;
struct timeval time_out;

time_out.tv_sec = 0;
time_out.tv_usec = TIME_OUT;

int ret = 0;

while( 1 )
{
FD_ZERO( &fd_read );
FD_SET( sock, &fd_read );
FD_SET( real_server_sock, &fd_read );

ret = select( (sock > real_server_sock ? sock : real_server_sock) + 1, &fd_read, NULL, NULL, &time_out );
if( -1 == ret )
{
perror( "select socket error" );
break;
}
else if( 0 == ret )
{
//perror( "select time out" );
continue;
}

//printf( "[DEBUG] testing readable!\n" );
if( FD_ISSET(sock, &fd_read) )
{
//printf( "client can read!\n" );
memset( recv_buffer, 0, BUFF_SIZE );
ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
if( ret > 0 )
{
//printf( "%s", recv_buffer );
//printf( "recv %d bytes from client.\n", ret );
ret = send( real_server_sock, recv_buffer, ret, 0 );
if( ret == -1 )
{
perror( "send data to real server error" );
break;
}
//printf( "send %d bytes to client!\n", ret );
}
else if( ret == 0 )
{
//printf( "client close socket.\n" );
break;
}
else
{
//perror( "recv from client error" );
break;
}
}

else if( FD_ISSET(real_server_sock, &fd_read) )
{
//printf( "real server can read!\n" );
memset( recv_buffer, 0, BUFF_SIZE );
ret = recv( real_server_sock, recv_buffer, BUFF_SIZE, 0 );
if( ret > 0 )
{
//printf( "%s", recv_buffer );
//printf( "recv %d bytes from real server.\n", ret );
ret = send( sock, recv_buffer, ret, 0 );
if( ret == -1 )
{
perror( "send data to client error" );
break;
}
}
else if( ret == 0 )
{
//printf( "real server close socket.\n" );
break;
}
else
{
perror( "recv from real server error" );
break;
}
}
}

return 0;
}

int Socks5( void *client_sock )
{
int sock = *(int *)client_sock;

if( SelectMethod( sock ) == -1 )
{
//printf( "socks version error\n" );
return -1;
}

if( AuthPassword( sock ) == -1 )
{
//printf( "auth password error\n" );
return -1;
}

int real_server_sock = ParseCommand( sock );
if( real_server_sock == -1 )
{
//printf( "parse command error.\n" );
return -1;
}

ForwardData( sock, real_server_sock );

close( sock );
close( real_server_sock );

return 0;
}

int main( int argc, char *argv[] )
{
if( argc != 2 )
{
printf( "Socks5 proxy for test,code by YunShu\n" );
printf( "Usage: %s \n", argv[0] );
printf( "Options:\n" );
printf( " ---which port of this proxy server will listen.\n" );

return 1;
}

struct sockaddr_in sin;

memset( (void *)&sin, 0, sizeof( struct sockaddr_in) );
sin.sin_family = AF_INET;
sin.sin_port = htons( atoi(argv[1]) );
sin.sin_addr.s_addr = htonl(INADDR_ANY);

int listen_sock = socket( AF_INET, SOCK_STREAM, 0 );
if( listen_sock < 0 )
{
perror( "Socket creation failed\n");
return -1;
}

int opt = SO_REUSEADDR;
setsockopt( listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt) );

if( bind( listen_sock, (struct sockaddr*)&sin, sizeof(struct sockaddr_in) ) < 0 )
{
perror( "Bind error" );
return -1;
}

if( listen( listen_sock, MAX_USER ) < 0 )
{
perror( "Listen error" );
return -1;
}

struct sockaddr_in cin;
int client_sock;
int client_len = sizeof( struct sockaddr_in );

while( client_sock = accept( listen_sock, (struct sockaddr *)&cin, (socklen_t *)&client_len ) )
{
printf( "Connected from %s, processing......\n", inet_ntoa( cin.sin_addr ) );

pthread_t work_thread;
if( pthread_create( &work_thread, NULL, (void *)Socks5, (void *)&client_sock ) )
{
perror( "Create thread error..." );
close( client_sock );
}
else
{
pthread_detach( work_thread );
}
}
}

聂文龙 2008-10-21 11:35 发表评论

re: 代理服务器代码

聂文龙 — Mon, 20 Oct 2008 18:29:00 GMT

关于通过http代理访问Internet
最近在网上查了一点关于通过Socket代理或者http代理访问internet的资料，国内的资料比较少，查到了一点英文资料，觉得讲得还不错。
When an HTTP connection is made through a proxy server the client (usually the browser) sends the request to the proxy. The proxy opens the connection to the destination, sends the request, receives the response and sends it back to the client. The HTTP protocol specifies a request method called CONNECT. The CONNECT method can be used by the client to inform the proxy server that a connection to some host on some port is required. The proxy server, if allows such connections, tries to connect to the destination address specified in the request header. If it the operation fails it sends back to the client a negative HTTP response and close the connection. If the operation succeeded then send back an HTTP positive response and the connection is consider established. After that, the proxy does not care what data is transferred between client requesting the connection and the destination. It just forwards data in both ways acting as a tunnel.

About the protocol
We are interested in CONNECT method from the HTTP protocol. After the applications opens a connection with the proxy server it must send the connect request in the form of an HTTP request:

CONNECT : ...The proxy server process the request and try to make a connection to :.

The proxy server sends back an HTTP response in the form:

 ...If it is a positive response (code=200) then after the empty line the proxy begins to acts as a tunnel and forwards data. If it is a negative response (code!=200) then connection is closed after the empty line. 



The HTTPTunneling application

The application act as specified in a configuration file. An entry in the configuration file locks like this: 



    If the application is running and an entry in the configuration files changes, the application automatically updates itself. 



For every entry in the configuration file the application creates a port listener. This is a thread that opens a socket on  and waits for connection. When a request arrives on that port it tries to open a tunnel to the :< port>. If the  and  are missing, a direct connection is made. If the field are present it opens a connection to the proxy and sends a CONNECT request using the method specified above. The tunnel construction is made in a separate thread to let the port listener to accept immediatelly new connections. After the connection is established a tunnel object is constructed based on the opened sockets, sockets are marked as non-blocking and the object is passed to manager object. The thread that has created the tunnel is destroyed. Data transfer is made on a single thread. When one of the ends closes the connection the tunnel closes the other and the tunnel is marked as inactive. The manager finds the tunnel inactive and removes it from the list of active tunnels. By default the application generates log information in HTTPTunneling.log file. This file can be consulted to find wrong application behaviour.



聂文龙 2008-10-21 02:29 发表评论



re: 代理服务器代码
聂文龙 — Mon, 20 Oct 2008 18:25:00 GMT
通过Socket5代理服务器访问网络的问题

SOCKS5



Socks5版本的协议说明参考 RFC1928,RFC1929

下面简单地罗列程序实现，不涉及详细的协议规范。首先对于TCP连接，然后再讨论UDP传输。至于通过socks5的多播通讯，有兴趣可以参考D. Chouinard的文章。



1、TCP:



// 建立流套接字 

SOCKET m_socTCP=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);



// 连接到代理服务器

int nRet = connect(m_socTCP,(SOCKADDR*)&m_saiProxy,sizeof(m_saiProxy));



// Step 1: 连接代理服务器成功后，马上开始和代理协商，协商报文如下,询问服务器，版本5，是需要验证(0x02)还是不需要验证(0x00)

　　+------+-------------------+------------+

　　|VER   | Number of METHODS | METHODS    |

　　+------+-------------------+------------+

　　| 0x05 | 0x02 (有两个方法)  | 0x00 | 0x02|

　　+------+-------------------+------------+

const char reqNego[4]={(char)0x05,(char)0x02,(char)0x00,(char)0x02};

nRet = send(m_socTCP,reqNego,4,0);



// Setp 2: 代理服务器将返回两个字节的协商结果，接收协商结果

fd_set fdread;FD_ZERO(&fdread);

FD_SET(m_socTCP,&fdread);

// Last param set to NULL for blocking operation. (struct timeval*)

if((nRet=select(0,&fdread,NULL,NULL,NULL))==SOCKET_ERROR){return NC_E_PROXY_SELECT_READ|WSAGetLastError();}

char resNego[2]={'\0'};

int nRcvd=0,nCount=0;

while(1)

{

if(FD_ISSET(m_socTCP,&fdread))

{

//接收sock[0]发送来的数据

do{

nRet = recv(m_socTCP, (char*)resNego+nRcvd, 2-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=2)&&(++nCount<1000));

if(nRcvd==2) break;

}

if(nCount++>=2000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

}

if(resNego[0]!=0x05 || (resNego[1]!=0x00 && resNego[1]!=0x02)){return NC_E_PROXY_PROTOCOL_VERSION|WSAGetLastError();};



// Step 3: 根据协商结果判断是否需要验证用户，如果是0x02，则需要提供验证，验证部分参考RFC1929

if(resNego[1]==0x02)

{

// 需要密码验证

char reqAuth[513]={'\0'};

BYTE byLenUser = (BYTE)strlen(m_szProxyUserName);

BYTE byLenPswd = (BYTE)strlen(m_szProxyPassword);

reqAuth[0]=0x01;

reqAuth[1]=byLenUser;

sprintf(&reqAuth[2],"%s",m_szProxyUserName);

reqAuth[2+byLenUser]=byLenPswd;

sprintf(&reqAuth[3+byLenUser],"%s",m_szProxyPassword);

//Send authentication info

int len = (int)byLenUser + (int)byLenPswd + 3;

nRet=send(m_socTCP,(const char*)reqAuth,len,0);

if (nRet==SOCKET_ERROR){return NC_E_PROXY_SEND|WSAGetLastError();}

//Now : Response to the auth request

char resAuth[2]={'\0'};

int nRcvd=0,nCount=0;

do{

nRet = recv(m_socTCP,resAuth+nRcvd,2-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=2)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

if (resAuth[1]!=0) return NC_E_PROXY_AUTHORIZE;

// 密码验证通过了

}



// Step 4: 协商完成，开始发送连接远程服务器请求,请求报文格式如下：

　　+----+-----+-------+------+----------+----------+

　　|VER | CMD |　RSV　| ATYP | DST.ADDR | DST.PORT |

　　+----+-----+-------+------+----------+----------+

　　| 1　| 　1 | 0x00  | 　1　| Variable |　　 2　　 |

　　+----+-----+-------+------+----------+----------+

// CMD==0x01 表示连接, ATYP==0x01表示采用IPV4格式地址，DST.ADDR是远程服务器地址，DST.PORT是远程服务器端口

// 如果需要接受外来连接，则需要在连接完成之后，发送CMD==0x02绑定请求，代理将为此请求绑定一个套接字接受外部连接

char reqSubNego[10]={(char)0x05,(char)0x01,(char)0x00,(char)0x01,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00};

*(unsigned long*)&reqSubNego[4] =m_saiServerTCP.sin_addr.S_un.S_addr;

*(unsigned short*)&reqSubNego[8]=m_saiServerTCP.sin_port;

nRet=send(m_socTCP,(const char*)reqSubNego,10,0);

if (nRet==SOCKET_ERROR){return NC_E_PROXY_SEND|WSAGetLastError();}



// Step 5: 接收对请求的响应，响应包格式如下

　　+----+-----+-------+------+----------+----------+

　　|VER | REP |　RSV　| ATYP | BND.ADDR | BND.PORT |

　　+----+-----+-------+------+----------+----------+

　　| 1　|　1　| 0x00  |　1 　 | Variable | 　　2 　 |

　　+----+-----+-------+------+----------+----------+

// VER 必须是0x05, REP==0x00表示成功，ATYP==0x01表示地址是IPV4地址，BND.ADDR 是代理为连接远程服务器绑定的地址，BND.PORT是这个套接字的端口

char resSubNego1[5]={'\0'};

if(FD_ISSET(m_socTCP,&fdread))

{

int nRcvd=0,nCount=0;

do{

nRet = recv(m_socTCP,resSubNego1+nRcvd,5-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=5)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

if(resSubNego1[0]!=0x05||resSubNego1[1]!=0x00){return NC_E_PROXY_PROTOCOL_VERSION_SUB|WSAGetLastError();};



switch(resSubNego1[3])

{

case 0x01:

{

// IP V4

char resSubNego2[6]={resSubNego1[4],0};

int nRet=-1;

if(FD_ISSET(m_socTCP,&fdread))

{

int nRcvd=0,nCount=0;

do{

int nRet = recv(m_socTCP,&resSubNego2[1]+nRcvd,5-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=5)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

}

// 得到代理绑定地址

unsigned long  ulBINDAddr = *(unsigned long*)&resSubNego2; // SOCKS BIND ADDR

unsigned short usBINDPort = *(unsigned short*)&resSubNego2[4]; // SOCKS BIND PORT

m_saiProxyBindTCP.sin_addr.S_un.S_addr=ulBINDAddr;

m_saiProxyBindTCP.sin_port=usBINDPort;

// 得到本机绑定地址

int len = sizeof(m_saiHostTCP);

getsockname(m_socTCP,(SOCKADDR*)&m_saiHostTCP,&len);

}

break;

case 0x03:

{

// Domain name

int nLen = resSubNego1[4]+2;

char* presSubNego2 = new char[nLen];

if(FD_ISSET(m_socTCP,&fdread))

{

int nRet=0,nRcvd=0,nCount=0;

do{

nRet = recv(m_socTCP,presSubNego2+nRcvd,nLen-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=nLen)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

}

unsigned short usBINDPort = *(unsigned short*)(presSubNego2+nLen-2); // BIND PORT;

// 此时得到的是远程主机的Domain Name

delete[] presSubNego2; presSubNego2=NULL;

}

break;

case 0x04:

{

// IPV6

AfxMessageBox("该版本不支持IPV6";

}

break;

default:

break;

}



// 至此，连接已经建立。在此套接字上可进行数据的收发。

}



2、UDP



SOCKS V5提供了对UDP的支持，它通过在代理服务器和内网主机之间建立一个UDP中继的TCP连接，来辅助进行UDP数据包的收发。此连接有一个有效期，在此有效生命周期内，必须往代理发送UDP数据报确认连接有效，来维持此连接的有效性，否则，代理服务器超时，将会自动释放此连接的资源。

下面简单地罗列程序实现，不涉及详细的协议规范。



// 客户端为UDP中继建立一个相关的流套接字

SOCKET m_socClientTCP_UdpAssociate = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);



// 连接代理服务器

int nRet=connect(m_socClientTCP_UdpAssociate,(SOCKADDR*)&saiProxy,sizeof(saiProxy));



// 连接成功，开始和代理服务器协商，首先发送版本标志，方法选择报文

const char reqNego[4]={(char)0x05,(char)0x02,(char)0x00,(char)0x02};

nRet = send(m_socClientTCP_UdpAssociate,reqNego,4,0);

if( nRet==SOCKET_ERROR 

{

DWORD dwError = WSAGetLastError();

if (dwError!=WSAEWOULDBLOCK) return NCM_E_WM_CREATE_PROXYREQUESTFAILED;

}



// 接收协商的响应

fd_set fdread; FD_ZERO(&fdread);

FD_SET(m_socClientTCP_UdpAssociate,&fdread);

if((nRet=select(0,&fdread,NULL,NULL,NULL))==SOCKET_ERROR) return NCM_E_WM_CREATE_PROXYCONNECTFAILED;

char resNego[2]={0};

int nRcvd=0,nCount=0;

if(FD_ISSET(m_socClientTCP_UdpAssociate,&fdread))

{

nRcvd = recv(m_socClientTCP_UdpAssociate, (char*)resNego+nRcvd, 2,0);

if(nRcvd==SOCKET_ERROR) return NCM_E_WM_CREATE_PROXYCONNECTFAILED;

}

if(resNego[0]!=0x05 || (resNego[1]!=0x00 && resNego[1]!=0x02)) return NCM_E_WM_CREATE_PROXYCONNECTFAILED;



// 看是否需要密码验证

if(resNego[1]==0x02)

{

// 需要密码验证

char reqAuth[513]; memset(reqAuth,0,513);

BYTE byLenUser = (BYTE)strlen(m_szProxyUserName);

BYTE byLenPswd = (BYTE)strlen(m_szProxyPassword);

reqAuth[0]=0x01;

reqAuth[1]=byLenUser;

sprintf(&reqAuth[2],"%s",m_szProxyUserName);

reqAuth[2+byLenUser]=byLenPswd;

sprintf(&reqAuth[3+byLenUser],"%s",m_szProxyPassword);

//Send authentication info

int len = (int)byLenUser + (int)byLenPswd + 3;

int ret=send(m_socClientTCP_UdpAssociate,(const char*)reqAuth,len,0);

if (ret==SOCKET_ERROR) if (GetLastError()!=WSAEWOULDBLOCK) return NCM_E_WM_CREATE_PROXYREQUESTFAILED;



//Now : Response to the auth request

char resAuth[2]={'\0'};

int nRcvd=0,nCount=0;

do{

ret = recv(m_socClientTCP_UdpAssociate,resAuth+nRcvd,2-nRcvd,0);

if(ret==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=2)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE}

if (resAuth[1]!=0)     return NEM_E_WM_CREATE_PROXYAUTHFAILED;

// 密码验证通过了

}



// 开始发送向目标服务器的连接请求，其中DST.ADDR是目标服务器的地址，DST.PORT是目标服务器的UDP端口

char reqSubNego[10]={(char)0x05,(char)0x03,(char)0x00,(char)0x01,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00};

*(unsigned long*)&reqSubNego[4] =saiServerUDP.sin_addr.S_un.S_addr; // cmd: DEST.addr

*(unsigned short*)&reqSubNego[8]=saiServerUDP.sin_port; // cmd: DEST.port in network octet order

nRet=send(m_socClientTCP_UdpAssociate,(const char*)reqSubNego,10,0);

if (nRet==SOCKET_ERROR) return NEM_E_WM_CREATE_PROXYREQFAILED;



// 接收响应信息

int nRecvCount = 0;

int nRecvBufferLen = 10;

char szRecvBuf[10];

nRet = 0;

if(FD_ISSET(m_socClientTCP_UdpAssociate,&fdread))

{

int nRcvd=0,nCount=0;

do{

nRet = recv(m_socClientTCP_UdpAssociate,(char*)szRecvBuf+nRcvd,10-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=10)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE;}

if (szRecvBuf[0]!=0x05||szRecvBuf[1]!=0x00){return NC_E_PROXY_PROTOCOL_VERSION_SUB;}

}

else

{

return NCM_E_WM_CREATE_PROXYREQUESTFAILED;

}



// 代理服务器绑定udp地址BND.ADR，一般代理服务器都是多宿主机器，因此这个绑定地址是局域网地址，代理服务器绑定udp端口BND.PORT

// m_ulProxyUDPAddr 代理绑定地址

// m_usUDPAssociatePort 代理绑定端口

memmove(&m_ulProxyUDPAddr,&szRecvBuf[4],4);

memmove(&m_usUDPAssociatePort,&szRecvBuf[8],2);



m_bUDPAssociated = TRUE;

// 至此，得到了代理绑定的地址和端口，客户端就可以通过它来收发UDP数据报了





// 客户端收发实例

// 首先创建数据报套接字，绑定套接字，得到本地数据报套接字地址，端口

SOCKET m_socClientUDP=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,WSA_FLAG_OVERLAPPED);

SOCKADDR_IN saiLocal;

memset(&saiLocal,0,sizeof(saiLocal));

saiLocal.sin_family = AF_INET;

saiLocal.sin_port = 0;

saiLocal.sin_addr.S_un.S_addr = INADDR_ANY;

// 绑定本地udp套接字地址，地址+端口由系统决定

if (bind(m_socClientUDP, (SOCKADDR *)&saiLocal, sizeof(saiLocal)  == SOCKET_ERROR)

getsockname(m_socClientUDP, (sockaddr*)&saiLocal, &len);

// m_ulHostAddr 本机绑定地址

// m_usHostPortUdp 本机绑定端口

m_ulHostAddr = saiLocal.sin_addr.S_un.S_addr;

m_usHostPortUdp = saiLocal.sin_port;



// 按照格式，发送数据

SOCKADDR_IN saiProxy;

memset(&saiProxy,0,sizeof(saiProxy));

saiProxy.sin_family = AF_INET;

saiProxy.sin_addr.S_un.S_addr = m_ulProxyUDPAddr; // 代理绑定的udp地址

saiProxy.sin_port = m_usUDPAssociatePort; // 代理绑定的udp端口



// 每个UDP包必须携带如下所述的头：

      +----+------+------+----------+----------+----------+

      |RSV | FRAG | ATYP | DST.ADDR | DST.PORT |   DATA   |

      +----+------+------+----------+----------+----------+

      | 2  |  1   |  1   | Variable |    2     | Variable |

      +----+------+------+----------+----------+----------+

// 其中 ATYP==0x01 表示采用 IPV4 地址，那么头长度就是10，DST.ADDR并不是服务器地址，而是本机绑定地址，DST.PORT是本机绑定端口

char buf[10+2]={'0x00','0x00','0x00','0x01','0xff'};

memmove(&buf[4],&m_ulHostAddr,4);

*(unsigned short*)&buf[8]=m_usHostPortUDP;

int nRet = sendto(m_socClientUDP,buf,12,0,(SOCKADDR*)&saiProxy,sizeof(saiProxy));



// 接收数据

int nLen = sizeof(saiProxy);

char buf=new char[MAX_UDPLEN];

nRet = recvfrom(m_socClientUDP,buf,MAX_UDPLEN,0,(SOCKADDR *)&saiProxy,&nLen);

if(nRet==SOCKET_ERROR) return SOCKET_ERROR;

BYTE flag=0xff;

if(memcmp(&buf[0],&flag,1)==0) return SOCKET_ERROR;

BYTE byProxyHead[20];

byProxyHead[0]=byProxyHead[1]=byProxyHead[2]=0;

byProxyHead[3]=1;

*(unsigned long*)&byProxyHead[4] = saiServerUDP.sin_addr.S_un.S_addr;

*(unsigned short*)&byProxyHead[8] = saiServerUDP.sin_port;

byProxyHead[10]=byProxyHead[11]=byProxyHead[12]=0;

byProxyHead[13]=1;

*(unsigned long*)&byProxyHead[14] = m_ulHostAddr;

*(unsigned short*)&byProxyHead[18] = m_usHostPortUdp;



int i=0;

BOOL bIsForMe=FALSE;

if(memcmp(&byProxyHead[0],&buf[i],4)==0)

{

unsigned long ulRetAddr = *(unsigned long*)&buf[i+4];

if(ulRetAddr==m_ulHostAddr)

{

unsigned short usRetPort = ntohs((unsigned short)(*(unsigned short*)&buf[i+8]));

if(usRetPort==m_usHostPortUdp)

{

bIsForMe=TRUE;

}

}

i+=10;

}

// 客户端收发结束





// 服务器端发送实例

// m_ulProxyUDPAddr 代理绑定地址

// m_usUDPAssociatePort 代理绑定端口

// m_ulHostAddr 本机绑定地址

// m_usHostPortUdp 本机绑定端口

// 客户端必须把上面的m_ulProxyUDPAddr,m_usUDPAssociatePort,m_ulHostAddr,m_usHostPortUdp告知服务器，服务器通过这两个套接字进行数据的收发



// 服务器创建数据报套接字

SOCKET m_socUDP=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,WSA_FLAG_OVERLAPPED);



// 代理的udp中继地址

SOCKADDR_IN saiClient;

saiClient.sin_family = AF_INET;

saiClient.sin_addr.S_un.S_addr = m_ulProxyUDPAddr;

saiClient.sin_port = m_usUDPAssociatePort;

// 如果远程目标在代理服务器后面，透过代理，指定远程目标的socks信息，参照RFC1928

char buffer[10]={'\0'};

buffer[0]=buffer[1]=buffer[2]=0;

buffer[3]=1; // No Fragment, It's a dependent udp, no need for socks server to arrange udp fragments



// 目标机器的地址端口，透过代理后发向这里

*(int*)&buffer[4]=m_ulHostAddr;

*(unsigned short*)&buffer[8]=m_usHostPortUdp;

BYTE buf[DATA_BUFSIZE]={'\0'};

memmove(&buf[10],&szSendbuf[0],dwLength);

memmove(&buf[0],&buffer[0],10);

int nSent = sendto(m_socUDP, (const char*)&buf[0], dwLength+10, 0, (SOCKADDR*)&saiClient,sizeof(saiClient));

// 服务器端发送结束

聂文龙 2008-10-21 02:25 发表评论


re: 代理服务器代码
聂文龙 — Mon, 20 Oct 2008 18:23:00 GMT
VC++6实现简单的代理服务器 



本文转自CSDN的blog：http://blog.csdn.net/snaill/archive/2006/03/14/624437.aspx 



#include "stdafx.h" 

#include "Proxy.h" 

#include < winsock2.h > //WINSOCKET API 2。0 

#include < stdlib.h > 

#include < stdio.h > 

#include < string.h > 



#ifdef _DEBUG 

#define new DEBUG_NEW 

#undef THIS_FILE 

static char THIS_FILE[] = __FILE__; 

#endif 



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





#define HTTP "http://" 

#define FTP "ftp://" 

#define PROXYPORT 5001 //Proxy 端口 

#define BUFSIZE 10240 //缓冲区大小 





CWinApp theApp; 



using namespace std; 



UINT ProxyToServer(LPVOID pParam); 

UINT UserToProxyThread(void *pParam); 



struct SocketPair{ 

SOCKET user_proxy; //socket : 本地机器到PROXY 服务机 

SOCKET proxy_server; //socket : PROXY 服务机到远程主机 

BOOL IsUser_ProxyClosed; // 本地机器到PROXY 服务机状态 

BOOL IsProxy_ServerClosed; // PROXY 服务机到远程主机状态 

}; 





struct ProxyParam{ 

char Address[256]; // 远程主机地址 

HANDLE User_SvrOK; // PROXY 服务机到远程主机的联结状态 

SocketPair *pPair; // 维护一组SOCKET的指针 

int Port; // 用来联结远程主机的端口 

}; //这个结构用来PROXY SERVER与远程主机的信息交换. 



SOCKET gListen_Socket; //用来侦听的SOCKET。 



int StartServer() //启动服务 

{ 

WSADATA wsaData; 

sockaddr_in local; 

SOCKET listen_socket; 



if(::WSAStartup(0x202,&wsaData)!=0) 

{printf("\nError in Startup session.\n");WSACleanup();return -1;}; 



local.sin_family=AF_INET; 

local.sin_addr.s_addr=INADDR_ANY; 

local.sin_port=htons(PROXYPORT); 



listen_socket=socket(AF_INET,SOCK_STREAM,0); 

if(listen_socket==INVALID_SOCKET) 

{printf("\nError in New a Socket.");WSACleanup();return -2;} 



if(::bind(listen_socket,(sockaddr *)&local,sizeof(local))!=0) 

{printf("\n Error in Binding socket."); WSACleanup();return -3; }; 



if(::listen(listen_socket,5)!=0) 

{printf("\n Error in Listen."); WSACleanup(); return -4;} 

gListen_Socket=listen_socket; 

AfxBeginThread(UserToProxyThread,NULL); //启动侦听 

return 1; 

} 



int CloseServer() //关闭服务 

{ 

closesocket(gListen_Socket); 

WSACleanup(); 

return 1; 

} 

//分析接收到的字符，得到远程主机地址 



int GetAddressAndPort( char * str, char *address, int * port) 

{ 

char buf[BUFSIZE], command[512], proto[128], *p; 

int j; 

sscanf(str,"%s%s%s",command,buf,proto); 

p=strstr(buf,HTTP); 

//HTTP 

if(p) 

{ 

p+=strlen(HTTP); 

for(int i=0;i< strlen(p);i++) 

if( *(p+i)=='/') break; 

*(p+i)=0; 

strcpy(address,p); 

p=strstr(str,HTTP); 

for(int j=0;j< i+strlen(HTTP);j++) 

*(p+j)=' '; //去掉远程主机名: GET http:/www.csdn.net/ HTTP1.1 == > GET / HTTP1.1 

*port=80; //缺省的 http 端口 

} 

else 

{//FTP, 不支持, 下面的代码可以省略. 

p=strstr(buf,FTP); 

if(!p) return 0; 

p+=strlen(FTP); 

for(int i=0;i< strlen(p);i++) 

if( *(p+i)=='/') break; //Get The Remote Host 

*(p+i)=0; 

for(j=0;j< strlen(p);j++) 

if(*(p+j)==':') 

{*port=atoi(p+j+1); //Get The Port 

*(p+j)=0; 

} 

else *port=21; 



strcpy(address,p); 

p=strstr(str,FTP); 

for(j=0;j< i+strlen(FTP);j++) 

*(p+j)=' '; 

} 

return 1; 

} 



// 取到本地的数据，发往远程主机 

UINT UserToProxyThread(void *pParam) 

{ 

char Buffer[BUFSIZE]; 

int Len; 

sockaddr_in from; 

SOCKET msg_socket; 

int fromlen,retval; 

SocketPair SPair; 

ProxyParam ProxyP; 

CWinThread *pChildThread; 

fromlen=sizeof(from); 

msg_socket=accept(gListen_Socket,(struct sockaddr*)&from,&fromlen); 

AfxBeginThread(UserToProxyThread,pParam); //启动另一侦听. 

if( msg_socket==INVALID_SOCKET) 

{ printf( "\nError in accept "); return -5;} 

//读客户的第一行数据 



SPair.IsUser_ProxyClosed=FALSE; 

SPair.IsProxy_ServerClosed=TRUE; 

SPair.user_proxy=msg_socket; 



retval=recv(SPair.user_proxy,Buffer,sizeof(Buffer),0); 



if(retval==SOCKET_ERROR) 

{ printf("\nError Recv"); 

if(SPair.IsUser_ProxyClosed==FALSE) 

{closesocket(SPair.user_proxy); 

SPair.IsUser_ProxyClosed=TRUE; 

} 

} 

if(retval==0) 

{printf("Client Close connection\n"); 

if(SPair.IsUser_ProxyClosed==FALSE) 

{closesocket(SPair.user_proxy); 

SPair.IsUser_ProxyClosed=TRUE; 

} 

} 

Len=retval; 

#ifdef _DEBUG 



Buffer[Len]=0; 

printf("\n Received %d bytes,data[%s]from client\n",retval,Buffer); 

#endif 

// 

SPair.IsUser_ProxyClosed=FALSE; 

SPair.IsProxy_ServerClosed=TRUE; 

SPair.user_proxy=msg_socket; 



ProxyP.pPair=&SPair; 

ProxyP.User_SvrOK=CreateEvent(NULL,TRUE,FALSE,NULL); 



GetAddressAndPort( Buffer,ProxyP.Address,&ProxyP.Port); 



pChildThread=AfxBeginThread(ProxyToServer,(LPVOID)&ProxyP); 

::WaitForSingleObject(ProxyP.User_SvrOK,60000); //等待联结 

::CloseHandle(ProxyP.User_SvrOK); 



while(SPair.IsProxy_ServerClosed ==FALSE && SPair.IsUser_ProxyClosed==FALSE) 

{ 

retval=send(SPair.proxy_server,Buffer,Len,0); 

if(retval==SOCKET_ERROR) 

{ printf("\n send() failed:error%d\n",WSAGetLastError()); 

if(SPair.IsProxy_ServerClosed==FALSE) 

{ 

closesocket(SPair.proxy_server); 

SPair.IsProxy_ServerClosed=TRUE; 

} 

continue; 

} 

retval=recv(SPair.user_proxy,Buffer,sizeof(Buffer),0); 



if(retval==SOCKET_ERROR) 

{ printf("\nError Recv"); 

if(SPair.IsUser_ProxyClosed==FALSE) 

{closesocket(SPair.user_proxy); 

SPair.IsUser_ProxyClosed=TRUE; 

} 

continue; 

} 

if(retval==0) 

{printf("Client Close connection\n"); 

if(SPair.IsUser_ProxyClosed==FALSE) 

{closesocket(SPair.user_proxy); 

SPair.IsUser_ProxyClosed=TRUE; 

} 

break; 

} 

Len=retval; 

#ifdef _DEBUG 

Buffer[Len]=0; 

printf("\n Received %d bytes,data[%s]from client\n",retval,Buffer); 

#endif 



} //End While 



if(SPair.IsProxy_ServerClosed==FALSE) 

{ 

closesocket(SPair.proxy_server); 

SPair.IsProxy_ServerClosed=TRUE; 

} 

if(SPair.IsUser_ProxyClosed==FALSE) 

{closesocket(SPair.user_proxy); 

SPair.IsUser_ProxyClosed=TRUE; 

} 

::WaitForSingleObject(pChildThread- >m_hThread,20000); //Should check the return value 

return 0; 

} 

// 读取远程主机数据，并发往本地客户机 

UINT ProxyToServer(LPVOID pParam){ 

ProxyParam * pPar=(ProxyParam*)pParam; 

char Buffer[BUFSIZE]; 

char *server_name= "localhost"; 

unsigned short port ; 

int retval,Len; 

unsigned int addr; 

int socket_type ; 

struct sockaddr_in server; 

struct hostent *hp; 

SOCKET conn_socket; 



socket_type = SOCK_STREAM; 

server_name = pPar- >Address; 

port = pPar- >Port; 



if (isalpha(server_name[0])) { /* server address is a name */ 

hp = gethostbyname(server_name); 

} 

else { /* Convert nnn.nnn address to a usable one */ 

addr = inet_addr(server_name); 

hp = gethostbyaddr((char *)&addr,4,AF_INET); 

} 

if (hp == NULL ) { 

fprintf(stderr,"Client: Cannot resolve address [%s]: Error %d\n", 

server_name,WSAGetLastError()); 

::SetEvent(pPar- >User_SvrOK); 

return 0; 

} 



// 

// Copy the resolved information into the sockaddr_in structure 

// 

memset(server,0,sizeof(server)); 

memcpy(&(server.sin_addr),hp- >h_addr,hp- >h_length); 

server.sin_family = hp- >h_addrtype; 

server.sin_port = htons(port); 



conn_socket = socket(AF_INET,socket_type,0); /* 打开一个 socket */ 

if (conn_socket < 0 ) { 

fprintf(stderr,"Client: Error Opening socket: Error %d\n", 

WSAGetLastError()); 

pPar- >pPair- >IsProxy_ServerClosed=TRUE; 

::SetEvent(pPar- >User_SvrOK); 

return -1; 

} 

#ifdef _DEBUG 

printf("Client connecting to: %s\n",hp- >h_name); 

#endif 

if (connect(conn_socket,(struct sockaddr*)server,sizeof(server)) 

== SOCKET_ERROR) { 

fprintf(stderr,"connect() failed: %d\n",WSAGetLastError()); 

pPar- >pPair- >IsProxy_ServerClosed=TRUE; 

::SetEvent(pPar- >User_SvrOK); 

return -1; 

} 

pPar- >pPair- >proxy_server=conn_socket; 

pPar- >pPair- >IsProxy_ServerClosed=FALSE; 

::SetEvent(pPar- >User_SvrOK); 

// cook up a string to send 

while(!pPar- >pPair- >IsProxy_ServerClosed &&!pPar- >pPair- >IsUser_ProxyClosed) 

{ 

retval = recv(conn_socket,Buffer,sizeof (Buffer),0 ); 

if (retval == SOCKET_ERROR ) { 

fprintf(stderr,"recv() failed: error %d\n",WSAGetLastError()); 

closesocket(conn_socket); 

pPar- >pPair- >IsProxy_ServerClosed=TRUE; 

break; 

} 

Len=retval; 

if (retval == 0) { 

printf("Server closed connection\n"); 

closesocket(conn_socket); 

pPar- >pPair- >IsProxy_ServerClosed=TRUE; 

break; 

} 



retval = send(pPar- >pPair- >user_proxy,Buffer,Len,0); 

if (retval == SOCKET_ERROR) { 

fprintf(stderr,"send() failed: error %d\n",WSAGetLastError()); 

closesocket(pPar- >pPair- >user_proxy); 

pPar- >pPair- >IsUser_ProxyClosed=TRUE; 

break; 

} 

#ifdef _DEBUG 

Buffer[Len]=0; 

printf("Received %d bytes, data [%s] from server\n",retval,Buffer); 

#endif 

} 

if(pPar- >pPair- >IsProxy_ServerClosed==FALSE) 

{ 

closesocket(pPar- >pPair- >proxy_server); 

pPar- >pPair- >IsProxy_ServerClosed=TRUE; 

} 

if(pPar- >pPair- >IsUser_ProxyClosed==FALSE) 

{closesocket(pPar- >pPair- >user_proxy); 

pPar- >pPair- >IsUser_ProxyClosed=TRUE; 

} 

return 1; 

} 







int _tmain(int argc, TCHAR* argv[], TCHAR* envp[]) 

{ 

int nRetCode = 0; 



// 初始化SOCKET 

if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0)) 

{ 

// 错误处理 

cerr < < _T("Fatal Error: MFC initialization failed") < < endl; 

nRetCode = 1; 

} 

else 

{ 

// 主程序开始. 

StartServer(); 

while(1) 

if(getchar()=='q') break; 

CloseServer(); 

} 



return nRetCode; 

} 

聂文龙 2008-10-21 02:23 发表评论


re: 代理服务器代码
聂文龙 — Mon, 20 Oct 2008 18:22:00 GMT
打造自己的HTTP代理服务器

#include "stdafx.h"

#include "HTTPPROXY.h"

#define FD_NOEVENT 0

//

#define BACKUP 100

#define MAXDATALEN 65535

int HttpListenPort;

SOCKET HttpListenSock;

//

typedef struct _CLIENTINFO{

SOCKET clientsock;

SOCKET udpsock;

sockaddr_in clientsock_addr;

}CLIENTINFO,*LPCLIENTINFO;

CLIENTINFO HttpClientInfo;

//

typedef struct _SOCKINFO{

SOCKET sourcesock;

SOCKET destsock;

}SOCKINFO,*LPSOCKINFO;

SOCKINFO httpsockinfo;

//

extern long GetSocketEventId(SOCKET remotesock);

extern unsigned long GetLocalIp();

extern unsigned long GetDomainIp(char domainname[250]);

/*

long GetSocketEventId(SOCKET remotesock){

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,i,index_start,index_end,port;

CString HttpString,UrlString,PortString;

pclientinfo=(LPCLIENTINFO)info;

clientsock=pclientinfo->clientsock;

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;

TRACE("get http string:\r\n");

TRACE(HttpString);

index_start=HttpString.Find("Host: ",0); //寻找url标记

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); //读取 url字符串

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;

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.clientsock=NewSock;

HttpClientInfo.clientsock_addr=remotesock_addr;

TRACE("start proxy thread\r\n");

AfxBeginThread(HttpProxyServerThread,(LPVOID)&HttpClientInfo);

Sleep(100);

}

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();

}

}



int CHTTPPROXY::StartProxy(int listenport)

{

HttpListenPort=listenport;

AfxBeginThread(StartHttpProxy,(LPVOID)NULL);

return 1;

}





/*=========================================================

FILE:HTTPPROXY.h

==========================================================*/

class CHTTPPROXY 

{

public:

int StartProxy(int listenport);

bool WsaStartupOk;

CHTTPPROXY();

virtual ~CHTTPPROXY();



};



/*==================================================

FILE:stdafx.h

===================================================*/

#include 

#include 

#include 

#include





注:不要忘了在link选项中添加wsock32.lib和ws2_32.lib，或在文件前部加上如下语句：

#paragma comment(lib,"wsock32.lib")

#paragma comment(lib,"ws2_32.lib")



本代码在win2k和vc6.0下编译成功~~

用法,把这几个文件添加到你的项目中，在WinMain()中添加如下代码:

CHTTPPROXY httpproxy;

httpproxy.StartProxy(7890);

有问题mailto me！ 



 



聂文龙 2008-10-21 02:22 发表评论