libpq-int.h File Reference

#include "libpq-events.h"
#include <time.h>
#include "getaddrinfo.h"
#include "libpq/pqcomm.h"
#include "pqexpbuffer.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
struct	pg_cancel

Macros
#define	CMDSTATUS_LEN   64 /* should match COMPLETION_TAG_BUFSIZE */
#define	NULL_LEN   (-1) /* pg_result len for NULL value */
#define	pglock_thread()   ((void) 0)
#define	pgunlock_thread()   ((void) 0)
#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 }
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	PGTernaryBool { PG_BOOL_UNKNOWN = 0, PG_BOOL_YES, PG_BOOL_NO }
enum	pg_conn_host_type { CHT_HOST_NAME, CHT_HOST_ADDRESS, CHT_UNIX_SOCKET }
enum	PGQueryClass {   PGQUERY_SIMPLE, PGQUERY_EXTENDED, PGQUERY_PREPARE, PGQUERY_DESCRIBE,   PGQUERY_SYNC }

Functions
void	pqDropConnection (PGconn *conn, bool flushInput)
int	pqPacketSend (PGconn *conn, char pack_type, const void *buf, size_t buf_len)
bool	pqGetHomeDirectory (char *buf, int bufsize)
void	pqSetResultError (PGresult *res, const char *msg)
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)
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	pqGetCopyData3 (PGconn *conn, char **buffer, int async)
int	pqGetline3 (PGconn *conn, char *s, int maxlen)
int	pqGetlineAsync3 (PGconn *conn, char *buffer, int bufsize)
int	pqEndcopy3 (PGconn *conn)
PGresult *	pqFunctionCall3 (PGconn *conn, Oid fnid, int *result_buf, int *actual_result_len, int result_is_int, const PQArgBlock *args, int nargs)
int	pqCheckOutBufferSpace (size_t bytes_needed, PGconn *conn)
int	pqCheckInBufferSpace (size_t bytes_needed, PGconn *conn)
int	pqGetc (char *result, PGconn *conn)
int	pqPutc (char c, PGconn *conn)
int	pqGets (PQExpBuffer buf, PGconn *conn)
int	pqGets_append (PQExpBuffer buf, PGconn *conn)
int	pqPuts (const char *s, PGconn *conn)
int	pqGetnchar (char *s, size_t len, PGconn *conn)
int	pqSkipnchar (size_t len, PGconn *conn)
int	pqPutnchar (const char *s, size_t len, PGconn *conn)
int	pqGetInt (int *result, size_t bytes, PGconn *conn)
int	pqPutInt (int value, size_t bytes, PGconn *conn)
int	pqPutMsgStart (char msg_type, PGconn *conn)
int	pqPutMsgEnd (PGconn *conn)
int	pqReadData (PGconn *conn)
int	pqFlush (PGconn *conn)
int	pqWait (int forRead, int forWrite, PGconn *conn)
int	pqWaitTimed (int forRead, int forWrite, PGconn *conn, time_t finish_time)
int	pqReadReady (PGconn *conn)
int	pqWriteReady (PGconn *conn)
int	pqsecure_initialize (PGconn *, bool, bool)
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)
void	pgtls_init_library (bool do_ssl, int do_crypto)
int	pgtls_init (PGconn *conn, bool do_ssl, bool do_crypto)
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)
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)

Variables
char *const	pgresStatus []

Macro Definition Documentation

CMDSTATUS_LEN

#define CMDSTATUS_LEN   64 /* should match COMPLETION_TAG_BUFSIZE */

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

Referenced by pqParseInput3().

libpq_gettext

#define libpq_gettext

(

x

)

(x)

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

Referenced by build_client_final_message(), build_client_first_message(), check_expected_areq(), connectFailureMessage(), connectNoDelay(), connectOptions2(), conninfo_add_defaults(), conninfo_array_parse(), conninfo_init(), conninfo_parse(), conninfo_storeval(), conninfo_uri_decode(), conninfo_uri_parse_options(), conninfo_uri_parse_params(), do_field(), do_header(), emitHostIdentityInfo(), fillPGconn(), getAnotherTuple(), getParamDescriptions(), getRowDescriptions(), handleSyncLoss(), initialize_SSL(), lo_create(), lo_export(), lo_import_internal(), lo_initialize(), lo_lseek64(), lo_read(), lo_tell64(), lo_truncate(), lo_truncate64(), lo_write(), open_client_SSL(), openssl_verify_peer_name_matches_certificate_name(), parse_int_param(), parseServiceFile(), parseServiceInfo(), passwordFromFile(), pg_fe_getauthname(), pg_fe_scram_exchange(), pg_fe_sendauth(), pg_GSS_load_servicename(), pg_GSS_read(), pg_GSS_write(), pg_local_sendauth(), pg_password_sendauth(), pg_SASL_continue(), pg_SASL_init(), pgpassfileWarning(), pgtls_read(), pgtls_write(), pq_verify_peer_name_matches_certificate(), pq_verify_peer_name_matches_certificate_name(), pqAddTuple(), pqAllocCmdQueueEntry(), pqBuildErrorMessage3(), PQconnectPoll(), PQdefaultSSLKeyPassHook_OpenSSL(), PQdisplayTuples(), PQencryptPasswordConn(), pqEndcopy3(), PQenterPipelineMode(), PQenv2encoding(), PQerrorMessage(), PQescapeByteaInternal(), PQescapeInternal(), PQescapeStringInternal(), PQexecStart(), PQexitPipelineMode(), PQfn(), pqFunctionCall3(), PQgetCopyData(), pqGetCopyData3(), pqGetErrorNotice3(), pqGetline3(), PQgetResult(), pqInternalNotice(), pqPacketSend(), pqParseInput3(), pqPipelineProcessQueue(), PQpipelineSync(), PQprint(), PQprintTuples(), PQputCopyData(), PQputCopyEnd(), pqReadData(), PQreset(), PQresetPoll(), PQresStatus(), PQresultVerboseErrorMessage(), pqSaveWriteError(), pqsecure_open_gss(), pqsecure_raw_read(), pqsecure_raw_write(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), PQsendQueryParams(), PQsendQueryPrepared(), PQsendQueryStart(), pqSendSome(), PQsetdbLogin(), PQsetvalue(), pqSocketCheck(), pqWaitTimed(), read_attr_value(), read_server_final_message(), read_server_first_message(), reportErrorPosition(), setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), setTCPUserTimeout(), and SSLerrmessage().

libpq_ngettext

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

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

Referenced by pq_verify_peer_name_matches_certificate(), and PQenv2encoding().

NULL_LEN

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

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

Referenced by PQgetisnull(), PQgetlength(), pqRowProcessor(), and PQsetvalue().

OUTBUFFER_THRESHOLD

#define OUTBUFFER_THRESHOLD   65536

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

Referenced by pqPipelineFlush().

pglock_thread

#define pglock_thread

(

)

((void) 0)

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

Referenced by pg_fe_getauthname(), and pg_fe_sendauth().

pgunlock_thread

#define pgunlock_thread

(

)

((void) 0)

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

Referenced by pg_fe_getauthname(), and pg_fe_sendauth().

pqIsnonblocking

#define pqIsnonblocking

(

conn

)

((conn)->nonblocking)

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

Referenced by PQconsumeInput(), pqEndcopy3(), PQisnonblocking(), PQputCopyData(), and pqSendSome().

SOCK_ERRNO

#define SOCK_ERRNO   errno

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

Referenced by connectNoDelay(), internal_cancel(), my_sock_read(), my_sock_write(), open_client_SSL(), pgtls_read(), pgtls_write(), PQconnectPoll(), PQgssEncInUse(), pqReadData(), pqsecure_raw_read(), pqsecure_raw_write(), pqSendSome(), pqSocketCheck(), setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), and setTCPUserTimeout().

SOCK_ERRNO_SET

#define SOCK_ERRNO_SET

(

e

)

(errno = (e))

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

Referenced by internal_cancel(), pgtls_read(), pgtls_write(), PQgssEncInUse(), pqsecure_raw_read(), and pqsecure_raw_write().

SOCK_STRERROR

#define SOCK_STRERROR   strerror_r

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

Referenced by connectFailureMessage(), connectNoDelay(), internal_cancel(), open_client_SSL(), pgtls_read(), pgtls_write(), PQconnectPoll(), pqsecure_raw_read(), pqsecure_raw_write(), pqSocketCheck(), setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), and setTCPUserTimeout().

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 101 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 296 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

Definition at line 216 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 */
} PGAsyncStatusType;

PGQueryClass

enum PGQueryClass

Enumerator
PGQUERY_SIMPLE
PGQUERY_EXTENDED
PGQUERY_PREPARE
PGQUERY_DESCRIBE
PGQUERY_SYNC

Definition at line 307 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) */
} 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 231 of file libpq-int.h.

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

PGTernaryBool

enum PGTernaryBool

Enumerator
PG_BOOL_UNKNOWN
PG_BOOL_YES
PG_BOOL_NO

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

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

Function Documentation

pgtls_close()

void pgtls_close

(

PGconn *

conn

)

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

References destroy_ssl_system(), and pg_conn::ssl_in_use.

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

{
    bool        destroy_needed = false;

    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;

            destroy_needed = true;
        }

        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
    }
    else
    {
        /*
         * In the non-SSL case, just remove the crypto callbacks if the
         * connection has then loaded.  This code path has no dependency
         * on any pending SSL calls.
         */
        if (conn->crypto_loaded)
            destroy_needed = true;
    }

    /*
     * This will remove our crypto locking hooks if this is the last
     * connection using libcrypto which means we must wait to call it until
     * after all the potential SSL calls have been made, otherwise we can end
     * up with a race condition and possible deadlocks.
     *
     * See comments above destroy_ssl_system().
     */
    if (destroy_needed)
    {
        destroy_ssl_system();
        conn->crypto_loaded = false;
    }
}

pgtls_init()

int pgtls_init	(	PGconn *	conn,
		bool	do_ssl,
		bool	do_crypto
	)

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

References free, i, malloc, pq_init_crypto_lib, pq_init_ssl_lib, pthread_mutex_init(), pthread_mutex_lock(), pthread_mutex_unlock(), and ssl_lib_initialized.

Referenced by pqsecure_initialize().

{
#ifdef ENABLE_THREAD_SAFETY
#ifdef WIN32
    /* Also see similar code in fe-connect.c, default_threadlock() */
    if (ssl_config_mutex == NULL)
    {
        while (InterlockedExchange(&win32_ssl_create_mutex, 1) == 1)
             /* loop, another thread own the lock */ ;
        if (ssl_config_mutex == NULL)
        {
            if (pthread_mutex_init(&ssl_config_mutex, NULL))
                return -1;
        }
        InterlockedExchange(&win32_ssl_create_mutex, 0);
    }
#endif
    if (pthread_mutex_lock(&ssl_config_mutex))
        return -1;

#ifdef HAVE_CRYPTO_LOCK
    if (pq_init_crypto_lib)
    {
        /*
         * If necessary, set up an array to hold locks for libcrypto.
         * libcrypto will tell us how big to make this array.
         */
        if (pq_lockarray == NULL)
        {
            int         i;

            pq_lockarray = malloc(sizeof(pthread_mutex_t) * CRYPTO_num_locks());
            if (!pq_lockarray)
            {
                pthread_mutex_unlock(&ssl_config_mutex);
                return -1;
            }
            for (i = 0; i < CRYPTO_num_locks(); i++)
            {
                if (pthread_mutex_init(&pq_lockarray[i], NULL))
                {
                    free(pq_lockarray);
                    pq_lockarray = NULL;
                    pthread_mutex_unlock(&ssl_config_mutex);
                    return -1;
                }
            }
        }

        if (do_crypto && !conn->crypto_loaded)
        {
            if (crypto_open_connections++ == 0)
            {
                /*
                 * These are only required for threaded libcrypto
                 * applications, but make sure we don't stomp on them if
                 * they're already set.
                 */
                if (CRYPTO_get_id_callback() == NULL)
                    CRYPTO_set_id_callback(pq_threadidcallback);
                if (CRYPTO_get_locking_callback() == NULL)
                    CRYPTO_set_locking_callback(pq_lockingcallback);
            }

            conn->crypto_loaded = true;
        }
    }
#endif                          /* HAVE_CRYPTO_LOCK */
#endif                          /* ENABLE_THREAD_SAFETY */

    if (!ssl_lib_initialized && do_ssl)
    {
        if (pq_init_ssl_lib)
        {
#ifdef HAVE_OPENSSL_INIT_SSL
            OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, NULL);
#else
            OPENSSL_config(NULL);
            SSL_library_init();
            SSL_load_error_strings();
#endif
        }
        ssl_lib_initialized = true;
    }

#ifdef ENABLE_THREAD_SAFETY
    pthread_mutex_unlock(&ssl_config_mutex);
#endif
    return 0;
}

pgtls_init_library()

void pgtls_init_library	(	bool	do_ssl,
		int	do_crypto
	)

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

References pq_init_crypto_lib, and pq_init_ssl_lib.

Referenced by PQinitOpenSSL(), and PQinitSSL().

{
#ifdef ENABLE_THREAD_SAFETY

    /*
     * Disallow changing the flags while we have open connections, else we'd
     * get completely confused.
     */
    if (crypto_open_connections != 0)
        return;
#endif

    pq_init_ssl_lib = do_ssl;
    pq_init_crypto_lib = do_crypto;
}

pgtls_open_client()

PostgresPollingStatusType pgtls_open_client

(

PGconn *

conn

)

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

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

Referenced by pqsecure_open_client().

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

pgtls_read()

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

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

References appendPQExpBuffer(), appendPQExpBufferStr(), ECONNRESET, pg_conn::errorMessage, libpq_gettext, PG_STRERROR_R_BUFLEN, SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, SSLerrfree(), and SSLerrmessage().

Referenced by pqsecure_read().

{
    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)
            {
                result_errno = SOCK_ERRNO;
                if (result_errno == EPIPE ||
                    result_errno == ECONNRESET)
                    appendPQExpBufferStr(&conn->errorMessage,
                                         libpq_gettext("server closed the connection unexpectedly\n"
                                                       "\tThis probably means the server terminated abnormally\n"
                                                       "\tbefore or while processing the request.\n"));
                else
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("SSL SYSCALL error: %s\n"),
                                      SOCK_STRERROR(result_errno,
                                                    sebuf, sizeof(sebuf)));
            }
            else
            {
                appendPQExpBufferStr(&conn->errorMessage,
                                     libpq_gettext("SSL SYSCALL error: EOF detected\n"));
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            {
                char       *errm = SSLerrmessage(ecode);

                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("SSL error: %s\n"), 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.
             */
            appendPQExpBufferStr(&conn->errorMessage,
                                 libpq_gettext("SSL connection has been closed unexpectedly\n"));
            result_errno = ECONNRESET;
            n = -1;
            break;
        default:
            appendPQExpBuffer(&conn->errorMessage,
                              libpq_gettext("unrecognized SSL error code: %d\n"),
                              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;
}

pgtls_read_pending()

bool pgtls_read_pending

(

PGconn *

conn

)

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

Referenced by pqSocketCheck().

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

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 512 of file fe-secure-openssl.c.

References free, i, mode, name, openssl_verify_peer_name_matches_certificate_name(), pthread_mutex_lock(), pthread_mutex_unlock(), and pthread_self().

Referenced by pq_verify_peer_name_matches_certificate().

{
    STACK_OF(GENERAL_NAME) * peer_san;
    int         i;
    int         rc = 0;

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

            if (name->type == GEN_DNS)
            {
                char       *alt_name;

                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_name(conn,
                                                                       name->d.dNSName,
                                                                       &alt_name);

                if (alt_name)
                {
                    if (!*first_name)
                        *first_name = alt_name;
                    else
                        free(alt_name);
                }
            }
            if (rc != 0)
                break;
        }
        sk_GENERAL_NAME_pop_free(peer_san, GENERAL_NAME_free);
    }

    /*
     * If there is no subjectAltName extension of type dNSName, check the
     * Common Name.
     *
     * (Per RFC 2818 and RFC 6125, if the subjectAltName extension of type
     * dNSName is present, the CN must be ignored.)
     */
    if (*names_examined == 0)
    {
        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)
            {
                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_name(conn,
                                                                       X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subject_name, cn_index)),
                                                                       first_name);
            }
        }
    }

    return rc;
}

pgtls_write()

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

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

References appendPQExpBuffer(), appendPQExpBufferStr(), conn, ECONNRESET, pg_conn::errorMessage, hash(), libpq_gettext, malloc, PG_STRERROR_R_BUFLEN, SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, SSLerrfree(), and SSLerrmessage().

Referenced by pqsecure_write().

{
    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 (n < 0)
            {
                result_errno = SOCK_ERRNO;
                if (result_errno == EPIPE || result_errno == ECONNRESET)
                    appendPQExpBufferStr(&conn->errorMessage,
                                         libpq_gettext("server closed the connection unexpectedly\n"
                                                       "\tThis probably means the server terminated abnormally\n"
                                                       "\tbefore or while processing the request.\n"));
                else
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("SSL SYSCALL error: %s\n"),
                                      SOCK_STRERROR(result_errno,
                                                    sebuf, sizeof(sebuf)));
            }
            else
            {
                appendPQExpBufferStr(&conn->errorMessage,
                                     libpq_gettext("SSL SYSCALL error: EOF detected\n"));
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            {
                char       *errm = SSLerrmessage(ecode);

                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("SSL error: %s\n"), 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.
             */
            appendPQExpBufferStr(&conn->errorMessage,
                                 libpq_gettext("SSL connection has been closed unexpectedly\n"));
            result_errno = ECONNRESET;
            n = -1;
            break;
        default:
            appendPQExpBuffer(&conn->errorMessage,
                              libpq_gettext("unrecognized SSL error code: %d\n"),
                              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;
}

pqBuildErrorMessage3()

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

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

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().

{
    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');
        }
    }
}

pqBuildStartupPacket3()

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

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

References build_startup_packet(), and malloc.

Referenced by PQconnectPoll().

{
    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;
}

pqCheckInBufferSpace()

int pqCheckInBufferSpace	(	size_t	bytes_needed,
		PGconn *	conn
	)

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

References appendPQExpBufferStr(), 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().

{
    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;
}

pqCheckOutBufferSpace()

int pqCheckOutBufferSpace	(	size_t	bytes_needed,
		PGconn *	conn
	)

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

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

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

{
    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;
}

pqClearAsyncResult()

void pqClearAsyncResult

(

PGconn *

conn

)

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

References pg_conn::next_result, PQclear(), and pg_conn::result.

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

{
    if (conn->result)
        PQclear(conn->result);
    conn->result = NULL;
    if (conn->next_result)
        PQclear(conn->next_result);
    conn->next_result = NULL;
}

pqCommandQueueAdvance()

void pqCommandQueueAdvance

(

PGconn *

conn

)

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

References pg_conn::cmd_queue_head, PGcmdQueueEntry::next, and pqRecycleCmdQueueEntry().

Referenced by PQgetResult(), and pqParseInput3().

{
    PGcmdQueueEntry *prevquery;

    if (conn->cmd_queue_head == NULL)
        return;

    /* delink from queue */
    prevquery = conn->cmd_queue_head;
    conn->cmd_queue_head = conn->cmd_queue_head->next;

    /* and make it recyclable */
    prevquery->next = NULL;
    pqRecycleCmdQueueEntry(conn, prevquery);
}

pqDropConnection()

void pqDropConnection	(	PGconn *	conn,
		bool	flushInput
	)

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

References closesocket, free, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, pg_conn::outCount, pg_fe_scram_free(), PGINVALID_SOCKET, pqsecure_close(), pg_conn::sasl_state, and pg_conn::sock.

Referenced by closePGconn(), connectDBStart(), handleSyncLoss(), PQconnectPoll(), and pqReadData().

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

    /* Free authentication/encryption state */
#ifdef ENABLE_GSS
    {
        OM_uint32   min_s;

        if (conn->gcred != GSS_C_NO_CREDENTIAL)
        {
            gss_release_cred(&min_s, &conn->gcred);
            conn->gcred = GSS_C_NO_CREDENTIAL;
        }
        if (conn->gctx)
            gss_delete_sec_context(&min_s, &conn->gctx, GSS_C_NO_BUFFER);
        if (conn->gtarg_nam)
            gss_release_name(&min_s, &conn->gtarg_nam);
        if (conn->gss_SendBuffer)
        {
            free(conn->gss_SendBuffer);
            conn->gss_SendBuffer = NULL;
        }
        if (conn->gss_RecvBuffer)
        {
            free(conn->gss_RecvBuffer);
            conn->gss_RecvBuffer = NULL;
        }
        if (conn->gss_ResultBuffer)
        {
            free(conn->gss_ResultBuffer);
            conn->gss_ResultBuffer = NULL;
        }
        conn->gssenc = false;
    }
#endif
#ifdef ENABLE_SSPI
    if (conn->sspitarget)
    {
        free(conn->sspitarget);
        conn->sspitarget = NULL;
    }
    if (conn->sspicred)
    {
        FreeCredentialsHandle(conn->sspicred);
        free(conn->sspicred);
        conn->sspicred = NULL;
    }
    if (conn->sspictx)
    {
        DeleteSecurityContext(conn->sspictx);
        free(conn->sspictx);
        conn->sspictx = NULL;
    }
    conn->usesspi = 0;
#endif
    if (conn->sasl_state)
    {
        /*
         * XXX: if support for more authentication mechanisms is added, this
         * needs to call the right 'free' function.
         */
        pg_fe_scram_free(conn->sasl_state);
        conn->sasl_state = NULL;
    }
}

pqEndcopy3()

int pqEndcopy3

(

PGconn *

conn

)

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

References appendPQExpBufferStr(), pg_conn::asyncStatus, pg_conn::cmd_queue_head, PQExpBufferData::data, pg_conn::errorMessage, PQExpBufferData::len, libpq_gettext, 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, pqPutMsgEnd(), pqPutMsgStart(), PGcmdQueueEntry::queryclass, and pg_result::resultStatus.

Referenced by PQendcopy().

{
    PGresult   *result;

    if (conn->asyncStatus != PGASYNC_COPY_IN &&
        conn->asyncStatus != PGASYNC_COPY_OUT &&
        conn->asyncStatus != PGASYNC_COPY_BOTH)
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             libpq_gettext("no COPY in progress\n"));
        return 1;
    }

    /* Send the CopyDone message if needed */
    if (conn->asyncStatus == PGASYNC_COPY_IN ||
        conn->asyncStatus == PGASYNC_COPY_BOTH)
    {
        if (pqPutMsgStart('c', 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('S', 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;
}

pqFlush()

int pqFlush

(

PGconn *

conn

)

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

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

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

{
    if (conn->outCount > 0)
    {
        if (conn->Pfdebug)
            fflush(conn->Pfdebug);

        return pqSendSome(conn, conn->outCount);
    }

    return 0;
}

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 1948 of file fe-protocol3.c.

References appendPQExpBuffer(), Assert, pg_conn::errorMessage, getNotify(), getParameterStatus(), getReadyForQuery(), handleSyncLoss(), i, pg_conn::inBuffer, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, PQArgBlock::integer, PQArgBlock::len, libpq_gettext, pg_conn::Pfdebug, PGRES_COMMAND_OK, PGRES_FATAL_ERROR, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqCheckInBufferSpace(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetnchar(), PQmakeEmptyPGresult(), pqPrepareAsyncResult(), pqPutInt(), pqPutMsgEnd(), pqPutMsgStart(), pqPutnchar(), pqReadData(), pqSaveErrorResult(), pqTraceOutputMessage(), pqWait(), PQArgBlock::ptr, pg_conn::result, status(), and VALID_LONG_MESSAGE_TYPE.

Referenced by PQfn().

{
    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('F', conn) < 0 || /* function call msg */
        pqPutInt(fnid, 4, conn) < 0 ||  /* function id */
        pqPutInt(1, 2, conn) < 0 || /* # of format codes */
        pqPutInt(1, 2, conn) < 0 || /* format code: BINARY */
        pqPutInt(nargs, 2, conn) < 0)   /* # of args */
    {
        /* error message should be set up already */
        return NULL;
    }

    for (i = 0; i < nargs; ++i)
    {                           /* len.int4 + contents     */
        if (pqPutInt(args[i].len, 4, conn))
            return NULL;
        if (args[i].len == -1)
            continue;           /* it's NULL */

        if (args[i].isint)
        {
            if (pqPutInt(args[i].u.integer, args[i].len, conn))
                return NULL;
        }
        else
        {
            if (pqPutnchar((char *) args[i].u.ptr, args[i].len, conn))
                return NULL;
        }
    }

    if (pqPutInt(1, 2, conn) < 0)   /* result format code: BINARY */
        return NULL;

    if (pqPutMsgEnd(conn) < 0 ||
        pqFlush(conn))
        return NULL;

    for (;;)
    {
        if (needInput)
        {
            /* Wait for some data to arrive (or for the channel to close) */
            if (pqWait(true, false, conn) ||
                pqReadData(conn) < 0)
                break;
        }

        /*
         * Scan the message. If we run out of data, loop around to try again.
         */
        needInput = true;

        conn->inCursor = conn->inStart;
        if (pqGetc(&id, conn))
            continue;
        if (pqGetInt(&msgLength, 4, conn))
            continue;

        /*
         * Try to validate message type/length here.  A length less than 4 is
         * definitely broken.  Large lengths should only be believed for a few
         * message types.
         */
        if (msgLength < 4)
        {
            handleSyncLoss(conn, id, msgLength);
            break;
        }
        if (msgLength > 30000 && !VALID_LONG_MESSAGE_TYPE(id))
        {
            handleSyncLoss(conn, id, msgLength);
            break;
        }

        /*
         * Can't process if message body isn't all here yet.
         */
        msgLength -= 4;
        avail = conn->inEnd - conn->inCursor;
        if (avail < msgLength)
        {
            /*
             * Before looping, enlarge the input buffer if needed to hold the
             * whole message.  See notes in parseInput.
             */
            if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
                                     conn))
            {
                /*
                 * XXX add some better recovery code... plan is to skip over
                 * the message using its length, then report an error. For the
                 * moment, just treat this like loss of sync (which indeed it
                 * might be!)
                 */
                handleSyncLoss(conn, id, msgLength);
                break;
            }
            continue;
        }

        /*
         * We should see V or E response to the command, but might get N
         * and/or A notices first. We also need to swallow the final Z before
         * returning.
         */
        switch (id)
        {
            case 'V':           /* function result */
                if (pqGetInt(actual_result_len, 4, conn))
                    continue;
                if (*actual_result_len != -1)
                {
                    if (result_is_int)
                    {
                        if (pqGetInt(result_buf, *actual_result_len, conn))
                            continue;
                    }
                    else
                    {
                        if (pqGetnchar((char *) result_buf,
                                       *actual_result_len,
                                       conn))
                            continue;
                    }
                }
                /* correctly finished function result message */
                status = PGRES_COMMAND_OK;
                break;
            case 'E':           /* error return */
                if (pqGetErrorNotice3(conn, true))
                    continue;
                status = PGRES_FATAL_ERROR;
                break;
            case 'A':           /* notify message */
                /* handle notify and go back to processing return values */
                if (getNotify(conn))
                    continue;
                break;
            case 'N':           /* notice */
                /* handle notice and go back to processing return values */
                if (pqGetErrorNotice3(conn, false))
                    continue;
                break;
            case 'Z':           /* backend is ready for new query */
                if (getReadyForQuery(conn))
                    continue;
                /* consume the message and exit */
                conn->inStart += 5 + msgLength;
                /* if we saved a result object (probably an error), use it */
                if (conn->result)
                    return pqPrepareAsyncResult(conn);
                return PQmakeEmptyPGresult(conn, status);
            case 'S':           /* parameter status */
                if (getParameterStatus(conn))
                    continue;
                break;
            default:
                /* The backend violates the protocol. */
                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("protocol error: id=0x%x\n"),
                                  id);
                pqSaveErrorResult(conn);
                /* trust the specified message length as what to skip */
                conn->inStart += 5 + msgLength;
                return pqPrepareAsyncResult(conn);
        }

        /* trace server-to-client message */
        if (conn->Pfdebug)
            pqTraceOutputMessage(conn, conn->inBuffer + conn->inStart, false);

        /* Completed this message, keep going */
        /* trust the specified message length as what to skip */
        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);
}

pqGetc()

int pqGetc	(	char *	result,
		PGconn *	conn
	)

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

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

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

{
    if (conn->inCursor >= conn->inEnd)
        return EOF;

    *result = conn->inBuffer[conn->inCursor++];

    return 0;
}

pqGetCopyData3()

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

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

References appendPQExpBufferStr(), pg_conn::errorMessage, getCopyDataMessage(), pg_conn::inBuffer, pg_conn::inCursor, pg_conn::inStart, libpq_gettext, malloc, pqReadData(), and pqWait().

Referenced by PQgetCopyData().

{
    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)
            {
                appendPQExpBufferStr(&conn->errorMessage,
                                     libpq_gettext("out of memory\n"));
                return -2;
            }
            memcpy(*buffer, &conn->inBuffer[conn->inCursor], msgLength);
            (*buffer)[msgLength] = '\0';    /* Add terminating null */

            /* Mark message consumed */
            conn->inStart = conn->inCursor + msgLength;

            return msgLength;
        }

        /* Empty, so drop it and loop around for another */
        conn->inStart = conn->inCursor;
    }
}

pqGetErrorNotice3()

int pqGetErrorNotice3	(	PGconn *	conn,
		bool	isError
	)

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

References appendPQExpBufferStr(), pg_conn::cmd_queue_head, PQExpBufferData::data, pg_result::errMsg, pg_conn::errorMessage, pg_result::errQuery, initPQExpBuffer(), pg_conn::last_sqlstate, 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(), 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().

{
    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)
    {
        if (res)
            res->errMsg = pqResultStrdup(res, workBuf.data);
        pqClearAsyncResult(conn);   /* redundant, but be safe */
        conn->result = res;
        if (PQExpBufferDataBroken(workBuf))
            appendPQExpBufferStr(&conn->errorMessage,
                                 libpq_gettext("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. */
            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;
}

pqGetHomeDirectory()

bool pqGetHomeDirectory	(	char *	buf,
		int	bufsize
	)

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

References pqGetpwuid(), snprintf, and strlcpy().

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

{
#ifndef WIN32
    char        pwdbuf[BUFSIZ];
    struct passwd pwdstr;
    struct passwd *pwd = NULL;

    (void) pqGetpwuid(geteuid(), &pwdstr, pwdbuf, sizeof(pwdbuf), &pwd);
    if (pwd == NULL)
        return false;
    strlcpy(buf, pwd->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
}

pqGetInt()

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

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

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

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

{
    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;
}

pqGetline3()

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

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

References appendPQExpBufferStr(), pg_conn::asyncStatus, pg_conn::copy_is_binary, pg_conn::errorMessage, libpq_gettext, PGASYNC_COPY_BOTH, PGASYNC_COPY_OUT, PGINVALID_SOCKET, PQgetlineAsync(), pqReadData(), pqWait(), pg_conn::sock, and status().

Referenced by PQgetline().

{
    int         status;

    if (conn->sock == PGINVALID_SOCKET ||
        (conn->asyncStatus != PGASYNC_COPY_OUT &&
         conn->asyncStatus != PGASYNC_COPY_BOTH) ||
        conn->copy_is_binary)
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             libpq_gettext("PQgetline: not doing text COPY OUT\n"));
        *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;
    }
}

pqGetlineAsync3()

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

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

References pg_conn::asyncStatus, 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().

{
    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;
    }
}

pqGetnchar()

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

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

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

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

{
    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;
}

pqGets()

int pqGets	(	PQExpBuffer	buf,
		PGconn *	conn
	)

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

References pqGets_internal().

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

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

pqGets_append()

int pqGets_append	(	PQExpBuffer	buf,
		PGconn *	conn
	)

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

References pqGets_internal().

Referenced by PQconnectPoll().

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

pqInternalNotice()

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

pqPacketSend()

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

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

References appendPQExpBuffer(), appendPQExpBufferStr(), DefaultHost, free, hostname, i, _internalPQconninfoOption::keyword, _PQconninfoOption::keyword, libpq_gettext, malloc, pg_strcasecmp(), pg_strncasecmp(), port, pqFlush(), pqPutMsgEnd(), pqPutMsgStart(), pqPutnchar(), STATUS_ERROR, STATUS_OK, _internalPQconninfoOption::val, _PQconninfoOption::val, and values.

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

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

pqParseInput3()

void pqParseInput3

(

PGconn *

conn

)

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

References appendPQExpBuffer(), appendPQExpBufferStr(), pg_conn::asyncStatus, pg_conn::be_key, pg_conn::be_pid, pg_conn::cmd_queue_head, pg_result::cmdStatus, CMDSTATUS_LEN, pg_conn::copy_already_done, PQExpBufferData::data, pg_conn::errorMessage, getAnotherTuple(), getCopyStart(), getNotify(), getParamDescriptions(), getParameterStatus(), getReadyForQuery(), getRowDescriptions(), handleSyncLoss(), pg_conn::inBuffer, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, libpq_gettext, pg_conn::noticeHooks, pg_conn::Pfdebug, PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_READY, PGQUERY_DESCRIBE, PGQUERY_PREPARE, PGQUERY_SIMPLE, PGRES_COMMAND_OK, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_EMPTY_QUERY, PGRES_FATAL_ERROR, PGRES_PIPELINE_SYNC, PGRES_TUPLES_OK, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PQ_PIPELINE_ON, pqCheckInBufferSpace(), pqCommandQueueAdvance(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGets(), pqInternalNotice(), PQmakeEmptyPGresult(), pqSaveErrorResult(), pqTraceOutputMessage(), PGcmdQueueEntry::queryclass, pg_conn::result, pg_result::resultStatus, strlcpy(), VALID_LONG_MESSAGE_TYPE, and pg_conn::workBuffer.

Referenced by parseInput().

{
    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 == 'A')
        {
            if (getNotify(conn))
                return;
        }
        else if (id == 'N')
        {
            if (pqGetErrorNotice3(conn, false))
                return;
        }
        else if (conn->asyncStatus != PGASYNC_BUSY)
        {
            /* If not IDLE state, just wait ... */
            if (conn->asyncStatus != PGASYNC_IDLE)
                return;

            /*
             * We're also notionally not-IDLE when in pipeline mode the state
             * says "idle" (so we have completed receiving the results of one
             * query from the server and dispatched them to the application)
             * but another query is queued; yield back control to caller so
             * that they can initiate processing of the next query in the
             * queue.
             */
            if (conn->pipelineStatus != PQ_PIPELINE_OFF &&
                conn->cmd_queue_head != NULL)
                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 == 'E')
            {
                if (pqGetErrorNotice3(conn, false /* treat as notice */ ))
                    return;
            }
            else if (id == 'S')
            {
                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 'C':       /* command complete */
                    if (pqGets(&conn->workBuffer, conn))
                        return;
                    if (conn->result == NULL)
                    {
                        conn->result = PQmakeEmptyPGresult(conn,
                                                           PGRES_COMMAND_OK);
                        if (!conn->result)
                        {
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("out of memory"));
                            pqSaveErrorResult(conn);
                        }
                    }
                    if (conn->result)
                        strlcpy(conn->result->cmdStatus, conn->workBuffer.data,
                                CMDSTATUS_LEN);
                    conn->asyncStatus = PGASYNC_READY;
                    break;
                case 'E':       /* error return */
                    if (pqGetErrorNotice3(conn, true))
                        return;
                    conn->asyncStatus = PGASYNC_READY;
                    break;
                case 'Z':       /* sync response, backend is ready for new
                                 * query */
                    if (getReadyForQuery(conn))
                        return;
                    if (conn->pipelineStatus != PQ_PIPELINE_OFF)
                    {
                        conn->result = PQmakeEmptyPGresult(conn,
                                                           PGRES_PIPELINE_SYNC);
                        if (!conn->result)
                        {
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("out of memory"));
                            pqSaveErrorResult(conn);
                        }
                        else
                        {
                            conn->pipelineStatus = PQ_PIPELINE_ON;
                            conn->asyncStatus = PGASYNC_READY;
                        }
                    }
                    else
                    {
                        /*
                         * In simple query protocol, advance the command queue
                         * (see PQgetResult).
                         */
                        if (conn->cmd_queue_head &&
                            conn->cmd_queue_head->queryclass == PGQUERY_SIMPLE)
                            pqCommandQueueAdvance(conn);
                        conn->asyncStatus = PGASYNC_IDLE;
                    }
                    break;
                case 'I':       /* empty query */
                    if (conn->result == NULL)
                    {
                        conn->result = PQmakeEmptyPGresult(conn,
                                                           PGRES_EMPTY_QUERY);
                        if (!conn->result)
                        {
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("out of memory"));
                            pqSaveErrorResult(conn);
                        }
                    }
                    conn->asyncStatus = PGASYNC_READY;
                    break;
                case '1':       /* Parse Complete */
                    /* If we're doing PQprepare, we're done; else ignore */
                    if (conn->cmd_queue_head &&
                        conn->cmd_queue_head->queryclass == PGQUERY_PREPARE)
                    {
                        if (conn->result == NULL)
                        {
                            conn->result = PQmakeEmptyPGresult(conn,
                                                               PGRES_COMMAND_OK);
                            if (!conn->result)
                            {
                                appendPQExpBufferStr(&conn->errorMessage,
                                                     libpq_gettext("out of memory"));
                                pqSaveErrorResult(conn);
                            }
                        }
                        conn->asyncStatus = PGASYNC_READY;
                    }
                    break;
                case '2':       /* Bind Complete */
                case '3':       /* Close Complete */
                    /* Nothing to do for these message types */
                    break;
                case 'S':       /* parameter status */
                    if (getParameterStatus(conn))
                        return;
                    break;
                case 'K':       /* secret key data from the backend */

                    /*
                     * This is expected only during backend startup, but it's
                     * just as easy to handle it as part of the main loop.
                     * Save the data and continue processing.
                     */
                    if (pqGetInt(&(conn->be_pid), 4, conn))
                        return;
                    if (pqGetInt(&(conn->be_key), 4, conn))
                        return;
                    break;
                case 'T':       /* Row Description */
                    if (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 'n':       /* No Data */

                    /*
                     * 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 (conn->result == NULL)
                        {
                            conn->result = PQmakeEmptyPGresult(conn,
                                                               PGRES_COMMAND_OK);
                            if (!conn->result)
                            {
                                appendPQExpBufferStr(&conn->errorMessage,
                                                     libpq_gettext("out of memory"));
                                pqSaveErrorResult(conn);
                            }
                        }
                        conn->asyncStatus = PGASYNC_READY;
                    }
                    break;
                case 't':       /* Parameter Description */
                    if (getParamDescriptions(conn, msgLength))
                        return;
                    break;
                case 'D':       /* Data Row */
                    if (conn->result != NULL &&
                        conn->result->resultStatus == PGRES_TUPLES_OK)
                    {
                        /* Read another tuple of a normal query response */
                        if (getAnotherTuple(conn, msgLength))
                            return;
                    }
                    else if (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 */
                        appendPQExpBufferStr(&conn->errorMessage,
                                             libpq_gettext("server sent data (\"D\" message) without prior row description (\"T\" message)\n"));
                        pqSaveErrorResult(conn);
                        /* Discard the unexpected message */
                        conn->inCursor += msgLength;
                    }
                    break;
                case 'G':       /* Start Copy In */
                    if (getCopyStart(conn, PGRES_COPY_IN))
                        return;
                    conn->asyncStatus = PGASYNC_COPY_IN;
                    break;
                case 'H':       /* Start Copy Out */
                    if (getCopyStart(conn, PGRES_COPY_OUT))
                        return;
                    conn->asyncStatus = PGASYNC_COPY_OUT;
                    conn->copy_already_done = 0;
                    break;
                case 'W':       /* Start Copy Both */
                    if (getCopyStart(conn, PGRES_COPY_BOTH))
                        return;
                    conn->asyncStatus = PGASYNC_COPY_BOTH;
                    conn->copy_already_done = 0;
                    break;
                case 'd':       /* Copy Data */

                    /*
                     * 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 'c':       /* Copy Done */

                    /*
                     * 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:
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("unexpected response from server; first received character was \"%c\"\n"),
                                      id);
                    /* build an error result holding the error message */
                    pqSaveErrorResult(conn);
                    /* 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)
        {
            /* trace server-to-client message */
            if (conn->Pfdebug)
                pqTraceOutputMessage(conn, conn->inBuffer + conn->inStart, false);

            /* Normal case: parsing agrees with specified length */
            conn->inStart = conn->inCursor;
        }
        else
        {
            /* Trouble --- report it */
            appendPQExpBuffer(&conn->errorMessage,
                              libpq_gettext("message contents do not agree with length in message type \"%c\"\n"),
                              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;
        }
    }
}

pqPrepareAsyncResult()

PGresult* pqPrepareAsyncResult

(

PGconn *

conn

)

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

References pg_conn::next_result, PGRES_FATAL_ERROR, PQmakeEmptyPGresult(), and pg_conn::result.

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

{
    PGresult   *res;

    /*
     * conn->result is the PGresult to return.  If it is NULL (which probably
     * shouldn't happen) we assume there is an appropriate error message in
     * conn->errorMessage.
     */
    res = conn->result;
    if (!res)
        res = PQmakeEmptyPGresult(conn, PGRES_FATAL_ERROR);

    /*
     * Replace conn->result with next_result, if any.  In the normal case
     * there isn't a next result and we're just dropping ownership of the
     * current result.  In single-row mode this restores the situation to what
     * it was before we created the current single-row result.
     */
    conn->result = conn->next_result;
    conn->next_result = NULL;

    return res;
}

pqPutc()

int pqPutc	(	char	c,
		PGconn *	conn
	)

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

References pqPutMsgBytes().

Referenced by PQsendDescribe(), PQsendQueryGuts(), and PQsendQueryInternal().

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

    return 0;
}

pqPutInt()

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

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

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

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

{
    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;
}

pqPutMsgEnd()

int pqPutMsgEnd

(

PGconn *

conn

)

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

References 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(), PQpipelineSync(), PQputCopyData(), PQputCopyEnd(), PQsendDescribe(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and sendTerminateConn().

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

pqPutMsgStart()

int pqPutMsgStart	(	char	msg_type,
		PGconn *	conn
	)

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

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

Referenced by pg_SASL_init(), pqEndcopy3(), pqFunctionCall3(), pqPacketSend(), PQpipelineSync(), PQputCopyData(), PQputCopyEnd(), PQsendDescribe(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and sendTerminateConn().

{
    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;
}

pqPutnchar()

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

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

References pqPutMsgBytes().

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

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

    return 0;
}

pqPuts()

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

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

References pqPutMsgBytes().

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

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

    return 0;
}

pqReadData()

int pqReadData

(

PGconn *

conn

)

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

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

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

{
    int         someread = 0;
    int         nread;

    if (conn->sock == PGINVALID_SOCKET)
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             libpq_gettext("connection not open\n"));
        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:
    appendPQExpBufferStr(&conn->errorMessage,
                         libpq_gettext("server closed the connection unexpectedly\n"
                                       "\tThis probably means the server terminated abnormally\n"
                                       "\tbefore or while processing the request.\n"));

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

pqReadReady()

int pqReadReady

(

PGconn *

conn

)

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

References pqSocketCheck().

Referenced by gss_read(), and pqReadData().

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

pqResultAlloc()

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

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

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().

{
    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;
}

pqResultStrdup()

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

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

References pqResultAlloc().

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

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

    if (space)
        strcpy(space, str);
    return space;
}

pqRowProcessor()

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

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

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

Referenced by getAnotherTuple().

{
    PGresult   *res = conn->result;
    int         nfields = res->numAttributes;
    const PGdataValue *columns = conn->rowBuf;
    PGresAttValue *tup;
    int         i;

    /*
     * In single-row mode, make a new PGresult that will hold just this one
     * row; the original conn->result is left unchanged so that it can be used
     * again as the template for future rows.
     */
    if (conn->singleRowMode)
    {
        /* 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;
    }

    /*
     * 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)
        goto fail;

    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)
                goto fail;

            /* 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))
        goto fail;

    /*
     * Success.  In single-row mode, make the result available to the client
     * immediately.
     */
    if (conn->singleRowMode)
    {
        /* Change result status to special single-row value */
        res->resultStatus = PGRES_SINGLE_TUPLE;
        /* Stash old result for re-use later */
        conn->next_result = conn->result;
        conn->result = res;
        /* And mark the result ready to return */
        conn->asyncStatus = PGASYNC_READY_MORE;
    }

    return 1;

fail:
    /* release locally allocated PGresult, if we made one */
    if (res != conn->result)
        PQclear(res);
    return 0;
}

pqSaveErrorResult()

void pqSaveErrorResult

(

PGconn *

conn

)

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

References PGRES_FATAL_ERROR, pqClearAsyncResult(), PQmakeEmptyPGresult(), and pg_conn::result.

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

{
    pqClearAsyncResult(conn);
    conn->result = PQmakeEmptyPGresult(conn, PGRES_FATAL_ERROR);
}

pqSaveMessageField()

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

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

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

Referenced by pqGetErrorNotice3(), and pqInternalNotice().

{
    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;
}

pqSaveParameterStatus()

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

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

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

Referenced by getParameterStatus().

{
    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;
    }
}

pqsecure_close()

void pqsecure_close

(

PGconn *

)

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

References pgtls_close().

Referenced by pqDropConnection().

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

pqsecure_initialize()

int pqsecure_initialize	(	PGconn *	,
		bool	,
		bool
	)

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

References pgtls_init().

Referenced by PQconnectPoll().

{
    int         r = 0;

#ifdef USE_SSL
    r = pgtls_init(conn, do_ssl, do_crypto);
#endif

    return r;
}

pqsecure_open_client()

PostgresPollingStatusType pqsecure_open_client

(

PGconn *

)

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

References PGRES_POLLING_FAILED, and pgtls_open_client().

Referenced by PQconnectPoll().

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

pqsecure_raw_read()

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

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

References appendPQExpBuffer(), appendPQExpBufferStr(), EAGAIN, ECONNRESET, EINTR, pg_conn::errorMessage, EWOULDBLOCK, libpq_gettext, PG_STRERROR_R_BUFLEN, recv, pg_conn::sock, SOCK_ERRNO, SOCK_ERRNO_SET, and SOCK_STRERROR.

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

{
    ssize_t     n;
    int         result_errno = 0;
    char        sebuf[PG_STRERROR_R_BUFLEN];

    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:
                appendPQExpBufferStr(&conn->errorMessage,
                                     libpq_gettext("server closed the connection unexpectedly\n"
                                                   "\tThis probably means the server terminated abnormally\n"
                                                   "\tbefore or while processing the request.\n"));
                break;

            default:
                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("could not receive data from server: %s\n"),
                                  SOCK_STRERROR(result_errno,
                                                sebuf, sizeof(sebuf)));
                break;
        }
    }

    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);

    return n;
}

pqsecure_raw_write()

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

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

References appendPQExpBuffer(), appendPQExpBufferStr(), DECLARE_SIGPIPE_INFO, DISABLE_SIGPIPE, EAGAIN, ECONNRESET, EINTR, pg_conn::errorMessage, EWOULDBLOCK, libpq_gettext, PG_STRERROR_R_BUFLEN, REMEMBER_EPIPE, RESTORE_SIGPIPE, send, pg_conn::sigpipe_flag, pg_conn::sock, SOCK_ERRNO, SOCK_ERRNO_SET, and SOCK_STRERROR.

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

{
    ssize_t     n;
    int         flags = 0;
    int         result_errno = 0;
    char        sebuf[PG_STRERROR_R_BUFLEN];

    DECLARE_SIGPIPE_INFO(spinfo);

#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:
                appendPQExpBufferStr(&conn->errorMessage,
                                     libpq_gettext("server closed the connection unexpectedly\n"
                                                   "\tThis probably means the server terminated abnormally\n"
                                                   "\tbefore or while processing the request.\n"));
                break;

            default:
                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("could not send data to server: %s\n"),
                                  SOCK_STRERROR(result_errno,
                                                sebuf, sizeof(sebuf)));
                break;
        }
    }

    RESTORE_SIGPIPE(conn, spinfo);

    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);

    return n;
}

pqsecure_read()

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

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

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

Referenced by pqReadData().

{
    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;
}

pqsecure_write()

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

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

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

Referenced by pqSendSome().

{
    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;
}

PQsendQueryContinue()

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

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

References PQsendQueryInternal().

Referenced by PQconnectPoll().

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

pqSetResultError()

void pqSetResultError	(	PGresult *	res,
		const char *	msg
	)

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

References pg_result::errMsg, and pqResultStrdup().

Referenced by PQgetResult(), and PQmakeEmptyPGresult().

{
    if (!res)
        return;
    if (msg && *msg)
        res->errMsg = pqResultStrdup(res, msg);
    else
        res->errMsg = NULL;
}

pqSkipnchar()

int pqSkipnchar	(	size_t	len,
		PGconn *	conn
	)

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

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

Referenced by getAnotherTuple().

{
    if (len > (size_t) (conn->inEnd - conn->inCursor))
        return EOF;

    conn->inCursor += len;

    return 0;
}

pqTraceOutputMessage()

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

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

References fprintf, pg_conn::Pfdebug, pg_ntoh32, PQTRACE_REGRESS_MODE, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), pqTraceOutputA(), pqTraceOutputB(), pqTraceOutputC(), pqTraceOutputD(), pqTraceOutputE(), pqTraceOutputf(), pqTraceOutputF(), pqTraceOutputG(), pqTraceOutputH(), pqTraceOutputK(), pqTraceOutputNR(), pqTraceOutputP(), pqTraceOutputQ(), pqTraceOutputR(), pqTraceOutputS(), pqTraceOutputt(), pqTraceOutputT(), pqTraceOutputv(), pqTraceOutputV(), pqTraceOutputW(), pqTraceOutputZ(), and pg_conn::traceFlags.

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

{
    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 == 'E' || id == 'N'))
        fprintf(conn->Pfdebug, "%s\tNN\t", prefix);
    else
        fprintf(conn->Pfdebug, "%s\t%d\t", prefix, length);

    switch (id)
    {
        case '1':
            fprintf(conn->Pfdebug, "ParseComplete");
            /* No message content */
            break;
        case '2':
            fprintf(conn->Pfdebug, "BindComplete");
            /* No message content */
            break;
        case '3':
            fprintf(conn->Pfdebug, "CloseComplete");
            /* No message content */
            break;
        case 'A':               /* Notification Response */
            pqTraceOutputA(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'B':               /* Bind */
            pqTraceOutputB(conn->Pfdebug, message, &logCursor);
            break;
        case 'c':
            fprintf(conn->Pfdebug, "CopyDone");
            /* No message content */
            break;
        case 'C':               /* Close(F) or Command Complete(B) */
            pqTraceOutputC(conn->Pfdebug, toServer, message, &logCursor);
            break;
        case 'd':               /* Copy Data */
            /* Drop COPY data to reduce the overhead of logging. */
            break;
        case 'D':               /* Describe(F) or Data Row(B) */
            pqTraceOutputD(conn->Pfdebug, toServer, message, &logCursor);
            break;
        case 'E':               /* Execute(F) or Error Response(B) */
            pqTraceOutputE(conn->Pfdebug, toServer, message, &logCursor,
                           regress);
            break;
        case 'f':               /* Copy Fail */
            pqTraceOutputf(conn->Pfdebug, message, &logCursor);
            break;
        case 'F':               /* Function Call */
            pqTraceOutputF(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'G':               /* Start Copy In */
            pqTraceOutputG(conn->Pfdebug, message, &logCursor);
            break;
        case 'H':               /* Flush(F) or Start Copy Out(B) */
            if (!toServer)
                pqTraceOutputH(conn->Pfdebug, message, &logCursor);
            else
                fprintf(conn->Pfdebug, "Flush");    /* no message content */
            break;
        case 'I':
            fprintf(conn->Pfdebug, "EmptyQueryResponse");
            /* No message content */
            break;
        case 'K':               /* secret key data from the backend */
            pqTraceOutputK(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'n':
            fprintf(conn->Pfdebug, "NoData");
            /* No message content */
            break;
        case 'N':
            pqTraceOutputNR(conn->Pfdebug, "NoticeResponse", message,
                            &logCursor, regress);
            break;
        case 'P':               /* Parse */
            pqTraceOutputP(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'Q':               /* Query */
            pqTraceOutputQ(conn->Pfdebug, message, &logCursor);
            break;
        case 'R':               /* Authentication */
            pqTraceOutputR(conn->Pfdebug, message, &logCursor);
            break;
        case 's':
            fprintf(conn->Pfdebug, "PortalSuspended");
            /* No message content */
            break;
        case 'S':               /* Parameter Status(B) or Sync(F) */
            if (!toServer)
                pqTraceOutputS(conn->Pfdebug, message, &logCursor);
            else
                fprintf(conn->Pfdebug, "Sync"); /* no message content */
            break;
        case 't':               /* Parameter Description */
            pqTraceOutputt(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'T':               /* Row Description */
            pqTraceOutputT(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'v':               /* Negotiate Protocol Version */
            pqTraceOutputv(conn->Pfdebug, message, &logCursor);
            break;
        case 'V':               /* Function Call response */
            pqTraceOutputV(conn->Pfdebug, message, &logCursor);
            break;
        case 'W':               /* Start Copy Both */
            pqTraceOutputW(conn->Pfdebug, message, &logCursor, length);
            break;
        case 'X':
            fprintf(conn->Pfdebug, "Terminate");
            /* No message content */
            break;
        case 'Z':               /* Ready For Query */
            pqTraceOutputZ(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);
}

pqTraceOutputNoTypeByteMessage()

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

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

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

Referenced by pqPutMsgEnd().

{
    int         length;
    int         logCursor = 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);

    switch (length)
    {
        case 16:                /* CancelRequest */
            fprintf(conn->Pfdebug, "CancelRequest\t");
            pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
            pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
            pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
            break;
        case 8:                 /* GSSENCRequest or SSLRequest */
            /* These messages do not reach here. */
        default:
            fprintf(conn->Pfdebug, "Unknown message: length is %d", length);
            break;
    }

    fputc('\n', conn->Pfdebug);
}

pqWait()

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

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

References pqWaitTimed().

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

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

pqWaitTimed()

int pqWaitTimed	(	int	forRead,
		int	forWrite,
		PGconn *	conn,
		time_t	finish_time
	)

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

References appendPQExpBufferStr(), pg_conn::errorMessage, libpq_gettext, and pqSocketCheck().

Referenced by connectDBComplete(), and pqWait().

{
    int         result;

    result = pqSocketCheck(conn, forRead, forWrite, finish_time);

    if (result < 0)
        return -1;              /* errorMessage is already set */

    if (result == 0)
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             libpq_gettext("timeout expired\n"));
        return 1;
    }

    return 0;
}

pqWriteReady()

int pqWriteReady

(

PGconn *

conn

)

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

References pqSocketCheck().

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

Variable Documentation

pgresStatus

char* const pgresStatus[]

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

Referenced by PQresStatus().