北京网站建设开发,房地产网站建设策划书,做个普通的网站多少钱,建设平台型网站多少钱Socket编程 这一个课程的笔记 相关文章 协议 Socket编程 高并发服务器实现 线程池 网络套接字
socket: #xff08;电源#xff09;插座#xff08;电器上的#xff09;插口#xff0c;插孔#xff0c;管座
在通信过程中, 套接字是成对存在的, 一个客户端的套接字, 一个…Socket编程 这一个课程的笔记 相关文章 协议 Socket编程 高并发服务器实现 线程池 网络套接字
socket: 电源插座电器上的插口插孔管座
在通信过程中, 套接字是成对存在的, 一个客户端的套接字, 一个服务器的套接字 **在网络通信中套接字一定是成对出现的。**一端的发送缓冲区对应对端的接收缓冲区。我们使用同一个文件描述符索发送缓冲区和接收缓冲区。 为TCP/IP协议设计的应用层编程接口称为socket API。 网络字节序
我们已经知道内存中的多字节数据相对于内存地址有大端和小端之分磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分。网络数据流同样有大端小端之分那么如何定义网络数据流的地址呢发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出接收主机把从网络上接到的字节依次保存在接收缓冲区中也是按内存地址从低到高的顺序保存因此网络数据流的地址应这样规定先发出的数据是低地址后发出的数据是高地址。 小段法: 高位的数据在高地址, 低位的数据在低地址(计算机本地使用) 大端法: 高位在地地址, 低位在高地址(网络使用) TCP/IP协议规定网络数据流应采用大端字节序即低地址高字节。例如上一节的UDP段格式地址0-1是16位的源端口号如果这个端口号是10000x3e8则地址0是0x03地址1是0xe8也就是先发0x03再发0xe8这16位在发送主机的缓冲区中也应该是低地址存0x03高地址存0xe8。但是如果发送主机是小端字节序的这16位被解释成0xe803而不是1000。因此发送主机把1000填到发送缓冲区之前需要做字节序的转换。同样地接收主机如果是小端字节序的接到16位的源端口号也要做字节序的转换。如果主机是大端字节序的发送和接收都不需要做转换。同理32位的IP地址也要考虑网络字节序和主机字节序的问题。
为使网络程序具有可移植性使同样的C代码在大端和小端计算机上编译后都能正常运行可以调用以下库函数做网络字节序和主机字节序的转换。
#include arpa/inet.huint32_t htonl(uint32_t hostlong); //本地到网络, 主要是IP
uint16_t htons(uint16_t hostshort);//本地到网络, 这一个主要是端口
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);h表示hostn表示networkl表示32位长整数s表示16位短整数。 如果主机是小端字节序这些函数将参数做相应的大小端转换然后返回如果主机是大端字节序这些函数不做转换将参数原封不动地返回。 IP地址转换函数
#include arpa/inet.h
int inet_pton(int af, const char *src, void *dst);
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);支持IPv4和IPv6\ This function converts the character string src into a network address structure in the af address family, then copies the network address struc‐ture to dst. The af argument must be either AF_INET or AF_INET6. dst is written in network byte order. af : 使用的协议, 可以使用两个宏定义 AF_INET: IPV4 AF_INET6: IPV6 src: 源字符串 dst: 获取到的转换后的网络字节序的IP地址 返回值: 1成功, 0:这一个src不是一个有效的ip地址 网络套接字函数
socket模型创建流程图 sockaddr数据结构
strcut sockaddr 很多网络编程函数诞生早于IPv4协议那时候都使用的是sockaddr结构体,为了向前兼容现在sockaddr退化成了void *的作用传递一个地址给函数至于这个函数是sockaddr_in还是sockaddr_in6由地址族确定然后函数内部再强制类型转化为所需的地址类型。
可参看 man 7 ip 从左向右依次进化 sockaddr数据结构
struct sockaddr {sa_family_t sa_family; /* address family, AF_xxx */char sa_data[14]; /* 14 bytes of protocol address */};使用 sudo grep -r “struct sockaddr_in {” /usr 命令可查看到struct sockaddr_in结构体的定义。一般其默认的存储位置/usr/include/linux/in.h 文件中。 这一个struct sockaddr_in这一个是实际使用的参数, 使用的时候需要进行一个强制转换, 这是因为这一个函数设计的时间比较早, 为了兼容早期的程序 struct sockaddr_in {__kernel_sa_family_t sin_family; /* Address family 地址结构类型, 可以使用AF_INET表示ipv4 */__be16 sin_port; /* Port number 端口号 使用函数htons*/struct in_addr sin_addr; /* Internet address IP地址, 这一个需要使用inet_pton进行转换 , 这一个可以使用宏定义INADDR_ANY获取当前的有效的IP地址, 之后使用htonl转换一下*//* Pad to size of struct sockaddr. */unsigned char __pad[__SOCK_SIZE__ - sizeof(short int) -sizeof(unsigned short int) - sizeof(struct in_addr)];};struct in_addr { /* Internet address. */__be32 s_addr;};struct sockaddr_in6 {unsigned short int sin6_family; /* AF_INET6 */__be16 sin6_port; /* Transport layer port # */__be32 sin6_flowinfo; /* IPv6 flow information */struct in6_addr sin6_addr; /* IPv6 address */__u32 sin6_scope_id; /* scope id (new in RFC2553) */};struct in6_addr {union {__u8 u6_addr8[16];__be16 u6_addr16[8];__be32 u6_addr32[4];} in6_u;#define s6_addr in6_u.u6_addr8#define s6_addr16 in6_u.u6_addr16#define s6_addr32 in6_u.u6_addr32};#define UNIX_PATH_MAX 108struct sockaddr_un {__kernel_sa_family_t sun_family; /* AF_UNIX */char sun_path[UNIX_PATH_MAX]; /* pathname */};Pv4和IPv6的地址格式定义在netinet/in.h中IPv4地址用sockaddr_in结构体表示包括16位端口号和32位IP地址IPv6地址用sockaddr_in6结构体表示包括16位端口号、128位IP地址和一些控制字段。UNIX Domain Socket的地址格式定义在sys/un.h中用sock-addr_un结构体表示。各种socket地址结构体的开头都是相同的前16位表示整个结构体的长度并不是所有UNIX的实现都有长度字段如Linux就没有后16位表示地址类型。
IPv4、IPv6和Unix Domain Socket的地址类型分别定义为常数AF_INET、AF_INET6、AF_UNIX。这样只要取得某种sockaddr结构体的首地址不需要知道具体是哪种类型的sockaddr结构体就可以根据地址类型字段确定结构体中的内容。因此socket API可以接受各种类型的sockaddr结构体指针做参数例如bind、accept、connect等函数这些函数的参数应该设计成void *类型以便接受各种类型的指针但是sock API的实现早于ANSI C标准化那时还没有void *类型因此这些函数的参数都用struct sockaddr *类型表示在传递参数之前要强制类型转换一下例如
struct sockaddr_in servaddr;
bind(listen_fd, (struct sockaddr *)servaddr, sizeof(servaddr)); /* initialize servaddr */网络套接字函数
socket模型创建流程图 实际使用的时候客户有一个套接字, 和服务器的一个套接字进行通讯, 服务器还有一个套接字用于监听 这一个监听的客户端设置完成以后, 使用accept函数获取连接, 返回一个新的socket的描述符, 实际通信使用的是这一个新的socket描述符 socket创建一个套接字
#include sys/types.h /* See NOTES */#include sys/socket.hint socket(int domain, int type, int protocol);domain: AF_INET 这是大多数用来产生socket的协议使用TCP或UDP来传输用IPv4的地址 AF_INET6 与上面类似不过是来用IPv6的地址 AF_UNIX, AF_LOCAL本地协议使用在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。对于IPv4domain参数指定为AF_INET。对于TCP协议type参数指定为SOCK_STREAM表示面向流的传输协议。如果是UDP协议则type参数指定为SOCK_DGRAM表示面向数据报的传输协议。protocol参数的介绍从略指定为0即可。
bind绑定ip端口
#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地址加端口号, 这一个结构体实际使用的是sockaddr_in, 里面的协议要和socket一样, 实际传参的时候需要一个类型转换 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.sin_family AF_INET;
servaddr.sin_addr.s_addr htonl(INADDR_ANY);
servaddr.sin_port htons(6666);首先将整个结构体清零然后设置地址类型为AF_INET网络地址为INADDR_ANY这个宏表示本地的任意IP地址因为服务器可能有多个网卡每个网卡也可能绑定多个IP地址这样设置可以在所有的IP地址上监听直到与某个客户端建立了连接时才确定下来到底用哪个IP地址端口号为6666。
listen设置监听上限
#include sys/types.h /* See NOTES */
#include sys/socket.h
int listen(int sockfd, int backlog);sockfd: socket文件描述符 backlog: 排队建立3次握手队列和刚刚建立3次握手队列的链接数和, 这一个系统的默认最大值是128 查看系统默认backlog
cat /proc/sys/net/ipv4/tcp_max_syn_backlog
典型的服务器程序可以同时服务于多个客户端当有客户端发起连接时服务器调用的accept()返回并接受这个连接如果有大量的客户端发起连接而服务器来不及处理尚未accept的客户端就处于连接等待状态listen()声明sockfd处于监听状态并且最多允许有backlog个客户端处于连接待状态如果接收到更多的连接请求就忽略。listen()成功返回0失败返回-1。
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。
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。 之后就可以使用read和write函数进行读写, 进行数据的传递 read的错误: errno EINTR 这个被一个信号中断了, 需要再重新读取一次errno EAGIN 或 EWOULDBLOCK 以一个非阻塞的模式进行读取, 需要再一次读取errno ECONNRESET 连接被重置了需要close, 之后移除监听队列(这一个是服务器端三次握手只进行一般发生RET返回的情景) 如果不使用bind函数绑定客户端的ip和端口, 这一个会隐式绑定 端口复用 socket 网络编程——端口复用技术setsockoptlinux下多个进程监听同一个端口_linux端口复用怎么区分不同的客户端-CSDN博客 setsockopt函数的作用和说明-CSDN博客 在server的TCP连接没有完全断开之前不允许重新监听是不合理的。因为TCP连接没有完全断开指的是connfd127.0.0.1:6666没有完全断开而我们重新监听的是lis-tenfd0.0.0.0:6666虽然是占用同一个端口但IP地址不同connfd对应的是与某个客户端通讯的一个具体的IP地址而listenfd对应的是wildcard address。解决这个问题的方法是使用setsockopt()设置socket描述符的选项SO_REUSEADDR为1表示允许创建端口号相同但IP地址不同的多个socket描述符。
int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);optval : 1设置端口复用, 0:设置端口不复用 在server代码的socket()和bind()调用之间插入如下代码
int opt 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (void *)opt, sizeof(opt));重用本地地址, 这一个设置需要在bind之前 SO_REUSEADDR提供如下四个功能 允许启动一个监听服务器并捆绑其众所周知端口即使以前建立的将此端口用做他们的本地端口的连接仍存在。这通常是重启监听服务器时出现若不设置此选项则bind时将出错。允许在同一端口上启动同一服务器的多个实例只要每个实例捆绑一个不同的本地IP地址即可。对于TCP我们根本不可能启动捆绑相同IP地址和相同端口号的多个服务器。允许单个进程捆绑同一端口到多个套接口上只要每个捆绑指定不同的本地IP地址即可。这一般不用于TCP服务器。允许完全重复的捆绑当一个IP地址和端口绑定到某个套接口上时还允许此IP地址和端口捆绑到另一个套接口上。一般来说这个特性仅在支持多播的系统上才有而且只对UDP套接口而言TCP不支持多播。 SO_REUSEPORT有如下语义 此选项允许完全重复捆绑但仅在想捆绑相同IP地址和端口的套接口都指定了此套接口选项才行。如果被捆绑的IP地址是一个多播地址则SO_REUSEADDR和SO_REUSEPORT等效。 有关setsockopt可以设置的其它选项请参考UNP第7章。
实际的使用流程
server
socket: 获取一个socket用于监听
bind: 绑定一下IP地址和端口号
listen: 设置监听的上限
accept: 阻塞监听客户端连接
read: 读取信息 NAME recv, recvfrom, recvmsg - receive a message from a socket SYNOPSIS #include sys/types.h
#include sys/socket.h
ssize_t recv(int sockfd, void *buf, size_t len, int flags);这一个函数和read的区别只有flags参数的不同, 使用0的时候和read一样 write:发送信息 NAME send, sendto, sendmsg - send a message on a socket SYNOPSIS #include sys/types.h
#include sys/socket.h
ssize_t send(int sockfd, const void *buf, size_t len, int flags);close
client
socket
connect:创建数据
write: 写入数据
read: 读取数据
close
示例
服务器
#include ctype.h
#include stdio.h
#include stdlib.h
#include unistd.h
#include errno.h
#include sys/socket.h
#include sys/types.h
#include arpa/inet.h#define SERV_PORT 9078int main(void){int lfd 0, cfd;struct sockaddr_in serv_addr, clit_addr;socklen_t clit_addr_len;char buf[BUFSIZ];lfd socket(AF_INET, SOCK_STREAM, 0);if(lfd -1){perror(socket error\n);exit(0);}serv_addr.sin_family AF_INET; //使用IPV4serv_addr.sin_port htons(SERV_PORT); //设置端口serv_addr.sin_addr.s_addr htonl(INADDR_ANY);//设置检测本地的所有ipint ret bind(lfd, (struct sockaddr *)serv_addr, sizeof(serv_addr));if(ret ! 0){perror(bind error\n);exit(0);}ret listen(lfd, 128); //设置最大的处理个数if(ret ! 0){perror(listen error\n);exit(0);}clit_addr_len sizeof(clit_addr);cfd accept(lfd, (struct sockaddr *)clit_addr, clit_addr_len); //设置阻塞if(cfd -1){perror(sccept error\n);exit(1);}while(1){ret read(cfd, buf, sizeof(buf));if(ret 0){perror(read error\n);exit(1);}else if(ret 0){break;}write(STDOUT_FILENO , buf, ret);for(int i 0;iret;i){buf[i] toupper(buf[i]); //获取的数据转换为大写}write(cfd, buf, ret);}close(cfd);close(lfd);return 0;
}cfd accept(lfd, (struct sockaddr *)clit_addr, clit_addr_len);
if(cfd -1){perror(sccept error\n);exit(1);
}
printf(client ip: %s port %d\n, inet_ntop(AF_INET, clit_addr.sin_addr.s_addr, buf, sizeof(buf)), ntohs(clit_addr.sin_port));可以使用这一个获取连接的客户端的信息 客户端
#include stdio.h
#include stdlib.h
#include unistd.h
#include errno.h
#include sys/socket.h
#include sys/types.h
#include arpa/inet.h
int main(void){int cfd; cfd socket(AF_INET, SOCK_STREAM, 0);if(cfd -1){perror(socket error);exit(1);}struct sockaddr_in c_sock;int ip_addr;inet_pton(AF_INET, 127.0.0.1, ip_addr);//获取ip地址的二进制小端数据c_sock.sin_addr.s_addr ip_addr;c_sock.sin_port htons(9078);c_sock.sin_family AF_INET;int ret connect(cfd, (struct sockaddr *)c_sock, sizeof(c_sock));//连接if(ret -1){perror(connect error);exit(1);}char buf[1024];while(1){int len read(STDIN_FILENO, buf, sizeof(buf));//获取输入write(cfd, buf, len);//发送信息len read(cfd, buf, sizeof(buf));//获取返回值write(STDOUT_FILENO, buf, len);//显示}return 0;
}这一个实现的功能是从stdin获取信息发送给服务器, 之后打印服务器的返回值 多进程处理
#include ctype.h
#include stdio.h
#include stdlib.h
#include unistd.h
#include errno.h
#include sys/socket.h
#include sys/types.h
#include arpa/inet.h#define SERV_PORT 9078
void deal_one_server(struct sockaddr_in *clit_addr, int cfd){int ret;char buf[1024];printf(client ip: %s port %d\n, inet_ntop(AF_INET, clit_addr-sin_addr.s_addr, buf, sizeof(buf)), ntohs(clit_addr-sin_port));while(1){ret read(cfd, buf, sizeof(buf));if(ret 0){perror(read error\n);exit(1);}else if(ret 0){break;}write(STDOUT_FILENO , buf, ret);for(int i 0;iret;i){buf[i] toupper(buf[i]);}write(cfd, buf, ret);}
}
int main(void){int lfd 0, cfd;struct sockaddr_in serv_addr, clit_addr;socklen_t clit_addr_len;char buf[BUFSIZ];lfd socket(AF_INET, SOCK_STREAM, 0);if(lfd -1){perror(socket error\n);exit(0);}serv_addr.sin_family AF_INET;serv_addr.sin_port htons(SERV_PORT);serv_addr.sin_addr.s_addr htonl(INADDR_ANY);int ret bind(lfd, (struct sockaddr *)serv_addr, sizeof(serv_addr));if(ret ! 0){perror(bind error\n);exit(0);}ret listen(lfd, 128);if(ret ! 0){perror(listen error\n);exit(0);}clit_addr_len sizeof(clit_addr);pid_t pid;while(1){printf(waiting connect\n);cfd accept(lfd, (struct sockaddr *)clit_addr, clit_addr_len);if(cfd -1){perror(sccept error\n);exit(1);}else{pid fork();//创建一个子进程printf(pid %d\n, pid);if(pid -1){perror(fork error);exit(1);}if(pid 0){//使用子进程处理这一个连接close(lfd);printf(deal a connect %d %d\n, getpid(), getppid());deal_one_server(clit_addr, cfd);close(cfd);exit(1);}else{//父进程继续捕获close(cfd);}}}return 0;
}可以使用信号机制回收子进程, 如果使用的线程, 可以使用一个detach把这一个线程分离出去, 也可以专门使用一个线程进行回收兄弟线程 多线程
#include ctype.h
#include stdio.h
#include stdlib.h
#include unistd.h
#include errno.h
#include sys/socket.h
#include sys/types.h
#include arpa/inet.h
#include pthread.h#define SERV_PORT 9078
//子线程的处理函数
void *deal_one_server(void * arg){int ret;int cfd (int)arg;char buf[1024];while(1){ret read(cfd, buf, sizeof(buf));if(ret 0){perror(read error\n);exit(1);}else if(ret 0){break;}write(STDOUT_FILENO , buf, ret);for(int i 0;iret;i){buf[i] toupper(buf[i]);}write(cfd, buf, ret);}close(cfd);
}
int main(void){int lfd 0, cfd;struct sockaddr_in serv_addr, clit_addr;socklen_t clit_addr_len;char buf[BUFSIZ];lfd socket(AF_INET, SOCK_STREAM, 0);if(lfd -1){perror(socket error\n);exit(0);}//设置一下服务器的接收serv_addr.sin_family AF_INET;serv_addr.sin_port htons(SERV_PORT);serv_addr.sin_addr.s_addr htonl(INADDR_ANY);int ret bind(lfd, (struct sockaddr *)serv_addr, sizeof(serv_addr));if(ret ! 0){perror(bind error\n);exit(0);}ret listen(lfd, 128);//设置可以接受的个数if(ret ! 0){perror(listen error\n);exit(0);}clit_addr_len sizeof(clit_addr);pid_t pid;while(1){printf(waiting connect\n);
sig_continue:cfd accept(lfd, (struct sockaddr *)clit_addr, clit_addr_len);//开始接收if(cfd -1){if((errno ECONNABORTED) || (errno EINTR)){goto sig_continue;//处理一下信号打断}perror(sccept error\n);exit(1);}else{printf(client ip: %s port %d\n, inet_ntop(AF_INET, clit_addr.sin_addr.s_addr, buf, sizeof(buf)), ntohs(clit_addr.sin_port));pthread_t pid;pthread_create(pid, NULL, deal_one_server, (void *)cfd);//使用一个线程接收pthread_detach(pid);//把这一个线程分离}}return 0;
}和TCP协议的对应 服务器调用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段
使用UDP进行数据传输
在使用的时候accept以及connect函数不再使用
实际接收的时候不能使用recv/send以及read/write函数, 需要使用函数recvfrom以及sendto函数
recvfrom获取数据
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);socket: socket返回的lfd buf: 数据 len: 缓冲区大小 flags: 0 src_addr: 接收的地址, 这一个是一个传出参数 addrlen :这一个结构体的大小 返回值: 成功获取的数据的个数, -1失败, 0对端关闭 sendto发送数据
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);socket: socket返回的lfd buf: 数据 len: 缓冲区大小 flags: 0 dest_addr: 发送的目标地址 addrlen :这一个结构体的大小 返回值: 实际发送的字节数, 失败的时候返回-1 server
lfd socket(AF_INET, SOCK_DGRAM, 0);
bind();
listen(); – 不需要连接, 所以这一个函数可有可无
while(1){
recvfrom
处理
sendto
}
client
lfd socket(AF_INET, SOCK_DGRAM, 0);
sendto
recvfrom
处理获取的数据
实际实现
#include stdio.h
#include stdlib.h
#include unistd.h
#include errno.h
#include string.h
#include ctype.h
#include arpa/inet.h
#include sys/socket.hint main(void){struct sockaddr_in serveraddr, clientaddr;socklen_t addrlen sizeof(struct sockaddr_in);char buf[BUFSIZ];char str[INET_ADDRSTRLEN]; // #define INET_ADDRSTRLEN 16int i, n;int sockfd;int ret;//获取套接字sockfd socket(AF_INET, SOCK_DGRAM, 0);if(sockfd 0){perror(socket);exit(-1);}printf(sockfd %d\n, sockfd);bzero(serveraddr, sizeof(serveraddr));serveraddr.sin_family AF_INET;serveraddr.sin_port htons(8000);serveraddr.sin_addr.s_addr htonl(INADDR_ANY);bind(sockfd, (struct sockaddr *)serveraddr, addrlen);while(1){n recvfrom(sockfd, buf, BUFSIZ, 0, (struct sockaddr *)clientaddr, addrlen);if(n -1){perror(recvfrom);exit(-1);}printf(received from %s at PORT %d\n, inet_ntop(AF_INET, clientaddr.sin_addr, str, sizeof(str)),ntohs(clientaddr.sin_port));for(i 0; i n; i){buf[i] toupper(buf[i]);}n sendto(sockfd, buf, n, 0, (struct sockaddr *)clientaddr, addrlen);if(n -1){perror(sendto);exit(-1);}}close(sockfd);return 0;
}#include stdio.h
#include stdlib.h
#include unistd.h
#include errno.h
#include string.h
#include arpa/inet.h
#include sys/socket.h
int main(void){struct sockaddr_in server_addr;int sockfd, n;char buf[1024];sockfd socket(AF_INET, SOCK_DGRAM, 0);if(sockfd 0){perror(socket);exit(1);}server_addr.sin_family AF_INET;server_addr.sin_port htons(8000);inet_pton(AF_INET, 127.0.0.1, server_addr.sin_addr);while(fgets(buf, sizeof(buf), stdin) ! NULL){n sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)server_addr, sizeof(server_addr));if(n 0){perror(sendto);exit(1);}n recvfrom(sockfd, buf, sizeof(buf), 0, NULL, NULL);write(STDOUT_FILENO, buf, n);}close(sockfd);return 0;
}出错处理封装函数
上面的例子不仅功能简单而且简单到几乎没有什么错误处理我们知道系统调用不能保证每次都成功必须进行出错处理这样一方面可以保证程序逻辑正常另一方面可以迅速得到故障信息。
为使错误处理的代码不影响主程序的可读性我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数做成一个模块wrap.c 这里只改变了一个字母的大小写不影响进入man手册 wrap.c
#include stdlib.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;//这一个系统调研被一个中断打断elseperr_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;elsereturn -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;elsereturn -1;}return n;
}int Close(int fd)
{int n;if ((n close(fd)) -1)perr_exit(close error);return n;
}
//在socket编程里面没有文件描述符, 所以这一个读取的时候只能使用系统调用
//在使用的时候封装一下会提高效率
ssize_t Readn(int fd, void *vptr, size_t n)
{size_t nleft;ssize_t nread;char *ptr;ptr vptr;nleft n;while (nleft 0) {if ( (nread read(fd, ptr, nleft)) 0) {if (errno EINTR)nread 0;elsereturn -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;elsereturn -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;} elsereturn -1;}*ptr 0;return n;
}wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_
void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif补充函数(非常用)
shutdown关闭连接
当TCP链接中A发送FIN请求关闭B端回应ACK后A端进入FIN_WAIT_2状态B没有立即发送FIN给A时A方处在半链接状态此时A可以接收B发送的数据但是A已不能再向B发送数据。
从程序的角度可以使用API来控制实现半连接状态。
#include sys/socket.h
int shutdown(int sockfd, int how);sockfd: 需要关闭的socket的描述符 how: 允许为shutdown操作选择以下几种方式: SHUT_RD(0) 关闭sockfd上的读功能此选项将不允许sockfd进行读操作。 该套接字不再接收数据任何当前在套接字接受缓冲区的数据将被无声的丢弃掉。 SHUT_WR(1): 关闭sockfd的写功能此选项将不允许sockfd进行写操作。进程不能在对此套接字发出写操作。 SHUT_RDWR(2): 关闭sockfd的读写功能。相当于调用shutdown两次首先是以SHUT_RD,然后以SHUT_WR。 使用close中止一个连接但它只是减少描述符的引用计数并不直接关闭连接只有当描述符的引用计数为0时才关闭连接。
shutdown不考虑描述符的引用计数直接关闭描述符。也可选择中止一个方向的连接只中止读或只中止写。
注意:
如果有多个进程共享一个套接字close每被调用一次计数减1直到计数为0时也就是所用进程都调用了close套接字将被释放。在多进程中如果一个进程调用了shutdown(sfd, SHUT_RDWR)后其它的进程将无法进行通信。但如果一个进程close(sfd)将不会影响到其它进程。
补充
把文件上传服务器
scp -r 文件名 服务器用户名服务器ip:目录
scp -r ./socket.c root110.41.39.131:/root/
