/*++
/* NAME
/* readlline 3
/* SUMMARY
/* read logical line
/* SYNOPSIS
/* #include <readlline.h>
/*
/* VSTRING *readllines(buf, fp, lineno, first_line)
/* VSTRING *buf;
/* VSTREAM *fp;
/* int *lineno;
/* int *first_line;
/*
/* VSTRING *readlline(buf, fp, lineno)
/* VSTRING *buf;
/* VSTREAM *fp;
/* int *lineno;
/* DESCRIPTION
/* readllines() reads one logical line from the named stream.
/* .IP "blank lines and comments"
/* Empty lines and whitespace-only lines are ignored, as
/* are lines whose first non-whitespace character is a `#'.
/* .IP "multi-line text"
/* A logical line starts with non-whitespace text. A line that
/* starts with whitespace continues a logical line.
/* .PP
/* The result value is the input buffer argument or a null pointer
/* when no input is found.
/*
/* readlline() is a backwards-compatibility wrapper.
/*
/* Arguments:
/* .IP buf
/* A variable-length buffer for input. The result is null terminated.
/* .IP fp
/* Handle to an open stream.
/* .IP lineno
/* A null pointer, or a pointer to an integer that is incremented
/* after reading a physical line.
/* .IP first_line
/* A null pointer, or a pointer to an integer that will contain
/* the line number of the first non-blank, non-comment line
/* in the result logical line.
/* DIAGNOSTICS
/* Warning: a continuation line that does not continue preceding text.
/* The invalid input is ignored, to avoid complicating caller code.
/* SECURITY
/* .ad
/* .fi
/* readlline() imposes no logical line length limit therefore it
/* should be used for reading trusted information only.
/* LICENSE
/* .ad
/* .fi
/* The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/* Wietse Venema
/* IBM T.J. Watson Research
/* P.O. Box 704
/* Yorktown Heights, NY 10598, USA
/*--*/

/* System library. */

#include <sys_defs.h>
#include <ctype.h>

/* Utility library. */

#include "msg.h"
#include "vstream.h"
#include "vstring.h"
#include "readlline.h"

#define STR(x) vstring_str(x)
#define LEN(x) VSTRING_LEN(x)
#define END(x) vstring_end(x)

/* readllines - read one logical line */

VSTRING *readllines(VSTRING *buf, VSTREAM *fp, int *lineno, int *first_line)
{
    int     ch;
    int     next;
    ssize_t start;
    char   *cp;
    int     my_lineno = 0, my_first_line, got_null = 0;

    VSTRING_RESET(buf);

    if (lineno == 0)
 lineno = &my_lineno;
    if (first_line == 0)
 first_line = &my_first_line;

    /*
     * Ignore comment lines, all whitespace lines, and empty lines. Terminate
     * at EOF or at the beginning of the next logical line.
     */
    for (;;) {
 /* Read one line, possibly not newline terminated. */
 start = LEN(buf);
 while ((ch = VSTREAM_GETC(fp)) != VSTREAM_EOF && ch != '\n') {
     VSTRING_ADDCH(buf, ch);
     if (ch == 0)
  got_null = 1;
 }
 if (ch == '\n' || LEN(buf) > start)
     *lineno += 1;
 /* Ignore comment line, all whitespace line, or empty line. */
 for (cp = STR(buf) + start; cp < END(buf) && ISSPACE(*cp); cp++)
      /* void */ ;
 if (cp == END(buf) || *cp == '#')
     vstring_truncate(buf, start);
 if (start == 0)
     *first_line = *lineno;
 /* Terminate at EOF or at the beginning of the next logical line. */
 if (ch == VSTREAM_EOF)
     break;
 if (LEN(buf) > 0) {
     if ((next = VSTREAM_GETC(fp)) != VSTREAM_EOF)
  vstream_ungetc(fp, next);
     if (next != '#' && !ISSPACE(next))
  break;
 }
    }
    VSTRING_TERMINATE(buf);

    /*
     * This code does not care about embedded null bytes, but callers do.
     */
    if (got_null) {
 const char *why = "text after null byte may be ignored";

 if (*first_line == *lineno)
     msg_warn("%s, line %d: %s",
       VSTREAM_PATH(fp), *lineno, why);
 else
     msg_warn("%s, line %d-%d: %s",
       VSTREAM_PATH(fp), *first_line, *lineno, why);
    }

    /*
     * Invalid input: continuing text without preceding text. Allowing this
     * would complicate "postconf -e", which implements its own multi-line
     * parsing routine. Do not abort, just warn, so that critical programs
     * like postmap do not leave behind a truncated table.
     */
    if (LEN(buf) > 0 && ISSPACE(*STR(buf))) {
 msg_warn("%s: logical line must not start with whitespace: \"%.30s%s\"",
   VSTREAM_PATH(fp), STR(buf),
   LEN(buf) > 30 ? "..." : "");
 return (readllines(buf, fp, lineno, first_line));
    }

    /*
     * Done.
     */
    return (LEN(buf) > 0 ? buf : 0);
}

 /*
  * Stand-alone test program.
  */
#ifdef TEST
#include <stdlib.h>
#include <string.h>
#include <msg.h>
#include <msg_vstream.h>
#include <stringops.h>
#include <vstream.h>
#include <vstring.h>

 /*
  * Test cases. Note: the input and exp_output fields are converted with
  * unescape(). Embedded null bytes must be specified as \\0.
  */
struct testcase {
    const char *name;
    const char *input;
    const char *exp_output;
    int     exp_first_line;
    int     exp_last_line;
};

static const struct testcase testcases[] = {
    {"leading space before non-comment",
 " abcde\nfghij\n",
 "fghij",
 2, 2
 /* Expect "logical line must not start with whitespace" */
    },
    {"leading space before leading comment",
 " #abcde\nfghij\n",
 "fghij",
 2, 2
    },
    {"leading #comment at beginning of line",
 "#abc\ndef",
 "def",
 2, 2,
    },
    {"empty line before non-comment",
 "\nabc\n",
 "abc",
 2, 2,
    },
    {"whitespace line before non-comment",
 " \nabc\n",
 "abc",
 2, 2,
    },
    {"missing newline at end of non-comment",
 "abc def",
 "abc def",
 1, 1,
    },
    {"missing newline at end of comment",
 "#abc def",
 "",
 1, 1,
    },
    {"embedded null, single-line",
 "abc\\0def",
 "abc\\0def",
 1, 1,
 /* Expect "line 1: text after null byte may be ignored" */
    },
    {"embedded null, multiline",
 "abc\\0\n def",
 "abc\\0 def",
 1, 2,
 /* Expect "line 1-2: text after null byte may be ignored" */
    },
    {"embedded null in comment",
 "#abc\\0\ndef",
 "def",
 2, 2,
 /* Expect "line 2: text after null byte may be ignored" */
    },
    {"multiline input",
 "abc\n def\n",
 "abc def",
 1, 2,
    },
    {"multiline input with embedded #comment after space",
 "abc\n #def\n ghi",
 "abc ghi",
 1, 3,
    },
    {"multiline input with embedded #comment flush left",
 "abc\n#def\n ghi",
 "abc ghi",
 1, 3,
    },
    {"multiline input with embedded whitespace line",
 "abc\n \n ghi",
 "abc ghi",
 1, 3,
    },
    {"multiline input with embedded empty line",
 "abc\n\n ghi",
 "abc ghi",
 1, 3,
    },
    {"multiline input with embedded #comment after space",
 "abc\n #def\n",
 "abc",
 1, 2,
    },
    {"multiline input with embedded #comment flush left",
 "abc\n#def\n",
 "abc",
 1, 2,
    },
    {"empty line at end of file",
 "\n",
 "",
 1, 1,
    },
    {"whitespace line at end of file",
 "\n \n",
 "",
 2, 2,
    },
    {"whitespace at end of file",
 "abc\n ",
 "abc",
 1, 2,
    },
};

int     main(int argc, char **argv)
{
    const struct testcase *tp;
    VSTRING *inp_buf = vstring_alloc(100);
    VSTRING *exp_buf = vstring_alloc(100);
    VSTRING *out_buf = vstring_alloc(100);
    VSTRING *esc_buf = vstring_alloc(100);
    VSTREAM *fp;
    int     last_line;
    int     first_line;
    int     pass;
    int     fail;

#define NUM_TESTS       sizeof(testcases)/sizeof(testcases[0])

    msg_vstream_init(basename(argv[0]), VSTREAM_ERR);
    util_utf8_enable = 1;

    for (pass = fail = 0, tp = testcases; tp < testcases + NUM_TESTS; tp++) {
 int     ok = 0;

 vstream_fprintf(VSTREAM_ERR, "RUN  %s\n", tp->name);
 unescape(inp_buf, tp->input);
 unescape(exp_buf, tp->exp_output);
 if ((fp = vstream_memopen(inp_buf, O_RDONLY)) == 0)
     msg_panic("open memory stream for reading: %m");
 vstream_control(fp, CA_VSTREAM_CTL_PATH("memory buffer"),
   CA_VSTREAM_CTL_END);
 last_line = 0;
 if (readllines(out_buf, fp, &last_line, &first_line) == 0) {
     VSTRING_RESET(out_buf);
     VSTRING_TERMINATE(out_buf);
 }
 if (LEN(out_buf) != LEN(exp_buf)) {
     msg_warn("unexpected output length, got: %ld, want: %ld",
       (long) LEN(out_buf), (long) LEN(exp_buf));
 } else if (memcmp(STR(out_buf), STR(exp_buf), LEN(out_buf)) != 0) {
     msg_warn("unexpected output: got: >%s<, want: >%s<",
       STR(escape(esc_buf, STR(out_buf), LEN(out_buf))),
       tp->exp_output);
 } else if (first_line != tp->exp_first_line) {
     msg_warn("unexpected first_line: got: %d, want: %d",
       first_line, tp->exp_first_line);
 } else if (last_line != tp->exp_last_line) {
     msg_warn("unexpected last_line: got: %d, want: %d",
       last_line, tp->exp_last_line);
 } else {
     vstream_fprintf(VSTREAM_ERR, "got and want: >%s<\n",
       tp->exp_output);
     ok = 1;
 }
 if (ok) {
     vstream_fprintf(VSTREAM_ERR, "PASS %s\n", tp->name);
     pass++;
 } else {
     vstream_fprintf(VSTREAM_ERR, "FAIL %s\n", tp->name);
     fail++;
 }
 vstream_fclose(fp);
    }
    vstring_free(inp_buf);
    vstring_free(exp_buf);
    vstring_free(out_buf);
    vstring_free(esc_buf);

    msg_info("PASS=%d FAIL=%d", pass, fail);
    return (fail > 0);
}

#endif