csapp.c

ICS 课程的Lab8

    if ((rc = pthread_detach(tid)) != 0)
	posix_error(rc, "Pthread_detach error");
}
/* $end detach */

void Pthread_exit(void *retval) {
    pthread_exit(retval);
}

pthread_t Pthread_self(void) {
    return pthread_self();
}
 
void Pthread_once(pthread_once_t *once_control, void (*init_function)()) {
    pthread_once(once_control, init_function);
}


/*************************************************************
 * Wrappers for Pthreads mutex and condition variable functions
 ************************************************************/

void Pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr) 
{
    int rc;

    if ((rc = pthread_mutex_init(mutex, attr)) != 0)
	posix_error(rc, "Pthread_mutex_init error");
}

/* $begin lock */
void Pthread_mutex_lock(pthread_mutex_t *mutex) 
{
    int rc;

    if ((rc = pthread_mutex_lock(mutex)) != 0)
	posix_error(rc, "Pthread_mutex_lock error");
}
/* $end lock */

void Pthread_mutex_unlock(pthread_mutex_t *mutex) 
{
    int rc;

    if ((rc = pthread_mutex_unlock(mutex)) != 0)
	posix_error(rc, "Pthread_mutex_unlock error");
}

void Pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr) 
{
    int rc;

    if ((rc = pthread_cond_init(cond, attr)) != 0)
	posix_error(rc, "Pthread_cond_init error");
}

void Pthread_cond_signal(pthread_cond_t *cond) 
{
    int rc;

    if ((rc = pthread_cond_signal(cond)) != 0)
	posix_error(rc, "Pthread_cond_signal error");
}

void Pthread_cond_broadcast(pthread_cond_t *cond) 
{
    int rc;

    if ((rc = pthread_cond_broadcast(cond)) != 0)
	posix_error(rc, "Pthread_cond_broadcast error");
}

void Pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 
{
    int rc;

    if ((rc = pthread_cond_wait(cond, mutex)) != 0)
	posix_error(rc, "Pthread_cond_wait error");
}

/* $begin timedwait */
int Pthread_cond_timedwait(pthread_cond_t *cond, 
			   pthread_mutex_t *mutex,
			   struct timespec *abstime) 
{
    int rc = pthread_cond_timedwait(cond, mutex, abstime);

    if ((rc != 0) && (rc != ETIMEDOUT))  
	posix_error(rc, "Pthread_cond_timedwait error");
    return rc;
}  
/* $end timedwait */


/*******************************
 * Wrappers for Posix semaphores
 *******************************/

void Sem_init(sem_t *sem, int pshared, unsigned int value) 
{
    if (sem_init(sem, pshared, value) < 0)
	unix_error("Sem_init error");
}

void P(sem_t *sem) 
{
    if (sem_wait(sem) < 0)
	unix_error("P error");
}

void V(sem_t *sem) 
{
    if (sem_post(sem) < 0)
	unix_error("V error");
}

/*********************************************************************
 * The Rio package - robust I/O functions
 **********************************************************************/


/* wrapper for "plain" read function --
   does nothing more than check for EINTR */

ssize_t rio_readp(int fd, void *ptr, size_t nbytes)
{
  int n;
  while(1){
    if ((n = read(fd, ptr, nbytes)) < 0) {
      if (errno == EINTR) continue;
    }
    break;
  }
  return n;
}

/* wrapper for "plain" write function --
   does nothing more than check for EINTR */

ssize_t rio_writep(int fd, void *ptr, size_t nbytes)
{
  int n;
  while(1){
    if ((n = write(fd, ptr, nbytes)) < 0) {
      if (errno == EINTR) continue;
    }
    break;
  }
  return n;
}

/*
 * 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;

    n = 0;

    while (n < maxlen-1){
	if ((rc = rio_read(rp, &c, 1)) == 1) {
	  n++;
	  *bufp++ = c;
	  if (c == '\n')
	    break;
	} else if (rc == 0) {
	  break;    /* EOF */
	} else
	  return -1;	  /* error */
    }
    *bufp = 0;
    return n;
}
/* $end rio_readlineb */

/**********************************
 * Wrappers for robust I/O routines
 **********************************/

ssize_t Rio_readp(int fd, void *ptr, size_t nbytes) 
{
    ssize_t n;
  
    if ((n = rio_readp(fd, ptr, nbytes)) < 0) {
        if (errno != EPIPE)
	   unix_error("Rio_readp error");
	else {
//	   printf("Rio_readp: socket has closed with EPIPE\n");
	   return -1;
	}   
    }	   
	   
    return n;
}

void Rio_writep(int fd, void *usrbuf, size_t n) 
{
    if (rio_writep(fd, usrbuf, n) != n) {
        if (errno != EPIPE)
	   unix_error("Rio_writen error");
	else {
//	   printf("Rio_writen: socket has closed with EPIPE\n");
        }
    }	   
}

ssize_t Rio_readn(int fd, void *ptr, size_t nbytes) 
{
    ssize_t n;
  
    if ((n = rio_readn(fd, ptr, nbytes)) < 0) {
        if (errno != EPIPE)
	   unix_error("Rio_readn error");
	else {
//	   printf("Rio_readn: socket has closed with EPIPE\n");
	   return -1;
	}   
    }	   
	   
    return n;
}

void Rio_writen(int fd, void *usrbuf, size_t n) 
{
    if (rio_writen(fd, usrbuf, n) != n) {
        if (errno != EPIPE)
	   unix_error("Rio_writen error");
	else {
//	   printf("Rio_writen: socket has closed with EPIPE\n");
        }
    }	   
}

void Rio_readinitb(rio_t *rp, int fd)
{
    rio_readinitb(rp, fd);
} 

ssize_t Rio_readnb(rio_t *rp, void *usrbuf, size_t n) 
{
    ssize_t rc;

    if ((rc = rio_readnb(rp, usrbuf, n)) < 0)
	unix_error("Rio_readnb error");
    return rc;
}

ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 
{
    ssize_t rc;

    if ((rc = rio_readlineb(rp, usrbuf, maxlen)) < 0)
	unix_error("Rio_readlineb error");
    return rc;
} 

/******************************** 
 * Client/server helper functions
 ********************************/
/*
 * open_clientfd - 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_clientfd */
int open_clientfd(char *hostname, int port) 
{
    int clientfd;
    struct hostent *hp;
    struct sockaddr_in serveraddr;

    if ((clientfd = 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, 
	  (char *)&serveraddr.sin_addr.s_addr, hp->h_length);
    serveraddr.sin_port = htons(port);

    /* Establish a connection with the server */
    if (connect(clientfd, (SA *) &serveraddr, sizeof(serveraddr)) < 0)
	return -1;
    return clientfd;
}
/* $end open_clientfd */

/*  
 * open_listenfd - open and return a listening socket on port
 *     Returns -1 and sets errno on Unix error.
 */
/* $begin open_listenfd */
int open_listenfd(int port) 
{
    int listenfd, optval=1;
    struct sockaddr_in serveraddr;
  
    /* Create a socket descriptor */
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	return -1;
 
    /* Eliminates "Address already in use" error from bind. */
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, 
		   (const void *)&optval , sizeof(int)) < 0)
	return -1;

    /* Listenfd 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(listenfd, (SA *)&serveraddr, sizeof(serveraddr)) < 0)
	return -1;

    /* Make it a listening socket ready to accept connection requests */
    if (listen(listenfd, LISTENQ) < 0)
	return -1;
    return listenfd;
}
/* $end open_listenfd */

/******************************************
 * Wrappers for the client/server helper routines 
 ******************************************/
int Open_clientfd(char *hostname, int port) 
{
    int rc;

    if ((rc = open_clientfd(hostname, port)) < 0) {
	if (rc == -1)
	    unix_error("Open_clientfd Unix error");
	else        
	    dns_error("Open_clientfd DNS error");
    }
    return rc;
}

int Open_listenfd(int port) 
{
    int rc;

    if ((rc = open_listenfd(port)) < 0)
	unix_error("Open_listenfd error");
    return rc;
}
/* $end csapp.c */