CVS diff for buff.c between 1.3 and 1.1:

/****
 * Reads a complete line from the socket into the provided buffer.  A
 * line is defined as a sequence of characters ending with a \n.  The \n
 * and, if present, the \r before it are stripped before being copied to
 * the buffer.
 *
 * @param in    The socket to read from
 * @param buf   The buffer to read into
 * @param nbyte Size of buffer; TODO: either remove or check this
 * @param timeout Give up after waiting this long
 *
 * @return The length of the line copied to the buffer.  If we timeout
 *      before reading an entire line then -1 * (chars read + 1) is returned
 *      and errno is set to EINTR.
 ****/
int cow_read_line(BUFF* in, char* buf, int nbyte, pth_event_t timeout) {
    int i, nrd;
    char* eol;
    
    /* If there's a socket error, just return */
    if (in->flags & B_RDERR)
        return -1;

    /* Is there a complete line in the buffer? */
    nrd = in->incnt;
    if (nrd > 0) {
        eol = strchr(in->inptr, '\n');
        if (eol != NULL) {
            int len = (eol - (char*)in->inptr);
            memcpy(buf, in->inptr, len);
            in->incnt = nrd - (len+1);
            in->inptr += (len+1);

            /* Null terminate the user buffer */
            if (len > 0 && buf[len - 1] == '\r') {
                buf[len - 1] = '\0';
                return len - 1;
            } else {
                buf[len] = '\0';
                return len;
            }
        }
    }

    /*
     * Need to read some more from the socket.  Start by copying what we've
     * already got.
     */
    if (nrd > 0) {
        memcpy(buf, in->inptr, nrd);
        buf = nrd + (char *) buf;
    }
    in->incnt = 0;
    in->inptr = in->inbase;
    in->inptr[0] = '\0';
    if (in->flags & B_EOF)
        return nrd;

    /*
     * Read as much as we can directly into the user buffer.  If we read more
     * than one line in, copy the excess back into the hold buffer.
     */
    i = read_with_errors(in, buf, nbyte, timeout);
    if (i <= 0 || errno == EINTR)
        return -1;
    eol = strchr(buf, '\n');
    if (eol != NULL) {
        int len;

        /* Copy excess into hold buffer */
        if (eol != buf + i - 1) {
            in->incnt = i - (eol - buf) - 1;
            memcpy(in->inbase, eol+1, in->incnt);
            in->inptr = in->inbase;
        } else {
            in->incnt = 0;
            in->inptr = in->inbase;
        }
        
        /* Add null-terminator to user buffer */
        len = eol - buf;
        if (len > 0 && buf[len-1] == '\r') {
            buf[len-1] = '\0';
            return len - 1;
        } else {
            buf[len] = '\0';
            return len;
        }
    }

    /*
     * We read some stuff, but we still haven't seen that newline...
     * Call ourselves recursively to get the rest.
     */
    return cow_read_line(in, buf+i, nbyte-i, timeout);
}

     

    if (rv < nbyte && error == EINTR) {
        printf("DEBUG: Writing timed out!\n");
    } else if (rv < nbyte) {
        printf("DEBUG: Error writing!\n");
    }