libpq-int.h File Reference

#include "libpq-events.h"
#include <netdb.h>
#include <sys/socket.h>
#include <time.h>
#include <pthread.h>
#include <signal.h>
#include "libpq/pqcomm.h"
#include "fe-auth-sasl.h"
#include "pqexpbuffer.h"
#include "common/pg_prng.h"

Include dependency graph for libpq-int.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
union	pgresult_data
struct	pgresParamDesc
struct	pgresAttValue
struct	pgMessageField
struct	PGNoticeHooks
struct	PGEvent
struct	pg_result
struct	PQEnvironmentOption
struct	pgParameterStatus
struct	pgLobjfuncs
struct	pgDataValue
struct	PGcmdQueueEntry
struct	pg_conn_host
struct	pg_conn

Macros
#define	CMDSTATUS_LEN   64 /* should match COMPLETION_TAG_BUFSIZE */
#define	NULL_LEN   (-1) /* pg_result len for NULL value */
#define	ENC_ERROR   0
#define	ENC_PLAINTEXT   0x01
#define	ENC_GSSAPI   0x02
#define	ENC_SSL   0x04
#define	AUTH_RESPONSE_GSS   'G'
#define	AUTH_RESPONSE_PASSWORD   'P'
#define	AUTH_RESPONSE_SASL_INITIAL   'I'
#define	AUTH_RESPONSE_SASL   'S'
#define	pglock_thread()   pg_g_threadlock(true)
#define	pgunlock_thread()   pg_g_threadlock(false)
#define	pqClearConnErrorState(conn)
#define	pgHavePendingResult(conn)    ((conn)->result != NULL || (conn)->error_result)
#define	pqIsnonblocking(conn)   ((conn)->nonblocking)
#define	OUTBUFFER_THRESHOLD   65536
#define	libpq_gettext(x)   (x)
#define	libpq_ngettext(s, p, n)   ((n) == 1 ? (s) : (p))
#define	SOCK_ERRNO   errno
#define	SOCK_STRERROR   strerror_r
#define	SOCK_ERRNO_SET(e)   (errno = (e))

Typedefs
typedef union pgresult_data	PGresult_data
typedef struct pgresParamDesc	PGresParamDesc
typedef struct pgresAttValue	PGresAttValue
typedef struct pgMessageField	PGMessageField
typedef struct PGEvent	PGEvent
typedef struct PQEnvironmentOption	PQEnvironmentOption
typedef struct pgParameterStatus	pgParameterStatus
typedef struct pgLobjfuncs	PGlobjfuncs
typedef struct pgDataValue	PGdataValue
typedef enum pg_conn_host_type	pg_conn_host_type
typedef struct PGcmdQueueEntry	PGcmdQueueEntry
typedef struct pg_conn_host	pg_conn_host

Enumerations
enum	PGAsyncStatusType {   PGASYNC_IDLE , PGASYNC_BUSY , PGASYNC_READY , PGASYNC_READY_MORE ,   PGASYNC_COPY_IN , PGASYNC_COPY_OUT , PGASYNC_COPY_BOTH , PGASYNC_PIPELINE_IDLE }
enum	PGTargetServerType {   SERVER_TYPE_ANY = 0 , SERVER_TYPE_READ_WRITE , SERVER_TYPE_READ_ONLY , SERVER_TYPE_PRIMARY ,   SERVER_TYPE_STANDBY , SERVER_TYPE_PREFER_STANDBY , SERVER_TYPE_PREFER_STANDBY_PASS2 }
enum	PGLoadBalanceType { LOAD_BALANCE_DISABLE = 0 , LOAD_BALANCE_RANDOM }
enum	PGTernaryBool { PG_BOOL_UNKNOWN = 0 , PG_BOOL_YES , PG_BOOL_NO }
enum	pg_conn_host_type { CHT_HOST_NAME , CHT_HOST_ADDRESS , CHT_UNIX_SOCKET }
enum	PGQueryClass {   PGQUERY_SIMPLE , PGQUERY_EXTENDED , PGQUERY_PREPARE , PGQUERY_DESCRIBE ,   PGQUERY_SYNC , PGQUERY_CLOSE }

Functions
void	pqDropConnection (PGconn *conn, bool flushInput)
bool	pqConnectOptions2 (PGconn *conn)
int	pqConnectDBStart (PGconn *conn)
int	pqConnectDBComplete (PGconn *conn)
PGconn *	pqMakeEmptyPGconn (void)
void	pqReleaseConnHosts (PGconn *conn)
void	pqClosePGconn (PGconn *conn)
int	pqPacketSend (PGconn *conn, char pack_type, const void *buf, size_t buf_len)
bool	pqGetHomeDirectory (char *buf, int bufsize)
bool	pqCopyPGconn (PGconn *srcConn, PGconn *dstConn)
bool	pqParseIntParam (const char *value, int *result, PGconn *conn, const char *context)
void	pqSetResultError (PGresult *res, PQExpBuffer errorMessage, int offset)
void *	pqResultAlloc (PGresult *res, size_t nBytes, bool isBinary)
char *	pqResultStrdup (PGresult *res, const char *str)
void	pqClearAsyncResult (PGconn *conn)
void	pqSaveErrorResult (PGconn *conn)
PGresult *	pqPrepareAsyncResult (PGconn *conn)
void	pqInternalNotice (const PGNoticeHooks *hooks, const char *fmt,...) pg_attribute_printf(2
void void	pqSaveMessageField (PGresult *res, char code, const char *value)
void	pqSaveParameterStatus (PGconn *conn, const char *name, const char *value)
int	pqRowProcessor (PGconn *conn, const char **errmsgp)
void	pqCommandQueueAdvance (PGconn *conn, bool isReadyForQuery, bool gotSync)
int	PQsendQueryContinue (PGconn *conn, const char *query)
char *	pqBuildStartupPacket3 (PGconn *conn, int *packetlen, const PQEnvironmentOption *options)
void	pqParseInput3 (PGconn *conn)
int	pqGetErrorNotice3 (PGconn *conn, bool isError)
void	pqBuildErrorMessage3 (PQExpBuffer msg, const PGresult *res, PGVerbosity verbosity, PGContextVisibility show_context)
int	pqGetNegotiateProtocolVersion3 (PGconn *conn)
int	pqGetCopyData3 (PGconn *conn, char **buffer, int async)
int	pqGetline3 (PGconn *conn, char *s, int maxlen)
int	pqGetlineAsync3 (PGconn *conn, char *buffer, int bufsize)
int	pqEndcopy3 (PGconn *conn)
PGresult *	pqFunctionCall3 (PGconn *conn, Oid fnid, int *result_buf, int *actual_result_len, int result_is_int, const PQArgBlock *args, int nargs)
int	pqCheckOutBufferSpace (size_t bytes_needed, PGconn *conn)
int	pqCheckInBufferSpace (size_t bytes_needed, PGconn *conn)
void	pqParseDone (PGconn *conn, int newInStart)
int	pqGetc (char *result, PGconn *conn)
int	pqPutc (char c, PGconn *conn)
int	pqGets (PQExpBuffer buf, PGconn *conn)
int	pqGets_append (PQExpBuffer buf, PGconn *conn)
int	pqPuts (const char *s, PGconn *conn)
int	pqGetnchar (char *s, size_t len, PGconn *conn)
int	pqSkipnchar (size_t len, PGconn *conn)
int	pqPutnchar (const char *s, size_t len, PGconn *conn)
int	pqGetInt (int *result, size_t bytes, PGconn *conn)
int	pqPutInt (int value, size_t bytes, PGconn *conn)
int	pqPutMsgStart (char msg_type, PGconn *conn)
int	pqPutMsgEnd (PGconn *conn)
int	pqReadData (PGconn *conn)
int	pqFlush (PGconn *conn)
int	pqWait (int forRead, int forWrite, PGconn *conn)
int	pqWaitTimed (int forRead, int forWrite, PGconn *conn, pg_usec_time_t end_time)
int	pqReadReady (PGconn *conn)
int	pqWriteReady (PGconn *conn)
PostgresPollingStatusType	pqsecure_open_client (PGconn *)
void	pqsecure_close (PGconn *)
ssize_t	pqsecure_read (PGconn *, void *ptr, size_t len)
ssize_t	pqsecure_write (PGconn *, const void *ptr, size_t len)
ssize_t	pqsecure_raw_read (PGconn *, void *ptr, size_t len)
ssize_t	pqsecure_raw_write (PGconn *, const void *ptr, size_t len)
int	pq_block_sigpipe (sigset_t *osigset, bool *sigpipe_pending)
void	pq_reset_sigpipe (sigset_t *osigset, bool sigpipe_pending, bool got_epipe)
PostgresPollingStatusType	pgtls_open_client (PGconn *conn)
void	pgtls_close (PGconn *conn)
ssize_t	pgtls_read (PGconn *conn, void *ptr, size_t len)
bool	pgtls_read_pending (PGconn *conn)
ssize_t	pgtls_write (PGconn *conn, const void *ptr, size_t len)
char *	pgtls_get_peer_certificate_hash (PGconn *conn, size_t *len)
int	pgtls_verify_peer_name_matches_certificate_guts (PGconn *conn, int *names_examined, char **first_name)
void	pqTraceOutputMessage (PGconn *conn, const char *message, bool toServer)
void	pqTraceOutputNoTypeByteMessage (PGconn *conn, const char *message)
void	pqTraceOutputCharResponse (PGconn *conn, const char *responseType, char response)
void	libpq_append_error (PQExpBuffer errorMessage, const char *fmt,...) pg_attribute_printf(2
void void	libpq_append_conn_error (PGconn *conn, const char *fmt,...) pg_attribute_printf(2

Variables
char *const	pgresStatus []
pgthreadlock_t	pg_g_threadlock

Macro Definition Documentation

AUTH_RESPONSE_GSS

#define AUTH_RESPONSE_GSS   'G'

Definition at line 341 of file libpq-int.h.

AUTH_RESPONSE_PASSWORD

#define AUTH_RESPONSE_PASSWORD   'P'

Definition at line 342 of file libpq-int.h.

AUTH_RESPONSE_SASL

#define AUTH_RESPONSE_SASL   'S'

Definition at line 344 of file libpq-int.h.

AUTH_RESPONSE_SASL_INITIAL

#define AUTH_RESPONSE_SASL_INITIAL   'I'

Definition at line 343 of file libpq-int.h.

CMDSTATUS_LEN

#define CMDSTATUS_LEN   64 /* should match COMPLETION_TAG_BUFSIZE */

Definition at line 89 of file libpq-int.h.

ENC_ERROR

#define ENC_ERROR   0

Definition at line 235 of file libpq-int.h.

ENC_GSSAPI

#define ENC_GSSAPI   0x02

Definition at line 237 of file libpq-int.h.

ENC_PLAINTEXT

#define ENC_PLAINTEXT   0x01

Definition at line 236 of file libpq-int.h.

ENC_SSL

#define ENC_SSL   0x04

Definition at line 238 of file libpq-int.h.

libpq_gettext

#define libpq_gettext

(

x

)

(x)

Definition at line 905 of file libpq-int.h.

libpq_ngettext

#define libpq_ngettext	(		s,
			p,
			n
	)		((n) == 1 ? (s) : (p))

Definition at line 906 of file libpq-int.h.

NULL_LEN

#define NULL_LEN   (-1) /* pg_result len for NULL value */

Definition at line 136 of file libpq-int.h.

OUTBUFFER_THRESHOLD

#define OUTBUFFER_THRESHOLD   65536

Definition at line 899 of file libpq-int.h.

pgHavePendingResult

#define pgHavePendingResult

(

conn

)

((conn)->result != NULL || (conn)->error_result)

Definition at line 887 of file libpq-int.h.

pglock_thread

#define pglock_thread

(

)

pg_g_threadlock(true)

Definition at line 703 of file libpq-int.h.

pgunlock_thread

#define pgunlock_thread

(

)

pg_g_threadlock(false)

Definition at line 704 of file libpq-int.h.

pqClearConnErrorState

#define pqClearConnErrorState

(

conn

)

Value:

    (resetPQExpBuffer(&(conn)->errorMessage), \
     (conn)->errorReported = 0)

Definition at line 878 of file libpq-int.h.

pqIsnonblocking

#define pqIsnonblocking

(

conn

)

((conn)->nonblocking)

Definition at line 894 of file libpq-int.h.

SOCK_ERRNO

#define SOCK_ERRNO   errno

Definition at line 926 of file libpq-int.h.

SOCK_ERRNO_SET

#define SOCK_ERRNO_SET

(

e

)

(errno = (e))

Definition at line 928 of file libpq-int.h.

SOCK_STRERROR

#define SOCK_STRERROR   strerror_r

Definition at line 927 of file libpq-int.h.

Typedef Documentation

pg_conn_host

typedef struct pg_conn_host pg_conn_host

pg_conn_host_type

typedef enum pg_conn_host_type pg_conn_host_type

PGcmdQueueEntry

typedef struct PGcmdQueueEntry PGcmdQueueEntry

PGdataValue

typedef struct pgDataValue PGdataValue

PGEvent

typedef struct PGEvent PGEvent

PGlobjfuncs

typedef struct pgLobjfuncs PGlobjfuncs

PGMessageField

typedef struct pgMessageField PGMessageField

pgParameterStatus

typedef struct pgParameterStatus pgParameterStatus

PGresAttValue

typedef struct pgresAttValue PGresAttValue

PGresParamDesc

typedef struct pgresParamDesc PGresParamDesc

PGresult_data

typedef union pgresult_data PGresult_data

Definition at line 1 of file libpq-int.h.

PQEnvironmentOption

typedef struct PQEnvironmentOption PQEnvironmentOption

Enumeration Type Documentation

pg_conn_host_type

enum pg_conn_host_type

Enumerator
CHT_HOST_NAME
CHT_HOST_ADDRESS
CHT_UNIX_SOCKET

Definition at line 313 of file libpq-int.h.

{
    CHT_HOST_NAME,
    CHT_HOST_ADDRESS,
    CHT_UNIX_SOCKET
} pg_conn_host_type;

PGAsyncStatusType

enum PGAsyncStatusType

Enumerator
PGASYNC_IDLE
PGASYNC_BUSY
PGASYNC_READY
PGASYNC_READY_MORE
PGASYNC_COPY_IN
PGASYNC_COPY_OUT
PGASYNC_COPY_BOTH
PGASYNC_PIPELINE_IDLE

Definition at line 219 of file libpq-int.h.

{
    PGASYNC_IDLE,               /* nothing's happening, dude */
    PGASYNC_BUSY,               /* query in progress */
    PGASYNC_READY,              /* query done, waiting for client to fetch
                                 * result */
    PGASYNC_READY_MORE,         /* query done, waiting for client to fetch
                                 * result, more results expected from this
                                 * query */
    PGASYNC_COPY_IN,            /* Copy In data transfer in progress */
    PGASYNC_COPY_OUT,           /* Copy Out data transfer in progress */
    PGASYNC_COPY_BOTH,          /* Copy In/Out data transfer in progress */
    PGASYNC_PIPELINE_IDLE,      /* "Idle" between commands in pipeline mode */
} PGAsyncStatusType;

PGLoadBalanceType

enum PGLoadBalanceType

Enumerator
LOAD_BALANCE_DISABLE
LOAD_BALANCE_RANDOM

Definition at line 253 of file libpq-int.h.

{
    LOAD_BALANCE_DISABLE = 0,   /* Use the existing host order (default) */
    LOAD_BALANCE_RANDOM,        /* Randomly shuffle the hosts */
} PGLoadBalanceType;

PGQueryClass

enum PGQueryClass

Enumerator
PGQUERY_SIMPLE
PGQUERY_EXTENDED
PGQUERY_PREPARE
PGQUERY_DESCRIBE
PGQUERY_SYNC
PGQUERY_CLOSE

Definition at line 324 of file libpq-int.h.

{
    PGQUERY_SIMPLE,             /* simple Query protocol (PQexec) */
    PGQUERY_EXTENDED,           /* full Extended protocol (PQexecParams) */
    PGQUERY_PREPARE,            /* Parse only (PQprepare) */
    PGQUERY_DESCRIBE,           /* Describe Statement or Portal */
    PGQUERY_SYNC,               /* Sync (at end of a pipeline) */
    PGQUERY_CLOSE               /* Close Statement or Portal */
} PGQueryClass;

PGTargetServerType

enum PGTargetServerType

Enumerator
SERVER_TYPE_ANY
SERVER_TYPE_READ_WRITE
SERVER_TYPE_READ_ONLY
SERVER_TYPE_PRIMARY
SERVER_TYPE_STANDBY
SERVER_TYPE_PREFER_STANDBY
SERVER_TYPE_PREFER_STANDBY_PASS2

Definition at line 241 of file libpq-int.h.

{
    SERVER_TYPE_ANY = 0,        /* Any server (default) */
    SERVER_TYPE_READ_WRITE,     /* Read-write server */
    SERVER_TYPE_READ_ONLY,      /* Read-only server */
    SERVER_TYPE_PRIMARY,        /* Primary server */
    SERVER_TYPE_STANDBY,        /* Standby server */
    SERVER_TYPE_PREFER_STANDBY, /* Prefer standby server */
    SERVER_TYPE_PREFER_STANDBY_PASS2    /* second pass - behaves same as ANY */
} PGTargetServerType;

PGTernaryBool

enum PGTernaryBool

Enumerator
PG_BOOL_UNKNOWN
PG_BOOL_YES
PG_BOOL_NO

Definition at line 260 of file libpq-int.h.

{
    PG_BOOL_UNKNOWN = 0,        /* Currently unknown */
    PG_BOOL_YES,                /* Yes (true) */
    PG_BOOL_NO                  /* No (false) */
} PGTernaryBool;

Function Documentation

libpq_append_conn_error()

void void libpq_append_conn_error	(	PGconn *	conn,
		const char *	fmt,
			...
	)

libpq_append_error()

void libpq_append_error	(	PQExpBuffer	errorMessage,
		const char *	fmt,
			...
	)

pgtls_close()

void pgtls_close

(

PGconn *

conn

)

Definition at line 1440 of file fe-secure-openssl.c.

{
    if (conn->ssl_in_use)
    {
        if (conn->ssl)
        {
            /*
             * We can't destroy everything SSL-related here due to the
             * possible later calls to OpenSSL routines which may need our
             * thread callbacks, so set a flag here and check at the end.
             */
 
            SSL_shutdown(conn->ssl);
            SSL_free(conn->ssl);
            conn->ssl = NULL;
            conn->ssl_in_use = false;
            conn->ssl_handshake_started = false;
        }
 
        if (conn->peer)
        {
            X509_free(conn->peer);
            conn->peer = NULL;
        }
 
#ifdef USE_SSL_ENGINE
        if (conn->engine)
        {
            ENGINE_finish(conn->engine);
            ENGINE_free(conn->engine);
            conn->engine = NULL;
        }
#endif
    }
}

References conn, pg_conn::ssl_handshake_started, and pg_conn::ssl_in_use.

Referenced by open_client_SSL(), pgtls_open_client(), and pqsecure_close().

pgtls_get_peer_certificate_hash()

char* pgtls_get_peer_certificate_hash	(	PGconn *	conn,
		size_t *	len
	)

Definition at line 339 of file fe-secure-openssl.c.

{
    X509       *peer_cert;
    const EVP_MD *algo_type;
    unsigned char hash[EVP_MAX_MD_SIZE];    /* size for SHA-512 */
    unsigned int hash_size;
    int         algo_nid;
    char       *cert_hash;
 
    *len = 0;
 
    if (!conn->peer)
        return NULL;
 
    peer_cert = conn->peer;
 
    /*
     * Get the signature algorithm of the certificate to determine the hash
     * algorithm to use for the result.  Prefer X509_get_signature_info(),
     * introduced in OpenSSL 1.1.1, which can handle RSA-PSS signatures.
     */
#if HAVE_X509_GET_SIGNATURE_INFO
    if (!X509_get_signature_info(peer_cert, &algo_nid, NULL, NULL, NULL))
#else
    if (!OBJ_find_sigid_algs(X509_get_signature_nid(peer_cert),
                             &algo_nid, NULL))
#endif
    {
        libpq_append_conn_error(conn, "could not determine server certificate signature algorithm");
        return NULL;
    }
 
    /*
     * The TLS server's certificate bytes need to be hashed with SHA-256 if
     * its signature algorithm is MD5 or SHA-1 as per RFC 5929
     * (https://tools.ietf.org/html/rfc5929#section-4.1).  If something else
     * is used, the same hash as the signature algorithm is used.
     */
    switch (algo_nid)
    {
        case NID_md5:
        case NID_sha1:
            algo_type = EVP_sha256();
            break;
        default:
            algo_type = EVP_get_digestbynid(algo_nid);
            if (algo_type == NULL)
            {
                libpq_append_conn_error(conn, "could not find digest for NID %s",
                                        OBJ_nid2sn(algo_nid));
                return NULL;
            }
            break;
    }
 
    if (!X509_digest(peer_cert, algo_type, hash, &hash_size))
    {
        libpq_append_conn_error(conn, "could not generate peer certificate hash");
        return NULL;
    }
 
    /* save result */
    cert_hash = malloc(hash_size);
    if (cert_hash == NULL)
    {
        libpq_append_conn_error(conn, "out of memory");
        return NULL;
    }
    memcpy(cert_hash, hash, hash_size);
    *len = hash_size;
 
    return cert_hash;
}

References conn, hash(), len, libpq_append_conn_error(), and malloc.

Referenced by build_client_final_message().

pgtls_open_client()

PostgresPollingStatusType pgtls_open_client

(

PGconn *

conn

)

Definition at line 95 of file fe-secure-openssl.c.

{
    /* First time through? */
    if (conn->ssl == NULL)
    {
        /*
         * Create a connection-specific SSL object, and load client
         * certificate, private key, and trusted CA certs.
         */
        if (initialize_SSL(conn) != 0)
        {
            /* initialize_SSL already put a message in conn->errorMessage */
            pgtls_close(conn);
            return PGRES_POLLING_FAILED;
        }
    }
 
    /* Begin or continue the actual handshake */
    return open_client_SSL(conn);
}

References conn, initialize_SSL(), open_client_SSL(), PGRES_POLLING_FAILED, and pgtls_close().

Referenced by pqsecure_open_client().

pgtls_read()

ssize_t pgtls_read	(	PGconn *	conn,
		void *	ptr,
		size_t	len
	)

Definition at line 117 of file fe-secure-openssl.c.

{
    ssize_t     n;
    int         result_errno = 0;
    char        sebuf[PG_STRERROR_R_BUFLEN];
    int         err;
    unsigned long ecode;
 
rloop:
 
    /*
     * Prepare to call SSL_get_error() by clearing thread's OpenSSL error
     * queue.  In general, the current thread's error queue must be empty
     * before the TLS/SSL I/O operation is attempted, or SSL_get_error() will
     * not work reliably.  Since the possibility exists that other OpenSSL
     * clients running in the same thread but not under our control will fail
     * to call ERR_get_error() themselves (after their own I/O operations),
     * pro-actively clear the per-thread error queue now.
     */
    SOCK_ERRNO_SET(0);
    ERR_clear_error();
    n = SSL_read(conn->ssl, ptr, len);
    err = SSL_get_error(conn->ssl, n);
 
    /*
     * Other clients of OpenSSL may fail to call ERR_get_error(), but we
     * always do, so as to not cause problems for OpenSSL clients that don't
     * call ERR_clear_error() defensively.  Be sure that this happens by
     * calling now.  SSL_get_error() relies on the OpenSSL per-thread error
     * queue being intact, so this is the earliest possible point
     * ERR_get_error() may be called.
     */
    ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
    switch (err)
    {
        case SSL_ERROR_NONE:
            if (n < 0)
            {
                /* Not supposed to happen, so we don't translate the msg */
                appendPQExpBufferStr(&conn->errorMessage,
                                     "SSL_read failed but did not provide error information\n");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
            }
            break;
        case SSL_ERROR_WANT_READ:
            n = 0;
            break;
        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 rloop;
        case SSL_ERROR_SYSCALL:
            if (n < 0 && SOCK_ERRNO != 0)
            {
                result_errno = SOCK_ERRNO;
                if (result_errno == EPIPE ||
                    result_errno == ECONNRESET)
                    libpq_append_conn_error(conn, "server closed the connection unexpectedly\n"
                                            "\tThis probably means the server terminated abnormally\n"
                                            "\tbefore or while processing the request.");
                else
                    libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
                                            SOCK_STRERROR(result_errno,
                                                          sebuf, sizeof(sebuf)));
            }
            else
            {
                libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            {
                char       *errm = SSLerrmessage(ecode);
 
                libpq_append_conn_error(conn, "SSL error: %s", errm);
                SSLerrfree(errm);
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
                break;
            }
        case SSL_ERROR_ZERO_RETURN:
 
            /*
             * Per OpenSSL documentation, this error code is only returned for
             * a clean connection closure, so we should not report it as a
             * server crash.
             */
            libpq_append_conn_error(conn, "SSL connection has been closed unexpectedly");
            result_errno = ECONNRESET;
            n = -1;
            break;
        default:
            libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
            /* assume the connection is broken */
            result_errno = ECONNRESET;
            n = -1;
            break;
    }
 
    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);
 
    return n;
}

References appendPQExpBufferStr(), conn, ECONNRESET, err(), pg_conn::errorMessage, len, libpq_append_conn_error(), PG_STRERROR_R_BUFLEN, SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, SSLerrfree(), and SSLerrmessage().

Referenced by pqsecure_read().

pgtls_read_pending()

bool pgtls_read_pending

(

PGconn *

conn

)

Definition at line 233 of file fe-secure-openssl.c.

{
    return SSL_pending(conn->ssl) > 0;
}

References conn.

Referenced by pqSocketCheck().

pgtls_verify_peer_name_matches_certificate_guts()

int pgtls_verify_peer_name_matches_certificate_guts	(	PGconn *	conn,
		int *	names_examined,
		char **	first_name
	)

Definition at line 543 of file fe-secure-openssl.c.

{
    STACK_OF(GENERAL_NAME) * peer_san;
    int         i;
    int         rc = 0;
    char       *host = conn->connhost[conn->whichhost].host;
    int         host_type;
    bool        check_cn = true;
 
    Assert(host && host[0]);    /* should be guaranteed by caller */
 
    /*
     * We try to match the NSS behavior here, which is a slight departure from
     * the spec but seems to make more intuitive sense:
     *
     * If connhost contains a DNS name, and the certificate's SANs contain any
     * dNSName entries, then we'll ignore the Subject Common Name entirely;
     * otherwise, we fall back to checking the CN. (This behavior matches the
     * RFC.)
     *
     * If connhost contains an IP address, and the SANs contain iPAddress
     * entries, we again ignore the CN. Otherwise, we allow the CN to match,
     * EVEN IF there is a dNSName in the SANs. (RFC 6125 prohibits this: "A
     * client MUST NOT seek a match for a reference identifier of CN-ID if the
     * presented identifiers include a DNS-ID, SRV-ID, URI-ID, or any
     * application-specific identifier types supported by the client.")
     *
     * NOTE: Prior versions of libpq did not consider iPAddress entries at
     * all, so this new behavior might break a certificate that has different
     * IP addresses in the Subject CN and the SANs.
     */
    if (is_ip_address(host))
        host_type = GEN_IPADD;
    else
        host_type = GEN_DNS;
 
    /*
     * First, get the Subject Alternative Names (SANs) from the certificate,
     * and compare them against the originally given hostname.
     */
    peer_san = (STACK_OF(GENERAL_NAME) *)
        X509_get_ext_d2i(conn->peer, NID_subject_alt_name, NULL, NULL);
 
    if (peer_san)
    {
        int         san_len = sk_GENERAL_NAME_num(peer_san);
 
        for (i = 0; i < san_len; i++)
        {
            const GENERAL_NAME *name = sk_GENERAL_NAME_value(peer_san, i);
            char       *alt_name = NULL;
 
            if (name->type == host_type)
            {
                /*
                 * This SAN is of the same type (IP or DNS) as our host name,
                 * so don't allow a fallback check of the CN.
                 */
                check_cn = false;
            }
 
            if (name->type == GEN_DNS)
            {
                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_name(conn,
                                                                       name->d.dNSName,
                                                                       &alt_name);
            }
            else if (name->type == GEN_IPADD)
            {
                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_ip(conn,
                                                                     name->d.iPAddress,
                                                                     &alt_name);
            }
 
            if (alt_name)
            {
                if (!*first_name)
                    *first_name = alt_name;
                else
                    free(alt_name);
            }
 
            if (rc != 0)
            {
                /*
                 * Either we hit an error or a match, and either way we should
                 * not fall back to the CN.
                 */
                check_cn = false;
                break;
            }
        }
        sk_GENERAL_NAME_pop_free(peer_san, GENERAL_NAME_free);
    }
 
    /*
     * If there is no subjectAltName extension of the matching type, check the
     * Common Name.
     *
     * (Per RFC 2818 and RFC 6125, if the subjectAltName extension of type
     * dNSName is present, the CN must be ignored. We break this rule if host
     * is an IP address; see the comment above.)
     */
    if (check_cn)
    {
        X509_NAME  *subject_name;
 
        subject_name = X509_get_subject_name(conn->peer);
        if (subject_name != NULL)
        {
            int         cn_index;
 
            cn_index = X509_NAME_get_index_by_NID(subject_name,
                                                  NID_commonName, -1);
            if (cn_index >= 0)
            {
                char       *common_name = NULL;
 
                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_name(conn,
                                                                       X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subject_name, cn_index)),
                                                                       &common_name);
 
                if (common_name)
                {
                    if (!*first_name)
                        *first_name = common_name;
                    else
                        free(common_name);
                }
            }
        }
    }
 
    return rc;
}

References Assert, conn, pg_conn::connhost, free, pg_conn_host::host, i, is_ip_address(), name, openssl_verify_peer_name_matches_certificate_ip(), openssl_verify_peer_name_matches_certificate_name(), and pg_conn::whichhost.

Referenced by pq_verify_peer_name_matches_certificate().

pgtls_write()

ssize_t pgtls_write	(	PGconn *	conn,
		const void *	ptr,
		size_t	len
	)

Definition at line 239 of file fe-secure-openssl.c.

{
    ssize_t     n;
    int         result_errno = 0;
    char        sebuf[PG_STRERROR_R_BUFLEN];
    int         err;
    unsigned long ecode;
 
    SOCK_ERRNO_SET(0);
    ERR_clear_error();
    n = SSL_write(conn->ssl, ptr, len);
    err = SSL_get_error(conn->ssl, n);
    ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
    switch (err)
    {
        case SSL_ERROR_NONE:
            if (n < 0)
            {
                /* Not supposed to happen, so we don't translate the msg */
                appendPQExpBufferStr(&conn->errorMessage,
                                     "SSL_write failed but did not provide error information\n");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
            }
            break;
        case SSL_ERROR_WANT_READ:
 
            /*
             * Returning 0 here causes caller to wait for write-ready, which
             * is not really the right thing, but it's the best we can do.
             */
            n = 0;
            break;
        case SSL_ERROR_WANT_WRITE:
            n = 0;
            break;
        case SSL_ERROR_SYSCALL:
 
            /*
             * If errno is still zero then assume it's a read EOF situation,
             * and report EOF.  (This seems possible because SSL_write can
             * also do reads.)
             */
            if (n < 0 && SOCK_ERRNO != 0)
            {
                result_errno = SOCK_ERRNO;
                if (result_errno == EPIPE || result_errno == ECONNRESET)
                    libpq_append_conn_error(conn, "server closed the connection unexpectedly\n"
                                            "\tThis probably means the server terminated abnormally\n"
                                            "\tbefore or while processing the request.");
                else
                    libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
                                            SOCK_STRERROR(result_errno,
                                                          sebuf, sizeof(sebuf)));
            }
            else
            {
                libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            {
                char       *errm = SSLerrmessage(ecode);
 
                libpq_append_conn_error(conn, "SSL error: %s", errm);
                SSLerrfree(errm);
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
                break;
            }
        case SSL_ERROR_ZERO_RETURN:
 
            /*
             * Per OpenSSL documentation, this error code is only returned for
             * a clean connection closure, so we should not report it as a
             * server crash.
             */
            libpq_append_conn_error(conn, "SSL connection has been closed unexpectedly");
            result_errno = ECONNRESET;
            n = -1;
            break;
        default:
            libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
            /* assume the connection is broken */
            result_errno = ECONNRESET;
            n = -1;
            break;
    }
 
    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);
 
    return n;
}

References appendPQExpBufferStr(), conn, ECONNRESET, err(), pg_conn::errorMessage, len, libpq_append_conn_error(), PG_STRERROR_R_BUFLEN, SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, SSLerrfree(), and SSLerrmessage().

Referenced by pqsecure_write().

pq_block_sigpipe()

int pq_block_sigpipe	(	sigset_t *	osigset,
		bool *	sigpipe_pending
	)

Definition at line 504 of file fe-secure.c.

{
    sigset_t    sigpipe_sigset;
    sigset_t    sigset;
 
    sigemptyset(&sigpipe_sigset);
    sigaddset(&sigpipe_sigset, SIGPIPE);
 
    /* Block SIGPIPE and save previous mask for later reset */
    SOCK_ERRNO_SET(pthread_sigmask(SIG_BLOCK, &sigpipe_sigset, osigset));
    if (SOCK_ERRNO)
        return -1;
 
    /* We can have a pending SIGPIPE only if it was blocked before */
    if (sigismember(osigset, SIGPIPE))
    {
        /* Is there a pending SIGPIPE? */
        if (sigpending(&sigset) != 0)
            return -1;
 
        if (sigismember(&sigset, SIGPIPE))
            *sigpipe_pending = true;
        else
            *sigpipe_pending = false;
    }
    else
        *sigpipe_pending = false;
 
    return 0;
}

References SIGPIPE, SOCK_ERRNO, and SOCK_ERRNO_SET.

Referenced by PQprint().

pq_reset_sigpipe()

void pq_reset_sigpipe	(	sigset_t *	osigset,
		bool	sigpipe_pending,
		bool	got_epipe
	)

Definition at line 554 of file fe-secure.c.

{
    int         save_errno = SOCK_ERRNO;
    int         signo;
    sigset_t    sigset;
 
    /* Clear SIGPIPE only if none was pending */
    if (got_epipe && !sigpipe_pending)
    {
        if (sigpending(&sigset) == 0 &&
            sigismember(&sigset, SIGPIPE))
        {
            sigset_t    sigpipe_sigset;
 
            sigemptyset(&sigpipe_sigset);
            sigaddset(&sigpipe_sigset, SIGPIPE);
 
            sigwait(&sigpipe_sigset, &signo);
        }
    }
 
    /* Restore saved block mask */
    pthread_sigmask(SIG_SETMASK, osigset, NULL);
 
    SOCK_ERRNO_SET(save_errno);
}

References SIGPIPE, SOCK_ERRNO, and SOCK_ERRNO_SET.

Referenced by PQprint().

pqBuildErrorMessage3()

void pqBuildErrorMessage3	(	PQExpBuffer	msg,
		const PGresult *	res,
		PGVerbosity	verbosity,
		PGContextVisibility	show_context
	)

Definition at line 1010 of file fe-protocol3.c.

{
    const char *val;
    const char *querytext = NULL;
    int         querypos = 0;
 
    /* If we couldn't allocate a PGresult, just say "out of memory" */
    if (res == NULL)
    {
        appendPQExpBufferStr(msg, libpq_gettext("out of memory\n"));
        return;
    }
 
    /*
     * If we don't have any broken-down fields, just return the base message.
     * This mainly applies if we're given a libpq-generated error result.
     */
    if (res->errFields == NULL)
    {
        if (res->errMsg && res->errMsg[0])
            appendPQExpBufferStr(msg, res->errMsg);
        else
            appendPQExpBufferStr(msg, libpq_gettext("no error message available\n"));
        return;
    }
 
    /* Else build error message from relevant fields */
    val = PQresultErrorField(res, PG_DIAG_SEVERITY);
    if (val)
        appendPQExpBuffer(msg, "%s:  ", val);
 
    if (verbosity == PQERRORS_SQLSTATE)
    {
        /*
         * If we have a SQLSTATE, print that and nothing else.  If not (which
         * shouldn't happen for server-generated errors, but might possibly
         * happen for libpq-generated ones), fall back to TERSE format, as
         * that seems better than printing nothing at all.
         */
        val = PQresultErrorField(res, PG_DIAG_SQLSTATE);
        if (val)
        {
            appendPQExpBuffer(msg, "%s\n", val);
            return;
        }
        verbosity = PQERRORS_TERSE;
    }
 
    if (verbosity == PQERRORS_VERBOSE)
    {
        val = PQresultErrorField(res, PG_DIAG_SQLSTATE);
        if (val)
            appendPQExpBuffer(msg, "%s: ", val);
    }
    val = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
    if (val)
        appendPQExpBufferStr(msg, val);
    val = PQresultErrorField(res, PG_DIAG_STATEMENT_POSITION);
    if (val)
    {
        if (verbosity != PQERRORS_TERSE && res->errQuery != NULL)
        {
            /* emit position as a syntax cursor display */
            querytext = res->errQuery;
            querypos = atoi(val);
        }
        else
        {
            /* emit position as text addition to primary message */
            /* translator: %s represents a digit string */
            appendPQExpBuffer(msg, libpq_gettext(" at character %s"),
                              val);
        }
    }
    else
    {
        val = PQresultErrorField(res, PG_DIAG_INTERNAL_POSITION);
        if (val)
        {
            querytext = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
            if (verbosity != PQERRORS_TERSE && querytext != NULL)
            {
                /* emit position as a syntax cursor display */
                querypos = atoi(val);
            }
            else
            {
                /* emit position as text addition to primary message */
                /* translator: %s represents a digit string */
                appendPQExpBuffer(msg, libpq_gettext(" at character %s"),
                                  val);
            }
        }
    }
    appendPQExpBufferChar(msg, '\n');
    if (verbosity != PQERRORS_TERSE)
    {
        if (querytext && querypos > 0)
            reportErrorPosition(msg, querytext, querypos,
                                res->client_encoding);
        val = PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL);
        if (val)
            appendPQExpBuffer(msg, libpq_gettext("DETAIL:  %s\n"), val);
        val = PQresultErrorField(res, PG_DIAG_MESSAGE_HINT);
        if (val)
            appendPQExpBuffer(msg, libpq_gettext("HINT:  %s\n"), val);
        val = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
        if (val)
            appendPQExpBuffer(msg, libpq_gettext("QUERY:  %s\n"), val);
        if (show_context == PQSHOW_CONTEXT_ALWAYS ||
            (show_context == PQSHOW_CONTEXT_ERRORS &&
             res->resultStatus == PGRES_FATAL_ERROR))
        {
            val = PQresultErrorField(res, PG_DIAG_CONTEXT);
            if (val)
                appendPQExpBuffer(msg, libpq_gettext("CONTEXT:  %s\n"),
                                  val);
        }
    }
    if (verbosity == PQERRORS_VERBOSE)
    {
        val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
        if (val)
            appendPQExpBuffer(msg,
                              libpq_gettext("SCHEMA NAME:  %s\n"), val);
        val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
        if (val)
            appendPQExpBuffer(msg,
                              libpq_gettext("TABLE NAME:  %s\n"), val);
        val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
        if (val)
            appendPQExpBuffer(msg,
                              libpq_gettext("COLUMN NAME:  %s\n"), val);
        val = PQresultErrorField(res, PG_DIAG_DATATYPE_NAME);
        if (val)
            appendPQExpBuffer(msg,
                              libpq_gettext("DATATYPE NAME:  %s\n"), val);
        val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
        if (val)
            appendPQExpBuffer(msg,
                              libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
    }
    if (verbosity == PQERRORS_VERBOSE)
    {
        const char *valf;
        const char *vall;
 
        valf = PQresultErrorField(res, PG_DIAG_SOURCE_FILE);
        vall = PQresultErrorField(res, PG_DIAG_SOURCE_LINE);
        val = PQresultErrorField(res, PG_DIAG_SOURCE_FUNCTION);
        if (val || valf || vall)
        {
            appendPQExpBufferStr(msg, libpq_gettext("LOCATION:  "));
            if (val)
                appendPQExpBuffer(msg, libpq_gettext("%s, "), val);
            if (valf && vall)   /* unlikely we'd have just one */
                appendPQExpBuffer(msg, libpq_gettext("%s:%s"),
                                  valf, vall);
            appendPQExpBufferChar(msg, '\n');
        }
    }
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), pg_result::client_encoding, pg_result::errFields, pg_result::errMsg, pg_result::errQuery, libpq_gettext, PG_DIAG_COLUMN_NAME, PG_DIAG_CONSTRAINT_NAME, PG_DIAG_CONTEXT, PG_DIAG_DATATYPE_NAME, PG_DIAG_INTERNAL_POSITION, PG_DIAG_INTERNAL_QUERY, PG_DIAG_MESSAGE_DETAIL, PG_DIAG_MESSAGE_HINT, PG_DIAG_MESSAGE_PRIMARY, PG_DIAG_SCHEMA_NAME, PG_DIAG_SEVERITY, PG_DIAG_SOURCE_FILE, PG_DIAG_SOURCE_FUNCTION, PG_DIAG_SOURCE_LINE, PG_DIAG_SQLSTATE, PG_DIAG_STATEMENT_POSITION, PG_DIAG_TABLE_NAME, PGRES_FATAL_ERROR, PQERRORS_SQLSTATE, PQERRORS_TERSE, PQERRORS_VERBOSE, PQresultErrorField(), PQSHOW_CONTEXT_ALWAYS, PQSHOW_CONTEXT_ERRORS, reportErrorPosition(), res, pg_result::resultStatus, and val.

Referenced by pqGetErrorNotice3(), and PQresultVerboseErrorMessage().

pqBuildStartupPacket3()

char* pqBuildStartupPacket3	(	PGconn *	conn,
		int *	packetlen,
		const PQEnvironmentOption *	options
	)

Definition at line 2231 of file fe-protocol3.c.

{
    char       *startpacket;
 
    *packetlen = build_startup_packet(conn, NULL, options);
    startpacket = (char *) malloc(*packetlen);
    if (!startpacket)
        return NULL;
    *packetlen = build_startup_packet(conn, startpacket, options);
    return startpacket;
}

References build_startup_packet(), conn, and malloc.

Referenced by PQconnectPoll().

pqCheckInBufferSpace()

int pqCheckInBufferSpace	(	size_t	bytes_needed,
		PGconn *	conn
	)

Definition at line 351 of file fe-misc.c.

{
    int         newsize = conn->inBufSize;
    char       *newbuf;
 
    /* Quick exit if we have enough space */
    if (bytes_needed <= (size_t) newsize)
        return 0;
 
    /*
     * Before concluding that we need to enlarge the buffer, left-justify
     * whatever is in it and recheck.  The caller's value of bytes_needed
     * includes any data to the left of inStart, but we can delete that in
     * preference to enlarging the buffer.  It's slightly ugly to have this
     * function do this, but it's better than making callers worry about it.
     */
    bytes_needed -= conn->inStart;
 
    if (conn->inStart < conn->inEnd)
    {
        if (conn->inStart > 0)
        {
            memmove(conn->inBuffer, conn->inBuffer + conn->inStart,
                    conn->inEnd - conn->inStart);
            conn->inEnd -= conn->inStart;
            conn->inCursor -= conn->inStart;
            conn->inStart = 0;
        }
    }
    else
    {
        /* buffer is logically empty, reset it */
        conn->inStart = conn->inCursor = conn->inEnd = 0;
    }
 
    /* Recheck whether we have enough space */
    if (bytes_needed <= (size_t) newsize)
        return 0;
 
    /*
     * If we need to enlarge the buffer, we first try to double it in size; if
     * that doesn't work, enlarge in multiples of 8K.  This avoids thrashing
     * the malloc pool by repeated small enlargements.
     *
     * Note: tests for newsize > 0 are to catch integer overflow.
     */
    do
    {
        newsize *= 2;
    } while (newsize > 0 && bytes_needed > (size_t) newsize);
 
    if (newsize > 0 && bytes_needed <= (size_t) newsize)
    {
        newbuf = realloc(conn->inBuffer, newsize);
        if (newbuf)
        {
            /* realloc succeeded */
            conn->inBuffer = newbuf;
            conn->inBufSize = newsize;
            return 0;
        }
    }
 
    newsize = conn->inBufSize;
    do
    {
        newsize += 8192;
    } while (newsize > 0 && bytes_needed > (size_t) newsize);
 
    if (newsize > 0 && bytes_needed <= (size_t) newsize)
    {
        newbuf = realloc(conn->inBuffer, newsize);
        if (newbuf)
        {
            /* realloc succeeded */
            conn->inBuffer = newbuf;
            conn->inBufSize = newsize;
            return 0;
        }
    }
 
    /* realloc failed. Probably out of memory */
    appendPQExpBufferStr(&conn->errorMessage,
                         "cannot allocate memory for input buffer\n");
    return EOF;
}

References appendPQExpBufferStr(), conn, pg_conn::errorMessage, pg_conn::inBuffer, pg_conn::inBufSize, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, and realloc.

Referenced by getCopyDataMessage(), PQconnectPoll(), pqFunctionCall3(), pqParseInput3(), and pqReadData().

pqCheckOutBufferSpace()

int pqCheckOutBufferSpace	(	size_t	bytes_needed,
		PGconn *	conn
	)

Definition at line 287 of file fe-misc.c.

{
    int         newsize = conn->outBufSize;
    char       *newbuf;
 
    /* Quick exit if we have enough space */
    if (bytes_needed <= (size_t) newsize)
        return 0;
 
    /*
     * If we need to enlarge the buffer, we first try to double it in size; if
     * that doesn't work, enlarge in multiples of 8K.  This avoids thrashing
     * the malloc pool by repeated small enlargements.
     *
     * Note: tests for newsize > 0 are to catch integer overflow.
     */
    do
    {
        newsize *= 2;
    } while (newsize > 0 && bytes_needed > (size_t) newsize);
 
    if (newsize > 0 && bytes_needed <= (size_t) newsize)
    {
        newbuf = realloc(conn->outBuffer, newsize);
        if (newbuf)
        {
            /* realloc succeeded */
            conn->outBuffer = newbuf;
            conn->outBufSize = newsize;
            return 0;
        }
    }
 
    newsize = conn->outBufSize;
    do
    {
        newsize += 8192;
    } while (newsize > 0 && bytes_needed > (size_t) newsize);
 
    if (newsize > 0 && bytes_needed <= (size_t) newsize)
    {
        newbuf = realloc(conn->outBuffer, newsize);
        if (newbuf)
        {
            /* realloc succeeded */
            conn->outBuffer = newbuf;
            conn->outBufSize = newsize;
            return 0;
        }
    }
 
    /* realloc failed. Probably out of memory */
    appendPQExpBufferStr(&conn->errorMessage,
                         "cannot allocate memory for output buffer\n");
    return EOF;
}

References appendPQExpBufferStr(), conn, pg_conn::errorMessage, pg_conn::outBuffer, pg_conn::outBufSize, and realloc.

Referenced by PQputCopyData(), pqPutMsgBytes(), and pqPutMsgStart().

pqClearAsyncResult()

void pqClearAsyncResult

(

PGconn *

conn

)

Definition at line 779 of file fe-exec.c.

{
    PQclear(conn->result);
    conn->result = NULL;
    conn->error_result = false;
    PQclear(conn->saved_result);
    conn->saved_result = NULL;
}

References conn, pg_conn::error_result, PQclear(), pg_conn::result, and pg_conn::saved_result.

Referenced by getAnotherTuple(), getParamDescriptions(), getRowDescriptions(), pqClosePGconn(), PQconnectPoll(), pqGetErrorNotice3(), pqPipelineProcessQueue(), pqSaveErrorResult(), and PQsendQueryStart().

pqClosePGconn()

void pqClosePGconn

(

PGconn *

conn

)

Definition at line 4847 of file fe-connect.c.

{
    /*
     * If possible, send Terminate message to close the connection politely.
     */
    sendTerminateConn(conn);
 
    /*
     * Must reset the blocking status so a possible reconnect will work.
     *
     * Don't call PQsetnonblocking() because it will fail if it's unable to
     * flush the connection.
     */
    conn->nonblocking = false;
 
    /*
     * Close the connection, reset all transient state, flush I/O buffers.
     * Note that this includes clearing conn's error state; we're no longer
     * interested in any failures associated with the old connection, and we
     * want a clean slate for any new connection attempt.
     */
    pqDropConnection(conn, true);
    conn->status = CONNECTION_BAD;  /* Well, not really _bad_ - just absent */
    conn->asyncStatus = PGASYNC_IDLE;
    conn->xactStatus = PQTRANS_IDLE;
    conn->pipelineStatus = PQ_PIPELINE_OFF;
    pqClearAsyncResult(conn);   /* deallocate result */
    pqClearConnErrorState(conn);
 
    /*
     * Release addrinfo, but since cancel requests never change their addrinfo
     * we don't do that. Otherwise we would have to rebuild it during a
     * PQcancelReset.
     */
    if (!conn->cancelRequest)
        release_conn_addrinfo(conn);
 
    /* Reset all state obtained from server, too */
    pqDropServerData(conn);
}

References pg_conn::asyncStatus, pg_conn::cancelRequest, conn, CONNECTION_BAD, pg_conn::nonblocking, PGASYNC_IDLE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqClearAsyncResult(), pqClearConnErrorState, pqDropConnection(), pqDropServerData(), PQTRANS_IDLE, release_conn_addrinfo(), sendTerminateConn(), pg_conn::status, and pg_conn::xactStatus.

Referenced by PQcancelReset(), PQfinish(), PQreset(), and PQresetStart().

pqCommandQueueAdvance()

void pqCommandQueueAdvance	(	PGconn *	conn,
		bool	isReadyForQuery,
		bool	gotSync
	)

Definition at line 3142 of file fe-exec.c.

{
    PGcmdQueueEntry *prevquery;
 
    if (conn->cmd_queue_head == NULL)
        return;
 
    /*
     * If processing a query of simple query protocol, we only advance the
     * queue when we receive the ReadyForQuery message for it.
     */
    if (conn->cmd_queue_head->queryclass == PGQUERY_SIMPLE && !isReadyForQuery)
        return;
 
    /*
     * If we're waiting for a SYNC, don't advance the queue until we get one.
     */
    if (conn->cmd_queue_head->queryclass == PGQUERY_SYNC && !gotSync)
        return;
 
    /* delink element from queue */
    prevquery = conn->cmd_queue_head;
    conn->cmd_queue_head = conn->cmd_queue_head->next;
 
    /* If the queue is now empty, reset the tail too */
    if (conn->cmd_queue_head == NULL)
        conn->cmd_queue_tail = NULL;
 
    /* and make the queue element recyclable */
    prevquery->next = NULL;
    pqRecycleCmdQueueEntry(conn, prevquery);
}

References pg_conn::cmd_queue_head, pg_conn::cmd_queue_tail, conn, PGcmdQueueEntry::next, PGQUERY_SIMPLE, PGQUERY_SYNC, pqRecycleCmdQueueEntry(), and PGcmdQueueEntry::queryclass.

Referenced by PQgetResult(), and pqParseInput3().

pqConnectDBComplete()

int pqConnectDBComplete

(

PGconn *

conn

)

Definition at line 2471 of file fe-connect.c.

{
    PostgresPollingStatusType flag = PGRES_POLLING_WRITING;
    pg_usec_time_t end_time = -1;
    int         timeout = 0;
    int         last_whichhost = -2;    /* certainly different from whichhost */
    int         last_whichaddr = -2;    /* certainly different from whichaddr */
 
    if (conn == NULL || conn->status == CONNECTION_BAD)
        return 0;
 
    /*
     * Set up a time limit, if connect_timeout is greater than zero.
     */
    if (conn->connect_timeout != NULL)
    {
        if (!pqParseIntParam(conn->connect_timeout, &timeout, conn,
                             "connect_timeout"))
        {
            /* mark the connection as bad to report the parsing failure */
            conn->status = CONNECTION_BAD;
            return 0;
        }
    }
 
    for (;;)
    {
        int         ret = 0;
 
        /*
         * (Re)start the connect_timeout timer if it's active and we are
         * considering a different host than we were last time through.  If
         * we've already succeeded, though, needn't recalculate.
         */
        if (flag != PGRES_POLLING_OK &&
            timeout > 0 &&
            (conn->whichhost != last_whichhost ||
             conn->whichaddr != last_whichaddr))
        {
            end_time = PQgetCurrentTimeUSec() + (pg_usec_time_t) timeout * 1000000;
            last_whichhost = conn->whichhost;
            last_whichaddr = conn->whichaddr;
        }
 
        /*
         * Wait, if necessary.  Note that the initial state (just after
         * PQconnectStart) is to wait for the socket to select for writing.
         */
        switch (flag)
        {
            case PGRES_POLLING_OK:
                return 1;       /* success! */
 
            case PGRES_POLLING_READING:
                ret = pqWaitTimed(1, 0, conn, end_time);
                if (ret == -1)
                {
                    /* hard failure, eg select() problem, aborts everything */
                    conn->status = CONNECTION_BAD;
                    return 0;
                }
                break;
 
            case PGRES_POLLING_WRITING:
                ret = pqWaitTimed(0, 1, conn, end_time);
                if (ret == -1)
                {
                    /* hard failure, eg select() problem, aborts everything */
                    conn->status = CONNECTION_BAD;
                    return 0;
                }
                break;
 
            default:
                /* Just in case we failed to set it in PQconnectPoll */
                conn->status = CONNECTION_BAD;
                return 0;
        }
 
        if (ret == 1)           /* connect_timeout elapsed */
        {
            /*
             * Give up on current server/address, try the next one.
             */
            conn->try_next_addr = true;
            conn->status = CONNECTION_NEEDED;
        }
 
        /*
         * Now try to advance the state machine.
         */
        if (conn->cancelRequest)
            flag = PQcancelPoll((PGcancelConn *) conn);
        else
            flag = PQconnectPoll(conn);
    }
}

References pg_conn::cancelRequest, conn, pg_conn::connect_timeout, CONNECTION_BAD, CONNECTION_NEEDED, end_time, flag(), PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PQcancelPoll(), PQconnectPoll(), PQgetCurrentTimeUSec(), pqParseIntParam(), pqWaitTimed(), pg_conn::status, pg_conn::try_next_addr, pg_conn::whichaddr, and pg_conn::whichhost.

Referenced by internal_ping(), PQcancelBlocking(), PQconnectdb(), PQconnectdbParams(), PQreset(), and PQsetdbLogin().

pqConnectDBStart()

int pqConnectDBStart

(

PGconn *

conn

)

Definition at line 2393 of file fe-connect.c.

{
    if (!conn)
        return 0;
 
    if (!conn->options_valid)
        goto connect_errReturn;
 
    /*
     * Check for bad linking to backend-internal versions of src/common
     * functions (see comments in link-canary.c for the reason we need this).
     * Nobody but developers should see this message, so we don't bother
     * translating it.
     */
    if (!pg_link_canary_is_frontend())
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             "libpq is incorrectly linked to backend functions\n");
        goto connect_errReturn;
    }
 
    /* Ensure our buffers are empty */
    conn->inStart = conn->inCursor = conn->inEnd = 0;
    conn->outCount = 0;
 
    /*
     * Set up to try to connect to the first host.  (Setting whichhost = -1 is
     * a bit of a cheat, but PQconnectPoll will advance it to 0 before
     * anything else looks at it.)
     *
     * Cancel requests are special though, they should only try one host and
     * address, and these fields have already been set up in PQcancelCreate,
     * so leave these fields alone for cancel requests.
     */
    if (!conn->cancelRequest)
    {
        conn->whichhost = -1;
        conn->try_next_host = true;
        conn->try_next_addr = false;
    }
 
    conn->status = CONNECTION_NEEDED;
 
    /* Also reset the target_server_type state if needed */
    if (conn->target_server_type == SERVER_TYPE_PREFER_STANDBY_PASS2)
        conn->target_server_type = SERVER_TYPE_PREFER_STANDBY;
 
    /*
     * The code for processing CONNECTION_NEEDED state is in PQconnectPoll(),
     * so that it can easily be re-executed if needed again during the
     * asynchronous startup process.  However, we must run it once here,
     * because callers expect a success return from this routine to mean that
     * we are in PGRES_POLLING_WRITING connection state.
     */
    if (PQconnectPoll(conn) == PGRES_POLLING_WRITING)
        return 1;
 
connect_errReturn:
 
    /*
     * If we managed to open a socket, close it immediately rather than
     * waiting till PQfinish.  (The application cannot have gotten the socket
     * from PQsocket yet, so this doesn't risk breaking anything.)
     */
    pqDropConnection(conn, true);
    conn->status = CONNECTION_BAD;
    return 0;
}

References appendPQExpBufferStr(), pg_conn::cancelRequest, conn, CONNECTION_BAD, CONNECTION_NEEDED, pg_conn::errorMessage, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, pg_conn::options_valid, pg_conn::outCount, pg_link_canary_is_frontend(), PGRES_POLLING_WRITING, PQconnectPoll(), pqDropConnection(), SERVER_TYPE_PREFER_STANDBY, SERVER_TYPE_PREFER_STANDBY_PASS2, pg_conn::status, pg_conn::target_server_type, pg_conn::try_next_addr, pg_conn::try_next_host, and pg_conn::whichhost.

Referenced by PQcancelStart(), PQconnectStart(), PQconnectStartParams(), PQreset(), PQresetStart(), and PQsetdbLogin().

pqConnectOptions2()

bool pqConnectOptions2

(

PGconn *

conn

)

Definition at line 1121 of file fe-connect.c.

{
    int         i;
 
    /*
     * Allocate memory for details about each host to which we might possibly
     * try to connect.  For that, count the number of elements in the hostaddr
     * or host options.  If neither is given, assume one host.
     */
    conn->whichhost = 0;
    if (conn->pghostaddr && conn->pghostaddr[0] != '\0')
        conn->nconnhost = count_comma_separated_elems(conn->pghostaddr);
    else if (conn->pghost && conn->pghost[0] != '\0')
        conn->nconnhost = count_comma_separated_elems(conn->pghost);
    else
        conn->nconnhost = 1;
    conn->connhost = (pg_conn_host *)
        calloc(conn->nconnhost, sizeof(pg_conn_host));
    if (conn->connhost == NULL)
        goto oom_error;
 
    /*
     * We now have one pg_conn_host structure per possible host.  Fill in the
     * host and hostaddr fields for each, by splitting the parameter strings.
     */
    if (conn->pghostaddr != NULL && conn->pghostaddr[0] != '\0')
    {
        char       *s = conn->pghostaddr;
        bool        more = true;
 
        for (i = 0; i < conn->nconnhost && more; i++)
        {
            conn->connhost[i].hostaddr = parse_comma_separated_list(&s, &more);
            if (conn->connhost[i].hostaddr == NULL)
                goto oom_error;
        }
 
        /*
         * If hostaddr was given, the array was allocated according to the
         * number of elements in the hostaddr list, so it really should be the
         * right size.
         */
        Assert(!more);
        Assert(i == conn->nconnhost);
    }
 
    if (conn->pghost != NULL && conn->pghost[0] != '\0')
    {
        char       *s = conn->pghost;
        bool        more = true;
 
        for (i = 0; i < conn->nconnhost && more; i++)
        {
            conn->connhost[i].host = parse_comma_separated_list(&s, &more);
            if (conn->connhost[i].host == NULL)
                goto oom_error;
        }
 
        /* Check for wrong number of host items. */
        if (more || i != conn->nconnhost)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "could not match %d host names to %d hostaddr values",
                                    count_comma_separated_elems(conn->pghost), conn->nconnhost);
            return false;
        }
    }
 
    /*
     * Now, for each host slot, identify the type of address spec, and fill in
     * the default address if nothing was given.
     */
    for (i = 0; i < conn->nconnhost; i++)
    {
        pg_conn_host *ch = &conn->connhost[i];
 
        if (ch->hostaddr != NULL && ch->hostaddr[0] != '\0')
            ch->type = CHT_HOST_ADDRESS;
        else if (ch->host != NULL && ch->host[0] != '\0')
        {
            ch->type = CHT_HOST_NAME;
            if (is_unixsock_path(ch->host))
                ch->type = CHT_UNIX_SOCKET;
        }
        else
        {
            free(ch->host);
 
            /*
             * This bit selects the default host location.  If you change
             * this, see also pg_regress.
             */
            if (DEFAULT_PGSOCKET_DIR[0])
            {
                ch->host = strdup(DEFAULT_PGSOCKET_DIR);
                ch->type = CHT_UNIX_SOCKET;
            }
            else
            {
                ch->host = strdup(DefaultHost);
                ch->type = CHT_HOST_NAME;
            }
            if (ch->host == NULL)
                goto oom_error;
        }
    }
 
    /*
     * Next, work out the port number corresponding to each host name.
     *
     * Note: unlike the above for host names, this could leave the port fields
     * as null or empty strings.  We will substitute DEF_PGPORT whenever we
     * read such a port field.
     */
    if (conn->pgport != NULL && conn->pgport[0] != '\0')
    {
        char       *s = conn->pgport;
        bool        more = true;
 
        for (i = 0; i < conn->nconnhost && more; i++)
        {
            conn->connhost[i].port = parse_comma_separated_list(&s, &more);
            if (conn->connhost[i].port == NULL)
                goto oom_error;
        }
 
        /*
         * If exactly one port was given, use it for every host.  Otherwise,
         * there must be exactly as many ports as there were hosts.
         */
        if (i == 1 && !more)
        {
            for (i = 1; i < conn->nconnhost; i++)
            {
                conn->connhost[i].port = strdup(conn->connhost[0].port);
                if (conn->connhost[i].port == NULL)
                    goto oom_error;
            }
        }
        else if (more || i != conn->nconnhost)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "could not match %d port numbers to %d hosts",
                                    count_comma_separated_elems(conn->pgport), conn->nconnhost);
            return false;
        }
    }
 
    /*
     * If user name was not given, fetch it.  (Most likely, the fetch will
     * fail, since the only way we get here is if pg_fe_getauthname() failed
     * during conninfo_add_defaults().  But now we want an error message.)
     */
    if (conn->pguser == NULL || conn->pguser[0] == '\0')
    {
        free(conn->pguser);
        conn->pguser = pg_fe_getauthname(&conn->errorMessage);
        if (!conn->pguser)
        {
            conn->status = CONNECTION_BAD;
            return false;
        }
    }
 
    /*
     * If database name was not given, default it to equal user name
     */
    if (conn->dbName == NULL || conn->dbName[0] == '\0')
    {
        free(conn->dbName);
        conn->dbName = strdup(conn->pguser);
        if (!conn->dbName)
            goto oom_error;
    }
 
    /*
     * If password was not given, try to look it up in password file.  Note
     * that the result might be different for each host/port pair.
     */
    if (conn->pgpass == NULL || conn->pgpass[0] == '\0')
    {
        /* If password file wasn't specified, use ~/PGPASSFILE */
        if (conn->pgpassfile == NULL || conn->pgpassfile[0] == '\0')
        {
            char        homedir[MAXPGPATH];
 
            if (pqGetHomeDirectory(homedir, sizeof(homedir)))
            {
                free(conn->pgpassfile);
                conn->pgpassfile = malloc(MAXPGPATH);
                if (!conn->pgpassfile)
                    goto oom_error;
                snprintf(conn->pgpassfile, MAXPGPATH, "%s/%s",
                         homedir, PGPASSFILE);
            }
        }
 
        if (conn->pgpassfile != NULL && conn->pgpassfile[0] != '\0')
        {
            for (i = 0; i < conn->nconnhost; i++)
            {
                /*
                 * Try to get a password for this host from file.  We use host
                 * for the hostname search key if given, else hostaddr (at
                 * least one of them is guaranteed nonempty by now).
                 */
                const char *pwhost = conn->connhost[i].host;
 
                if (pwhost == NULL || pwhost[0] == '\0')
                    pwhost = conn->connhost[i].hostaddr;
 
                conn->connhost[i].password =
                    passwordFromFile(pwhost,
                                     conn->connhost[i].port,
                                     conn->dbName,
                                     conn->pguser,
                                     conn->pgpassfile);
            }
        }
    }
 
    /*
     * parse and validate require_auth option
     */
    if (conn->require_auth && conn->require_auth[0])
    {
        char       *s = conn->require_auth;
        bool        first,
                    more;
        bool        negated = false;
 
        /*
         * By default, start from an empty set of allowed options and add to
         * it.
         */
        conn->auth_required = true;
        conn->allowed_auth_methods = 0;
 
        for (first = true, more = true; more; first = false)
        {
            char       *method,
                       *part;
            uint32      bits;
 
            part = parse_comma_separated_list(&s, &more);
            if (part == NULL)
                goto oom_error;
 
            /*
             * Check for negation, e.g. '!password'. If one element is
             * negated, they all have to be.
             */
            method = part;
            if (*method == '!')
            {
                if (first)
                {
                    /*
                     * Switch to a permissive set of allowed options, and
                     * subtract from it.
                     */
                    conn->auth_required = false;
                    conn->allowed_auth_methods = -1;
                }
                else if (!negated)
                {
                    conn->status = CONNECTION_BAD;
                    libpq_append_conn_error(conn, "negative require_auth method \"%s\" cannot be mixed with non-negative methods",
                                            method);
 
                    free(part);
                    return false;
                }
 
                negated = true;
                method++;
            }
            else if (negated)
            {
                conn->status = CONNECTION_BAD;
                libpq_append_conn_error(conn, "require_auth method \"%s\" cannot be mixed with negative methods",
                                        method);
 
                free(part);
                return false;
            }
 
            if (strcmp(method, "password") == 0)
            {
                bits = (1 << AUTH_REQ_PASSWORD);
            }
            else if (strcmp(method, "md5") == 0)
            {
                bits = (1 << AUTH_REQ_MD5);
            }
            else if (strcmp(method, "gss") == 0)
            {
                bits = (1 << AUTH_REQ_GSS);
                bits |= (1 << AUTH_REQ_GSS_CONT);
            }
            else if (strcmp(method, "sspi") == 0)
            {
                bits = (1 << AUTH_REQ_SSPI);
                bits |= (1 << AUTH_REQ_GSS_CONT);
            }
            else if (strcmp(method, "scram-sha-256") == 0)
            {
                /* This currently assumes that SCRAM is the only SASL method. */
                bits = (1 << AUTH_REQ_SASL);
                bits |= (1 << AUTH_REQ_SASL_CONT);
                bits |= (1 << AUTH_REQ_SASL_FIN);
            }
            else if (strcmp(method, "none") == 0)
            {
                /*
                 * Special case: let the user explicitly allow (or disallow)
                 * connections where the server does not send an explicit
                 * authentication challenge, such as "trust" and "cert" auth.
                 */
                if (negated)    /* "!none" */
                {
                    if (conn->auth_required)
                        goto duplicate;
 
                    conn->auth_required = true;
                }
                else            /* "none" */
                {
                    if (!conn->auth_required)
                        goto duplicate;
 
                    conn->auth_required = false;
                }
 
                free(part);
                continue;       /* avoid the bitmask manipulation below */
            }
            else
            {
                conn->status = CONNECTION_BAD;
                libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                        "require_auth", method);
 
                free(part);
                return false;
            }
 
            /* Update the bitmask. */
            if (negated)
            {
                if ((conn->allowed_auth_methods & bits) == 0)
                    goto duplicate;
 
                conn->allowed_auth_methods &= ~bits;
            }
            else
            {
                if ((conn->allowed_auth_methods & bits) == bits)
                    goto duplicate;
 
                conn->allowed_auth_methods |= bits;
            }
 
            free(part);
            continue;
 
    duplicate:
 
            /*
             * A duplicated method probably indicates a typo in a setting
             * where typos are extremely risky.
             */
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "require_auth method \"%s\" is specified more than once",
                                    part);
 
            free(part);
            return false;
        }
    }
 
    /*
     * validate channel_binding option
     */
    if (conn->channel_binding)
    {
        if (strcmp(conn->channel_binding, "disable") != 0
            && strcmp(conn->channel_binding, "prefer") != 0
            && strcmp(conn->channel_binding, "require") != 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                    "channel_binding", conn->channel_binding);
            return false;
        }
    }
    else
    {
        conn->channel_binding = strdup(DefaultChannelBinding);
        if (!conn->channel_binding)
            goto oom_error;
    }
 
#ifndef USE_SSL
 
    /*
     * sslrootcert=system is not supported. Since setting this changes the
     * default sslmode, check this _before_ we validate sslmode, to avoid
     * confusing the user with errors for an option they may not have set.
     */
    if (conn->sslrootcert
        && strcmp(conn->sslrootcert, "system") == 0)
    {
        conn->status = CONNECTION_BAD;
        libpq_append_conn_error(conn, "%s value \"%s\" invalid when SSL support is not compiled in",
                                "sslrootcert", conn->sslrootcert);
        return false;
    }
#endif
 
    /*
     * validate sslmode option
     */
    if (conn->sslmode)
    {
        if (strcmp(conn->sslmode, "disable") != 0
            && strcmp(conn->sslmode, "allow") != 0
            && strcmp(conn->sslmode, "prefer") != 0
            && strcmp(conn->sslmode, "require") != 0
            && strcmp(conn->sslmode, "verify-ca") != 0
            && strcmp(conn->sslmode, "verify-full") != 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                    "sslmode", conn->sslmode);
            return false;
        }
 
#ifndef USE_SSL
        switch (conn->sslmode[0])
        {
            case 'a':           /* "allow" */
            case 'p':           /* "prefer" */
 
                /*
                 * warn user that an SSL connection will never be negotiated
                 * since SSL was not compiled in?
                 */
                break;
 
            case 'r':           /* "require" */
            case 'v':           /* "verify-ca" or "verify-full" */
                conn->status = CONNECTION_BAD;
                libpq_append_conn_error(conn, "%s value \"%s\" invalid when SSL support is not compiled in",
                                        "sslmode", conn->sslmode);
                return false;
        }
#endif
    }
    else
    {
        conn->sslmode = strdup(DefaultSSLMode);
        if (!conn->sslmode)
            goto oom_error;
    }
 
    /*
     * validate sslnegotiation option, default is "postgres" for the postgres
     * style negotiated connection with an extra round trip but more options.
     */
    if (conn->sslnegotiation)
    {
        if (strcmp(conn->sslnegotiation, "postgres") != 0
            && strcmp(conn->sslnegotiation, "direct") != 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                    "sslnegotiation", conn->sslnegotiation);
            return false;
        }
 
#ifndef USE_SSL
        if (conn->sslnegotiation[0] != 'p')
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "%s value \"%s\" invalid when SSL support is not compiled in",
                                    "sslnegotiation", conn->sslnegotiation);
            return false;
        }
#endif
 
        /*
         * Don't allow direct SSL negotiation with sslmode='prefer', because
         * that poses a risk of unintentional fallback to plaintext connection
         * when connecting to a pre-v17 server that does not support direct
         * SSL connections. To keep things simple, don't allow it with
         * sslmode='allow' or sslmode='disable' either. If a user goes through
         * the trouble of setting sslnegotiation='direct', they probably
         * intend to use SSL, and sslmode=disable or allow is probably a user
         * user mistake anyway.
         */
        if (conn->sslnegotiation[0] == 'd' &&
            conn->sslmode[0] != 'r' && conn->sslmode[0] != 'v')
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "weak sslmode \"%s\" may not be used with sslnegotiation=direct (use \"require\", \"verify-ca\", or \"verify-full\")",
                                    conn->sslmode);
            return false;
        }
    }
    else
    {
        conn->sslnegotiation = strdup(DefaultSSLNegotiation);
        if (!conn->sslnegotiation)
            goto oom_error;
    }
 
#ifdef USE_SSL
 
    /*
     * If sslrootcert=system, make sure our chosen sslmode is compatible.
     */
    if (conn->sslrootcert
        && strcmp(conn->sslrootcert, "system") == 0
        && strcmp(conn->sslmode, "verify-full") != 0)
    {
        conn->status = CONNECTION_BAD;
        libpq_append_conn_error(conn, "weak sslmode \"%s\" may not be used with sslrootcert=system (use \"verify-full\")",
                                conn->sslmode);
        return false;
    }
#endif
 
    /*
     * Validate TLS protocol versions for ssl_min_protocol_version and
     * ssl_max_protocol_version.
     */
    if (!sslVerifyProtocolVersion(conn->ssl_min_protocol_version))
    {
        conn->status = CONNECTION_BAD;
        libpq_append_conn_error(conn, "invalid \"%s\" value: \"%s\"",
                                "ssl_min_protocol_version",
                                conn->ssl_min_protocol_version);
        return false;
    }
    if (!sslVerifyProtocolVersion(conn->ssl_max_protocol_version))
    {
        conn->status = CONNECTION_BAD;
        libpq_append_conn_error(conn, "invalid \"%s\" value: \"%s\"",
                                "ssl_max_protocol_version",
                                conn->ssl_max_protocol_version);
        return false;
    }
 
    /*
     * Check if the range of SSL protocols defined is correct.  This is done
     * at this early step because this is independent of the SSL
     * implementation used, and this avoids unnecessary cycles with an
     * already-built SSL context when the connection is being established, as
     * it would be doomed anyway.
     */
    if (!sslVerifyProtocolRange(conn->ssl_min_protocol_version,
                                conn->ssl_max_protocol_version))
    {
        conn->status = CONNECTION_BAD;
        libpq_append_conn_error(conn, "invalid SSL protocol version range");
        return false;
    }
 
    /*
     * validate sslcertmode option
     */
    if (conn->sslcertmode)
    {
        if (strcmp(conn->sslcertmode, "disable") != 0 &&
            strcmp(conn->sslcertmode, "allow") != 0 &&
            strcmp(conn->sslcertmode, "require") != 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                    "sslcertmode", conn->sslcertmode);
            return false;
        }
#ifndef USE_SSL
        if (strcmp(conn->sslcertmode, "require") == 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "%s value \"%s\" invalid when SSL support is not compiled in",
                                    "sslcertmode", conn->sslcertmode);
            return false;
        }
#endif
#ifndef HAVE_SSL_CTX_SET_CERT_CB
 
        /*
         * Without a certificate callback, the current implementation can't
         * figure out if a certificate was actually requested, so "require" is
         * useless.
         */
        if (strcmp(conn->sslcertmode, "require") == 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "%s value \"%s\" is not supported (check OpenSSL version)",
                                    "sslcertmode", conn->sslcertmode);
            return false;
        }
#endif
    }
    else
    {
        conn->sslcertmode = strdup(DefaultSSLCertMode);
        if (!conn->sslcertmode)
            goto oom_error;
    }
 
    /*
     * validate gssencmode option
     */
    if (conn->gssencmode)
    {
        if (strcmp(conn->gssencmode, "disable") != 0 &&
            strcmp(conn->gssencmode, "prefer") != 0 &&
            strcmp(conn->gssencmode, "require") != 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "invalid %s value: \"%s\"", "gssencmode", conn->gssencmode);
            return false;
        }
#ifndef ENABLE_GSS
        if (strcmp(conn->gssencmode, "require") == 0)
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "gssencmode value \"%s\" invalid when GSSAPI support is not compiled in",
                                    conn->gssencmode);
            return false;
        }
#endif
    }
    else
    {
        conn->gssencmode = strdup(DefaultGSSMode);
        if (!conn->gssencmode)
            goto oom_error;
    }
 
    /*
     * validate target_session_attrs option, and set target_server_type
     */
    if (conn->target_session_attrs)
    {
        if (strcmp(conn->target_session_attrs, "any") == 0)
            conn->target_server_type = SERVER_TYPE_ANY;
        else if (strcmp(conn->target_session_attrs, "read-write") == 0)
            conn->target_server_type = SERVER_TYPE_READ_WRITE;
        else if (strcmp(conn->target_session_attrs, "read-only") == 0)
            conn->target_server_type = SERVER_TYPE_READ_ONLY;
        else if (strcmp(conn->target_session_attrs, "primary") == 0)
            conn->target_server_type = SERVER_TYPE_PRIMARY;
        else if (strcmp(conn->target_session_attrs, "standby") == 0)
            conn->target_server_type = SERVER_TYPE_STANDBY;
        else if (strcmp(conn->target_session_attrs, "prefer-standby") == 0)
            conn->target_server_type = SERVER_TYPE_PREFER_STANDBY;
        else
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                    "target_session_attrs",
                                    conn->target_session_attrs);
            return false;
        }
    }
    else
        conn->target_server_type = SERVER_TYPE_ANY;
 
    /*
     * validate load_balance_hosts option, and set load_balance_type
     */
    if (conn->load_balance_hosts)
    {
        if (strcmp(conn->load_balance_hosts, "disable") == 0)
            conn->load_balance_type = LOAD_BALANCE_DISABLE;
        else if (strcmp(conn->load_balance_hosts, "random") == 0)
            conn->load_balance_type = LOAD_BALANCE_RANDOM;
        else
        {
            conn->status = CONNECTION_BAD;
            libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                    "load_balance_hosts",
                                    conn->load_balance_hosts);
            return false;
        }
    }
    else
        conn->load_balance_type = LOAD_BALANCE_DISABLE;
 
    if (conn->load_balance_type == LOAD_BALANCE_RANDOM)
    {
        libpq_prng_init(conn);
 
        /*
         * This is the "inside-out" variant of the Fisher-Yates shuffle
         * algorithm. Notionally, we append each new value to the array and
         * then swap it with a randomly-chosen array element (possibly
         * including itself, else we fail to generate permutations with the
         * last integer last).  The swap step can be optimized by combining it
         * with the insertion.
         */
        for (i = 1; i < conn->nconnhost; i++)
        {
            int         j = pg_prng_uint64_range(&conn->prng_state, 0, i);
            pg_conn_host temp = conn->connhost[j];
 
            conn->connhost[j] = conn->connhost[i];
            conn->connhost[i] = temp;
        }
    }
 
    /*
     * Resolve special "auto" client_encoding from the locale
     */
    if (conn->client_encoding_initial &&
        strcmp(conn->client_encoding_initial, "auto") == 0)
    {
        free(conn->client_encoding_initial);
        conn->client_encoding_initial = strdup(pg_encoding_to_char(pg_get_encoding_from_locale(NULL, true)));
        if (!conn->client_encoding_initial)
            goto oom_error;
    }
 
    /*
     * Only if we get this far is it appropriate to try to connect. (We need a
     * state flag, rather than just the boolean result of this function, in
     * case someone tries to PQreset() the PGconn.)
     */
    conn->options_valid = true;
 
    return true;
 
oom_error:
    conn->status = CONNECTION_BAD;
    libpq_append_conn_error(conn, "out of memory");
    return false;
}

References pg_conn::allowed_auth_methods, Assert, AUTH_REQ_GSS, AUTH_REQ_GSS_CONT, AUTH_REQ_MD5, AUTH_REQ_PASSWORD, AUTH_REQ_SASL, AUTH_REQ_SASL_CONT, AUTH_REQ_SASL_FIN, AUTH_REQ_SSPI, pg_conn::auth_required, calloc, pg_conn::channel_binding, CHT_HOST_ADDRESS, CHT_HOST_NAME, CHT_UNIX_SOCKET, pg_conn::client_encoding_initial, conn, CONNECTION_BAD, pg_conn::connhost, count_comma_separated_elems(), pg_conn::dbName, DEFAULT_PGSOCKET_DIR, DefaultChannelBinding, DefaultGSSMode, DefaultHost, DefaultSSLCertMode, DefaultSSLMode, DefaultSSLNegotiation, pg_conn::errorMessage, free, pg_conn::gssencmode, pg_conn_host::host, pg_conn_host::hostaddr, i, is_unixsock_path(), j, libpq_append_conn_error(), libpq_prng_init(), LOAD_BALANCE_DISABLE, pg_conn::load_balance_hosts, LOAD_BALANCE_RANDOM, pg_conn::load_balance_type, malloc, MAXPGPATH, pg_conn::nconnhost, pg_conn::options_valid, parse_comma_separated_list(), pg_conn_host::password, passwordFromFile(), pg_encoding_to_char, pg_fe_getauthname(), pg_get_encoding_from_locale(), pg_prng_uint64_range(), pg_conn::pghost, pg_conn::pghostaddr, pg_conn::pgpass, PGPASSFILE, pg_conn::pgpassfile, pg_conn::pgport, pg_conn::pguser, pg_conn_host::port, pqGetHomeDirectory(), pg_conn::prng_state, pg_conn::require_auth, SERVER_TYPE_ANY, SERVER_TYPE_PREFER_STANDBY, SERVER_TYPE_PRIMARY, SERVER_TYPE_READ_ONLY, SERVER_TYPE_READ_WRITE, SERVER_TYPE_STANDBY, snprintf, pg_conn::ssl_max_protocol_version, pg_conn::ssl_min_protocol_version, pg_conn::sslcertmode, pg_conn::sslmode, pg_conn::sslnegotiation, pg_conn::sslrootcert, sslVerifyProtocolRange(), sslVerifyProtocolVersion(), pg_conn::status, pg_conn::target_server_type, pg_conn::target_session_attrs, pg_conn_host::type, and pg_conn::whichhost.

Referenced by PQcancelCreate(), PQconnectStart(), PQconnectStartParams(), and PQsetdbLogin().

pqCopyPGconn()

bool pqCopyPGconn	(	PGconn *	srcConn,
		PGconn *	dstConn
	)

Definition at line 957 of file fe-connect.c.

{
    const internalPQconninfoOption *option;
 
    /* copy over connection options */
    for (option = PQconninfoOptions; option->keyword; option++)
    {
        if (option->connofs >= 0)
        {
            const char **tmp = (const char **) ((char *) srcConn + option->connofs);
 
            if (*tmp)
            {
                char      **dstConnmember = (char **) ((char *) dstConn + option->connofs);
 
                if (*dstConnmember)
                    free(*dstConnmember);
                *dstConnmember = strdup(*tmp);
                if (*dstConnmember == NULL)
                {
                    libpq_append_conn_error(dstConn, "out of memory");
                    return false;
                }
            }
        }
    }
    return true;
}

References free, libpq_append_conn_error(), and PQconninfoOptions.

Referenced by PQcancelCreate().

pqDropConnection()

void pqDropConnection	(	PGconn *	conn,
		bool	flushInput
	)

Definition at line 472 of file fe-connect.c.

{
    /* Drop any SSL state */
    pqsecure_close(conn);
 
    /* Close the socket itself */
    if (conn->sock != PGINVALID_SOCKET)
        closesocket(conn->sock);
    conn->sock = PGINVALID_SOCKET;
 
    /* Optionally discard any unread data */
    if (flushInput)
        conn->inStart = conn->inCursor = conn->inEnd = 0;
 
    /* Always discard any unsent data */
    conn->outCount = 0;
 
    /* Likewise, discard any pending pipelined commands */
    pqFreeCommandQueue(conn->cmd_queue_head);
    conn->cmd_queue_head = conn->cmd_queue_tail = NULL;
    pqFreeCommandQueue(conn->cmd_queue_recycle);
    conn->cmd_queue_recycle = NULL;
 
    /* Free authentication/encryption state */
#ifdef ENABLE_GSS
    {
        OM_uint32   min_s;
 
        if (conn->gcred != GSS_C_NO_CREDENTIAL)
        {
            gss_release_cred(&min_s, &conn->gcred);
            conn->gcred = GSS_C_NO_CREDENTIAL;
        }
        if (conn->gctx)
            gss_delete_sec_context(&min_s, &conn->gctx, GSS_C_NO_BUFFER);
        if (conn->gtarg_nam)
            gss_release_name(&min_s, &conn->gtarg_nam);
        if (conn->gss_SendBuffer)
        {
            free(conn->gss_SendBuffer);
            conn->gss_SendBuffer = NULL;
        }
        if (conn->gss_RecvBuffer)
        {
            free(conn->gss_RecvBuffer);
            conn->gss_RecvBuffer = NULL;
        }
        if (conn->gss_ResultBuffer)
        {
            free(conn->gss_ResultBuffer);
            conn->gss_ResultBuffer = NULL;
        }
        conn->gssenc = false;
    }
#endif
#ifdef ENABLE_SSPI
    if (conn->sspitarget)
    {
        free(conn->sspitarget);
        conn->sspitarget = NULL;
    }
    if (conn->sspicred)
    {
        FreeCredentialsHandle(conn->sspicred);
        free(conn->sspicred);
        conn->sspicred = NULL;
    }
    if (conn->sspictx)
    {
        DeleteSecurityContext(conn->sspictx);
        free(conn->sspictx);
        conn->sspictx = NULL;
    }
    conn->usesspi = 0;
#endif
    if (conn->sasl_state)
    {
        conn->sasl->free(conn->sasl_state);
        conn->sasl_state = NULL;
    }
}

References closesocket, pg_conn::cmd_queue_head, pg_conn::cmd_queue_recycle, pg_conn::cmd_queue_tail, conn, free, pg_fe_sasl_mech::free, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, pg_conn::outCount, PGINVALID_SOCKET, pqFreeCommandQueue(), pqsecure_close(), pg_conn::sasl, pg_conn::sasl_state, and pg_conn::sock.

Referenced by handleSyncLoss(), pqClosePGconn(), pqConnectDBStart(), PQconnectPoll(), and pqReadData().

pqEndcopy3()

int pqEndcopy3

(

PGconn *

conn

)

Definition at line 1908 of file fe-protocol3.c.

{
    PGresult   *result;
 
    if (conn->asyncStatus != PGASYNC_COPY_IN &&
        conn->asyncStatus != PGASYNC_COPY_OUT &&
        conn->asyncStatus != PGASYNC_COPY_BOTH)
    {
        libpq_append_conn_error(conn, "no COPY in progress");
        return 1;
    }
 
    /* Send the CopyDone message if needed */
    if (conn->asyncStatus == PGASYNC_COPY_IN ||
        conn->asyncStatus == PGASYNC_COPY_BOTH)
    {
        if (pqPutMsgStart(PqMsg_CopyDone, conn) < 0 ||
            pqPutMsgEnd(conn) < 0)
            return 1;
 
        /*
         * If we sent the COPY command in extended-query mode, we must issue a
         * Sync as well.
         */
        if (conn->cmd_queue_head &&
            conn->cmd_queue_head->queryclass != PGQUERY_SIMPLE)
        {
            if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
                pqPutMsgEnd(conn) < 0)
                return 1;
        }
    }
 
    /*
     * make sure no data is waiting to be sent, abort if we are non-blocking
     * and the flush fails
     */
    if (pqFlush(conn) && pqIsnonblocking(conn))
        return 1;
 
    /* Return to active duty */
    conn->asyncStatus = PGASYNC_BUSY;
 
    /*
     * Non blocking connections may have to abort at this point.  If everyone
     * played the game there should be no problem, but in error scenarios the
     * expected messages may not have arrived yet.  (We are assuming that the
     * backend's packetizing will ensure that CommandComplete arrives along
     * with the CopyDone; are there corner cases where that doesn't happen?)
     */
    if (pqIsnonblocking(conn) && PQisBusy(conn))
        return 1;
 
    /* Wait for the completion response */
    result = PQgetResult(conn);
 
    /* Expecting a successful result */
    if (result && result->resultStatus == PGRES_COMMAND_OK)
    {
        PQclear(result);
        return 0;
    }
 
    /*
     * Trouble. For backwards-compatibility reasons, we issue the error
     * message as if it were a notice (would be nice to get rid of this
     * silliness, but too many apps probably don't handle errors from
     * PQendcopy reasonably).  Note that the app can still obtain the error
     * status from the PGconn object.
     */
    if (conn->errorMessage.len > 0)
    {
        /* We have to strip the trailing newline ... pain in neck... */
        char        svLast = conn->errorMessage.data[conn->errorMessage.len - 1];
 
        if (svLast == '\n')
            conn->errorMessage.data[conn->errorMessage.len - 1] = '\0';
        pqInternalNotice(&conn->noticeHooks, "%s", conn->errorMessage.data);
        conn->errorMessage.data[conn->errorMessage.len - 1] = svLast;
    }
 
    PQclear(result);
 
    return 1;
}

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, PQExpBufferData::data, pg_conn::errorMessage, PQExpBufferData::len, libpq_append_conn_error(), pg_conn::noticeHooks, PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGQUERY_SIMPLE, PGRES_COMMAND_OK, PQclear(), pqFlush(), PQgetResult(), pqInternalNotice(), PQisBusy(), pqIsnonblocking, PqMsg_CopyDone, PqMsg_Sync, pqPutMsgEnd(), pqPutMsgStart(), PGcmdQueueEntry::queryclass, and pg_result::resultStatus.

Referenced by PQendcopy().

pqFlush()

int pqFlush

(

PGconn *

conn

)

Definition at line 968 of file fe-misc.c.

{
    if (conn->outCount > 0)
    {
        if (conn->Pfdebug)
            fflush(conn->Pfdebug);
 
        return pqSendSome(conn, conn->outCount);
    }
 
    return 0;
}

References conn, fflush(), pg_conn::outCount, pg_conn::Pfdebug, and pqSendSome().

Referenced by pg_SASL_init(), PQconnectPoll(), PQconsumeInput(), pqEndcopy3(), PQexitPipelineMode(), PQflush(), pqFunctionCall3(), PQgetResult(), pqPacketSend(), pqPipelineFlush(), pqPipelineSyncInternal(), PQputCopyData(), PQputCopyEnd(), PQsendQueryInternal(), PQsetnonblocking(), and sendTerminateConn().

pqFunctionCall3()

PGresult* pqFunctionCall3	(	PGconn *	conn,
		Oid	fnid,
		int *	result_buf,
		int *	actual_result_len,
		int	result_is_int,
		const PQArgBlock *	args,
		int	nargs
	)

Definition at line 2001 of file fe-protocol3.c.

{
    bool        needInput = false;
    ExecStatusType status = PGRES_FATAL_ERROR;
    char        id;
    int         msgLength;
    int         avail;
    int         i;
 
    /* already validated by PQfn */
    Assert(conn->pipelineStatus == PQ_PIPELINE_OFF);
 
    /* PQfn already validated connection state */
 
    if (pqPutMsgStart(PqMsg_FunctionCall, conn) < 0 ||
        pqPutInt(fnid, 4, conn) < 0 ||  /* function id */
        pqPutInt(1, 2, conn) < 0 || /* # of format codes */
        pqPutInt(1, 2, conn) < 0 || /* format code: BINARY */
        pqPutInt(nargs, 2, conn) < 0)   /* # of args */
    {
        /* error message should be set up already */
        return NULL;
    }
 
    for (i = 0; i < nargs; ++i)
    {                           /* len.int4 + contents     */
        if (pqPutInt(args[i].len, 4, conn))
            return NULL;
        if (args[i].len == -1)
            continue;           /* it's NULL */
 
        if (args[i].isint)
        {
            if (pqPutInt(args[i].u.integer, args[i].len, conn))
                return NULL;
        }
        else
        {
            if (pqPutnchar((char *) args[i].u.ptr, args[i].len, conn))
                return NULL;
        }
    }
 
    if (pqPutInt(1, 2, conn) < 0)   /* result format code: BINARY */
        return NULL;
 
    if (pqPutMsgEnd(conn) < 0 ||
        pqFlush(conn))
        return NULL;
 
    for (;;)
    {
        if (needInput)
        {
            /* Wait for some data to arrive (or for the channel to close) */
            if (pqWait(true, false, conn) ||
                pqReadData(conn) < 0)
                break;
        }
 
        /*
         * Scan the message. If we run out of data, loop around to try again.
         */
        needInput = true;
 
        conn->inCursor = conn->inStart;
        if (pqGetc(&id, conn))
            continue;
        if (pqGetInt(&msgLength, 4, conn))
            continue;
 
        /*
         * Try to validate message type/length here.  A length less than 4 is
         * definitely broken.  Large lengths should only be believed for a few
         * message types.
         */
        if (msgLength < 4)
        {
            handleSyncLoss(conn, id, msgLength);
            break;
        }
        if (msgLength > 30000 && !VALID_LONG_MESSAGE_TYPE(id))
        {
            handleSyncLoss(conn, id, msgLength);
            break;
        }
 
        /*
         * Can't process if message body isn't all here yet.
         */
        msgLength -= 4;
        avail = conn->inEnd - conn->inCursor;
        if (avail < msgLength)
        {
            /*
             * Before looping, enlarge the input buffer if needed to hold the
             * whole message.  See notes in parseInput.
             */
            if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
                                     conn))
            {
                /*
                 * XXX add some better recovery code... plan is to skip over
                 * the message using its length, then report an error. For the
                 * moment, just treat this like loss of sync (which indeed it
                 * might be!)
                 */
                handleSyncLoss(conn, id, msgLength);
                break;
            }
            continue;
        }
 
        /*
         * We should see V or E response to the command, but might get N
         * and/or A notices first. We also need to swallow the final Z before
         * returning.
         */
        switch (id)
        {
            case 'V':           /* function result */
                if (pqGetInt(actual_result_len, 4, conn))
                    continue;
                if (*actual_result_len != -1)
                {
                    if (result_is_int)
                    {
                        if (pqGetInt(result_buf, *actual_result_len, conn))
                            continue;
                    }
                    else
                    {
                        if (pqGetnchar((char *) result_buf,
                                       *actual_result_len,
                                       conn))
                            continue;
                    }
                }
                /* correctly finished function result message */
                status = PGRES_COMMAND_OK;
                break;
            case 'E':           /* error return */
                if (pqGetErrorNotice3(conn, true))
                    continue;
                status = PGRES_FATAL_ERROR;
                break;
            case 'A':           /* notify message */
                /* handle notify and go back to processing return values */
                if (getNotify(conn))
                    continue;
                break;
            case 'N':           /* notice */
                /* handle notice and go back to processing return values */
                if (pqGetErrorNotice3(conn, false))
                    continue;
                break;
            case 'Z':           /* backend is ready for new query */
                if (getReadyForQuery(conn))
                    continue;
 
                /* consume the message */
                pqParseDone(conn, conn->inStart + 5 + msgLength);
 
                /*
                 * If we already have a result object (probably an error), use
                 * that.  Otherwise, if we saw a function result message,
                 * report COMMAND_OK.  Otherwise, the backend violated the
                 * protocol, so complain.
                 */
                if (!pgHavePendingResult(conn))
                {
                    if (status == PGRES_COMMAND_OK)
                    {
                        conn->result = PQmakeEmptyPGresult(conn, status);
                        if (!conn->result)
                        {
                            libpq_append_conn_error(conn, "out of memory");
                            pqSaveErrorResult(conn);
                        }
                    }
                    else
                    {
                        libpq_append_conn_error(conn, "protocol error: no function result");
                        pqSaveErrorResult(conn);
                    }
                }
                /* and we're out */
                return pqPrepareAsyncResult(conn);
            case 'S':           /* parameter status */
                if (getParameterStatus(conn))
                    continue;
                break;
            default:
                /* The backend violates the protocol. */
                libpq_append_conn_error(conn, "protocol error: id=0x%x", id);
                pqSaveErrorResult(conn);
 
                /*
                 * We can't call parsing done due to the protocol violation
                 * (so message tracing wouldn't work), but trust the specified
                 * message length as what to skip.
                 */
                conn->inStart += 5 + msgLength;
                return pqPrepareAsyncResult(conn);
        }
 
        /* Completed parsing this message, keep going */
        pqParseDone(conn, conn->inStart + 5 + msgLength);
        needInput = false;
    }
 
    /*
     * We fall out of the loop only upon failing to read data.
     * conn->errorMessage has been set by pqWait or pqReadData. We want to
     * append it to any already-received error message.
     */
    pqSaveErrorResult(conn);
    return pqPrepareAsyncResult(conn);
}

References generate_unaccent_rules::args, Assert, conn, getNotify(), getParameterStatus(), getReadyForQuery(), handleSyncLoss(), i, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, len, libpq_append_conn_error(), pgHavePendingResult, PGRES_COMMAND_OK, PGRES_FATAL_ERROR, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqCheckInBufferSpace(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetnchar(), PQmakeEmptyPGresult(), PqMsg_FunctionCall, pqParseDone(), pqPrepareAsyncResult(), pqPutInt(), pqPutMsgEnd(), pqPutMsgStart(), pqPutnchar(), pqReadData(), pqSaveErrorResult(), pqWait(), pg_conn::result, and VALID_LONG_MESSAGE_TYPE.

Referenced by PQfn().

pqGetc()

int pqGetc	(	char *	result,
		PGconn *	conn
	)

Definition at line 77 of file fe-misc.c.

{
    if (conn->inCursor >= conn->inEnd)
        return EOF;
 
    *result = conn->inBuffer[conn->inCursor++];
 
    return 0;
}

References conn, pg_conn::inBuffer, pg_conn::inCursor, and pg_conn::inEnd.

Referenced by getCopyDataMessage(), getCopyStart(), getReadyForQuery(), PQconnectPoll(), pqFunctionCall3(), pqGetErrorNotice3(), and pqParseInput3().

pqGetCopyData3()

int pqGetCopyData3	(	PGconn *	conn,
		char **	buffer,
		int	async
	)

Definition at line 1743 of file fe-protocol3.c.

{
    int         msgLength;
 
    for (;;)
    {
        /*
         * Collect the next input message.  To make life simpler for async
         * callers, we keep returning 0 until the next message is fully
         * available, even if it is not Copy Data.
         */
        msgLength = getCopyDataMessage(conn);
        if (msgLength < 0)
            return msgLength;   /* end-of-copy or error */
        if (msgLength == 0)
        {
            /* Don't block if async read requested */
            if (async)
                return 0;
            /* Need to load more data */
            if (pqWait(true, false, conn) ||
                pqReadData(conn) < 0)
                return -2;
            continue;
        }
 
        /*
         * Drop zero-length messages (shouldn't happen anyway).  Otherwise
         * pass the data back to the caller.
         */
        msgLength -= 4;
        if (msgLength > 0)
        {
            *buffer = (char *) malloc(msgLength + 1);
            if (*buffer == NULL)
            {
                libpq_append_conn_error(conn, "out of memory");
                return -2;
            }
            memcpy(*buffer, &conn->inBuffer[conn->inCursor], msgLength);
            (*buffer)[msgLength] = '\0';    /* Add terminating null */
 
            /* Mark message consumed */
            pqParseDone(conn, conn->inCursor + msgLength);
 
            return msgLength;
        }
 
        /* Empty, so drop it and loop around for another */
        pqParseDone(conn, conn->inCursor);
    }
}

References conn, getCopyDataMessage(), pg_conn::inBuffer, pg_conn::inCursor, libpq_append_conn_error(), malloc, pqParseDone(), pqReadData(), and pqWait().

Referenced by PQgetCopyData().

pqGetErrorNotice3()

int pqGetErrorNotice3	(	PGconn *	conn,
		bool	isError
	)

Definition at line 878 of file fe-protocol3.c.

{
    PGresult   *res = NULL;
    bool        have_position = false;
    PQExpBufferData workBuf;
    char        id;
 
    /* If in pipeline mode, set error indicator for it */
    if (isError && conn->pipelineStatus != PQ_PIPELINE_OFF)
        conn->pipelineStatus = PQ_PIPELINE_ABORTED;
 
    /*
     * If this is an error message, pre-emptively clear any incomplete query
     * result we may have.  We'd just throw it away below anyway, and
     * releasing it before collecting the error might avoid out-of-memory.
     */
    if (isError)
        pqClearAsyncResult(conn);
 
    /*
     * Since the fields 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.  We shouldn't use
     * conn->errorMessage either, since this might be only a notice.
     */
    initPQExpBuffer(&workBuf);
 
    /*
     * Make a PGresult to hold the accumulated fields.  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;
 
    /*
     * Read the fields and save into res.
     *
     * While at it, save the SQLSTATE in conn->last_sqlstate, and note whether
     * we saw a PG_DIAG_STATEMENT_POSITION field.
     */
    for (;;)
    {
        if (pqGetc(&id, conn))
            goto fail;
        if (id == '\0')
            break;              /* terminator found */
        if (pqGets(&workBuf, conn))
            goto fail;
        pqSaveMessageField(res, id, workBuf.data);
        if (id == PG_DIAG_SQLSTATE)
            strlcpy(conn->last_sqlstate, workBuf.data,
                    sizeof(conn->last_sqlstate));
        else if (id == PG_DIAG_STATEMENT_POSITION)
            have_position = true;
    }
 
    /*
     * Save the active query text, if any, into res as well; but only if we
     * might need it for an error cursor display, which is only true if there
     * is a PG_DIAG_STATEMENT_POSITION field.
     */
    if (have_position && res && conn->cmd_queue_head && conn->cmd_queue_head->query)
        res->errQuery = pqResultStrdup(res, conn->cmd_queue_head->query);
 
    /*
     * Now build the "overall" error message for PQresultErrorMessage.
     */
    resetPQExpBuffer(&workBuf);
    pqBuildErrorMessage3(&workBuf, res, conn->verbosity, conn->show_context);
 
    /*
     * Either save error as current async result, or just emit the notice.
     */
    if (isError)
    {
        pqClearAsyncResult(conn);   /* redundant, but be safe */
        if (res)
        {
            pqSetResultError(res, &workBuf, 0);
            conn->result = res;
        }
        else
        {
            /* Fall back to using the internal-error processing paths */
            conn->error_result = true;
        }
 
        if (PQExpBufferDataBroken(workBuf))
            libpq_append_conn_error(conn, "out of memory");
        else
            appendPQExpBufferStr(&conn->errorMessage, workBuf.data);
    }
    else
    {
        /* if we couldn't allocate the result set, just discard the NOTICE */
        if (res)
        {
            /*
             * We can cheat a little here and not copy the message.  But if we
             * were unlucky enough to run out of memory while filling workBuf,
             * insert "out of memory", as in pqSetResultError.
             */
            if (PQExpBufferDataBroken(workBuf))
                res->errMsg = libpq_gettext("out of memory\n");
            else
                res->errMsg = workBuf.data;
            if (res->noticeHooks.noticeRec != NULL)
                res->noticeHooks.noticeRec(res->noticeHooks.noticeRecArg, res);
            PQclear(res);
        }
    }
 
    termPQExpBuffer(&workBuf);
    return 0;
 
fail:
    PQclear(res);
    termPQExpBuffer(&workBuf);
    return EOF;
}

References appendPQExpBufferStr(), pg_conn::cmd_queue_head, conn, PQExpBufferData::data, pg_result::errMsg, pg_conn::error_result, pg_conn::errorMessage, pg_result::errQuery, initPQExpBuffer(), pg_conn::last_sqlstate, libpq_append_conn_error(), libpq_gettext, pg_result::noticeHooks, PGNoticeHooks::noticeRec, PGNoticeHooks::noticeRecArg, PG_DIAG_SQLSTATE, PG_DIAG_STATEMENT_POSITION, PGRES_EMPTY_QUERY, PGRES_FATAL_ERROR, PGRES_NONFATAL_ERROR, pg_conn::pipelineStatus, PQ_PIPELINE_ABORTED, PQ_PIPELINE_OFF, pqBuildErrorMessage3(), PQclear(), pqClearAsyncResult(), PQExpBufferDataBroken, pqGetc(), pqGets(), PQmakeEmptyPGresult(), pqResultStrdup(), pqSaveMessageField(), pqSetResultError(), PGcmdQueueEntry::query, res, resetPQExpBuffer(), pg_conn::result, pg_result::resultStatus, pg_conn::show_context, strlcpy(), termPQExpBuffer(), and pg_conn::verbosity.

Referenced by getCopyDataMessage(), PQconnectPoll(), pqFunctionCall3(), and pqParseInput3().

pqGetHomeDirectory()

bool pqGetHomeDirectory	(	char *	buf,
		int	bufsize
	)

Definition at line 7697 of file fe-connect.c.

{
#ifndef WIN32
    const char *home;
 
    home = getenv("HOME");
    if (home && home[0])
    {
        strlcpy(buf, home, bufsize);
        return true;
    }
    else
    {
        struct passwd pwbuf;
        struct passwd *pw;
        char        tmpbuf[1024];
        int         rc;
 
        rc = getpwuid_r(geteuid(), &pwbuf, tmpbuf, sizeof tmpbuf, &pw);
        if (rc != 0 || !pw)
            return false;
        strlcpy(buf, pw->pw_dir, bufsize);
        return true;
    }
#else
    char        tmppath[MAX_PATH];
 
    ZeroMemory(tmppath, sizeof(tmppath));
    if (SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, tmppath) != S_OK)
        return false;
    snprintf(buf, bufsize, "%s/postgresql", tmppath);
    return true;
#endif
}

References buf, bufsize, snprintf, strlcpy(), and tmpbuf.

Referenced by initialize_SSL(), parseServiceInfo(), and pqConnectOptions2().

pqGetInt()

int pqGetInt	(	int *	result,
		size_t	bytes,
		PGconn *	conn
	)

Definition at line 216 of file fe-misc.c.

{
    uint16      tmp2;
    uint32      tmp4;
 
    switch (bytes)
    {
        case 2:
            if (conn->inCursor + 2 > conn->inEnd)
                return EOF;
            memcpy(&tmp2, conn->inBuffer + conn->inCursor, 2);
            conn->inCursor += 2;
            *result = (int) pg_ntoh16(tmp2);
            break;
        case 4:
            if (conn->inCursor + 4 > conn->inEnd)
                return EOF;
            memcpy(&tmp4, conn->inBuffer + conn->inCursor, 4);
            conn->inCursor += 4;
            *result = (int) pg_ntoh32(tmp4);
            break;
        default:
            pqInternalNotice(&conn->noticeHooks,
                             "integer of size %lu not supported by pqGetInt",
                             (unsigned long) bytes);
            return EOF;
    }
 
    return 0;
}

References conn, pg_conn::inBuffer, pg_conn::inCursor, pg_conn::inEnd, pg_conn::noticeHooks, pg_ntoh16, pg_ntoh32, and pqInternalNotice().

Referenced by getAnotherTuple(), getCopyDataMessage(), getCopyStart(), getNotify(), getParamDescriptions(), getRowDescriptions(), PQconnectPoll(), pqFunctionCall3(), pqGetNegotiateProtocolVersion3(), and pqParseInput3().

pqGetline3()

int pqGetline3	(	PGconn *	conn,
		char *	s,
		int	maxlen
	)

Definition at line 1802 of file fe-protocol3.c.

{
    int         status;
 
    if (conn->sock == PGINVALID_SOCKET ||
        (conn->asyncStatus != PGASYNC_COPY_OUT &&
         conn->asyncStatus != PGASYNC_COPY_BOTH) ||
        conn->copy_is_binary)
    {
        libpq_append_conn_error(conn, "PQgetline: not doing text COPY OUT");
        *s = '\0';
        return EOF;
    }
 
    while ((status = PQgetlineAsync(conn, s, maxlen - 1)) == 0)
    {
        /* need to load more data */
        if (pqWait(true, false, conn) ||
            pqReadData(conn) < 0)
        {
            *s = '\0';
            return EOF;
        }
    }
 
    if (status < 0)
    {
        /* End of copy detected; gin up old-style terminator */
        strcpy(s, "\\.");
        return 0;
    }
 
    /* Add null terminator, and strip trailing \n if present */
    if (s[status - 1] == '\n')
    {
        s[status - 1] = '\0';
        return 0;
    }
    else
    {
        s[status] = '\0';
        return 1;
    }
}

References pg_conn::asyncStatus, conn, pg_conn::copy_is_binary, libpq_append_conn_error(), PGASYNC_COPY_BOTH, PGASYNC_COPY_OUT, PGINVALID_SOCKET, PQgetlineAsync(), pqReadData(), pqWait(), and pg_conn::sock.

Referenced by PQgetline().

pqGetlineAsync3()

int pqGetlineAsync3	(	PGconn *	conn,
		char *	buffer,
		int	bufsize
	)

Definition at line 1853 of file fe-protocol3.c.

{
    int         msgLength;
    int         avail;
 
    if (conn->asyncStatus != PGASYNC_COPY_OUT
        && conn->asyncStatus != PGASYNC_COPY_BOTH)
        return -1;              /* we are not doing a copy... */
 
    /*
     * Recognize the next input message.  To make life simpler for async
     * callers, we keep returning 0 until the next message is fully available
     * even if it is not Copy Data.  This should keep PQendcopy from blocking.
     * (Note: unlike pqGetCopyData3, we do not change asyncStatus here.)
     */
    msgLength = getCopyDataMessage(conn);
    if (msgLength < 0)
        return -1;              /* end-of-copy or error */
    if (msgLength == 0)
        return 0;               /* no data yet */
 
    /*
     * Move data from libpq's buffer to the caller's.  In the case where a
     * prior call found the caller's buffer too small, we use
     * conn->copy_already_done to remember how much of the row was already
     * returned to the caller.
     */
    conn->inCursor += conn->copy_already_done;
    avail = msgLength - 4 - conn->copy_already_done;
    if (avail <= bufsize)
    {
        /* Able to consume the whole message */
        memcpy(buffer, &conn->inBuffer[conn->inCursor], avail);
        /* Mark message consumed */
        conn->inStart = conn->inCursor + avail;
        /* Reset state for next time */
        conn->copy_already_done = 0;
        return avail;
    }
    else
    {
        /* We must return a partial message */
        memcpy(buffer, &conn->inBuffer[conn->inCursor], bufsize);
        /* The message is NOT consumed from libpq's buffer */
        conn->copy_already_done += bufsize;
        return bufsize;
    }
}

References pg_conn::asyncStatus, bufsize, conn, pg_conn::copy_already_done, getCopyDataMessage(), pg_conn::inBuffer, pg_conn::inCursor, pg_conn::inStart, PGASYNC_COPY_BOTH, and PGASYNC_COPY_OUT.

Referenced by PQgetlineAsync().

pqGetnchar()

int pqGetnchar	(	char *	s,
		size_t	len,
		PGconn *	conn
	)

Definition at line 165 of file fe-misc.c.

{
    if (len > (size_t) (conn->inEnd - conn->inCursor))
        return EOF;
 
    memcpy(s, conn->inBuffer + conn->inCursor, len);
    /* no terminating null */
 
    conn->inCursor += len;
 
    return 0;
}

References conn, pg_conn::inBuffer, pg_conn::inCursor, pg_conn::inEnd, and len.

Referenced by pg_password_sendauth(), pg_SASL_continue(), and pqFunctionCall3().

pqGetNegotiateProtocolVersion3()

int pqGetNegotiateProtocolVersion3

(

PGconn *

conn

)

Definition at line 1408 of file fe-protocol3.c.

{
    int         tmp;
    ProtocolVersion their_version;
    int         num;
    PQExpBufferData buf;
 
    if (pqGetInt(&tmp, 4, conn) != 0)
        return EOF;
    their_version = tmp;
 
    if (pqGetInt(&num, 4, conn) != 0)
        return EOF;
 
    initPQExpBuffer(&buf);
    for (int i = 0; i < num; i++)
    {
        if (pqGets(&conn->workBuffer, conn))
        {
            termPQExpBuffer(&buf);
            return EOF;
        }
        if (buf.len > 0)
            appendPQExpBufferChar(&buf, ' ');
        appendPQExpBufferStr(&buf, conn->workBuffer.data);
    }
 
    if (their_version < conn->pversion)
        libpq_append_conn_error(conn, "protocol version not supported by server: client uses %u.%u, server supports up to %u.%u",
                                PG_PROTOCOL_MAJOR(conn->pversion), PG_PROTOCOL_MINOR(conn->pversion),
                                PG_PROTOCOL_MAJOR(their_version), PG_PROTOCOL_MINOR(their_version));
    if (num > 0)
    {
        appendPQExpBuffer(&conn->errorMessage,
                          libpq_ngettext("protocol extension not supported by server: %s",
                                         "protocol extensions not supported by server: %s", num),
                          buf.data);
        appendPQExpBufferChar(&conn->errorMessage, '\n');
    }
 
    /* neither -- server shouldn't have sent it */
    if (!(their_version < conn->pversion) && !(num > 0))
        libpq_append_conn_error(conn, "invalid %s message", "NegotiateProtocolVersion");
 
    termPQExpBuffer(&buf);
    return 0;
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), buf, conn, PQExpBufferData::data, pg_conn::errorMessage, i, initPQExpBuffer(), libpq_append_conn_error(), libpq_ngettext, PG_PROTOCOL_MAJOR, PG_PROTOCOL_MINOR, pqGetInt(), pqGets(), pg_conn::pversion, termPQExpBuffer(), and pg_conn::workBuffer.

Referenced by PQconnectPoll().

pqGets()

int pqGets	(	PQExpBuffer	buf,
		PGconn *	conn
	)

Definition at line 136 of file fe-misc.c.

{
    return pqGets_internal(buf, conn, true);
}

References buf, conn, and pqGets_internal().

Referenced by getNotify(), getParameterStatus(), getRowDescriptions(), pg_SASL_init(), pqGetErrorNotice3(), pqGetNegotiateProtocolVersion3(), and pqParseInput3().

pqGets_append()

int pqGets_append	(	PQExpBuffer	buf,
		PGconn *	conn
	)

Definition at line 142 of file fe-misc.c.

{
    return pqGets_internal(buf, conn, false);
}

References buf, conn, and pqGets_internal().

Referenced by PQconnectPoll().

pqInternalNotice()

void pqInternalNotice	(	const PGNoticeHooks *	hooks,
		const char *	fmt,
			...
	)

pqMakeEmptyPGconn()

PGconn* pqMakeEmptyPGconn

(

void

)

Definition at line 4550 of file fe-connect.c.

{
    PGconn     *conn;
 
#ifdef WIN32
 
    /*
     * Make sure socket support is up and running in this process.
     *
     * Note: the Windows documentation says that we should eventually do a
     * matching WSACleanup() call, but experience suggests that that is at
     * least as likely to cause problems as fix them.  So we don't.
     */
    static bool wsastartup_done = false;
 
    if (!wsastartup_done)
    {
        WSADATA     wsaData;
 
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
            return NULL;
        wsastartup_done = true;
    }
 
    /* Forget any earlier error */
    WSASetLastError(0);
#endif                          /* WIN32 */
 
    conn = (PGconn *) malloc(sizeof(PGconn));
    if (conn == NULL)
        return conn;
 
    /* Zero all pointers and booleans */
    MemSet(conn, 0, sizeof(PGconn));
 
    /* install default notice hooks */
    conn->noticeHooks.noticeRec = defaultNoticeReceiver;
    conn->noticeHooks.noticeProc = defaultNoticeProcessor;
 
    conn->status = CONNECTION_BAD;
    conn->asyncStatus = PGASYNC_IDLE;
    conn->pipelineStatus = PQ_PIPELINE_OFF;
    conn->xactStatus = PQTRANS_IDLE;
    conn->options_valid = false;
    conn->nonblocking = false;
    conn->client_encoding = PG_SQL_ASCII;
    conn->std_strings = false;  /* unless server says differently */
    conn->default_transaction_read_only = PG_BOOL_UNKNOWN;
    conn->in_hot_standby = PG_BOOL_UNKNOWN;
    conn->scram_sha_256_iterations = SCRAM_SHA_256_DEFAULT_ITERATIONS;
    conn->verbosity = PQERRORS_DEFAULT;
    conn->show_context = PQSHOW_CONTEXT_ERRORS;
    conn->sock = PGINVALID_SOCKET;
    conn->Pfdebug = NULL;
 
    /*
     * We try to send at least 8K at a time, which is the usual size of pipe
     * buffers on Unix systems.  That way, when we are sending a large amount
     * of data, we avoid incurring extra kernel context swaps for partial
     * bufferloads.  The output buffer is initially made 16K in size, and we
     * try to dump it after accumulating 8K.
     *
     * With the same goal of minimizing context swaps, the input buffer will
     * be enlarged anytime it has less than 8K free, so we initially allocate
     * twice that.
     */
    conn->inBufSize = 16 * 1024;
    conn->inBuffer = (char *) malloc(conn->inBufSize);
    conn->outBufSize = 16 * 1024;
    conn->outBuffer = (char *) malloc(conn->outBufSize);
    conn->rowBufLen = 32;
    conn->rowBuf = (PGdataValue *) malloc(conn->rowBufLen * sizeof(PGdataValue));
    initPQExpBuffer(&conn->errorMessage);
    initPQExpBuffer(&conn->workBuffer);
 
    if (conn->inBuffer == NULL ||
        conn->outBuffer == NULL ||
        conn->rowBuf == NULL ||
        PQExpBufferBroken(&conn->errorMessage) ||
        PQExpBufferBroken(&conn->workBuffer))
    {
        /* out of memory already :-( */
        freePGconn(conn);
        conn = NULL;
    }
 
    return conn;
}

References pg_conn::asyncStatus, pg_conn::client_encoding, conn, CONNECTION_BAD, pg_conn::default_transaction_read_only, defaultNoticeProcessor(), defaultNoticeReceiver(), pg_conn::errorMessage, freePGconn(), pg_conn::in_hot_standby, pg_conn::inBuffer, pg_conn::inBufSize, initPQExpBuffer(), malloc, MemSet, pg_conn::nonblocking, pg_conn::noticeHooks, PGNoticeHooks::noticeProc, PGNoticeHooks::noticeRec, pg_conn::options_valid, pg_conn::outBuffer, pg_conn::outBufSize, pg_conn::Pfdebug, PG_BOOL_UNKNOWN, PG_SQL_ASCII, PGASYNC_IDLE, PGINVALID_SOCKET, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PQERRORS_DEFAULT, PQExpBufferBroken, PQSHOW_CONTEXT_ERRORS, PQTRANS_IDLE, pg_conn::rowBuf, pg_conn::rowBufLen, SCRAM_SHA_256_DEFAULT_ITERATIONS, pg_conn::scram_sha_256_iterations, pg_conn::show_context, pg_conn::sock, pg_conn::status, pg_conn::std_strings, pg_conn::verbosity, pg_conn::workBuffer, and pg_conn::xactStatus.

Referenced by PQcancelCreate(), PQconnectStart(), PQconnectStartParams(), and PQsetdbLogin().

pqPacketSend()

int pqPacketSend	(	PGconn *	conn,
		char	pack_type,
		const void *	buf,
		size_t	buf_len
	)

Definition at line 5001 of file fe-connect.c.

{
    /* Start the message. */
    if (pqPutMsgStart(pack_type, conn))
        return STATUS_ERROR;
 
    /* Send the message body. */
    if (pqPutnchar(buf, buf_len, conn))
        return STATUS_ERROR;
 
    /* Finish the message. */
    if (pqPutMsgEnd(conn))
        return STATUS_ERROR;
 
    /* Flush to ensure backend gets it. */
    if (pqFlush(conn))
        return STATUS_ERROR;
 
    return STATUS_OK;
}

References buf, conn, pqFlush(), pqPutMsgEnd(), pqPutMsgStart(), pqPutnchar(), STATUS_ERROR, and STATUS_OK.

Referenced by pg_password_sendauth(), pg_SASL_continue(), and PQconnectPoll().

pqParseDone()

void pqParseDone	(	PGconn *	conn,
		int	newInStart
	)

Definition at line 443 of file fe-misc.c.

{
    /* trace server-to-client message */
    if (conn->Pfdebug)
        pqTraceOutputMessage(conn, conn->inBuffer + conn->inStart, false);
 
    /* Mark message as done */
    conn->inStart = newInStart;
}

References conn, pg_conn::inBuffer, pg_conn::inStart, pg_conn::Pfdebug, and pqTraceOutputMessage().

Referenced by getCopyDataMessage(), PQconnectPoll(), pqFunctionCall3(), pqGetCopyData3(), and pqParseInput3().

pqParseInput3()

void pqParseInput3

(

PGconn *

conn

)

Definition at line 66 of file fe-protocol3.c.

{
    char        id;
    int         msgLength;
    int         avail;
 
    /*
     * Loop to parse successive complete messages available in the buffer.
     */
    for (;;)
    {
        /*
         * Try to read a message.  First get the type code and length. Return
         * if not enough data.
         */
        conn->inCursor = conn->inStart;
        if (pqGetc(&id, conn))
            return;
        if (pqGetInt(&msgLength, 4, conn))
            return;
 
        /*
         * Try to validate message type/length here.  A length less than 4 is
         * definitely broken.  Large lengths should only be believed for a few
         * message types.
         */
        if (msgLength < 4)
        {
            handleSyncLoss(conn, id, msgLength);
            return;
        }
        if (msgLength > 30000 && !VALID_LONG_MESSAGE_TYPE(id))
        {
            handleSyncLoss(conn, id, msgLength);
            return;
        }
 
        /*
         * Can't process if message body isn't all here yet.
         */
        msgLength -= 4;
        avail = conn->inEnd - conn->inCursor;
        if (avail < msgLength)
        {
            /*
             * Before returning, enlarge the input buffer if needed to hold
             * the whole message.  This is better than leaving it to
             * pqReadData because we can avoid multiple cycles of realloc()
             * when the message is large; also, we can implement a reasonable
             * recovery strategy if we are unable to make the buffer big
             * enough.
             */
            if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
                                     conn))
            {
                /*
                 * XXX add some better recovery code... plan is to skip over
                 * the message using its length, then report an error. For the
                 * moment, just treat this like loss of sync (which indeed it
                 * might be!)
                 */
                handleSyncLoss(conn, id, msgLength);
            }
            return;
        }
 
        /*
         * NOTIFY and NOTICE messages can happen in any state; 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.
         *
         * ParameterStatus ('S') messages are a special case: in IDLE state we
         * must process 'em (this case could happen if a new value was adopted
         * from config file due to SIGHUP), but otherwise we hold off until
         * BUSY state.
         */
        if (id == PqMsg_NotificationResponse)
        {
            if (getNotify(conn))
                return;
        }
        else if (id == PqMsg_NoticeResponse)
        {
            if (pqGetErrorNotice3(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 handled using the notice processor;
             * ParameterStatus is handled normally; 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 == PqMsg_ErrorResponse)
            {
                if (pqGetErrorNotice3(conn, false /* treat as notice */ ))
                    return;
            }
            else if (id == PqMsg_ParameterStatus)
            {
                if (getParameterStatus(conn))
                    return;
            }
            else
            {
                /* Any other case is unexpected and we summarily skip it */
                pqInternalNotice(&conn->noticeHooks,
                                 "message type 0x%02x arrived from server while idle",
                                 id);
                /* Discard the unexpected message */
                conn->inCursor += msgLength;
            }
        }
        else
        {
            /*
             * In BUSY state, we can process everything.
             */
            switch (id)
            {
                case PqMsg_CommandComplete:
                    if (pqGets(&conn->workBuffer, conn))
                        return;
                    if (!pgHavePendingResult(conn))
                    {
                        conn->result = PQmakeEmptyPGresult(conn,
                                                           PGRES_COMMAND_OK);
                        if (!conn->result)
                        {
                            libpq_append_conn_error(conn, "out of memory");
                            pqSaveErrorResult(conn);
                        }
                    }
                    if (conn->result)
                        strlcpy(conn->result->cmdStatus, conn->workBuffer.data,
                                CMDSTATUS_LEN);
                    conn->asyncStatus = PGASYNC_READY;
                    break;
                case PqMsg_ErrorResponse:
                    if (pqGetErrorNotice3(conn, true))
                        return;
                    conn->asyncStatus = PGASYNC_READY;
                    break;
                case PqMsg_ReadyForQuery:
                    if (getReadyForQuery(conn))
                        return;
                    if (conn->pipelineStatus != PQ_PIPELINE_OFF)
                    {
                        conn->result = PQmakeEmptyPGresult(conn,
                                                           PGRES_PIPELINE_SYNC);
                        if (!conn->result)
                        {
                            libpq_append_conn_error(conn, "out of memory");
                            pqSaveErrorResult(conn);
                        }
                        else
                        {
                            conn->pipelineStatus = PQ_PIPELINE_ON;
                            conn->asyncStatus = PGASYNC_READY;
                        }
                    }
                    else
                    {
                        /* Advance the command queue and set us idle */
                        pqCommandQueueAdvance(conn, true, false);
                        conn->asyncStatus = PGASYNC_IDLE;
                    }
                    break;
                case PqMsg_EmptyQueryResponse:
                    if (!pgHavePendingResult(conn))
                    {
                        conn->result = PQmakeEmptyPGresult(conn,
                                                           PGRES_EMPTY_QUERY);
                        if (!conn->result)
                        {
                            libpq_append_conn_error(conn, "out of memory");
                            pqSaveErrorResult(conn);
                        }
                    }
                    conn->asyncStatus = PGASYNC_READY;
                    break;
                case PqMsg_ParseComplete:
                    /* If we're doing PQprepare, we're done; else ignore */
                    if (conn->cmd_queue_head &&
                        conn->cmd_queue_head->queryclass == PGQUERY_PREPARE)
                    {
                        if (!pgHavePendingResult(conn))
                        {
                            conn->result = PQmakeEmptyPGresult(conn,
                                                               PGRES_COMMAND_OK);
                            if (!conn->result)
                            {
                                libpq_append_conn_error(conn, "out of memory");
                                pqSaveErrorResult(conn);
                            }
                        }
                        conn->asyncStatus = PGASYNC_READY;
                    }
                    break;
                case PqMsg_BindComplete:
                    /* Nothing to do for this message type */
                    break;
                case PqMsg_CloseComplete:
                    /* If we're doing PQsendClose, we're done; else ignore */
                    if (conn->cmd_queue_head &&
                        conn->cmd_queue_head->queryclass == PGQUERY_CLOSE)
                    {
                        if (!pgHavePendingResult(conn))
                        {
                            conn->result = PQmakeEmptyPGresult(conn,
                                                               PGRES_COMMAND_OK);
                            if (!conn->result)
                            {
                                libpq_append_conn_error(conn, "out of memory");
                                pqSaveErrorResult(conn);
                            }
                        }
                        conn->asyncStatus = PGASYNC_READY;
                    }
                    break;
                case PqMsg_ParameterStatus:
                    if (getParameterStatus(conn))
                        return;
                    break;
                case PqMsg_BackendKeyData:
 
                    /*
                     * 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 PqMsg_RowDescription:
                    if (conn->error_result ||
                        (conn->result != NULL &&
                         conn->result->resultStatus == PGRES_FATAL_ERROR))
                    {
                        /*
                         * We've already choked for some reason.  Just discard
                         * the data till we get to the end of the query.
                         */
                        conn->inCursor += msgLength;
                    }
                    else if (conn->result == NULL ||
                             (conn->cmd_queue_head &&
                              conn->cmd_queue_head->queryclass == PGQUERY_DESCRIBE))
                    {
                        /* First 'T' in a query sequence */
                        if (getRowDescriptions(conn, msgLength))
                            return;
                    }
                    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 PqMsg_NoData:
 
                    /*
                     * NoData indicates that we will not be seeing a
                     * RowDescription message because the statement or portal
                     * inquired about doesn't return rows.
                     *
                     * If we're doing a Describe, we have to pass something
                     * back to the client, so set up a COMMAND_OK result,
                     * instead of PGRES_TUPLES_OK.  Otherwise we can just
                     * ignore this message.
                     */
                    if (conn->cmd_queue_head &&
                        conn->cmd_queue_head->queryclass == PGQUERY_DESCRIBE)
                    {
                        if (!pgHavePendingResult(conn))
                        {
                            conn->result = PQmakeEmptyPGresult(conn,
                                                               PGRES_COMMAND_OK);
                            if (!conn->result)
                            {
                                libpq_append_conn_error(conn, "out of memory");
                                pqSaveErrorResult(conn);
                            }
                        }
                        conn->asyncStatus = PGASYNC_READY;
                    }
                    break;
                case PqMsg_ParameterDescription:
                    if (getParamDescriptions(conn, msgLength))
                        return;
                    break;
                case PqMsg_DataRow:
                    if (conn->result != NULL &&
                        (conn->result->resultStatus == PGRES_TUPLES_OK ||
                         conn->result->resultStatus == PGRES_TUPLES_CHUNK))
                    {
                        /* Read another tuple of a normal query response */
                        if (getAnotherTuple(conn, msgLength))
                            return;
                    }
                    else if (conn->error_result ||
                             (conn->result != NULL &&
                              conn->result->resultStatus == PGRES_FATAL_ERROR))
                    {
                        /*
                         * We've already choked for some reason.  Just discard
                         * tuples till we get to the end of the query.
                         */
                        conn->inCursor += msgLength;
                    }
                    else
                    {
                        /* Set up to report error at end of query */
                        libpq_append_conn_error(conn, "server sent data (\"D\" message) without prior row description (\"T\" message)");
                        pqSaveErrorResult(conn);
                        /* Discard the unexpected message */
                        conn->inCursor += msgLength;
                    }
                    break;
                case PqMsg_CopyInResponse:
                    if (getCopyStart(conn, PGRES_COPY_IN))
                        return;
                    conn->asyncStatus = PGASYNC_COPY_IN;
                    break;
                case PqMsg_CopyOutResponse:
                    if (getCopyStart(conn, PGRES_COPY_OUT))
                        return;
                    conn->asyncStatus = PGASYNC_COPY_OUT;
                    conn->copy_already_done = 0;
                    break;
                case PqMsg_CopyBothResponse:
                    if (getCopyStart(conn, PGRES_COPY_BOTH))
                        return;
                    conn->asyncStatus = PGASYNC_COPY_BOTH;
                    conn->copy_already_done = 0;
                    break;
                case PqMsg_CopyData:
 
                    /*
                     * If we see Copy Data, just silently drop it.  This would
                     * only occur if application exits COPY OUT mode too
                     * early.
                     */
                    conn->inCursor += msgLength;
                    break;
                case PqMsg_CopyDone:
 
                    /*
                     * If we see Copy Done, just silently drop it.  This is
                     * the normal case during PQendcopy.  We will keep
                     * swallowing data, expecting to see command-complete for
                     * the COPY command.
                     */
                    break;
                default:
                    libpq_append_conn_error(conn, "unexpected response from server; first received character was \"%c\"", id);
                    /* build an error result holding the error message */
                    pqSaveErrorResult(conn);
                    /* not sure if we will see more, so go to ready state */
                    conn->asyncStatus = PGASYNC_READY;
                    /* Discard the unexpected message */
                    conn->inCursor += msgLength;
                    break;
            }                   /* switch on protocol character */
        }
        /* Successfully consumed this message */
        if (conn->inCursor == conn->inStart + 5 + msgLength)
        {
            /* Normal case: parsing agrees with specified length */
            pqParseDone(conn, conn->inCursor);
        }
        else
        {
            /* Trouble --- report it */
            libpq_append_conn_error(conn, "message contents do not agree with length in message type \"%c\"", id);
            /* build an error result holding the error message */
            pqSaveErrorResult(conn);
            conn->asyncStatus = PGASYNC_READY;
            /* trust the specified message length as what to skip */
            conn->inStart += 5 + msgLength;
        }
    }
}

References pg_conn::asyncStatus, pg_conn::be_key, pg_conn::be_pid, pg_conn::cmd_queue_head, pg_result::cmdStatus, CMDSTATUS_LEN, conn, pg_conn::copy_already_done, PQExpBufferData::data, pg_conn::error_result, getAnotherTuple(), getCopyStart(), getNotify(), getParamDescriptions(), getParameterStatus(), getReadyForQuery(), getRowDescriptions(), handleSyncLoss(), pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, libpq_append_conn_error(), pg_conn::noticeHooks, PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_READY, pgHavePendingResult, PGQUERY_CLOSE, PGQUERY_DESCRIBE, PGQUERY_PREPARE, PGRES_COMMAND_OK, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_EMPTY_QUERY, PGRES_FATAL_ERROR, PGRES_PIPELINE_SYNC, PGRES_TUPLES_CHUNK, PGRES_TUPLES_OK, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PQ_PIPELINE_ON, pqCheckInBufferSpace(), pqCommandQueueAdvance(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGets(), pqInternalNotice(), PQmakeEmptyPGresult(), PqMsg_BackendKeyData, PqMsg_BindComplete, PqMsg_CloseComplete, PqMsg_CommandComplete, PqMsg_CopyBothResponse, PqMsg_CopyData, PqMsg_CopyDone, PqMsg_CopyInResponse, PqMsg_CopyOutResponse, PqMsg_DataRow, PqMsg_EmptyQueryResponse, PqMsg_ErrorResponse, PqMsg_NoData, PqMsg_NoticeResponse, PqMsg_NotificationResponse, PqMsg_ParameterDescription, PqMsg_ParameterStatus, PqMsg_ParseComplete, PqMsg_ReadyForQuery, PqMsg_RowDescription, pqParseDone(), pqSaveErrorResult(), PGcmdQueueEntry::queryclass, pg_conn::result, pg_result::resultStatus, strlcpy(), VALID_LONG_MESSAGE_TYPE, and pg_conn::workBuffer.

Referenced by parseInput().

pqParseIntParam()

bool pqParseIntParam	(	const char *	value,
		int *	result,
		PGconn *	conn,
		const char *	context
	)

Definition at line 7738 of file fe-connect.c.

{
    char       *end;
    long        numval;
 
    Assert(value != NULL);
 
    *result = 0;
 
    /* strtol(3) skips leading whitespaces */
    errno = 0;
    numval = strtol(value, &end, 10);
 
    /*
     * If no progress was done during the parsing or an error happened, fail.
     * This tests properly for overflows of the result.
     */
    if (value == end || errno != 0 || numval != (int) numval)
        goto error;
 
    /*
     * Skip any trailing whitespace; if anything but whitespace remains before
     * the terminating character, fail
     */
    while (*end != '\0' && isspace((unsigned char) *end))
        end++;
 
    if (*end != '\0')
        goto error;
 
    *result = numval;
    return true;
 
error:
    libpq_append_conn_error(conn, "invalid integer value \"%s\" for connection option \"%s\"",
                            value, context);
    return false;
}

References Assert, conn, context, error(), libpq_append_conn_error(), and value.

Referenced by pqConnectDBComplete(), PQconnectPoll(), PQgetCancel(), setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), setTCPUserTimeout(), and useKeepalives().

pqPrepareAsyncResult()

PGresult* pqPrepareAsyncResult

(

PGconn *

conn

)

Definition at line 851 of file fe-exec.c.

{
    PGresult   *res;
 
    res = conn->result;
    if (res)
    {
        /*
         * If the pre-existing result is an ERROR (presumably something
         * received from the server), assume that it represents whatever is in
         * conn->errorMessage, and advance errorReported.
         */
        if (res->resultStatus == PGRES_FATAL_ERROR)
            conn->errorReported = conn->errorMessage.len;
    }
    else
    {
        /*
         * We get here after internal-to-libpq errors.  We should probably
         * always have error_result = true, but if we don't, gin up some error
         * text.
         */
        if (!conn->error_result)
            libpq_append_conn_error(conn, "no error text available");
 
        /* Paranoia: be sure errorReported offset is sane */
        if (conn->errorReported < 0 ||
            conn->errorReported >= conn->errorMessage.len)
            conn->errorReported = 0;
 
        /*
         * Make a PGresult struct for the error.  We temporarily lie about the
         * result status, so that PQmakeEmptyPGresult doesn't uselessly copy
         * all of conn->errorMessage.
         */
        res = PQmakeEmptyPGresult(conn, PGRES_EMPTY_QUERY);
        if (res)
        {
            /*
             * Report whatever new error text we have, and advance
             * errorReported.
             */
            res->resultStatus = PGRES_FATAL_ERROR;
            pqSetResultError(res, &conn->errorMessage, conn->errorReported);
            conn->errorReported = conn->errorMessage.len;
        }
        else
        {
            /*
             * Ouch, not enough memory for a PGresult.  Fortunately, we have a
             * card up our sleeve: we can use the static OOM_result.  Casting
             * away const here is a bit ugly, but it seems best to declare
             * OOM_result as const, in hopes it will be allocated in read-only
             * storage.
             */
            res = unconstify(PGresult *, &OOM_result);
 
            /*
             * Don't advance errorReported.  Perhaps we'll be able to report
             * the text later.
             */
        }
    }
 
    /*
     * Replace conn->result with saved_result, if any.  In the normal case
     * there isn't a saved result and we're just dropping ownership of the
     * current result.  In partial-result mode this restores the situation to
     * what it was before we created the current partial result.
     */
    conn->result = conn->saved_result;
    conn->error_result = false; /* saved_result is never an error */
    conn->saved_result = NULL;
 
    return res;
}

References conn, pg_conn::error_result, pg_conn::errorMessage, pg_conn::errorReported, PQExpBufferData::len, libpq_append_conn_error(), OOM_result, PGRES_EMPTY_QUERY, PGRES_FATAL_ERROR, PQmakeEmptyPGresult(), pqSetResultError(), res, pg_conn::result, pg_result::resultStatus, pg_conn::saved_result, and unconstify.

Referenced by getCopyResult(), pqFunctionCall3(), and PQgetResult().

pqPutc()

int pqPutc	(	char	c,
		PGconn *	conn
	)

Definition at line 92 of file fe-misc.c.

{
    if (pqPutMsgBytes(&c, 1, conn))
        return EOF;
 
    return 0;
}

References conn, and pqPutMsgBytes().

Referenced by PQsendQueryGuts(), and PQsendTypedCommand().

pqPutInt()

int pqPutInt	(	int	value,
		size_t	bytes,
		PGconn *	conn
	)

Definition at line 253 of file fe-misc.c.

{
    uint16      tmp2;
    uint32      tmp4;
 
    switch (bytes)
    {
        case 2:
            tmp2 = pg_hton16((uint16) value);
            if (pqPutMsgBytes((const char *) &tmp2, 2, conn))
                return EOF;
            break;
        case 4:
            tmp4 = pg_hton32((uint32) value);
            if (pqPutMsgBytes((const char *) &tmp4, 4, conn))
                return EOF;
            break;
        default:
            pqInternalNotice(&conn->noticeHooks,
                             "integer of size %lu not supported by pqPutInt",
                             (unsigned long) bytes);
            return EOF;
    }
 
    return 0;
}

References conn, pg_conn::noticeHooks, pg_hton16, pg_hton32, pqInternalNotice(), pqPutMsgBytes(), and value.

Referenced by pg_SASL_init(), pqFunctionCall3(), PQsendPrepare(), and PQsendQueryGuts().

pqPutMsgEnd()

int pqPutMsgEnd

(

PGconn *

conn

)

Definition at line 532 of file fe-misc.c.

{
    /* Fill in length word if needed */
    if (conn->outMsgStart >= 0)
    {
        uint32      msgLen = conn->outMsgEnd - conn->outMsgStart;
 
        msgLen = pg_hton32(msgLen);
        memcpy(conn->outBuffer + conn->outMsgStart, &msgLen, 4);
    }
 
    /* trace client-to-server message */
    if (conn->Pfdebug)
    {
        if (conn->outCount < conn->outMsgStart)
            pqTraceOutputMessage(conn, conn->outBuffer + conn->outCount, true);
        else
            pqTraceOutputNoTypeByteMessage(conn,
                                           conn->outBuffer + conn->outMsgStart);
    }
 
    /* Make message eligible to send */
    conn->outCount = conn->outMsgEnd;
 
    if (conn->outCount >= 8192)
    {
        int         toSend = conn->outCount - (conn->outCount % 8192);
 
        if (pqSendSome(conn, toSend) < 0)
            return EOF;
        /* in nonblock mode, don't complain if unable to send it all */
    }
 
    return 0;
}

References conn, pg_conn::outBuffer, pg_conn::outCount, pg_conn::outMsgEnd, pg_conn::outMsgStart, pg_conn::Pfdebug, pg_hton32, pqSendSome(), pqTraceOutputMessage(), and pqTraceOutputNoTypeByteMessage().

Referenced by pg_SASL_init(), pqEndcopy3(), pqFunctionCall3(), pqPacketSend(), pqPipelineSyncInternal(), PQputCopyData(), PQputCopyEnd(), PQsendFlushRequest(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), PQsendTypedCommand(), and sendTerminateConn().

pqPutMsgStart()

int pqPutMsgStart	(	char	msg_type,
		PGconn *	conn
	)

Definition at line 473 of file fe-misc.c.

{
    int         lenPos;
    int         endPos;
 
    /* allow room for message type byte */
    if (msg_type)
        endPos = conn->outCount + 1;
    else
        endPos = conn->outCount;
 
    /* do we want a length word? */
    lenPos = endPos;
    /* allow room for message length */
    endPos += 4;
 
    /* make sure there is room for message header */
    if (pqCheckOutBufferSpace(endPos, conn))
        return EOF;
    /* okay, save the message type byte if any */
    if (msg_type)
        conn->outBuffer[conn->outCount] = msg_type;
    /* set up the message pointers */
    conn->outMsgStart = lenPos;
    conn->outMsgEnd = endPos;
    /* length word, if needed, will be filled in by pqPutMsgEnd */
 
    return 0;
}

References conn, pg_conn::outBuffer, pg_conn::outCount, pg_conn::outMsgEnd, pg_conn::outMsgStart, and pqCheckOutBufferSpace().

Referenced by pg_SASL_init(), pqEndcopy3(), pqFunctionCall3(), pqPacketSend(), pqPipelineSyncInternal(), PQputCopyData(), PQputCopyEnd(), PQsendFlushRequest(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), PQsendTypedCommand(), and sendTerminateConn().

pqPutnchar()

int pqPutnchar

(

const char *