今天继续学习socket网络编程，最近北京阴雨连绵，降温明显，感觉是要立马转入冬季的节奏，天冷晚上得注意多盖点被子哦，言归正传，进入正题：

对于之前写的回射客户/服务器端的程序中，我们是用的read和write来读取和发送数据的，如下：

那recv相对于read有什么区别呢？先看一下man帮助：

其实它跟read函数功能一样，都可以从套接口缓冲区sockfd中取数据到buf,但是recv仅仅只能够用于套接口IO，并不能用于文件IO以及其它的IO，而read函数可以用于任何的IO；

recv函数相比read函数多了一个flags参数，通过这个参数可以指定接收的行为，比较有用的两个选项是：

关于这个选项，先做下了解。

这个这次要学习的，它可以接收缓冲区中的数据，但是并不从缓冲区中清除，这是跟read函数有区别的地方，read函数一旦读取了，就会直接从缓冲区中清除。

下面用recv函数来封装一个recv_peek函数，还是继上节中的程序进行修改:

注意：这时缓冲区中的数据还在，下面利用这个封装的函数来实现readline。

也就是实现按行读取，读取直到\n字符，实际上，它也能解决上节中提到的粘包问题，回顾下上节的粘包问题解决方案：

我们只要解释\n为止，表示前面是一个条合法的消息，对于readline的实现，可以有三种方案：

①、最简单的方案就是一个字符一个字符的读取，然后做判断是否有"\n"，但是这种效率比较低，因为会多次掉用read或recv系统函数。

②、用一个static变量保存接收到的数据进行缓存，在下次时从这个缓存变量中读取然后估"\n"判断。但是一旦用到了static变量，这意味着用到的函数是不可重录函数【关于这个概念，可以参考博文：http://www.cnblogs.com/webor2006/p/3744002.html】。

③、偷窥的方法，也就是这次要采用的方案。下面就利用我们封装的recv_peek函数实现readline：

首先用recv从缓冲区中偷窥数据：

接着判断是否有"\n"字符，然后将其从缓冲区中读出来，并且清空缓冲区：

如果没有找到"\n"字符，则读取数据并清空缓存，并不断循环,具体如下：

  1. ssize_t readline(int sockfd, void *buf, size_t maxline)
  2. {
  3.     int ret;
  4.     int nread;//已读字节数
  5.     char *bufp = buf;
  6.     int nleft = maxline;//剩余字节数
  7.     while ()
  8.     {
  9.         ret = recv_peek(sockfd, bufp, nleft);
  10.         if (ret < )//证明读取失败了
  11.             return ret;
  12.         else if (ret == )//证明是对方关闭了
  13.             return ret;
  14.  
  15.         nread = ret;
  16.  
  17.         int i;
  18.         for (i=; i<nread; i++)
  19.         {
  20.             if (bufp[i] == '\n')
  21.             {
  22.                 ret = readn(sockfd, bufp, i+);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样
  23.                 if (ret != i+)//如果读出来的字符数不等于i+1，则说明读取失败了
  24.                     exit(EXIT_FAILURE);
  25.  
  26.                 return ret;
  27.             }
  28.         }
  29.  
  30.         if (nread > nleft)//这种情况说明也是读取有问题的
  31.             exit(EXIT_FAILURE);
  32.  
  33.         //执行到此则说明没有找到"\n"字符,这时读取数据然后清空缓冲区
  34.         nleft -= nread;
  35.         ret = readn(sockfd, bufp, nread);
  36.         if (ret != nread)
  37.             exit(EXIT_FAILURE);
  38.  
  39.         bufp += nread;//再继续读后面的
  40.     }
  41.  
  42.     return -;//执行到此，则说明失败了
  43. }

下面则用这个readline方法来解决回射客户/服务端粘包问题，由于是按一行一行发送数据，说明消息之间的边界就是"\n"，所以对于之前封装的定长包结构的方式可以去掉了：

将服务端改成按行读取代码如下：

对于客户端修改也同理：

首先将我们封装的readline的两个方法拷贝过来：

然后也改成按行读取：

最后来编译运行：

可见，通过按行读取的方式，也同样达到了回射客户/服务器端的效果，并且也解决了粘包问题。

下面贴出服务端与客户端修改后的完整代码：

echosrv.c:

  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <arpa/inet.h>
  6.  
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <errno.h>
  10. #include <string.h>
  11.  
  12. #define ERR_EXIT(m) \
  13.         do \
  14.         { \
  15.                 perror(m); \
  16.                 exit(EXIT_FAILURE); \
  17.         } while()
  18.  
  19. ssize_t readn(int fd, void *buf, size_t count)
  20. {
  21.     size_t nleft = count;
  22.     ssize_t nread;
  23.     char *bufp = (char*)buf;
  24.  
  25.     while (nleft > )
  26.     {
  27.         if ((nread = read(fd, bufp, nleft)) < )
  28.         {
  29.             if (errno == EINTR)
  30.                 continue;
  31.             return -;
  32.         }
  33.         else if (nread == )
  34.             return count - nleft;
  35.  
  36.         bufp += nread;
  37.         nleft -= nread;
  38.     }
  39.  
  40.     return count;
  41. }
  42.  
  43. ssize_t writen(int fd, const void *buf, size_t count)
  44. {
  45.     size_t nleft = count;
  46.     ssize_t nwritten;
  47.     char *bufp = (char*)buf;
  48.  
  49.     while (nleft > )
  50.     {
  51.         if ((nwritten = write(fd, bufp, nleft)) < )
  52.         {
  53.             if (errno == EINTR)
  54.                 continue;
  55.             return -;
  56.         }
  57.         else if (nwritten == )
  58.             continue;
  59.  
  60.         bufp += nwritten;
  61.         nleft -= nwritten;
  62.     }
  63.  
  64.     return count;
  65. }
  66.  
  67. ssize_t recv_peek(int sockfd, void *buf, size_t len)
  68. {
  69.     while ()
  70.     {
  71.         int ret = recv(sockfd, buf, len, MSG_PEEK);
  72.         if (ret == - && errno == EINTR)
  73.             continue;
  74.         return ret;
  75.     }
  76. }
  77.  
  78. ssize_t readline(int sockfd, void *buf, size_t maxline)
  79. {
  80.     int ret;
  81.     int nread;//已读字节数
  82.     char *bufp = buf;
  83.     int nleft = maxline;//剩余字节数
  84.     while ()
  85.     {
  86.         ret = recv_peek(sockfd, bufp, nleft);
  87.         if (ret < )//证明读取失败了
  88.             return ret;
  89.         else if (ret == )//证明是对方关闭了
  90.             return ret;
  91.  
  92.         nread = ret;
  93.  
  94.         int i;
  95.         for (i=; i<nread; i++)
  96.         {
  97.             if (bufp[i] == '\n')
  98.             {
  99.                 ret = readn(sockfd, bufp, i+);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样
  100.                 if (ret != i+)//如果读出来的字符数不等于i+1，则说明读取失败了
  101.                     exit(EXIT_FAILURE);
  102.  
  103.                 return ret;
  104.             }
  105.         }
  106.  
  107.         if (nread > nleft)//这种情况说明也是读取有问题的
  108.             exit(EXIT_FAILURE);
  109.  
  110.         //执行到此则说明没有找到"\n"字符,这时读取数据然后清空缓冲区
  111.         nleft -= nread;
  112.         ret = readn(sockfd, bufp, nread);
  113.         if (ret != nread)
  114.             exit(EXIT_FAILURE);
  115.  
  116.         bufp += nread;//再继续读后面的
  117.     }
  118.  
  119.     return -;//执行到此，则说明失败了
  120. }
  121.  
  122. void do_service(int conn)
  123. {
  124.     char recvbuf[];
  125.     while ()
  126.     {
  127.         memset(recvbuf, , sizeof(recvbuf));
  128.         int ret = readline(conn, recvbuf, );
  129.         if (ret == -)
  130.             ERR_EXIT("readline");
  131.         if (ret == )
  132.         {
  133.             printf("client close\n");
  134.             break;
  135.         }
  136.         fputs(recvbuf, stdout);
  137.         writen(conn, recvbuf, strlen(recvbuf));
  138.     }
  139. }
  140.  
  141. int main(void)
  142. {
  143.     int listenfd;
  144.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
  145. /*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
  146.         ERR_EXIT("socket");
  147.  
  148.     struct sockaddr_in servaddr;
  149.     memset(&servaddr, , sizeof(servaddr));
  150.     servaddr.sin_family = AF_INET;
  151.     servaddr.sin_port = htons();
  152.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  153.     /*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
  154.     /*inet_aton("127.0.0.1", &servaddr.sin_addr);*/
  155.  
  156.     int on = ;
  157.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
  158.         ERR_EXIT("setsockopt");
  159.  
  160.     if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
  161.         ERR_EXIT("bind");
  162.     if (listen(listenfd, SOMAXCONN) < )
  163.         ERR_EXIT("listen");
  164.  
  165.     struct sockaddr_in peeraddr;
  166.     socklen_t peerlen = sizeof(peeraddr);
  167.     int conn;
  168.  
  169.     pid_t pid;
  170.     while ()
  171.     {
  172.         if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < )
  173.             ERR_EXIT("accept");
  174.  
  175.         printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
  176.  
  177.         pid = fork();
  178.         if (pid == -)
  179.             ERR_EXIT("fork");
  180.         if (pid == )
  181.         {
  182.             close(listenfd);
  183.             do_service(conn);
  184.             exit(EXIT_SUCCESS);
  185.         }
  186.         else
  187.             close(conn);
  188.     }
  189.  
  190.     return ;
  191. }

echocli.c:

  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <arpa/inet.h>
  6.  
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <errno.h>
  10. #include <string.h>
  11.  
  12. #define ERR_EXIT(m) \
  13.         do \
  14.         { \
  15.                 perror(m); \
  16.                 exit(EXIT_FAILURE); \
  17.         } while()
  18.  
  19. ssize_t readn(int fd, void *buf, size_t count)
  20. {
  21.     size_t nleft = count;
  22.     ssize_t nread;
  23.     char *bufp = (char*)buf;
  24.  
  25.     while (nleft > )
  26.     {
  27.         if ((nread = read(fd, bufp, nleft)) < )
  28.         {
  29.             if (errno == EINTR)
  30.                 continue;
  31.             return -;
  32.         }
  33.         else if (nread == )
  34.             return count - nleft;
  35.  
  36.         bufp += nread;
  37.         nleft -= nread;
  38.     }
  39.  
  40.     return count;
  41. }
  42.  
  43. ssize_t writen(int fd, const void *buf, size_t count)
  44. {
  45.     size_t nleft = count;
  46.     ssize_t nwritten;
  47.     char *bufp = (char*)buf;
  48.  
  49.     while (nleft > )
  50.     {
  51.         if ((nwritten = write(fd, bufp, nleft)) < )
  52.         {
  53.             if (errno == EINTR)
  54.                 continue;
  55.             return -;
  56.         }
  57.         else if (nwritten == )
  58.             continue;
  59.  
  60.         bufp += nwritten;
  61.         nleft -= nwritten;
  62.     }
  63.  
  64.     return count;
  65. }
  66.  
  67. ssize_t recv_peek(int sockfd, void *buf, size_t len)
  68. {
  69.     while ()
  70.     {
  71.         int ret = recv(sockfd, buf, len, MSG_PEEK);
  72.         if (ret == - && errno == EINTR)
  73.             continue;
  74.         return ret;
  75.     }
  76. }
  77.  
  78. ssize_t readline(int sockfd, void *buf, size_t maxline)
  79. {
  80.     int ret;
  81.     int nread;//已读字节数
  82.     char *bufp = buf;
  83.     int nleft = maxline;//剩余字节数
  84.     while ()
  85.     {
  86.         ret = recv_peek(sockfd, bufp, nleft);
  87.         if (ret < )//证明读取失败了
  88.             return ret;
  89.         else if (ret == )//证明是对方关闭了
  90.             return ret;
  91.  
  92.         nread = ret;
  93.  
  94.         int i;
  95.         for (i=; i<nread; i++)
  96.         {
  97.             if (bufp[i] == '\n')
  98.             {
  99.                 ret = readn(sockfd, bufp, i+);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样
  100.                 if (ret != i+)//如果读出来的字符数不等于i+1，则说明读取失败了
  101.                     exit(EXIT_FAILURE);
  102.  
  103.                 return ret;
  104.             }
  105.         }
  106.  
  107.         if (nread > nleft)//这种情况说明也是读取有问题的
  108.             exit(EXIT_FAILURE);
  109.  
  110.         //执行到此则说明没有找到"\n"字符,这时读取数据然后清空缓冲区
  111.         nleft -= nread;
  112.         ret = readn(sockfd, bufp, nread);
  113.         if (ret != nread)
  114.             exit(EXIT_FAILURE);
  115.  
  116.         bufp += nread;//再继续读后面的
  117.     }
  118.  
  119.     return -;//执行到此，则说明失败了
  120. }
  121.  
  122. int main(void)
  123. {
  124.     int sock;
  125.     if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
  126.         ERR_EXIT("socket");
  127.  
  128.     struct sockaddr_in servaddr;
  129.     memset(&servaddr, , sizeof(servaddr));
  130.     servaddr.sin_family = AF_INET;
  131.     servaddr.sin_port = htons();
  132.     servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  133.  
  134.     if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
  135.         ERR_EXIT("connect");
  136.  
  137.     char sendbuf[] = {};
  138.     char recvbuf[] = {};
  139.     while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
  140.     {
  141.         writen(sock, sendbuf, strlen(sendbuf));
  142.  
  143.         int ret = readline(sock, recvbuf, sizeof(recvbuf));
  144.         if (ret == -)
  145.                 ERR_EXIT("readline");
  146.         else if (ret == )
  147.         {
  148.                 printf("client close\n");
  149.                 break;
  150.         }
  151.  
  152.         fputs(recvbuf, stdout);
  153.         memset(sendbuf, , sizeof(sendbuf));
  154.         memset(recvbuf, , sizeof(recvbuf));
  155.     }
  156.  
  157.     return ;
  158. }

接下来需要学习几个新的函数，之后的学习会用到，如下：

getsockname:获取套接口本地的地址

当客户端成功与服务端连接之后，如果想知道客户端的地址，就可以通过它来获取，修改代码如下：

然后编译运行：

getpeername:获取对等方的地址

由于它的使用方法跟getsockname一样，这里就不说明了，注意：sockfd需是连接成功的套接口，另外对于服务端获取客户端ip，像这种情况下也需用这个接口来获得：

gethostname:获取主机的名称

gethostbyname:通过主机名来获取主机上所有的ip地址

下面利用上面的函数，来获取主机上所有的ip地址：

编译运行：

查看man：

于是加入该头文件：

再次编译：

可能本地ip列表有多个，但是一般来说默认本机ip都是第一个，所以，对于获得本机ip可以将其封装成一个方法，便于之后直接调用，如下：

  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <arpa/inet.h>
  6. #include <netdb.h>
  7.  
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <errno.h>
  11. #include <string.h>
  12.  
  13. #define ERR_EXIT(m) \
  14.         do \
  15.         { \
  16.                 perror(m); \
  17.                 exit(EXIT_FAILURE); \
  18.         } while()
  19.  
  20. int getlocalip(char *ip)
  21. {
  22.     char host[100] = {0};
  23.     if (gethostname(host, sizeof(host)) < 0)
  24.       return -1;
  25.     struct hostent *hp;
  26.     if ((hp = gethostbyname(host)) == NULL)
  27.       return -1;
  28.     strcpy(ip, inet_ntoa(*(struct in_addr*)hp->h_addr_list[0]));
  29.     return 0;
  31. }
  33. int main(void)
  34. {
  35.     char host[] = {};
  36.     if (gethostname(host, sizeof(host)) < )
  37.         ERR_EXIT("gethostname");
  38.  
  39.     struct hostent *hp;
  40.     if ((hp = gethostbyname(host)) == NULL)
  41.         ERR_EXIT("gethostbyname");
  42.  
  43.     int i = ;
  44.     while (hp->h_addr_list[i] != NULL)
  45.     {
  46.         printf("%s\n", inet_ntoa(*(struct in_addr*)hp->h_addr_list[i]));
  47.         i++;
  48.     }
  49.  
  50.     char ip[] = {};
  51.     getlocalip(ip);
  52.     printf("localip=%s\n", ip);
  53.     return ;
  54. }

编译运行：

另外，通过man帮助可以查看到一点：

那得到的信息就可以将上面获得默认地址用它进行替换：

好了，今天的学到到这，下节继续~

linux网络编程之socket编程(五)的更多相关文章

  1. linux网络编程之socket编程(十五)

    今天继续学习socket编程,这次主要是学习UNIX域协议相关的知识,下面开始: [有个大概的认识,它是来干嘛的] ①.UNIX域套接字与TCP套接字相比较,在同一台主机的传输速度前者是后者的两倍. ...

  2. linux网络编程之socket编程(六)

    经过一个国庆长假,又有一段时间没有写博文了,今天继续对linux网络编程进行学习,如今的北京又全面进入雾霾天气了,让我突然想到了一句名句:“真爱生活,珍惜生命”,好了,言归正传. 回顾一下我们之间实现 ...

  3. linux网络编程之socket编程(四)

    经过两周的等待,终于可以回归我正常的学习之旅了,表哥来北京了在我这暂住,晚上回家了基本在和他聊天,周末带他在北京城到处乱转,几乎剥夺了我自由学习的时间了,不过,亲人之情还是很难得的,工作学习并不是生活 ...

  4. linux网络编程之socket编程(一)

    今天开始,继续来学习linux编程,这次主要是研究下linux下的网络编程,而网络编程中最基本的需从socket编程开始,下面正式开始学习: 什么是socket: 在学习套接口之前,先要回顾一下Tcp ...

  5. linux网络编程之socket编程(八)

    学习socket编程继续,今天要学习的内容如下: 先来简单介绍一下这五种模型分别是哪些,偏理论,有个大致的印象就成,做个对比,因为最终只会研究一个I/O模型,也是经常会用到的, 阻塞I/O: 先用一个 ...

  6. linux网络编程之socket编程(十六)

    继续学习socket编程,今天的内容会有些难以理解,一步步来分解,也就不难了,正入正题: 实际上sockpair有点像之前linux系统编程中学习的pipe匿名管道,匿名管道它是半双工的,只能用于亲缘 ...

  7. linux网络编程之socket编程(三)

    今天继续对socket编程进行学习,在学习之前,需要回顾一下上一篇中编写的回射客户/服务器程序(http://www.cnblogs.com/webor2006/p/3923254.html),因为今 ...

  8. linux网络编程之socket编程(二)

    今天继续对socket编程进行研究,这里会真正开如用socket写一个小例子,进入正题: TCP客户/服务器模型:   关于这个模型的流程这里就不多说了,比较容易理解,下面则利用这种模型来编写一个实际 ...

  9. linux网络编程之socket编程(十二)

    今天继续学习socket编程,期待的APEC会议终于在京召开了,听说昨晚鸟巢那灯火通明,遍地礼花,有点08年奥运会的架势,有种冲动想去瞅见一下习大大的真容,"伟大的祖国,我爱你~~~&quo ...

随机推荐

  1. Configuration system failed to initialize

    引用:https://cloud.tencent.com/developer/article/1336954 重装.net Framework

  2. 实验1 C 语言开发环境使用和数据类型、运算符、表达式

    # include <stdio.h> int main() { int x; printf("x:\n"); scanf("%d",&x) ...

  3. 深入css过渡transition

    通过过渡transition,可以让web前端开发人员不需要javascript就可以实现简单的动画交互效果.过渡属性看似简单,但实际上它有很多需要注意的细节和容易混淆的地方. 过渡transitio ...

  4. 按键板的原理与实现 扩展GPIO

    在系统可用的GPIO口数量有限的情况下实现按键板的另一个选择就是:扩展GPIO口.扩展GPIO的方法有很多,市场上已经有很多种类的GPIO口扩展器件,但是从成本上考虑,但它们总是显得昂贵.对于按键板的 ...

  5. js原生导出excel和csv

    ​ 严格意义来说并不是真正的excel文件,只是可以用excel打开查看而已,实际上的格式是逗号分隔文件即csv文件. 这里有几个坑要说一下: 不加Unicode的utf8头部标识excel打开文件会 ...

  6. 《ucore lab8》实验报告

    资源 ucore在线实验指导书 我的ucore实验代码 练习1: 完成读文件操作的实现(需要编码) 题目 首先了解打开文件的处理流程,然后参考本实验后续的文件读写操作的过程分析,编写在sfs_inod ...

  7. PHP 与操作判断奇偶

    /** * 判断奇偶数 * @param $n * @return int */ function isOdd($n){ // $a & $b And(按位与) 将把 $a 和 $b 中都为 ...

  8. Rust零碎总结

    1.Rust里没有null的概念,但是实际上有很多地方是需要null的概念的,这个时候就可以用Option来代替,它是泛型T的一个包装类,就是C#里的int?或Java里的Optional: [但反序 ...

  9. 016 Android 图片选择器(在选中和未选中的过程中,切换展示图片)

    1.目标效果 在选中和未选中的过程中,切换展示图片 2.实现方法 (1)在app--->res--->drawable 右击drawable文件夹右键,new ---->drawab ...

  10. STM32之串口波特率计算

    1.1 波特率结构框图 1.2 波特率寄存器示意图 1.3 波特率计算公式示意图 两图看出,串口波特率寄存器是一个32位,只用低16位,低16位又划分,低4位用来装小数,其他用来装整数. 波特率计算公 ...