《UNIX网络编程》例子程序中所使用的包裹函数及部分常量

来源：互联网发布：欢迎来到东莫村知乎编辑：程序博客网时间：2024/04/30 06:41

原文连接 http://blog.csdn.net/small_qch/article/details/8096701

《UNIX网络编程套接字联网API》这本书的示例中定义了许多包裹函数，它们的名称和标准函数一样，只是首字母变成大写字母；每个包裹函数完成实际的函数调用，检查返回值，并在发生错误时终止程序。

我在重写书上例子的时候，也仿照书上的方式，定义了许多包裹函数，提高程序的可读性（当然，我定义的包裹函数的错误处理没有书上例子这么详细了）

PS：这篇文章（博客）会持续更新。

文件my_unp.h：它定义了一些常量，声明了所有的包裹函数

[cpp] view plaincopyprint?
#ifndef MY_UNP_H_    
#define MY_UNP_H_    
  
#include <stdio.h>    
#include <stdarg.h>    
#include <stdlib.h>    
#include <string.h>    
#include <time.h>    
  
#include <unistd.h>    
#include <errno.h>    
#include <pthread.h>  
#include <semaphore.h>  
#include <sys/socket.h>    
#include <sys/wait.h>    
#include <netinet/in.h>    
#include <arpa/inet.h>    
#include <sys/select.h>    
#include <sys/epoll.h>    
#include <sys/poll.h>    
#include <sys/file.h>    
#include <sys/mman.h>  
  
#define MAXLINE 1024    
#define LISTENQ 1024    
  
#define MAXNITEMS 1000000  
#define MAXNTHREADS 100  
  
#define SERV_PORT 9877    
#define SERV_PORT_STR "9877"    
  
#define SA struct sockaddr    
typedef void Sigfunc(int);    
  
#define min(a,b)    ((a) < (b) ? (a) : (b))    
#define max(a,b)    ((a) > (b) ? (a) : (b))    
  
  
//错误处理函数，输出错误信息后退出程序    
void error_quit(char *fmt, ...);    
  
//为了适应网络的慢速IO而编写的读写函数  
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);    
  
//各类读写包裹函数    
void Write(int fd, void *ptr, size_t nbytes);    
ssize_t Read(int fd, void *ptr, size_t nbytes);    
ssize_t Readn(int fd, void *ptr, size_t nbytes);    
void Writen(int fd, void *ptr, size_t nbytes);    
ssize_t Readline(int fd, void *ptr, size_t maxlen);    
void Fputs(const char *ptr, FILE *stream);    
char *Fgets(char *ptr, int n, FILE *stream);     
  
//各类标准包裹函数    
int Open(const char *pathname, int flags, mode_t mode);  
void Close(int fd);   
Sigfunc *Signal(int signo, Sigfunc *func);    
void *Malloc(size_t size);    
void *Calloc(size_t n, size_t size);  
void Pipe(int *fds);    
pid_t Fork(void);    
pid_t Waitpid(pid_t pid, int *iptr, int options);   
void Dup2(int fd1, int fd2);  
  
//各类网络包裹函数    
int Socket(int family, int type, int protocol);    
void Inet_pton(int family, const char *strptr, void *addrptr);    
void Connect(int fd, const struct sockaddr *sa, socklen_t salen);    
void Listen(int fd, int backlog);    
void Bind(int fd, const struct sockaddr *sa, socklen_t salen);    
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);    
const char *Inet_ntop(int family, const void *addrptr, char *strptr, size_t len);    
int Select(int nfds, fd_set *readfds, fd_set *writefds,     
           fd_set *exceptfds, struct timeval *timeout);    
int Poll(struct pollfd *fdarray, unsigned long nfds, int timeout);    
void Shutdown(int fd, int how);    
int Epoll_create(int size);    
void Epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);    
int Epoll_wait(int epfd, struct epoll_event *events,    
               int maxevents, int timeout);    
void Sendto(int fd, const void *ptr, size_t nbytes, int flags,    
            const struct sockaddr *sa, socklen_t salen);    
ssize_t Recvfrom(int fd, void *ptr, size_t nbytes, int flags,   
                struct sockaddr *sa, socklen_t *salenptr);    
void Setsockopt(int fd, int level, int optname,   
                const void *optval, socklen_t optlen);  
void *Mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset);  
void Munmap(void *addr, size_t len);  
void Ftruncate(int fd, off_t length);  
  
//各类和线程操作相关的包裹函数    
void Pthread_create(pthread_t *tid, const pthread_attr_t *attr,  
                    void * (*func)(void *), void *arg);  
void Pthread_detach(pthread_t tid);  
void Pthread_join(pthread_t tid, void **status);  
void Pthread_kill(pthread_t tid, int signo);  
void Pthread_mutex_lock(pthread_mutex_t *mptr);  
void Pthread_mutex_unlock(pthread_mutex_t *mptr);  
//此函数相当于UNP书上的set_concurrency函数  
void Pthread_setconcurrency(int level);  
void Pthread_cond_signal(pthread_cond_t *cptr);  
void Pthread_cond_wait(pthread_cond_t *cptr, pthread_mutex_t *mptr);  
  
//各类和信号量相关的包裹函数  
sem_t *Sem_open(const char *name, int oflag,  
                mode_t mode, unsigned int value);  
void Sem_close(sem_t *sem);  
void Sem_unlink(const char *pathname);  
void Sem_init(sem_t *sem, int pshared, unsigned int value);  
void Sem_destroy(sem_t *sem);  
void Sem_wait(sem_t *sem);  
void Sem_post(sem_t *sem);  
void Sem_getvalue(sem_t *sem, int *valp);  
  
#endif    

文件unp_base.c：它定义了基本的包裹函数

[cpp] view plaincopyprint?
#include "my_unp.h"    
  
//此函数是在程序发生错误时被调用    
//先输出字符串fmt，再根据errno输出错误原因（如果有的话），最后退出程序    
//注：在多线程程序中，错误原因可能不正确    
void error_quit(char *fmt, ...)    
{    
    int res;    
    va_list list;    
    va_start(list, fmt);    
    res = vfprintf(stderr, fmt, list);    
    if( errno != 0 )    
        fprintf(stderr, " : %s", strerror(errno));    
    fprintf(stderr, "\n", list);    
    va_end(list);    
    exit(1);    
}    
  
//字节流套接字上调用read时，输入的字节数可能比请求的数量少，    
//但这不是出错的状态，原因是内核中用于套接字的缓冲区可能已经达到了极限，    
//此时需要调用者再次调用read函数    
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;      /* and call read() again */    
            else    
                return(-1);    
        }     
        else if (nread == 0)    
            break;              /* EOF */    
        nleft -= nread;    
        ptr   += nread;    
    }    
    return (n - nleft);     /* return >= 0 */    
}    
  
//字节流套接字上调用write时，输出的字节数可能比请求的数量少，    
//但这不是出错的状态，原因是内核中用于套接字的缓冲区可能已经达到了极限，    
//此时需要调用者再次调用write函数    
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;       /* and call write() again */    
            else    
                return(-1);         /* error */    
        }    
        nleft -= nwritten;    
        ptr   += nwritten;    
    }    
    return n;    
}    
  
static int  read_cnt;    
static char *read_ptr;    
static char read_buf[MAXLINE];    
  
//内部函数my_read每次最多读MAXLINE个字节，然后每次返回一个字节    
static ssize_t my_read(int fd, char *ptr)    
{    
    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;  /* newline is stored, like fgets() */    
        }     
        else if (rc == 0)    
        {    
            *ptr = 0;    
            return(n - 1);  /* EOF, n - 1 bytes were read */    
        }    
        else    
            return(-1);     /* error, errno set by read() */    
    }    
    *ptr = 0;   /* null terminate like fgets() */    
    return n;    
}    
  
ssize_t Readn(int fd, void *ptr, size_t nbytes)    
{    
    ssize_t n = readn(fd, ptr, nbytes);    
    if ( n < 0)    
        error_quit("readn error");    
    return n;    
}    
  
void Writen(int fd, void *ptr, size_t nbytes)    
{    
    if ( writen(fd, ptr, nbytes) != nbytes )    
        error_quit("writen error");    
}    
  
ssize_t Readline(int fd, void *ptr, size_t maxlen)    
{    
    ssize_t n = readline(fd, ptr, maxlen);    
    if ( n < 0)    
        error_quit("readline error");    
    return n;    
}    
  
ssize_t Read(int fd, void *ptr, size_t nbytes)    
{    
    ssize_t n = read(fd, ptr, nbytes);    
    if ( n == -1)    
        error_quit("read error");    
    return n;    
}    
  
void Write(int fd, void *ptr, size_t nbytes)    
{    
    if (write(fd, ptr, nbytes) != nbytes)    
        error_quit("write error");    
}    
  
int Open(const char *pathname, int flags, mode_t mode)  
{  
    int fd = open(pathname, flags, mode);  
    if( -1 == fd )  
        error_quit("open file %s error", pathname);  
    return fd;  
}  
  
void Close(int fd)    
{    
    if (close(fd) == -1)    
        error_quit("close error");    
}    
  
void Fputs(const char *ptr, FILE *stream)    
{    
    if (fputs(ptr, stream) == EOF)    
        error_quit("fputs error");    
}    
  
char *Fgets(char *ptr, int n, FILE *stream)    
{    
    char *rptr = fgets(ptr, n, stream);    
    if ( rptr == NULL && ferror(stream) )    
        error_quit("fgets error");    
    return rptr;    
}    
  
int Socket(int family, int type, int protocol)    
{    
    int n = socket(family, type, protocol);    
    if( n < 0)    
        error_quit("socket error");    
    return n;    
}    
  
void Inet_pton(int family, const char *strptr, void *addrptr)    
{    
    int n = inet_pton(family, strptr, addrptr);    
    if( n < 0)    
        error_quit("inet_pton error for %s", strptr);    
}    
  
void Connect(int fd, const struct sockaddr *sa, socklen_t salen)    
{    
    if (connect(fd, sa, salen) < 0)    
        error_quit("connect error");    
}    
  
void Listen(int fd, int backlog)    
{    
    if (listen(fd, backlog) < 0)    
        error_quit("listen error");    
}    
  
void Bind(int fd, const struct sockaddr *sa, socklen_t salen)    
{    
    if (bind(fd, sa, salen) < 0)    
        error_quit("bind error");    
}    
  
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)    
{    
    int n = accept(fd, sa, salenptr);    
    if ( n < 0)    
        error_quit("accept error");    
    return n;    
}    
  
const char *Inet_ntop(int family, const void *addrptr, char *strptr, size_t len)    
{    
    const char  *ptr = inet_ntop(family, addrptr, strptr, len);    
    if ( ptr == NULL)    
        error_quit("inet_ntop error");    
    return ptr;    
}    
  
pid_t Fork(void)    
{    
    pid_t pid = fork();    
    if ( pid == -1)    
        error_quit("fork error");    
    return pid;    
}    
  
Sigfunc *Signal(int signo, Sigfunc *func)    
{    
    Sigfunc *sigfunc = signal(signo, func);    
    if ( sigfunc == SIG_ERR)    
        error_quit("signal error");    
    return sigfunc;    
}    
  
int Select(int nfds, fd_set *readfds, fd_set *writefds,     
           fd_set *exceptfds, struct timeval *timeout)    
{    
    int n = select(nfds, readfds, writefds, exceptfds, timeout);    
    if ( n < 0 )    
        error_quit("select error");    
    return n;       /* can return 0 on timeout */    
}    
  
int Poll(struct pollfd *fdarray, unsigned long nfds, int timeout)    
{    
    int n = poll(fdarray, nfds, timeout);    
    if ( n < 0 )    
        error_quit("poll error");    
    return n;    
}    
  
void Shutdown(int fd, int how)    
{    
    if (shutdown(fd, how) < 0)    
        error_quit("shutdown error");    
}    
  
int Epoll_create(int size)    
{    
    int n = epoll_create(size);    
    if( n < 0 )    
        error_quit("epoll create error");    
    return n;    
}    
  
void Epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)    
{    
    if( epoll_ctl(epfd, op, fd, event) < 0 )    
        error_quit("epoll ctl error");    
}    
  
int Epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)    
{    
    int n = epoll_wait(epfd, events, maxevents, timeout);    
    if( n < 0 )    
        error_quit("epoll wait error");    
    return n;    
}    
  
void Sendto(int fd, const void *ptr, size_t nbytes, int flags,    
            const struct sockaddr *sa, socklen_t salen)    
{    
    if (sendto(fd, ptr, nbytes, flags, sa, salen) != (ssize_t)nbytes)    
        error_quit("sendto error");    
}    
  
ssize_t Recvfrom(int fd, void *ptr, size_t nbytes, int flags,    
struct sockaddr *sa, socklen_t *salenptr)    
{    
    ssize_t n = recvfrom(fd, ptr, nbytes, flags, sa, salenptr);    
    if ( n < 0 )    
        error_quit("recvfrom error");    
    return n;    
}    
  
ssize_t Recvmsg(int fd, struct msghdr *msg, int flags)    
{    
    ssize_t n = recvmsg(fd, msg, flags);    
    if ( n < 0 )    
        error_quit("recvmsg error");    
    return(n);    
}    
  
void *Malloc(size_t size)    
{    
    void *ptr = malloc(size);    
    if ( ptr == NULL )    
        error_quit("malloc error");    
    return ptr;    
}    
  
void *Calloc(size_t n, size_t size)  
{  
    void *ptr = calloc(n, size);  
    if ( ptr == NULL)  
        error_quit("calloc error");  
    return ptr;  
}  
  
void Pipe(int *fds)    
{    
    if ( pipe(fds) < 0 )    
        error_quit("pipe error");    
}    
  
pid_t Waitpid(pid_t pid, int *iptr, int options)    
{    
    pid_t   retpid = waitpid(pid, iptr, options);    
    if ( retpid == -1)    
        error_quit("waitpid error");    
    return retpid;    
}  
  
void Setsockopt(int fd, int level, int optname,   
                const void *optval, socklen_t optlen)  
{  
    if (setsockopt(fd, level, optname, optval, optlen) < 0)  
        error_quit("setsockopt error");  
}  
  
void Socketpair(int family, int type, int protocol, int *fd)  
{  
    int n = socketpair(family, type, protocol, fd);  
    if ( n < 0 )  
        error_quit("socketpair error");  
}  
  
void Dup2(int fd1, int fd2)  
{  
    if (dup2(fd1, fd2) == -1)  
        error_quit("dup2 error");  
}  
  
void *Mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset)  
{  
    void *ptr = mmap(addr, len, prot, flags, fd, offset);  
    if ( ptr == MAP_FAILED )  
        error_quit("mmap error");  
    return ptr;  
}  
  
void Munmap(void *addr, size_t len)  
{  
    if (munmap(addr, len) == -1)  
        error_quit("munmap error");  
}  
  
void Ftruncate(int fd, off_t length)  
{  
    if (ftruncate(fd, length) == -1)  
        error_quit("ftruncate error");  
}  

文件unp_pthread.c：它定义了基本的线程类包裹函数

[cpp] view plaincopyprint?
#include "my_unp.h"  
  
void Pthread_create(pthread_t *tid, const pthread_attr_t *attr,  
                    void * (*func)(void *), void *arg)  
{  
    int n = pthread_create(tid, attr, func, arg);  
    if ( n == 0)  
        return;  
    errno = n;  
    error_quit("pthread_create error");  
}  
  
void Pthread_detach(pthread_t tid)  
{  
    int n = pthread_detach(tid);  
    if ( n == 0)  
        return;  
    errno = n;  
    error_quit("pthread_detach error");  
}  
  
void Pthread_join(pthread_t tid, void **status)  
{  
    int n = pthread_join(tid, status);  
    if ( n == 0 )  
        return;  
    errno = n;  
    error_quit("pthread_join error");  
}  
  
void Pthread_kill(pthread_t tid, int signo)  
{  
    int n = pthread_kill(tid, signo);  
    if ( n == 0 )  
        return;  
    errno = n;  
    error_quit("pthread_kill error");  
}  
  
void Pthread_mutex_lock(pthread_mutex_t *mptr)  
{  
    int n = pthread_mutex_lock(mptr);  
    if ( n == 0 )  
        return;  
    errno = n;  
    error_quit("pthread_mutex_lock error");  
}  
  
void Pthread_mutex_unlock(pthread_mutex_t *mptr)  
{  
    int n = pthread_mutex_unlock(mptr);  
    if ( n == 0 )  
        return;  
    errno = n;  
    error_quit("pthread_mutex_unlock error");  
}  
  
void Pthread_setconcurrency(int level)  
{  
    int n = pthread_setconcurrency(level);  
    if ( n == 0 )  
        return;  
    errno = n;  
    error_quit("pthread_mutex_unlock error");  
}  
  
void Pthread_cond_signal(pthread_cond_t *cptr)  
{  
    int n = pthread_cond_signal(cptr);  
    if ( n == 0 )  
        return;  
    errno = n;  
    error_quit("pthread_cond_signal error");  
}  
  
void Pthread_cond_wait(pthread_cond_t *cptr, pthread_mutex_t *mptr)  
{  
    int n = pthread_cond_wait(cptr, mptr);  
    if ( n == 0 )  
        return;  
    errno = n;  
    error_quit("pthread_cond_wait error");  
}  
  
sem_t *Sem_open(const char *name, int oflag,  
                mode_t mode, unsigned int value)  
{  
    sem_t *sem = sem_open(name, oflag, mode, value);  
    if( NULL == sem )  
        error_quit("sem_open error for %s", name);  
    return sem;  
}  
  
void Sem_close(sem_t *sem)  
{  
    if (sem_close(sem) == -1)  
        error_quit("sem_close error");  
}  
  
void Sem_unlink(const char *pathname)  
{  
    if (sem_unlink(pathname) == -1)  
        error_quit("sem_unlink error");  
}  
  
void Sem_init(sem_t *sem, int pshared, unsigned int value)  
{  
    if (sem_init(sem, pshared, value) == -1)  
        error_quit("sem_init error");  
}  
  
void Sem_destroy(sem_t *sem)  
{  
    if (sem_destroy(sem) == -1)  
        error_quit("sem_destroy error");  
}  
  
void Sem_wait(sem_t *sem)  
{  
    if (sem_wait(sem) == -1)  
        error_quit("sem_wait error");  
}  
  
void Sem_post(sem_t *sem)  
{  
    if (sem_post(sem) == -1)  
        error_quit("sem_post error");  
}  
  
void Sem_getvalue(sem_t *sem, int *valp)  
{  
    if (sem_getvalue(sem, valp) == -1)  
        error_quit("sem_getvalue error");  
}  

0 0