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 "libpq/pg-gssapi.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 , 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	PQsendCancelRequest (PGconn *cancelConn)
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 (void *s, size_t len, PGconn *conn)
int	pqSkipnchar (size_t len, PGconn *conn)
int	pqPutnchar (const void *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 335 of file libpq-int.h.

AUTH_RESPONSE_PASSWORD

#define AUTH_RESPONSE_PASSWORD   'P'

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

AUTH_RESPONSE_SASL

#define AUTH_RESPONSE_SASL   'S'

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

AUTH_RESPONSE_SASL_INITIAL

#define AUTH_RESPONSE_SASL_INITIAL   'I'

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

CMDSTATUS_LEN

#define CMDSTATUS_LEN   64 /* should match COMPLETION_TAG_BUFSIZE */

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

ENC_ERROR

#define ENC_ERROR   0

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

ENC_GSSAPI

#define ENC_GSSAPI   0x02

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

ENC_PLAINTEXT

#define ENC_PLAINTEXT   0x01

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

ENC_SSL

#define ENC_SSL   0x04

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

libpq_gettext

#define libpq_gettext

(

x

)

(x)

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

libpq_ngettext

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

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

NULL_LEN

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

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

OUTBUFFER_THRESHOLD

#define OUTBUFFER_THRESHOLD   65536

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

pgHavePendingResult

#define pgHavePendingResult

(

conn

)

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

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

pglock_thread

#define pglock_thread

(

)

pg_g_threadlock(true)

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

pgunlock_thread

#define pgunlock_thread

(

)

pg_g_threadlock(false)

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

pqClearConnErrorState

#define pqClearConnErrorState

(

conn

)

Value:

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

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

pqIsnonblocking

#define pqIsnonblocking

(

conn

)

((conn)->nonblocking)

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

SOCK_ERRNO

#define SOCK_ERRNO   errno

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

SOCK_ERRNO_SET

#define SOCK_ERRNO_SET

(

e

)

(errno = (e))

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

SOCK_STRERROR

#define SOCK_STRERROR   strerror_r

Definition at line 960 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 98 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 307 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 213 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 247 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 318 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 235 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
PG_BOOL_UNKNOWN
PG_BOOL_YES
PG_BOOL_NO

Definition at line 254 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 1498 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 340 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 96 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 118 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 234 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 544 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 240 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 172 of file oauth-utils.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 pg_fe_run_oauth_flow(), and PQprint().

pq_reset_sigpipe()

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

Definition at line 208 of file oauth-utils.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 pg_fe_run_oauth_flow(), and 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(), pg_result::resultStatus, and val.

Referenced by pqGetErrorNotice3(), and PQresultVerboseErrorMessage().

pqBuildStartupPacket3()

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

Definition at line 2313 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 5253 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;
    pqClearOAuthToken(conn);
    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, pqClearOAuthToken(), 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 2781 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 2703 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 1246 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 methods and
         * mechanisms, and add to it.
         */
        conn->auth_required = true;
        conn->allowed_auth_methods = 0;
        clear_allowed_sasl_mechs(conn);
 
        for (first = true, more = true; more; first = false)
        {
            char       *method,
                       *part;
            uint32      bits = 0;
            const pg_fe_sasl_mech *mech = NULL;
 
            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 methods and
                     * mechanisms, and subtract from it.
                     */
                    conn->auth_required = false;
                    conn->allowed_auth_methods = -1;
                    fill_allowed_sasl_mechs(conn);
                }
                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;
            }
 
            /*
             * First group: methods that can be handled solely with the
             * authentication request codes.
             */
            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);
            }
 
            /*
             * Next group: SASL mechanisms. All of these use the same request
             * codes, so the list of allowed mechanisms is tracked separately.
             *
             * supported_sasl_mechs must contain all mechanisms handled here.
             */
            else if (strcmp(method, "scram-sha-256") == 0)
            {
                mech = &pg_scram_mech;
            }
            else if (strcmp(method, "oauth") == 0)
            {
                mech = &pg_oauth_mech;
            }
 
            /*
             * Final group: meta-options.
             */
            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;
            }
 
            if (mech)
            {
                /*
                 * Update the mechanism set only. The method bitmask will be
                 * updated for SASL further down.
                 */
                Assert(!bits);
 
                if (negated)
                {
                    /* Remove the existing mechanism from the list. */
                    i = index_of_allowed_sasl_mech(conn, mech);
                    if (i < 0)
                        goto duplicate;
 
                    conn->allowed_sasl_mechs[i] = NULL;
                }
                else
                {
                    /*
                     * Find a space to put the new mechanism (after making
                     * sure it's not already there).
                     */
                    i = index_of_allowed_sasl_mech(conn, mech);
                    if (i >= 0)
                        goto duplicate;
 
                    i = index_of_allowed_sasl_mech(conn, NULL);
                    if (i < 0)
                    {
                        /* Should not happen; the pointer list is corrupted. */
                        Assert(false);
 
                        conn->status = CONNECTION_BAD;
                        libpq_append_conn_error(conn,
                                                "internal error: no space in allowed_sasl_mechs");
                        free(part);
                        return false;
                    }
 
                    conn->allowed_sasl_mechs[i] = mech;
                }
            }
            else
            {
                /* Update the method bitmask. */
                Assert(bits);
 
                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;
        }
 
        /*
         * Finally, allow SASL authentication requests if (and only if) we've
         * allowed any mechanisms.
         */
        {
            bool        allowed = false;
            const uint32 sasl_bits =
                (1 << AUTH_REQ_SASL)
                | (1 << AUTH_REQ_SASL_CONT)
                | (1 << AUTH_REQ_SASL_FIN);
 
            for (i = 0; i < lengthof(conn->allowed_sasl_mechs); i++)
            {
                if (conn->allowed_sasl_mechs[i])
                {
                    allowed = true;
                    break;
                }
            }
 
            /*
             * For the standard case, add the SASL bits to the (default-empty)
             * set if needed. For the negated case, remove them.
             */
            if (!negated && allowed)
                conn->allowed_auth_methods |= sasl_bits;
            else if (negated && !allowed)
                conn->allowed_auth_methods &= ~sasl_bits;
        }
    }
 
    /*
     * 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
         * 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;
 
    if (conn->scram_client_key)
    {
        int         len;
 
        len = pg_b64_dec_len(strlen(conn->scram_client_key));
        conn->scram_client_key_binary = malloc(len);
        if (!conn->scram_client_key_binary)
            goto oom_error;
        len = pg_b64_decode(conn->scram_client_key, strlen(conn->scram_client_key),
                            conn->scram_client_key_binary, len);
        if (len < 0)
        {
            libpq_append_conn_error(conn, "invalid SCRAM client key");
            return false;
        }
        if (len != SCRAM_MAX_KEY_LEN)
        {
            libpq_append_conn_error(conn, "invalid SCRAM client key length: %d", len);
            return false;
        }
        conn->scram_client_key_len = len;
    }
 
    if (conn->scram_server_key)
    {
        int         len;
 
        len = pg_b64_dec_len(strlen(conn->scram_server_key));
        conn->scram_server_key_binary = malloc(len);
        if (!conn->scram_server_key_binary)
            goto oom_error;
        len = pg_b64_decode(conn->scram_server_key, strlen(conn->scram_server_key),
                            conn->scram_server_key_binary, len);
        if (len < 0)
        {
            libpq_append_conn_error(conn, "invalid SCRAM server key");
            return false;
        }
        if (len != SCRAM_MAX_KEY_LEN)
        {
            libpq_append_conn_error(conn, "invalid SCRAM server key length: %d", len);
            return false;
        }
        conn->scram_server_key_len = len;
    }
 
    /*
     * 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;
        }
    }
 
    if (conn->min_protocol_version)
    {
        if (!pqParseProtocolVersion(conn->min_protocol_version, &conn->min_pversion, conn, "min_protocol_version"))
        {
            conn->status = CONNECTION_BAD;
            return false;
        }
    }
    else
    {
        conn->min_pversion = PG_PROTOCOL_EARLIEST;
    }
 
    if (conn->max_protocol_version)
    {
        if (!pqParseProtocolVersion(conn->max_protocol_version, &conn->max_pversion, conn, "max_protocol_version"))
        {
            conn->status = CONNECTION_BAD;
            return false;
        }
    }
    else
    {
        /*
         * To not break connecting to older servers/poolers that do not yet
         * support NegotiateProtocolVersion, default to the 3.0 protocol at
         * least for a while longer. Except when min_protocol_version is set
         * to something larger, then we might as well default to the latest.
         */
        if (conn->min_pversion > PG_PROTOCOL(3, 0))
            conn->max_pversion = PG_PROTOCOL_LATEST;
        else
            conn->max_pversion = PG_PROTOCOL(3, 0);
    }
 
    if (conn->min_pversion > conn->max_pversion)
    {
        conn->status = CONNECTION_BAD;
        libpq_append_conn_error(conn, "min_protocol_version is greater than max_protocol_version");
        return false;
    }
 
    /*
     * 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, pg_conn::allowed_sasl_mechs, 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, clear_allowed_sasl_mechs(), 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, fill_allowed_sasl_mechs(), free, pg_conn::gssencmode, pg_conn_host::host, pg_conn_host::hostaddr, i, index_of_allowed_sasl_mech(), is_unixsock_path(), j, len, lengthof, libpq_append_conn_error(), libpq_prng_init(), LOAD_BALANCE_DISABLE, pg_conn::load_balance_hosts, LOAD_BALANCE_RANDOM, pg_conn::load_balance_type, malloc, pg_conn::max_protocol_version, pg_conn::max_pversion, MAXPGPATH, pg_conn::min_protocol_version, pg_conn::min_pversion, pg_conn::nconnhost, pg_conn::options_valid, parse_comma_separated_list(), pg_conn_host::password, passwordFromFile(), pg_b64_dec_len(), pg_b64_decode(), pg_encoding_to_char, pg_fe_getauthname(), pg_get_encoding_from_locale(), pg_oauth_mech, pg_prng_uint64_range(), PG_PROTOCOL, PG_PROTOCOL_EARLIEST, PG_PROTOCOL_LATEST, pg_scram_mech, pg_conn::pghost, pg_conn::pghostaddr, pg_conn::pgpass, PGPASSFILE, pg_conn::pgpassfile, pg_conn::pgport, pg_conn::pguser, pg_conn_host::port, pqGetHomeDirectory(), pqParseProtocolVersion(), pg_conn::prng_state, pg_conn::require_auth, pg_conn::scram_client_key, pg_conn::scram_client_key_binary, pg_conn::scram_client_key_len, SCRAM_MAX_KEY_LEN, pg_conn::scram_server_key, pg_conn::scram_server_key_binary, pg_conn::scram_server_key_len, 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 1031 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 526 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 */
    if (conn->cleanup_async_auth)
    {
        /*
         * Any in-progress async authentication should be torn down first so
         * that cleanup_async_auth() can depend on the other authentication
         * state if necessary.
         */
        conn->cleanup_async_auth(conn);
        conn->cleanup_async_auth = NULL;
    }
    conn->async_auth = NULL;
    /* cleanup_async_auth() should have done this, but make sure */
    conn->altsock = PGINVALID_SOCKET;
#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 pg_conn::altsock, pg_conn::async_auth, pg_conn::cleanup_async_auth, 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 1990 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, 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(), PQsendCancelRequest(), 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 2083 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(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(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 1825 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, 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 8146 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(), getBackendKeyData(), getCopyDataMessage(), getCopyStart(), getNotify(), getParamDescriptions(), getRowDescriptions(), PQconnectPoll(), pqFunctionCall3(), pqGetNegotiateProtocolVersion3(), and pqParseInput3().

pqGetline3()

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

Definition at line 1884 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 1935 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	(	void *	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 getBackendKeyData(), pg_password_sendauth(), pg_SASL_continue(), and pqFunctionCall3().

pqGetNegotiateProtocolVersion3()

int pqGetNegotiateProtocolVersion3

(

PGconn *

conn

)

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

{
    int         their_version;
    int         num;
 
    if (pqGetInt(&their_version, 4, conn) != 0)
        goto eof;
 
    if (pqGetInt(&num, 4, conn) != 0)
        goto eof;
 
    /* Check the protocol version */
    if (their_version > conn->pversion)
    {
        libpq_append_conn_error(conn, "received invalid protocol negotiation message: server requested downgrade to a higher-numbered version");
        goto failure;
    }
 
    if (their_version < PG_PROTOCOL(3, 0))
    {
        libpq_append_conn_error(conn, "received invalid protocol negotiation message: server requested downgrade to pre-3.0 protocol version");
        goto failure;
    }
 
    /* 3.1 never existed, we went straight from 3.0 to 3.2 */
    if (their_version == PG_PROTOCOL(3, 1))
    {
        libpq_append_conn_error(conn, "received invalid protocol negotiation message: server requests downgrade to non-existent 3.1 protocol version");
        goto failure;
    }
 
    if (num < 0)
    {
        libpq_append_conn_error(conn, "received invalid protocol negotiation message: server reported negative number of unsupported parameters");
        goto failure;
    }
 
    if (their_version == conn->pversion && num == 0)
    {
        libpq_append_conn_error(conn, "received invalid protocol negotiation message: server negotiated but asks for no changes");
        goto failure;
    }
 
    if (their_version < conn->min_pversion)
    {
        libpq_append_conn_error(conn, "server only supports protocol version %d.%d, but min_protocol_version was set to %d.%d",
                                PG_PROTOCOL_MAJOR(their_version),
                                PG_PROTOCOL_MINOR(their_version),
                                PG_PROTOCOL_MAJOR(conn->min_pversion),
                                PG_PROTOCOL_MINOR(conn->min_pversion));
 
        goto failure;
    }
 
    /* the version is acceptable */
    conn->pversion = their_version;
 
    /*
     * We don't currently request any protocol extensions, so we don't expect
     * the server to reply with any either.
     */
    for (int i = 0; i < num; i++)
    {
        if (pqGets(&conn->workBuffer, conn))
        {
            goto eof;
        }
        if (strncmp(conn->workBuffer.data, "_pq_.", 5) != 0)
        {
            libpq_append_conn_error(conn, "received invalid protocol negotiation message: server reported unsupported parameter name without a _pq_. prefix (\"%s\")", conn->workBuffer.data);
            goto failure;
        }
        libpq_append_conn_error(conn, "received invalid protocol negotiation message: server reported an unsupported parameter that was not requested (\"%s\")", conn->workBuffer.data);
        goto failure;
    }
 
    return 0;
 
eof:
    libpq_append_conn_error(conn, "received invalid protocol negotiation message: message too short");
failure:
    conn->asyncStatus = PGASYNC_READY;
    pqSaveErrorResult(conn);
    return 1;
}

References pg_conn::asyncStatus, conn, PQExpBufferData::data, i, libpq_append_conn_error(), pg_conn::min_pversion, PG_PROTOCOL, PG_PROTOCOL_MAJOR, PG_PROTOCOL_MINOR, PGASYNC_READY, pqGetInt(), pqGets(), pqSaveErrorResult(), pg_conn::pversion, 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 4939 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->altsock = 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::altsock, 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 5408 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 67 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 (getBackendKeyData(conn, msgLength))
                        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::cmd_queue_head, pg_result::cmdStatus, CMDSTATUS_LEN, conn, pg_conn::copy_already_done, PQExpBufferData::data, pg_conn::error_result, getAnotherTuple(), getBackendKeyData(), 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 8187 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, 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(), 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(), PQsendCancelRequest(), 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(), PQsendCancelRequest(), PQsendFlushRequest(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), PQsendTypedCommand(), and sendTerminateConn().

pqPutnchar()

int pqPutnchar	(	const void *	s,
		size_t	len,
		PGconn *	conn
	)

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

{
    if (pqPutMsgBytes(s, len, conn))
        return EOF;
 
    return 0;
}

References conn, len, and pqPutMsgBytes().

Referenced by pg_SASL_init(), pqFunctionCall3(), pqPacketSend(), PQputCopyData(), PQsendCancelRequest(), and PQsendQueryGuts().

pqPuts()

int pqPuts	(	const char *	s,
		PGconn *	conn
	)

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

{
    if (pqPutMsgBytes(s, strlen(s) + 1, conn))
        return EOF;
 
    return 0;
}

References conn, and pqPutMsgBytes().

Referenced by pg_SASL_init(), PQputCopyEnd(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and PQsendTypedCommand().

pqReadData()

int pqReadData

(

PGconn *

conn

)

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

{
    int         someread = 0;
    int         nread;
 
    if (conn->sock == PGINVALID_SOCKET)
    {
        libpq_append_conn_error(conn, "connection not open");
        return -1;
    }
 
    /* Left-justify any data in the buffer to make room */
    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;
    }
 
    /*
     * If the buffer is fairly full, enlarge it. We need to be able to enlarge
     * the buffer in case a single message exceeds the initial buffer size. We
     * enlarge before filling the buffer entirely so as to avoid asking the
     * kernel for a partial packet. The magic constant here should be large
     * enough for a TCP packet or Unix pipe bufferload.  8K is the usual pipe
     * buffer size, so...
     */
    if (conn->inBufSize - conn->inEnd < 8192)
    {
        if (pqCheckInBufferSpace(conn->inEnd + (size_t) 8192, conn))
        {
            /*
             * We don't insist that the enlarge worked, but we need some room
             */
            if (conn->inBufSize - conn->inEnd < 100)
                return -1;      /* errorMessage already set */
        }
    }
 
    /* OK, try to read some data */
retry3:
    nread = pqsecure_read(conn, conn->inBuffer + conn->inEnd,
                          conn->inBufSize - conn->inEnd);
    if (nread < 0)
    {
        switch (SOCK_ERRNO)
        {
            case EINTR:
                goto retry3;
 
                /* Some systems return EAGAIN/EWOULDBLOCK for no data */
#ifdef EAGAIN
            case EAGAIN:
                return someread;
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
            case EWOULDBLOCK:
                return someread;
#endif
 
                /* We might get ECONNRESET etc here if connection failed */
            case ALL_CONNECTION_FAILURE_ERRNOS:
                goto definitelyFailed;
 
            default:
                /* pqsecure_read set the error message for us */
                return -1;
        }
    }
    if (nread > 0)
    {
        conn->inEnd += nread;
 
        /*
         * Hack to deal with the fact that some kernels will only give us back
         * 1 packet per recv() call, even if we asked for more and there is
         * more available.  If it looks like we are reading a long message,
         * loop back to recv() again immediately, until we run out of data or
         * buffer space.  Without this, the block-and-restart behavior of
         * libpq's higher levels leads to O(N^2) performance on long messages.
         *
         * Since we left-justified the data above, conn->inEnd gives the
         * amount of data already read in the current message.  We consider
         * the message "long" once we have acquired 32k ...
         */
        if (conn->inEnd > 32768 &&
            (conn->inBufSize - conn->inEnd) >= 8192)
        {
            someread = 1;
            goto retry3;
        }
        return 1;
    }
 
    if (someread)
        return 1;               /* got a zero read after successful tries */
 
    /*
     * A return value of 0 could mean just that no data is now available, or
     * it could mean EOF --- that is, the server has closed the connection.
     * Since we have the socket in nonblock mode, the only way to tell the
     * difference is to see if select() is saying that the file is ready.
     * Grumble.  Fortunately, we don't expect this path to be taken much,
     * since in normal practice we should not be trying to read data unless
     * the file selected for reading already.
     *
     * In SSL mode it's even worse: SSL_read() could say WANT_READ and then
     * data could arrive before we make the pqReadReady() test, but the second
     * SSL_read() could still say WANT_READ because the data received was not
     * a complete SSL record.  So we must play dumb and assume there is more
     * data, relying on the SSL layer to detect true EOF.
     */
 
#ifdef USE_SSL
    if (conn->ssl_in_use)
        return 0;
#endif
 
    switch (pqReadReady(conn))
    {
        case 0:
            /* definitely no data available */
            return 0;
        case 1:
            /* ready for read */
            break;
        default:
            /* we override pqReadReady's message with something more useful */
            goto definitelyEOF;
    }
 
    /*
     * Still not sure that it's EOF, because some data could have just
     * arrived.
     */
retry4:
    nread = pqsecure_read(conn, conn->inBuffer + conn->inEnd,
                          conn->inBufSize - conn->inEnd);
    if (nread < 0)
    {
        switch (SOCK_ERRNO)
        {
            case EINTR:
                goto retry4;
 
                /* Some systems return EAGAIN/EWOULDBLOCK for no data */
#ifdef EAGAIN
            case EAGAIN:
                return 0;
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
            case EWOULDBLOCK:
                return 0;
#endif
 
                /* We might get ECONNRESET etc here if connection failed */
            case ALL_CONNECTION_FAILURE_ERRNOS:
                goto definitelyFailed;
 
            default:
                /* pqsecure_read set the error message for us */
                return -1;
        }
    }
    if (nread > 0)
    {
        conn->inEnd += nread;
        return 1;
    }
 
    /*
     * OK, we are getting a zero read even though select() says ready. This
     * means the connection has been closed.  Cope.
     */
definitelyEOF:
    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.");
 
    /* Come here if lower-level code already set a suitable errorMessage */
definitelyFailed:
    /* Do *not* drop any already-read data; caller still wants it */
    pqDropConnection(conn, false);
    conn->status = CONNECTION_BAD;  /* No more connection to backend */
    return -1;
}

References ALL_CONNECTION_FAILURE_ERRNOS, conn, CONNECTION_BAD, EAGAIN, EINTR, EWOULDBLOCK, pg_conn::inBuffer, pg_conn::inBufSize, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, libpq_append_conn_error(), PGINVALID_SOCKET, pqCheckInBufferSpace(), pqDropConnection(), pqReadReady(), pqsecure_read(), pg_conn::sock, SOCK_ERRNO, pg_conn::ssl_in_use, and pg_conn::status.

Referenced by PQcancelPoll(), PQconnectPoll(), PQconsumeInput(), pqFunctionCall3(), pqGetCopyData3(), pqGetline3(), PQgetResult(), and pqSendSome().

pqReadReady()

int pqReadReady

(

PGconn *

conn

)

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

{
    return pqSocketCheck(conn, 1, 0, 0);
}

References conn, and pqSocketCheck().

Referenced by gss_read(), and pqReadData().

pqReleaseConnHosts()

void pqReleaseConnHosts

(

PGconn *

conn

)

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

{
    if (conn->connhost)
    {
        for (int i = 0; i < conn->nconnhost; ++i)
        {
            free(conn->connhost[i].host);
            free(conn->connhost[i].hostaddr);
            free(conn->connhost[i].port);
            if (conn->connhost[i].password != NULL)
            {
                explicit_bzero(conn->connhost[i].password,
                               strlen(conn->connhost[i].password));
                free(conn->connhost[i].password);
            }
        }
        free(conn->connhost);
        conn->connhost = NULL;
    }
}

References conn, pg_conn::connhost, explicit_bzero(), free, pg_conn_host::host, pg_conn_host::hostaddr, i, pg_conn::nconnhost, pg_conn_host::password, and pg_conn_host::port.

Referenced by freePGconn(), and PQcancelCreate().

pqResultAlloc()

void * pqResultAlloc	(	PGresult *	res,
		size_t	nBytes,
		bool	isBinary
	)

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

{
    char       *space;
    PGresult_data *block;
 
    if (!res)
        return NULL;
 
    if (nBytes <= 0)
        return res->null_field;
 
    /*
     * If alignment is needed, round up the current position to an alignment
     * boundary.
     */
    if (isBinary)
    {
        int         offset = res->curOffset % PGRESULT_ALIGN_BOUNDARY;
 
        if (offset)
        {
            res->curOffset += PGRESULT_ALIGN_BOUNDARY - offset;
            res->spaceLeft -= PGRESULT_ALIGN_BOUNDARY - offset;
        }
    }
 
    /* If there's enough space in the current block, no problem. */
    if (nBytes <= (size_t) res->spaceLeft)
    {
        space = res->curBlock->space + res->curOffset;
        res->curOffset += nBytes;
        res->spaceLeft -= nBytes;
        return space;
    }
 
    /*
     * If the requested object is very large, give it its own block; this
     * avoids wasting what might be most of the current block to start a new
     * block.  (We'd have to special-case requests bigger than the block size
     * anyway.)  The object is always given binary alignment in this case.
     */
    if (nBytes >= PGRESULT_SEP_ALLOC_THRESHOLD)
    {
        size_t      alloc_size = nBytes + PGRESULT_BLOCK_OVERHEAD;
 
        block = (PGresult_data *) malloc(alloc_size);
        if (!block)
            return NULL;
        res->memorySize += alloc_size;
        space = block->space + PGRESULT_BLOCK_OVERHEAD;
        if (res->curBlock)
        {
            /*
             * Tuck special block below the active block, so that we don't
             * have to waste the free space in the active block.
             */
            block->next = res->curBlock->next;
            res->curBlock->next = block;
        }
        else
        {
            /* Must set up the new block as the first active block. */
            block->next = NULL;
            res->curBlock = block;
            res->spaceLeft = 0; /* be sure it's marked full */
        }
        return space;
    }
 
    /* Otherwise, start a new block. */
    block = (PGresult_data *) malloc(PGRESULT_DATA_BLOCKSIZE);
    if (!block)
        return NULL;
    res->memorySize += PGRESULT_DATA_BLOCKSIZE;
    block->next = res->curBlock;
    res->curBlock = block;
    if (isBinary)
    {
        /* object needs full alignment */
        res->curOffset = PGRESULT_BLOCK_OVERHEAD;
        res->spaceLeft = PGRESULT_DATA_BLOCKSIZE - PGRESULT_BLOCK_OVERHEAD;
    }
    else
    {
        /* we can cram it right after the overhead pointer */
        res->curOffset = sizeof(PGresult_data);
        res->spaceLeft = PGRESULT_DATA_BLOCKSIZE - sizeof(PGresult_data);
    }
 
    space = block->space + res->curOffset;
    res->curOffset += nBytes;
    res->spaceLeft -= nBytes;
    return space;
}

References pg_result::curBlock, pg_result::curOffset, malloc, pg_result::memorySize, pgresult_data::next, pg_result::null_field, PGRESULT_ALIGN_BOUNDARY, PGRESULT_BLOCK_OVERHEAD, PGRESULT_DATA_BLOCKSIZE, PGRESULT_SEP_ALLOC_THRESHOLD, pgresult_data::space, and pg_result::spaceLeft.

Referenced by getCopyStart(), getParamDescriptions(), getRowDescriptions(), pqInternalNotice(), PQresultAlloc(), pqResultStrdup(), pqRowProcessor(), pqSaveMessageField(), and PQsetvalue().

pqResultStrdup()

char * pqResultStrdup	(	PGresult *	res,
		const char *	str
	)

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

{
    char       *space = (char *) pqResultAlloc(res, strlen(str) + 1, false);
 
    if (space)
        strcpy(space, str);
    return space;
}

References pqResultAlloc(), and str.

Referenced by getRowDescriptions(), pqGetErrorNotice3(), PQsetResultAttrs(), and pqSetResultError().

pqRowProcessor()

int pqRowProcessor	(	PGconn *	conn,
		const char **	errmsgp
	)

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

{
    PGresult   *res = conn->result;
    int         nfields = res->numAttributes;
    const PGdataValue *columns = conn->rowBuf;
    PGresAttValue *tup;
    int         i;
 
    /*
     * In partial-result mode, if we don't already have a partial PGresult
     * then make one by cloning conn->result (which should hold the correct
     * result metadata by now).  Then the original conn->result is moved over
     * to saved_result so that we can re-use it as a reference for future
     * partial results.  The saved result will become active again after
     * pqPrepareAsyncResult() returns the partial result to the application.
     */
    if (conn->partialResMode && conn->saved_result == NULL)
    {
        /* Copy everything that should be in the result at this point */
        res = PQcopyResult(res,
                           PG_COPYRES_ATTRS | PG_COPYRES_EVENTS |
                           PG_COPYRES_NOTICEHOOKS);
        if (!res)
            return 0;
        /* Change result status to appropriate special value */
        res->resultStatus = (conn->singleRowMode ? PGRES_SINGLE_TUPLE : PGRES_TUPLES_CHUNK);
        /* And stash it as the active result */
        conn->saved_result = conn->result;
        conn->result = res;
    }
 
    /*
     * Basically we just allocate space in the PGresult for each field and
     * copy the data over.
     *
     * Note: on malloc failure, we return 0 leaving *errmsgp still NULL, which
     * caller will take to mean "out of memory".  This is preferable to trying
     * to set up such a message here, because evidently there's not enough
     * memory for gettext() to do anything.
     */
    tup = (PGresAttValue *)
        pqResultAlloc(res, nfields * sizeof(PGresAttValue), true);
    if (tup == NULL)
        return 0;
 
    for (i = 0; i < nfields; i++)
    {
        int         clen = columns[i].len;
 
        if (clen < 0)
        {
            /* null field */
            tup[i].len = NULL_LEN;
            tup[i].value = res->null_field;
        }
        else
        {
            bool        isbinary = (res->attDescs[i].format != 0);
            char       *val;
 
            val = (char *) pqResultAlloc(res, clen + 1, isbinary);
            if (val == NULL)
                return 0;
 
            /* copy and zero-terminate the data (even if it's binary) */
            memcpy(val, columns[i].value, clen);
            val[clen] = '\0';
 
            tup[i].len = clen;
            tup[i].value = val;
        }
    }
 
    /* And add the tuple to the PGresult's tuple array */
    if (!pqAddTuple(res, tup, errmsgp))
        return 0;
 
    /*
     * Success.  In partial-result mode, if we have enough rows then make the
     * result available to the client immediately.
     */
    if (conn->partialResMode && res->ntups >= conn->maxChunkSize)
        conn->asyncStatus = PGASYNC_READY_MORE;
 
    return 1;
}

References pg_conn::asyncStatus, pg_result::attDescs, conn, pgresAttDesc::format, i, pgresAttValue::len, pgDataValue::len, pg_conn::maxChunkSize, pg_result::ntups, pg_result::null_field, NULL_LEN, pg_result::numAttributes, pg_conn::partialResMode, PG_COPYRES_ATTRS, PG_COPYRES_EVENTS, PG_COPYRES_NOTICEHOOKS, PGASYNC_READY_MORE, PGRES_SINGLE_TUPLE, PGRES_TUPLES_CHUNK, pqAddTuple(), PQcopyResult(), pqResultAlloc(), pg_conn::result, pg_result::resultStatus, pg_conn::rowBuf, pg_conn::saved_result, pg_conn::singleRowMode, val, value, and pgresAttValue::value.

Referenced by getAnotherTuple().

pqSaveErrorResult()

void pqSaveErrorResult

(

PGconn *

conn

)

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

{
    /* Drop any pending result ... */
    pqClearAsyncResult(conn);
    /* ... and set flag to remember to make an error result later */
    conn->error_result = true;
}

References conn, pg_conn::error_result, and pqClearAsyncResult().

Referenced by getAnotherTuple(), getCopyResult(), getParamDescriptions(), getRowDescriptions(), handleSyncLoss(), pqFunctionCall3(), pqGetNegotiateProtocolVersion3(), PQgetResult(), pqParseInput3(), pqPipelineProcessQueue(), and pqSaveWriteError().

pqSaveMessageField()

void void pqSaveMessageField	(	PGresult *	res,
		char	code,
		const char *	value
	)

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

{
    PGMessageField *pfield;
 
    pfield = (PGMessageField *)
        pqResultAlloc(res,
                      offsetof(PGMessageField, contents) +
                      strlen(value) + 1,
                      true);
    if (!pfield)
        return;                 /* out of memory? */
    pfield->code = code;
    strcpy(pfield->contents, value);
    pfield->next = res->errFields;
    res->errFields = pfield;
}

References pgMessageField::code, pgMessageField::contents, pg_result::errFields, pgMessageField::next, pqResultAlloc(), and value.

Referenced by pqGetErrorNotice3(), and pqInternalNotice().

pqSaveParameterStatus()

void pqSaveParameterStatus	(	PGconn *	conn,
		const char *	name,
		const char *	value
	)

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

{
    pgParameterStatus *pstatus;
    pgParameterStatus *prev;
 
    /*
     * Forget any old information about the parameter
     */
    for (pstatus = conn->pstatus, prev = NULL;
         pstatus != NULL;
         prev = pstatus, pstatus = pstatus->next)
    {
        if (strcmp(pstatus->name, name) == 0)
        {
            if (prev)
                prev->next = pstatus->next;
            else
                conn->pstatus = pstatus->next;
            free(pstatus);      /* frees name and value strings too */
            break;
        }
    }
 
    /*
     * Store new info as a single malloc block
     */
    pstatus = (pgParameterStatus *) malloc(sizeof(pgParameterStatus) +
                                           strlen(name) + strlen(value) + 2);
    if (pstatus)
    {
        char       *ptr;
 
        ptr = ((char *) pstatus) + sizeof(pgParameterStatus);
        pstatus->name = ptr;
        strcpy(ptr, name);
        ptr += strlen(name) + 1;
        pstatus->value = ptr;
        strcpy(ptr, value);
        pstatus->next = conn->pstatus;
        conn->pstatus = pstatus;
    }
 
    /*
     * Save values of settings that are of interest to libpq in fields of the
     * PGconn object.  We keep client_encoding and standard_conforming_strings
     * in static variables as well, so that PQescapeString and PQescapeBytea
     * can behave somewhat sanely (at least in single-connection-using
     * programs).
     */
    if (strcmp(name, "client_encoding") == 0)
    {
        conn->client_encoding = pg_char_to_encoding(value);
        /* if we don't recognize the encoding name, fall back to SQL_ASCII */
        if (conn->client_encoding < 0)
            conn->client_encoding = PG_SQL_ASCII;
        static_client_encoding = conn->client_encoding;
    }
    else if (strcmp(name, "standard_conforming_strings") == 0)
    {
        conn->std_strings = (strcmp(value, "on") == 0);
        static_std_strings = conn->std_strings;
    }
    else if (strcmp(name, "server_version") == 0)
    {
        /* We convert the server version to numeric form. */
        int         cnt;
        int         vmaj,
                    vmin,
                    vrev;
 
        cnt = sscanf(value, "%d.%d.%d", &vmaj, &vmin, &vrev);
 
        if (cnt == 3)
        {
            /* old style, e.g. 9.6.1 */
            conn->sversion = (100 * vmaj + vmin) * 100 + vrev;
        }
        else if (cnt == 2)
        {
            if (vmaj >= 10)
            {
                /* new style, e.g. 10.1 */
                conn->sversion = 100 * 100 * vmaj + vmin;
            }
            else
            {
                /* old style without minor version, e.g. 9.6devel */
                conn->sversion = (100 * vmaj + vmin) * 100;
            }
        }
        else if (cnt == 1)
        {
            /* new style without minor version, e.g. 10devel */
            conn->sversion = 100 * 100 * vmaj;
        }
        else
            conn->sversion = 0; /* unknown */
    }
    else if (strcmp(name, "default_transaction_read_only") == 0)
    {
        conn->default_transaction_read_only =
            (strcmp(value, "on") == 0) ? PG_BOOL_YES : PG_BOOL_NO;
    }
    else if (strcmp(name, "in_hot_standby") == 0)
    {
        conn->in_hot_standby =
            (strcmp(value, "on") == 0) ? PG_BOOL_YES : PG_BOOL_NO;
    }
    else if (strcmp(name, "scram_iterations") == 0)
    {
        conn->scram_sha_256_iterations = atoi(value);
    }
}

References pg_conn::client_encoding, conn, pg_conn::default_transaction_read_only, free, pg_conn::in_hot_standby, malloc, name, pgParameterStatus::name, pgParameterStatus::next, PG_BOOL_NO, PG_BOOL_YES, pg_char_to_encoding, PG_SQL_ASCII, pg_conn::pstatus, pg_conn::scram_sha_256_iterations, static_client_encoding, static_std_strings, pg_conn::std_strings, pg_conn::sversion, value, and pgParameterStatus::value.

Referenced by getParameterStatus().

pqsecure_close()

void pqsecure_close

(

PGconn *

conn

)

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

{
#ifdef USE_SSL
    pgtls_close(conn);
#endif
}

References conn, and pgtls_close().

Referenced by pqDropConnection().

pqsecure_open_client()

PostgresPollingStatusType pqsecure_open_client

(

PGconn *

conn

)

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

{
#ifdef USE_SSL
    return pgtls_open_client(conn);
#else
    /* shouldn't get here */
    return PGRES_POLLING_FAILED;
#endif
}

References conn, PGRES_POLLING_FAILED, and pgtls_open_client().

Referenced by PQconnectPoll().

pqsecure_raw_read()

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

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

{
    ssize_t     n;
    int         result_errno = 0;
    char        sebuf[PG_STRERROR_R_BUFLEN];
 
    SOCK_ERRNO_SET(0);
 
    n = recv(conn->sock, ptr, len, 0);
 
    if (n < 0)
    {
        result_errno = SOCK_ERRNO;
 
        /* Set error message if appropriate */
        switch (result_errno)
        {
#ifdef EAGAIN
            case EAGAIN:
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
            case EWOULDBLOCK:
#endif
            case EINTR:
                /* no error message, caller is expected to retry */
                break;
 
            case EPIPE:
            case 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.");
                break;
 
            case 0:
                /* If errno didn't get set, treat it as regular EOF */
                n = 0;
                break;
 
            default:
                libpq_append_conn_error(conn, "could not receive data from server: %s",
                                        SOCK_STRERROR(result_errno,
                                                      sebuf, sizeof(sebuf)));
                break;
        }
    }
 
    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);
 
    return n;
}

References conn, EAGAIN, ECONNRESET, EINTR, EWOULDBLOCK, len, libpq_append_conn_error(), PG_STRERROR_R_BUFLEN, recv, pg_conn::sock, SOCK_ERRNO, SOCK_ERRNO_SET, and SOCK_STRERROR.

Referenced by gss_read(), pg_GSS_read(), pgconn_bio_read(), and pqsecure_read().

pqsecure_raw_write()

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

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

{
    ssize_t     n;
    int         flags = 0;
    int         result_errno = 0;
    char        msgbuf[1024];
    char        sebuf[PG_STRERROR_R_BUFLEN];
 
    DECLARE_SIGPIPE_INFO(spinfo);
 
    /*
     * If we already had a write failure, we will never again try to send data
     * on that connection.  Even if the kernel would let us, we've probably
     * lost message boundary sync with the server.  conn->write_failed
     * therefore persists until the connection is reset, and we just discard
     * all data presented to be written.
     */
    if (conn->write_failed)
        return len;
 
#ifdef MSG_NOSIGNAL
    if (conn->sigpipe_flag)
        flags |= MSG_NOSIGNAL;
 
retry_masked:
#endif                          /* MSG_NOSIGNAL */
 
    DISABLE_SIGPIPE(conn, spinfo, return -1);
 
    n = send(conn->sock, ptr, len, flags);
 
    if (n < 0)
    {
        result_errno = SOCK_ERRNO;
 
        /*
         * If we see an EINVAL, it may be because MSG_NOSIGNAL isn't available
         * on this machine.  So, clear sigpipe_flag so we don't try the flag
         * again, and retry the send().
         */
#ifdef MSG_NOSIGNAL
        if (flags != 0 && result_errno == EINVAL)
        {
            conn->sigpipe_flag = false;
            flags = 0;
            goto retry_masked;
        }
#endif                          /* MSG_NOSIGNAL */
 
        /* Set error message if appropriate */
        switch (result_errno)
        {
#ifdef EAGAIN
            case EAGAIN:
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
            case EWOULDBLOCK:
#endif
            case EINTR:
                /* no error message, caller is expected to retry */
                break;
 
            case EPIPE:
                /* Set flag for EPIPE */
                REMEMBER_EPIPE(spinfo, true);
 
                /* FALL THRU */
 
            case ECONNRESET:
                conn->write_failed = true;
                /* Store error message in conn->write_err_msg, if possible */
                /* (strdup failure is OK, we'll cope later) */
                snprintf(msgbuf, sizeof(msgbuf),
                         libpq_gettext("server closed the connection unexpectedly\n"
                                       "\tThis probably means the server terminated abnormally\n"
                                       "\tbefore or while processing the request."));
                /* keep newline out of translated string */
                strlcat(msgbuf, "\n", sizeof(msgbuf));
                conn->write_err_msg = strdup(msgbuf);
                /* Now claim the write succeeded */
                n = len;
                break;
 
            default:
                conn->write_failed = true;
                /* Store error message in conn->write_err_msg, if possible */
                /* (strdup failure is OK, we'll cope later) */
                snprintf(msgbuf, sizeof(msgbuf),
                         libpq_gettext("could not send data to server: %s"),
                         SOCK_STRERROR(result_errno,
                                       sebuf, sizeof(sebuf)));
                /* keep newline out of translated string */
                strlcat(msgbuf, "\n", sizeof(msgbuf));
                conn->write_err_msg = strdup(msgbuf);
                /* Now claim the write succeeded */
                n = len;
                break;
        }
    }
 
    RESTORE_SIGPIPE(conn, spinfo);
 
    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);
 
    return n;
}

References conn, DECLARE_SIGPIPE_INFO, DISABLE_SIGPIPE, EAGAIN, ECONNRESET, EINTR, EWOULDBLOCK, len, libpq_gettext, PG_STRERROR_R_BUFLEN, REMEMBER_EPIPE, RESTORE_SIGPIPE, send, pg_conn::sigpipe_flag, snprintf, pg_conn::sock, SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, strlcat(), pg_conn::write_err_msg, and pg_conn::write_failed.

Referenced by pg_GSS_write(), pgconn_bio_write(), pqsecure_open_gss(), and pqsecure_write().

pqsecure_read()

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

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

{
    ssize_t     n;
 
#ifdef USE_SSL
    if (conn->ssl_in_use)
    {
        n = pgtls_read(conn, ptr, len);
    }
    else
#endif
#ifdef ENABLE_GSS
    if (conn->gssenc)
    {
        n = pg_GSS_read(conn, ptr, len);
    }
    else
#endif
    {
        n = pqsecure_raw_read(conn, ptr, len);
    }
 
    return n;
}

References conn, len, pg_GSS_read(), pgtls_read(), pqsecure_raw_read(), and pg_conn::ssl_in_use.

Referenced by pqReadData().

pqsecure_write()

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

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

{
    ssize_t     n;
 
#ifdef USE_SSL
    if (conn->ssl_in_use)
    {
        n = pgtls_write(conn, ptr, len);
    }
    else
#endif
#ifdef ENABLE_GSS
    if (conn->gssenc)
    {
        n = pg_GSS_write(conn, ptr, len);
    }
    else
#endif
    {
        n = pqsecure_raw_write(conn, ptr, len);
    }
 
    return n;
}

References conn, len, pg_GSS_write(), pgtls_write(), pqsecure_raw_write(), and pg_conn::ssl_in_use.

Referenced by pqSendSome().

PQsendCancelRequest()

int PQsendCancelRequest

(

PGconn *

cancelConn

)

Definition at line 454 of file fe-cancel.c.

{
    CancelRequestPacket req;
 
    /* Start the message. */
    if (pqPutMsgStart(0, cancelConn))
        return STATUS_ERROR;
 
    /* Send the message body. */
    memset(&req, 0, offsetof(CancelRequestPacket, cancelAuthCode));
    req.cancelRequestCode = (MsgType) pg_hton32(CANCEL_REQUEST_CODE);
    req.backendPID = pg_hton32(cancelConn->be_pid);
    if (pqPutnchar(&req, offsetof(CancelRequestPacket, cancelAuthCode), cancelConn))
        return STATUS_ERROR;
    if (pqPutnchar(cancelConn->be_cancel_key, cancelConn->be_cancel_key_len, cancelConn))
        return STATUS_ERROR;
 
    /* Finish the message. */
    if (pqPutMsgEnd(cancelConn))
        return STATUS_ERROR;
 
    /* Flush to ensure backend gets it. */
    if (pqFlush(cancelConn))
        return STATUS_ERROR;
 
    return STATUS_OK;
}

References CancelRequestPacket::backendPID, pg_cancel::be_pid, CANCEL_REQUEST_CODE, cancelConn, CancelRequestPacket::cancelRequestCode, pg_hton32, pqFlush(), pqPutMsgEnd(), pqPutMsgStart(), pqPutnchar(), STATUS_ERROR, and STATUS_OK.

Referenced by PQconnectPoll().

PQsendQueryContinue()

int PQsendQueryContinue	(	PGconn *	conn,
		const char *	query
	)

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

{
    return PQsendQueryInternal(conn, query, false);
}

References conn, and PQsendQueryInternal().

Referenced by PQconnectPoll().

pqSetResultError()

void pqSetResultError	(	PGresult *	res,
		PQExpBuffer	errorMessage,
		int	offset
	)

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

{
    char       *msg;
 
    if (!res)
        return;
 
    /*
     * We handle two OOM scenarios here.  The errorMessage buffer might be
     * marked "broken" due to having previously failed to allocate enough
     * memory for the message, or it might be fine but pqResultStrdup fails
     * and returns NULL.  In either case, just make res->errMsg point directly
     * at a constant "out of memory" string.
     */
    if (!PQExpBufferBroken(errorMessage))
        msg = pqResultStrdup(res, errorMessage->data + offset);
    else
        msg = NULL;
    if (msg)
        res->errMsg = msg;
    else
        res->errMsg = libpq_gettext("out of memory\n");
}

References PQExpBufferData::data, pg_result::errMsg, libpq_gettext, PQExpBufferBroken, and pqResultStrdup().

Referenced by pqGetErrorNotice3(), PQmakeEmptyPGresult(), and pqPrepareAsyncResult().

pqSkipnchar()

int pqSkipnchar	(	size_t	len,
		PGconn *	conn
	)

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

{
    if (len > (size_t) (conn->inEnd - conn->inCursor))
        return EOF;
 
    conn->inCursor += len;
 
    return 0;
}

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

Referenced by getAnotherTuple().

pqTraceOutputCharResponse()

void pqTraceOutputCharResponse	(	PGconn *	conn,
		const char *	responseType,
		char	response
	)

Definition at line 915 of file fe-trace.c.

{
    if ((conn->traceFlags & PQTRACE_SUPPRESS_TIMESTAMPS) == 0)
    {
        char        timestr[128];
 
        pqTraceFormatTimestamp(timestr, sizeof(timestr));
        fprintf(conn->Pfdebug, "%s\t", timestr);
    }
 
    fprintf(conn->Pfdebug, "B\t1\t%s\t %c\n", responseType, response);
}

References conn, fprintf, pg_conn::Pfdebug, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), and pg_conn::traceFlags.

Referenced by PQconnectPoll().

pqTraceOutputMessage()

void pqTraceOutputMessage	(	PGconn *	conn,
		const char *	message,
		bool	toServer
	)

Definition at line 624 of file fe-trace.c.

{
    char        id;
    int         length;
    char       *prefix = toServer ? "F" : "B";
    int         logCursor = 0;
    bool        regress;
 
    if ((conn->traceFlags & PQTRACE_SUPPRESS_TIMESTAMPS) == 0)
    {
        char        timestr[128];
 
        pqTraceFormatTimestamp(timestr, sizeof(timestr));
        fprintf(conn->Pfdebug, "%s\t", timestr);
    }
    regress = (conn->traceFlags & PQTRACE_REGRESS_MODE) != 0;
 
    id = message[logCursor++];
 
    memcpy(&length, message + logCursor, 4);
    length = (int) pg_ntoh32(length);
    logCursor += 4;
 
    /*
     * In regress mode, suppress the length of ErrorResponse and
     * NoticeResponse.  The F (file name), L (line number) and R (routine
     * name) fields can change as server code is modified, and if their
     * lengths differ from the originals, that would break tests.
     */
    if (regress && !toServer && (id == PqMsg_ErrorResponse || id == PqMsg_NoticeResponse))
        fprintf(conn->Pfdebug, "%s\tNN\t", prefix);
    else
        fprintf(conn->Pfdebug, "%s\t%d\t", prefix, length);
 
    switch (id)
    {
        case PqMsg_ParseComplete:
            fprintf(conn->Pfdebug, "ParseComplete");
            /* No message content */
            break;
        case PqMsg_BindComplete:
            fprintf(conn->Pfdebug, "BindComplete");
            /* No message content */
            break;
        case PqMsg_CloseComplete:
            fprintf(conn->Pfdebug, "CloseComplete");
            /* No message content */
            break;
        case PqMsg_NotificationResponse:
            pqTraceOutput_NotificationResponse(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_Bind:
            pqTraceOutput_Bind(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_CopyDone:
            fprintf(conn->Pfdebug, "CopyDone");
            /* No message content */
            break;
        case PqMsg_CommandComplete:
            /* Close(F) and CommandComplete(B) use the same identifier. */
            Assert(PqMsg_Close == PqMsg_CommandComplete);
            if (toServer)
                pqTraceOutput_Close(conn->Pfdebug, message, &logCursor);
            else
                pqTraceOutput_CommandComplete(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_CopyData:
            pqTraceOutput_CopyData(conn->Pfdebug, message, &logCursor,
                                   length, regress);
            break;
        case PqMsg_Describe:
            /* Describe(F) and DataRow(B) use the same identifier. */
            Assert(PqMsg_Describe == PqMsg_DataRow);
            if (toServer)
                pqTraceOutput_Describe(conn->Pfdebug, message, &logCursor);
            else
                pqTraceOutput_DataRow(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_Execute:
            /* Execute(F) and ErrorResponse(B) use the same identifier. */
            Assert(PqMsg_Execute == PqMsg_ErrorResponse);
            if (toServer)
                pqTraceOutput_Execute(conn->Pfdebug, message, &logCursor, regress);
            else
                pqTraceOutput_ErrorResponse(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_CopyFail:
            pqTraceOutput_CopyFail(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_GSSResponse:
            Assert(PqMsg_GSSResponse == PqMsg_PasswordMessage);
            Assert(PqMsg_GSSResponse == PqMsg_SASLInitialResponse);
            Assert(PqMsg_GSSResponse == PqMsg_SASLResponse);
 
            /*
             * These messages share a common type byte, so we discriminate by
             * having the code store the auth type separately.
             */
            switch (conn->current_auth_response)
            {
                case AUTH_RESPONSE_GSS:
                    pqTraceOutput_GSSResponse(conn->Pfdebug, message,
                                              &logCursor, length, regress);
                    break;
                case AUTH_RESPONSE_PASSWORD:
                    pqTraceOutput_PasswordMessage(conn->Pfdebug, message,
                                                  &logCursor);
                    break;
                case AUTH_RESPONSE_SASL_INITIAL:
                    pqTraceOutput_SASLInitialResponse(conn->Pfdebug, message,
                                                      &logCursor, regress);
                    break;
                case AUTH_RESPONSE_SASL:
                    pqTraceOutput_SASLResponse(conn->Pfdebug, message,
                                               &logCursor, length, regress);
                    break;
                default:
                    fprintf(conn->Pfdebug, "UnknownAuthenticationResponse");
                    break;
            }
            conn->current_auth_response = '\0';
            break;
        case PqMsg_FunctionCall:
            pqTraceOutput_FunctionCall(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_CopyInResponse:
            pqTraceOutput_CopyInResponse(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_Flush:
            /* Flush(F) and CopyOutResponse(B) use the same identifier */
            Assert(PqMsg_CopyOutResponse == PqMsg_Flush);
            if (toServer)
                fprintf(conn->Pfdebug, "Flush");    /* no message content */
            else
                pqTraceOutput_CopyOutResponse(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_EmptyQueryResponse:
            fprintf(conn->Pfdebug, "EmptyQueryResponse");
            /* No message content */
            break;
        case PqMsg_BackendKeyData:
            pqTraceOutput_BackendKeyData(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_NoData:
            fprintf(conn->Pfdebug, "NoData");
            /* No message content */
            break;
        case PqMsg_NoticeResponse:
            pqTraceOutput_NoticeResponse(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_Parse:
            pqTraceOutput_Parse(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_Query:
            pqTraceOutput_Query(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_AuthenticationRequest:
            pqTraceOutput_Authentication(conn->Pfdebug, message, &logCursor,
                                         length, regress);
            break;
        case PqMsg_PortalSuspended:
            fprintf(conn->Pfdebug, "PortalSuspended");
            /* No message content */
            break;
        case PqMsg_Sync:
            /* ParameterStatus(B) and Sync(F) use the same identifier */
            Assert(PqMsg_ParameterStatus == PqMsg_Sync);
            if (toServer)
                fprintf(conn->Pfdebug, "Sync"); /* no message content */
            else
                pqTraceOutput_ParameterStatus(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_ParameterDescription:
            pqTraceOutput_ParameterDescription(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_RowDescription:
            pqTraceOutput_RowDescription(conn->Pfdebug, message, &logCursor, regress);
            break;
        case PqMsg_NegotiateProtocolVersion:
            pqTraceOutput_NegotiateProtocolVersion(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_FunctionCallResponse:
            pqTraceOutput_FunctionCallResponse(conn->Pfdebug, message, &logCursor);
            break;
        case PqMsg_CopyBothResponse:
            pqTraceOutput_CopyBothResponse(conn->Pfdebug, message, &logCursor, length);
            break;
        case PqMsg_Terminate:
            fprintf(conn->Pfdebug, "Terminate");
            /* No message content */
            break;
        case PqMsg_ReadyForQuery:
            pqTraceOutput_ReadyForQuery(conn->Pfdebug, message, &logCursor);
            break;
        default:
            fprintf(conn->Pfdebug, "Unknown message: %02x", id);
            break;
    }
 
    fputc('\n', conn->Pfdebug);
 
    /*
     * Verify the printing routine did it right.  Note that the one-byte
     * message identifier is not included in the length, but our cursor does
     * include it.
     */
    if (logCursor - 1 != length)
        fprintf(conn->Pfdebug,
                "mismatched message length: consumed %d, expected %d\n",
                logCursor - 1, length);
}

References Assert(), AUTH_RESPONSE_GSS, AUTH_RESPONSE_PASSWORD, AUTH_RESPONSE_SASL, AUTH_RESPONSE_SASL_INITIAL, conn, pg_conn::current_auth_response, fprintf, pg_conn::Pfdebug, pg_ntoh32, PqMsg_AuthenticationRequest, PqMsg_BackendKeyData, PqMsg_Bind, PqMsg_BindComplete, PqMsg_Close, PqMsg_CloseComplete, PqMsg_CommandComplete, PqMsg_CopyBothResponse, PqMsg_CopyData, PqMsg_CopyDone, PqMsg_CopyFail, PqMsg_CopyInResponse, PqMsg_CopyOutResponse, PqMsg_DataRow, PqMsg_Describe, PqMsg_EmptyQueryResponse, PqMsg_ErrorResponse, PqMsg_Execute, PqMsg_Flush, PqMsg_FunctionCall, PqMsg_FunctionCallResponse, PqMsg_GSSResponse, PqMsg_NegotiateProtocolVersion, PqMsg_NoData, PqMsg_NoticeResponse, PqMsg_NotificationResponse, PqMsg_ParameterDescription, PqMsg_ParameterStatus, PqMsg_Parse, PqMsg_ParseComplete, PqMsg_PasswordMessage, PqMsg_PortalSuspended, PqMsg_Query, PqMsg_ReadyForQuery, PqMsg_RowDescription, PqMsg_SASLInitialResponse, PqMsg_SASLResponse, PqMsg_Sync, PqMsg_Terminate, PQTRACE_REGRESS_MODE, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), pqTraceOutput_Authentication(), pqTraceOutput_BackendKeyData(), pqTraceOutput_Bind(), pqTraceOutput_Close(), pqTraceOutput_CommandComplete(), pqTraceOutput_CopyBothResponse(), pqTraceOutput_CopyData(), pqTraceOutput_CopyFail(), pqTraceOutput_CopyInResponse(), pqTraceOutput_CopyOutResponse(), pqTraceOutput_DataRow(), pqTraceOutput_Describe(), pqTraceOutput_ErrorResponse(), pqTraceOutput_Execute(), pqTraceOutput_FunctionCall(), pqTraceOutput_FunctionCallResponse(), pqTraceOutput_GSSResponse(), pqTraceOutput_NegotiateProtocolVersion(), pqTraceOutput_NoticeResponse(), pqTraceOutput_NotificationResponse(), pqTraceOutput_ParameterDescription(), pqTraceOutput_ParameterStatus(), pqTraceOutput_Parse(), pqTraceOutput_PasswordMessage(), pqTraceOutput_Query(), pqTraceOutput_ReadyForQuery(), pqTraceOutput_RowDescription(), pqTraceOutput_SASLInitialResponse(), pqTraceOutput_SASLResponse(), and pg_conn::traceFlags.

Referenced by pg_password_sendauth(), pg_SASL_continue(), pg_SASL_init(), pqParseDone(), and pqPutMsgEnd().

pqTraceOutputNoTypeByteMessage()

void pqTraceOutputNoTypeByteMessage	(	PGconn *	conn,
		const char *	message
	)

Definition at line 841 of file fe-trace.c.

{
    int         length;
    int         version;
    bool        regress;
    int         logCursor = 0;
 
    regress = (conn->traceFlags & PQTRACE_REGRESS_MODE) != 0;
 
    if ((conn->traceFlags & PQTRACE_SUPPRESS_TIMESTAMPS) == 0)
    {
        char        timestr[128];
 
        pqTraceFormatTimestamp(timestr, sizeof(timestr));
        fprintf(conn->Pfdebug, "%s\t", timestr);
    }
 
    memcpy(&length, message + logCursor, 4);
    length = (int) pg_ntoh32(length);
    logCursor += 4;
 
    fprintf(conn->Pfdebug, "F\t%d\t", length);
 
    if (length < 8)
    {
        fprintf(conn->Pfdebug, "Unknown message\n");
        return;
    }
 
    memcpy(&version, message + logCursor, 4);
    version = (int) pg_ntoh32(version);
 
    if (version == CANCEL_REQUEST_CODE && length >= 16)
    {
        fprintf(conn->Pfdebug, "CancelRequest\t");
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
        pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, regress);
        pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, regress);
    }
    else if (version == NEGOTIATE_SSL_CODE)
    {
        fprintf(conn->Pfdebug, "SSLRequest\t");
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
    }
    else if (version == NEGOTIATE_GSS_CODE)
    {
        fprintf(conn->Pfdebug, "GSSENCRequest\t");
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
    }
    else
    {
        fprintf(conn->Pfdebug, "StartupMessage\t");
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
        pqTraceOutputInt16(conn->Pfdebug, message, &logCursor);
        while (message[logCursor] != '\0')
        {
            /* XXX should we suppress anything in regress mode? */
            pqTraceOutputString(conn->Pfdebug, message, &logCursor, false);
            pqTraceOutputString(conn->Pfdebug, message, &logCursor, false);
        }
    }
 
    fputc('\n', conn->Pfdebug);
}

References CANCEL_REQUEST_CODE, conn, fprintf, NEGOTIATE_GSS_CODE, NEGOTIATE_SSL_CODE, pg_conn::Pfdebug, pg_ntoh32, PQTRACE_REGRESS_MODE, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), pqTraceOutputInt16(), pqTraceOutputInt32(), pqTraceOutputString(), and pg_conn::traceFlags.

Referenced by pqPutMsgEnd().

pqWait()

int pqWait	(	int	forRead,
		int	forWrite,
		PGconn *	conn
	)

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

{
    return pqWaitTimed(forRead, forWrite, conn, -1);
}

References conn, and pqWaitTimed().

Referenced by pqFunctionCall3(), pqGetCopyData3(), pqGetline3(), PQgetResult(), and pqSendSome().

pqWaitTimed()

int pqWaitTimed	(	int	forRead,
		int	forWrite,
		PGconn *	conn,
		pg_usec_time_t	end_time
	)

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

{
    int         result;
 
    result = pqSocketCheck(conn, forRead, forWrite, end_time);
 
    if (result < 0)
        return -1;              /* errorMessage is already set */
 
    if (result == 0)
    {
        libpq_append_conn_error(conn, "timeout expired");
        return 1;
    }
 
    return 0;
}

References conn, end_time, libpq_append_conn_error(), and pqSocketCheck().

Referenced by pqConnectDBComplete(), and pqWait().

pqWriteReady()

int pqWriteReady

(

PGconn *

conn

)

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

{
    return pqSocketCheck(conn, 0, 1, 0);
}

References conn, and pqSocketCheck().

Variable Documentation

pg_g_threadlock

pgthreadlock_t pg_g_threadlock

extern

Definition at line 35 of file oauth-utils.c.

Referenced by libpq_oauth_init(), and PQregisterThreadLock().

pgresStatus

char* const pgresStatus[]

extern

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

Referenced by PQresStatus().