socket编程中函数封装的思想，异常处理和wrapSocket.c

函数封装的思想-处理异常情况

阻塞函数若收到信号会被信号中断，ettono设置为EINTR，这个错误不应该视为错误，不应该进程关闭。
结合man和errno进行封装。
在封装的时候起名可以把第一个函数名的字母大写，如socket可以封装成Socket，搜索函数说明的时候不区分大小写，使用man也可以查看，man对大小写不区分。

像accept，read这样的能够引起阻塞的函数，若被信号打断，由于信号的优先级较高，会优先处理信号，信号处理完成后，会使accept或者read解除阻塞，然后返回，此时返回值为 -1，设置errno=EINTR;
errno=ECONNABORTED表示连接被打断，异常。

errno宏：
errno.h文件中包含了errno所有的宏和对应的错误描述信息。

wrapSocket.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

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

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

int Close (int fd)
{
    int n;
    if ((n = close(fd)) == -1)
        perr_exit("close error");
    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;
}

static ssize_t my_read (int fd, char *ptr)
{
    static int read_cnt;
    static char *read_ptr;
    static char read_buf[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;   
}

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

int tcp4bind (short port, const char *IP)
{
    struct sockaddr_in serv_addr;
    int lfd = Socket (AF_INET, SOCK_STREAM, 0);
    bzero (&serv_addr, sizeof(serv_addr));
    if (IP == NULL){
        //如果这样使用 0.0.0.0，任意ip将可以连接
        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);
        }
    }
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port   = htons(port);
    //int opt = 1;
    //setsocketopt(ldf, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

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

wrapSocket.h

#ifndef WRAP_SOCKET_H
#define WRAP_SOCKET_H

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

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 Readline (int fd, void *vptr, size_t maxlen);
int tcp4bind (short port, const char *IP);

#endif // WRAP_SOCKET_H