Vyššie na [Platon] / ep / src

Changed URL from www.platon.sk to platon.sk.

/*
 * ep - extended pipelining
 *
 * conf.c - command line and config file parsing implementation
 * ____________________________________________________________
 *
 * Developed by Ondrej Jombik <nepto@platon.sk>
 *          and Lubomir Host <rajo@platon.sk>
 * Copyright (c) 2000-2003 Platon SDG, http://platon.sk/
 * All rights reserved.
 *
 * See README file for more information about this software.
 * See COPYING file for license information.
 *
 * Download the latest version from
 * http://platon.sk/projects/ep/
 */

/* $Platon: ep/src/conf.c,v 1.40 2003/05/03 09:58:19 nepto Exp $ */

/* Includes {{{ */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#include <platon/cfg+.h>
#include "platon-str.h"

#include "fd.h"
#include "proctable.h"
#include "proclink.h"
#include "message.h"
#include "conf.h"
/* }}} */

/* Static variables {{{ */
static char *section_boundaries[2]       = {"[", "]"};
static char *name_vs_stream_separator[4] = {".", "..", "-", NULL};
static char *global_str                  = "Global";
static char *process_str                 = "Process";
/* }}} */

/* Options structures (used only with libcfg+ context) {{{ */
static struct conf_struct_global global_cfg;
static struct conf_struct_process process_cfg;
/* }}} */

/* Options contexts {{{ */
static CFG_CONTEXT global_context = NULL;
static CFG_CONTEXT process_context = NULL;
/* }}} */

/* Global options {{{ */
static struct cfg_option global_options[] = { /* } */
{ "help", 'h', NULL, CFG_BOOLEAN + CFG_MULTI, (void *) &(global_cfg.help), 0 },
{"quiet", 'q', "quiet", CFG_BOOLEAN, (void *) &(global_cfg.quiet), 0},
{"verbose", 'v', "verbose", CFG_BOOLEAN + CFG_MULTI, (void *) &(global_cfg.verbose), 0},
{"config-file", 'f', NULL, CFG_STRING + CFG_MULTI, (void *) &(global_cfg.config_file), 0},
{"disable-global-config",'\0',NULL,CFG_BOOLEAN,(void*)&(global_cfg.disable_global_config),0},
{"disable-user-config",'\0',NULL,CFG_BOOLEAN,(void*)&(global_cfg.disable_user_config),0},
{"case-insensitive-names",'\0',NULL,CFG_BOOLEAN,(void*)&(global_cfg.case_insensitive_names),0},
{"fast-data-transfer",'F',"fast data transfer",CFG_BOOLEAN,(void*)&(global_cfg.fast_data_transfer),0},
    CFG_END_OF_LIST
    }; /* }}} */

/* Process options {{{ */
static struct cfg_option process_options[] = { /* } */
{"nice", 'N', "nice", CFG_INT, (void *) &(process_cfg.nice), 0},
{"name", 'n', "name", CFG_STRING+CFG_MULTI_SEPARATED, (void *) &(process_cfg.name), 0},
{"input", 'i', "input", CFG_STRING+CFG_MULTI_SEPARATED, (void *) &(process_cfg.fd_str[0]), 0},
{"output", 'o', "output", CFG_STRING+CFG_MULTI_SEPARATED, (void *)&(process_cfg.fd_str[1]),0},
{"errput", 'e', "errput", CFG_STRING+CFG_MULTI_SEPARATED, (void *)&(process_cfg.fd_str[2]),0},
{NULL, '\0', "command", CFG_LEFTOVER_ARGS+CFG_STRING+CFG_MULTI_SEPARATED,
    (void *)&(process_cfg.argv),0},
    CFG_END_OF_LIST
    }; /* }}} */

/* Static function declarations {{{ */
static void print_cfg_error(const CFG_CONTEXT con);
static int test_process_cfg_argv(const char *config_filename);
static char *get_user_config_filename(void);
static void clear_global_cfg(void);
static void clear_process_cfg(void);
static int check_context(CFG_CONTEXT *context, struct cfg_option options[]);
static int is_cfgfile_section(char *section_str);
static void free_global(struct conf_struct_global **global);
static void free_processes(struct conf_struct_process ***processes);
static int get_processes_index_by_name(
        struct conf_struct_process **processes, char *name);
static int add_global_cfg_to_global(struct conf_struct_global **global);
static int add_process_cfg_to_processes(
        struct conf_struct_process ***processes,
        int *size);
static int add_processes_to_processes(
        struct conf_struct_process ***dest_processes,
        struct conf_struct_process **src_processes);
static int add_processes_to_proctable(
        PROCTABLE *p_ptbl,
        struct conf_struct_process **processes,
        int start_idx_size, int *start_idx);
/* }}} */

/*
 * Function definitions
 */

/*    PARSING SCHEME (do not delete) {{{
 *    ------------------------------
 *
 *    conf_cmdline_parse_process();
 *    if (error) {
 *        conf_cmdline_parse_global();
 *        if (err) {
 *            fail;
 *        }
 *
 *        if (config_file) {
 *            conf_cfgfile_parse_all();
 *        }
 *    }
 *
 *    while(1) {
 *
 *        conf_cmdline_parse_process();
 *
 *        if (error) {
 *            fail;
 *        }
 *    }
 */ /* }}} */

    int
conf_init(void)
{/* {{{ */
    return check_context(&global_context, global_options)
        && check_context(&process_context, process_options);
} /* }}} */

    void
conf_destroy(void)
{ /* {{{ */
    if (global_context != NULL)
        cfg_free_context(global_context);
    if (process_context != NULL)
        cfg_free_context(process_context);
} /* }}} */

    PROCTABLE
conf_parse_all(argc, argv)
    int    argc;
    char   **argv;
{ /* {{{ */
    register int ret, i;
    struct conf_struct_global *global;
    struct conf_struct_global *global_work;
    struct conf_struct_process **processes;
    struct conf_struct_process **processes_work;

    PROCTABLE ptbl;

    int *start_idx;
    int start_idx_size;

    global    = NULL;
    processes = NULL;
    ret = conf_cmdline_parse(argc - 1, argv + 1, &global, &processes);

    if (ret != CFG_OK) {
        /* TODO: better error information */
        /* print_cfg_error(con, ret); */
        if (ret == CFG_ERR_NOMEM)
            msg_error_print("not enough memory for command line parsing\n");
        /* XXX: free structures */
        free_global(&global);
        free_processes(&processes);
        return NULL;
    }

    if (global->help) {
        msg_usage_print();
        free_global(&global);
        free_processes(&processes);
        return NULL;
    }

    for (start_idx_size = 0; global->config_file != NULL
            && global->config_file[start_idx_size] != NULL;
            start_idx_size++)
        ;

    start_idx_size += 3; /* command line, global config, homedir config */
    start_idx = (int *) malloc(start_idx_size * sizeof(int));

    if (start_idx == NULL) {
        msg_error_print("not enough memory for parsing indexes\n");
        /* XXX: free structures */
        free_global(&global);
        free_processes(&processes);
        return NULL;
    }

    start_idx[0] = 0;

    for (i = 0; i < start_idx_size - 1; i++) {

        register char *filename;

        if ((i == 0 && global->disable_global_config)
                || (i == 1 && global->disable_user_config))
            continue;

        filename = i <= 0 ? conf_global_filename
            : i == 1 ? get_user_config_filename()
            : global->config_file[i - 2];

        if (/* i == 1 && */ filename == NULL) {
            msg_error_print("not enough memory for filename buffer\n");
            /* XXX: free structures */
            free(start_idx);
            free_global(&global);
            free_processes(&processes);
            return NULL;
        }

#if DEBUG
        msg_debug_print("conf_parse_all(): parsing file '%s'\n", filename);
#endif

        global_work    = NULL;
        processes_work = NULL;
        ret = conf_cfgfile_parse(filename, &global_work, &processes_work);

        /* TODO: Progressive config file type reporting in error messages.
           There are three types: global, local/user, user defined. */

        if (ret != CFG_OK
                && (i >= 2 || (i < 2 && ret != CFG_ERR_FILE_NOT_FOUND))) {
            /* TODO: better error information */
            /* print_cfg_error(con, ret); */
            if (ret == CFG_ERR_NOMEM)
                msg_error_print("not enough memory for config file parsing\n");
            if (ret == CFG_ERR_FILE_NOT_FOUND)
                msg_error_print("file '%s' not found\n", filename);
            /* msg_error_print("config file '%s' parsing error %d\n",
               filename, ret); */
            /* XXX: free structures */
            if (i == 1)
                free(filename);
            free(start_idx);
            free_global(&global_work);
            free_processes(&processes_work);
            free_global(&global);
            free_processes(&processes);
            return NULL;
        }

        for (start_idx[i + 1] = 0; processes_work != NULL
                && processes_work[start_idx[i + 1]] != NULL;
                start_idx[i + 1]++)
            ;
        start_idx[i + 1] += start_idx[i];

        if (! add_processes_to_processes(&processes, processes_work)) {
            msg_error_print("not enough memory for config file '%s'"
                    "process table merging\n", filename);
            /* XXX: free structures */
            if (i == 1)
                free(filename);
            free(start_idx);
            free_global(&global_work);
            free_processes(&processes_work);
            free_global(&global);
            free_processes(&processes);
            return NULL;
        }

        if (i == 1)
            free(filename);

        free(global_work);
        free(processes_work);
    }

#if DEBUG
    {
        register int dbg_i;
        register char *names;
        register char *argvs;

        msg_debug_print("conf_parse_all(): ret = %d\n", ret);

        msg_debug_print("verbose = %d\n", global->verbose);

        for (dbg_i = 0; processes != NULL && processes[dbg_i] != NULL;
                dbg_i++) {

            if (processes[dbg_i]->name != NULL)
                names = PLATON_FUNC(strdyn_implode_str)
                    (processes[dbg_i]->name, ", ");
            else
                names = strdup("-- N/A --");

            if (processes[dbg_i]->argv != NULL)
                argvs = PLATON_FUNC(strdyn_implode_str)
                    (processes[dbg_i]->argv, " ");
            else
                argvs = strdup("-- N/A --");

            msg_debug_print("Process %d\n", dbg_i);
            msg_debug_print("  NAMES: %s\n", names);
            msg_debug_print("  ARGVS: %s\n", argvs);

            free(names);
            free(argvs);
        }

        msg_debug_print("Indexes:\n");
        for (dbg_i = 0; dbg_i < start_idx_size; dbg_i++)
            msg_debug_print("  %d -> %d\n", dbg_i, start_idx[dbg_i]);
    }
#endif

    /*
     * Here are proccesses going to be added into new PROCTABLE.
     */

    if ((ptbl = proctable_create(0)) == NULL ||
            proctable_add_std_process(&ptbl) < 0) {
        msg_error_print("not enough memory\n");
        /* XXX: free structures */
        free(start_idx);
        free_global(&global);
        free_processes(&processes);
        return NULL;
    }

    if (add_processes_to_proctable(&ptbl, processes,
                start_idx_size, start_idx) < 0) {
        /* msg_error_print("not enough memory\n"); */
        /* XXX: free structures */
        proctable_destroy(&ptbl);
        free(start_idx);
        free_global(&global);
        free_processes(&processes);
        return NULL;
    }

    cfg = *global;

    free(start_idx);
    free_global(&global);
    free_processes(&processes);

    return ptbl;
} /* }}} */

    int
conf_cfgfile_parse(filename, global, processes)
    char                       *filename;
    struct conf_struct_global  **global;
    struct conf_struct_process ***processes;
{ /* {{{ */
    register int ret;
    int processes_size;
    CFG_CONTEXT cur_context;

    *processes = NULL;
    processes_size = 0;

    clear_global_cfg();
    clear_process_cfg();

    cfg_reset_context(global_context);
    cfg_reset_context(process_context);

    /* Start at first line (0) and parse to end (-1) */
    cfg_set_cfgfile_context(global_context, 0, -1, filename);
    cfg_set_cfgfile_context(process_context, 0, -1, filename);

    for (cur_context = global_context; ; ) {

        ret = cfg_parse(cur_context);

        if (ret != CFG_ERR_STOP_STR) {
#if DEBUG
            msg_debug_print("detected %s error %d in <%s>\n",
                    cur_context == process_context ? "process" : "global",
                    ret, cfg_get_cur_opt(cur_context));
#endif
            break;
        }
        else { /* Section boundaries detected */
            register int   section_no;
            register char *section_str;

            section_str = cfg_get_cur_opt(cur_context);
            section_no  = is_cfgfile_section(section_str);

            if (section_no > 0) {
                if (cur_context == process_context) {
                    if (! test_process_cfg_argv(filename)) {
                        ret = CFG_ERROR_STOP_STR;
                        cur_context = NULL;
                        break;
                    }
                    /* Adding to processes array */
                    if (! add_process_cfg_to_processes(processes,
                                &processes_size))
                        return CFG_ERR_NOMEM;

                    clear_process_cfg();
                }

                /* If section name is correct, set appropriate context and
                   continue with parsing on next line (it is that '+ 1'). */

                if (section_no == 1) { /* [Global] section */
                    cfg_set_cfgfile_context(global_context,
                            cfg_get_cur_idx(cur_context) + 1, -1, NULL);
                    cur_context = global_context;
                }
                else { /* [Process] section */
                    cfg_set_cfgfile_context(process_context,
                            cfg_get_cur_idx(cur_context) + 1, -1, NULL);
                    cur_context = process_context;
                }
            }
            else {
                msg_error_print("unknown section '%s' in config file '%s'\n",
                        section_str, filename);
                ret = CFG_ERROR_STOP_STR;
                cur_context = NULL;
                break;
            }
        }
    }

    /* Set returning parameters. */
    if (ret == CFG_OK) {
        if (cur_context == process_context) {
            if (! test_process_cfg_argv(filename))
                ret = CFG_ERROR_STOP_STR;
            else if (! add_process_cfg_to_processes(processes, &processes_size))
                return CFG_ERR_NOMEM;
        }
    }

    if (! add_global_cfg_to_global(global))
        return CFG_ERR_NOMEM;

    switch (ret) {
        case CFG_OK:
        case CFG_ERR_NOMEM:
        case CFG_ERR_FILE_NOT_FOUND:
        case CFG_ERR_STOP_STR_FOUND:
            break;
        default:
            print_cfg_error(cur_context);
            break;
    };

    return ret;
} /* }}} */

    int
conf_cmdline_parse(argc, argv, global, processes)
    int                        argc;
    char                       **argv;
    struct conf_struct_global  **global;
    struct conf_struct_process ***processes;
{ /* {{{ */
    register int ret = CFG_OK, first_loop, index;
    int processes_size;
    CFG_CONTEXT cur_context;

    *processes = NULL;
    processes_size = 0;

    clear_global_cfg();
    clear_process_cfg();

    cfg_reset_context(global_context);
    cfg_reset_context(process_context);

    cfg_set_cmdline_context(global_context, 0, argc, argv);
    cfg_set_cmdline_context(process_context, 0, argc, argv);

    /*
     * Yokotasi intelligent parser. :-)
     */

    for (cur_context = process_context, first_loop = 1, index = 0;
            index < argc; first_loop = 0) {

        ret = cfg_parse(cur_context);

        if (ret < 0 && ret != CFG_ERR_STOP_STR_FOUND) {
            if (! first_loop)
                break;

            cur_context = global_context;
            /* not needed:
               cfg_set_cmdline_context_by_argc(cur_context, argc, argv); */
            continue;
        }
        else if (ret == CFG_ERR_STOP_STR_FOUND) {
            register int cur_idx = cfg_get_cur_idx(cur_context);

            if (cur_idx - index < 1 && ! first_loop) {
                msg_error_print("double process separator '--'"
                        " on command line\n");
                break;
            }

            if (cur_idx + 1 >= argc) {
                msg_error_print("misplaced process separator '--'"
                        " at the end of command line\n");
                break;
            }

            if (cur_context == process_context) {
                if (first_loop && process_cfg.argv == NULL) {
                    /* empty global options (./ep -- ...) are allowed */
                }
                else {
                    if (! test_process_cfg_argv(NULL)) {
                        ret = CFG_ERROR_STOP_STR;
                        break;
                    }

                    /* Adding to processes array */
                    if (! add_process_cfg_to_processes(processes,
                                &processes_size))
                        return CFG_ERR_NOMEM;

                }

                clear_process_cfg();
            }

            index = cur_idx + 1;
            cur_context = process_context;
            cfg_set_cmdline_context(cur_context, index, argc - index, argv);
        }
        else { /* ret == CFG_OK */
            break;
        }
    }

    /* Set returning parameters. */
    if (cur_context == process_context
            && ret == CFG_OK
            && cfg_get_cur_idx(cur_context) > 0) {
        if (! test_process_cfg_argv(NULL))
            ret = CFG_ERROR_STOP_STR;
        else if (! add_process_cfg_to_processes(processes, &processes_size))
            return CFG_ERR_NOMEM;
    }

    if (! add_global_cfg_to_global(global))
        return CFG_ERR_NOMEM;

    switch (ret) {
        case CFG_OK:
        case CFG_ERR_NOMEM:
        case CFG_ERR_STOP_STR_FOUND:
            break;
        default:
            print_cfg_error(cur_context);
            break;
    };

    return ret;
} /* }}} */

/*
 * Static function definitions
 */

    static void
print_cfg_error(con)
    const CFG_CONTEXT con;
{ /* {{{ */
    register char *s;

    if ((s = cfg_get_error_str(con)) == NULL) {
        msg_error_print("not enough memory for error message creating\n");
        return;
    }

    msg_error_print("%s\n", s);
    free(s);

    return;
} /* }}} */

/* Test if argv was specified */
    static int
test_process_cfg_argv(config_filename)
    const char *config_filename;
{ /* {{{ */
    if (process_cfg.argv == NULL) {

        if (process_cfg.name != NULL && process_cfg.name[0]) {
            /* At least one process name is defined in this case */
            if (config_filename != NULL)
                msg_error_print("process '%s' has not"
                        " 'command' clausule in config file '%s'\n",
                        process_cfg.name[0],
                        config_filename);
            else
                msg_error_print("process '%s' has not specified"
                        " what to run on command line\n",
                        process_cfg.name[0]);
        }
        else {
            /* No process name is defined in this case */
            if (config_filename != NULL)
                msg_error_print("some process has not"
                        " 'command' clausule in config file '%s'\n",
                        config_filename);
            else
                msg_error_print("some process has not specified"
                        " what to run on command line\n");
        }

        return 0;
    }

    return 1;
} /* }}} */

    static char *
get_user_config_filename(void)
{ /* {{{ */
    register char *homedir, *filename;

    if ((homedir = getenv("HOME")) == NULL)
        return strdup(conf_user_filename);

    filename = (char *) malloc((strlen(homedir)
                + strlen(conf_user_filename) + 2) * sizeof(char));
    if (filename == NULL)
        return NULL;

    strcpy(filename, homedir);
    if (strlen(filename) > 0 && filename[strlen(filename) - 1] != '/')
        strcpy(filename + strlen(filename), "/");

    strcpy(filename + strlen(filename), conf_user_filename);

    return filename;
} /* }}} */

    static void
clear_global_cfg(void)
{ /* {{{ */
    memset((void *) &global_cfg, '\0',
            sizeof(struct conf_struct_global));
} /* }}} */

    static void
clear_process_cfg(void)
{ /* {{{ */
    memset((void *) &process_cfg, '\0',
            sizeof(struct conf_struct_process));
} /* }}} */

    static int
check_context(context, options)
    CFG_CONTEXT       *context;
    struct cfg_option options[];
{ /* {{{ */
    if (*context == NULL) {
        if ((*context = cfg_get_context(options)) == NULL)
            return 0;

        cfg_set_context_flag(*context, CFG_PROCESS_FIRST);
        cfg_clear_context_flag(*context, CFG_SKIP_FIRST);
        cfg_set_context_flag(*context, CFG_FILE_LINE_POS_USAGE);

        /* TODO: one call for multi vals properties */
        cfg_clear_property(*context, CFG_LINE_STOP_STRING);
        cfg_clear_property(*context, CFG_MULTI_VALS_SEPARATOR);
        cfg_clear_property(*context, CFG_FILE_STOP_PREFIX);

        if (! cfg_add_property(*context, CFG_LINE_STOP_STRING, "--")
                || ! cfg_add_property(*context,
                    CFG_NORMAL_MULTI_VALS_SEPARATOR, ",")
                || ! cfg_add_property(*context,
                    CFG_FILE_LEFTOVER_MULTI_VALS_SEPARATOR, " ")
                || ! cfg_add_property(*context,
                    CFG_FILE_STOP_PREFIX, section_boundaries[0]))
            return 0;
    }

    return 1;
} /* }}} */

    static int
is_cfgfile_section(section_str)
    char *section_str;
{ /* {{{ */
    register int secstr_size = strlen(section_str);
    register int secb0_size  = strlen(section_boundaries[0]);
    register int secb1_size  = strlen(section_boundaries[1]);

    register int ret = 0;

    if (secstr_size > secb0_size + secb1_size
            && ! strncmp(section_str, section_boundaries[0], secb0_size)
            && ! strncmp(section_str + secstr_size - secb1_size,
                section_boundaries[1], secb1_size))
    {
        register char *pos = section_str + secb0_size;

        while (isspace(*pos))
            pos++;

        if (! strncasecmp(global_str, pos, strlen(global_str))) {
            pos += strlen(global_str);
            ret = 1;
        }
        else if (! strncasecmp(process_str, pos, strlen(process_str))) {
            pos += strlen(process_str);
            ret = 2;
        }

        while (ret > 0 && pos < section_str + secstr_size - secb1_size)
            if (isspace(*pos))
                pos++;
            else
                ret = 0;
    }

    return ret;
} /* }}} */

    static void
free_global(global)
    struct conf_struct_global **global;
{ /* {{{ */
    if (*global == NULL)
        return;

    PLATON_FUNC(strdyn_safe_free)((*global)->config_file);

    free(*global);
    *global = NULL;
} /* }}} */

    static void
free_processes(processes)
    struct conf_struct_process ***processes;
{ /* {{{ */
    register int i, j;

    if (*processes == NULL)
        return;

    for (i = 0; (*processes)[i] != NULL; i++) {
        PLATON_FUNC(strdyn_safe_free)((*processes)[i]->name);
        PLATON_FUNC(strdyn_safe_free)((*processes)[i]->argv);

        for (j = 0; j < N_FD; j++)
            PLATON_FUNC(strdyn_safe_free)((*processes)[i]->fd_str[j]);

        free((*processes)[i]);
    }

    free(*processes);
    *processes = NULL;
} /* }}} */

    static int
get_processes_index_by_name(processes, name)
    struct conf_struct_process **processes;
    char                       *name;
{ /* {{{ */
    register int i;

    for (i = 0; processes != NULL && processes[i] != NULL; i++)
        if (processes[i]->name != NULL
                && ! PLATON_FUNC(strdyn_casecmp)(processes[i]->name, name))
            return i;

    return -1;
} /* }}} */

    static int
add_global_cfg_to_global(global)
    struct conf_struct_global **global;
{ /* {{{ */
    *global = (struct conf_struct_global *)
        malloc(sizeof(struct conf_struct_global));
    if (*global == NULL)
        return 0;

    **global = global_cfg;

    return 1;
} /* }}} */

    static int
add_process_cfg_to_processes(processes, size)
    struct conf_struct_process ***processes;
    int                        *size;
{ /* {{{ */
    register int items;

    for (items = 0; *processes != NULL && (*processes)[items] != NULL; items++)
        ;

    if (items + 1 >= *size) {

#if DEBUG /* minimum increment value is 2 */
        *size += 2;
#else
        *size += 10;
#endif
        *processes = (struct conf_struct_process **)
            realloc(*processes, sizeof(struct conf_struct_process*) * (*size));

        if (*processes == NULL)
            return 0;
    }

    (*processes)[items] = (struct conf_struct_process *)
        malloc(sizeof(struct conf_struct_process));
    if ((*processes)[items] == NULL)
        return 0;

    *((*processes)[items]) = process_cfg;
    (*processes)[items + 1] = NULL;

    return 1;
} /* }}} */

    static int
add_processes_to_processes(dest_processes, src_processes)
    struct conf_struct_process ***dest_processes;
    struct conf_struct_process **src_processes;
{ /* {{{ */
    register int i, dest_size, src_size;

    if (dest_processes == NULL)
        return 0;

    for (i = 0; *dest_processes != NULL && (*dest_processes)[i] != NULL; i++)
        ;
    dest_size = i;

    for (i = 0; src_processes != NULL && src_processes[i] != NULL; i++)
        ;
    src_size = i;

    *dest_processes = (struct conf_struct_process **) realloc(*dest_processes,
            sizeof(struct conf_struct_process*) * (dest_size + src_size + 1));
    if (*dest_processes == NULL)
        return 0;

    for (i = 0; i < src_size; i++)
        (*dest_processes)[dest_size + i] = src_processes[i];

    (*dest_processes)[dest_size + src_size] = NULL;

    return 1;
} /* }}} */

/*
 * XXX: TODO: FIXME: reindexing proctable! remove +1 above too
 */

    static int
add_processes_to_proctable(p_ptbl, processes, start_idx_size, start_idx)
    PROCTABLE                  *p_ptbl;
    struct conf_struct_process **processes;
    int                        start_idx_size;
    int                        *start_idx;
{ /* {{{ */
    register int i, j, k, idx;
    register int resource_idx = 0;
    register int ptbl_size, new_ptbl_size;
    PROCTABLE new_ptbl;

    ptbl_size = proctable_get_size(*p_ptbl);

    for (new_ptbl_size = 0; processes != NULL
            && processes[new_ptbl_size] != NULL; new_ptbl_size++)
        ;
#if DEBUG
    msg_debug_print("add_processes_to_proctable():"
            " ptbl_size = %d, new_ptbl_size = %d\n",
            ptbl_size, new_ptbl_size);
#endif

    if ((new_ptbl = proctable_create(new_ptbl_size)) == NULL) {
        msg_error_print("not enough memory for process table creation\n");
        return -1;
    }

    for (i = 0; i < new_ptbl_size; i++) {

        /* Counting resource_idx. */
        while (resource_idx < start_idx_size - 1
                && start_idx[resource_idx + 1] <= i)
            resource_idx++;

        /* Checking processes names. */
        for (j = 0; processes[i]->name != NULL
                && processes[i]->name[j] != NULL; j++) {
            idx = proctable_get_process_index_by_name(
                    *p_ptbl, processes[i]->name[j]);
            if (idx >= 0) {
                msg_error_print("process %d from resource %d (%s) already"
                        " exists in process table with index %d\n",
                        j - start_idx[resource_idx], resource_idx,
                        processes[i]->name[j], idx);
                return -1;
            }
        }

        new_ptbl[i]->pid  = 0;
        new_ptbl[i]->nice = processes[i]->nice;
        new_ptbl[i]->name = PLATON_FUNC(strdyn_safe_duplicate)
            (processes[i]->name);
        new_ptbl[i]->argv = PLATON_FUNC(strdyn_safe_duplicate)
            (processes[i]->argv);

        /* Converting filedescriptors strings to indexes. */
        for (j = 0; j < N_FD; j++) {
            register int size = processes[i]->fd_str[j] == NULL
                ? 0 : PLATON_FUNC(strdyn_get_size)(processes[i]->fd_str[j]);

            new_ptbl[i]->fd[j].n_link  = 0;
            new_ptbl[i]->fd[j].pipe[0] = 0;
            new_ptbl[i]->fd[j].pipe[1] = 0;

            for (k = 0; k < size; k++) {
                struct proclink link;
                char **ar;
                register char *fd_str = NULL, *char_in_name;

                if (strlen(processes[i]->fd_str[j][k]) <= 0)
                    continue;

                ar = PLATON_FUNC(strdyn_explode2_ar)(processes[i]->fd_str[j][k],
                        name_vs_stream_separator);

                if (ar == NULL) {
                    msg_error_print("not enough memory"
                            " for link argument exploding\n");
                    proctable_destroy(&new_ptbl);
                    return -1;
                }

                switch (PLATON_FUNC(strdyn_get_size)(ar)) {
                    case 1:
                        link.proc_id = 0;
                        fd_str = ar[0];
                        break;

                    case 2:

                        for (char_in_name = ar[0];
                                isdigit(*char_in_name);
                                char_in_name++)
                            ;

                        fd_str = ar[1];

                        /*
                         * Process link initialization by local number
                         */

                        if (*char_in_name == '\0') {
                            char *end;
                            link.proc_id = (int) strtol(ar[0], &end, 0);

                            if ((end && *end == '\0') && link.proc_id >= 0) {
                                if (link.proc_id == 0) /* 0 is always valid */
                                    break;

                                if (link.proc_id > 0) {
                                    link.proc_id--; /* make real index */

                                    if (link.proc_id <=
                                            start_idx[resource_idx + 1]
                                            - start_idx[resource_idx] - 1) {

                                        link.proc_id += ptbl_size;
                                        link.proc_id += start_idx[resource_idx];
                                        break;
                                    }
                                }
                            }

                            msg_error_print("bad process number '%s'\n", ar[0]);
                            proctable_destroy(&new_ptbl);
                            PLATON_FUNC(strdyn_free)(ar);
                            return -1;
                        }

                        /*
                         * Process link initialization by name
                         */

                        /* Searching name in original (old) proctable. */
                        link.proc_id = proctable_get_process_index_by_name(
                                *p_ptbl, ar[0]);

                        if (link.proc_id >= 0)
                            break;

                        /* Searching name in existing new proctable.
                         * THIS IS ABSOLUTELY WRONG!
                         * You cannot search proctable which is not already
                         * built!

                         link.proc_id = proctable_get_process_index_by_name(
                         new_ptbl, ar[0]);

                         if (link.proc_id >= 0) {
                         link.proc_id += ptbl_size;
                         break;
                         }
                         */

                        /* Searching name in processes. */
                        link.proc_id = get_processes_index_by_name(
                                processes, ar[0]);

                        if (link.proc_id >= 0) {
                            link.proc_id += ptbl_size;
                            /* link.proc_id += start_idx[resource_idx]; */
                            break;
                        }

                        msg_error_print("bad process name '%s'\n", ar[0]);
                        proctable_destroy(&new_ptbl);
                        PLATON_FUNC(strdyn_free)(ar);
                        return -1;

                    default:
                        msg_error_print("bad link specification: %s\n",
                                processes[i]->fd_str[j][k]);
                        proctable_destroy(&new_ptbl);
                        PLATON_FUNC(strdyn_free)(ar);
                        return -1;
                }

                link.fd_id = fd_str_to_fd_id(fd_str);
                PLATON_FUNC(strdyn_free)(ar); /* fd_str points to ar[] */
                if (link.fd_id < 0) {
                    msg_error_print("bad stream specification '%s'\n", fd_str);
                    proctable_destroy(&new_ptbl);
                    return -1;
                }

                if (! fd_add_proclink(&(new_ptbl[i]->fd[j]), &link)) {
                    msg_error_print("not enought memory for"
                            " process link addition\n");
                    proctable_destroy(&new_ptbl);
                    return -1;
                }
            }
        }
    }

    if (! proctable_join(p_ptbl, new_ptbl)) {
        msg_error_print("not enought memory for process table resize\n");
        proctable_destroy(&new_ptbl);
        return -1;
    }

    return 0;
} /* }}} */

/* Modeline for ViM {{{
 * vim:set ts=4:
 * vim600:fdm=marker fdl=0 fdc=0:
 * }}} */