home *** CD-ROM | disk | FTP | other *** search
/ ftp.ncftp.com / ftp.ncftp.com.zip / ftp.ncftp.com / libncftp / older_versions / libncftp-3.1.5-src.tar.gz / libncftp-3.1.5-src.tar / libncftp-3.1.5 / sio / SReadline.c < prev    next >
C/C++ Source or Header  |  2001-11-19  |  3KB  |  161 lines
  1. #include "syshdrs.h"
  2. #ifdef PRAGMA_HDRSTOP
  3. #    pragma hdrstop
  4. #endif
  5.  
  6. void
  7. FlushSReadlineInfo(SReadlineInfo *srl)
  8. {
  9.     /* Discards any input left in the current buffer,
  10.      * and resets the buffer and its pointer.
  11.      */
  12.     srl->bufSize = srl->bufSizeMax;
  13.     memset(srl->buf, 0, srl->bufSize);
  14.     srl->bufLim = srl->buf + srl->bufSizeMax;
  15.  
  16.     /* This line sets the buffer pointer
  17.      * so that the first thing to do is reset and fill the buffer
  18.      * using real I/O.
  19.      */
  20.     srl->bufPtr = srl->bufLim;
  21. }    /* FlushSReadlineInfo */
  22.  
  23.  
  24.  
  25.  
  26. int
  27. InitSReadlineInfo(SReadlineInfo *srl, int fd, char *buf, size_t bsize, int tlen, int requireEOLN)
  28. {
  29.     if (buf == NULL) {
  30.         if (bsize < 512)
  31.             bsize = 512;    /* Pointless, otherwise. */
  32.         buf = (char *) malloc(bsize);
  33.         if (buf == NULL)
  34.             return (-1);
  35.         srl->malloc = 1;
  36.     } else {
  37.         srl->malloc = 0;
  38.     }
  39.     memset(buf, 0, bsize);
  40.     srl->buf = buf;
  41.     srl->bufSize = bsize;
  42.     srl->bufSizeMax = bsize;
  43.     srl->bufLim = srl->buf + bsize;
  44.     srl->fd = fd;
  45.     srl->timeoutLen = tlen;
  46.     srl->requireEOLN = requireEOLN;
  47.  
  48.     /* This line sets the buffer pointer
  49.      * so that the first thing to do is reset and fill the buffer
  50.      * using real I/O.
  51.      */
  52.     srl->bufPtr = srl->bufLim;
  53.     return (0);
  54. }    /* InitSReadlineInfo */
  55.  
  56.  
  57.  
  58.  
  59. void
  60. DisposeSReadlineInfo(SReadlineInfo *srl)
  61. {
  62.     memset(srl->buf, 0, srl->bufSizeMax);
  63.     if (srl->malloc != 0)
  64.         free(srl->buf);
  65.     memset(srl, 0, sizeof(SReadlineInfo));
  66.  
  67.     /* Note: it does not close(srl->fd). */
  68. }    /* DisposeSReadlineInfo */
  69.  
  70.  
  71.  
  72.  
  73. /* Returns the number of bytes read, including the newline which is
  74.  * also appended to the buffer.  If you don't want that newline,
  75.  * set buf[nread - 1] = '\0', if nread > 0.
  76.  */
  77.  
  78. int 
  79. SReadline(SReadlineInfo *srl, char *const linebuf, size_t linebufsize)
  80. {
  81.     int err;
  82.     char *src;
  83.     char *dst;
  84.     char *dstlim;
  85.     int len;
  86.     int nr;
  87.     int requireEOLN;
  88.     int illegals;
  89.  
  90.     illegals = 0;
  91.     err = 0;
  92.     dst = linebuf;
  93.     dstlim = dst + linebufsize - 1;               /* Leave room for NUL. */
  94.     src = srl->bufPtr;
  95.     requireEOLN = srl->requireEOLN;
  96.     if (requireEOLN)
  97.         dstlim--;
  98.     if (dstlim <= dst)
  99.         return (-1);                /* Buffer too small. */
  100.  
  101.     forever {
  102.         if ((requireEOLN == 0) && (dst >= dstlim))
  103.             break;
  104.         if (src >= srl->bufLim) {
  105.             /* Fill the buffer. */
  106.             if (illegals > 1) {
  107.                 /* Probable DOS -- return now and give you an
  108.                  * opportunity to handle bogus input.
  109.                  */
  110.                 goto done;
  111.             }
  112.             nr = SRead(srl->fd, srl->buf, srl->bufSizeMax, srl->timeoutLen, 0);
  113.             if (nr == 0) {
  114.                 /* EOF. */
  115.                 goto done;
  116.             } else if (nr < 0) {
  117.                 /* Error. */
  118.                 err = nr;
  119.                 goto done;
  120.             }
  121.             srl->bufPtr = src = srl->buf;
  122.             srl->bufLim = srl->buf + nr;
  123.         }
  124.         if (*src == '\0') {
  125.             ++src;
  126.             illegals++;
  127.         } else if (*src == '\r') {
  128.             ++src;
  129.             /* If the next character is a \n that is valid,
  130.              * otherwise treat a stray \r as an illegal character.
  131.              */
  132.             if ((src < srl->bufLim) && (*src != '\n'))
  133.                 illegals++;
  134.         } else {
  135.             if (*src == '\n') {
  136.                 if (dst < dstlim)
  137.                     *dst++ = *src++;
  138.                 else
  139.                     src++;
  140.                 goto done;
  141.             }
  142.             if (dst < dstlim)
  143.                 *dst++ = *src++;
  144.             else
  145.                 src++;
  146.         }
  147.     }
  148.  
  149. done:
  150.     srl->bufPtr = src;
  151.     if ((requireEOLN != 0) && (dst != linebuf) && (dst[-1] != '\n'))
  152.         *dst++ = '\n';
  153.     if ((requireEOLN != 0) && (dst == linebuf) && (illegals > 0))
  154.         *dst++ = '\n';
  155.     *dst = '\0';
  156.     len = (int) (dst - linebuf);
  157.     if (err < 0)
  158.         return (err);
  159.     return (len);
  160. }                               /* SReadline */
  161.