C Makefile error on Solaris

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <arpa/inet.h>       
#include <unistd.h>           
#include <ctype.h>
#include <sys/wait.h>
#include "sockwrap.h"
#include "errlib.h"
#if 0
#include "sockwrap_hex.gh" // in order to do debug
#endif
 
/***********************************************************************************************
**                       List of Defines used for the messages                               **
***********************************************************************************************/
 
#define MAX_LINE 1000 /* mainly for array size */
#define HERE "HERE"
#define WHO "WHO?"
#define NOOB "NOOB"
#define PASS "PASS"
#define BYE "BYE!"
#define FAIL "FAIL"
#define NAUT "NAUT"
#define FULL "FULL"
#define GOOD "GOOD"
#define ALERT "ALERT"
#define WHAT "????"
 
/***********************************************************************************************
**                       Linked List Struct                                                  **
***********************************************************************************************/
 
struct NODE {
	int code; 
	char name[1000];
	struct NODE *next;
	int size;
	int line;
};
 
 
/***********************************************************************************************
**                      Global Variables                                                     **
***********************************************************************************************/
 
struct NODE *llist;
 
int size = 0;
int auth = 0;
int linea = 0;
char *prog;
 
 
/***********************************************************************************************
**                       Function prototypes                                                  **
***********************************************************************************************/
 
int  search_value(struct NODE *llist, int text_line, int fd);
void append_node(struct NODE *llist, char* name, int num, int linea);
void display_list(struct NODE *llist, int fd);
int verify_login(char *, char *);
void clean_list(struct NODE *llist);
void listen_client_requests(int fd);
void load_file_in_list(int fd);
 
 
/***********************************************************************************************
**                       Strings which server sends                                           **
***********************************************************************************************/
 
void sendHERE(int fd){
	Writen(fd, HERE, strlen(HERE));
}
 
void sendWHO(int fd){
	Writen(fd, WHO, strlen(WHO));
}
 
void sendNOOB(int fd){
	Writen(fd, NOOB, strlen(NOOB));
}
 
void sendPASS(int fd){
	Writen(fd, PASS, strlen(PASS));
}
 
void sendFAIL(int fd){
	Writen(fd, FAIL, strlen(FAIL));
}
 
void sendGOOD(int fd){
	Writen(fd, GOOD, strlen(GOOD));
}
 
void sendNAUT(int fd){
	Writen(fd, NAUT, strlen(NAUT));
}
 
void sendALERT(int fd){
	Writen(fd, ALERT, strlen(ALERT));
}
 
void sendFULL(int fd){
	Writen(fd, FULL, strlen(FULL));
}
 
void sendBYE(int fd){
	Writen(fd, BYE, strlen(BYE));
}
 
void sendWHAT(int fd){
	Writen(fd, WHAT, strlen(WHAT));
}
 
/***********************************************************************************************
**                    In order to display the list when server receives LIST                  **
***********************************************************************************************/
 
void display_list(struct NODE *llist, int fd)
{
	
	char stringa[MAX_LINE];
	
	if (llist->next == NULL )
		sendNOOB(fd);  
	
	if(llist->next != NULL)
	{
		
		sendHERE(fd);
		int i;
		
		for(i=0; i < (size-1); i++)
		{
			
			llist = llist->next;
			snprintf(stringa, sizeof(stringa), "%s\r\n", llist->name);
			Writen(fd, stringa, strlen(stringa));
			
		}
		
		llist = llist->next;
		snprintf(stringa, sizeof(stringa), "%s\r\n\r\n", llist->name);
		Writen(fd, stringa, strlen(stringa));
		
	}  
	
	
}
 
/***********************************************************************************************
**                  I store the content of text file in my Linked List                        **
***********************************************************************************************/
 
void append_node(struct NODE *llist, char * name, int num, int line)
{
	
	while(llist->next != NULL) 
	llist = llist->next; 
	llist->next = (struct NODE *)malloc(sizeof(struct NODE));
	llist->next->code = num;
	llist->next->line = line;
	strcpy((char*)llist->next->name, (char*)name);
	llist->next->next = NULL;
	
}
 
 
/***********************************************************************************************
**                  Search for Values present at a given text line                           **
***********************************************************************************************/
 
int search_value(struct NODE *llist, int text_line, int fd)
{
		
	
	while(llist != NULL)
	{
		
		if(llist->line == text_line)
		{ 			
			
			return llist->code;
			break;		                	
		}	 
		 
		llist = llist->next;
		
	}
	
	return 65535;
	
}
 
 
/***********************************************************************************************
**                                 Free all the list                                          **
***********************************************************************************************/
 
void clean_list(struct NODE *llist)
{
		
	
	while(llist != NULL)
	{	
		
		struct NODE *tmp = llist->next;
            free(llist);
            llist = tmp;
		
	}
	
	
}
 
 
/***********************************************************************************************
**                                  Children Handling                                         **
***********************************************************************************************/
 
int count = 0; 
 
void signal_handler(int sig)
{
	pid_t pid;
	int status;
	
	/* for solaris and unix system */
	signal(sig, signal_handler);
	
	while( (pid = waitpid(-1,&status,WNOHANG)) > 0)
	{		    
		count--; /* child processes counter */
	}
	
}
 
 
/***********************************************************************************************
**                  Variables for parameters and user control                                **
***********************************************************************************************/
 
int your_choise, use_port = 1, use_child_max = 1, child_max;
char *objs_file = NULL;
char *usrs_file = NULL;
unsigned char msg[1];
 
 
/***********************************************************************************************
**          The main() program: opens and receives new connections                          **
***********************************************************************************************/
 
 
int main (int argc, char *argv[])
{
	int port = 0, sock, fd, value;
	unsigned int client_len;
	struct sockaddr_in server, client;
	char host[40];  
	
	
	int c;
	
	opterr = 0;
	
	while ((c = getopt (argc, argv, "p:n:f:")) != -1)
		switch (c)
	{
		case 'p':
			port = atoi(optarg);
			use_port = 0;
			if ( port <= 0){
				printf("Errore: Numero di porta errato!\n");
				exit(3);
			}
			break;
			case 'n':
			child_max = atoi(optarg);
			use_child_max = 0;
			if( child_max <= 0){
				printf("Errore: Numero massimo di processi errato!\n");
				exit(3);
			}
			break;
			case 'o':
			objs_file = optarg;
			break;
			case 'u':
			usrs_file = optarg;
			break;
			case '?':
			if (optopt == 'o')
				fprintf (stderr, "il parametro -%c richiede come argomento il nome di un file di testo.\n", optopt);
			if (optopt == 'u')
				fprintf (stderr, "il parametro -%c richiede come argomento il nome di un file di testo.\n", optopt);
			if (optopt == 'p')
				fprintf (stderr, "il parametro -%c per la scelta della porta richiede come argomento un numero intero.\n", optopt);
			if (optopt == 'n')
				fprintf (stderr, "il parametro -%c per la scelta del numero massimo di processi richiede come argomento un numero intero.\n", optopt);
			else if (isprint (optopt)){
				fprintf (stderr, "\nComando sconosciuto `-%c'.\n", optopt);
				printf("\nUsage:\n%s -pPORT -nCHILD_MAX -uTEXT_FILE -oTEXT_FILE\n\n", argv[0]);
				exit(1);
			}
			else
				fprintf (stderr,
						 "Opzione carattere non riconosciuta `\\x%x'.\n",
						 optopt);
			return 1;
			default:
			abort ();
	}          
	
	
	
	if (objs_file == NULL){
		objs_file = "obj.txt";
	}
	
	if (usrs_file == NULL){
		usrs_file = "usr.dat";
	}
	
	if (use_port == 1){ 
		port = 1234;
	}
	
	if (use_child_max == 1){
		child_max = 2;
	}	  	  
	
	setbuf(stdout,NULL);		/* serve per settare a unbuffered stdout */
	
	prog = argv[0];
	
	sock = socket(AF_INET, SOCK_STREAM, 0);  /* SOCK_STREAM per TCP; */
	
	if (sock < 0)
	{
		perror("Creating a stream socket");
		exit(1);
	}
	
	
	server.sin_family = AF_INET; 
	server.sin_addr.s_addr = htonl(INADDR_ANY); 
	
	server.sin_port = htons(port);
	
	/* call SO_REUSEADDR before bind() */
	value = 1;
	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&value, sizeof(value)) < 0)
	{
		perror("during setsockopt");
		exit(5);
	}
	
	
	if (bind(sock, (struct sockaddr *) &server, sizeof(server)) < 0) 
	{
		perror("binding socket");
		exit(2); 
	}
	
	listen(sock, 10); 
	
	
	//signal(SIGTSTP, signal_handler); /* trap CTRL-Z signal */ 
	signal(SIGCHLD, signal_handler); 
	
	pid_t pid;
	
	while (1) { 
		
		client_len = sizeof(client);
		printf("\nServer in attesa\n");
		
		if ((fd = accept(sock, (struct sockaddr *) &client, &client_len)) < 0) {
			
			//perror("accepting connection");	per eventuali debug/test
			continue;			
			//exit(3);
		}
		
		
		if ( count < child_max)
		{
		
			count ++;
			sendWHO(fd);
			
			if ( (pid = fork()) == 0 )
			{		
				
				gethostname(host, 40);
				printf("Accepted client: IP= %s, port=%d, hostname= %s\n",
				inet_ntoa(client.sin_addr),
				ntohs(client.sin_port), host);
				close(sock);
				listen_client_requests(fd); 
				close(fd);
				
				exit(0);	
						/* when a child ends */
			} 
			
			else
				close(fd);
				
		}
		
		else if (count >= child_max)
		{
			sendFULL(fd);
			close(fd);
		}
		
		
	}
	
	return 0;
}
 
 
 
/***********************************************************************************************
**                         Add and Manage a Client                                            **
***********************************************************************************************/
 
 
void listen_client_requests(int fd)
{
	load_file_in_list(fd);
	char buffer[5];
	int i = 0;	
	char *username = (char *)malloc(18*sizeof(char));
	char *password = (char *)malloc(18*sizeof(char));
	char *user = (char *)malloc(18*sizeof(char));
	char *passwd = (char *)malloc(18*sizeof(char));
		
	
	while(1)
    {
		Readn(fd,buffer,4*sizeof(char));
		
		
		
			  if ( strncmp(buffer, "HELO", 4*sizeof(char)) == 0)
				{ 					
					memset(username,0,18*sizeof(char));
                    memset(password,0,18*sizeof(char));
					
					for(i=1;i<=18;i++)
					{                      
					    Readn(fd,&(username[i-1]),1*sizeof(char));
                     
					    if( i > 1)					  
					    {
                      
					    if(username[i-1]=='\n' && username[i-2]=='\r') i=19;
                      
					    }
					  
                    }
					
					user = strtok(username, "\r\n");
					
					sendPASS(fd);					
					
					for(i=1;i<=18;i++)
					{
					
                       Readn(fd,&(password[i-1]),1*sizeof(char));
                      
					  if(i > 1)
					  {
					  
                       if(password[i-1]=='\n' && password[i-2]=='\r') i=19;
					   
                      }
					  
                    }					
					
					passwd = strtok(password, "\r\n");
					
				
					if (verify_login(username, password)==1)
					{
						auth=1;
						sendGOOD(fd);
					}
					
					else if(verify_login(username, password)==-1)
					{
						auth=0;
						sendFAIL(fd);
					}  
					
					
					
				}				
				
				else if ( strncmp(buffer, "LIST", 4) == 0)
				{  
					display_list(llist, fd);
					
				}
				
				else if ( strncmp(buffer, "QUIT", 4) == 0)
				{  
					sendBYE(fd);
					clean_list(llist);
					
					return;
				}
				
				else if(strncmp(buffer, "COST", 4) == 0)
				{  
					
					uint16_t arr;
					unsigned int val=0;								
					int found;
					uint16_t net;   
					
					if (auth == 0) 
					{
						sendNAUT(fd);
					}
					
					
					else if (llist ->next != NULL)
					{   
					    	
						sendHERE(fd);
						while(1)
						{
                        Readn(fd, &arr, 1*sizeof(uint16_t));
                        val = ntohs(arr);
                        if ( val != 0)
						{
							Writen(fd, &arr, 2);
						}
						else if ( val == 0)
						{
							break;
						}
						
						found = search_value(llist, val, fd);       
						
						if ( found != 0 )
						{
							net = htons(found);                               
							Writen(fd, &net, sizeof(net));
						}			
		
							
						}   
						                            
					}
				}
				
			else 
			{
			sendWHAT(fd);
			}					
				
    }
		
				
}
 
 
/***********************************************************************************************
**                       Open and Load data into the Linked List                              **
***********************************************************************************************/
 
void load_file_in_list(fd)
{
	
	llist = (struct NODE *)malloc(sizeof(struct NODE));
	llist->code = 0;
	llist->next = NULL;
	llist->size = 0;
	llist->line = 0;  
	
	FILE * pFile;
	char buffer [1000];
	int code;
	char name[1000];
	
	
	pFile = fopen (objs_file , "r");
	
	if (pFile == NULL)
	{
		perror ("Error opening file");
	}
	else
	{
		while ( fgets (buffer , 100 , pFile) != NULL )
		{
			
			sscanf(buffer,"%d %s \n", &code, name);  
			linea++;
			append_node(llist, name, code, linea); 
			size++;
		}
		
		fclose (pFile);
	}
	
}
 
int verify_login(char * usern, char * pass)
{
	
	char entry[32];
	char username[17] = { 0 }; 
	char password[17] = { 0 };
	char * temp = (char *)malloc(17*sizeof(char));;
	
	FILE * passfile = fopen(usrs_file, "r");
	
	if ( passfile == NULL)
	{
		return -1;	
	}   
	
	
	while (fread(entry, 1, 32, passfile))
	{
		
		strncpy (username, entry, 16);
		username[16]='\0';
		temp = strchr(username, '~');
		if (temp)
			*temp = '\0';
		
		strncpy (password, &entry[16], 16);
		password[16]='\0';
		temp = strchr(password, '~');
		if (temp)
			*temp = '\0';
		
		if (strcmp(usern, username) == 0 &&
			strcmp(pass, password) ==0 )
		{
			fclose(passfile);
			return 1;
		}
		
	}
	
	fclose(passfile);
	return -1;
	
}
 
 
#### sockwrap.c ###
 
#include <stdlib.h> // getenv()
 
#include <sys/types.h>
 
#include <sys/socket.h>
 
#include <sys/time.h> // timeval
 
#include <sys/select.h>
 
#include <netinet/in.h>
 
#include <arpa/inet.h> // inet_aton()
 
#include <netdb.h>
 
#include <errno.h>
 
#include <unistd.h>
 
 
 
#include "errlib.h"
 
#include "sockwrap.h"
 
 
 
#define INTERRUPTED_BY_SIGNAL (errno == EINTR || errno == ECHILD)
 
 
 
extern char *prog;
 
 
 
int Socket (int family, int type, int protocol)
 
{
 
  int n;
 
  if ( (n = socket(family,type,protocol)) < 0)
 
    err_sys ("(%s) error - socket() failed", prog);
 
  return n;
 
}
 
 
 
void Bind (int sockfd, const SA *myaddr,  socklen_t myaddrlen)
 
{
 
  if ( bind(sockfd, myaddr, myaddrlen) != 0)
 
    err_sys ("(%s) error - bind() failed", prog);
 
}
 
 
 
void Listen (int sockfd, int backlog)
 
{
 
  char *ptr;
 
  if ( (ptr = getenv("LISTENQ")) != NULL)
 
    backlog = atoi(ptr);
 
  if ( listen(sockfd,backlog) < 0 )
 
    err_sys ("(%s) error - listen() failed", prog);
 
}
 
 
 
 
 
int Accept (int listen_sockfd, SA *cliaddr, socklen_t *addrlenp)
 
{
 
  int n;
 
again:
 
  if ( (n = accept(listen_sockfd, cliaddr, addrlenp)) < 0)
 
  {
 
    if (INTERRUPTED_BY_SIGNAL)
 
      goto again;
 
    else
 
      err_sys ("(%s) error - accept() failed", prog);
 
  }
 
  return n;
 
}
 
 
 
 
 
void Connect (int sockfd, const SA *srvaddr, socklen_t addrlen)
 
{
 
  if ( connect(sockfd, srvaddr, addrlen) != 0)
 
    err_sys ("(%s) error - connect() failed", prog);
 
}
 
 
 
 
 
void Close (int fd)
 
{
 
  if (close(fd) != 0)
 
    err_sys ("(%s) error - close() failed", prog);
 
}
 
 
 
 
 
void Shutdown (int fd, int howto)
 
{
 
  if (shutdown(fd,howto) != 0)
 
    err_sys ("(%s) error - shutdown() failed", prog);
 
}
 
 
 
 
 
ssize_t Read (int fd, void *bufptr, size_t nbytes)
 
{
 
  ssize_t n;
 
again:
 
  if ( (n = read(fd,bufptr,nbytes)) < 0)
 
  {
 
    if (INTERRUPTED_BY_SIGNAL)
 
      goto again;
 
    else
 
      err_sys ("(%s) error - read() failed", prog);
 
  }
 
  return n;
 
}
 
 
 
 
 
void Write (int fd, void *bufptr, size_t nbytes)
 
{
 
  if (write(fd,bufptr,nbytes) != nbytes)
 
    err_sys ("(%s) error - write() failed", prog);
 
}
 
 
 
 
 
ssize_t Recvfrom (int fd, void *bufptr, size_t nbytes, int flags, SA *sa, socklen_t *salenptr)
 
{
 
  ssize_t n;
 
 
 
  if ( (n = recvfrom(fd,bufptr,nbytes,flags,sa,salenptr)) < 0)
 
    err_sys ("(%s) error - recvfrom() failed", prog);
 
  return n;
 
}
 
 
 
 
 
ssize_t Recvfrom_timeout (int fd, void *bufptr, size_t nbytes, int flags, SA *sa, socklen_t *salenptr, int timeout)
 
{
 
  ssize_t n;
 
again:
 
  if ( (n = recvfrom(fd,bufptr,nbytes,flags,sa,salenptr)) < 0)
 
  {
 
    if (INTERRUPTED_BY_SIGNAL)
 
    {
 
      if (errno==EINTR && timeout)
 
        return -1;
 
      else
 
        goto again;
 
    }
 
    else
 
      err_sys ("(%s) error - recvfrom() failed", prog);
 
  }
 
  return n;
 
}
 
 
 
 
 
void Sendto (int fd, void *bufptr, size_t nbytes, int flags, const SA *sa, socklen_t salen)
 
{
 
  if (sendto(fd,bufptr,nbytes,flags,sa,salen) != nbytes)
 
    err_sys ("(%s) error - sendto() failed", prog);
 
}
 
 
 
/*
 
 * deprecated and no more supported in recent systems
 
 *
 
 
 
void Inet_aton (const char *strptr, struct in_addr *addrptr)
 
{
 
  if (inet_aton(strptr, addrptr) == 0)
 
    err_quit ("(%s) error - inet_aton() failed for '%s'", prog, strptr);
 
}
 
 
 
*/
 
 
 
void Inet_pton (int af, const char *strptr, void *addrptr)
 
{
 
  int status = inet_pton(af, strptr, addrptr);
 
  if (status == 0)
 
    err_quit ("(%s) error - inet_pton() failed for '%s': invalid address", prog, strptr);
 
  if (status < 0)
 
    err_sys ("(%s) error - inet_pton() failed for '%s'", prog, strptr);
 
}
 
 
 
 
 
void Inet_ntop (int af, const void *addrptr, char *strptr, size_t length)
 
{
 
  if ( inet_ntop(af, addrptr, strptr, length) == NULL)
 
     err_quit ("(%s) error - inet_ntop() failed: invalid address", prog);
 
}
 
 
 
 
 
#ifndef MAXLINE
 
#define MAXLINE 1024
 
#endif
 
 
 
/* reads exactly "n" bytes from a descriptor */
 
 
 
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 (INTERRUPTED_BY_SIGNAL)
 
      {
 
        nread = 0;
 
        continue; /* and call read() again */
 
      }
 
      else
 
        return -1;
 
    }
 
    else
 
      if (nread == 0)
 
        break; /* EOF */
 
 
 
    nleft -= nread;
 
    ptr   += nread;
 
  }
 
  return n - nleft;
 
}
 
 
 
 
 
ssize_t Readn (int fd, void *ptr, size_t nbytes)
 
{
 
  ssize_t n;
 
 
 
  if ( (n = readn(fd, ptr, nbytes)) < 0)
 
    err_sys ("(%s) error - readn() failed", prog);
 
  return n;
 
}
 
 
 
 
 
/*
 
 
 
read a whole buffer, for performance, and then return one char at a time
 
 
 
*/
 
static ssize_t my_read (int fd, char *ptr)
 
{
 
  static int read_cnt = 0;
 
  static char *read_ptr;
 
  static char read_buf[MAXLINE];
 
 
 
  if (read_cnt <= 0)
 
  {
 
again:
 
    if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0)
 
    {
 
      if (INTERRUPTED_BY_SIGNAL)
 
      	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)
 
{
 
  int 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)
 
    {
 
      if (n == 1)
 
      	return 0; /* EOF, no data read */
 
      else
 
      	break; /* EOF, some data was read */
 
    }
 
    else
 
      return -1; /* error, errno set by read() */
 
  }
 
  *ptr = 0; /* null terminate like fgets() */
 
  return n;
 
}
 
 
 
 
 
ssize_t Readline (int fd, void *ptr, size_t maxlen)
 
{
 
  ssize_t n;
 
 
 
  if ( (n = readline(fd, ptr, maxlen)) < 0)
 
    err_sys ("(%s) error - readline() failed", prog);
 
  return n;
 
}
 
 
 
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 (INTERRUPTED_BY_SIGNAL)
 
      {
 
      	nwritten = 0;
 
        continue; /* and call write() again */
 
      }
 
      else
 
      	return -1;
 
    }
 
    nleft -= nwritten;
 
    ptr   += nwritten;
 
  }
 
  return n;
 
}
 
 
 
 
 
void Writen (int fd, void *ptr, size_t nbytes)
 
{
 
  if (writen(fd, ptr, nbytes) != nbytes)
 
    err_sys ("(%s) error - writen() failed", prog);
 
}
 
 
 
 
 
int Select (int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, struct timeval *timeout)
 
{
 
  int n;
 
again:
 
  if ( (n = select (maxfdp1, readset, writeset, exceptset, timeout)) < 0)
 
  {
 
    if (INTERRUPTED_BY_SIGNAL)
 
      goto again;
 
    else
 
      err_sys ("(%s) error - select() failed", prog);
 
  }
 
  return n;
 
}
 
 
 
 
 
pid_t Fork (void)
 
{
 
  pid_t pid;
 
  if ((pid=fork()) < 0)
 
    err_sys ("(%s) error - fork() failed", prog);
 
  return pid;
 
}
 
 
 
#ifdef SOLARIS
 
const char * hstrerror (int err)
 
{
 
   if (err == NETDB_INTERNAL)
 
      return "internal error - see errno";
 
   if (err == NETDB_SUCCESS)
 
      return "no error";
 
   if (err == HOST_NOT_FOUND)
 
      return "unknown host";
 
   if (err == TRY_AGAIN)
 
      return "hostname lookup failure";
 
   if (err == NO_RECOVERY)
 
      return "unknown server error";
 
   if (err == NO_DATA)
 
      return "no address associated with name";
 
   return "unknown error";
 
}
 
#endif
 
 
 
struct hostent *Gethostbyname (const char *hostname)
 
{
 
  struct hostent *hp;
 
  if ((hp = gethostbyname(hostname)) == NULL)
 
    err_quit ("(%s) error - gethostbyname() failed for '%s': %s",
 
      prog, hostname, hstrerror(h_errno));
 
  return hp;
 
}
 
 
 
void Getsockname (int sockfd, struct sockaddr *localaddr, socklen_t *addrp)
 
{
 
  if ((getsockname(sockfd, localaddr, addrp)) != 0)
 
    err_quit ("(%s) error - getsockname() failed", prog);
 
}
 
######
 
errlib.c
 
/*
 
module: errlib.c
 
purpose: library of error functions
 
reference: Stevens, Unix network programming (2ed), p.922
 
*/
 
#include <stdio.h>
#include <stdlib.h> /* exit() */
#include <stdarg.h>
#include <syslog.h>
#include <string.h>
#include <errno.h>
 
#define MAXLINE 4095
 
int daemon_proc = 0; /* set to 0 if stdout/stderr available, else set to 1 */
 
static void err_doit (int errnoflag, int level, const char *fmt, va_list ap)
{
  int errno_save = errno;
  size_t n;
  char buf[MAXLINE+1];
 
  vsnprintf (buf, MAXLINE, fmt, ap);
  n = strlen(buf);
  if (errnoflag)
    snprintf (buf+n, MAXLINE-n, ": %s", strerror(errno_save));
  strcat (buf, "\n");
 
  if (daemon_proc)
    syslog (level, buf);
  else
  {
    fflush (stdout);
    fputs (buf, stderr);
    fflush (stderr);
  }
}
 
void err_ret (const char *fmt, ...)
{
  va_list ap;
 
  va_start (ap, fmt);
  err_doit (1, LOG_INFO, fmt, ap);
  va_end (ap);
  return;
}
 
void err_sys (const char *fmt, ...)
{
  va_list ap;
 
  va_start (ap, fmt);
  err_doit (1, LOG_ERR, fmt, ap);
  va_end (ap);
  exit (1);
}
 
void err_msg (const char *fmt, ...)
{
  va_list ap;
 
  va_start (ap, fmt);
  err_doit (0, LOG_INFO, fmt, ap);
  va_end (ap);
  return;
}
 
void err_quit (const char *fmt, ...)
{
  va_list ap;
 
  va_start (ap, fmt);
  err_doit (0, LOG_ERR, fmt, ap);
  va_end (ap);
  exit (1);
}
 
#####