2
This commit is contained in:
243
server-exp2/common.c
Normal file
243
server-exp2/common.c
Normal file
@@ -0,0 +1,243 @@
|
||||
/* $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 */
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user