libpq-fe.h File Reference

#include <stdint.h>
#include <stdio.h>
#include "postgres_ext.h"

Include dependency graph for libpq-fe.h:

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

Go to the source code of this file.

Data Structures
struct	pgNotify
struct	_PQprintOpt
struct	_PQconninfoOption
struct	PQArgBlock
struct	pgresAttDesc
struct	_PGpromptOAuthDevice
struct	PGoauthBearerRequest

Macros
#define	LIBPQ_HAS_PIPELINING   1
#define	LIBPQ_HAS_TRACE_FLAGS   1
#define	LIBPQ_HAS_SSL_LIBRARY_DETECTION   1
#define	LIBPQ_HAS_ASYNC_CANCEL   1
#define	LIBPQ_HAS_CHANGE_PASSWORD   1
#define	LIBPQ_HAS_CHUNK_MODE   1
#define	LIBPQ_HAS_CLOSE_PREPARED   1
#define	LIBPQ_HAS_SEND_PIPELINE_SYNC   1
#define	LIBPQ_HAS_SOCKET_POLL   1
#define	LIBPQ_HAS_FULL_PROTOCOL_VERSION   1
#define	LIBPQ_HAS_PROMPT_OAUTH_DEVICE   1
#define	PG_COPYRES_ATTRS   0x01
#define	PG_COPYRES_TUPLES   0x02 /* Implies PG_COPYRES_ATTRS */
#define	PG_COPYRES_EVENTS   0x04
#define	PG_COPYRES_NOTICEHOOKS   0x08
#define	PQsetdb(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME)    PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, NULL, NULL)
#define	PQTRACE_SUPPRESS_TIMESTAMPS   (1<<0)
#define	PQTRACE_REGRESS_MODE   (1<<1)
#define	PQ_QUERY_PARAM_MAX_LIMIT   65535
#define	PQfreeNotify(ptr)   PQfreemem(ptr)
#define	PQnoPasswordSupplied   "fe_sendauth: no password supplied\n"
#define	SOCKTYPE   int

Typedefs
typedef struct pg_conn	PGconn
typedef struct pg_cancel_conn	PGcancelConn
typedef struct pg_result	PGresult
typedef struct pg_cancel	PGcancel
typedef struct pgNotify	PGnotify
typedef int64_t	pg_usec_time_t
typedef void(*	PQnoticeReceiver) (void *arg, const PGresult *res)
typedef void(*	PQnoticeProcessor) (void *arg, const char *message)
typedef char	pqbool
typedef struct _PQprintOpt	PQprintOpt
typedef struct _PQconninfoOption	PQconninfoOption
typedef struct pgresAttDesc	PGresAttDesc
typedef void(*	pgthreadlock_t) (int acquire)
typedef struct _PGpromptOAuthDevice	PGpromptOAuthDevice
typedef struct PGoauthBearerRequest	PGoauthBearerRequest
typedef int(*	PQauthDataHook_type) (PGauthData type, PGconn *conn, void *data)
typedef int(*	PQsslKeyPassHook_OpenSSL_type) (char *buf, int size, PGconn *conn)

Enumerations
enum	ConnStatusType {   CONNECTION_OK , CONNECTION_BAD , CONNECTION_STARTED , CONNECTION_MADE ,   CONNECTION_AWAITING_RESPONSE , CONNECTION_AUTH_OK , CONNECTION_SETENV , CONNECTION_SSL_STARTUP ,   CONNECTION_NEEDED , CONNECTION_CHECK_WRITABLE , CONNECTION_CONSUME , CONNECTION_GSS_STARTUP ,   CONNECTION_CHECK_TARGET , CONNECTION_CHECK_STANDBY , CONNECTION_ALLOCATED , CONNECTION_AUTHENTICATING }
enum	PostgresPollingStatusType {   PGRES_POLLING_FAILED = 0 , PGRES_POLLING_READING , PGRES_POLLING_WRITING , PGRES_POLLING_OK ,   PGRES_POLLING_ACTIVE }
enum	ExecStatusType {   PGRES_EMPTY_QUERY = 0 , PGRES_COMMAND_OK , PGRES_TUPLES_OK , PGRES_COPY_OUT ,   PGRES_COPY_IN , PGRES_BAD_RESPONSE , PGRES_NONFATAL_ERROR , PGRES_FATAL_ERROR ,   PGRES_COPY_BOTH , PGRES_SINGLE_TUPLE , PGRES_PIPELINE_SYNC , PGRES_PIPELINE_ABORTED ,   PGRES_TUPLES_CHUNK }
enum	PGTransactionStatusType {   PQTRANS_IDLE , PQTRANS_ACTIVE , PQTRANS_INTRANS , PQTRANS_INERROR ,   PQTRANS_UNKNOWN }
enum	PGVerbosity { PQERRORS_TERSE , PQERRORS_DEFAULT , PQERRORS_VERBOSE , PQERRORS_SQLSTATE }
enum	PGContextVisibility { PQSHOW_CONTEXT_NEVER , PQSHOW_CONTEXT_ERRORS , PQSHOW_CONTEXT_ALWAYS }
enum	PGPing { PQPING_OK , PQPING_REJECT , PQPING_NO_RESPONSE , PQPING_NO_ATTEMPT }
enum	PGpipelineStatus { PQ_PIPELINE_OFF , PQ_PIPELINE_ON , PQ_PIPELINE_ABORTED }
enum	PGauthData { PQAUTHDATA_PROMPT_OAUTH_DEVICE , PQAUTHDATA_OAUTH_BEARER_TOKEN }

Functions
PGconn *	PQconnectStart (const char *conninfo)
PGconn *	PQconnectStartParams (const char *const *keywords, const char *const *values, int expand_dbname)
PostgresPollingStatusType	PQconnectPoll (PGconn *conn)
PGconn *	PQconnectdb (const char *conninfo)
PGconn *	PQconnectdbParams (const char *const *keywords, const char *const *values, int expand_dbname)
PGconn *	PQsetdbLogin (const char *pghost, const char *pgport, const char *pgoptions, const char *pgtty, const char *dbName, const char *login, const char *pwd)
void	PQfinish (PGconn *conn)
PQconninfoOption *	PQconndefaults (void)
PQconninfoOption *	PQconninfoParse (const char *conninfo, char **errmsg)
PQconninfoOption *	PQconninfo (PGconn *conn)
void	PQconninfoFree (PQconninfoOption *connOptions)
int	PQresetStart (PGconn *conn)
PostgresPollingStatusType	PQresetPoll (PGconn *conn)
void	PQreset (PGconn *conn)
PGcancelConn *	PQcancelCreate (PGconn *conn)
int	PQcancelStart (PGcancelConn *cancelConn)
int	PQcancelBlocking (PGcancelConn *cancelConn)
PostgresPollingStatusType	PQcancelPoll (PGcancelConn *cancelConn)
ConnStatusType	PQcancelStatus (const PGcancelConn *cancelConn)
int	PQcancelSocket (const PGcancelConn *cancelConn)
char *	PQcancelErrorMessage (const PGcancelConn *cancelConn)
void	PQcancelReset (PGcancelConn *cancelConn)
void	PQcancelFinish (PGcancelConn *cancelConn)
PGcancel *	PQgetCancel (PGconn *conn)
void	PQfreeCancel (PGcancel *cancel)
int	PQcancel (PGcancel *cancel, char *errbuf, int errbufsize)
int	PQrequestCancel (PGconn *conn)
char *	PQdb (const PGconn *conn)
char *	PQuser (const PGconn *conn)
char *	PQpass (const PGconn *conn)
char *	PQhost (const PGconn *conn)
char *	PQhostaddr (const PGconn *conn)
char *	PQport (const PGconn *conn)
char *	PQtty (const PGconn *conn)
char *	PQoptions (const PGconn *conn)
ConnStatusType	PQstatus (const PGconn *conn)
PGTransactionStatusType	PQtransactionStatus (const PGconn *conn)
const char *	PQparameterStatus (const PGconn *conn, const char *paramName)
int	PQprotocolVersion (const PGconn *conn)
int	PQfullProtocolVersion (const PGconn *conn)
int	PQserverVersion (const PGconn *conn)
char *	PQerrorMessage (const PGconn *conn)
int	PQsocket (const PGconn *conn)
int	PQbackendPID (const PGconn *conn)
PGpipelineStatus	PQpipelineStatus (const PGconn *conn)
int	PQconnectionNeedsPassword (const PGconn *conn)
int	PQconnectionUsedPassword (const PGconn *conn)
int	PQconnectionUsedGSSAPI (const PGconn *conn)
int	PQclientEncoding (const PGconn *conn)
int	PQsetClientEncoding (PGconn *conn, const char *encoding)
int	PQsslInUse (PGconn *conn)
void *	PQsslStruct (PGconn *conn, const char *struct_name)
const char *	PQsslAttribute (PGconn *conn, const char *attribute_name)
const char *const *	PQsslAttributeNames (PGconn *conn)
void *	PQgetssl (PGconn *conn)
void	PQinitSSL (int do_init)
void	PQinitOpenSSL (int do_ssl, int do_crypto)
int	PQgssEncInUse (PGconn *conn)
void *	PQgetgssctx (PGconn *conn)
PGVerbosity	PQsetErrorVerbosity (PGconn *conn, PGVerbosity verbosity)
PGContextVisibility	PQsetErrorContextVisibility (PGconn *conn, PGContextVisibility show_context)
PQnoticeReceiver	PQsetNoticeReceiver (PGconn *conn, PQnoticeReceiver proc, void *arg)
PQnoticeProcessor	PQsetNoticeProcessor (PGconn *conn, PQnoticeProcessor proc, void *arg)
pgthreadlock_t	PQregisterThreadLock (pgthreadlock_t newhandler)
void	PQtrace (PGconn *conn, FILE *debug_port)
void	PQuntrace (PGconn *conn)
void	PQsetTraceFlags (PGconn *conn, int flags)
PGresult *	PQexec (PGconn *conn, const char *query)
PGresult *	PQexecParams (PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
PGresult *	PQprepare (PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
PGresult *	PQexecPrepared (PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
int	PQsendQuery (PGconn *conn, const char *query)
int	PQsendQueryParams (PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
int	PQsendPrepare (PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
int	PQsendQueryPrepared (PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
int	PQsetSingleRowMode (PGconn *conn)
int	PQsetChunkedRowsMode (PGconn *conn, int chunkSize)
PGresult *	PQgetResult (PGconn *conn)
int	PQisBusy (PGconn *conn)
int	PQconsumeInput (PGconn *conn)
int	PQenterPipelineMode (PGconn *conn)
int	PQexitPipelineMode (PGconn *conn)
int	PQpipelineSync (PGconn *conn)
int	PQsendFlushRequest (PGconn *conn)
int	PQsendPipelineSync (PGconn *conn)
PGnotify *	PQnotifies (PGconn *conn)
int	PQputCopyData (PGconn *conn, const char *buffer, int nbytes)
int	PQputCopyEnd (PGconn *conn, const char *errormsg)
int	PQgetCopyData (PGconn *conn, char **buffer, int async)
int	PQgetline (PGconn *conn, char *buffer, int length)
int	PQputline (PGconn *conn, const char *string)
int	PQgetlineAsync (PGconn *conn, char *buffer, int bufsize)
int	PQputnbytes (PGconn *conn, const char *buffer, int nbytes)
int	PQendcopy (PGconn *conn)
int	PQsetnonblocking (PGconn *conn, int arg)
int	PQisnonblocking (const PGconn *conn)
int	PQisthreadsafe (void)
PGPing	PQping (const char *conninfo)
PGPing	PQpingParams (const char *const *keywords, const char *const *values, int expand_dbname)
int	PQflush (PGconn *conn)
PGresult *	PQfn (PGconn *conn, int fnid, int *result_buf, int *result_len, int result_is_int, const PQArgBlock *args, int nargs)
ExecStatusType	PQresultStatus (const PGresult *res)
char *	PQresStatus (ExecStatusType status)
char *	PQresultErrorMessage (const PGresult *res)
char *	PQresultVerboseErrorMessage (const PGresult *res, PGVerbosity verbosity, PGContextVisibility show_context)
char *	PQresultErrorField (const PGresult *res, int fieldcode)
int	PQntuples (const PGresult *res)
int	PQnfields (const PGresult *res)
int	PQbinaryTuples (const PGresult *res)
char *	PQfname (const PGresult *res, int field_num)
int	PQfnumber (const PGresult *res, const char *field_name)
Oid	PQftable (const PGresult *res, int field_num)
int	PQftablecol (const PGresult *res, int field_num)
int	PQfformat (const PGresult *res, int field_num)
Oid	PQftype (const PGresult *res, int field_num)
int	PQfsize (const PGresult *res, int field_num)
int	PQfmod (const PGresult *res, int field_num)
char *	PQcmdStatus (PGresult *res)
char *	PQoidStatus (const PGresult *res)
Oid	PQoidValue (const PGresult *res)
char *	PQcmdTuples (PGresult *res)
char *	PQgetvalue (const PGresult *res, int tup_num, int field_num)
int	PQgetlength (const PGresult *res, int tup_num, int field_num)
int	PQgetisnull (const PGresult *res, int tup_num, int field_num)
int	PQnparams (const PGresult *res)
Oid	PQparamtype (const PGresult *res, int param_num)
PGresult *	PQdescribePrepared (PGconn *conn, const char *stmt)
PGresult *	PQdescribePortal (PGconn *conn, const char *portal)
int	PQsendDescribePrepared (PGconn *conn, const char *stmt)
int	PQsendDescribePortal (PGconn *conn, const char *portal)
PGresult *	PQclosePrepared (PGconn *conn, const char *stmt)
PGresult *	PQclosePortal (PGconn *conn, const char *portal)
int	PQsendClosePrepared (PGconn *conn, const char *stmt)
int	PQsendClosePortal (PGconn *conn, const char *portal)
void	PQclear (PGresult *res)
void	PQfreemem (void *ptr)
PGresult *	PQmakeEmptyPGresult (PGconn *conn, ExecStatusType status)
PGresult *	PQcopyResult (const PGresult *src, int flags)
int	PQsetResultAttrs (PGresult *res, int numAttributes, PGresAttDesc *attDescs)
void *	PQresultAlloc (PGresult *res, size_t nBytes)
size_t	PQresultMemorySize (const PGresult *res)
int	PQsetvalue (PGresult *res, int tup_num, int field_num, char *value, int len)
size_t	PQescapeStringConn (PGconn *conn, char *to, const char *from, size_t length, int *error)
char *	PQescapeLiteral (PGconn *conn, const char *str, size_t len)
char *	PQescapeIdentifier (PGconn *conn, const char *str, size_t len)
unsigned char *	PQescapeByteaConn (PGconn *conn, const unsigned char *from, size_t from_length, size_t *to_length)
unsigned char *	PQunescapeBytea (const unsigned char *strtext, size_t *retbuflen)
size_t	PQescapeString (char *to, const char *from, size_t length)
unsigned char *	PQescapeBytea (const unsigned char *from, size_t from_length, size_t *to_length)
void	PQprint (FILE *fout, const PGresult *res, const PQprintOpt *po)
void	PQdisplayTuples (const PGresult *res, FILE *fp, int fillAlign, const char *fieldSep, int printHeader, int quiet)
void	PQprintTuples (const PGresult *res, FILE *fout, int PrintAttNames, int TerseOutput, int colWidth)
int	lo_open (PGconn *conn, Oid lobjId, int mode)
int	lo_close (PGconn *conn, int fd)
int	lo_read (PGconn *conn, int fd, char *buf, size_t len)
int	lo_write (PGconn *conn, int fd, const char *buf, size_t len)
int	lo_lseek (PGconn *conn, int fd, int offset, int whence)
int64_t	lo_lseek64 (PGconn *conn, int fd, int64_t offset, int whence)
Oid	lo_creat (PGconn *conn, int mode)
Oid	lo_create (PGconn *conn, Oid lobjId)
int	lo_tell (PGconn *conn, int fd)
int64_t	lo_tell64 (PGconn *conn, int fd)
int	lo_truncate (PGconn *conn, int fd, size_t len)
int	lo_truncate64 (PGconn *conn, int fd, int64_t len)
int	lo_unlink (PGconn *conn, Oid lobjId)
Oid	lo_import (PGconn *conn, const char *filename)
Oid	lo_import_with_oid (PGconn *conn, const char *filename, Oid lobjId)
int	lo_export (PGconn *conn, Oid lobjId, const char *filename)
int	PQlibVersion (void)
int	PQsocketPoll (int sock, int forRead, int forWrite, pg_usec_time_t end_time)
pg_usec_time_t	PQgetCurrentTimeUSec (void)
int	PQmblen (const char *s, int encoding)
int	PQmblenBounded (const char *s, int encoding)
int	PQdsplen (const char *s, int encoding)
int	PQenv2encoding (void)
char *	PQencryptPassword (const char *passwd, const char *user)
char *	PQencryptPasswordConn (PGconn *conn, const char *passwd, const char *user, const char *algorithm)
PGresult *	PQchangePassword (PGconn *conn, const char *user, const char *passwd)
void	PQsetAuthDataHook (PQauthDataHook_type hook)
PQauthDataHook_type	PQgetAuthDataHook (void)
int	PQdefaultAuthDataHook (PGauthData type, PGconn *conn, void *data)
int	pg_char_to_encoding (const char *name)
const char *	pg_encoding_to_char (int encoding)
int	pg_valid_server_encoding_id (int encoding)
PQsslKeyPassHook_OpenSSL_type	PQgetSSLKeyPassHook_OpenSSL (void)
void	PQsetSSLKeyPassHook_OpenSSL (PQsslKeyPassHook_OpenSSL_type hook)
int	PQdefaultSSLKeyPassHook_OpenSSL (char *buf, int size, PGconn *conn)

Macro Definition Documentation

LIBPQ_HAS_ASYNC_CANCEL

#define LIBPQ_HAS_ASYNC_CANCEL   1

Definition at line 48 of file libpq-fe.h.

LIBPQ_HAS_CHANGE_PASSWORD

#define LIBPQ_HAS_CHANGE_PASSWORD   1

Definition at line 50 of file libpq-fe.h.

LIBPQ_HAS_CHUNK_MODE

#define LIBPQ_HAS_CHUNK_MODE   1

Definition at line 52 of file libpq-fe.h.

LIBPQ_HAS_CLOSE_PREPARED

#define LIBPQ_HAS_CLOSE_PREPARED   1

Definition at line 54 of file libpq-fe.h.

LIBPQ_HAS_FULL_PROTOCOL_VERSION

#define LIBPQ_HAS_FULL_PROTOCOL_VERSION   1

Definition at line 62 of file libpq-fe.h.

LIBPQ_HAS_PIPELINING

#define LIBPQ_HAS_PIPELINING   1

Definition at line 38 of file libpq-fe.h.

LIBPQ_HAS_PROMPT_OAUTH_DEVICE

#define LIBPQ_HAS_PROMPT_OAUTH_DEVICE   1

Definition at line 64 of file libpq-fe.h.

LIBPQ_HAS_SEND_PIPELINE_SYNC

#define LIBPQ_HAS_SEND_PIPELINE_SYNC   1

Definition at line 56 of file libpq-fe.h.

LIBPQ_HAS_SOCKET_POLL

#define LIBPQ_HAS_SOCKET_POLL   1

Definition at line 58 of file libpq-fe.h.

LIBPQ_HAS_SSL_LIBRARY_DETECTION

#define LIBPQ_HAS_SSL_LIBRARY_DETECTION   1

Definition at line 44 of file libpq-fe.h.

LIBPQ_HAS_TRACE_FLAGS

#define LIBPQ_HAS_TRACE_FLAGS   1

Definition at line 40 of file libpq-fe.h.

PG_COPYRES_ATTRS

#define PG_COPYRES_ATTRS   0x01

Definition at line 69 of file libpq-fe.h.

PG_COPYRES_EVENTS

#define PG_COPYRES_EVENTS   0x04

Definition at line 71 of file libpq-fe.h.

PG_COPYRES_NOTICEHOOKS

#define PG_COPYRES_NOTICEHOOKS   0x08

Definition at line 72 of file libpq-fe.h.

PG_COPYRES_TUPLES

#define PG_COPYRES_TUPLES   0x02 /* Implies PG_COPYRES_ATTRS */

Definition at line 70 of file libpq-fe.h.

PQ_QUERY_PARAM_MAX_LIMIT

#define PQ_QUERY_PARAM_MAX_LIMIT   65535

Definition at line 507 of file libpq-fe.h.

PQfreeNotify

#define PQfreeNotify

(

ptr

)

PQfreemem(ptr)

Definition at line 629 of file libpq-fe.h.

PQnoPasswordSupplied

#define PQnoPasswordSupplied   "fe_sendauth: no password supplied\n"

Definition at line 633 of file libpq-fe.h.

PQsetdb

#define PQsetdb	(		M_PGHOST,
			M_PGPORT,
			M_PGOPT,
			M_PGTTY,
			M_DBNAME
	)		PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, NULL, NULL)

Definition at line 339 of file libpq-fe.h.

PQTRACE_REGRESS_MODE

#define PQTRACE_REGRESS_MODE   (1<<1)

Definition at line 480 of file libpq-fe.h.

PQTRACE_SUPPRESS_TIMESTAMPS

#define PQTRACE_SUPPRESS_TIMESTAMPS   (1<<0)

Definition at line 478 of file libpq-fe.h.

SOCKTYPE

#define SOCKTYPE   int

Definition at line 745 of file libpq-fe.h.

Typedef Documentation

pg_usec_time_t

typedef int64_t pg_usec_time_t

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

PGcancel

typedef struct pg_cancel PGcancel

Definition at line 220 of file libpq-fe.h.

PGcancelConn

typedef struct pg_cancel_conn PGcancelConn

Definition at line 207 of file libpq-fe.h.

PGconn

typedef struct pg_conn PGconn

Definition at line 202 of file libpq-fe.h.

PGnotify

typedef struct pgNotify PGnotify

PGoauthBearerRequest

typedef struct PGoauthBearerRequest PGoauthBearerRequest

PGpromptOAuthDevice

typedef struct _PGpromptOAuthDevice PGpromptOAuthDevice

PGresAttDesc

typedef struct pgresAttDesc PGresAttDesc

PGresult

typedef struct pg_result PGresult

Definition at line 214 of file libpq-fe.h.

pgthreadlock_t

typedef void(* pgthreadlock_t) (int acquire)

Definition at line 468 of file libpq-fe.h.

PQauthDataHook_type

typedef int(* PQauthDataHook_type) (PGauthData type, PGconn *conn, void *data)

Definition at line 807 of file libpq-fe.h.

pqbool

typedef char pqbool

Definition at line 245 of file libpq-fe.h.

PQconninfoOption

typedef struct _PQconninfoOption PQconninfoOption

PQnoticeProcessor

typedef void(* PQnoticeProcessor) (void *arg, const char *message)

Definition at line 242 of file libpq-fe.h.

PQnoticeReceiver

typedef void(* PQnoticeReceiver) (void *arg, const PGresult *res)

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

PQprintOpt

typedef struct _PQprintOpt PQprintOpt

PQsslKeyPassHook_OpenSSL_type

typedef int(* PQsslKeyPassHook_OpenSSL_type) (char *buf, int size, PGconn *conn)

Definition at line 821 of file libpq-fe.h.

Enumeration Type Documentation

ConnStatusType

enum ConnStatusType

Enumerator
CONNECTION_OK
CONNECTION_BAD
CONNECTION_STARTED
CONNECTION_MADE
CONNECTION_AWAITING_RESPONSE
CONNECTION_AUTH_OK
CONNECTION_SETENV
CONNECTION_SSL_STARTUP
CONNECTION_NEEDED
CONNECTION_CHECK_WRITABLE
CONNECTION_CONSUME
CONNECTION_GSS_STARTUP
CONNECTION_CHECK_TARGET
CONNECTION_CHECK_STANDBY
CONNECTION_ALLOCATED
CONNECTION_AUTHENTICATING

Definition at line 82 of file libpq-fe.h.

{
    CONNECTION_OK,
    CONNECTION_BAD,
    /* Non-blocking mode only below here */
 
    /*
     * The existence of these should never be relied upon - they should only
     * be used for user feedback or similar purposes.
     */
    CONNECTION_STARTED,         /* Waiting for connection to be made.  */
    CONNECTION_MADE,            /* Connection OK; waiting to send.     */
    CONNECTION_AWAITING_RESPONSE,   /* Waiting for a response from the
                                     * postmaster.        */
    CONNECTION_AUTH_OK,         /* Received authentication; waiting for
                                 * backend startup. */
    CONNECTION_SETENV,          /* This state is no longer used. */
    CONNECTION_SSL_STARTUP,     /* Performing SSL handshake. */
    CONNECTION_NEEDED,          /* Internal state: connect() needed. */
    CONNECTION_CHECK_WRITABLE,  /* Checking if session is read-write. */
    CONNECTION_CONSUME,         /* Consuming any extra messages. */
    CONNECTION_GSS_STARTUP,     /* Negotiating GSSAPI. */
    CONNECTION_CHECK_TARGET,    /* Internal state: checking target server
                                 * properties. */
    CONNECTION_CHECK_STANDBY,   /* Checking if server is in standby mode. */
    CONNECTION_ALLOCATED,       /* Waiting for connection attempt to be
                                 * started.  */
    CONNECTION_AUTHENTICATING,  /* Authentication is in progress with some
                                 * external system. */
} ConnStatusType;

ExecStatusType

enum ExecStatusType

Enumerator
PGRES_EMPTY_QUERY
PGRES_COMMAND_OK
PGRES_TUPLES_OK
PGRES_COPY_OUT
PGRES_COPY_IN
PGRES_BAD_RESPONSE
PGRES_NONFATAL_ERROR
PGRES_FATAL_ERROR
PGRES_COPY_BOTH
PGRES_SINGLE_TUPLE
PGRES_PIPELINE_SYNC
PGRES_PIPELINE_ABORTED
PGRES_TUPLES_CHUNK

Definition at line 122 of file libpq-fe.h.

{
    PGRES_EMPTY_QUERY = 0,      /* empty query string was executed */
    PGRES_COMMAND_OK,           /* a query command that doesn't return
                                 * anything was executed properly by the
                                 * backend */
    PGRES_TUPLES_OK,            /* a query command that returns tuples was
                                 * executed properly by the backend, PGresult
                                 * contains the result tuples */
    PGRES_COPY_OUT,             /* Copy Out data transfer in progress */
    PGRES_COPY_IN,              /* Copy In data transfer in progress */
    PGRES_BAD_RESPONSE,         /* an unexpected response was recv'd from the
                                 * backend */
    PGRES_NONFATAL_ERROR,       /* notice or warning message */
    PGRES_FATAL_ERROR,          /* query failed */
    PGRES_COPY_BOTH,            /* Copy In/Out data transfer in progress */
    PGRES_SINGLE_TUPLE,         /* single tuple from larger resultset */
    PGRES_PIPELINE_SYNC,        /* pipeline synchronization point */
    PGRES_PIPELINE_ABORTED,     /* Command didn't run because of an abort
                                 * earlier in a pipeline */
    PGRES_TUPLES_CHUNK          /* chunk of tuples from larger resultset */
} ExecStatusType;

PGauthData

enum PGauthData

Enumerator
PQAUTHDATA_PROMPT_OAUTH_DEVICE
PQAUTHDATA_OAUTH_BEARER_TOKEN

Definition at line 192 of file libpq-fe.h.

{
    PQAUTHDATA_PROMPT_OAUTH_DEVICE, /* user must visit a device-authorization
                                     * URL */
    PQAUTHDATA_OAUTH_BEARER_TOKEN,  /* server requests an OAuth Bearer token */
} PGauthData;

PGContextVisibility

enum PGContextVisibility

Enumerator
PQSHOW_CONTEXT_NEVER
PQSHOW_CONTEXT_ERRORS
PQSHOW_CONTEXT_ALWAYS

Definition at line 162 of file libpq-fe.h.

{
    PQSHOW_CONTEXT_NEVER,       /* never show CONTEXT field */
    PQSHOW_CONTEXT_ERRORS,      /* show CONTEXT for errors only (default) */
    PQSHOW_CONTEXT_ALWAYS       /* always show CONTEXT field */
} PGContextVisibility;

PGPing

enum PGPing

Enumerator
PQPING_OK
PQPING_REJECT
PQPING_NO_RESPONSE
PQPING_NO_ATTEMPT

Definition at line 174 of file libpq-fe.h.

{
    PQPING_OK,                  /* server is accepting connections */
    PQPING_REJECT,              /* server is alive but rejecting connections */
    PQPING_NO_RESPONSE,         /* could not establish connection */
    PQPING_NO_ATTEMPT           /* connection not attempted (bad params) */
} PGPing;

PGpipelineStatus

enum PGpipelineStatus

Enumerator
PQ_PIPELINE_OFF
PQ_PIPELINE_ON
PQ_PIPELINE_ABORTED

Definition at line 185 of file libpq-fe.h.

{
    PQ_PIPELINE_OFF,
    PQ_PIPELINE_ON,
    PQ_PIPELINE_ABORTED
} PGpipelineStatus;

PGTransactionStatusType

enum PGTransactionStatusType

Enumerator
PQTRANS_IDLE
PQTRANS_ACTIVE
PQTRANS_INTRANS
PQTRANS_INERROR
PQTRANS_UNKNOWN

Definition at line 145 of file libpq-fe.h.

{
    PQTRANS_IDLE,               /* connection idle */
    PQTRANS_ACTIVE,             /* command in progress */
    PQTRANS_INTRANS,            /* idle, within transaction block */
    PQTRANS_INERROR,            /* idle, within failed transaction */
    PQTRANS_UNKNOWN             /* cannot determine status */
} PGTransactionStatusType;

PGVerbosity

enum PGVerbosity

Enumerator
PQERRORS_TERSE
PQERRORS_DEFAULT
PQERRORS_VERBOSE
PQERRORS_SQLSTATE

Definition at line 154 of file libpq-fe.h.

{
    PQERRORS_TERSE,             /* single-line error messages */
    PQERRORS_DEFAULT,           /* recommended style */
    PQERRORS_VERBOSE,           /* all the facts, ma'am */
    PQERRORS_SQLSTATE           /* only error severity and SQLSTATE code */
} PGVerbosity;

PostgresPollingStatusType

enum PostgresPollingStatusType

Enumerator
PGRES_POLLING_FAILED
PGRES_POLLING_READING
PGRES_POLLING_WRITING
PGRES_POLLING_OK
PGRES_POLLING_ACTIVE

Definition at line 113 of file libpq-fe.h.

{
    PGRES_POLLING_FAILED = 0,
    PGRES_POLLING_READING,      /* These two indicate that one may    */
    PGRES_POLLING_WRITING,      /* use select before polling again.   */
    PGRES_POLLING_OK,
    PGRES_POLLING_ACTIVE        /* unused; keep for backwards compatibility */
} PostgresPollingStatusType;

Function Documentation

lo_close()

int lo_close	(	PGconn *	conn,
		int	fd
	)

Definition at line 96 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
    res = PQfn(conn, conn->lobjfuncs->fn_lo_close,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_close, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by dumpLOs(), EndRestoreLO(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), and pickout().

lo_creat()

Oid lo_creat	(	PGconn *	conn,
		int	mode
	)

Definition at line 438 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return InvalidOid;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = mode;
    res = PQfn(conn, conn->lobjfuncs->fn_lo_creat,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return (Oid) retval;
    }
    else
    {
        PQclear(res);
        return InvalidOid;
    }
}

References conn, pgLobjfuncs::fn_lo_creat, PQArgBlock::integer, InvalidOid, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, mode, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by importFile(), and lo_import_internal().

lo_create()

Oid lo_create	(	PGconn *	conn,
		Oid	lobjId
	)

Definition at line 474 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return InvalidOid;
 
    /* Must check this on-the-fly because it's not there pre-8.1 */
    if (conn->lobjfuncs->fn_lo_create == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_create");
        return InvalidOid;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = lobjId;
    res = PQfn(conn, conn->lobjfuncs->fn_lo_create,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return (Oid) retval;
    }
    else
    {
        PQclear(res);
        return InvalidOid;
    }
}

References conn, pgLobjfuncs::fn_lo_create, PQArgBlock::integer, InvalidOid, PQArgBlock::isint, PQArgBlock::len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by lo_import_internal(), and StartRestoreLO().

lo_export()

int lo_export	(	PGconn *	conn,
		Oid	lobjId,
		const char *	filename
	)

Definition at line 748 of file fe-lobj.c.

{
    int         result = 1;
    int         fd;
    int         nbytes,
                tmp;
    char        buf[LO_BUFSIZE];
    int         lobj;
    char        sebuf[PG_STRERROR_R_BUFLEN];
 
    /*
     * open the large object.
     */
    lobj = lo_open(conn, lobjId, INV_READ);
    if (lobj == -1)
    {
        /* we assume lo_open() already set a suitable error message */
        return -1;
    }
 
    /*
     * create the file to be written to
     */
    fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, 0666);
    if (fd < 0)
    {
        /* We must do lo_close before setting the errorMessage */
        int         save_errno = errno;
 
        (void) lo_close(conn, lobj);
        /* deliberately overwrite any error from lo_close */
        pqClearConnErrorState(conn);
        libpq_append_conn_error(conn, "could not open file \"%s\": %s",
                                filename,
                                strerror_r(save_errno, sebuf, sizeof(sebuf)));
        return -1;
    }
 
    /*
     * read in from the large object and write to the file
     */
    while ((nbytes = lo_read(conn, lobj, buf, LO_BUFSIZE)) > 0)
    {
        tmp = write(fd, buf, nbytes);
        if (tmp != nbytes)
        {
            /* We must do lo_close before setting the errorMessage */
            int         save_errno = errno;
 
            (void) lo_close(conn, lobj);
            (void) close(fd);
            /* deliberately overwrite any error from lo_close */
            pqClearConnErrorState(conn);
            libpq_append_conn_error(conn, "could not write to file \"%s\": %s",
                                    filename,
                                    strerror_r(save_errno, sebuf, sizeof(sebuf)));
            return -1;
        }
    }
 
    /*
     * If lo_read() failed, we are now in an aborted transaction so there's no
     * need for lo_close(); furthermore, if we tried it we'd overwrite the
     * useful error result with a useless one. So skip lo_close() if we got a
     * failure result.
     */
    if (nbytes < 0 ||
        lo_close(conn, lobj) != 0)
    {
        /* assume lo_read() or lo_close() left a suitable error message */
        result = -1;
    }
 
    /* if we already failed, don't overwrite that msg with a close error */
    if (close(fd) != 0 && result >= 0)
    {
        libpq_append_conn_error(conn, "could not write to file \"%s\": %s",
                                filename, strerror_r(errno, sebuf, sizeof(sebuf)));
        result = -1;
    }
 
    return result;
}

References buf, close, conn, fd(), filename, INV_READ, libpq_append_conn_error(), LO_BUFSIZE, lo_close(), lo_open(), lo_read(), PG_BINARY, PG_STRERROR_R_BUFLEN, pqClearConnErrorState, strerror_r, and write.

Referenced by do_lo_export(), and main().

lo_import()

Oid lo_import	(	PGconn *	conn,
		const char *	filename
	)

Definition at line 626 of file fe-lobj.c.

{
    return lo_import_internal(conn, filename, InvalidOid);
}

References conn, filename, InvalidOid, and lo_import_internal().

Referenced by do_lo_import(), and main().

lo_import_with_oid()

Oid lo_import_with_oid	(	PGconn *	conn,
		const char *	filename,
		Oid	lobjId
	)

Definition at line 641 of file fe-lobj.c.

{
    return lo_import_internal(conn, filename, lobjId);
}

References conn, filename, and lo_import_internal().

lo_lseek()

int lo_lseek	(	PGconn *	conn,
		int	fd,
		int	offset,
		int	whence
	)

Definition at line 344 of file fe-lobj.c.

{
    PQArgBlock  argv[3];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = offset;
 
    argv[2].isint = 1;
    argv[2].len = 4;
    argv[2].u.integer = whence;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek,
               &retval, &result_len, 1, argv, 3);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_lseek, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by overwrite(), and pickout().

lo_lseek64()

int64_t lo_lseek64	(	PGconn *	conn,
		int	fd,
		int64_t	offset,
		int	whence
	)

Definition at line 385 of file fe-lobj.c.

{
    PQArgBlock  argv[3];
    PGresult   *res;
    int64       retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    if (conn->lobjfuncs->fn_lo_lseek64 == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_lseek64");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    offset = lo_hton64(offset);
    argv[1].isint = 0;
    argv[1].len = 8;
    argv[1].u.ptr = (int *) &offset;
 
    argv[2].isint = 1;
    argv[2].len = 4;
    argv[2].u.integer = whence;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek64,
               (void *) &retval, &result_len, 0, argv, 3);
    if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
    {
        PQclear(res);
        return lo_ntoh64(retval);
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_lseek64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_append_conn_error(), lo_hton64(), lo_initialize(), lo_ntoh64(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, PQArgBlock::ptr, and PQArgBlock::u.

Referenced by overwrite(), and pickout().

lo_open()

int lo_open	(	PGconn *	conn,
		Oid	lobjId,
		int	mode
	)

Definition at line 57 of file fe-lobj.c.

{
    int         fd;
    int         result_len;
    PQArgBlock  argv[2];
    PGresult   *res;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = lobjId;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = mode;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_open, &fd, &result_len, 1, argv, 2);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return fd;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_open, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, mode, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by dumpLOs(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), pickout(), and StartRestoreLO().

lo_read()

int lo_read	(	PGconn *	conn,
		int	fd,
		char *	buf,
		size_t	len
	)

Definition at line 245 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    /*
     * Long ago, somebody thought it'd be a good idea to declare this function
     * as taking size_t ... but the underlying backend function only accepts a
     * signed int32 length.  So throw error if the given value overflows
     * int32.
     */
    if (len > (size_t) INT_MAX)
    {
        libpq_append_conn_error(conn, "argument of lo_read exceeds integer range");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = (int) len;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_read,
               (void *) buf, &result_len, 0, argv, 2);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return result_len;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References buf, conn, fd(), pgLobjfuncs::fn_lo_read, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by lo_export().

lo_tell()

int lo_tell	(	PGconn *	conn,
		int	fd
	)

Definition at line 515 of file fe-lobj.c.

{
    int         retval;
    PQArgBlock  argv[1];
    PGresult   *res;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_tell,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_tell, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

lo_tell64()

int64_t lo_tell64	(	PGconn *	conn,
		int	fd
	)

Definition at line 548 of file fe-lobj.c.

{
    int64       retval;
    PQArgBlock  argv[1];
    PGresult   *res;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    if (conn->lobjfuncs->fn_lo_tell64 == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_tell64");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_tell64,
               (void *) &retval, &result_len, 0, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
    {
        PQclear(res);
        return lo_ntoh64(retval);
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_tell64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_append_conn_error(), lo_initialize(), lo_ntoh64(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by pickout().

lo_truncate()

int lo_truncate	(	PGconn *	conn,
		int	fd,
		size_t	len
	)

Definition at line 131 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    /* Must check this on-the-fly because it's not there pre-8.3 */
    if (conn->lobjfuncs->fn_lo_truncate == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_truncate");
        return -1;
    }
 
    /*
     * Long ago, somebody thought it'd be a good idea to declare this function
     * as taking size_t ... but the underlying backend function only accepts a
     * signed int32 length.  So throw error if the given value overflows
     * int32.  (A possible alternative is to automatically redirect the call
     * to lo_truncate64; but if the caller wanted to rely on that backend
     * function being available, he could have called lo_truncate64 for
     * himself.)
     */
    if (len > (size_t) INT_MAX)
    {
        libpq_append_conn_error(conn, "argument of lo_truncate exceeds integer range");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = (int) len;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate,
               &retval, &result_len, 1, argv, 2);
 
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_truncate, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

lo_truncate64()

int lo_truncate64	(	PGconn *	conn,
		int	fd,
		int64_t	len
	)

Definition at line 195 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    if (conn->lobjfuncs->fn_lo_truncate64 == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_truncate64");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    len = lo_hton64(len);
    argv[1].isint = 0;
    argv[1].len = 8;
    argv[1].u.ptr = (int *) &len;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate64,
               &retval, &result_len, 1, argv, 2);
 
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_truncate64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_hton64(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, PQArgBlock::ptr, and PQArgBlock::u.

Referenced by my_truncate().

lo_unlink()

int lo_unlink	(	PGconn *	conn,
		Oid	lobjId
	)

Definition at line 589 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         result_len;
    int         retval;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = lobjId;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_unlink,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, pgLobjfuncs::fn_lo_unlink, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, and PQArgBlock::u.

Referenced by do_lo_unlink(), and vacuumlo().

lo_write()

int lo_write	(	PGconn *	conn,
		int	fd,
		const char *	buf,
		size_t	len
	)

Definition at line 295 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         result_len;
    int         retval;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    /*
     * Long ago, somebody thought it'd be a good idea to declare this function
     * as taking size_t ... but the underlying backend function only accepts a
     * signed int32 length.  So throw error if the given value overflows
     * int32.
     */
    if (len > (size_t) INT_MAX)
    {
        libpq_append_conn_error(conn, "argument of lo_write exceeds integer range");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 0;
    argv[1].len = (int) len;
    argv[1].u.ptr = (int *) unconstify(char *, buf);
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_write,
               &retval, &result_len, 1, argv, 2);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References buf, conn, fd(), pgLobjfuncs::fn_lo_write, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear, PQfn(), PQresultStatus, PQArgBlock::ptr, PQArgBlock::u, and unconstify.

Referenced by lo_import_internal().

pg_char_to_encoding()

int pg_char_to_encoding

(

const char *

name

)

Definition at line 549 of file encnames.c.

{
    unsigned int nel = lengthof(pg_encname_tbl);
    const pg_encname *base = pg_encname_tbl,
               *last = base + nel - 1,
               *position;
    int         result;
    char        buff[NAMEDATALEN],
               *key;
 
    if (name == NULL || *name == '\0')
        return -1;
 
    if (strlen(name) >= NAMEDATALEN)
        return -1;              /* it's certainly not in the table */
 
    key = clean_encoding_name(name, buff);
 
    while (last >= base)
    {
        position = base + ((last - base) >> 1);
        result = key[0] - position->name[0];
 
        if (result == 0)
        {
            result = strcmp(key, position->name);
            if (result == 0)
                return position->encoding;
        }
        if (result < 0)
            last = position - 1;
        else
            base = position + 1;
    }
    return -1;
}

References clean_encoding_name(), sort-test::key, lengthof, name, NAMEDATALEN, and pg_encname_tbl.

Referenced by pg_valid_client_encoding(), and pg_valid_server_encoding().

pg_encoding_to_char()

const char * pg_encoding_to_char

(

int

encoding

)

Definition at line 587 of file encnames.c.

{
    if (PG_VALID_ENCODING(encoding))
    {
        const pg_enc2name *p = &pg_enc2name_tbl[encoding];
 
        Assert(encoding == p->encoding);
        return p->name;
    }
    return "";
}

References Assert(), encoding, pg_enc2name::encoding, pg_enc2name::name, pg_enc2name_tbl, and PG_VALID_ENCODING.

pg_valid_server_encoding_id()

int pg_valid_server_encoding_id

(

int

encoding

)

Definition at line 513 of file encnames.c.

{
    return PG_VALID_BE_ENCODING(encoding);
}

References encoding, and PG_VALID_BE_ENCODING.

PQbackendPID()

int PQbackendPID

(

const PGconn *

conn

)

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

{
    if (!conn || conn->status != CONNECTION_OK)
        return 0;
    return conn->be_pid;
}

References pg_conn::be_pid, conn, CONNECTION_OK, and pg_conn::status.

Referenced by exec_command_conninfo(), get_prompt(), libpqrcv_get_backend_pid(), main(), postgres_fdw_get_connections_internal(), send_cancellable_query_impl(), and StartLogStreamer().

PQbinaryTuples()

int PQbinaryTuples

(

const PGresult *

res

)

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

{
    if (!res)
        return 0;
    return res->binary;
}

References pg_result::binary.

Referenced by HandleCopyResult().

PQcancel()

int PQcancel	(	PGcancel *	cancel,
		char *	errbuf,
		int	errbufsize
	)

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

{
    int         save_errno = SOCK_ERRNO;
    pgsocket    tmpsock = PGINVALID_SOCKET;
    int         maxlen;
    char        recvbuf;
    int         cancel_pkt_len;
 
    if (!cancel)
    {
        strlcpy(errbuf, "PQcancel() -- no cancel object supplied", errbufsize);
        /* strlcpy probably doesn't change errno, but be paranoid */
        SOCK_ERRNO_SET(save_errno);
        return false;
    }
 
    if (cancel->cancel_pkt_len == 0)
    {
        /* This is a dummy PGcancel object, see PQgetCancel */
        strlcpy(errbuf, "PQcancel() -- no cancellation key received", errbufsize);
        /* strlcpy probably doesn't change errno, but be paranoid */
        SOCK_ERRNO_SET(save_errno);
        return false;
    }
 
    /*
     * We need to open a temporary connection to the postmaster. Do this with
     * only kernel calls.
     */
    if ((tmpsock = socket(cancel->raddr.addr.ss_family, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
    {
        strlcpy(errbuf, "PQcancel() -- socket() failed: ", errbufsize);
        goto cancel_errReturn;
    }
 
    /*
     * Since this connection will only be used to send a single packet of
     * data, we don't need NODELAY.  We also don't set the socket to
     * nonblocking mode, because the API definition of PQcancel requires the
     * cancel to be sent in a blocking way.
     *
     * We do set socket options related to keepalives and other TCP timeouts.
     * This ensures that this function does not block indefinitely when
     * reasonable keepalive and timeout settings have been provided.
     */
    if (cancel->raddr.addr.ss_family != AF_UNIX &&
        cancel->keepalives != 0)
    {
#ifndef WIN32
        if (!optional_setsockopt(tmpsock, SOL_SOCKET, SO_KEEPALIVE, 1))
        {
            strlcpy(errbuf, "PQcancel() -- setsockopt(SO_KEEPALIVE) failed: ", errbufsize);
            goto cancel_errReturn;
        }
 
#ifdef PG_TCP_KEEPALIVE_IDLE
        if (!optional_setsockopt(tmpsock, IPPROTO_TCP, PG_TCP_KEEPALIVE_IDLE,
                                 cancel->keepalives_idle))
        {
            strlcpy(errbuf, "PQcancel() -- setsockopt(" PG_TCP_KEEPALIVE_IDLE_STR ") failed: ", errbufsize);
            goto cancel_errReturn;
        }
#endif
 
#ifdef TCP_KEEPINTVL
        if (!optional_setsockopt(tmpsock, IPPROTO_TCP, TCP_KEEPINTVL,
                                 cancel->keepalives_interval))
        {
            strlcpy(errbuf, "PQcancel() -- setsockopt(TCP_KEEPINTVL) failed: ", errbufsize);
            goto cancel_errReturn;
        }
#endif
 
#ifdef TCP_KEEPCNT
        if (!optional_setsockopt(tmpsock, IPPROTO_TCP, TCP_KEEPCNT,
                                 cancel->keepalives_count))
        {
            strlcpy(errbuf, "PQcancel() -- setsockopt(TCP_KEEPCNT) failed: ", errbufsize);
            goto cancel_errReturn;
        }
#endif
 
#else                           /* WIN32 */
 
#ifdef SIO_KEEPALIVE_VALS
        if (!pqSetKeepalivesWin32(tmpsock,
                                  cancel->keepalives_idle,
                                  cancel->keepalives_interval))
        {
            strlcpy(errbuf, "PQcancel() -- WSAIoctl(SIO_KEEPALIVE_VALS) failed: ", errbufsize);
            goto cancel_errReturn;
        }
#endif                          /* SIO_KEEPALIVE_VALS */
#endif                          /* WIN32 */
 
        /* TCP_USER_TIMEOUT works the same way on Unix and Windows */
#ifdef TCP_USER_TIMEOUT
        if (!optional_setsockopt(tmpsock, IPPROTO_TCP, TCP_USER_TIMEOUT,
                                 cancel->pgtcp_user_timeout))
        {
            strlcpy(errbuf, "PQcancel() -- setsockopt(TCP_USER_TIMEOUT) failed: ", errbufsize);
            goto cancel_errReturn;
        }
#endif
    }
 
retry3:
    if (connect(tmpsock, (struct sockaddr *) &cancel->raddr.addr,
                cancel->raddr.salen) < 0)
    {
        if (SOCK_ERRNO == EINTR)
            /* Interrupted system call - we'll just try again */
            goto retry3;
        strlcpy(errbuf, "PQcancel() -- connect() failed: ", errbufsize);
        goto cancel_errReturn;
    }
 
    cancel_pkt_len = pg_ntoh32(cancel->cancel_pkt_len);
 
retry4:
 
    /*
     * Send the cancel request packet. It starts with the message length at
     * cancel_pkt_len, followed by the actual packet.
     */
    if (send(tmpsock, (char *) &cancel->cancel_pkt_len, cancel_pkt_len, 0) != cancel_pkt_len)
    {
        if (SOCK_ERRNO == EINTR)
            /* Interrupted system call - we'll just try again */
            goto retry4;
        strlcpy(errbuf, "PQcancel() -- send() failed: ", errbufsize);
        goto cancel_errReturn;
    }
 
    /*
     * Wait for the postmaster to close the connection, which indicates that
     * it's processed the request.  Without this delay, we might issue another
     * command only to find that our cancel zaps that command instead of the
     * one we thought we were canceling.  Note we don't actually expect this
     * read to obtain any data, we are just waiting for EOF to be signaled.
     */
retry5:
    if (recv(tmpsock, &recvbuf, 1, 0) < 0)
    {
        if (SOCK_ERRNO == EINTR)
            /* Interrupted system call - we'll just try again */
            goto retry5;
        /* we ignore other error conditions */
    }
 
    /* All done */
    closesocket(tmpsock);
    SOCK_ERRNO_SET(save_errno);
    return true;
 
cancel_errReturn:
 
    /*
     * Make sure we don't overflow the error buffer. Leave space for the \n at
     * the end, and for the terminating zero.
     */
    maxlen = errbufsize - strlen(errbuf) - 2;
    if (maxlen >= 0)
    {
        /*
         * We can't invoke strerror here, since it's not signal-safe.  Settle
         * for printing the decimal value of errno.  Even that has to be done
         * the hard way.
         */
        int         val = SOCK_ERRNO;
        char        buf[32];
        char       *bufp;
 
        bufp = buf + sizeof(buf) - 1;
        *bufp = '\0';
        do
        {
            *(--bufp) = (val % 10) + '0';
            val /= 10;
        } while (val > 0);
        bufp -= 6;
        memcpy(bufp, "error ", 6);
        strncat(errbuf, bufp, maxlen);
        strcat(errbuf, "\n");
    }
    if (tmpsock != PGINVALID_SOCKET)
        closesocket(tmpsock);
    SOCK_ERRNO_SET(save_errno);
    return false;
}

References SockAddr::addr, buf, pg_cancel::cancel_pkt_len, closesocket, connect, EINTR, pg_cancel::keepalives, pg_cancel::keepalives_count, pg_cancel::keepalives_idle, pg_cancel::keepalives_interval, optional_setsockopt(), pg_ntoh32, PGINVALID_SOCKET, pg_cancel::pgtcp_user_timeout, pg_cancel::raddr, recv, SockAddr::salen, send, SOCK_ERRNO, SOCK_ERRNO_SET, socket, strlcpy(), and val.

Referenced by DisconnectDatabase(), handle_sigint(), PQrequestCancel(), ShutdownWorkersHard(), sigTermHandler(), and test_cancel().

PQcancelBlocking()

int PQcancelBlocking

(

PGcancelConn *

cancelConn

)

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

{
    if (!PQcancelStart(cancelConn))
        return 0;
    return pqConnectDBComplete(&cancelConn->conn);
}

References cancelConn, PQcancelStart(), and pqConnectDBComplete().

Referenced by disconnectDatabase(), test_cancel(), and try_complete_step().

PQcancelCreate()

PGcancelConn * PQcancelCreate

(

PGconn *

conn

)

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

{
    PGconn     *cancelConn = pqMakeEmptyPGconn();
    pg_conn_host originalHost;
 
    if (cancelConn == NULL)
        return NULL;
 
    /* Check we have an open connection */
    if (!conn)
    {
        libpq_append_conn_error(cancelConn, "connection pointer is NULL");
        return (PGcancelConn *) cancelConn;
    }
 
    if (conn->sock == PGINVALID_SOCKET)
    {
        libpq_append_conn_error(cancelConn, "connection not open");
        return (PGcancelConn *) cancelConn;
    }
 
    /* Check that we have received a cancellation key */
    if (conn->be_cancel_key_len == 0)
    {
        libpq_append_conn_error(cancelConn, "no cancellation key received");
        return (PGcancelConn *) cancelConn;
    }
 
    /*
     * Indicate that this connection is used to send a cancellation
     */
    cancelConn->cancelRequest = true;
 
    if (!pqCopyPGconn(conn, cancelConn))
        return (PGcancelConn *) cancelConn;
 
    /*
     * Compute derived options
     */
    if (!pqConnectOptions2(cancelConn))
        return (PGcancelConn *) cancelConn;
 
    /*
     * Copy cancellation token data from the original connection
     */
    cancelConn->be_pid = conn->be_pid;
    if (conn->be_cancel_key != NULL)
    {
        cancelConn->be_cancel_key = malloc(conn->be_cancel_key_len);
        if (cancelConn->be_cancel_key == NULL)
            goto oom_error;
        memcpy(cancelConn->be_cancel_key, conn->be_cancel_key, conn->be_cancel_key_len);
    }
    cancelConn->be_cancel_key_len = conn->be_cancel_key_len;
    cancelConn->pversion = conn->pversion;
 
    /*
     * Cancel requests should not iterate over all possible hosts. The request
     * needs to be sent to the exact host and address that the original
     * connection used. So we manually create the host and address arrays with
     * a single element after freeing the host array that we generated from
     * the connection options.
     */
    pqReleaseConnHosts(cancelConn);
    cancelConn->nconnhost = 1;
    cancelConn->naddr = 1;
 
    cancelConn->connhost = calloc(cancelConn->nconnhost, sizeof(pg_conn_host));
    if (!cancelConn->connhost)
        goto oom_error;
 
    originalHost = conn->connhost[conn->whichhost];
    cancelConn->connhost[0].type = originalHost.type;
    if (originalHost.host)
    {
        cancelConn->connhost[0].host = strdup(originalHost.host);
        if (!cancelConn->connhost[0].host)
            goto oom_error;
    }
    if (originalHost.hostaddr)
    {
        cancelConn->connhost[0].hostaddr = strdup(originalHost.hostaddr);
        if (!cancelConn->connhost[0].hostaddr)
            goto oom_error;
    }
    if (originalHost.port)
    {
        cancelConn->connhost[0].port = strdup(originalHost.port);
        if (!cancelConn->connhost[0].port)
            goto oom_error;
    }
    if (originalHost.password)
    {
        cancelConn->connhost[0].password = strdup(originalHost.password);
        if (!cancelConn->connhost[0].password)
            goto oom_error;
    }
 
    cancelConn->addr = calloc(cancelConn->naddr, sizeof(AddrInfo));
    if (!cancelConn->addr)
        goto oom_error;
 
    cancelConn->addr[0].addr = conn->raddr;
    cancelConn->addr[0].family = conn->raddr.addr.ss_family;
 
    cancelConn->status = CONNECTION_ALLOCATED;
    return (PGcancelConn *) cancelConn;
 
oom_error:
    cancelConn->status = CONNECTION_BAD;
    libpq_append_conn_error(cancelConn, "out of memory");
    return (PGcancelConn *) cancelConn;
}

References SockAddr::addr, pg_conn::be_cancel_key, pg_conn::be_cancel_key_len, pg_cancel::be_pid, pg_conn::be_pid, calloc, cancelConn, conn, CONNECTION_ALLOCATED, CONNECTION_BAD, pg_conn::connhost, pg_conn_host::host, pg_conn_host::hostaddr, libpq_append_conn_error(), malloc, pg_conn_host::password, PGINVALID_SOCKET, pg_conn_host::port, pqConnectOptions2(), pqCopyPGconn(), pqMakeEmptyPGconn(), pqReleaseConnHosts(), pg_conn::pversion, pg_conn::raddr, pg_conn::sock, pg_conn_host::type, and pg_conn::whichhost.

Referenced by disconnectDatabase(), libpqsrv_cancel(), test_cancel(), and try_complete_step().

PQcancelErrorMessage()

char * PQcancelErrorMessage

(

const PGcancelConn *

cancelConn

)

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

{
    return PQerrorMessage(&cancelConn->conn);
}

References cancelConn, and PQerrorMessage().

Referenced by libpqsrv_cancel(), test_cancel(), and try_complete_step().

PQcancelFinish()

void PQcancelFinish

(

PGcancelConn *

cancelConn

)

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

{
    PQfinish(&cancelConn->conn);
}

References cancelConn, and PQfinish().

Referenced by disconnectDatabase(), libpqsrv_cancel(), test_cancel(), and try_complete_step().

PQcancelPoll()

PostgresPollingStatusType PQcancelPoll

(

PGcancelConn *

cancelConn

)

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

{
    PGconn     *conn = &cancelConn->conn;
    int         n;
 
    /*
     * We leave most of the connection establishment to PQconnectPoll, since
     * it's very similar to normal connection establishment. But once we get
     * to the CONNECTION_AWAITING_RESPONSE we need to start doing our own
     * thing.
     */
    if (conn->status != CONNECTION_AWAITING_RESPONSE)
    {
        return PQconnectPoll(conn);
    }
 
    /*
     * At this point we are waiting on the server to close the connection,
     * which is its way of communicating that the cancel has been handled.
     */
 
    n = pqReadData(conn);
 
    if (n == 0)
        return PGRES_POLLING_READING;
 
#ifndef WIN32
 
    /*
     * If we receive an error report it, but only if errno is non-zero.
     * Otherwise we assume it's an EOF, which is what we expect from the
     * server.
     *
     * We skip this for Windows, because Windows is a bit special in its EOF
     * behaviour for TCP. Sometimes it will error with an ECONNRESET when
     * there is a clean connection closure. See these threads for details:
     * https://www.postgresql.org/message-id/flat/90b34057-4176-7bb0-0dbb-9822a5f6425b%40greiz-reinsdorf.de
     *
     * https://www.postgresql.org/message-id/flat/CA%2BhUKG%2BOeoETZQ%3DQw5Ub5h3tmwQhBmDA%3DnuNO3KG%3DzWfUypFAw%40mail.gmail.com
     *
     * PQcancel ignores such errors and reports success for the cancellation
     * anyway, so even if this is not always correct we do the same here.
     */
    if (n < 0 && errno != 0)
    {
        conn->status = CONNECTION_BAD;
        return PGRES_POLLING_FAILED;
    }
#endif
 
    /*
     * We don't expect any data, only connection closure. So if we strangely
     * do receive some data we consider that an error.
     */
    if (n > 0)
    {
        libpq_append_conn_error(conn, "unexpected response from server");
        conn->status = CONNECTION_BAD;
        return PGRES_POLLING_FAILED;
    }
 
    /*
     * Getting here means that we received an EOF, which is what we were
     * expecting -- the cancel request has completed.
     */
    cancelConn->conn.status = CONNECTION_OK;
    resetPQExpBuffer(&conn->errorMessage);
    return PGRES_POLLING_OK;
}

References cancelConn, conn, CONNECTION_AWAITING_RESPONSE, CONNECTION_BAD, CONNECTION_OK, pg_conn::errorMessage, libpq_append_conn_error(), PGRES_POLLING_FAILED, PGRES_POLLING_OK, PGRES_POLLING_READING, PQconnectPoll(), pqReadData(), resetPQExpBuffer(), and pg_conn::status.

Referenced by libpqsrv_cancel(), pqConnectDBComplete(), and test_cancel().

PQcancelReset()

void PQcancelReset

(

PGcancelConn *

cancelConn

)

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

{
    pqClosePGconn(&cancelConn->conn);
    cancelConn->conn.status = CONNECTION_ALLOCATED;
    cancelConn->conn.whichhost = 0;
    cancelConn->conn.whichaddr = 0;
    cancelConn->conn.try_next_host = false;
    cancelConn->conn.try_next_addr = false;
}

References cancelConn, CONNECTION_ALLOCATED, and pqClosePGconn().

Referenced by test_cancel().

PQcancelSocket()

int PQcancelSocket

(

const PGcancelConn *

cancelConn

)

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

{
    return PQsocket(&cancelConn->conn);
}

References cancelConn, and PQsocket().

Referenced by libpqsrv_cancel(), and test_cancel().

PQcancelStart()

int PQcancelStart

(

PGcancelConn *

cancelConn

)

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

{
    if (!cancelConn || cancelConn->conn.status == CONNECTION_BAD)
        return 0;
 
    if (cancelConn->conn.status != CONNECTION_ALLOCATED)
    {
        libpq_append_conn_error(&cancelConn->conn,
                                "cancel request is already being sent on this connection");
        cancelConn->conn.status = CONNECTION_BAD;
        return 0;
    }
 
    return pqConnectDBStart(&cancelConn->conn);
}

References cancelConn, CONNECTION_ALLOCATED, CONNECTION_BAD, libpq_append_conn_error(), and pqConnectDBStart().

Referenced by libpqsrv_cancel(), PQcancelBlocking(), and test_cancel().

PQcancelStatus()

ConnStatusType PQcancelStatus

(

const PGcancelConn *

cancelConn

)

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

{
    return PQstatus(&cancelConn->conn);
}

References cancelConn, and PQstatus().

Referenced by test_cancel().

PQchangePassword()

PGresult * PQchangePassword	(	PGconn *	conn,
		const char *	user,
		const char *	passwd
	)

Definition at line 1531 of file fe-auth.c.

{
    char       *encrypted_password = PQencryptPasswordConn(conn, passwd,
                                                           user, NULL);
 
    if (!encrypted_password)
    {
        /* PQencryptPasswordConn() already registered the error */
        return NULL;
    }
    else
    {
        char       *fmtpw = PQescapeLiteral(conn, encrypted_password,
                                            strlen(encrypted_password));
 
        /* no longer needed, so clean up now */
        PQfreemem(encrypted_password);
 
        if (!fmtpw)
        {
            /* PQescapeLiteral() already registered the error */
            return NULL;
        }
        else
        {
            char       *fmtuser = PQescapeIdentifier(conn, user, strlen(user));
 
            if (!fmtuser)
            {
                /* PQescapeIdentifier() already registered the error */
                PQfreemem(fmtpw);
                return NULL;
            }
            else
            {
                PQExpBufferData buf;
                PGresult   *res;
 
                initPQExpBuffer(&buf);
                printfPQExpBuffer(&buf, "ALTER USER %s PASSWORD %s",
                                  fmtuser, fmtpw);
 
                res = PQexec(conn, buf.data);
 
                /* clean up */
                termPQExpBuffer(&buf);
                PQfreemem(fmtuser);
                PQfreemem(fmtpw);
 
                return res;
            }
        }
    }
}

References buf, conn, initPQExpBuffer(), PQencryptPasswordConn(), PQescapeIdentifier(), PQescapeLiteral(), PQexec(), PQfreemem(), printfPQExpBuffer(), termPQExpBuffer(), and user.

Referenced by exec_command_password().

PQclear()

void PQclear

(

PGresult *

res

)

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

{
    PGresult_data *block;
    int         i;
 
    /* As a convenience, do nothing for a NULL pointer */
    if (!res)
        return;
    /* Also, do nothing if the argument is OOM_result */
    if ((const PGresult *) res == &OOM_result)
        return;
 
    /* Close down any events we may have */
    for (i = 0; i < res->nEvents; i++)
    {
        /* only send DESTROY to successfully-initialized event procs */
        if (res->events[i].resultInitialized)
        {
            PGEventResultDestroy evt;
 
            evt.result = res;
            (void) res->events[i].proc(PGEVT_RESULTDESTROY, &evt,
                                       res->events[i].passThrough);
        }
        free(res->events[i].name);
    }
 
    free(res->events);
 
    /* Free all the subsidiary blocks */
    while ((block = res->curBlock) != NULL)
    {
        res->curBlock = block->next;
        free(block);
    }
 
    /* Free the top-level tuple pointer array */
    free(res->tuples);
 
    /* zero out the pointer fields to catch programming errors */
    res->attDescs = NULL;
    res->tuples = NULL;
    res->paramDescs = NULL;
    res->errFields = NULL;
    res->events = NULL;
    res->nEvents = 0;
    /* res->curBlock was zeroed out earlier */
 
    /* Free the PGresult structure itself */
    free(res);
}

References pg_result::attDescs, pg_result::curBlock, pg_result::errFields, pg_result::events, free, i, PGEvent::name, pg_result::nEvents, pgresult_data::next, OOM_result, pg_result::paramDescs, PGEvent::passThrough, PGEVT_RESULTDESTROY, PGEvent::proc, PGEventResultDestroy::result, PGEvent::resultInitialized, and pg_result::tuples.

Referenced by pqClearAsyncResult(), PQcopyResult(), PQexecFinish(), PQexecStart(), pqInternalNotice(), and PQmakeEmptyPGresult().

PQclientEncoding()

int PQclientEncoding

(

const PGconn *

conn

)

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

{
    if (!conn || conn->status != CONNECTION_OK)
        return -1;
    return conn->client_encoding;
}

References pg_conn::client_encoding, conn, CONNECTION_OK, and pg_conn::status.

Referenced by appendQualifiedRelation(), appendStringLiteralConn(), dblink_connect(), dblink_get_conn(), escape_append_literal(), escape_fmt_id(), exec_command_encoding(), gen_reindex_command(), get_parallel_tabidx_list(), get_parallel_tables_list(), main(), processSQLNamePattern(), retrieve_objects(), SendQuery(), setup_connection(), SyncVariables(), test_one_vector_escape(), and test_psql_parse().

PQclosePortal()

PGresult * PQclosePortal	(	PGconn *	conn,
		const char *	portal
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendTypedCommand(conn, PqMsg_Close, 'P', portal))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), PqMsg_Close, and PQsendTypedCommand().

Referenced by test_prepared().

PQclosePrepared()

PGresult * PQclosePrepared	(	PGconn *	conn,
		const char *	stmt
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendTypedCommand(conn, PqMsg_Close, 'S', stmt))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), PqMsg_Close, PQsendTypedCommand(), and stmt.

Referenced by test_prepared().

PQcmdStatus()

char * PQcmdStatus

(

PGresult *

res

)

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

{
    if (!res)
        return NULL;
    return res->cmdStatus;
}

References pg_result::cmdStatus.

PQcmdTuples()

char * PQcmdTuples

(

PGresult *

res

)

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

{
    char       *p,
               *c;
 
    if (!res)
        return "";
 
    if (strncmp(res->cmdStatus, "INSERT ", 7) == 0)
    {
        p = res->cmdStatus + 7;
        /* INSERT: skip oid and space */
        while (*p && *p != ' ')
            p++;
        if (*p == 0)
            goto interpret_error;   /* no space? */
        p++;
    }
    else if (strncmp(res->cmdStatus, "SELECT ", 7) == 0 ||
             strncmp(res->cmdStatus, "DELETE ", 7) == 0 ||
             strncmp(res->cmdStatus, "UPDATE ", 7) == 0)
        p = res->cmdStatus + 7;
    else if (strncmp(res->cmdStatus, "FETCH ", 6) == 0 ||
             strncmp(res->cmdStatus, "MERGE ", 6) == 0)
        p = res->cmdStatus + 6;
    else if (strncmp(res->cmdStatus, "MOVE ", 5) == 0 ||
             strncmp(res->cmdStatus, "COPY ", 5) == 0)
        p = res->cmdStatus + 5;
    else
        return "";
 
    /* check that we have an integer (at least one digit, nothing else) */
    for (c = p; *c; c++)
    {
        if (!isdigit((unsigned char) *c))
            goto interpret_error;
    }
    if (c == p)
        goto interpret_error;
 
    return p;
 
interpret_error:
    pqInternalNotice(&res->noticeHooks,
                     "could not interpret result from server: %s",
                     res->cmdStatus);
    return "";
}

References pg_result::cmdStatus, pg_result::noticeHooks, and pqInternalNotice().

PQconndefaults()

PQconninfoOption * PQconndefaults

(

void

)

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

{
    PQExpBufferData errorBuf;
    PQconninfoOption *connOptions;
 
    /* We don't actually report any errors here, but callees want a buffer */
    initPQExpBuffer(&errorBuf);
    if (PQExpBufferDataBroken(errorBuf))
        return NULL;            /* out of memory already :-( */
 
    connOptions = conninfo_init(&errorBuf);
    if (connOptions != NULL)
    {
        /* pass NULL errorBuf to ignore errors */
        if (!conninfo_add_defaults(connOptions, NULL))
        {
            PQconninfoFree(connOptions);
            connOptions = NULL;
        }
    }
 
    termPQExpBuffer(&errorBuf);
    return connOptions;
}

References conninfo_add_defaults(), conninfo_init(), initPQExpBuffer(), PQconninfoFree(), PQExpBufferDataBroken, and termPQExpBuffer().

Referenced by check_pghost_envvar(), dblink_fdw_validator(), do_connect(), get_connect_string(), GetDbnameFromConnectionOptions(), InitPgFdwOptions(), and main().

PQconnectdb()

PGconn * PQconnectdb

(

const char *

conninfo

)

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

{
    PGconn     *conn = PQconnectStart(conninfo);
 
    if (conn && conn->status != CONNECTION_BAD)
        (void) pqConnectDBComplete(conn);
 
    return conn;
}

References conn, CONNECTION_BAD, pqConnectDBComplete(), PQconnectStart(), and pg_conn::status.

Referenced by connect_database(), get_db_conn(), and main().

PQconnectdbParams()

PGconn * PQconnectdbParams	(	const char *const *	keywords,
		const char *const *	values,
		int	expand_dbname
	)

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

{
    PGconn     *conn = PQconnectStartParams(keywords, values, expand_dbname);
 
    if (conn && conn->status != CONNECTION_BAD)
        (void) pqConnectDBComplete(conn);
 
    return conn;
}

References conn, CONNECTION_BAD, keywords, pqConnectDBComplete(), PQconnectStartParams(), pg_conn::status, and values.

Referenced by ConnectDatabase(), connectDatabase(), copy_connection(), doConnect(), ECPGconnect(), GetConnection(), main(), sql_conn(), test_protocol_version(), and vacuumlo().

PQconnectionNeedsPassword()

int PQconnectionNeedsPassword

(

const PGconn *

conn

)

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

{
    char       *password;
 
    if (!conn)
        return false;
    password = PQpass(conn);
    if (conn->password_needed &&
        (password == NULL || password[0] == '\0'))
        return true;
    else
        return false;
}

References conn, password, pg_conn::password_needed, and PQpass().

Referenced by ConnectDatabase(), connectDatabase(), do_connect(), doConnect(), GetConnection(), main(), sql_conn(), and vacuumlo().

PQconnectionUsedGSSAPI()

int PQconnectionUsedGSSAPI

(

const PGconn *

conn

)

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

{
    if (!conn)
        return false;
    if (conn->gssapi_used)
        return true;
    else
        return false;
}

References conn, and pg_conn::gssapi_used.

Referenced by dblink_security_check(), exec_command_conninfo(), and pgfdw_security_check().

PQconnectionUsedPassword()

int PQconnectionUsedPassword

(

const PGconn *

conn

)

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

{
    if (!conn)
        return false;
    if (conn->password_needed)
        return true;
    else
        return false;
}

References conn, and pg_conn::password_needed.

Referenced by ConnectDatabaseAhx(), dblink_security_check(), exec_command_conninfo(), libpqrcv_connect(), and pgfdw_security_check().

PQconnectPoll()

PostgresPollingStatusType PQconnectPoll

(

PGconn *

conn

)

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

{
    bool        reset_connection_state_machine = false;
    bool        need_new_connection = false;
    PGresult   *res;
    char        sebuf[PG_STRERROR_R_BUFLEN];
    int         optval;
 
    if (conn == NULL)
        return PGRES_POLLING_FAILED;
 
    /* Get the new data */
    switch (conn->status)
    {
            /*
             * We really shouldn't have been polled in these two cases, but we
             * can handle it.
             */
        case CONNECTION_BAD:
            return PGRES_POLLING_FAILED;
        case CONNECTION_OK:
            return PGRES_POLLING_OK;
 
            /* These are reading states */
        case CONNECTION_AWAITING_RESPONSE:
        case CONNECTION_AUTH_OK:
        case CONNECTION_CHECK_WRITABLE:
        case CONNECTION_CONSUME:
        case CONNECTION_CHECK_STANDBY:
            {
                /* Load waiting data */
                int         n = pqReadData(conn);
 
                if (n < 0)
                    goto error_return;
                if (n == 0)
                    return PGRES_POLLING_READING;
 
                break;
            }
 
            /* These are writing states, so we just proceed. */
        case CONNECTION_STARTED:
        case CONNECTION_MADE:
            break;
 
            /* Special cases: proceed without waiting. */
        case CONNECTION_SSL_STARTUP:
        case CONNECTION_NEEDED:
        case CONNECTION_GSS_STARTUP:
        case CONNECTION_CHECK_TARGET:
        case CONNECTION_AUTHENTICATING:
            break;
 
        default:
            libpq_append_conn_error(conn, "invalid connection state, probably indicative of memory corruption");
            goto error_return;
    }
 
 
keep_going:                     /* We will come back to here until there is
                                 * nothing left to do. */
 
    /* Time to advance to next address, or next host if no more addresses? */
    if (conn->try_next_addr)
    {
        if (conn->whichaddr < conn->naddr)
        {
            conn->whichaddr++;
            reset_connection_state_machine = true;
        }
        else
            conn->try_next_host = true;
        conn->try_next_addr = false;
    }
 
    /* Time to advance to next connhost[] entry? */
    if (conn->try_next_host)
    {
        pg_conn_host *ch;
        struct addrinfo hint;
        struct addrinfo *addrlist;
        int         thisport;
        int         ret;
        char        portstr[MAXPGPATH];
 
        if (conn->whichhost + 1 < conn->nconnhost)
            conn->whichhost++;
        else
        {
            /*
             * Oops, no more hosts.
             *
             * If we are trying to connect in "prefer-standby" mode, then drop
             * the standby requirement and start over. Don't do this for
             * cancel requests though, since we are certain the list of
             * servers won't change as the target_server_type option is not
             * applicable to those connections.
             *
             * Otherwise, an appropriate error message is already set up, so
             * we just need to set the right status.
             */
            if (conn->target_server_type == SERVER_TYPE_PREFER_STANDBY &&
                conn->nconnhost > 0 &&
                !conn->cancelRequest)
            {
                conn->target_server_type = SERVER_TYPE_PREFER_STANDBY_PASS2;
                conn->whichhost = 0;
            }
            else
                goto error_return;
        }
 
        /* Drop any address info for previous host */
        release_conn_addrinfo(conn);
 
        /*
         * Look up info for the new host.  On failure, log the problem in
         * conn->errorMessage, then loop around to try the next host.  (Note
         * we don't clear try_next_host until we've succeeded.)
         */
        ch = &conn->connhost[conn->whichhost];
 
        /* Initialize hint structure */
        MemSet(&hint, 0, sizeof(hint));
        hint.ai_socktype = SOCK_STREAM;
        hint.ai_family = AF_UNSPEC;
 
        /* Figure out the port number we're going to use. */
        if (ch->port == NULL || ch->port[0] == '\0')
            thisport = DEF_PGPORT;
        else
        {
            if (!pqParseIntParam(ch->port, &thisport, conn, "port"))
                goto error_return;
 
            if (thisport < 1 || thisport > 65535)
            {
                libpq_append_conn_error(conn, "invalid port number: \"%s\"", ch->port);
                goto keep_going;
            }
        }
        snprintf(portstr, sizeof(portstr), "%d", thisport);
 
        /* Use pg_getaddrinfo_all() to resolve the address */
        switch (ch->type)
        {
            case CHT_HOST_NAME:
                ret = pg_getaddrinfo_all(ch->host, portstr, &hint,
                                         &addrlist);
                if (ret || !addrlist)
                {
                    libpq_append_conn_error(conn, "could not translate host name \"%s\" to address: %s",
                                            ch->host, gai_strerror(ret));
                    goto keep_going;
                }
                break;
 
            case CHT_HOST_ADDRESS:
                hint.ai_flags = AI_NUMERICHOST;
                ret = pg_getaddrinfo_all(ch->hostaddr, portstr, &hint,
                                         &addrlist);
                if (ret || !addrlist)
                {
                    libpq_append_conn_error(conn, "could not parse network address \"%s\": %s",
                                            ch->hostaddr, gai_strerror(ret));
                    goto keep_going;
                }
                break;
 
            case CHT_UNIX_SOCKET:
                hint.ai_family = AF_UNIX;
                UNIXSOCK_PATH(portstr, thisport, ch->host);
                if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
                {
                    libpq_append_conn_error(conn, "Unix-domain socket path \"%s\" is too long (maximum %d bytes)",
                                            portstr,
                                            (int) (UNIXSOCK_PATH_BUFLEN - 1));
                    goto keep_going;
                }
 
                /*
                 * NULL hostname tells pg_getaddrinfo_all to parse the service
                 * name as a Unix-domain socket path.
                 */
                ret = pg_getaddrinfo_all(NULL, portstr, &hint,
                                         &addrlist);
                if (ret || !addrlist)
                {
                    libpq_append_conn_error(conn, "could not translate Unix-domain socket path \"%s\" to address: %s",
                                            portstr, gai_strerror(ret));
                    goto keep_going;
                }
                break;
        }
 
        /*
         * Store a copy of the addrlist in private memory so we can perform
         * randomization for load balancing.
         */
        ret = store_conn_addrinfo(conn, addrlist);
        pg_freeaddrinfo_all(hint.ai_family, addrlist);
        if (ret)
            goto error_return;  /* message already logged */
 
        /*
         * If random load balancing is enabled we shuffle the addresses.
         */
        if (conn->load_balance_type == LOAD_BALANCE_RANDOM)
        {
            /*
             * This is the "inside-out" variant of the Fisher-Yates shuffle
             * algorithm. Notionally, we append each new value to the array
             * and then swap it with a randomly-chosen array element (possibly
             * including itself, else we fail to generate permutations with
             * the last integer last).  The swap step can be optimized by
             * combining it with the insertion.
             *
             * We don't need to initialize conn->prng_state here, because that
             * already happened in pqConnectOptions2.
             */
            for (int i = 1; i < conn->naddr; i++)
            {
                int         j = pg_prng_uint64_range(&conn->prng_state, 0, i);
                AddrInfo    temp = conn->addr[j];
 
                conn->addr[j] = conn->addr[i];
                conn->addr[i] = temp;
            }
        }
 
        reset_connection_state_machine = true;
        conn->try_next_host = false;
    }
 
    /* Reset connection state machine? */
    if (reset_connection_state_machine)
    {
        /*
         * (Re) initialize our connection control variables for a set of
         * connection attempts to a single server address.  These variables
         * must persist across individual connection attempts, but we must
         * reset them when we start to consider a new server.
         */
        conn->pversion = conn->max_pversion;
        conn->send_appname = true;
        conn->failed_enc_methods = 0;
        conn->current_enc_method = 0;
        conn->allowed_enc_methods = 0;
        reset_connection_state_machine = false;
        need_new_connection = true;
    }
 
    /* Force a new connection (perhaps to the same server as before)? */
    if (need_new_connection)
    {
        /* Drop any existing connection */
        pqDropConnection(conn, true);
 
        /* Reset all state obtained from old server */
        pqDropServerData(conn);
 
        /* Drop any PGresult we might have, too */
        conn->asyncStatus = PGASYNC_IDLE;
        conn->xactStatus = PQTRANS_IDLE;
        conn->pipelineStatus = PQ_PIPELINE_OFF;
        pqClearAsyncResult(conn);
 
        /* Reset conn->status to put the state machine in the right state */
        conn->status = CONNECTION_NEEDED;
 
        need_new_connection = false;
    }
 
    /*
     * Decide what to do next, if server rejects SSL or GSS negotiation, but
     * the connection is still valid.  If there are no options left, error out
     * with 'msg'.
     */
#define ENCRYPTION_NEGOTIATION_FAILED(msg) \
    do { \
        switch (encryption_negotiation_failed(conn)) \
        { \
            case 0: \
                libpq_append_conn_error(conn, (msg)); \
                goto error_return; \
            case 1: \
                conn->status = CONNECTION_MADE; \
                return PGRES_POLLING_WRITING; \
            case 2: \
                need_new_connection = true; \
                goto keep_going; \
        } \
    } while(0);
 
    /*
     * Decide what to do next, if connection fails.  If there are no options
     * left, return with an error.  The error message has already been written
     * to the connection's error buffer.
     */
#define CONNECTION_FAILED() \
    do { \
        if (connection_failed(conn)) \
        { \
            need_new_connection = true; \
            goto keep_going; \
        } \
        else \
            goto error_return; \
    } while(0);
 
    /* Now try to advance the state machine for this connection */
    switch (conn->status)
    {
        case CONNECTION_NEEDED:
            {
                /*
                 * Try to initiate a connection to one of the addresses
                 * returned by pg_getaddrinfo_all().  conn->whichaddr is the
                 * next one to try.
                 *
                 * The extra level of braces here is historical.  It's not
                 * worth reindenting this whole switch case to remove 'em.
                 */
                {
                    char        host_addr[NI_MAXHOST];
                    int         sock_type;
                    AddrInfo   *addr_cur;
 
                    /*
                     * Advance to next possible host, if we've tried all of
                     * the addresses for the current host.
                     */
                    if (conn->whichaddr == conn->naddr)
                    {
                        conn->try_next_host = true;
                        goto keep_going;
                    }
                    addr_cur = &conn->addr[conn->whichaddr];
 
                    /* Remember current address for possible use later */
                    memcpy(&conn->raddr, &addr_cur->addr, sizeof(SockAddr));
 
#ifdef ENABLE_GSS
 
                    /*
                     * Before establishing the connection, check if it's
                     * doomed to fail because gssencmode='require' but GSSAPI
                     * is not available.
                     */
                    if (conn->gssencmode[0] == 'r')
                    {
                        if (conn->raddr.addr.ss_family == AF_UNIX)
                        {
                            libpq_append_conn_error(conn,
                                                    "GSSAPI encryption required but it is not supported over a local socket");
                            goto error_return;
                        }
                        if (conn->gcred == GSS_C_NO_CREDENTIAL)
                        {
                            if (!pg_GSS_have_cred_cache(&conn->gcred))
                            {
                                libpq_append_conn_error(conn,
                                                        "GSSAPI encryption required but no credential cache");
                                goto error_return;
                            }
                        }
                    }
#endif
 
                    /*
                     * Choose the encryption method to try first.  Do this
                     * before establishing the connection, so that if none of
                     * the modes allowed by the connections options are
                     * available, we can error out before establishing the
                     * connection.
                     */
                    if (!init_allowed_encryption_methods(conn))
                        goto error_return;
 
                    /*
                     * Set connip, too.  Note we purposely ignore strdup
                     * failure; not a big problem if it fails.
                     */
                    if (conn->connip != NULL)
                    {
                        free(conn->connip);
                        conn->connip = NULL;
                    }
                    getHostaddr(conn, host_addr, NI_MAXHOST);
                    if (host_addr[0])
                        conn->connip = strdup(host_addr);
 
                    /* Try to create the socket */
                    sock_type = SOCK_STREAM;
#ifdef SOCK_CLOEXEC
 
                    /*
                     * Atomically mark close-on-exec, if possible on this
                     * platform, so that there isn't a window where a
                     * subprogram executed by another thread inherits the
                     * socket.  See fallback code below.
                     */
                    sock_type |= SOCK_CLOEXEC;
#endif
#ifdef SOCK_NONBLOCK
 
                    /*
                     * We might as well skip a system call for nonblocking
                     * mode too, if we can.
                     */
                    sock_type |= SOCK_NONBLOCK;
#endif
                    conn->sock = socket(addr_cur->family, sock_type, 0);
                    if (conn->sock == PGINVALID_SOCKET)
                    {
                        int         errorno = SOCK_ERRNO;
 
                        /*
                         * Silently ignore socket() failure if we have more
                         * addresses to try; this reduces useless chatter in
                         * cases where the address list includes both IPv4 and
                         * IPv6 but kernel only accepts one family.
                         */
                        if (conn->whichaddr < conn->naddr ||
                            conn->whichhost + 1 < conn->nconnhost)
                        {
                            conn->try_next_addr = true;
                            goto keep_going;
                        }
                        emitHostIdentityInfo(conn, host_addr);
                        libpq_append_conn_error(conn, "could not create socket: %s",
                                                SOCK_STRERROR(errorno, sebuf, sizeof(sebuf)));
                        goto error_return;
                    }
 
                    /*
                     * Once we've identified a target address, all errors
                     * except the preceding socket()-failure case should be
                     * prefixed with host-identity information.  (If the
                     * connection succeeds, the contents of conn->errorMessage
                     * won't matter, so this is harmless.)
                     */
                    emitHostIdentityInfo(conn, host_addr);
 
                    /*
                     * Select socket options: no delay of outgoing data for
                     * TCP sockets, nonblock mode, close-on-exec.  Try the
                     * next address if any of this fails.
                     */
                    if (addr_cur->family != AF_UNIX)
                    {
                        if (!connectNoDelay(conn))
                        {
                            /* error message already created */
                            conn->try_next_addr = true;
                            goto keep_going;
                        }
                    }
#ifndef SOCK_NONBLOCK
                    if (!pg_set_noblock(conn->sock))
                    {
                        libpq_append_conn_error(conn, "could not set socket to nonblocking mode: %s",
                                                SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        conn->try_next_addr = true;
                        goto keep_going;
                    }
#endif
 
#ifndef SOCK_CLOEXEC
#ifdef F_SETFD
                    if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
                    {
                        libpq_append_conn_error(conn, "could not set socket to close-on-exec mode: %s",
                                                SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        conn->try_next_addr = true;
                        goto keep_going;
                    }
#endif                          /* F_SETFD */
#endif
 
                    if (addr_cur->family != AF_UNIX)
                    {
#ifndef WIN32
                        int         on = 1;
#endif
                        int         usekeepalives = useKeepalives(conn);
                        int         err = 0;
 
                        if (usekeepalives < 0)
                        {
                            /* error is already reported */
                            err = 1;
                        }
                        else if (usekeepalives == 0)
                        {
                            /* Do nothing */
                        }
#ifndef WIN32
                        else if (setsockopt(conn->sock,
                                            SOL_SOCKET, SO_KEEPALIVE,
                                            (char *) &on, sizeof(on)) < 0)
                        {
                            libpq_append_conn_error(conn, "%s(%s) failed: %s",
                                                    "setsockopt",
                                                    "SO_KEEPALIVE",
                                                    SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                            err = 1;
                        }
                        else if (!setKeepalivesIdle(conn)
                                 || !setKeepalivesInterval(conn)
                                 || !setKeepalivesCount(conn))
                            err = 1;
#else                           /* WIN32 */
#ifdef SIO_KEEPALIVE_VALS
                        else if (!prepKeepalivesWin32(conn))
                            err = 1;
#endif                          /* SIO_KEEPALIVE_VALS */
#endif                          /* WIN32 */
                        else if (!setTCPUserTimeout(conn))
                            err = 1;
 
                        if (err)
                        {
                            conn->try_next_addr = true;
                            goto keep_going;
                        }
                    }
 
                    /*----------
                     * We have three methods of blocking SIGPIPE during
                     * send() calls to this socket:
                     *
                     *  - setsockopt(sock, SO_NOSIGPIPE)
                     *  - send(sock, ..., MSG_NOSIGNAL)
                     *  - setting the signal mask to SIG_IGN during send()
                     *
                     * The third method requires three syscalls per send,
                     * so we prefer either of the first two, but they are
                     * less portable.  The state is tracked in the following
                     * members of PGconn:
                     *
                     * conn->sigpipe_so     - we have set up SO_NOSIGPIPE
                     * conn->sigpipe_flag   - we're specifying MSG_NOSIGNAL
                     *
                     * If we can use SO_NOSIGPIPE, then set sigpipe_so here
                     * and we're done.  Otherwise, set sigpipe_flag so that
                     * we will try MSG_NOSIGNAL on sends.  If we get an error
                     * with MSG_NOSIGNAL, we'll clear that flag and revert to
                     * signal masking.
                     *----------
                     */
                    conn->sigpipe_so = false;
#ifdef MSG_NOSIGNAL
                    conn->sigpipe_flag = true;
#else
                    conn->sigpipe_flag = false;
#endif                          /* MSG_NOSIGNAL */
 
#ifdef SO_NOSIGPIPE
                    optval = 1;
                    if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
                                   (char *) &optval, sizeof(optval)) == 0)
                    {
                        conn->sigpipe_so = true;
                        conn->sigpipe_flag = false;
                    }
#endif                          /* SO_NOSIGPIPE */
 
                    /*
                     * Start/make connection.  This should not block, since we
                     * are in nonblock mode.  If it does, well, too bad.
                     */
                    if (connect(conn->sock, (struct sockaddr *) &addr_cur->addr.addr,
                                addr_cur->addr.salen) < 0)
                    {
                        if (SOCK_ERRNO == EINPROGRESS ||
#ifdef WIN32
                            SOCK_ERRNO == EWOULDBLOCK ||
#endif
                            SOCK_ERRNO == EINTR)
                        {
                            /*
                             * This is fine - we're in non-blocking mode, and
                             * the connection is in progress.  Tell caller to
                             * wait for write-ready on socket.
                             */
                            conn->status = CONNECTION_STARTED;
                            return PGRES_POLLING_WRITING;
                        }
                        /* otherwise, trouble */
                    }
                    else
                    {
                        /*
                         * Hm, we're connected already --- seems the "nonblock
                         * connection" wasn't.  Advance the state machine and
                         * go do the next stuff.
                         */
                        conn->status = CONNECTION_STARTED;
                        goto keep_going;
                    }
 
                    /*
                     * This connection failed.  Add the error report to
                     * conn->errorMessage, then try the next address if any.
                     */
                    connectFailureMessage(conn, SOCK_ERRNO);
                    conn->try_next_addr = true;
                    goto keep_going;
                }
            }
 
        case CONNECTION_STARTED:
            {
                socklen_t   optlen = sizeof(optval);
 
                /*
                 * Write ready, since we've made it here, so the connection
                 * has been made ... or has failed.
                 */
 
                /*
                 * Now check (using getsockopt) that there is not an error
                 * state waiting for us on the socket.
                 */
 
                if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
                               (char *) &optval, &optlen) == -1)
                {
                    libpq_append_conn_error(conn, "could not get socket error status: %s",
                                            SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                    goto error_return;
                }
                else if (optval != 0)
                {
                    /*
                     * When using a nonblocking connect, we will typically see
                     * connect failures at this point, so provide a friendly
                     * error message.
                     */
                    connectFailureMessage(conn, optval);
 
                    /*
                     * Try the next address if any, just as in the case where
                     * connect() returned failure immediately.
                     */
                    conn->try_next_addr = true;
                    goto keep_going;
                }
 
                /* Fill in the client address */
                conn->laddr.salen = sizeof(conn->laddr.addr);
                if (getsockname(conn->sock,
                                (struct sockaddr *) &conn->laddr.addr,
                                &conn->laddr.salen) < 0)
                {
                    libpq_append_conn_error(conn, "could not get client address from socket: %s",
                                            SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                    goto error_return;
                }
 
                /*
                 * Implement requirepeer check, if requested and it's a
                 * Unix-domain socket.
                 */
                if (conn->requirepeer && conn->requirepeer[0] &&
                    conn->raddr.addr.ss_family == AF_UNIX)
                {
#ifndef WIN32
                    char       *remote_username;
#endif
                    uid_t       uid;
                    gid_t       gid;
 
                    errno = 0;
                    if (getpeereid(conn->sock, &uid, &gid) != 0)
                    {
                        /*
                         * Provide special error message if getpeereid is a
                         * stub
                         */
                        if (errno == ENOSYS)
                            libpq_append_conn_error(conn, "requirepeer parameter is not supported on this platform");
                        else
                            libpq_append_conn_error(conn, "could not get peer credentials: %s",
                                                    strerror_r(errno, sebuf, sizeof(sebuf)));
                        goto error_return;
                    }
 
#ifndef WIN32
                    remote_username = pg_fe_getusername(uid,
                                                        &conn->errorMessage);
                    if (remote_username == NULL)
                        goto error_return;  /* message already logged */
 
                    if (strcmp(remote_username, conn->requirepeer) != 0)
                    {
                        libpq_append_conn_error(conn, "requirepeer specifies \"%s\", but actual peer user name is \"%s\"",
                                                conn->requirepeer, remote_username);
                        free(remote_username);
                        goto error_return;
                    }
                    free(remote_username);
#else                           /* WIN32 */
                    /* should have failed with ENOSYS above */
                    Assert(false);
#endif                          /* WIN32 */
                }
 
                /*
                 * Make sure we can write before advancing to next step.
                 */
                conn->status = CONNECTION_MADE;
                return PGRES_POLLING_WRITING;
            }
 
        case CONNECTION_MADE:
            {
                char       *startpacket;
                int         packetlen;
 
#ifdef ENABLE_GSS
 
                /*
                 * If GSSAPI encryption is enabled, send a packet to the
                 * server asking for GSSAPI Encryption and proceed with GSSAPI
                 * handshake.  We will come back here after GSSAPI encryption
                 * has been established, with conn->gctx set.
                 */
                if (conn->current_enc_method == ENC_GSSAPI && !conn->gctx)
                {
                    ProtocolVersion pv = pg_hton32(NEGOTIATE_GSS_CODE);
 
                    if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                    {
                        libpq_append_conn_error(conn, "could not send GSSAPI negotiation packet: %s",
                                                SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        goto error_return;
                    }
 
                    /* Ok, wait for response */
                    conn->status = CONNECTION_GSS_STARTUP;
                    return PGRES_POLLING_READING;
                }
#endif
 
#ifdef USE_SSL
 
                /*
                 * If SSL is enabled, start the SSL negotiation. We will come
                 * back here after SSL encryption has been established, with
                 * ssl_in_use set.
                 */
                if (conn->current_enc_method == ENC_SSL && !conn->ssl_in_use)
                {
                    /*
                     * If traditional postgres SSL negotiation is used, send
                     * the SSL request.  In direct negotiation, jump straight
                     * into the SSL handshake.
                     */
                    if (conn->sslnegotiation[0] == 'p')
                    {
                        ProtocolVersion pv;
 
                        /*
                         * Send the SSL request packet.
                         *
                         * Theoretically, this could block, but it really
                         * shouldn't since we only got here if the socket is
                         * write-ready.
                         */
                        pv = pg_hton32(NEGOTIATE_SSL_CODE);
                        if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                        {
                            libpq_append_conn_error(conn, "could not send SSL negotiation packet: %s",
                                                    SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                            goto error_return;
                        }
                        /* Ok, wait for response */
                        conn->status = CONNECTION_SSL_STARTUP;
                        return PGRES_POLLING_READING;
                    }
                    else
                    {
                        Assert(conn->sslnegotiation[0] == 'd');
                        conn->status = CONNECTION_SSL_STARTUP;
                        return PGRES_POLLING_WRITING;
                    }
                }
#endif                          /* USE_SSL */
 
                /*
                 * For cancel requests this is as far as we need to go in the
                 * connection establishment. Now we can actually send our
                 * cancellation request.
                 */
                if (conn->cancelRequest)
                {
                    if (PQsendCancelRequest(conn) != STATUS_OK)
                    {
                        libpq_append_conn_error(conn, "could not send cancel packet: %s",
                                                SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        goto error_return;
                    }
                    conn->status = CONNECTION_AWAITING_RESPONSE;
                    return PGRES_POLLING_READING;
                }
 
                /*
                 * We have now established encryption, or we are happy to
                 * proceed without.
                 */
 
                /* Build the startup packet. */
                startpacket = pqBuildStartupPacket3(conn, &packetlen,
                                                    EnvironmentOptions);
                if (!startpacket)
                {
                    libpq_append_conn_error(conn, "out of memory");
                    goto error_return;
                }
 
                /*
                 * Send the startup packet.
                 *
                 * Theoretically, this could block, but it really shouldn't
                 * since we only got here if the socket is write-ready.
                 */
                if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
                {
                    libpq_append_conn_error(conn, "could not send startup packet: %s",
                                            SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                    free(startpacket);
                    goto error_return;
                }
 
                free(startpacket);
 
                conn->status = CONNECTION_AWAITING_RESPONSE;
                return PGRES_POLLING_READING;
            }
 
            /*
             * Handle SSL negotiation: wait for postmaster messages and
             * respond as necessary.
             */
        case CONNECTION_SSL_STARTUP:
            {
#ifdef USE_SSL
                PostgresPollingStatusType pollres;
 
                /*
                 * On first time through with traditional SSL negotiation, get
                 * the postmaster's response to our SSLRequest packet. With
                 * sslnegotiation='direct', go straight to initiating SSL.
                 */
                if (!conn->ssl_in_use && conn->sslnegotiation[0] == 'p')
                {
                    /*
                     * We use pqReadData here since it has the logic to
                     * distinguish no-data-yet from connection closure. Since
                     * conn->ssl isn't set, a plain recv() will occur.
                     */
                    char        SSLok;
                    int         rdresult;
 
                    rdresult = pqReadData(conn);
                    if (rdresult < 0)
                    {
                        /* errorMessage is already filled in */
                        goto error_return;
                    }
                    if (rdresult == 0)
                    {
                        /* caller failed to wait for data */
                        return PGRES_POLLING_READING;
                    }
                    if (pqGetc(&SSLok, conn) < 0)
                    {
                        /* should not happen really */
                        return PGRES_POLLING_READING;
                    }
                    if (SSLok == 'S')
                    {
                        if (conn->Pfdebug)
                            pqTraceOutputCharResponse(conn, "SSLResponse",
                                                      SSLok);
                        /* mark byte consumed */
                        conn->inStart = conn->inCursor;
                    }
                    else if (SSLok == 'N')
                    {
                        if (conn->Pfdebug)
                            pqTraceOutputCharResponse(conn, "SSLResponse",
                                                      SSLok);
                        /* mark byte consumed */
                        conn->inStart = conn->inCursor;
 
                        /*
                         * The connection is still valid, so if it's OK to
                         * continue without SSL, we can proceed using this
                         * connection.  Otherwise return with an error.
                         */
                        ENCRYPTION_NEGOTIATION_FAILED(libpq_gettext("server does not support SSL, but SSL was required"));
                    }
                    else if (SSLok == 'E')
                    {
                        /*
                         * Server failure of some sort, such as failure to
                         * fork a backend process.  Don't bother retrieving
                         * the error message; we should not trust it as the
                         * server has not been authenticated yet.
                         */
                        libpq_append_conn_error(conn, "server sent an error response during SSL exchange");
                        goto error_return;
                    }
                    else
                    {
                        libpq_append_conn_error(conn, "received invalid response to SSL negotiation: %c",
                                                SSLok);
                        goto error_return;
                    }
                }
 
                /*
                 * Begin or continue the SSL negotiation process.
                 */
                pollres = pqsecure_open_client(conn);
                if (pollres == PGRES_POLLING_OK)
                {
                    /*
                     * At this point we should have no data already buffered.
                     * If we do, it was received before we performed the SSL
                     * handshake, so it wasn't encrypted and indeed may have
                     * been injected by a man-in-the-middle.
                     */
                    if (conn->inCursor != conn->inEnd)
                    {
                        libpq_append_conn_error(conn, "received unencrypted data after SSL response");
                        goto error_return;
                    }
 
                    /* SSL handshake done, ready to send startup packet */
                    conn->status = CONNECTION_MADE;
                    return PGRES_POLLING_WRITING;
                }
                if (pollres == PGRES_POLLING_FAILED)
                {
                    /*
                     * SSL handshake failed.  We will retry with a plaintext
                     * connection, if permitted by sslmode.
                     */
                    CONNECTION_FAILED();
                }
                /* Else, return POLLING_READING or POLLING_WRITING status */
                return pollres;
#else                           /* !USE_SSL */
                /* can't get here */
                goto error_return;
#endif                          /* USE_SSL */
            }
 
        case CONNECTION_GSS_STARTUP:
            {
#ifdef ENABLE_GSS
                PostgresPollingStatusType pollres;
 
                /*
                 * If we haven't yet, get the postmaster's response to our
                 * negotiation packet
                 */
                if (!conn->gctx)
                {
                    char        gss_ok;
                    int         rdresult = pqReadData(conn);
 
                    if (rdresult < 0)
                        /* pqReadData fills in error message */
                        goto error_return;
                    else if (rdresult == 0)
                        /* caller failed to wait for data */
                        return PGRES_POLLING_READING;
                    if (pqGetc(&gss_ok, conn) < 0)
                        /* shouldn't happen... */
                        return PGRES_POLLING_READING;
 
                    if (gss_ok == 'E')
                    {
                        /*
                         * Server failure of some sort, possibly protocol
                         * version support failure.  Don't bother retrieving
                         * the error message; we should not trust it anyway as
                         * the server has not authenticated yet.
                         *
                         * Note that unlike on an error response to
                         * SSLRequest, we allow falling back to SSL or
                         * plaintext connection here.  GSS support was
                         * introduced in PostgreSQL version 12, so an error
                         * response might mean that we are connecting to a
                         * pre-v12 server.
                         */
                        libpq_append_conn_error(conn, "server sent an error response during GSS encryption exchange");
                        CONNECTION_FAILED();
                    }
 
                    /* mark byte consumed */
                    conn->inStart = conn->inCursor;
 
                    if (gss_ok == 'N')
                    {
                        if (conn->Pfdebug)
                            pqTraceOutputCharResponse(conn, "GSSENCResponse",
                                                      gss_ok);
 
                        /*
                         * The connection is still valid, so if it's OK to
                         * continue without GSS, we can proceed using this
                         * connection.  Otherwise return with an error.
                         */
                        ENCRYPTION_NEGOTIATION_FAILED(libpq_gettext("server doesn't support GSSAPI encryption, but it was required"));
                    }
                    else if (gss_ok != 'G')
                    {
                        libpq_append_conn_error(conn, "received invalid response to GSSAPI negotiation: %c",
                                                gss_ok);
                        goto error_return;
                    }
 
                    if (conn->Pfdebug)
                        pqTraceOutputCharResponse(conn, "GSSENCResponse",
                                                  gss_ok);
                }
 
                /* Begin or continue GSSAPI negotiation */
                pollres = pqsecure_open_gss(conn);
                if (pollres == PGRES_POLLING_OK)
                {
                    /*
                     * At this point we should have no data already buffered.
                     * If we do, it was received before we performed the GSS
                     * handshake, so it wasn't encrypted and indeed may have
                     * been injected by a man-in-the-middle.
                     */
                    if (conn->inCursor != conn->inEnd)
                    {
                        libpq_append_conn_error(conn, "received unencrypted data after GSSAPI encryption response");
                        goto error_return;
                    }
 
                    /* All set for startup packet */
                    conn->status = CONNECTION_MADE;
                    return PGRES_POLLING_WRITING;
                }
                else if (pollres == PGRES_POLLING_FAILED)
                {
                    /*
                     * GSS handshake failed.  We will retry with an SSL or
                     * plaintext connection, if permitted by the options.
                     */
                    CONNECTION_FAILED();
                }
                /* Else, return POLLING_READING or POLLING_WRITING status */
                return pollres;
#else                           /* !ENABLE_GSS */
                /* unreachable */
                goto error_return;
#endif                          /* ENABLE_GSS */
            }
 
            /*
             * Handle authentication exchange: wait for postmaster messages
             * and respond as necessary.
             */
        case CONNECTION_AWAITING_RESPONSE:
            {
                char        beresp;
                int         msgLength;
                int         avail;
                AuthRequest areq;
                int         res;
                bool        async;
 
                /*
                 * Scan the message from current point (note that if we find
                 * the message is incomplete, we will return without advancing
                 * inStart, and resume here next time).
                 */
                conn->inCursor = conn->inStart;
 
                /* Read type byte */
                if (pqGetc(&beresp, conn))
                {
                    /* We'll come back when there is more data */
                    return PGRES_POLLING_READING;
                }
 
                /*
                 * Validate message type: we expect only an authentication
                 * request, NegotiateProtocolVersion, or an error here.
                 * Anything else probably means it's not Postgres on the other
                 * end at all.
                 */
                if (beresp != PqMsg_AuthenticationRequest &&
                    beresp != PqMsg_ErrorResponse &&
                    beresp != PqMsg_NegotiateProtocolVersion)
                {
                    libpq_append_conn_error(conn, "expected authentication request from server, but received %c",
                                            beresp);
                    goto error_return;
                }
 
                /* Read message length word */
                if (pqGetInt(&msgLength, 4, conn))
                {
                    /* We'll come back when there is more data */
                    return PGRES_POLLING_READING;
                }
 
                /*
                 * Try to validate message length before using it.
                 *
                 * Authentication requests can't be very large, although GSS
                 * auth requests may not be that small.  Same for
                 * NegotiateProtocolVersion.
                 *
                 * Errors can be a little larger, but not huge.  If we see a
                 * large apparent length in an error, it means we're really
                 * talking to a pre-3.0-protocol server; cope.  (Before
                 * version 14, the server also used the old protocol for
                 * errors that happened before processing the startup packet.)
                 */
                if (beresp == PqMsg_AuthenticationRequest &&
                    (msgLength < 8 || msgLength > 2000))
                {
                    libpq_append_conn_error(conn, "received invalid authentication request");
                    goto error_return;
                }
                if (beresp == PqMsg_NegotiateProtocolVersion &&
                    (msgLength < 8 || msgLength > 2000))
                {
                    libpq_append_conn_error(conn, "received invalid protocol negotiation message");
                    goto error_return;
                }
 
#define MAX_ERRLEN 30000
                if (beresp == PqMsg_ErrorResponse &&
                    (msgLength < 8 || msgLength > MAX_ERRLEN))
                {
                    /* Handle error from a pre-3.0 server */
                    conn->inCursor = conn->inStart + 1; /* reread data */
                    if (pqGets_append(&conn->errorMessage, conn))
                    {
                        /*
                         * We may not have authenticated the server yet, so
                         * don't let the buffer grow forever.
                         */
                        avail = conn->inEnd - conn->inCursor;
                        if (avail > MAX_ERRLEN)
                        {
                            libpq_append_conn_error(conn, "received invalid error message");
                            goto error_return;
                        }
 
                        /* We'll come back when there is more data */
                        return PGRES_POLLING_READING;
                    }
                    /* OK, we read the message; mark data consumed */
                    pqParseDone(conn, conn->inCursor);
 
                    /*
                     * Before 7.2, the postmaster didn't always end its
                     * messages with a newline, so add one if needed to
                     * conform to libpq conventions.
                     */
                    if (conn->errorMessage.len == 0 ||
                        conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
                    {
                        appendPQExpBufferChar(&conn->errorMessage, '\n');
                    }
 
                    goto error_return;
                }
#undef MAX_ERRLEN
 
                /*
                 * Can't process if message body isn't all here yet.
                 *
                 * After this check passes, any further EOF during parsing
                 * implies that the server sent a bad/truncated message.
                 * Reading more bytes won't help in that case, so don't return
                 * PGRES_POLLING_READING after this point.
                 */
                msgLength -= 4;
                avail = conn->inEnd - conn->inCursor;
                if (avail < msgLength)
                {
                    /*
                     * Before returning, try to enlarge the input buffer if
                     * needed to hold the whole message; see notes in
                     * pqParseInput3.
                     */
                    if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
                                             conn))
                        goto error_return;
                    /* We'll come back when there is more data */
                    return PGRES_POLLING_READING;
                }
 
                /* Handle errors. */
                if (beresp == PqMsg_ErrorResponse)
                {
                    if (pqGetErrorNotice3(conn, true))
                    {
                        libpq_append_conn_error(conn, "received invalid error message");
                        goto error_return;
                    }
                    /* OK, we read the message; mark data consumed */
                    pqParseDone(conn, conn->inCursor);
 
                    /*
                     * If error is "cannot connect now", try the next host if
                     * any (but we don't want to consider additional addresses
                     * for this host, nor is there much point in changing SSL
                     * or GSS mode).  This is helpful when dealing with
                     * standby servers that might not be in hot-standby state.
                     */
                    if (strcmp(conn->last_sqlstate,
                               ERRCODE_CANNOT_CONNECT_NOW) == 0)
                    {
                        conn->try_next_host = true;
                        goto keep_going;
                    }
 
                    /* Check to see if we should mention pgpassfile */
                    pgpassfileWarning(conn);
 
                    CONNECTION_FAILED();
                }
                /* Handle NegotiateProtocolVersion */
                else if (beresp == PqMsg_NegotiateProtocolVersion)
                {
                    if (conn->pversion_negotiated)
                    {
                        libpq_append_conn_error(conn, "received duplicate protocol negotiation message");
                        goto error_return;
                    }
                    if (pqGetNegotiateProtocolVersion3(conn))
                    {
                        /* pqGetNegotiateProtocolVersion3 set error already */
                        goto error_return;
                    }
                    conn->pversion_negotiated = true;
 
                    /* OK, we read the message; mark data consumed */
                    pqParseDone(conn, conn->inCursor);
 
                    goto keep_going;
                }
 
                /* It is an authentication request. */
                conn->auth_req_received = true;
 
                /* Get the type of request. */
                if (pqGetInt((int *) &areq, 4, conn))
                {
                    /* can't happen because we checked the length already */
                    libpq_append_conn_error(conn, "received invalid authentication request");
                    goto error_return;
                }
                msgLength -= 4;
 
                /*
                 * Process the rest of the authentication request message, and
                 * respond to it if necessary.
                 *
                 * Note that conn->pghost must be non-NULL if we are going to
                 * avoid the Kerberos code doing a hostname look-up.
                 */
                res = pg_fe_sendauth(areq, msgLength, conn, &async);
 
                if (async && (res == STATUS_OK))
                {
                    /*
                     * We'll come back later once we're ready to respond.
                     * Don't consume the request yet.
                     */
                    conn->status = CONNECTION_AUTHENTICATING;
                    goto keep_going;
                }
 
                /*
                 * OK, we have processed the message; mark data consumed.  We
                 * don't call pqParseDone here because we already traced this
                 * message inside pg_fe_sendauth.
                 */
                conn->inStart = conn->inCursor;
 
                if (res != STATUS_OK)
                {
                    /*
                     * OAuth connections may perform two-step discovery, where
                     * the first connection is a dummy.
                     */
                    if (conn->sasl == &pg_oauth_mech && conn->oauth_want_retry)
                    {
                        need_new_connection = true;
                        goto keep_going;
                    }
 
                    goto error_return;
                }
 
                /*
                 * Just make sure that any data sent by pg_fe_sendauth is
                 * flushed out.  Although this theoretically could block, it
                 * really shouldn't since we don't send large auth responses.
                 */
                if (pqFlush(conn))
                    goto error_return;
 
                if (areq == AUTH_REQ_OK)
                {
                    /* We are done with authentication exchange */
                    conn->status = CONNECTION_AUTH_OK;
 
                    /*
                     * Set asyncStatus so that PQgetResult will think that
                     * what comes back next is the result of a query.  See
                     * below.
                     */
                    conn->asyncStatus = PGASYNC_BUSY;
                }
 
                /* Look to see if we have more data yet. */
                goto keep_going;
            }
 
        case CONNECTION_AUTHENTICATING:
            {
                PostgresPollingStatusType status;
 
                if (!conn->async_auth || !conn->cleanup_async_auth)
                {
                    /* programmer error; should not happen */
                    libpq_append_conn_error(conn,
                                            "internal error: async authentication has no handler");
                    goto error_return;
                }
 
                /* Drive some external authentication work. */
                status = conn->async_auth(conn);
 
                if (status == PGRES_POLLING_FAILED)
                    goto error_return;
 
                if (status == PGRES_POLLING_OK)
                {
                    /* Done. Tear down the async implementation. */
                    conn->cleanup_async_auth(conn);
                    conn->cleanup_async_auth = NULL;
 
                    /*
                     * Cleanup must unset altsock, both as an indication that
                     * it's been released, and to stop pqSocketCheck from
                     * looking at the wrong socket after async auth is done.
                     */
                    if (conn->altsock != PGINVALID_SOCKET)
                    {
                        Assert(false);
                        libpq_append_conn_error(conn,
                                                "internal error: async cleanup did not release polling socket");
                        goto error_return;
                    }
 
                    /*
                     * Reenter the authentication exchange with the server. We
                     * didn't consume the message that started external
                     * authentication, so it'll be reprocessed as if we just
                     * received it.
                     */
                    conn->status = CONNECTION_AWAITING_RESPONSE;
 
                    goto keep_going;
                }
 
                /*
                 * Caller needs to poll some more. conn->async_auth() should
                 * have assigned an altsock to poll on.
                 */
                if (conn->altsock == PGINVALID_SOCKET)
                {
                    Assert(false);
                    libpq_append_conn_error(conn,
                                            "internal error: async authentication did not set a socket for polling");
                    goto error_return;
                }
 
                return status;
            }
 
        case CONNECTION_AUTH_OK:
            {
                /*
                 * Now we expect to hear from the backend. A ReadyForQuery
                 * message indicates that startup is successful, but we might
                 * also get an Error message indicating failure. (Notice
                 * messages indicating nonfatal warnings are also allowed by
                 * the protocol, as are ParameterStatus and BackendKeyData
                 * messages.) Easiest way to handle this is to let
                 * PQgetResult() read the messages. We just have to fake it
                 * out about the state of the connection, by setting
                 * asyncStatus = PGASYNC_BUSY (done above).
                 */
 
                if (PQisBusy(conn))
                    return PGRES_POLLING_READING;
 
                res = PQgetResult(conn);
 
                /*
                 * NULL return indicating we have gone to IDLE state is
                 * expected
                 */
                if (res)
                {
                    if (res->resultStatus != PGRES_FATAL_ERROR)
                        libpq_append_conn_error(conn, "unexpected message from server during startup");
                    else if (conn->send_appname &&
                             (conn->appname || conn->fbappname))
                    {
                        /*
                         * If we tried to send application_name, check to see
                         * if the error is about that --- pre-9.0 servers will
                         * reject it at this stage of the process.  If so,
                         * close the connection and retry without sending
                         * application_name.  We could possibly get a false
                         * SQLSTATE match here and retry uselessly, but there
                         * seems no great harm in that; we'll just get the
                         * same error again if it's unrelated.
                         */
                        const char *sqlstate;
 
                        sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
                        if (sqlstate &&
                            strcmp(sqlstate, ERRCODE_APPNAME_UNKNOWN) == 0)
                        {
                            PQclear(res);
                            conn->send_appname = false;
                            need_new_connection = true;
                            goto keep_going;
                        }
                    }
 
                    /*
                     * if the resultStatus is FATAL, then conn->errorMessage
                     * already has a copy of the error; needn't copy it back.
                     * But add a newline if it's not there already, since
                     * postmaster error messages may not have one.
                     */
                    if (conn->errorMessage.len <= 0 ||
                        conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
                        appendPQExpBufferChar(&conn->errorMessage, '\n');
                    PQclear(res);
                    goto error_return;
                }
 
                /* Almost there now ... */
                conn->status = CONNECTION_CHECK_TARGET;
                goto keep_going;
            }
 
        case CONNECTION_CHECK_TARGET:
            {
                /*
                 * If a read-write, read-only, primary, or standby connection
                 * is required, see if we have one.
                 */
                if (conn->target_server_type == SERVER_TYPE_READ_WRITE ||
                    conn->target_server_type == SERVER_TYPE_READ_ONLY)
                {
                    bool        read_only_server;
 
                    /*
                     * If the server didn't report
                     * "default_transaction_read_only" or "in_hot_standby" at
                     * startup, we must determine its state by sending the
                     * query "SHOW transaction_read_only".  This GUC exists in
                     * all server versions that support 3.0 protocol.
                     */
                    if (conn->default_transaction_read_only == PG_BOOL_UNKNOWN ||
                        conn->in_hot_standby == PG_BOOL_UNKNOWN)
                    {
                        /*
                         * We use PQsendQueryContinue so that
                         * conn->errorMessage does not get cleared.  We need
                         * to preserve any error messages related to previous
                         * hosts we have tried and failed to connect to.
                         */
                        conn->status = CONNECTION_OK;
                        if (!PQsendQueryContinue(conn,
                                                 "SHOW transaction_read_only"))
                            goto error_return;
                        /* We'll return to this state when we have the answer */
                        conn->status = CONNECTION_CHECK_WRITABLE;
                        return PGRES_POLLING_READING;
                    }
 
                    /* OK, we can make the test */
                    read_only_server =
                        (conn->default_transaction_read_only == PG_BOOL_YES ||
                         conn->in_hot_standby == PG_BOOL_YES);
 
                    if ((conn->target_server_type == SERVER_TYPE_READ_WRITE) ?
                        read_only_server : !read_only_server)
                    {
                        /* Wrong server state, reject and try the next host */
                        if (conn->target_server_type == SERVER_TYPE_READ_WRITE)
                            libpq_append_conn_error(conn, "session is read-only");
                        else
                            libpq_append_conn_error(conn, "session is not read-only");
 
                        /* Close connection politely. */
                        conn->status = CONNECTION_OK;
                        sendTerminateConn(conn);
 
                        /*
                         * Try next host if any, but we don't want to consider
                         * additional addresses for this host.
                         */
                        conn->try_next_host = true;
                        goto keep_going;
                    }
                }
                else if (conn->target_server_type == SERVER_TYPE_PRIMARY ||
                         conn->target_server_type == SERVER_TYPE_STANDBY ||
                         conn->target_server_type == SERVER_TYPE_PREFER_STANDBY)
                {
                    /*
                     * If the server didn't report "in_hot_standby" at
                     * startup, we must determine its state by sending the
                     * query "SELECT pg_catalog.pg_is_in_recovery()".  Servers
                     * before 9.0 don't have that function, but by the same
                     * token they don't have any standby mode, so we may just
                     * assume the result.
                     */
                    if (conn->sversion < 90000)
                        conn->in_hot_standby = PG_BOOL_NO;
 
                    if (conn->in_hot_standby == PG_BOOL_UNKNOWN)
                    {
                        /*
                         * We use PQsendQueryContinue so that
                         * conn->errorMessage does not get cleared.  We need
                         * to preserve any error messages related to previous
                         * hosts we have tried and failed to connect to.
                         */
                        conn->status = CONNECTION_OK;
                        if (!PQsendQueryContinue(conn,
                                                 "SELECT pg_catalog.pg_is_in_recovery()"))
                            goto error_return;
                        /* We'll return to this state when we have the answer */
                        conn->status = CONNECTION_CHECK_STANDBY;
                        return PGRES_POLLING_READING;
                    }
 
                    /* OK, we can make the test */
                    if ((conn->target_server_type == SERVER_TYPE_PRIMARY) ?
                        (conn->in_hot_standby == PG_BOOL_YES) :
                        (conn->in_hot_standby == PG_BOOL_NO))
                    {
                        /* Wrong server state, reject and try the next host */
                        if (conn->target_server_type == SERVER_TYPE_PRIMARY)
                            libpq_append_conn_error(conn, "server is in hot standby mode");
                        else
                            libpq_append_conn_error(conn, "server is not in hot standby mode");
 
                        /* Close connection politely. */
                        conn->status = CONNECTION_OK;
                        sendTerminateConn(conn);
 
                        /*
                         * Try next host if any, but we don't want to consider
                         * additional addresses for this host.
                         */
                        conn->try_next_host = true;
                        goto keep_going;
                    }
                }
 
                /* Don't hold onto any OAuth tokens longer than necessary. */
                pqClearOAuthToken(conn);
 
                /*
                 * For non cancel requests we can release the address list
                 * now. For cancel requests we never actually resolve
                 * addresses and instead the addrinfo exists for the lifetime
                 * of the connection.
                 */
                if (!conn->cancelRequest)
                    release_conn_addrinfo(conn);
 
                /*
                 * Contents of conn->errorMessage are no longer interesting
                 * (and it seems some clients expect it to be empty after a
                 * successful connection).
                 */
                pqClearConnErrorState(conn);
 
                /* We are open for business! */
                conn->status = CONNECTION_OK;
                return PGRES_POLLING_OK;
            }
 
        case CONNECTION_CONSUME:
            {
                /*
                 * This state just makes sure the connection is idle after
                 * we've obtained the result of a SHOW or SELECT query.  Once
                 * we're clear, return to CONNECTION_CHECK_TARGET state to
                 * decide what to do next.  We must transiently set status =
                 * CONNECTION_OK in order to use the result-consuming
                 * subroutines.
                 */
                conn->status = CONNECTION_OK;
                if (!PQconsumeInput(conn))
                    goto error_return;
 
                if (PQisBusy(conn))
                {
                    conn->status = CONNECTION_CONSUME;
                    return PGRES_POLLING_READING;
                }
 
                /* Call PQgetResult() again until we get a NULL result */
                res = PQgetResult(conn);
                if (res != NULL)
                {
                    PQclear(res);
                    conn->status = CONNECTION_CONSUME;
                    return PGRES_POLLING_READING;
                }
 
                conn->status = CONNECTION_CHECK_TARGET;
                goto keep_going;
            }
 
        case CONNECTION_CHECK_WRITABLE:
            {
                /*
                 * Waiting for result of "SHOW transaction_read_only".  We
                 * must transiently set status = CONNECTION_OK in order to use
                 * the result-consuming subroutines.
                 */
                conn->status = CONNECTION_OK;
                if (!PQconsumeInput(conn))
                    goto error_return;
 
                if (PQisBusy(conn))
                {
                    conn->status = CONNECTION_CHECK_WRITABLE;
                    return PGRES_POLLING_READING;
                }
 
                res = PQgetResult(conn);
                if (res && PQresultStatus(res) == PGRES_TUPLES_OK &&
                    PQntuples(res) == 1)
                {
                    char       *val = PQgetvalue(res, 0, 0);
 
                    /*
                     * "transaction_read_only = on" proves that at least one
                     * of default_transaction_read_only and in_hot_standby is
                     * on, but we don't actually know which.  We don't care
                     * though for the purpose of identifying a read-only
                     * session, so satisfy the CONNECTION_CHECK_TARGET code by
                     * claiming they are both on.  On the other hand, if it's
                     * a read-write session, they are certainly both off.
                     */
                    if (strncmp(val, "on", 2) == 0)
                    {
                        conn->default_transaction_read_only = PG_BOOL_YES;
                        conn->in_hot_standby = PG_BOOL_YES;
                    }
                    else
                    {
                        conn->default_transaction_read_only = PG_BOOL_NO;
                        conn->in_hot_standby = PG_BOOL_NO;
                    }
                    PQclear(res);
 
                    /* Finish reading messages before continuing */
                    conn->status = CONNECTION_CONSUME;
                    goto keep_going;
                }
 
                /* Something went wrong with "SHOW transaction_read_only". */
                PQclear(res);
 
                /* Append error report to conn->errorMessage. */
                libpq_append_conn_error(conn, "\"%s\" failed",
                                        "SHOW transaction_read_only");
 
                /* Close connection politely. */
                conn->status = CONNECTION_OK;
                sendTerminateConn(conn);
 
                /* Try next host. */
                conn->try_next_host = true;
                goto keep_going;
            }
 
        case CONNECTION_CHECK_STANDBY:
            {
                /*
                 * Waiting for result of "SELECT pg_is_in_recovery()".  We
                 * must transiently set status = CONNECTION_OK in order to use
                 * the result-consuming subroutines.
                 */
                conn->status = CONNECTION_OK;
                if (!PQconsumeInput(conn))
                    goto error_return;
 
                if (PQisBusy(conn))
                {
                    conn->status = CONNECTION_CHECK_STANDBY;
                    return PGRES_POLLING_READING;
                }
 
                res = PQgetResult(conn);
                if (res && PQresultStatus(res) == PGRES_TUPLES_OK &&
                    PQntuples(res) == 1)
                {
                    char       *val = PQgetvalue(res, 0, 0);
 
                    if (strncmp(val, "t", 1) == 0)
                        conn->in_hot_standby = PG_BOOL_YES;
                    else
                        conn->in_hot_standby = PG_BOOL_NO;
                    PQclear(res);
 
                    /* Finish reading messages before continuing */
                    conn->status = CONNECTION_CONSUME;
                    goto keep_going;
                }
 
                /* Something went wrong with "SELECT pg_is_in_recovery()". */
                PQclear(res);
 
                /* Append error report to conn->errorMessage. */
                libpq_append_conn_error(conn, "\"%s\" failed",
                                        "SELECT pg_is_in_recovery()");
 
                /* Close connection politely. */
                conn->status = CONNECTION_OK;
                sendTerminateConn(conn);
 
                /* Try next host. */
                conn->try_next_host = true;
                goto keep_going;
            }
 
        default:
            libpq_append_conn_error(conn,
                                    "invalid connection state %d, probably indicative of memory corruption",
                                    conn->status);
            goto error_return;
    }
 
    /* Unreachable */
 
error_return:
 
    /*
     * We used to close the socket at this point, but that makes it awkward
     * for those above us if they wish to remove this socket from their own
     * records (an fd_set for example).  We'll just have this socket closed
     * when PQfinish is called (which is compulsory even after an error, since
     * the connection structure must be freed).
     */
    conn->status = CONNECTION_BAD;
    return PGRES_POLLING_FAILED;
}

References SockAddr::addr, AddrInfo::addr, pg_conn::addr, pg_conn::allowed_enc_methods, pg_conn::altsock, appendPQExpBufferChar(), pg_conn::appname, Assert(), pg_conn::async_auth, pg_conn::asyncStatus, AUTH_REQ_OK, pg_conn::auth_req_received, pg_conn::cancelRequest, CHT_HOST_ADDRESS, CHT_HOST_NAME, CHT_UNIX_SOCKET, pg_conn::cleanup_async_auth, conn, connect, connectFailureMessage(), CONNECTION_AUTH_OK, CONNECTION_AUTHENTICATING, CONNECTION_AWAITING_RESPONSE, CONNECTION_BAD, CONNECTION_CHECK_STANDBY, CONNECTION_CHECK_TARGET, CONNECTION_CHECK_WRITABLE, CONNECTION_CONSUME, CONNECTION_FAILED, CONNECTION_GSS_STARTUP, CONNECTION_MADE, CONNECTION_NEEDED, CONNECTION_OK, CONNECTION_SSL_STARTUP, CONNECTION_STARTED, connectNoDelay(), pg_conn::connhost, pg_conn::connip, pg_conn::current_enc_method, PQExpBufferData::data, pg_conn::default_transaction_read_only, EINPROGRESS, EINTR, emitHostIdentityInfo(), ENC_GSSAPI, ENC_SSL, ENCRYPTION_NEGOTIATION_FAILED, EnvironmentOptions, err(), ERRCODE_APPNAME_UNKNOWN, ERRCODE_CANNOT_CONNECT_NOW, pg_conn::errorMessage, EWOULDBLOCK, pg_conn::failed_enc_methods, AddrInfo::family, pg_conn::fbappname, free, gai_strerror(), getHostaddr(), getpeereid(), pg_conn::gssencmode, pg_conn_host::host, pg_conn_host::hostaddr, i, pg_conn::in_hot_standby, pg_conn::inCursor, pg_conn::inEnd, init_allowed_encryption_methods(), pg_conn::inStart, j, pg_conn::laddr, pg_conn::last_sqlstate, PQExpBufferData::len, libpq_append_conn_error(), libpq_gettext, LOAD_BALANCE_RANDOM, pg_conn::load_balance_type, MAX_ERRLEN, pg_conn::max_pversion, MAXPGPATH, MemSet, pg_conn::naddr, pg_conn::nconnhost, NEGOTIATE_GSS_CODE, NEGOTIATE_SSL_CODE, pg_conn::oauth_want_retry, pg_conn::Pfdebug, PG_BOOL_NO, PG_BOOL_UNKNOWN, PG_BOOL_YES, PG_DIAG_SQLSTATE, pg_fe_getusername(), pg_fe_sendauth(), pg_freeaddrinfo_all(), pg_getaddrinfo_all(), pg_GSS_have_cred_cache(), pg_hton32, pg_oauth_mech, pg_prng_uint64_range(), pg_set_noblock(), PG_STRERROR_R_BUFLEN, PGASYNC_BUSY, PGASYNC_IDLE, PGINVALID_SOCKET, pgpassfileWarning(), PGRES_FATAL_ERROR, PGRES_POLLING_FAILED, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PGRES_TUPLES_OK, pg_conn::pipelineStatus, pg_conn_host::port, portstr, PQ_PIPELINE_OFF, pqBuildStartupPacket3(), pqCheckInBufferSpace(), PQclear, pqClearAsyncResult(), pqClearConnErrorState, pqClearOAuthToken(), PQconsumeInput(), pqDropConnection(), pqDropServerData(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetNegotiateProtocolVersion3(), PQgetResult, pqGets_append(), PQgetvalue, PQisBusy(), PqMsg_AuthenticationRequest, PqMsg_ErrorResponse, PqMsg_NegotiateProtocolVersion, PQntuples, pqPacketSend(), pqParseDone(), pqParseIntParam(), pqReadData(), PQresultErrorField, PQresultStatus, pqsecure_open_client(), pqsecure_open_gss(), PQsendCancelRequest(), PQsendQueryContinue(), pqTraceOutputCharResponse(), PQTRANS_IDLE, pg_conn::prng_state, pg_conn::pversion, pg_conn::pversion_negotiated, pg_conn::raddr, release_conn_addrinfo(), pg_conn::requirepeer, pg_result::resultStatus, SockAddr::salen, pg_conn::sasl, pg_conn::send_appname, sendTerminateConn(), SERVER_TYPE_PREFER_STANDBY, SERVER_TYPE_PREFER_STANDBY_PASS2, SERVER_TYPE_PRIMARY, SERVER_TYPE_READ_ONLY, SERVER_TYPE_READ_WRITE, SERVER_TYPE_STANDBY, setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), setTCPUserTimeout(), pg_conn::sigpipe_flag, pg_conn::sigpipe_so, snprintf, pg_conn::sock, SOCK_ERRNO, SOCK_STRERROR, socket, pg_conn::ssl_in_use, pg_conn::sslnegotiation, pg_conn::status, STATUS_OK, store_conn_addrinfo(), strerror_r, pg_conn::sversion, pg_conn::target_server_type, pg_conn::try_next_addr, pg_conn::try_next_host, pg_conn_host::type, UNIXSOCK_PATH, UNIXSOCK_PATH_BUFLEN, useKeepalives(), val, pg_conn::whichaddr, pg_conn::whichhost, and pg_conn::xactStatus.

Referenced by libpqsrv_connect_internal(), main(), PQcancelPoll(), pqConnectDBComplete(), pqConnectDBStart(), PQresetPoll(), process_slot(), and wait_until_connected().

PQconnectStart()

PGconn * PQconnectStart

(

const char *

conninfo

)

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

{
    PGconn     *conn;
 
    /*
     * Allocate memory for the conn structure.  Note that we also expect this
     * to initialize conn->errorMessage to empty.  All subsequent steps during
     * connection initialization will only append to that buffer.
     */
    conn = pqMakeEmptyPGconn();
    if (conn == NULL)
        return NULL;
 
    /*
     * Parse the conninfo string
     */
    if (!connectOptions1(conn, conninfo))
        return conn;
 
    /*
     * Compute derived options
     */
    if (!pqConnectOptions2(conn))
        return conn;
 
    /*
     * Connect to the database
     */
    if (!pqConnectDBStart(conn))
    {
        /* Just in case we failed to set it in pqConnectDBStart */
        conn->status = CONNECTION_BAD;
    }
 
    return conn;
}

References conn, CONNECTION_BAD, connectOptions1(), pqConnectDBStart(), pqConnectOptions2(), pqMakeEmptyPGconn(), and pg_conn::status.

Referenced by libpqsrv_connect(), main(), PQconnectdb(), PQping(), and start_conn().

PQconnectStartParams()

PGconn * PQconnectStartParams	(	const char *const *	keywords,
		const char *const *	values,
		int	expand_dbname
	)

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

{
    PGconn     *conn;
    PQconninfoOption *connOptions;
 
    /*
     * Allocate memory for the conn structure.  Note that we also expect this
     * to initialize conn->errorMessage to empty.  All subsequent steps during
     * connection initialization will only append to that buffer.
     */
    conn = pqMakeEmptyPGconn();
    if (conn == NULL)
        return NULL;
 
    /*
     * Parse the conninfo arrays
     */
    connOptions = conninfo_array_parse(keywords, values,
                                       &conn->errorMessage,
                                       true, expand_dbname);
    if (connOptions == NULL)
    {
        conn->status = CONNECTION_BAD;
        /* errorMessage is already set */
        return conn;
    }
 
    /*
     * Move option values into conn structure
     */
    if (!fillPGconn(conn, connOptions))
    {
        PQconninfoFree(connOptions);
        return conn;
    }
 
    /*
     * Free the option info - all is in conn now
     */
    PQconninfoFree(connOptions);
 
    /*
     * Compute derived options
     */
    if (!pqConnectOptions2(conn))
        return conn;
 
    /*
     * Connect to the database
     */
    if (!pqConnectDBStart(conn))
    {
        /* Just in case we failed to set it in pqConnectDBStart */
        conn->status = CONNECTION_BAD;
    }
 
    return conn;
}

References conn, CONNECTION_BAD, conninfo_array_parse(), pg_conn::errorMessage, fillPGconn(), keywords, pqConnectDBStart(), pqConnectOptions2(), PQconninfoFree(), pqMakeEmptyPGconn(), pg_conn::status, and values.

Referenced by do_connect(), libpqsrv_connect_params(), PQconnectdbParams(), and PQpingParams().

PQconninfo()

PQconninfoOption * PQconninfo

(

PGconn *

conn

)

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

{
    PQExpBufferData errorBuf;
    PQconninfoOption *connOptions;
 
    if (conn == NULL)
        return NULL;
 
    /*
     * We don't actually report any errors here, but callees want a buffer,
     * and we prefer not to trash the conn's errorMessage.
     */
    initPQExpBuffer(&errorBuf);
    if (PQExpBufferDataBroken(errorBuf))
        return NULL;            /* out of memory already :-( */
 
    connOptions = conninfo_init(&errorBuf);
 
    if (connOptions != NULL)
    {
        const internalPQconninfoOption *option;
 
        for (option = PQconninfoOptions; option->keyword; option++)
        {
            char      **connmember;
 
            if (option->connofs < 0)
                continue;
 
            connmember = (char **) ((char *) conn + option->connofs);
 
            if (*connmember)
                conninfo_storeval(connOptions, option->keyword, *connmember,
                                  &errorBuf, true, false);
        }
    }
 
    termPQExpBuffer(&errorBuf);
 
    return connOptions;
}

References conn, conninfo_init(), conninfo_storeval(), initPQExpBuffer(), PQconninfoOptions, PQExpBufferDataBroken, and termPQExpBuffer().

Referenced by copy_connection(), do_connect(), GenerateRecoveryConfig(), get_conninfo_value(), libpqrcv_get_conninfo(), and test_protocol_version().

PQconninfoFree()

void PQconninfoFree

(

PQconninfoOption *

connOptions

)

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

{
    if (connOptions == NULL)
        return;
 
    for (PQconninfoOption *option = connOptions; option->keyword != NULL; option++)
        free(option->val);
    free(connOptions);
}

References free, and option::val.

Referenced by check_pghost_envvar(), ConnectDatabase(), connectOptions1(), conninfo_array_parse(), conninfo_parse(), conninfo_uri_parse(), copy_connection(), dblink_connstr_has_pw(), dblink_connstr_has_required_scram_options(), do_connect(), GenerateRecoveryConfig(), get_base_conninfo(), get_conninfo_value(), GetConnection(), GetDbnameFromConnectionOptions(), InitPgFdwOptions(), libpqrcv_check_conninfo(), libpqrcv_get_conninfo(), libpqrcv_get_dbname_from_conninfo(), PQconndefaults(), PQconnectStartParams(), and test_protocol_version().

PQconninfoParse()

PQconninfoOption * PQconninfoParse	(	const char *	conninfo,
		char **	errmsg
	)

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

{
    PQExpBufferData errorBuf;
    PQconninfoOption *connOptions;
 
    if (errmsg)
        *errmsg = NULL;         /* default */
    initPQExpBuffer(&errorBuf);
    if (PQExpBufferDataBroken(errorBuf))
        return NULL;            /* out of memory already :-( */
    connOptions = parse_connection_string(conninfo, &errorBuf, false);
    if (connOptions == NULL && errmsg)
        *errmsg = errorBuf.data;
    else
        termPQExpBuffer(&errorBuf);
    return connOptions;
}

References PQExpBufferData::data, errmsg(), initPQExpBuffer(), parse_connection_string(), PQExpBufferDataBroken, and termPQExpBuffer().

Referenced by ConnectDatabase(), dblink_connstr_has_pw(), dblink_connstr_has_required_scram_options(), do_connect(), get_base_conninfo(), GetConnection(), GetDbnameFromConnectionOptions(), libpqrcv_check_conninfo(), libpqrcv_get_dbname_from_conninfo(), and main().

PQconsumeInput()

int PQconsumeInput

(

PGconn *

conn

)

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

{
    if (!conn)
        return 0;
 
    /*
     * for non-blocking connections try to flush the send-queue, otherwise we
     * may never get a response for something that may not have already been
     * sent because it's in our write buffer!
     */
    if (pqIsnonblocking(conn))
    {
        if (pqFlush(conn) < 0)
            return 0;
    }
 
    /*
     * Load more data, if available. We do this no matter what state we are
     * in, since we are probably getting called because the application wants
     * to get rid of a read-select condition. Note that we will NOT block
     * waiting for more input.
     */
    if (pqReadData(conn) < 0)
        return 0;
 
    /* Parsing of the data waits till later. */
    return 1;
}

References conn, pqFlush(), pqIsnonblocking, and pqReadData().

Referenced by advanceConnectionState(), consume_query_cancel_impl(), CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), do_sql_command_end(), ecpg_process_output(), libpqrcv_receive(), libpqsrv_get_result(), main(), pgfdw_cancel_query_end(), pgfdw_exec_cleanup_query_end(), pgfdw_get_cleanup_result(), postgresForeignAsyncNotify(), PQconnectPoll(), PrintNotifications(), process_slot(), StreamLogicalLog(), test_nosync(), test_pipelined_insert(), test_uniqviol(), try_complete_step(), and wait_on_slots().

PQcopyResult()

PGresult * PQcopyResult	(	const PGresult *	src,
		int	flags
	)

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

{
    PGresult   *dest;
    int         i;
 
    if (!src)
        return NULL;
 
    dest = PQmakeEmptyPGresult(NULL, PGRES_TUPLES_OK);
    if (!dest)
        return NULL;
 
    /* Always copy these over.  Is cmdStatus really useful here? */
    dest->client_encoding = src->client_encoding;
    strcpy(dest->cmdStatus, src->cmdStatus);
 
    /* Wants attrs? */
    if (flags & (PG_COPYRES_ATTRS | PG_COPYRES_TUPLES))
    {
        if (!PQsetResultAttrs(dest, src->numAttributes, src->attDescs))
        {
            PQclear(dest);
            return NULL;
        }
    }
 
    /* Wants to copy tuples? */
    if (flags & PG_COPYRES_TUPLES)
    {
        int         tup,
                    field;
 
        for (tup = 0; tup < src->ntups; tup++)
        {
            for (field = 0; field < src->numAttributes; field++)
            {
                if (!PQsetvalue(dest, tup, field,
                                src->tuples[tup][field].value,
                                src->tuples[tup][field].len))
                {
                    PQclear(dest);
                    return NULL;
                }
            }
        }
    }
 
    /* Wants to copy notice hooks? */
    if (flags & PG_COPYRES_NOTICEHOOKS)
        dest->noticeHooks = src->noticeHooks;
 
    /* Wants to copy PGEvents? */
    if ((flags & PG_COPYRES_EVENTS) && src->nEvents > 0)
    {
        dest->events = dupEvents(src->events, src->nEvents,
                                 &dest->memorySize);
        if (!dest->events)
        {
            PQclear(dest);
            return NULL;
        }
        dest->nEvents = src->nEvents;
    }
 
    /* Okay, trigger PGEVT_RESULTCOPY event */
    for (i = 0; i < dest->nEvents; i++)
    {
        /* We don't fire events that had some previous failure */
        if (src->events[i].resultInitialized)
        {
            PGEventResultCopy evt;
 
            evt.src = src;
            evt.dest = dest;
            if (dest->events[i].proc(PGEVT_RESULTCOPY, &evt,
                                     dest->events[i].passThrough))
                dest->events[i].resultInitialized = true;
        }
    }
 
    return dest;
}

References pg_result::attDescs, pg_result::client_encoding, pg_result::cmdStatus, generate_unaccent_rules::dest, PGEventResultCopy::dest, dupEvents(), pg_result::events, i, pgresAttValue::len, pg_result::nEvents, pg_result::noticeHooks, pg_result::ntups, pg_result::numAttributes, PG_COPYRES_ATTRS, PG_COPYRES_EVENTS, PG_COPYRES_NOTICEHOOKS, PG_COPYRES_TUPLES, PGEVT_RESULTCOPY, PGRES_TUPLES_OK, PQclear(), PQmakeEmptyPGresult(), PQsetResultAttrs(), PQsetvalue(), PGEvent::resultInitialized, PGEventResultCopy::src, pg_result::tuples, and pgresAttValue::value.

Referenced by pqRowProcessor().

PQdb()

char * PQdb

(

const PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
    return conn->dbName;
}

References conn, and pg_conn::dbName.

Referenced by append_rel_pattern_filtered_cte(), cluster_one_database(), do_connect(), exec_command_conninfo(), find_matching_idle_slot(), get_prompt(), GetTableInfo(), main(), prohibit_crossdb_refs(), reindex_one_database(), run_command(), run_reindex_command(), run_vacuum_command(), slashUsage(), SyncVariables(), TableCommandResultHandler(), vacuum_one_database(), validateSQLNamePattern(), and WriteHead().

PQdefaultAuthDataHook()

int PQdefaultAuthDataHook	(	PGauthData	type,
		PGconn *	conn,
		void *	data
	)

Definition at line 1601 of file fe-auth.c.

{
    return 0;                   /* handle nothing */
}

Referenced by PQsetAuthDataHook().

PQdefaultSSLKeyPassHook_OpenSSL()

int PQdefaultSSLKeyPassHook_OpenSSL	(	char *	buf,
		int	size,
		PGconn *	conn
	)

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

{
    if (conn && conn->sslpassword)
    {
        if (strlen(conn->sslpassword) + 1 > size)
            fprintf(stderr, libpq_gettext("WARNING: sslpassword truncated\n"));
        strncpy(buf, conn->sslpassword, size);
        buf[size - 1] = '\0';
        return strlen(buf);
    }
    else
    {
        buf[0] = '\0';
        return 0;
    }
}

References buf, conn, fprintf, libpq_gettext, and pg_conn::sslpassword.

Referenced by PQssl_passwd_cb().

PQdescribePortal()

PGresult * PQdescribePortal	(	PGconn *	conn,
		const char *	portal
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendTypedCommand(conn, PqMsg_Describe, 'P', portal))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), PqMsg_Describe, and PQsendTypedCommand().

Referenced by test_prepared().

PQdescribePrepared()

PGresult * PQdescribePrepared	(	PGconn *	conn,
		const char *	stmt
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendTypedCommand(conn, PqMsg_Describe, 'S', stmt))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), PqMsg_Describe, PQsendTypedCommand(), and stmt.

Referenced by DescribeQuery(), ECPGdescribe(), and test_prepared().

PQdisplayTuples()

void PQdisplayTuples	(	const PGresult *	res,
		FILE *	fp,
		int	fillAlign,
		const char *	fieldSep,
		int	printHeader,
		int	quiet
	)

Definition at line 574 of file fe-print.c.

{
#define DEFAULT_FIELD_SEP " "
 
    int         i,
                j;
    int         nFields;
    int         nTuples;
    int        *fLength = NULL;
 
    if (fieldSep == NULL)
        fieldSep = DEFAULT_FIELD_SEP;
 
    /* Get some useful info about the results */
    nFields = PQnfields(res);
    nTuples = PQntuples(res);
 
    if (fp == NULL)
        fp = stdout;
 
    /* Figure the field lengths to align to */
    /* will be somewhat time consuming for very large results */
    if (fillAlign)
    {
        fLength = (int *) malloc(nFields * sizeof(int));
        if (!fLength)
        {
            fprintf(stderr, libpq_gettext("out of memory\n"));
            return;
        }
 
        for (j = 0; j < nFields; j++)
        {
            fLength[j] = strlen(PQfname(res, j));
            for (i = 0; i < nTuples; i++)
            {
                int         flen = PQgetlength(res, i, j);
 
                if (flen > fLength[j])
                    fLength[j] = flen;
            }
        }
    }
 
    if (printHeader)
    {
        /* first, print out the attribute names */
        for (i = 0; i < nFields; i++)
        {
            fputs(PQfname(res, i), fp);
            if (fillAlign)
                fill(strlen(PQfname(res, i)), fLength[i], ' ', fp);
            fputs(fieldSep, fp);
        }
        fprintf(fp, "\n");
 
        /* Underline the attribute names */
        for (i = 0; i < nFields; i++)
        {
            if (fillAlign)
                fill(0, fLength[i], '-', fp);
            fputs(fieldSep, fp);
        }
        fprintf(fp, "\n");
    }
 
    /* next, print out the instances */
    for (i = 0; i < nTuples; i++)
    {
        for (j = 0; j < nFields; j++)
        {
            fprintf(fp, "%s", PQgetvalue(res, i, j));
            if (fillAlign)
                fill(strlen(PQgetvalue(res, i, j)), fLength[j], ' ', fp);
            fputs(fieldSep, fp);
        }
        fprintf(fp, "\n");
    }
 
    if (!quiet)
        fprintf(fp, "\nQuery returned %d row%s.\n", PQntuples(res),
                (PQntuples(res) == 1) ? "" : "s");
 
    fflush(fp);
 
    free(fLength);
}

References DEFAULT_FIELD_SEP, fill(), fprintf, free, i, j, libpq_gettext, malloc, PQfname, PQgetlength, PQgetvalue, PQnfields, PQntuples, and generate_unaccent_rules::stdout.

PQdsplen()

int PQdsplen	(	const char *	s,
		int	encoding
	)

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

{
    return pg_encoding_dsplen(encoding, s);
}

References encoding, and pg_encoding_dsplen().

Referenced by get_prompt(), pg_wcsformat(), pg_wcssize(), pg_wcswidth(), and strlen_max_width().

PQencryptPassword()

char * PQencryptPassword	(	const char *	passwd,
		const char *	user
	)

Definition at line 1363 of file fe-auth.c.

{
    char       *crypt_pwd;
    const char *errstr = NULL;
 
    crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
    if (!crypt_pwd)
        return NULL;
 
    if (!pg_md5_encrypt(passwd, (uint8 *) user, strlen(user), crypt_pwd, &errstr))
    {
        free(crypt_pwd);
        return NULL;
    }
 
    return crypt_pwd;
}

References free, malloc, MD5_PASSWD_LEN, pg_md5_encrypt(), and user.

PQencryptPasswordConn()

char * PQencryptPasswordConn	(	PGconn *	conn,
		const char *	passwd,
		const char *	user,
		const char *	algorithm
	)

Definition at line 1406 of file fe-auth.c.

{
#define MAX_ALGORITHM_NAME_LEN 50
    char        algobuf[MAX_ALGORITHM_NAME_LEN + 1];
    char       *crypt_pwd = NULL;
 
    if (!conn)
        return NULL;
 
    pqClearConnErrorState(conn);
 
    /* If no algorithm was given, ask the server. */
    if (algorithm == NULL)
    {
        PGresult   *res;
        char       *val;
 
        res = PQexec(conn, "show password_encryption");
        if (res == NULL)
        {
            /* PQexec() should've set conn->errorMessage already */
            return NULL;
        }
        if (PQresultStatus(res) != PGRES_TUPLES_OK)
        {
            /* PQexec() should've set conn->errorMessage already */
            PQclear(res);
            return NULL;
        }
        if (PQntuples(res) != 1 || PQnfields(res) != 1)
        {
            PQclear(res);
            libpq_append_conn_error(conn, "unexpected shape of result set returned for SHOW");
            return NULL;
        }
        val = PQgetvalue(res, 0, 0);
 
        if (strlen(val) > MAX_ALGORITHM_NAME_LEN)
        {
            PQclear(res);
            libpq_append_conn_error(conn, "\"password_encryption\" value too long");
            return NULL;
        }
        strcpy(algobuf, val);
        PQclear(res);
 
        algorithm = algobuf;
    }
 
    /*
     * Also accept "on" and "off" as aliases for "md5", because
     * password_encryption was a boolean before PostgreSQL 10.  We refuse to
     * send the password in plaintext even if it was "off".
     */
    if (strcmp(algorithm, "on") == 0 ||
        strcmp(algorithm, "off") == 0)
        algorithm = "md5";
 
    /*
     * Ok, now we know what algorithm to use
     */
    if (strcmp(algorithm, "scram-sha-256") == 0)
    {
        const char *errstr = NULL;
 
        crypt_pwd = pg_fe_scram_build_secret(passwd,
                                             conn->scram_sha_256_iterations,
                                             &errstr);
        if (!crypt_pwd)
            libpq_append_conn_error(conn, "could not encrypt password: %s", errstr);
    }
    else if (strcmp(algorithm, "md5") == 0)
    {
        crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
        if (crypt_pwd)
        {
            const char *errstr = NULL;
 
            if (!pg_md5_encrypt(passwd, (uint8 *) user, strlen(user), crypt_pwd, &errstr))
            {
                libpq_append_conn_error(conn, "could not encrypt password: %s", errstr);
                free(crypt_pwd);
                crypt_pwd = NULL;
            }
        }
        else
            libpq_append_conn_error(conn, "out of memory");
    }
    else
    {
        libpq_append_conn_error(conn, "unrecognized password encryption algorithm \"%s\"",
                                algorithm);
        return NULL;
    }
 
    return crypt_pwd;
}

References conn, free, libpq_append_conn_error(), malloc, MAX_ALGORITHM_NAME_LEN, MD5_PASSWD_LEN, pg_fe_scram_build_secret(), pg_md5_encrypt(), PGRES_TUPLES_OK, PQclear, pqClearConnErrorState, PQexec(), PQgetvalue, PQnfields, PQntuples, PQresultStatus, pg_conn::scram_sha_256_iterations, user, and val.

Referenced by main(), and PQchangePassword().

PQendcopy()

int PQendcopy

(

PGconn *

conn

)

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

{
    if (!conn)
        return 0;
 
    return pqEndcopy3(conn);
}

References conn, and pqEndcopy3().

Referenced by ecpg_check_PQresult(), initPopulateTable(), and libpqrcv_endstreaming().

PQenterPipelineMode()

int PQenterPipelineMode

(

PGconn *

conn

)

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

{
    if (!conn)
        return 0;
 
    /* succeed with no action if already in pipeline mode */
    if (conn->pipelineStatus != PQ_PIPELINE_OFF)
        return 1;
 
    if (conn->asyncStatus != PGASYNC_IDLE)
    {
        libpq_append_conn_error(conn, "cannot enter pipeline mode, connection not idle");
        return 0;
    }
 
    conn->pipelineStatus = PQ_PIPELINE_ON;
 
    return 1;
}

References pg_conn::asyncStatus, conn, libpq_append_conn_error(), PGASYNC_IDLE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, and PQ_PIPELINE_ON.

Referenced by ExecQueryAndProcessResults(), executeMetaCommand(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), and test_uniqviol().

PQenv2encoding()

int PQenv2encoding

(

void

)

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

{
    char       *str;
    int         encoding = PG_SQL_ASCII;
 
    str = getenv("PGCLIENTENCODING");
    if (str && *str != '\0')
    {
        encoding = pg_char_to_encoding(str);
        if (encoding < 0)
            encoding = PG_SQL_ASCII;
    }
    return encoding;
}

References encoding, pg_char_to_encoding, PG_SQL_ASCII, and str.

Referenced by main().

PQerrorMessage()

char * PQerrorMessage

(

const PGconn *

conn

)

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

{
    if (!conn)
        return libpq_gettext("connection pointer is NULL\n");
 
    /*
     * The errorMessage buffer might be marked "broken" due to having
     * previously failed to allocate enough memory for the message.  In that
     * case, tell the application we ran out of memory.
     */
    if (PQExpBufferBroken(&conn->errorMessage))
        return libpq_gettext("out of memory\n");
 
    return conn->errorMessage.data;
}

References conn, PQExpBufferData::data, pg_conn::errorMessage, libpq_gettext, and PQExpBufferBroken.

Referenced by _doSetSessionAuth(), _printTableAccessMethodNoStorage(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), AcceptResult(), advanceConnectionState(), BaseBackup(), check_loadable_libraries(), check_prepare_conn(), CheckCopyStreamStop(), cluster_one_database(), compile_database_list(), compile_relation_list_one_db(), confirm_result_status_impl(), connect_database(), connect_pg_server(), ConnectDatabase(), connectDatabase(), connectToServer(), consume_null_result_impl(), consume_query_cancel_impl(), copy_connection(), CopyStreamPoll(), CopyStreamReceive(), CreateReplicationSlot(), dblink_connect(), dblink_error_message(), dblink_get_conn(), dblink_res_error(), dblink_res_internalerror(), dblink_send_query(), DescribeQuery(), die_on_query_failure(), do_connect(), do_lo_export(), do_lo_import(), do_lo_unlink(), doConnect(), DropReplicationSlot(), dump_lo_buf(), dumpLOs(), dumpTableData_copy(), ecpg_check_PQresult(), ecpg_raise_backend(), ECPGconnect(), EndDBCopyMode(), escape_identifier(), escape_literal(), escape_string_conn(), exec_command_password(), ExecQueryAndProcessResults(), executeCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlCommandBuf(), executeStatement(), get_table_relkind(), GetConnection(), GetSlotInformation(), GetTableInfo(), handleCopyIn(), handleCopyOut(), HandleEndOfCopyStream(), initPopulateTable(), libpqrcv_alter_slot(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_send(), libpqrcv_startstreaming(), main(), my_truncate(), overwrite(), pgfdw_cancel_query_end(), pgfdw_report_internal(), pickout(), PQcancelErrorMessage(), prepareCommand(), process_query_result(), process_queued_fetch_requests(), process_result(), process_slot(), ProcessWALDataMsg(), psql_get_variable(), readCommandResponse(), ReceiveCopyData(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_command(), run_permutation(), run_reindex_command(), run_vacuum_command(), RunIdentifySystem(), send_cancellable_query_impl(), sendFeedback(), SendQuery(), sql_conn(), sql_exec(), start_postmaster(), StartRestoreLO(), storeQueryResult(), StreamLogicalLog(), TableCommandResultHandler(), test_cancel(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_nosync(), test_one_vector(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_protocol_version(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), test_uniqviol(), threadRun(), try_complete_step(), tryExecuteStatement(), vacuumlo(), verify_btree_slot_handler(), verify_heap_slot_handler(), and wait_for_connection_state().

PQescapeBytea()

unsigned char * PQescapeBytea	(	const unsigned char *	from,
		size_t	from_length,
		size_t *	to_length
	)

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

{
    return PQescapeByteaInternal(NULL, from, from_length, to_length,
                                 static_std_strings,
                                 false /* can't use hex */ );
}

References PQescapeByteaInternal(), and static_std_strings.

PQescapeByteaConn()

unsigned char * PQescapeByteaConn	(	PGconn *	conn,
		const unsigned char *	from,
		size_t	from_length,
		size_t *	to_length
	)

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

{
    if (!conn)
        return NULL;
 
    if (conn->cmd_queue_head == NULL)
        pqClearConnErrorState(conn);
 
    return PQescapeByteaInternal(conn, from, from_length, to_length,
                                 conn->std_strings,
                                 (conn->sversion >= 90000));
}

References pg_conn::cmd_queue_head, conn, pqClearConnErrorState, PQescapeByteaInternal(), pg_conn::std_strings, and pg_conn::sversion.

PQescapeIdentifier()

char * PQescapeIdentifier	(	PGconn *	conn,
		const char *	str,
		size_t	len
	)

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

{
    return PQescapeInternal(conn, str, len, true);
}

References conn, len, PQescapeInternal(), and str.

Referenced by create_publication(), create_subscription(), drop_publication(), enable_subscription(), escape_identifier(), initCreatePKeys(), initCreateTables(), main(), PQchangePassword(), psql_get_variable(), stringlist_to_identifierstr(), and vacuumlo().

PQescapeLiteral()

char * PQescapeLiteral	(	PGconn *	conn,
		const char *	str,
		size_t	len
	)

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

{
    return PQescapeInternal(conn, str, len, false);
}

References conn, len, PQescapeInternal(), and str.

Referenced by check_and_drop_existing_subscriptions(), create_logical_replication_slot(), create_publication(), create_subscription(), DescribeQuery(), drop_replication_slot(), escape_literal(), libpqrcv_startstreaming(), PQchangePassword(), psql_get_variable(), set_locale_and_encoding(), set_replication_progress(), and test_gb18030_page_multiple().

PQescapeString()

size_t PQescapeString	(	char *	to,
		const char *	from,
		size_t	length
	)

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

{
    return PQescapeStringInternal(NULL, to, from, length, NULL,
                                  static_client_encoding,
                                  static_std_strings);
}

References PQescapeStringInternal(), static_client_encoding, and static_std_strings.

Referenced by escape_string(), get_comma_elts(), and quote_postgres().

PQescapeStringConn()

size_t PQescapeStringConn	(	PGconn *	conn,
		char *	to,
		const char *	from,
		size_t	length,
		int *	error
	)

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

{
    if (!conn)
    {
        /* force empty-string result */
        *to = '\0';
        if (error)
            *error = 1;
        return 0;
    }
 
    if (conn->cmd_queue_head == NULL)
        pqClearConnErrorState(conn);
 
    return PQescapeStringInternal(conn, to, from, length, error,
                                  conn->client_encoding,
                                  conn->std_strings);
}

References pg_conn::client_encoding, pg_conn::cmd_queue_head, conn, error(), pqClearConnErrorState, PQescapeStringInternal(), and pg_conn::std_strings.

Referenced by AppendStringCommandOption(), appendStringLiteralConn(), check_loadable_libraries(), do_lo_import(), and escape_string_conn().

PQexec()

PGresult * PQexec	(	PGconn *	conn,
		const char *	query
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendQuery(conn, query))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), and PQsendQuery().

Referenced by _doSetSessionAuth(), _printTableAccessMethodNoStorage(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), check_and_drop_existing_subscriptions(), check_and_drop_publications(), check_loadable_libraries(), check_prepare_conn(), check_publisher(), check_subscriber(), connect_database(), create_logical_replication_slot(), create_publication(), create_subscription(), CreateReplicationSlot(), deallocate_one(), DescribeQuery(), drop_existing_subscriptions(), drop_failover_replication_slots(), drop_publication(), drop_replication_slot(), DropReplicationSlot(), ecpg_autostart_transaction(), ecpg_execute(), ecpg_is_type_an_array(), ECPGsetcommit(), ECPGtrans(), enable_subscription(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), generate_object_name(), get_create_object_cmd(), get_primary_sysid(), get_publisher_databases(), GetConnection(), GetSlotInformation(), GetTableInfo(), init_libpq_conn(), initPopulateTable(), libpq_traverse_files(), lo_initialize(), lockTableForWorker(), lookup_object_oid(), main(), PQchangePassword(), PQencryptPasswordConn(), PQsetClientEncoding(), PSQLexec(), ReceiveXlogStream(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), SendQuery(), server_is_in_recovery(), set_replication_progress(), setup_publisher(), sql_conn(), sql_exec(), StreamLogicalLog(), test_disallowed_in_pipeline(), test_pipeline_abort(), test_prepared(), test_transaction(), test_uniqviol(), tryExecuteStatement(), and vacuumlo().

PQexecParams()

PGresult * PQexecParams	(	PGconn *	conn,
		const char *	command,
		int	nParams,
		const Oid *	paramTypes,
		const char *const *	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendQueryParams(conn, command,
                           nParams, paramTypes, paramValues, paramLengths,
                           paramFormats, resultFormat))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), and PQsendQueryParams().

Referenced by ecpg_execute(), get_table_relkind(), libpq_fetch_file(), main(), and wait_for_connection_state().

PQexecPrepared()

PGresult * PQexecPrepared	(	PGconn *	conn,
		const char *	stmtName,
		int	nParams,
		const char *const *	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendQueryPrepared(conn, stmtName,
                             nParams, paramValues, paramLengths,
                             paramFormats, resultFormat))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), and PQsendQueryPrepared().

Referenced by ecpg_execute(), and try_complete_step().

PQexitPipelineMode()

int PQexitPipelineMode

(

PGconn *

conn

)

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

{
    if (!conn)
        return 0;
 
    if (conn->pipelineStatus == PQ_PIPELINE_OFF &&
        (conn->asyncStatus == PGASYNC_IDLE ||
         conn->asyncStatus == PGASYNC_PIPELINE_IDLE) &&
        conn->cmd_queue_head == NULL)
        return 1;
 
    switch (conn->asyncStatus)
    {
        case PGASYNC_READY:
        case PGASYNC_READY_MORE:
            /* there are some uncollected results */
            libpq_append_conn_error(conn, "cannot exit pipeline mode with uncollected results");
            return 0;
 
        case PGASYNC_BUSY:
            libpq_append_conn_error(conn, "cannot exit pipeline mode while busy");
            return 0;
 
        case PGASYNC_IDLE:
        case PGASYNC_PIPELINE_IDLE:
            /* OK */
            break;
 
        case PGASYNC_COPY_IN:
        case PGASYNC_COPY_OUT:
        case PGASYNC_COPY_BOTH:
            libpq_append_conn_error(conn, "cannot exit pipeline mode while in COPY");
    }
 
    /* still work to process */
    if (conn->cmd_queue_head != NULL)
    {
        libpq_append_conn_error(conn, "cannot exit pipeline mode with uncollected results");
        return 0;
    }
 
    conn->pipelineStatus = PQ_PIPELINE_OFF;
    conn->asyncStatus = PGASYNC_IDLE;
 
    /* Flush any pending data in out buffer */
    if (pqFlush(conn) < 0)
        return 0;               /* error message is setup already */
    return 1;
}

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, libpq_append_conn_error(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, PGASYNC_READY, PGASYNC_READY_MORE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, and pqFlush().

Referenced by discardUntilSync(), ExecQueryAndProcessResults(), readCommandResponse(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), and test_transaction().

PQfformat()

int PQfformat	(	const PGresult *	res,
		int	field_num
	)

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

{
    if (!check_field_number(res, field_num))
        return 0;
    if (res->attDescs)
        return res->attDescs[field_num].format;
    else
        return 0;
}

References pg_result::attDescs, check_field_number(), and pgresAttDesc::format.

Referenced by ecpg_get_data(), ecpg_store_result(), and process_queued_fetch_requests().

PQfinish()

void PQfinish

(

PGconn *

conn

)

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

{
    if (conn)
    {
        pqClosePGconn(conn);
        freePGconn(conn);
    }
}

References conn, freePGconn(), and pqClosePGconn().

Referenced by appendQualifiedRelation(), BaseBackup(), check_for_connection_status(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_is_install_user(), check_loadable_libraries(), check_new_cluster_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), CheckConnection(), cluster_all_databases(), cluster_one_database(), connect_database(), ConnectDatabase(), connectDatabase(), connectToServer(), create_conflict_detection_slot(), create_logical_replication_slots(), create_new_objects(), disconnect_atexit(), disconnect_database(), DisconnectDatabase(), disconnectDatabase(), do_connect(), doConnect(), dumpRoleGUCPrivs(), dumpRoleMembership(), dumpTablespaces(), ecpg_finish(), executeCommand(), executeQuery(), executeQueryOrDie(), exit_nicely(), expand_dbname_patterns(), finishCon(), get_db_infos(), get_subscription_info(), get_tablespace_paths(), get_template0_info(), GetConnection(), libpqsrv_connect_internal(), libpqsrv_disconnect(), LogStreamerMain(), main(), old_9_6_invalidate_hash_indexes(), PQcancelFinish(), PQping(), PQpingParams(), process_slot(), ReconnectToServer(), reindex_all_databases(), reindex_one_database(), runInitSteps(), set_frozenxids(), set_locale_and_encoding(), sql_conn(), sql_exec(), start_postmaster(), StreamLog(), StreamLogicalLog(), test_cancel(), test_protocol_version(), unicode_version_changed(), vacuum_all_databases(), vacuum_one_database(), and vacuumlo().

PQflush()

int PQflush

(

PGconn *

conn

)

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

{
    if (!conn || conn->status == CONNECTION_BAD)
        return -1;
    return pqFlush(conn);
}

References conn, CONNECTION_BAD, pqFlush(), and pg_conn::status.

Referenced by CheckCopyStreamStop(), ExecQueryAndProcessResults(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), libpqrcv_send(), prepareToTerminate(), ProcessWALDataMsg(), sendFeedback(), test_nosync(), test_pipelined_insert(), and test_uniqviol().

PQfmod()

int PQfmod	(	const PGresult *	res,
		int	field_num
	)

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

{
    if (!check_field_number(res, field_num))
        return 0;
    if (res->attDescs)
        return res->attDescs[field_num].atttypmod;
    else
        return 0;
}

References pg_result::attDescs, pgresAttDesc::atttypmod, and check_field_number().

Referenced by DescribeQuery(), and ECPGget_desc().

PQfn()

PGresult * PQfn	(	PGconn *	conn,
		int	fnid,
		int *	result_buf,
		int *	result_len,
		int	result_is_int,
		const PQArgBlock *	args,
		int	nargs
	)

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

{
    *result_len = 0;
 
    if (!conn)
        return NULL;
 
    /*
     * Since this is the beginning of a query cycle, reset the error state.
     * However, in pipeline mode with something already queued, the error
     * buffer belongs to that command and we shouldn't clear it.
     */
    if (conn->cmd_queue_head == NULL)
        pqClearConnErrorState(conn);
 
    if (conn->pipelineStatus != PQ_PIPELINE_OFF)
    {
        libpq_append_conn_error(conn, "%s not allowed in pipeline mode", "PQfn");
        return NULL;
    }
 
    if (conn->sock == PGINVALID_SOCKET || conn->asyncStatus != PGASYNC_IDLE ||
        pgHavePendingResult(conn))
    {
        libpq_append_conn_error(conn, "connection in wrong state");
        return NULL;
    }
 
    return pqFunctionCall3(conn, fnid,
                           result_buf, result_len,
                           result_is_int,
                           args, nargs);
}

References generate_unaccent_rules::args, pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, libpq_append_conn_error(), PGASYNC_IDLE, pgHavePendingResult, PGINVALID_SOCKET, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqClearConnErrorState, pqFunctionCall3(), and pg_conn::sock.

Referenced by lo_close(), lo_creat(), lo_create(), lo_lseek(), lo_lseek64(), lo_open(), lo_read(), lo_tell(), lo_tell64(), lo_truncate(), lo_truncate64(), lo_unlink(), and lo_write().

PQfname()

char * PQfname	(	const PGresult *	res,
		int	field_num
	)

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

{
    if (!check_field_number(res, field_num))
        return NULL;
    if (res->attDescs)
        return res->attDescs[field_num].name;
    else
        return NULL;
}

References pg_result::attDescs, check_field_number(), and pgresAttDesc::name.

PQfnumber()

int PQfnumber	(	const PGresult *	res,
		const char *	field_name
	)

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

{
    char       *field_case;
    bool        in_quotes;
    bool        all_lower = true;
    const char *iptr;
    char       *optr;
    int         i;
 
    if (!res)
        return -1;
 
    /*
     * Note: it is correct to reject a zero-length input string; the proper
     * input to match a zero-length field name would be "".
     */
    if (field_name == NULL ||
        field_name[0] == '\0' ||
        res->attDescs == NULL)
        return -1;
 
    /*
     * Check if we can avoid the strdup() and related work because the
     * passed-in string wouldn't be changed before we do the check anyway.
     */
    for (iptr = field_name; *iptr; iptr++)
    {
        char        c = *iptr;
 
        if (c == '"' || c != pg_tolower((unsigned char) c))
        {
            all_lower = false;
            break;
        }
    }
 
    if (all_lower)
        for (i = 0; i < res->numAttributes; i++)
            if (strcmp(field_name, res->attDescs[i].name) == 0)
                return i;
 
    /* Fall through to the normal check if that didn't work out. */
 
    /*
     * Note: this code will not reject partially quoted strings, eg
     * foo"BAR"foo will become fooBARfoo when it probably ought to be an error
     * condition.
     */
    field_case = strdup(field_name);
    if (field_case == NULL)
        return -1;              /* grotty */
 
    in_quotes = false;
    optr = field_case;
    for (iptr = field_case; *iptr; iptr++)
    {
        char        c = *iptr;
 
        if (in_quotes)
        {
            if (c == '"')
            {
                if (iptr[1] == '"')
                {
                    /* doubled quotes become a single quote */
                    *optr++ = '"';
                    iptr++;
                }
                else
                    in_quotes = false;
            }
            else
                *optr++ = c;
        }
        else if (c == '"')
            in_quotes = true;
        else
        {
            c = pg_tolower((unsigned char) c);
            *optr++ = c;
        }
    }
    *optr = '\0';
 
    for (i = 0; i < res->numAttributes; i++)
    {
        if (strcmp(field_case, res->attDescs[i].name) == 0)
        {
            free(field_case);
            return i;
        }
    }
    free(field_case);
    return -1;
}

References pg_result::attDescs, free, i, pgresAttDesc::name, pg_result::numAttributes, and pg_tolower().

Referenced by append_depends_on_extension(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), check_for_connection_status(), check_for_pg_role_prefix(), check_new_cluster_replication_slots(), collectComments(), collectSecLabels(), describeOneTableDetails(), dropRoles(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpFunc(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRelationStats_dumper(), dumpRoleMembership(), dumpRoles(), dumpTableSchema(), dumpTSConfig(), dumpUserMappings(), get_db_infos(), get_subscription_info(), get_tablespace_paths(), get_template0_info(), getAccessMethods(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRules(), getSubscriptions(), getSubscriptionTables(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), old_9_6_invalidate_hash_indexes(), process_data_type_check(), process_extension_updates(), process_incompat_polymorphics(), process_inconsistent_notnull(), process_isn_and_int8_passing_mismatch(), process_old_cluster_logical_slot_infos(), process_old_sub_state_check(), process_rel_infos(), process_unicode_update(), process_user_defined_encoding_conversions(), process_user_defined_postfix_ops(), process_with_oids_check(), processExtensionTables(), set_frozenxids(), and show_binary_results().

PQfreeCancel()

void PQfreeCancel

(

PGcancel *

cancel

)

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

{
    free(cancel);
}

References free.

Referenced by PQrequestCancel(), ResetCancelConn(), set_archive_cancel_info(), SetCancelConn(), and test_cancel().

PQfreemem()

void PQfreemem

(

void *

ptr

)

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

{
    free(ptr);
}

References free.

Referenced by check_and_drop_existing_subscriptions(), create_logical_replication_slot(), create_publication(), create_subscription(), dblink_get_notify(), DescribeQuery(), do_connect(), drop_publication(), drop_replication_slot(), dumpTableData_copy(), ecpg_process_output(), enable_subscription(), escape_identifier(), escape_literal(), exec_command_errverbose(), get_base_conninfo(), handleCopyOut(), HandleCopyStream(), initCreatePKeys(), initCreateTables(), libpqrcv_check_conninfo(), libpqrcv_disconnect(), libpqrcv_get_dbname_from_conninfo(), libpqrcv_receive(), libpqrcv_startstreaming(), main(), PQchangePassword(), PQfreeNotify(), PrintNotifications(), psql_get_variable(), ReceiveCopyData(), set_locale_and_encoding(), set_replication_progress(), StreamLogicalLog(), stringlist_to_identifierstr(), try_complete_step(), and vacuumlo().

PQfsize()

int PQfsize	(	const PGresult *	res,
		int	field_num
	)

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

{
    if (!check_field_number(res, field_num))
        return 0;
    if (res->attDescs)
        return res->attDescs[field_num].typlen;
    else
        return 0;
}

References pg_result::attDescs, check_field_number(), and pgresAttDesc::typlen.

Referenced by ecpg_build_compat_sqlda(), and ECPGget_desc().

PQftable()

Oid PQftable	(	const PGresult *	res,
		int	field_num
	)

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

{
    if (!check_field_number(res, field_num))
        return InvalidOid;
    if (res->attDescs)
        return res->attDescs[field_num].tableid;
    else
        return InvalidOid;
}

References pg_result::attDescs, check_field_number(), InvalidOid, and pgresAttDesc::tableid.

PQftablecol()

int PQftablecol	(	const PGresult *	res,
		int	field_num
	)

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

{
    if (!check_field_number(res, field_num))
        return 0;
    if (res->attDescs)
        return res->attDescs[field_num].columnid;
    else
        return 0;
}

References pg_result::attDescs, check_field_number(), and pgresAttDesc::columnid.

PQftype()

Oid PQftype	(	const PGresult *	res,
		int	field_num
	)

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

{
    if (!check_field_number(res, field_num))
        return InvalidOid;
    if (res->attDescs)
        return res->attDescs[field_num].typid;
    else
        return InvalidOid;
}

References pg_result::attDescs, check_field_number(), InvalidOid, and pgresAttDesc::typid.

Referenced by DescribeQuery(), dumpTableData_insert(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_store_result(), ECPGget_desc(), printCrosstab(), printQuery(), process_queued_fetch_requests(), sqlda_common_total_size(), and test_prepared().

PQfullProtocolVersion()

int PQfullProtocolVersion

(

const PGconn *

conn

)

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

{
    if (!conn)
        return 0;
    if (conn->status == CONNECTION_BAD)
        return 0;
    return PG_PROTOCOL_FULL(conn->pversion);
}

References conn, CONNECTION_BAD, PG_PROTOCOL_FULL, pg_conn::pversion, and pg_conn::status.

Referenced by exec_command_conninfo(), and test_protocol_version().

PQgetAuthDataHook()

PQauthDataHook_type PQgetAuthDataHook

(

void

)

Definition at line 1589 of file fe-auth.c.

{
    return PQauthDataHook;
}

References PQauthDataHook.

Referenced by prompt_user().

PQgetCancel()

PGcancel * PQgetCancel

(

PGconn *

conn

)

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

{
    PGcancel   *cancel;
    int         cancel_req_len;
    CancelRequestPacket *req;
 
    if (!conn)
        return NULL;
 
    if (conn->sock == PGINVALID_SOCKET)
        return NULL;
 
    /* Check that we have received a cancellation key */
    if (conn->be_cancel_key_len == 0)
    {
        /*
         * In case there is no cancel key, return an all-zero PGcancel object.
         * Actually calling PQcancel on this will fail, but we allow creating
         * the PGcancel object anyway. Arguably it would be better return NULL
         * to indicate that cancellation is not possible, but there'd be no
         * way for the caller to distinguish "out of memory" from "server did
         * not send a cancel key". Also, this is how PGgetCancel() has always
         * behaved, and if we changed it, some clients would stop working
         * altogether with servers that don't support cancellation. (The
         * modern PQcancelCreate() function returns a failed connection object
         * instead.)
         *
         * The returned dummy object has cancel_pkt_len == 0; we check for
         * that in PQcancel() to identify it as a dummy.
         */
        return calloc(1, sizeof(PGcancel));
    }
 
    cancel_req_len = offsetof(CancelRequestPacket, cancelAuthCode) + conn->be_cancel_key_len;
    cancel = malloc(offsetof(PGcancel, cancel_req) + cancel_req_len);
    if (cancel == NULL)
        return NULL;
 
    memcpy(&cancel->raddr, &conn->raddr, sizeof(SockAddr));
 
    /* We use -1 to indicate an unset connection option */
    cancel->pgtcp_user_timeout = -1;
    cancel->keepalives = -1;
    cancel->keepalives_idle = -1;
    cancel->keepalives_interval = -1;
    cancel->keepalives_count = -1;
    if (conn->pgtcp_user_timeout != NULL)
    {
        if (!pqParseIntParam(conn->pgtcp_user_timeout,
                             &cancel->pgtcp_user_timeout,
                             conn, "tcp_user_timeout"))
            goto fail;
    }
    if (conn->keepalives != NULL)
    {
        if (!pqParseIntParam(conn->keepalives,
                             &cancel->keepalives,
                             conn, "keepalives"))
            goto fail;
    }
    if (conn->keepalives_idle != NULL)
    {
        if (!pqParseIntParam(conn->keepalives_idle,
                             &cancel->keepalives_idle,
                             conn, "keepalives_idle"))
            goto fail;
    }
    if (conn->keepalives_interval != NULL)
    {
        if (!pqParseIntParam(conn->keepalives_interval,
                             &cancel->keepalives_interval,
                             conn, "keepalives_interval"))
            goto fail;
    }
    if (conn->keepalives_count != NULL)
    {
        if (!pqParseIntParam(conn->keepalives_count,
                             &cancel->keepalives_count,
                             conn, "keepalives_count"))
            goto fail;
    }
 
    req = (CancelRequestPacket *) &cancel->cancel_req;
    req->cancelRequestCode = (MsgType) pg_hton32(CANCEL_REQUEST_CODE);
    req->backendPID = pg_hton32(conn->be_pid);
    memcpy(req->cancelAuthCode, conn->be_cancel_key, conn->be_cancel_key_len);
    /* include the length field itself in the length */
    cancel->cancel_pkt_len = pg_hton32(cancel_req_len + 4);
 
    return cancel;
 
fail:
    free(cancel);
    return NULL;
}

References CancelRequestPacket::backendPID, pg_conn::be_cancel_key, pg_conn::be_cancel_key_len, pg_conn::be_pid, calloc, pg_cancel::cancel_pkt_len, pg_cancel::cancel_req, CANCEL_REQUEST_CODE, CancelRequestPacket::cancelAuthCode, CancelRequestPacket::cancelRequestCode, conn, free, pg_cancel::keepalives, pg_conn::keepalives, pg_cancel::keepalives_count, pg_conn::keepalives_count, pg_cancel::keepalives_idle, pg_conn::keepalives_idle, pg_cancel::keepalives_interval, pg_conn::keepalives_interval, malloc, pg_hton32, PGINVALID_SOCKET, pg_cancel::pgtcp_user_timeout, pg_conn::pgtcp_user_timeout, pqParseIntParam(), pg_cancel::raddr, pg_conn::raddr, and pg_conn::sock.

Referenced by PQrequestCancel(), set_archive_cancel_info(), SetCancelConn(), and test_cancel().

PQgetCopyData()

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

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

{
    *buffer = NULL;             /* for all failure cases */
    if (!conn)
        return -2;
    if (conn->asyncStatus != PGASYNC_COPY_OUT &&
        conn->asyncStatus != PGASYNC_COPY_BOTH)
    {
        libpq_append_conn_error(conn, "no COPY in progress");
        return -2;
    }
    return pqGetCopyData3(conn, buffer, async);
}

References pg_conn::asyncStatus, conn, libpq_append_conn_error(), PGASYNC_COPY_BOTH, PGASYNC_COPY_OUT, and pqGetCopyData3().

Referenced by CopyStreamReceive(), dumpTableData_copy(), ecpg_process_output(), handleCopyOut(), libpqrcv_receive(), ReceiveCopyData(), and StreamLogicalLog().

PQgetCurrentTimeUSec()

pg_usec_time_t PQgetCurrentTimeUSec

(

void

)

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

{
    struct timeval tval;
 
    gettimeofday(&tval, NULL);
    return (pg_usec_time_t) tval.tv_sec * 1000000 + tval.tv_usec;
}

References gettimeofday().

Referenced by pqConnectDBComplete(), PQsocketPoll(), and wait_until_connected().

PQgetgssctx()

void * PQgetgssctx

(

PGconn *

conn

)

Definition at line 756 of file fe-secure-gssapi.c.

{
    if (!conn)
        return NULL;
 
    return conn->gctx;
}

References conn.

PQgetisnull()

int PQgetisnull	(	const PGresult *	res,
		int	tup_num,
		int	field_num
	)

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

{
    if (!check_tuple_field_number(res, tup_num, field_num))
        return 1;               /* pretend it is null */
    if (res->tuples[tup_num][field_num].len == NULL_LEN)
        return 1;
    else
        return 0;
}

References check_tuple_field_number(), pgresAttValue::len, NULL_LEN, and pg_result::tuples.

PQgetlength()

int PQgetlength	(	const PGresult *	res,
		int	tup_num,
		int	field_num
	)

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

{
    if (!check_tuple_field_number(res, tup_num, field_num))
        return 0;
    if (res->tuples[tup_num][field_num].len != NULL_LEN)
        return res->tuples[tup_num][field_num].len;
    else
        return 0;
}

References check_tuple_field_number(), pgresAttValue::len, NULL_LEN, and pg_result::tuples.

PQgetline()

int PQgetline	(	PGconn *	conn,
		char *	buffer,
		int	length
	)

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

{
    if (!buffer || length <= 0)
        return EOF;
    *buffer = '\0';
    /* length must be at least 3 to hold the \. terminator! */
    if (length < 3)
        return EOF;
 
    if (!conn)
        return EOF;
 
    return pqGetline3(conn, buffer, length);
}

References conn, and pqGetline3().

PQgetlineAsync()

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

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

{
    if (!conn)
        return -1;
 
    return pqGetlineAsync3(conn, buffer, bufsize);
}

References bufsize, conn, and pqGetlineAsync3().

Referenced by pqGetline3().

PQgetResult()

PGresult * PQgetResult

(

PGconn *

conn

)

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

{
    PGresult   *res;
 
    if (!conn)
        return NULL;
 
    /* Parse any available data, if our state permits. */
    parseInput(conn);
 
    /* If not ready to return something, block until we are. */
    while (conn->asyncStatus == PGASYNC_BUSY)
    {
        int         flushResult;
 
        /*
         * If data remains unsent, send it.  Else we might be waiting for the
         * result of a command the backend hasn't even got yet.
         */
        while ((flushResult = pqFlush(conn)) > 0)
        {
            if (pqWait(false, true, conn))
            {
                flushResult = -1;
                break;
            }
        }
 
        /*
         * Wait for some more data, and load it.  (Note: if the connection has
         * been lost, pqWait should return immediately because the socket
         * should be read-ready, either with the last server data or with an
         * EOF indication.  We expect therefore that this won't result in any
         * undue delay in reporting a previous write failure.)
         */
        if (flushResult ||
            pqWait(true, false, conn) ||
            pqReadData(conn) < 0)
        {
            /* Report the error saved by pqWait or pqReadData */
            pqSaveErrorResult(conn);
            conn->asyncStatus = PGASYNC_IDLE;
            return pqPrepareAsyncResult(conn);
        }
 
        /* Parse it. */
        parseInput(conn);
 
        /*
         * If we had a write error, but nothing above obtained a query result
         * or detected a read error, report the write error.
         */
        if (conn->write_failed && conn->asyncStatus == PGASYNC_BUSY)
        {
            pqSaveWriteError(conn);
            conn->asyncStatus = PGASYNC_IDLE;
            return pqPrepareAsyncResult(conn);
        }
    }
 
    /* Return the appropriate thing. */
    switch (conn->asyncStatus)
    {
        case PGASYNC_IDLE:
            res = NULL;         /* query is complete */
            break;
        case PGASYNC_PIPELINE_IDLE:
            Assert(conn->pipelineStatus != PQ_PIPELINE_OFF);
 
            /*
             * We're about to return the NULL that terminates the round of
             * results from the current query; prepare to send the results of
             * the next query, if any, when we're called next.  If there's no
             * next element in the command queue, this gets us in IDLE state.
             */
            pqPipelineProcessQueue(conn);
            res = NULL;         /* query is complete */
            break;
 
        case PGASYNC_READY:
            res = pqPrepareAsyncResult(conn);
 
            /*
             * Normally pqPrepareAsyncResult will have left conn->result
             * empty.  Otherwise, "res" must be a not-full PGRES_TUPLES_CHUNK
             * result, which we want to return to the caller while staying in
             * PGASYNC_READY state.  Then the next call here will return the
             * empty PGRES_TUPLES_OK result that was restored from
             * saved_result, after which we can proceed.
             */
            if (conn->result)
            {
                Assert(res->resultStatus == PGRES_TUPLES_CHUNK);
                break;
            }
 
            /* Advance the queue as appropriate */
            pqCommandQueueAdvance(conn, false,
                                  res->resultStatus == PGRES_PIPELINE_SYNC);
 
            if (conn->pipelineStatus != PQ_PIPELINE_OFF)
            {
                /*
                 * We're about to send the results of the current query.  Set
                 * us idle now, and ...
                 */
                conn->asyncStatus = PGASYNC_PIPELINE_IDLE;
 
                /*
                 * ... in cases when we're sending a pipeline-sync result,
                 * move queue processing forwards immediately, so that next
                 * time we're called, we're prepared to return the next result
                 * received from the server.  In all other cases, leave the
                 * queue state change for next time, so that a terminating
                 * NULL result is sent.
                 *
                 * (In other words: we don't return a NULL after a pipeline
                 * sync.)
                 */
                if (res->resultStatus == PGRES_PIPELINE_SYNC)
                    pqPipelineProcessQueue(conn);
            }
            else
            {
                /* Set the state back to BUSY, allowing parsing to proceed. */
                conn->asyncStatus = PGASYNC_BUSY;
            }
            break;
        case PGASYNC_READY_MORE:
            res = pqPrepareAsyncResult(conn);
            /* Set the state back to BUSY, allowing parsing to proceed. */
            conn->asyncStatus = PGASYNC_BUSY;
            break;
        case PGASYNC_COPY_IN:
            res = getCopyResult(conn, PGRES_COPY_IN);
            break;
        case PGASYNC_COPY_OUT:
            res = getCopyResult(conn, PGRES_COPY_OUT);
            break;
        case PGASYNC_COPY_BOTH:
            res = getCopyResult(conn, PGRES_COPY_BOTH);
            break;
        default:
            libpq_append_conn_error(conn, "unexpected asyncStatus: %d", (int) conn->asyncStatus);
            pqSaveErrorResult(conn);
            conn->asyncStatus = PGASYNC_IDLE;   /* try to restore valid state */
            res = pqPrepareAsyncResult(conn);
            break;
    }
 
    /* Time to fire PGEVT_RESULTCREATE events, if there are any */
    if (res && res->nEvents > 0)
        (void) PQfireResultCreateEvents(conn, res);
 
    return res;
}

References Assert(), pg_conn::asyncStatus, conn, getCopyResult(), libpq_append_conn_error(), pg_result::nEvents, parseInput(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, PGASYNC_READY, PGASYNC_READY_MORE, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_PIPELINE_SYNC, PGRES_TUPLES_CHUNK, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqCommandQueueAdvance(), PQfireResultCreateEvents(), pqFlush(), pqPipelineProcessQueue(), pqPrepareAsyncResult(), pqReadData(), pqSaveErrorResult(), pqSaveWriteError(), pqWait(), pg_conn::result, pg_result::resultStatus, and pg_conn::write_failed.

Referenced by PQexecFinish(), and PQexecStart().

PQgetssl()

void * PQgetssl

(

PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
    return conn->ssl;
}

References conn.

PQgetSSLKeyPassHook_OpenSSL()

PQsslKeyPassHook_OpenSSL_type PQgetSSLKeyPassHook_OpenSSL

(

void

)

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

{
    return PQsslKeyPassHook;
}

References PQsslKeyPassHook.

PQgetvalue()

char * PQgetvalue	(	const PGresult *	res,
		int	tup_num,
		int	field_num
	)

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

{
    if (!check_tuple_field_number(res, tup_num, field_num))
        return NULL;
    return res->tuples[tup_num][field_num].value;
}

References check_tuple_field_number(), pg_result::tuples, and pgresAttValue::value.

PQgssEncInUse()

int PQgssEncInUse

(

PGconn *

conn

)

Definition at line 768 of file fe-secure-gssapi.c.

{
    if (!conn || !conn->gctx)
        return 0;
 
    return conn->gssenc;
}

References conn.

Referenced by printGSSInfo().

PQhost()

char * PQhost

(

const PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
 
    if (conn->connhost != NULL)
    {
        /*
         * Return the verbatim host value provided by user, or hostaddr in its
         * lack.
         */
        if (conn->connhost[conn->whichhost].host != NULL &&
            conn->connhost[conn->whichhost].host[0] != '\0')
            return conn->connhost[conn->whichhost].host;
        else if (conn->connhost[conn->whichhost].hostaddr != NULL &&
                 conn->connhost[conn->whichhost].hostaddr[0] != '\0')
            return conn->connhost[conn->whichhost].hostaddr;
    }
 
    return "";
}

References conn, pg_conn::connhost, pg_conn_host::host, pg_conn_host::hostaddr, and pg_conn::whichhost.

Referenced by do_connect(), exec_command_conninfo(), get_prompt(), libpqrcv_get_senderinfo(), main(), pg_GSS_load_servicename(), and SyncVariables().

PQhostaddr()

char * PQhostaddr

(

const PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
 
    /* Return the parsed IP address */
    if (conn->connhost != NULL && conn->connip != NULL)
        return conn->connip;
 
    return "";
}

References conn, pg_conn::connhost, and pg_conn::connip.

Referenced by do_connect(), and exec_command_conninfo().

PQinitOpenSSL()

void PQinitOpenSSL	(	int	do_ssl,
		int	do_crypto
	)

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

{
    /* no-op */
}

PQinitSSL()

void PQinitSSL

(

int

do_init

)

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

{
    /* no-op */
}

PQisBusy()

int PQisBusy

(

PGconn *

conn

)

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

{
    if (!conn)
        return false;
 
    /* Parse any available data, if our state permits. */
    parseInput(conn);
 
    /*
     * PQgetResult will return immediately in all states except BUSY.  Also,
     * if we've detected read EOF and dropped the connection, we can expect
     * that PQgetResult will fail immediately.  Note that we do *not* check
     * conn->write_failed here --- once that's become set, we know we have
     * trouble, but we need to keep trying to read until we have a complete
     * server message or detect read EOF.
     */
    return conn->asyncStatus == PGASYNC_BUSY && conn->status != CONNECTION_BAD;
}

References pg_conn::asyncStatus, conn, CONNECTION_BAD, parseInput(), PGASYNC_BUSY, and pg_conn::status.

Referenced by advanceConnectionState(), consume_query_cancel_impl(), dblink_is_busy(), libpqsrv_get_result(), pgfdw_get_cleanup_result(), PQconnectPoll(), pqEndcopy3(), process_slot(), test_disallowed_in_pipeline(), test_pipelined_insert(), test_uniqviol(), try_complete_step(), and wait_on_slots().

PQisnonblocking()

int PQisnonblocking

(

const PGconn *

conn

)

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

{
    if (!conn || conn->status == CONNECTION_BAD)
        return false;
    return pqIsnonblocking(conn);
}

References conn, CONNECTION_BAD, pqIsnonblocking, and pg_conn::status.

Referenced by test_disallowed_in_pipeline(), and test_simple_pipeline().

PQisthreadsafe()

int PQisthreadsafe

(

void

)

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

{
    return true;
}

PQlibVersion()

int PQlibVersion

(

void

)

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

{
    return PG_VERSION_NUM;
}

PQmakeEmptyPGresult()

PGresult * PQmakeEmptyPGresult	(	PGconn *	conn,
		ExecStatusType	status
	)

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

{
    PGresult   *result;
 
    result = (PGresult *) malloc(sizeof(PGresult));
    if (!result)
        return NULL;
 
    result->ntups = 0;
    result->numAttributes = 0;
    result->attDescs = NULL;
    result->tuples = NULL;
    result->tupArrSize = 0;
    result->numParameters = 0;
    result->paramDescs = NULL;
    result->resultStatus = status;
    result->cmdStatus[0] = '\0';
    result->binary = 0;
    result->events = NULL;
    result->nEvents = 0;
    result->errMsg = NULL;
    result->errFields = NULL;
    result->errQuery = NULL;
    result->null_field[0] = '\0';
    result->curBlock = NULL;
    result->curOffset = 0;
    result->spaceLeft = 0;
    result->memorySize = sizeof(PGresult);
 
    if (conn)
    {
        /* copy connection data we might need for operations on PGresult */
        result->noticeHooks = conn->noticeHooks;
        result->client_encoding = conn->client_encoding;
 
        /* consider copying conn's errorMessage */
        switch (status)
        {
            case PGRES_EMPTY_QUERY:
            case PGRES_COMMAND_OK:
            case PGRES_TUPLES_OK:
            case PGRES_COPY_OUT:
            case PGRES_COPY_IN:
            case PGRES_COPY_BOTH:
            case PGRES_SINGLE_TUPLE:
            case PGRES_TUPLES_CHUNK:
                /* non-error cases */
                break;
            default:
                /* we intentionally do not use or modify errorReported here */
                pqSetResultError(result, &conn->errorMessage, 0);
                break;
        }
 
        /* copy events last; result must be valid if we need to PQclear */
        if (conn->nEvents > 0)
        {
            result->events = dupEvents(conn->events, conn->nEvents,
                                       &result->memorySize);
            if (!result->events)
            {
                PQclear(result);
                return NULL;
            }
            result->nEvents = conn->nEvents;
        }
    }
    else
    {
        /* defaults... */
        result->noticeHooks.noticeRec = NULL;
        result->noticeHooks.noticeRecArg = NULL;
        result->noticeHooks.noticeProc = NULL;
        result->noticeHooks.noticeProcArg = NULL;
        result->client_encoding = PG_SQL_ASCII;
    }
 
    return result;
}

References pg_result::attDescs, pg_result::binary, pg_result::client_encoding, pg_conn::client_encoding, pg_result::cmdStatus, conn, pg_result::curBlock, pg_result::curOffset, dupEvents(), pg_result::errFields, pg_result::errMsg, pg_conn::errorMessage, pg_result::errQuery, pg_result::events, pg_conn::events, malloc, pg_result::memorySize, pg_result::nEvents, pg_conn::nEvents, pg_result::noticeHooks, pg_conn::noticeHooks, PGNoticeHooks::noticeProc, PGNoticeHooks::noticeProcArg, PGNoticeHooks::noticeRec, PGNoticeHooks::noticeRecArg, pg_result::ntups, pg_result::null_field, pg_result::numAttributes, pg_result::numParameters, pg_result::paramDescs, PG_SQL_ASCII, PGRES_COMMAND_OK, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_EMPTY_QUERY, PGRES_SINGLE_TUPLE, PGRES_TUPLES_CHUNK, PGRES_TUPLES_OK, PQclear(), pqSetResultError(), pg_result::resultStatus, pg_result::spaceLeft, pg_result::tupArrSize, and pg_result::tuples.

Referenced by ECPGallocate_desc(), getCopyResult(), getCopyStart(), getParamDescriptions(), getRowDescriptions(), PQcopyResult(), pqFunctionCall3(), pqGetErrorNotice3(), pqInternalNotice(), pqParseInput3(), pqPipelineProcessQueue(), and pqPrepareAsyncResult().

PQmblen()

int PQmblen	(	const char *	s,
		int	encoding
	)

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

{
    return pg_encoding_mblen(encoding, s);
}

References encoding, and pg_encoding_mblen().

Referenced by appendStringLiteral(), get_prompt(), pg_wcsformat(), pg_wcssize(), pg_wcswidth(), psqlscan_prepare_buffer(), and strlen_max_width().

PQmblenBounded()

int PQmblenBounded	(	const char *	s,
		int	encoding
	)

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

{
    return strnlen(s, pg_encoding_mblen(encoding, s));
}

References encoding, pg_encoding_mblen(), and strnlen().

Referenced by command_no_begin(), dequote_downcase_identifier(), do_field(), patternToSQLRegex(), quote_if_needed(), reportErrorPosition(), skip_white_space(), splitTableColumnsSpec(), strip_quotes(), and strtokx().

PQnfields()

int PQnfields

(

const PGresult *

res

)

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

{
    if (!res)
        return 0;
    return res->numAttributes;
}

References pg_result::numAttributes.

PQnotifies()

PGnotify * PQnotifies

(

PGconn *

conn

)

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

{
    PGnotify   *event;
 
    if (!conn)
        return NULL;
 
    /* Parse any available data to see if we can extract NOTIFY messages. */
    parseInput(conn);
 
    event = conn->notifyHead;
    if (event)
    {
        conn->notifyHead = event->next;
        if (!conn->notifyHead)
            conn->notifyTail = NULL;
        event->next = NULL;     /* don't let app see the internal state */
    }
    return event;
}

References conn, pgNotify::next, pg_conn::notifyHead, pg_conn::notifyTail, and parseInput().

Referenced by dblink_get_notify(), ecpg_process_output(), main(), PrintNotifications(), and try_complete_step().

PQnparams()

int PQnparams

(

const PGresult *

res

)

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

{
    if (!res)
        return 0;
    return res->numParameters;
}

References pg_result::numParameters.

PQntuples()

int PQntuples

(

const PGresult *

res

)

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

{
    if (!res)
        return 0;
    return res->ntups;
}

References pg_result::ntups.

PQoidStatus()

char * PQoidStatus

(

const PGresult *

res

)

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

{
    /*
     * This must be enough to hold the result. Don't laugh, this is better
     * than what this function used to do.
     */
    static char buf[24];
 
    size_t      len;
 
    if (!res || strncmp(res->cmdStatus, "INSERT ", 7) != 0)
        return "";
 
    len = strspn(res->cmdStatus + 7, "0123456789");
    if (len > sizeof(buf) - 1)
        len = sizeof(buf) - 1;
    memcpy(buf, res->cmdStatus + 7, len);
    buf[len] = '\0';
 
    return buf;
}

References buf, pg_result::cmdStatus, and len.

PQoidValue()

Oid PQoidValue

(

const PGresult *

res

)

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

{
    char       *endptr = NULL;
    unsigned long result;
 
    if (!res ||
        strncmp(res->cmdStatus, "INSERT ", 7) != 0 ||
        res->cmdStatus[7] < '0' ||
        res->cmdStatus[7] > '9')
        return InvalidOid;
 
    result = strtoul(res->cmdStatus + 7, &endptr, 10);
 
    if (!endptr || (*endptr != ' ' && *endptr != '\0'))
        return InvalidOid;
    else
        return (Oid) result;
}

References pg_result::cmdStatus, and InvalidOid.

Referenced by ecpg_process_output(), and PrintQueryStatus().

PQoptions()

char * PQoptions

(

const PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
    return conn->pgoptions;
}

References conn, and pg_conn::pgoptions.

Referenced by exec_command_conninfo().

PQparameterStatus()

const char * PQparameterStatus	(	const PGconn *	conn,
		const char *	paramName
	)

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

{
    const pgParameterStatus *pstatus;
 
    if (!conn || !paramName)
        return NULL;
    for (pstatus = conn->pstatus; pstatus != NULL; pstatus = pstatus->next)
    {
        if (strcmp(pstatus->name, paramName) == 0)
            return pstatus->value;
    }
    return NULL;
}

References conn, pgParameterStatus::name, pgParameterStatus::next, pg_conn::pstatus, and pgParameterStatus::value.

Referenced by _check_database_version(), applyRemoteGucs(), BaseBackup(), CheckServerVersionForStreaming(), ConnectDatabase(), connection_warnings(), ecpg_build_params(), exec_command_conninfo(), GetConnection(), is_superuser(), main(), printVersion(), session_username(), setup_connection(), standard_strings(), and SyncVariables().

PQparamtype()

Oid PQparamtype	(	const PGresult *	res,
		int	param_num
	)

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

{
    if (!check_param_number(res, param_num))
        return InvalidOid;
    if (res->paramDescs)
        return res->paramDescs[param_num].typid;
    else
        return InvalidOid;
}

References check_param_number(), InvalidOid, pg_result::paramDescs, and pgresParamDesc::typid.

PQpass()

char * PQpass

(

const PGconn *

conn

)

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

{
    char       *password = NULL;
 
    if (!conn)
        return NULL;
    if (conn->connhost != NULL)
        password = conn->connhost[conn->whichhost].password;
    if (password == NULL)
        password = conn->pgpass;
    /* Historically we've returned "" not NULL for no password specified */
    if (password == NULL)
        password = "";
    return password;
}

References conn, pg_conn::connhost, password, pg_conn_host::password, pg_conn::pgpass, and pg_conn::whichhost.

Referenced by ConnectDatabaseAhx(), and PQconnectionNeedsPassword().

PQping()

PGPing PQping

(

const char *

conninfo

)

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

{
    PGconn     *conn = PQconnectStart(conninfo);
    PGPing      ret;
 
    ret = internal_ping(conn);
    PQfinish(conn);
 
    return ret;
}

References conn, internal_ping(), PQconnectStart(), and PQfinish().

PQpingParams()

PGPing PQpingParams	(	const char *const *	keywords,
		const char *const *	values,
		int	expand_dbname
	)

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

{
    PGconn     *conn = PQconnectStartParams(keywords, values, expand_dbname);
    PGPing      ret;
 
    ret = internal_ping(conn);
    PQfinish(conn);
 
    return ret;
}

References conn, internal_ping(), keywords, PQconnectStartParams(), PQfinish(), and values.

Referenced by main(), and regression_main().

PQpipelineStatus()

PGpipelineStatus PQpipelineStatus

(

const PGconn *

conn

)

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

{
    if (!conn)
        return PQ_PIPELINE_OFF;
 
    return conn->pipelineStatus;
}

References conn, pg_conn::pipelineStatus, and PQ_PIPELINE_OFF.

Referenced by advanceConnectionState(), exec_command_g(), exec_command_gexec(), exec_command_gset(), exec_command_sendpipeline(), exec_command_watch(), ExecQueryAndProcessResults(), executeMetaCommand(), get_prompt(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_pipeline_abort(), and test_simple_pipeline().

PQpipelineSync()

int PQpipelineSync

(

PGconn *

conn

)

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

{
    return pqPipelineSyncInternal(conn, true);
}

References conn, and pqPipelineSyncInternal().

Referenced by discardUntilSync(), ExecQueryAndProcessResults(), executeMetaCommand(), test_multi_pipelines(), test_pipeline_abort(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), and test_transaction().

PQport()

char * PQport

(

const PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
 
    if (conn->connhost != NULL &&
        conn->connhost[conn->whichhost].port != NULL &&
        conn->connhost[conn->whichhost].port[0] != '\0')
        return conn->connhost[conn->whichhost].port;
 
    return DEF_PGPORT_STR;
}

References conn, pg_conn::connhost, pg_conn_host::port, and pg_conn::whichhost.

Referenced by do_connect(), exec_command_conninfo(), get_prompt(), libpqrcv_get_senderinfo(), main(), and SyncVariables().

PQprepare()

PGresult * PQprepare	(	PGconn *	conn,
		const char *	stmtName,
		const char *	query,
		int	nParams,
		const Oid *	paramTypes
	)

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

{
    if (!PQexecStart(conn))
        return NULL;
    if (!PQsendPrepare(conn, stmtName, query, nParams, paramTypes))
        return NULL;
    return PQexecFinish(conn);
}

References conn, PQexecFinish(), PQexecStart(), and PQsendPrepare().

Referenced by DescribeQuery(), init_libpq_conn(), main(), prepare_common(), prepareCommand(), and test_uniqviol().

PQprint()

void PQprint	(	FILE *	fout,
		const PGresult *	res,
		const PQprintOpt *	po
	)

Definition at line 68 of file fe-print.c.

{
    int         nFields;
 
    nFields = PQnfields(res);
 
    if (nFields > 0)
    {                           /* only print rows with at least 1 field.  */
        int         i,
                    j;
        int         nTups;
        int        *fieldMax = NULL;    /* in case we don't use them */
        unsigned char *fieldNotNum = NULL;
        char       *border = NULL;
        char      **fields = NULL;
        const char **fieldNames = NULL;
        int         fieldMaxLen = 0;
        int         numFieldName;
        int         fs_len = strlen(po->fieldSep);
        int         total_line_length = 0;
        bool        usePipe = false;
        char       *pagerenv;
 
#if !defined(WIN32)
        sigset_t    osigset;
        bool        sigpipe_masked = false;
        bool        sigpipe_pending;
#endif
 
#ifdef TIOCGWINSZ
        struct winsize screen_size;
#else
        struct winsize
        {
            int         ws_row;
            int         ws_col;
        }           screen_size;
#endif
 
        nTups = PQntuples(res);
        fieldNames = (const char **) calloc(nFields, sizeof(char *));
        fieldNotNum = (unsigned char *) calloc(nFields, 1);
        fieldMax = (int *) calloc(nFields, sizeof(int));
        if (!fieldNames || !fieldNotNum || !fieldMax)
        {
            fprintf(stderr, libpq_gettext("out of memory\n"));
            goto exit;
        }
        for (numFieldName = 0;
             po->fieldName && po->fieldName[numFieldName];
             numFieldName++)
            ;
        for (j = 0; j < nFields; j++)
        {
            int         len;
            const char *s = (j < numFieldName && po->fieldName[j][0]) ?
                po->fieldName[j] : PQfname(res, j);
 
            fieldNames[j] = s;
            len = s ? strlen(s) : 0;
            fieldMax[j] = len;
            len += fs_len;
            if (len > fieldMaxLen)
                fieldMaxLen = len;
            total_line_length += len;
        }
 
        total_line_length += nFields * strlen(po->fieldSep) + 1;
 
        if (fout == NULL)
            fout = stdout;
        if (po->pager && fout == stdout && isatty(fileno(stdin)) &&
            isatty(fileno(stdout)))
        {
            /*
             * If we think there'll be more than one screen of output, try to
             * pipe to the pager program.
             */
#ifdef TIOCGWINSZ
            if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) == -1 ||
                screen_size.ws_col == 0 ||
                screen_size.ws_row == 0)
            {
                screen_size.ws_row = 24;
                screen_size.ws_col = 80;
            }
#else
            screen_size.ws_row = 24;
            screen_size.ws_col = 80;
#endif
 
            /*
             * Since this function is no longer used by psql, we don't examine
             * PSQL_PAGER.  It's possible that the hypothetical external users
             * of the function would like that to happen, but in the name of
             * backwards compatibility, we'll stick to just examining PAGER.
             */
            pagerenv = getenv("PAGER");
            /* if PAGER is unset, empty or all-white-space, don't use pager */
            if (pagerenv != NULL &&
                strspn(pagerenv, " \t\r\n") != strlen(pagerenv) &&
                !po->html3 &&
                ((po->expanded &&
                  nTups * (nFields + 1) >= screen_size.ws_row) ||
                 (!po->expanded &&
                  nTups * (total_line_length / screen_size.ws_col + 1) *
                  (1 + (po->standard != 0)) >= screen_size.ws_row -
                  (po->header != 0) *
                  (total_line_length / screen_size.ws_col + 1) * 2
                  - (po->header != 0) * 2   /* row count and newline */
                  )))
            {
                fflush(NULL);
                fout = popen(pagerenv, "w");
                if (fout)
                {
                    usePipe = true;
#ifndef WIN32
                    if (pq_block_sigpipe(&osigset, &sigpipe_pending) == 0)
                        sigpipe_masked = true;
#endif                          /* WIN32 */
                }
                else
                    fout = stdout;
            }
        }
 
        if (!po->expanded && (po->align || po->html3))
        {
            fields = (char **) calloc((size_t) nTups + 1,
                                      nFields * sizeof(char *));
            if (!fields)
            {
                fprintf(stderr, libpq_gettext("out of memory\n"));
                goto exit;
            }
        }
        else if (po->header && !po->html3)
        {
            if (po->expanded)
            {
                if (po->align)
                    fprintf(fout, libpq_gettext("%-*s%s Value\n"),
                            fieldMaxLen - fs_len, libpq_gettext("Field"), po->fieldSep);
                else
                    fprintf(fout, libpq_gettext("%s%sValue\n"), libpq_gettext("Field"), po->fieldSep);
            }
            else
            {
                int         len = 0;
 
                for (j = 0; j < nFields; j++)
                {
                    const char *s = fieldNames[j];
 
                    fputs(s, fout);
                    len += strlen(s) + fs_len;
                    if ((j + 1) < nFields)
                        fputs(po->fieldSep, fout);
                }
                fputc('\n', fout);
                for (len -= fs_len; len--; fputc('-', fout));
                fputc('\n', fout);
            }
        }
        if (po->expanded && po->html3)
        {
            if (po->caption)
                fprintf(fout, "<center><h2>%s</h2></center>\n", po->caption);
            else
                fprintf(fout,
                        "<center><h2>"
                        "Query retrieved %d rows * %d fields"
                        "</h2></center>\n",
                        nTups, nFields);
        }
        for (i = 0; i < nTups; i++)
        {
            if (po->expanded)
            {
                if (po->html3)
                    fprintf(fout,
                            "<table %s><caption align=\"top\">%d</caption>\n",
                            po->tableOpt ? po->tableOpt : "", i);
                else
                    fprintf(fout, libpq_gettext("-- RECORD %d --\n"), i);
            }
            for (j = 0; j < nFields; j++)
            {
                if (!do_field(po, res, i, j, fs_len, fields, nFields,
                              fieldNames, fieldNotNum,
                              fieldMax, fieldMaxLen, fout))
                    goto exit;
            }
            if (po->html3 && po->expanded)
                fputs("</table>\n", fout);
        }
        if (!po->expanded && (po->align || po->html3))
        {
            if (po->html3)
            {
                if (po->header)
                {
                    if (po->caption)
                        fprintf(fout,
                                "<table %s><caption align=\"top\">%s</caption>\n",
                                po->tableOpt ? po->tableOpt : "",
                                po->caption);
                    else
                        fprintf(fout,
                                "<table %s><caption align=\"top\">"
                                "Retrieved %d rows * %d fields"
                                "</caption>\n",
                                po->tableOpt ? po->tableOpt : "", nTups, nFields);
                }
                else
                    fprintf(fout, "<table %s>", po->tableOpt ? po->tableOpt : "");
            }
            if (po->header)
                border = do_header(fout, po, nFields, fieldMax, fieldNames,
                                   fieldNotNum, fs_len, res);
            for (i = 0; i < nTups; i++)
                output_row(fout, po, nFields, fields,
                           fieldNotNum, fieldMax, border, i);
        }
        if (po->header && !po->html3)
            fprintf(fout, "(%d row%s)\n\n", PQntuples(res),
                    (PQntuples(res) == 1) ? "" : "s");
        if (po->html3 && !po->expanded)
            fputs("</table>\n", fout);
 
exit:
        free(fieldMax);
        free(fieldNotNum);
        free(border);
        if (fields)
        {
            /* if calloc succeeded, this shouldn't overflow size_t */
            size_t      numfields = ((size_t) nTups + 1) * (size_t) nFields;
 
            while (numfields-- > 0)
                free(fields[numfields]);
            free(fields);
        }
        free(fieldNames);
        if (usePipe)
        {
#ifdef WIN32
            _pclose(fout);
#else
            pclose(fout);
 
            /* we can't easily verify if EPIPE occurred, so say it did */
            if (sigpipe_masked)
                pq_reset_sigpipe(&osigset, sigpipe_pending, true);
#endif                          /* WIN32 */
        }
    }
}

References _PQprintOpt::align, calloc, _PQprintOpt::caption, do_field(), do_header(), _PQprintOpt::expanded, _PQprintOpt::fieldName, _PQprintOpt::fieldSep, fprintf, free, _PQprintOpt::header, _PQprintOpt::html3, i, j, len, libpq_gettext, output_row(), _PQprintOpt::pager, pq_block_sigpipe(), pq_reset_sigpipe(), PQfname, PQnfields, PQntuples, _PQprintOpt::standard, generate_unaccent_rules::stdout, and _PQprintOpt::tableOpt.

Referenced by printResultSet().

PQprintTuples()

void PQprintTuples	(	const PGresult *	res,
		FILE *	fout,
		int	PrintAttNames,
		int	TerseOutput,
		int	colWidth
	)

Definition at line 671 of file fe-print.c.

{
    int         nFields;
    int         nTups;
    int         i,
                j;
    char        formatString[80];
    char       *tborder = NULL;
 
    nFields = PQnfields(res);
    nTups = PQntuples(res);
 
    if (colWidth > 0)
        sprintf(formatString, "%%s %%-%ds", colWidth);
    else
        sprintf(formatString, "%%s %%s");
 
    if (nFields > 0)
    {                           /* only print rows with at least 1 field.  */
 
        if (!TerseOutput)
        {
            int         width;
 
            width = nFields * 14;
            tborder = (char *) malloc(width + 1);
            if (!tborder)
            {
                fprintf(stderr, libpq_gettext("out of memory\n"));
                return;
            }
            for (i = 0; i < width; i++)
                tborder[i] = '-';
            tborder[width] = '\0';
            fprintf(fout, "%s\n", tborder);
        }
 
        for (i = 0; i < nFields; i++)
        {
            if (PrintAttNames)
            {
                fprintf(fout, formatString,
                        TerseOutput ? "" : "|",
                        PQfname(res, i));
            }
        }
 
        if (PrintAttNames)
        {
            if (TerseOutput)
                fprintf(fout, "\n");
            else
                fprintf(fout, "|\n%s\n", tborder);
        }
 
        for (i = 0; i < nTups; i++)
        {
            for (j = 0; j < nFields; j++)
            {
                const char *pval = PQgetvalue(res, i, j);
 
                fprintf(fout, formatString,
                        TerseOutput ? "" : "|",
                        pval ? pval : "");
            }
            if (TerseOutput)
                fprintf(fout, "\n");
            else
                fprintf(fout, "|\n%s\n", tborder);
        }
    }
 
    free(tborder);
}

References fprintf, free, i, j, libpq_gettext, malloc, PQfname, PQgetvalue, PQnfields, PQntuples, and sprintf.

PQprotocolVersion()

int PQprotocolVersion

(

const PGconn *

conn

)

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

{
    if (!conn)
        return 0;
    if (conn->status == CONNECTION_BAD)
        return 0;
    return PG_PROTOCOL_MAJOR(conn->pversion);
}

References conn, CONNECTION_BAD, PG_PROTOCOL_MAJOR, pg_conn::pversion, and pg_conn::status.

Referenced by handleCopyIn().

PQputCopyData()

int PQputCopyData	(	PGconn *	conn,
		const char *	buffer,
		int	nbytes
	)

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

{
    if (!conn)
        return -1;
    if (conn->asyncStatus != PGASYNC_COPY_IN &&
        conn->asyncStatus != PGASYNC_COPY_BOTH)
    {
        libpq_append_conn_error(conn, "no COPY in progress");
        return -1;
    }
 
    /*
     * Process any NOTICE or NOTIFY messages that might be pending in the
     * input buffer.  Since the server might generate many notices during the
     * COPY, we want to clean those out reasonably promptly to prevent
     * indefinite expansion of the input buffer.  (Note: the actual read of
     * input data into the input buffer happens down inside pqSendSome, but
     * it's not authorized to get rid of the data again.)
     */
    parseInput(conn);
 
    if (nbytes > 0)
    {
        /*
         * Try to flush any previously sent data in preference to growing the
         * output buffer.  If we can't enlarge the buffer enough to hold the
         * data, return 0 in the nonblock case, else hard error. (For
         * simplicity, always assume 5 bytes of overhead.)
         */
        if ((conn->outBufSize - conn->outCount - 5) < nbytes)
        {
            if (pqFlush(conn) < 0)
                return -1;
            if (pqCheckOutBufferSpace(conn->outCount + 5 + (size_t) nbytes,
                                      conn))
                return pqIsnonblocking(conn) ? 0 : -1;
        }
        /* Send the data (too simple to delegate to fe-protocol files) */
        if (pqPutMsgStart(PqMsg_CopyData, conn) < 0 ||
            pqPutnchar(buffer, nbytes, conn) < 0 ||
            pqPutMsgEnd(conn) < 0)
            return -1;
    }
    return 1;
}

References pg_conn::asyncStatus, conn, libpq_append_conn_error(), pg_conn::outBufSize, pg_conn::outCount, parseInput(), PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, pqCheckOutBufferSpace(), pqFlush(), pqIsnonblocking, PqMsg_CopyData, pqPutMsgEnd(), pqPutMsgStart(), and pqPutnchar().

Referenced by BaseBackup(), ExecuteSqlCommandBuf(), handleCopyIn(), libpqrcv_send(), PQputnbytes(), and sendFeedback().

PQputCopyEnd()

int PQputCopyEnd	(	PGconn *	conn,
		const char *	errormsg
	)

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

{
    if (!conn)
        return -1;
    if (conn->asyncStatus != PGASYNC_COPY_IN &&
        conn->asyncStatus != PGASYNC_COPY_BOTH)
    {
        libpq_append_conn_error(conn, "no COPY in progress");
        return -1;
    }
 
    /*
     * Send the COPY END indicator.  This is simple enough that we don't
     * bother delegating it to the fe-protocol files.
     */
    if (errormsg)
    {
        /* Send COPY FAIL */
        if (pqPutMsgStart(PqMsg_CopyFail, conn) < 0 ||
            pqPuts(errormsg, conn) < 0 ||
            pqPutMsgEnd(conn) < 0)
            return -1;
    }
    else
    {
        /* Send COPY DONE */
        if (pqPutMsgStart(PqMsg_CopyDone, conn) < 0 ||
            pqPutMsgEnd(conn) < 0)
            return -1;
    }
 
    /*
     * If we sent the COPY command in extended-query mode, we must issue a
     * Sync as well.
     */
    if (conn->cmd_queue_head &&
        conn->cmd_queue_head->queryclass != PGQUERY_SIMPLE)
    {
        if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
            pqPutMsgEnd(conn) < 0)
            return -1;
    }
 
    /* Return to active duty */
    if (conn->asyncStatus == PGASYNC_COPY_BOTH)
        conn->asyncStatus = PGASYNC_COPY_OUT;
    else
        conn->asyncStatus = PGASYNC_BUSY;
 
    /* Try to flush data */
    if (pqFlush(conn) < 0)
        return -1;
 
    return 1;
}

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, libpq_append_conn_error(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGQUERY_SIMPLE, pqFlush(), PqMsg_CopyDone, PqMsg_CopyFail, PqMsg_Sync, pqPutMsgEnd(), pqPutMsgStart(), pqPuts(), and PGcmdQueueEntry::queryclass.

Referenced by BaseBackup(), CheckCopyStreamStop(), EndDBCopyMode(), handleCopyIn(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), PQexecStart(), prepareToTerminate(), and ProcessWALDataMsg().

PQputline()

int PQputline	(	PGconn *	conn,
		const char *	string
	)

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

{
    return PQputnbytes(conn, string, strlen(string));
}

References conn, and PQputnbytes().

Referenced by initPopulateTable().

PQputnbytes()

int PQputnbytes	(	PGconn *	conn,
		const char *	buffer,
		int	nbytes
	)

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

{
    if (PQputCopyData(conn, buffer, nbytes) > 0)
        return 0;
    else
        return EOF;
}

References conn, and PQputCopyData().

Referenced by PQputline().

PQregisterThreadLock()

pgthreadlock_t PQregisterThreadLock

(

pgthreadlock_t

newhandler

)

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

{
    pgthreadlock_t prev = pg_g_threadlock;
 
    if (newhandler)
        pg_g_threadlock = newhandler;
    else
        pg_g_threadlock = default_threadlock;
 
    return prev;
}

References default_threadlock(), and pg_g_threadlock.

PQrequestCancel()

int PQrequestCancel

(

PGconn *

conn

)

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

{
    int         r;
    PGcancel   *cancel;
 
    /* Check we have an open connection */
    if (!conn)
        return false;
 
    if (conn->sock == PGINVALID_SOCKET)
    {
        strlcpy(conn->errorMessage.data,
                "PQrequestCancel() -- connection is not open\n",
                conn->errorMessage.maxlen);
        conn->errorMessage.len = strlen(conn->errorMessage.data);
        conn->errorReported = 0;
 
        return false;
    }
 
    cancel = PQgetCancel(conn);
    if (cancel)
    {
        r = PQcancel(cancel, conn->errorMessage.data,
                     conn->errorMessage.maxlen);
        PQfreeCancel(cancel);
    }
    else
    {
        strlcpy(conn->errorMessage.data, "out of memory",
                conn->errorMessage.maxlen);
        r = false;
    }
 
    if (!r)
    {
        conn->errorMessage.len = strlen(conn->errorMessage.data);
        conn->errorReported = 0;
    }
 
    return r;
}

References conn, PQExpBufferData::data, pg_conn::errorMessage, pg_conn::errorReported, PQExpBufferData::len, PQExpBufferData::maxlen, PGINVALID_SOCKET, PQcancel(), PQfreeCancel(), PQgetCancel(), pg_conn::sock, and strlcpy().

Referenced by test_cancel().

PQreset()

void PQreset

(

PGconn *

conn

)

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

{
    if (conn)
    {
        pqClosePGconn(conn);
 
        if (pqConnectDBStart(conn) && pqConnectDBComplete(conn))
        {
            /*
             * Notify event procs of successful reset.
             */
            int         i;
 
            for (i = 0; i < conn->nEvents; i++)
            {
                PGEventConnReset evt;
 
                evt.conn = conn;
                (void) conn->events[i].proc(PGEVT_CONNRESET, &evt,
                                            conn->events[i].passThrough);
            }
        }
    }
}

References conn, PGEventConnReset::conn, pg_conn::events, i, pg_conn::nEvents, PGEvent::passThrough, PGEVT_CONNRESET, pqClosePGconn(), pqConnectDBComplete(), pqConnectDBStart(), and PGEvent::proc.

Referenced by CheckConnection().

PQresetPoll()

PostgresPollingStatusType PQresetPoll

(

PGconn *

conn

)

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

{
    if (conn)
    {
        PostgresPollingStatusType status = PQconnectPoll(conn);
 
        if (status == PGRES_POLLING_OK)
        {
            /*
             * Notify event procs of successful reset.
             */
            int         i;
 
            for (i = 0; i < conn->nEvents; i++)
            {
                PGEventConnReset evt;
 
                evt.conn = conn;
                (void) conn->events[i].proc(PGEVT_CONNRESET, &evt,
                                            conn->events[i].passThrough);
            }
        }
 
        return status;
    }
 
    return PGRES_POLLING_FAILED;
}

References conn, PGEventConnReset::conn, pg_conn::events, i, pg_conn::nEvents, PGEvent::passThrough, PGEVT_CONNRESET, PGRES_POLLING_FAILED, PGRES_POLLING_OK, PQconnectPoll(), and PGEvent::proc.

PQresetStart()

int PQresetStart

(

PGconn *

conn

)

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

{
    if (conn)
    {
        pqClosePGconn(conn);
 
        return pqConnectDBStart(conn);
    }
 
    return 0;
}

References conn, pqClosePGconn(), and pqConnectDBStart().

PQresStatus()

char * PQresStatus

(

ExecStatusType

status

)

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

{
    if ((unsigned int) status >= lengthof(pgresStatus))
        return libpq_gettext("invalid ExecStatusType code");
    return pgresStatus[status];
}

References lengthof, libpq_gettext, and pgresStatus.

Referenced by BaseBackup(), confirm_result_status_impl(), consume_null_result_impl(), process_result(), test_pipeline_abort(), test_pipelined_insert(), test_prepared(), test_singlerowmode(), test_transaction(), and try_complete_step().

PQresultAlloc()

void * PQresultAlloc	(	PGresult *	res,
		size_t	nBytes
	)

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

{
    /* Fail if argument is NULL or OOM_result */
    if (!res || (const PGresult *) res == &OOM_result)
        return NULL;
 
    return pqResultAlloc(res, nBytes, true);
}

References OOM_result, and pqResultAlloc().

Referenced by PQsetResultAttrs().

PQresultErrorField()

char * PQresultErrorField	(	const PGresult *	res,
		int	fieldcode
	)

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

{
    PGMessageField *pfield;
 
    if (!res)
        return NULL;
    for (pfield = res->errFields; pfield != NULL; pfield = pfield->next)
    {
        if (pfield->code == fieldcode)
            return pfield->contents;
    }
    return NULL;
}

References pgMessageField::code, pgMessageField::contents, pg_result::errFields, and pgMessageField::next.

PQresultErrorMessage()

char * PQresultErrorMessage

(

const PGresult *

res

)

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

{
    if (!res || !res->errMsg)
        return "";
    return res->errMsg;
}

References pg_result::errMsg.

PQresultMemorySize()

size_t PQresultMemorySize

(

const PGresult *

res

)

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

{
    if (!res)
        return 0;
    return res->memorySize;
}

References pg_result::memorySize.

PQresultStatus()

ExecStatusType PQresultStatus

(

const PGresult *

res

)

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

{
    if (!res)
        return PGRES_FATAL_ERROR;
    return res->resultStatus;
}

References PGRES_FATAL_ERROR, and pg_result::resultStatus.

PQresultVerboseErrorMessage()

char * PQresultVerboseErrorMessage	(	const PGresult *	res,
		PGVerbosity	verbosity,
		PGContextVisibility	show_context
	)

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

{
    PQExpBufferData workBuf;
 
    /*
     * Because the caller is expected to free the result string, we must
     * strdup any constant result.  We use plain strdup and document that
     * callers should expect NULL if out-of-memory.
     */
    if (!res ||
        (res->resultStatus != PGRES_FATAL_ERROR &&
         res->resultStatus != PGRES_NONFATAL_ERROR))
        return strdup(libpq_gettext("PGresult is not an error result\n"));
 
    initPQExpBuffer(&workBuf);
 
    pqBuildErrorMessage3(&workBuf, res, verbosity, show_context);
 
    /* If insufficient memory to format the message, fail cleanly */
    if (PQExpBufferDataBroken(workBuf))
    {
        termPQExpBuffer(&workBuf);
        return strdup(libpq_gettext("out of memory\n"));
    }
 
    return workBuf.data;
}

References PQExpBufferData::data, initPQExpBuffer(), libpq_gettext, PGRES_FATAL_ERROR, PGRES_NONFATAL_ERROR, pqBuildErrorMessage3(), PQExpBufferDataBroken, pg_result::resultStatus, and termPQExpBuffer().

Referenced by exec_command_errverbose().

PQsendClosePortal()

int PQsendClosePortal	(	PGconn *	conn,
		const char *	portal
	)

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

{
    return PQsendTypedCommand(conn, PqMsg_Close, 'P', portal);
}

References conn, PqMsg_Close, and PQsendTypedCommand().

Referenced by test_prepared().

PQsendClosePrepared()

int PQsendClosePrepared	(	PGconn *	conn,
		const char *	stmt
	)

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

{
    return PQsendTypedCommand(conn, PqMsg_Close, 'S', stmt);
}

References conn, PqMsg_Close, PQsendTypedCommand(), and stmt.

Referenced by ExecQueryAndProcessResults(), and test_prepared().

PQsendDescribePortal()

int PQsendDescribePortal	(	PGconn *	conn,
		const char *	portal
	)

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

{
    return PQsendTypedCommand(conn, PqMsg_Describe, 'P', portal);
}

References conn, PqMsg_Describe, and PQsendTypedCommand().

Referenced by test_prepared().

PQsendDescribePrepared()

int PQsendDescribePrepared	(	PGconn *	conn,
		const char *	stmt
	)

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

{
    return PQsendTypedCommand(conn, PqMsg_Describe, 'S', stmt);
}

References conn, PqMsg_Describe, PQsendTypedCommand(), and stmt.

Referenced by test_prepared().

PQsendFlushRequest()

int PQsendFlushRequest

(

PGconn *

conn

)

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

{
    if (!conn)
        return 0;
 
    /* Don't try to send if we know there's no live connection. */
    if (conn->status != CONNECTION_OK)
    {
        libpq_append_conn_error(conn, "no connection to the server");
        return 0;
    }
 
    /* Can't send while already busy, either, unless enqueuing for later */
    if (conn->asyncStatus != PGASYNC_IDLE &&
        conn->pipelineStatus == PQ_PIPELINE_OFF)
    {
        libpq_append_conn_error(conn, "another command is already in progress");
        return 0;
    }
 
    if (pqPutMsgStart(PqMsg_Flush, conn) < 0 ||
        pqPutMsgEnd(conn) < 0)
    {
        return 0;
    }
 
    /*
     * Give the data a push (in pipeline mode, only if we're past the size
     * threshold).  In nonblock mode, don't complain if we're unable to send
     * it all; PQgetResult() will do any additional flushing needed.
     */
    if (pqPipelineFlush(conn) < 0)
        return 0;
 
    return 1;
}

References pg_conn::asyncStatus, conn, CONNECTION_OK, libpq_append_conn_error(), PGASYNC_IDLE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PqMsg_Flush, pqPipelineFlush(), pqPutMsgEnd(), pqPutMsgStart(), and pg_conn::status.

Referenced by ExecQueryAndProcessResults(), test_nosync(), test_pipeline_idle(), test_singlerowmode(), and test_uniqviol().

PQsendPipelineSync()

int PQsendPipelineSync

(

PGconn *

conn

)

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

{
    return pqPipelineSyncInternal(conn, false);
}

References conn, and pqPipelineSyncInternal().

Referenced by ExecQueryAndProcessResults(), executeMetaCommand(), and test_multi_pipelines().

PQsendPrepare()

int PQsendPrepare	(	PGconn *	conn,
		const char *	stmtName,
		const char *	query,
		int	nParams,
		const Oid *	paramTypes
	)

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

{
    PGcmdQueueEntry *entry = NULL;
 
    if (!PQsendQueryStart(conn, true))
        return 0;
 
    /* check the arguments */
    if (!stmtName)
    {
        libpq_append_conn_error(conn, "statement name is a null pointer");
        return 0;
    }
    if (!query)
    {
        libpq_append_conn_error(conn, "command string is a null pointer");
        return 0;
    }
    if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
    {
        libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
                                PQ_QUERY_PARAM_MAX_LIMIT);
        return 0;
    }
 
    entry = pqAllocCmdQueueEntry(conn);
    if (entry == NULL)
        return 0;               /* error msg already set */
 
    /* construct the Parse message */
    if (pqPutMsgStart(PqMsg_Parse, conn) < 0 ||
        pqPuts(stmtName, conn) < 0 ||
        pqPuts(query, conn) < 0)
        goto sendFailed;
 
    if (nParams > 0 && paramTypes)
    {
        int         i;
 
        if (pqPutInt(nParams, 2, conn) < 0)
            goto sendFailed;
        for (i = 0; i < nParams; i++)
        {
            if (pqPutInt(paramTypes[i], 4, conn) < 0)
                goto sendFailed;
        }
    }
    else
    {
        if (pqPutInt(0, 2, conn) < 0)
            goto sendFailed;
    }
    if (pqPutMsgEnd(conn) < 0)
        goto sendFailed;
 
    /* Add a Sync, unless in pipeline mode. */
    if (conn->pipelineStatus == PQ_PIPELINE_OFF)
    {
        if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
            pqPutMsgEnd(conn) < 0)
            goto sendFailed;
    }
 
    /* remember we are doing just a Parse */
    entry->queryclass = PGQUERY_PREPARE;
 
    /* and remember the query text too, if possible */
    /* if insufficient memory, query just winds up NULL */
    entry->query = strdup(query);
 
    /*
     * Give the data a push (in pipeline mode, only if we're past the size
     * threshold).  In nonblock mode, don't complain if we're unable to send
     * it all; PQgetResult() will do any additional flushing needed.
     */
    if (pqPipelineFlush(conn) < 0)
        goto sendFailed;
 
    /* OK, it's launched! */
    pqAppendCmdQueueEntry(conn, entry);
 
    return 1;
 
sendFailed:
    pqRecycleCmdQueueEntry(conn, entry);
    /* error message should be set up already */
    return 0;
}

References conn, i, libpq_append_conn_error(), PGQUERY_PREPARE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PQ_QUERY_PARAM_MAX_LIMIT, pqAllocCmdQueueEntry(), pqAppendCmdQueueEntry(), PqMsg_Parse, PqMsg_Sync, pqPipelineFlush(), pqPutInt(), pqPutMsgEnd(), pqPutMsgStart(), pqPuts(), pqRecycleCmdQueueEntry(), PQsendQueryStart(), PGcmdQueueEntry::query, and PGcmdQueueEntry::queryclass.

Referenced by ExecQueryAndProcessResults(), PQprepare(), prepare_foreign_modify(), test_pipelined_insert(), test_prepared(), and test_transaction().

PQsendQuery()

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

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

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

References conn, and PQsendQueryInternal().

Referenced by advanceConnectionState(), BaseBackup(), dblink_send_query(), do_sql_command_begin(), ExecQueryAndProcessResults(), fetch_more_data_begin(), libpqsrv_exec(), pgfdw_exec_cleanup_query_begin(), pgfdw_exec_query(), pgfdw_finish_pre_commit_cleanup(), PQexec(), process_slot(), run_command(), run_permutation(), run_reindex_command(), run_vacuum_command(), sendCommand(), storeQueryResult(), and test_disallowed_in_pipeline().

PQsendQueryParams()

int PQsendQueryParams	(	PGconn *	conn,
		const char *	command,
		int	nParams,
		const Oid *	paramTypes,
		const char *const *	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

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

{
    if (!PQsendQueryStart(conn, true))
        return 0;
 
    /* check the arguments */
    if (!command)
    {
        libpq_append_conn_error(conn, "command string is a null pointer");
        return 0;
    }
    if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
    {
        libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
                                PQ_QUERY_PARAM_MAX_LIMIT);
        return 0;
    }
 
    return PQsendQueryGuts(conn,
                           command,
                           "",  /* use unnamed statement */
                           nParams,
                           paramTypes,
                           paramValues,
                           paramLengths,
                           paramFormats,
                           resultFormat);
}

References conn, libpq_append_conn_error(), PQ_QUERY_PARAM_MAX_LIMIT, PQsendQueryGuts(), and PQsendQueryStart().

Referenced by create_cursor(), ExecQueryAndProcessResults(), execute_dml_stmt(), libpqsrv_exec_params(), PQexecParams(), send_cancellable_query_impl(), sendCommand(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_simple_pipeline(), test_singlerowmode(), and test_transaction().

PQsendQueryPrepared()

int PQsendQueryPrepared	(	PGconn *	conn,
		const char *	stmtName,
		int	nParams,
		const char *const *	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

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

{
    if (!PQsendQueryStart(conn, true))
        return 0;
 
    /* check the arguments */
    if (!stmtName)
    {
        libpq_append_conn_error(conn, "statement name is a null pointer");
        return 0;
    }
    if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
    {
        libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
                                PQ_QUERY_PARAM_MAX_LIMIT);
        return 0;
    }
 
    return PQsendQueryGuts(conn,
                           NULL,    /* no command to parse */
                           stmtName,
                           nParams,
                           NULL,    /* no param types */
                           paramValues,
                           paramLengths,
                           paramFormats,
                           resultFormat);
}

References conn, libpq_append_conn_error(), PQ_QUERY_PARAM_MAX_LIMIT, PQsendQueryGuts(), and PQsendQueryStart().

Referenced by ExecQueryAndProcessResults(), execute_foreign_modify(), PQexecPrepared(), process_queued_fetch_requests(), sendCommand(), test_pipelined_insert(), test_transaction(), and test_uniqviol().

PQserverVersion()

int PQserverVersion

(

const PGconn *

conn

)

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

{
    if (!conn)
        return 0;
    if (conn->status == CONNECTION_BAD)
        return 0;
    return conn->sversion;
}

References conn, CONNECTION_BAD, pg_conn::status, and pg_conn::sversion.

Referenced by _check_database_version(), appendStringLiteralConn(), BaseBackup(), CheckServerVersionForStreaming(), configure_remote_session(), ConnectDatabase(), CreateReplicationSlot(), dumpRoleMembership(), GenerateRecoveryConfig(), GetConnection(), initPopulateTable(), libpqrcv_create_slot(), libpqrcv_server_version(), libpqrcv_startstreaming(), main(), postgresAcquireSampleRowsFunc(), postgresImportForeignSchema(), postgresReScanForeignScan(), prepare_vacuum_command(), printVersion(), processSQLNamePattern(), ReceiveTarFile(), reindex_one_database(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), RunIdentifySystem(), StartLogStreamer(), StreamLog(), SyncVariables(), vacuum_one_database(), vacuumlo(), and WriteRecoveryConfig().

PQsetAuthDataHook()

void PQsetAuthDataHook

(

PQauthDataHook_type

hook

)

Definition at line 1595 of file fe-auth.c.

{
    PQauthDataHook = hook ? hook : PQdefaultAuthDataHook;
}

References PQauthDataHook, and PQdefaultAuthDataHook().

Referenced by main().

PQsetChunkedRowsMode()

int PQsetChunkedRowsMode	(	PGconn *	conn,
		int	chunkSize
	)

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

{
    if (chunkSize > 0 && canChangeResultMode(conn))
    {
        conn->partialResMode = true;
        conn->singleRowMode = false;
        conn->maxChunkSize = chunkSize;
        return 1;
    }
    else
        return 0;
}

References canChangeResultMode(), conn, pg_conn::maxChunkSize, pg_conn::partialResMode, and pg_conn::singleRowMode.

Referenced by ExecQueryAndProcessResults(), and test_singlerowmode().

PQsetClientEncoding()

int PQsetClientEncoding	(	PGconn *	conn,
		const char *	encoding
	)

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

{
    char        qbuf[128];
    static const char query[] = "set client_encoding to '%s'";
    PGresult   *res;
    int         status;
 
    if (!conn || conn->status != CONNECTION_OK)
        return -1;
 
    if (!encoding)
        return -1;
 
    /* Resolve special "auto" value from the locale */
    if (strcmp(encoding, "auto") == 0)
        encoding = pg_encoding_to_char(pg_get_encoding_from_locale(NULL, true));
 
    /* check query buffer overflow */
    if (sizeof(qbuf) < (sizeof(query) + strlen(encoding)))
        return -1;
 
    /* ok, now send a query */
    sprintf(qbuf, query, encoding);
    res = PQexec(conn, qbuf);
 
    if (res == NULL)
        return -1;
    if (res->resultStatus != PGRES_COMMAND_OK)
        status = -1;
    else
    {
        /*
         * We rely on the backend to report the parameter value, and we'll
         * change state at that time.
         */
        status = 0;             /* everything is ok */
    }
    PQclear(res);
    return status;
}

References conn, CONNECTION_OK, encoding, pg_encoding_to_char, pg_get_encoding_from_locale(), PGRES_COMMAND_OK, PQclear, PQexec(), pg_result::resultStatus, sprintf, and pg_conn::status.

Referenced by dblink_connect(), dblink_get_conn(), exec_command_encoding(), main(), setup_connection(), test_gb18030_page_multiple(), and test_one_vector().

PQsetdbLogin()

PGconn * PQsetdbLogin	(	const char *	pghost,
		const char *	pgport,
		const char *	pgoptions,
		const char *	pgtty,
		const char *	dbName,
		const char *	login,
		const char *	pwd
	)

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

{
    PGconn     *conn;
 
    /*
     * Allocate memory for the conn structure.  Note that we also expect this
     * to initialize conn->errorMessage to empty.  All subsequent steps during
     * connection initialization will only append to that buffer.
     */
    conn = pqMakeEmptyPGconn();
    if (conn == NULL)
        return NULL;
 
    /*
     * If the dbName parameter contains what looks like a connection string,
     * parse it into conn struct using connectOptions1.
     */
    if (dbName && recognized_connection_string(dbName))
    {
        if (!connectOptions1(conn, dbName))
            return conn;
    }
    else
    {
        /*
         * Old-style path: first, parse an empty conninfo string in order to
         * set up the same defaults that PQconnectdb() would use.
         */
        if (!connectOptions1(conn, ""))
            return conn;
 
        /* Insert dbName parameter value into struct */
        if (dbName && dbName[0] != '\0')
        {
            free(conn->dbName);
            conn->dbName = strdup(dbName);
            if (!conn->dbName)
                goto oom_error;
        }
    }
 
    /*
     * Insert remaining parameters into struct, overriding defaults (as well
     * as any conflicting data from dbName taken as a conninfo).
     */
    if (pghost && pghost[0] != '\0')
    {
        free(conn->pghost);
        conn->pghost = strdup(pghost);
        if (!conn->pghost)
            goto oom_error;
    }
 
    if (pgport && pgport[0] != '\0')
    {
        free(conn->pgport);
        conn->pgport = strdup(pgport);
        if (!conn->pgport)
            goto oom_error;
    }
 
    if (pgoptions && pgoptions[0] != '\0')
    {
        free(conn->pgoptions);
        conn->pgoptions = strdup(pgoptions);
        if (!conn->pgoptions)
            goto oom_error;
    }
 
    if (login && login[0] != '\0')
    {
        free(conn->pguser);
        conn->pguser = strdup(login);
        if (!conn->pguser)
            goto oom_error;
    }
 
    if (pwd && pwd[0] != '\0')
    {
        free(conn->pgpass);
        conn->pgpass = strdup(pwd);
        if (!conn->pgpass)
            goto oom_error;
    }
 
    /*
     * Compute derived options
     */
    if (!pqConnectOptions2(conn))
        return conn;
 
    /*
     * Connect to the database
     */
    if (pqConnectDBStart(conn))
        (void) pqConnectDBComplete(conn);
 
    return conn;
 
oom_error:
    conn->status = CONNECTION_BAD;
    libpq_append_conn_error(conn, "out of memory");
    return conn;
}

References conn, CONNECTION_BAD, connectOptions1(), dbName, pg_conn::dbName, free, libpq_append_conn_error(), pghost, pg_conn::pghost, pg_conn::pgoptions, pg_conn::pgpass, pgport, pg_conn::pgport, pg_conn::pguser, pqConnectDBComplete(), pqConnectDBStart(), pqConnectOptions2(), pqMakeEmptyPGconn(), recognized_connection_string(), and pg_conn::status.

PQsetErrorContextVisibility()

PGContextVisibility PQsetErrorContextVisibility	(	PGconn *	conn,
		PGContextVisibility	show_context
	)

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

{
    PGContextVisibility old;
 
    if (!conn)
        return PQSHOW_CONTEXT_ERRORS;
    old = conn->show_context;
    conn->show_context = show_context;
    return old;
}

References conn, PQSHOW_CONTEXT_ERRORS, and pg_conn::show_context.

Referenced by show_context_hook(), and SyncVariables().

PQsetErrorVerbosity()

PGVerbosity PQsetErrorVerbosity	(	PGconn *	conn,
		PGVerbosity	verbosity
	)

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

{
    PGVerbosity old;
 
    if (!conn)
        return PQERRORS_DEFAULT;
    old = conn->verbosity;
    conn->verbosity = verbosity;
    return old;
}

References conn, PQERRORS_DEFAULT, and pg_conn::verbosity.

Referenced by main(), SyncVariables(), and verbosity_hook().

PQsetnonblocking()

int PQsetnonblocking	(	PGconn *	conn,
		int	arg
	)

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

{
    bool        barg;
 
    if (!conn || conn->status == CONNECTION_BAD)
        return -1;
 
    barg = (arg ? true : false);
 
    /* early out if the socket is already in the state requested */
    if (barg == conn->nonblocking)
        return 0;
 
    /*
     * to guarantee constancy for flushing/query/result-polling behavior we
     * need to flush the send queue at this point in order to guarantee proper
     * behavior. this is ok because either they are making a transition _from_
     * or _to_ blocking mode, either way we can block them.
     *
     * Clear error state in case pqFlush adds to it, unless we're actively
     * pipelining, in which case it seems best not to.
     */
    if (conn->cmd_queue_head == NULL)
        pqClearConnErrorState(conn);
 
    /* if we are going from blocking to non-blocking flush here */
    if (pqFlush(conn))
        return -1;
 
    conn->nonblocking = barg;
 
    return 0;
}

References arg, pg_conn::cmd_queue_head, conn, CONNECTION_BAD, pg_conn::nonblocking, pqClearConnErrorState, pqFlush(), pg_conn::status, and true.

Referenced by test_cancel(), test_pipelined_insert(), and test_uniqviol().

PQsetNoticeProcessor()

PQnoticeProcessor PQsetNoticeProcessor	(	PGconn *	conn,
		PQnoticeProcessor	proc,
		void *	arg
	)

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

{
    PQnoticeProcessor old;
 
    if (conn == NULL)
        return NULL;
 
    old = conn->noticeHooks.noticeProc;
    if (proc)
    {
        conn->noticeHooks.noticeProc = proc;
        conn->noticeHooks.noticeProcArg = arg;
    }
    return old;
}

References arg, conn, pg_conn::noticeHooks, PGNoticeHooks::noticeProc, and PGNoticeHooks::noticeProcArg.

Referenced by ConnectDatabaseAhx(), do_connect(), main(), and test_pipeline_idle().

PQsetNoticeReceiver()

PQnoticeReceiver PQsetNoticeReceiver	(	PGconn *	conn,
		PQnoticeReceiver	proc,
		void *	arg
	)

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

{
    PQnoticeReceiver old;
 
    if (conn == NULL)
        return NULL;
 
    old = conn->noticeHooks.noticeRec;
    if (proc)
    {
        conn->noticeHooks.noticeRec = proc;
        conn->noticeHooks.noticeRecArg = arg;
    }
    return old;
}

References arg, conn, pg_conn::noticeHooks, PGNoticeHooks::noticeRec, and PGNoticeHooks::noticeRecArg.

Referenced by connect_pg_server(), dblink_connect(), dblink_get_conn(), ECPGconnect(), and libpqrcv_connect().

PQsetResultAttrs()

int PQsetResultAttrs	(	PGresult *	res,
		int	numAttributes,
		PGresAttDesc *	attDescs
	)

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

{
    int         i;
 
    /* Fail if argument is NULL or OOM_result */
    if (!res || (const PGresult *) res == &OOM_result)
        return false;
 
    /* If attrs already exist, they cannot be overwritten. */
    if (res->numAttributes > 0)
        return false;
 
    /* ignore no-op request */
    if (numAttributes <= 0 || !attDescs)
        return true;
 
    res->attDescs = (PGresAttDesc *)
        PQresultAlloc(res, numAttributes * sizeof(PGresAttDesc));
 
    if (!res->attDescs)
        return false;
 
    res->numAttributes = numAttributes;
    memcpy(res->attDescs, attDescs, numAttributes * sizeof(PGresAttDesc));
 
    /* deep-copy the attribute names, and determine format */
    res->binary = 1;
    for (i = 0; i < res->numAttributes; i++)
    {
        if (res->attDescs[i].name)
            res->attDescs[i].name = pqResultStrdup(res, res->attDescs[i].name);
        else
            res->attDescs[i].name = res->null_field;
 
        if (!res->attDescs[i].name)
            return false;
 
        if (res->attDescs[i].format == 0)
            res->binary = 0;
    }
 
    return true;
}

References pg_result::attDescs, pg_result::binary, pgresAttDesc::format, i, pgresAttDesc::name, pg_result::null_field, pg_result::numAttributes, OOM_result, PQresultAlloc(), and pqResultStrdup().

Referenced by PQcopyResult().

PQsetSingleRowMode()

int PQsetSingleRowMode

(

PGconn *

conn

)

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

{
    if (canChangeResultMode(conn))
    {
        conn->partialResMode = true;
        conn->singleRowMode = true;
        conn->maxChunkSize = 1;
        return 1;
    }
    else
        return 0;
}

References canChangeResultMode(), conn, pg_conn::maxChunkSize, pg_conn::partialResMode, and pg_conn::singleRowMode.

Referenced by process_queued_fetch_requests(), storeQueryResult(), test_pipeline_abort(), and test_singlerowmode().

PQsetSSLKeyPassHook_OpenSSL()

void PQsetSSLKeyPassHook_OpenSSL

(

PQsslKeyPassHook_OpenSSL_type

hook

)

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

{
    PQsslKeyPassHook = hook;
}

References PQsslKeyPassHook.

PQsetTraceFlags()

void PQsetTraceFlags	(	PGconn *	conn,
		int	flags
	)

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

{
    if (conn == NULL)
        return;
    /* If PQtrace() failed, do nothing. */
    if (conn->Pfdebug == NULL)
        return;
    conn->traceFlags = flags;
}

References conn, pg_conn::Pfdebug, and pg_conn::traceFlags.

Referenced by main().

PQsetvalue()

int PQsetvalue	(	PGresult *	res,
		int	tup_num,
		int	field_num,
		char *	value,
		int	len
	)

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

{
    PGresAttValue *attval;
    const char *errmsg = NULL;
 
    /* Fail if argument is NULL or OOM_result */
    if (!res || (const PGresult *) res == &OOM_result)
        return false;
 
    /* Invalid field_num? */
    if (!check_field_number(res, field_num))
        return false;
 
    /* Invalid tup_num, must be <= ntups */
    if (tup_num < 0 || tup_num > res->ntups)
    {
        pqInternalNotice(&res->noticeHooks,
                         "row number %d is out of range 0..%d",
                         tup_num, res->ntups);
        return false;
    }
 
    /* need to allocate a new tuple? */
    if (tup_num == res->ntups)
    {
        PGresAttValue *tup;
        int         i;
 
        tup = (PGresAttValue *)
            pqResultAlloc(res, res->numAttributes * sizeof(PGresAttValue),
                          true);
 
        if (!tup)
            goto fail;
 
        /* initialize each column to NULL */
        for (i = 0; i < res->numAttributes; i++)
        {
            tup[i].len = NULL_LEN;
            tup[i].value = res->null_field;
        }
 
        /* add it to the array */
        if (!pqAddTuple(res, tup, &errmsg))
            goto fail;
    }
 
    attval = &res->tuples[tup_num][field_num];
 
    /* treat either NULL_LEN or NULL value pointer as a NULL field */
    if (len == NULL_LEN || value == NULL)
    {
        attval->len = NULL_LEN;
        attval->value = res->null_field;
    }
    else if (len <= 0)
    {
        attval->len = 0;
        attval->value = res->null_field;
    }
    else
    {
        attval->value = (char *) pqResultAlloc(res, len + 1, true);
        if (!attval->value)
            goto fail;
        attval->len = len;
        memcpy(attval->value, value, len);
        attval->value[len] = '\0';
    }
 
    return true;
 
    /*
     * Report failure via pqInternalNotice.  If preceding code didn't provide
     * an error message, assume "out of memory" was meant.
     */
fail:
    if (!errmsg)
        errmsg = libpq_gettext("out of memory");
    pqInternalNotice(&res->noticeHooks, "%s", errmsg);
 
    return false;
}

References check_field_number(), errmsg(), i, pgresAttValue::len, len, libpq_gettext, pg_result::noticeHooks, pg_result::ntups, pg_result::null_field, NULL_LEN, pg_result::numAttributes, OOM_result, pqAddTuple(), pqInternalNotice(), pqResultAlloc(), pg_result::tuples, value, and pgresAttValue::value.

Referenced by PQcopyResult().

PQsocket()

int PQsocket

(

const PGconn *

conn

)

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

{
    if (!conn)
        return -1;
    if (conn->altsock != PGINVALID_SOCKET)
        return conn->altsock;
    return (conn->sock != PGINVALID_SOCKET) ? conn->sock : -1;
}

References pg_conn::altsock, conn, PGINVALID_SOCKET, and pg_conn::sock.

Referenced by connect_slot(), CopyStreamPoll(), libpqrcv_receive(), libpqsrv_connect_internal(), libpqsrv_get_result(), main(), pgfdw_conn_check(), pgfdw_get_cleanup_result(), postgresForeignAsyncConfigureWait(), PQcancelSocket(), StreamLogicalLog(), test_nosync(), test_pipelined_insert(), test_uniqviol(), threadRun(), try_complete_step(), wait_on_slots(), and wait_until_connected().

PQsocketPoll()

int PQsocketPoll	(	int	sock,
		int	forRead,
		int	forWrite,
		pg_usec_time_t	end_time
	)

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

{
    /* We use poll(2) if available, otherwise select(2) */
#ifdef HAVE_POLL
    struct pollfd input_fd;
    int         timeout_ms;
 
    if (!forRead && !forWrite)
        return 0;
 
    input_fd.fd = sock;
    input_fd.events = POLLERR;
    input_fd.revents = 0;
 
    if (forRead)
        input_fd.events |= POLLIN;
    if (forWrite)
        input_fd.events |= POLLOUT;
 
    /* Compute appropriate timeout interval */
    if (end_time == -1)
        timeout_ms = -1;
    else if (end_time == 0)
        timeout_ms = 0;
    else
    {
        pg_usec_time_t now = PQgetCurrentTimeUSec();
 
        if (end_time > now)
            timeout_ms = (end_time - now) / 1000;
        else
            timeout_ms = 0;
    }
 
    return poll(&input_fd, 1, timeout_ms);
#else                           /* !HAVE_POLL */
 
    fd_set      input_mask;
    fd_set      output_mask;
    fd_set      except_mask;
    struct timeval timeout;
    struct timeval *ptr_timeout;
 
    if (!forRead && !forWrite)
        return 0;
 
    FD_ZERO(&input_mask);
    FD_ZERO(&output_mask);
    FD_ZERO(&except_mask);
    if (forRead)
        FD_SET(sock, &input_mask);
 
    if (forWrite)
        FD_SET(sock, &output_mask);
    FD_SET(sock, &except_mask);
 
    /* Compute appropriate timeout interval */
    if (end_time == -1)
        ptr_timeout = NULL;
    else if (end_time == 0)
    {
        timeout.tv_sec = 0;
        timeout.tv_usec = 0;
        ptr_timeout = &timeout;
    }
    else
    {
        pg_usec_time_t now = PQgetCurrentTimeUSec();
 
        if (end_time > now)
        {
            timeout.tv_sec = (end_time - now) / 1000000;
            timeout.tv_usec = (end_time - now) % 1000000;
        }
        else
        {
            timeout.tv_sec = 0;
            timeout.tv_usec = 0;
        }
        ptr_timeout = &timeout;
    }
 
    return select(sock + 1, &input_mask, &output_mask,
                  &except_mask, ptr_timeout);
#endif                          /* HAVE_POLL */
}

References end_time, now(), PQgetCurrentTimeUSec(), and select.

Referenced by pqSocketCheck(), timer_expired(), and wait_until_connected().

PQsslAttribute()

const char * PQsslAttribute	(	PGconn *	conn,
		const char *	attribute_name
	)

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

{
    if (!conn)
    {
        /* PQsslAttribute(NULL, "library") reports the default SSL library */
        if (strcmp(attribute_name, "library") == 0)
            return "OpenSSL";
        return NULL;
    }
 
    /* All attributes read as NULL for a non-encrypted connection */
    if (conn->ssl == NULL)
        return NULL;
 
    if (strcmp(attribute_name, "library") == 0)
        return "OpenSSL";
 
    if (strcmp(attribute_name, "key_bits") == 0)
    {
        static char sslbits_str[12];
        int         sslbits;
 
        SSL_get_cipher_bits(conn->ssl, &sslbits);
        snprintf(sslbits_str, sizeof(sslbits_str), "%d", sslbits);
        return sslbits_str;
    }
 
    if (strcmp(attribute_name, "cipher") == 0)
        return SSL_get_cipher(conn->ssl);
 
    if (strcmp(attribute_name, "compression") == 0)
        return SSL_get_current_compression(conn->ssl) ? "on" : "off";
 
    if (strcmp(attribute_name, "protocol") == 0)
        return SSL_get_version(conn->ssl);
 
    if (strcmp(attribute_name, "alpn") == 0)
    {
        const unsigned char *data;
        unsigned int len;
        static char alpn_str[256];  /* alpn doesn't support longer than 255
                                     * bytes */
 
        SSL_get0_alpn_selected(conn->ssl, &data, &len);
        if (data == NULL || len == 0 || len > sizeof(alpn_str) - 1)
            return "";
        memcpy(alpn_str, data, len);
        alpn_str[len] = 0;
        return alpn_str;
    }
 
    return NULL;                /* unknown attribute */
}

References conn, data, len, and snprintf.

Referenced by exec_command_conninfo(), print_ssl_library(), and printSSLInfo().

PQsslAttributeNames()

const char *const * PQsslAttributeNames

(

PGconn *

conn

)

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

{
    static const char *const openssl_attrs[] = {
        "library",
        "key_bits",
        "cipher",
        "compression",
        "protocol",
        "alpn",
        NULL
    };
    static const char *const empty_attrs[] = {NULL};
 
    if (!conn)
    {
        /* Return attributes of default SSL library */
        return openssl_attrs;
    }
 
    /* No attrs for unencrypted connection */
    if (conn->ssl == NULL)
        return empty_attrs;
 
    return openssl_attrs;
}

References conn.

PQsslInUse()

int PQsslInUse

(

PGconn *

conn

)

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

{
    if (!conn)
        return 0;
    return conn->ssl_in_use;
}

References conn, and pg_conn::ssl_in_use.

Referenced by exec_command_conninfo(), and printSSLInfo().

PQsslStruct()

void * PQsslStruct	(	PGconn *	conn,
		const char *	struct_name
	)

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

{
    if (!conn)
        return NULL;
    if (strcmp(struct_name, "OpenSSL") == 0)
        return conn->ssl;
    return NULL;
}

References conn.

PQstatus()

ConnStatusType PQstatus

(

const PGconn *

conn

)

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

{
    if (!conn)
        return CONNECTION_BAD;
    return conn->status;
}

References conn, CONNECTION_BAD, and pg_conn::status.

Referenced by check_prepare_conn(), connect_database(), connect_pg_server(), ConnectDatabase(), connectDatabase(), ConnectionUp(), connectToServer(), copy_connection(), dblink_connect(), dblink_get_conn(), do_connect(), doConnect(), ecpg_raise_backend(), ECPGconnect(), GetConnection(), getTransactionStatus(), libpqrcv_connect(), libpqrcv_receive(), libpqsrv_connect_internal(), libpqsrv_get_result_last(), main(), pgfdw_conn_check(), pgfdw_finish_pre_commit_cleanup(), pgfdw_reset_xact_state(), PQcancelStatus(), process_query_result(), sql_conn(), start_postmaster(), test_cancel(), test_protocol_version(), and vacuumlo().

PQtrace()

void PQtrace	(	PGconn *	conn,
		FILE *	debug_port
	)

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

{
    if (conn == NULL)
        return;
    PQuntrace(conn);
    if (debug_port == NULL)
        return;
 
    conn->Pfdebug = debug_port;
    conn->traceFlags = 0;
}

References conn, pg_conn::Pfdebug, PQuntrace(), and pg_conn::traceFlags.

Referenced by main().

PQtransactionStatus()

PGTransactionStatusType PQtransactionStatus

(

const PGconn *

conn

)

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

{
    if (!conn || conn->status != CONNECTION_OK)
        return PQTRANS_UNKNOWN;
    if (conn->asyncStatus != PGASYNC_IDLE)
        return PQTRANS_ACTIVE;
    return conn->xactStatus;
}

References pg_conn::asyncStatus, conn, CONNECTION_OK, PGASYNC_IDLE, PQTRANS_ACTIVE, PQTRANS_UNKNOWN, pg_conn::status, and pg_conn::xactStatus.

Referenced by dblink_open(), DisconnectDatabase(), disconnectDatabase(), ecpg_autostart_transaction(), ECPGsetcommit(), ECPGtrans(), ECPGtransactionStatus(), get_prompt(), getTransactionStatus(), pgfdw_abort_cleanup(), pgfdw_abort_cleanup_begin(), pgfdw_reset_xact_state(), SendQuery(), start_lo_xact(), and vacuumlo().

PQtty()

char * PQtty

(

const PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
    return "";
}

References conn.

PQunescapeBytea()

unsigned char * PQunescapeBytea	(	const unsigned char *	strtext,
		size_t *	retbuflen
	)

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

{
    size_t      strtextlen,
                buflen;
    unsigned char *buffer,
               *tmpbuf;
    size_t      i,
                j;
 
    if (strtext == NULL)
        return NULL;
 
    strtextlen = strlen((const char *) strtext);
 
    if (strtext[0] == '\\' && strtext[1] == 'x')
    {
        const unsigned char *s;
        unsigned char *p;
 
        buflen = (strtextlen - 2) / 2;
        /* Avoid unportable malloc(0) */
        buffer = (unsigned char *) malloc(buflen > 0 ? buflen : 1);
        if (buffer == NULL)
            return NULL;
 
        s = strtext + 2;
        p = buffer;
        while (*s)
        {
            char        v1,
                        v2;
 
            /*
             * Bad input is silently ignored.  Note that this includes
             * whitespace between hex pairs, which is allowed by byteain.
             */
            v1 = get_hex(*s++);
            if (!*s || v1 == (char) -1)
                continue;
            v2 = get_hex(*s++);
            if (v2 != (char) -1)
                *p++ = (v1 << 4) | v2;
        }
 
        buflen = p - buffer;
    }
    else
    {
        /*
         * Length of input is max length of output, but add one to avoid
         * unportable malloc(0) if input is zero-length.
         */
        buffer = (unsigned char *) malloc(strtextlen + 1);
        if (buffer == NULL)
            return NULL;
 
        for (i = j = 0; i < strtextlen;)
        {
            switch (strtext[i])
            {
                case '\\':
                    i++;
                    if (strtext[i] == '\\')
                        buffer[j++] = strtext[i++];
                    else
                    {
                        if ((ISFIRSTOCTDIGIT(strtext[i])) &&
                            (ISOCTDIGIT(strtext[i + 1])) &&
                            (ISOCTDIGIT(strtext[i + 2])))
                        {
                            int         byte;
 
                            byte = OCTVAL(strtext[i++]);
                            byte = (byte << 3) + OCTVAL(strtext[i++]);
                            byte = (byte << 3) + OCTVAL(strtext[i++]);
                            buffer[j++] = byte;
                        }
                    }
 
                    /*
                     * Note: if we see '\' followed by something that isn't a
                     * recognized escape sequence, we loop around having done
                     * nothing except advance i.  Therefore the something will
                     * be emitted as ordinary data on the next cycle. Corner
                     * case: '\' at end of string will just be discarded.
                     */
                    break;
 
                default:
                    buffer[j++] = strtext[i++];
                    break;
            }
        }
        buflen = j;             /* buflen is the length of the dequoted data */
    }
 
    /* Shrink the buffer to be no larger than necessary */
    /* +1 avoids unportable behavior when buflen==0 */
    tmpbuf = realloc(buffer, buflen + 1);
 
    /* It would only be a very brain-dead realloc that could fail, but... */
    if (!tmpbuf)
    {
        free(buffer);
        return NULL;
    }
 
    *retbuflen = buflen;
    return tmpbuf;
}

References free, get_hex(), i, ISFIRSTOCTDIGIT, ISOCTDIGIT, j, malloc, OCTVAL, realloc, and tmpbuf.

PQuntrace()

void PQuntrace

(

PGconn *

conn

)

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

{
    if (conn == NULL)
        return;
    if (conn->Pfdebug)
    {
        fflush(conn->Pfdebug);
        conn->Pfdebug = NULL;
    }
 
    conn->traceFlags = 0;
}

References conn, pg_conn::Pfdebug, and pg_conn::traceFlags.

Referenced by PQtrace().

PQuser()

char * PQuser

(

const PGconn *

conn

)

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

{
    if (!conn)
        return NULL;
    return conn->pguser;
}

References conn, and pg_conn::pguser.

Referenced by do_connect(), exec_command_conninfo(), get_prompt(), main(), session_username(), and SyncVariables().