C/S通信过程
程序流程图
状态转换图
服务器调用socket()、bind()、listen()
完成初始化后,调用accept()
阻塞等待,处于监听端口的状态,客户端调用socket()
初始化后,调用connect()
发出SYN
段并阻塞等待服务器应答,服务器应答一个SYN-ACK
段,客户端收到后从connect()
返回,同时应答一个ACK
段,服务器收到后从accept()
返回。
数据传输的过程:
建立连接后,TCP协议提供全双工的通信服务,但是一般的客户端/服务器程序的流程是由客户端主动发起请求,服务器被动处理请求,一问一答的方式。因此,服务器从accept()
返回后立刻调用read()
,读socket
就像读管道一样,如果没有数据到达就阻塞等待,这时客户端调用write()发送请求给服务器,服务器收到后从read()
返回,对客户端的请求进行处理,在此期间客户端调用read()
阻塞等待服务器的应答,服务器调用write()
将处理结果发回给客户端,再次调用read()
阻塞等待下一条请求,客户端收到后从read()
返回,发送下一条请求,如此循环下去。
如果客户端没有更多的请求了,就调用close()
关闭连接,就像写端关闭的管道一样,服务器的read()
返回0
,这样服务器就知道客户端关闭了连接,也调用close()
关闭连接。注意,任何一方调用close()
后,连接的两个传输方向都关闭,不能再发送数据了。如果一方调用shutdown()
则连接处于半关闭状态,仍可接收对方发来的数据。
在学习socket API
时要注意应用程序和TCP协议层是如何交互的: 应用程序调用某个socket
函数时TCP协议层完成什么动作,比如调用connect()
会发出SYN
段 应用程序如何知道TCP协议层的状态变化,比如从某个阻塞的socket
函数返回就表明TCP协议收到了某些段,再比如read()
返回0
就表明收到了FIN
段
补充一下,其实TCP 共有11
种状态,上图没有出现的CLOSING
状态,当双方同时关闭连接时会出现此状态,替换掉FIN_WAIT2
状态。
查看端口状态:netstat -pan | grep 端口号
socket函数说明
1. socket 函数
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
/*
作用:创建一个套接字用于通信
参数:
domain:
AF_INET 这是大多数用来产生socket的协议,使用TCP或UDP来传输,用IPv4的地址
AF_INET6 与上面类似,不过是来用IPv6的地址
AF_UNIX 本地协议,使用在Unix和Linux系统上,一般都是当客户端和服务器在同一台及其上的时候使用
type:
SOCK_STREAM 这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型,这个socket是使用TCP来进行传输。
SOCK_DGRAM 这个协议是无连接的、固定长度的传输调用。该协议是不可靠的,使用UDP来进行它的连接。
SOCK_SEQPACKET该协议是双线路的、可靠的连接,发送固定长度的数据包进行传输。必须把这个包完整的接受才能进行读取。
SOCK_RAW socket类型提供单一的网络访问,这个socket类型使用ICMP公共协议。(ping、traceroute使用该协议)
SOCK_RDM 这个类型是很少使用的,在大部分的操作系统上没有实现,它是提供给数据链路层使用,不保证数据包的顺序
protocol:
传0 表示使用默认协议。
返回值:
成功:返回指向新创建的socket的文件描述符,失败:返回-1,设置errno
*/
socket()
打开一个网络通讯端口,如果成功的话,就像open()
一样返回一个文件描述符,应用程序可以像读写文件一样用read/write在网络上收发数据,如果socket()
调用出错则返回-1
。对于IPv4
,domain
参数指定为AF_INET
。对于TCP协议,type
参数指定为SOCK_STREAM
,表示面向流的传输协议。如果是UDP协议,则type
参数指定为SOCK_DGRAM
,表示面向数据报的传输协议。protocol
参数的介绍从略,指定为0即可。
2. bind
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd:
socket文件描述符
addr:
构造出IP地址加端口号
addrlen:
sizeof(addr)长度
返回值:
成功返回0,失败返回-1, 设置errno
服务器程序所监听的网络地址和端口号通常是固定不变的,客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接,因此服务器需要调用bind
绑定一个固定的网络地址和端口号。
bind()
的作用是将参数sockfd
和addr
绑定在一起,使sockfd
这个用于网络通讯的文件描述符监听addr
所描述的地址和端口号。struct sockaddr *
是一个通用指针类型,addr
参数实际上可以接受多种协议的sockaddr
结构体,而它们的长度各不相同,所以需要第三个参数addrlen
指定结构体的长度。如:
struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr)); // 将servaddr清零
servaddr.sin_family = AF_INET; // 使用IPv4
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 绑定地址
servaddr.sin_port = htons(9999); // 绑定端口
首先将整个结构体清零,然后设置地址类型为AF_INET
,网络地址为INADDR_ANY
,这个宏表示本地的任意IP地址,因为服务器可能有多个网卡,每个网卡也可能绑定多个IP地址,这样设置可以在所有的IP地址上监听,直到与某个客户端建立了连接时才确定下来到底用哪个IP地址,端口号为9999
3. listen 函数
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int listen(int sockfd, int backlog);
sockfd:
socket文件描述符
backlog:
排队建立3次握手队列和刚刚建立3次握手队列的链接总数
查看系统默认backlog
cat /proc/sys/net/ipv4/tcp_max_syn_backlog
典型的服务器程序可以同时服务于多个客户端,当有客户端发起连接时,服务器调用的accept()
返回并接受这个连接,如果有大量的客户端发起连接而服务器来不及处理,尚未accept
的客户端就处于连接等待状态,listen()
声明sockfd
处于监听状态,并且最多允许有backlog
个客户端处于连接待状态,如果接收到更多的连接请求就忽略。listen()
成功返回0
,失败返回-1
。
4. accept 函数
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
sockdf:
socket文件描述符
addr:
传出参数,返回链接客户端地址信息,含IP地址和端口号
addrlen:
传入传出参数(值-结果),传入sizeof(addr)大小,函数返回时返回真正接收到地址结构体的大小
返回值:
成功返回一个新的socket文件描述符,用于和客户端通信,失败返回-1,设置errno
三方握手完成后,服务器调用accept()
接受连接,如果服务器调用accept()
时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来。addr
是一个传出参数,accept()
返回时传出客户端的地址和端口号。addrlen
参数是一个传入传出参数(value-result argument)
,传入的是调用者提供的缓冲区addr
的长度以避免缓冲区溢出问题,传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区)。如果给addr
参数传NULL
,表示不关心客户端的地址。
我们的服务器程序结构是这样的:
while (1) {
cliaddr_len = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
n = read(connfd, buf, MAXLINE);
......
close(connfd);
}
整个是一个while
死循环,每次循环处理一个客户端连接。由于cliaddr_len
是传入传出参数,每次调用accept()
之前应该重新赋初值。accept()的参数listenfd是先前的监听文件描述符,而accept()
的返回值是另外一个文件描述符connfd,之后与客户端之间就通过这个connfd
通讯,最后关闭connfd
断开连接,而不关闭listenfd
,再次回到循环开头listenfd
仍然用作accept
的参数。accept()
成功返回一个文件描述符用来和客户端进行通信,出错返回-1
。
5. connect 函数
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockdf:
socket文件描述符
addr:
传入参数,指定服务器端地址信息,含IP地址和端口号
addrlen:
传入参数,传入sizeof(addr)大小
返回值:
成功返回0,失败返回-1,设置errno
客户端需要调用connect()
连接服务器,connect
和bind
的参数形式一致,区别在于bind
的参数是自己的地址,而connect
的参数是对方的地址。connect()
成功返回0
,出错返回-1
。
对以上函数进行封装
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
void perr_exit(const char *s)
{
perror(s);
exit(-1);
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
int n;
again:
if ((n = accept(fd, sa, salenptr)) < 0) {
if ((errno == ECONNABORTED) || (errno == EINTR))
goto again;
else
perr_exit("accept error");
}
return n;
}
int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = bind(fd, sa, salen)) < 0)
perr_exit("bind error");
return n;
}
int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = connect(fd, sa, salen)) < 0)
perr_exit("connect error");
return n;
}
int Listen(int fd, int backlog)
{
int n;
if ((n = listen(fd, backlog)) < 0)
perr_exit("listen error");
return n;
}
int Socket(int family, int type, int protocol)
{
int n;
if ((n = socket(family, type, protocol)) < 0)
perr_exit("socket error");
return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = read(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = write(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
int Close(int fd)
{
int n;
if ((n = close(fd)) == -1)
perr_exit("close error");
return n;
}
/*参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n)
{
size_t nleft; //usigned int 剩余未读取的字节数
ssize_t nread; //int 实际读到的字节数
char *ptr;
ptr = vptr;
nleft = n;
while (nleft > 0) {
if ((nread = read(fd, ptr, nleft)) < 0) {
if (errno == EINTR)
nread = 0;
else
return -1;
} else if (nread == 0)
break;
nleft -= nread;
ptr += nread;
}
return n - nleft;
}
ssize_t Writen(int fd, const void *vptr, size_t n)
{
size_t nleft;
ssize_t nwritten;
const char *ptr;
ptr = vptr;
nleft = n;
while (nleft > 0) {
if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
if (nwritten < 0 && errno == EINTR)
nwritten = 0;
else
return -1;
}
nleft -= nwritten;
ptr += nwritten;
}
return n;
}
static ssize_t my_read(int fd, char *ptr)
{
static int read_cnt;
static char *read_ptr;
static char read_buf[100];
if (read_cnt <= 0) {
again:
if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
if (errno == EINTR)
goto again;
return -1;
} else if (read_cnt == 0)
return 0;
read_ptr = read_buf;
}
read_cnt--;
*ptr = *read_ptr++;
return 1;
}
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
ssize_t n, rc;
char c, *ptr;
ptr = vptr;
for (n = 1; n < maxlen; n++) {
if ( (rc = my_read(fd, &c)) == 1) {
*ptr++ = c;
if (c == '\n')
break;
} else if (rc == 0) {
*ptr = 0;
return n - 1;
} else
return -1;
}
*ptr = 0;
return n;
}