WinSock学习笔记（一）

作者：肖进

Socket（套接字）

◆先看定义：

typedef unsigned int u_int;
typedef u_int SOCKET;

◆Socket相当于进行网络通信两端的插座，只要对方的Socket和自己的Socket有通信联接，双方就可以发送和接收数据了。其定义类似于文件句柄的定义。

◆Socket有五种不同的类型：

1、流式套接字(stream socket)
定义：

#define SOCK_STREAM 1

流式套接字提供了双向、有序的、无重复的以及无记录边界的数据流服务，适合处理大量数据。它是面向联结的，必须建立数据传输链路，同时还必须对传输的数据进行验证，确保数据的准确性。因此，系统开销较大。

2、 数据报套接字(datagram socket)

定义：

#define SOCK_DGRAM 2

数据报套接字也支持双向的数据流，但不保证传输数据的准确性，但保留了记录边界。由于数据报套接字是无联接的，例如广播时的联接，所以并不保证接收端是否正在侦听。数据报套接字传输效率比较高。

3、原始套接字(raw-protocol interface)

定义：

#define SOCK_RAW 3

原始套接字保存了数据包中的完整IP头，前面两种套接字只能收到用户数据。因此可以通过原始套接字对数据进行分析。
其它两种套接字不常用，这里就不介绍了。

◆Socket开发所必须需要的文件(以WinSock V2.0为例)：

头文件：Winsock2.h

库文件：WS2_32.LIB

动态库：W32_32.DLL

一些重要的定义

1、数据类型的基本定义：这个大家一看就懂。

typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;

2、 网络地址的数据结构，有一个老的和一个新的的，请大家留意，如果想知道为什么，
请发邮件给Bill Gate。其实就是计算机的IP地址，不过一般不用用点分开的IP地
址，当然也提供一些转换函数。

◆ 旧的网络地址结构的定义，为一个4字节的联合：

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 & ip code */
//下面几行省略,反正没什么用处。
};

其实完全不用这么麻烦，请看下面:

◆ 新的网络地址结构的定义：
非常简单，就是一个无符号长整数 unsigned long。举个例子：IP地址为127.0.0.1的网络地址是什么呢？请看定义：

#define INADDR_LOOPBACK 0x7f000001

3、 套接字地址结构

(1)、sockaddr结构：

struct sockaddr {
u_short sa_family; /* address family */
char sa_data[14]; /* up to 14 bytes of direct address */
};

sa_family为网络地址类型，一般为AF_INET，表示该socket在Internet域中进行通信，该地址结构随选择的协议的不同而变化，因此一般情况下另一个与该地址结构大小相同的sockaddr_in结构更为常用，sockaddr_in结构用来标识TCP/IP协议下的地址。换句话说，这个结构是通用socket地址结构，而下面的sockaddr_in是专门针对Internet域的socket地址结构。

(2)、sockaddr_in结构

struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};

sin _family为网络地址类型，必须设定为AF_INET。sin_port为服务端口，注意不要使用已固定的服务端口，如HTTP的端口80等。如果端口设置为0，则系统会自动分配一个唯一端口。sin_addr为一个unsigned long的IP地址。sin_zero为填充字段，纯粹用来保证结构的大小。

◆ 将常用的用点分开的IP地址转换为unsigned long类型的IP地址的函数：

unsigned long inet_addr(const char FAR * cp )

用法：

unsigned long addr=inet_addr("192.1.8.84")

◆ 如果将sin_addr设置为INADDR_ANY，则表示所有的IP地址，也即所有的计算机。

#define INADDR_ANY (u_long)0x00000000

4、 主机地址：

先看定义：

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地址，如果该主机有多个网卡，就包括地址的列表。

另外还有几个类似的结构，这里就不一一介绍了。

5、 常见TCP/IP协议的定义：

#define IPPROTO_IP 0
#define IPPROTO_ICMP 1
#define IPPROTO_IGMP 2
#define IPPROTO_TCP 6
#define IPPROTO_UDP 17
#define IPPROTO_RAW 255

具体是什么协议，大家一看就知道了。

套接字的属性

为了灵活使用套接字，我们可以对它的属性进行设定。

1、 属性内容：

//允许调试输出
#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 */

2、 读取socket属性：

int getsockopt(SOCKET s, int level, int optname, char FAR * optval, int FAR * optlen)

s为欲读取属性的套接字。level为套接字选项的级别，大多数是特定协议和套接字专有的。如IP协议应为 IPPROTO_IP。

optname为读取选项的名称
optval为存放选项值的缓冲区指针。
optlen为缓冲区的长度

用法：

int ttl=0; //读取TTL值
int rc = getsockopt( s, IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl));
//来自MS platform SDK 2003

3、 设置socket属性：

int setsockopt(SOCKET s,int level, int optname,const char FAR * optval, int optlen)

s为欲设置属性的套接字。
level为套接字选项的级别，用法同上。
optname为设置选项的名称
optval为存放选项值的缓冲区指针。
optlen为缓冲区的长度

用法：

int ttl=32; //设置TTL值
int rc = setsockopt( s, IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl));

套接字的使用步骤

1、启动Winsock：对Winsock DLL进行初始化，协商Winsock的版本支持并分配必要的
资源。（服务器端和客户端）

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;

如果加载成功后数据为：

wVersion＝2表示加载版本为2.0。
wHighVersion＝514表示当前系统支持socket最高版本为2.2。
szDescription="WinSock 2.0"
szSystemStatus="Running"表示正在运行。
iMaxSockets＝0表示同时打开的socket最大数，为0表示没有限制。
iMaxUdpDg＝0表示同时打开的数据报最大数，为0表示没有限制。
lpVendorInfo没有使用，为厂商指定信息预留。

该函数使用方法：

WORD wVersion=MAKEWORD(2,0);
WSADATA wsData;
int nResult= WSAStartup(wVersion,&wsData);
if(nResult !=0)
{
//错误处理
}

2、创建套接字：（服务器端和客户端）

SOCKET socket( int af, int type, int protocol );
af为网络地址类型，一般为AF_INET，表示在Internet域中使用。
type为套接字类型，前面已经介绍了。
protocol为指定网络协议，一般为IPPROTO_IP。

用法：

SOCKET sock=socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
if(sock==INVALID_SOCKET)
{
//错误处理
}

3、套接字的绑定：将本地地址绑定到所创建的套接字上。（服务器端和客户端）

int bind( SOCKET s, const struct sockaddr FAR * name, int namelen )
s为已经创建的套接字。
name为socket地址结构，为sockaddr结构，如前面讨论的，我们一般使用sockaddr_in
结构，在使用再强制转换为sockaddr结构。
namelen为地址结构的长度。

用法：

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*)&addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//错误处理
}

4、 套接字的监听：（服务器端）

int listen(SOCKET s, int backlog )

s为一个已绑定但未联接的套接字。
backlog为指定正在等待联接的最大队列长度，这个参数非常重要，因为服务器一般可
以提供多个连接。
用法：

int nResult=listen(s,5) //最多5个连接
if(nResult==SOCKET_ERROR)
{
//错误处理
}

5、套接字等待连接:：（服务器端）

SOCKET accept( SOCKET s, struct sockaddr FAR * addr, int FAR * addrlen )

s为处于监听模式的套接字。
sockaddr为接收成功后返回客户端的网络地址。
addrlen为网络地址的长度。

用法：

sockaddr_in addr;
SOCKET s_d=accept(s,(sockaddr*)&addr,sizeof(sockaddr));
if(s==INVALID_SOCKET)
{
//错误处理
}

6、套接字的连结：将两个套接字连结起来准备通信。（客户端）

int connect(SOCKET s, const struct sockaddr FAR * name, int namelen )

s为欲连结的已创建的套接字。
name为欲连结的socket地址。
namelen为socket地址的结构的长度。

用法：

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*)&addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//错误处理
}

7、套接字发送数据：（服务器端和客户端）

int send(SOCKET s, const char FAR * buf, int len, int flags )

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表示不要将包路由出去。

用法：

char buf[]="xiaojin";
int nResult=send(s,buf,strlen(buf));
if(nResult==SOCKET_ERROR)
{
//错误处理
}

8、 套接字的数据接收：（客户端）

int recv( SOCKET s, char FAR * buf, int len, int flags )

s为准备接收数据的套接字。
buf为准备接收数据的缓冲区。
len为准备接收数据缓冲区的大小。
flags为数据接收标记。
返回值为接收的数据的字符数。

用法：

char mess[1000];
int nResult =recv(s,mess,1000,0);
if(nResult==SOCKET_ERROR)
{
//错误处理
}

9、中断套接字连接：通知服务器端或客户端停止接收和发送数据。（服务器端和客户端）

int shutdown(SOCKET s, int how)

s为欲中断连接的套接字。
How为描述禁止哪些操作，取值为：SD_RECEIVE、SD_SEND、SD_BOTH。

#define SD_RECEIVE 0x00
#define SD_SEND 0x01
#define SD_BOTH 0x02

用法：

int nResult= shutdown(s,SD_BOTH);
if(nResult==SOCKET_ERROR)
{
//错误处理
}

10、 关闭套接字：释放所占有的资源。（服务器端和客户端）

int closesocket( SOCKET s )

s为欲关闭的套接字。

用法：

int nResult=closesocket(s);
if(nResult==SOCKET_ERROR)
{
//错误处理
}

 作者信息
肖进
单位：南京中萃食品有限公司 资讯部
邮箱：xiaoj@njb.swirebev.com
电话：025-58642091

WinSock学习笔记（二）

作者：肖进

与socket有关的一些函数介绍

1、读取当前错误值：每次发生错误时，如果要对具体问题进行处理，那么就应该调用这个函数取得错误代码。

      int  WSAGetLastError(void );
#define h_errno   WSAGetLastError()

错误值请自己阅读Winsock2.h。

2、将主机的unsigned long值转换为网络字节顺序(32位)：为什么要这样做呢？因为不同的计算机使用不同的字节顺序存储数据。因此任何从Winsock函数对IP地址和端口号的引用和传给Winsock函数的IP地址和端口号均时按照网络顺序组织的。

      u_long  htonl(u_long hostlong);
举例：htonl(0)=0
htonl(80)= 1342177280

3、将unsigned long数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。

      u_long  ntohl(u_long netlong);
举例：ntohl(0)=0
ntohl(1342177280)= 80

4、将主机的unsigned short值转换为网络字节顺序(16位)：原因同2：

      u_short  htons(u_short hostshort);
举例：htonl(0)=0
htonl(80)= 20480

5、将unsigned short数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。

      u_short  ntohs(u_short netshort);
举例：ntohs(0)=0
ntohsl(20480)= 80

6、将用点分割的IP地址转换位一个in_addr结构的地址，这个结构的定义见笔记(一)，实际上就是一个unsigned long值。计算机内部处理IP地址可是不认识如192.1.8.84之类的数据。

      unsigned long  inet_addr( const char FAR * cp );
举例：inet_addr("192.1.8.84")=1409810880
inet_addr("127.0.0.1")= 16777343

如果发生错误，函数返回INADDR_NONE值。

7、将网络地址转换位用点分割的IP地址，是上面函数的逆函数。

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

这样addr的值就变为127.0.0.1。
注意意不要修改返回值或者进行释放动作。如果函数失败就会返回NULL值。

8、获取套接字的本地地址结构：

      int  getsockname(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s为套接字
name为函数调用后获得的地址值
namelen为缓冲区的大小。

9、获取与套接字相连的端地址结构：

      int  getpeername(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s为套接字
name为函数调用后获得的端地址值
namelen为缓冲区的大小。

10、获取计算机名：

      int  gethostname( char FAR * name, int namelen );
name是存放计算机名的缓冲区
namelen是缓冲区的大小
用法：
char szName[255];
memset(szName,0,255);
if(gethostname(szName,255)==SOCKET_ERROR)
{
//错误处理
}
返回值为：szNmae="xiaojin"

11、根据计算机名获取主机地址：

      struct hostent FAR *  gethostbyname( const char FAR * name );
name为计算机名。
用法：
hostent * host;
char* ip;
host= gethostbyname("xiaojin");
if(host->h_addr_list[0])
{
struct in_addr addr;
memmove(&addr, host->h_addr_list[0]，4);
//获得标准IP地址
ip=inet_ ntoa (addr);
}
返回值为：hostent->h_name="xiaojin"
hostent->h_addrtype=2    //AF_INET
hostent->length=4
ip="127.0.0.1"

Winsock 的I/O操作：

1、 两种I/O模式

  • 阻塞模式：执行I/O操作完成前会一直进行等待，不会将控制权交给程序。套接字 默认为阻塞模式。可以通过多线程技术进行处理。
  • 非阻塞模式：执行I/O操作时，Winsock函数会返回并交出控制权。这种模式使用 起来比较复杂，因为函数在没有运行完成就进行返回，会不断地返回 WSAEWOULDBLOCK错误。但功能强大。

为了解决这个问题，提出了进行I/O操作的一些I/O模型,下面介绍最常见的三种：

2、select模型：

　　通过调用select函数可以确定一个或多个套接字的状态，判断套接字上是否有数据，或
者能否向一个套接字写入数据。

      int  select( int nfds, fd_set FAR * readfds, fd_set FAR * writefds,
fd_set FAR *exceptfds, const struct timeval FAR * timeout );

◆先来看看涉及到的结构的定义：
a、 d_set结构：

#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;

fd_count为已设定socket的数量
fd_array为socket列表，FD_SETSIZE为最大socket数量，建议不小于64。这是微软建
议的。

B、timeval结构：

struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};

tv_sec为时间的秒值。
tv_usec为时间的毫秒值。
这个结构主要是设置select()函数的等待值，如果将该结构设置为(0,0)，则select()函数
会立即返回。

◆再来看看select函数各参数的作用：

  1. nfds：没有任何用处，主要用来进行系统兼容用，一般设置为0。
  2. readfds：等待可读性检查的套接字组。
  3. writefds；等待可写性检查的套接字组。
  4. exceptfds：等待错误检查的套接字组。
  5. timeout：超时时间。
  6. 函数失败的返回值：调用失败返回SOCKET_ERROR,超时返回0。

readfds、writefds、exceptfds三个变量至少有一个不为空，同时这个不为空的套接字组
种至少有一个socket，道理很简单，否则要select干什么呢。 举例：测试一个套接字是否可读：

fd_set fdread;
//FD_ZERO定义
// #define FD_ZERO(set) (((fd_set FAR *)(set))->fd_count=0)
FD_ZERO(&fdread);
FD_SET(s,&fdread)； //加入套接字，详细定义请看winsock2.h
if(select(0,%fdread,NULL,NULL,NULL)>0
{
//成功
if(FD_ISSET(s,&fread) //是否存在fread中，详细定义请看winsock2.h
{
//是可读的
}
}

◆I/O操作函数：主要用于获取与套接字相关的操作参数。

 int  ioctlsocket(SOCKET s, long cmd, u_long FAR * argp );

s为I/O操作的套接字。
cmd为对套接字的操作命令。
argp为命令所带参数的指针。

常见的命令：

//确定套接字自动读入的数据量
#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? */

3、WSAAsynSelect模型：
WSAAsynSelect模型也是一个常用的异步I/O模型。应用程序可以在一个套接字上接收以
WINDOWS消息为基础的网络事件通知。该模型的实现方法是通过调用WSAAsynSelect函
数 自动将套接字设置为非阻塞模式，并向WINDOWS注册一个或多个网络时间，并提供一
个通知时使用的窗口句柄。当注册的事件发生时，对应的窗口将收到一个基于消息的通知。

      int  WSAAsyncSelect( SOCKET s, HWND hWnd, u_int wMsg, long lEvent);

s为需要事件通知的套接字
hWnd为接收消息的窗口句柄
wMsg为要接收的消息
lEvent为掩码，指定应用程序感兴趣的网络事件组合，主要如下：

#define FD_READ_BIT 0
#define FD_READ (1 << FD_READ_BIT)
#define FD_WRITE_BIT 1
#define FD_WRITE (1 << FD_WRITE_BIT)
#define FD_OOB_BIT 2
#define FD_OOB (1 << FD_OOB_BIT)
#define FD_ACCEPT_BIT 3
#define FD_ACCEPT (1 << FD_ACCEPT_BIT)
#define FD_CONNECT_BIT 4
#define FD_CONNECT (1 << FD_CONNECT_BIT)
#define FD_CLOSE_BIT 5
#define FD_CLOSE (1 << FD_CLOSE_BIT)

用法：要接收读写通知：

int nResult= WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE)；
if(nResult==SOCKET_ERROR)
{
//错误处理
}

取消通知：

      int nResult= WSAAsyncSelect(s,hWnd,0，0)；

当应用程序窗口hWnd收到消息时，wMsg.wParam参数标识了套接字，lParam的低字标明
了网络事件，高字则包含错误代码。

4、WSAEventSelect模型
WSAEventSelect模型类似WSAAsynSelect模型，但最主要的区别是网络事件发生时会被发
送到一个事件对象句柄，而不是发送到一个窗口。

使用步骤如下：
a、 创建事件对象来接收网络事件：

#define WSAEVENT HANDLE
#define LPWSAEVENT LPHANDLE
WSAEVENT WSACreateEvent( void );

该函数的返回值为一个事件对象句柄，它具有两种工作状态：已传信(signaled)和未传信
(nonsignaled)以及两种工作模式：人工重设(manual reset)和自动重设(auto reset)。默认未
未传信的工作状态和人工重设模式。

b、将事件对象与套接字关联，同时注册事件，使事件对象的工作状态从未传信转变未
已传信。

      int  WSAEventSelect( SOCKET s,WSAEVENT hEventObject,long lNetworkEvents );

s为套接字
hEventObject为刚才创建的事件对象句柄
lNetworkEvents为掩码，定义如上面所述

c、I/O处理后，设置事件对象为未传信

BOOL WSAResetEvent( WSAEVENT hEvent );

Hevent为事件对象

成功返回TRUE，失败返回FALSE。

d、等待网络事件来触发事件句柄的工作状态：

DWORD WSAWaitForMultipleEvents( DWORD cEvents,
const WSAEVENT FAR * lphEvents, BOOL fWaitAll,
DWORD dwTimeout, BOOL fAlertable );

lpEvent为事件句柄数组的指针
cEvent为为事件句柄的数目，其最大值为WSA_MAXIMUM_WAIT_EVENTS 
fWaitAll指定等待类型：TRUE：当lphEvent数组重所有事件对象同时有信号时返回；
FALSE：任一事件有信号就返回。
dwTimeout为等待超时（毫秒）
fAlertable为指定函数返回时是否执行完成例程

对事件数组中的事件进行引用时，应该用WSAWaitForMultipleEvents的返回值，减去
预声明值WSA_WAIT_EVENT_0，得到具体的引用值。例如：

nIndex=WSAWaitForMultipleEvents(…);
MyEvent=EventArray[Index- WSA_WAIT_EVENT_0];

e、判断网络事件类型：

int WSAEnumNetworkEvents( SOCKET s,
WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents );

s为套接字
hEventObject为需要重设的事件对象
lpNetworkEvents为记录网络事件和错误代码，其结构定义如下：

typedef struct _WSANETWORKEVENTS {
long lNetworkEvents;
int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;

f、关闭事件对象句柄：

BOOL WSACloseEvent(WSAEVENT hEvent);

调用成功返回TRUE，否则返回FALSE。
　
作者简介
肖进
南京中萃食品有限公司 资讯部
电子邮件：xiaoj@njb.swirebev.com
电话：025-58642091

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

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

一、TCP/IP 体系结构与特点

1、TCP/IP体系结构

TCP/IP协议实际上就是在物理网上的一组完整的网络协议。其中TCP是提供传输层服务，而IP则是提供网络层服务。TCP/IP包括以下协议：（结构如图1.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协议核心与应用程序关系图。

(图1.2)

二、专用术语
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 网络编程(二) —— 套接字编程原理
作者: 冰点工作室 小鹰

一、客户机/服务器模式
在TCP/IP网络中两个进程间的相互作用的主机模式是客户机/服务器模式(Client/Server model)。该模式的建立基于以下两点：1、非对等作用；2、通信完全是异步的。客户机/服务器模式在操作过程中采取的是主动请示方式：

首先服务器方要先启动，并根据请示提供相应服务：（过程如下）
1、打开一通信通道并告知本地主机，它愿意在某一个公认地址上接收客户请求。
2、等待客户请求到达该端口。
3、接收到重复服务请求，处理该请求并发送应答信号。
4、返回第二步，等待另一客户请求
5、关闭服务器。
客户方：
1、打开一通信通道，并连接到服务器所在主机的特定端口。
2、向服务器发送服务请求报文，等待并接收应答；继续提出请求……
3、请求结束后关闭通信通道并终止。

二、基本套接字
为了更好说明套接字编程原理，给出几个基本的套接字，在以后的篇幅中会给出更详细的使用说明。
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);

三、典型过程图
2.1 面向连接的套接字的系统调用时序图

2.2 无连接协议的套接字调用时序图

2.3 面向连接的应用程序流程图

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

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

二、主要扩充说明

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() 启动和终止套接字。

三、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

winsock的两篇文章相关推荐

  1. 关于微服务的两篇文章以及Eventuate

    微服务相关的两篇文章,很多之前一知半解的概念与关系,看过之后,茅塞顿开! 微服务架构之事件驱动架构 http://m.blog.csdn.net/article/details?id=52537886 ...

  2. C++/JAVA 计算两篇文章的相似度

    C++/JAVA 计算两篇文章的相似度 这位少侠,要不要进店瞧瞧? 实验介绍及思路 问题描述: 编写程序,计算任意两篇文章的相似度. 基本思路: 利用余弦相似度来计算其相似度. 完整代码 C++ 代码 ...

  3. python余弦定理_使用余弦定理计算两篇文章的相似性

    使用余弦定理计算两篇文章的相似性:(方法论,细致易懂版) http://blog.csdn.net/dearwind153/article/details/52316151 python 实现(代码) ...

  4. 【读书笔记】NeurIPS2018的两篇文章：The Tradeoffs of Large Scale Learning和Neural Ordinary Differential Equations

    今天看了 NeurIPS 2018 上的两篇文章,一篇是获得 best paper 的 Neural Ordinary Differential Equations (陈天奇的文章),一篇是获经典论文 ...

  5. 【python 走进NLP】simhash 算法计算两篇文章相似度

    互联网网页存在大量的重复内容网页,无论对于搜索引擎的网页去重和过滤.新闻小说等内容网站的内容反盗版和追踪,还是社交媒体等文本去重和聚类,都需要对网页或者文本进行去重和过滤.最简单的文本相似性计算方法可 ...

  6. [将小白进行到底] 如何比较两篇文章的相似度

    其实这个题目已经有很多人写过了,数学之美里就有,最近阮一峰的博客里也写了,本文基本上遵循的就是他的思路,只是让其看起来再小白一点点.其实说白了就是用自己的话,再把同样一件事描述一下,顺便扩扩句,把其中 ...

  7. 比较两篇文章的相似性方法

       对于这个题目,开始毫无头绪,后来经过查阅资料现在讲方法总结如下:   1.利用余弦定理    我们知道向量a,b之间的夹角可用余弦定理求得:              如果夹角的余弦值越小,那么 ...

  8. 目前需要开发出一个功能，对比查找并标注出两篇文章中类似的段落或者词句，有什么开源项目有这个功能吗？ 其实有点像论文查重的功能，有论文查重的比较通用的开源项目推荐吗？...

    是的,你可以使用论文查重的工具来对比查找并标注两篇文章之间的相似段落或词句. 你可以尝试使用这些开源项目: MOSS (Measure Of Software Similarity):这是一个用于检测 ...

  9. 学习两篇文章后才知道 高价值分享之写作这件事值得坚持做

    01 写在前面 进入私密圈子社群.勾搭大V 青眼有加 .先别人获取第一手价值信息 .不知道你们想过没,这些事情我不止想了一次. 但是作为一个普通人,身上没有那些牛叉的 Title 加成,几乎很难实现. ...

最新文章

  1. php值传递和java_Java的值传递和引用传递
  2. PermSize 设置过小对性能的影响（OutOfMemoryError:PermGen spac）
  3. 90.386（32位）的保护模式 （286是过渡24位） 91.什么是实模式
  4. IT软件开发 书籍汇总
  5. Filter_细节_过滤器拦截路径配置
  6. 听说，霸都.NET技术社区准备搞线下聚会了？
  7. leetcode面试题 08.12. 八皇后（回溯）
  8. 吴恩达神经网络和深度学习-学习笔记-12-RMSprop算法
  9. iOS UIImage的剪裁、合并实现
  10. 下载:HD AUDIO For XP SP3修正补丁
  11. 案例分享：Qt的PPT播放器
  12. 【转帖】八类网线与六类网线有什么区别呢？
  13. 技术经理、架构师、技术总监、VP、CTO，这些岗位都是如何挣出来
  14. 计算机专业电脑需要显卡吗,组装电脑要不要配独立显卡?
  15. Python 创建商店营业额模拟数据并对其分析
  16. 谷歌服务框架(google services framework)是什么?
  17. 13.华为秋招一二面
  18. 电子制作——锂电池大功率充电器
  19. Python实现练打字小程序
  20. Kinectfusion开源实现_配置Kinfu环境_Cmake编译PCL点云库_Kinect3D重建

热门文章

  1. html5之footer标签
  2. tomcat隐藏版本号
  3. 智能合约_AElf智能合约开发-第一个AElf智能合约
  4. 如何在抖音中一键复制微信号打开微信？
  5. Android键盘的显示与隐藏
  6. Ubuntu 使用Compiz配置炫酷3D桌面
  7. CAD查看建筑图纸有什么技巧？怎么快速查看建筑图纸？
  8. xadmin中写ajax,关于xadmin后台下拉框修改为ajax模糊搜索问题
  9. 如何选择香港虚拟主机
  10. 华为html5不支持,华为携手云适配 共拓HTML5蓝海