/* include udp_connect */intudp_connect(const char *host, const char *serv){	int				sockfd, n;	struct addrinfo	hints, *res, *ressave;	bzero(&hints, sizeof(struct addrinfo));	hints.ai_family = AF_UNSPEC;	hints.ai_socktype = SOCK_DGRAM;	if ( (n = getaddrinfo(host, serv, &hints, &res)) != 0)		err_quit("udp_connect error for %s, %s",				 host, serv);	ressave = res;	do {		sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);		if (sockfd < 0)			continue;	/* ignore this one */		if (connect(sockfd, res->ai_addr, res->ai_addrlen) == 0)			break;		/* success */		Close(sockfd);	/* ignore this one */	} while ( (res = res->ai_next) != NULL);	if (res == NULL)	/* errno set from final connect() */		err_sys("udp_connect error for %s, %s", host, serv);	freeaddrinfo(ressave);	return(sockfd);}/* end udp_connect */intUdp_connect(const char *host, const char *serv){	int		n;	if ( (n = udp_connect(host, serv)) < 0) {		err_quit("udp_connect error for %s, %s",					 host, serv);	}	return(n);}/* include udp_server */intudp_server(const char *host, const char *serv, socklen_t *addrlenp){	int				sockfd, n;	struct addrinfo	hints, *res, *ressave;	bzero(&hints, sizeof(struct addrinfo));	hints.ai_flags = AI_PASSIVE;	hints.ai_family = AF_UNSPEC;	hints.ai_socktype = SOCK_DGRAM;	if ( (n = getaddrinfo(host, serv, &hints, &res)) != 0)		err_quit("udp_server error for %s, %s",				 host, serv);	ressave = res;	do {		sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);		if (sockfd < 0)			continue;		/* error, try next one */		if (bind(sockfd, res->ai_addr, res->ai_addrlen) == 0)			break;			/* success */		Close(sockfd);		/* bind error, close and try next one */	} while ( (res = res->ai_next) != NULL);	if (res == NULL)	/* errno from final socket() or bind() */		err_sys("udp_server error for %s, %s", host, serv);	if (addrlenp)		*addrlenp = res->ai_addrlen;	/* return size of protocol address */	freeaddrinfo(ressave);	return(sockfd);}/* end udp_server */intUdp_server(const char *host, const char *serv, socklen_t *addrlenp){	return(udp_server(host, serv, addrlenp));}/* Errors Function */ #include	<stdarg.h>		/* ANSI C header file */#include	<syslog.h>		/* for syslog() */int		daemon_proc;		/* set nonzero by daemon_init() */static void	err_doit(int, int, const char *, va_list);/* Nonfatal error related to a system call. * Print a message and return. */voiderr_ret(const char *fmt, ...){	va_list		ap;	va_start(ap, fmt);	err_doit(1, LOG_INFO, fmt, ap);	va_end(ap);	return;}/* Fatal error related to a system call. * Print a message and terminate. */voiderr_sys(const char *fmt, ...){	va_list		ap;	va_start(ap, fmt);	err_doit(1, LOG_ERR, fmt, ap);	va_end(ap);	exit(1);}/* Fatal error related to a system call. * Print a message, dump core, and terminate. */voiderr_dump(const char *fmt, ...){	va_list		ap;	va_start(ap, fmt);	err_doit(1, LOG_ERR, fmt, ap);	va_end(ap);	abort();		/* dump core and terminate */	exit(1);		/* shouldn't get here */}/* Nonfatal error unrelated to a system call. * Print a message and return. */voiderr_msg(const char *fmt, ...){	va_list		ap;	va_start(ap, fmt);	err_doit(0, LOG_INFO, fmt, ap);	va_end(ap);	return;}/* Fatal error unrelated to a system call. * Print a message and terminate. */voiderr_quit(const char *fmt, ...){	va_list		ap;	va_start(ap, fmt);	err_doit(0, LOG_ERR, fmt, ap);	va_end(ap);	exit(1);}/* Print a message and return to caller. * Caller specifies "errnoflag" and "level". */static voiderr_doit(int errnoflag, int level, const char *fmt, va_list ap){	int		errno_save, n;	char	buf[MAXLINE];	errno_save = errno;		/* value caller might want printed */#ifdef	HAVE_VSNPRINTF	vsnprintf(buf, sizeof(buf), fmt, ap);	/* this is safe */#else	vsprintf(buf, fmt, ap);					/* this is not safe */#endif	n = strlen(buf);	if (errnoflag)		snprintf(buf+n, sizeof(buf)-n, ": %s", strerror(errno_save));	strcat(buf, "\n");	if (daemon_proc) {		syslog(level, buf);	} else {		fflush(stdout);		/* in case stdout and stderr are the same */		fputs(buf, stderr);		fflush(stderr);	}	return;}/* include signal */Sigfunc *signal(int signo, Sigfunc *func){	struct sigaction	act, oact;	act.sa_handler = func;	sigemptyset(&act.sa_mask);	act.sa_flags = 0;	if (signo == SIGALRM) {#ifdef	SA_INTERRUPT		act.sa_flags |= SA_INTERRUPT;	/* SunOS 4.x */#endif	} else {#ifdef	SA_RESTART		act.sa_flags |= SA_RESTART;		/* SVR4, 44BSD */#endif	}	if (sigaction(signo, &act, &oact) < 0)		return(SIG_ERR);	return(oact.sa_handler);}/* end signal */Sigfunc *Signal(int signo, Sigfunc *func)	/* for our signal() function */{	Sigfunc	*sigfunc;	if ( (sigfunc = signal(signo, func)) == SIG_ERR)		err_sys("signal error");	return(sigfunc);}/* * Throughout the book I use snprintf() because it's safer than sprintf(). * But as of the time of this writing, not all systems provide this * function.  The function below should only be built on those systems * that do not provide a real snprintf(). * The function below just acts like sprintf(); it is not safe, but it * tries to detect overflow. */#include	<stdarg.h>		/* ANSI C header file */intsnprintf(char *buf, size_t size, const char *fmt, ...){	int			n;	va_list		ap;	va_start(ap, fmt);	vsprintf(buf, fmt, ap);	/* Sigh, some vsprintf's return ptr, not length */	n = strlen(buf);	va_end(ap);	if (n >= size)		err_quit("snprintf: '%s' overflowed array", fmt);	return(n);}/* start daemon */#include	<syslog.h>#define	MAXFD	64extern int	daemon_proc;	/* defined in error.c */voiddaemon_init(const char *pname, int facility){	int		i;	pid_t	pid;	if ( (pid = Fork()) != 0)		exit(0);			/* parent terminates */	/* 41st child continues */	setsid();				/* become session leader */	Signal(SIGHUP, SIG_IGN);	if ( (pid = Fork()) != 0)		exit(0);			/* 1st child terminates */	/* 42nd child continues */	daemon_proc = 1;		/* for our err_XXX() functions */	chdir("/");				/* change working directory */	umask(0);				/* clear our file mode creation mask */	for (i = 0; i < MAXFD; i++)		close(i);	openlog(pname, LOG_PID, facility);}/* include signal_intr */Sigfunc *signal_intr(int signo, Sigfunc *func){	struct sigaction	act, oact;	act.sa_handler = func;	sigemptyset(&act.sa_mask);	act.sa_flags = 0;#ifdef	SA_INTERRUPT	/* SunOS */	act.sa_flags |= SA_INTERRUPT;#endif	if (sigaction(signo, &act, &oact) < 0)		return(SIG_ERR);	return(oact.sa_handler);}/* end signal_intr */Sigfunc *Signal_intr(int signo, Sigfunc *func){	Sigfunc	*sigfunc;	if ( (sigfunc = signal_intr(signo, func)) == SIG_ERR)		err_sys("signal_intr error");	return(sigfunc);}/* include readline */static ssize_tmy_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 (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_treadline(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);}/* end readline */ssize_tReadline(int fd, void *ptr, size_t maxlen){	ssize_t		n;	if ( (n = readline(fd, ptr, maxlen)) < 0)		err_sys("readline error");	return(n);}/* include readn */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_tReadn(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 */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 */voidWriten(int fd, void *ptr, size_t nbytes){	if (writen(fd, ptr, nbytes) != nbytes)		err_sys("writen error");}unsigned long Getaddr(char *name){	struct hostent *host_event_point;	host_event_point = gethostbyname(name);	if(!host_event_point) {		fprintf(stderr, "Unknown host %s\n", name);		return -1;	}	return *(unsigned long *)host_event_point->h_addr;}#endif