HEADER FILE AND ERROR HANDLING FILE & FIRST C PROGRAM

APUE.H

/* our own header to be included before all standard system headers */

#ifndef  _APUE_H
#define  _APUE_H

#define  _XOPEN_SOURCE  600 /* Single unix specification version 3 */

#include <sys/types.h>
#include <sys/termios.h>

#ifndef TIOCGWINSZ
#include <sys/ioctl.h>
#endif
#include <stdio.h>                     /* for conversions */
#include <stdlib.h>                    /* for conversions */
#include <stddef.h>                    /* for offsetof */
#include <string.h>                    /*for conversions */
#include <unistd.h>                    /* for convenience */
#include <signal.h>                     /* for  SIG_ERR  */
#define MAXLINE   4096                        /* max line length */

/*
 * defualt file access permissions for new files
 */
#define FILE_MODE (S_IRUSR | S_IWUSR | S_RGRP | S_IROTH )

/*
 * Default permissions for new directories
 */
#define DIR_MODE (FILE_MODE | S_IXUSR | S_IXGRP | S_IXOTH )

typedef  void      Sigfunc(int );         /* for signal handlers */

#if defined(SIG_IGN) && !defined(SIG_ERR)
#define SIG_ERR((Sigfunc *) -1 )
#endif

#define min(a,b)  ((a) < (b) ? (a) : (b))
#define max(a,b)  ((a) > (b) ? (a) : (b))

/*
 * Prototype for our owner functions
 */
char * path_alloc(int *);
long  open_max(void);
void  clr_fl(int,int);
void   set_fl(int,int);
void  pr_exit(int);
void  pr_mask(const char *);
Sigfunc *signal(int,Sigfunc *);

int tty_cbreak(int);
int tty_raw(int);
int tty_reset(int);
void tty_atexit(void);
#ifdef ECHO   /*only if <termios.h> has been include */
struct termios *tty_termios(void);;
#endif

void sleep_us(unsigned int);
ssize_t readn(int,void *,size_t);
ssize_t writen(int,const void *,size_t);
void daemonize(const char  * );

int s_pipe(int *);
int recv_fd(int,ssize_t ( *func)(int,const void *,size_t));
int send_fd(int,int);
int send_err(int,int,const char *); int serv_listen(const char *);
int serv_accept(int,uid_t *);
int cli_conn(const char *);
int buf_args(char *,int (*func)(int,char **));

int ptym_open(char *,int);
int ptys_open(char *);
#ifdef TIOCGWINSZ
pid_t pty_fork(int *,char  *,int,const struct termios *,const struct winsize *);
#endif

int lock_reg(int,int,int,off_t,int,off_t);
#define read_lock(fd,offset,whence,len) \
           lock_reg((fd),F_SETLK,F_RDLCK,(offset),(whence),(len))

#define readw_lock(fd,offset,whence,len) \
                lock_reg((fd),F_SETLKW,F_RDLCK,(offset),(whence),(len));
#define write_lock(fd,offset,whence,len) \
              lock_reg((fd),F_SETLK,F_WRLCK,(offset),(whence),(len));
#define writew_lock(fd,offset,whence,len) \
                 lock_reg((fd),F_SETLKW,F_WRLCK,(offset),(whence),(len));
#define unlock(fd,offset,whence,len) \
              lock_reg((fd),F_SETLK,F_UNLCK,(offset),(whence),(len));

pid_t lock_test(int,int,off_t,int,off_t);

#define is_read_lockable(fd,offsset,whence,len)  \
             (lock_test((fd),F_RDLCK,(offset),(whence),(len)) ==  0)
#define is_write_lockable(fd,offset,whence,len) \
             (lock_test((fd),F_WRLCK,(offset),(whence),(len)) == 0)
void err_dump(const char *,...);
void err_msg(const char *,...);
void err_quit(const char *,...);
void err_exit(int,const char *,...);
void err_ret(const char *,...);
void err_sys(const char  *,...);

void log_dump(const,char *,...);
void log_msg(const char *,...);
void log_quit(const char *,...);
void log_exit(int,const char *,...);
void log_ret(const char *,...);
void log_sys(const char *,...);

void TELL_WAIT(void);
void TELL_PARENT(pid_t );
void TELL_CHILD(pid_t );
void WAIT_CHILD(void);
void WAIT_PARENT(void);
#endif /* _APUE_H */

ERROR.C

#include "apue.h"
#include <errno.h> /* for definition of errno */
#include <stdarg.h> /* iso c variable arguement */

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

/*
 * Fatal error unrelated to system call
 * Error code passed as explicted parameter
 * exit(1);
 * 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 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 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 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  "errorflag "
 */
static void
err_doit(int errnoflag,int error,const char * fmt,va_list ap)
{
    char buf[MAXLINE];

    vsnprintf(buf,MAXLINE,fmt,ap);
    if (errnoflag  )
        snprintf(buf+strlen(buf),MAXLINE-strlen(buf),";%s",strerror(error));
    strcat(buf,"\n");
    fflush(stdout);         /* in case stdout and stderr are the saem */
    fputs(buf,stderr);
    fflush(NULL);       /* flush all stdio output stream */
}

handler of log error :

#include "apue.h"
#include <errno.h>       /*  for definition of errno */
#include <stdarg.h>      /* ISO  c variable arguement */
#include <syslog.h>

static void log_doit(int,int,const char * ,va_list );

/*
 * Caller must define and set this : nonzero if
 * interactive ,zero  if daemon
 */

extern  int log_to_stderr;

/*
 * Initialize syslog(), if running  as a daemon
 */

void log_open(const char * ident,int option,int facility)
{
    if ( log_to_stderr == 0 )
        openlog(ident,option,facility);
}

/*
 * Nonfatal  error related to a system call
 * Print a message  with the system's errno  value and return
 */

void
log_ret(const char * fmt,...)
{
    va_list ap;
    va_start(ap,fmt);

    log_doit(1,LOG_ERR,fmt,ap);
    va_end(ap);
}

/*
 * Fatal error related to a system call
 *Print a message  and terminate
 */

void
log_sys(const char * fmt,...)
{
    va_list ap;
    va_start(ap,fmt);

    log_doit(1,LOG_ERR,fmt,ap);
    va_end(ap);
    exit(2);
}

/*
 *Nonfatal error unrelated to a system call
 * Print a message and return
 */

void
log_msg(const char * fmt,...)
{
    va_list ap;
    va_start(ap,fmt);

    log_doit(0,LOG_ERR,fmt,ap);
    va_end(ap);
}

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

    log_doit(0,LOG_ERR,fmt,ap);
    va_end(ap);
    exit(2);
}

/*
 *Print a message  and return
 * to Caller,& caller specifies errnoflag and priority
 */

static void
log_doit(int errnoflag,int priority,const char * fmt,va_list ap)
{
    int errno_save = 0;
    char buf[MAXLINE];

    errno = errno; /* value caller might want to print */
    vsnprintf(buf,MAXLINE,fmt,ap);
    if ( errnoflag)
        snprintf(buf+strlen(buf),MAXLINE-strlen(buf),":%s ",strerror(errno_save));
    strcat(buf,"\n");
    if (log_to_stderr )
    {
        fflush(stdout);
        fputs(buf,stderr);
        fflush(stderr);
    } else {
        syslog(priority,buf,"%s ");
    }
}

MY FIRST C PROGRAM OF APUE:

#include "apue.h"
#include <dirent.h>

int main(int argc,char * argv[])
{
    DIR *dp;
    struct dirent *dirp;

    if ( argc != 2 )
        err_quit("usage : myls is a directory name ");
    if ((dp =opendir(argv[1])) == NULL )
        err_sys("can't open %s",argv[1]);
    while(( dirp = readdir(dp)) != NULL)
    printf("%s\n",dirp->d_name);
    closedir(dp);
    exit(0);
}