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。

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

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

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

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

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

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

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

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

ssize_t readline(int sockfd, void *buf, size_t maxline)

{

    int ret;

    int nread;//已读字节数

    char *bufp = buf;

    int nleft = maxline;//剩余字节数

    while ()

    {

        ret = recv_peek(sockfd, bufp, nleft);

        if (ret < )//证明读取失败了

            return ret;

        else if (ret == )//证明是对方关闭了

            return ret;

        nread = ret;

        int i;

        for (i=; i<nread; i++)

        {

            if (bufp[i] == '\n')

            {

                ret = readn(sockfd, bufp, i+);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样

                if (ret != i+)//如果读出来的字符数不等于i+1，则说明读取失败了

                    exit(EXIT_FAILURE);

                return ret;

            }

        }

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

            exit(EXIT_FAILURE);

        //执行到此则说明没有找到"\n"字符,这时读取数据然后清空缓冲区

        nleft -= nread;

        ret = readn(sockfd, bufp, nread);

        if (ret != nread)

            exit(EXIT_FAILURE);

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

    }

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

}

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

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

对于客户端修改也同理：

首先将我们封装的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()

ssize_t readn(int fd, void *buf, size_t count)

{

    size_t nleft = count;

    ssize_t nread;

    char *bufp = (char*)buf;

    while (nleft > )

    {

        if ((nread = read(fd, bufp, nleft)) < )

        {

            if (errno == EINTR)

                continue;

            return -;

        }

        else if (nread == )

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

    {

        if ((nwritten = write(fd, bufp, nleft)) < )

        {

            if (errno == EINTR)

                continue;

            return -;

        }

        else if (nwritten == )

            continue;

        bufp += nwritten;

        nleft -= nwritten;

    }

    return count;

}

ssize_t recv_peek(int sockfd, void *buf, size_t len)

{

    while ()

    {

        int ret = recv(sockfd, buf, len, MSG_PEEK);

        if (ret == - && 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 ()

    {

        ret = recv_peek(sockfd, bufp, nleft);

        if (ret < )//证明读取失败了

            return ret;

        else if (ret == )//证明是对方关闭了

            return ret;

        nread = ret;

        int i;

        for (i=; i<nread; i++)

        {

            if (bufp[i] == '\n')

            {

                ret = readn(sockfd, bufp, i+);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样

                if (ret != i+)//如果读出来的字符数不等于i+1，则说明读取失败了

                    exit(EXIT_FAILURE);

                return ret;

            }

        }

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

            exit(EXIT_FAILURE);

        //执行到此则说明没有找到"\n"字符,这时读取数据然后清空缓冲区

        nleft -= nread;

        ret = readn(sockfd, bufp, nread);

        if (ret != nread)

            exit(EXIT_FAILURE);

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

    }

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

}

void do_service(int conn)

{

    char recvbuf[];

    while ()

    {

        memset(recvbuf, , sizeof(recvbuf));

        int ret = readline(conn, recvbuf, );

        if (ret == -)

            ERR_EXIT("readline");

        if (ret == )

        {

            printf("client close\n");

            break;

        }

        fputs(recvbuf, stdout);

        writen(conn, recvbuf, strlen(recvbuf));

    }

}

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

    {

        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 = fork();

        if (pid == -)

            ERR_EXIT("fork");

        if (pid == )

        {

            close(listenfd);

            do_service(conn);

            exit(EXIT_SUCCESS);

        }

        else

            close(conn);

    }

    return ;

}

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

ssize_t readn(int fd, void *buf, size_t count)

{

    size_t nleft = count;

    ssize_t nread;

    char *bufp = (char*)buf;

    while (nleft > )

    {

        if ((nread = read(fd, bufp, nleft)) < )

        {

            if (errno == EINTR)

                continue;

            return -;

        }

        else if (nread == )

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

    {

        if ((nwritten = write(fd, bufp, nleft)) < )

        {

            if (errno == EINTR)

                continue;

            return -;

        }

        else if (nwritten == )

            continue;

        bufp += nwritten;

        nleft -= nwritten;

    }

    return count;

}

ssize_t recv_peek(int sockfd, void *buf, size_t len)

{

    while ()

    {

        int ret = recv(sockfd, buf, len, MSG_PEEK);

        if (ret == - && 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 ()

    {

        ret = recv_peek(sockfd, bufp, nleft);

        if (ret < )//证明读取失败了

            return ret;

        else if (ret == )//证明是对方关闭了

            return ret;

        nread = ret;

        int i;

        for (i=; i<nread; i++)

        {

            if (bufp[i] == '\n')

            {

                ret = readn(sockfd, bufp, i+);//由于readn中是用的read函数读取，所以读取数据之后会将清空缓冲区，也正好需要这样

                if (ret != i+)//如果读出来的字符数不等于i+1，则说明读取失败了

                    exit(EXIT_FAILURE);

                return ret;

            }

        }

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

            exit(EXIT_FAILURE);

        //执行到此则说明没有找到"\n"字符,这时读取数据然后清空缓冲区

        nleft -= nread;

        ret = readn(sockfd, bufp, nread);

        if (ret != nread)

            exit(EXIT_FAILURE);

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

    }

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

}

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");

    char sendbuf[] = {};

    char recvbuf[] = {};

    while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)

    {

        writen(sock, sendbuf, strlen(sendbuf));

        int ret = readline(sock, recvbuf, sizeof(recvbuf));

        if (ret == -)

                ERR_EXIT("readline");

        else if (ret == )

        {

                printf("client close\n");

                break;

        }

        fputs(recvbuf, stdout);

        memset(sendbuf, , sizeof(sendbuf));

        memset(recvbuf, , sizeof(recvbuf));

    }

    return ;

}

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

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

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[] = {};

    if (gethostname(host, sizeof(host)) < )

        ERR_EXIT("gethostname");

    struct hostent *hp;

    if ((hp = gethostbyname(host)) == NULL)

        ERR_EXIT("gethostbyname");

    int i = ;

    while (hp->h_addr_list[i] != NULL)

    {

        printf("%s\n", inet_ntoa(*(struct in_addr*)hp->h_addr_list[i]));

        i++;

    }

    char ip[] = {};

    getlocalip(ip);

    printf("localip=%s\n", ip);

    return ;

}

编译运行：

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

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

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

巴特西

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

最新文章

热门文章