LINUX下的C网络通信函数封装

LINUX下的C网络通信函数封装

声明(wrap.h)

#ifndef __WRAP_H_
#define __WRAP_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.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);

//连接目标IP和端口
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);

//关闭文件描述符
int Close(int fd);

//创建TCP通信的服务端
int tcp4BindListen(short port, const char *IP, int backlog);

//写入或读取数据，写入完毕或缓冲区无数据结束
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);

//一直写入或读取n个字节数据
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);

#endif

实现(wrap.c)

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


void perr_exit(const char *s)
{
        perror(s);
        exit(-1);
}

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

again:
        if((n = accept(fd, sa, salenptr)) < 0)
        {
                if((errno == ECONNABORTED) || (errno == EINTR))
                {
                        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;
}

int Close(int fd)
{
        int n;

        if((n = close(fd)) == -1)
        {
                perr_exit("close error");
        }

        return n;
}

int tcp4BindListen(short port, const char *IP, int backlog)
{
        int lfd = Socket(AF_INET, SOCK_STREAM, 0);
        int opt = 1;
		setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt,sizeof(int));

        struct sockaddr_in serv_addr;
        bzero(&serv_addr, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(port);
        
        if(IP == NULL)
        {
                serv_addr.sin_addr.s_addr = INADDR_ANY;
        }
        else
        {
                if(inet_pton(AF_INET, IP,\
                                        &serv_addr.sin_addr.s_addr) <= 0)
                {
                        perror(IP);
                        exit(1);
                }
        }

        Bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

        Listen(lfd, backlog);

        return lfd;
}

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;
}

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;
}

ssize_t Readn(int fd, void *vptr, size_t n)
{
        size_t nleft;
        ssize_t nread;
        char *ptr;

        ptr = vptr;
        nleft = 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;
}

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;

}