243 lines
6.2 KiB
C
243 lines
6.2 KiB
C
/* $begin common.c */
|
|
|
|
#include "common.h"
|
|
|
|
|
|
/*********************************************************************
|
|
* The Rio package - robust I/O functions
|
|
**********************************************************************/
|
|
/*
|
|
* rio_readn - robustly read n bytes (unbuffered)
|
|
*/
|
|
/* $begin rio_readn */
|
|
ssize_t rio_readn(int fd, void *usrbuf, size_t n)
|
|
{
|
|
size_t nleft = n;
|
|
ssize_t nread;
|
|
char *bufp = usrbuf;
|
|
|
|
while (nleft > 0) {
|
|
if ((nread = read(fd, bufp, nleft)) < 0) {
|
|
if (errno == EINTR) /* interrupted by sig handler return */
|
|
nread = 0; /* and call read() again */
|
|
else
|
|
return -1; /* errno set by read() */
|
|
}
|
|
else if (nread == 0)
|
|
break; /* EOF */
|
|
nleft -= nread;
|
|
bufp += nread;
|
|
}
|
|
return (n - nleft); /* return >= 0 */
|
|
}
|
|
/* $end rio_readn */
|
|
|
|
/*
|
|
* rio_writen - robustly write n bytes (unbuffered)
|
|
*/
|
|
/* $begin rio_writen */
|
|
ssize_t rio_writen(int fd, void *usrbuf, size_t n)
|
|
{
|
|
size_t nleft = n;
|
|
ssize_t nwritten;
|
|
char *bufp = usrbuf;
|
|
|
|
while (nleft > 0) {
|
|
if ((nwritten = write(fd, bufp, nleft)) <= 0) {
|
|
if (errno == EINTR) /* interrupted by sig handler return */
|
|
nwritten = 0; /* and call write() again */
|
|
else
|
|
return -1; /* errorno set by write() */
|
|
}
|
|
nleft -= nwritten;
|
|
bufp += nwritten;
|
|
}
|
|
return n;
|
|
}
|
|
/* $end rio_writen */
|
|
|
|
|
|
/*
|
|
* rio_read - This is a wrapper for the Unix read() function that
|
|
* transfers min(n, rio_cnt) bytes from an internal buffer to a user
|
|
* buffer, where n is the number of bytes requested by the user and
|
|
* rio_cnt is the number of unread bytes in the internal buffer. On
|
|
* entry, rio_read() refills the internal buffer via a call to
|
|
* read() if the internal buffer is empty.
|
|
*/
|
|
/* $begin rio_read */
|
|
static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
|
|
{
|
|
int cnt;
|
|
|
|
while (rp->rio_cnt <= 0) { /* refill if buf is empty */
|
|
rp->rio_cnt = read(rp->rio_fd, rp->rio_buf,
|
|
sizeof(rp->rio_buf));
|
|
if (rp->rio_cnt < 0) {
|
|
if (errno != EINTR) /* interrupted by sig handler return */
|
|
return -1;
|
|
}
|
|
else if (rp->rio_cnt == 0) /* EOF */
|
|
return 0;
|
|
else
|
|
rp->rio_bufptr = rp->rio_buf; /* reset buffer ptr */
|
|
}
|
|
|
|
/* Copy min(n, rp->rio_cnt) bytes from internal buf to user buf */
|
|
cnt = n;
|
|
if (rp->rio_cnt < n)
|
|
cnt = rp->rio_cnt;
|
|
memcpy(usrbuf, rp->rio_bufptr, cnt);
|
|
rp->rio_bufptr += cnt;
|
|
rp->rio_cnt -= cnt;
|
|
return cnt;
|
|
}
|
|
/* $end rio_read */
|
|
|
|
/*
|
|
* rio_readinitb - Associate a descriptor with a read buffer and reset buffer
|
|
*/
|
|
/* $begin rio_readinitb */
|
|
void rio_readinitb(rio_t *rp, int fd)
|
|
{
|
|
rp->rio_fd = fd;
|
|
rp->rio_cnt = 0;
|
|
rp->rio_bufptr = rp->rio_buf;
|
|
}
|
|
/* $end rio_readinitb */
|
|
|
|
/*
|
|
* rio_readnb - Robustly read n bytes (buffered)
|
|
*/
|
|
/* $begin rio_readnb */
|
|
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n)
|
|
{
|
|
size_t nleft = n;
|
|
ssize_t nread;
|
|
char *bufp = usrbuf;
|
|
|
|
while (nleft > 0) {
|
|
if ((nread = rio_read(rp, bufp, nleft)) < 0) {
|
|
if (errno == EINTR) /* interrupted by sig handler return */
|
|
nread = 0; /* call read() again */
|
|
else
|
|
return -1; /* errno set by read() */
|
|
}
|
|
else if (nread == 0)
|
|
break; /* EOF */
|
|
nleft -= nread;
|
|
bufp += nread;
|
|
}
|
|
return (n - nleft); /* return >= 0 */
|
|
}
|
|
/* $end rio_readnb */
|
|
|
|
/*
|
|
* rio_readlineb - robustly read a text line (buffered)
|
|
*/
|
|
/* $begin rio_readlineb */
|
|
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
|
|
{
|
|
int n, rc;
|
|
char c, *bufp = usrbuf;
|
|
|
|
for (n = 1; n < maxlen; n++) {
|
|
if ((rc = rio_read(rp, &c, 1)) == 1) {
|
|
*bufp++ = c;
|
|
if (c == '\n')
|
|
break;
|
|
} else if (rc == 0) {
|
|
if (n == 1)
|
|
return 0; /* EOF, no data read */
|
|
else
|
|
break; /* EOF, some data was read */
|
|
} else
|
|
return -1; /* error */
|
|
}
|
|
*bufp = 0;
|
|
return n;
|
|
}
|
|
/* $end rio_readlineb */
|
|
|
|
/**********************************
|
|
* Wrappers for robust I/O routines
|
|
**********************************/
|
|
|
|
|
|
/********************************
|
|
* Client/server helper functions
|
|
********************************/
|
|
/*
|
|
* open_client_sock - open connection to server at <hostname, port>
|
|
* and return a socket descriptor ready for reading and writing.
|
|
* Returns -1 and sets errno on Unix error.
|
|
* Returns -2 and sets h_errno on DNS (gethostbyname) error.
|
|
*/
|
|
/* $begin open_client_sock */
|
|
int open_client_sock(char *hostname, int port)
|
|
{
|
|
int client_sock;
|
|
struct hostent *hp;
|
|
struct sockaddr_in serveraddr;
|
|
|
|
if ((client_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
|
return -1; /* check errno for cause of error */
|
|
|
|
/* Fill in the server's IP address and port */
|
|
if ((hp = gethostbyname(hostname)) == NULL)
|
|
return -2; /* check h_errno for cause of error */
|
|
bzero((char *) &serveraddr, sizeof(serveraddr));
|
|
serveraddr.sin_family = AF_INET;
|
|
bcopy((char *)hp->h_addr_list[0],
|
|
(char *)&serveraddr.sin_addr.s_addr, hp->h_length);
|
|
serveraddr.sin_port = htons(port);
|
|
|
|
/* Establish a connection with the server */
|
|
if (connect(client_sock, (SA *) &serveraddr, sizeof(serveraddr)) < 0)
|
|
return -1;
|
|
return client_sock;
|
|
}
|
|
/* $end open_client_sock */
|
|
|
|
/*
|
|
* open_listen_sock - open and return a listening socket on port
|
|
* Returns -1 and sets errno on Unix error.
|
|
*/
|
|
/* $begin open_listen_sock */
|
|
int open_listen_sock(int port)
|
|
{
|
|
int listen_sock, optval=1;
|
|
struct sockaddr_in serveraddr;
|
|
|
|
/* Create a socket descriptor */
|
|
if ((listen_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
|
return -1;
|
|
|
|
/* Eliminates "Address already in use" error from bind. */
|
|
if (setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR,
|
|
(const void *)&optval , sizeof(int)) < 0)
|
|
return -1;
|
|
|
|
/* Listen_sock will be an endpoint for all requests to port
|
|
on any IP address for this host */
|
|
bzero((char *) &serveraddr, sizeof(serveraddr));
|
|
serveraddr.sin_family = AF_INET;
|
|
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
serveraddr.sin_port = htons((unsigned short)port);
|
|
if (bind(listen_sock, (SA *)&serveraddr, sizeof(serveraddr)) < 0)
|
|
return -1;
|
|
|
|
/* Make it a listening socket ready to accept connection requests */
|
|
if (listen(listen_sock, LISTENQ) < 0)
|
|
return -1;
|
|
return listen_sock;
|
|
}
|
|
/* $end open_listen_sock */
|
|
|
|
|
|
/* $end wrapper.c */
|
|
|
|
|
|
|
|
|