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;//返回读到的字节数

}

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

巴特西

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

最新文章

热门文章