/* * 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; }