#define AP_GETLINE_CRLF 2 /*Whether line ends must be in the form CR LF */

#define AP_GETLINE_CRLF 2 /* Whether line ends must be in the form CR LF */

#define AP_GETLINE_NOSPC_EOL 4 /* Whether to consume up to and including the

                                  end of line on APR_ENOSPC */

    for (;;) {

    do {

                rv = APR_ENOSPC;

                /* Before we die, let's fill the buffer up to its limit (i.e.

                goto cleanup;

                 * fall through with the remaining length, if any), setting

                 * saw_eol on LF to stop the outer loop appropriately; we may

                 * come back here once the buffer is filled (no LF seen), and

                 * either be done at that time or continue to wait for LF here

                 * if nospc_eol is set.

                 *

                 * But there is also a corner cases which we want to address,

                 * namely if the buffer is overrun by the final LF only (i.e.

                 * the CR fits in); this is not really an overrun since we'll

                 * strip the CR finally (and use it for NUL byte), but anyway

                 * we have to handle the case so that it's not returned to the

                 * caller as part of the truncated line (it's not!). This is

                 * easier to consider that LF is out of counting and thus fall

                 * through with no error (saw_eol is set to 2 so that we later

                 * ignore LF handling already done here), while folding and

                 * nospc_eol logics continue to work (or fail) appropriately.

                 */

                saw_eol = (str[len - 1] == APR_ASCII_LF);

                if (/* First time around */

                    saw_eol && !saw_nospc

                    /*  Single LF completing the buffered CR, */

                    && ((len == 1 && ((*s)[bytes_handled - 1] == APR_ASCII_CR))

                    /*  or trailing CRLF overuns by LF only */

                        || (len > 1 && str[len - 2] == APR_ASCII_CR

                            && n - bytes_handled + 1 == len))) {

                    /* In both cases *last_char is (to be) the CR stripped by

                     * later 'bytes_handled = last_char - *s'.

                     */

                    saw_eol = 2;

                }

                else {

                    /* In any other case we'd lose data. */

                    rv = APR_ENOSPC;

                    saw_nospc = 1;

                }

                len = n - bytes_handled;

                if (!len) {

                    if (saw_eol) {

                        break;

                    }

                    if (nospc_eol) {

                        continue;

                    }

                    goto cleanup;

                }

            break;

            saw_eol = 1;

     * if the last-but-one character is a CR, terminate there */

     * if the last-but-one character is a CR, terminate there.

    if (last_char > *s && last_char[-1] == APR_ASCII_CR) {

     * LF is handled above (not accounted) when saw_eol == 2,

        last_char--;

     * the last char is CR to terminate at still.

     */

    if (saw_eol < 2) {

        if (last_char > *s && last_char[-1] == APR_ASCII_CR) {

            last_char--;

        }

        else if (crlf) {

            rv = APR_EINVAL;

            goto cleanup;

        }

        (*s)[bytes_handled] = '\0';

        (*s)[*read] = '\0';

    }

    *read = bytes_handled;

    if (rv != APR_SUCCESS) {

        /* PR#43039: We shouldn't accept NULL bytes within the line */

        return rv;

        bytes_handled = strlen(*s);

        if (bytes_handled < *read) {

            *read = bytes_handled;

            if (rv == APR_SUCCESS) {

                rv = APR_EINVAL;

            }

        }

    return rv;

    /* PR#43039: We shouldn't accept NULL bytes within the line */

    if (strlen(*s) < bytes_handled) {

        return APR_EINVAL;

    }

    return APR_SUCCESS;