C/S模型的简单实现（UDP服务器）、本地套接字（sockaddr_un ）的讲解
1.UDP
1.1 UDP服务器
输层主要应用的协议模型有两种，一种是TCP协议，另外一种则是UDP协议。TCP协议在网络通信中占主导地位，绝大多数的网络通信借助TCP协议完成数据传输。但UDP也是网络通信中不可或缺的重要通信手段。
相较于TCP而言，UDP通信的形式更像是发短信。不需要在数据传输之前建立、维护连接。只专心获取数据就好。省去了三次握手的过程，通信速度可以大大提高，但与之伴随的通信的稳定性和正确率便得不到保证。因此，我们称UDP为“无连接的不可靠报文传递”。
那么与我们熟知的TCP相比，UDP有哪些优点和不足呢？由于无需创建连接，所以UDP开销较小，数据传输速度快，实时性较强。多用于对实时性要求较高的通信场合，如视频会议、电话会议等。但随之也伴随着数据传输不可靠，传输数据的正确率、传输顺序和流量都得不到控制和保证。所以，通常情况下，使用UDP协议进行数据传输，为保证数据的正确性，我们需要在应用层添加辅助校验协议来弥补UDP的不足，以达到数据可靠传输的目的。
与TCP类似的，UDP也有可能出现缓冲区被填满后，再接收数据时丢包的现象。由于它没有TCP滑动窗口的机制，通常采用如下两种方法解决：
1) 服务器应用层设计流量控制，控制发送数据速度。
2) 借助setsockopt函数改变接收缓冲区大小。如：
#include <sys/socket.h>
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
int n = 220x1024
setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));1.2 TPC和UDP的优缺点
TCP
TCP：面向连接的，可靠数据包穿传输。对于不稳定的网络层，采取完全弥补的通信方式 -- 丢包重传
优点：稳定 -- 数据流量、速度、顺序
缺点：传输速度慢、效率低、开销大
使用场景：数据的完整性要求较高，不追求效率 -- 大数据传输、文件传出
UDP
UDP：无连接的，不可靠的数据报传递。对于不稳定的网络层，采取完全不弥补的通信方式 -- 默认还原网络状况
优点：传输速度快，效率高，开销小
缺点：不稳定 -- 数据浏览、速度、顺序
使用场景：对时效性要求较高的场合，稳定性其次 -- 游戏、视频会议、视频电话
腾讯、华为、阿里用UDP较多，通过在应用层里添加数据校验协议，弥补UDP的不足
1.3 C/S模型 -- UDP
由于UDP不需要维护连接，程序逻辑简单了很多，但是UDP协议是不可靠的，保证通讯可靠性的机制需要在应用层实现。
编译运行server，在两个终端里各开一个client与server交互，看看server是否具有并发服务的能力。用Ctrl+C关闭server，然后再运行server，看此时client还能否和server联系上。和前面TCP程序的运行结果相比较，体会无连接的含义。
recvfrom、sendto
recv() / send只能用于TCP通信，代替read和write，具体参数去按K查看man手册
而在UDP中能替换read和write则是：recvfrom()和sendto
ssize_t recvfrom(int sockfd, //自己的套接字
void *buf， //读取数据后存放的缓冲区
size_t len, //缓冲区的大小
int flags, //默认传0
struct sockaddr *src_addr, //传出对端的地址结构，传出参数
socklen_t *addrlen) //对端套接字的大小，传入传出
返回值：成功接收数据：字节数；失败：-1，errno；对端关闭：0
ssize_t sendto(int sockfd, //自己的套接字
const void *buf, //存储数据的缓冲区
size_t len, //数据的长度
int flags, //默认0
const struct sockaddr *dest_addr, //发送数据给目标的地址结果，传入
socklen_t addrlen); //目标地址结构体的长度
返回值：成功：字节数；失败：-1，errnoserver
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <unistd.h>
#include <strings.h>
#include <arpa/inet.h>
#include <ctype.h>
#define MAXLINE 80
#define SERV_PORT 6666
int main(void)
{
struct sockaddr_in servaddr, cliaddr;
socklen_t cliaddr_len;
int sockfd;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];
int i, n;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
//参数2：SOCK_DRGAM，报式协议
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
//listen()：可有可无
bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
printf("Accepting connections ...\n");
while (1) {
cliaddr_len = sizeof(cliaddr);
n = recvfrom(sockfd, buf, MAXLINE,0, (struct sockaddr *)&cliaddr, &cliaddr_len);
if (n == -1)
perror("recvfrom error");
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
ntohs(cliaddr.sin_port));
for (i = 0; i < n; i++)
buf[i] = toupper(buf[i]);
n = sendto(sockfd, buf, n, 0, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
if (n == -1)
perror("sendto error");
}
close(sockfd);
return 0;
}client
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <strings.h>
#include <ctype.h>
#define MAXLINE 80
#define SERV_PORT 6666
int main(int argc, char *argv[])
{
struct sockaddr_in servaddr;
int sockfd, n;
char buf[MAXLINE];
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
servaddr.sin_port = htons(SERV_PORT);
while (fgets(buf, MAXLINE, stdin) != NULL) {
n = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
if (n == -1)
perror("sendto error");
n = recvfrom(sockfd, buf, MAXLINE, 0, NULL, 0);
if (n == -1)
perror("recvfrom error");
write(STDOUT_FILENO, buf, n);
}
close(sockfd);
return 0;
}2.本地套接字
IPC：pipe、fifo、mmap、信号、本地套接字(domain)
socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口，类似于TCP和UDP，但是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。
UNIX Domain Socket是全双工的，API接口语义丰富，相比其它IPC机制有明显的优越性，目前已成为使用最广泛的IPC机制，比如X Window服务器和GUI程序之间就是通过UNIXDomain Socket通讯的。
使用UNIX Domain Socket的过程和网络socket十分相似，也要先调用socket()创建一个socket文件描述符，address family指定为AF_UNIX，type可以选择SOCK_DGRAM或SOCK_STREAM，protocol参数仍然指定为0即可。socket函数介绍点击这里
UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同，用结构体sockaddr_un表示，网络编程的socket地址是IP地址加端口号，而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。
2.1 套接字比较
对比网络套接字地址结构和本地套接字地址结构：
网络套接字的称地址结构 -- 封装了IP和端口号
struct sockaddr_in {
__kernel_sa_family_t sin_family; /* Address family */ //地址结构类型 -- AF_INET(IPv4)
__be16 sin_port;/* Port number */端口号
struct in_addr sin_addr;/* Internet address */ IP地址
};
本地套接字的地址结构：
struct sockaddr_un {
__kernel_sa_family_t sun_family;/* AF_UNIX */ //地址结构类型 -- AF_UNIX(本地协议)
char sun_path[UNIX_PATH_MAX]; /* pathname */ socket文件名(含路径)
};
以下程序将UNIX Domain socket绑定到一个地址。
size = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
#define offsetof(type, member) ((int)&((type *)0)->MEMBER)
2.2 函数参数选用
int socket(int domain, int type, int protocol);
domain:
AF_UNIX/AF_LOCAL 本地协议，使用在Unix和Linux系统上，一般都是当客户端和服务器在同一台及其上的时候使用
type:下面随便选一个
SOCK_STREAM 这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型，这个socket是使用TCP来进行传输。
SOCK_DGRAM 这个协议是无连接的、固定长度的传输调用。该协议是不可靠的，使用UDP来进行它的连接。
protocol:
传0 表示使用默认协议
返回值：
成功：返回用于引用socket的文件描述符，失败：返回-1，设置errno
要注意的是返回的fd是个文件描述符，在UDP中需要绑定上地址结构后该套接字才真正被创建，服务器和客户端都需要整一个伪文件出来进行绑定创建伪文件(套接字)
所以都需要给bind传入地址结构 -- 创建传入的名为(struct sockaddr_un).sun_path的伪文件 -- 绑定 -- socket真正形成
因此调用bind前需要用unlink对名为srv.socket的文件进行删除 -- 减少其连接数为0，系统就会将其回收，防止文件名冲突而创建不了
而在TCP网络通信中，即使不用bind绑定上IP和端口号，系统也会自动分配，一调用socket函数套接字便创建
TCP中IP和port就对应一个socket，而UDP中是一个名为(struct sockaddr_un).sun_path的伪文件对应一个socket int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd:
lfd = socket(AF_UNIX, SOCK_STREAM,0); //空壳，是文件描述符 -- 套接字
addr:
// struct sockaddr_un {
// __kernel_sa_family_t sun_family;/* AF_UNIX */ //地址结构类型 -- AF_UNIX(本地协议)
// char sun_path[UNIX_PATH_MAX]; /* pathname */ socket文件名(含路径)
// };
struct sockaddr_un srv_addr;
srv_addr.faimly = AF_UNIX; //根据socket函数参数domain指定一样的协议
strcpy(srv_addr.sun_path,"srv.socket"); //给套接字起名字 -- 给伪文件命名
addr = (struct sockaddr *)srv_addr;
addrlen:
地址结构的长度
addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(srv_addr.sun_path);
// #define offsetof(type, member) ((int)&((type *)0)->MEMBER)
//offsetof求的参2到参1的首地址偏移大小为多少，其实就是两字节
传出一个绑定伪文件的套接字文件描述符 参1 socket，指向名为“srv.socket”的伪文件
因此调用bind前需要用unlink对名为srv.socket的文件进行删除 -- 减少其连接数为0，系统就会将其回收
防止文件名冲突而创建不了
所以UDP中套接字是调用bind创建的 -- (struct sockaddr_un).sun.path的伪文件
2.3 server
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#define QLEN 10
/*
* Create a server endpoint of a connection.
* Returns fd if all OK, <0 on error.
*/
int serv_listen(const char* name)
{
int fd, len, err, rval;
struct sockaddr_un un;
/* create a UNIX domain stream socket */
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
return(-1);
/* in case it already exists */
unlink(name);
/* fill in socket address structure */
memset(&un, 0, sizeof(un));
un.sun_family = AF_UNIX;
strcpy(un.sun_path, name);
len = offsetof(struct sockaddr_un, sun_path) + strlen(name);
/* bind the name to the descriptor */
if (bind(fd, (struct sockaddr*)&un, len) < 0) {
rval = -2;
goto errout;
}
if (listen(fd, QLEN) < 0) { /* tell kernel we're a server */
rval = -3;
goto errout;
}
return(fd);
errout:
err = errno;
close(fd);
errno = err;
return(rval);
}
int serv_accept(int listenfd, uid_t* uidptr)
{
int clifd, len, err, rval;
time_t staletime;
struct sockaddr_un un; //存放客户端的
struct stat statbuf;
len = sizeof(un);
//阻塞等待客户端连接，获取到客户端的套接字文件描述符clifd和套接字un已经该套接字的长度len
if ((clifd = accept(listenfd, (struct sockaddr*)&un, &len)) < 0)
return(-1); /* often errno=EINTR, if signal caught */
/* obtain the client's uid from its calling address */
len = offsetof(struct sockaddr_un, sun_path); /* len of pathname */
un.sun_path[len] = 0; /* null terminate */
//获取到un.sun_path的文件属性 -- 套接字的文件属性 -- 系统编程第4节笔记有将stat函数
if (stat(un.sun_path, &statbuf) < 0) {
rval = -2;
goto errout;
}
//判断获取到的文件的类型是不是套接字 -- 系统编程第4节
if (S_ISSOCK(statbuf.st_mode) == 0) {
rval = -3; /* not a socket */
goto errout;
}
if (uidptr != NULL)
*uidptr = statbuf.st_uid; /* return uid of caller */
/* we're done with pathname now */
unlink(un.sun_path);
return(clifd);
errout:
err = errno;
close(clifd);
errno = err;
return(rval);
}
int main(void)
{
int lfd, cfd, n, i;
uid_t cuid;
char buf[1024];
lfd = serv_listen("foo.socket");
if (lfd < 0) {
switch (lfd) {
case -3:perror("listen"); break;
case -2:perror("bind"); break;
case -1:perror("socket"); break;
}
exit(-1);
}
cfd = serv_accept(lfd, &cuid);
if (cfd < 0) {
switch (cfd) {
case -3:perror("not a socket"); break;
case -2:perror("a bad filename"); break;
case -1:perror("accept"); break;
}
exit(-1);
}
while (1) {
r_again:
n = read(cfd, buf, 1024);
if (n == -1) {
if (errno == EINTR)
goto r_again;
}
else if (n == 0) {
printf("the other side has been closed.\n");
break;
}
for (i = 0; i < n; i++)
buf[i] = toupper(buf[i]);
write(cfd, buf, n);
}
close(cfd);
close(lfd);
return 0;
}2.4 client
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#define CLI_PATH "/var/tmp/" /* +5 for pid = 14 chars */
/*
* Create a client endpoint and connect to a server.
* Returns fd if all OK, <0 on error.
*/
int cli_conn(const char *name)
{
int fd, len, err, rval;
struct sockaddr_un un;
/* create a UNIX domain stream socket */
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
return(-1);
/* fill socket address structure with our address */
memset(&un, 0, sizeof(un));
un.sun_family = AF_UNIX;
sprintf(un.sun_path, "%s%05d", CLI_PATH, getpid()); // /var/tmp/自己的线程Id 作为客户端伪文件的名字
len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
/* in case it already exists */
unlink(un.sun_path);
if (bind(fd, (struct sockaddr *)&un, len) < 0) {
rval = -2;
goto errout;
}
/* fill socket address structure with server's address */
memset(&un, 0, sizeof(un));
un.sun_family = AF_UNIX;
strcpy(un.sun_path, name);
len = offsetof(struct sockaddr_un, sun_path) + strlen(name);
if (connect(fd, (struct sockaddr *)&un, len) < 0) {
rval = -4;
goto errout;
}
return(fd);
errout:
err = errno;
close(fd);
errno = err;
return(rval);
}
int main(void)
{
int fd, n;
char buf[1024];
fd = cli_conn("foo.socket");
if (fd < 0) {
switch (fd) {
case -4:perror("connect"); break;
case -3:perror("listen"); break;
case -2:perror("bind"); break;
case -1:perror("socket"); break;
}
exit(-1);
}
while (fgets(buf, sizeof(buf), stdin) != NULL) {
write(fd, buf, strlen(buf));
n = read(fd, buf, sizeof(buf));
write(STDOUT_FILENO, buf, n);
}
close(fd);
return 0;
}2.5 实现对比
原文地址：https://blog.csdn.net/caiji0169/article/details/142698048
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！