C linux socket tcp封装库

• myconnect.h

#ifndef __MYCONNECT_H_
#define __MYCONNECT_H_

#include<sys/socket.h>

int Accept(int __fd, struct sockaddr *__restrict__ __addr, socklen_t *__restrict__ __addr_len);
int Bind(int __fd, const struct sockaddr *__addr, socklen_t __len);
int Connect(int __fd, const struct sockaddr *__addr, socklen_t __len);
int Listen(int __fd, int __n);
int Socket(int __domain, int __type, int __protocol);
ssize_t Read(int __fd, void *__buf, size_t __nbytes);
ssize_t Write(int __fd, const void *__buf, size_t __n);
int Close(int __fd);

ssize_t Readn(int __fd, void *__buf, size_t n);
ssize_t Writen(int __fd, const void *__buf, size_t n);
ssize_t Readline(int __fd, void *__buf, size_t maxlen);

#endif

• myconnect.c

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

#define handle_error(msg) \
           do { perror(msg); exit(EXIT_FAILURE); } while (0)

int Accept(int __fd, struct sockaddr *__restrict__ __addr, socklen_t *__restrict__ __addr_len)
{
    int n;
again:
    if ((n = accept(__fd, __addr, __addr_len)) < 0)
        if((errno==ECONNABORTED)||(errno==EINTR))
            goto again;
        else
            handle_error("accept");
    return n;
}

int Bind(int __fd, const struct sockaddr *__addr, socklen_t __len)
{
    int n;
    if ((n = bind(__fd, __addr, __len)) < 0)
        handle_error("bind");
    return n;
}

int Connect(int __fd, const struct sockaddr *__addr, socklen_t __len)
{
    int n;
    ;
    if ((n = connect(__fd, __addr, __len)) < 0)
        handle_error("connect");
    return n;
}

int Listen(int __fd, int __n)
{
    int n;
    if ((n = listen(__fd, __n)) < 0)
        handle_error("listen");
    return n;
}

int Socket(int __domain, int __type, int __protocol)
{
    int n;
    if ((n = socket(__domain, __type, __protocol)) < 0)
        handle_error("socket");
    return n;
}

/**
 * read返回值：
 *      1.> 0 实际读到的字节数
 *      2.= 0 数据读完（读到文件末尾、管道写端关闭、socket对端关闭）
 *      3.-1  异常
 *              1.errno==EINTR  被信号中断  重启/退出
 *              2.errno==EAGAIN（EWOULDBLOCK）  非阻塞方式读，并且没有数据
 *              3.其他情况  错误。---perror；  exit；
*/
ssize_t Read(int __fd, void *__buf, size_t __nbytes)
{
    ssize_t n;
again:
    if ((n = read(__fd, __buf, __nbytes)) == -1)
        if (errno == EINTR)
            goto again;
        else
            return -1;
    return n;
}

ssize_t Write(int __fd, const void *__buf, size_t __n)
{
    ssize_t n;
again:
    if((n=write(__fd,__buf,__n))==-1)
        if(errno==EINTR)
            goto again;
        else
            return -1;
    return n;
}

int Close(int __fd)
{
    int n;
    if((n=close(__fd))==-1)
        handle_error("close");
    return n;
}

/**
 * 读一定数量字符串，成功返回0，失败返回非零。
 * size_t n:应该读取的字节数
*/
ssize_t Readn(int __fd, void *__buf, size_t n)
{
    size_t nleft;           //unsigned int 剩余未读取的字节数
    ssize_t nread;          //int 实际读到的字节数
    char *ptr;

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

/*写一定数量字符串，成功返回0，失败返回-1或大于0的数*/
ssize_t Writen(int __fd, const void *__buf, size_t n)
{
    size_t nleft;
    ssize_t nwritten;
    const char *ptr = __buf;
    nleft = n;
    while (nleft > 0)
    {
        if((nwritten = write(__fd, ptr, nleft))<0)
        {
            if (errno == EINTR)
                nwritten = 0;
            else
                return -1;
        }
        else if (nwritten == 0)
            break;
        nleft -= nwritten;
        ptr += nwritten;
    }
    return nleft;
}

/*供Readline()使用*/
static ssize_t my_read(int __fd,char*ptr)
{
    static int read_cnt;
    static char *read_ptr;
    static char read_buff[100];

    if (read_cnt <= 0)
    {
again:
        if ((read_cnt = read(__fd, read_buff, sizeof(read_buff))) < 0)
        {
            if(errno==EINTR)
                goto again;
            return -1;
        }
        else if(read_cnt==0)
            return 0;

        read_ptr = read_buff;
    }
    read_cnt--;
    *ptr = *read_ptr++;

    return 1;
}
/*调用my_read(),实现一次读一行，即读到\n结束，末尾\n\0。*/
ssize_t Readline(int __fd, void *__buf, size_t maxlen)
{
    ssize_t n, rc;
    char    c, *ptr;
    ptr = __buf;

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