libpq-fe.h File Reference

#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

Macros
#define	LIBPQ_HAS_PIPELINING   1
#define	LIBPQ_HAS_TRACE_FLAGS   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"

Typedefs
typedef struct pg_conn	PGconn
typedef struct pg_result	PGresult
typedef struct pg_cancel	PGcancel
typedef struct pgNotify	PGnotify
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 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 }
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 }
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 }

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)
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	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	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)
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)
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 *string, 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)
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 *ps)
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)
pg_int64	lo_lseek64 (PGconn *conn, int fd, pg_int64 offset, int whence)
Oid	lo_creat (PGconn *conn, int mode)
Oid	lo_create (PGconn *conn, Oid lobjId)
int	lo_tell (PGconn *conn, int fd)
pg_int64	lo_tell64 (PGconn *conn, int fd)
int	lo_truncate (PGconn *conn, int fd, size_t len)
int	lo_truncate64 (PGconn *conn, int fd, pg_int64 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	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)
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_PIPELINING

#define LIBPQ_HAS_PIPELINING   1

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

LIBPQ_HAS_TRACE_FLAGS

#define LIBPQ_HAS_TRACE_FLAGS   1

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

PG_COPYRES_ATTRS

#define PG_COPYRES_ATTRS   0x01

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

Referenced by PQcopyResult(), and pqRowProcessor().

PG_COPYRES_EVENTS

#define PG_COPYRES_EVENTS   0x04

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

Referenced by PQcopyResult(), and pqRowProcessor().

PG_COPYRES_NOTICEHOOKS

#define PG_COPYRES_NOTICEHOOKS   0x08

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

Referenced by PQcopyResult(), and pqRowProcessor().

PG_COPYRES_TUPLES

#define PG_COPYRES_TUPLES   0x02 /* Implies PG_COPYRES_ATTRS */

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

Referenced by PQcopyResult().

PQ_QUERY_PARAM_MAX_LIMIT

#define PQ_QUERY_PARAM_MAX_LIMIT   65535

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

Referenced by postgresGetForeignModifyBatchSize(), PQsendPrepare(), PQsendQueryParams(), and PQsendQueryPrepared().

PQfreeNotify

#define PQfreeNotify

(

ptr

)

PQfreemem(ptr)

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

PQnoPasswordSupplied

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

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

Referenced by pg_fe_sendauth(), and pg_SASL_init().

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 293 of file libpq-fe.h.

Referenced by main().

PQTRACE_REGRESS_MODE

#define PQTRACE_REGRESS_MODE   (1<<1)

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

Referenced by main(), and pqTraceOutputMessage().

PQTRACE_SUPPRESS_TIMESTAMPS

#define PQTRACE_SUPPRESS_TIMESTAMPS   (1<<0)

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

Referenced by main(), pqTraceOutputMessage(), and pqTraceOutputNoTypeByteMessage().

Typedef Documentation

PGcancel

typedef struct pg_cancel PGcancel

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

PGconn

typedef struct pg_conn PGconn

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

PGnotify

typedef struct pgNotify PGnotify

PGresAttDesc

typedef struct pgresAttDesc PGresAttDesc

PGresult

typedef struct pg_result PGresult

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

pgthreadlock_t

typedef void(* pgthreadlock_t) (int acquire)

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

pqbool

typedef char pqbool

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

PQconninfoOption

typedef struct _PQconninfoOption PQconninfoOption

PQnoticeProcessor

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

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

PQnoticeReceiver

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

Definition at line 195 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 663 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

Definition at line 56 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,     /* Negotiating SSL. */
    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,    /* Checking target server properties. */
    CONNECTION_CHECK_STANDBY    /* Checking if server is in standby mode. */
} 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

Definition at line 92 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 */
} ExecStatusType;

PGContextVisibility

enum PGContextVisibility

Enumerator
PQSHOW_CONTEXT_NEVER
PQSHOW_CONTEXT_ERRORS
PQSHOW_CONTEXT_ALWAYS

Definition at line 131 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 143 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 154 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 114 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 123 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 82 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 awhile for backwards
                                 * compatibility */
} PostgresPollingStatusType;

Function Documentation

lo_close()

int lo_close	(	PGconn *	conn,
		int	fd
	)

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

References 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 dumpBlobs(), EndRestoreBlob(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), and pickout().

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

lo_creat()

Oid lo_creat	(	PGconn *	conn,
		int	mode
	)

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

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

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

lo_create()

Oid lo_create	(	PGconn *	conn,
		Oid	lobjId
	)

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

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

Referenced by lo_import_internal(), and StartRestoreBlob().

{
    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)
    {
        appendPQExpBuffer(&conn->errorMessage,
                          libpq_gettext("cannot determine OID of function %s\n"),
                          "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;
    }
}

lo_export()

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

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

References appendPQExpBuffer(), buf, close, pg_conn::errorMessage, fd(), INV_READ, libpq_gettext, LO_BUFSIZE, lo_close(), lo_open(), lo_read(), PG_BINARY, PG_STRERROR_R_BUFLEN, printfPQExpBuffer(), strerror_r, and write.

Referenced by do_lo_export(), and main().

{
    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 */
        printfPQExpBuffer(&conn->errorMessage,
                          libpq_gettext("could not open file \"%s\": %s\n"),
                          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 */
            printfPQExpBuffer(&conn->errorMessage,
                              libpq_gettext("could not write to file \"%s\": %s\n"),
                              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)
    {
        appendPQExpBuffer(&conn->errorMessage,
                          libpq_gettext("could not write to file \"%s\": %s\n"),
                          filename, strerror_r(errno, sebuf, sizeof(sebuf)));
        result = -1;
    }

    return result;
}

lo_import()

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

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

References InvalidOid, and lo_import_internal().

Referenced by do_lo_import(), and main().

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

lo_import_with_oid()

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

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

References lo_import_internal().

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

lo_lseek()

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

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

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

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

lo_lseek64()

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

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

References appendPQExpBuffer(), pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_lseek64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, 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().

{
    PQArgBlock  argv[3];
    PGresult   *res;
    pg_int64    retval;
    int         result_len;

    if (lo_initialize(conn) < 0)
        return -1;

    if (conn->lobjfuncs->fn_lo_lseek64 == 0)
    {
        appendPQExpBuffer(&conn->errorMessage,
                          libpq_gettext("cannot determine OID of function %s\n"),
                          "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;
    }
}

lo_open()

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

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

References 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 dumpBlobs(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), pickout(), and StartRestoreBlob().

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

lo_read()

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

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

References appendPQExpBufferStr(), pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_read, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by lo_export().

{
    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)
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             libpq_gettext("argument of lo_read exceeds integer range\n"));
        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;
    }
}

lo_tell()

int lo_tell	(	PGconn *	conn,
		int	fd
	)

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

References 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.

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

lo_tell64()

pg_int64 lo_tell64	(	PGconn *	conn,
		int	fd
	)

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

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

Referenced by pickout().

{
    pg_int64    retval;
    PQArgBlock  argv[1];
    PGresult   *res;
    int         result_len;

    if (lo_initialize(conn) < 0)
        return -1;

    if (conn->lobjfuncs->fn_lo_tell64 == 0)
    {
        appendPQExpBuffer(&conn->errorMessage,
                          libpq_gettext("cannot determine OID of function %s\n"),
                          "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;
    }
}

lo_truncate()

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

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

References appendPQExpBuffer(), appendPQExpBufferStr(), pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_truncate, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

{
    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)
    {
        appendPQExpBuffer(&conn->errorMessage,
                          libpq_gettext("cannot determine OID of function %s\n"),
                          "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)
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             libpq_gettext("argument of lo_truncate exceeds integer range\n"));
        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;
    }
}

lo_truncate64()

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

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

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

Referenced by my_truncate().

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         retval;
    int         result_len;

    if (lo_initialize(conn) < 0)
        return -1;

    if (conn->lobjfuncs->fn_lo_truncate64 == 0)
    {
        appendPQExpBuffer(&conn->errorMessage,
                          libpq_gettext("cannot determine OID of function %s\n"),
                          "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;
    }
}

lo_unlink()

int lo_unlink	(	PGconn *	conn,
		Oid	lobjId
	)

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

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

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

lo_write()

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

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

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

Referenced by lo_import_internal().

{
    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)
    {
        appendPQExpBufferStr(&conn->errorMessage,
                             libpq_gettext("argument of lo_write exceeds integer range\n"));
        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;
    }
}

pg_char_to_encoding()

int pg_char_to_encoding

(

const char *

name

)

Definition at line 550 of file encnames.c.

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

Referenced by CreateConversionCommand(), length_in_encoding(), main(), PG_char_to_encoding(), pg_convert(), pg_get_utf8_id(), pg_valid_client_encoding(), pg_valid_server_encoding(), PQenv2encoding(), pqSaveParameterStatus(), ProcessCopyOptions(), processEncodingEntry(), test_enc_conversion(), and to_ascii_encname().

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

pg_encoding_to_char()

const char* pg_encoding_to_char

(

int

encoding

)

Definition at line 588 of file encnames.c.

References Assert, pg_encname::encoding, pg_enc2name::encoding, pg_enc2name::name, and PG_VALID_ENCODING.

Referenced by _doSetFixedOutputState(), check_client_encoding(), check_encoding_locale_matches(), check_locale_and_encoding(), check_locale_encoding(), CollationCreate(), connectOptions2(), ConversionCreate(), createdb(), dumpEncoding(), exec_command_encoding(), get_collation_actual_version(), main(), pg_do_encoding_conversion(), PG_encoding_to_char(), pg_to_ascii(), PQsetClientEncoding(), SendQuery(), setup_locale_encoding(), setupDumpWorker(), SyncVariables(), test_enc_conversion(), and xml_is_document().

{
    if (PG_VALID_ENCODING(encoding))
    {
        const pg_enc2name *p = &pg_enc2name_tbl[encoding];

        Assert(encoding == p->encoding);
        return p->name;
    }
    return "";
}

pg_valid_server_encoding_id()

int pg_valid_server_encoding_id

(

int

encoding

)

Definition at line 514 of file encnames.c.

References PG_VALID_BE_ENCODING.

Referenced by setup_locale_encoding().

{
    return PG_VALID_BE_ENCODING(encoding);
}

PQbackendPID()

int PQbackendPID

(

const PGconn *

conn

)

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

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

Referenced by get_prompt(), libpqrcv_get_backend_pid(), main(), and StartLogStreamer().

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

PQbinaryTuples()

int PQbinaryTuples

(

const PGresult *

res

)

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

References pg_result::binary.

Referenced by ProcessResult().

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

PQcancel()

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

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

References pg_cancel::be_key, pg_cancel::be_pid, internal_cancel(), pg_cancel::raddr, and strlcpy().

Referenced by dblink_cancel_query(), disconnectDatabase(), DisconnectDatabase(), handle_sigint(), pgfdw_cancel_query(), setup_cancel_handler(), ShutdownWorkersHard(), sigTermHandler(), and try_complete_step().

{
    if (!cancel)
    {
        strlcpy(errbuf, "PQcancel() -- no cancel object supplied", errbufsize);
        return false;
    }

    return internal_cancel(&cancel->raddr, cancel->be_pid, cancel->be_key,
                           errbuf, errbufsize);
}

PQclear()

void PQclear

(

PGresult *

res

)

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

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

Referenced by _check_database_version(), _doSetSessionAuth(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), add_tablespace_footer(), append_depends_on_extension(), appendQualifiedRelation(), BaseBackup(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_rel_oid(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), buildShSecLabels(), check_for_data_types_usage(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_tables_with_oids(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_is_install_user(), check_loadable_libraries(), check_prepare_conn(), check_proper_datallowconn(), ClearOrSaveResult(), close_cursor(), cluster_all_databases(), compile_database_list(), compile_relation_list_one_db(), connectDatabase(), ConnectDatabase(), connectToServer(), convertTSFunction(), create_cursor(), CreateReplicationSlot(), createViewAsClause(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), dblink_res_error(), deallocate_one(), deallocate_query(), describeAccessMethods(), describeAggregates(), describeFunctions(), describeOneTableDetails(), describeOneTSConfig(), describeOneTSParser(), describeOperators(), describePublications(), DescribeQuery(), describeRoles(), describeSubscriptions(), describeTableDetails(), describeTablespaces(), describeTypes(), descriptor_free(), do_lo_import(), do_lo_list(), do_sql_command(), dropDBs(), DropReplicationSlot(), dropRoles(), dropTablespaces(), dumpAgg(), dumpBaseType(), dumpBlobs(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpDomain(), dumpEnumType(), dumpFunc(), dumpGroups(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSearchPath(), dumpSequence(), dumpSequenceData(), dumpStatisticsExt(), dumpTable(), dumpTableData_copy(), dumpTableData_insert(), dumpTableSchema(), dumpTablespaces(), dumpTSConfig(), dumpTSDictionary(), dumpUserConfig(), dumpUserMappings(), ecpg_autostart_transaction(), ecpg_check_PQresult(), ecpg_is_type_an_array(), ecpg_process_output(), ECPGdescribe(), ECPGsetcommit(), ECPGtrans(), EndDBCopyMode(), exec_command_password(), ExecQueryUsingCursor(), execute_foreign_modify(), executeCommand(), executeMaintenanceCommand(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlStatement(), executeStatement(), expand_dbname_patterns(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), fail_lo_xact(), fetch_more_data(), findLastBuiltinOid_V71(), finish_lo_xact(), get_create_object_cmd(), get_db_infos(), get_language_name(), get_loadable_libraries(), get_next_possible_free_pg_type_oid(), get_parallel_object_list(), get_rel_infos(), get_remote_estimate(), get_returning_data(), get_synchronized_snapshot(), get_tablespace_paths(), getAccessMethods(), getAggregates(), getBlobs(), getCasts(), getCollations(), GetConnection(), getConstraints(), getConversions(), getCopyStart(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFormattedTypeName(), getFuncs(), getIndexes(), getInherits(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getParamDescriptions(), getPolicies(), getProcLangs(), getPublications(), getPublicationTables(), getRowDescriptions(), getRules(), getSubscriptions(), getTableAttrs(), GetTableInfo(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), handleCopyIn(), HandleEndOfCopyStream(), init_libpq_conn(), initGenerateDataClientSide(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_PQexec(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_startstreaming(), listAllDbs(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtendedStats(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listOneExtensionContents(), listOperatorClasses(), listOperatorFamilies(), listOpFamilyFunctions(), listOpFamilyOperators(), listPartitionedTables(), listPublications(), listSchemas(), listTables(), listTSConfigs(), listTSConfigsVerbose(), listTSDictionaries(), listTSParsers(), listTSParsersVerbose(), listTSTemplates(), listUserMappings(), lo_close(), lo_creat(), lo_create(), lo_initialize(), lo_lseek(), lo_lseek64(), lo_open(), lo_read(), lo_tell(), lo_tell64(), lo_truncate(), lo_truncate64(), lo_unlink(), lo_write(), lockTableForWorker(), lookup_object_oid(), main(), materializeResult(), new_9_0_populate_pg_largeobject_metadata(), objectDescription(), old_9_6_invalidate_hash_indexes(), permissionsList(), pg_attribute_noreturn(), pgfdw_cancel_query(), pgfdw_exec_cleanup_query(), pgfdw_get_cleanup_result(), pgfdw_get_result(), pgfdw_report_error(), pgfdw_xact_callback(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresEndDirectModify(), postgresImportForeignSchema(), postgresReScanForeignScan(), pqClearAsyncResult(), PQconnectPoll(), PQcopyResult(), PQencryptPasswordConn(), pqEndcopy3(), PQexecFinish(), PQexecStart(), pqGetErrorNotice3(), pqInternalNotice(), PQmakeEmptyPGresult(), pqRowProcessor(), PQsetClientEncoding(), prepare_common(), prepare_foreign_modify(), process_queued_fetch_requests(), process_result(), processExtensionTables(), processQueryResult(), ProcessResult(), PSQLexecWatch(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), reindex_all_databases(), report_extension_updates(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), sendCommand(), SendQuery(), set_frozenxids(), setup_connection(), sql_conn(), sql_exec(), start_lo_xact(), store_returning_result(), storeQueryResult(), StreamLogicalLog(), TableCommandResultHandler(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), try_complete_step(), tryExecuteStatement(), vacuum_all_databases(), vacuum_one_database(), and vacuumlo().

{
    PGresult_data *block;
    int         i;

    if (!res)
        return;

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

    if (res->events)
        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 */
    if (res->tuples)
        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);
}

PQclientEncoding()

int PQclientEncoding

(

const PGconn *

conn

)

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

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

Referenced by appendQualifiedRelation(), appendStringLiteralConn(), dblink_connect(), dblink_get_conn(), exec_command_encoding(), main(), processSQLNamePattern(), SendQuery(), setup_connection(), SyncVariables(), and vacuum_one_database().

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

PQcmdStatus()

char* PQcmdStatus

(

PGresult *

res

)

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

References pg_result::cmdStatus.

Referenced by dblink_exec(), ecpg_process_output(), materializeResult(), PrintQueryResults(), PrintQueryStatus(), PSQLexecWatch(), SendQuery(), and test_pipelined_insert().

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

PQcmdTuples()

char* PQcmdTuples

(

PGresult *

res

)

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

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

Referenced by ecpg_process_output(), execute_dml_stmt(), execute_foreign_modify(), and SetResultVariables().

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

PQconndefaults()

PQconninfoOption* PQconndefaults

(

void

)

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

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

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

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

PQconnectdb()

PGconn* PQconnectdb

(

const char *

conninfo

)

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

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

Referenced by dblink_connect(), dblink_get_conn(), get_db_conn(), and main().

{
    PGconn     *conn = PQconnectStart(conninfo);

    if (conn && conn->status != CONNECTION_BAD)
        (void) connectDBComplete(conn);

    return conn;
}

PQconnectdbParams()

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

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

References conn, connectDBComplete(), CONNECTION_BAD, PQconnectStartParams(), and pg_conn::status.

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

{
    PGconn     *conn = PQconnectStartParams(keywords, values, expand_dbname);

    if (conn && conn->status != CONNECTION_BAD)
        (void) connectDBComplete(conn);

    return conn;

}

PQconnectionNeedsPassword()

int PQconnectionNeedsPassword

(

const PGconn *

conn

)

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

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

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

{
    char       *password;

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

PQconnectionUsedPassword()

int PQconnectionUsedPassword

(

const PGconn *

conn

)

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

References pg_conn::password_needed.

Referenced by connect_pg_server(), ConnectDatabase(), and dblink_security_check().

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

PQconnectPoll()

PostgresPollingStatusType PQconnectPoll

(

PGconn *

conn

)

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

References SockAddr::addr, pg_conn::addr_cur, pg_conn::addrlist, pg_conn::addrlist_family, addrinfo::ai_addr, addrinfo::ai_addrlen, addrinfo::ai_family, addrinfo::ai_flags, addrinfo::ai_next, AI_NUMERICHOST, addrinfo::ai_socktype, appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), pg_conn::appname, Assert, pg_conn::asyncStatus, AUTH_REQ_OK, pg_conn::auth_req_received, CHT_HOST_ADDRESS, CHT_HOST_NAME, CHT_UNIX_SOCKET, connect, connectFailureMessage(), CONNECTION_AUTH_OK, CONNECTION_AWAITING_RESPONSE, CONNECTION_BAD, CONNECTION_CHECK_STANDBY, CONNECTION_CHECK_TARGET, CONNECTION_CHECK_WRITABLE, CONNECTION_CONSUME, CONNECTION_GSS_STARTUP, CONNECTION_MADE, CONNECTION_NEEDED, CONNECTION_OK, CONNECTION_SSL_STARTUP, CONNECTION_STARTED, connectNoDelay(), pg_conn::connhost, pg_conn::connip, PQExpBufferData::data, pg_conn::default_transaction_read_only, EINPROGRESS, EINTR, emitHostIdentityInfo(), ERRCODE_APPNAME_UNKNOWN, ERRCODE_CANNOT_CONNECT_NOW, pg_conn::errorMessage, EWOULDBLOCK, pg_conn::fbappname, free, gai_strerror, getHostaddr(), getpeereid(), pg_conn::gssencmode, pg_conn_host::host, pg_conn_host::hostaddr, pg_conn::in_hot_standby, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, IS_AF_UNIX, pg_conn::laddr, pg_conn::last_sqlstate, PQExpBufferData::len, libpq_gettext, MAXPGPATH, MemSet, pg_conn::nconnhost, NEGOTIATE_GSS_CODE, NEGOTIATE_SSL_CODE, NI_MAXHOST, parse_int_param(), PG_BOOL_NO, PG_BOOL_UNKNOWN, PG_BOOL_YES, PG_DIAG_SQLSTATE, pg_fe_sendauth(), pg_getaddrinfo_all(), pg_GSS_have_cred_cache(), pg_hton32, PG_PROTOCOL, 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, PQ_PIPELINE_OFF, pqBuildStartupPacket3(), pqCheckInBufferSpace(), PQclear(), pqClearAsyncResult(), PQconsumeInput(), pqDropConnection(), pqDropServerData(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetpwuid(), PQgetResult(), pqGets_append(), PQgetvalue(), PQisBusy(), PQntuples(), pqPacketSend(), pqReadData(), PQresultErrorField(), PQresultStatus(), pqsecure_initialize(), pqsecure_open_client(), pqsecure_open_gss(), PQsendQueryContinue(), PQTRANS_IDLE, pg_conn::pversion, pg_conn::raddr, release_conn_addrinfo(), pg_conn::requirepeer, resetPQExpBuffer(), pg_result::resultStatus, SockAddr::salen, 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::sslmode, pg_conn::status, STATUS_OK, 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(), _internalPQconninfoOption::val, pg_conn::whichhost, and pg_conn::xactStatus.

Referenced by connectDBComplete(), connectDBStart(), libpqrcv_connect(), and PQresetPoll().

{
    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:
            break;

        default:
            appendPQExpBufferStr(&conn->errorMessage,
                                 libpq_gettext("invalid connection state, probably indicative of memory corruption\n"));
            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->addr_cur && conn->addr_cur->ai_next)
        {
            conn->addr_cur = conn->addr_cur->ai_next;
            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;
        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.
             *
             * 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->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;
        conn->addrlist_family = 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 (!parse_int_param(ch->port, &thisport, conn, "port"))
                goto error_return;

            if (thisport < 1 || thisport > 65535)
            {
                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("invalid port number: \"%s\"\n"),
                                  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,
                                         &conn->addrlist);
                if (ret || !conn->addrlist)
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("could not translate host name \"%s\" to address: %s\n"),
                                      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,
                                         &conn->addrlist);
                if (ret || !conn->addrlist)
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("could not parse network address \"%s\": %s\n"),
                                      ch->hostaddr, gai_strerror(ret));
                    goto keep_going;
                }
                break;

            case CHT_UNIX_SOCKET:
#ifdef HAVE_UNIX_SOCKETS
                conn->addrlist_family = hint.ai_family = AF_UNIX;
                UNIXSOCK_PATH(portstr, thisport, ch->host);
                if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("Unix-domain socket path \"%s\" is too long (maximum %d bytes)\n"),
                                      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,
                                         &conn->addrlist);
                if (ret || !conn->addrlist)
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("could not translate Unix-domain socket path \"%s\" to address: %s\n"),
                                      portstr, gai_strerror(ret));
                    goto keep_going;
                }
#else
                Assert(false);
#endif
                break;
        }

        /* OK, scan this addrlist for a working server address */
        conn->addr_cur = conn->addrlist;
        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 = PG_PROTOCOL(3, 0);
        conn->send_appname = true;
#ifdef USE_SSL
        /* initialize these values based on SSL mode */
        conn->allow_ssl_try = (conn->sslmode[0] != 'd');    /* "disable" */
        conn->wait_ssl_try = (conn->sslmode[0] == 'a'); /* "allow" */
#endif
#ifdef ENABLE_GSS
        conn->try_gss = (conn->gssencmode[0] != 'd');   /* "disable" */
#endif

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

    /* 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->addr_cur 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.
                 */
                {
                    struct addrinfo *addr_cur = conn->addr_cur;
                    char        host_addr[NI_MAXHOST];

                    /*
                     * Advance to next possible host, if we've tried all of
                     * the addresses for the current host.
                     */
                    if (addr_cur == NULL)
                    {
                        conn->try_next_host = true;
                        goto keep_going;
                    }

                    /* Remember current address for possible use later */
                    memcpy(&conn->raddr.addr, addr_cur->ai_addr,
                           addr_cur->ai_addrlen);
                    conn->raddr.salen = addr_cur->ai_addrlen;

                    /*
                     * 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 */
                    conn->sock = socket(addr_cur->ai_family, SOCK_STREAM, 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 (addr_cur->ai_next != NULL ||
                            conn->whichhost + 1 < conn->nconnhost)
                        {
                            conn->try_next_addr = true;
                            goto keep_going;
                        }
                        emitHostIdentityInfo(conn, host_addr);
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("could not create socket: %s\n"),
                                          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 (!IS_AF_UNIX(addr_cur->ai_family))
                    {
                        if (!connectNoDelay(conn))
                        {
                            /* error message already created */
                            conn->try_next_addr = true;
                            goto keep_going;
                        }
                    }
                    if (!pg_set_noblock(conn->sock))
                    {
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("could not set socket to nonblocking mode: %s\n"),
                                          SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        conn->try_next_addr = true;
                        goto keep_going;
                    }

#ifdef F_SETFD
                    if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
                    {
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("could not set socket to close-on-exec mode: %s\n"),
                                          SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        conn->try_next_addr = true;
                        goto keep_going;
                    }
#endif                          /* F_SETFD */

                    if (!IS_AF_UNIX(addr_cur->ai_family))
                    {
#ifndef WIN32
                        int         on = 1;
#endif
                        int         usekeepalives = useKeepalives(conn);
                        int         err = 0;

                        if (usekeepalives < 0)
                        {
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("keepalives parameter must be an integer\n"));
                            err = 1;
                        }
                        else if (usekeepalives == 0)
                        {
                            /* Do nothing */
                        }
#ifndef WIN32
                        else if (setsockopt(conn->sock,
                                            SOL_SOCKET, SO_KEEPALIVE,
                                            (char *) &on, sizeof(on)) < 0)
                        {
                            appendPQExpBuffer(&conn->errorMessage,
                                              libpq_gettext("%s(%s) failed: %s\n"),
                                              "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 (!setKeepalivesWin32(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, addr_cur->ai_addr,
                                addr_cur->ai_addrlen) < 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:
            {
                ACCEPT_TYPE_ARG3 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)
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("could not get socket error status: %s\n"),
                                      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)
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("could not get client address from socket: %s\n"),
                                      SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                    goto error_return;
                }

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

                /*
                 * Implement requirepeer check, if requested and it's a
                 * Unix-domain socket.
                 */
                if (conn->requirepeer && conn->requirepeer[0] &&
                    IS_AF_UNIX(conn->raddr.addr.ss_family))
                {
#ifndef WIN32
                    char        pwdbuf[BUFSIZ];
                    struct passwd pass_buf;
                    struct passwd *pass;
                    int         passerr;
#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)
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("requirepeer parameter is not supported on this platform\n"));
                        else
                            appendPQExpBuffer(&conn->errorMessage,
                                              libpq_gettext("could not get peer credentials: %s\n"),
                                              strerror_r(errno, sebuf, sizeof(sebuf)));
                        goto error_return;
                    }

#ifndef WIN32
                    passerr = pqGetpwuid(uid, &pass_buf, pwdbuf, sizeof(pwdbuf), &pass);
                    if (pass == NULL)
                    {
                        if (passerr != 0)
                            appendPQExpBuffer(&conn->errorMessage,
                                              libpq_gettext("could not look up local user ID %d: %s\n"),
                                              (int) uid,
                                              strerror_r(passerr, sebuf, sizeof(sebuf)));
                        else
                            appendPQExpBuffer(&conn->errorMessage,
                                              libpq_gettext("local user with ID %d does not exist\n"),
                                              (int) uid);
                        goto error_return;
                    }

                    if (strcmp(pass->pw_name, conn->requirepeer) != 0)
                    {
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n"),
                                          conn->requirepeer, pass->pw_name);
                        goto error_return;
                    }
#else                           /* WIN32 */
                    /* should have failed with ENOSYS above */
                    Assert(false);
#endif                          /* WIN32 */
                }

                if (IS_AF_UNIX(conn->raddr.addr.ss_family))
                {
                    /* Don't request SSL or GSSAPI over Unix sockets */
#ifdef USE_SSL
                    conn->allow_ssl_try = false;
#endif
#ifdef ENABLE_GSS
                    conn->try_gss = false;
#endif
                }

#ifdef ENABLE_GSS

                /*
                 * If GSSAPI encryption is enabled, then call
                 * pg_GSS_have_cred_cache() which will return true if we can
                 * acquire credentials (and give us a handle to use in
                 * conn->gcred), and then send a packet to the server asking
                 * for GSSAPI Encryption (and skip past SSL negotiation and
                 * regular startup below).
                 */
                if (conn->try_gss && !conn->gctx)
                    conn->try_gss = pg_GSS_have_cred_cache(&conn->gcred);
                if (conn->try_gss && !conn->gctx)
                {
                    ProtocolVersion pv = pg_hton32(NEGOTIATE_GSS_CODE);

                    if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                    {
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("could not send GSSAPI negotiation packet: %s\n"),
                                          SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        goto error_return;
                    }

                    /* Ok, wait for response */
                    conn->status = CONNECTION_GSS_STARTUP;
                    return PGRES_POLLING_READING;
                }
                else if (!conn->gctx && conn->gssencmode[0] == 'r')
                {
                    appendPQExpBufferStr(&conn->errorMessage,
                                         libpq_gettext("GSSAPI encryption required but was impossible (possibly no credential cache, no server support, or using a local socket)\n"));
                    goto error_return;
                }
#endif

#ifdef USE_SSL

                /*
                 * Enable the libcrypto callbacks before checking if SSL needs
                 * to be done.  This is done before sending the startup packet
                 * as depending on the type of authentication done, like MD5
                 * or SCRAM that use cryptohashes, the callbacks would be
                 * required even without a SSL connection
                 */
                if (pqsecure_initialize(conn, false, true) < 0)
                    goto error_return;

                /*
                 * If SSL is enabled and we haven't already got encryption of
                 * some sort running, request SSL instead of sending the
                 * startup message.
                 */
                if (conn->allow_ssl_try && !conn->wait_ssl_try &&
                    !conn->ssl_in_use
#ifdef ENABLE_GSS
                    && !conn->gssenc
#endif
                    )
                {
                    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)
                    {
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("could not send SSL negotiation packet: %s\n"),
                                          SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                        goto error_return;
                    }
                    /* Ok, wait for response */
                    conn->status = CONNECTION_SSL_STARTUP;
                    return PGRES_POLLING_READING;
                }
#endif                          /* USE_SSL */

                /*
                 * Build the startup packet.
                 */
                startpacket = pqBuildStartupPacket3(conn, &packetlen,
                                                    EnvironmentOptions);
                if (!startpacket)
                {
                    appendPQExpBufferStr(&conn->errorMessage,
                                         libpq_gettext("out of memory\n"));
                    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)
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("could not send startup packet: %s\n"),
                                      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, get the postmaster's response to our
                 * SSL negotiation packet.
                 */
                if (!conn->ssl_in_use)
                {
                    /*
                     * 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')
                    {
                        /* mark byte consumed */
                        conn->inStart = conn->inCursor;

                        /*
                         * Set up global SSL state if required.  The crypto
                         * state has already been set if libpq took care of
                         * doing that, so there is no need to make that happen
                         * again.
                         */
                        if (pqsecure_initialize(conn, true, false) != 0)
                            goto error_return;
                    }
                    else if (SSLok == 'N')
                    {
                        /* mark byte consumed */
                        conn->inStart = conn->inCursor;
                        /* OK to do without SSL? */
                        if (conn->sslmode[0] == 'r' ||  /* "require" */
                            conn->sslmode[0] == 'v')    /* "verify-ca" or
                                                         * "verify-full" */
                        {
                            /* Require SSL, but server does not want it */
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("server does not support SSL, but SSL was required\n"));
                            goto error_return;
                        }
                        /* Otherwise, proceed with normal startup */
                        conn->allow_ssl_try = false;
                        /* We can proceed using this connection */
                        conn->status = CONNECTION_MADE;
                        return PGRES_POLLING_WRITING;
                    }
                    else if (SSLok == 'E')
                    {
                        /*
                         * Server failure of some sort, such as failure to
                         * fork a backend process.  We need to process and
                         * report the error message, which might be formatted
                         * according to either protocol 2 or protocol 3.
                         * Rather than duplicate the code for that, we flip
                         * into AWAITING_RESPONSE state and let the code there
                         * deal with it.  Note we have *not* consumed the "E"
                         * byte here.
                         */
                        conn->status = CONNECTION_AWAITING_RESPONSE;
                        goto keep_going;
                    }
                    else
                    {
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("received invalid response to SSL negotiation: %c\n"),
                                          SSLok);
                        goto error_return;
                    }
                }

                /*
                 * Begin or continue the SSL negotiation process.
                 */
                pollres = pqsecure_open_client(conn);
                if (pollres == PGRES_POLLING_OK)
                {
                    /* SSL handshake done, ready to send startup packet */
                    conn->status = CONNECTION_MADE;
                    return PGRES_POLLING_WRITING;
                }
                if (pollres == PGRES_POLLING_FAILED)
                {
                    /*
                     * Failed ... if sslmode is "prefer" then do a non-SSL
                     * retry
                     */
                    if (conn->sslmode[0] == 'p' /* "prefer" */
                        && conn->allow_ssl_try  /* redundant? */
                        && !conn->wait_ssl_try) /* redundant? */
                    {
                        /* only retry once */
                        conn->allow_ssl_try = false;
                        need_new_connection = true;
                        goto keep_going;
                    }
                    /* Else it's a hard failure */
                    goto error_return;
                }
                /* 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->try_gss && !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.  Assume it's a
                         * protocol version support failure, and let's see if
                         * we can't recover (if it's not, we'll get a better
                         * error message on retry).  Server gets fussy if we
                         * don't hang up the socket, though.
                         */
                        conn->try_gss = false;
                        need_new_connection = true;
                        goto keep_going;
                    }

                    /* mark byte consumed */
                    conn->inStart = conn->inCursor;

                    if (gss_ok == 'N')
                    {
                        /* Server doesn't want GSSAPI; fall back if we can */
                        if (conn->gssencmode[0] == 'r')
                        {
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("server doesn't support GSSAPI encryption, but it was required\n"));
                            goto error_return;
                        }

                        conn->try_gss = false;
                        /* We can proceed using this connection */
                        conn->status = CONNECTION_MADE;
                        return PGRES_POLLING_WRITING;
                    }
                    else if (gss_ok != 'G')
                    {
                        appendPQExpBuffer(&conn->errorMessage,
                                          libpq_gettext("received invalid response to GSSAPI negotiation: %c\n"),
                                          gss_ok);
                        goto error_return;
                    }
                }

                /* Begin or continue GSSAPI negotiation */
                pollres = pqsecure_open_gss(conn);
                if (pollres == PGRES_POLLING_OK)
                {
                    /* All set for startup packet */
                    conn->status = CONNECTION_MADE;
                    return PGRES_POLLING_WRITING;
                }
                else if (pollres == PGRES_POLLING_FAILED &&
                         conn->gssencmode[0] == 'p')
                {
                    /*
                     * We failed, but we can retry on "prefer".  Have to drop
                     * the current connection to do so, though.
                     */
                    conn->try_gss = false;
                    need_new_connection = true;
                    goto keep_going;
                }
                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;

                /*
                 * 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 or an error here.  Anything else probably means
                 * it's not Postgres on the other end at all.
                 */
                if (!(beresp == 'R' || beresp == 'E'))
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("expected authentication request from server, but received %c\n"),
                                      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.  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 == 'R' && (msgLength < 8 || msgLength > 2000))
                {
                    appendPQExpBuffer(&conn->errorMessage,
                                      libpq_gettext("expected authentication request from server, but received %c\n"),
                                      beresp);
                    goto error_return;
                }

                if (beresp == 'E' && (msgLength < 8 || msgLength > 30000))
                {
                    /* Handle error from a pre-3.0 server */
                    conn->inCursor = conn->inStart + 1; /* reread data */
                    if (pqGets_append(&conn->errorMessage, conn))
                    {
                        /* We'll come back when there is more data */
                        return PGRES_POLLING_READING;
                    }
                    /* OK, we read the message; mark data consumed */
                    conn->inStart = 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;
                }

                /*
                 * Can't process if message body isn't all here yet.
                 */
                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 == 'E')
                {
                    if (pqGetErrorNotice3(conn, true))
                    {
                        /* We'll come back when there is more data */
                        return PGRES_POLLING_READING;
                    }
                    /* OK, we read the message; mark data consumed */
                    conn->inStart = 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);

#ifdef ENABLE_GSS

                    /*
                     * If gssencmode is "prefer" and we're using GSSAPI, retry
                     * without it.
                     */
                    if (conn->gssenc && conn->gssencmode[0] == 'p')
                    {
                        /* only retry once */
                        conn->try_gss = false;
                        need_new_connection = true;
                        goto keep_going;
                    }
#endif

#ifdef USE_SSL

                    /*
                     * if sslmode is "allow" and we haven't tried an SSL
                     * connection already, then retry with an SSL connection
                     */
                    if (conn->sslmode[0] == 'a' /* "allow" */
                        && !conn->ssl_in_use
                        && conn->allow_ssl_try
                        && conn->wait_ssl_try)
                    {
                        /* only retry once */
                        conn->wait_ssl_try = false;
                        need_new_connection = true;
                        goto keep_going;
                    }

                    /*
                     * if sslmode is "prefer" and we're in an SSL connection,
                     * then do a non-SSL retry
                     */
                    if (conn->sslmode[0] == 'p' /* "prefer" */
                        && conn->ssl_in_use
                        && conn->allow_ssl_try  /* redundant? */
                        && !conn->wait_ssl_try) /* redundant? */
                    {
                        /* only retry once */
                        conn->allow_ssl_try = false;
                        need_new_connection = true;
                        goto keep_going;
                    }
#endif

                    goto error_return;
                }

                /* It is an authentication request. */
                conn->auth_req_received = true;

                /* Get the type of request. */
                if (pqGetInt((int *) &areq, 4, conn))
                {
                    /* We'll come back when there are more data */
                    return PGRES_POLLING_READING;
                }
                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);

                /* OK, we have processed the message; mark data consumed */
                conn->inStart = conn->inCursor;

                if (res != STATUS_OK)
                    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_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)
                        appendPQExpBufferStr(&conn->errorMessage,
                                             libpq_gettext("unexpected message from server during startup\n"));
                    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)
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("session is read-only\n"));
                        else
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("session is not read-only\n"));

                        /* 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)
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("server is in hot standby mode\n"));
                        else
                            appendPQExpBufferStr(&conn->errorMessage,
                                                 libpq_gettext("server is not in hot standby mode\n"));

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

                /* We can release the address list now. */
                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).
                 */
                resetPQExpBuffer(&conn->errorMessage);

                /* 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". */
                if (res)
                    PQclear(res);

                /* Append error report to conn->errorMessage. */
                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("\"%s\" failed\n"),
                                  "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()". */
                if (res)
                    PQclear(res);

                /* Append error report to conn->errorMessage. */
                appendPQExpBuffer(&conn->errorMessage,
                                  libpq_gettext("\"%s\" failed\n"),
                                  "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:
            appendPQExpBuffer(&conn->errorMessage,
                              libpq_gettext("invalid connection state %d, "
                                            "probably indicative of memory corruption\n"),
                              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;
}

PQconnectStart()

PGconn* PQconnectStart

(

const char *

conninfo

)

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

References conn, connectDBStart(), CONNECTION_BAD, connectOptions1(), connectOptions2(), makeEmptyPGconn(), and pg_conn::status.

Referenced by PQconnectdb(), and PQping().

{
    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 = makeEmptyPGconn();
    if (conn == NULL)
        return NULL;

    /*
     * Parse the conninfo string
     */
    if (!connectOptions1(conn, conninfo))
        return conn;

    /*
     * Compute derived options
     */
    if (!connectOptions2(conn))
        return conn;

    /*
     * Connect to the database
     */
    if (!connectDBStart(conn))
    {
        /* Just in case we failed to set it in connectDBStart */
        conn->status = CONNECTION_BAD;
    }

    return conn;
}

PQconnectStartParams()

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

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

References conn, connectDBStart(), CONNECTION_BAD, connectOptions2(), conninfo_array_parse(), pg_conn::errorMessage, fillPGconn(), makeEmptyPGconn(), PQconninfoFree(), and pg_conn::status.

Referenced by libpqrcv_connect(), PQconnectdbParams(), and PQpingParams().

{
    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 = makeEmptyPGconn();
    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 (!connectOptions2(conn))
        return conn;

    /*
     * Connect to the database
     */
    if (!connectDBStart(conn))
    {
        /* Just in case we failed to set it in connectDBStart */
        conn->status = CONNECTION_BAD;
    }

    return conn;
}

PQconninfo()

PQconninfoOption* PQconninfo

(

PGconn *

conn

)

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

References conninfo_init(), conninfo_storeval(), _internalPQconninfoOption::connofs, initPQExpBuffer(), _internalPQconninfoOption::keyword, PQExpBufferDataBroken, and termPQExpBuffer().

Referenced by do_connect(), GenerateRecoveryConfig(), and libpqrcv_get_conninfo().

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

PQconninfoFree()

void PQconninfoFree

(

PQconninfoOption *

connOptions

)

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

References free, _PQconninfoOption::keyword, and _PQconninfoOption::val.

Referenced by check_pghost_envvar(), connectDatabase(), connectOptions1(), conninfo_array_parse(), conninfo_parse(), conninfo_uri_parse(), dblink_connstr_check(), do_connect(), GenerateRecoveryConfig(), GetConnection(), libpqrcv_check_conninfo(), libpqrcv_get_conninfo(), PQconndefaults(), and PQconnectStartParams().

{
    PQconninfoOption *option;

    if (connOptions == NULL)
        return;

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

PQconninfoParse()

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

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

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

Referenced by connectDatabase(), dblink_connstr_check(), do_connect(), GetConnection(), libpqrcv_check_conninfo(), and main().

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

PQconsumeInput()

int PQconsumeInput

(

PGconn *

conn

)

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

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

Referenced by advanceConnectionState(), CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), ecpg_process_output(), libpqrcv_PQgetResult(), libpqrcv_receive(), main(), pgfdw_get_cleanup_result(), pgfdw_get_result(), postgresForeignAsyncNotify(), PQconnectPoll(), PrintNotifications(), StreamLogicalLog(), test_nosync(), test_pipelined_insert(), test_uniqviol(), try_complete_step(), and wait_on_slots().

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

PQcopyResult()

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

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

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

Referenced by pqRowProcessor().

{
    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++)
    {
        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))
            {
                PQclear(dest);
                return NULL;
            }
            dest->events[i].resultInitialized = true;
        }
    }

    return dest;
}

PQdb()

char* PQdb

(

const PGconn *

conn

)

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

References 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(), reindex_one_database(), run_command(), run_reindex_command(), run_vacuum_command(), slashUsage(), SyncVariables(), TableCommandResultHandler(), vacuum_one_database(), and WriteHead().

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

PQdefaultSSLKeyPassHook_OpenSSL()

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

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

References fprintf, libpq_gettext, and pg_conn::sslpassword.

Referenced by PQssl_passwd_cb().

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

PQdescribePortal()

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

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

References PQexecFinish(), PQexecStart(), and PQsendDescribe().

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

PQdescribePrepared()

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

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

References PQexecFinish(), PQexecStart(), and PQsendDescribe().

Referenced by DescribeQuery(), and ECPGdescribe().

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

PQdisplayTuples()

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

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

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

{
#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);

    if (fLength)
        free(fLength);
}

PQdsplen()

int PQdsplen	(	const char *	s,
		int	encoding
	)

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

References pg_encoding_dsplen().

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

{
    return pg_encoding_dsplen(encoding, s);
}

PQencryptPassword()

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

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

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

{
    char       *crypt_pwd;

    crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
    if (!crypt_pwd)
        return NULL;

    if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd))
    {
        free(crypt_pwd);
        return NULL;
    }

    return crypt_pwd;
}