#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-features.h>

#include <net-snmp/net-snmp-includes.h>

#include <stdio.h>

#include <ctype.h>

#if HAVE_STDLIB_H

#   include <stdlib.h>

#endif

#if HAVE_UNISTD_H

#   include <unistd.h>

#endif

#if HAVE_STRING_H

#   include <string.h>

#else

#  include <strings.h>

#endif

#include <sys/types.h>

#if HAVE_LIMITS_H

#   include <limits.h>

#endif

#if HAVE_SYS_PARAM_H

#   include <sys/param.h>

#endif

#ifdef HAVE_SYS_STAT_H

#   include <sys/stat.h>

#endif

#ifdef HAVE_FCNTL_H

#   include <fcntl.h>

#endif

#include <errno.h>

#if HAVE_DMALLOC_H

#  include <dmalloc.h>

#endif

#include <net-snmp/types.h>

#include <net-snmp/library/snmp_debug.h>

#include <net-snmp/library/container.h>

#include <net-snmp/library/file_utils.h>

#include <net-snmp/library/text_utils.h>

netsnmp_feature_child_of(text_utils, libnetsnmp)

netsnmp_feature_provide(text_utils)

#ifdef NETSNMP_FEATURE_REQUIRE_TEXT_UTILS

netsnmp_feature_require(file_utils)

#endif /* NETSNMP_FEATURE_REQUIRE_TEXT_UTILS */

#ifndef NETSNMP_FEATURE_REMOVE_TEXT_UTILS

/*------------------------------------------------------------------

 *

 * Prototypes

 *

 */

/*

 * parse methods

 */

static void

_pm_save_index_string_string(FILE *f, netsnmp_container *cin,

                             int flags);

static void

_pm_save_everything(FILE *f, netsnmp_container *cin, int flags);

static void

_pm_user_function(FILE *f, netsnmp_container *cin,

                  netsnmp_line_process_info *lpi, int flags);

/*

 * line processors

 */

static int

_process_line_tvi(netsnmp_line_info *line_info, void *mem,

                  struct netsnmp_line_process_info_s* lpi);

/*------------------------------------------------------------------

 *

 * Text file processing functions

 *

 */

/**

 * process text file, reading into extras

 */

netsnmp_container *

netsnmp_file_text_parse(netsnmp_file *f, netsnmp_container *cin,

                        int parse_mode, u_int flags, void *context)

{

    netsnmp_container *c = cin;

    FILE              *fin;

    int                rc;

    if (NULL == f)

        return NULL;

    if ((NULL == c) && (!(flags & PM_FLAG_NO_CONTAINER))) {

        c = netsnmp_container_find("text_parse:binary_array");

        if (NULL == c)

            return NULL;

    }

    rc = netsnmp_file_open(f);

    if (rc < 0) { /** error already logged */

        if ((NULL !=c) && (c != cin))

            CONTAINER_FREE(c);

        return NULL;

    }

    /*

     * get a stream from the file descriptor. This DOES NOT rewind the

     * file (if fd was previously opened).

     */

    fin = fdopen(f->fd, "r");

    if (NULL == fin) {

        if (NS_FI_AUTOCLOSE(f->ns_flags))

            close(f->fd);

        if ((NULL !=c) && (c != cin))

            CONTAINER_FREE(c);

        return NULL;

    }

    switch (parse_mode) {

        case PM_SAVE_EVERYTHING:

            _pm_save_everything(fin, c, flags);

            break;

        case PM_INDEX_STRING_STRING:

            _pm_save_index_string_string(fin, c, flags);

            break;

        case PM_USER_FUNCTION:

            if (NULL != context)

                _pm_user_function(fin, c, (netsnmp_line_process_info*)context,

                                  flags);

            break;

        default:

            snmp_log(LOG_ERR, "unknown parse mode %d\n", parse_mode);

            break;

    }

    /*

     * close the stream, which will have the side effect of also closing

     * the file descriptor, so we need to reset it.

     */

    fclose(fin);

    f->fd = -1;

    return c;

}

netsnmp_feature_child_of(text_token_container_from_file, netsnmp_unused)

#ifndef NETSNMP_FEATURE_REMOVE_TEXT_TOKEN_CONTAINER_FROM_FILE

netsnmp_container *

netsnmp_text_token_container_from_file(const char *file, u_int flags,

                                       netsnmp_container *cin, void *context)

{

    netsnmp_line_process_info  lpi;

    netsnmp_container         *c = cin, *c_rc;

    netsnmp_file              *fp;

    if (NULL == file)

        return NULL;

    /*

     * allocate file resources

     */

    fp = netsnmp_file_fill(NULL, file, O_RDONLY, 0, 0);

    if (NULL == fp) /** msg already logged */

        return NULL;

    memset(&lpi, 0x0, sizeof(lpi));

    lpi.mem_size = sizeof(netsnmp_token_value_index);

    lpi.process = _process_line_tvi;

    lpi.user_context = context;

    if (NULL == c) {

        c = netsnmp_container_find("string:binary_array");

        if (NULL == c) {

            snmp_log(LOG_ERR,"malloc failed\n");

            netsnmp_file_release(fp);

            return NULL;

        }

    }

    c_rc = netsnmp_file_text_parse(fp, c, PM_USER_FUNCTION, 0, &lpi;;

    /*

     * if we got a bad return and the user didn't pass us a container,

     * we need to release the container we allocated.

     */

    if ((NULL == c_rc) && (NULL == cin)) {

        CONTAINER_FREE(c);

        c = NULL;

    }

    else

        c = c_rc;

    /*

     * release file resources

     */

    netsnmp_file_release(fp);

    return c;

}

#endif /* NETSNMP_FEATURE_REMOVE_TEXT_TOKEN_CONTAINER_FROM_FILE */

/*------------------------------------------------------------------

 *

 * Text file process modes helper functions

 *

 */

/**

 * @internal

 * parse mode: save everything

 */

static void

_pm_save_everything(FILE *f, netsnmp_container *cin, int flags)

{

    char               line[STRINGMAX], *ptr;

    size_t             len;

    netsnmp_assert(NULL != f);

    netsnmp_assert(NULL != cin);

    while (fgets(line, sizeof(line), f) != NULL) {

        ptr = line;

        len = strlen(line) - 1;

        if (line[len] == '\n')

            line[len] = 0;

        /*

         * save blank line or comment?

         */

        if (flags & PM_FLAG_SKIP_WHITESPACE) {

            if (NULL == (ptr = skip_white(ptr)))

                continue;

        }

        ptr = strdup(line);

        if (NULL == ptr) {

            snmp_log(LOG_ERR,"malloc failed\n");

            break;

        }

        CONTAINER_INSERT(cin,ptr);

    }

}

/**

 * @internal

 * parse mode:

 */

static void

_pm_save_index_string_string(FILE *f, netsnmp_container *cin,

                             int flags)

{

    char                        line[STRINGMAX], *ptr;

    netsnmp_token_value_index  *tvi;

    size_t                      count = 0, len;

    netsnmp_assert(NULL != f);

    netsnmp_assert(NULL != cin);

    while (fgets(line, sizeof(line), f) != NULL) {

        ++count;

        ptr = line;

        len = strlen(line) - 1;

        if (line[len] == '\n')

            line[len] = 0;

        /*

         * save blank line or comment?

         */

        if (flags & PM_FLAG_SKIP_WHITESPACE) {

            if (NULL == (ptr = skip_white(ptr)))

                continue;

        }

        tvi = SNMP_MALLOC_TYPEDEF(netsnmp_token_value_index);

        if (NULL == tvi) {

            snmp_log(LOG_ERR,"malloc failed\n");

            break;

        }

        /*

         * copy whole line, then set second pointer to

         * after token. One malloc, 2 strings!

         */

        tvi->index = count;

        tvi->token = strdup(line);

        if (NULL == tvi->token) {

            snmp_log(LOG_ERR,"malloc failed\n");

            free(tvi);

            break;

        }

        tvi->value.cp = skip_not_white(tvi->token);

        if (NULL != tvi->value.cp) {

            *(tvi->value.cp) = 0;

            ++(tvi->value.cp);

        }

        CONTAINER_INSERT(cin, tvi);

    }

}

/**

 * @internal

 * parse mode:

 */

static void

_pm_user_function(FILE *f, netsnmp_container *cin,

                  netsnmp_line_process_info *lpi, int flags)

{

    char                        buf[STRINGMAX];

    netsnmp_line_info           li;

    void                       *mem = NULL;

    int                         rc;

    netsnmp_assert(NULL != f);

    netsnmp_assert(NULL != cin);

    /*

     * static buf, or does the user want the memory?

     */

    if (flags & PMLP_FLAG_ALLOC_LINE) {

        if (0 != lpi->line_max)

            li.line_max =  lpi->line_max;

        else

            li.line_max = STRINGMAX;

        li.line = (char *)calloc(li.line_max, 1);

        if (NULL == li.line) {

            snmp_log(LOG_ERR,"malloc failed\n");

            return;

        }

    }

    else {

        li.line = buf;

        li.line_max = sizeof(buf);

    }

    li.index = 0;

    while (fgets(li.line, li.line_max, f) != NULL) {

        ++li.index;

        li.start = li.line;

        li.line_len = strlen(li.line) - 1;

        if ((!(lpi->flags & PMLP_FLAG_LEAVE_NEWLINE)) &&

            (li.line[li.line_len] == '\n'))

            li.line[li.line_len] = 0;

        /*

         * save blank line or comment?

         */

        if (!(lpi->flags & PMLP_FLAG_PROCESS_WHITESPACE)) {

            if (NULL == (li.start = skip_white(li.start)))

                continue;

        }

        /*

         *  do we need to allocate memory for the use?

         * if the last call didn't use the memory we allocated,

         * re-use it. Otherwise, allocate new chunk.

         */

        if ((0 != lpi->mem_size) && (NULL == mem)) {

            mem = calloc(lpi->mem_size, 1);

            if (NULL == mem) {

                snmp_log(LOG_ERR,"malloc failed\n");

                break;

            }

        }

        /*

         * do they want a copy ot the line?

         */

        if (lpi->flags & PMLP_FLAG_STRDUP_LINE) {

            li.start = strdup(li.start);

            if (NULL == li.start) {

                snmp_log(LOG_ERR,"malloc failed\n");

                break;

            }

        }

        else if (lpi->flags & PMLP_FLAG_ALLOC_LINE) {

            li.start = li.line;

        }

        /*

         * call the user function. If the function wants to save

         * the memory chunk, insert it in the container, the clear

         * pointer so we reallocate next time.

         */

        li.start_len = strlen(li.start);

        rc = (*lpi->process)(&li, mem, lpi);

        if (PMLP_RC_MEMORY_USED == rc) {

            if (!(lpi->flags & PMLP_FLAG_NO_CONTAINER))

                CONTAINER_INSERT(cin, mem);

            mem = NULL;

            if (lpi->flags & PMLP_FLAG_ALLOC_LINE) {

	        li.line = (char *)calloc(li.line_max, 1);

                if (NULL == li.line) {

                    snmp_log(LOG_ERR,"malloc failed\n");

                    break;

                }

            }

        }

        else if (PMLP_RC_MEMORY_UNUSED == rc ) {

            /*

             * they didn't use the memory. if li.start was a strdup, we have

             * to release it. leave mem, we can re-use it (its a fixed size).

             */

            if (lpi->flags & PMLP_FLAG_STRDUP_LINE)

                free(li.start); /* no point in SNMP_FREE */

        }

        else {

            if (PMLP_RC_STOP_PROCESSING != rc )

                snmp_log(LOG_ERR, "unknown rc %d from text processor\n", rc);

            break;

        }

    }

    SNMP_FREE(mem);

}

/*------------------------------------------------------------------

 *

 * Test line process helper functions

 *

 */

/**

 * @internal

 * process token value index line

 */

static int

_process_line_tvi(netsnmp_line_info *line_info, void *mem,

                  struct netsnmp_line_process_info_s* lpi)

{

    netsnmp_token_value_index *tvi = (netsnmp_token_value_index *)mem;

    char                      *ptr;

    /*

     * get token

     */

    ptr = skip_not_white(line_info->start);

    if (NULL == ptr) {

        DEBUGMSGTL(("text:util:tvi", "no value after token '%s'\n",

                    line_info->start));

        return PMLP_RC_MEMORY_UNUSED;

    }

    /*

     * null terminate, search for value;

     */

    *(ptr++) = 0;

    ptr = skip_white(ptr);

    if (NULL == ptr) {

        DEBUGMSGTL(("text:util:tvi", "no value after token '%s'\n",

                    line_info->start));

        return PMLP_RC_MEMORY_UNUSED;

    }

    /*

     * get value

     */

    switch((int)(intptr_t)lpi->user_context) {

        case PMLP_TYPE_UNSIGNED:

            tvi->value.ul = strtoul(ptr, NULL, 0);

            if ((errno == ERANGE) && (ULONG_MAX == tvi->value.ul))

                snmp_log(LOG_WARNING,"value overflow\n");

            break;

        case PMLP_TYPE_INTEGER:

            tvi->value.sl = strtol(ptr, NULL, 0);

            if ((errno == ERANGE) &&

                ((LONG_MAX == tvi->value.sl) ||

                 (LONG_MIN == tvi->value.sl)))

                snmp_log(LOG_WARNING,"value over/under-flow\n");

            break;

        case PMLP_TYPE_STRING:

            tvi->value.cp = strdup(ptr);

            break;

        case PMLP_TYPE_BOOLEAN:

            if (isdigit((unsigned char)(*ptr)))

                tvi->value.ul = strtoul(ptr, NULL, 0);

            else if (strcasecmp(ptr,"true") == 0)

                tvi->value.ul = 1;

            else if (strcasecmp(ptr,"false") == 0)

                tvi->value.ul = 0;

            else {

                snmp_log(LOG_WARNING,"bad value for boolean\n");

                return PMLP_RC_MEMORY_UNUSED;

            }

            break;

        default:

            snmp_log(LOG_ERR,"unsupported value type %d\n",

                     (int)(intptr_t)lpi->user_context);

            break;

    }

    /*

     * save token and value

     */

    tvi->token = strdup(line_info->start);

    tvi->index = line_info->index;

    return PMLP_RC_MEMORY_USED;

}

#else  /* ! NETSNMP_FEATURE_REMOVE_TEXT_UTILS */

netsnmp_feature_unused(text_utils);

#endif /* ! NETSNMP_FEATURE_REMOVE_TEXT_UTILS */