prestogres 0.1.0

data/pgpool2/pool_auth.c

@@ -0,0 +1,1390 @@
+/* -*-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_auth.c: authentication stuff
+ *
+*/
+
+#include "pool.h"
+#include "pool_stream.h"
+#include "pool_config.h"
+#include "pool_passwd.h"
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_PARAM_H
+#include <param.h>
+#endif
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define AUTHFAIL_ERRORCODE "28000"
+
+static POOL_STATUS pool_send_backend_key_data(POOL_CONNECTION *frontend, int pid, int key, int protoMajor);
+static int do_clear_text_password(POOL_CONNECTION *backend, POOL_CONNECTION *frontend, int reauth, int protoMajor);
+static void pool_send_auth_fail(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *cp);
+static int do_crypt(POOL_CONNECTION *backend, POOL_CONNECTION *frontend, int reauth, int protoMajor);
+static int do_md5(POOL_CONNECTION *backend, POOL_CONNECTION *frontend, int reauth, int protoMajor);
+//static int send_md5auth_request(POOL_CONNECTION *frontend, int protoMajor, char *salt);
+//static int read_password_packet(POOL_CONNECTION *frontend, int protoMajor, 	char *password, int *pwdSize);
+static int send_password_packet(POOL_CONNECTION *backend, int protoMajor, char *password);
+static int send_auth_ok(POOL_CONNECTION *frontend, int protoMajor);
+
+/*
+ * After sending the start up packet to the backend, do the
+ * authentication against backend. if success return 0 otherwise non
+ * 0.
+*/
+int pool_do_auth(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *cp)
+{
+	signed char kind;
+	int pid;
+	int key;
+	int protoMajor;
+	int length;
+	int authkind;
+	int i;
+	StartupPacket *sp;
+
+	protoMajor = MAJOR(cp);
+
+	kind = pool_read_kind(cp);
+	if (kind < 0)
+	{
+		return -1;
+	}
+
+	/* error response? */
+	if (kind == 'E')
+	{
+		/* we assume error response at this stage is likely version
+		 * protocol mismatch (v3 frontend vs. v2 backend). So we throw
+		 * a V2 protocol error response in the hope that v3 frontend
+		 * will negotiate again using v2 protocol.
+		 */
+		pool_log("pool_do_auth: maybe protocol version mismatch (current version %d)", protoMajor);
+		ErrorResponse(frontend, cp);
+		return -1;
+	}
+	else if (kind != 'R')
+	{
+		pool_error("pool_do_auth: expect \"R\" got %c", kind);
+		return -1;
+	}
+
+	/*
+	 * message length (v3 only)
+	 */
+	if (protoMajor == PROTO_MAJOR_V3 && pool_read_message_length(cp) < 0)
+	{
+		pool_error("Failed to read the authentication packet length. \
+This is likely caused by the inconsistency of auth method among DB nodes. \
+In this case you can check the previous error messages (hint: length field) \
+from pool_read_message_length and recheck the pg_hba.conf settings.");
+		return -1;
+	}
+
+	/*
+	 * read authentication request kind.
+	 *
+	 * 0: authentication ok
+	 * 1: kerberos v4
+	 * 2: kerberos v5
+	 * 3: clear text password
+	 * 4: crypt password
+	 * 5: md5 password
+	 * 6: scm credential
+	 *
+	 * in replication mode, we only support  kind = 0, 3. this is because "salt"
+	 * cannot be replicated.
+	 * in non replication mode, we support kind = 0, 3, 4, 5
+	 */
+
+	authkind = pool_read_int(cp);
+	if (authkind < 0)
+	{
+		pool_error("pool_do_auth: read auth kind failed");
+		return -1;
+	}
+
+	authkind = ntohl(authkind);
+
+	pool_debug("pool_do_auth: auth kind:%d", authkind);
+
+	/* trust? */
+	if (authkind == 0)
+	{
+		int msglen;
+
+		pool_write(frontend, "R", 1);
+
+		if (protoMajor == PROTO_MAJOR_V3)
+		{
+			msglen = htonl(8);
+			pool_write(frontend, &msglen, sizeof(msglen));
+		}
+
+		msglen = htonl(0);
+		if (pool_write_and_flush(frontend, &msglen, sizeof(msglen)) < 0)
+		{
+			return -1;
+		}
+		MASTER(cp)->auth_kind = 0;
+	}
+
+	/* clear text password authentication? */
+	else if (authkind == 3)
+	{
+		for (i=0;i<NUM_BACKENDS;i++)
+		{
+			if (!VALID_BACKEND(i))
+				continue;
+
+			pool_debug("trying clear text password authentication");
+
+			authkind = do_clear_text_password(CONNECTION(cp, i), frontend, 0, protoMajor);
+
+			if (authkind < 0)
+			{
+				pool_debug("do_clear_text_password failed in slot %d", i);
+				pool_send_auth_fail(frontend, cp);
+				return -1;
+			}
+		}
+	}
+
+	/* crypt authentication? */
+	else if (authkind == 4)
+	{
+		for (i=0;i<NUM_BACKENDS;i++)
+		{
+			if (!VALID_BACKEND(i))
+				continue;
+
+			pool_debug("trying crypt authentication");
+
+			authkind = do_crypt(CONNECTION(cp, i), frontend, 0, protoMajor);
+
+			if (authkind < 0)
+			{
+				pool_debug("do_crypt_text_password failed in slot %d", i);
+				pool_send_auth_fail(frontend, cp);
+				return -1;
+			}
+		}
+	}
+
+	/* md5 authentication? */
+	else if (authkind == 5)
+	{
+		/* If MD5 auth is not active in pool_hba.conf, it cannot be
+		 * used with other than raw mode.
+		 */
+		if (frontend->auth_method != uaMD5 && !RAW_MODE && NUM_BACKENDS > 1)
+		{
+			pool_send_error_message(frontend, protoMajor, AUTHFAIL_ERRORCODE,
+									"MD5 authentication is unsupported in replication, master-slave and parallel modes.",
+									"",
+									"check pg_hba.conf",
+									__FILE__, __LINE__);
+			return -1;
+		}
+
+		for (i=0;i<NUM_BACKENDS;i++)
+		{
+			if (!VALID_BACKEND(i))
+				continue;
+
+			pool_debug("trying md5 authentication");
+
+			authkind = do_md5(CONNECTION(cp, i), frontend, 0, protoMajor);
+
+			if (authkind < 0)
+			{
+				pool_debug("do_md5failed in slot %d", i);
+				pool_send_auth_fail(frontend, cp);
+				return -1;
+			}
+		}
+	}
+
+	else
+	{
+		pool_error("pool_do_auth: unsupported auth kind received: %d", authkind);
+		return -1;
+	}
+
+	if (authkind != 0)
+	{
+		pool_error("pool_do_auth: unknown authentication response from backend %d", authkind);
+		return -1;
+	}
+
+	/*
+	 * authentication ok. now read pid and secret key from the
+	 * backend
+	 */
+	for (;;)
+	{
+		char *message;
+
+		kind = pool_read_kind(cp);
+		if (kind < 0)
+		{
+			pool_error("pool_do_auth: failed to read kind before BackendKeyData");
+			return -1;
+		}
+		else if (kind == 'K')
+			break;
+
+		if (protoMajor == PROTO_MAJOR_V3)
+		{
+			switch (kind)
+			{
+				case 'S':
+					/* process parameter status */
+					if (ParameterStatus(frontend, cp) != POOL_CONTINUE)
+						return -1;
+					pool_flush(frontend);
+					break;
+
+				case 'N':
+					if (pool_extract_error_message(true, MASTER(cp), protoMajor, true, &message) == 1)
+					{
+						pool_log("pool_do_auth: notice message from backend:%s", message);
+					}
+					/* process notice message */
+					if (SimpleForwardToFrontend(kind, frontend, cp))
+						return -1;
+					pool_flush(frontend);
+					break;
+
+					/* process error message */
+				case 'E':
+					if (pool_extract_error_message(true, MASTER(cp), protoMajor, true, &message) == 1)
+					{
+						pool_log("pool_do_auth: error message from backend:%s", message);
+					}
+					SimpleForwardToFrontend(kind, frontend, cp);
+					pool_flush(frontend);
+					return -1;
+					break;
+
+				default:
+					pool_error("pool_do_auth: unknown response \"%c\" before processing BackendKeyData",
+							   kind);
+					return -1;
+					break;
+			}
+		}
+		else
+		{
+			/* V2 case */
+			switch (kind)
+			{
+				case 'N':
+					/* process notice message */
+					if (NoticeResponse(frontend, cp) != POOL_CONTINUE)
+						return -1;
+					break;
+
+					/* process error message */
+				case 'E':
+					ErrorResponse(frontend, cp);
+					return -1;
+					break;
+
+				default:
+					pool_error("pool_do_auth: unknown response \"%c\" before processing V2 BackendKeyData",
+							   kind);
+					return -1;
+					break;
+			}
+		}
+	}
+
+	/*
+	 * message length (V3 only)
+	 */
+	if (protoMajor == PROTO_MAJOR_V3)
+	{
+		if (kind != 'K')
+		{
+			pool_error("pool_do_auth: expect \"K\" got %c", kind);
+			return -1;
+		}
+
+		if ((length = pool_read_message_length(cp)) != 12)
+		{
+			pool_error("pool_do_auth: invalid messages length(%d) for BackendKeyData", length);
+			return -1;
+		}
+	}
+
+	/*
+	 * OK, read pid and secret key
+	 */
+	sp = MASTER_CONNECTION(cp)->sp;
+	pid = -1;
+
+	for (i=0;i<NUM_BACKENDS;i++)
+	{
+		if (VALID_BACKEND(i))
+		{
+			/* read pid */
+			if (pool_read(CONNECTION(cp, i), &pid, sizeof(pid)) < 0)
+			{
+				pool_error("pool_do_auth: failed to read pid in slot %d", i);
+				return -1;
+			}
+
+			pool_debug("pool_do_auth: cp->info[i]:%p pid:%u", &cp->info[i], ntohl(pid));
+
+			CONNECTION_SLOT(cp, i)->pid = cp->info[i].pid = pid;
+
+			/* read key */
+			if (pool_read(CONNECTION(cp, i), &key, sizeof(key)) < 0)
+			{
+				pool_error("pool_do_auth: failed to read key in slot %d", i);
+				return -1;
+			}
+			CONNECTION_SLOT(cp, i)->key = cp->info[i].key = key;
+
+			cp->info[i].major = sp->major;
+			cp->info[i].minor = sp->minor;
+			strlcpy(cp->info[i].database, sp->database, sizeof(cp->info[i].database));
+			strlcpy(cp->info[i].user, sp->user, sizeof(cp->info[i].user));
+			cp->info[i].counter = 1;
+		}
+	}
+
+	if (pid == -1)
+	{
+		pool_error("pool_do_auth: all backends are down");
+		return -1;
+	}
+
+	return pool_send_backend_key_data(frontend, pid, key, protoMajor);
+}
+
+/*
+* do re-authentication for reused connection. if success return 0 otherwise non 0.
+*/
+int pool_do_reauth(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *cp)
+{
+	int status;
+	int protoMajor;
+
+	protoMajor = MAJOR(cp);
+
+	switch(MASTER(cp)->auth_kind)
+	{
+		case 0:
+			/* trust */
+			status = 0;
+			break;
+
+		case 3:
+			/* clear text password */
+			status = do_clear_text_password(MASTER(cp), frontend, 1, protoMajor);
+			break;
+
+		case 4:
+			/* crypt password */
+			status = do_crypt(MASTER(cp), frontend, 1, protoMajor);
+			break;
+
+		case 5:
+			/* md5 password */
+			status = do_md5(MASTER(cp), frontend, 1, protoMajor);
+			break;
+
+		default:
+			pool_error("pool_do_reauth: unknown authentication request code %d",
+					   MASTER(cp)->auth_kind);
+			return -1;
+	}
+
+	if (status == 0)
+	{
+		int msglen;
+
+		pool_write(frontend, "R", 1);
+
+		if (protoMajor == PROTO_MAJOR_V3)
+		{
+			msglen = htonl(8);
+			pool_write(frontend, &msglen, sizeof(msglen));
+		}
+
+		msglen = htonl(0);
+		if (pool_write_and_flush(frontend, &msglen, sizeof(msglen)) < 0)
+		{
+			return -1;
+		}
+	}
+	else
+	{
+		pool_debug("pool_do_reauth: authentication failed");
+		pool_send_auth_fail(frontend, cp);               
+		return -1;
+	}
+
+	return (pool_send_backend_key_data(frontend, MASTER_CONNECTION(cp)->pid, MASTER_CONNECTION(cp)->key, protoMajor) != POOL_CONTINUE);
+}
+
+/*
+* send authentication failure message text to frontend
+*/
+static void pool_send_auth_fail(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *cp)
+{
+	int messagelen;
+	char *errmessage;
+	int protoMajor;
+
+	bool send_error_to_frontend = true;
+
+	protoMajor = MAJOR(cp);
+
+	messagelen = strlen(MASTER_CONNECTION(cp)->sp->user) + 100;
+	if ((errmessage = (char *)malloc(messagelen+1)) == NULL)
+	{
+		pool_error("pool_send_auth_fail_failed: malloc failed: %s", strerror(errno));
+		child_exit(1);
+	}
+
+	snprintf(errmessage, messagelen, "password authentication failed for user \"%s\"",
+		 MASTER_CONNECTION(cp)->sp->user);
+	if (send_error_to_frontend)
+	pool_send_fatal_message(frontend, protoMajor, "XX000", errmessage,
+				"", "", __FILE__, __LINE__);
+	free(errmessage);
+} 
+
+/*
+* Send backend key data to frontend. if success return 0 otherwise non 0.
+*/
+static POOL_STATUS pool_send_backend_key_data(POOL_CONNECTION *frontend, int pid, int key, int protoMajor)
+{
+	char kind;
+	int len;
+
+	/* Send backend key data */
+	kind = 'K';
+	pool_write(frontend, &kind, 1);
+	if (protoMajor == PROTO_MAJOR_V3)
+	{
+		len = htonl(12);
+		pool_write(frontend, &len, sizeof(len));
+	}
+
+	pool_debug("pool_send_auth_ok: send pid %d to frontend", ntohl(pid));
+
+	pool_write(frontend, &pid, sizeof(pid));
+	if (pool_write_and_flush(frontend, &key, sizeof(key)) < 0)
+	{
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * perform clear text password authentication
+ */
+static int do_clear_text_password(POOL_CONNECTION *backend, POOL_CONNECTION *frontend, int reauth, int protoMajor)
+{
+	static int size;
+	static char password[MAX_PASSWORD_SIZE];
+	char response;
+	int kind;
+	int len;
+
+	/* master? */
+	if (IS_MASTER_NODE_ID(backend->db_node_id))
+	{
+		pool_write(frontend, "R", 1);	/* authentication */
+		if (protoMajor == PROTO_MAJOR_V3)
+		{
+			len = htonl(8);
+			pool_write(frontend, &len, sizeof(len));
+		}
+		kind = htonl(3);		/* clear text password authentication */
+		pool_write_and_flush(frontend, &kind, sizeof(kind));	/* indicating clear text password authentication */
+
+		/* read password packet */
+		if (protoMajor == PROTO_MAJOR_V2)
+		{
+			if (pool_read(frontend, &size, sizeof(size)))
+			{
+				pool_debug("do_clear_text_password: failed to read password packet size");
+				return -1;
+			}
+		}
+		else
+		{
+			char k;
+
+			if (pool_read(frontend, &k, sizeof(k)))
+			{
+				pool_debug("do_clear_text_password: failed to read password packet \"p\"");
+				return -1;
+			}
+			if (k != 'p')
+			{
+				pool_error("do_clear_text_password: password packet does not start with \"p\"");
+				return -1;
+			}
+			if (pool_read(frontend, &size, sizeof(size)))
+			{
+				pool_error("do_clear_text_password: failed to read password packet size");
+				return -1;
+			}
+		}
+
+		if ((ntohl(size) - 4) > sizeof(password))
+		{
+			pool_error("do_clear_text_password: password is too long (size: %d)", ntohl(size) - 4);
+			return -1;
+		}
+
+		if (pool_read(frontend, password, ntohl(size) - 4))
+		{
+			pool_error("do_clear_text_password: failed to read password (size: %d)", ntohl(size) - 4);
+			return -1;
+		}
+	}
+
+	/* connection reusing? */
+	if (reauth)
+	{
+		if ((ntohl(size) - 4) != backend->pwd_size)
+		{
+			pool_debug("do_clear_text_password; password size does not match in re-authentication");
+			return -1;
+		}
+
+		if (memcmp(password, backend->password, backend->pwd_size) != 0)
+		{
+			pool_debug("do_clear_text_password; password does not match in re-authentication");
+			return -1;
+		}
+
+		return 0;
+	}
+
+	/* send password packet to backend */
+	if (protoMajor == PROTO_MAJOR_V3)
+		pool_write(backend, "p", 1);
+	pool_write(backend, &size, sizeof(size));
+	pool_write_and_flush(backend, password, ntohl(size) -4);
+	if (pool_read(backend, &response, sizeof(response)))
+	{
+		pool_error("do_clear_text_password: failed to read authentication response");
+		return -1;
+	}
+
+	if (response != 'R')
+	{
+		pool_debug("do_clear_text_password: backend does not return R while processing clear text password authentication");
+		return -1;
+	}
+
+	if (protoMajor == PROTO_MAJOR_V3)
+	{
+		if (pool_read(backend, &len, sizeof(len)))
+		{
+			pool_error("do_clear_text_password: failed to read authentication packet size");
+			return -1;
+		}
+
+		if (ntohl(len) != 8)
+		{
+			pool_error("do_clear_text_password: incorrect authentication packet size (%d)", ntohl(len));
+			return -1;
+		}
+	}
+
+	/* expect to read "Authentication OK" response. kind should be 0... */
+	if (pool_read(backend, &kind, sizeof(kind)))
+	{
+		pool_debug("do_clear_text_password: failed to read Authentication OK response");
+		return -1;
+	}
+
+	/* if authenticated, save info */
+	if (!reauth && kind == 0)
+	{
+		if (IS_MASTER_NODE_ID(backend->db_node_id))
+		{
+			int msglen;
+
+			pool_write(frontend, "R", 1);
+
+			if (protoMajor == PROTO_MAJOR_V3)
+			{
+				msglen = htonl(8);
+				pool_write(frontend, &msglen, sizeof(msglen));
+			}
+
+			msglen = htonl(0);
+			if (pool_write_and_flush(frontend, &msglen, sizeof(msglen)) < 0)
+			{
+				return -1;
+			}
+		}
+
+		backend->auth_kind = 3;
+		backend->pwd_size = ntohl(size) - 4;
+		memcpy(backend->password, password, backend->pwd_size);
+	}
+	return kind;
+}
+
+/*
+ * perform crypt authentication
+ */
+static int do_crypt(POOL_CONNECTION *backend, POOL_CONNECTION *frontend, int reauth, int protoMajor)
+{
+	char salt[2];
+	static int size;
+	static char password[MAX_PASSWORD_SIZE];
+	char response;
+	int kind;
+	int len;
+
+	if (!reauth)
+	{
+		/* read salt */
+		if (pool_read(backend, salt, sizeof(salt)))
+		{
+			pool_error("do_crypt: failed to read salt");
+			return -1;
+		}
+	}
+	else
+	{
+		memcpy(salt, backend->salt, sizeof(salt));
+	}
+
+	/* master? */
+	if (IS_MASTER_NODE_ID(backend->db_node_id))
+	{
+		pool_write(frontend, "R", 1);	/* authentication */
+		if (protoMajor == PROTO_MAJOR_V3)
+		{
+			len = htonl(10);
+			pool_write(frontend, &len, sizeof(len));
+		}
+		kind = htonl(4);		/* crypt authentication */
+		pool_write(frontend, &kind, sizeof(kind));	/* indicating crypt authentication */
+		pool_write_and_flush(frontend, salt, sizeof(salt));		/* salt */
+
+		/* read password packet */
+		if (protoMajor == PROTO_MAJOR_V2)
+		{
+			if (pool_read(frontend, &size, sizeof(size)))
+			{
+				pool_error("do_crypt: failed to read password packet size");
+				return -1;
+			}
+		}
+		else
+		{
+			char k;
+
+			if (pool_read(frontend, &k, sizeof(k)))
+			{
+				pool_debug("do_crypt_password: failed to read password packet \"p\"");
+				return -1;
+			}
+			if (k != 'p')
+			{
+				pool_error("do_crypt_password: password packet does not start with \"p\"");
+				return -1;
+			}
+			if (pool_read(frontend, &size, sizeof(size)))
+			{
+				pool_error("do_crypt_password: failed to read password packet size");
+				return -1;
+			}
+		}
+
+		if ((ntohl(size) - 4) > sizeof(password))
+		{
+			pool_error("do_crypt: password is too long(size: %d)", ntohl(size) - 4);
+			return -1;
+		}
+
+		if (pool_read(frontend, password, ntohl(size) - 4))
+		{
+			pool_error("do_crypt: failed to read password (size: %d)", ntohl(size) - 4);
+			return -1;
+		}
+	}
+
+	/* connection reusing? */
+	if (reauth)
+	{
+		pool_debug("size: %d saved_size: %d", (ntohl(size) - 4), backend->pwd_size);
+		if ((ntohl(size) - 4) != backend->pwd_size)
+		{
+			pool_debug("do_crypt: password size does not match in re-authentication");
+			return -1;
+		}
+
+		if (memcmp(password, backend->password, backend->pwd_size) != 0)
+		{
+			pool_debug("do_crypt: password does not match in re-authentication");
+			return -1;
+		}
+
+		return 0;
+	}
+
+	/* send password packet to backend */
+	if (protoMajor == PROTO_MAJOR_V3)
+		pool_write(backend, "p", 1);
+	pool_write(backend, &size, sizeof(size));
+	pool_write_and_flush(backend, password, ntohl(size) -4);
+	if (pool_read(backend, &response, sizeof(response)))
+	{
+		pool_error("do_crypt: failed to read authentication response");
+		return -1;
+	}
+
+	if (response != 'R')
+	{
+		pool_debug("do_crypt: backend does not return R while processing crypt authentication(%02x) DB node id: %d", response, backend->db_node_id);
+		return -1;
+	}
+
+	if (protoMajor == PROTO_MAJOR_V3)
+	{
+		if (pool_read(backend, &len, sizeof(len)))
+		{
+			pool_error("do_crypt: failed to read authentication packet size");
+			return -1;
+		}
+
+		if (ntohl(len) != 8)
+		{
+			pool_error("do_crypt: incorrect authentication packet size (%d)", ntohl(len));
+			return -1;
+		}
+	}
+
+	/* expect to read "Authentication OK" response. kind should be 0... */
+	if (pool_read(backend, &kind, sizeof(kind)))
+	{
+		pool_debug("do_crypt: failed to read Authentication OK response");
+		return -1;
+	}
+
+	/* if authenticated, save info */
+	if (!reauth && kind == 0)
+	{
+		int msglen;
+
+		pool_write(frontend, "R", 1);
+
+		if (protoMajor == PROTO_MAJOR_V3)
+		{
+			msglen = htonl(8);
+			pool_write(frontend, &msglen, sizeof(msglen));
+		}
+
+		msglen = htonl(0);
+		if (pool_write_and_flush(frontend, &msglen, sizeof(msglen)) < 0)
+		{
+			return -1;
+		}
+
+		backend->auth_kind = 4;
+		backend->pwd_size = ntohl(size) - 4;
+		memcpy(backend->password, password, backend->pwd_size);
+		memcpy(backend->salt, salt, sizeof(salt));
+	}
+	return kind;
+}
+
+/*
+ * perform MD5 authentication
+ */
+static int do_md5(POOL_CONNECTION *backend, POOL_CONNECTION *frontend, int reauth, int protoMajor)
+{
+	char salt[4];
+	static int size;
+	static char password[MAX_PASSWORD_SIZE];
+	int kind;
+	char encbuf[POOL_PASSWD_LEN+1];
+	char *pool_passwd = NULL;
+
+	if (NUM_BACKENDS > 1)
+	{
+		/* Read password entry from pool_passwd */
+		pool_passwd = pool_get_passwd(frontend->username);
+		if (!pool_passwd)
+		{
+			pool_debug("do_md5: %s does not exist in pool_passwd", frontend->username);
+			return -1;
+		}
+
+		/* master? */
+		if (IS_MASTER_NODE_ID(backend->db_node_id))
+		{
+			/* Send md5 auth request to frontend with my own salt */
+			pool_random_salt(salt);
+			if (send_md5auth_request(frontend, protoMajor, salt))
+			{
+				pool_error("do_md5: send_md5auth_request failed");
+				return -1;
+			}
+
+			/* Read password packet */
+			if (read_password_packet(frontend, protoMajor, password, &size))
+			{
+				pool_debug("do_md5: read_password_packet failed");
+				return -1;
+			}
+
+			/* Check the password using my salt + pool_passwd */
+			pg_md5_encrypt(pool_passwd+strlen("md5"), salt, sizeof(salt), encbuf);
+			if (strcmp(password, encbuf))
+			{
+				/* Password does not match */
+				pool_debug("password does not match: frontend:%s pgpool:%s", password, encbuf);
+				return -1;
+			}
+		}
+		kind = 0;
+
+		if (!reauth)
+		{
+			/*
+			 * If ok, authenticate against backends using pool_passwd
+			 */
+			/* Read salt */
+			if (pool_read(backend, salt, sizeof(salt)))
+			{
+				pool_error("do_md5: failed to read salt");
+				return -1;
+			}
+			pool_debug("DB node id: %d salt: %hhx%hhx%hhx%hhx", backend->db_node_id,
+					   salt[0], salt[1], salt[2], salt[3]);
+
+			/* Encrypt password in pool_passwd using the salt */
+			pg_md5_encrypt(pool_passwd+strlen("md5"), salt, sizeof(salt), encbuf);
+
+			/* Send password packet to backend and receive auth response */
+			kind = send_password_packet(backend, protoMajor, encbuf);
+			if (kind < 0)
+			{
+				return -1;
+			}
+		}
+
+		if (!reauth && kind == 0)
+		{
+			if (IS_MASTER_NODE_ID(backend->db_node_id))
+			{
+				/* Send auth ok to frontend */
+				if (send_auth_ok(frontend, protoMajor) < 0)
+				{
+					pool_error("do_md5: send_auth_ok failed");
+					return -1;
+				}
+			}
+
+			/* Save the auth info */
+			backend->auth_kind = 5;
+		}
+		return kind;
+	}
+
+	/*
+	 * Followings are NUM_BACKEND == 1 case.
+	 */
+	if (!reauth)
+	{
+		/* read salt */
+		if (pool_read(backend, salt, sizeof(salt)))
+		{
+			pool_error("do_md5: failed to read salt");
+			return -1;
+		}
+		pool_debug("DB node id: %d salt: %hhx%hhx%hhx%hhx", backend->db_node_id,
+				   salt[0], salt[1], salt[2], salt[3]);
+	}
+	else
+	{
+		memcpy(salt, backend->salt, sizeof(salt));
+	}
+
+	/* master? */
+	if (IS_MASTER_NODE_ID(backend->db_node_id))
+	{
+		/* Send md5 auth request to frontend */
+		if (send_md5auth_request(frontend, protoMajor, salt))
+		{
+			pool_error("do_md5: send_md5auth_request failed");
+			return -1;
+		}
+
+		/* Read password packet */
+		if (read_password_packet(frontend, protoMajor, password, &size))
+		{
+			pool_debug("do_md5: read_password_packet failed");
+			return -1;
+		}
+	}
+
+	/* connection reusing? */
+	if (reauth)
+	{
+		if (size != backend->pwd_size)
+		{
+			pool_debug("do_md5; password size does not match in re-authentication");
+			return -1;
+		}
+
+		if (memcmp(password, backend->password, backend->pwd_size) != 0)
+		{
+			pool_debug("do_md5; password does not match in re-authentication");
+			return -1;
+		}
+
+		return 0;
+	}
+
+	/* Send password packet to backend and receive auth response */
+	kind = send_password_packet(backend, protoMajor, password);
+	if (kind < 0)
+	{
+		return -1;
+	}
+
+	/* If authenticated, reply back to frontend and save info */
+	if (!reauth && kind == 0)
+	{
+		if (send_auth_ok(frontend, protoMajor) < 0)
+		{
+			pool_error("do_md5: send_auth_ok failed");
+			return -1;
+		}
+
+		backend->auth_kind = 5;
+		backend->pwd_size = size;
+		memcpy(backend->password, password, backend->pwd_size);
+		memcpy(backend->salt, salt, sizeof(salt));
+	}
+	return kind;
+}
+
+/*
+ * Send md5 authentication request packet to frontend
+ */
+int send_md5auth_request(POOL_CONNECTION *frontend, int protoMajor, char *salt)
+{
+	int len;
+	int kind;
+
+	pool_write(frontend, "R", 1);	/* authentication */
+	if (protoMajor == PROTO_MAJOR_V3)
+	{
+		len = htonl(12);
+		pool_write(frontend, &len, sizeof(len));
+	}
+	kind = htonl(5);
+	pool_write(frontend, &kind, sizeof(kind));	/* indicating MD5 */
+	pool_write_and_flush(frontend, salt, 4);		/* salt */
+
+	return 0;
+}
+
+/*
+ * Read password packet from frontend
+ */
+int read_password_packet(POOL_CONNECTION *frontend, int protoMajor, 	char *password, int *pwdSize)
+{
+	int size;
+
+	/* Read password packet */
+	if (protoMajor == PROTO_MAJOR_V2)
+	{
+		if (pool_read(frontend, &size, sizeof(size)))
+		{
+			pool_error("read_password_packet: failed to read password packet size");
+			return -1;
+		}
+	}
+	else
+	{
+		char k;
+
+		if (pool_read(frontend, &k, sizeof(k)))
+		{
+			pool_debug("read_password_packet: failed to read password packet \"p\"");
+			return -1;
+		}
+		if (k != 'p')
+		{
+			pool_error("read_password_packet: password packet does not start with \"p\"");
+			return -1;
+		}
+		if (pool_read(frontend, &size, sizeof(size)))
+		{
+			pool_error("read_password_packet: failed to read password packet size");
+			return -1;
+		}
+	}
+
+	*pwdSize = ntohl(size) - 4;
+	if (*pwdSize > MAX_PASSWORD_SIZE)
+	{
+		pool_error("read_password_packet: too long password string (size: %d)", *pwdSize);
+		/*
+		 * We do not read to throw away packet here. Since it is possible that
+		 * it's a denial of service attack.
+		 */
+		return -1;
+	}
+	else if (*pwdSize <= 0)
+	{
+		pool_error("read_password_packet: invalid password string size (size: %d)", *pwdSize);
+		return -1;
+	}
+
+	if (pool_read(frontend, password, *pwdSize))
+	{
+		pool_error("read_password_packet: failed to read password (size: %d)", *pwdSize);
+		return -1;
+	}
+	
+	password[*pwdSize] = '\0';
+
+	return 0;
+}
+
+/*
+ * Send password packet to backend and receive authentication response
+ * packet.  Return value is the last field of authentication
+ * response. If it's 0, authentication was successful.
+ * "password" must be null-terminated.
+ */
+static int send_password_packet(POOL_CONNECTION *backend, int protoMajor, char *password)
+{
+	int size;
+	int len;
+	int kind;
+	char response;
+
+	/* Send password packet to backend */
+	if (protoMajor == PROTO_MAJOR_V3)
+		pool_write(backend, "p", 1);
+	size = htonl(sizeof(size) + strlen(password)+1);
+	pool_write(backend, &size, sizeof(size));
+	pool_write_and_flush(backend, password, strlen(password)+1);
+
+	if (pool_read(backend, &response, sizeof(response)))
+	{
+		pool_error("send_password_packet: failed to read authentication response");
+		return -1;
+	}
+
+	if (response != 'R')
+	{
+		pool_debug("send_password_packet: backend does not return R");
+		return -1;
+	}
+
+	if (protoMajor == PROTO_MAJOR_V3)
+	{
+		if (pool_read(backend, &len, sizeof(len)))
+		{
+			pool_error("send_password_packet: failed to read authentication packet size");
+			return -1;
+		}
+
+		if (ntohl(len) != 8)
+		{
+			pool_error("send_password_packet: incorrect authentication packet size (%d)", ntohl(len));
+			return -1;
+		}
+	}
+
+	/* Expect to read "Authentication OK" response. kind should be 0... */
+	if (pool_read(backend, &kind, sizeof(kind)))
+	{
+		pool_debug("send_password_packet: failed to read Authentication OK response");
+		return -1;
+	}
+
+	return kind;
+}
+
+/*
+ * Send auth ok to frontend
+ */
+static int send_auth_ok(POOL_CONNECTION *frontend, int protoMajor)
+{
+	int msglen;
+
+	pool_write(frontend, "R", 1);
+
+	if (protoMajor == PROTO_MAJOR_V3)
+	{
+		msglen = htonl(8);
+		pool_write(frontend, &msglen, sizeof(msglen));
+	}
+
+	msglen = htonl(0);
+	if (pool_write_and_flush(frontend, &msglen, sizeof(msglen)) < 0)
+	{
+		return -1;
+	}
+	return 0;
+}
+
+/*
+ * read message length (V3 only)
+ */
+int pool_read_message_length(POOL_CONNECTION_POOL *cp)
+{
+	int status;
+	int length, length0;
+	int i;
+
+	/* read message from master node */
+	status = pool_read(CONNECTION(cp, MASTER_NODE_ID), &length0, sizeof(length0));
+	if (status < 0)
+	{
+		pool_error("pool_read_message_length: error while reading message length in slot %d", MASTER_NODE_ID);
+		return -1;
+	}
+	length0 = ntohl(length0);
+	pool_debug("pool_read_message_length: slot: %d length: %d", MASTER_NODE_ID, length0);
+
+	for (i=0;i<NUM_BACKENDS;i++)
+	{
+		if (!VALID_BACKEND(i) || IS_MASTER_NODE_ID(i))
+		{
+			continue;
+		}
+
+		status = pool_read(CONNECTION(cp, i), &length, sizeof(length));
+		if (status < 0)
+		{
+			pool_error("pool_read_message_length: error while reading message length in slot %d", i);
+			return -1;
+		}
+
+		length = ntohl(length);
+		pool_debug("pool_read_message_length: slot: %d length: %d", i, length);
+
+		if (length != length0)
+		{
+			pool_error("pool_read_message_length: message length (%d) in slot %d does not match with slot 0(%d)", length, i, length0);
+			return -1;
+		}
+	}
+
+	if (length0 < 0)
+	{
+		pool_error("pool_read_message_length: invalid message length (%d)", length);
+		return -1;
+	}
+
+	return length0;
+}
+
+/*
+ * read message length2 (V3 only)
+ * unlike pool_read_message_length, this returns an array of message length.
+ * The array is in the static storage, thus it will be destroyed by subsequent calls.
+ */
+int *pool_read_message_length2(POOL_CONNECTION_POOL *cp)
+{
+	int status;
+	int length, length0;
+	int i;
+	static int length_array[MAX_CONNECTION_SLOTS];
+
+	/* read message from master node */
+	status = pool_read(CONNECTION(cp, MASTER_NODE_ID), &length0, sizeof(length0));
+	if (status < 0)
+	{
+		pool_error("pool_read_message_length2: error while reading message length in slot %d", MASTER_NODE_ID);
+		return NULL;
+	}
+
+	length0 = ntohl(length0);
+	length_array[MASTER_NODE_ID] = length0;
+	pool_debug("pool_read_message_length2: master slot: %d length: %d", MASTER_NODE_ID, length0);
+	for (i=0;i<NUM_BACKENDS;i++)
+	{
+		if (VALID_BACKEND(i) && !IS_MASTER_NODE_ID(i))
+		{
+			status = pool_read(CONNECTION(cp, i), &length, sizeof(length));
+			if (status < 0)
+			{
+				pool_error("pool_read_message_length2: error while reading message length in slot %d", i);
+				return NULL;
+			}
+
+			length = ntohl(length);
+			pool_debug("pool_read_message_length2: master slot: %d length: %d", i, length);
+
+			if (length != length0)
+			{
+				pool_log("pool_read_message_length2: message length (%d) in slot %d does not match with slot 0(%d)", length, i, length0);
+			}
+
+			if (length < 0)
+			{
+				pool_error("pool_read_message_length2: invalid message length (%d)", length);
+				return NULL;
+			}
+
+			length_array[i] = length;
+		}
+
+	}
+	return &length_array[0];
+}
+
+signed char pool_read_kind(POOL_CONNECTION_POOL *cp)
+{
+	int status;
+	char kind0, kind;
+	int i;
+
+	kind = -1;
+	kind0 = 0;
+
+	for (i=0;i<NUM_BACKENDS;i++)
+	{
+		if (!VALID_BACKEND(i))
+		{
+			continue;
+		}
+
+		status = pool_read(CONNECTION(cp, i), &kind, sizeof(kind));
+		if (status < 0)
+		{
+			pool_error("pool_read_kind: error while reading message kind");
+			return -1;
+		}
+
+		if (IS_MASTER_NODE_ID(i))
+		{
+			kind0 = kind;
+		}
+		else
+		{
+			if (kind != kind0)
+			{
+				char *message;
+
+				pool_error("pool_read_kind: kind does not match between master(%x) slot[%d] (%x)",
+						   kind0, i, kind);
+				if (kind0 == 'E')
+				{
+					if (pool_extract_error_message(false, MASTER(cp), MAJOR(cp), true, &message) == 1)
+					{
+						pool_log("pool_read_kind: error message from master backend:%s", message);
+					}
+				}
+				else if (kind == 'E')
+				{
+					if (pool_extract_error_message(false, CONNECTION(cp, i), MAJOR(cp), true, &message) == 1)
+					{
+						pool_log("pool_read_kind: error message from %d th backend:%s", i, message);
+					}
+				}
+				return -1;
+			}
+		}
+	}
+
+	return kind;
+}
+
+int pool_read_int(POOL_CONNECTION_POOL *cp)
+{
+	int status;
+	int data0, data;
+	int i;
+
+	data = -1;
+	data0 = 0;
+
+	for (i=0;i<NUM_BACKENDS;i++)
+	{
+		if (!VALID_BACKEND(i))
+		{
+			continue;
+		}
+
+		status = pool_read(CONNECTION(cp, i), &data, sizeof(data));
+		if (status < 0)
+		{
+			pool_error("pool_read_int: error while reading message data");
+			return -1;
+		}
+
+		if (IS_MASTER_NODE_ID(i))
+		{
+			data0 = data;
+		}
+		else
+		{
+			if (data != data0)
+			{
+				pool_error("pool_read_int: data does not match between between master(%x) slot[%d] (%x)",
+						   data0, i, data);
+				return -1;
+			}
+		}
+	}
+
+	return data;
+}
+
+/*
+ *  pool_random_salt
+ */
+void pool_random_salt(char *md5Salt)
+{
+	long rand = random();
+
+	md5Salt[0] = (rand % 255) + 1;
+	rand = random();
+	md5Salt[1] = (rand % 255) + 1;
+	rand = random();
+	md5Salt[2] = (rand % 255) + 1;
+	rand = random();
+	md5Salt[3] = (rand % 255) + 1;
+}