linux网络编程之socket编程(三)
今天继续对socket编程进行学习，在学习之前，需要回顾一下上一篇中编写的回射客户/服务器程序(http://www.cnblogs.com/webor2006/p/3923254.html)，因为今天的知识点需要基于它来进行说明，下面来回顾一下关键代码:
对于服务器端：echosrv.c
对于客户端：echocli.c
下面通过一个简单的图来描述一下其关系：
可想而知，这两个套接字都有自己的地址，对于conn服务端而言，它的地址是在绑定的时候确认的，也就是：
而对于sock客户端而言，它的地址是在连接成功时确定的。一旦连接成功，则会自动选择一个本机的地址和端口号，当一个客户端连接服务器成功时，在服务器端是可以打印出客户端的地址和端口信息的，具体代码如下：
所以可以将其客户端的地址和端口号打印出来，修改服务端代码如下：
这次编译运行看下效果：
当客户端连接成功时，则在服务端将其客户端的ip和端口号打印出来了。
接下来，要解决一个上篇博文中遇到的问题，问题现象就是如下：
原因是由于，重启时会重新再绑定，而此时该服务器是处于TIME_WAIT状态，通过命令可以查看到该状态：
【注意】:TIME_WAIT状态，需服务器与客户端都已经退出来才会出来。
而该状态下，默认是无法再次绑定的，那如何解决此问题呢？可以使用SO_REUSEADDR选项来解决此问题:
具体使用方法如下，修改服务端代码如下：
这时再来看是否解决了此问题：
但是，这个错误还会在一种场景下报出来，如下：
下面再来看一下目前程序的问题：目前服务器只能接收一个客户端的连接，看下面：
分析一下服务端的代码就可以得知：
解决这个问题的思路就是：一个连接一个进程来处理并发(process-per-connection)，也就是上面画红圈的放到子进程去处理，然后主进程可以去accept客户端的请求了，具体代码修改如下:
echosrv.c:
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h> #include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h> #define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while() void do_service(int conn)//将处理客户端请求数据逻辑封装到一个函数中，这样代码更加模块化
{
char recvbuf[1024];
while (1)
{
memset(recvbuf, 0, sizeof(recvbuf));
int ret = read(conn, recvbuf, sizeof(recvbuf));
fputs(recvbuf, stdout);
write(conn, recvbuf, ret);
}
} int main(void)
{
int listenfd;
if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
/* if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
ERR_EXIT("socket"); struct sockaddr_in servaddr;
memset(&servaddr, , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons();
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
/*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
/*inet_aton("127.0.0.1", &servaddr.sin_addr);*/ int on = ;
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
ERR_EXIT("setsockopt"); if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < )
ERR_EXIT("listen"); struct sockaddr_in peeraddr;
socklen_t peerlen = sizeof(peeraddr);
int conn; pid_t pid;
while (1)//用一个循环来不断处理客户端的请求，所以将accept操作也放到循环中
{
if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
ERR_EXIT("accept"); printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port)); pid = fork();//创建进程
if (pid == -1)
ERR_EXIT("fork");
if (pid == 0)
{//子进程来处理与客户端的数据
close(listenfd);//对于子进程而言，监听listenfd套接字没用，则直接关闭掉，注意：套接字在父子进程是共享的
do_service(conn);//开始处理请求数据
}
else//父进程则回到while循环头，去accept新的客户端的请求，这样就比较好的解决多个客户端的请求问题
close(conn);
} return ;
}
下面来看下效果：
对于这段程序，其实还需要完善，也就是不能监听客户端的退出，
那怎么监听客户端的监听呢？
编译运行看一下效果：
从中可以看到，当客户端退出时，服务端也收到消息了。
下面用多进程方式实现点对点聊天来进一步理解套接字编程，这里实现的聊天程序是这样：
那不管对于服务端，还是客户端，应该每个端点都有有两个进程，一个进程读取对等方的数据，另一个进程专门从键盘中接收数据发送给对待方，这里实现的只是一个服务端跟一个客户端的通讯，不考虑一个服务端跟多个客户端的通讯了，重在练习，下面还是基于之前的代码开始实现：
p2psrv.c【点对点通信服务端】:
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h> #include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h> #define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while() int main(void)
{
int listenfd;
if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
/* if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
ERR_EXIT("socket"); struct sockaddr_in servaddr;
memset(&servaddr, , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons();
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
/*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
/*inet_aton("127.0.0.1", &servaddr.sin_addr);*/ int on = ;
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
ERR_EXIT("setsockopt"); if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < )
ERR_EXIT("listen"); struct sockaddr_in peeraddr;
socklen_t peerlen = sizeof(peeraddr);
int conn;
if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < )
ERR_EXIT("accept"); printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port)); pid_t pid;
pid = fork();
if (pid == -1)
ERR_EXIT("fork"); if (pid == 0)
{//子进程用来从键盘中获取输入输数据向客户端发送数据
char sendbuf[1024] = {0};
while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
{
write(conn, sendbuf, strlen(sendbuf));
memset(sendbuf, 0, sizeof(sendbuf));
}
exit(EXIT_SUCCESS);
}
else
{//父进程读取从客户端发送过来的数据
char recvbuf[1024];
while (1)
{
memset(recvbuf, 0, sizeof(recvbuf));
int ret = read(conn, recvbuf, sizeof(recvbuf));
if (ret == -1)
ERR_EXIT("read");
else if (ret == 0)
{
printf("peer close\n");
break;
} fputs(recvbuf, stdout);
}
exit(EXIT_SUCCESS);
} return ;
}
基本上前面的listen、bind、accept的代码没动，编译一下：
木有问题~~~
p2pcli.c【点对点通信客户端】:
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h> #include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h> #define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while() int main(void)
{
int sock;
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
ERR_EXIT("socket"); struct sockaddr_in servaddr;
memset(&servaddr, , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons();
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
ERR_EXIT("connect"); pid_t pid;
pid = fork();
if (pid == -1)
ERR_EXIT("fork"); if (pid == 0)
{//子进程接收来自服务端发来的数据
char recvbuf[1024];
while (1)
{
memset(recvbuf, 0, sizeof(recvbuf));
int ret = read(sock, recvbuf, sizeof(recvbuf));
if (ret == -1)
ERR_EXIT("read");
else if (ret == 0)
{
printf("peer close\n");
break;
} fputs(recvbuf, stdout);
}
close(sock);
}
else
{//父进程获取从键盘中敲入的命令向服务端发送数据
char sendbuf[1024] = {0};
while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
{
write(sock, sendbuf, strlen(sendbuf));
memset(sendbuf, 0, sizeof(sendbuf));
}
close(sock);
}
return ;
}
编译运行：
可见就实现了点对点的聊天程序。这时客户端关闭时，服务端也关闭了，但是，实际上服务端的程序还是有些问题的，分析一下代码：
可以在父子进程退出时都打印一个log来验证下：
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h> #include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h> #define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while() int main(void)
{
int listenfd;
if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
/* if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
ERR_EXIT("socket"); struct sockaddr_in servaddr;
memset(&servaddr, , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons();
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
/*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
/*inet_aton("127.0.0.1", &servaddr.sin_addr);*/ int on = ;
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
ERR_EXIT("setsockopt"); if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < )
ERR_EXIT("listen"); struct sockaddr_in peeraddr;
socklen_t peerlen = sizeof(peeraddr);
int conn;
if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < )
ERR_EXIT("accept"); printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port)); pid_t pid;
pid = fork();
if (pid == -)
ERR_EXIT("fork"); if (pid == )
{
char sendbuf[] = {};
while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
{
write(conn, sendbuf, strlen(sendbuf));
memset(sendbuf, , sizeof(sendbuf));
}
printf("child close\n");
exit(EXIT_SUCCESS);
}
else
{
char recvbuf[];
while ()
{
memset(recvbuf, , sizeof(recvbuf));
int ret = read(conn, recvbuf, sizeof(recvbuf));
if (ret == -)
ERR_EXIT("read");
else if (ret == )
{
printf("peer close\n");
break;
} fputs(recvbuf, stdout);
}
printf("parent close\n");
exit(EXIT_SUCCESS);
} return ;
}
而此时，如果我按任意一个字符，则子进程就退出来：
那怎么解决当父进程退出时，也让其子进程退出呢，就可以用到我们之前学过的信号来解决了，具体如下：
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h> #include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h> #define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while() void handler(int sig)//当子进程收到信号时，则将自身退出
{
printf("recv a sig=%d\n", sig);
exit(EXIT_SUCCESS);
} int main(void)
{
int listenfd;
if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
/* if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
ERR_EXIT("socket"); struct sockaddr_in servaddr;
memset(&servaddr, , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons();
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
/*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
/*inet_aton("127.0.0.1", &servaddr.sin_addr);*/ int on = ;
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
ERR_EXIT("setsockopt"); if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < )
ERR_EXIT("listen"); struct sockaddr_in peeraddr;
socklen_t peerlen = sizeof(peeraddr);
int conn;
if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < )
ERR_EXIT("accept"); printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port)); pid_t pid;
pid = fork();
if (pid == -)
ERR_EXIT("fork"); if (pid == )
{
signal(SIGUSR1, handler);//子进程注册一个SIGUSR1信号，以便在父进程退出时，通知子进程退出
char sendbuf[] = {};
while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
{
write(conn, sendbuf, strlen(sendbuf));
memset(sendbuf, , sizeof(sendbuf));
}
printf("child close\n");
exit(EXIT_SUCCESS);
}
else
{
char recvbuf[];
while ()
{
memset(recvbuf, , sizeof(recvbuf));
int ret = read(conn, recvbuf, sizeof(recvbuf));
if (ret == -)
ERR_EXIT("read");
else if (ret == )
{
printf("peer close\n");
break;
} fputs(recvbuf, stdout);
}
printf("parent close\n");
kill(pid, SIGUSR1);//当父进程退出时，发送一个SIGUSR1信号
exit(EXIT_SUCCESS);
} return ;
}
这时再看下效果：
如果反过来呢，将服务端关闭，那客户端程序也会关闭么？
可以看到，当服务端退出时，客户端并没有退出，那是啥原因呢？
那解决此问题也是可以利用信号来解决，就像服务端一样，可以在子进程退出时，向父进程发送一个信号，然后父进程也退出既可，修改代码如下：
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h> #include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h> #define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while() void handler(int sig)
{
printf("recv a sig=%d\n", sig);
exit(EXIT_SUCCESS);
} int main(void)
{
int sock;
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
ERR_EXIT("socket"); struct sockaddr_in servaddr;
memset(&servaddr, , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons();
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
ERR_EXIT("connect"); pid_t pid;
pid = fork();
if (pid == -)
ERR_EXIT("fork"); if (pid == )
{
char recvbuf[];
while ()
{
memset(recvbuf, , sizeof(recvbuf));
int ret = read(sock, recvbuf, sizeof(recvbuf));
if (ret == -)
ERR_EXIT("read");
else if (ret == )
{
printf("peer close\n");
break;
} fputs(recvbuf, stdout);
}
close(sock);
kill(getppid(), SIGUSR1);
}
else
{
signal(SIGUSR1, handler);
char sendbuf[] = {};
while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
{
write(sock, sendbuf, strlen(sendbuf));
memset(sendbuf, , sizeof(sendbuf));
}
close(sock);
} return ;
}
这里就不多解释了，跟服务端的道理一样，这样再来运行一下看下效果：
这样，就实现了一个点对点的聊天的程序，当然，这里没有考虑到多个客户端与服务端通讯的问题，但是根据这个程序也能容易进行扩展，今天的内容就先学到这，下次再见~~~
linux网络编程之socket编程(三)的更多相关文章
- linux网络编程之socket编程(一)
今天开始,继续来学习linux编程,这次主要是研究下linux下的网络编程,而网络编程中最基本的需从socket编程开始,下面正式开始学习: 什么是socket: 在学习套接口之前,先要回顾一下Tcp ...
- linux网络编程之socket编程(六)
经过一个国庆长假,又有一段时间没有写博文了,今天继续对linux网络编程进行学习,如今的北京又全面进入雾霾天气了,让我突然想到了一句名句:“真爱生活,珍惜生命”,好了,言归正传. 回顾一下我们之间实现 ...
- linux网络编程之socket编程(四)
经过两周的等待,终于可以回归我正常的学习之旅了,表哥来北京了在我这暂住,晚上回家了基本在和他聊天,周末带他在北京城到处乱转,几乎剥夺了我自由学习的时间了,不过,亲人之情还是很难得的,工作学习并不是生活 ...
- linux网络编程之socket编程(八)
学习socket编程继续,今天要学习的内容如下: 先来简单介绍一下这五种模型分别是哪些,偏理论,有个大致的印象就成,做个对比,因为最终只会研究一个I/O模型,也是经常会用到的, 阻塞I/O: 先用一个 ...
- linux网络编程之socket编程(二)
今天继续对socket编程进行研究,这里会真正开如用socket写一个小例子,进入正题: TCP客户/服务器模型: 关于这个模型的流程这里就不多说了,比较容易理解,下面则利用这种模型来编写一个实际 ...
- linux网络编程之socket编程(十一)
今天继续学习socket编程,这次主要是学习超时方法的封装,内容如下: ①.alarm[不常用,了解既可] 它的实现思路是这样的: 但是这种方案有一定的问题,因为闹钟可能会作为其它的用途,这时所设置的 ...
- linux网络编程之socket编程(七)
今天继续学习socket编程,北京在持续几天的雾霾天之后久违的太阳终于出来了,心情也特别特别的好,于是乎,在这美好的夜晚,该干点啥事吧,那当然就是继续坚持我的程序学习喽,闲话不多说,进入正题: 通过这 ...
- linux网络编程之socket编程(十六)
继续学习socket编程,今天的内容会有些难以理解,一步步来分解,也就不难了,正入正题: 实际上sockpair有点像之前linux系统编程中学习的pipe匿名管道,匿名管道它是半双工的,只能用于亲缘 ...
- linux网络编程之socket编程(十五)
今天继续学习socket编程,这次主要是学习UNIX域协议相关的知识,下面开始: [有个大概的认识,它是来干嘛的] ①.UNIX域套接字与TCP套接字相比较,在同一台主机的传输速度前者是后者的两倍. ...
随机推荐
- DevOps - DevOps精要 - 变革
特别说明 本文是已读书籍的学习笔记和内容摘要,原文内容有少部分改动,并添加一些相关信息,但总体不影响原文表达. <DevOps入门与实践> :本书结合实例详细介绍了在开发现场引入DevOp ...
- (CSDN迁移) 替换字符串中的空格
题目描述 请实现一个函数,将一个字符串中的空格替换成"%20".例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy. public ...
- [转帖]抢先AMD一步，英特尔推出新处理器，支持LPDDR5！
抢先AMD一步,英特尔推出新处理器,支持LPDDR5! http://www.eetop.cn/cpu_soc/6946240.html 2019.10 intel的最新技术发展. 近日,知名硬件爆料 ...
- 43 多线程（十三）——CAS（了解即可）
emm...记一些关键词吧 原子操作 悲观锁.乐观锁 比较交换 硬件层面 C.C#底层实现 JUC = java.util.concurrent 高级并发才使用 面试会问到 了解即可 剩下的内容交给未 ...
- Linux命令xargs的使用
ls | xargs catls | xargs -I {} cat {} 大写I,指定参数的替换符号为{} 自定义
- 最简单的Python3多线程实现
最简单的实现了一下Python的多线程: import threading def write_dbs(i): print(i) if __name__ == '__main__': for i in ...
- 【Linux】一步一步学Linux——初识Linux命令解析器(10)
目录 00. 目录 01. Shell简介 02. Shell分类 03. 交互式shell和非交互式shell 04. 登录shell和非登录shell 05. Shell类型 06. 参考 00. ...
- deepin 删除navicat,重新开始计时
1.执行 sudo apt-get autoremove navicat --purge 删除navicat 文件 2.cd /home/你的用户名 rm -rf .navicat64或rm -rf ...
- mvn: command not found in Jenkins slave
在Jenkins上添加了一个slave node, 并绑定了一个团队项目,通过shell来执行后续操作,结果卡在了 mvn: command not found 其实这个node上是配置了maven的 ...
- 【题解】Luogu P4910 帕秋莉的手环
原题传送门 "连续的两个中至少有1个金的"珂以理解为"不能有两个木相连" 我们考虑一个一个将元素加入手环 设f\([i][0/1]\)表示长度为\(i\)手环末 ...