在基于 TCP 的通信连接请求过程有三次握手,其过程如下所示:
第一次握手:客户端发送syn包(seq=x)到服务器,并进入SYN_SEND状态,等待服务器确认;
第二次握手:服务器收到syn包,必须确认客户的SYN(ack=x+1),同时自己也发送一个SYN包(seq=y),即SYN+ACK包,此时服务器进入SYN_RECV状态;
第三次握手:客户端收到服务器的SYN+ACK包,向服务器发送确认包ACK(ack=y+1),此包发送完毕,客户端和服务器进入ESTABLISHED状态,完成三次握手。
数据传输过程如下图所示:
关闭通信时,需要四次挥手过程,如下所示:
第一次挥手:主动关闭方发送一个FIN,用来关闭主动方到被动关闭方的数据传送,也就是主动关闭方告诉被动关闭方:我已经不会再给你发数据了(当然,在fin包之前发送出去的数据,如果没有收到对应的ack确认报文,主动关闭方依然会重发这些数据),但此时主动关闭方还可以接受数据。
第二次挥手:被动关闭方收到FIN包后,发送一个ACK给对方,确认序号为收到序号+1(与SYN相同,一个FIN占用一个序号)。
第三次挥手:被动关闭方发送一个FIN,用来关闭被动关闭方到主动关闭方的数据传送,也就是告诉主动关闭方,我的数据也发送完了,不会再给你发数据了。
第四次挥手:主动关闭方收到FIN后,发送一个ACK给被动关闭方,确认序号为收到序号+1,至此,完成四次挥手。
下面是基于套接字的编程:
客户端:
/* 基于TCP协议面向连接的客户端进程 */
#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <sys/socket.h>
#include "connectre.h"
/* 地址的最长大小 */
#define MAXADDRLEN 256
/* 缓冲区大小 */
#define BUFLEN 128
/* 外部函数定义,该函数功能是实现套接字连接 */
//extern int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t len);
/* 打印客户端所接收的数据信息 */
void print_uptime(int sockfd);
int main(int argc, char *argv[])
{
struct addrinfo *ailist, *aip;
struct addrinfo hint;
int sockfd, err;
if(argc != 2)
err_quit("usage: %s hostname", argv[0]);
/* 初始化addrinfo结构变量hint */
hint.ai_flags = 0;
hint.ai_family = 0;
hint.ai_socktype = SOCK_STREAM;/* 有序、可靠、双向的面向连接字节流 */
hint.ai_protocol = 0;/* 使用默认协议 */
hint.ai_addrlen = 0;
hint.ai_canonname = NULL;
hint.ai_addr = NULL;
hint.ai_next = NULL;/* 表示只有一个addrinfo链表结构 */
/* 将主机名和服务名映射到一个地址 */
if((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0)
err_quit("getaddrinfo error: %s", gai_strerror(err));
/* 对每个结构addrinfo链表进行以下操作,其实这里只有一个addrinfo结构 */
for(aip = ailist; aip != NULL; aip = aip->ai_next)
{
/* 其中这里才是客户端套接字编程 */
/* 步骤1:创建套接字描述符 */
if((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)
err =errno;
/* 步骤2:connect请求连接 */
if(connect_retry(sockfd, aip->ai_addr, aip->ai_addrlen) < 0)
err = errno;/* 请求连接失败 */
else /* 请求连接成功,则准备传输数据 */
{
/* 接收来自服务器进程的消息,并打印输出 */
print_uptime(sockfd);
exit(0);/* 正常退出 */
}
}
/* 异常退出 */
fprintf(stderr, "can't connect to %s: %s\n",argv[1], strerror(err));
exit(1);
}
void print_uptime(int sockfd)
{
int n;
char buf[BUFLEN];
/* 接收数据 */
while((n = recv(sockfd, buf, BUFLEN, 0)) > 0)
/* 把接收到的数据输出到终端 */
write(STDOUT_FILENO, buf, n);
if(n < 0)
err_sys("recv error");
}
这个程序连接服务器,读取服务器发送过来的字符串并将其打印到标准输出。
服务器端:
/* 基于TCP的面向连接的服务器进程 */
#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include "serverin.h"
/* 定义等待请求队列的最大数 */
#define QLEN 10
#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX 256
#endif
/* 外部定义的服务器初始化套接字端点 */
//extern int initserver(int type, const struct sockaddr *addr, socklen_t len, int qlen);
/* 服务器接收连接请求,并向请求客户端发送数据 */
void server(int sockfd);
int main(int argc, char *argv[])
{
struct addrinfo *ailist, *aip;
struct addrinfo hint;
int sockfd, err, n;
char *host;
if(argc != 1)
err_quit("usage: %s", argv[0]);
#ifdef _SC_HOST_NAME_MAX
n = sysconf(_SC_HOST_NAME_MAX);
if(n < 0) /* best guess */
#endif
n = HOST_NAME_MAX;
host = (char *)malloc(n);
if(NULL == host)
err_sys("malloc error");
/* 获取客户端的主机名 */
if(gethostname(host, n) < 0)
err_sys("gethostname error");
daemonize("ruptimed");
/* 初始化addrinfo结构变量hint */
hint.ai_flags = AI_CANONNAME;/* 需要一个规范名 */
hint.ai_family = 0;
hint.ai_socktype = SOCK_STREAM;/* 有序、可靠、双向的面向连接字节流 */
hint.ai_protocol = 0;/* 使用默认协议 */
hint.ai_addrlen = 0;
hint.ai_canonname = NULL;
hint.ai_addr = NULL;
hint.ai_next = NULL;/* 表示只有一个addrinfo链表结构 */
/* 将主机名和服务名映射到一个地址 */
if((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0)
{
syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err));
exit(1);
}
/* 对每个结构addrinfo链表进行以下操作,其实这里只有一个addrinfo结构 */
for(aip = ailist; aip != NULL; aip = aip->ai_next)
{
/* 其中这里才是服务进程套接字编程 */
if((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0)
{
server(sockfd);
exit(0);
}
}
exit(1);
}
void server(int sockfd)
{
int clfd, status;
pid_t pid;
while(1)
{
clfd = accept(sockfd, NULL, NULL);
if(clfd < 0)
{
syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
exit(1);
}
if((pid = fork()) < 0)
{
syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
exit(1);
}
else if(pid == 0)
{
if(dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO || dup2(clfd, STDERR_FILENO) != STDERR_FILENO)
{
syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
exit(1);
}
close(clfd);
execl("/usr/bin/uptime", "uptime", (char *)0);/* 执行 uptime指令 */
syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
}
else
{
close(clfd);
waitpid(pid, &status, 0);
}
}
}
为了找到地址,服务器程序需要调用gethostname获得其运行时的主机名字,并查看远程uptime服务地址。
其中客户端和服务器端包含的函数头文件内容如下:
服务器serverin.h:
/* 服务器初始化套接字端点 */
#ifndef SERVERIN_H
#define SERVERIN_H
#include "apue.h"
#include <sys/socket.h>
#include <errno.h>
#include <syslog.h>
#include <fcntl.h>
#include <sys/resource.h>
/* type 套接字类型, qlen是监听队列的最大个数 */
int initserver(int type, const struct sockaddr *addr, socklen_t len, int qlen)
{
int fd;
int err = 0;
/* 采用type类型默认的协议 */
if((fd = socket(addr->sa_family, type, 0)) < 0)
return -1;/* 出错返回-1*/
int reuse = 1;
if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) < 0)
{
err = errno;
goto errout;
}
/* 将地址绑定到一个套接字 */
if(bind(fd, addr, len) < 0)
{
err =errno;
goto errout;/* 跳转到出错输出语句 */
}
/* 若套接字类型type是面向连接(SOCK_STREAM, SOCK_SEQPACKET)的,则执行以下语句 */
if(type == SOCK_STREAM || type == SOCK_SEQPACKET)
{
/* 监听套接字连接队列 */
if(listen(fd, qlen) < 0)
{
err = errno;
goto errout;
}
}
return (fd);
errout:
close(fd);
errno = err;
return -1;
}
/* 初始化守护进程 */
void daemonize(const char *cmd)
{
int i, fd0, fd1, fd2;
pid_t pid;
struct rlimit rl;
struct sigaction sa;
umask(0);
if(getrlimit(RLIMIT_NOFILE, &rl) < 0)
err_quit("%s: can't get file limit", cmd);
if((pid =fork()) < 0)
err_quit("%s: can't fork", cmd);
else if(pid != 0)
exit(0);
setsid();
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if(sigaction(SIGHUP, &sa, NULL) < 0)
err_quit("%s: can't ignore SIGHUP");
if((pid =fork()) < 0)
err_quit("%s: can't fork", cmd);
else if(pid != 0)
exit(0);
if(chdir("/") < 0)
err_quit("%s: can't change directory to /");
if(rl.rlim_max == RLIM_INFINITY)
rl.rlim_max = 1024;
for(i = 0; i < (int)rl.rlim_max; i++)
close(i);
fd0 = open("/dev/null", O_RDWR);
fd1 = dup(0);
fd2 = dup(0);
openlog(cmd, LOG_CONS, LOG_DAEMON);
if(fd0 != 0 || fd1 != 1 || fd2 != 2)
{
syslog(LOG_ERR, "unexpectrd file descriptors %d %d %d", fd0, fd1, fd2);
exit(1);
}
}
#endif
客户端connectre.h:
/* 建立连接 */
/* 该函数的功能和connect相同,当connect连接出错时,这里支持重试连接 */
#ifndef CONNECTRE_H
#define CONNECTRE_H
#include "apue.h"
#include <sys/socket.h>
#define MAXSLEEP 128
int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t len)
{
int nsec;
/* Try to connect with exponential backoff */
for(nsec = 1; nsec <= MAXSLEEP; nsec <<= 1)
{
if(connect(sockfd, addr, len) == 0)
return 0;
/* Delay before trying again */
if(nsec <= MAXSLEEP/2)
sleep(nsec);
}
return -1;
}
#endif
输出结果:
/*
*在输出结果之前一些准备工作,在文件 /etc/servers 添加 ruptime 4000/tcp
*/
[root@chenchen 16]# ./server
[root@chenchen 16]# ./client chenchen //chenchen是主机名,可以通过uname–n查看
15:30:47 up 14 min, 2 users, load average: 0.00, 0.12, 0.16
[root@chenchen 16]#
16.6 套接字选项
套接字机制有两种套接字选项接口来控制套接字行为:一种接口用来设置选项;另一种接口允许查询一个选项的状态;可以设置或获取下面三种选项:
(1)通用选项,工作在所有套接字类型上;
(2)在套接字层次管理的选项,但依赖于下层协议的支持;
(3)特定于某种协议的选项,为每个协议所独有;
若要对套接字选项进行设置时,可以调用函数 setsockopt 进行设置,调用函数 getsockopt 获取套接字选项的当前值,其定义如下:
/* 套接字选项 */
/*
* 函数功能:设置套接字选项;
* 返回值:若成功返回0,若出错返回-1;
* 函数原型:
*/
#include <sys/socket.h>
int setsockopt(int sockfd, int level, int option, const void *val, socklen_t len);
/*
* 说明:
* level表示选项应用的协议,若选项是通用套接字选项,则level设置为SOL_SOCKET,否则设置为控制这个协议的协议号;
* val根据选项 option 不同指向一个数据结构或者一个整数,若整数非零,则启用选项,若整数为零,则禁止选项;
* len指定了val指向的对象的大小;
*/
/*
* 函数功能:获取套接字选项的当前值;
* 返回值:若成功返回0,若出错返回-1;
* 函数原型:
*/
#include <sys/socket.h>
int getsockopt(int sockfd, int level, int option, void *val, socklen_t *lenp);
/*
* 说明:
* lenp是指向整数的指针,在调用该函数之前,设置该参数为复制选项缓冲区的大小;
* 其他参数和setsockopt函数类型;
*/
16.7 带外数据
带外数据是一些通信协议所支持的可选特征,允许更高优先级的数据比普通数据优先传输。即使传输队列已经有数据,带外数据先行传输。TCP 支持带外数据,但是 UDP 并不支持。
TCP 将带外数据称为紧急数据,但是 紧急数据 并不是 带外数据。TCP 仅支持一个字节的紧急数据,但是允许紧急数据在普通数据传输机制数据流之外传输。为了产生紧急数据,在三个 send 函数中任何一个指定标志 MSG_OOB。如果带 MSG_OOB 标志传输字节超过一个时,最后一个字节被看做紧急数据字节。
TCP 支持紧急标记:在普通数据流中紧急数据所在的位置,如果采用套接字选项 SO_OOBINLINE,那么可以在普通数据中接收紧急数据。判断是否接收到紧急标记,可以使用函数 sockatmark,其定义如下:
/*
* 函数功能:判断是否接收到紧急标记;
* 返回值:若在标记处则返回0,若没有在标记处则返回0,若出错返回-1;
* 函数原型:
*/
#include <sys/socket.h>
int sockatmark(int sockfd);
/*
* 说明:
* 当下一个要读的字节在紧急标记所标识的位置,则该函数返回1;
*/
当带外数据出现在套接字读取队列时,select函数会返回一个文件描述符,并且拥有一个异常状态挂起。可以在普通数据流上接收紧急数据,或者在某个recv函数中采用MSG_OOB 标志在其他队列数据之前接收紧急数据。TCP 队列仅有一个字节的紧急数据,如果在接收当前的紧急数据字节之前又有新的紧急数据到来,那么当前的字节会被丢弃。