socket网络编程——错误函数封装

已于 2022-03-29 13:51:14 修改
阅读量356 收藏 2
点赞数
分类专栏： socket 线程 文章标签： c语言 网络编程 socket 错误函数封装
于 2022-03-16 20:43:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42734533/article/details/123531214
版权

错误封装函数

系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。 为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块

错误封装函数

错误函数源码

wrap.c

#include "wrap.h"
/* 打印错误原因并退出 */
void perr_exit(const char *s)
{
    perror(s);
    exit(1);
}
 
//accept()--right:n;error:-1  /* accept出错封装 */
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n;//保存用于通信的socket文件描述符
again:
    if ( (n = accept(fd, sa, salenptr)) < 0)
    {
        if ((errno == ECONNABORTED) || (errno == EINTR))
            goto again;//如果连接终止 或 被信号中断 则再试一次
        else
            perr_exit("accept error");
    }
    return n;
}
 
/* 绑定IP、端口号和socket,出错则返回错误信息 */  // bind()--right:0;error:-1
void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    if (bind(fd, sa, salen) < 0)
        perr_exit("bind error");
}
 
/* 客户机连接服务器函数封装,错误则打印出错信息 */  //connect()--right:0;error:-1
void Connect(int fd, const struct sockaddr *sa, socklen_t salen)

{
	 if (connect(fd, sa, salen) < 0) 
  		 perr_exit("connect error");
}
 
/* listen函数出错处理封装 */  //listen()--right:0;error-1
void Listen(int fd, int backlog)
{
    if (listen(fd, backlog) < 0)
        perr_exit("listen error");
}
 
/* 建立套接字socket出错处理封装 */   //socket()--right:n;error:-1
int Socket(int family, int type, int protocol)
{
    int n;//保存建立socket时返回的文件描述符
    if ( (n = socket(family, type, protocol)) < 0)
        perr_exit("socket error");
    return n;
}
 
/* read函数出错处理封装 */  //read()--right:n;error:-1 
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
    ssize_t n;//读到的字节数
again:
    if ( (n = read(fd, ptr, nbytes)) == -1)
    {
        if (errno == EINTR)
            goto again;//如果是由于信号被中断 则再试一次
        else
            return -1;
    }
    return n;
}



//recv()函数错误封装
ssize_t Recv(int fd,  void *ptr, size_t nbytes, int flags)
{
    ssize_t n;
 again:
    if((n=recv(fd,ptr,nbytes,flags))==-1)
    {
        if (errno == EINTR)
            goto again;//如果是由于信号被中断 则再试一次
        else if(errno ==  EWOULDBLOCK)
       			 {perr_exit("EWOULDBLOCK");}
        else if(errno == EAGAIN)
             {perr_exit("EAGAIN");}
        else
            return -1;
    }
    return n;
}


 
/* write函数出错处理封装 */  //write()--right:n;error:-1
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;
}

//send()函数出错处理封装

ssize_t Send(int fd, const void *ptr, size_t nbytes, int flags)
{
    ssize_t n;
 again:
    if((n=send(fd,ptr,nbytes,flags))==-1)
    {
        if (errno == EINTR)
            goto again;//如果是由于信号被中断 则再试一次
        else if(errno ==  EWOULDBLOCK)
       			 {perr_exit("EWOULDBLOCK");}
        else if(errno == EAGAIN)
             {perr_exit("EAGAIN");}
        else
            return -1;  
    }
    return n;
}
                            
 
/* close关闭文件出错处理封装 */  //close()--right:0;error:-1
void Close(int fd)
{
    if (close(fd) == -1)
        perr_exit("close error");
}
 
/* 至少读满n个字符再返回 */
ssize_t Readn(int fd, void *vptr, size_t n)
{
    size_t nleft;   //剩下的字符数
    ssize_t nread;  //已读的字符数
    char *ptr;      //读写指针
 
    /* 初始化 */
    ptr = vptr;
    nleft = n;
 
    /* 至少读满n个字节返回,或出错返回 */
    while (nleft > 0)
    {
        if ( (nread = read(fd, ptr, nleft)) < 0)//如果读出错
        {
            if (errno == EINTR)//是由于信号中断的话 则退出读
                nread = 0;
            else
                return -1;
        }
        else if (nread == 0)//信号中断 或 读到空 则退出
            break;
 
        nleft -= nread;//记录每次读完,还剩的未读的字节数
        ptr += nread;  //为将下一次读到的值补充到这次的末尾做准备
    }
    return n - nleft;  //返回已读到的字节数
}
 
/* 写满n个字符才返回 */
ssize_t Writen(int fd, const void *vptr, size_t n)
{
    size_t nleft;       //剩下还要写的字节个数
    ssize_t nwritten;   //已经写的字节个数
    const char *ptr;    //写指针
 
    /* 初始化 */
    ptr = 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;
}
 
/*返回第一次调用时字符串的一个字符,调用一次返回下一个字符,供下面的函数调用*/
/* fd为要读的文件 ptr为要返回的字符(为传出参数) */
static ssize_t my_read(int fd, char *ptr)
{
    /* 定义静态变量,上一次调用的值会被保存 */
    static int read_cnt;    //剩下待返回的字符串的长度,系统将其初始化为0
    static char *read_ptr;  //当前读到的位置
    static char read_buf[128];  //读到的字符串
 
    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)//如果读到的字节数为0(即读到的文件为空)
            return 0;
 
        /* 否则有读到内容 则将读指针指向该字符串的首部 */
        read_ptr = read_buf;
    }
 
    //返回当前指向的字符,之后指向下一个字符,供下一调用时使用
    *ptr = *read_ptr++;
    read_cnt--;//剩下待返回的字符串的长度减一
    return 1;//调用成功返回1
}
 
/* 一次读一行 */
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
    ssize_t n, rc;
    char c, *ptr;
 
    ptr = 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;
}

wrap.h

#ifndef __WRAP_H_
#define __WRAP_H_

#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include <sys/types.h>
#include<sys/socket.h>

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
void Bind(int fd, const struct sockaddr *sa, socklen_t salen);
void Connect(int fd, const struct sockaddr *sa, socklen_t salen);
void 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 Recv(int fd, void *ptr, size_t nbytes, int flags);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
ssize_t Send(int fd, const void *ptr, size_t nbytes, int flags);
void Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
static ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif

server

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>  //IP转换函数
#include <ctype.h>  //toupper函数头文件
#include <string.h>

#include "wrap.h"  // 

#define MAXLINE 800
#define SERV_PORT 6666

int main(void)
{
        struct sockaddr_in servaddr, cliaddr;
        socklen_t cliaddr_len;
        int listenfd, connfd;
        char buf[MAXLINE];
        char str[INET_ADDRSTRLEN];
        int i, n;

        listenfd = Socket(AF_INET, SOCK_STREAM, 0);


        /*
        bzero函数
        函数原型：void bzero(void *s,int n)
        作用：bzero函数的作用是将s指针指向的地址的前n个字节清零。
        */
        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port = htons(SERV_PORT);

        Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
        Listen(listenfd, 20);

	    printf("Accepting connections ...\n");
		cliaddr_len=sizeof(cliaddr);
		connfd=Accept(listenfd,(struct sockaddr *)&cliaddr,&cliaddr_len);

	 	while (1)
			{
				n=Read(connfd,buf,MAXLINE);
				if(n==0)
				{break;}
                printf("Data from Client is:%s",buf);
                for(i=0;i<n;i++)
                  buf[i]=toupper(buf[i]);
				Write(connfd, buf, n);
				memset(buf,0,sizeof(buf));
			}
		Close(listenfd);
		Close(connfd);
		return 0;
}

client

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

#include "wrap.h"

#define MAXLINE 800
#define SERV_PORT 6666

int main(void)
{
        struct sockaddr_in servaddr;
        char buf[MAXLINE];
        int sockfd, n;

        sockfd = socket(AF_INET, SOCK_STREAM, 0);

        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        inet_pton(AF_INET, "127.127.0.1", &servaddr.sin_addr);
        servaddr.sin_port = htons(SERV_PORT);

        connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

        while(1)
        {
        fgets(buf,sizeof(buf),stdin);
        write(sockfd,buf, strlen(buf));

        read(sockfd, buf, MAXLINE);
        printf("Response from server:%s",buf);
		memset(buf,0,sizeof(buf));

        }
        close(sockfd);
        return 0;
}

运行结果附图：
在这里插入图片描述

联合编译

以上代码生成可执行文件的方法是在编译运行时输入：

gcc server.c  wrap.c -o server

联合编译——多源文件的编译方法（test.c、testfun.c）

1.多个源文件一起编译，用法：

gcc testfun.c test.c -o test

作用：将testfun .c 和test.c 分别编译后链接成test可执行文件

2.分别编译各个源文件，之后对编译后输出的目标文件进行链接，用法：

gcc -c testfun.c //将testfun.c编译成testfun.o
gcc -c test.c  //将test.c 编译成test.o
gcc -o testfun.o test.o -o test //将testfun.o和test.o链接成test

区别：第一中方法编译时需要所有文件重新编译，而第二种方法可以只重新编译修改的文件，未修改的文件不用重新编译。

3.若要编译的文件在同一个目录下，可以用通配符【gcc *.c -o】来进行编译

4.针对一个项目下存在众多文件时，需要将上述编译过程写进一个文本文件中，即linux下的makefile

PS：接下来将详细介绍，多进程/线程的数据传输：
多进程/多线程通信实例

weixin_42734533
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
socket错误处理函数的封装
Y0uX1Nr3N的博客
04-25 383
为使主程序具有可读性，将socket相关的系统函数的错误处理封装成一个wrap.cwrap.c#include &lt;stdlib.h&gt; #include &lt;errno.h&gt; #include &lt;sys/socket.h&gt; /* 打印错误原因并退出 */ void perr_exit(const char *s) { perror(s); exit(...
linux 网络规避错误类
jiletianzun的博客
03-17 350
说明： 下面在用的时候，直接新建一个hpp文件，把代码考到文件中。 用的时候，#include"路径/warp.hpp" ,hpp文件具体路径看hpp文件放的位置 #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <errno.h> #include <string.h> #include <sys/socket.h> #includ...
【误区】关于Linux C 网络编程函数accept第三个参数
weixin_34162228的博客
01-22 241
在自学Linux C 网络编程时，经过实验发现一个问题。 intaccept(intsockfd,structsockaddr*addr,socklen_t*addrlen) 大部分资料对于accept函数第三个参数的描述如下： 连线成功时，参数addr所指的结构会被系统填入远程主机的地址数据，参数addrlen为scokaddr的结构长度。 亦即指...
LINUX编译错误总结
m0_37321987的博客
05-20 6056
1.make[1]: *** No rule to make target `confparser', needed by `spider'.  Stop. 原因是文件名中有空格
011.socket函数错误封装处理
dearQiHao的博客
05-06 3041
在 008.一个简单的网络服务器开发----回声服务器中所实现的服务器功能简单，简单到几乎没有什么错误处理，我们知道，系统调用不能保证每次都成功。如 010所示，如果我们因为自己代码写的有些问题那么光是排查错误就够我们受的了。出错的可能千千万，所以我们必须进行出错处理，这样一方面可以保证我们的程序逻辑正常，另一方面可以迅速定位到故障信息。 为了使错误处理的代码不影响主程序的可读性，我们封装的 socket相关的系统函数加上错误处理代码包装秤新的函数，做成一个新的模块，名为 error_handling er
Socket.txt
12-09
历史上的网络编程都倾向于困难、复杂，而且极易出错...除此以外，在我们处理另一个连网问题——同时控制多个网络连接——的时候，Java内建的多线程机制也是十分方便的。 本章将用一系列易懂的例子解释Java的连网支持。
C#全能速查宝典
04-26
1.1.5 Console类——控制台中的输入流、输出流和错误流 6 1.1.6 Convert类——类型转换 8 1.1.7 常量——值不改变的量 9 1.1.8 Dispose方法——释放资源 10 1.1.9 迭代器——相同类型的值的有序序列的一段代码 10 ...
C语言实现简单的服务器端和客户端TCP的SOCKET通信(封装错误处理函数)，实现小写字母转为大写字母（2）
Shayne_Li的专栏
04-29 358
封装的函数和库函数名字唯一差别就是封装的函数首字母是大写，如库函数socket函数封装的是Socket，这样是为了方便在vi中即便光标在Socket上使用shift + K也能查询到socket函数 /****************makefile*****************/ src = $(wildcard *.c) obj = $(patsubst %.c, %.o, $(src...
3socket编程：UDP编程
涂作权的博客
09-30 1403
 1 C/S模型—UDP UDP处理模型 说明： 由于UDP不需要维护连接，程序逻辑简单了很多，但是UDP协议是不可靠的，实际上有很多保证通讯可靠性的机制需要在应用层实现。 编译运行server，在两个终端里各开一个client与server交互，看看server是否具有并 发服务的能力。用Ctrl+C关闭server，然后再运行server，看此时
unp中my_read和readline
围剿
10-31 1610
my_read每次读取MAXLINE个字符，然后每次返回一个字符 用my_read先读取MAXLINE个字符，存储在数组里面，然后再用readline从数组里面一个一个字符读取 my_read只调用了一次read系统调用，相比较于以前的readline版本每次读取一个字符都调用一次read系统调用，会减少很多I/O操作，节省很多时间 #include "unp.h" static int
Linux系统编程（33）—— socket编程之TCP程序的错误处理
weixin_30443731的博客
09-04 194
上一篇的例子不仅功能简单，而且简单到几乎没有什么错误处理，我们知道，系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块wrap.c：#include <stdlib.h> #include <e...
UNP:《UNIX网络编程》例子程序中所使用的包裹函数及部分常量
u012839809的专栏
08-02 1889
《UNIX网络编程套接字联网API》这本书的示例中定义了许多包裹函数，它们的名称和标准函数一样，只是首字母变成大写字母；每个包裹函数完成实际的函数调用，检查返回值，并在发生错误时终止程序。 本文作者在重写书上例子的时候，也仿照书上的方式，定义了许多包裹函数，提高程序的可读性（当然，我定义的包裹函数的错误处理没有书上例子这么详细了） PS：这篇文章（博客）会持续更新。 文件my_u
linux网络编程-出错处理函数封装
baidu_41553551的博客
07-06 166
系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。如果上次每次函数的调用都要加判断，那太过于繁琐。 为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块wrap.c，这个wrap.c还是原有函数的参数，只不过将函数首字母大写了。 上面这个goto…就这么写的，那就有吧，这里是因为accept可能会被信号打断，使用goto再调用一次。socket中不能使用fread和fwrite，
Socket 编程基础
热门推荐
Bit_Dong的博客
11-04 2万+
套接字（socket）是 Linux 下的一种进程间通信机制（socket IPC），在前面的内容中已经给大家提到过，使用 socket IPC 可以使得在不同主机上的应用程序之间进行通信（网络通信），当然也可以是同一台主机上的不同应用程序。socket IPC 通常使用客户端服务器这种模式完成通信，多个客户端可以同时连接到服务器中，与服务器之间完成数据交互。内核向应用层提供了 socket 接口，对于应用程序开发人员来说，我们只需要调用 socket 接口开发自己的应用程序即可！
Socket编程的简单使用与介绍
qq_43688708的博客
04-05 1574
Socket编程的简单使用与介绍
一、Socket编程
qq_45926015的博客
10-29 799
Socket编程 Socket编程是网络编程最常用的手段，单纯要应用socket编程事实上不需要了解计算机网络那么多的知识，我们只需要知道两个概念： IP地址可以唯一的标识一台计算机。 端口号可以唯一的标识计算机中的某一网络进程。 这两个概念都不完全严谨，但在不了解太多网络知识的前提下我们可以先认为这是对的。 IP地址可以认为是我们现实生活中的一个身份证，通过身份证号我们可以唯一的在我们国家找到一个人。也就是说，如果我们知道某一台计算机的IP地址，那么我们就可以在全国那么多台计算机中找到我们要进行通信的
socket编程
xyzgulang的博客
08-23 4104
socket 是一种 IPC 方法，它允许位于同一主机（计算机）或使用网络连接起来的不同主机上的应用程序之间交换数据。
_linux下C++ socket网络编程——即时通信系统（含源码）
最新发布
05-29
以下是一个简单的即时通信系统的C++网络编程示例，基于Linux平台使用socket库进行开发。 客户端代码： ```c++ #include #include #include <sys/socket.h> #include #include using namespace std; int main...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值