APUE之对于系统中缺失的error.c文件的阶段性总结

大多数人在学习APUE过程中都会受到缺失apue.h和error.c文件的困扰

• 本文意指在学习完整个APUE的过程中对于error.c 文件由原官方文件的基础上做出的N次扩充，也就是说在以后的学习中，基本上所有代码的包含了apue.h的时候，也会利用到error.c文件。

• 此文件当你拷贝到linux系统中后，请与apue.h一同放到/usr/include/当中。与此同时，在从第一章到第十七章的过程中，代码是逐步添加，当你遇到复制困扰时，可采用：

• 可选方案： 将此文件利用cat -n filename 得到你所需要的代码行数例如是15-20行。与此同时，采用sed -n '15,20p' filename >> /usr/include/error.c采用sed编辑器可以很方便的将代码放入error.c当中。到此，又可以开心的对APUE进行学习了。

• 至于如何学习？这本书比较厚，但是作为程序员，代码量必须垒足了，所以呢？最好将整本书的代码撸一遍，就算有时候不理解代码的意思，也可以看到程序的运行效果，相信我，你会在这里遇到很多问题。吐过你能够一步步解决的话，那么我相信，代码之力会赐予你很多你想要的东西。
• 如若不信，我把github地址放在这里(https://github.com/VVictorQi/APUE你可以将我的代码拷过去进行学习，也可以与我一起，进行APUE的学习，在github页面，记得点赞和关注哦，我会带给更多喜悦与惊喜~~~

#include "apue.h"
#include <errno.h> /* for definition of errno */
#include <stdarg.h> /* ISO C variable aruments */
#include<fcntl.h>
static void err_doit(int, int, const char *, va_list);
/* * Nonfatal error related to a system call. * Print a message and return. */
void
err_ret(const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(1, errno, fmt, ap);
    va_end(ap);
}

/* * Fatal error related to a system call. * Print a message and terminate. */
void
err_sys(const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(1, errno, fmt, ap);
    va_end(ap);
    exit(1);
}

/* * Nonfatal error unrelated to a system call. * Error code passed as explict parameter. * Print a message and return. */
void
err_cont(int error, const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(1, error, fmt, ap);
    va_end(ap);
}

/* * Fatal error unrelated to a system call. * Error code passed as explict parameter. * Print a message and terminate. */
void
err_exit(int error, const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(1, error, fmt, ap);
    va_end(ap);
    exit(1);
}

/* * Fatal error related to a system call. * Print a message, dump core, and terminate. */
void
err_dump(const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(1, errno, fmt, ap);
    va_end(ap);
    abort();        /* dump core and terminate */
    exit(1);        /* shouldn't get here */
}

/* * Nonfatal error unrelated to a system call. * Print a message and return. */
void
err_msg(const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(0, 0, fmt, ap);
    va_end(ap);
}

/* * Fatal error unrelated to a system call. * Print a message and terminate. */
void
err_quit(const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(0, 0, fmt, ap);
    va_end(ap);
    exit(1);
}

/* * Print a message and return to caller. * Caller specifies "errnoflag". */
static void
err_doit(int errnoflag, int error, const char *fmt, va_list ap)
{
    char    buf[MAXLINE];

    vsnprintf(buf, MAXLINE-1, fmt, ap);
    if (errnoflag)
        snprintf(buf+strlen(buf), MAXLINE-strlen(buf)-1, ": %s",
          strerror(error));
    strcat(buf, "\n");
    fflush(stdout);     /* in case stdout and stderr are the same */
    fputs(buf, stderr);
    fflush(NULL);       /* flushes all stdio output streams */
}
void pr_mask(const char *str)
{
    sigset_t sigset;
    int errno_save;
    errno_save=errno;
    if(sigprocmask(0,NULL,&sigset))
    {
        err_ret("sigprocmask error");
    }
    else
    {
        printf("%s",str);
        if(sigismember(&sigset,SIGINT))
            printf("SIGINT");
        if(sigismember(&sigset,SIGQUIT))
            printf("QUIT");
        if(sigismember(&sigset,SIGUSR1))
            printf("USR1");
        if(sigismember(&sigset,SIGUSR2))
            printf("USR2");
        printf("\n");
    }
    errno =errno_save;
}
//主要讲8.9节中说到的五个例程的实现
//分别是TELLWAIT、TELL_PARENT、TELL_CHILD、WAIT_PARENT、WAIT_CHILD


static volatile sig_atomic_t sigflag;
static sigset_t newmask,oldmask,zeromask;

static void sig_usr(int signo)
{
    sigflag=1;
}
void TELL_WAIT(void)
{
    if(signal(SIGUSR1,sig_usr)==SIG_ERR)
        err_sys("signal sigusr1 error");
    if(signal(SIGUSR2,sig_usr)==SIG_ERR)
        err_sys("signal sigusr2 error");
    sigemptyset(&newmask);
    sigemptyset(&zeromask);
    sigaddset(&newmask,SIGUSR1);
    sigaddset(&newmask,SIGUSR2);

    if(sigprocmask(SIG_BLOCK,&newmask,&oldmask)<0)
        err_sys("SIG_BLOCK error");
}

void TELL_PARENT(pid_t pid)
{
    kill(pid,SIGUSR2);
}
void WAIT_PARENT(void)
{
    while(sigflag==0)
        sigsuspend(&zeromask);
    sigflag=0;
    if(sigprocmask(SIG_SETMASK,&oldmask,NULL)<0)
        err_sys("SIG_SETMASK error");
}
void TELL_CHILD(pid_t pid)
{
    kill(pid,SIGUSR1);
}
void WAIT_CHILD(void)
{

    while(sigflag==0)
        sigsuspend(&zeromask);
    sigflag=0;
    if(sigprocmask(SIG_SETMASK,&oldmask,NULL)<0)
        err_sys("SIG_SETMASK error");
}
void clr_fl(int fd,int flags)
{
    int val;
    if((val=fcntl(fd,F_GETFL,0))<0)
        err_sys("fcntl F_GETFL error");
    val = ~flags;
    if(fcntl(fd,F_SETFL,val)<0)
        err_sys("fcntl F_SETFL error");
}
void set_fl(int fd,int flags)
{
    int val;
    if((val=fcntl(fd,F_GETFL,0))<0)
        err_sys("fcntl F_GETFL error");
    val |=flags;
    if(fcntl(fd,F_SETFL,val)<0)
        err_sys("fcntl F_SETFL error");
}
int lock_reg(int fd,int cmd,int type,off_t offset ,int whence , off_t len)
{
    struct flock lock;


    lock.l_type=type;
    lock.l_start=offset;
    lock.l_whence=whence;
    lock.l_len=len;

    //为避免每次分配flock结构的繁琐，将其动作封装成函数，一起运用，提高效率
    //，在以后会用到
    return fcntl(fd,cmd,&lock);
}

pid_t lock_test(int fd,int type,off_t offset ,int whence ,off_t len)
{   
    //函数的作用是测试一把锁，如果存在一把锁，它阻塞由参数指定的锁请求，则此函数返回持有
    //这把锁的进程的进程ID，否则此函数返回0。
    struct flock lock;
    lock.l_type=type;
    lock.l_start=offset;
    lock.l_whence=whence;
    lock.l_len=len;
    if(fcntl(fd,F_GETLK,&lock)<0)//利用fcntl添加记录锁，并且记录状态
        err_sys("fcntl error");
    if(lock.l_type==F_UNLCK)
        return 0;
    return (lock.l_pid);
}
ssize_t readn(int fd,void *ptr ,size_t n)
{
    size_t      nleft;
    ssize_t     nread;


    nleft=n;
    while(nleft>0)
    {
        if(nread=read(fd,ptr,nleft)<0)
        {
            if(nleft==0)
                return -1;
            else 
                break;
        }
        else if(nread==0)
        {
            break;//EOF error
        }
        nleft-=nread;
        ptr+=nread;
    }
    return (n=nleft);//return >=0
}

//改进版的read 和write函数。以为传进数据，读写指定的 数据
ssize_t writen(int fd, const void * ptr ,size_t n)
{
    size_t      nleft;
    ssize_t     nwriten;

    nleft=n;

    while(nleft>0)
    {
        if(nwriten=write(fd,ptr,nleft)<0)
        {
            if(nleft==n)
                return -1;
            else
                break;
        }
        else if(nwriten==0)
            break;
        nleft-=nwriten;
        ptr+=nwriten;
    }
    return (n-nleft);
}