unp.h

unp.h

#ifndef _UNP_H_

#define _UNP_H_

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <fcntl.h>

#include <stdarg.h>

#include <signal.h>

#include <string.h> /* for strerror */

#include <sys/wait.h>

#include <sys/select.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <sys/types.h>

#define MAXLINE 4096

#define SERV_PORT 6666

typedef void Sigfunc(int);

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

ssize_t readn(int fd,void *ptr,size_t n);

ssize_t writen(int fd,const void *ptr,size_t n);

ssize_t Read(int fd,void *buff,size_t n);

void Write(int fd,const void *buff,size_t n);

char *Fgets(char *buff,int nbytes,FILE *fp);

int Fputs(const char *str,FILE *fp);

void Close(int fd);

void err_quit(char *fmt,...);

int Socket(int family,int type,int protocol);

void Connect(int sockfd,const struct sockaddr *servaddr,socklen_t addrlen);

void Bind(int sockfd,const struct sockaddr *myaddr,socklen_t addrlen);

void Listen(int sockfd,int backlog);

int Accept(int sockfd,struct sockaddr *cliaddr,socklen_t *addrlen);

int Fork();

Sigfunc *Signal(int signo,Sigfunc *func);

int Select(int maxfdp1,fd_set *readsex,fd_set *writeset,fd_set *exceptset,

        struct timeval *timeout);

char *sock_ntop(const struct sockaddr *sockaddr, socklen_t addrlen);

#endif

unp.c

#include "unp.h"

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 == n)

                return -1;

            else

                break;

        }else if(nread == 0)

            break;

        nleft -= nread;

        ptr += nread;

    }

    return(n-nleft);

}

ssize_t writen(int fd,const void *ptr,size_t n){

    size_t nleft;

    ssize_t nwritten;

    nleft=n;

    while(nleft > 0){

        if((nwritten=write(fd,buff,nleft)) < 0){

            if(nleft == n)

                return -1;

            else

                break;

        }else if(nwritten == 0)

            break;

        nleft -= nwritten;

        ptr += nwritten;

    }

    return(n-nleft);

}

ssize_t Read(int fd,void *buff,size_t n){

    int nread;

    if((nread=read(fd,buff,n)) < 0)

        err_quit("read error");

    return nread;

}

void Write(int fd,const void *buff,size_t n){

    if(write(fd,buff,n) != n)

        err_quit("write error");

}

char *Fgets(char *buff,int nbytes,FILE *fp){

    char *ptr=fgets(buff,nbytes,fp);

    if(ptr==NULL && ferror(fp))

        err_quit("fgets error");

    return ptr;

}

int Fputs(const char *str,FILE *fp){

    int ret=fputs(str,fp);

    if(ret == EOF)

        err_quit("fputs error");

    return ret;

}

void Close(int fd){

    if(close(fd)<0)

        err_quit("close error");

}

void err_quit(char *fmt,...){

    int errno_save=errno;

    va_list va;

    va_start(va,fmt);

    vfprintf(stderr,fmt,va);

    if(errno_save != 0)

        fprintf(stderr," :%s",strerror(errno_save));

    fprintf(stderr,"\n");

    va_end(va);

    exit(0);

}

int Socket(int family,int type,int protocol){

    int sockfd=socket(family,type,protocol);

    if(sockfd == -1)

        err_quit("socket error");

    return sockfd;

}

void Connect(int sockfd,const struct sockaddr *servaddr,socklen_t addrlen){

    if(connect(sockfd,servaddr,addrlen) == -1)

        err_quit("connect error");

}

void Bind(int sockfd,const struct sockaddr *myaddr,socklen_t addrlen){

    if(bind(sockfd,myaddr,addrlen) == -1)

        err_quit("bind error");

}

void Listen(int sockfd,int backlog){

    if(listen(sockfd,backlog) == -1)

        err_quit("listen error");

}

int Accept(int sockfd,struct sockaddr *cliaddr,socklen_t *addrlen){

    int connfd=accept(sockfd,cliaddr,addrlen);

    if(connfd < 0)

        err_quit("accept error");

    return connfd;

}

int Fork(){

    pid_t pid=fork();

    if(pid < 0)

        err_quit("fork error");

    return pid;

}

Sigfunc *Signal(int signo,Sigfunc *func){

    Sigfunc *sigfunc=signal(signo,func);

    if(sigfunc == SIG_ERR)

        err_quit("signal error");

    return sigfunc;

}

int Select(int maxfdp1,fd_set *readsex,fd_set *writeset,fd_set *exceptset,

        struct timeval *timeout){

    int ret;

    if((ret=select(maxfdp1,readsex,writeset,exceptset,timeout)) < 0)

        err_quit("select error");

    return ret;

}

char *sock_ntop(const struct sockaddr *sa, socklen_t addrlen){

    char portstr[8];

    static char str[128];

    switch(sa->sa_family){

        case AF_INET:{

                         struct sockaddr_in *sin=(struct sockaddr_in *)sa;

                         if(inet_ntop(AF_INET,&sin->sin_addr,str,sizeof(str)) == NULL)

                             return(NULL);

                         if(ntohs(sin->sin_port) != 0){

                             snprintf(portstr,sizeof(portstr),":%d",

                                     ntohs(sin->sin_port));

                             strcat(str,portstr);

                         }

                         return(str);

                     }

        case AF_INET6:{

                         struct sockaddr_in6 *sin=(struct sockaddr_in6 *)sa;

                         if(inet_ntop(AF_INET6,&sin->sin6_addr,str,sizeof(str)) == NULL)

                             return(NULL);

                         if(ntohs(sin->sin6_port) != 0){

                             snprintf(portstr,sizeof(portstr),":%d",

                                     ntohs(sin->sin6_port));

                             strcat(str,portstr);

                         }

                         return(str);

                     }

        default:

                      printf("unknown sockaddr family\n");

                      break;

    }

}