httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Dean Gaudet <dgau...@hyperreal.org>
Subject cvs commit: apachen/src/main buff.c buff.h
Date Sun, 14 Sep 1997 11:13:55 GMT
dgaudet     97/09/14 04:13:54

  Modified:    src      INDENT
               src/main buff.c buff.h
  Log:
  indent
  
  Revision  Changes    Path
  1.7       +4 -4      apachen/src/INDENT
  
  Index: INDENT
  ===================================================================
  RCS file: /export/home/cvs/apachen/src/INDENT,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- INDENT	1997/09/14 11:09:32	1.6
  +++ INDENT	1997/09/14 11:13:51	1.7
  @@ -3,10 +3,10 @@
   If a file has already been indent'd, or doesn't need it, mark it as DONE
   
   ./main:				STATUS
  -   alloc.c
  -   alloc.h
  -   buff.c			RESERVED by Dean
  -   buff.h			RESERVED by Dean
  +   alloc.c			RESERVED by Dean
  +   alloc.h			RESERVED by Dean
  +   buff.c			DONE by Dean
  +   buff.h			DONE by Dean
      conf.h
      dummy.c
      explain.c
  
  
  
  1.45      +318 -300  apachen/src/main/buff.c
  
  Index: buff.c
  ===================================================================
  RCS file: /export/home/cvs/apachen/src/main/buff.c,v
  retrieving revision 1.44
  retrieving revision 1.45
  diff -u -r1.44 -r1.45
  --- buff.c	1997/08/17 11:40:11	1.44
  +++ buff.c	1997/09/14 11:13:52	1.45
  @@ -97,8 +97,7 @@
   
   #ifdef WIN32
   
  -int
  -sendwithtimeout(int sock, const char *buf, int len, int flags)
  +int sendwithtimeout(int sock, const char *buf, int len, int flags)
   {
       int iostate = 1;
       fd_set fdset;
  @@ -106,47 +105,42 @@
       int err = WSAEWOULDBLOCK;
       int rv;
   
  -    if(!(tv.tv_sec = check_alarm()))
  -        return(send(sock, buf, len, flags));
  -    
  +    if (!(tv.tv_sec = check_alarm()))
  +	return (send(sock, buf, len, flags));
  +
       rv = ioctlsocket(sock, FIONBIO, &iostate);
       iostate = 0;
  -    if(rv)
  -    {
  -        err = WSAGetLastError();
  -        ap_assert(0);
  +    if (rv) {
  +	err = WSAGetLastError();
  +	ap_assert(0);
       }
       rv = send(sock, buf, len, flags);
  -    if(rv == SOCKET_ERROR)
  -    {
  -        err = WSAGetLastError();
  -        if(err == WSAEWOULDBLOCK)
  -        {
  -            FD_ZERO(&fdset);
  -            FD_SET(sock, &fdset);
  -            tv.tv_usec = 0;
  -            rv = select(FD_SETSIZE, NULL, &fdset, NULL, &tv);
  -            if(rv == 0)
  -            {
  -                ioctlsocket(sock, FIONBIO, &iostate);
  -                check_alarm();
  -                WSASetLastError(WSAEWOULDBLOCK);
  -                return(SOCKET_ERROR);
  -            }
  -            rv = send(sock, buf, len, flags);
  -            if(rv == SOCKET_ERROR)
  -                err = WSAGetLastError();
  -        }
  +    if (rv == SOCKET_ERROR) {
  +	err = WSAGetLastError();
  +	if (err == WSAEWOULDBLOCK) {
  +	    FD_ZERO(&fdset);
  +	    FD_SET(sock, &fdset);
  +	    tv.tv_usec = 0;
  +	    rv = select(FD_SETSIZE, NULL, &fdset, NULL, &tv);
  +	    if (rv == 0) {
  +		ioctlsocket(sock, FIONBIO, &iostate);
  +		check_alarm();
  +		WSASetLastError(WSAEWOULDBLOCK);
  +		return (SOCKET_ERROR);
  +	    }
  +	    rv = send(sock, buf, len, flags);
  +	    if (rv == SOCKET_ERROR)
  +		err = WSAGetLastError();
  +	}
       }
       ioctlsocket(sock, FIONBIO, &iostate);
  -    if(rv == SOCKET_ERROR)
  -        WSASetLastError(err);
  -    return(rv);
  +    if (rv == SOCKET_ERROR)
  +	WSASetLastError(err);
  +    return (rv);
   }
   
   
  -int
  -recvwithtimeout(int sock, char *buf, int len, int flags)
  +int recvwithtimeout(int sock, char *buf, int len, int flags)
   {
       int iostate = 1;
       fd_set fdset;
  @@ -154,74 +148,71 @@
       int err = WSAEWOULDBLOCK;
       int rv;
   
  -    if(!(tv.tv_sec = check_alarm()))
  -        return(recv(sock, buf, len, flags));
  -    
  +    if (!(tv.tv_sec = check_alarm()))
  +	return (recv(sock, buf, len, flags));
  +
       rv = ioctlsocket(sock, FIONBIO, &iostate);
       iostate = 0;
       ap_assert(!rv);
       rv = recv(sock, buf, len, flags);
  -    if(rv == SOCKET_ERROR)
  -    {
  -        err = WSAGetLastError();
  -        if(err == WSAEWOULDBLOCK)
  -        {
  -            FD_ZERO(&fdset);
  -            FD_SET(sock, &fdset);
  -            tv.tv_usec = 0;
  -            rv = select(FD_SETSIZE, &fdset, NULL, NULL, &tv);
  -            if(rv == 0)
  -            {
  -                ioctlsocket(sock, FIONBIO, &iostate);
  -                check_alarm();
  -                WSASetLastError(WSAEWOULDBLOCK);
  -                return(SOCKET_ERROR);
  -            }
  -            rv = recv(sock, buf, len, flags);
  -            if(rv == SOCKET_ERROR)
  -                err = WSAGetLastError();
  -        }
  +    if (rv == SOCKET_ERROR) {
  +	err = WSAGetLastError();
  +	if (err == WSAEWOULDBLOCK) {
  +	    FD_ZERO(&fdset);
  +	    FD_SET(sock, &fdset);
  +	    tv.tv_usec = 0;
  +	    rv = select(FD_SETSIZE, &fdset, NULL, NULL, &tv);
  +	    if (rv == 0) {
  +		ioctlsocket(sock, FIONBIO, &iostate);
  +		check_alarm();
  +		WSASetLastError(WSAEWOULDBLOCK);
  +		return (SOCKET_ERROR);
  +	    }
  +	    rv = recv(sock, buf, len, flags);
  +	    if (rv == SOCKET_ERROR)
  +		err = WSAGetLastError();
  +	}
       }
       ioctlsocket(sock, FIONBIO, &iostate);
  -    if(rv == SOCKET_ERROR)
  -        WSASetLastError(err);
  -    return(rv);
  +    if (rv == SOCKET_ERROR)
  +	WSASetLastError(err);
  +    return (rv);
   }
   
  -#endif /* WIN32 */    
  +#endif /* WIN32 */
   
   /* the lowest level reading primitive */
  -static inline int buff_read (BUFF *fb, void *buf, int nbyte)
  +static inline int buff_read(BUFF *fb, void *buf, int nbyte)
   {
       int rv;
   
   #if defined (WIN32)
       if (fb->flags & B_SOCKET) {
  -	rv = recvwithtimeout( fb->fd_in, buf, nbyte, 0 );
  +	rv = recvwithtimeout(fb->fd_in, buf, nbyte, 0);
   	if (rv == SOCKET_ERROR)
   	    errno = WSAGetLastError() - WSABASEERR;
       }
       else
  -	rv = read( fb->fd_in, buf, nbyte );
  +	rv = read(fb->fd_in, buf, nbyte);
   #else
  -    rv = read( fb->fd_in, buf, nbyte );
  +    rv = read(fb->fd_in, buf, nbyte);
   #endif /* WIN32 */
       return rv;
   }
   
   /* the lowest level writing primitive */
  -static inline int buff_write (BUFF *fb, const void *buf, int nbyte)
  +static inline int buff_write(BUFF *fb, const void *buf, int nbyte)
   {
       int rv;
   
   #if defined(WIN32)
       if (fb->flags & B_SOCKET) {
  -	rv = sendwithtimeout( fb->fd, buf, nbyte, 0);
  +	rv = sendwithtimeout(fb->fd, buf, nbyte, 0);
   	if (rv == SOCKET_ERROR)
   	    errno = WSAGetLastError() - WSABASEERR;
       }
       else
  -	rv = write( fb->fd, buf, nbyte );
  +	rv = write(fb->fd, buf, nbyte);
   #elif defined (B_SFIO)
       rv = sfwrite(fb->sf_out, buf, nbyte);
   #else
  @@ -230,16 +221,16 @@
       return rv;
   }
   
  -static void
  -doerror(BUFF *fb, int err)
  +static void doerror(BUFF *fb, int err)
   {
  -    int errsave = errno;  /* Save errno to prevent overwriting it below */
  +    int errsave = errno;	/* Save errno to prevent overwriting it below */
   
       if (err == B_RD)
   	fb->flags |= B_RDERR;
       else
   	fb->flags |= B_WRERR;
  -    if (fb->error != NULL) (*fb->error)(fb, err, fb->error_data);
  +    if (fb->error != NULL)
  +	(*fb->error) (fb, err, fb->error_data);
   
       errno = errsave;
   }
  @@ -253,17 +244,21 @@
       BUFF *fb;
   
       fb = palloc(p, sizeof(BUFF));
  -    fb->pool=p;
  +    fb->pool = p;
       fb->bufsiz = DEFAULT_BUFSIZE;
  -    fb->flags = flags & (B_RDWR|B_SOCKET);
  +    fb->flags = flags & (B_RDWR | B_SOCKET);
   
  -    if (flags & B_RD) fb->inbase = palloc(p, fb->bufsiz);
  -    else fb->inbase = NULL;
  +    if (flags & B_RD)
  +	fb->inbase = palloc(p, fb->bufsiz);
  +    else
  +	fb->inbase = NULL;
   
       /* overallocate so that we can put a chunk trailer of CRLF into this
        * buffer */
  -    if (flags & B_WR) fb->outbase = palloc(p, fb->bufsiz + 2);
  -    else fb->outbase = NULL;
  +    if (flags & B_WR)
  +	fb->outbase = palloc(p, fb->bufsiz + 2);
  +    else
  +	fb->outbase = NULL;
   
       fb->inptr = fb->inbase;
   
  @@ -277,12 +272,12 @@
       fb->fd_in = -1;
   
   #ifdef B_SFIO
  -    fb->sf_in  = NULL;
  +    fb->sf_in = NULL;
       fb->sf_out = NULL;
  -    fb->sf_in  = sfnew(fb->sf_in, NIL(Void_t*),
  -		       (size_t)SF_UNBOUND, 0, SF_READ); 
  -    fb->sf_out = sfnew(fb->sf_out, NIL(Void_t*), 
  -		       (size_t)SF_UNBOUND, 1, SF_WRITE);
  +    fb->sf_in = sfnew(fb->sf_in, NIL(Void_t *),
  +		      (size_t) SF_UNBOUND, 0, SF_READ);
  +    fb->sf_out = sfnew(fb->sf_out, NIL(Void_t *),
  +		       (size_t) SF_UNBOUND, 1, SF_WRITE);
   #endif
   
       return fb;
  @@ -299,12 +294,11 @@
   
   API_EXPORT(int) bsetopt(BUFF *fb, int optname, const void *optval)
   {
  -    if (optname == BO_BYTECT)
  -    {
  -	fb->bytes_sent = *(const long int *)optval - (long int)fb->outcnt;;
  +    if (optname == BO_BYTECT) {
  +	fb->bytes_sent = *(const long int *) optval - (long int) fb->outcnt;;
   	return 0;
  -    } else
  -    {
  +    }
  +    else {
   	errno = EINVAL;
   	return -1;
       }
  @@ -312,14 +306,14 @@
   
   API_EXPORT(int) bgetopt(BUFF *fb, int optname, void *optval)
   {
  -    if (optname == BO_BYTECT)
  -    {
  -	long int bs=fb->bytes_sent + fb->outcnt;
  -	if (bs < 0L) bs = 0L;
  -	*(long int *)optval = bs;
  +    if (optname == BO_BYTECT) {
  +	long int bs = fb->bytes_sent + fb->outcnt;
  +	if (bs < 0L)
  +	    bs = 0L;
  +	*(long int *) optval = bs;
   	return 0;
  -    } else
  -    {
  +    }
  +    else {
   	errno = EINVAL;
   	return -1;
       }
  @@ -328,33 +322,32 @@
   /*
    * start chunked encoding
    */
  -static void
  -start_chunk( BUFF *fb )
  +static void start_chunk(BUFF *fb)
   {
  -    char chunksize[16];	/* Big enough for practically anything */
  +    char chunksize[16];		/* Big enough for practically anything */
       int chunk_header_size;
   
       if (fb->outchunk != -1) {
   	/* already chunking */
   	return;
       }
  -    if (!(fb->flags & B_WR) || (fb->flags & (B_WRERR|B_EOUT))) {
  +    if (!(fb->flags & B_WR) || (fb->flags & (B_WRERR | B_EOUT))) {
   	/* unbuffered writes */
   	return;
       }
   
       /* we know that the chunk header is going to take at least 3 bytes... */
  -    chunk_header_size = ap_snprintf( chunksize, sizeof(chunksize),
  -	"%x\015\012", fb->bufsiz - fb->outcnt - 3 );
  +    chunk_header_size = ap_snprintf(chunksize, sizeof(chunksize),
  +				 "%x\015\012", fb->bufsiz - fb->outcnt - 3);
       /* we need at least the header_len + at least 1 data byte
        * remember that we've overallocated fb->outbase so that we can always
        * fit the two byte CRLF trailer
        */
  -    if( fb->bufsiz - fb->outcnt < chunk_header_size + 1 ) {
  +    if (fb->bufsiz - fb->outcnt < chunk_header_size + 1) {
   	bflush(fb);
       }
       /* assume there's enough space now */
  -    memcpy( &fb->outbase[fb->outcnt], chunksize, chunk_header_size );
  +    memcpy(&fb->outbase[fb->outcnt], chunksize, chunk_header_size);
       fb->outchunk = fb->outcnt;
       fb->outcnt += chunk_header_size;
       fb->outchunk_header_size = chunk_header_size;
  @@ -364,17 +357,16 @@
   /*
    * end a chunk -- tweak the chunk_header from start_chunk, and add a trailer
    */
  -static void
  -end_chunk( BUFF *fb )
  +static void end_chunk(BUFF *fb)
   {
       int i;
   
  -    if( fb->outchunk == -1 ) {
  +    if (fb->outchunk == -1) {
   	/* not chunking */
   	return;
       }
   
  -    if( fb->outchunk + fb->outchunk_header_size == fb->outcnt ) {
  +    if (fb->outchunk + fb->outchunk_header_size == fb->outcnt) {
   	/* nothing was written into this chunk, and we can't write a 0 size
   	 * chunk because that signifies EOF, so just erase it
   	 */
  @@ -384,9 +376,9 @@
       }
   
       /* we know this will fit because of how we wrote it in start_chunk() */
  -    i = ap_snprintf( (char *)&fb->outbase[fb->outchunk],
  -	fb->outchunk_header_size,
  -	"%x", fb->outcnt - fb->outchunk - fb->outchunk_header_size );
  +    i = ap_snprintf((char *) &fb->outbase[fb->outchunk],
  +		    fb->outchunk_header_size,
  +		"%x", fb->outcnt - fb->outchunk - fb->outchunk_header_size);
   
       /* we may have to tack some trailing spaces onto the number we just wrote
        * in case it was smaller than our estimated size.  We've also written
  @@ -394,12 +386,12 @@
        * \r back in.
        */
       i += fb->outchunk;
  -    while( fb->outbase[i] != '\015' && fb->outbase[i] != '\012' ) {
  +    while (fb->outbase[i] != '\015' && fb->outbase[i] != '\012') {
   	fb->outbase[i++] = ' ';
       }
  -    if( fb->outbase[i] == '\012' ) {
  +    if (fb->outbase[i] == '\012') {
   	/* we overwrote the \r, so put it back */
  -	fb->outbase[i-1] = '\015';
  +	fb->outbase[i - 1] = '\015';
       }
   
       /* tack on the trailing CRLF, we've reserved room for this */
  @@ -420,7 +412,8 @@
   	if (flag & B_CHUNK) {
   	    start_chunk(fb);
   	}
  -    } else {
  +    }
  +    else {
   	fb->flags &= ~flag;
   	if (flag & B_CHUNK) {
   	    end_chunk(fb);
  @@ -434,11 +427,11 @@
   {
       int fd;
   
  -    fd = ( direction == B_RD ) ? fb->fd_in : fb->fd;
  +    fd = (direction == B_RD) ? fb->fd_in : fb->fd;
   #if defined(O_NONBLOCK)
  -    return fcntl (fd, F_SETFL, O_NONBLOCK);
  +    return fcntl(fd, F_SETFL, O_NONBLOCK);
   #elif defined(F_NDELAY)
  -    return fcntl (fd, F_SETFL, F_NDELAY);
  +    return fcntl(fd, F_SETFL, F_NDELAY);
   #else
       return 0;
   #endif
  @@ -460,15 +453,14 @@
   #if !defined (B_SFIO) || defined (WIN32)
   #define saferead saferead_guts
   #else
  -static int
  -saferead(BUFF *fb, char *buf, int nbyte)
  +static int saferead(BUFF *fb, char *buf, int nbyte)
   {
       return sfread(fb->sf_in, buf, nbyte);
   }
   #endif
   
   
  -API_EXPORT(void) bhalfduplex (BUFF *fb)
  +API_EXPORT(void) bhalfduplex(BUFF *fb)
   {
       int rv;
       fd_set fds;
  @@ -479,65 +471,64 @@
       }
       /* test for a block */
       do {
  -	FD_ZERO( &fds );
  -	FD_SET( fb->fd_in, &fds );
  +	FD_ZERO(&fds);
  +	FD_SET(fb->fd_in, &fds);
   	tv.tv_sec = 0;
   	tv.tv_usec = 0;
  -	rv = ap_select( fb->fd_in + 1, &fds, NULL, NULL, &tv );
  -    } while( rv < 0 && errno == EINTR );
  +	rv = ap_select(fb->fd_in + 1, &fds, NULL, NULL, &tv);
  +    } while (rv < 0 && errno == EINTR);
       /* treat any error as if it would block as well */
  -    if( rv != 1 ) {
  +    if (rv != 1) {
   	bflush(fb);
       }
   }
   
  -static inline int
  -saferead_guts(BUFF *fb, void *buf, int nbyte)
  +static inline int saferead_guts(BUFF *fb, void *buf, int nbyte)
   {
       int rv;
   
  -    if( fb->flags & B_SAFEREAD ) {
  -	bhalfduplex (fb);
  +    if (fb->flags & B_SAFEREAD) {
  +	bhalfduplex(fb);
       }
       do {
  -	rv = buff_read (fb, buf, nbyte);
  +	rv = buff_read(fb, buf, nbyte);
       } while (rv == -1 && errno == EINTR && !(fb->flags & B_EOUT));
  -    return( rv );
  +    return (rv);
   }
   
   #ifdef B_SFIO
  -int bsfio_read(Sfio_t *f, char *buf, int nbyte, apache_sfio *disc)
  +int bsfio_read(Sfio_t * f, char *buf, int nbyte, apache_sfio *disc)
   {
       int rv;
       BUFF *fb = disc->buff;
  -    
  +
       rv = saferead_guts(fb, buf, nbyte);
   
       buf[rv] = '\0';
       f->next = 0;
   
  -    return(rv);
  +    return (rv);
   }
   
  -int bsfio_write(Sfio_t *f, char *buf, int nbyte, apache_sfio *disc)
  +int bsfio_write(Sfio_t * f, char *buf, int nbyte, apache_sfio *disc)
   {
       return write(disc->buff->fd, buf, nbyte);
   }
   
   Sfdisc_t *bsfio_new(pool *p, BUFF *b)
   {
  -    apache_sfio*   disc;
  -    
  -    if(!(disc = (apache_sfio*)palloc(p, sizeof(apache_sfio))) )
  -	return (Sfdisc_t *)disc;
  -
  -    disc->disc.readf   = (Sfread_f)bsfio_read; 
  -    disc->disc.writef  = (Sfwrite_f)bsfio_write;
  -    disc->disc.seekf   = (Sfseek_f)NULL;
  -    disc->disc.exceptf = (Sfexcept_f)NULL;
  +    apache_sfio *disc;
  +
  +    if (!(disc = (apache_sfio *) palloc(p, sizeof(apache_sfio))))
  +	            return (Sfdisc_t *) disc;
  +
  +    disc->disc.readf = (Sfread_f) bsfio_read;
  +    disc->disc.writef = (Sfwrite_f) bsfio_write;
  +    disc->disc.seekf = (Sfseek_f) NULL;
  +    disc->disc.exceptf = (Sfexcept_f) NULL;
       disc->buff = b;
   
  -    return (Sfdisc_t *)disc;
  +    return (Sfdisc_t *) disc;
   }
   #endif
   
  @@ -547,15 +538,16 @@
    * and then there's the SFIO case.  Note that saferead takes care
    * of EINTR.
    */
  -static int read_with_errors (BUFF *fb, void *buf, int nbyte)
  +static int read_with_errors(BUFF *fb, void *buf, int nbyte)
   {
       int rv;
   
  -    rv = saferead (fb, buf, nbyte);
  +    rv = saferead(fb, buf, nbyte);
       if (rv == 0) {
   	fb->flags |= B_EOF;
  -    } else if (rv == -1 && errno != EAGAIN) {
  -	doerror (fb, B_RD);
  +    }
  +    else if (rv == -1 && errno != EAGAIN) {
  +	doerror(fb, B_RD);
       }
       return rv;
   }
  @@ -569,46 +561,47 @@
   {
       int i, nrd;
   
  -    if (fb->flags & B_RDERR) return -1;
  -    if (nbyte == 0) return 0;
  +    if (fb->flags & B_RDERR)
  +	return -1;
  +    if (nbyte == 0)
  +	return 0;
   
       if (!(fb->flags & B_RD)) {
   	/* Unbuffered reading.  First check if there was something in the
   	 * buffer from before we went unbuffered. */
   	if (fb->incnt) {
   	    i = (fb->incnt > nbyte) ? nbyte : fb->incnt;
  -	    memcpy (buf, fb->inptr, i);
  +	    memcpy(buf, fb->inptr, i);
   	    fb->incnt -= i;
   	    fb->inptr += i;
   	    return i;
   	}
  -	i = read_with_errors (fb, buf, nbyte);
  +	i = read_with_errors(fb, buf, nbyte);
   	return i;
       }
   
       nrd = fb->incnt;
   /* can we fill the buffer */
  -    if (nrd >= nbyte)
  -    {
  +    if (nrd >= nbyte) {
   	memcpy(buf, fb->inptr, nbyte);
   	fb->incnt = nrd - nbyte;
   	fb->inptr += nbyte;
   	return nbyte;
       }
  -	
  -    if (nrd > 0)
  -    {
  +
  +    if (nrd > 0) {
   	memcpy(buf, fb->inptr, nrd);
   	nbyte -= nrd;
  -	buf = nrd + (char *)buf;
  +	buf = nrd + (char *) buf;
   	fb->incnt = 0;
       }
  -    if (fb->flags & B_EOF) return nrd;
  +    if (fb->flags & B_EOF)
  +	return nrd;
   
   /* do a single read */
       if (nbyte >= fb->bufsiz) {
   /* read directly into buffer */
  -	i = read_with_errors (fb, buf, nbyte);
  +	i = read_with_errors(fb, buf, nbyte);
   	if (i == -1) {
   	    return nrd ? nrd : -1;
   	}
  @@ -616,12 +609,13 @@
       else {
   /* read into hold buffer, then memcpy */
   	fb->inptr = fb->inbase;
  -	i = read_with_errors (fb, fb->inptr, fb->bufsiz);
  +	i = read_with_errors(fb, fb->inptr, fb->bufsiz);
   	if (i == -1) {
   	    return nrd ? nrd : -1;
   	}
   	fb->incnt = i;
  -	if (i > nbyte) i = nbyte;
  +	if (i > nbyte)
  +	    i = nbyte;
   	memcpy(buf, fb->inptr, i);
   	fb->incnt -= i;
   	fb->inptr += i;
  @@ -653,50 +647,52 @@
       int i, ch, ct;
   
   /* Can't do bgets on an unbuffered stream */
  -    if (!(fb->flags & B_RD))
  -    {
  +    if (!(fb->flags & B_RD)) {
   	errno = EINVAL;
   	return -1;
       }
  -    if (fb->flags & B_RDERR) return -1;
  +    if (fb->flags & B_RDERR)
  +	return -1;
   
       ct = 0;
       i = 0;
  -    for (;;)
  -    {
  -	if (i == fb->incnt)
  -	{
  +    for (;;) {
  +	if (i == fb->incnt) {
   /* no characters left */
   	    fb->inptr = fb->inbase;
   	    fb->incnt = 0;
  -	    if (fb->flags & B_EOF) break;
  -	    i = read_with_errors (fb, fb->inptr, fb->bufsiz);
  +	    if (fb->flags & B_EOF)
  +		break;
  +	    i = read_with_errors(fb, fb->inptr, fb->bufsiz);
   	    if (i == -1) {
   		buff[ct] = '\0';
   		return ct ? ct : -1;
   	    }
   	    fb->incnt = i;
  -	    if (i == 0) break;	/* EOF */
  +	    if (i == 0)
  +		break;		/* EOF */
   	    i = 0;
  -	    continue;  /* restart with the new data */
  +	    continue;		/* restart with the new data */
   	}
   
   	ch = fb->inptr[i++];
  -	if (ch == '\012')  /* got LF */
  -	{
  -	    if (ct == 0) buff[ct++] = '\n';
  +	if (ch == '\012') {	/* got LF */
  +	    if (ct == 0)
  +		buff[ct++] = '\n';
   /* if just preceeded by CR, replace CR with LF */
  -	    else if (buff[ct-1] == '\015') buff[ct-1] = '\n';
  -	    else if (ct < n-1) buff[ct++] = '\n';
  -	    else i--; /* no room for LF */
  +	    else if (buff[ct - 1] == '\015')
  +		buff[ct - 1] = '\n';
  +	    else if (ct < n - 1)
  +		buff[ct++] = '\n';
  +	    else
  +		i--;		/* no room for LF */
   	    break;
   	}
  -	if (ct == n-1)
  -	{
  -	    i--;  /* push back ch */
  +	if (ct == n - 1) {
  +	    i--;		/* push back ch */
   	    break;
   	}
  -	
  +
   	buff[ct++] = ch;
       }
       fb->incnt -= i;
  @@ -718,23 +714,24 @@
       int i;
   
       *buff = '\0';
  -    
  -    if (!(fb->flags & B_RD)) {   /* Can't do blookc on an unbuffered stream */
  -        errno = EINVAL;
  -        return -1;
  -    }
  -    if (fb->flags & B_RDERR) return -1;
  -
  -    if (fb->incnt == 0) {        /* no characters left in stream buffer */
  -        fb->inptr = fb->inbase;
  -        if (fb->flags & B_EOF)
  -            return 0;
   
  -	i = read_with_errors (fb, fb->inptr, fb->bufsiz);
  +    if (!(fb->flags & B_RD)) {	/* Can't do blookc on an unbuffered stream */
  +	errno = EINVAL;
  +	return -1;
  +    }
  +    if (fb->flags & B_RDERR)
  +	return -1;
  +
  +    if (fb->incnt == 0) {	/* no characters left in stream buffer */
  +	fb->inptr = fb->inbase;
  +	if (fb->flags & B_EOF)
  +	    return 0;
  +
  +	i = read_with_errors(fb, fb->inptr, fb->bufsiz);
   	if (i <= 0) {
   	    return i;
   	}
  -        fb->incnt = i;
  +	fb->incnt = i;
       }
   
       *buff = fb->inptr[0];
  @@ -751,18 +748,16 @@
       int i;
   
   /* Can't do bskiplf on an unbuffered stream */
  -    if (!(fb->flags & B_RD))
  -    {
  +    if (!(fb->flags & B_RD)) {
   	errno = EINVAL;
   	return -1;
       }
  -    if (fb->flags & B_RDERR) return -1;
  +    if (fb->flags & B_RDERR)
  +	return -1;
   
  -    for (;;)
  -    {
  -	x = (unsigned char *)memchr(fb->inptr, '\012', fb->incnt);
  -	if (x != NULL)
  -	{
  +    for (;;) {
  +	x = (unsigned char *) memchr(fb->inptr, '\012', fb->incnt);
  +	if (x != NULL) {
   	    x++;
   	    fb->incnt -= x - fb->inptr;
   	    fb->inptr = x;
  @@ -771,9 +766,11 @@
   
   	fb->inptr = fb->inbase;
   	fb->incnt = 0;
  -	if (fb->flags & B_EOF) return 0;
  -	i = read_with_errors (fb, fb->inptr, fb->bufsiz);
  -	if (i <= 0) return i;
  +	if (fb->flags & B_EOF)
  +	    return 0;
  +	i = read_with_errors(fb, fb->inptr, fb->bufsiz);
  +	if (i <= 0)
  +	    return i;
   	fb->incnt = i;
       }
   }
  @@ -798,9 +795,12 @@
       char buf[1];
   
       i = bread(fb, buf, 1);
  -    if (i == 0) errno = 0;  /* no error; EOF */
  -    if (i != 1) return EOF;
  -    else return buf[0];
  +    if (i == 0)
  +	errno = 0;		/* no error; EOF */
  +    if (i != 1)
  +	return EOF;
  +    else
  +	return buf[0];
   }
   
   
  @@ -813,25 +813,24 @@
    *
    * Deals with calling doerror and setting bytes_sent.
    */
  -static int
  -write_it_all(BUFF *fb, const void *buf, int nbyte)
  +static int write_it_all(BUFF *fb, const void *buf, int nbyte)
   {
       int i;
   
  -    if (fb->flags & (B_WRERR|B_EOUT))
  +    if (fb->flags & (B_WRERR | B_EOUT))
   	return -1;
   
       while (nbyte > 0) {
  -	i = buff_write (fb, buf, nbyte);
  +	i = buff_write(fb, buf, nbyte);
   	if (i < 0) {
   	    if (errno != EAGAIN && errno != EINTR) {
  -		doerror (fb, B_WR);
  +		doerror(fb, B_WR);
   		return -1;
   	    }
   	}
   	else {
   	    nbyte -= i;
  -	    buf = i + (const char *)buf;
  +	    buf = i + (const char *) buf;
   	    fb->bytes_sent += i;
   	}
   	if (fb->flags & B_EOUT)
  @@ -847,7 +846,7 @@
    *
    * Deals with doerror() and bytes_sent.
    */
  -static int writev_it_all (BUFF *fb, struct iovec *vec, int nvec)
  +static int writev_it_all(BUFF *fb, struct iovec *vec, int nvec)
   {
       int i, rv;
   
  @@ -856,12 +855,13 @@
        */
       i = 0;
       while (i < nvec) {
  -	do rv = writev( fb->fd, &vec[i], nvec - i );
  +	do
  +	    rv = writev(fb->fd, &vec[i], nvec - i);
   	while (rv == -1 && (errno == EINTR || errno == EAGAIN)
  -		&& !(fb->flags & B_EOUT));
  +	       && !(fb->flags & B_EOUT));
   	if (rv == -1) {
   	    if (errno != EINTR && errno != EAGAIN) {
  -		doerror (fb, B_WR);
  +		doerror(fb, B_WR);
   	    }
   	    return -1;
   	}
  @@ -869,13 +869,14 @@
   	/* recalculate vec to deal with partial writes */
   	while (rv > 0) {
   	    if (rv < vec[i].iov_len) {
  -		vec[i].iov_base = (char *)vec[i].iov_base + rv;
  +		vec[i].iov_base = (char *) vec[i].iov_base + rv;
   		vec[i].iov_len -= rv;
   		rv = 0;
   		if (vec[i].iov_len == 0) {
   		    ++i;
   		}
  -	    } else {
  +	    }
  +	    else {
   		rv -= vec[i].iov_len;
   		++i;
   	    }
  @@ -891,18 +892,20 @@
   /* A wrapper for buff_write which deals with error conditions and
    * bytes_sent.  Also handles non-blocking writes.
    */
  -static int write_with_errors (BUFF *fb, const void *buf, int nbyte)
  +static int write_with_errors(BUFF *fb, const void *buf, int nbyte)
   {
       int rv;
   
  -    do rv = buff_write(fb, buf, nbyte);
  +    do
  +	rv = buff_write(fb, buf, nbyte);
       while (rv == -1 && errno == EINTR && !(fb->flags & B_EOUT));
       if (rv == -1) {
   	if (errno != EAGAIN) {
  -	    doerror (fb, B_WR);
  +	    doerror(fb, B_WR);
   	}
   	return -1;
  -    } else if (rv == 0) {
  +    }
  +    else if (rv == 0) {
   	errno = EAGAIN;
   	return -1;
       }
  @@ -920,19 +923,18 @@
    * Can be used on non-blocking descriptors, but only if they're not chunked.
    * Deals with doerror() and bytes_sent.
    */
  -static int
  -bcwrite(BUFF *fb, const void *buf, int nbyte)
  +static int bcwrite(BUFF *fb, const void *buf, int nbyte)
   {
  -    char chunksize[16];	/* Big enough for practically anything */
  +    char chunksize[16];		/* Big enough for practically anything */
   #ifndef NO_WRITEV
       struct iovec vec[3];
   #endif
   
  -    if (fb->flags & (B_WRERR|B_EOUT))
  +    if (fb->flags & (B_WRERR | B_EOUT))
   	return -1;
   
       if (!(fb->flags & B_CHUNK)) {
  -	return write_with_errors (fb, buf, nbyte);
  +	return write_with_errors(fb, buf, nbyte);
       }
   
   #ifdef NO_WRITEV
  @@ -949,13 +951,13 @@
   #else
       vec[0].iov_base = chunksize;
       vec[0].iov_len = ap_snprintf(chunksize, sizeof(chunksize), "%x\015\012",
  -	nbyte);
  -    vec[1].iov_base = (void *)buf;	/* cast is to avoid const warning */
  +				 nbyte);
  +    vec[1].iov_base = (void *) buf;	/* cast is to avoid const warning */
       vec[1].iov_len = nbyte;
       vec[2].iov_base = "\r\n";
       vec[2].iov_len = 2;
   
  -    return writev_it_all (fb, vec, (sizeof(vec)/sizeof(vec[0]))) ? -1 : nbyte;
  +    return writev_it_all(fb, vec, (sizeof(vec) / sizeof(vec[0]))) ? -1 : nbyte;
   #endif
   }
   
  @@ -965,7 +967,7 @@
    * Used to combine the contents of the fb buffer, and a large buffer
    * passed in.
    */
  -static int large_write (BUFF *fb, const void *buf, int nbyte)
  +static int large_write(BUFF *fb, const void *buf, int nbyte)
   {
       struct iovec vec[4];
       int nvec;
  @@ -978,29 +980,30 @@
       }
       nvec = 0;
       if (fb->outcnt > 0) {
  -	vec[nvec].iov_base = (void *)fb->outbase;
  +	vec[nvec].iov_base = (void *) fb->outbase;
   	vec[nvec].iov_len = fb->outcnt;
   	++nvec;
       }
       if (fb->flags & B_CHUNK) {
   	vec[nvec].iov_base = chunksize;
  -	vec[nvec].iov_len = ap_snprintf (chunksize, sizeof(chunksize),
  -	    "%x\015\012", nbyte);
  +	vec[nvec].iov_len = ap_snprintf(chunksize, sizeof(chunksize),
  +					"%x\015\012", nbyte);
   	++nvec;
  -	vec[nvec].iov_base = (void *)buf;
  +	vec[nvec].iov_base = (void *) buf;
   	vec[nvec].iov_len = nbyte;
   	++nvec;
   	vec[nvec].iov_base = "\r\n";
   	vec[nvec].iov_len = 2;
   	++nvec;
  -    } else {
  -	vec[nvec].iov_base = (void *)buf;
  +    }
  +    else {
  +	vec[nvec].iov_base = (void *) buf;
   	vec[nvec].iov_len = nbyte;
   	++nvec;
       }
   
       fb->outcnt = 0;
  -    return writev_it_all (fb, vec, nvec) ? -1 : nbyte;
  +    return writev_it_all(fb, vec, nvec) ? -1 : nbyte;
   }
   #endif
   
  @@ -1016,8 +1019,10 @@
   {
       int i, nwr;
   
  -    if (fb->flags & (B_WRERR|B_EOUT)) return -1;
  -    if (nbyte == 0) return 0;
  +    if (fb->flags & (B_WRERR | B_EOUT))
  +	return -1;
  +    if (nbyte == 0)
  +	return 0;
   
       if (!(fb->flags & B_WR)) {
   /* unbuffered write -- have to use bcwrite since we aren't taking care
  @@ -1031,7 +1036,7 @@
    * current buffer with it in a single writev()
    */
       if (fb->outcnt > 0 && nbyte + fb->outcnt >= fb->bufsiz) {
  -	return large_write (fb, buf, nbyte);
  +	return large_write(fb, buf, nbyte);
       }
   #endif
   
  @@ -1040,19 +1045,19 @@
    * out
    */
       nwr = 0;
  -    while (fb->outcnt > 0)
  -    {
  +    while (fb->outcnt > 0) {
   /* can we accept some data? */
   	i = fb->bufsiz - fb->outcnt;
  -	if (i > 0)
  -	{
  -	    if (i > nbyte) i = nbyte;
  +	if (i > 0) {
  +	    if (i > nbyte)
  +		i = nbyte;
   	    memcpy(fb->outbase + fb->outcnt, buf, i);
   	    fb->outcnt += i;
   	    nbyte -= i;
  -	    buf = i + (const char *)buf;
  +	    buf = i + (const char *) buf;
   	    nwr += i;
  -	    if (nbyte == 0) return nwr; /* return if none left */
  +	    if (nbyte == 0)
  +		return nwr;	/* return if none left */
   	}
   
   /* the buffer must be full */
  @@ -1068,17 +1073,17 @@
   	    fb->outcnt = 0;
   	    break;
   	}
  -	i = write_with_errors (fb, fb->outbase, fb->outcnt);
  +	i = write_with_errors(fb, fb->outbase, fb->outcnt);
   	if (i <= 0) {
   	    return nwr ? nwr : -1;
   	}
   
   	/* deal with a partial write */
  -	if (i < fb->outcnt)
  -	{
  -	    int j, n=fb->outcnt;
  -	    unsigned char *x=fb->outbase;
  -	    for (j=i; j < n; j++) x[j-i] = x[j];
  +	if (i < fb->outcnt) {
  +	    int j, n = fb->outcnt;
  +	    unsigned char *x = fb->outbase;
  +	    for (j = i; j < n; j++)
  +		x[j - i] = x[j];
   	    fb->outcnt -= i;
   	}
   	else
  @@ -1092,14 +1097,13 @@
    * use bcwrite() to do this for us, it will do the chunking so that
    * we don't have to dink around building a chunk in our own buffer.
    */
  -    while (nbyte >= fb->bufsiz)
  -    {
  +    while (nbyte >= fb->bufsiz) {
   	i = bcwrite(fb, buf, nbyte);
   	if (i <= 0) {
   	    return nwr ? nwr : -1;
   	}
   
  -	buf = i + (const char *)buf;
  +	buf = i + (const char *) buf;
   	nwr += i;
   	nbyte -= i;
   
  @@ -1108,8 +1112,10 @@
       }
   /* copy what's left to the file buffer */
       fb->outcnt = 0;
  -    if( fb->flags & B_CHUNK ) start_chunk( fb );
  -    if (nbyte > 0) memcpy(fb->outbase + fb->outcnt, buf, nbyte);
  +    if (fb->flags & B_CHUNK)
  +	start_chunk(fb);
  +    if (nbyte > 0)
  +	memcpy(fb->outbase + fb->outcnt, buf, nbyte);
       fb->outcnt += nbyte;
       nwr += nbyte;
       return nwr;
  @@ -1123,26 +1129,29 @@
   {
       int i;
   
  -    if (!(fb->flags & B_WR) || (fb->flags & B_EOUT)) return 0;
  +    if (!(fb->flags & B_WR) || (fb->flags & B_EOUT))
  +	return 0;
  +
  +    if (fb->flags & B_WRERR)
  +	return -1;
   
  -    if (fb->flags & B_WRERR) return -1;
  -    
  -    if (fb->flags & B_CHUNK) end_chunk(fb);
  -
  -    while (fb->outcnt > 0)
  -    {
  -	i = write_with_errors (fb, fb->outbase, fb->outcnt);
  -	if (i <= 0) return -1;
  +    if (fb->flags & B_CHUNK)
  +	end_chunk(fb);
  +
  +    while (fb->outcnt > 0) {
  +	i = write_with_errors(fb, fb->outbase, fb->outcnt);
  +	if (i <= 0)
  +	    return -1;
   
   	/*
  - 	 * We should have written all the data, but if the fd was in a
  - 	 * strange (non-blocking) mode, then we might not have done so.
  - 	 */
  -	if (i < fb->outcnt)
  -	{
  -	    int j, n=fb->outcnt;
  -	    unsigned char *x=fb->outbase;
  -	    for (j=i; j < n; j++) x[j-i] = x[j];
  +	 * We should have written all the data, but if the fd was in a
  +	 * strange (non-blocking) mode, then we might not have done so.
  +	 */
  +	if (i < fb->outcnt) {
  +	    int j, n = fb->outcnt;
  +	    unsigned char *x = fb->outbase;
  +	    for (j = i; j < n; j++)
  +		x[j - i] = x[j];
   	}
   	fb->outcnt -= i;
   
  @@ -1166,22 +1175,27 @@
   {
       int rc1, rc2, rc3;
   
  -    if (fb->flags & B_WR) rc1 = bflush(fb);
  -    else rc1 = 0;
  +    if (fb->flags & B_WR)
  +	rc1 = bflush(fb);
  +    else
  +	rc1 = 0;
   #ifdef WIN32
       if (fb->flags & B_SOCKET) {
   	rc2 = pclosesocket(fb->pool, fb->fd);
   	if (fb->fd_in != fb->fd) {
   	    rc3 = pclosesocket(fb->pool, fb->fd_in);
  -	} else {
  +	}
  +	else {
   	    rc3 = 0;
   	}
  -    } else {
  +    }
  +    else {
   #endif
   	rc2 = pclosef(fb->pool, fb->fd);
   	if (fb->fd_in != fb->fd) {
   	    rc3 = pclosef(fb->pool, fb->fd_in);
  -	} else {
  +	}
  +	else {
   	    rc3 = 0;
   	}
   #ifdef WIN32
  @@ -1199,11 +1213,14 @@
   #ifdef B_SFIO
       sfclose(fb->sf_in);
       sfclose(fb->sf_out);
  -#endif  
  +#endif
   
  -    if (rc1 != 0) return rc1;
  -    else if (rc2 != 0) return rc2;
  -    else return rc3;
  +    if (rc1 != 0)
  +	return rc1;
  +    else if (rc2 != 0)
  +	return rc2;
  +    else
  +	return rc3;
   }
   
   /*
  @@ -1211,30 +1228,31 @@
    */
   API_EXPORT(int) bputs(const char *x, BUFF *fb)
   {
  -    int i, j=strlen(x);
  +    int i, j = strlen(x);
       i = bwrite(fb, x, j);
  -    if (i != j) return -1;
  -    else return j;
  +    if (i != j)
  +	return -1;
  +    else
  +	return j;
   }
   
   /*
    * returns the number of bytes written or -1 on error
    */
  -API_EXPORT_NONSTD(int) bvputs(BUFF *fb, ...)
  +API_EXPORT_NONSTD(int) bvputs(BUFF *fb,...)
   {
       int i, j, k;
       va_list v;
       const char *x;
   
       va_start(v, fb);
  -    for (k=0;;)
  -    {
  +    for (k = 0;;) {
   	x = va_arg(v, const char *);
  -	if (x == NULL) break;
  +	if (x == NULL)
  +	    break;
   	j = strlen(x);
   	i = bwrite(fb, x, j);
  -	if (i != j)
  -	{
  +	if (i != j) {
   	    va_end(v);
   	    return -1;
   	}
  @@ -1246,7 +1264,7 @@
       return k;
   }
   
  -API_EXPORT(void) bonerror(BUFF *fb, void (*error)(BUFF *, int, void *),
  +API_EXPORT(void) bonerror(BUFF *fb, void (*error) (BUFF *, int, void *),
   			  void *data)
   {
       fb->error = error;
  
  
  
  1.24      +25 -26    apachen/src/main/buff.h
  
  Index: buff.h
  ===================================================================
  RCS file: /export/home/cvs/apachen/src/main/buff.h,v
  retrieving revision 1.23
  retrieving revision 1.24
  diff -u -r1.23 -r1.24
  --- buff.h	1997/08/08 08:00:19	1.23
  +++ buff.h	1997/09/14 11:13:53	1.24
  @@ -79,34 +79,33 @@
   
   typedef struct buff_struct BUFF;
   
  -struct buff_struct
  -{
  -    int flags;             /* flags */
  -    unsigned char *inptr;  /* pointer to next location to read */
  -    int incnt;             /* number of bytes left to read from input buffer;
  -			    * always 0 if had a read error  */
  -    int outchunk;	   /* location of chunk header when chunking */
  -    int outchunk_header_size; /* how long the header is */
  -    int outcnt;            /* number of byte put in output buffer */
  +struct buff_struct {
  +    int flags;			/* flags */
  +    unsigned char *inptr;	/* pointer to next location to read */
  +    int incnt;			/* number of bytes left to read from input buffer;
  +				 * always 0 if had a read error  */
  +    int outchunk;		/* location of chunk header when chunking */
  +    int outchunk_header_size;	/* how long the header is */
  +    int outcnt;			/* number of byte put in output buffer */
       unsigned char *inbase;
       unsigned char *outbase;
       int bufsiz;
  -    void (*error)(BUFF *fb, int op, void *data);
  +    void (*error) (BUFF *fb, int op, void *data);
       void *error_data;
  -    long int bytes_sent;   /* number of bytes actually written */
  +    long int bytes_sent;	/* number of bytes actually written */
   
       pool *pool;
   
   /* could also put pointers to the basic I/O routines here */
  -    int fd;                /* the file descriptor */
  -    int fd_in;             /* input file descriptor, if different */
  +    int fd;			/* the file descriptor */
  +    int fd_in;			/* input file descriptor, if different */
   
  -     /* transport handle, for RPC binding handle or some such */
  -     void *t_handle;
  +    /* transport handle, for RPC binding handle or some such */
  +    void *t_handle;
   
   #ifdef B_SFIO
  -    Sfio_t   *sf_in;
  -    Sfio_t   *sf_out;
  +    Sfio_t *sf_in;
  +    Sfio_t *sf_out;
   #endif
   };
   
  @@ -133,8 +132,8 @@
   #define bgetflag(fb, flag)	((fb)->flags & (flag))
   
   /* Error handling */
  -API_EXPORT(void) bonerror(BUFF *fb, void (*error)(BUFF *, int, void *),
  -		     void *data);
  +API_EXPORT(void) bonerror(BUFF *fb, void (*error) (BUFF *, int, void *),
  +			  void *data);
   
   /* I/O */
   API_EXPORT(int) bread(BUFF *fb, void *buf, int nbyte);
  @@ -144,9 +143,9 @@
   API_EXPORT(int) bwrite(BUFF *fb, const void *buf, int nbyte);
   API_EXPORT(int) bflush(BUFF *fb);
   API_EXPORT(int) bputs(const char *x, BUFF *fb);
  -API_EXPORT(int) bvputs(BUFF *fb, ...);
  -API_EXPORT_NONSTD(int) bprintf(BUFF *fb,const char *fmt,...);
  -API_EXPORT_NONSTD(int) vbprintf(BUFF *fb,const char *fmt,va_list vlist);
  +API_EXPORT(int) bvputs(BUFF *fb,...);
  +API_EXPORT_NONSTD(int) bprintf(BUFF *fb, const char *fmt,...);
  +API_EXPORT_NONSTD(int) vbprintf(BUFF *fb, const char *fmt, va_list vlist);
   
   /* Internal routines */
   API_EXPORT(int) bflsbuf(int c, BUFF *fb);
  @@ -159,9 +158,9 @@
   		     (fb)->outcnt == (fb)->bufsiz) ? bflsbuf(c, (fb)) : \
   		     ((fb)->outbase[(fb)->outcnt++] = (c), 0))
   
  -API_EXPORT(int) spawn_child_err_buff (pool *, int (*)(void *), void *,
  -           	  enum kill_conditions, BUFF **pipe_in, BUFF **pipe_out,
  -                  BUFF **pipe_err);
  +API_EXPORT(int) spawn_child_err_buff(pool *, int (*)(void *), void *,
  +		      enum kill_conditions, BUFF **pipe_in, BUFF **pipe_out,
  +				     BUFF **pipe_err);
   
   /* enable non-blocking operations */
   API_EXPORT(int) bnonblock(BUFF *fb, int direction);
  @@ -169,4 +168,4 @@
   API_EXPORT(int) bfileno(BUFF *fb, int direction);
   
   /* bflush() if a read now would block, but don't actually read anything */
  -API_EXPORT(void) bhalfduplex (BUFF *fb);
  +API_EXPORT(void) bhalfduplex(BUFF *fb);
  
  
  

Mime
View raw message