Linux：服务器/客户端API调用错误检查

昨天和今天上午，我分别实现简单的服务器和客户端，运行之后表示没问题，一切正常。但是这还是有问题的，最大的一个就是没有错误检查。现在我们来加上错误检查：

服务器的代码：

#include
<stdio.h>

#include
<ctype.h>

#include
<unistd.h>

#include
<sys/types.h>

#include
<arpa/inet.h>

#include
<sys/socket.h>

#include
<stdlib.h>

 

#define
SERV_PORT 9527 //不能过大也不能过小

 

int main(void)

{

    int sfd; //服务器的socket文件描述符

    int cfd; //客户端的socket文件描述符

    struct
sockaddr_in serv_addr; //服务器的地址结构体

    struct
sockaddr_in clie_addr; //客户端的地址结构体

    socklen_t clie_len; //客户端的地址结构的大小

    char buf[BUFSIZ]; //用于储存客户端发来的信息

 

                                        //第一个参数是指定IPV4协议族，第二个参数是指定TCP协议，第三个参数是使用默认的协议，一般都是用0

    if (-1 == (sfd = socket(AF_INET, SOCK_STREAM, 0)))//创建服务器的socket文件

    {

        perror("socket error");

        exit(1);

    }

 

    //赋值服务器地址结构体

    serv_addr.sin_family = AF_INET; //选择协议族位IPV4

    serv_addr.sin_port = htons(SERV_PORT); //监听本地所有的IP地址；INADDR_ANY表示的是一个服务器上所有的网卡（服务器可能不止一个网卡）多个本地ip地址都进行绑定端口号，进行侦听。

    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); //绑定我们自定义的端口号9527

 

                                                 //第一个参数是服务器的socket文件描述符，第二个参数要强转为sockaddr，原因后面会说；第三个参数是服务器地址结构体的大小

    if (-1 == (bind(sfd, (struct
sockaddr*)&serv_addr, sizeof(serv_addr))))//绑定服务器地址结构体

    {

        perror("bind error");

        exit(1);

    }

    //服务器能够同时接受多少个客户端连接，默认128.

    if (-1 == (listen(sfd, 32)))

    {

        perror("listen error");

        exit(1);

    }

 

    //确定客户端地址结构大小，用于accept函数使用

    clie_len = sizeof(clie_addr);

 

    //连接客户端，返回一个新的socket文件描述符。第一个参数时服务器socket文件描述符，第二个时客户端地址结构体，这里也要强转，第三个是客户端地址的大小，注意的是：第二个是传出参数，第三个 是传入传出参数

    if (-1 == (cfd = accept(sfd, (struct
sockaddr*)&clie_addr, &clie_len)))

    {

        perror("accept error");

        exit(1);

    }

 

    while (1)

    {

        int n = read(cfd, buf, sizeof(buf));//从客户端读

        for (int i = 0; i < n; i++)

            buf[i] = toupper(buf[i]);

        write(cfd, buf, n);//写到客户端

    }

    //关闭文件描述符

    close(sfd);

    close(cfd);

}

客户端的代码：

#include
<string.h>

#include
<sys/types.h>

#include
<sys/socket.h>

#include
<stdio.h>

#include
<stdlib.h>

#include
<unistd.h>

#include
<sys/stat.h>

#include
<arpa/inet.h>

#include
<netinet/in.h>

#define
ADDR_POST 9527

int main(void)

{

    int c_fd;

    int len;

    char buf[BUFSIZ];

    struct
sockaddr_in clie_addr;

    socklen_t addr_len;

 

    if ((c_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)

    {

        perror("socket error");

        exit(1);

    }

 

 

    if (-1 == (inet_pton(AF_INET, "127.0.0.1", &clie_addr.sin_addr.s_addr)))

    {

        perror("inet_pton error");

        exit(1);

    }

    clie_addr.sin_family = AF_INET;

    clie_addr.sin_port = htons(ADDR_POST);

 

    if (-1 == (connect(c_fd, (struct
sockaddr*)&clie_addr, sizeof(clie_addr))))

    {

        perror("connect error");

        exit(1);

    }

 

    while (1)

    {

        fgets(buf, sizeof(buf), stdin);

        write(c_fd, buf, strlen(buf));

        len = read(c_fd, buf, sizeof(buf));

        write(STDOUT_FILENO, buf, len);

    }

    close(c_fd);

 

    return 0;

}

哇，好累的啊。这样检查效率好低，并且严重的扰乱了代码逻辑，并且还没检查完所有的函数，不行，得换方法了。

方法就是：封装！

    我们自己实现一个同名函数（首字母大小），在新函数中调用原来的系统函数。并且做错误处理。头文件：my_error.h

#ifndef __WRAP_H_

#define
__WRAP_H_

void perr_exit(const
char *s);

int Accept(int
fd, struct
sockaddr *sa, socklen_t *salenptr);

int Bind(int
fd, const
struct
sockaddr *sa, socklen_t
salen);

int Connect(int
fd, const
struct
sockaddr *sa, socklen_t
salen);

int Listen(int
fd, int
backlog);

int Socket(int
family, int
type, int
protocol);

ssize_t Read(int
fd, void *ptr, size_t
nbytes);

ssize_t Write(int
fd, const
void *ptr, size_t
nbytes);

int Close(int
fd);

ssize_t Readn(int
fd, void *vptr, size_t
n);

ssize_t Writen(int
fd, const
void *vptr, size_t
n);

ssize_t my_read(int
fd, char *ptr);

ssize_t Readline(int
fd, void *vptr, size_t
maxlen);

#endif

然后是实现：my_error.c

#include
<string.h>

#include
<sys/types.h>

#include
<sys/socket.h>

#include
<stdio.h>

#include
<stdlib.h>

#include
<unistd.h>

#include
<sys/stat.h>

#include
<arpa/inet.h>

#include
<netinet/in.h>

#include
<errno.h>

void perr_exit(const
char *s)

{

    perror(s);

    exit(1);

}

int Accept(int
fd, struct
sockaddr *sa, socklen_t *salenptr)

{

    int n;

again: //accrpt是慢速系统调用，在阻塞期间可能会被信号杀死

    if ((n = accept(fd, sa, salenptr)) < 0) {

        if ((errno == ECONNABORTED) || (errno == EINTR))//进一步判断返回值，EINTR代表函数被信号中断；ECONNABORTED代表连接中断，这两种情况不算是异常，所以重启

            goto again;

        else

            perr_exit("accept error");

    }

    return n;

}

int Bind(int
fd, const
struct
sockaddr *sa, socklen_t
salen)

{

    int n;

    if ((n = bind(fd, sa, salen)) < 0)

        perr_exit("bind error");

    return n;

}

int Connect(int
fd, const
struct
sockaddr *sa, socklen_t
salen)

{

    int n;

    if ((n = connect(fd, sa, salen)) < 0)

        perr_exit("connect error");

    return n;

}

int Listen(int
fd, int
backlog)

{

    int n;

    if ((n = listen(fd, backlog)) < 0)

        perr_exit("listen error");

    return n;

}

int Socket(int
family, int
type, int
protocol)

{

    int n;

    if ((n = socket(family, type, protocol)) < 0)

        perr_exit("socket error");

    return n;

}

ssize_t Read(int
fd, void *ptr, size_t
nbytes)

{

    ssize_t n;

again: //read也是慢速系统调用。

    if ((n = read(fd, ptr, nbytes)) == -1) {

        if (errno == EINTR)

            goto again;

        else

            return -1;

    }

    return n;

}

ssize_t Write(int
fd, const
void *ptr, size_t
nbytes)

{

    ssize_t n;

again:

    if ((n = write(fd, ptr, nbytes)) == -1) {

        if (errno == EINTR)

            goto again;

        else

            return -1;

    }

    return n;

}

int Close(int
fd)

{

    int n;

    if ((n = close(fd)) == -1)

        perr_exit("close error");

    return n;

}

 

/*

应用场景：以太网帧一次最多发送1500字节的数据，若是我们要读取4096字节的数据，但是4096字节的数据需要四次才能完全发送过来，如果只调用一次read，那就只能读到1500就返回不读了，所以我们需要让系统调用多次，必须读够那么多数据。所以这次调用，n要等于4096

 

//参数三：应该读取到的字节数*/

ssize_t Readn(int
fd, void *vptr, size_t
n)

{

    size_t nleft; //unsigned int 剩余未读取的字节数

    ssize_t nread; //int 实际读取到的字节数

    char *ptr;

 

    ptr = (char*)vptr;

    nleft = n; //n 未读取到的字节数

 

    while (nleft > 0) {

        if ((nread = read(fd, ptr, nleft)) < 0) {

            if (errno == EINTR)// EINTR(表"被信号中断")

                nread = 0; // 读到了0个字节

            else

                return -1;//其他错误

        }

        else
if (nread == 0)// 文件读取完

            break;

        nleft -= nread;

        ptr += nread;

    }

    return
n - nleft;//返回实际读取到的字节数

}

 

ssize_t Writen(int
fd, const
void *vptr, size_t
n)

{

    size_t nleft; //剩余未写的字节数

    ssize_t nwritten; //实际写的字节数

    const
char *ptr;

 

    ptr = (char*)vptr;

    nleft = n; //未写的字节数

 

    while (nleft > 0) {

        if ((nwritten = write(fd, ptr, nleft)) <= 0) {

            if (nwritten < 0 && errno == EINTR)

                nwritten = 0;

            else

                return -1;

        }

        nleft -= nwritten;

        ptr += nwritten;

    }

    return
n;

}

 

static
ssize_t my_read(const
int
fd, char *ptr)

{

    static
int read_cnt;

    static
char *read_ptr;

    static
char read_buf[100];//读一次可以传出100字节，但是不是一次性传出100字节，实际上是一次传一个字符出去

 

    if (read_cnt <= 0) {

    again:

        if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {

            if (errno == EINTR)

                goto again;

            return -1;

        }

        else
if (read_cnt == 0)

            return 0;

        read_ptr = read_buf;

    }

    read_cnt--;

    *ptr = *read_ptr++;

    return 1;

}

/*

应用场景：fgets只能从普通文件或者标准输入输出设备读去数据，他不能从socket中读取数据，所以用readline代替fgets来读取一行

*/

ssize_t Readline(int
fd, void *vptr, size_t
maxlen)

{

    ssize_t n, rc;

    char c, *ptr;

    ptr = (char*)vptr;

 

    for (n = 1; n < maxlen; n++) {

        if ((rc = my_read(fd, &c)) == 1) {

            *ptr++ = c;

            if (c == '\n')

                break;

        }

        else
if (rc == 0) {

            *ptr = 0;

            return n - 1;

        }

        else

            return -1;

    }

    *ptr = 0;

    return n;//返回读到的字节数

}

在这里面。尤其要引起重视的是最后四个函数。在以后的开发中是很有可能用到的。