/*++
/* NAME
/* mystrtok 3
/* SUMMARY
/* safe tokenizer
/* SYNOPSIS
/* #include <stringops.h>
/*
/* char *mystrtok(bufp, delimiters)
/* char **bufp;
/* const char *delimiters;
/*
/* char *mystrtokq(bufp, delimiters, parens)
/* char **bufp;
/* const char *delimiters;
/* const char *parens;
/*
/* char *mystrtokdq(bufp, delimiters)
/* char **bufp;
/* const char *delimiters;
/*
/* char *mystrtok_cw(bufp, delimiters, blame)
/* char **bufp;
/* const char *delimiters;
/* const char *blame;
/*
/* char *mystrtokq_cw(bufp, delimiters, parens, blame)
/* char **bufp;
/* const char *delimiters;
/* const char *parens;
/* const char *blame;
/*
/* char *mystrtokdq_cw(bufp, delimiters, blame)
/* char **bufp;
/* const char *delimiters;
/* const char *blame;
/* DESCRIPTION
/* mystrtok() splits a buffer on the specified \fIdelimiters\fR.
/* Tokens are delimited by runs of delimiters, so this routine
/* cannot return zero-length tokens.
/*
/* mystrtokq() is like mystrtok() but will not split text
/* between balanced parentheses.  \fIparens\fR specifies the
/* opening and closing parenthesis (one of each).  The set of
/* \fIparens\fR must be distinct from the set of \fIdelimiters\fR.
/*
/* mystrtokdq() is like mystrtok() but will not split text
/* between double quotes. The backslash character may be used
/* to escape characters. The double quote and backslash
/* character must not appear in the set of \fIdelimiters\fR.
/*
/* The \fIbufp\fR argument specifies the start of the search; it
/* is updated with each call. The input is destroyed.
/*
/* The result value is the next token, or a null pointer when the
/* end of the buffer was reached.
/*
/* mystrtok_cw(), mystrtokq_cw(), and mystrtokdq_cw, log a
/* warning and return null when the result would look like
/* comment. The \fBblame\fR argument provides context for
/* warning messages. Specify a null pointer to disable the
/* comment check.
/* 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
/*
/* Wietse Venema
/* Google, Inc.
/* 111 8th Avenue
/* New York, NY 10011, USA
/*--*/

/* System library. */

#include <sys_defs.h>
#include <string.h>

/* Utility library. */

#include <msg.h>
#include <stringops.h>

/* mystrtok_warn - warn for #comment after other text */

static void mystrtok_warn(const char *start, const char *bufp, const char *blame)
{
    msg_warn("%s: #comment after other text is not allowed: %s %.20s...",
      blame, start, bufp);
}

/* mystrtok - ABI compatibility wrapper */

#undef mystrtok

char   *mystrtok(char **src, const char *sep)
{
    return (mystrtok_cw(src, sep, (char *) 0));
}

/* mystrtok - safe tokenizer */

char   *mystrtok_cw(char **src, const char *sep, const char *blame)
{
    char   *start = *src;
    char   *end;

    /*
     * Skip over leading delimiters.
     */
    start += strspn(start, sep);
    if (*start == 0) {
 *src = start;
 return (0);
    }

    /*
     * Separate off one token.
     */
    end = start + strcspn(start, sep);
    if (*end != 0)
 *end++ = 0;
    *src = end;

    if (blame && *start == '#') {
 mystrtok_warn(start, *src, blame);
 return (0);
    } else {
 return (start);
    }
}

/* mystrtokq - ABI compatibility wrapper */

#undef mystrtokq

char   *mystrtokq(char **src, const char *sep, const char *parens)
{
    return (mystrtokq_cw(src, sep, parens, (char *) 0));
}

/* mystrtokq_cw - safe tokenizer with quoting support */

char   *mystrtokq_cw(char **src, const char *sep, const char *parens,
               const char *blame)
{
    char   *start = *src;
    static char *cp;
    int     ch;
    int     level;

    /*
     * Skip over leading delimiters.
     */
    start += strspn(start, sep);
    if (*start == 0) {
 *src = start;
 return (0);
    }

    /*
     * Parse out the next token.
     */
    for (level = 0, cp = start; (ch = *(unsigned char *) cp) != 0; cp++) {
 if (ch == parens[0]) {
     level++;
 } else if (level > 0 && ch == parens[1]) {
     level--;
 } else if (level == 0 && strchr(sep, ch) != 0) {
     *cp++ = 0;
     break;
 }
    }
    *src = cp;

    if (blame && *start == '#') {
 mystrtok_warn(start, *src, blame);
 return (0);
    } else {
 return (start);
    }
}

/* mystrtokdq - ABI compatibility wrapper */

#undef mystrtokdq

char   *mystrtokdq(char **src, const char *sep)
{
    return (mystrtokdq_cw(src, sep, (char *) 0));
}

/* mystrtokdq_cw - safe tokenizer, double quote and backslash support */

char   *mystrtokdq_cw(char **src, const char *sep, const char *blame)
{
    char   *cp = *src;
    char   *start;

    /*
     * Skip leading delimiters.
     */
    cp += strspn(cp, sep);

    /*
     * Skip to next unquoted space or comma.
     */
    if (*cp == 0) {
 start = 0;
    } else {
 int     in_quotes;

 for (in_quotes = 0, start = cp; *cp; cp++) {
     if (*cp == '\\') {
  if (*++cp == 0)
      break;
     } else if (*cp == '"') {
  in_quotes = !in_quotes;
     } else if (!in_quotes && strchr(sep, *(unsigned char *) cp) != 0) {
  *cp++ = 0;
  break;
     }
 }
    }
    *src = cp;

    if (blame && start && *start == '#') {
 mystrtok_warn(start, *src, blame);
 return (0);
    } else {
 return (start);
    }
}

#ifdef TEST

 /*
  * Test program.
  */
#include "msg.h"
#include "mymalloc.h"

 /*
  * The following needs to be large enough to include a null terminator in
  * every testcase.expected field.
  */
#define EXPECT_SIZE 5

struct testcase {
    const char *action;
    const char *input;
    const char *expected[EXPECT_SIZE];
};
static const struct testcase testcases[] = {
    {"mystrtok", ""},
    {"mystrtok", "  foo  ", {"foo"}},
    {"mystrtok", "  foo  bar  ", {"foo", "bar"}},
    {"mystrtokq", ""},
    {"mystrtokq", "foo bar", {"foo", "bar"}},
    {"mystrtokq", "{ bar }  ", {"{ bar }"}},
    {"mystrtokq", "foo { bar } baz", {"foo", "{ bar }", "baz"}},
    {"mystrtokq", "foo{ bar } baz", {"foo{ bar }", "baz"}},
    {"mystrtokq", "foo { bar }baz", {"foo", "{ bar }baz"}},
    {"mystrtokdq", ""},
    {"mystrtokdq", "  foo  ", {"foo"}},
    {"mystrtokdq", "  foo  bar  ", {"foo", "bar"}},
    {"mystrtokdq", "  foo\\ bar  ", {"foo\\ bar"}},
    {"mystrtokdq", "  foo \\\" bar", {"foo", "\\\"", "bar"}},
    {"mystrtokdq", "  foo \" bar baz\"  ", {"foo", "\" bar baz\""}},
    {"mystrtok_cw", "#after text"},
    {"mystrtok_cw", "before-text #after text", {"before-text"}},
    {"mystrtokq_cw", "#after text"},
    {"mystrtokq_cw", "{ before text } #after text", "{ before text }"},
    {"mystrtokdq_cw", "#after text"},
    {"mystrtokdq_cw", "\"before text\" #after text", {"\"before text\""}},
};

int     main(void)
{
    const struct testcase *tp;
    char   *actual;
    int     pass;
    int     fail;
    int     match;
    int     n;

#define NUM_TESTS       sizeof(testcases)/sizeof(testcases[0])
#define STR_OR_NULL(s) ((s) ? (s) : "null")

    for (pass = fail = 0, tp = testcases; tp < testcases + NUM_TESTS; tp++) {
 char   *saved_input = mystrdup(tp->input);
 char   *cp = saved_input;

 msg_info("RUN test case %ld %s >%s<",
   (long) (tp - testcases), tp->action, tp->input);
#if 0
 msg_info("action=%s", tp->action);
 msg_info("input=%s", tp->input);
 for (n = 0; tp->expected[n]; tp++)
     msg_info("expected[%d]=%s", n, tp->expected[n]);
#endif

 for (n = 0; n < EXPECT_SIZE; n++) {
     if (strcmp(tp->action, "mystrtok") == 0) {
  actual = mystrtok(&cp, CHARS_SPACE);
     } else if (strcmp(tp->action, "mystrtokq") == 0) {
  actual = mystrtokq(&cp, CHARS_SPACE, CHARS_BRACE);
     } else if (strcmp(tp->action, "mystrtokdq") == 0) {
  actual = mystrtokdq(&cp, CHARS_SPACE);
     } else if (strcmp(tp->action, "mystrtok_cw") == 0) {
  actual = mystrtok_cw(&cp, CHARS_SPACE, "test");
     } else if (strcmp(tp->action, "mystrtokq_cw") == 0) {
  actual = mystrtokq_cw(&cp, CHARS_SPACE, CHARS_BRACE, "test");
     } else if (strcmp(tp->action, "mystrtokdq_cw") == 0) {
  actual = mystrtokdq_cw(&cp, CHARS_SPACE, "test");
     } else {
  msg_panic("invalid command: %s", tp->action);
     }
     if ((match = (actual && tp->expected[n]) ?
   (strcmp(actual, tp->expected[n]) == 0) :
   (actual == tp->expected[n])) != 0) {
  if (actual == 0) {
      msg_info("PASS test %ld", (long) (tp - testcases));
      pass++;
      break;
  }
     } else {
  msg_warn("expected: >%s<, got: >%s<",
    STR_OR_NULL(tp->expected[n]), STR_OR_NULL(actual));
  msg_info("FAIL test %ld", (long) (tp - testcases));
  fail++;
  break;
     }
 }
 if (n >= EXPECT_SIZE)
     msg_panic("need to increase EXPECT_SIZE");
 myfree(saved_input);
    }
    return (fail > 0);
}

#endif