第6章 嵌入式Linux网络编程

Transcription

1

2 第 6 章嵌入式 Linux 网络编程 本章目标本章主要介绍嵌入式 Linux 网络编程的基础知识 由于网络在嵌入式中的应用非常广泛, 基本上常见的应用都会与网络有关, 因此, 掌握这一部分的内容是非常重要的, 学习完本章读者将掌握如下内容 TCP/IP 协议概述网络基础编程网络高级编程 NTP 客户端的实现

3 6.1. TCP/IP 协议概述 6.1.1TCP/IP 的分层模型读者一定都听说过著名的 OSI 协议参考模型, 它是基于国际标准化组织 (ISO) 的建议发展起来的, 它分为 7 个层次 : 应用层 表示层 会话层 传输层 网络层 数据链路层及物理层 这个 7 层的协议模型虽然规定得非常细致和完善, 但在实际中 却得不到广泛的应用, 其重要的原因之一就在于它过于复杂 但它仍是此后很多协议 模型的基础 与此相区别的 TCP/IP 协议模型将 OSI 的 7 层协议模型简化为 4 层, 从 而更有利于实现和使用 TCP/IP 的协议参考模型和 OSI 协议参考模型的对应关系如 下图 6.1 所示 图 6.1 OSI 模型和 TCP/IP 参考模型对应关系 TCP/IP 协议是一个复制的协议, 是由一组专业化协议组成的 这些协议包括 IP TCP UDP ARP ICMP 以及其他的一些被称为子协议的协议 TCP/IP 协议的前身是由美国国防部在 20 世纪 60 年代末期为其远景研究规划署网络 (ARPANET) 而开发的 由于低成本以及在多个不同平台通信的可靠性,TCP/IP 迅速发展并开始流行 它实际上是一个关于因特网的标准, 迅速成为局域网的首选协议 下面具体讲解各层在 TCP/IP 整体架构中的作用 1. 网络接口层 (Network Interface Layer) 网络接口层是 TCP/IP 协议软件的最底层, 负责将二进制流转换为数据帧, 并进行数据帧的发送和接收 数据帧是网络传输的基本单元 2. 网络层 (Internet Layer)

4 网络层负责在主机之间的通信中选择数据报的传输路径, 即路由 当网络层接收 到传输层的请求后, 传输某个具有目的地址信息的分组 该层把分组封装在 IP 数据 报中, 填入数据报的首部, 使用路由算法来确定是直接交付数据报, 还是把它传递给 路由器, 然后把数据报交给适当的网络接口进行传输 网络层还要负责处理传入的数据报, 检验其有效性, 使用路由算法来决定应该对 数据报进行本地处理还是应该转发 如果数据报的目的机处于本机所在的网络, 该层软件就会除去数据报的首部, 再 选择适当的运输层协议来处理这个分组 最后, 网络层还要根据需要发出和接收 ICMP (Internet 控制报文协议 ) 差错和控制报文 3. 传输层 (Transport Layer) 传输层负责提供应用程序之间的通信服务 这种通信又称为端到端通信 传输层 要系统地管理信息的流动, 还要提供可靠的传输服务, 以确保数据到达无差错 无乱 序 为了达到这个目的, 传输层协议软件要进行协商, 让接收方回送确认信息及让发 送方重发丢失的分组 传输层协议软件把要传输的数据流划分为分组, 把每个分组 连同目的地址交给网络层去发送 4. 应用层 (Application Layer) 应用层是分层模型的最高层, 在这个最高层中, 用户调用应用程序通过 TCP/IP 互联网来访问可行的服务 与各个传输层协议交互的应用程序负责接收和发送数据 每个应用程序选择适当的传输服务类型, 把数据按照传输层的格式要求封装好向下层 传输 综上可知,TCP/IP 分层模型每一层负责不同的通信功能, 整体联动合作, 就可以完 成互联网的大部分传输要求 6.1.2TCP/IP 分层模型特点 TCP/IP 是目前 Internet 上最成功 使用最频繁的互联协议 虽然现在已有很多协 议都适用于互联网, 但 TCP/IP 的使用最广泛 下面讲解一下 TCP/IP 的特点 1.TCP/IP 模型边界特性 TCP/IP 分层模型中有两大边界特性 : 一个是地址边界特性, 它将 IP 逻辑地址与底 层网络的硬件地址分开 ; 一个是操作系统边界特性, 它将网络应用与协议软件分开, 如 图 6.2 所示 TCP/IP 分层模型边界特性是指在模型中存在一 个地址上的边界, 它将底层网络的物理地址与网络层 的 IP 地址分开 该边界出现在网络层与网络接口层之 间 图 6.2 TCP/IP 分层模型边界特性

5 网络层和其上的各层均使用 IP 地址, 网络接口层则使用物理地址, 即底层网络设 备的硬件地址 TCP/IP 提供在两种地址之间进行映射的功能 划分地址边界的目的是 为了屏蔽底层物理网络的地址细节, 以便使互联网软件地址上易于实现和理解 TCP/IP 软件在操作系统内具体的位置和 TCP/IP 的实现有关, 但大部分实现都类 似于图 6.2 所示情况 影响操作系统边界划分的最重要因素是协议的效率问题, 在操 作系统内部实现的协议软件, 其数据传递的效率明显要高 2.IP 层特性 IP 层作为通信子网的最高层, 提供无连接的数据报传输机制, 但 IP 协议并不能 保证 IP 报文传递的可靠性,IP 的机制是点到点的 用 IP 进行通信的主机或路由器位 于同一物理网络, 对等机器之间拥有直接的物理连接 TCP/IP 设计原则之一是为包容各种物理网络技术, 包容性主要体现在 IP 层中 各种物理网络技术在帧或报文格式 地址格式等方面差别很大,TCP/IP 的重要思想之 一就是通过 IP 将各种底层网络技术统一起来, 达到屏蔽底层细节, 提供统一虚拟网 的目的 IP 向上层提供统一的 IP 报文, 使得各种网络帧或报文格式的差异性对高层协议 不复存在 IP 层是 TCP/IP 实现异构网互联最关键的一层 3.TCP/IP 的可靠性特性 在 TCP/IP 网络中,IP 采用无连接的数据报机制, 对数据进行 尽力而为 的传递机制, 即只管将报文尽力传送到目的主机, 无论传输正确与否, 不做验证, 不发确认, 也不保证报文的顺序 TCP/IP 的可靠性体现在传输层协议之一的 TCP 协议 TCP 协议提供面向连接的服务, 因为传输层是端到端的, 所以 TCP/IP 的 可靠性被称为端到端可靠性 综上可知,TCP/IP 的特点就是将不同的底层物理网络 拓扑结构隐藏起来, 向用户和应用程序提供通用 统一的网络服务 这样, 从用户的角度看, 整个 TCP/IP 互联网就是一个统一的整体, 它独立于具体的各种物理网络技术, 能够向用户提供 一个通用的网络服务 TCP/IP 网络完全撇开了底层物理网络的特性, 是一个高度抽象的概念, 正是由于 这个原因, 其为 TCP/IP 网络赋予了巨大的灵活性和通用性 6.1.3TCP/IP 核心协议在 TCP/IP 协议族中, 有很多种协议, 如图 6.3 所示 TCP/IP 协议群中的核心协议被设计运行在网络层和传输层, 它们为网络中的各主机提供通信服务, 也为模型的最高层 应用层中的协议提供服务 用户进程 TCP ICMP IP 用户进程 UDP IGMP 应用层 传输层 网络层 ARP RARP 网络接口层 图 6.3 TCP/IP 协议族不同分层中的协

6 在此主要介绍在网络编程中涉及的传输层 TCP 和 UDP 协议 1.TCP (1) 概述 TCP 的上一层是应用层,TCP 向应用层提供可靠的面向对象的数据流传输服务, TCP 数据传输实现了从一个应用程序到另一个应用程序的数据传递 它能提供高可靠性通信 ( 即数据无误 数据无丢失 数据无失序 数据无重复到达的通信 ), 应用程序通过向 TCP 层提交数据接发送 / 收端的地址和端口号而实现应用层的数据通信 通过 IP 的源 / 目的可以惟一地区分网络中两个设备的连接, 通过 socket 的源 / 目的可以惟一地区分网络中两个应用程序的连接 (2)3 次握手协议 TCP 是面向连接的, 所谓面向连接, 就是当计算机双方通信时必需先建立连接, 然后进行数据通信, 最后拆除连接三个过程 TCP 在建立连接时又分三步走 : 第一步 (A->B): 主机 A 向主机 B 发送一个包含 SYN 即同步 (Synchronize) 标志的 TCP 报文,SYN 同步报文会指明客户端使用的端口以及 TCP 连接的初始序号 ; 第二步 (B->A): 主机 B 在收到客户端的 SYN 报文后, 将返回一个 SYN+ACK 的报文, 表示主机 B 的请求被接受, 同时 TCP 序号被加一,ACK 即确认 (Acknowledgement) 第三步 (A->B): 主机 A 也返回一个确认报文 ACK 给服务器端, 同样 TCP 序列号被加一, 到此一个 TCP 连接完成 图 6.4 就是这个流程的简单示意图 SYN J SYN K,ACK J+1 ACK K+1 图 6.4 TCP3 次握手协议 TCP 实体所采用的基本协议是滑动窗口协议 当发送方传送一个数据报时, 它将启动计时器 当该数据报到达目的地后, 接收方的 TCP 实体向回发送一个数据报, 其中包含有一个确认序号, 它意思是希望收到的下一个数据报的顺序号 如果发送方的定时器在确认信息到达之前超时, 那么发送方会重发该数据报 (3)TCP 数据报头图 6.5 为 TCP 数据报头的格式

7 图 6.5 TCP 数据报头的格式 源端口 目的端口 :16 位长, 标识出远端和本地的端口号 序号 :32 位长, 标识发送的数据报的顺序 确认号 :32 位长, 希望收到的下一个数据报的序列号 TCP 头长 :4 位长, 表明 TCP 头中包含多少个 32 位字 6 位未用 ACK:ACK 位置 1 表明确认号是合法的 ; 如果 ACK 为 0, 那么数据报不包含确认信息, 确认字段被省略 PSH: 表示是带有 PUSH 标志的数据 因此请求数据报一到接收方便可送往应用程序而不必等到缓冲区装满时才传送 RST: 用于复位由于主机崩溃或其他原因而出现的错误的连接, 还可以用于拒绝非法的数据报或拒绝连接请求 SYN: 用于建立连接 FIN: 用于释放连接 窗口大小 :16 位长, 窗口大小字段表示在确认了字节之后还可以发送多少个字节 校验和 :16 位长, 是为了确保高可靠性而设置的, 它校验头部 数据和伪 TCP 头部之和 可选项 :0 个或多个 32 位字, 包括最大 TCP 载荷 窗口比例 选择重发数据报等选项 2.UDP (1) 概述 UDP 即用户数据报协议, 是一种面向无连接的不可靠传输协议, 不需要通过 3 次握手来建立一个连接, 同时, 一个 UDP 应用可同时作为应用的客户或服务器方 由于 UDP 协议并不需要建立一个明确的连接, 因此建立 UDP 应用要比建立 TCP 应用简单得多 UDP 比 TCP 协议更为高效, 也能更好地解决实时性的问题, 如今, 包括网络视频会议系统在内的众多的客户 / 服务器模式的网络应用都使用 UDP 协议 (2)UDP 数据包头 UDP 数据包头如图 6.6 所示

8 源地址 目的地址 :16 位长, 标识出远端和本地的端口号 数据报的长度是指包括报头和数据部分在内的总的字节数 因为报头的长度是固定的, 所以该域主要用来计算可变长度的数据部分 ( 又称为数据负载 ) 3. 协议的选择 图 6.6 UDP 数据包头 协议的选择应该考虑到数据可靠性 应用的实时性和网络的可靠性 对数据可靠性要求高的应用需选择 TCP 协议, 而对数据的可靠性要求不那么高的应用可选择 UDP 传送 TCP 协议中的 3 次握手 重传确认等手段可以保证数据传输的可靠性, 但使用 TCP 协议会有较大的时延, 因此不适合对实时性要求较高的应用 ; 而 UDP 协议则有很好的实时性 网络状况不是很好的情况下需选用 TCP 协议 ( 如在广域网等情况 ), 网络状况很好的情况下选择 UDP 协议可以减少网络负荷 6.2. 网络编程基本 套接字 (socket) 概述 1. 套接字定义在 Linux 中的网络编程是通过 socket 接口来进行的 套接字 (socket) 是一种特殊的 I/O 接口, 它也是一种文件描述符 socket 是一种常用的进程之间通信机制, 通过它不仅能实现本地机器上的进程之间的通信, 而且通过网络能够在不同机器上的进程之间进行通信 每一个 socket 都用一个半相关描述 协议 本地地址 本地端口 来表示 ; 一个完整的套接字则用一个相关描述 协议 本地地址 本地端口 远程地址 远程端口 来表示 socket 也有一个类似于打开文件的函数调用, 该函数返回一个整型的 socket 描述符, 随后的连接建立 数据传输等操作都是通过 socket 来实现的 2. 套接字类型常见的 socket 有 3 种类型如下 (1) 流式套接字 (SOCK_STREAM) 流式套接字提供可靠的 面向连接的通信流 ; 它使用 TCP 协议, 从而保证了数据传输的可靠性和顺序性 (2) 数据报套接字 (SOCK_DGRAM)

9 数据报套接字定义了一种无可靠 面向无连接的服务, 数据通过相互独立的报文 进行传输, 是无序的, 并且不保证是可靠 无差错的 它使用数据报协议 UDP (3) 原始套接字 (SOCK_RAW) 原始套接字允许对底层协议如 IP 或 ICMP 进行直接访问, 它功能强大但使用较为 不便, 主要用于一些协议的开发 地址及顺序处理 1. 地址结构相关处理 (1) 数据结构介绍 下面首先介绍两个重要的数据类型 :sockaddr 和 sockaddr_in, 这两个结构类型都 是用来保存 socket 信息的, 如下所示 : struct sockaddr unsigned short sa_family; /* 地址族 */ */ char sa_data[14]; /*14 字节的协议地址, 包含该 socket 的 IP 地址和端口号 ; struct sockaddr_in short int sa_family; /* 地址族 */ unsigned short int sin_port; /* 端口号 */ struct in_addr sin_addr; /*IP 地址 */ unsigned char sin_zero[8]; /* 填充 0 以保持与 struct sockaddr 同样大 小 */ ; 这两个数据类型是等效的, 可以相互转化, 通常 sockaddr_in 数据类型使用更为方便 在建立 socketadd 或 sockaddr_in 后, 就可以对该 socket 进行适当的操作了 (2) 结构字段表 6.1 列出了该结构 sa_family 字段可选的常见值 表 6.1 sa_family 字段值 结构定义头文件 sa_family #include <netinet/in.h> AF_INET:IPv4 协议 AF_INET6:IPv6 协议 AF_LOCAL:UNIX 域协议 AF_LINK: 链路地址协议 AF_KEY: 密钥套接字 sockaddr_in 其他字段的含义非常清楚, 具体的设置涉及到其他函数, 在后面会有 详细的讲解

10 2. 数据存储优先顺序 (1) 函数说明计算机数据存储有两种字节优先顺序 : 高位字节优先 ( 称为大端模式 ) 和低位字节优先 ( 称为小端模式,PC 机通常采用小端模式 ) Internet 上数据以高位字节优先顺序在网络上传输, 因此在有些情况下, 需要对这两个字节存储优先顺序进行相互转化 这里用到了四个函数 :htons() ntohs() htonl() 和 ntohl() 这四个地址分别实现网络字节序和主机字节序的转化, 这里的 h 代表 host,n 代表 network,s 代表 short,l 代表 long 通常 16 位的 IP 端口号用 s 代表, 而 IP 地址用 l 来代表 调用这些函数只是使其得到相应的字节序, 用户不需清楚该系统的主机字节序和网络字节序是否真正相等 如果是相同不需要转换的话, 该系统的这些函数会定义成空宏 (2) 函数格式表 6.2 列出了这 4 个函数的语法格式 表 6.2 所需头文件函数原型函数传入值函数返回值 htons 等函数语法要点 #include <netinet/in.h> uint16_t htons(unit16_t host16bit) uint32_t htonl(unit32_t host32bit) uint16_t ntohs(unit16_t net16bit) uint32_t ntohs(unit32_t net32bit) host16bit: 主机字节序的 16bit 数据 host32bit: 主机字节序的 32bit 数据 net16bit: 网络字节序的 16bit 数据 net32bit: 网络字节序的 32bit 数据 成功 : 返回要转换的字节序 出错 : 1 3. 地址格式转化 (1) 函数说明用户在表达地址时通常采用点分十进制表示的数值字符串 ( 或者是以冒号分开的十进制 IPv6 地址 ), 而在通常使用的 socket 编程中所使用的则是二进制值 ( 例如, 用 in_addr 结构和 in6_addr 结构分别表示 IPv4 和 IPv6 中的网络地址 ), 这就需要将这两个数值进行转换 这里在 IPv4 中用到的函数有 inet_aton() inet_addr() 和 inet_ntoa(), 而 IPv4 和 IPv6 兼容的函数有 inet_pton() 和 inet_ntop() 由于 IPv6 是下一代互联网的标准协议, 因此, 本书讲解的函数都能够同时兼容 IPv4 和 IPv6, 但在具体举例时仍以 IPv4 为例 inet_pton() 函数是将点分十进制地址字符串转换为二进制地址 ( 例如 : 将 IPv4 的地址字符串 转换为 4 个字节的数据 ( 从低字节起依次为 )), 而 inet_ntop() 是 inet_pton() 的反操向作, 将二进制地址转换为点分十进制地址字符串 (2) 函数格式

11 表 6.3 列出了 inet_pton() 函数的语法要点 表 6.3 所需头文件函数原型函数传入值函数返回值 inet_pton() 函数语法要点 #include <arpa/inet.h> int inet_pton(int family, const char *strptr, void *addrptr) AF_INET:IPv4 协议 family AF_INET6:IPv6 协议 strptr: 要转化的值 ( 十进制地址字符串 ) addrptr: 转化后的地址成功 :0 出错 : 1 表 6.4 列出了 inet_ntop() 函数的语法要点 表 6.4 所需头文件函数原型函数传入值函数返回值 inet_ntop() 函数语法要点 #include <arpa/inet.h> int inet_ntop(int family, void *addrptr, char *strptr, size_t len) AF_INET:IPv4 协议 family AF_INET6:IPv6 协议 addrptr: 要转化的地址 strptr: 转化后的十进制地址字符串 len: 转化后值的大小成功 :0 出错 : 1 4. 名字地址转化 (1) 函数说明在 Linux 中有一些函数可以实现主机名和地址的转化, 如 gethostbyname() gethostbyaddr() 和 getaddrinfo() 等, 它们都可以实现 IPv4 和 IPv6 的地址和主机名之间的转化 其中 gethostbyname() 是将主机名转化为 IP 地址,gethostbyaddr() 则是逆操作, 是将 IP 地址转化为主机名, 另外 getaddrinfo() 还能实现自动识别 IPv4 地址和 IPv6 地址 gethostbyname() 和 gethostbyaddr() 都涉及到一个 hostent 的结构体, 如下所示 : struct hostent char *h_name; /* 正式主机名 */ char **h_aliases; /* 主机别名 */ int h_addrtype; /* 地址类型 */ int h_length; /* 地址字节长度 */ char **h_addr_list; /* 指向 IPv4 或 IPv6 的地址指针数组 */

12 调用 gethostbyname() 函数或 gethostbyaddr() 函数后就能返回 hostent 结构体的相关 信息 getaddrinfo() 函数涉及到一个 addrinfo 的结构体, 如下所示 : struct addrinfo int ai_flags; /*AI_PASSIVE, AI_CANONNAME;*/ int ai_family; /* 地址族 */ int ai_socktype; /*socket 类型 */ int ai_protocol; /* 协议类型 */ size_t ai_addrlen; /* 地址字节长度 */ char *ai_canonname; /* 主机名 */ struct sockaddr *ai_addr; /*socket 结构体 */ struct addrinfo *ai_next; /* 下一个指针链表 */ hostent 结构体而言,addrinfo 结构体包含更多的信息 (2) 函数格式 表 6.5 列出了 gethostbyname() 函数的语法要点 表 6.5 所需头文件函数原型函数传入值函数返回值 gethostbyname 函数语法要点 #include <netdb.h> struct hostent *gethostbyname(const char *hostname) hostname: 主机名成功 :hostent 类型指针出错 : 1 调用该函数时可以首先对 hostent 结构体中的 h_addrtype 和 h_length 进行设置, 若为 IPv4 可设置为 AF_INET 和 4; 若为 IPv6 可设置为 AF_INET6 和 16; 若不设置则默认为 IPv4 地址类型 表 6.6 列出了 getaddrinfo() 函数的语法要点 表 6.6 所需头文件函数原型函数传入值函数返回值 #include <netdb.h> getaddrinfo() 函数语法要点 int getaddrinfo(const char *node, const char *service, const struct addrinfo *hi struct addrinfo **result) node: 网络地址或者网络主机名 service: 服务名或十进制的端口号字符串 hints: 服务线索 result: 返回结果 成功 :0 出错 : 1

13 在调用之前, 首先要对 hints 服务线索进行设置 它是一个 addrinfo 结构体, 表 6.7 列举了该结构体常见的选项值 表 6.7 结构体头文件 ai_flags ai_family ai_socktype ai_protocol addrinfo 结构体常见选项值 #include <netdb.h> AI_PASSIVE: 该套接口是用作被动地打开 AI_CANONNAME: 通知 getaddrinfo 函数返回主机的名字 AF_INET:IPv4 协议 AF_INET6:IPv6 协议 AF_UNSPEC:IPv4 或 IPv6 均可 SOCK_STREAM: 字节流套接字 socket(tcp) SOCK_DGRAM: 数据报套接字 socket(udp) IPPROTO_IP:IP 协议 IPPROTO_IPV4:IPv4 协议 IPPROTO_IPV6:IPv6 协议 IPPROTO_UDP:UDP IPPROTO_TCP:TCP 注意 : 通常服务器端在调用 getaddrinfo() 之前,ai_flags 设置 AI_PASSIVE, 用于 bind() 函数 ( 用于端口和地址的绑定, 后面会讲到 ), 主机名 nodename 通常会设置为 NULL 客户端调用 getaddrinfo() 时,ai_flags 一般不设置 AI_PASSIVE, 但是主机名 nodename 和服务名 servname( 端口 ) 则应该不为空 即使不设置 ai_flags 为 AI_PASSIVE, 取出的地址也可以被绑定, 很多程序中 ai_flags 直接设置为 0, 即 3 个标志位都不设置, 这种情况下只要 hostname 和 servname 设置的没有问题就可以正确绑定 (3) 使用实例下面的实例给出了 getaddrinfo() 函数用法的示例 根据使用 gethostname() 获取的主机名, 调用 getaddrinfo() 函数得到关于主机的相关信息 最后调用 inet_ntop() 函数将主机的 IP 地址转换成字符串, 以便显示到屏幕上 /* getaddrinfo.c */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <netdb.h> #include <sys/types.h> #include <netinet/in.h> #include <sys/socket.h> #include <arpa/inet.h> #define MAXNAMELEN 256

14 int main() struct addrinfo hints, *res = NULL; char host_name[maxnamelen], addr_str[inet_addrstrlen], *addr_str1; int rc; struct in_addr addr; memset(&hints, 0, sizeof(hints)); /* 设置 addrinfo 结构体中各参数 */ hints.ai_flags = AI_CANONNAME; hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; /* 调用 gethostname() 函数获得主机名 */ if ((gethostname(host_name,maxnamelen)) == -1) perror("gethostname"); rc = getaddrinfo(host_name, NULL, &hints, &res); if (rc!= 0) perror("getaddrinfo"); else addr = ((struct sockaddr_in*)(res->ai_addr))->sin_addr; inet_ntop(res->ai_family, &(addr.s_addr), addr_str, INET_ADDRSTRLEN); printf("host name:%s\nip address: %s\n", res->ai_canonname, addr_str); exit(0);

15 6.2.3 套接字编程 (1) 函数说明 嵌入式应用程序设计 第 6 章嵌入式 Linux 网络编程 socket 编程的基本函数有 socket() bind() listen() accept() send() sendto() recv() 以及 recvfrom() 等, 其中根据客户端还是服务端, 或者根据使用 TCP 协议还是 UDP 协议, 这些函数的调用流程都有所区别, 这里先对每个函数进行说明, 再给出各种情 况下使用的流程图 socket(): 该函数用于建立一个套接字, 一条通信路线的端点 在建立了 socket 之后, 可对 sockaddr 或 sockaddr_in 结构进行初始化, 以保存所建立的 socket 地址信 息 bind(): 该函数是用于将 sockaddr 结构的地址信息与套接字进行绑定, 它主要 用于 TCP 的连接, 而在 UDP 的连接中则无必要 ( 但可以使用 ) 3 listen(): 在服务端程序成功建立套接字和与地址进行绑定之后, 还需要准备在 该套接字上接收新的连接请求 此时调用 listen() 函数来创建一个等待队列, 在其中存 放未处理的客户端连接请求 accept(): 服务端程序调用 listen() 函数创建等待队列之后, 调用 accept() 函数等 待并接收客户端的连接请求 它通常从由 listen() 所创建的等待队列中取出第一个未处 理的连接请求 connect(): 客户端通过一个未命名套接字 ( 未使用 bind() 函数 ) 和服务器监听 套接字之间建立连接的方法来连接到服务器 这个工作客户端通过使用 connect() 函数 来实现 send() 和 recv(): 这两个函数分别用于发送和接收数据, 可以用在 TCP 中, 也 可以用在 UDP 中 当用在 UDP 时, 可以在 connect() 函数建立连接之后再使用 sendto() 和 recvfrom(): 这两个函数的作用与 send() 和 recv() 函数类似, 也可以 用在 TCP 和 UDP 中 当用在 TCP 时, 后面的几个与地址有关参数不起作用, 函数作 用等同于 send() 和 recv(); 当用在 UDP 时, 可以用在之前没有使用 connect() 的情况下, 这两个函数可以自动寻找指定地址并进行连接 服务器端和客户端使用 TCP 协议的流程如图 6.7 所示

16 图 6.7 使用 TCP 协议 socket 编程流程图 服务器端和客户端使用 UDP 协议的流程图如图 6.8 所示 图 6.8 使用 UDP 协议 socket 编程流程图 (2) 函数格式 表 6.8 列出了 socket() 函数的语法要点 表 6.8 所需头文件函数原型函数传入值 #include <sys/socket.h> socket() 函数语法要点 int socket(int family, int type, int protocol) family: 协议族 AF_INET:IPv4 协议 AF_INET6:IPv6 协议 AF_LOCAL:UNIX 域协议

17 函数返回值 type: 套接字类型 protoco:0( 原始套接字除外 ) 成功 : 非负套接字描述符 出错 : 1 AF_ROUTE: 路由套接字 (socket) AF_KEY: 密钥套接字 (socket) SOCK_STREAM: 字节流套接字 socket SOCK_DGRAM: 数据报套接字 socket SOCK_RAW: 原始套接字 socket 表 6.9 列出了 bind() 函数的语法要点 表 6.9 所需头文件函数原型函数传入值函数返回值 bind() 函数语法要点 #include <sys/socket.h> int bind(int sockfd, struct sockaddr *my_addr, int addrlen) socktd: 套接字描述符 my_addr: 本地地址 addrlen: 地址长度成功 :0 出错 : 1 端口号和地址在 my_addr 中给出了, 若不指定地址, 则内核随意分配一个临时端口给该应用程序 IP 地址可以直接指定 ( 比如 :inet_addr( )), 或者使用宏 INADDR_ANY, 允许将套接字与服务器的任一网络接口 ( 比如 :eth0, eth0:1 eth1 等 ) 进行绑定 表 6.10 列出了 listen() 函数的语法要点 表 6.10 listen() 函数语法要点 所需头文件 #include <sys/socket.h> 函数原型 int listen(int sockfd, int backlog) 函数传入值 socktd: 套接字描述符 backlog: 请求队列中允许的最大请求数, 大多数系统缺省值为 5 函数返回值 成功 :0 出错 : 1 表 6.11 列出了 accept() 函数的语法要点 表 6.11 所需头文件函数原型函数传入值函数返回值 accept() 函数语法要点 #include <sys/socket.h> int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) socktd: 套接字描述符 addr: 客户端地址 addrlen: 地址长度成功 : 接收到的非负的套接字出错 : 1

18 表 6.12 列出了 connect() 函数的语法要点 表 6.12 所需头文件函数原型函数传入值函数返回值 connect() 函数语法要点 #include <sys/socket.h> int connect(int sockfd, struct sockaddr *serv_addr, int addrlen) socktd: 套接字描述符 serv_addr: 服务器端地址 addrlen: 地址长度成功 :0 出错 : 1 表 6.13 列出了 send() 函数的语法要点 表 6.13 所需头文件函数原型函数传入值函数返回值 send() 函数语法要点 #include <sys/socket.h> int send(int sockfd, const void *msg, int len, int flags) socktd: 套接字描述符 msg: 指向要发送数据的指针 len: 数据长度 flags: 一般为 0 成功 : 实际发送的字节数出错 : 1 表 6.14 列出了 recv() 函数的语法要点 表 6.14 所需头文件函数原型函数传入值函数返回值 recv() 函数语法要点 #include <sys/socket.h> int recv(int sockfd, void *buf,int len, unsigned int flags) socktd: 套接字描述符 buf: 存放接收数据的缓冲区 len: 数据长度 flags: 一般为 0 成功 : 实际接收到的字节数出错 : 1 表 6.15 列出了 sendto() 函数的语法要点 表 6.15 所需头文件函数原型函数传入值 #include <sys/socket.h> sendto() 函数语法要点 int sendto(int sockfd, const void *msg,int len, unsigned int flags, const struct socka *to, int tolen) socktd: 套接字描述符 msg: 指向要发送数据的指针 len: 数据长度 flags: 一般为 0

19 函数返回值 to: 目地机的 IP 地址和端口号信息 tolen: 地址长度成功 : 实际发送的字节数出错 : 1 表 6.16 列出了 recvfrom() 函数的语法要点 表 6.16 所需头文件函数原型函数传入值函数返回值 #include <sys/socket.h> recvfrom() 函数语法要点 int recvfrom(int sockfd,void *buf, int len, unsigned int flags, struct sockaddr *fr int *fromlen) socktd: 套接字描述符 buf: 存放接收数据的缓冲区 len: 数据长度 flags: 一般为 0 from: 源主机的 IP 地址和端口号信息 tolen: 地址长度 成功 : 实际接收到的字节数 出错 : 编程实例该实例分为客户端和服务器端两部分, 其中服务器端首先建立起 socket, 然后与 本地端口进行绑定, 接着就开始接收从客户端的连接请求并建立与它的连接, 接下来, 接收客户端发送的消息 客户端则在建立 socket 之后调用 connect() 函数来建立连接 服务端的代码如下所示 : /*server.c*/ #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #define PORT 4321 #define BUFFER_SIZE 1024 #define MAX_QUE_CONN_NM5 int main() struct sockaddr_in server_sockaddr, client_sockaddr;

20 int sin_size, recvbytes; int sockfd, client_fd; char buf[buffer_size]; /* 建立 socket 连接 */ if ((sockfd = socket(af_inet,sock_stream,0))== -1) perror("socket"); printf("socket id = %d\n",sockfd); /* 设置 sockaddr_in 结构体中相关参数 */ server_sockaddr.sin_family = AF_INET; server_sockaddr.sin_port = htons(port); server_sockaddr.sin_addr.s_addr = INADDR_ANY; bzero(&(server_sockaddr.sin_zero), 8); int i = 1;/* 允许重复使用本地地址与套接字进行绑定 */ setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); /* 绑定函数 bind()*/ if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr)) == -1) perror("bind"); printf("bind success!\n"); /* 调用 listen() 函数, 创建未处理请求的队列 */ if (listen(sockfd, MAX_QUE_CONN_NM) == -1) perror("listen"); printf("listening...\n"); /* 调用 accept() 函数, 等待客户端的连接 */

21 sin_size = sizeof(client_sockaddr); if ((client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size)) == -1) perror("accept"); /* 调用 recv() 函数接收客户端的请求 */ memset(buf, 0, sizeof(buf)); if ((recvbytes = recv(client_fd, buf, BUFFER_SIZE, 0)) == -1) perror("recv"); printf("received a message: %s\n", buf); close(sockfd); exit(0); 客户端的代码如下所示 : /*client.c*/ ( 头文件的部分跟 server.c 相同 ) #define PORT 4321 #define BUFFER_SIZE 1024 int main(int argc, char *argv[]) int sockfd,sendbytes; char buf[buffer_size]; struct hostent *host; struct sockaddr_in serv_addr; if(argc < 3) fprintf(stderr,"usage:./client Hostname(or ip address) Text\n"); /* 地址解析函数 */ if ((host = gethostbyname(argv[1])) == NULL)

22 perror("gethostbyname"); memset(buf, 0, sizeof(buf)); sprintf(buf, "%s", argv[2]); /* 创建 socket*/ if ((sockfd = socket(af_inet, SOCK_STREAM, 0)) == -1) perror("socket"); /* 设置 sockaddr_in 结构体中相关参数 */ serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(port); serv_addr.sin_addr = *((struct in_addr *)host->h_addr); bzero(&(serv_addr.sin_zero), 8); /* 调用 connect 函数主动发起对服务器端的连接 */ if(connect(sockfd,(struct sockaddr *)&serv_addr, sizeof(struct sockaddr))== -1) perror("connect"); /* 发送消息给服务器端 */ if ((sendbytes = send(sockfd, buf, strlen(buf), 0)) == -1) perror("send"); close(sockfd); exit(0); 在运行时需要先启动服务器端, 再启动客户端 这里可以把服务器端下载到开发 板上, 客户端在宿主机上运行, 然后配置双方的 IP 地址, 在确保双方可以通信 ( 如 使用 ping 命令验证 ) 的情况下运行该程序即可

23 $./server Socket id = 3 Bind success! Listening... Received a message: Hello,Server! $./client 目标板 IP 地址 Hello,Server! 6.3. 网络高级编程 在实际情况中, 人们往往遇到多个客户端连接服务器端的情况 在之前介绍的例子中我们使用阻塞函数, 因此如果资源没有准备好, 则调用该函数的进程将进入睡眠状态, 这样就无法处理其他请求的情况了 本节给出了三种解决 I/O 多路复用的解决方法, 分别为非阻塞和异步式处理 ( 使用 fcntl() 函数 ) 以及多路复用处理 ( 使用 select() 或 poll() 函数 ) 此外有多进程和多线程编程是在网络编程中常用的事务处理方法, 下一节的例子中会用到多进程网络编程 读者可以尝试使用多线程机制修改书上的所有例子, 会发现多线程编程在网络编程中非常有效的方法之一 1. 非阻塞和异步 I/O 在 socket 编程中可以使用函数 fcntl(int fd, int cmd, int arg) 的如下的编程特性 获得文件状态标志 : 将 cmd 设置为 F_GETFL, 会返回由 fd 指向的文件的状态标志 非阻塞 I/O: 将 cmd 设置为 F_SETFL, 将 arg 设置为 O_NONBLOCK 异步 I/O: 将 cmd 设置为 F_SETFL, 将 arg 设置为 O_ASYNC, 后面有说明 下面是用 fcntl() 将套接字设置为非阻塞 I/O 的实例代码 : /* nonblock_server.c */ /* 省略重复的 #include 部分 */ #include <fcntl.h> #define PORT 1234 #define MAX_QUE_CONN_NM 5 #define BUFFER_SIZE 1024 int main() struct sockaddr_in server_sockaddr, client_sockaddr; int sin_size, recvbytes, flags; int sockfd, client_fd; char buf[buffer_size]; if ((sockfd = socket(af_inet, SOCK_STREAM, 0)) == -1)

24 perror("socket"); server_sockaddr.sin_family = AF_INET; server_sockaddr.sin_port = htons(port); server_sockaddr.sin_addr.s_addr = INADDR_ANY; bzero(&(server_sockaddr.sin_zero), 8); int i = 1;/* 允许重复使用本地地址与套接字进行绑定 */ setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr)) == -1) perror("bind"); if(listen(sockfd,max_que_conn_nm) == -1) perror("listen"); /* 调用 fcntl() 函数给套接字设置非阻塞属性 */ flags = fcntl(sockfd, F_GETFL); if (flags < 0 fcntl(sockfd, F_SETFL, flags O_NONBLOCK) < 0) perror("fcntl"); < 0) while(1) sin_size = sizeof(struct sockaddr_in); if ((client_fd = accept(sockfd, (struct sockaddr*)&client_sockaddr, &sin_size)) perror("accept");

25 if ((recvbytes = recv(client_fd, buf, BUFFER_SIZE, 0)) < 0) perror("recv"); printf("received a message: %s\n", buf); /* end of while */ close(client_fd); 运行该程序, 结果如下所示 : $./nonblock_server Listening... accept: Resource temporarily unavailable 可以看到, 当 accept() 的资源不可用 ( 没有任何未处理的等待连接的请求 ) 时, 程序就会自动返回, 此时 errno 值等于 EAGAIN 可以采用循环查询的方法来解决这个问题, 例如, 每一秒轮询是否有等待处理的连接请求, 主要修改部分如下所示 ( 用黑粗体表示修改部分 ): while(1) sin_size = sizeof(struct sockaddr_in); do if (!((client_fd = accept(sockfd, (struct sockaddr*)&client_sockaddr, &sin_size)) < 0)) break; if (errno == EAGAIN) /* 在没有等待处理的连接请求时, errno 值等于 EAGAIN */ printf("resource temporarily unavailable\n"); sleep(1); else

26 /* 其他错误 */ perror("accept"); while (1); if ((recvbytes = recv(client_fd, buf, BUFFER_SIZE, 0)) < 0) perror("recv"); printf("received a message: %s\n", buf); /* end of while */ 修改之后运行结果如下所示 : $./nonblock_server_plus Resource temporarily unavailable /* 暂时没有可处理的等待请求 */ Resource temporarily unavailable Resource temporarily unavailable Received a message: hello! /* 处理新的连接请求, 而读取数据 */ Resource temporarily unavailable Resource temporarily unavailable $./client hello! /* 客户端代码如同 小节的实例 */ 尽管在很多情况下, 使用阻塞式和非阻塞式以及多路复用等机制可以有效地进行网络通信, 但效率最高的方法是使用异步通知机制 这种方法在设备 I/O 编程中常见的 内核通过使用异步 I/O, 在某一个进程需要处理的事件发生 ( 例如, 接收到新的连接请求 ) 时, 向该进程发送一个 SIGIO 信号 这样, 应用程序不需要不停地等待着某些事件的发生, 而可以往下运行, 以完成其它的工作 只有收到从内核发来的 SIGIO 信号时, 去处理它 ( 例如, 读取数据 ) 就可以 我们使用 fcntl() 函数就可以实现高效率的异步 I/O 的方法 首先必须使用 fcntl 的 F_SETOWN 命令, 使套接字归属于当前进程, 以内核能够判断应该向哪个进程发送信号 接下来, 使用 fcntl 的 F_SETFL 命令将套接字的状态标志位设置为异步通知方式 ( 使用 O_ASYNC 参数 ) 下面是使用 fcntl() 函数实现基于异步 I/O 方式的套接字通信的示例程序 /* async_server.c */ /* 省略重复的 #include 部分 */ #include <fcntl.h> #include <signal.h>

27 #define PORT 4321 #define BUFFER_SIZE 1024 #define MAX_QUE_CONN_NM5 struct sockaddr_in server_sockaddr, client_sockaddr; int sockfd, client_fd; char buf[buffer_size]; int sin_size, recvbytes; void do_work() /* 模拟的任务 : 这里只是在每秒钟打印一句信息 */ while(1) sleep(1); printf("i'm working...\n"); /* 异步信号处理函数, 处理新的套接字的连接和数据 */ void accept_async(int sig_num) sin_size = sizeof(client_sockaddr); if ((client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size)) == -1) perror("accept"); /* 调用 recv 函数接收客户端的请求 */ memset(buf, 0, sizeof(buf)); if ((recvbytes = recv(client_fd, buf, BUFFER_SIZE, 0)) == -1) perror("recv"); printf("asyncronous method: received a message: %s\n", buf); int main()

28 int flags; /* 建立 socket 连接 */ if ((sockfd = socket(af_inet, SOCK_STREAM, 0))== -1) perror("socket"); /* 设置 sockaddr_in 结构体中相关参数 */ server_sockaddr.sin_family = AF_INET; server_sockaddr.sin_port = htons(port); server_sockaddr.sin_addr.s_addr = INADDR_ANY; bzero(&(server_sockaddr.sin_zero), 8); int i = 1;/* 使得重复使用本地地址与套接字进行绑定 */ setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); /* 绑定函数 bind*/ if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr))== -1) perror("bind"); /* 调用 listen 函数 */ if (listen(sockfd, MAX_QUE_CONN_NM) == -1) perror("listen"); /* 设置异步方式 */ signal(sigio, accept_async); /* SIGIO 信号处理函数的注册 */ fcntl(sockfd, F_SETOWN, getpid()); /* 使套接字归属于该进程 */ flags = fcntl(sockfd, F_GETFL); /* 获得套接字的状态标志位 */ if (flags < 0 fcntl(sockfd, F_SETFL, flags O_ASYNC) < 0) /* 设置成异步访问模式 */ perror("fcntl"); do_work(); /* 继续完成自己的工作, 不再需要等待了! */ close(sockfd); exit(0);

29 客户端程序与 小节中的例子相同, 运行结果如下所示 : $./async_server /* 启动服务端程序 */ I'm working... I'm working... Asyncronous method: received a message: Hello! I'm working Asyncronous method: received a message: Asyncronous! I'm working... $./client Hello! /* 运行两个客户端程序 */ $./client Asyncronous! 2. 使用多路复用使用 fcntl() 函数虽然可以实现非阻塞, 但在实际使用时往往会对资源是否准备完毕进行循环测试, 这样就大大增加了不必要的 CPU 资源的占用 在这里可以使用 select() 函数 ( 或者使用 poll() 函数 ) 来解决这个问题, 同时, 使用 select() 函数还可以设置等待的时间, 可以说功能更加强大 下面是使用 select() 函数的服务器端源代码 客户端程序基本上与 小节中的例子相同, 仅加入一行 sleep() 函数, 使得客户端进程等待几秒钟才结束 /* net_select.c */ ( 头文件部分跟 小节的实例相同 ) #define PORT 4321 #define MAX_QUE_CONN_NM 5 #define MAX_SOCK_FD FD_SETSIZE #define BUFFER_SIZE 1024 int main() struct sockaddr_in server_sockaddr, client_sockaddr; int sin_size, count; fd_set inset, tmp_inset; int sockfd, client_fd, fd; char buf[buffer_size]; if ((sockfd = socket(af_inet, SOCK_STREAM, 0)) == -1)

30 perror("socket"); server_sockaddr.sin_family = AF_INET; server_sockaddr.sin_port = htons(port); server_sockaddr.sin_addr.s_addr = INADDR_ANY; bzero(&(server_sockaddr.sin_zero), 8); int i = 1;/* 允许重复使用本地地址与套接字进行绑定 */ setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr)) == -1) perror("bind"); if(listen(sockfd, MAX_QUE_CONN_NM) == -1) perror("listen"); printf("listening...\n"); /* 将调用 socket() 函数的描述符作为文件描述符 */ FD_ZERO(&inset); FD_SET(sockfd, &inset); while(1) /* 文件描述符集合的备份, 这样可以避免每次进行初始化 */ tmp_inset = inset; sin_size=sizeof(struct sockaddr_in); memset(buf, 0, sizeof(buf)); /* 调用 select() 函数 */ if (!(select(max_sock_fd, &tmp_inset, NULL, NULL, NULL) > 0)) perror("select"); for (fd = 0; fd < MAX_SOCK_FD; fd++)

31 if (FD_ISSET(fd, &tmp_inset) > 0) if (fd == sockfd) /* 服务端接收客户端的连接请求 */ if ((client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size))== -1) perror("accept"); /* 将新连接的客户端套接字加入观察列表中 */ FD_SET(client_fd, &inset); printf("new connection from %d(socket)\n", client_fd); else /* 处理从客户端发来的消息 */ if ((count = recv(client_fd, buf, BUFFER_SIZE, 0)) > 0) printf("received a message from %d: %s\n", client_fd, buf); else close(fd); FD_CLR(fd, &inset); printf("client %d(socket) has left\n", fd); /* end of if FD_ISSET*/ /* end of for fd*/ /* end if while while*/ close(sockfd); exit(0);

32 运行该程序时, 可以先启动服务器端, 再反复运行客户端程序 ( 这里启动两个客户端进程 ) 即可, 服务器端运行结果如下所示 : $./server listening... */ */ */ */ New connection from 4(socket) Received a message from 4: Hello,First! New connection from 5(socket) Received a message from 5: Hello,Second! /* 接受第一个客户端的连接请求 /* 接收第一个客户端发送的数据 /* 接受第二个客户端的连接请求 /* 接收第二个客户端发送的数据 Client 4(socket) has left /* 检测到第一个客户端离线了 */ Client 5(socket) has left /* 检测到第二个客户端离线了 */ $./client localhost Hello,First! &./client localhost Hello,Second 6.4. 实验内容 NTP 协议的客户端实现 1. 实验目的通过实现 NTP 协议的练习, 进一步掌握 Linux 网络编程, 并且提高协议的分析与实现能力, 为参与完成综合性项目打下良好的基础 2. 实验内容 Network Time Protocol(NTP) 协议是用来使计算机时间同步化的一种协议, 它可以使计算机对其服务器或时钟源 ( 如石英钟,GPS 等 ) 做同步化, 它可以提供高精确度的时间校正 (LAN 上与标准时间差小于 1 毫秒,WAN 上几十毫秒 ), 且可用加密确认的方式来防止恶毒的协议攻击 NTP 提供准确时间, 首先要有准确的时间来源, 这一时间应该是国际标准时间 UTC NTP 获得 UTC 的时间来源可以是原子钟 天文台 卫星, 也可以从 Internet 上获取 这样就有了准确而可靠的时间源 时间是按 NTP 服务器的等级传播 按照距离外部 UTC 源的远近将所有服务器归入不同的 Stratum( 层 ) 中 Stratum-1 在顶层, 有外部 UTC 接入, 而 Stratum-2 则从 Stratum-1 获取时间,Stratum-3 从 Stratum-2 获取时间, 以此类推, 但 Stratum 层的总数限制在 15 以内 所有这些服务器在逻辑上形成阶梯式的架构并相互连接, 而 Stratum-1 的时间服务器是整个系统的基础 进行网络协议实现时最重要的是了解协议数据格式 NTP 数据包有 48 个字节, 其中 NTP 包头 16 字节, 时间戳 32 个字节 其协议格式如图 6.10 所示

33 图 6.10 NTP 协议数据格式 其协议字段的含义如下所示 LI: 跳跃指示器, 警告在当月最后一天的最终时刻插入的迫近闺秒 ( 闺秒 ) VN: 版本号 Mode: 工作模式 该字段包括以下值 :0- 预留 ;1- 对称行为 ;3- 客户机 ;4 - 服务器 ;5- 广播 ;6-NTP 控制信息 NTP 协议具有三种工作模式, 分别为主 / 被动对称模式 客户 / 服务器模式 广播模式 在主 / 被动对称模式中, 有一对一的连接, 双方均可同步对方或被对方同步, 先发出申请建立连接的一方工作在主动模式下, 另一方工作在被动模式下 ; 客户 / 服务器模式与主 / 被动模式基本相同, 唯一区别在于客户方可被服务器同步, 但服务器不能被客户同步 ; 在广播模式中, 有一对多的连接, 服务器不论客户工作在何种模式下, 都会主动发出时间信息, 客户根据此信息调整自己的时间 Stratum: 对本地时钟级别的整体识别 Poll: 有符号整数表示连续信息间的最大间隔 Precision: 有符号整数表示本地时钟精确度 Root Delay: 有符号固定点序号表示主要参考源的总延迟, 很短时间内的位 15 到 16 间的分段点 Root Dispersion: 无符号固定点序号表示相对于主要参考源的正常差错, 很短时间内的位 15 到 16 间的分段点 Reference Identifier: 识别特殊参考源 Originate Timestamp: 这是向服务器请求分离客户机的时间, 采用 64 位时标格式 Receive Timestamp: 这是向服务器请求到达客户机的时间, 采用 64 位时标格式 Transmit Timestamp: 这是向客户机答复分离服务器的时间, 采用 64 位时标格式

34 Authenticator(Optional): 当实现了 NTP 认证模式时, 主要标识符和信息数字域就包括已定义的信息认证代码 (MAC) 信息 由于 NTP 协议中涉及到比较多的时间相关的操作, 从实用性而起见, 在本实验中, 仅要求实现 NTP 协议客户端部分的网络通信模块, 也就是构造 NTP 协议字段进行发送和接收, 最后与时间相关的操作不需进行处理 NTP 协议是作为 OSI 参考模型的高层协议比较适合采用 UDP 传输协议进行数据传输, 专用端口号为 123 在实验中, 以国家授时中心服务器 (IP 地址为 ) 作为 NTP( 网络时间 ) 服务器 3. 实验步骤 (1) 画出流程图简易 NTP 客户端的实现流程图如图 6.11 所示 (2) 编写程序 图 6.11 NTP 客户端的实现流程 NTP 协议的客户端所需要的宏定义和数据结构如下所示 : /* ntp.c */ ( 省略头文件部分 ) #define NTP_PORT 123 /*NTP 专用端口号字符串 */ #define TIME_PORT 37 /* TIME/UDP 端口号 */ #define NTP_SERVER_IP " " /* 国家授时中心 IP*/ #define NTP_PORT_STR "123" /*NTP 专用端口号字符串 */ #define NTPV1 "NTP/V1" /* 协议及其版本号 */ #define NTPV2 "NTP/V2" #define NTPV3 "NTP/V3" #define NTPV4 "NTP/V4"

35 #define TIME "TIME/UDP" #define NTP_PCK_LEN 48 #define LI 0 #define VN 3 #define MODE 3 #define STRATUM 0 #define POLL 4 #define PREC -6 #define JAN_1970 0x83aa7e80 /* 从 1900 年到 1970 年之间的时间秒数 */ #define NTPFRAC(x) (4294 * (x) + ((1981 * (x)) >> 11)) #define USEC(x) (((x) >> 12) * ((((x) >> 10) ) >> 16)) typedef struct _ntp_time unsigned int coarse; unsigned int fine; ntp_time; struct ntp_packet unsigned char leap_ver_mode; unsigned char startum; char poll; char precision; int root_delay; int root_dispersion; int reference_identifier; ntp_time reference_timestamp; ntp_time originage_timestamp; ntp_time receive_timestamp; ntp_time transmit_timestamp; ; char protocol[32]; 使用 construct_packet() 函数构造 NTP 协议包, 以发送到 NTP 服务器 /* 构建 NTP 协议包 */

36 int construct_packet(char *packet) char version = 1; long tmp_wrd; int port; time_t timer; strcpy(protocol, NTPV3); /* 判断协议版本 */ if(!strcmp(protocol, NTPV1)!strcmp(protocol, NTPV2)!strcmp(protocol, NTPV3)!strcmp(protocol, NTPV4)) memset(packet, 0, NTP_PCK_LEN); port = NTP_PORT; /* 设置 16 字节的包头 */ version = protocol[5] - 0x30; tmp_wrd = htonl((li << 30) (version << 27) (MODE << 24) (STRATUM << 16) (POLL << 8) (PREC & 0xff)); memcpy(packet, &tmp_wrd, sizeof(tmp_wrd)); /* 设置 Root Delay Root Dispersion 和 Reference Indentifier */ tmp_wrd = htonl(1<<16); memcpy(&packet[4], &tmp_wrd, sizeof(tmp_wrd)); memcpy(&packet[8], &tmp_wrd, sizeof(tmp_wrd)); /* 设置 Timestamp 部分 */ time(&timer); /* 设置 Transmit Timestamp coarse*/ tmp_wrd = htonl(jan_ (long)timer); memcpy(&packet[40], &tmp_wrd, sizeof(tmp_wrd)); /* 设置 Transmit Timestamp fine*/ tmp_wrd = htonl((long)ntpfrac(timer)); memcpy(&packet[44], &tmp_wrd, sizeof(tmp_wrd)); return NTP_PCK_LEN; else if (!strcmp(protocol, TIME))/* "TIME/UDP" */ port = TIME_PORT; memset(packet, 0, 4); return 4;

37 return 0; 通过网络从 NTP 服务器获取 NTP 时间, 代码如下所示 : int get_ntp_time(int sk, struct addrinfo *addr, struct ntp_packet *ret_time) fd_set pending_data; struct timeval block_time; char data[ntp_pck_len * 8]; int packet_len, data_len = addr->ai_addrlen, count = 0, result, i, re; if (!(packet_len = construct_packet(data))) return 0; /* 客户端给服务器端发送 NTP 协议数据包 */ if ((result = sendto(sk, data, packet_len, 0, addr->ai_addr, data_len)) < 0) perror("sendto"); return 0; 0) /* 调用 select() 函数, 并设定超时时间为 1s*/ FD_ZERO(&pending_data); FD_SET(sk, &pending_data); block_time.tv_sec=10; block_time.tv_usec=0; if (select(sk + 1, &pending_data, NULL, NULL, &block_time) > 0) /* 接收服务器端的信息 */ if ((count = recvfrom(sk, data, NTP_PCK_LEN * 8, 0, addr->ai_addr, &data_len)) < perror("recvfrom");

38 return 0; if (protocol == TIME) memcpy(&ret_time->transmit_timestamp, data, 4); return 1; else if (count < NTP_PCK_LEN) return 0; /* 设置接收 NTP 包的数据结构 */ ret_time->leap_ver_mode = ntohl(data[0]); ret_time->startum = ntohl(data[1]); ret_time->poll = ntohl(data[2]); ret_time->precision = ntohl(data[3]); ret_time->root_delay = ntohl(*(int*)&(data[4])); ret_time->root_dispersion = ntohl(*(int*)&(data[8])); ret_time->reference_identifier = ntohl(*(int*)&(data[12])); ret_time->reference_timestamp.coarse = ntohl(*(int*)&(data[16])); ret_time->reference_timestamp.fine = ntohl(*(int*)&(data[20])); ret_time->originage_timestamp.coarse = ntohl(*(int*)&(data[24])); ret_time->originage_timestamp.fine = ntohl(*(int*)&(data[28])); ret_time->receive_timestamp.coarse = ntohl(*(int*)&(data[32])); ret_time->receive_timestamp.fine =ntohl(*(int*)&(data[36])); ret_time->transmit_timestamp.coarse = ntohl(*(int*)&(data[40])); ret_time->transmit_timestamp.fine = ntohl(*(int*)&(data[44])); return 1; /* end of if select */ return 0;

39 使用 set_local_time() 函数, 根据 NTP 数据包信息更新本地的当前时间 int set_local_time(struct ntp_packet * pnew_time_packet) struct timeval tv; tv.tv_sec = pnew_time_packet->transmit_timestamp.coarse - JAN_1970; tv.tv_usec = USEC(pnew_time_packet->transmit_timestamp.fine); return settimeofday(&tv, NULL); 主函数如下所示 : int main() int sockfd, rc; struct addrinfo hints, *res = NULL; struct ntp_packet new_time_packet; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; /* 调用 getaddrinfo() 函数, 获取地址信息 */ rc = getaddrinfo(ntp_server_ip, NTP_PORT_STR, &hints, &res); if (rc!= 0) perror("getaddrinfo"); return 1; /* 创建套接字 */ sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (sockfd <0 ) perror("socket"); return 1; /* 调用取得 NTP 时间的函数 */ if (get_ntp_time(sockfd, res, &new_time_packet))

40 /* 调整本地时间 */ if (!set_local_time(&new_time_packet)) printf("ntp client success!\n"); close(sockfd); return 0; 为了更好地观察程序的效果, 先用 date 命令修改一下系统时间, 再运行实例程序 运行完了之后再 查看系统时间, 可以发现已经恢复准确的系统时间了 具体运行结果如下所示 $ date -s " :00:00" 2001 年 01 月 01 日星期一 01:00:00 EST $ date 2001 年 01 月 01 日星期一 01:00:00 EST $./ntp NTP client success! $ date 能够显示当前准确的日期和时间了! 本章小结 本章首先概括地讲解了 OSI 分层结构以及 TCP/IP 协议各层的主要功能, 介绍了常见的 TCP/IP 协议族, 并且重点讲解了网络编程中需要用到的 TCP 和 UDP 协议, 为嵌入式 Linux 的网络编程打下良好的基础 接着本章介绍了 socket 的定义及其类型, 并逐个介绍常见的 socket 相关的基本函数, 包括地址处理函数 数据存储转换函数等, 这些函数都是最为常用的函数, 要在理解概念的基础上熟练掌握 接下来介绍的是网络编程中的基本函数, 这也是最为常见的几个函数, 这里要注意 TCP 和 UDP 在处理过程中的不同 同时, 本章还介绍了较为高级的网络编程, 包括调用 fcntl() 和 select() 函数, 这两个函数在前面的章节中都已经讲解过, 但在本章中有特殊的用途 最后, 本章以 ping 程序为例, 讲解了常见协议的实现过程, 读者可以看到一个成熟的协议是如何实现的

41 本章的实验安排了实现一个比较简单但完整的 NTP 客户端程序, 主要实现了其中数据收发的主要功能, 以及时间同步调整的功能 本章讲解了嵌入式 Linux 网络开发的相关 API 函数 网络开发几乎已成为当今嵌入式 Linux 应用开发必不可少的一部分, 因此, 希望读者能够切实掌握 本章首先介绍了 TCP/IP 层次模型的基本知识, 并介绍了其中的重要协议, 这些都是非常必要的基础知识 接下来, 介绍了网络基础编程的相关 API 函数和几个高级网络编程议题, 并介绍了常见的开发流程, 希望读者能够认真学习这部分的内容, 并通过实践, 切实掌握 再接下来, 详细讲解了两个比较完整的综合实例 :Web 服务器和 NTP 协议的客户端 这两个实例在 Linux 系统都是很常用的软件, 小型 Web 服务器在嵌入式 Linux 开发中应用非常广泛, 希望读者认真学习网络应用实例 思考与练习 1. 分别用多线程和多路复用实现网络聊天程序 2. 实现一个小型模拟的路由器, 就是接收从某个 IP 地址的连接请求, 再把该请求转发到另一个 IP 地址的主机上去 3. 使用多线程来设计实现 Web 服务器 资源分享 : 1 华清远见精品图书专区 : 2 华清远见视频学习基地 : 3 华清远见近期免费活动公告 : 联系我们 : 免费电话 : , 咨询邮件 :einfo@farsight.com.cn 华清远见集团官网 :

42 华清远见企业学院 : 华清远见 3G 学院 :