/*
* Collect password response packet from frontend.
*
* Returns NULL if couldn't get password, else malloc'd string.
*/
static char *recv_password_packet(POOL_CONNECTION *frontend)
{
int rsize;
char *passwd;
char *returnVal;
if (frontend->protoVersion == PROTO_MAJOR_V3)
{
/* Expect 'p' message type */
char kind;
if (pool_read(frontend, &kind, 1) < 0)
return NULL;
if (kind != 'p')
{
pool_error("expected password response, got message type %c",
kind);
return NULL; /* bad message type */
}
}
/* pre-3.0 protocol does not send a message type */
if (pool_read(frontend, &rsize, sizeof(int)) < 0)
return NULL;
rsize = ntohl(rsize) - 4;
passwd = pool_read2(frontend, rsize); /* retrieve password */
if (passwd == NULL)
return NULL;
/* Do not echo password to logs, for security. */
pool_debug("received password packet from frontend for pgpool's HBA");
/*
* Return the received string. Note we do not attempt to do any
* character-set conversion on it; since we don't yet know the
* client's encoding, there wouldn't be much point.
*/
returnVal = strdup(passwd);
if (returnVal == NULL)
{
pool_error("recv_password_packet: strdup failed: %s", strerror(errno));
exit(1);
}
return returnVal;
}
/*
* Do authentication. Assuming the only caller is
* *make_persistent_db_connection().
*/
static int s_do_auth(POOL_CONNECTION_POOL_SLOT *cp, char *password)
{
char kind;
int status;
int length;
int auth_kind;
char state;
char *p;
int pid, key;
bool keydata_done;
/*
* read kind expecting 'R' packet (authentication response)
*/
status = pool_read(cp->con, &kind, sizeof(kind));
if (status < 0)
{
pool_error("s_do_auth: error while reading message kind");
return -1;
}
if (kind != 'R')
{
pool_error("s_do_auth: expecting R got %c", kind);
return -1;
}
/* read message length */
status = pool_read(cp->con, &length, sizeof(length));
if (status < 0)
{
pool_error("s_do_auth: error while reading message length");
return -1;
}
length = ntohl(length);
/* read auth kind */
status = pool_read(cp->con, &auth_kind, sizeof(auth_kind));
if (status < 0)
{
pool_error("s_do_auth: error while reading auth kind");
return -1;
}
auth_kind = ntohl(auth_kind);
pool_debug("s_do_auth: auth kind: %d", auth_kind);
if (auth_kind == 0) /* trust authentication? */
{
cp->con->auth_kind = 0;
}
else if (auth_kind == 3) /* clear text password? */
{
int size = htonl(strlen(password) + 5);
pool_write(cp->con, "p", 1);
pool_write(cp->con, &size, sizeof(size));
pool_write_and_flush(cp->con, password, strlen(password) + 1);
status = pool_flush(cp->con);
if (status > 0)
{
pool_error("s_do_auth: error while sending clear text password");
return -1;
}
return s_do_auth(cp, password);
}
else if (auth_kind == 4) /* crypt password? */
{
int size;
char salt[3];
char *crypt_password;
status = pool_read(cp->con, &salt, 2);
if (status > 0)
{
pool_error("s_do_auth: error while reading crypt salt");
return -1;
}
salt[2] = '\0';
crypt_password = crypt(password, salt);
size = htonl(strlen(crypt_password) + 5);
pool_write(cp->con, "p", 1);
pool_write(cp->con, &size, sizeof(size));
pool_write_and_flush(cp->con, crypt_password, strlen(crypt_password) + 1);
status = pool_flush(cp->con);
if (status > 0)
{
pool_error("s_do_auth: error while sending crypt password");
return -1;
}
return s_do_auth(cp, password);
}
else if (auth_kind == 5) /* md5 password? */
{
char salt[4];
char *buf, *buf1;
int size;
status = pool_read(cp->con, &salt, 4);
if (status > 0)
{
pool_error("s_do_auth: error while reading md5 salt");
return -1;
}
buf = malloc(2 * (MD5_PASSWD_LEN + 4)); /* hash + "md5" + '\0' */
if (buf == NULL)
{
pool_error("s_do_auth(): malloc failed: %s", strerror(errno));
return -1;
}
memset(buf, 0, 2 * (MD5_PASSWD_LEN + 4));
/* build md5 password */
buf1 = buf + MD5_PASSWD_LEN + 4;
pool_md5_encrypt(password, cp->sp->user, strlen(cp->sp->user), buf1);
pool_md5_encrypt(buf1, salt, 4, buf + 3);
memcpy(buf, "md5", 3);
size = htonl(strlen(buf) + 5);
pool_write(cp->con, "p", 1);
pool_write(cp->con, &size, sizeof(size));
pool_write_and_flush(cp->con, buf, strlen(buf) + 1);
status = pool_flush(cp->con);
if (status > 0)
{
pool_error("s_do_auth: error while sending md5 password");
return -1;
}
status = s_do_auth(cp, password);
free(buf);
return status;
}
else
{
pool_error("s_do_auth: auth kind %d not supported yet", auth_kind);
return -1;
}
/*
* Read backend key data and wait until Ready for query arriving or
* error happens.
*/
keydata_done = false;
for (;;)
{
status = pool_read(cp->con, &kind, sizeof(kind));
if (status < 0)
{
pool_error("s_do_auth: error while reading message kind");
return -1;
}
switch (kind)
{
case 'K': /* backend key data */
keydata_done = true;
pool_debug("s_do_auth: backend key data received");
/* read message length */
status = pool_read(cp->con, &length, sizeof(length));
if (status < 0)
{
pool_error("s_do_auth: error while reading message length");
return -1;
}
if (ntohl(length) != 12)
{
pool_error("s_do_auth: backend key data length is not 12 (%d)", ntohl(length));
}
/* read pid */
if (pool_read(cp->con, &pid, sizeof(pid)) < 0)
{
pool_error("s_do_auth: failed to read pid");
return -1;
}
cp->pid = pid;
/* read key */
if (pool_read(cp->con, &key, sizeof(key)) < 0)
{
pool_error("s_do_auth: failed to read key");
return -1;
}
cp->key = key;
break;
case 'Z': /* Ready for query */
/* read message length */
status = pool_read(cp->con, &length, sizeof(length));
if (status < 0)
{
pool_error("s_do_auth: error while reading message length");
return -1;
}
length = ntohl(length);
/* read transaction state */
status = pool_read(cp->con, &state, sizeof(state));
if (status < 0)
{
pool_error("s_do_auth: error while reading transaction state");
return -1;
}
pool_debug("s_do_auth: transaction state: %c", state);
cp->con->tstate = state;
if (!keydata_done)
{
pool_error("s_do_auth: ready for query arrived before receiving keydata");
}
return 0;
break;
case 'S': /* parameter status */
case 'N': /* notice response */
case 'E': /* error response */
/* Just throw away data */
status = pool_read(cp->con, &length, sizeof(length));
if (status < 0)
{
pool_error("s_do_auth: error while reading message length. kind:%c", kind);
return -1;
}
length = ntohl(length);
length -= 4;
p = pool_read2(cp->con, length);
if (p == NULL)
return -1;
break;
default:
pool_error("s_do_auth: unknown response \"%c\" while processing BackendKeyData",
kind);
break;
}
}
return -1;
}
POOL_STATUS FunctionResultResponse(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend)
{
char dummy;
int len;
char *result = 0;
int i;
pool_write(frontend, "V", 1);
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
{
if (pool_read(CONNECTION(backend, i), &dummy, 1) < 0)
return POOL_ERROR;
}
}
pool_write(frontend, &dummy, 1);
/* non empty result? */
if (dummy == 'G')
{
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
{
/* length of result in bytes */
if (pool_read(CONNECTION(backend, i), &len, sizeof(len)) < 0)
return POOL_ERROR;
}
}
pool_write(frontend, &len, sizeof(len));
len = ntohl(len);
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
{
/* result value itself */
if ((result = pool_read2(MASTER(backend), len)) == NULL)
return POOL_ERROR;
}
}
pool_write(frontend, result, len);
}
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
{
/* unused ('0') */
if (pool_read(MASTER(backend), &dummy, 1) < 0)
return POOL_ERROR;
}
}
pool_write(frontend, "0", 1);
return pool_flush(frontend);
}
/* --------------------------------
* search_system_db_for_cache - search for query cache in libpq protocol level
*
* sends a cache searching query string using libpq protocol to the SystemDB.
* if the SystemDB returns cache, forward the data to the frontend, and return
* CACHE_FOUND. if cache was not found, silently discards the remaining data
* returned by the SystemDB, and return CACHE_NOT_FOUND. returns CACHE_ERROR
* if an error was encountered.
* --------------------------------
*/
static CACHE_STATUS
search_system_db_for_cache(POOL_CONNECTION *frontend, char *sql, int sql_len, struct timeval *t, char tstate)
{
fd_set readmask;
int fds;
int num_fds;
struct timeval *timeout = NULL;
char kind;
int readlen;
char *data = NULL;
CACHE_STATUS return_value = CACHE_ERROR;
int cache_found = 0;
pool_debug("pool_query_cache_lookup: executing query: \"%s\"", sql);
pool_write(SYSDB_CON, "Q", 1);
if (SYSDB_MAJOR == PROTO_MAJOR_V3)
{
int sendlen = htonl(sql_len + 4);
pool_write(SYSDB_CON, &sendlen, sizeof(sendlen));
}
if (pool_write_and_flush(SYSDB_CON, sql, sql_len) < 0)
{
pool_error("pool_query_cache_lookup: error while sending data to the SystemDB");
return CACHE_ERROR;
}
if ((t->tv_sec + t->tv_usec) == 0)
timeout = NULL;
else
timeout = t;
/* don't really need select() or for(;;) here, but we may need it someday... or not */
for (;;)
{
FD_ZERO(&readmask);
num_fds = 0;
num_fds = SYSDB_CON->fd + 1;
FD_SET(SYSDB_CON->fd, &readmask);
fds = select(num_fds, &readmask, NULL, NULL, timeout);
if (fds == -1)
{
if (errno == EINTR)
continue;
pool_error("pool_query_cache_lookup: select() failed. reason: %s", strerror(errno));
return CACHE_ERROR;
}
/* select() timeout */
if (fds == 0)
return CACHE_ERROR;
for (;;)
{
if (! FD_ISSET(SYSDB_CON->fd, &readmask))
{
pool_error("pool_query_cache_lookup: select() failed");
return CACHE_ERROR;
}
/* read kind */
if (pool_read(SYSDB_CON, &kind, sizeof(kind)) < 0)
{
pool_error("pool_query_cache_lookup: error while reading message kind");
return CACHE_ERROR;
}
pool_debug("pool_query_cache_lookup: received %c from systemdb", kind);
/* just do the routine work of reading data in. data won't be used */
if (kind == 'T')
{
if (SYSDB_MAJOR == PROTO_MAJOR_V3)
{
if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
{
pool_error("pool_query_cache_lookup: error while reading message length");
return CACHE_ERROR;
}
readlen = ntohl(readlen) - sizeof(int);
data = pool_read2(SYSDB_CON, readlen);
}
else
{
data = pool_read_string(SYSDB_CON, &readlen, 0);
}
}
else if (kind == 'D') /* cache found! forward it to the frontend */
{
char *cache;
int status;
cache_found = 1;
if (SYSDB_MAJOR == PROTO_MAJOR_V3)
{
if (pool_read(SYSDB_CON, &readlen, sizeof(readlen)) < 0)
{
pool_error("pool_query_cache_lookup: error while reading message length");
return CACHE_ERROR;
}
readlen = ntohl(readlen) - sizeof(int);
cache = pool_read2(SYSDB_CON, readlen);
}
else
{
cache = pool_read_string(SYSDB_CON, &readlen, 0);
}
if (cache == NULL)
{
pool_error("pool_query_cache_lookup: error while reading message body");
return CACHE_ERROR;
}
cache[readlen] = '\0';
cache += sizeof(short); /* number of columns in 'D' (we know it's always going to be 1, so skip) */
cache += sizeof(int); /* length of escaped bytea cache in string format. don't need the length */
status = ForwardCacheToFrontend(frontend, cache, tstate);
if (status < 0)
{
/* fatal error has occured while forwarding cache */
pool_error("pool_query_cache_lookup: query cache forwarding failed");
return_value = CACHE_ERROR;
}
}
else if (kind == 'C') /* see if 'D' was received */
{
if (cache_found)
return_value = CACHE_FOUND;
else
return_value = CACHE_NOT_FOUND;
/* must discard the remaining data */
if (SYSDB_MAJOR == PROTO_MAJOR_V3)
{
if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
{
pool_error("pool_query_cache_lookup: error while reading message length");
return CACHE_ERROR;
}
readlen = ntohl(readlen) - sizeof(int);
data = pool_read2(SYSDB_CON, readlen);
}
else
{
data = pool_read_string(SYSDB_CON, &readlen, 0);
}
}
else if (kind == 'Z')
{
/* must discard the remaining data */
if (SYSDB_MAJOR == PROTO_MAJOR_V3)
{
if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
{
pool_error("pool_query_cache_lookup: error while reading message length");
return CACHE_ERROR;
}
readlen = ntohl(readlen) - sizeof(int);
data = pool_read2(SYSDB_CON, readlen);
}
else
{
data = pool_read_string(SYSDB_CON, &readlen, 0);
}
break;
}
else if (kind == 'E')
{
/* must discard the remaining data */
if (SYSDB_MAJOR == PROTO_MAJOR_V3)
{
if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
{
pool_error("pool_query_cache_lookup: error while reading message length");
return CACHE_ERROR;
}
readlen = ntohl(readlen) - sizeof(int);
data = pool_read2(SYSDB_CON, readlen);
}
else
{
data = pool_read_string(SYSDB_CON, &readlen, 0);
}
return_value = CACHE_ERROR;
}
else
{
/* shouldn't get here, but just in case */
return CACHE_ERROR;
}
}
break;
}
return return_value;
}
POOL_STATUS AsciiRow(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend,
short num_fields)
{
static char nullmap[8192], nullmap1[8192];
int nbytes;
int i, j;
unsigned char mask;
int size, size1 = 0;
char *buf = NULL, *sendbuf = NULL;
char msgbuf[1024];
pool_write(frontend, "D", 1);
nbytes = (num_fields + 7)/8;
if (nbytes <= 0)
return POOL_CONTINUE;
/* NULL map */
pool_read(MASTER(backend), nullmap, nbytes);
memcpy(nullmap1, nullmap, nbytes);
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i) && !IS_MASTER_NODE_ID(i))
{
pool_read(CONNECTION(backend, i), nullmap, nbytes);
if (memcmp(nullmap, nullmap1, nbytes))
{
/* XXX: NULLMAP maybe different among
backends. If we were a paranoid, we have to treat
this as a fatal error. However in the real world
we'd better to adapt this situation. Just throw a
log... */
pool_debug("AsciiRow: NULLMAP differ between master and %d th backend", i);
}
}
}
if (pool_write(frontend, nullmap1, nbytes) < 0)
return POOL_END;
mask = 0;
for (i = 0;i<num_fields;i++)
{
if (mask == 0)
mask = 0x80;
/* NOT NULL? */
if (mask & nullmap[i/8])
{
/* field size */
if (pool_read(MASTER(backend), &size, sizeof(int)) < 0)
return POOL_END;
size1 = ntohl(size) - 4;
/* read and send actual data only when size > 0 */
if (size1 > 0)
{
sendbuf = pool_read2(MASTER(backend), size1);
if (sendbuf == NULL)
return POOL_END;
}
/* forward to frontend */
pool_write(frontend, &size, sizeof(int));
pool_write(frontend, sendbuf, size1);
snprintf(msgbuf, Min(sizeof(msgbuf), size1+1), "%s", sendbuf);
pool_debug("AsciiRow: len: %d data: %s", size1, msgbuf);
for (j=0;j<NUM_BACKENDS;j++)
{
if (VALID_BACKEND(j) && !IS_MASTER_NODE_ID(j))
{
/* field size */
if (pool_read(CONNECTION(backend, j), &size, sizeof(int)) < 0)
return POOL_END;
buf = NULL;
size = ntohl(size) - 4;
/* XXX: field size maybe different among
backends. If we were a paranoid, we have to treat
this as a fatal error. However in the real world
we'd better to adapt this situation. Just throw a
log... */
if (size != size1)
pool_debug("AsciiRow: %d th field size does not match between master(%d) and %d th backend(%d)",
i, ntohl(size), j, ntohl(size1));
/* read and send actual data only when size > 0 */
if (size > 0)
{
buf = pool_read2(CONNECTION(backend, j), size);
if (buf == NULL)
return POOL_END;
}
}
}
}
mask >>= 1;
}
if (pool_flush(frontend))
return POOL_END;
return POOL_CONTINUE;
}
