prestogres 0.1.0

data/pgpool2/pool_config.h

@@ -0,0 +1,284 @@
+/* -*-pgsql-c-*- */
+/*
+ *
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2013	PgPool Global Development Group
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of the
+ * author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission. The author makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * pool_config.h.: pool_config.l related header file
+ *
+ */
+
+#ifndef POOL_CONFIG_H
+#define POOL_CONFIG_H
+
+/*
+ * watchdog
+ */
+#include "watchdog/watchdog.h"
+
+/*
+ * Master/slave sub mode
+ */
+#define MODE_STREAMREP 	"stream"	/* Streaming Replication */
+#define MODE_SLONY 		"slony"		/* Slony-I */
+
+/*
+ * watchdog lifecheck method
+ */
+#define MODE_HEARTBEAT	"heartbeat"
+#define MODE_QUERY 		"query"
+
+/*
+ *  Regex support in white and black list function
+ */
+#include <regex.h>
+#define BLACKLIST	0
+#define WHITELIST	1
+#define PATTERN_ARR_SIZE 16     /* Default length of regex array: 16 patterns */
+typedef struct {
+  char *pattern;
+  int type;
+  int flag;
+  regex_t regexv;
+} RegPattern;
+
+/*
+ * Flags for backendN_flag
+ */
+#define POOL_FAILOVER	0x0001	/* allow or disallow failover */
+#define POOL_DISALLOW_TO_FAILOVER(x) ((unsigned short)(x) & POOL_FAILOVER)
+#define POOL_ALLOW_TO_FAILOVER(x) (!(POOL_DISALLOW_TO_FAILOVER(x)))
+
+/*
+ * configuration parameters
+ */
+typedef struct {
+	char *listen_addresses; /* hostnames/IP addresses to listen on */
+    int	port;	/* port # to bind */
+	int pcp_port;				/* PCP port # to bind */
+	char *socket_dir;		/* pgpool socket directory */
+	char *pcp_socket_dir;		/* PCP socket directory */
+	int pcp_timeout;			/* PCP timeout for an idle client */
+    int	num_init_children;	/* # of children initially pre-forked */
+    int	child_life_time;	/* if idle for this seconds, child exits */
+    int	connection_life_time;	/* if idle for this seconds, connection closes */
+    int	child_max_connections;	/* if max_connections received, child exits */
+	int client_idle_limit;		/* If client_idle_limit is n (n > 0), the client is forced to be
+								   disconnected after n seconds idle */
+	int authentication_timeout; /* maximum time in seconds to complete client authentication */
+    int	max_pool;	/* max # of connection pool per child */
+    char *logdir;		/* logging directory */
+    char *log_destination;      /* log destination: stderr or syslog */
+    int syslog_facility;        /* syslog facility: LOCAL0, LOCAL1, ... */
+    char *syslog_ident;         /* syslog ident string: pgpool */
+    char *pid_file_name;		/* pid file name */
+    char *backend_socket_dir;	/* Unix domain socket directory for the PostgreSQL server */
+	int replication_mode;		/* replication mode */
+
+	int log_connections;		/* 0:false, 1:true - logs incoming connections */
+	int log_hostname;		/* 0:false, 1:true - resolve hostname */
+	int enable_pool_hba;		/* 0:false, 1:true - enables pool_hba.conf file authentication */
+	char *pool_passwd;	/* pool_passwd file name. "" disables pool_passwd */
+
+	char *presto_server;	/* Presto default server address, and optionally :port */
+	char *presto_catalog;	/* Presto default catalog name */
+	char *presto_schema;	/* Presto default schema name */
+	char *presto_external_auth_prog;	/* Presto default external authentication program */
+
+	int load_balance_mode;		/* load balance mode */
+
+	int replication_stop_on_mismatch;		/* if there's a data mismatch between master and secondary
+											 * start degeneration to stop replication mode
+											 */
+
+	/* If there's a disagreement with the number of affected tuples in
+	 * UPDATE/DELETE, then degenerate the node which is most likely
+	 * "minority".  # If false, just abort the transaction to keep the
+	 * consistency.*/
+	int failover_if_affected_tuples_mismatch;
+
+	int replicate_select; /* if non 0, replicate SELECT statement when load balancing is disabled. */
+	char **reset_query_list;		/* comma separated list of queries to be issued at the end of session */
+	char **white_function_list;		/* list of functions with no side effects */
+	char **black_function_list;		/* list of functions with side effects */
+	int print_timestamp;		/* if non 0, print time stamp to each log line */
+	int master_slave_mode;		/* if non 0, operate in master/slave mode */
+	char *master_slave_sub_mode;		/* either "slony" or "stream" */
+	unsigned long long int delay_threshold;		/* If the standby server delays more than delay_threshold,
+										 * any query goes to the primary only. The unit is in bytes.
+										 * 0 disables the check. Default is 0.
+										 * Note that health_check_period required to be greater than 0
+										 * to enable the functionality. */
+	char *log_standby_delay;		/* how to log standby lag */
+	int connection_cache;		/* if non 0, cache connection pool */
+	int health_check_timeout;	/* health check timeout */
+	int health_check_period;	/* health check period */
+	char *health_check_user;		/* PostgreSQL user name for health check */
+	char *health_check_password; /* password for health check username */
+	int health_check_max_retries;	/* health check max retries */
+	int health_check_retry_delay;	/* amount of time to wait between retries */
+	int sr_check_period;		/* streaming replication check period */
+	char *sr_check_user;		/* PostgreSQL user name streaming replication check */
+	char *sr_check_password;	/* password for sr_check_user */
+	char *failover_command;     /* execute command when failover happens */
+	char *follow_master_command; /* execute command when failover is ended */
+	char *failback_command;     /* execute command when failback happens */
+
+	/*
+	 * If true, trigger fail over when writing to the backend
+	 * communication socket fails. This is the same behavior of
+	 * pgpool-II 2.2.x or earlier. If set to false, pgpool will report
+	 * an error and disconnect the session.
+	 */
+	int	fail_over_on_backend_error;
+
+	char *recovery_user;		/* PostgreSQL user name for online recovery */
+	char *recovery_password;		/* PostgreSQL user password for online recovery */
+	char *recovery_1st_stage_command;   /* Online recovery command in 1st stage */
+	char *recovery_2nd_stage_command;   /* Online recovery command in 2nd stage */
+	int recovery_timeout;				/* maximum time in seconds to wait for remote start-up */
+	int search_primary_node_timeout;	/* maximum time in seconds to search for new primary
+										 * node after failover */
+	int client_idle_limit_in_recovery;		/* If > 0, the client is forced to be
+											 *  disconnected after n seconds idle
+											 *  This parameter is only valid while in recovery 2nd stage */
+	int insert_lock;	/* if non 0, automatically lock table with INSERT to keep SERIAL
+						   data consistency */
+	int ignore_leading_white_space;		/* ignore leading white spaces of each query */
+ 	int log_statement; /* 0:false, 1: true - logs all SQL statements */
+ 	int log_per_node_statement; /* 0:false, 1: true - logs per node detailed SQL statements */
+
+	int parallel_mode;	/* if non 0, run in parallel query mode */
+
+	int enable_query_cache;		/* if non 0, use query cache. 0 by default */
+
+	char *pgpool2_hostname;		/* pgpool2 hostname */
+	char *system_db_hostname;	/* system DB hostname */
+	int system_db_port;			/* system DB port number */
+	char *system_db_dbname;		/* system DB name */
+	char *system_db_schema;		/* system DB schema name */
+	char *system_db_user;		/* user name to access system DB */
+	char *system_db_password;	/* password to access system DB */
+
+	char *lobj_lock_table;		/* table name to lock for rewriting lo_creat */
+
+	int debug_level;			/* debug message verbosity level.
+								 * 0: no message, 1 <= : more verbose
+								 */
+
+	BackendDesc *backend_desc;	/* PostgreSQL Server description. Placed on shared memory */
+
+	LOAD_BALANCE_STATUS	load_balance_status[MAX_NUM_BACKENDS];	/* to remember which DB node is selected for load balancing */
+
+	/* followings do not exist in the configuration file */
+	int num_reset_queries;		/* number of queries in reset_query_list */
+	int num_white_function_list;		/* number of functions in white_function_list */
+	int num_black_function_list;		/* number of functions in black_function_list */
+	int num_white_memqcache_table_list;		/* number of functions in white_memqcache_table_list */
+	int num_black_memqcache_table_list;		/* number of functions in black_memqcache_table_list */
+	int logsyslog;		/* flag used to start logging to syslog */
+
+	/* ssl configuration */
+	int ssl;	/* if non 0, activate ssl support (frontend+backend) */
+	char *ssl_cert;	/* path to ssl certificate (frontend only) */
+	char *ssl_key;	/* path to ssl key (frontend only) */
+	char *ssl_ca_cert;	/* path to root (CA) certificate */
+	char *ssl_ca_cert_dir;	/* path to directory containing CA certificates */
+
+	time_t relcache_expire;		/* relation cache life time in seconds */
+	int relcache_size;		/* number of relation cache life entry */
+	int check_temp_table;		/* enable temporary table check */
+
+	/* followings are for regex support and do not exist in the configuration file */
+	RegPattern *lists_patterns; /* Precompiled regex patterns for black/white lists */
+	int pattc; /* number of regexp pattern */
+	int current_pattern_size; /* size of the regex pattern array */
+
+	int memory_cache_enabled;   /* if true, use the memory cache functionality, false by default */
+	char *memqcache_method;   /* Cache store method. Either 'shmem'(shared memory) or 'memcached'. 'shmem' by default */
+	char *memqcache_memcached_host;   /* Memcached host name. Mandatory if memqcache_method=memcached. */
+	int memqcache_memcached_port;   /* Memcached port number. Mandatory if memqcache_method=memcached. */
+	int memqcache_total_size;   /* Total memory size in bytes for storing memory cache. Mandatory if memqcache_method=shmem. */
+	int memqcache_max_num_cache;   /* Total number of cache entries. Mandatory if memqcache_method=shmem. */
+	int memqcache_expire;   /* Memory cache entry life time specified in seconds. 60 by default. */
+	int memqcache_auto_cache_invalidation; /* If true, invalidation of query cache is triggered by corresponding */
+										   /* DDL/DML/DCL(and memqcache_expire).  If false, it is only triggered */
+										   /* by memqcache_expire.  True by default. */
+	int memqcache_maxcache;   /* Maximum SELECT result size in bytes. */
+	int memqcache_cache_block_size;   /* Cache block size in bytes. 8192 by default */
+	char *memqcache_oiddir;		/* Temporary work directory to record table oids */
+	char **white_memqcache_table_list;		/* list of tables to memqcache */
+	char **black_memqcache_table_list;		/* list of tables not to memqcache */
+
+	RegPattern *lists_memqcache_table_patterns; /* Precompiled regex patterns for black/white lists */
+	int memqcache_table_pattc; /* number of regexp pattern */
+	int current_memqcache_table_pattern_size; /* size of the regex pattern array */
+
+	/*
+	 * add for watchdog
+	 */
+	int use_watchdog;					/* if non 0, use watchdog */
+	char *wd_lifecheck_method;			/* method of lifecheck. 'heartbeat' or 'query' */
+	int clear_memqcache_on_escalation;	/* if no 0, clear query cache on shmem when escalating */
+    char *wd_escalation_command;		/* Executes this command at escalation on new active pgpool.*/
+	char *wd_hostname;					/* watchdog hostname */
+	int wd_port;						/* watchdog port */
+	WdDesc * other_wd;					/* watchdog lists */
+	char * trusted_servers;				/* icmp reachable server list (A,B,C) */
+	char * delegate_IP;					/* delegate IP address */
+	int  wd_interval;					/* lifecheck interval (sec) */
+	char *wd_authkey;					/* Authentication key for watchdog communication */
+	char * ping_path;					/* path to ping command */
+	char * ifconfig_path;				/* path to ifconfig command */
+	char * if_up_cmd;					/* ifup command */
+	char * if_down_cmd;					/* ifdown command */
+	char * arping_path;					/* path to arping command */
+	char * arping_cmd;					/* arping command */
+	int  wd_life_point;					/* life point (retry times at lifecheck) */
+	char *wd_lifecheck_query;			/* lifecheck query */
+	char *wd_lifecheck_dbname;			/* Database name connected for lifecheck */
+	char *wd_lifecheck_user;			/* PostgreSQL user name for watchdog */
+	char *wd_lifecheck_password;		/* password for watchdog user */
+	int wd_heartbeat_port;				/* Port number for heartbeat lifecheck */
+	int wd_heartbeat_keepalive;			/* Interval time of sending heartbeat signal (sec) */
+	int wd_heartbeat_deadtime;			/* Deadtime interval for heartbeat signal (sec) */
+	WdHbIf hb_if[WD_MAX_IF_NUM];		/* interface devices */
+	int num_hb_if;						/* number of interface devices */
+} POOL_CONFIG;
+
+typedef enum {
+	INIT_CONFIG = 1,   /* 0x01 */
+	RELOAD_CONFIG = 2  /* 0x02 */
+} POOL_CONFIG_CONTEXT;
+
+extern POOL_CONFIG *pool_config;	/* configuration values */
+
+extern int pool_init_config(void);
+extern int pool_get_config(char *confpath, POOL_CONFIG_CONTEXT context);
+extern int eval_logical(char *str);
+extern char *pool_flag_to_str(unsigned short flag);
+
+/* method use for syslog support */
+extern int set_syslog_facility (char *);
+
+/* methods used for regexp support */
+extern int add_regex_pattern(char *type, char *s);
+extern int growFunctionPatternArray(RegPattern item);
+extern int growMemqcacheTablePatternArray(RegPattern item);
+
+#endif /* POOL_CONFIG_H */

data/pgpool2/pool_config.l

@@ -0,0 +1,3281 @@
+/* -*-pgsql-c-*- */
+/*
+ *
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2013	PgPool Global Development Group
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of the
+ * author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission. The author makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * pool_config.l: read configuration file
+ *
+ */
+
+%{
+
+#include "pool.h"
+#include "pool_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define CHECK_CONTEXT(mask, context) ((mask) & (context))
+
+/* to shut off compiler warnings */
+int yylex(void);
+
+POOL_CONFIG *pool_config;	/* configuration values */
+POOL_SYSTEMDB_CONNECTION_POOL *system_db_info;
+static unsigned Lineno;
+static char *default_reset_query_list[] = {"ABORT", "DISCARD ALL"};
+static char *default_black_function_list[] = {"nextval", "setval"};
+
+typedef enum {
+  POOL_KEY = 1,
+  POOL_INTEGER,
+  POOL_REAL,
+  POOL_STRING,
+  POOL_UNQUOTED_STRING,
+  POOL_EQUALS,
+  POOL_EOL,
+  POOL_PARSE_ERROR
+} POOL_TOKEN;
+
+static char *extract_string(char *value, POOL_TOKEN token);
+static char **extract_string_tokens(char *str, char *delim, int *n);
+static void clear_host_entry(int slot);
+
+%}
+
+%option 8bit
+%option never-interactive
+%option nounput
+%option noyywrap
+
+SIGN            ("-"|"+")
+DIGIT           [0-9]
+HEXDIGIT        [0-9a-fA-F]
+
+INTEGER         {SIGN}?({DIGIT}+|0x{HEXDIGIT}+)
+
+EXPONENT        [Ee]{SIGN}?{DIGIT}+
+REAL            {SIGN}?{DIGIT}*"."{DIGIT}*{EXPONENT}?
+
+LETTER          [A-Za-z_\200-\377]
+LETTER_OR_DIGIT [A-Za-z_0-9\200-\377]
+
+KEY              {LETTER}{LETTER_OR_DIGIT}*
+
+UNQUOTED_STRING {LETTER}({LETTER_OR_DIGIT}|[-._:/])*
+STRING          \'([^'\n]|\\.)*\'
+
+%%
+
+\n              Lineno++; return POOL_EOL;
+[ \t\r]+        /* eat whitespace */
+#.*$            /* eat comment */
+
+{KEY}           return POOL_KEY;
+{STRING}        return POOL_STRING;
+{UNQUOTED_STRING} return POOL_UNQUOTED_STRING;
+{INTEGER}       return POOL_INTEGER;
+{REAL}          return POOL_REAL;
+=               return POOL_EQUALS;
+
+.               return POOL_PARSE_ERROR;
+
+%%
+
+int pool_init_config(void)
+{
+	int res;
+	static char localhostname[256];
+	int i;
+
+	pool_config = malloc(sizeof(POOL_CONFIG));
+	if (pool_config == NULL)
+	{
+		pool_error("failed to allocate pool_config");
+		return(-1);
+	}
+
+	memset(pool_config, 0, sizeof(POOL_CONFIG));
+
+#ifndef POOL_PRIVATE
+	pool_config->backend_desc = pool_shared_memory_create(sizeof(BackendDesc));
+	if (pool_config->backend_desc == NULL)
+	{
+		pool_error("failed to allocate pool_config->backend_desc");
+		return -1;
+	}
+#else
+	pool_config->backend_desc = malloc(sizeof(BackendDesc));
+	if (pool_config->backend_desc == NULL)
+	{
+		pool_error("failed to allocate pool_config->backend_desc");
+		return -1;
+	}
+#endif
+
+	/*
+	 * add for watchdog
+	 */
+	pool_config->other_wd = malloc(sizeof(WdDesc));
+	if (pool_config->other_wd == NULL)
+	{
+		pool_error("failed to allocate pool_config->cwother_wd");
+		return -1;
+	}
+	memset(pool_config->other_wd, 0, sizeof(WdDesc));
+
+	/* set hardcoded default values */
+	pool_config->listen_addresses = "localhost";
+	pool_config->port = 9999;
+	pool_config->pcp_port = 9898;
+	pool_config->socket_dir = DEFAULT_SOCKET_DIR;
+	pool_config->pcp_socket_dir = DEFAULT_SOCKET_DIR;
+	pool_config->backend_socket_dir = NULL;
+	pool_config->pcp_timeout = 10;
+	pool_config->num_init_children = 32;
+	pool_config->max_pool = 4;
+	pool_config->child_life_time = 300;
+	pool_config->client_idle_limit = 0;
+	pool_config->connection_life_time = 0;
+	pool_config->child_max_connections = 0;
+	pool_config->authentication_timeout = 60;
+	pool_config->logdir = DEFAULT_LOGDIR;
+    pool_config->logsyslog = 0;
+    pool_config->log_destination = "stderr";
+    pool_config->syslog_facility = LOG_LOCAL0;
+    pool_config->syslog_ident = "pgpool";
+	pool_config->pid_file_name = DEFAULT_PID_FILE_NAME;
+ 	pool_config->log_statement = 0;
+ 	pool_config->log_per_node_statement = 0;
+	pool_config->log_connections = 0;
+	pool_config->log_hostname = 0;
+	pool_config->enable_pool_hba = 0;
+	pool_config->pool_passwd = "pool_passwd";
+
+	pool_config->presto_server = "";
+	pool_config->presto_catalog = "";
+	pool_config->presto_schema = "default";
+	pool_config->presto_external_auth_prog = NULL;
+
+	pool_config->replication_mode = 0;
+	pool_config->load_balance_mode = 0;
+	pool_config->replication_stop_on_mismatch = 0;
+	pool_config->failover_if_affected_tuples_mismatch = 0;
+	pool_config->replicate_select = 0;
+	pool_config->reset_query_list = default_reset_query_list;
+	pool_config->num_reset_queries = sizeof(default_reset_query_list)/sizeof(char *);
+	pool_config->white_function_list = NULL;
+	pool_config->num_white_function_list = 0;
+	pool_config->black_function_list = default_black_function_list;
+	pool_config->num_black_function_list = sizeof(default_black_function_list)/sizeof(char *);
+	pool_config->print_timestamp = 1;
+	pool_config->master_slave_mode = 0;
+	pool_config->master_slave_sub_mode = "slony";
+	pool_config->delay_threshold = 0;
+	pool_config->log_standby_delay = "none";
+	pool_config->connection_cache = 1;
+	pool_config->health_check_timeout = 20;
+	pool_config->health_check_period = 0;
+	pool_config->health_check_user = "nobody";
+	pool_config->health_check_password = "";
+	pool_config->health_check_max_retries = 0;
+	pool_config->health_check_retry_delay = 1;
+	pool_config->sr_check_period = 0;
+	pool_config->sr_check_user = "nobody";
+	pool_config->sr_check_password = "";
+	pool_config->failover_command = "";
+	pool_config->follow_master_command = "";
+	pool_config->failback_command = "";
+	pool_config->fail_over_on_backend_error = 1;
+	pool_config->insert_lock = 1;
+	pool_config->ignore_leading_white_space = 1;
+	pool_config->parallel_mode = 0;
+	pool_config->enable_query_cache = 0;
+	pool_config->system_db_hostname = "localhost";
+	pool_config->system_db_port = 5432;
+	pool_config->system_db_dbname = "pgpool";
+	pool_config->system_db_schema = "pgpool_catalog";
+	pool_config->system_db_user = "pgpool";
+	pool_config->system_db_password = "";
+	pool_config->backend_desc->num_backends = 0;
+    pool_config->recovery_user = "";
+    pool_config->recovery_password = "";
+    pool_config->recovery_1st_stage_command = "";
+    pool_config->recovery_2nd_stage_command = "";
+	pool_config->recovery_timeout = 90;
+	pool_config->search_primary_node_timeout = 10;
+	pool_config->client_idle_limit_in_recovery = 0;
+	pool_config->lobj_lock_table = "";
+	pool_config->ssl = 0;
+	pool_config->ssl_cert = "";
+	pool_config->ssl_key = "";
+	pool_config->ssl_ca_cert = "";
+	pool_config->ssl_ca_cert_dir = "";
+	pool_config->debug_level = 0;
+	pool_config->relcache_expire = 0;
+	pool_config->relcache_size = 256;
+	pool_config->check_temp_table = 1;
+	pool_config->lists_patterns = NULL;
+	pool_config->pattc = 0;
+	pool_config->current_pattern_size = 0;
+	/*
+	 * add for watchdog
+	 */
+	pool_config->use_watchdog = 0;
+	pool_config->wd_lifecheck_method = MODE_HEARTBEAT;
+	pool_config->clear_memqcache_on_escalation = 1;	
+    pool_config->wd_escalation_command = "";
+	pool_config->trusted_servers = "";
+	pool_config->delegate_IP = "";
+	res = gethostname(localhostname,sizeof(localhostname));
+	if(res !=0 )
+	{
+		pool_debug("failed to get this hostname");
+	}
+	pool_config->wd_hostname = localhostname;
+	pool_config->wd_port = 9000;
+	pool_config->other_wd->num_wd = 0;
+	pool_config->wd_interval = 10;
+	pool_config->wd_authkey = "";
+	pool_config->ping_path = "/bin";
+	pool_config->ifconfig_path = "/sbin";
+	pool_config->if_up_cmd = "ifconfig eth0:0 inet $_IP_$ netmask 255.255.255.0";
+	pool_config->if_down_cmd = "ifconfig eth0:0 down";
+	pool_config->arping_path = "/usr/sbin";
+	pool_config->arping_cmd = "arping -U $_IP_$ -w 1";
+	pool_config->wd_life_point = 3;
+	pool_config->wd_lifecheck_query = "SELECT 1";
+	pool_config->wd_lifecheck_dbname = "template1";
+	pool_config->wd_lifecheck_user = "nobody";
+	pool_config->wd_lifecheck_password = "";
+	pool_config->wd_heartbeat_port = 9694;
+	pool_config->wd_heartbeat_keepalive = 2;
+	pool_config->wd_heartbeat_deadtime = 30;
+	pool_config->num_hb_if = 0;
+
+    pool_config->memory_cache_enabled = 0;
+    pool_config->memqcache_method = "shmem";
+    pool_config->memqcache_memcached_host = "localhost";
+    pool_config->memqcache_memcached_port = 11211;
+    pool_config->memqcache_total_size = 67108864;
+    pool_config->memqcache_max_num_cache = 1000000;
+    pool_config->memqcache_expire = 0;
+    pool_config->memqcache_auto_cache_invalidation = 1;
+    pool_config->memqcache_maxcache = 409600;
+    pool_config->memqcache_cache_block_size = 1048576;
+    pool_config->memqcache_oiddir = "/var/log/pgpool/oiddir";
+	pool_config->white_memqcache_table_list = NULL;
+	pool_config->num_white_memqcache_table_list = 0;
+	pool_config->black_memqcache_table_list = NULL;
+	pool_config->num_black_memqcache_table_list = 0;
+    pool_config->lists_memqcache_table_patterns = NULL;
+    pool_config->memqcache_table_pattc = 0;
+    pool_config->current_memqcache_table_pattern_size = 0;
+
+	res = gethostname(localhostname,sizeof(localhostname));
+	if(res !=0 )
+	{
+		pool_debug("failed to get this hostname");
+	}
+	pool_config->pgpool2_hostname = localhostname;
+
+	for (i=0;i<MAX_CONNECTION_SLOTS;i++)
+	{
+		clear_host_entry(i);
+	}
+	return 0;
+}
+
+/*
+ * Add regex expression to patterns array
+ * The supported type are: black_function_list and white_function_list
+ * Return 0 on error, 1 on success
+ */
+int add_regex_pattern(char *type, char *s)
+{
+	int regex_flags = REG_NOSUB;
+	RegPattern currItem;
+	/* force case insensitive pattern matching */
+	regex_flags |= REG_ICASE;
+	/* Add extended regex search */
+	regex_flags |= REG_EXTENDED;
+	/* Fill the pattern type */
+	if (strcmp(type, "black_function_list") == 0 ||
+        strcmp(type, "black_memqcache_table_list") == 0)
+	{
+		currItem.type = BLACKLIST;
+	}
+	else if (strcmp(type, "white_function_list") == 0 ||
+	         strcmp(type, "white_memqcache_table_list") == 0)
+	{
+		currItem.type = WHITELIST;
+	}
+	else
+	{
+		pool_error("add_to_patterns: bad pattern type %s", type);
+		return 0;
+	}
+	/* Fill the pattern flag */
+	currItem.flag = regex_flags;
+
+	/* Fill pattern array */
+	currItem.pattern = malloc(sizeof(char)*(strlen(s)+3));
+	if (currItem.pattern == NULL)
+	{
+		pool_error("add_to_patterns: unable to allocate new pattern");
+		return 0;
+	}
+	/* Force exact matching of function name with ^ and $ on the regex
+	   if required to prevent partial matching. It also allow backward
+	   compatibility.
+	 */
+	if (strncmp(s, "^", 1) != 0) {
+		strncpy(currItem.pattern, "^", 2);
+		strncat(currItem.pattern, s, strlen(s) + 1);
+	} else {
+		strncpy(currItem.pattern, s, strlen(s) + 1);
+	}
+	if (s[strlen(s)-1] != '$') {
+		strncat(currItem.pattern, "$", 2);
+	}
+	pool_debug("add_to_patterns: regex pattern: %s", currItem.pattern);
+	/* compile our regex */
+	if (regcomp(&currItem.regexv, currItem.pattern, currItem.flag) != 0)
+	{
+		pool_error("add_to_patterns: invalid regex pattern: %s", currItem.pattern);
+	}
+    else if ((strcmp(type, "white_function_list") == 0 ||
+	          strcmp(type, "black_function_list") == 0) &&
+             growFunctionPatternArray(currItem) < 0)
+    {
+        pool_error("add_to_patterns: unable to allocate new pattern");
+        return 0;
+    }
+    else if ((strcmp(type, "white_memqcache_table_list") == 0 ||
+	          strcmp(type, "black_memqcache_table_list") == 0) &&
+             growMemqcacheTablePatternArray(currItem) < 0)
+    {
+        pool_error("add_to_patterns: unable to allocate new pattern");
+        return 0;
+    }
+
+	return 1;
+}
+
+/*
+ * Dynamically grow the regex pattern array
+ * The array start with PATTERN_ARR_SIZE storage place, if required
+ * it will grow of PATTERN_ARR_SIZE more each time.
+ */
+int growFunctionPatternArray(RegPattern item)
+{
+	void *_tmp = NULL;
+	if (pool_config->pattc == pool_config->current_pattern_size)
+	{
+		pool_config->current_pattern_size += PATTERN_ARR_SIZE;
+		_tmp = realloc(pool_config->lists_patterns,
+		               (pool_config->current_pattern_size * sizeof(RegPattern)));
+		if (!_tmp)
+		{
+			return(-1);
+		}
+
+		pool_config->lists_patterns = (RegPattern*)_tmp;
+	}
+	pool_config->lists_patterns[pool_config->pattc] = item;
+	pool_config->pattc++;
+
+	return(pool_config->pattc);
+}
+
+int growMemqcacheTablePatternArray(RegPattern item)
+{
+	void *_tmp = NULL;
+	if (pool_config->memqcache_table_pattc == pool_config->current_memqcache_table_pattern_size)
+	{
+		pool_config->current_memqcache_table_pattern_size += PATTERN_ARR_SIZE;
+		_tmp = realloc(pool_config->lists_memqcache_table_patterns,
+		               (pool_config->current_memqcache_table_pattern_size * sizeof(RegPattern)));
+		if (!_tmp)
+		{
+			return(-1);
+		}
+
+		pool_config->lists_memqcache_table_patterns = (RegPattern*)_tmp;
+	}
+	pool_config->lists_memqcache_table_patterns[pool_config->memqcache_table_pattc] = item;
+	pool_config->memqcache_table_pattc++;
+
+	return(pool_config->memqcache_table_pattc);
+}
+
+int pool_get_config(char *confpath, POOL_CONFIG_CONTEXT context)
+{
+	FILE *fd;
+	int token;
+	char key[1024];
+	double total_weight;
+	int i;
+    bool log_destination_changed = false;
+#ifdef USE_MEMCACHED
+	bool use_memcached = true;
+#else
+	bool use_memcached = false;
+#endif
+
+#define PARSE_ERROR()		pool_error("pool_config: parse error at line %d '%s'", Lineno, yytext)
+
+	/* open config file */
+	fd = fopen(confpath, "r");
+	if (!fd)
+	{
+		fprintf(stderr, "pool_config: could not open configuration file (%s)\n",
+				POOL_CONF_FILE_NAME);
+		fprintf(stderr, "pool_config: using default values...\n");
+		return 0;
+	}
+
+	yyin = fd;
+	Lineno = 1;
+
+	for(;;)
+	{
+		token = yylex();
+		if (token == 0)
+		{
+			break;
+		}
+		if (token == POOL_PARSE_ERROR)
+		{
+			PARSE_ERROR();
+			fclose(fd);
+			return(-1);
+		}
+		if (token == POOL_EOL)
+			continue;
+
+		if (token != POOL_KEY)
+		{
+			PARSE_ERROR();
+			fclose(fd);
+			return(-1);
+		}
+
+		strlcpy(key, yytext, sizeof(key));
+
+		pool_debug("key: %s", key);
+
+		token = yylex();
+
+		if (token == POOL_EQUALS)
+			token = yylex();
+
+		pool_debug("value: %s kind: %d", yytext, token);
+
+		if (!strcmp(key, "allow_inet_domain_socket") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			/* for backward compatibility */
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			if (v)
+				pool_config->listen_addresses = strdup("*");
+			else
+				pool_config->listen_addresses = strdup("");
+		}
+		else if (!strcmp(key, "listen_addresses") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->listen_addresses = str;
+		}
+
+		else if (!strcmp(key, "port") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 1024)
+			{
+				pool_error("pool_config: %s must be 1024 or higher numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->port = v;
+		}
+		else if (!strcmp(key, "pcp_port") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 1024)
+			{
+				pool_error("pool_config: %s must be 1024 or higher numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->pcp_port = v;
+		}
+		else if (!strcmp(key, "socket_dir") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->socket_dir = str;
+		}
+		else if (!strcmp(key, "pcp_socket_dir") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->pcp_socket_dir = str;
+		}
+		else if (!strcmp(key, "pcp_timeout") &&
+			 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or greater or equal to 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->pcp_timeout = v;
+		}
+		else if (!strcmp(key, "num_init_children") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 1)
+			{
+				pool_error("pool_config: %s must be higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->num_init_children = v;
+		}
+		else if (!strcmp(key, "child_life_time") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be greater or equal to 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->child_life_time = v;
+		}
+		else if (!strcmp(key, "client_idle_limit") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be greater or equal to 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->client_idle_limit = v;
+		}
+		else if (!strcmp(key, "connection_life_time") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be greater or equal to 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->connection_life_time = v;
+		}
+		else if (!strcmp(key, "child_max_connections") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be greater or equal to 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->child_max_connections = v;
+		}
+		else if (!strcmp(key, "authentication_timeout") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->authentication_timeout = v;
+		}
+		else if (!strcmp(key, "max_pool") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be greater or equal to 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->max_pool = v;
+		}
+		else if (!strcmp(key, "logdir") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->logdir = str;
+		}
+		else if (!strcmp(key, "log_destination") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+            log_destination_changed = pool_config->log_destination != str;
+			pool_config->log_destination = str;
+		}
+		else if (!strcmp(key, "syslog_facility") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->syslog_facility = set_syslog_facility(str);
+		}
+		else if (!strcmp(key, "syslog_ident") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+            log_destination_changed = log_destination_changed || pool_config->syslog_ident != str;
+			pool_config->syslog_ident = str;
+		}
+		else if (!strcmp(key, "pid_file_name") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->pid_file_name = str;
+		}
+       	else if (!strcmp(key, "log_connections") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->log_connections = v;
+		}
+       	else if (!strcmp(key, "log_hostname") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->log_hostname = v;
+		}
+       	else if (!strcmp(key, "enable_pool_hba") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->enable_pool_hba = v;
+		}
+		else if (!strcmp(key, "pool_passwd") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->pool_passwd = str;
+		}
+
+		else if (!strcmp(key, "presto_server") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->presto_server = str;
+		}
+		else if (!strcmp(key, "presto_catalog") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->presto_catalog = str;
+		}
+		else if (!strcmp(key, "presto_schema") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->presto_schema = str;
+		}
+		else if (!strcmp(key, "presto_external_auth_prog") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->presto_external_auth_prog = str;
+		}
+
+		else if (!strcmp(key, "backend_socket_dir") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+			
+			pool_log("pool_config: backend_socket_dir is deprecated, please use backend_hostname");
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->backend_socket_dir = str;
+		}
+		else if (!strcmp(key, "replication_mode") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->replication_mode = v;
+
+			if (pool_config->master_slave_mode && pool_config->replication_mode)
+			{
+				pool_error("pool_config: replication_mode and master_slave_mode cannot be enabled at the same time");
+				fclose(fd);
+				return(-1);
+			}
+
+		}
+		else if (!strcmp(key, "load_balance_mode") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->load_balance_mode = v;
+		}
+		else if (!strcmp(key, "replication_stop_on_mismatch") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_debug("replication_stop_on_mismatch: %d", v);
+			pool_config->replication_stop_on_mismatch = v;
+		}
+		else if (!strcmp(key, "failover_if_affected_tuples_mismatch") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_debug("failover_if_affected_tuples_mismatch: %d", v);
+			pool_config->failover_if_affected_tuples_mismatch = v;
+		}
+		else if (!strcmp(key, "replicate_select") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_debug("replicate_select: %d", v);
+			pool_config->replicate_select = v;
+		}
+		else if (!strcmp(key, "reset_query_list") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->reset_query_list = extract_string_tokens(str, ";", &pool_config->num_reset_queries);
+			if (pool_config->reset_query_list == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+		}
+
+		else if (!strcmp(key, "white_function_list") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->white_function_list =
+				extract_string_tokens(str, ",", &pool_config->num_white_function_list);
+
+			if (pool_config->white_function_list == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			for (i=0;i<pool_config->num_white_function_list;i++)
+			{
+				add_regex_pattern("white_function_list", pool_config->white_function_list[i]);
+			}
+		}
+
+		else if (!strcmp(key, "black_function_list") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->black_function_list =
+				extract_string_tokens(str, ",", &pool_config->num_black_function_list);
+
+			if (pool_config->black_function_list == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			for (i=0;i<pool_config->num_black_function_list;i++)
+			{
+				add_regex_pattern("black_function_list", pool_config->black_function_list[i]);
+			}
+		}
+
+		else if (!strcmp(key, "print_timestamp") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->print_timestamp = v;
+		}
+
+		else if (!strcmp(key, "master_slave_mode") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->master_slave_mode = v;
+
+			if (pool_config->master_slave_mode && pool_config->replication_mode)
+			{
+				pool_error("pool_config: replication_mode and master_slave_mode cannot be enabled at the same time");
+				fclose(fd);
+				return(-1);
+			}
+		}
+
+		else if (!strcmp(key, "master_slave_sub_mode") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+
+			if (strcmp(str, MODE_SLONY) && strcmp(str, MODE_STREAMREP))
+			{
+				pool_error("pool_config: %s must be either \"slony\" or \"stream\"", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->master_slave_sub_mode = str;
+		}
+
+		else if (!strcmp(key, "delay_threshold") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			long long int v = atol(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be greater or equal to 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->delay_threshold = v;
+		}
+
+		else if (!strcmp(key, "log_standby_delay") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+
+			if (strcmp(str, "always") && strcmp(str, "if_over_threshold") && strcmp(str, "none"))
+			{
+				pool_error("pool_config: invalid log_standby_delay %s", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->log_standby_delay = str;
+		}
+
+		else if (!strcmp(key, "connection_cache") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->connection_cache = v;
+		}
+
+		else if (!strcmp(key, "health_check_timeout") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->health_check_timeout = v;
+		}
+
+		else if (!strcmp(key, "health_check_period") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->health_check_period = v;
+		}
+
+		else if (!strcmp(key, "health_check_user") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->health_check_user = str;
+		}
+
+		else if (!strcmp(key, "health_check_password") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->health_check_password = str;
+		}
+
+                else if (!strcmp(key, "health_check_max_retries") &&
+                                 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+                {
+                        int v = atoi(yytext);
+
+                        if (token != POOL_INTEGER || v < 0)
+                        {
+                                pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+                                fclose(fd);
+                                return(-1);
+                        }
+                        pool_config->health_check_max_retries = v;
+                }
+
+                else if (!strcmp(key, "health_check_retry_delay") &&
+                                 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+                {
+                        int v = atoi(yytext);
+
+                        if (token != POOL_INTEGER || v < 0)
+                        {
+                                pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+                                fclose(fd);
+                                return(-1);
+                        }
+                        pool_config->health_check_retry_delay = v;
+                }
+
+		else if (!strcmp(key, "sr_check_period") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->sr_check_period = v;
+		}
+
+		else if (!strcmp(key, "sr_check_user") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->sr_check_user = str;
+		}
+
+		else if (!strcmp(key, "sr_check_password") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->sr_check_password = str;
+		}
+
+		else if (!strcmp(key, "failover_command") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->failover_command = str;
+		}
+
+		else if (!strcmp(key, "follow_master_command") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->follow_master_command = str;
+		}
+
+		else if (!strcmp(key, "failback_command") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->failback_command = str;
+		}
+
+		else if (!strcmp(key, "fail_over_on_backend_error") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->fail_over_on_backend_error = v;
+		}
+
+		else if (!strcmp(key, "recovery_user") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->recovery_user = str;
+		}
+
+		else if (!strcmp(key, "recovery_password") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->recovery_password = str;
+		}
+
+		else if (!strcmp(key, "recovery_1st_stage_command") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->recovery_1st_stage_command = str;
+		}
+
+		else if (!strcmp(key, "recovery_2nd_stage_command") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->recovery_2nd_stage_command = str;
+		}
+
+		else if (!strcmp(key, "recovery_timeout") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->recovery_timeout = v;
+		}
+
+		else if (!strcmp(key, "search_primary_node_timeout") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->search_primary_node_timeout = v;
+		}
+
+		else if (!strcmp(key, "client_idle_limit_in_recovery") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < -1)
+			{
+				pool_error("pool_config: %s must be greater or equal to -1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->client_idle_limit_in_recovery = v;
+		}
+
+		else if (!strcmp(key, "insert_lock") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->insert_lock = v;
+		}
+
+		else if (!strcmp(key, "ignore_leading_white_space") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->ignore_leading_white_space = v;
+		}
+
+		else if (!strcmp(key, "parallel_mode") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->parallel_mode = v;
+		}
+
+		else if (!strcmp(key, "enable_query_cache") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->enable_query_cache = v;
+		}
+
+		else if (!strcmp(key, "pgpool2_hostname") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->pgpool2_hostname = str;
+		}
+
+		else if (!strcmp(key, "system_db_hostname") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->system_db_hostname = str;
+		}
+
+		else if (!strcmp(key, "system_db_port") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->system_db_port = v;
+		}
+
+		else if (!strcmp(key, "system_db_dbname") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->system_db_dbname = str;
+		}
+
+		else if (!strcmp(key, "system_db_schema") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->system_db_schema = str;
+		}
+
+		else if (!strcmp(key, "system_db_user") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->system_db_user = str;
+		}
+
+		else if (!strcmp(key, "system_db_password") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->system_db_password = str;
+		}
+
+		else if (!strncmp(key, "backend_hostname", 16) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+			char *str;
+
+			slot = atoi(key + 16);
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: backend number %s for backend_hostname out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if (context == INIT_CONFIG ||
+				(context == RELOAD_CONFIG && BACKEND_INFO(slot).backend_status == CON_UNUSED))
+				strlcpy(BACKEND_INFO(slot).backend_hostname, str, MAX_DB_HOST_NAMELEN);
+		}
+
+		else if (!strncmp(key, "backend_port", 12) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+
+			slot = atoi(key + 12);
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: host number %s for port number out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_debug("pool_config: port slot number %d ", slot);
+			if (context == INIT_CONFIG)
+			{
+				BACKEND_INFO(slot).backend_port = atoi(yytext);
+				BACKEND_INFO(slot).backend_status = CON_CONNECT_WAIT;
+			}
+			else if (context == RELOAD_CONFIG && BACKEND_INFO(slot).backend_status == CON_UNUSED)
+			{
+				BACKEND_INFO(slot).backend_port = atoi(yytext);
+				BACKEND_INFO(slot).backend_status = CON_DOWN;
+			}
+		}
+
+		else if (!strncmp(key, "backend_weight", 14) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+			double v;
+			BACKEND_STATUS status;
+
+			slot = atoi(key + 14);
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: weight number %s for port number out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			v = atof(yytext);
+
+			if (v < 0.0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+
+			pool_debug("pool_config: weight slot number %d weight: %f", slot, v);
+			status = BACKEND_INFO(slot).backend_status;
+
+			if (context == INIT_CONFIG || context == RELOAD_CONFIG)
+			{
+				double old_v = BACKEND_INFO(slot).unnormalized_weight;
+				BACKEND_INFO(slot).unnormalized_weight = v;
+
+				/*
+				 * Log weight change event only when context is
+				 * reloading of pgpool.conf and weight is actually
+				 * changed
+				 */
+				if (context == RELOAD_CONFIG && old_v != v)
+				{
+					pool_log("Backend weight for backend%d changed from %f to %f. This will take effect from next client session.", slot, old_v, v);
+				}
+			}
+		}
+		else if (!strncmp(key, "backend_data_directory", 22) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+			char *str;
+			BACKEND_STATUS status;
+
+			slot = atoi(key + 22);
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: backend number %s for backend_data_directory out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			status = BACKEND_INFO(slot).backend_status;
+			if (context == INIT_CONFIG ||
+				(context == RELOAD_CONFIG && (status == CON_UNUSED || status == CON_DOWN)))
+				strlcpy(BACKEND_INFO(slot).backend_data_directory, str, MAX_PATH_LENGTH);
+		}
+		else if (!strncmp(key, "backend_flag", 12) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			char *str;
+			char **flags;
+			int n;
+			int i;
+			int slot;
+			unsigned short flag = 0;
+			bool allow_to_failover_is_specified = 0;
+			bool disallow_to_failover_is_specified = 0;
+
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				pool_error("pool_config: extract_string failed: %s", yytext);
+				fclose(fd);
+				return(-1);
+			}
+
+			flags = extract_string_tokens(str, "|", &n);
+			if (!flags || n < 0)
+			{
+				pool_debug("pool_config: unable to get backend flags");
+				fclose(fd);
+				return(-1);
+			}
+
+			for (i=0;i<n;i++)
+			{
+				if (!strcmp(flags[i], "ALLOW_TO_FAILOVER"))
+				{
+					if (disallow_to_failover_is_specified)
+					{
+						pool_error("pool_config: cannot set ALLOW_TO_FAILOVER and DISALLOW_TO_FAILOVER at the same time");
+						fclose(fd);
+						return(-1);
+					}
+					flag &= ~POOL_FAILOVER;
+					allow_to_failover_is_specified = true;
+					pool_debug("pool_config: allow_to_failover on");
+				}
+
+				else if (!strcmp(flags[i], "DISALLOW_TO_FAILOVER"))
+				{
+					if (allow_to_failover_is_specified)
+					{
+						pool_error("pool_config: cannot set ALLOW_TO_FAILOVER and DISALLOW_TO_FAILOVER at the same time");
+						fclose(fd);
+						return(-1);
+					}
+					flag |= POOL_FAILOVER;
+					disallow_to_failover_is_specified = true;
+					pool_debug("pool_config: disallow_to_failover on");
+				}
+
+				else
+				{
+					pool_error("pool_config: invalid backend flag:%s", flags[i]);
+				}
+			}
+
+			slot = atoi(key + 12);
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: slot number %s for flag out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			BACKEND_INFO(slot).flag = flag;
+
+			pool_debug("pool_config: slot number %d flag: %04x", slot, flag);
+		}
+
+       	else if (!strcmp(key, "log_statement") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				return(-1);
+			}
+			pool_config->log_statement = v;
+		}
+       	else if (!strcmp(key, "log_per_node_statement") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				return(-1);
+			}
+			pool_config->log_per_node_statement = v;
+		}
+
+		else if (!strcmp(key, "lobj_lock_table") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->lobj_lock_table = str;
+		}
+		/*
+		 * add for watchdog
+		 */
+		else if (!strncmp(key, "other_pgpool_hostname", 21) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+			char *str;
+
+			slot = atoi(key + 21) ;
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: pgpool number %s for other_pgpool_hostname out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if (context == INIT_CONFIG || (context == RELOAD_CONFIG ))
+				strlcpy(WD_INFO(slot).hostname, str, WD_MAX_HOST_NAMELEN);
+		}
+
+		else if (!strncmp(key, "other_pgpool_port", 17) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+
+			slot = atoi(key + 17);
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: pgpool number %s for other_pgpool_port out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			if (context == INIT_CONFIG || (context == RELOAD_CONFIG ))
+				WD_INFO(slot).pgpool_port = atoi(yytext);
+		}
+
+		else if (!strncmp(key, "other_wd_port", 13) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+
+			slot = atoi(key + 13);
+			if (slot < 0 || slot >= MAX_CONNECTION_SLOTS)
+			{
+				pool_error("pool_config: pgpool number %s for other_wd_port out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			if (context == INIT_CONFIG || (context == RELOAD_CONFIG ))
+			{
+				WD_INFO(slot).wd_port = atoi(yytext);
+				WD_INFO(slot).status = WD_INIT;
+				pool_config->other_wd->num_wd = slot + 1;
+			}
+		}
+		else if (!strcmp(key, "use_watchdog") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->use_watchdog = v;
+		}
+
+		else if (!strcmp(key, "clear_memqcache_on_escalation") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->clear_memqcache_on_escalation = v;
+		}
+
+		else if (!strcmp(key, "wd_escalation_command") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_escalation_command = str;
+		}
+
+		else if (!strcmp(key, "trusted_servers") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->trusted_servers = str;
+		}
+		else if (!strcmp(key, "delegate_IP") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->delegate_IP = str;
+		}
+		else if (!strcmp(key, "wd_hostname") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->wd_hostname = str;
+		}
+		else if (!strcmp(key, "wd_port") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v <= 0)
+			{
+				pool_error("pool_config: %s must be higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_port = v;
+		}
+		else if (!strcmp(key, "wd_interval") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v <= 0)
+			{
+				pool_error("pool_config: %s must be higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_interval = v;
+		}
+		else if (!strcmp(key, "ping_path") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->ping_path = str;
+		}
+		else if (!strcmp(key, "ifconfig_path") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->ifconfig_path = str;
+		}
+		else if (!strcmp(key, "if_up_cmd") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->if_up_cmd = str;
+		}
+		else if (!strcmp(key, "if_down_cmd") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->if_down_cmd = str;
+		}
+		else if (!strcmp(key, "arping_path") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->arping_path = str;
+		}
+		else if (!strcmp(key, "arping_cmd") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->arping_cmd = str;
+		}
+		else if (!strcmp(key, "wd_life_point") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v <= 0)
+			{
+				pool_error("pool_config: %s must be higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_life_point = v;
+		}
+		else if (!strcmp(key, "wd_lifecheck_query") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if(strlen(str))
+				pool_config->wd_lifecheck_query = str;
+		}
+
+		else if (!strcmp(key, "wd_lifecheck_dbname") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_lifecheck_dbname = str;
+		}
+
+		else if (!strcmp(key, "wd_lifecheck_user") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_lifecheck_user = str;
+		}
+
+		else if (!strcmp(key, "wd_lifecheck_password") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_lifecheck_password = str;
+		}
+
+		else if (!strcmp(key, "wd_lifecheck_method") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+
+			if (strcmp(str, MODE_HEARTBEAT) && strcmp(str, MODE_QUERY))
+			{
+				pool_error("pool_config: %s must be either \"heartbeat\" or \"query\"", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_lifecheck_method = str;
+		}
+		else if (!strcmp(key, "wd_heartbeat_port") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v <= 0)
+			{
+				pool_error("pool_config: %s must be higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_heartbeat_port = v;
+		}
+		else if (!strcmp(key, "wd_heartbeat_keepalive") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v <= 0)
+			{
+				pool_error("pool_config: %s must be higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_heartbeat_keepalive = v;
+		}
+		else if (!strcmp(key, "wd_heartbeat_deadtime") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v <= 0)
+			{
+				pool_error("pool_config: %s must be higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_heartbeat_deadtime = v;
+		}
+		else if (!strcmp(key, "wd_authkey") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->wd_authkey = str;
+		}
+
+		else if (!strncmp(key, "heartbeat_device", 16) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+			char *str;
+
+			slot = atoi(key + 16) ;
+			if (slot < 0 || slot >= WD_MAX_IF_NUM)
+			{
+				pool_error("pool_config: pgpool number %s for heartbeat_device out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if (context == INIT_CONFIG || (context == RELOAD_CONFIG ))
+				strlcpy(WD_HB_IF(slot).if_name, str, WD_MAX_IF_NAME_LEN);
+
+		}
+		/* this must be prior to hertbeat_destination */
+		else if (!strncmp(key, "heartbeat_destination_port", 26) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+
+			slot = atoi(key + 26) ;
+			if (slot < 0 || slot >= WD_MAX_IF_NUM)
+			{
+				pool_error("pool_config: pgpool number %s for heartbeat_destination_port out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			if (context == INIT_CONFIG || (context == RELOAD_CONFIG ))
+			{
+				WD_HB_IF(slot).dest_port = atoi(yytext);
+				pool_config->num_hb_if = slot + 1;
+			}
+		}
+		else if (!strncmp(key, "heartbeat_destination", 21) &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context) &&
+				 mypid == getpid()) /* this parameter must be modified by parent pid */
+		{
+			int slot;
+			char *str;
+
+			slot = atoi(key + 21) ;
+			if (slot < 0 || slot >= WD_MAX_IF_NUM)
+			{
+				pool_error("pool_config: pgpool number %s for heartbeat_destination out of range", key);
+				fclose(fd);
+				return(-1);
+			}
+
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			if (context == INIT_CONFIG || (context == RELOAD_CONFIG ))
+				strlcpy(WD_HB_IF(slot).addr, str, WD_MAX_HOST_NAMELEN);
+		}
+
+        else if (!strcmp(key, "ssl") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				return(-1);
+			}
+			pool_config->ssl = v;
+		}
+		else if (!strcmp(key, "ssl_cert") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->ssl_cert = str;
+		}
+		else if (!strcmp(key, "ssl_key") && CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->ssl_key = str;
+		}
+		else if (!strcmp(key, "ssl_ca_cert") &&
+		         CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->ssl_ca_cert = str;
+		}
+		else if (!strcmp(key, "ssl_ca_cert_dir") &&
+		         CHECK_CONTEXT(INIT_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->ssl_ca_cert_dir = str;
+		}
+
+		else if (!strcmp(key, "debug_level") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->debug_level = v;
+		}
+
+		else if (!strcmp(key, "relcache_expire") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 0)
+			{
+				pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->relcache_expire = v;
+		}
+
+		else if (!strcmp(key, "relcache_size") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = atoi(yytext);
+
+			if (token != POOL_INTEGER || v < 1)
+			{
+				pool_error("pool_config: %s must be equal or higher than 1 numeric value", key);
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->relcache_size = v;
+		}
+
+		else if (!strcmp(key, "check_temp_table") && CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			int v = eval_logical(yytext);
+
+			if (v < 0)
+			{
+				pool_error("pool_config: invalid value %s for %s", yytext, key);
+				return(-1);
+			}
+			pool_config->check_temp_table = v;
+		}
+
+        else if (!strcmp(key, "memory_cache_enabled") &&
+                 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+        {
+            int v = eval_logical(yytext);
+
+            if (v < 0)
+            {
+                pool_error("pool_config: invalid value %s for %s", yytext, key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memory_cache_enabled = v;
+        }
+        else if (!strcmp(key, "memqcache_method") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            char *str;
+
+            if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+            {
+                PARSE_ERROR();
+                fclose(fd);
+                return(-1);
+            }
+            str = extract_string(yytext, token);
+            if (str == NULL)
+            {
+                fclose(fd);
+                return(-1);
+            }
+
+			if (!strcmp(str, "memcached") && !use_memcached)
+			{
+				pool_error("memqcached_method cannot be memcached because pgpool-II is not built with MEMCACHED enabled");
+				fclose(fd);
+				return -1;
+			}
+
+			if (strcmp(str, "memcached") && strcmp(str, "shmem"))
+			{
+				pool_error("memqcached_method must be either shmem or memcached");
+				fclose(fd);
+				return -1;
+			}
+
+            pool_config->memqcache_method = str;
+        }
+        else if (!strcmp(key, "memqcache_memcached_host") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            char *str;
+
+            if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+            {
+                PARSE_ERROR();
+                fclose(fd);
+                return(-1);
+            }
+            str = extract_string(yytext, token);
+            if (str == NULL)
+            {
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_memcached_host = str;
+        }
+        else if (!strcmp(key, "memqcache_memcached_port") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            int v = atoi(yytext);
+
+            if (token != POOL_INTEGER || v < 0)
+            {
+                pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_memcached_port = v;
+        }
+        else if (!strcmp(key, "memqcache_total_size") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            int v = atoi(yytext);
+
+            if (token != POOL_INTEGER || v < 0)
+            {
+                pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_total_size = v;
+        }
+        else if (!strcmp(key, "memqcache_max_num_cache") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            int v = atoi(yytext);
+
+            if (token != POOL_INTEGER || v < 0)
+            {
+                pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_max_num_cache = v;
+        }
+        else if (!strcmp(key, "memqcache_expire") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            int v = atoi(yytext);
+
+            if (token != POOL_INTEGER || v < 0)
+            {
+                pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_expire = v;
+        }
+        else if (!strcmp(key, "memqcache_auto_cache_invalidation") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            int v = eval_logical(yytext);
+
+            if (v < 0)
+            {
+                pool_error("pool_config: invalid value %s for %s", yytext, key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_auto_cache_invalidation = v;
+        }
+        else if (!strcmp(key, "memqcache_maxcache") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            int v = atoi(yytext);
+
+            if (token != POOL_INTEGER || v < 0)
+            {
+                pool_error("pool_config: %s must be equal or higher than 0 numeric value", key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_maxcache = v;
+        }
+        else if (!strcmp(key, "memqcache_cache_block_size") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            int v = atoi(yytext);
+
+            if (token != POOL_INTEGER || v < 512)
+            {
+                pool_error("pool_config: %s must be equal or higher than 512 numeric value", key);
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_cache_block_size = v;
+        }
+        else if (!strcmp(key, "memqcache_oiddir") && CHECK_CONTEXT(INIT_CONFIG, context))
+        {
+            char *str;
+
+            if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+            {
+                PARSE_ERROR();
+                fclose(fd);
+                return(-1);
+            }
+            str = extract_string(yytext, token);
+            if (str == NULL)
+            {
+                fclose(fd);
+                return(-1);
+            }
+            pool_config->memqcache_oiddir = str;
+        }
+		else if (!strcmp(key, "white_memqcache_table_list") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->white_memqcache_table_list =
+				extract_string_tokens(str, ",", &pool_config->num_white_memqcache_table_list);
+
+			if (pool_config->white_memqcache_table_list == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			for (i=0;i<pool_config->num_white_memqcache_table_list;i++)
+			{
+				add_regex_pattern("white_memqcache_table_list", pool_config->white_memqcache_table_list[i]);
+			}
+		}
+
+		else if (!strcmp(key, "black_memqcache_table_list") &&
+				 CHECK_CONTEXT(INIT_CONFIG|RELOAD_CONFIG, context))
+		{
+			char *str;
+
+			if (token != POOL_STRING && token != POOL_UNQUOTED_STRING && token != POOL_KEY)
+			{
+				PARSE_ERROR();
+				fclose(fd);
+				return(-1);
+			}
+			str = extract_string(yytext, token);
+			if (str == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			pool_config->black_memqcache_table_list =
+				extract_string_tokens(str, ",", &pool_config->num_black_memqcache_table_list);
+
+			if (pool_config->black_memqcache_table_list == NULL)
+			{
+				fclose(fd);
+				return(-1);
+			}
+			for (i=0;i<pool_config->num_black_memqcache_table_list;i++)
+			{
+				add_regex_pattern("black_memqcache_table_list", pool_config->black_memqcache_table_list[i]);
+			}
+		}
+	}
+
+	fclose(fd);
+
+    if (log_destination_changed)
+    {
+        /* log_destination has changed, we need to open syslog or close it */
+		if (!strcmp(pool_config->log_destination, "stderr"))
+        {
+	        closelog();
+    	   	pool_config->logsyslog = 0;
+        }
+        else
+        {
+    	   	openlog(pool_config->syslog_ident, LOG_PID|LOG_NDELAY|LOG_NOWAIT, pool_config->syslog_facility);
+    	   	pool_config->logsyslog = 1;
+        }
+    }
+
+	pool_config->backend_desc->num_backends = 0;
+	total_weight = 0.0;
+
+	for (i=0;i<MAX_CONNECTION_SLOTS;i++)
+	{
+		/* port number == 0 indicates that this server is out of use */
+		if (BACKEND_INFO(i).backend_port == 0)
+		{
+			clear_host_entry(i);
+		}
+
+		else
+		{
+			total_weight += BACKEND_INFO(i).unnormalized_weight;
+			pool_config->backend_desc->num_backends = i+1;
+			
+			/* initialize backend_hostname with a default socket path if empty */
+			if (*(BACKEND_INFO(i).backend_hostname) == '\0')
+			{
+				if (pool_config->backend_socket_dir == NULL)
+				{
+					pool_debug("pool_config: empty backend_hostname%d, use PostgreSQL's default unix socket path (%s)", i, DEFAULT_SOCKET_DIR);
+					strlcpy(BACKEND_INFO(i).backend_hostname, DEFAULT_SOCKET_DIR, MAX_DB_HOST_NAMELEN);
+				}
+				else /* DEPRECATED. backward compatibility with older version. Use backend_socket_dir*/
+				{
+					pool_debug("pool_config: empty backend_hostname%d, use backend_socket_dir as unix socket path (%s)", i, pool_config->backend_socket_dir);
+					strlcpy(BACKEND_INFO(i).backend_hostname, pool_config->backend_socket_dir, MAX_DB_HOST_NAMELEN);
+				}
+			}
+		}	
+	}
+
+	pool_debug("num_backends: %d total_weight: %f",
+			   pool_config->backend_desc->num_backends, total_weight);
+	/*
+	 * Normalize load balancing weights. What we are doing here is,
+	 * assign 0 to RAND_MAX to each backend's weight according to the
+	 * value weightN.  For example, if two backends are assigned 1.0,
+	 * then each backend will get RAND_MAX/2 normalized weight.
+	 */
+	for (i=0;i<MAX_CONNECTION_SLOTS;i++)
+	{
+#ifdef DEBUG
+		print_host_entry(i);
+#endif
+
+		if (BACKEND_INFO(i).backend_port != 0)
+		{
+			BACKEND_INFO(i).backend_weight =
+				(RAND_MAX) * BACKEND_INFO(i).unnormalized_weight / total_weight;
+			pool_debug("backend %d weight: %f", i, BACKEND_INFO(i).backend_weight);
+			pool_debug("backend %d flag: %04x", i, BACKEND_INFO(i).flag);
+		}
+	}
+
+	if (pool_config->parallel_mode || pool_config->enable_query_cache)
+	{
+#ifndef POOL_PRIVATE
+		int dist_num;
+#endif
+		SystemDBInfo *info;
+		
+		system_db_info = malloc(sizeof(POOL_SYSTEMDB_CONNECTION_POOL));
+		if (system_db_info == NULL)
+		{
+			pool_error("failed to allocate system_db_info");
+			return -1;
+		}
+		memset(system_db_info, 0, sizeof(*system_db_info));
+
+#ifndef POOL_PRIVATE
+		system_db_info->system_db_status = pool_shared_memory_create(sizeof(BACKEND_STATUS));
+#else
+		system_db_info->system_db_status = malloc(sizeof(BACKEND_STATUS));
+#endif
+		if (system_db_info->system_db_status == NULL)
+		{
+			pool_error("failed to allocate system_db_info->system_db_status");
+			return -1;
+		}
+
+		*system_db_info->system_db_status = CON_CONNECT_WAIT;	/* which is the same as SYSDB_STATUS = CON_CONNECT_WAIT */
+
+		info = malloc(sizeof(SystemDBInfo));
+		if (info == NULL)
+		{
+			pool_error("failed to allocate info");
+			return -1;
+		}
+
+		system_db_info->info = info;
+		info->hostname = pool_config->system_db_hostname;
+		info->port = pool_config->system_db_port;
+		info->user = pool_config->system_db_user;
+		info->password = pool_config->system_db_password;
+		info->database_name = pool_config->system_db_dbname;
+		info->schema_name = pool_config->system_db_schema;
+		info->dist_def_num = 0;
+		info->dist_def_slot = NULL;
+
+#ifndef POOL_PRIVATE
+		if (pool_config->parallel_mode)
+		{
+
+			dist_num = pool_memset_system_db_info(info);
+			if(dist_num < 0)
+			{
+				pool_error("failed to get systemdb info");
+				return(-1);
+			}
+			if (!pool_config->replication_mode && !pool_config->load_balance_mode)
+			{
+				pool_error("pool_config: parallel_mode requires replication_mode or load_balance_mode turned on");
+				return(-1);
+			}
+		}
+		if (pool_config->enable_query_cache)
+		{
+			info->query_cache_table_info.register_prepared_statement = NULL;
+			if (! pool_query_cache_table_exists())
+			{
+				pool_error("failed to locate query_cache table. perhaps it's not defined?");
+				return -1;
+			}
+		}
+		SYSDB_STATUS = CON_UP;
+#endif
+	}
+
+	if (strcmp(pool_config->recovery_1st_stage_command, "") ||
+		strcmp(pool_config->recovery_2nd_stage_command, ""))
+	{
+		for (i=0;i<MAX_CONNECTION_SLOTS;i++)
+		{
+			if (pool_config->backend_desc->backend_info[i].backend_port != 0 &&
+				!strcmp(pool_config->backend_desc->backend_info[i].backend_data_directory, ""))
+			{
+				pool_error("pool_config: recovery_1st_stage_command and recovery_2nd_stage_command requires backend_data_directory to be set");
+				return -1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+static char *extract_string(char *value, POOL_TOKEN token)
+{
+	char *ret;
+
+	ret = strdup(value);
+	if (!ret)
+	{
+		pool_error("extract_string: out of memory");
+		return NULL;
+	}
+
+	if (token == POOL_STRING)
+	{
+		ret[strlen(ret)-1] = '\0';
+		return (ret+1);
+	}
+	return ret;
+}
+
+/*
+ * Try to interpret value as boolean value.  Valid values are: true,
+ * false, yes, no, on, off, 1, 0; as well as unique prefixes thereof.
+ * If the string parses okay, return true, else false.
+ * If okay and result is not NULL, return the value in *result.
+ * This function copied from PostgreSQL source code.
+ */
+static bool parse_bool_with_len(const char *value, size_t len, bool *result)
+{
+	switch (*value)
+	{
+		case 't':
+		case 'T':
+			if (strncasecmp(value, "true", len) == 0)
+			{
+				if (result)
+					*result = true;
+				return true;
+			}
+			break;
+		case 'f':
+		case 'F':
+			if (strncasecmp(value, "false", len) == 0)
+			{
+				if (result)
+					*result = false;
+				return true;
+			}
+			break;
+		case 'y':
+		case 'Y':
+			if (strncasecmp(value, "yes", len) == 0)
+			{
+				if (result)
+					*result = true;
+				return true;
+			}
+			break;
+		case 'n':
+		case 'N':
+			if (strncasecmp(value, "no", len) == 0)
+			{
+				if (result)
+					*result = false;
+				return true;
+			}
+			break;
+		case 'o':
+		case 'O':
+			/* 'o' is not unique enough */
+			if (strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
+			{
+				if (result)
+					*result = true;
+				return true;
+			}
+			else if (strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
+			{
+				if (result)
+					*result = false;
+				return true;
+			}
+			break;
+		case '1':
+			if (len == 1)
+			{
+				if (result)
+					*result = true;
+				return true;
+			}
+			break;
+		case '0':
+			if (len == 1)
+			{
+				if (result)
+					*result = false;
+				return true;
+			}
+			break;
+		default:
+			break;
+	}
+
+	if (result)
+		*result = false;		/* suppress compiler warning */
+	return false;
+}
+
+int eval_logical(char *str)
+{
+	bool result;
+
+	if (!parse_bool_with_len(str, strlen(str), &result))
+		return -1;
+
+	return (result ? 1 : 0);
+}
+
+/*
+ * Extract tokens separated by delimi from str. Return value is an
+ * array of pointers to malloced strings. number of tokens is set to
+ * n; note that str will be destroyed by strtok().
+ */
+#define MAXTOKENS 1024
+static char **extract_string_tokens(char *str, char *delimi, int *n)
+{
+	char *token;
+	static char **tokens;
+
+	*n = 0;
+
+	tokens = malloc(MAXTOKENS*sizeof(char *));
+	if (tokens == NULL)
+	{
+		pool_error("extract_string_tokens: out of memory");
+		return NULL;
+	}
+
+	for (token = strtok(str, delimi); token != NULL && *n < MAXTOKENS; token = strtok(NULL, delimi))
+	{
+		tokens[*n] = strdup(token);
+		if (tokens[*n] == NULL)
+		{
+			pool_error("extract_string_tokens: out of memory");
+			return NULL;
+		}
+		pool_debug("extract_string_tokens: token: %s", tokens[*n]);
+		(*n)++;
+	}
+	return tokens;
+}
+
+static void clear_host_entry(int slot)
+{
+	*pool_config->backend_desc->backend_info[slot].backend_hostname = '\0';
+	pool_config->backend_desc->backend_info[slot].backend_port = 0;
+	pool_config->backend_desc->backend_info[slot].backend_status = CON_UNUSED;
+	pool_config->backend_desc->backend_info[slot].backend_weight = 0.0;
+}
+
+#ifdef DEBUG
+static void print_host_entry(int slot)
+{
+	pool_debug("slot: %d host: %s port: %d status: %d weight: %f",
+			   slot,
+			   pool_config->server_hostnames[slot],
+			   pool_config->server_ports[slot],
+			   pool_config->server_status[slot],
+			   pool_config->server_weights[slot]);
+}
+#endif
+
+/* Use to set the syslog facility level if logsyslog is activated */
+int set_syslog_facility(char *value)
+{
+   int facility = LOG_LOCAL0;
+
+   if (value == NULL)
+     return facility;
+
+   if (strncmp(value, "LOCAL", 5) == 0 && strlen(value) == 6) {
+	  switch (value[5]) {
+	  case '0':
+	       facility = LOG_LOCAL0;
+	       break;
+	  case '1':
+	       facility = LOG_LOCAL1;
+	       break;
+	  case '2':
+	       facility = LOG_LOCAL2;
+	       break;
+	  case '3':
+	       facility = LOG_LOCAL3;
+	       break;
+	  case '4':
+	       facility = LOG_LOCAL4;
+	       break;
+	  case '5':
+	       facility = LOG_LOCAL5;
+	       break;
+	  case '6':
+	       facility = LOG_LOCAL6;
+	       break;
+	  case '7':
+	       facility = LOG_LOCAL7;
+	       break;
+	  }
+     }
+     return facility;
+}
+
+/*
+ * Translate binary form of backend flag to string.
+ * The returned data is in static buffer, and it will be destroyed
+ * at the next call to this function.
+ */
+char *pool_flag_to_str(unsigned short flag)
+{
+	static char buf[1024];		/* should be large enough */
+
+	if (POOL_ALLOW_TO_FAILOVER(flag))
+		snprintf(buf, sizeof(buf), "ALLOW_TO_FAILOVER");
+	else if (POOL_DISALLOW_TO_FAILOVER(flag))
+		snprintf(buf, sizeof(buf), "DISALLOW_TO_FAILOVER");
+	return buf;
+}