prestogres 0.1.0

data/pgpool2/pool_signal.h

@@ -0,0 +1,61 @@
+/* -*-pgsql-c-*- */
+/*
+ *
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL 
+ * written by Tatsuo Ishii
+ *
+ * Portions Copyright (c) 2003-2008,	PgPool Global Development Group
+ * Portions Copyright (c) 2004, PostgreSQL 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.h.: master definition header file
+ *
+ */
+
+#ifndef POOL_SIGNAL_H
+#define POOL_SIGNAL_H
+
+/*
+ * Signal stuff. Stolen from PostgreSQL source code.
+ */
+#include <signal.h>
+
+#ifdef HAVE_SIGPROCMASK
+extern sigset_t UnBlockSig,
+			BlockSig,
+			AuthBlockSig;
+
+#define POOL_SETMASK(mask)	sigprocmask(SIG_SETMASK, mask, NULL)
+#define POOL_SETMASK2(mask, oldmask)	sigprocmask(SIG_SETMASK, mask, oldmask)
+#else
+extern int	UnBlockSig,
+			BlockSig,
+			AuthBlockSig;
+
+#ifndef WIN32
+#define POOL_SETMASK(mask)	sigsetmask(*((int*)(mask)))
+#define POOL_SETMASK2(mask, oldmask)	do {oldmask = POOL_SETMASK(mask)} while (0)
+#else
+#define POOL_SETMASK(mask)		pqsigsetmask(*((int*)(mask)))
+#define POOL_SETMASK2(mask, oldmask)	do {oldmask = POOL_SETMASK(mask)} while (0)
+int			pqsigsetmask(int mask);
+#endif
+#endif
+
+typedef void (*pool_sighandler_t) (int);
+extern pool_sighandler_t pool_signal(int signo, pool_sighandler_t func);
+extern void poolinitmask(void);
+
+#endif /* POOL_SIGNAL_H */

data/pgpool2/pool_ssl.c

@@ -0,0 +1,339 @@
+/* -*-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_ssl.c: ssl negotiation functions
+ *
+ */
+
+#include <string.h>
+
+#include "config.h"
+#include "pool.h"
+#include "pool_stream.h"
+#include "pool_config.h"
+
+#ifdef USE_SSL
+
+#define SSL_RETURN_VOID_IF(cond, msg) \
+	do { \
+		if ( (cond) ) { \
+			perror_ssl( (msg) ); \
+			return; \
+		} \
+	} while (0);
+
+#define SSL_RETURN_ERROR_IF(cond, msg) \
+	do { \
+		if ( (cond) ) { \
+			perror_ssl( (msg) ); \
+			return -1; \
+		} \
+	} while (0);
+
+#include <arpa/inet.h> /* for htonl() */
+
+/* Major/minor codes to negotiate SSL prior to startup packet */
+#define NEGOTIATE_SSL_CODE ( 1234<<16 | 5679 )
+
+/* enum flag for differentiating server->client vs client->server SSL */
+enum ssl_conn_type { ssl_conn_clientserver, ssl_conn_serverclient };
+
+/* perform per-connection ssl initialization.  returns nonzero on error */
+static int init_ssl_ctx(POOL_CONNECTION *cp, enum ssl_conn_type conntype);
+
+/* OpenSSL error message */
+static void perror_ssl(const char *context);
+
+/* attempt to negotiate a secure connection */
+void pool_ssl_negotiate_clientserver(POOL_CONNECTION *cp) {
+	int ssl_packet[2] = { htonl(sizeof(int)*2), htonl(NEGOTIATE_SSL_CODE) };
+	char server_response;
+
+	cp->ssl_active = -1;
+
+	if ( (!pool_config->ssl) || init_ssl_ctx(cp, ssl_conn_clientserver))
+		return;
+
+	pool_debug("pool_ssl: sending client->server SSL request");
+	pool_write_and_flush(cp, ssl_packet, sizeof(int)*2);
+
+	if (pool_read(cp, &server_response, 1) < 0)
+	{
+		pool_error("pool_ssl_negotiate_clientserver: pool_read failed");
+		return;
+	}
+
+	pool_debug("pool_ssl: client->server SSL response: %c", server_response);
+
+	switch (server_response) {
+		case 'S':
+			SSL_set_fd(cp->ssl, cp->fd);
+			SSL_RETURN_VOID_IF( (SSL_connect(cp->ssl) < 0),
+			                    "SSL_connect");
+			cp->ssl_active = 1;
+			break;
+		case 'N':
+			/*
+			 * If backend does not support SSL but pgpool does, we get this.
+			 * i.e. This is normal.
+			 */
+			pool_debug("pool_ssl: server doesn't want to talk SSL");
+			break;
+		default:
+			pool_error("pool_ssl: unhandled response: %c", server_response);
+			break;
+	}
+}
+
+
+/* attempt to negotiate a secure connection */
+void pool_ssl_negotiate_serverclient(POOL_CONNECTION *cp) {
+
+	cp->ssl_active = -1;
+
+	if ( (!pool_config->ssl) || init_ssl_ctx(cp, ssl_conn_serverclient)) {
+		/* write back an "SSL reject" response before returning */
+		pool_write_and_flush(cp, "N", 1);
+	} else {
+		/* write back an "SSL accept" response */
+		pool_write_and_flush(cp, "S", 1);
+
+		SSL_set_fd(cp->ssl, cp->fd);
+		SSL_RETURN_VOID_IF( (SSL_accept(cp->ssl) < 0), "SSL_accept");
+		cp->ssl_active = 1;
+	}
+}
+
+void pool_ssl_close(POOL_CONNECTION *cp) {
+	if (cp->ssl) { 
+		SSL_shutdown(cp->ssl); 
+		SSL_free(cp->ssl); 
+	} 
+
+	if (cp->ssl_ctx) 
+		SSL_CTX_free(cp->ssl_ctx);
+}
+
+int pool_ssl_read(POOL_CONNECTION *cp, void *buf, int size) {
+	int n;
+	int err;
+
+ retry:
+	errno = 0;
+	n = SSL_read(cp->ssl, buf, size);
+	err = SSL_get_error(cp->ssl, n);
+
+	switch (err)
+	{
+		case SSL_ERROR_NONE:
+			break;
+		case SSL_ERROR_WANT_READ:
+		case SSL_ERROR_WANT_WRITE:
+
+			/*
+			 * Returning 0 here would cause caller to wait for read-ready,
+			 * which is not correct since what SSL wants is wait for
+			 * write-ready.  The former could get us stuck in an infinite
+			 * wait, so don't risk it; busy-loop instead.
+			 */
+			goto retry;
+
+		case SSL_ERROR_SYSCALL:
+			if (n == -1)
+			{
+				pool_error("SSL_read error: %d", err);
+			}
+			else
+			{
+				pool_error("SSL_read error: EOF detected");
+				n = -1;
+			}
+			break;
+
+		case SSL_ERROR_SSL:
+		case SSL_ERROR_ZERO_RETURN:
+			perror_ssl("SSL_read");
+			n = -1;
+			break;
+		default:
+			pool_error("pool_ssl_read: unrecognized error code: %d", err);
+			/*
+			 * We assume that the connection is broken. Returns 0
+			 * rather than -1 in this case because -1 triggers
+			 * unwanted failover in the caller (pool_read).
+			 */
+			n = 0;
+			break;
+	}
+
+	return n;
+}
+
+int pool_ssl_write(POOL_CONNECTION *cp, const void *buf, int size)
+{
+	int n;
+	int err;
+
+retry:
+	errno = 0;
+	n = SSL_write(cp->ssl, buf, size);
+	err = SSL_get_error(cp->ssl, n);
+	switch (err)
+	{
+		case SSL_ERROR_NONE:
+			break;
+
+		case SSL_ERROR_WANT_READ:
+		case SSL_ERROR_WANT_WRITE:
+			goto retry;
+
+		case SSL_ERROR_SYSCALL:
+			if (n == -1)
+			{
+				pool_error("SSL_write error: %d", err);
+			}
+			else
+			{
+				pool_error("SSL_write error: EOF detected");
+				n = -1;
+			}
+			break;
+
+		case SSL_ERROR_SSL:
+		case SSL_ERROR_ZERO_RETURN:
+			perror_ssl("SSL_write");
+			n = -1;
+			break;
+
+		default:
+			pool_error("pool_ssl_write: unrecognized error code: %d", err);
+			/*
+			 * We assume that the connection is broken.
+			 */
+			n = -1;
+			break;
+	}
+	return n;
+}
+
+static int init_ssl_ctx(POOL_CONNECTION *cp, enum ssl_conn_type conntype) {
+	int error = 0;
+	char *cacert = NULL, *cacert_dir = NULL;
+
+	/* initialize SSL members */
+	cp->ssl_ctx = SSL_CTX_new(TLSv1_method());
+	SSL_RETURN_ERROR_IF( (! cp->ssl_ctx), "SSL_CTX_new" );
+
+	if ( conntype == ssl_conn_serverclient) {
+		error = SSL_CTX_use_certificate_file(cp->ssl_ctx,
+		                                     pool_config->ssl_cert,
+		                                     SSL_FILETYPE_PEM);
+		SSL_RETURN_ERROR_IF( (error <= 0), "Loading SSL certificate");
+
+		error = SSL_CTX_use_PrivateKey_file(cp->ssl_ctx,
+		                                    pool_config->ssl_key,
+		                                    SSL_FILETYPE_PEM);
+		SSL_RETURN_ERROR_IF( (error <= 0), "Loading SSL private key");
+	} else {
+		/* set extra verification if ssl_ca_cert or ssl_ca_cert_dir are set */
+		if (strlen(pool_config->ssl_ca_cert))
+			cacert = pool_config->ssl_ca_cert;
+		if (strlen(pool_config->ssl_ca_cert_dir))
+			cacert_dir = pool_config->ssl_ca_cert_dir;
+    
+		if ( cacert || cacert_dir ) {
+			error = (!SSL_CTX_load_verify_locations(cp->ssl_ctx,
+			                                        cacert,
+			                                        cacert_dir));
+			SSL_RETURN_ERROR_IF(error, "SSL verification setup");
+			SSL_CTX_set_verify(cp->ssl_ctx, SSL_VERIFY_PEER, NULL);
+		}
+	}
+
+	cp->ssl = SSL_new(cp->ssl_ctx);
+	SSL_RETURN_ERROR_IF( (! cp->ssl), "SSL_new");
+
+	return 0;
+}
+
+static void perror_ssl(const char *context) {
+	unsigned long err;
+	static const char *no_err_reason = "no SSL error reported";
+	const char *reason;
+
+	err = ERR_get_error();
+	if (! err) {
+		reason = no_err_reason;
+	} else {
+		reason = ERR_reason_error_string(err);
+	}
+
+	if (reason != NULL) {
+		pool_error("pool_ssl: %s: %s", context, reason);
+	} else {
+		pool_error("pool_ssl: %s: Unknown SSL error %lu", context, err);
+	}
+}
+
+/*
+ * Return true if SSL layer has any pending data in buffer
+ */
+bool pool_ssl_pending(POOL_CONNECTION *cp)
+{
+	if (cp->ssl_active > 0 && SSL_pending(cp->ssl) > 0)
+		return true;
+	return false;
+}
+
+#else /* USE_SSL: wrap / no-op ssl functionality if it's not available */
+
+void pool_ssl_negotiate_serverclient(POOL_CONNECTION *cp) {
+	pool_debug("pool_ssl: SSL requested but SSL support is not available");
+	pool_write_and_flush(cp, "N", 1);
+	cp->ssl_active = -1;
+}
+
+void pool_ssl_negotiate_clientserver(POOL_CONNECTION *cp) {
+	pool_debug("pool_ssl: SSL requested but SSL support is not available");
+	cp->ssl_active = -1;
+}
+
+void pool_ssl_close(POOL_CONNECTION *cp) { return; }
+
+int pool_ssl_read(POOL_CONNECTION *cp, void *buf, int size) {
+	pool_error("pool_ssl: SSL i/o called but SSL support is not available");
+	notice_backend_error(cp->db_node_id);
+	child_exit(1);
+	return -1; /* never reached */
+}
+
+int pool_ssl_write(POOL_CONNECTION *cp, const void *buf, int size) {
+	pool_error("pool_ssl: SSL i/o called but SSL support is not available");
+	notice_backend_error(cp->db_node_id);
+	child_exit(1);
+	return -1; /* never reached */
+}
+
+bool pool_ssl_pending(POOL_CONNECTION *cp)
+{
+	return false;
+}
+
+#endif /* USE_SSL */

data/pgpool2/pool_stream.c

@@ -0,0 +1,962 @@
+/* -*-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_stream.c: stream I/O modules
+*
+*/
+
+#include "config.h"
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+
+#include "pool.h"
+#include "pool_stream.h"
+#include "pool_config.h"
+
+static int mystrlen(char *str, int upper, int *flag);
+static int mystrlinelen(char *str, int upper, int *flag);
+static int save_pending_data(POOL_CONNECTION *cp, void *data, int len);
+static int consume_pending_data(POOL_CONNECTION *cp, void *data, int len);
+
+/*
+* open read/write file descriptors.
+* returns POOL_CONNECTION on success otherwise NULL.
+*/
+POOL_CONNECTION *pool_open(int fd)
+{
+	POOL_CONNECTION *cp;
+
+	cp = (POOL_CONNECTION *)malloc(sizeof(POOL_CONNECTION));
+	if (cp == NULL)
+	{
+		pool_error("pool_open: malloc failed: %s", strerror(errno));
+		return NULL;
+	}
+
+	memset(cp, 0, sizeof(*cp));
+
+	/* initialize write buffer */
+	cp->wbuf = malloc(WRITEBUFSZ);
+	if (cp->wbuf == NULL)
+	{
+		pool_error("pool_open: malloc failed");
+		return NULL;
+	}
+	cp->wbufsz = WRITEBUFSZ;
+	cp->wbufpo = 0;
+
+	/* initialize pending data buffer */
+	cp->hp = malloc(READBUFSZ);
+	if (cp->hp == NULL)
+	{
+		pool_error("pool_open: malloc failed");
+		free(cp);
+		return NULL;
+	}
+	cp->bufsz = READBUFSZ;
+	cp->po = 0;
+	cp->len = 0;
+	cp->sbuf = NULL;
+	cp->sbufsz = 0;
+	cp->buf2 = NULL;
+	cp->bufsz2 = 0;
+
+	cp->fd = fd;
+	return cp;
+}
+
+/*
+* close read/write file descriptors.
+*/
+void pool_close(POOL_CONNECTION *cp)
+{
+	/*
+	 * shutdown connection to the client so that pgpool is not blocked
+	 */
+	if (!cp->isbackend)
+		shutdown(cp->fd, 1);
+	close(cp->fd);
+
+	free(cp->wbuf);
+	free(cp->hp);
+	if (cp->sbuf)
+		free(cp->sbuf);
+	if (cp->buf2)
+		free(cp->buf2);
+	pool_discard_params(&cp->params);
+
+	pool_ssl_close(cp);
+
+	free(cp);
+}
+
+/*
+* read len bytes from cp
+* returns 0 on success otherwise -1.
+*/
+int pool_read(POOL_CONNECTION *cp, void *buf, int len)
+{
+	static char readbuf[READBUFSZ];
+
+	int consume_size;
+	int readlen;
+
+	consume_size = consume_pending_data(cp, buf, len);
+	len -= consume_size;
+	buf += consume_size;
+
+	while (len > 0)
+	{
+		if (pool_check_fd(cp))
+		{
+			if (!IS_MASTER_NODE_ID(cp->db_node_id) && (getpid() != mypid))
+			{
+				pool_log("pool_read: data is not ready in DB node: %d. abort this session",
+						 cp->db_node_id);
+				exit(1);
+			}
+			else
+			{
+				pool_error("pool_read: pool_check_fd failed (%s)", strerror(errno));
+			    return -1;
+			}
+		}
+
+		if (cp->ssl_active > 0) {
+		  readlen = pool_ssl_read(cp, readbuf, READBUFSZ);
+		} else {
+		  readlen = read(cp->fd, readbuf, READBUFSZ);
+		}
+
+		if (readlen == -1)
+		{
+			if (errno == EINTR || errno == EAGAIN)
+			{
+				pool_debug("pool_read: retrying due to %s", strerror(errno));
+				continue;
+			}
+
+			pool_error("pool_read: read failed (%s)", strerror(errno));
+
+			if (cp->isbackend)
+			{
+				/* if fail_over_on_backend_error is true, then trigger failover */
+				if (pool_config->fail_over_on_backend_error)
+				{
+					notice_backend_error(cp->db_node_id);
+					child_exit(1);
+					pool_log("pool_read: do not failover because I am the main process");
+					return -1;
+				}
+				else
+				{
+					pool_log("pool_read: do not failover because fail_over_on_backend_error is off");
+					return -1;
+				}
+			}
+			else
+			{
+			    return -1;
+			}
+		}
+		else if (readlen == 0)
+		{
+			if (cp->isbackend)
+			{
+				pool_error("pool_read: EOF encountered with backend");
+				return -1;
+
+#ifdef NOT_USED
+			    /* fatal error, notice to parent and exit */
+			    notice_backend_error(IS_MASTER_NODE_ID(cp->db_node_id));
+				child_exit(1);
+#endif
+			}
+			else
+			{
+				/*
+				 * if backend offers authentication method, frontend could close connection
+				 */
+				return -1;
+			}
+		}
+
+		if (len < readlen)
+		{
+			/* overrun. we need to save remaining data to pending buffer */
+			if (save_pending_data(cp, readbuf+len, readlen-len))
+				return -1;
+			memmove(buf, readbuf, len);
+			break;
+		}
+
+		memmove(buf, readbuf, readlen);
+		buf += readlen;
+		len -= readlen;
+	}
+
+	return 0;
+}
+
+/*
+* read exactly len bytes from cp
+* returns buffer address on success otherwise NULL.
+*/
+char *pool_read2(POOL_CONNECTION *cp, int len)
+{
+	char *buf;
+	int req_size;
+	int alloc_size;
+	int consume_size;
+	int readlen;
+
+	req_size = cp->len + len;
+
+	if (req_size > cp->bufsz2)
+	{
+		alloc_size = ((req_size+1)/READBUFSZ+1)*READBUFSZ;
+		cp->buf2 = realloc(cp->buf2, alloc_size);
+		if (cp->buf2 == NULL)
+		{
+			pool_error("pool_read2: failed to realloc");
+			exit(1);
+		}
+		cp->bufsz2 = alloc_size;
+	}
+
+	buf = cp->buf2;
+
+	consume_size = consume_pending_data(cp, buf, len);
+	len -= consume_size;
+	buf += consume_size;
+
+	while (len > 0)
+	{
+		if (pool_check_fd(cp))
+		{
+			if (!IS_MASTER_NODE_ID(cp->db_node_id))
+			{
+				pool_log("pool_read2: data is not ready in DB node:%d. abort this session",
+						 cp->db_node_id);
+				exit(1);
+			}
+			else
+			{
+				pool_error("pool_read2: pool_check_fd failed (%s)", strerror(errno));
+			    return NULL;
+			}
+		}
+
+		if (cp->ssl_active > 0) {
+		  readlen = pool_ssl_read(cp, buf, len);
+		} else {
+		  readlen = read(cp->fd, buf, len);
+		}
+
+		if (readlen == -1)
+		{
+			if (errno == EINTR || errno == EAGAIN)
+			{
+				pool_debug("pool_read2: retrying due to %s", strerror(errno));
+				continue;
+			}
+
+			pool_error("pool_read2: read failed (%s)", strerror(errno));
+
+			if (cp->isbackend)
+			{
+				/* if fail_over_on_backend_error is true, then trigger failover */
+				if (pool_config->fail_over_on_backend_error)
+				{
+					notice_backend_error(cp->db_node_id);
+					child_exit(1);
+					pool_log("pool_read2: do not failover because I am the main process");
+					return NULL;
+				}
+				else
+				{
+					pool_log("pool_read2: do not failover because fail_over_on_backend_error is off");
+					return NULL;
+				}
+			}
+			else
+			{
+			    return NULL;
+			}
+		}
+		else if (readlen == 0)
+		{
+			if (cp->isbackend)
+			{
+				pool_error("pool_read2: EOF encountered with backend");
+				return NULL;
+
+#ifdef NOT_USED
+			    /* fatal error, notice to parent and exit */
+			    notice_backend_error(IS_MASTER_NODE_ID(cp->db_node_id));
+				child_exit(1);
+#endif
+			}
+			else
+			{
+				/*
+				 * if backend offers authentication method, frontend could close connection
+				 */
+				return NULL;
+			}
+		}
+
+		buf += readlen;
+		len -= readlen;
+	}
+
+	return cp->buf2;
+}
+
+/*
+* write len bytes to cp the write buffer.
+* returns 0 on success otherwise -1.
+*/
+int pool_write(POOL_CONNECTION *cp, void *buf, int len)
+{
+	if (len < 0)
+	{
+		pool_error("pool_write: invalid request size: %d", len);
+		return -1;
+	}
+
+	if (cp->no_forward)
+		return 0;
+
+	while (len > 0)
+	{
+		int remainder = WRITEBUFSZ - cp->wbufpo;
+
+		if (cp->wbufpo >= WRITEBUFSZ)
+		{
+			/*
+			 * Write buffer is full. so flush buffer.
+			 * wbufpo is reset in pool_flush_it().
+			 */
+			if (pool_flush_it(cp) == -1)
+				return -1;
+			remainder = WRITEBUFSZ;
+		}
+
+		/* check buffer size */
+		if (remainder >= len)
+		{
+			/* OK, buffer size is enough. */
+			remainder = len;
+		}
+		memcpy(cp->wbuf+cp->wbufpo, buf, remainder);
+		cp->wbufpo += remainder;
+		buf += remainder;
+		len -= remainder;
+	}
+
+	return 0;
+}
+
+/*
+ * flush write buffer
+ */
+int pool_flush_it(POOL_CONNECTION *cp)
+{
+	int sts;
+	int wlen;
+	int offset;
+	wlen = cp->wbufpo;
+
+	if (wlen == 0)
+	{
+		return 0;
+	}
+
+	offset = 0;
+
+	for (;;)
+	{
+		errno = 0;
+
+#ifdef NOT_USED
+		if (!cp->isbackend)
+		{
+			fd_set	writemask;
+			fd_set	exceptmask;
+
+			FD_ZERO(&writemask);
+			FD_ZERO(&exceptmask);
+			FD_SET(cp->fd, &writemask);
+			FD_SET(cp->fd, &exceptmask);
+
+			sts = select(cp->fd+1, NULL, &writemask, &exceptmask, NULL);
+			if (sts == -1)
+			{
+				if (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK)
+					continue;
+
+				pool_error("pool_flush_it: select() failed. reason: %s", strerror(errno));
+				cp->wbufpo = 0;
+				return -1;
+			}
+			else if (sts == 0)
+			{
+				continue;
+			}
+			else if (FD_ISSET(cp->fd, &exceptmask))
+			{
+				pool_log("pool_flush_it: exception occurred");
+				cp->wbufpo = 0;
+				return -1;
+			}
+		}
+#endif
+		if (cp->ssl_active > 0) {
+		  sts = pool_ssl_write(cp, cp->wbuf + offset, wlen);
+		} else {
+		  sts = write(cp->fd, cp->wbuf + offset, wlen);
+		}
+
+		if (sts > 0)
+		{
+			wlen -= sts;
+
+			if (wlen == 0)
+			{
+				/* write completed */
+				break;
+			}
+
+			else if (wlen < 0)
+			{
+				pool_error("pool_flush_it: invalid write size %d", sts);
+				cp->wbufpo = 0;
+				return -1;
+			}
+
+			else
+			{
+				/* need to write remaining data */
+				offset += sts;
+				continue;
+			}
+		}
+
+		else if (errno == EAGAIN || errno == EINTR)
+		{
+			continue;
+		}
+
+		else
+		{
+			/* If this is the backend stream, report error. Otherwise
+			 * just report debug message.
+			 */
+			if (cp->isbackend)
+				pool_error("pool_flush_it: write failed to backend (%d). reason: %s offset: %d wlen: %d",
+						   cp->db_node_id, strerror(errno), offset, wlen);
+			else
+				pool_debug("pool_flush_it: write failed to frontend. reason: %s offset: %d wlen: %d",
+						   strerror(errno), offset, wlen);
+
+			cp->wbufpo = 0;
+			return -1;
+		}
+	}
+
+	cp->wbufpo = 0;
+
+	return 0;
+}
+
+/*
+* flush write buffer and degenerate/failover if error occurs
+*/
+int pool_flush(POOL_CONNECTION *cp)
+{
+	if (pool_flush_it(cp) == -1)
+	{
+		if (cp->isbackend)
+		{
+			/* if fail_over_on_backend_error is true, then trigger failover */
+			if (pool_config->fail_over_on_backend_error)
+			{
+				notice_backend_error(cp->db_node_id);
+				child_exit(1);
+				pool_log("pool_flush: do not failover because I am the main process");
+				return -1;
+			}
+			else
+			{
+				pool_log("pool_flush: do not failover because fail_over_on_backend_error is off");
+				return -1;
+			}
+		}
+		else
+		{
+			/*
+			 * If we are in replication mode, we need to continue the
+			 * processing with backends to keep consistency among
+			 * backends, thus ignore error.
+			 */
+			if (REPLICATION)
+				return 0;
+			else
+				return -1;
+		}
+	}
+	return 0;
+}
+
+/*
+* combo of pool_write and pool_flush
+*/
+int pool_write_and_flush(POOL_CONNECTION *cp, void *buf, int len)
+{
+	if (pool_write(cp, buf, len))
+		return -1;
+	return pool_flush(cp);
+}
+
+/*
+ * read a string until EOF or NULL is encountered.
+ * if line is not 0, read until new line is encountered.
+*/
+char *pool_read_string(POOL_CONNECTION *cp, int *len, int line)
+{
+	int readp;
+	int readsize;
+	int readlen;
+	int strlength;
+	int flag;
+	int consume_size;
+
+#ifdef DEBUG
+	static char pbuf[READBUFSZ];
+#endif
+
+	*len = 0;
+	readp = 0;
+
+	/* initialize read buffer */
+	if (cp->sbufsz == 0)
+	{
+		cp->sbuf = malloc(READBUFSZ);
+		if (cp->sbuf == NULL)
+		{
+			pool_error("pool_read_string: malloc failed");
+			return NULL;
+		}
+		cp->sbufsz = READBUFSZ;
+		*cp->sbuf = '\0';
+	}
+
+	/* any pending data? */
+	if (cp->len)
+	{
+		if (line)
+			strlength = mystrlinelen(cp->hp+cp->po, cp->len, &flag);
+		else
+			strlength = mystrlen(cp->hp+cp->po, cp->len, &flag);
+
+		/* buffer is too small? */
+		if ((strlength + 1) > cp->sbufsz)
+		{
+			cp->sbufsz = ((strlength+1)/READBUFSZ+1)*READBUFSZ;
+			cp->sbuf = realloc(cp->sbuf, cp->sbufsz);
+			if (cp->sbuf == NULL)
+			{
+				pool_error("pool_read_string: realloc failed");
+				return NULL;
+			}
+		}
+
+		/* consume pending and save to read string buffer */
+		consume_size = consume_pending_data(cp, cp->sbuf, strlength);
+
+		*len = strlength;
+
+		/* is the string null terminated? */
+		if (consume_size == strlength && !flag)
+		{
+			/* not null or line terminated.
+			 * we need to read more since we have not encountered NULL or new line yet
+			 */
+			readsize = cp->sbufsz - strlength;
+			readp = strlength;
+		}
+		else
+		{
+			pool_debug("pool_read_string: read all from pending data. po:%d len:%d",
+					   cp->po, cp->len);
+			return cp->sbuf;
+		}
+	} else
+	{
+		readsize = cp->sbufsz;
+	}
+
+	for (;;)
+	{
+		if (pool_check_fd(cp))
+		{
+			if (!IS_MASTER_NODE_ID(cp->db_node_id))
+			{
+				pool_log("pool_read_string: data is not ready in DB node:%d. abort this session",
+						 cp->db_node_id);
+				exit(1);
+			}
+			else
+			{
+				pool_error("pool_read_string: pool_check_fd failed (%s)", strerror(errno));
+			    return NULL;
+			}
+		}
+
+		if (cp->ssl_active > 0) {
+		  readlen = pool_ssl_read(cp, cp->sbuf+readp, readsize);
+		} else {
+		  readlen = read(cp->fd, cp->sbuf+readp, readsize);
+		}
+
+		if (readlen == -1)
+		{
+			pool_error("pool_read_string: read() failed. reason:%s", strerror(errno));
+
+			if (cp->isbackend)
+			{
+				notice_backend_error(cp->db_node_id);
+				child_exit(1);
+				return NULL;
+			}
+			else
+			{
+			    return NULL;
+			}
+		}
+		else if (readlen == 0)	/* EOF detected */
+		{
+			/*
+			 * just returns an error, not trigger failover or degeneration
+			 */
+			pool_error("pool_read_string: read () EOF detected");
+			return NULL;
+		}
+
+		/* check overrun */
+		if (line)
+			strlength = mystrlinelen(cp->sbuf+readp, readlen, &flag);
+		else
+			strlength = mystrlen(cp->sbuf+readp, readlen, &flag);
+
+		if (strlength < readlen)
+		{
+			save_pending_data(cp, cp->sbuf+readp+strlength, readlen-strlength);
+			*len += strlength;
+			pool_debug("pool_read_string: total result %d with pending data po:%d len:%d", *len, cp->po, cp->len);
+			return cp->sbuf;
+		}
+
+		*len += readlen;
+
+		/* encountered null or newline? */
+		if (flag)
+		{
+			/* ok we have read all data */
+			pool_debug("pool_read_string: total result %d ", *len);
+			break;
+		}
+
+		readp += readlen;
+		readsize = READBUFSZ;
+
+		if ((*len+readsize) > cp->sbufsz)
+		{
+			cp->sbufsz += READBUFSZ;
+
+			cp->sbuf = realloc(cp->sbuf, cp->sbufsz);
+			if (cp->sbuf == NULL)
+			{
+				pool_error("pool_read_string: realloc failed");
+				return NULL;
+			}
+		}
+	}
+	return cp->sbuf;
+}
+
+/*
+ * returns the byte length of str, including \0, no more than upper.
+ * if encountered \0, flag is set to non 0.
+ * example:
+ *	mystrlen("abc", 2) returns 2
+ *	mystrlen("abc", 3) returns 3
+ *	mystrlen("abc", 4) returns 4
+ *	mystrlen("abc", 5) returns 4
+ */
+static int mystrlen(char *str, int upper, int *flag)
+{
+	int len;
+
+	*flag = 0;
+
+	for (len = 0;len < upper; len++, str++)
+	{
+	    if (!*str)
+	    {
+			len++;
+			*flag = 1;
+			break;
+	    }
+	}
+	return len;
+}
+
+/*
+ * returns the byte length of str terminated by \n or \0 (including \n or \0), no more than upper.
+ * if encountered \0 or \n, flag is set to non 0.
+ * example:
+ *	mystrlinelen("abc", 2) returns 2
+ *	mystrlinelen("abc", 3) returns 3
+ *	mystrlinelen("abc", 4) returns 4
+ *	mystrlinelen("abc", 5) returns 4
+ *	mystrlinelen("abcd\nefg", 4) returns 4
+ *	mystrlinelen("abcd\nefg", 5) returns 5
+ *	mystrlinelen("abcd\nefg", 6) returns 5
+ */
+static int mystrlinelen(char *str, int upper, int *flag)
+{
+	int len;
+
+	*flag = 0;
+
+	for (len = 0;len < upper; len++, str++)
+	{
+	    if (!*str || *str == '\n')
+	    {
+			len++;
+			*flag = 1;
+			break;
+	    }
+	}
+	return len;
+}
+
+/*
+ * save pending data
+ */
+static int save_pending_data(POOL_CONNECTION *cp, void *data, int len)
+{
+	int reqlen;
+	size_t realloc_size;
+	char *p;
+
+	/* to be safe */
+	if (cp->len == 0)
+		cp->po = 0;
+
+	reqlen = cp->po + cp->len + len;
+
+	/* pending buffer is enough? */
+	if (reqlen > cp->bufsz)
+	{
+		/* too small, enlarge it */
+		realloc_size = (reqlen/READBUFSZ+1)*READBUFSZ;
+		p = realloc(cp->hp, realloc_size);
+		if (p == NULL)
+		{
+			pool_error("save_pending_data: realloc failed");
+			return -1;
+		}
+
+		cp->bufsz = realloc_size;
+		cp->hp = p;
+	}
+
+	memmove(cp->hp + cp->po + cp->len, data, len);
+	cp->len += len;
+
+	return 0;
+}
+
+/*
+ * consume pending data. returns actually consumed data length.
+ */
+static int consume_pending_data(POOL_CONNECTION *cp, void *data, int len)
+{
+	int consume_size;
+
+	if (cp->len <= 0)
+		return 0;
+
+	consume_size = Min(len, cp->len);
+	memmove(data, cp->hp + cp->po, consume_size);
+	cp->len -= consume_size;
+
+	if (cp->len <= 0)
+		cp->po = 0;
+	else
+		cp->po += consume_size;
+
+	return consume_size;
+}
+
+/*
+ * pool_unread: Put back data to input buffer
+ */
+int pool_unread(POOL_CONNECTION *cp, void *data, int len)
+{
+	void *p = cp->hp;
+	int n = cp->len + len;
+	int realloc_size;
+
+	if (cp->bufsz < n)
+	{
+		realloc_size = (n/READBUFSZ+1)*READBUFSZ;
+		p = realloc(cp->hp, realloc_size);
+		if (p == NULL)
+		{
+			pool_error("pool_unread: realloc failed");
+			return -1;
+		}
+		cp->hp = p;
+	}
+	if (cp->len != 0)
+		memmove(p + len, cp->hp + cp->po, cp->len);
+	memmove(p, data, len);
+	cp->len = n;
+	cp->po = 0;
+	return 0;
+}
+
+/*
+ * pool_push: Push data into buffer stack.
+ */
+int pool_push(POOL_CONNECTION *cp, void *data, int len)
+{
+	char *p;
+
+	pool_debug("pool_push: len: %d", len);
+
+	if (cp->bufsz3 == 0)
+	{
+		p = cp->buf3 = malloc(len);
+		if (p == NULL)
+		{
+			pool_error("pool_push: malloc failed. len:%d", len);
+			return -1;
+		}
+	}
+	else
+	{
+		p = cp->buf3 + cp->bufsz3;
+		cp->buf3 = realloc(cp->buf3, cp->bufsz3 + len);
+	}
+
+	memcpy(p, data, len);
+	cp->bufsz3 += len;
+
+	return 0;
+}
+
+/*
+ * pool_pop: Pop data from buffer stack and put back data using
+ * pool_unread.
+ */
+void pool_pop(POOL_CONNECTION *cp, int *len)
+{
+	if (cp->bufsz3 == 0)
+	{
+		*len = 0;
+		pool_debug("pool_pop: len: %d", *len);
+		return;
+	}
+
+	pool_unread(cp, cp->buf3, cp->bufsz3);
+	*len = cp->bufsz3;
+	free(cp->buf3);
+	cp->bufsz3 = 0;
+	cp->buf3 = NULL;
+	pool_debug("pool_pop: len: %d", *len);
+}
+
+/*
+ * pool_stacklen: Returns buffer stack length
+ * pool_unread.
+ */
+int pool_stacklen(POOL_CONNECTION *cp)
+{
+	return cp->bufsz3;
+}
+
+/*
+ * set non-block flag
+ */
+void pool_set_nonblock(int fd)
+{
+	int var;
+
+	/* set fd to none blocking */
+	var = fcntl(fd, F_GETFL, 0);
+	if (var == -1)
+	{
+		pool_error("fcntl failed. %s", strerror(errno));
+		child_exit(1);
+	}
+	if (fcntl(fd, F_SETFL, var | O_NONBLOCK) == -1)
+	{
+		pool_error("fcntl failed. %s", strerror(errno));
+		child_exit(1);
+	}
+}
+
+/*
+ * unset non-block flag
+ */
+void pool_unset_nonblock(int fd)
+{
+	int var;
+
+	/* set fd to none blocking */
+	var = fcntl(fd, F_GETFL, 0);
+	if (var == -1)
+	{
+		pool_error("fcntl failed. %s", strerror(errno));
+		child_exit(1);
+	}
+	if (fcntl(fd, F_SETFL, var & ~O_NONBLOCK) == -1)
+	{
+		pool_error("fcntl failed. %s", strerror(errno));
+		child_exit(1);
+	}
+}