linux网络编程之socket编程(五)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
    int ret;
    int nread;//已读字节数
    char *bufp = buf;
    int nleft = maxline;//剩余字节数
    while (1)
    {
        ret = recv_peek(sockfd, bufp, nleft);
        if (ret < 0)//证明读取失败了
            return ret;
        else if (ret == 0)//证明是对方关闭了
            return ret;

        nread = ret;

        int i;
        for (i=0; i<nread; i++)
        {
            if (bufp[i] == '
')
            {
                ret = readn(sockfd, bufp, i+1);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样
                if (ret != i+1)//如果读出来的字符数不等于i+1，则说明读取失败了
                    exit(EXIT_FAILURE);

                return ret;
            }
        }

        if (nread > nleft)//这种情况说明也是读取有问题的
            exit(EXIT_FAILURE);

        //执行到此则说明没有找到"
"字符,这时读取数据然后清空缓冲区
        nleft -= nread;
        ret = readn(sockfd, bufp, nread);
        if (ret != nread)
            exit(EXIT_FAILURE);

        bufp += nread;//再继续读后面的
    }

    return -1;//执行到此，则说明失败了
}

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

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

对于客户端修改也同理：

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

然后也改成按行读取：

最后来编译运行：

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

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

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(0)

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nread;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nread = read(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nread == 0)
            return count - nleft;

        bufp += nread;
        nleft -= nread;
    }

    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nwritten == 0)
            continue;

        bufp += nwritten;
        nleft -= nwritten;
    }

    return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
            continue;
        return ret;
    }
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
    int ret;
    int nread;//已读字节数
    char *bufp = buf;
    int nleft = maxline;//剩余字节数
    while (1)
    {
        ret = recv_peek(sockfd, bufp, nleft);
        if (ret < 0)//证明读取失败了
            return ret;
        else if (ret == 0)//证明是对方关闭了
            return ret;

        nread = ret;

        int i;
        for (i=0; i<nread; i++)
        {
            if (bufp[i] == '
')
            {
                ret = readn(sockfd, bufp, i+1);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样
                if (ret != i+1)//如果读出来的字符数不等于i+1，则说明读取失败了
                    exit(EXIT_FAILURE);

                return ret;
            }
        }

        if (nread > nleft)//这种情况说明也是读取有问题的
            exit(EXIT_FAILURE);

        //执行到此则说明没有找到"
"字符,这时读取数据然后清空缓冲区
        nleft -= nread;
        ret = readn(sockfd, bufp, nread);
        if (ret != nread)
            exit(EXIT_FAILURE);

        bufp += nread;//再继续读后面的
    }

    return -1;//执行到此，则说明失败了
}

void do_service(int conn)
{
    char recvbuf[1024];
    while (1)
    {
        memset(recvbuf, 0, sizeof(recvbuf));
        int ret = readline(conn, recvbuf, 1024);
        if (ret == -1)
            ERR_EXIT("readline");
        if (ret == 0)
        {
            printf("client close
");
            break;
        }
        fputs(recvbuf, stdout);
        writen(conn, recvbuf, strlen(recvbuf));
    }
}

int main(void)
{
    int listenfd;
    if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
/*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    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 = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt");

    if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind");
    if (listen(listenfd, SOMAXCONN) < 0)
        ERR_EXIT("listen");

    struct sockaddr_in peeraddr;
    socklen_t peerlen = sizeof(peeraddr);
    int conn;
    
    pid_t pid;
    while (1)
    {
        if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
            ERR_EXIT("accept");

        printf("ip=%s port=%d
", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));

        pid = fork();
        if (pid == -1)
            ERR_EXIT("fork");
        if (pid == 0)
        {
            close(listenfd);
            do_service(conn);
            exit(EXIT_SUCCESS);
        }
        else
            close(conn);
    }
    
    return 0;
}

echocli.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(0)

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nread;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nread = read(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nread == 0)
            return count - nleft;

        bufp += nread;
        nleft -= nread;
    }

    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nwritten == 0)
            continue;

        bufp += nwritten;
        nleft -= nwritten;
    }

    return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
            continue;
        return ret;
    }
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
    int ret;
    int nread;//已读字节数
    char *bufp = buf;
    int nleft = maxline;//剩余字节数
    while (1)
    {
        ret = recv_peek(sockfd, bufp, nleft);
        if (ret < 0)//证明读取失败了
            return ret;
        else if (ret == 0)//证明是对方关闭了
            return ret;

        nread = ret;

        int i;
        for (i=0; i<nread; i++)
        {
            if (bufp[i] == '
')
            {
                ret = readn(sockfd, bufp, i+1);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样
                if (ret != i+1)//如果读出来的字符数不等于i+1，则说明读取失败了
                    exit(EXIT_FAILURE);

                return ret;
            }
        }

        if (nread > nleft)//这种情况说明也是读取有问题的
            exit(EXIT_FAILURE);

        //执行到此则说明没有找到"
"字符,这时读取数据然后清空缓冲区
        nleft -= nread;
        ret = readn(sockfd, bufp, nread);
        if (ret != nread)
            exit(EXIT_FAILURE);

        bufp += nread;//再继续读后面的
    }

    return -1;//执行到此，则说明失败了
}

int main(void)
{
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("connect");

    char sendbuf[1024] = {0};
    char recvbuf[1024] = {0};
    while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
    {
        writen(sock, sendbuf, strlen(sendbuf));

        int ret = readline(sock, recvbuf, sizeof(recvbuf));
        if (ret == -1)
                ERR_EXIT("readline");
        else if (ret == 0)
        {
                printf("client close
");
                break;
        }

        fputs(recvbuf, stdout);
        memset(sendbuf, 0, sizeof(sendbuf));
        memset(recvbuf, 0, sizeof(recvbuf));
    }
    
    return 0;
}

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

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

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

然后编译运行：

getpeername:获取对等方的地址

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

gethostname:获取主机的名称

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

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

编译运行：

查看man：

于是加入该头文件：

再次编译：

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

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) 
        do 
        { 
                perror(m); 
                exit(EXIT_FAILURE); 
        } while(0)

int getlocalip(char *ip)
{
    char host[100] = {0};
    if (gethostname(host, sizeof(host)) < 0)
      return -1;
    struct hostent *hp;
    if ((hp = gethostbyname(host)) == NULL)
      return -1;
    strcpy(ip, inet_ntoa(*(struct in_addr*)hp->h_addr_list[0]));
    return 0;

}

int main(void)
{
    char host[100] = {0};
    if (gethostname(host, sizeof(host)) < 0)
        ERR_EXIT("gethostname");

    struct hostent *hp;
    if ((hp = gethostbyname(host)) == NULL)
        ERR_EXIT("gethostbyname");

    int i = 0;
    while (hp->h_addr_list[i] != NULL)
    {
        printf("%s
", inet_ntoa(*(struct in_addr*)hp->h_addr_list[i]));
        i++;
    }
    
    char ip[16] = {0};
    getlocalip(ip);
    printf("localip=%s
", ip);
    return 0;
}

编译运行：

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

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

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