unix网络编程中的包裹函数

一下是unix网络编程中的包裹函数，同样适用与windows 编程：

Writen 和Readn   等等

/* include readn */
#include "unp.h"

ssize_t      /* Read "n" bytes from a descriptor. */
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 */
}
/* end readn */

ssize_t
Readn(int fd, void *ptr, size_t nbytes)
{
 ssize_t  n;

 if ( (n = readn(fd, ptr, nbytes)) < 0)
  err_sys("readn error");
 return(n);
}

/* include writen */
#include "unp.h"

ssize_t      /* Write "n" bytes to a descriptor. */
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 (errno == EINTR)
    nwritten = 0;  /* and call write() again */
   else
    return(-1);   /* error */
  }

  nleft -= nwritten;
  ptr   += nwritten;
 }
 return(n);
}
/* end writen */

void
Writen(int fd, void *ptr, size_t nbytes)
{
 if (writen(fd, ptr, nbytes) != nbytes)
  err_sys("writen error");
}

/*
 * Socket wrapper functions.
 * These could all go into separate files, so only the ones needed cause
 * the corresponding function to be added to the executable.  If sockets
 * are a library (SVR4) this might make a difference (?), but if sockets
 * are in the kernel (BSD) it doesn't matter.
 *
 * These wrapper functions also use the same prototypes as POSIX.1g,
 * which might differ from many implementations (i.e., POSIX.1g specifies
 * the fourth argument to getsockopt() as "void *", not "char *").
 *
 * If your system's headers are not correct [i.e., the Solaris 2.5
 * <sys/socket.h> omits the "const" from the second argument to both
 * bind() and connect()], you'll get warnings of the form:
 *warning: passing arg 2 of `bind' discards `const' from pointer target type
 *warning: passing arg 2 of `connect' discards `const' from pointer target type
 */

#include "unp.h"

int
Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
 int  n;

again:
 if ( (n = accept(fd, sa, salenptr)) < 0) {
#ifdef EPROTO
  if (errno == EPROTO || errno == ECONNABORTED)
#else
  if (errno == ECONNABORTED)
#endif
   goto again;
  else
   err_sys("accept error");
 }
 return(n);
}

void
Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (bind(fd, sa, salen) < 0)
  err_sys("bind error");
}

void
Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (connect(fd, sa, salen) < 0)
  err_sys("connect error");
}

void
Getpeername(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
 if (getpeername(fd, sa, salenptr) < 0)
  err_sys("getpeername error");
}

void
Getsockname(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
 if (getsockname(fd, sa, salenptr) < 0)
  err_sys("getsockname error");
}

void
Getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlenptr)
{
 if (getsockopt(fd, level, optname, optval, optlenptr) < 0)
  err_sys("getsockopt error");
}

int
Isfdtype(int fd, int fdtype)
{
 int  n;

 if ( (n = isfdtype(fd, fdtype)) < 0)
  err_sys("isfdtype error");
 return(n);
}

/* include Listen */
void
Listen(int fd, int backlog)
{
 char *ptr;

  /*4can override 2nd argument with environment variable */
 if ( (ptr = getenv("LISTENQ")) != NULL)
  backlog = atoi(ptr);

 if (listen(fd, backlog) < 0)
  err_sys("listen error");
}
/* end Listen */

#ifdef HAVE_POLL
int
Poll(struct pollfd *fdarray, unsigned long nfds, int timeout)
{
 int  n;

 if ( (n = poll(fdarray, nfds, timeout)) < 0)
  err_sys("poll error");

 return(n);
}
#endif

ssize_t
Recv(int fd, void *ptr, size_t nbytes, int flags)
{
 ssize_t  n;

 if ( (n = recv(fd, ptr, nbytes, flags)) < 0)
  err_sys("recv error");
 return(n);
}

ssize_t
Recvfrom(int fd, void *ptr, size_t nbytes, int flags,
   struct sockaddr *sa, socklen_t *salenptr)
{
 ssize_t  n;

 if ( (n = recvfrom(fd, ptr, nbytes, flags, sa, salenptr)) < 0)
  err_sys("recvfrom error");
 return(n);
}

ssize_t
Recvmsg(int fd, struct msghdr *msg, int flags)
{
 ssize_t  n;

 if ( (n = recvmsg(fd, msg, flags)) < 0)
  err_sys("recvmsg error");
 return(n);
}

int
Select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
       struct timeval *timeout)
{
 int  n;

 if ( (n = select(nfds, readfds, writefds, exceptfds, timeout)) < 0)
  err_sys("select error");
 return(n);  /* can return 0 on timeout */
}

void
Send(int fd, const void *ptr, size_t nbytes, int flags)
{
 if (send(fd, ptr, nbytes, flags) != nbytes)
  err_sys("send error");
}

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) != nbytes)
  err_sys("sendto error");
}

void
Sendmsg(int fd, const struct msghdr *msg, int flags)
{
 int   i;
 ssize_t  nbytes;

 nbytes = 0; /* must first figure out what return value should be */
 for (i = 0; i < msg->msg_iovlen; i++)
  nbytes += msg->msg_iov[i].iov_len;

 if (sendmsg(fd, msg, flags) != nbytes)
  err_sys("sendmsg error");
}

void
Setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
{
 if (setsockopt(fd, level, optname, optval, optlen) < 0)
  err_sys("setsockopt error");
}

void
Shutdown(int fd, int how)
{
 if (shutdown(fd, how) < 0)
  err_sys("shutdown error");
}

int
Sockatmark(int fd)
{
 int  n;

 if ( (n = sockatmark(fd)) < 0)
  err_sys("sockatmark error");
 return(n);
}

/* include Socket */
int
Socket(int family, int type, int protocol)
{
 int  n;

 if ( (n = socket(family, type, protocol)) < 0)
  err_sys("socket error");
 return(n);
}
/* end Socket */

void
Socketpair(int family, int type, int protocol, int *fd)
{
 int  n;

 if ( (n = socketpair(family, type, protocol, fd)) < 0)
  err_sys("socketpair error");
}
 

/*

unp,h

*/

/* include unph */
/* Our own header.  Tabs are set for 4 spaces, not 8 */

#ifndef __unp_h
#define __unp_h

#include "../config.h" /* configuration options for current OS */
       /* "../config.h" is generated by configure */

/* If anything changes in the following list of #includes, must change
   acsite.m4 also, for configure's tests. */

#include <sys/types.h> /* basic system data types */
#include <sys/socket.h> /* basic socket definitions */
#include <sys/time.h> /* timeval{} for select() */
#include <time.h>  /* timespec{} for pselect() */
#include <netinet/in.h> /* sockaddr_in{} and other Internet defns */
#include <arpa/inet.h> /* inet(3) functions */
#include <errno.h>
#include <fcntl.h>  /* for nonblocking */
#include <netdb.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h> /* for S_xxx file mode constants */
#include <sys/uio.h>  /* for iovec{} and readv/writev */
#include <unistd.h>
#include <sys/wait.h>
#include <sys/un.h>  /* for Unix domain sockets */

#ifdef HAVE_SYS_SELECT_H
# include <sys/select.h> /* for convenience */
#endif

#ifdef HAVE_POLL_H
# include <poll.h>  /* for convenience */
#endif

#ifdef HAVE_STRINGS_H
# include <strings.h>  /* for convenience */
#endif

/* Three headers are normally needed for socket/file ioctl's:
 * <sys/ioctl.h>, <sys/filio.h>, and <sys/sockio.h>.
 */
#ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#ifdef HAVE_SYS_FILIO_H
# include <sys/filio.h>
#endif
#ifdef HAVE_SYS_SOCKIO_H
# include <sys/sockio.h>
#endif

#ifdef HAVE_PTHREAD_H
# include <pthread.h>
#endif

/* OSF/1 actually disables recv() and send() in <sys/socket.h> */
#ifdef __osf__
#undef recv
#undef send
#define recv(a,b,c,d) recvfrom(a,b,c,d,0,0)
#define send(a,b,c,d) sendto(a,b,c,d,0,0)
#endif

#ifndef INADDR_NONE
/* $$.Ic INADDR_NONE$$ */
#define INADDR_NONE 0xffffffff /* should have been in <netinet/in.h> */
#endif

#ifndef SHUT_RD    /* these three Posix.1g names are quite new */
#define SHUT_RD  0 /* shutdown for reading */
#define SHUT_WR  1 /* shutdown for writing */
#define SHUT_RDWR 2 /* shutdown for reading and writing */
/* $$.Ic SHUT_RD$$ */
/* $$.Ic SHUT_WR$$ */
/* $$.Ic SHUT_RDWR$$ */
#endif

/* *INDENT-OFF* */
#ifndef INET_ADDRSTRLEN
/* $$.Ic INET_ADDRSTRLEN$$ */
#define INET_ADDRSTRLEN  16 /* "ddd.ddd.ddd.ddd/0"
            1234567890123456 */
#endif

/* Define following even if IPv6 not supported, so we can always allocate
   an adequately-sized buffer, without #ifdefs in the code. */
#ifndef INET6_ADDRSTRLEN
/* $$.Ic INET6_ADDRSTRLEN$$ */
#define INET6_ADDRSTRLEN 46 /* max size of IPv6 address string:
       "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx" or
       "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:ddd.ddd.ddd.ddd/0"
        1234567890123456789012345678901234567890123456 */
#endif
/* *INDENT-ON* */

/* Define bzero() as a macro if it's not in standard C library. */
#ifndef HAVE_BZERO
#define bzero(ptr,n)  memset(ptr, 0, n)
/* $$.If bzero$$ */
/* $$.If memset$$ */
#endif

/* Older resolvers do not have gethostbyname2() */
#ifndef HAVE_GETHOSTBYNAME2
#define gethostbyname2(host,family)  gethostbyname((host))
#endif

/* The structure returned by recvfrom_flags() */
struct in_pktinfo {
  struct in_addr ipi_addr; /* dst IPv4 address */
  int    ipi_ifindex;/* received interface index */
};
/* $$.It in_pktinfo$$ */
/* $$.Ib ipi_addr$$ */
/* $$.Ib ipi_ifindex$$ */

/* We need the newer CMSG_LEN() and CMSG_SPACE() macros, but few
   implementations support them today.  These two macros really need
    an ALIGN() macro, but each implementation does this differently. */
#ifndef CMSG_LEN
/* $$.Ic CMSG_LEN$$ */
#define CMSG_LEN(size)  (sizeof(struct cmsghdr) + (size))
#endif
#ifndef CMSG_SPACE
/* $$.Ic CMSG_SPACE$$ */
#define CMSG_SPACE(size) (sizeof(struct cmsghdr) + (size))
#endif

/* Posix.1g requires the SUN_LEN() macro but not all implementations DefinE
   it (yet).  Note that this 4.4BSD macro works regardless whether there is
   a length field or not. */
#ifndef SUN_LEN
/* $$.Im SUN_LEN$$ */
# define SUN_LEN(su) /
 (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
#endif

/* Posix.1g renames "Unix domain" as "local IPC".
   But not all systems DefinE AF_LOCAL and AF_LOCAL (yet). */
#ifndef AF_LOCAL
#define AF_LOCAL AF_UNIX
#endif
#ifndef PF_LOCAL
#define PF_LOCAL PF_UNIX
#endif

/* Posix.1g requires that an #include of <poll.h> DefinE INFTIM, but many
   systems still DefinE it in <sys/stropts.h>.  We don't want to include
   all the streams stuff if it's not needed, so we just DefinE INFTIM here.
   This is the standard value, but there's no guarantee it is -1. */
#ifndef INFTIM
#define INFTIM          (-1)    /* infinite poll timeout */
/* $$.Ic INFTIM$$ */
#ifdef HAVE_POLL_H
#define INFTIM_UNPH    /* tell unpxti.h we defined it */
#endif
#endif

/* Following could be derived from SOMAXCONN in <sys/socket.h>, but many
   kernels still #define it as 5, while actually supporting many more */
#define LISTENQ  1024 /* 2nd argument to listen() */

/* Miscellaneous constants */
#define MAXLINE  4096 /* max text line length */
#define MAXSOCKADDR  128 /* max socket address structure size */
#define BUFFSIZE 8192 /* buffer size for reads and writes */

/* Define some port number that can be used for client-servers */
#define SERV_PORT   9877   /* TCP and UDP client-servers */
#define SERV_PORT_STR "9877"   /* TCP and UDP client-servers */
#define UNIXSTR_PATH "/tmp/unix.str" /* Unix domain stream cli-serv */
#define UNIXDG_PATH  "/tmp/unix.dg" /* Unix domain datagram cli-serv */
/* $$.ix [LISTENQ]~constant,~definition~of$$ */
/* $$.ix [MAXLINE]~constant,~definition~of$$ */
/* $$.ix [MAXSOCKADDR]~constant,~definition~of$$ */
/* $$.ix [BUFFSIZE]~constant,~definition~of$$ */
/* $$.ix [SERV_PORT]~constant,~definition~of$$ */
/* $$.ix [UNIXSTR_PATH]~constant,~definition~of$$ */
/* $$.ix [UNIXDG_PATH]~constant,~definition~of$$ */

/* Following shortens all the type casts of pointer arguments */
#define SA struct sockaddr

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
     /* default file access permissions for new files */
#define DIR_MODE (FILE_MODE | S_IXUSR | S_IXGRP | S_IXOTH)
     /* default permissions for new directories */

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

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

#ifndef HAVE_ADDRINFO_STRUCT
# include "../lib/addrinfo.h"
#endif

#ifndef HAVE_IF_NAMEINDEX_STRUCT
struct if_nameindex {
  unsigned int   if_index;  /* 1, 2, ... */
  char          *if_name;   /* null terminated name: "le0", ... */
};
/* $$.It if_nameindex$$ */
/* $$.Ib if_index$$ */
/* $$.Ib if_name$$ */
#endif

#ifndef HAVE_TIMESPEC_STRUCT
struct timespec {
  time_t tv_sec;  /* seconds */
  long  tv_nsec; /* and nanoseconds */
};
/* $$.It timespec$$ */
/* $$.Ib tv_sec$$ */
/* $$.Ib tv_nsec$$ */
#endif
/* end unph */

   /* prototypes for our own library functions */
int   connect_nonb(int, const SA *, socklen_t, int);
int   connect_timeo(int, const SA *, socklen_t, int);
void  daemon_init(const char *, int);
void  daemon_inetd(const char *, int);
void  dg_cli(FILE *, int, const SA *, socklen_t);
void  dg_echo(int, SA *, socklen_t);
char *gf_time(void);
void  heartbeat_cli(int, int, int);
void  heartbeat_serv(int, int, int);
struct addrinfo *host_serv(const char *, const char *, int, int);
int   inet_srcrt_add(char *, int);
u_char  *inet_srcrt_init(void);
void  inet_srcrt_print(u_char *, int);
char   **my_addrs(int *);
int   readable_timeo(int, int);
ssize_t  readline(int, void *, size_t);
ssize_t  readn(int, void *, size_t);
ssize_t  read_fd(int, void *, size_t, int *);
ssize_t  recvfrom_flags(int, void *, size_t, int *, SA *, socklen_t *,
   struct in_pktinfo *);
Sigfunc *signal_intr(int, Sigfunc *);
int   sock_bind_wild(int, int);
int   sock_cmp_addr(const SA *, const SA *, socklen_t);
int   sock_cmp_port(const SA *, const SA *, socklen_t);
int   sock_get_port(const SA *, socklen_t);
void  sock_set_addr(SA *, socklen_t, const void *);
void  sock_set_port(SA *, socklen_t, int);
void  sock_set_wild(SA *, socklen_t);
char *sock_ntop(const SA *, socklen_t);
char *sock_ntop_host(const SA *, socklen_t);
int   sockfd_to_family(int);
void  str_echo(int);
void  str_cli(FILE *, int);
int   tcp_connect(const char *, const char *);
int   tcp_listen(const char *, const char *, socklen_t *);
void  tv_sub(struct timeval *, struct timeval *);
int   udp_client(const char *, const char *, void **, socklen_t *);
int   udp_connect(const char *, const char *);
int   udp_server(const char *, const char *, socklen_t *);
int   writable_timeo(int, int);
ssize_t  writen(int, const void *, size_t);
ssize_t  write_fd(int, void *, size_t, int);

#ifdef MCAST
int   mcast_leave(int, const SA *, socklen_t);
int   mcast_join(int, const SA *, socklen_t, const char *, u_int);
int   mcast_get_if(int);
int   mcast_get_loop(int);
int   mcast_get_ttl(int);
int   mcast_set_if(int, const char *, u_int);
int   mcast_set_loop(int, int);
int   mcast_set_ttl(int, int);

void  Mcast_leave(int, const SA *, socklen_t);
void  Mcast_join(int, const SA *, socklen_t, const char *, u_int);
int   Mcast_get_if(int);
int   Mcast_get_loop(int);
int   Mcast_get_ttl(int);
void  Mcast_set_if(int, const char *, u_int);
void  Mcast_set_loop(int, int);
void  Mcast_set_ttl(int, int);
#endif

unsigned short in_cksum(unsigned short *, int);

#ifndef HAVE_GETADDRINFO_PROTO
int   getaddrinfo(const char *, const char *, const struct addrinfo *,
      struct addrinfo **);
void  freeaddrinfo(struct addrinfo *);
char *gai_strerror(int);
#endif

#ifndef HAVE_GETNAMEINFO_PROTO
int   getnameinfo(const SA *, socklen_t, char *, size_t, char *, size_t, int);
#endif

#ifndef HAVE_GETHOSTNAME_PROTO
int   gethostname(char *, int);
#endif

#ifndef HAVE_HSTRERROR_PROTO
const char *hstrerror(int);
#endif

#ifndef HAVE_IF_NAMETOINDEX_PROTO
unsigned int  if_nametoindex(const char *);
char   *if_indextoname(unsigned int, char *);
void    if_freenameindex(struct if_nameindex *);
struct if_nameindex *if_nameindex(void);
#endif

#ifndef HAVE_INET_PTON_PROTO
int    inet_pton(int, const char *, void *);
const char *inet_ntop(int, const void *, char *, size_t);
#endif

#ifndef HAVE_INET_ATON_PROTO
int   inet_aton(const char *, struct in_addr *);
#endif

#ifndef HAVE_ISFDTYPE_PROTO
int   isfdtype(int, int);
#endif

#ifndef HAVE_PSELECT_PROTO
int   pselect(int, fd_set *, fd_set *, fd_set *,
     const struct timespec *, const sigset_t *);
#endif

#ifndef HAVE_SOCKATMARK_PROTO
int   sockatmark(int);
#endif

#ifndef HAVE_SNPRINTF_PROTO
int   snprintf(char *, size_t, const char *, ...);
#endif

   /* prototypes for our own library wrapper functions */
void  Connect_timeo(int, const SA *, socklen_t, int);
struct addrinfo *Host_serv(const char *, const char *, int, int);
const char  *Inet_ntop(int, const void *, char *, size_t);
void    Inet_pton(int, const char *, void *);
char   *If_indextoname(unsigned int, char *);
unsigned int   If_nametoindex(const char *);
struct if_nameindex *If_nameindex(void);
char   **My_addrs(int *);
ssize_t  Read_fd(int, void *, size_t, int *);
int   Readable_timeo(int, int);
ssize_t  Recvfrom_flags(int, void *, size_t, int *, SA *, socklen_t *,
   struct in_pktinfo *);
Sigfunc *Signal(int, Sigfunc *);
Sigfunc *Signal_intr(int, Sigfunc *);
int   Sock_bind_wild(int, int);
char *Sock_ntop(const SA *, socklen_t);
char *Sock_ntop_host(const SA *, socklen_t);
int   Sockfd_to_family(int);
int   Tcp_connect(const char *, const char *);
int   Tcp_listen(const char *, const char *, socklen_t *);
int   Udp_client(const char *, const char *, void **, socklen_t *);
int   Udp_connect(const char *, const char *);
int   Udp_server(const char *, const char *, socklen_t *);
ssize_t  Write_fd(int, void *, size_t, int);
int   Writable_timeo(int, int);

   /* prototypes for our Unix wrapper functions: see {Sec errors} */
void *Calloc(size_t, size_t);
void  Close(int);
void  Dup2(int, int);
int   Fcntl(int, int, int);
void  Gettimeofday(struct timeval *, void *);
int   Ioctl(int, int, void *);
pid_t  Fork(void);
void *Malloc(size_t);
void  Mktemp(char *);
void *Mmap(void *, size_t, int, int, int, off_t);
int   Open(const char *, int, mode_t);
void  Pipe(int *fds);
ssize_t  Read(int, void *, size_t);
void  Sigaddset(sigset_t *, int);
void  Sigdelset(sigset_t *, int);
void  Sigemptyset(sigset_t *);
void  Sigfillset(sigset_t *);
int   Sigismember(const sigset_t *, int);
void  Sigpending(sigset_t *);
void  Sigprocmask(int, const sigset_t *, sigset_t *);
char *Strdup(const char *);
long  Sysconf(int);
void  Sysctl(int *, u_int, void *, size_t *, void *, size_t);
void  Unlink(const char *);
pid_t  Wait(int *);
pid_t  Waitpid(pid_t, int *, int);
void  Write(int, void *, size_t);

   /* prototypes for our stdio wrapper functions: see {Sec errors} */
void  Fclose(FILE *);
FILE *Fdopen(int, const char *);
char *Fgets(char *, int, FILE *);
FILE *Fopen(const char *, const char *);
void  Fputs(const char *, FILE *);

   /* prototypes for our socket wrapper functions: see {Sec errors} */
int   Accept(int, SA *, socklen_t *);
void  Bind(int, const SA *, socklen_t);
void  Connect(int, const SA *, socklen_t);
void  Getpeername(int, SA *, socklen_t *);
void  Getsockname(int, SA *, socklen_t *);
void  Getsockopt(int, int, int, void *, socklen_t *);
int   Isfdtype(int, int);
void  Listen(int, int);
#ifdef HAVE_POLL
int   Poll(struct pollfd *, unsigned long, int);
#endif
ssize_t  Readline(int, void *, size_t);
ssize_t  Readn(int, void *, size_t);
ssize_t  Recv(int, void *, size_t, int);
ssize_t  Recvfrom(int, void *, size_t, int, SA *, socklen_t *);
ssize_t  Recvmsg(int, struct msghdr *, int);
int   Select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
void  Send(int, const void *, size_t, int);
void  Sendto(int, const void *, size_t, int, const SA *, socklen_t);
void  Sendmsg(int, const struct msghdr *, int);
void  Setsockopt(int, int, int, const void *, socklen_t);
void  Shutdown(int, int);
int   Sockatmark(int);
int   Socket(int, int, int);
void  Socketpair(int, int, int, int *);
void  Writen(int, void *, size_t);

void  err_dump(const char *, ...);
void  err_msg(const char *, ...);
void  err_quit(const char *, ...);
void  err_ret(const char *, ...);
void  err_sys(const char *, ...);

#endif /* __unp_h */