Windows socket-编程入门

原文看完整内容

         首先,Windows套接字在两种模式下执行I / O操作：锁定和非锁定。
         在锁定模式下，在I / O操作完成前，执行操作的Wi nsock函数（比如send和recv）会一直等候下去，不会立即返回程序（将控制权交还给程序）。而在非锁定模式下， Wi nsock函数无论如何都会立即返回。

1 锁定模式

 

       耗费或长或短的时间“等待”。

      大多数Wi nsock应用都是遵照一种“生产者－消费者”模型来编制的。在这种模型中，应用程序需要读取（或写入）指定数量的字节，然后以它为基础执行一些计算。将应用程序划分为一个读线程，以及一个计算线程。两个线程都共享同一个数据缓冲区。对这个缓冲区的访问需要受到一定的限制，这是用一个同步对象来实现的，比如一个事件或者Mutex。“读线程”的职责是从网络连续地读入数据，并将其置入共享缓冲区内。读线程将计算线程开始工作至少需要的数据量拿到手后，便会触发一个事件，通知计算线程：你老兄可以开始干活了！随后，计算线程从缓冲区取走（删除）一个数据块，然后进行要求的计算。
        缺点在于：应用程序很难同时通过多个建好连接的套接字通信, 想同时处理大量套接字时，恐怕难以下手。

2 非锁定模式

            将一个套接字置为非锁定模式之后， Winsock API调用会立即返回。大多数情况下，这些调用都会“失败”，并返回一个WSAEWOULDBLOCK错误。什么意思呢？它意味着请求的操作在调用期间没有时间完成。举个例子来说，假如在系统的输入缓冲区中，尚不存在“待决”的数据，那么recv（接收数据）调用就会返回WSAEWOULDBLOCK错误。通常，我们需要重复调用同一个函数，直至获得一个成功返回代码。
            由于非锁定调用会频繁返回WSAEWOULDBLOCK错误，所以在任何时候，都应仔细检查所有返回代码，并作好“失败”的准备。许多程序员易犯的一个错误便是连续不停地调用一个函数，直到它返回成功的消息为止。例如，假定在一个紧凑的循环中不断地调用recv，以读入2 0 0个字节的数据，那么与使用前述的MSG_PEEK标志来“轮询”一个锁定套接字相比，前一种做法根本没有任何优势可言。为此， Wi nsock的套接字I / O模型可帮助应用程序判断一个套接字何时可供读写。

         锁定和非锁定套接字模式都存在着优点和缺点。其中，从概念的角度说，锁定套接字更易使用。但在应付建立连接的多个套接字时，或在数据的收发量不均，时间不定时，却显得极难管理。而另一方面，假如需要编写更多的代码，以便在每个Wi nsock调用中，对收到一个WSAEWOULDBLOCK错误的可能性加以应付，那么非锁定套接字便显得有些难于操作。在这些情况下，可考虑使用“套接字I / O模型”，它有助于应用程序通过一种异步方式，同时对一个或多个套接字上进行的通信加以管理。

3 套接字I/O模型

         共有五种类型的套接字I / O模型： select（选择）、WSAAsyncSelect（异步选择）、WSAEventSelect（事件选择）、overlapped（重叠）以及completion port（完成端口）。

WSAEventSelect

       1) 首先创建一个事件对象。创建方法是调用

WSAEVENT  WSACreateEvent(void);
      2) 事件对象与某个套接字关联在一起，同时注册自己感兴趣的网络事件类型，方法是调用 

            int WSAEventSelect ( 
              SOCKET s,                
              WSAEVENT hEventObject,   
              long lNetworkEvents     // “位掩码”，用于指定应用程序感兴趣的各种网络事件类型的一个组合 
               ); 
          BOOL WSAResetEvent( 
             WSAEVENT hEvent  
            ); 

           BOOL WSACloseEvent( 
             WSAEVENT hEvent   
            ); 

      3) 等待网络事件触发事件对象句柄的工作状态。WSAWaitForMultipleEvents函数的设计宗旨便是用来等待一个或多个事件对象句柄，并在事先指定的一个或所有句柄进入“已激发”状态后，或在超过了一个规定的时间后，立即返回。

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

要注意的是， WSAWaitForMultipleEvents只能支持由WSA_MAXIMUM_WAIT_EVENTS对象规定的一个最大值，在此定义成6 4个。因此，针对发出WSAWaitForMultipleEvents调用的每个线程，该I / O模型一次最多都只能支持6 4个套接字。假如想让这个模型同时管理不止6 4个套接字，必须创建额外的工作者线程，以便等待更多的事件对象。

若WSAWaitForMultipleEvents收到一个事件对象的网络事件通知，便会返回一个值，指出造成函数返回的事件对象。这样一来，我们的应用程序便可引用事件数组中已传信的事件，并检索与那个事件对应的套接字，判断到底是在哪个套接字上，发生了什么网络事件类型。对事件数组中的事件进行引用时，应该用WSAWaitForMultipleEvents的返回值，减去预定义值WSA_WAIT_EVENT_0，得到具体的引用值（即索引位置）知道了造成网络事件的套接字后，接下来可调用WSAEnumNetworkEvents函数，调查发生了什么类型的网络事件。该函数定义如下：
s参数对应于造成了网络事件的套接字。hEventObject参数则是可选的；它指定了一个事件句柄，对应于打算重设的那个事件对象。由于我们的事件对象处在一个“已传信”状态，所以可将它传入，令其自动成为“未传信”状态。如果不想用hEventObject参数来重设事件，那么可使用WSAResetEvent 函数， 该函数早先已经讨论过了。最后一个参数是lpNetworkEvents，代表一个指针，指向WSANETWORKEVENTS结构，用于接收套接字上发生的网络事件类型以及可能出现的任何错误代码。下面是WSANETWORKEVENTS结构的定：
typedef struct _WSANETWORKEVENTS {
   long lNetworkEvents;
   int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
lNetworkEvents参数指定了一个值，对应于套接字上发生的所有网络事件类型。
注意一个事件进入传信状态时，可能会同时发生多个网络事件类型。例如，一个繁忙的服务器应用可能同时收到FD_READ和FD_WRITE通知。iErrorCode参数指定的是一个错误代码数组，同lNetworkEvents中的事件关联在一起。针对每个网络事件类型，都存在着一个特殊的事件索引，名字与事件类型的名字类似，只是要在事件名字后面添加一个“ _BIT”后缀字串即可。例如，对FD_READ事件类型来说，iErrorCode数组的索引标识符便是FD_READ_BIT。
完成了对WSANETWORKEVENTS结构中的事件的处理之后，我们的应用程序应在所有可用的套接字上，继续等待更多的网络事件。在程序中，我们阐释了如何使用WSAEventSelect这种I / O模型，来开发一个服务器应用，同时对事件对象进行管理。这个程序主要着眼于开发一个基本的服务器应用要涉及到的步骤，令其同时负责一个或多个套接字的管理。 

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

 

使用原始套接字发送自定义IP包

这里介绍Windows Sockets的一些关于原始套接字(Raw Socket)的编程。同Winsock1相比，最明显的就是支持了Raw Socket套接字类型，通过原始套接字，我们可以更加自如地控制Windows下的多种协议，而且能够对网络底层的传输机制进行控制。
1、创建一个原始套接字，并设置IP头选项。
SOCKET sock;
sock = socket(AF_INET,SOCK_RAW,IPPROTO_IP);
或者：
s = WSASoccket(AF_INET,SOCK_RAW,IPPROTO_IP,NULL,0,WSA_FLAG_OVERLAPPED);
这里，我们设置了SOCK_RAW标志，表示我们声明的是一个原始套接字类型。创建原始套接字后，IP头就会包含在接收的数据中，如果我们设定 IP_HDRINCL 选项，那么，就需要自己来构造IP头。注意，如果设置IP_HDRINCL 选项，那么必须具有 administrator权限，要不就必须修改注册表：
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Afd\Parameter\
修改键：DisableRawSecurity（类型为DWORD），把值修改为 1。如果没有，就添加。
BOOL blnFlag=TRUE;
setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&blnFlag, sizeof(blnFlag);
对于原始套接字在接收数据报的时候，要注意这么几点：
1、如果接收的数据报中协议类型和定义的原始套接字匹配，那么，接收的所有数据就拷贝到套接字中。
2、如果绑定了本地地址，那么只有接收数据IP头中对应的远端地址匹配，接收的数据就拷贝到套接字中。
3、如果定义的是外部地址，比如使用connect()，那么，只有接收数据IP头中对应的源地址匹配，接收的数据就拷贝到套接字中。
2、构造IP头和TCP头
这里，提供IP头和TCP头的结构：

// Standard TCP flags 
#define URG 0x20 
#define ACK 0x10 
#define PSH 0x08 
#define RST 0x04 
#define SYN 0x02 
#define FIN 0x01 
typedef struct _iphdr //定义IP首部 
{ 
unsigned char h_lenver; //4位首部长度+4位IP版本号 
unsigned char tos; //8位服务类型TOS 
unsigned short total_len; //16位总长度（字节） 
unsigned short ident; //16位标识 
unsigned short frag_and_flags; //3位标志位 
unsigned char ttl; //8位生存时间 TTL 
unsigned char proto; //8位协议 (TCP, UDP 或其他) 
unsigned short checksum; //16位IP首部校验和 
unsigned int sourceIP; //32位源IP地址 
unsigned int destIP; //32位目的IP地址 
}IP_HEADER; 
typedef struct psd_hdr //定义TCP伪首部 
{ 
unsigned long saddr; //源地址 
unsigned long daddr; //目的地址 
char mbz; 
char ptcl; //协议类型 
unsigned short tcpl; //TCP长度 
}PSD_HEADER; 
typedef struct _tcphdr //定义TCP首部 
{ 
USHORT th_sport; //16位源端口 
USHORT th_dport; //16位目的端口 
unsigned int th_seq; //32位序列号 
unsigned int th_ack; //32位确认号 
unsigned char th_lenres; //4位首部长度/6位保留字 
unsigned char th_flag; //6位标志位 
USHORT th_win; //16位窗口大小 
USHORT th_sum; //16位校验和 
USHORT th_urp; //16位紧急数据偏移量 
}TCP_HEADER; 

TCP伪首部并不是真正存在的，只是用于计算检验和。校验和函数：

USHORT checksum(USHORT *buffer, int size) 
{ 
unsigned long cksum=0; 
while (size > 1) 
{ 
cksum += *buffer++; 
size -= sizeof(USHORT); 
} 
if (size) 
{ 
cksum += *(UCHAR*)buffer; 
} 
cksum = (cksum >> 16) + (cksum & 0xffff); 
cksum += (cksum >>16); 
return (USHORT)(~cksum); 
} 

当需要自己填充IP头部和TCP头部的时候，就同时需要自己计算他们的检验和。
3、发送原始套接字数据报
填充这些头部稍微麻烦点，发送就相对简单多了。只需要使用sendto()就OK。
sendto(sock, (char*)&tcpHeader, sizeof(tcpHeader), 0, (sockaddr*)&addr_in,sizeof(addr_in));
下面是一个示例程序，可以作为SYN扫描的一部分。

#include <stdio.h> 
#include <winsock2.h> 
#include <ws2tcpip.h> 
#define SOURCE_PORT 7234 
#define MAX_RECEIVEBYTE 255 
typedef struct ip_hdr //定义IP首部 
{ 
unsigned char h_verlen; //4位首部长度,4位IP版本号 
unsigned char tos; //8位服务类型TOS 
unsigned short total_len; //16位总长度（字节） 
unsigned short ident; //16位标识 
unsigned short frag_and_flags; //3位标志位 
unsigned char ttl; //8位生存时间 TTL 
unsigned char proto; //8位协议 (TCP, UDP 或其他) 
unsigned short checksum; //16位IP首部校验和 
unsigned int sourceIP; //32位源IP地址 
unsigned int destIP; //32位目的IP地址 
}IPHEADER; 
typedef struct tsd_hdr //定义TCP伪首部 
{ 
unsigned long saddr; //源地址 
unsigned long daddr; //目的地址 
char mbz; 
char ptcl; //协议类型 
unsigned short tcpl; //TCP长度 
}PSDHEADER; 
typedef struct tcp_hdr //定义TCP首部 
{ 
USHORT th_sport; //16位源端口 
USHORT th_dport; //16位目的端口 
unsigned int th_seq; //32位序列号 
unsigned int th_ack; //32位确认号 
unsigned char th_lenres; //4位首部长度/6位保留字 
unsigned char th_flag; //6位标志位 
USHORT th_win; //16位窗口大小 
USHORT th_sum; //16位校验和 
USHORT th_urp; //16位紧急数据偏移量 
}TCPHEADER; 
//CheckSum:计算校验和的子函数 
USHORT checksum(USHORT *buffer, int size) 
{ 
unsigned long cksum=0; 
while(size >1) 
{ 
cksum+=*buffer++; 
size -=sizeof(USHORT); 
} 
if(size ) 
{ 
cksum += *(UCHAR*)buffer; 
} 
cksum = (cksum >> 16) + (cksum & 0xffff); 
cksum += (cksum >>16); 
return (USHORT)(~cksum); 
} 
void useage() 
{ 
printf("******************************************\n"); 
printf("TCPPing\n"); 
printf("\t Written by Refdom\n"); 
printf("\t Email: refdom@263.net\n"); 
printf("Useage: TCPPing.exe Target_ip Target_port \n"); 
printf("*******************************************\n"); 
} 
int main(int argc, char* argv[]) 
{ 
WSADATA WSAData; 
SOCKET sock; 
SOCKADDR_IN addr_in; 
IPHEADER ipHeader; 
TCPHEADER tcpHeader; 
PSDHEADER psdHeader; 
char szSendBuf[60]={0}; 
BOOL flag; 
int rect,nTimeOver; 
useage(); 
if (argc!= 3) 
{ return false; } 
if (WSAStartup(MAKEWORD(2,2), &WSAData)!=0) 
{ 
printf("WSAStartup Error!\n"); 
return false; 
} 
if ((sock=WSASocket(AF_INET,SOCK_RAW,IPPROTO_RAW,NULL,0,WSA_FLAG_OVERLAPPED))==INVALID_SOCKET) 
{ 
printf("Socket Setup Error!\n"); 
return false; 
} 
flag=true; 
if (setsockopt(sock,IPPROTO_IP, IP_HDRINCL,(char *)&flag,sizeof(flag))==SOCKET_ERROR) 
{ 
printf("setsockopt IP_HDRINCL error!\n"); 
return false; 
} 
nTimeOver=1000; 
if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&nTimeOver, sizeof(nTimeOver))==SOCKET_ERROR) 
{ 
printf("setsockopt SO_SNDTIMEO error!\n"); 
return false; 
} 
addr_in.sin_family=AF_INET; 
addr_in.sin_port=htons(atoi(argv[2])); 
addr_in.sin_addr.S_un.S_addr=inet_addr(argv[1]); 
// 
// 
//填充IP首部 
ipHeader.h_verlen=(4<<4 | sizeof(ipHeader)/sizeof(unsigned long)); 
// ipHeader.tos=0; 
ipHeader.total_len=htons(sizeof(ipHeader)+sizeof(tcpHeader)); 
ipHeader.ident=1; 
ipHeader.frag_and_flags=0; 
ipHeader.ttl=128; 
ipHeader.proto=IPPROTO_TCP; 
ipHeader.checksum=0; 
ipHeader.sourceIP=inet_addr("本地地址"); 
ipHeader.destIP=inet_addr(argv[1]); 
//填充TCP首部 
tcpHeader.th_dport=htons(atoi(argv[2])); 
tcpHeader.th_sport=htons(SOURCE_PORT); //源端口号 
tcpHeader.th_seq=htonl(0x12345678); 
tcpHeader.th_ack=0; 
tcpHeader.th_lenres=(sizeof(tcpHeader)/4<<4|0); 
tcpHeader.th_flag=2; //修改这里来实现不同的标志位探测，2是SYN，1是FIN，16是ACK探测 等等 
tcpHeader.th_win=htons(512); 
tcpHeader.th_urp=0; 
tcpHeader.th_sum=0; 
psdHeader.saddr=ipHeader.sourceIP; 
psdHeader.daddr=ipHeader.destIP; 
psdHeader.mbz=0; 
psdHeader.ptcl=IPPROTO_TCP; 
psdHeader.tcpl=htons(sizeof(tcpHeader)); 
//计算校验和 
memcpy(szSendBuf, &psdHeader, sizeof(psdHeader)); 
memcpy(szSendBuf+sizeof(psdHeader), &tcpHeader, sizeof(tcpHeader)); 
tcpHeader.th_sum=checksum((USHORT *)szSendBuf,sizeof(psdHeader)+sizeof(tcpHeader)); 
memcpy(szSendBuf, &ipHeader, sizeof(ipHeader)); 
memcpy(szSendBuf+sizeof(ipHeader), &tcpHeader, sizeof(tcpHeader)); 
memset(szSendBuf+sizeof(ipHeader)+sizeof(tcpHeader), 0, 4); 
ipHeader.checksum=checksum((USHORT *)szSendBuf, sizeof(ipHeader)+sizeof(tcpHeader)); 
memcpy(szSendBuf, &ipHeader, sizeof(ipHeader)); 
rect=sendto(sock, szSendBuf, sizeof(ipHeader)+sizeof(tcpHeader), 
0, (struct sockaddr*)&addr_in, sizeof(addr_in)); 
if (rect==SOCKET_ERROR) 
{ 
printf("send error!:%d\n",WSAGetLastError()); 
return false; 
} 
else 
printf("send ok!\n"); 
closesocket(sock); 
WSACleanup(); 
return 0; 
} 

 

4、接收数据
和发送原始套接字数据相比，接收就比较麻烦了。因为在WIN我们不能用recv()来接收raw socket上的数据，这是因为，所有的IP包都是先递交给系统核心，然后再传输到用户程序，当发送一个raws socket包的时候（比如syn），核心并不知道，也没有这个数据被发送或者连接建立的记录，因此，当远端主机回应的时候，系统核心就把这些包都全部丢 掉，从而到不了应用程序上。所以，就不能简单地使用接收函数来接收这些数据报。
要达到接收数据的目的，就必须采用嗅探，接收所有通过的数据包，然后进行筛选，留下符合我们需要的。可以再定义一个原始套接字，用来完成接收数据的任务，需要设置SIO_RCVALL，表示接收所有的数据。

SOCKET sniffersock; 
sniffsock = WSASocket(AF_INET, SOCK_RAW, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED); 
DWORD lpvBuffer = 1; 
DWORD lpcbBytesReturned = 0 ; 
WSAIoctl(sniffersock, SIO_RCVALL, &lpvBuffer, sizeof(lpvBuffer), NULL, 0, & lpcbBytesReturned, NULL, NULL); 

创建一个用于接收数据的原始套接字，我们可以用接收函数来接收数据包了。然后在使用一个过滤函数达到筛选的目的，接收我们需要的数据包。