/*-------------------------------------------------------------------------

*

* fe-protocol2.c

* functions that are specific to frontend/backend protocol version 2

*

* Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group

* Portions Copyright (c) 1994, Regents of the University of California

*

*

* IDENTIFICATION

* src/interfaces/libpq/fe-protocol2.c

*

*-------------------------------------------------------------------------

*/

#include "postgres_fe.h"

#include <ctype.h>

#include <fcntl.h>

#include "libpq-fe.h"

#include "libpq-int.h"

#ifdef WIN32

#include "win32.h"

#else

#include <unistd.h>

#include <netinet/in.h>

#ifdef HAVE_NETINET_TCP_H

#include <netinet/tcp.h>

#endif

#include <arpa/inet.h>

#endif

static int getRowDescriptions(PGconn *conn);

static int getAnotherTuple(PGconn *conn, bool binary);

static int pqGetErrorNotice2(PGconn *conn, bool isError);

static void checkXactStatus(PGconn *conn, const char *cmdTag);

static int getNotify(PGconn *conn);

/*

* pqSetenvPoll

*

* Polls the process of passing the values of a standard set of environment

* variables to the backend.

*/

PostgresPollingStatusType

pqSetenvPoll(PGconn *conn)

{

PGresult *res;

if (conn == NULL || conn->status == CONNECTION_BAD)

return PGRES_POLLING_FAILED;

/* Check whether there are any data for us */

switch (conn->setenv_state)

{

/* These are reading states */

case SETENV_STATE_CLIENT_ENCODING_WAIT:

case SETENV_STATE_OPTION_WAIT:

case SETENV_STATE_QUERY1_WAIT:

case SETENV_STATE_QUERY2_WAIT:

{

/* Load waiting data */

int n = pqReadData(conn);

if (n < 0)

goto error_return;

if (n == 0)

return PGRES_POLLING_READING;

break;

}

/* These are writing states, so we just proceed. */

case SETENV_STATE_CLIENT_ENCODING_SEND:

case SETENV_STATE_OPTION_SEND:

case SETENV_STATE_QUERY1_SEND:

case SETENV_STATE_QUERY2_SEND:

break;

/* Should we raise an error if called when not active? */

case SETENV_STATE_IDLE:

return PGRES_POLLING_OK;

default:

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext(

"invalid setenv state %c, "

"probably indicative of memory corruption\n"

),

conn->setenv_state);

goto error_return;

}

/* We will loop here until there is nothing left to do in this call. */

for (;;)

{

switch (conn->setenv_state)

{

/*

* The _CLIENT_ENCODING_SEND code is slightly different from

* _OPTION_SEND below (e.g., no getenv() call), which is why a

* different state is used.

*/

case SETENV_STATE_CLIENT_ENCODING_SEND:

{

char setQuery[100]; /* note length limit in

* sprintf below */

const char *val = conn->client_encoding_initial;

if (val)

{

if (pg_strcasecmp(val, "default") == 0)

sprintf(setQuery, "SET client_encoding = DEFAULT");

else

sprintf(setQuery, "SET client_encoding = '%.60s'",

val);

#ifdef CONNECTDEBUG

fprintf(stderr,

"Sending client_encoding with %s\n",

setQuery);

#endif

if (!PQsendQuery(conn, setQuery))

goto error_return;

conn->setenv_state = SETENV_STATE_CLIENT_ENCODING_WAIT;

}

else

conn->setenv_state = SETENV_STATE_OPTION_SEND;

break;

}

case SETENV_STATE_OPTION_SEND:

{

/*

* Send SET commands for stuff directed by Environment

* Options. Note: we assume that SET commands won't start

* transaction blocks, even in a 7.3 server with

* autocommit off.

*/

char setQuery[100]; /* note length limit in

* sprintf below */

if (conn->next_eo->envName)

{

const char *val;

if ((val = getenv(conn->next_eo->envName)))

{

if (pg_strcasecmp(val, "default") == 0)

sprintf(setQuery, "SET %s = DEFAULT",

conn->next_eo->pgName);

else

sprintf(setQuery, "SET %s = '%.60s'",

conn->next_eo->pgName, val);

#ifdef CONNECTDEBUG

fprintf(stderr,

"Use environment variable %s to send %s\n",

conn->next_eo->envName, setQuery);

#endif

if (!PQsendQuery(conn, setQuery))

goto error_return;

conn->setenv_state = SETENV_STATE_OPTION_WAIT;

}

else

conn->next_eo++;

}

else

{

/* No more options to send, so move on to querying */

conn->setenv_state = SETENV_STATE_QUERY1_SEND;

}

break;

}

case SETENV_STATE_CLIENT_ENCODING_WAIT:

{

if (PQisBusy(conn))

return PGRES_POLLING_READING;

res = PQgetResult(conn);

if (res)

{

if (PQresultStatus(res) != PGRES_COMMAND_OK)

{

PQclear(res);

goto error_return;

}

PQclear(res);

/* Keep reading until PQgetResult returns NULL */

}

else

{

/* Query finished, so send the next option */

conn->setenv_state = SETENV_STATE_OPTION_SEND;

}

break;

}

case SETENV_STATE_OPTION_WAIT:

{

if (PQisBusy(conn))

return PGRES_POLLING_READING;

res = PQgetResult(conn);

if (res)

{

if (PQresultStatus(res) != PGRES_COMMAND_OK)

{

PQclear(res);

goto error_return;

}

PQclear(res);

/* Keep reading until PQgetResult returns NULL */

}

else

{

/* Query finished, so send the next option */

conn->next_eo++;

conn->setenv_state = SETENV_STATE_OPTION_SEND;

}

break;

}

case SETENV_STATE_QUERY1_SEND:

{

/*

* Issue query to get information we need. Here we must

* use begin/commit in case autocommit is off by default

* in a 7.3 server.

*

* Note: version() exists in all protocol-2.0-supporting

* backends. In 7.3 it would be safer to write

* pg_catalog.version(), but we can't do that without

* causing problems on older versions.

*/

if (!PQsendQuery(conn, "begin; select version(); end"))

goto error_return;

conn->setenv_state = SETENV_STATE_QUERY1_WAIT;

return PGRES_POLLING_READING;

}

case SETENV_STATE_QUERY1_WAIT:

{

if (PQisBusy(conn))

return PGRES_POLLING_READING;

res = PQgetResult(conn);

if (res)

{

char *val;

if (PQresultStatus(res) == PGRES_COMMAND_OK)

{

/* ignore begin/commit command results */

PQclear(res);

continue;

}

if (PQresultStatus(res) != PGRES_TUPLES_OK ||

PQntuples(res) != 1)

{

PQclear(res);

goto error_return;

}

/*

* Extract server version and save as if

* ParameterStatus

*/

val = PQgetvalue(res, 0, 0);

if (val && strncmp(val, "PostgreSQL ", 11) == 0)

{

char *ptr;

/* strip off PostgreSQL part */

val += 11;

/*

* strip off platform part (scribbles on result,

* naughty naughty)

*/

ptr = strchr(val, ' ');

if (ptr)

*ptr = '\0';

pqSaveParameterStatus(conn, "server_version",

val);

}

PQclear(res);

/* Keep reading until PQgetResult returns NULL */

}

else

{

/* Query finished, move to next */

conn->setenv_state = SETENV_STATE_QUERY2_SEND;

}

break;

}

case SETENV_STATE_QUERY2_SEND:

{

const char *query;

/*

* pg_client_encoding does not exist in pre-7.2 servers.

* So we need to be prepared for an error here. Do *not*

* start a transaction block, except in 7.3 servers where

* we need to prevent autocommit-off from starting a

* transaction anyway.

*/

if (conn->sversion >= 70300 &&

conn->sversion < 70400)

query = "begin; select pg_catalog.pg_client_encoding(); end";

else

query = "select pg_client_encoding()";

if (!PQsendQuery(conn, query))

goto error_return;

conn->setenv_state = SETENV_STATE_QUERY2_WAIT;

return PGRES_POLLING_READING;

}

case SETENV_STATE_QUERY2_WAIT:

{

if (PQisBusy(conn))

return PGRES_POLLING_READING;

res = PQgetResult(conn);

if (res)

{

const char *val;

if (PQresultStatus(res) == PGRES_COMMAND_OK)

{

/* ignore begin/commit command results */

PQclear(res);

continue;

}

if (PQresultStatus(res) == PGRES_TUPLES_OK &&

PQntuples(res) == 1)

{

/* Extract client encoding and save it */

val = PQgetvalue(res, 0, 0);

if (val && *val) /* null should not happen, but */

pqSaveParameterStatus(conn, "client_encoding",

val);

}

else

{

/*

* Error: presumably function not available, so

* use PGCLIENTENCODING or SQL_ASCII as the

* fallback.

*/

val = getenv("PGCLIENTENCODING");

if (val && *val)

pqSaveParameterStatus(conn, "client_encoding",

val);

else

pqSaveParameterStatus(conn, "client_encoding",

"SQL_ASCII");

}

PQclear(res);

/* Keep reading until PQgetResult returns NULL */

}

else

{

/* Query finished, so we're done */

conn->setenv_state = SETENV_STATE_IDLE;

return PGRES_POLLING_OK;

}

break;

}

default:

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext("invalid state %c, "

"probably indicative of memory corruption\n"),

conn->setenv_state);

goto error_return;

}

}

/* Unreachable */

error_return:

conn->setenv_state = SETENV_STATE_IDLE;

return PGRES_POLLING_FAILED;

}

/*

* parseInput: if appropriate, parse input data from backend

* until input is exhausted or a stopping state is reached.

* Note that this function will NOT attempt to read more data from the backend.

*/

void

pqParseInput2(PGconn *conn)

{

char id;

/*

* Loop to parse successive complete messages available in the buffer.

*/

for (;;)

{

/*

* Quit if in COPY_OUT state: we expect raw data from the server until

* PQendcopy is called. Don't try to parse it according to the normal

* protocol. (This is bogus. The data lines ought to be part of the

* protocol and have identifying leading characters.)

*/

if (conn->asyncStatus == PGASYNC_COPY_OUT)

return;

/*

* OK to try to read a message type code.

*/

conn->inCursor = conn->inStart;

if (pqGetc(&id, conn))

return;

/*

* NOTIFY and NOTICE messages can happen in any state besides COPY

* OUT; always process them right away.

*

* Most other messages should only be processed while in BUSY state.

* (In particular, in READY state we hold off further parsing until

* the application collects the current PGresult.)

*

* However, if the state is IDLE then we got trouble; we need to deal

* with the unexpected message somehow.

*/

if (id == 'A')

{

if (getNotify(conn))

return;

}

else if (id == 'N')

{

if (pqGetErrorNotice2(conn, false))

return;

}

else if (conn->asyncStatus != PGASYNC_BUSY)

{

/* If not IDLE state, just wait ... */

if (conn->asyncStatus != PGASYNC_IDLE)

return;

/*

* Unexpected message in IDLE state; need to recover somehow.

* ERROR messages are displayed using the notice processor;

* anything else is just dropped on the floor after displaying a

* suitable warning notice. (An ERROR is very possibly the

* backend telling us why it is about to close the connection, so

* we don't want to just discard it...)

*/

if (id == 'E')

{

if (pqGetErrorNotice2(conn, false /* treat as notice */ ))

return;

}

else

{

pqInternalNotice(&conn->noticeHooks,

"message type 0x%02x arrived from server while idle",

id);

/* Discard the unexpected message; good idea?? */

conn->inStart = conn->inEnd;

break;

}

}

else

{

/*

* In BUSY state, we can process everything.

*/

switch (id)

{

case 'C': /* command complete */

if (pqGets(&conn->workBuffer, conn))

return;

if (conn->result == NULL)

{

conn->result = PQmakeEmptyPGresult(conn,

PGRES_COMMAND_OK);

if (!conn->result)

{

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext("out of memory"));

pqSaveErrorResult(conn);

}

}

if (conn->result)

{

strlcpy(conn->result->cmdStatus, conn->workBuffer.data,

CMDSTATUS_LEN);

}

checkXactStatus(conn, conn->workBuffer.data);

conn->asyncStatus = PGASYNC_READY;

break;

case 'E': /* error return */

if (pqGetErrorNotice2(conn, true))

return;

conn->asyncStatus = PGASYNC_READY;

break;

case 'Z': /* backend is ready for new query */

conn->asyncStatus = PGASYNC_IDLE;

break;

case 'I': /* empty query */

/* read and throw away the closing '\0' */

if (pqGetc(&id, conn))

return;

if (id != '\0')

pqInternalNotice(&conn->noticeHooks,

"unexpected character %c following empty query response (\"I\" message)",

id);

if (conn->result == NULL)

{

conn->result = PQmakeEmptyPGresult(conn,

PGRES_EMPTY_QUERY);

if (!conn->result)

{

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext("out of memory"));

pqSaveErrorResult(conn);

}

}

conn->asyncStatus = PGASYNC_READY;

break;

case 'K': /* secret key data from the backend */

/*

* This is expected only during backend startup, but it's

* just as easy to handle it as part of the main loop.

* Save the data and continue processing.

*/

if (pqGetInt(&(conn->be_pid), 4, conn))

return;

if (pqGetInt(&(conn->be_key), 4, conn))

return;

break;

case 'P': /* synchronous (normal) portal */

if (pqGets(&conn->workBuffer, conn))

return;

/* We pretty much ignore this message type... */

break;

case 'T': /* row descriptions (start of query results) */

if (conn->result == NULL)

{

/* First 'T' in a query sequence */

if (getRowDescriptions(conn))

return;

/* getRowDescriptions() moves inStart itself */

continue;

}

else

{

/*

* A new 'T' message is treated as the start of

* another PGresult. (It is not clear that this is

* really possible with the current backend.) We stop

* parsing until the application accepts the current

* result.

*/

conn->asyncStatus = PGASYNC_READY;

return;

}

break;

case 'D': /* ASCII data tuple */

if (conn->result != NULL)

{

/* Read another tuple of a normal query response */

if (getAnotherTuple(conn, FALSE))

return;

/* getAnotherTuple() moves inStart itself */

continue;

}

else

{

pqInternalNotice(&conn->noticeHooks,

"server sent data (\"D\" message) without prior row description (\"T\" message)");

/* Discard the unexpected message; good idea?? */

conn->inStart = conn->inEnd;

return;

}

break;

case 'B': /* Binary data tuple */

if (conn->result != NULL)

{

/* Read another tuple of a normal query response */

if (getAnotherTuple(conn, TRUE))

return;

/* getAnotherTuple() moves inStart itself */

continue;

}

else

{

pqInternalNotice(&conn->noticeHooks,

"server sent binary data (\"B\" message) without prior row description (\"T\" message)");

/* Discard the unexpected message; good idea?? */

conn->inStart = conn->inEnd;

return;

}

break;

case 'G': /* Start Copy In */

conn->asyncStatus = PGASYNC_COPY_IN;

break;

case 'H': /* Start Copy Out */

conn->asyncStatus = PGASYNC_COPY_OUT;

break;

/*

* Don't need to process CopyBothResponse here because it

* never arrives from the server during protocol 2.0.

*/

default:

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext(

"unexpected response from server; first received character was \"%c\"\n"),

id);

/* build an error result holding the error message */

pqSaveErrorResult(conn);

/* Discard the unexpected message; good idea?? */

conn->inStart = conn->inEnd;

conn->asyncStatus = PGASYNC_READY;

return;

} /* switch on protocol character */

}

/* Successfully consumed this message */

conn->inStart = conn->inCursor;

}

}

/*

* parseInput subroutine to read a 'T' (row descriptions) message.

* We build a PGresult structure containing the attribute data.

* Returns: 0 if completed message, EOF if error or not enough data

* received yet.

*

* Note that if we run out of data, we have to suspend and reprocess

* the message after more data is received. Otherwise, conn->inStart

* must get advanced past the processed data.

*/

static int

getRowDescriptions(PGconn *conn)

{

PGresult *result;

int nfields;

const char *errmsg;

int i;

result = PQmakeEmptyPGresult(conn, PGRES_TUPLES_OK);

if (!result)

{

errmsg = NULL; /* means "out of memory", see below */

goto advance_and_error;

}

/* parseInput already read the 'T' label. */

/* the next two bytes are the number of fields */

if (pqGetInt(&(result->numAttributes), 2, conn))

goto EOFexit;

nfields = result->numAttributes;

/* allocate space for the attribute descriptors */

if (nfields > 0)

{

result->attDescs = (PGresAttDesc *)

pqResultAlloc(result, nfields * sizeof(PGresAttDesc), TRUE);

if (!result->attDescs)

{

errmsg = NULL; /* means "out of memory", see below */

goto advance_and_error;

}

MemSet(result->attDescs, 0, nfields * sizeof(PGresAttDesc));

}

/* get type info */

for (i = 0; i < nfields; i++)

{

int typid;

int typlen;

int atttypmod;

if (pqGets(&conn->workBuffer, conn) ||

pqGetInt(&typid, 4, conn) ||

pqGetInt(&typlen, 2, conn) ||

pqGetInt(&atttypmod, 4, conn))

goto EOFexit;

/*

* Since pqGetInt treats 2-byte integers as unsigned, we need to

* coerce the result to signed form.

*/

typlen = (int) ((int16) typlen);

result->attDescs[i].name = pqResultStrdup(result,

conn->workBuffer.data);

if (!result->attDescs[i].name)

{

errmsg = NULL; /* means "out of memory", see below */

goto advance_and_error;

}

result->attDescs[i].tableid = 0;

result->attDescs[i].columnid = 0;

result->attDescs[i].format = 0;

result->attDescs[i].typid = typid;

result->attDescs[i].typlen = typlen;

result->attDescs[i].atttypmod = atttypmod;

}

/* Success! */

conn->result = result;

/* Advance inStart to show that the "T" message has been processed. */

conn->inStart = conn->inCursor;

/*

* We could perform additional setup for the new result set here, but for

* now there's nothing else to do.

*/

/* And we're done. */

return 0;

advance_and_error:

/*

* Discard the failed message. Unfortunately we don't know for sure where

* the end is, so just throw away everything in the input buffer. This is

* not very desirable but it's the best we can do in protocol v2.

*/

conn->inStart = conn->inEnd;

/*

* Replace partially constructed result with an error result. First

* discard the old result to try to win back some memory.

*/

pqClearAsyncResult(conn);

/*

* If preceding code didn't provide an error message, assume "out of

* memory" was meant. The advantage of having this special case is that

* freeing the old result first greatly improves the odds that gettext()

* will succeed in providing a translation.

*/

if (!errmsg)

errmsg = libpq_gettext("out of memory for query result");

printfPQExpBuffer(&conn->errorMessage, "%s\n", errmsg);

/*

* XXX: if PQmakeEmptyPGresult() fails, there's probably not much we can

* do to recover...

*/

conn->result = PQmakeEmptyPGresult(conn, PGRES_FATAL_ERROR);

conn->asyncStatus = PGASYNC_READY;

EOFexit:

if (result && result != conn->result)

PQclear(result);

return EOF;

}

/*

* parseInput subroutine to read a 'B' or 'D' (row data) message.

* We fill rowbuf with column pointers and then call the row processor.

* Returns: 0 if completed message, EOF if error or not enough data

* received yet.

*

* Note that if we run out of data, we have to suspend and reprocess

* the message after more data is received. Otherwise, conn->inStart

* must get advanced past the processed data.

*/

static int

getAnotherTuple(PGconn *conn, bool binary)

{

PGresult *result = conn->result;

int nfields = result->numAttributes;

const char *errmsg;

PGdataValue *rowbuf;

/* the backend sends us a bitmap of which attributes are null */

char std_bitmap[64]; /* used unless it doesn't fit */

char *bitmap = std_bitmap;

int i;

size_t nbytes; /* the number of bytes in bitmap */

char bmap; /* One byte of the bitmap */

int bitmap_index; /* Its index */

int bitcnt; /* number of bits examined in current byte */

int vlen; /* length of the current field value */

/* Resize row buffer if needed */

rowbuf = conn->rowBuf;

if (nfields > conn->rowBufLen)

{

rowbuf = (PGdataValue *) realloc(rowbuf,

nfields * sizeof(PGdataValue));

if (!rowbuf)

{

errmsg = NULL; /* means "out of memory", see below */

goto advance_and_error;

}

conn->rowBuf = rowbuf;

conn->rowBufLen = nfields;

}

/* Save format specifier */

result->binary = binary;

/*

* If it's binary, fix the column format indicators. We assume the

* backend will consistently send either B or D, not a mix.

*/

if (binary)

{

for (i = 0; i < nfields; i++)

result->attDescs[i].format = 1;

}

/* Get the null-value bitmap */

nbytes = (nfields + BITS_PER_BYTE - 1) / BITS_PER_BYTE;

/* malloc() only for unusually large field counts... */

if (nbytes > sizeof(std_bitmap))

{

bitmap = (char *) malloc(nbytes);

if (!bitmap)

{

errmsg = NULL; /* means "out of memory", see below */

goto advance_and_error;

}

}

if (pqGetnchar(bitmap, nbytes, conn))

goto EOFexit;

/* Scan the fields */

bitmap_index = 0;

bmap = bitmap[bitmap_index];

bitcnt = 0;

for (i = 0; i < nfields; i++)

{

/* get the value length */

if (!(bmap & 0200))

vlen = NULL_LEN;

else if (pqGetInt(&vlen, 4, conn))

goto EOFexit;

else

{

if (!binary)

vlen = vlen - 4;

if (vlen < 0)

vlen = 0;

}

rowbuf[i].len = vlen;

/*

* rowbuf[i].value always points to the next address in the data

* buffer even if the value is NULL. This allows row processors to

* estimate data sizes more easily.

*/

rowbuf[i].value = conn->inBuffer + conn->inCursor;

/* Skip over the data value */

if (vlen > 0)

{

if (pqSkipnchar(vlen, conn))

goto EOFexit;

}

/* advance the bitmap stuff */

bitcnt++;

if (bitcnt == BITS_PER_BYTE)

{

bitmap_index++;

bmap = bitmap[bitmap_index];

bitcnt = 0;

}

else

bmap <<= 1;

}

/* Release bitmap now if we allocated it */

if (bitmap != std_bitmap)

free(bitmap);

bitmap = NULL;

/* Advance inStart to show that the "D" message has been processed. */

conn->inStart = conn->inCursor;

/* Process the collected row */

errmsg = NULL;

if (pqRowProcessor(conn, &errmsg))

return 0; /* normal, successful exit */

goto set_error_result; /* pqRowProcessor failed, report it */

advance_and_error:

/*

* Discard the failed message. Unfortunately we don't know for sure where

* the end is, so just throw away everything in the input buffer. This is

* not very desirable but it's the best we can do in protocol v2.

*/

conn->inStart = conn->inEnd;

set_error_result:

/*

* Replace partially constructed result with an error result. First

* discard the old result to try to win back some memory.

*/

pqClearAsyncResult(conn);

/*

* If preceding code didn't provide an error message, assume "out of

* memory" was meant. The advantage of having this special case is that

* freeing the old result first greatly improves the odds that gettext()

* will succeed in providing a translation.

*/

if (!errmsg)

errmsg = libpq_gettext("out of memory for query result");

printfPQExpBuffer(&conn->errorMessage, "%s\n", errmsg);

/*

* XXX: if PQmakeEmptyPGresult() fails, there's probably not much we can

* do to recover...

*/

conn->result = PQmakeEmptyPGresult(conn, PGRES_FATAL_ERROR);

conn->asyncStatus = PGASYNC_READY;

EOFexit:

if (bitmap != NULL && bitmap != std_bitmap)

free(bitmap);

return EOF;

}

/*

* Attempt to read an Error or Notice response message.

* This is possible in several places, so we break it out as a subroutine.

* Entry: 'E' or 'N' message type has already been consumed.

* Exit: returns 0 if successfully consumed message.

* returns EOF if not enough data.

*/

static int

pqGetErrorNotice2(PGconn *conn, bool isError)

{

PGresult *res = NULL;

PQExpBufferData workBuf;

char *startp;

char *splitp;

/*

* Since the message might be pretty long, we create a temporary

* PQExpBuffer rather than using conn->workBuffer. workBuffer is intended

* for stuff that is expected to be short.

*/

initPQExpBuffer(&workBuf);

if (pqGets(&workBuf, conn))

goto failure;

/*

* Make a PGresult to hold the message. We temporarily lie about the

* result status, so that PQmakeEmptyPGresult doesn't uselessly copy

* conn->errorMessage.

*

* NB: This allocation can fail, if you run out of memory. The rest of the

* function handles that gracefully, and we still try to set the error

* message as the connection's error message.

*/

res = PQmakeEmptyPGresult(conn, PGRES_EMPTY_QUERY);

if (res)

{

res->resultStatus = isError ? PGRES_FATAL_ERROR : PGRES_NONFATAL_ERROR;

res->errMsg = pqResultStrdup(res, workBuf.data);

}

/*

* Break the message into fields. We can't do very much here, but we can

* split the severity code off, and remove trailing newlines. Also, we use

* the heuristic that the primary message extends only to the first

* newline --- anything after that is detail message. (In some cases it'd

* be better classed as hint, but we can hardly be expected to guess that