home *** CD-ROM | disk | FTP | other *** search
/ ftp.muug.mb.ca / 2014.06.ftp.muug.mb.ca.tar / ftp.muug.mb.ca / pub / src / gopher / gopher1.01 / misc / Radio / radiod / util.c < prev   
C/C++ Source or Header  |  1991-08-13  |  4KB  |  200 lines
  1. /*
  2.  *******************************************************************
  3.  * $Author: $
  4.  * $Revision: $
  5.  * $Date: $
  6.  * $Source: $
  7.  *******************************************************************
  8.  */
  9.  
  10.  
  11. /*
  12.  * Read "n" bytes from a descriptor.
  13.  * Use in place of read() when fd is a stream socket
  14.  *
  15.  * Returns the number of total bytes read.
  16.  */
  17.  
  18. int
  19. readn(fd, ptr, nbytes)
  20. int fd;
  21. char *ptr;
  22. int nbytes;
  23. {
  24.     int nleft, nread;
  25.  
  26.     nleft = nbytes;
  27.     while (nleft > 0) {
  28.         nread = read(fd, ptr, nleft);
  29.         if (nread < 0)
  30.             return(nread);    /* error, return <0 */
  31.         else if (nread == 0)    /* EOF */
  32.             break;
  33.     
  34.         nleft     -= nread;
  35.         ptr     += nread;
  36.     }
  37.     return(nbytes - nleft);    /* return >= 0) */
  38. }
  39.  
  40.  
  41.  
  42. /*
  43.  * Write "n" bytes to a descriptor.
  44.  * Use in place of write() when fd is a stream socket
  45.  *
  46.  * We return the number of bytes written
  47.  */
  48.  
  49. int
  50. writen(fd, ptr, nbytes)
  51. int    fd;
  52. char    *ptr;
  53. int    nbytes;
  54. {
  55.     int nleft, nwritten;
  56.  
  57.     nleft = nbytes;
  58.     while(nleft > 0) {
  59.         nwritten = write(fd, ptr, nleft);
  60.         if (nwritten <= 0)
  61.             return(nwritten);    /* error */
  62.  
  63.         nleft    -= nwritten;
  64.         ptr    += nwritten;
  65.     }
  66.     return(nbytes - nleft);
  67. }
  68.  
  69.  
  70. /*
  71.  * Writestring uses the writen and strlen calls to write a
  72.  * string to the file descriptor fd.  If the write fails
  73.  * a -1 is returned. Otherwise zero is returned.
  74.  */
  75.  
  76. int
  77. writestring(fd, stringptr)
  78. int    fd;
  79. char    *stringptr;
  80. {
  81.     int length;
  82.  
  83.     length = strlen(stringptr);
  84.     if (writen(fd, stringptr, length) != length)
  85.         return(-1);
  86.     else
  87.         return(0);
  88. }
  89.  
  90.  
  91. /*
  92.  * Read a line from a descriptor.  Read the line one byte at a time,
  93.  * looking for the newline.  We store the newline in the buffer,
  94.  * then follow it with a null (the same as fgets(3)).
  95.  * We return the number of characters up to, but not including,
  96.  * the null (the same as strlen(3))
  97.  */
  98.  
  99. int
  100. readline(fd, ptr, maxlen)
  101. int    fd;
  102. char    *ptr;
  103. int     maxlen;
  104. {
  105.     int n;
  106.     int rc;
  107.     char c;
  108.  
  109.     for (n=1; n < maxlen; n++) {
  110.         if ( (rc = read(fd, &c, 1)) == 1) {
  111.             *ptr++ = c;
  112.             if (c == '\n')
  113.                 break;
  114.         }
  115.         else if (rc == 0) {
  116.             if (n == 1)
  117.                 return(0);    /* EOF, no data read */
  118.             else
  119.                 break;        /* EOF, some data was read */
  120.         }
  121.         else
  122.             return(-1);        /* error */
  123.     }
  124.  
  125.     *ptr = 0;                 /* Tack a NULL on the end */
  126.     return(n);
  127. }
  128.  
  129.  
  130. /*
  131.  * Read a stream socket one line at a time, and write each
  132.  * line back to the sender
  133.  *
  134.  * Return when the connection is terminated
  135.  */
  136.  
  137. #define MAXLINE 512
  138.  
  139. void
  140. str_echo(sockfd)
  141. int sockfd;
  142. {
  143.     int n;
  144.     char line[MAXLINE];
  145.  
  146.     for ( ; ; ){
  147.         n = readline(sockfd, line, MAXLINE);
  148.         if (n == 0)
  149.             return;
  150.         else if (n < 0)
  151.             err_dump("str_echo: readline error");
  152.  
  153.         if (writen(sockfd, line, n) != n)
  154.             err_dump("str_echo: writen error");
  155.     }
  156. }
  157.  
  158.  
  159.  
  160. /*
  161.  * Read the contents of the FILE *fp, write each line to the
  162.  * stream socket (to the server process), then read a line back from
  163.  * the socket and write it to the standard output.
  164.  *
  165.  * Return to the caller when an EOF is encountered on the input file.
  166.  */
  167.  
  168. #include <stdio.h>
  169. #define     MAXLINE 512
  170.  
  171. void
  172. str_cli(fp, sockfd)
  173. FILE *fp;
  174. int sockfd;
  175. {
  176.     int n;
  177.     char sendline[MAXLINE];
  178.     char recline[MAXLINE+1];
  179.  
  180.     while (fgets(sendline, MAXLINE, fp) != NULL) {
  181.         n = strlen(sendline);
  182.         if (writen(sockfd, sendline, n) != n)
  183.             err_sys("str_cli: writen error on socket");
  184.     
  185.         /*
  186.          * Now read a line from the socket and write it to
  187.          * our standard output
  188.          */
  189.  
  190.         n = readline(sockfd, recline, MAXLINE);
  191.         if (n<0)
  192.             err_dump("str_cli: readline error");
  193.         recline[n]=0;
  194.         fputs(recline, stdout);
  195.     }
  196.  
  197.     if (ferror(fp))
  198.         err_sys("str_cli: error reading file");
  199. }
  200.