winsock的两篇文章

梦里梦外; 2022-09-30 00:37 142阅读 0赞

<table style="width: 100%; color: #000000; border-collapse: collapse;"> 
 <tbody> 
 <tr> 
 <td> WinSock学习笔记（一） 作者：<a href="mailto:xiaoj@njb.swirebev.com" rel="nofollow">肖进</a> Socket（套接字） ◆先看定义： <pre>typedef unsigned int u_int;
typedef u_int SOCKET;</pre> ◆Socket相当于进行网络通信两端的插座，只要对方的Socket和自己的Socket有通信联接，双方就可以发送和接收数据了。其定义类似于文件句柄的定义。 ◆Socket有五种不同的类型： 1、流式套接字(stream socket) 定义： <pre>#define SOCK_STREAM 1&nbsp;</pre> 流式套接字提供了双向、有序的、无重复的以及无记录边界的数据流服务，适合处理大量数据。它是面向联结的，必须建立数据传输链路，同时还必须对传输的数据进行验证，确保数据的准确性。因此，系统开销较大。 2、 数据报套接字(datagram socket) 定义： <pre>#define SOCK_DGRAM 2&nbsp;</pre> 数据报套接字也支持双向的数据流，但不保证传输数据的准确性，但保留了记录边界。由于数据报套接字是无联接的，例如广播时的联接，所以并不保证接收端是否正在侦听。数据报套接字传输效率比较高。 3、原始套接字(raw-protocol interface) 定义： <pre>#define SOCK_RAW 3&nbsp;</pre> 原始套接字保存了数据包中的完整IP头，前面两种套接字只能收到用户数据。因此可以通过原始套接字对数据进行分析。 其它两种套接字不常用，这里就不介绍了。 ◆Socket开发所必须需要的文件(以WinSock V2.0为例)： 头文件：Winsock2.h 库文件：WS2_32.LIB 动态库：W32_32.DLL <img alt=""> 一些重要的定义 1、数据类型的基本定义：这个大家一看就懂。 <pre>typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;</pre> 2、 网络地址的数据结构，有一个老的和一个新的的，请大家留意，如果想知道为什么， 请发邮件给Bill Gate。其实就是计算机的IP地址，不过一般不用用点分开的IP地 址，当然也提供一些转换函数。 ◆ 旧的网络地址结构的定义，为一个4字节的联合： <pre>struct in_addr {
union {
struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
struct { u_short s_w1,s_w2; } S_un_w;
u_long S_addr;
} S_un;
#define s_addr S_un.S_addr /* can be used for most tcp &amp; ip code */
//下面几行省略,反正没什么用处。
};</pre> 其实完全不用这么麻烦，请看下面: ◆ 新的网络地址结构的定义： 非常简单，就是一个无符号长整数 unsigned long。举个例子：IP地址为127.0.0.1的网络地址是什么呢？请看定义： <pre>#define INADDR_LOOPBACK 0x7f000001</pre> 3、 套接字地址结构 (1)、sockaddr结构： <pre>struct sockaddr {
u_short sa_family; /* address family */
char sa_data[14]; /* up to 14 bytes of direct address */
};</pre> sa_family为网络地址类型，一般为AF_INET，表示该socket在Internet域中进行通信，该地址结构随选择的协议的不同而变化，因此一般情况下另一个与该地址结构大小相同的sockaddr_in结构更为常用，sockaddr_in结构用来标识TCP/IP协议下的地址。换句话说，这个结构是通用socket地址结构，而下面的sockaddr_in是专门针对Internet域的socket地址结构。 (2)、sockaddr_in结构 <pre>struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};</pre> sin _family为网络地址类型，必须设定为AF_INET。sin_port为服务端口，注意不要使用已固定的服务端口，如HTTP的端口80等。如果端口设置为0，则系统会自动分配一个唯一端口。sin_addr为一个unsigned long的IP地址。sin_zero为填充字段，纯粹用来保证结构的大小。 ◆ 将常用的用点分开的IP地址转换为unsigned long类型的IP地址的函数： <pre>unsigned long inet_addr(const char FAR * cp )</pre> 用法： <pre>unsigned long addr=inet_addr("192.1.8.84")</pre> ◆ 如果将sin_addr设置为INADDR_ANY，则表示所有的IP地址，也即所有的计算机。 <pre>#define INADDR_ANY (u_long)0x00000000</pre> 4、 主机地址： 先看定义： <pre>struct hostent {
char FAR * h_name; /* official name of host */
char FAR * FAR * h_aliases; /* alias list */
short h_addrtype; /* host address type */
short h_length; /* length of address */
char FAR * FAR * h_addr_list; /* list of addresses */
#define h_addr h_addr_list[0] /* address, for backward compat */
};
h_name为主机名字。
h_aliases为主机别名列表。
h_addrtype为地址类型。
h_length为地址类型。
h_addr_list为IP地址，如果该主机有多个网卡，就包括地址的列表。</pre> 另外还有几个类似的结构，这里就不一一介绍了。 5、 常见TCP/IP协议的定义： <pre>#define IPPROTO_IP 0&nbsp;
#define IPPROTO_ICMP 1&nbsp;
#define IPPROTO_IGMP 2&nbsp;
#define IPPROTO_TCP 6&nbsp;
#define IPPROTO_UDP 17&nbsp;
#define IPPROTO_RAW 255&nbsp;</pre> 具体是什么协议，大家一看就知道了。 <img alt=""> 套接字的属性 为了灵活使用套接字，我们可以对它的属性进行设定。 1、 属性内容： <pre>//允许调试输出
#define SO_DEBUG 0x0001 /* turn on debugging info recording */
//是否监听模式
#define SO_ACCEPTCONN 0x0002 /* socket has had listen() */
//套接字与其他套接字的地址绑定
#define SO_REUSEADDR 0x0004 /* allow local address reuse */
//保持连接
#define SO_KEEPALIVE 0x0008 /* keep connections alive */
//不要路由出去
#define SO_DONTROUTE 0x0010 /* just use interface addresses */
//设置为广播
#define SO_BROADCAST 0x0020 /* permit sending of broadcast msgs */
//使用环回不通过硬件
#define SO_USELOOPBACK 0x0040 /* bypass hardware when possible */
//当前拖延值
#define SO_LINGER 0x0080 /* linger on close if data present */
//是否加入带外数据
#define SO_OOBINLINE 0x0100 /* leave received OOB data in line */
//禁用LINGER选项
#define SO_DONTLINGER (int)(~SO_LINGER)
//发送缓冲区长度
#define SO_SNDBUF 0x1001 /* send buffer size */
//接收缓冲区长度
#define SO_RCVBUF 0x1002 /* receive buffer size */
//发送超时时间
#define SO_SNDTIMEO 0x1005 /* send timeout */
//接收超时时间
#define SO_RCVTIMEO 0x1006 /* receive timeout */
//错误状态
#define SO_ERROR 0x1007 /* get error status and clear */
//套接字类型
#define SO_TYPE 0x1008 /* get socket type */</pre> 2、 读取socket属性： <pre>int getsockopt(SOCKET s, int level, int optname, char FAR * optval, int FAR * optlen)</pre> s为欲读取属性的套接字。level为套接字选项的级别，大多数是特定协议和套接字专有的。如IP协议应为 IPPROTO_IP。 <pre>optname为读取选项的名称
optval为存放选项值的缓冲区指针。
optlen为缓冲区的长度</pre> 用法： <pre>int ttl=0; //读取TTL值
int rc = getsockopt( s, IPPROTO_IP, IP_TTL, (char *)&amp;ttl, sizeof(ttl));
//来自MS platform SDK 2003</pre> 3、 设置socket属性： <pre>int setsockopt(SOCKET s,int level, int optname,const char FAR * optval, int optlen)</pre> s为欲设置属性的套接字。 level为套接字选项的级别，用法同上。 optname为设置选项的名称 optval为存放选项值的缓冲区指针。 optlen为缓冲区的长度 用法： <pre>int ttl=32; //设置TTL值
int rc = setsockopt( s, IPPROTO_IP, IP_TTL, (char *)&amp;ttl, sizeof(ttl));</pre> <img alt=""> 套接字的使用步骤 1、启动Winsock：对Winsock DLL进行初始化，协商Winsock的版本支持并分配必要的 资源。（服务器端和客户端） <pre>int WSAStartup( WORD wVersionRequested, LPWSADATA lpWSAData )

wVersionRequested为打算加载Winsock的版本，一般如下设置：
wVersionRequested=MAKEWORD(2,0)
或者直接赋值：wVersionRequested=2

LPWSADATA为初始化Socket后加载的版本的信息,定义如下：
typedef struct WSAData {
WORD wVersion;
WORD wHighVersion;
char szDescription[WSADESCRIPTION_LEN+1];
char szSystemStatus[WSASYS_STATUS_LEN+1];
unsigned short iMaxSockets;
unsigned short iMaxUdpDg;
char FAR * lpVendorInfo;
} WSADATA, FAR * LPWSADATA;</pre> 如果加载成功后数据为： <pre>wVersion＝2表示加载版本为2.0。
wHighVersion＝514表示当前系统支持socket最高版本为2.2。
szDescription="WinSock 2.0"
szSystemStatus="Running"表示正在运行。
iMaxSockets＝0表示同时打开的socket最大数，为0表示没有限制。
iMaxUdpDg＝0表示同时打开的数据报最大数，为0表示没有限制。
lpVendorInfo没有使用，为厂商指定信息预留。</pre> 该函数使用方法： <pre>WORD wVersion=MAKEWORD(2,0);
WSADATA wsData;
int nResult= WSAStartup(wVersion,&amp;wsData);
if(nResult !=0)
{
//错误处理
}</pre> 2、创建套接字：（服务器端和客户端） <pre>SOCKET socket( int af, int type, int protocol );
af为网络地址类型，一般为AF_INET，表示在Internet域中使用。
type为套接字类型，前面已经介绍了。
protocol为指定网络协议，一般为IPPROTO_IP。</pre> 用法： <pre>SOCKET sock=socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
if(sock==INVALID_SOCKET)
{
//错误处理
}</pre> 3、套接字的绑定：将本地地址绑定到所创建的套接字上。（服务器端和客户端） <pre>int bind( SOCKET s, const struct sockaddr FAR * name, int namelen )
s为已经创建的套接字。
name为socket地址结构，为sockaddr结构，如前面讨论的，我们一般使用sockaddr_in
结构，在使用再强制转换为sockaddr结构。
namelen为地址结构的长度。
</pre> 用法： <pre>sockaddr_in addr;
addr. sin_family=AF_INET;
addr. sin_port= htons(0); //保证字节顺序
addr. sin_addr.s_addr= inet_addr("192.1.8.84")
int nResult=bind(s,(sockaddr*)&amp;addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//错误处理
}</pre> 4、 套接字的监听：（服务器端） <pre>int listen(SOCKET s, int backlog )</pre> s为一个已绑定但未联接的套接字。 backlog为指定正在等待联接的最大队列长度，这个参数非常重要，因为服务器一般可 以提供多个连接。 用法： <pre>int nResult=listen(s,5) //最多5个连接
if(nResult==SOCKET_ERROR)
{
//错误处理
}</pre> 5、套接字等待连接:：（服务器端） <pre>SOCKET accept( SOCKET s, struct sockaddr FAR * addr, int FAR * addrlen )</pre> s为处于监听模式的套接字。 sockaddr为接收成功后返回客户端的网络地址。 addrlen为网络地址的长度。 用法： <pre>sockaddr_in addr;
SOCKET s_d=accept(s,(sockaddr*)&amp;addr,sizeof(sockaddr));
if(s==INVALID_SOCKET)
{
//错误处理
}</pre> 6、套接字的连结：将两个套接字连结起来准备通信。（客户端） <pre>int connect(SOCKET s, const struct sockaddr FAR * name, int namelen )</pre> s为欲连结的已创建的套接字。 name为欲连结的socket地址。 namelen为socket地址的结构的长度。 用法： <pre>sockaddr_in addr;
addr. sin_family=AF_INET;
addr. sin_port=htons(0); //保证字节顺序
addr. sin_addr.s_addr= htonl(INADDR_ANY) //保证字节顺序
int nResult=connect(s,(sockaddr*)&amp;addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//错误处理
}</pre> 7、套接字发送数据：（服务器端和客户端） <pre>int send(SOCKET s, const char FAR * buf, int len, int flags )</pre> s为服务器端监听的套接字。 buf为欲发送数据缓冲区的指针。 len为发送数据缓冲区的长度。 flags为数据发送标记。 返回值为发送数据的字符数。 ◆这里讲一下这个发送标记，下面8中讨论的接收标记也一样： flag取值必须为0或者如下定义的组合：0表示没有特殊行为。 #define MSG_OOB 0x1 /* process out-of-band data */ #define MSG_PEEK 0x2 /* peek at incoming message */ #define MSG_DONTROUTE 0x4 /* send without using routing tables */ MSG_OOB表示数据应该带外发送，所谓带外数据就是TCP紧急数据。 MSG_PEEK表示使有用的数据复制到缓冲区内，但并不从系统缓冲区内删除。 MSG_DONTROUTE表示不要将包路由出去。 用法： <pre>char buf[]="xiaojin";
int nResult=send(s,buf,strlen(buf));
if(nResult==SOCKET_ERROR)
{
//错误处理
}</pre> 8、 套接字的数据接收：（客户端） <pre>int recv( SOCKET s, char FAR * buf, int len, int flags )</pre> s为准备接收数据的套接字。 buf为准备接收数据的缓冲区。 len为准备接收数据缓冲区的大小。 flags为数据接收标记。 返回值为接收的数据的字符数。 用法： <pre>char mess[1000];
int nResult =recv(s,mess,1000,0);
if(nResult==SOCKET_ERROR)
{
//错误处理
}</pre> 9、中断套接字连接：通知服务器端或客户端停止接收和发送数据。（服务器端和客户端） <pre>int shutdown(SOCKET s, int how)</pre> s为欲中断连接的套接字。 How为描述禁止哪些操作，取值为：SD_RECEIVE、SD_SEND、SD_BOTH。 <pre>#define SD_RECEIVE 0x00
#define SD_SEND 0x01
#define SD_BOTH 0x02</pre> 用法： <pre>int nResult= shutdown(s,SD_BOTH);
if(nResult==SOCKET_ERROR)
{
//错误处理
}</pre> 10、 关闭套接字：释放所占有的资源。（服务器端和客户端） <pre>int closesocket( SOCKET s )</pre> s为欲关闭的套接字。 用法： <pre>int nResult=closesocket(s);
if(nResult==SOCKET_ERROR)
{
//错误处理
}
</pre> </td> 
 </tr> 
 <tr> 
 <td> &nbsp;作者信息 肖进 单位：南京中萃食品有限公司 资讯部 邮箱：xiaoj@njb.swirebev.com 电话：025-58642091 &nbsp; 
 <table style="width: 100%;"> 
 <tbody> 
 <tr> 
 <td> WinSock学习笔记（二） 作者：<a href="mailto:xiaoj@njb.swirebev.com" rel="nofollow">肖进</a> &nbsp; 与socket有关的一些函数介绍 1、读取当前错误值：每次发生错误时，如果要对具体问题进行处理，那么就应该调用这个函数取得错误代码。 <pre> int WSAGetLastError(void );
 #define h_errno WSAGetLastError()
</pre> 错误值请自己阅读Winsock2.h。 2、将主机的unsigned long值转换为网络字节顺序(32位)：为什么要这样做呢？因为不同的计算机使用不同的字节顺序存储数据。因此任何从Winsock函数对IP地址和端口号的引用和传给Winsock函数的IP地址和端口号均时按照网络顺序组织的。 <pre> u_long htonl(u_long hostlong);
 举例：htonl(0)=0
 htonl(80)= 1342177280
</pre> 3、将unsigned long数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。 <pre> u_long ntohl(u_long netlong);
 举例：ntohl(0)=0
 ntohl(1342177280)= 80
</pre> 4、将主机的unsigned short值转换为网络字节顺序(16位)：原因同2： <pre> u_short htons(u_short hostshort);
 举例：htonl(0)=0
 htonl(80)= 20480
</pre> 5、将unsigned short数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。 <pre> u_short ntohs(u_short netshort);
 举例：ntohs(0)=0
 ntohsl(20480)= 80
</pre> 6、将用点分割的IP地址转换位一个in_addr结构的地址，这个结构的定义见笔记(一)，实际上就是一个unsigned long值。计算机内部处理IP地址可是不认识如192.1.8.84之类的数据。 <pre> unsigned long inet_addr( const char FAR * cp );
 举例：inet_addr("192.1.8.84")=1409810880
 inet_addr("127.0.0.1")= 16777343
</pre> 如果发生错误，函数返回INADDR_NONE值。 7、将网络地址转换位用点分割的IP地址，是上面函数的逆函数。 <pre> char FAR * inet_ntoa( struct in_addr in );
 举例：char * ipaddr=NULL;
 char addr[20];
 in_addr inaddr;
 inaddr. s_addr=16777343;
 ipaddr= inet_ntoa(inaddr);
 strcpy(addr,ipaddr); </pre> 这样addr的值就变为127.0.0.1。 注意意不要修改返回值或者进行释放动作。如果函数失败就会返回NULL值。 8、获取套接字的本地地址结构： <pre> int getsockname(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
 s为套接字
 name为函数调用后获得的地址值
 namelen为缓冲区的大小。
 </pre> 9、获取与套接字相连的端地址结构： <pre> int getpeername(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
 s为套接字
 name为函数调用后获得的端地址值
 namelen为缓冲区的大小。
 </pre> 10、获取计算机名： <pre> int gethostname( char FAR * name, int namelen );
 name是存放计算机名的缓冲区
 namelen是缓冲区的大小
 用法：
 char szName[255];
 memset(szName,0,255);
 if(gethostname(szName,255)==SOCKET_ERROR)
 {
 		//错误处理
 }
 返回值为：szNmae="xiaojin"
 </pre> 11、根据计算机名获取主机地址： <pre> struct hostent FAR * gethostbyname( const char FAR * name );

name为计算机名。
      用法：
      hostent * host;
      char* ip;
      host= gethostbyname("xiaojin");
      if(host-&gt;h_addr_list[0])
      {
	      struct in_addr addr;
    	  memmove(&amp;addr, host-&gt;h_addr_list[0]，4);
	      //获得标准IP地址
	      ip=inet_ ntoa (addr);
      }

返回值为：hostent-&gt;h_name="xiaojin"
 hostent-&gt;h_addrtype=2 //AF_INET
 hostent-&gt;length=4
 ip="127.0.0.1"
 </pre> Winsock 的I/O操作： 1、 两种I/O模式 
 <ul> 
 <li>阻塞模式：执行I/O操作完成前会一直进行等待，不会将控制权交给程序。套接字 默认为阻塞模式。可以通过多线程技术进行处理。 </li> 
 <li>非阻塞模式：执行I/O操作时，Winsock函数会返回并交出控制权。这种模式使用 起来比较复杂，因为函数在没有运行完成就进行返回，会不断地返回 WSAEWOULDBLOCK错误。但功能强大。</li> 
 </ul> 为了解决这个问题，提出了进行I/O操作的一些I/O模型,下面介绍最常见的三种： 2、select模型： 　　通过调用select函数可以确定一个或多个套接字的状态，判断套接字上是否有数据，或 者能否向一个套接字写入数据。 <pre> int select( int nfds, fd_set FAR * readfds, fd_set FAR * writefds,&nbsp;
 fd_set FAR *exceptfds, const struct timeval FAR * timeout );
 </pre> ◆先来看看涉及到的结构的定义： a、 d_set结构： <pre>#define FD_SETSIZE 64?
typedef struct fd_set {
u_int fd_count; /* how many are SET? */
SOCKET fd_array[FD_SETSIZE]; /* an array of SOCKETs */
} fd_set; </pre> fd_count为已设定socket的数量 fd_array为socket列表，FD_SETSIZE为最大socket数量，建议不小于64。这是微软建 议的。 B、timeval结构： <pre>struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};
</pre> tv_sec为时间的秒值。 tv_usec为时间的毫秒值。 这个结构主要是设置select()函数的等待值，如果将该结构设置为(0,0)，则select()函数 会立即返回。 ◆再来看看select函数各参数的作用： 
 <ol> 
 <li>nfds：没有任何用处，主要用来进行系统兼容用，一般设置为0。</li> 
 <li>readfds：等待可读性检查的套接字组。</li> 
 <li>writefds；等待可写性检查的套接字组。</li> 
 <li>exceptfds：等待错误检查的套接字组。</li> 
 <li>timeout：超时时间。</li> 
 <li>函数失败的返回值：调用失败返回SOCKET_ERROR,超时返回0。</li> 
 </ol>readfds、writefds、exceptfds三个变量至少有一个不为空，同时这个不为空的套接字组 种至少有一个socket，道理很简单，否则要select干什么呢。 举例：测试一个套接字是否可读： <pre>fd_set fdread;
//FD_ZERO定义
// #define FD_ZERO(set) (((fd_set FAR *)(set))-&gt;fd_count=0)
FD_ZERO(&amp;fdread);
FD_SET(s,&amp;fdread)； //加入套接字，详细定义请看winsock2.h
if(select(0,%fdread,NULL,NULL,NULL)&gt;0
{
	//成功
	if(FD_ISSET(s,&amp;fread) //是否存在fread中，详细定义请看winsock2.h
	{
		//是可读的
	}
}</pre> ◆I/O操作函数：主要用于获取与套接字相关的操作参数。 <pre> int ioctlsocket(SOCKET s, long cmd, u_long FAR * argp ); </pre> s为I/O操作的套接字。 cmd为对套接字的操作命令。 argp为命令所带参数的指针。 常见的命令： <pre>//确定套接字自动读入的数据量
#define FIONREAD _IOR(''''f'''', 127, u_long) /* get # bytes to read */
//允许或禁止套接字的非阻塞模式，允许为非0，禁止为0
#define FIONBIO _IOW(''''f'''', 126, u_long) /* set/clear non-blocking i/o */
//确定是否所有带外数据都已被读入
#define SIOCATMARK _IOR(''''s'''', 7, u_long) /* at oob mark? */
</pre> 3、WSAAsynSelect模型： WSAAsynSelect模型也是一个常用的异步I/O模型。应用程序可以在一个套接字上接收以 WINDOWS消息为基础的网络事件通知。该模型的实现方法是通过调用WSAAsynSelect函 数 自动将套接字设置为非阻塞模式，并向WINDOWS注册一个或多个网络时间，并提供一 个通知时使用的窗口句柄。当注册的事件发生时，对应的窗口将收到一个基于消息的通知。 <pre> int WSAAsyncSelect( SOCKET s, HWND hWnd, u_int wMsg, long lEvent); </pre> s为需要事件通知的套接字 hWnd为接收消息的窗口句柄 wMsg为要接收的消息 lEvent为掩码，指定应用程序感兴趣的网络事件组合，主要如下： <pre>#define FD_READ_BIT 0
#define FD_READ (1 &lt;&lt; FD_READ_BIT)
#define FD_WRITE_BIT 1
#define FD_WRITE (1 &lt;&lt; FD_WRITE_BIT)
#define FD_OOB_BIT 2
#define FD_OOB (1 &lt;&lt; FD_OOB_BIT)
#define FD_ACCEPT_BIT 3
#define FD_ACCEPT (1 &lt;&lt; FD_ACCEPT_BIT)
#define FD_CONNECT_BIT 4
#define FD_CONNECT (1 &lt;&lt; FD_CONNECT_BIT)
#define FD_CLOSE_BIT 5
#define FD_CLOSE (1 &lt;&lt; FD_CLOSE_BIT)
</pre> 用法：要接收读写通知： <pre>int nResult= WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE)；
if(nResult==SOCKET_ERROR)
{
	//错误处理
}
</pre> 取消通知： <pre> int nResult= WSAAsyncSelect(s,hWnd,0，0)； 
</pre> 当应用程序窗口hWnd收到消息时，wMsg.wParam参数标识了套接字，lParam的低字标明 了网络事件，高字则包含错误代码。 4、WSAEventSelect模型 WSAEventSelect模型类似WSAAsynSelect模型，但最主要的区别是网络事件发生时会被发 送到一个事件对象句柄，而不是发送到一个窗口。 使用步骤如下： a、 创建事件对象来接收网络事件： <pre>#define WSAEVENT HANDLE
#define LPWSAEVENT LPHANDLE
WSAEVENT WSACreateEvent( void );
</pre> 该函数的返回值为一个事件对象句柄，它具有两种工作状态：已传信(signaled)和未传信 (nonsignaled)以及两种工作模式：人工重设(manual reset)和自动重设(auto reset)。默认未 未传信的工作状态和人工重设模式。 b、将事件对象与套接字关联，同时注册事件，使事件对象的工作状态从未传信转变未 已传信。 <pre> int WSAEventSelect( SOCKET s,WSAEVENT hEventObject,long lNetworkEvents ); </pre> s为套接字 hEventObject为刚才创建的事件对象句柄 lNetworkEvents为掩码，定义如上面所述 c、I/O处理后，设置事件对象为未传信 <pre>BOOL WSAResetEvent( WSAEVENT hEvent );</pre> Hevent为事件对象 成功返回TRUE，失败返回FALSE。 d、等待网络事件来触发事件句柄的工作状态： <pre>DWORD WSAWaitForMultipleEvents( DWORD cEvents,
const WSAEVENT FAR * lphEvents, BOOL fWaitAll,
DWORD dwTimeout, BOOL fAlertable );</pre> lpEvent为事件句柄数组的指针 cEvent为为事件句柄的数目，其最大值为WSA_MAXIMUM_WAIT_EVENTS&nbsp; fWaitAll指定等待类型：TRUE：当lphEvent数组重所有事件对象同时有信号时返回； FALSE：任一事件有信号就返回。 dwTimeout为等待超时（毫秒） fAlertable为指定函数返回时是否执行完成例程 对事件数组中的事件进行引用时，应该用WSAWaitForMultipleEvents的返回值，减去 预声明值WSA_WAIT_EVENT_0，得到具体的引用值。例如： <pre>nIndex=WSAWaitForMultipleEvents(…);
MyEvent=EventArray[Index- WSA_WAIT_EVENT_0];</pre> e、判断网络事件类型： <pre>int WSAEnumNetworkEvents( SOCKET s,
WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents );</pre> s为套接字 hEventObject为需要重设的事件对象 lpNetworkEvents为记录网络事件和错误代码，其结构定义如下： <pre>typedef struct _WSANETWORKEVENTS {
	long lNetworkEvents;
	int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;</pre> f、关闭事件对象句柄： <pre>BOOL WSACloseEvent(WSAEVENT hEvent);</pre> 调用成功返回TRUE，否则返回FALSE。 　 &nbsp; </td> 
 </tr> 
 <tr> 
 <td>作者简介 肖进 南京中萃食品有限公司 资讯部 电子邮件：xiaoj@njb.swirebev.com 电话：025-58642091 </td> 
 </tr> 
 </tbody> 
 </table> </td> 
 </tr> 
 </tbody> 
</table>

//-----------------------------------------------------------------------------

**Windows Socket 网络编程(一)** —— **TCP/IP体系结构、特点及相关术语**  
作者: [冰点工作室][Link 1] [小鹰][Link 2]

**![Image 1][] 一、TCP/IP 体系结构与特点**  
  
**1、TCP/IP体系结构**  
  
TCP/IP协议实际上就是在物理网上的一组完整的网络协议。其中TCP是提供传输层服务，而IP则是提供网络层服务。TCP/IP包括以下协议：（结构如图1.1）  
![Image 1][]  
(图1.1)  
  
IP： 网间协议(Internet Protocol) 负责主机间数据的路由和网络上数据的存储。同时为ICMP，TCP，UDP提供分组发送服务。用户进程通常不需要涉及这一层。  
ARP： 地址解析协议(Address Resolution Protocol)  
此协议将网络地址映射到硬件地址。  
RARP： 反向地址解析协议(Reverse Address Resolution Protocol)  
此协议将硬件地址映射到网络地址  
ICMP： 网间报文控制协议(Internet Control Message Protocol)  
此协议处理信关和主机的差错和传送控制。  
TCP： 传送控制协议(Transmission Control Protocol)  
这是一种提供给用户进程的可靠的全双工字节流面向连接的协议。它要为用户进程提供虚电路服务，并为数据可靠传输建立检查。（注：大多数网络用户程序使用TCP）  
UDP： 用户数据报协议(User Datagram Protocol)  
这是提供给用户进程的无连接协议，用于传送数据而不执行正确性检查。  
FTP： 文件传输协议(File Transfer Protocol)  
允许用户以文件操作的方式（文件的增、删、改、查、传送等）与另一主机相互通信。  
SMTP： 简单邮件传送协议(Simple Mail Transfer Protocol)  
SMTP协议为系统之间传送电子邮件。  
TELNET：终端协议(Telnet Terminal Procotol)  
允许用户以虚终端方式访问远程主机  
HTTP： 超文本传输协议(Hypertext Transfer Procotol)  
TFTP: 简单文件传输协议(Trivial File Transfer Protocol)  
  
**2、TCP/IP特点**  
TCP/IP协议的核心部分是传输层协议(TCP、UDP)，网络层协议(IP)和物理接口层，这三层通常是在操作系统内核中实现。因此用户一般不涉及。编程时，编程界面有两种形式：一、是由内核心直接提供的系统调用；二、使用以库函数方式提供的各种函数。前者为核内实现，后者为核外实现。用户服务要通过核外的应用程序才能实现，所以要使用套接字(socket)来实现。  
图1.2是TCP/IP协议核心与应用程序关系图。  
![Image 1][]  
(图1.2)  
  
**![Image 1][] 二、专用术语**  
1、套接字  
它是网络的基本构件。它是可以被命名和寻址的通信端点，使用中的每一个套接字都有其类型和一个与之相连听进程。套接字存在通信区域（通信区域又称地址簇）中。套接字只与同一区域中的套接字交换数据（跨区域时，需要执行某和转换进程才能实现）。WINDOWS 中的套接字只支持一个域——网际域。套接字具有类型。  
WINDOWS SOCKET 1.1 版本支持两种套接字：流套接字(SOCK\_STREAM)和数据报套接字(SOCK\_DGRAM)

2、WINDOWS SOCKETS 实现  
一个WINDOWS SOCKETS 实现是指实现了WINDOWS SOCKETS规范所描述的全部功能的一套软件。一般通过DLL文件来实现

3、阻塞处理例程  
阻塞处理例程(blocking hook,阻塞钩子)是WINDOWS SOCKETS实现为了支持阻塞套接字函数调用而提供的一种机制。

4、多址广播（multicast，多点传送或组播）  
是一种一对多的传输方式，传输发起者通过一次传输就将信息传送到一组接收者，与单点传送  
(unicast)和广播(Broadcast)相对应。

**Windows Socket 网络编程(二) —— 套接字编程原理**  
作者: [冰点工作室][Link 1] [小鹰][Link 2]

![Image 1][] **一、客户机/服务器模式**  
在TCP/IP网络中两个进程间的相互作用的主机模式是客户机/服务器模式(Client/Server model)。该模式的建立基于以下两点：1、非对等作用；2、通信完全是异步的。客户机/服务器模式在操作过程中采取的是主动请示方式：  
  
首先服务器方要先启动，并根据请示提供相应服务：（过程如下）  
1、打开一通信通道并告知本地主机，它愿意在某一个公认地址上接收客户请求。  
2、等待客户请求到达该端口。  
3、接收到重复服务请求，处理该请求并发送应答信号。  
4、返回第二步，等待另一客户请求  
5、关闭服务器。  
客户方：  
1、打开一通信通道，并连接到服务器所在主机的特定端口。  
2、向服务器发送服务请求报文，等待并接收应答；继续提出请求……  
3、请求结束后关闭通信通道并终止。  
  
![Image 1][] **二、基本套接字**  
为了更好说明套接字编程原理，给出几个基本的套接字，在以后的篇幅中会给出更详细的使用说明。  
1、创建套接字——socket()  
功能：使用前创建一个新的套接字  
格式：SOCKET PASCAL FAR socket(int af,int type,int procotol);  
参数：af: 通信发生的区域  
type: 要建立的套接字类型  
procotol: 使用的特定协议  
  
2、指定本地地址——bind()  
功能：将套接字地址与所创建的套接字号联系起来。  
格式：int PASCAL FAR bind(SOCKET s,const struct sockaddr FAR \* name,int namelen);  
参数：s: 是由socket()调用返回的并且未作连接的套接字描述符（套接字号）。  
其它：没有错误，bind()返回0，否则SOCKET\_ERROR  
地址结构说明：  
struct sockaddr\_in  
\{  
short sin\_family;//AF\_INET  
u\_short sin\_port;//16位端口号，网络字节顺序  
struct in\_addr sin\_addr;//32位IP地址，网络字节顺序  
char sin\_zero\[8\];//保留  
\}  
  
3、建立套接字连接——connect()和accept()  
功能：共同完成连接工作  
格式：int PASCAL FAR connect(SOCKET s,const struct sockaddr FAR \* name,int namelen);  
SOCKET PASCAL FAR accept(SOCKET s,struct sockaddr FAR \* name,int FAR \* addrlen);  
参数：同上  
  
4、监听连接——listen()  
功能：用于面向连接服务器，表明它愿意接收连接。  
格式：int PASCAL FAR listen(SOCKET s, int backlog);  
  
5、数据传输——send()与recv()  
功能：数据的发送与接收  
格式：int PASCAL FAR send(SOCKET s,const char FAR \* buf,int len,int flags);  
int PASCAL FAR recv(SOCKET s,const char FAR \* buf,int len,int flags);  
参数：buf:指向存有传输数据的缓冲区的指针。

6、多路复用——select()  
功能：用来检测一个或多个套接字状态。  
格式：int PASCAL FAR select(int nfds,fd\_set FAR \* readfds,fd\_set FAR \* writefds,  
fd\_set FAR \* exceptfds,const struct timeval FAR \* timeout);  
参数：readfds:指向要做读检测的指针  
writefds:指向要做写检测的指针  
exceptfds:指向要检测是否出错的指针  
timeout:最大等待时间

7、关闭套接字——closesocket()  
功能：关闭套接字s  
格式：BOOL PASCAL FAR closesocket(SOCKET s);

![Image 1][] **三、典型过程图**  
2.1 面向连接的套接字的系统调用时序图  
![Image 1][]  
  
  
2.2 无连接协议的套接字调用时序图  
![Image 1][]  
  
  
2.3 面向连接的应用程序流程图  
![Image 1][]

**Windows Sockets 网络编程(三) —— WINDOWS SOCKETS 1.1 程序设计**  
作者:[冰点工作室][Link 1] [小鹰][Link 2]

![Image 1][] **一、简介**  
WINDOWS SOCKETS 是从 Berkeley Sockets 扩展而来的，其在继承 Berkeley Sockets 的基础上，又进行了新的扩充。这些扩充主要是提供了一些异步函数，并增加了符合WINDOWS消息驱动特性的网络事件异步选择机制。  
WINDOWS SOCKETS由两部分组成：开发组件和运行组件。  
开发组件：WINDOWS SOCKETS 实现文档、应用程序接口(API)引入库和一些头文件。  
运行组件：WINDOWS SOCKETS 应用程序接口的动态链接库(WINSOCK.DLL)。

![Image 1][] **二、主要扩充说明**  
  
**1、异步选择机制：**  
WINDOWS SOCKETS 的异步选择函数提供了消息机制的网络事件选择，当使用它登记网络事件发生时，应用程序相应窗口函数将收到一个消息，消息中指示了发生的网络事件，以及与事件相关的一些信息。  
WINDOWS SOCKETS 提供了一个异步选择函数 WSAAsyncSelect()，用它来注册应用程序感兴趣的网络事件，当这些事件发生时，应用程序相应的窗口函数将收到一个消息。  
函数结构如下：

int PASCAL FAR WSAAsyncSelect(SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent);

参数说明：  
hWnd：窗口句柄  
wMsg：需要发送的消息  
lEvent：事件（以下为事件的内容）  
值： 含义：  
FD\_READ 期望在套接字上收到数据（即读准备好）时接到通知  
FD\_WRITE 期望在套接字上可发送数据（即写准备好）时接到通知  
FD\_OOB 期望在套接字上有带外数据到达时接到通知  
FD\_ACCEPT 期望在套接字上有外来连接时接到通知  
FD\_CONNECT 期望在套接字连接建立完成时接到通知  
FD\_CLOSE 期望在套接字关闭时接到通知  
例如：我们要在套接字读准备好或写准备好时接到通知，语句如下：

rc=WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE);

如果我们需要注销对套接字网络事件的消息发送，只要将 lEvent 设置为0  
  
**2、异步请求函数**  
在 Berkeley Sockets 中请求服务是阻塞的，WINDOWS SICKETS 除了支持这一类函数外，还增加了相应的异步请求函数(WSAAsyncGetXByY();)。

**3、阻塞处理方法**  
WINDOWS SOCKETS 为了实现当一个应用程序的套接字调用处于阻塞时，能够放弃CPU让其它应用程序运行，它在调用处于阻塞时便进入一个叫“HOOK”的例程，此例程负责接收和分配WINDOWS消息，使得其它应用程序仍然能够接收到自己的消息并取得控制权。  
WINDOWS 是非抢先的多任务环境，即若一个程序不主动放弃其控制权，别的程序就不能执行。因此在设计 WINDOWS SOCKETS 程序时，尽管系统支持阻塞操作，但还是反对程序员使用该操作。但由于 SUN 公司下的 Berkeley Sockets 的套接字默认操作是阻塞的，WINDOWS 作为移植的 SOCKETS 也不可避免对这个操作支持。  
在 WINDOWS SOCKETS 实现中，对于不能立即完成的阻塞操作做如下处理：DLL初始化→循环操作。在循环中，它发送任何 WINDOWS 消息，并检查这个 WINDOWS SOCKETS 调用是否完成，在必要时，它可以放弃CPU让其它应用程序执行（当然使用超线程的CPU就不会有这个麻烦了^\_^）。我们可以调用 WSACancelBlockingCall() 函数取消此阻塞操作。  
在 WINDOWS SOCKETS 中，有一个默认的阻塞处理例程 BlockingHook() 简单地获取并发送 WINDOWS 消息。如果要对复杂程序进行处理，WINDOWS SOCKETS 中还有 WSASetBlockingHook() 提供用户安装自己的阻塞处理例程能力；与该函数相对应的则是 SWAUnhookBlockingHook()，它用于删除先前安装的任何阻塞处理例程，并重新安装默认的处理例程。请注意，设计自己的阻塞处理例程时，除了函数 WSACancelBlockingHook() 之外，它不能使用其它的 WINDOWS SOCKETS API 函数。在处理例程中调用 WSACancelBlockingHook()函数将取消处于阻塞的操作，它将结束阻塞循环。

**4、出错处理**  
WINDOWS SOCKETS 为了和以后多线程环境（WINDOWS/UNIX）兼容，它提供了两个出错处理函数来获取和设置当前线程的最近错误号。（WSAGetLastEror()和WSASetLastError()）

**5、启动与终止**  
使用函数 WSAStartup() 和 WSACleanup() 启动和终止套接字。

![Image 1][] **三、WINDOWS SOCKETS 网络程序设计核心**  
  
我们终于可以开始真正的 WINDOWS SOCKETS 网络程序设计了。不过我们还是先看一看每个 WINDOWS SOCKETS 网络程序都要涉及的内容。让我们一步步慢慢走。  
  
**1、启动与终止**  
在所有 WINDOWS SOCKETS 函数中，只有启动函数 WSAStartup() 和终止函数 WSACleanup() 是必须使用的。  
启动函数必须是第一个使用的函数，而且它允许指定 WINDOWS SOCKETS API 的版本，并获得 SOCKETS的特定的一些技术细节。本结构如下：

int PASCAL FAR WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

其中 wVersionRequested 保证 SOCKETS 可正常运行的 DLL 版本，如果不支持，则返回错误信息。  
我们看一下下面这段代码，看一下如何进行 WSAStartup() 的调用

WORD wVersionRequested;// 定义版本信息变量
        WSADATA wsaData;//定义数据信息变量
        int err;//定义错误号变量
        wVersionRequested = MAKEWORD(1,1);//给版本信息赋值
        err = WSAStartup(wVersionRequested, &wsaData);//给错误信息赋值
        if(err!=0)
        {
            return;//告诉用户找不到合适的版本
        }
        //确认 WINDOWS SOCKETS DLL 支持 1.1 版本
        //DLL 版本可以高于 1.1
        //系统返回的版本号始终是最低要求的 1.1，即应用程序与DLL 中可支持的最低版本号
        if(LOBYTE(wsaData.wVersion)!= 1|| HIBYTE(wsaData.wVersion)!=1)
        {
            WSACleanup();//告诉用户找不到合适的版本
            return;
        }
        //WINDOWS SOCKETS DLL 被进程接受，可以进入下一步操作

关闭函数使用时，任何打开并已连接的 SOCK\_STREAM 套接字被复位，但那些已由 closesocket() 函数关闭的但仍有未发送数据的套接字不受影响，未发送的数据仍将被发送。程序运行时可能会多次调用 WSAStartuo() 函数，但必须保证每次调用时的 wVersionRequested 的值是相同的。  
  
**2、异步请求服务**  
WINDOWS SOCKETS 除支持 Berkeley Sockets 中同步请求，还增加了了一类异步请求服务函数 WSAAsyncGerXByY()。该函数是阻塞请求函数的异步版本。应用程序调用它时，由 WINDOWS SOCKETS DLL 初始化这一操作并返回调用者，此函数返回一个异步句柄，用来标识这个操作。当结果存储在调用者提供的缓冲区，并且发送一个消息到应用程序相应窗口。常用结构如下：

HANDLE taskHnd;
        char hostname="rs6000";
        taskHnd = WSAAsyncBetHostByName(hWnd,wMsg,hostname,buf,buflen);

需要注意的是，由于 Windows 的内存对像可以设置为可移动和可丢弃，因此在操作内存对象是，必须保证 WIindows Sockets DLL 对象是可用的。

**3、异步数据传输**  
使用 send() 或 sendto() 函数来发送数据，使用 recv() 或recvfrom() 来接收数据。Windows Sockets 不鼓励用户使用阻塞方式传输数据，因为那样可能会阻塞整个 Windows 环境。下面我们看一个异步数据传输实例：  
假设套接字 s 在连接建立后，已经使用了函数 WSAAsyncSelect() 在其上注册了网络事件 FD\_READ 和 FD\_WRITE，并且 wMsg 值为 UM\_SOCK，那么我们可以在 Windows 消息循环中增加如下的分支语句：

case UM_SOCK:
          switch(lParam)
          {
          case FD_READ:
              len = recv(wParam,lpBuffer,length,0);
              break;
          case FD_WRITE:
              while(send(wParam,lpBuffer,len,0)!=SOCKET_ERROR)
              break;
          }
          break;

**4、出错处理**  
Windows 提供了一个函数来获取最近的错误码 WSAGetLastError()，推荐的编写方式如下：

len = send (s,lpBuffer,len,0);
        of((len==SOCKET_ERROR)&&(WSAGetLastError()==WSAWOULDBLOCK)){...}

点对点多线程断点续传的实现
 作者:赵明 下载配套源代码(网络传圣源代码)
 下载地址二 http://h2osky.126.com 在如今的网络应用中，文件的传送是重要的功能之一，也是共享的基础。一些重要的协议像HTTP，FTP等都支持文件的传送。尤其是FTP，它的全称就是“文件传送协议”，当初的工程师设计这一协议就是为了解决网络间的文件传送问题，而且以其稳定，高速，简单而一直保持着很大的生命力。作为一个程序员，使用这些现有的协议传送文件相当简单，不过，它们只适用于服务器模式中。这样，当我们想在点与点之间传送文件就不适用了或相当麻烦，有一种大刀小用的意味。笔者一直想寻求一种简单有效，且具备多线程断点续传的方法来实现点与点之间的文件传送问题，经过大量的翻阅资料与测试，终于实现了，现把它共享出来，与大家分享。
 我写了一个以此为基础的实用程序（网络传圣，包含源代码），可用了基于TCP/IP的电脑上，供大家学习。
 
 
 (本文源代码运行效果图) 
 实现方法（VC＋＋，基于TCP/IP协议）如下：
 仍釆用服务器与客户模式，需分别对其设计与编程。
 服务器端较简单，主要就是加入待传文件，监听客户，和传送文件。而那些断点续传的功能，以及文件的管理都放在客户端上。
 
 一、服务器端
 
 首先介绍服务器端：
 最开始我们要定义一个简单的协议，也就是定义一个服务器端与客户端听得懂的语言。而为了把问题简化，我就让服务器只要听懂两句话，一就是客户说“我要读文件信息”，二就是“我准备好了，可以传文件了”。
 由于要实现多线程，必须把功能独立出来，且包装成线程，首先建一个监听线程，主要负责接入客户，并启动另一个客户线程。我用VC++实现如下： DWORD WINAPI listenthread(LPVOID lpparam)
 {	
 
 //由主函数传来的套接字
 　　SOCKET pthis=(SOCKET)lpparam;
 //开始监听
 	int rc=listen(pthis,30);
 //如果错就显示信息
 if(rc<0){
 	 CString aaa;
 	 aaa="listen错误/n";
 AfxGetMainWnd()->SendMessageToDescendants(WM_AGE1,(LPARAM)aaa.GetBuffer(0),1);
 	 aaa.ReleaseBuffer();
 	 return 0;
 	}
 //进入循环，并接收到来的套接字
 	while(1){
 //新建一个套接字，用于客户端
 	SOCKET s1;
 	s1=accept(pthis,NULL,NULL);
 	
 　 //给主函数发有人联入消息
 CString aa;
 aa="一人联入！/n";
 AfxGetMainWnd()->SendMessageToDescendants(WM_AGE1,(LPARAM)aa.GetBuffer(0),1);
 	aa.ReleaseBuffer();
 	DWORD dwthread;
 //建立用户线程
 	::CreateThread(NULL,0,clientthread,(LPVOID)s1,0,&dwthread);	
 	}
 	return 0;
 }
 
 接着我们来看用户线程：
 先看文件消息类定义：
 
 struct fileinfo
 {
 	int fileno;//文件号
 	int type;//客户端想说什么（前面那两句话，用1,2表示）
 	long len;//文件长度
 	int seek;//文件开始位置，用于多线程
 
 	char name[100];//文件名
 };
 
 用户线程函数:
 DWORD WINAPI clientthread(LPVOID lpparam)
 {
 	//文件消息
 	fileinfo* fiinfo;
 	//接收缓存
 	char* m_buf;
 	m_buf=new char[100];
 	//监听函数传来的用户套接字
 	SOCKET pthis=(SOCKET)lpparam;
 	//读传来的信息
 	int aa=readn(pthis,m_buf,100);
 	//如果有错就返回
 	if(aa<0){
 		closesocket (pthis);
 		return -1;
 	}
 	//把传来的信息转为定义的文件信息
 	fiinfo=(fileinfo*)m_buf;
 	CString aaa;
 	//检验客户想说什么
 	switch(fiinfo->type)
 	{
 	//我要读文件信息
 	case 0:
 	//读文件
 	aa=sendn(pthis,(char*)zmfile,1080);
 	//有错
 	if(aa<0){	
 		closesocket (pthis);
 		return -1;
 	}
 	//发消息给主函数
 	aaa="收到LIST命令/n";
 	AfxGetMainWnd()->SendMessageToDescendants(WM_AGE1,(LPARAM)aaa.GetBuffer(0),1);
 	break;
 	//我准备好了，可以传文件了
 
 	case 2:
 	//发文件消息给主函数
 	aaa.Format("%s 文件被请求！%s/n",zmfile[fiinfo->fileno].name,nameph[fiinfo->fileno]);
 	AfxGetMainWnd()->SendMessageToDescendants(WM_AGE1,(LPARAM)aaa.GetBuffer(0),1);
 	//读文件，并传送
 	readfile(pthis,fiinfo->seek,fiinfo->len,fiinfo->fileno);
 	//听不懂你说什么
 
 	default:
 	aaa="接收协议错误！/n";
 	AfxGetMainWnd()->SendMessageToDescendants(WM_AGE1,(LPARAM)aaa.GetBuffer(0),1);
 	break;
 }
 
 	return 0;
 } 
 读文件函数
 void readfile(SOCKET so,int seek,int len,int fino)
 {
 	//文件名
 	CString myname;
 	myname.Format("%s",nameph[fino]);
 	CFile myFile;
 	//打开文件
 	myFile.Open(myname, CFile::modeRead | CFile::typeBinary|CFile::shareDenyNone); 
 	//传到指定位置　
 	myFile.Seek(seek,CFile::begin);
 	char m_buf[SIZE];
 	int len2;
 	int len1;
 	len1=len;
 	//开始接收，直到发完整个文件
 	while(len1>0){
 		len2=len>SIZE?SIZE:len;
 		myFile.Read(m_buf, len2);
 		int aa=sendn(so,m_buf,len2);
 	if(aa<0){	
 		closesocket (so);
 		break;
 	}
 	len1=len1-aa;
 	len=len-aa;
 	}
 	myFile.Close();
 }
 
 服务器端最要的功能各技术就是这些，下面介绍客户端。
 
 二、客户端
 
 客户端最重要，也最复杂，它负责线程的管理，进度的记录等工作。
 
 大概流程如下：
 先连接服务器，接着发送命令1（给我文件信息），其中包括文件长度，名字等，然后根据长度决定分几个线程下载，并初使化下载进程，接着发送命令2（可以给我传文件了），并记录文件进程。最后，收尾。
 这其中有一个十分重要的类，就是cdownload类，定义如下： 
 class cdownload 
 {
 public:
 	void createthread();//开线程
 	DWORD finish1();//完成线程
 	int sendlist();//发命令1
 	downinfo doinfo;//文件信息（与服务器定义一样）
 	int startask(int n);开始传文件n
 	long m_index;
 	BOOL good[BLACK];
 	int filerange[100];
 	CString fname;
 	CString fnametwo;
 	UINT threadfunc(long index);//下载进程
 
 	int sendrequest(int n);//发文件信息
 	cdownload(int thno1);
 	virtual ~cdownload();
 }; 
 下面先介绍sendrequest(int n)，在开始前，向服务器发获得文件消息命令，以便让客户端知道有哪些文件可传
 int cdownload::sendrequest(int n)
 {
 	//建套接字
 	sockaddr_in local;
 	SOCKET m_socket;
 
 	int rc=0;
 	//初使化服务器地址
 	local.sin_family=AF_INET;
 	local.sin_port=htons(1028);
 	local.sin_addr.S_un.S_addr=inet_addr(ip);
 	m_socket=socket(AF_INET,SOCK_STREAM,0);
 
 	
 	int ret;
 	//联接服务器
 	ret=connect(m_socket,(LPSOCKADDR)&local,sizeof(local));
 	//有错的话
 	if(ret<0){
 		AfxMessageBox("联接错误");
 	closesocket(m_socket);
 	return -1;
 	}
 	//初使化命令
 	fileinfo fileinfo1;
 	fileinfo1.len=n;
 	fileinfo1.seek=50;
 	fileinfo1.type=1;
 	//发送命令
 	int aa=sendn(m_socket,(char*)&fileinfo1,100);
 	if(aa<0){
 		closesocket(m_socket);
 		return -1;
 	}
 	//接收服务器传来的信息
 	 aa=readn(m_socket,(char*)&fileinfo1,100);
 	if(aa<0){
 		closesocket(m_socket);
 		return -1;
 	}
 	//关闭
 	shutdown(m_socket,2);
 	closesocket(m_socket);
 
 	return 1;
 } 
 有了文件消息后我们就可以下载文件了。在主函数中，用法如下：
 //下载第clno个文件，并为它建一个新cdownload类
 down[clno]=new cdownload(clno);
 //开始下载，并初使化
 type=down[clno]->startask(clno);
 //建立各线程
 createthread(clno); 
 下面介绍开始方法:
 //开始方法
 int cdownload::startask(int n)
 {
 	//读入文件长度
 	doinfo.filelen=zmfile[n].length;
 	//读入名字
 	fname=zmfile[n].name;
 	CString tmep;
 	//初使化文件名
 	tmep.Format("//temp//%s",fname);
 
 	//给主函数发消息
 	CString aaa;
 	aaa="正在读取 "+fname+" 信息，马上开始下载。。。/n";
 	AfxGetMainWnd()->SendMessageToDescendants(WM_AGE1,(LPARAM)aaa.GetBuffer(0),1);
 	aaa.ReleaseBuffer();
 	//如果文件长度小于0就返回
 	if(doinfo.filelen<=0) return -1;
 	//建一个以.down结尾的文件记录文件信息
 	CString m_temp;
 	m_temp=fname+".down";
 	
 	doinfo.name=m_temp;
 	FILE* fp=NULL;
 	CFile myfile;
 	//如果是第一次下载文件，初使化各记录文件
 
 	if((fp=fopen(m_temp,"r"))==NULL){
 	filerange[0]=0;
 	//文件分块
 	for(int i=0;i<BLACK;i++)
 	{
 		if(i>0)
 			filerange[i*2]=i*(doinfo.filelen/BLACK+1);
 		filerange[i*2+1]=doinfo.filelen/BLACK+1;
 	}
 	filerange[BLACK*2-1]=doinfo.filelen-filerange[BLACK*2-2];
 
 	myfile.Open(m_temp,CFile::modeCreate|CFile::modeWrite | CFile::typeBinary);
 
 	//写入文件长度
 	myfile.Write(&doinfo.filelen,sizeof(int));
 	myfile.Close();
 　
 	CString temp;
 	for(int ii=0;ii<BLACK;ii++){
 	//初使化各进程记录文件信息（以.downN结尾）
 
 	temp.Format(".down%d",ii);
 	m_temp=fname+temp;
 	myfile.Open(m_temp,CFile::modeCreate|CFile::modeWrite | CFile::typeBinary);
 	//写入各进程文件信息
 	myfile.Write(&filerange[ii*2],sizeof(int));
 	myfile.Write(&filerange[ii*2+1],sizeof(int));
 	myfile.Close();
 	}
 
 	((CMainFrame*)::AfxGetMainWnd())->m_work.m_ListCtrl->AddItemtwo(n,2,0,0,0,doinfo.threadno);
 	}
 	else{
 	//如果文件已存在，说明是续传，读上次信息
 	CString temp;
 　
 	m_temp=fname+".down0";
 	if((fp=fopen(m_temp,"r"))==NULL)
 		return 1;
 	else fclose(fp);
 
 	int bb;
 	bb=0;
 	//读各进程记录的信息
 	for(int ii=0;ii<BLACK;ii++)
 	{
 		temp.Format(".down%d",ii);
 		m_temp=fname+temp;
 　
 		myfile.Open(m_temp,CFile::modeRead | CFile::typeBinary);
 		myfile.Read(&filerange[ii*2],sizeof(int));
 		myfile.Read(&filerange[ii*2+1],sizeof(int));
 		myfile.Close();
 
 		bb = bb+filerange[ii*2+1];
 		CString temp;
 	}
 	if(bb==0) return 1;
 	doinfo.totle=doinfo.filelen-bb;
 　
 	((CMainFrame*)::AfxGetMainWnd())->m_work.m_ListCtrl->AddItemtwo(n,2,doinfo.totle,1,0,doinfo.threadno);
 
 	}
 
 　	//建立下载结束进程timethread，以管现各进程结束时间。
 	DWORD dwthread;
 	::CreateThread(NULL,0,timethread,(LPVOID)this,0,&dwthread);
 
 	return 0;
 } 
 下面介绍建立各进程函数，很简单：
 void CMainFrame::createthread(int threadno)
 {
 	DWORD dwthread;
 	//建立BLACK个进程
 	for(int i=0;i<BLACK;i++)
 	{
 		m_thread[threadno][i]=	::CreateThread(NULL,0,downthread,(LPVOID)down[threadno],0,&dwthread);
 	}
 } 
 downthread进程函数
 DWORD WINAPI downthread(LPVOID lpparam)
 {
 	cdownload* pthis=(cdownload*)lpparam;
 	//进程引索＋1
 	InterlockedIncrement(&pthis->m_index);
 	//执行下载进程
 	pthis->threadfunc(pthis->m_index-1);
 	return 1;
 }
 
 下面介绍下载进程函数,最最核心的东西了
 UINT cdownload::threadfunc(long index)
 {
 	//初使化联接
 	sockaddr_in local;
 	SOCKET m_socket;
 
 	int rc=0;
 　
 	local.sin_family=AF_INET;
 	local.sin_port=htons(1028);
 	local.sin_addr.S_un.S_addr=inet_addr(ip);
 	m_socket=socket(AF_INET,SOCK_STREAM,0);
 
 	int ret;
 	//读入缓存
 	char* m_buf=new char[SIZE];
 	int re,len2;
 	fileinfo fileinfo1;
 	//联接
 	ret=connect(m_socket,(LPSOCKADDR)&local,sizeof(local));
 	//读入各进程的下载信息
 	fileinfo1.len=filerange[index*2+1];
 	fileinfo1.seek=filerange[index*2];
 	fileinfo1.type=2;
 	fileinfo1.fileno=doinfo.threadno;
 　
 	re=fileinfo1.len;
 　
 	//打开文件　
 	CFile destFile;
 	FILE* fp=NULL;
 	//是第一次传的话
 	if((fp=fopen(fname,"r"))==NULL)
 		destFile.Open(fname, CFile::modeCreate|CFile::modeWrite | CFile::typeBinary|CFile::shareDenyNone);
 	else
 		//如果文件存在，是续传
 		destFile.Open(fname,CFile::modeWrite | CFile::typeBinary|CFile::shareDenyNone);
 	//文件指针移到指定位置
 	destFile.Seek(filerange[index*2],CFile::begin);
 	//发消息给服务器，可以传文件了
 	sendn(m_socket,(char*)&fileinfo1,100);
 
 	CFile myfile;
 	CString temp;
 	temp.Format(".down%d",index);
 	m_temp=fname+temp;
 
 　	//当各段长度还不为0时
 	while(re>0){
 		len2=re>SIZE?SIZE:re;
 　
 		//读各段内容
 		int len1=readn(m_socket,m_buf,len2);
 		//有错的话
 		if(len1<0){
 			closesocket(m_socket);
 			break;
 		}
 　
 	//写入文件
 	destFile.Write(m_buf, len1);	
 
 	//更改记录进度信息
 
 	filerange[index*2+1]-=len1;
 	filerange[index*2]+=len1;
 	//移动记录文件指针到头
 	myfile.Seek(0,CFile::begin);
 	//写入记录进度
 	myfile.Write(&filerange[index*2],sizeof(int));
 	myfile.Write(&filerange[index*2+1],sizeof(int));
 
 	//减去这次读的长度
 	re=re-len1;
 
 	//加文件长度
 	doinfo.totle=doinfo.totle+len1;
 	};
 	
 	//这块下载完成，收尾
 　
 	myfile.Close();
 	destFile.Close();
 	delete [] m_buf;
 	shutdown(m_socket,2);
 　
 　
 	if(re<=0) good[index]=TRUE;
 	return 1;
 } 
 到这客户端的主要模块和机制已基本介绍完。希望好好体会一下这种多线程断点续传的方法。 
 作者信息:
 姓名:赵明
 email: papaya_zm@sina.com 或 zmpapaya@hotmail.com
 主页: http://h2osky.126.com

[Link 1]: http://bingdianstudio.yeah.net/
[Link 2]: mailto:eagle_21c@sina.com
[Image 1]: