#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:

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	LIBPQ_HAS_SSL_LIBRARY_DETECTION 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 buffer, int length)

int	PQputline (PGconn conn, const char string)

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

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

int	PQendcopy (PGconn *conn)

int	PQsetnonblocking (PGconn *conn, int arg)

int	PQisnonblocking (const PGconn *conn)

int	PQisthreadsafe (void)

PGPing	PQping (const char *conninfo)

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

int	PQflush (PGconn *conn)

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

ExecStatusType	PQresultStatus (const PGresult *res)

char *	PQresStatus (ExecStatusType status)

char *	PQresultErrorMessage (const PGresult *res)

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

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

int	PQntuples (const PGresult *res)

int	PQnfields (const PGresult *res)

int	PQbinaryTuples (const PGresult *res)

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

int	PQfnumber (const PGresult res, const char field_name)

Oid	PQftable (const PGresult *res, int field_num)

int	PQftablecol (const PGresult *res, int field_num)

int	PQfformat (const PGresult *res, int field_num)

Oid	PQftype (const PGresult *res, int field_num)

int	PQfsize (const PGresult *res, int field_num)

int	PQfmod (const PGresult *res, int field_num)

char *	PQcmdStatus (PGresult *res)

char *	PQoidStatus (const PGresult *res)

Oid	PQoidValue (const PGresult *res)

char *	PQcmdTuples (PGresult *res)

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

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

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

int	PQnparams (const PGresult *res)

Oid	PQparamtype (const PGresult *res, int param_num)

PGresult *	PQdescribePrepared (PGconn conn, const char stmt)

PGresult *	PQdescribePortal (PGconn conn, const char portal)

int	PQsendDescribePrepared (PGconn conn, const char stmt)

int	PQsendDescribePortal (PGconn conn, const char portal)

void	PQclear (PGresult *res)

void	PQfreemem (void *ptr)

PGresult *	PQmakeEmptyPGresult (PGconn *conn, ExecStatusType status)

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

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

void *	PQresultAlloc (PGresult *res, size_t nBytes)

size_t	PQresultMemorySize (const PGresult *res)

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

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

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

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

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

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

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

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

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

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

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

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

int	lo_close (PGconn *conn, int fd)

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

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

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

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_SSL_LIBRARY_DETECTION

#define LIBPQ_HAS_SSL_LIBRARY_DETECTION 1

Definition at line 40 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 45 of file libpq-fe.h.

◆ PG_COPYRES_EVENTS

#define PG_COPYRES_EVENTS 0x04

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

◆ PG_COPYRES_NOTICEHOOKS

#define PG_COPYRES_NOTICEHOOKS 0x08

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

◆ PG_COPYRES_TUPLES

#define PG_COPYRES_TUPLES 0x02 /* Implies PG_COPYRES_ATTRS */

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

◆ PQ_QUERY_PARAM_MAX_LIMIT

#define PQ_QUERY_PARAM_MAX_LIMIT 65535

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

◆ PQfreeNotify

#define PQfreeNotify ( ptr ) PQfreemem(ptr)

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

◆ PQnoPasswordSupplied

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

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

◆ PQsetdb

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

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

◆ PQTRACE_REGRESS_MODE

#define PQTRACE_REGRESS_MODE (1<<1)

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

◆ PQTRACE_SUPPRESS_TIMESTAMPS

#define PQTRACE_SUPPRESS_TIMESTAMPS (1<<0)

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

Typedef Documentation

◆ PGcancel

typedef struct pg_cancel PGcancel

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

◆ PGconn

typedef struct pg_conn PGconn

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

◆ PGnotify

typedef struct pgNotify PGnotify

◆ PGresAttDesc

typedef struct pgresAttDesc PGresAttDesc

◆ PGresult

typedef struct pg_result PGresult

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

◆ pgthreadlock_t

typedef void(* pgthreadlock_t) (int acquire)

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

◆ pqbool

typedef char pqbool

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

◆ PQconninfoOption

typedef struct _PQconninfoOption PQconninfoOption

◆ PQnoticeProcessor

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

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

◆ PQnoticeReceiver

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

Definition at line 197 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 665 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 58 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 94 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 133 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 145 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 156 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 116 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 125 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 84 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.

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

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

Referenced by dumpBlobs(), EndRestoreBlob(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), and pickout().

◆ lo_creat()

Oid lo_creat	(	PGconn *	conn,
		int	mode
	)

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

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

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

Referenced by importFile(), and lo_import_internal().

◆ lo_create()

Oid lo_create	(	PGconn *	conn,
		Oid	lobjId
	)

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

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

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

Referenced by lo_import_internal(), and StartRestoreBlob().

◆ lo_export()

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

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

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

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

Referenced by do_lo_export(), and main().

◆ lo_import()

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

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

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

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

Referenced by do_lo_import(), and main().

◆ lo_import_with_oid()

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

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

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

References conn, filename, and lo_import_internal().

◆ lo_lseek()

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

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

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

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

Referenced by overwrite(), and pickout().

◆ lo_lseek64()

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

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

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

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

Referenced by overwrite(), and pickout().

◆ lo_open()

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

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

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

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

Referenced by dumpBlobs(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), pickout(), and StartRestoreBlob().

◆ lo_read()

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

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

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

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

Referenced by lo_export().

◆ lo_tell()

int lo_tell	(	PGconn *	conn,
		int	fd
	)

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

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

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

◆ lo_tell64()

pg_int64 lo_tell64	(	PGconn *	conn,
		int	fd
	)

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

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

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

Referenced by pickout().

◆ lo_truncate()

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

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

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

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

◆ lo_truncate64()

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

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

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

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

Referenced by my_truncate().

◆ lo_unlink()

int lo_unlink	(	PGconn *	conn,
		Oid	lobjId
	)

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

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

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

Referenced by do_lo_unlink(), and vacuumlo().

◆ lo_write()

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

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

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

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

Referenced by lo_import_internal().

◆ pg_char_to_encoding()

int pg_char_to_encoding ( const char * name )

Definition at line 550 of file encnames.c.

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

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

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

◆ pg_encoding_to_char()

const char* pg_encoding_to_char ( int encoding )

Definition at line 588 of file encnames.c.

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

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

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

◆ pg_valid_server_encoding_id()

int pg_valid_server_encoding_id ( int encoding )

Definition at line 514 of file encnames.c.

 {
     return PG_VALID_BE_ENCODING(encoding);
 }

References encoding, and PG_VALID_BE_ENCODING.

Referenced by setup_locale_encoding().

◆ PQbackendPID()

int PQbackendPID ( const PGconn * conn )

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

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

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

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

◆ PQbinaryTuples()

int PQbinaryTuples ( const PGresult * res )

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

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

References pg_result::binary, and res.

Referenced by HandleCopyResult().

◆ PQcancel()

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

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

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

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

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

◆ PQclear()

void PQclear ( PGresult * res )

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

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

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

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

◆ PQclientEncoding()

int PQclientEncoding ( const PGconn * conn )

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

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

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

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

◆ PQcmdStatus()

char* PQcmdStatus ( PGresult * res )

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

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

References pg_result::cmdStatus, and res.

Referenced by dblink_exec(), ecpg_process_output(), ExecQueryAndProcessResults(), materializeResult(), PrintQueryResult(), PrintQueryStatus(), and test_pipelined_insert().

◆ PQcmdTuples()

char* PQcmdTuples ( PGresult * res )

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

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

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

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

◆ PQconndefaults()

PQconninfoOption* PQconndefaults ( void )

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

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

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

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

◆ PQconnectdb()

PGconn* PQconnectdb ( const char * conninfo )

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

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

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

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

◆ PQconnectdbParams()

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

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

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

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

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

◆ PQconnectionNeedsPassword()

int PQconnectionNeedsPassword ( const PGconn * conn )

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

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

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

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

◆ PQconnectionUsedPassword()

int PQconnectionUsedPassword ( const PGconn * conn )

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

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

References conn, and pg_conn::password_needed.

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

◆ PQconnectPoll()

PostgresPollingStatusType PQconnectPoll ( PGconn * conn )

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

 {
     bool        reset_connection_state_machine = false;
     bool        need_new_connection = false;
     PGresult   *res;
     char        sebuf[PG_STRERROR_R_BUFLEN];
     int         optval;
  
     if (conn == NULL)
         return PGRES_POLLING_FAILED;
  
     /* Get the new data */
     switch (conn->status)
     {
             /*
              * We really shouldn't have been polled in these two cases, but we
              * can handle it.
              */
         case CONNECTION_BAD:
             return PGRES_POLLING_FAILED;
         case CONNECTION_OK:
             return PGRES_POLLING_OK;
  
             /* These are reading states */
         case CONNECTION_AWAITING_RESPONSE:
         case CONNECTION_AUTH_OK:
         case CONNECTION_CHECK_WRITABLE:
         case CONNECTION_CONSUME:
         case CONNECTION_CHECK_STANDBY:
             {
                 /* Load waiting data */
                 int         n = pqReadData(conn);
  
                 if (n < 0)
                     goto error_return;
                 if (n == 0)
                     return PGRES_POLLING_READING;
  
                 break;
             }
  
             /* These are writing states, so we just proceed. */
         case CONNECTION_STARTED:
         case CONNECTION_MADE:
             break;
  
             /* Special cases: proceed without waiting. */
         case CONNECTION_SSL_STARTUP:
         case CONNECTION_NEEDED:
         case CONNECTION_GSS_STARTUP:
         case CONNECTION_CHECK_TARGET:
             break;
  
         default:
             libpq_append_conn_error(conn, "invalid connection state, probably indicative of memory corruption");
             goto error_return;
     }
  
  
 keep_going:                     /* We will come back to here until there is
                                  * nothing left to do. */
  
     /* Time to advance to next address, or next host if no more addresses? */
     if (conn->try_next_addr)
     {
         if (conn->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)
             {
                 libpq_append_conn_error(conn, "invalid port number: \"%s\"", ch->port);
                 goto keep_going;
             }
         }
         snprintf(portstr, sizeof(portstr), "%d", thisport);
  
         /* Use pg_getaddrinfo_all() to resolve the address */
         switch (ch->type)
         {
             case CHT_HOST_NAME:
                 ret = pg_getaddrinfo_all(ch->host, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     libpq_append_conn_error(conn, "could not translate host name \"%s\" to address: %s",
                                        ch->host, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
  
             case CHT_HOST_ADDRESS:
                 hint.ai_flags = AI_NUMERICHOST;
                 ret = pg_getaddrinfo_all(ch->hostaddr, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     libpq_append_conn_error(conn, "could not parse network address \"%s\": %s",
                                        ch->hostaddr, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
  
             case CHT_UNIX_SOCKET:
                 conn->addrlist_family = hint.ai_family = AF_UNIX;
                 UNIXSOCK_PATH(portstr, thisport, ch->host);
                 if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
                 {
                     libpq_append_conn_error(conn, "Unix-domain socket path \"%s\" is too long (maximum %d bytes)",
                                        portstr,
                                        (int) (UNIXSOCK_PATH_BUFLEN - 1));
                     goto keep_going;
                 }
  
                 /*
                  * NULL hostname tells pg_getaddrinfo_all to parse the service
                  * name as a Unix-domain socket path.
                  */
                 ret = pg_getaddrinfo_all(NULL, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     libpq_append_conn_error(conn, "could not translate Unix-domain socket path \"%s\" to address: %s",
                                        portstr, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
         }
  
         /* 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);
                         libpq_append_conn_error(conn, "could not create socket: %s",
                                            SOCK_STRERROR(errorno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
                     /*
                      * Once we've identified a target address, all errors
                      * except the preceding socket()-failure case should be
                      * prefixed with host-identity information.  (If the
                      * connection succeeds, the contents of conn->errorMessage
                      * won't matter, so this is harmless.)
                      */
                     emitHostIdentityInfo(conn, host_addr);
  
                     /*
                      * Select socket options: no delay of outgoing data for
                      * TCP sockets, nonblock mode, close-on-exec.  Try the
                      * next address if any of this fails.
                      */
                     if (addr_cur->ai_family != AF_UNIX)
                     {
                         if (!connectNoDelay(conn))
                         {
                             /* error message already created */
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
                     if (!pg_set_noblock(conn->sock))
                     {
                         libpq_append_conn_error(conn, "could not set socket to nonblocking mode: %s",
                                            SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
  
 #ifdef F_SETFD
                     if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
                     {
                         libpq_append_conn_error(conn, "could not set socket to close-on-exec mode: %s",
                                            SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
 #endif                          /* F_SETFD */
  
                     if (addr_cur->ai_family != AF_UNIX)
                     {
 #ifndef WIN32
                         int         on = 1;
 #endif
                         int         usekeepalives = useKeepalives(conn);
                         int         err = 0;
  
                         if (usekeepalives < 0)
                         {
                             libpq_append_conn_error(conn, "keepalives parameter must be an integer");
                             err = 1;
                         }
                         else if (usekeepalives == 0)
                         {
                             /* Do nothing */
                         }
 #ifndef WIN32
                         else if (setsockopt(conn->sock,
                                             SOL_SOCKET, SO_KEEPALIVE,
                                             (char *) &on, sizeof(on)) < 0)
                         {
                             libpq_append_conn_error(conn, "%s(%s) failed: %s",
                                                "setsockopt",
                                                "SO_KEEPALIVE",
                                                SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                             err = 1;
                         }
                         else if (!setKeepalivesIdle(conn)
                                  || !setKeepalivesInterval(conn)
                                  || !setKeepalivesCount(conn))
                             err = 1;
 #else                           /* WIN32 */
 #ifdef SIO_KEEPALIVE_VALS
                         else if (!prepKeepalivesWin32(conn))
                             err = 1;
 #endif                          /* SIO_KEEPALIVE_VALS */
 #endif                          /* WIN32 */
                         else if (!setTCPUserTimeout(conn))
                             err = 1;
  
                         if (err)
                         {
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
  
                     /*----------
                      * We have three methods of blocking SIGPIPE during
                      * send() calls to this socket:
                      *
                      *  - setsockopt(sock, SO_NOSIGPIPE)
                      *  - send(sock, ..., MSG_NOSIGNAL)
                      *  - setting the signal mask to SIG_IGN during send()
                      *
                      * The third method requires three syscalls per send,
                      * so we prefer either of the first two, but they are
                      * less portable.  The state is tracked in the following
                      * members of PGconn:
                      *
                      * conn->sigpipe_so     - we have set up SO_NOSIGPIPE
                      * conn->sigpipe_flag   - we're specifying MSG_NOSIGNAL
                      *
                      * If we can use SO_NOSIGPIPE, then set sigpipe_so here
                      * and we're done.  Otherwise, set sigpipe_flag so that
                      * we will try MSG_NOSIGNAL on sends.  If we get an error
                      * with MSG_NOSIGNAL, we'll clear that flag and revert to
                      * signal masking.
                      *----------
                      */
                     conn->sigpipe_so = false;
 #ifdef MSG_NOSIGNAL
                     conn->sigpipe_flag = true;
 #else
                     conn->sigpipe_flag = false;
 #endif                          /* MSG_NOSIGNAL */
  
 #ifdef SO_NOSIGPIPE
                     optval = 1;
                     if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
                                    (char *) &optval, sizeof(optval)) == 0)
                     {
                         conn->sigpipe_so = true;
                         conn->sigpipe_flag = false;
                     }
 #endif                          /* SO_NOSIGPIPE */
  
                     /*
                      * Start/make connection.  This should not block, since we
                      * are in nonblock mode.  If it does, well, too bad.
                      */
                     if (connect(conn->sock, 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:
             {
                 socklen_t   optlen = sizeof(optval);
  
                 /*
                  * Write ready, since we've made it here, so the connection
                  * has been made ... or has failed.
                  */
  
                 /*
                  * Now check (using getsockopt) that there is not an error
                  * state waiting for us on the socket.
                  */
  
                 if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
                                (char *) &optval, &optlen) == -1)
                 {
                     libpq_append_conn_error(conn, "could not get socket error status: %s",
                                        SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
                 else if (optval != 0)
                 {
                     /*
                      * When using a nonblocking connect, we will typically see
                      * connect failures at this point, so provide a friendly
                      * error message.
                      */
                     connectFailureMessage(conn, optval);
  
                     /*
                      * Try the next address if any, just as in the case where
                      * connect() returned failure immediately.
                      */
                     conn->try_next_addr = true;
                     goto keep_going;
                 }
  
                 /* Fill in the client address */
                 conn->laddr.salen = sizeof(conn->laddr.addr);
                 if (getsockname(conn->sock,
                                 (struct sockaddr *) &conn->laddr.addr,
                                 &conn->laddr.salen) < 0)
                 {
                     libpq_append_conn_error(conn, "could not get client address from socket: %s",
                                        SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
  
                 /*
                  * 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] &&
                     conn->raddr.addr.ss_family == AF_UNIX)
                 {
 #ifndef WIN32
                     char       *remote_username;
 #endif
                     uid_t       uid;
                     gid_t       gid;
  
                     errno = 0;
                     if (getpeereid(conn->sock, &uid, &gid) != 0)
                     {
                         /*
                          * Provide special error message if getpeereid is a
                          * stub
                          */
                         if (errno == ENOSYS)
                             libpq_append_conn_error(conn, "requirepeer parameter is not supported on this platform");
                         else
                             libpq_append_conn_error(conn, "could not get peer credentials: %s",
                                                strerror_r(errno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
 #ifndef WIN32
                     remote_username = pg_fe_getusername(uid,
                                                         &conn->errorMessage);
                     if (remote_username == NULL)
                         goto error_return;  /* message already logged */
  
                     if (strcmp(remote_username, conn->requirepeer) != 0)
                     {
                         libpq_append_conn_error(conn, "requirepeer specifies \"%s\", but actual peer user name is \"%s\"",
                                            conn->requirepeer, remote_username);
                         free(remote_username);
                         goto error_return;
                     }
                     free(remote_username);
 #else                           /* WIN32 */
                     /* should have failed with ENOSYS above */
                     Assert(false);
 #endif                          /* WIN32 */
                 }
  
                 if (conn->raddr.addr.ss_family == AF_UNIX)
                 {
                     /* 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)
                     {
                         libpq_append_conn_error(conn, "could not send GSSAPI negotiation packet: %s",
                                            SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
                     /* Ok, wait for response */
                     conn->status = CONNECTION_GSS_STARTUP;
                     return PGRES_POLLING_READING;
                 }
                 else if (!conn->gctx && conn->gssencmode[0] == 'r')
                 {
                     libpq_append_conn_error(conn,
                                        "GSSAPI encryption required but was impossible (possibly no credential cache, no server support, or using a local socket)");
                     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)
                     {
                         libpq_append_conn_error(conn, "could not send SSL negotiation packet: %s",
                                            SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
                     /* Ok, wait for response */
                     conn->status = CONNECTION_SSL_STARTUP;
                     return PGRES_POLLING_READING;
                 }
 #endif                          /* USE_SSL */
  
                 /*
                  * Build the startup packet.
                  */
                 startpacket = pqBuildStartupPacket3(conn, &packetlen,
                                                     EnvironmentOptions);
                 if (!startpacket)
                 {
                     libpq_append_conn_error(conn, "out of memory");
                     goto error_return;
                 }
  
                 /*
                  * Send the startup packet.
                  *
                  * Theoretically, this could block, but it really shouldn't
                  * since we only got here if the socket is write-ready.
                  */
                 if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
                 {
                     libpq_append_conn_error(conn, "could not send startup packet: %s",
                                        SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     free(startpacket);
                     goto error_return;
                 }
  
                 free(startpacket);
  
                 conn->status = CONNECTION_AWAITING_RESPONSE;
                 return PGRES_POLLING_READING;
             }
  
             /*
              * Handle SSL negotiation: wait for postmaster messages and
              * respond as necessary.
              */
         case CONNECTION_SSL_STARTUP:
             {
 #ifdef USE_SSL
                 PostgresPollingStatusType pollres;
  
                 /*
                  * On first time through, 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 */
                             libpq_append_conn_error(conn, "server does not support SSL, but SSL was required");
                             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
                     {
                         libpq_append_conn_error(conn, "received invalid response to SSL negotiation: %c",
                                            SSLok);
                         goto error_return;
                     }
                 }
  
                 /*
                  * Begin or continue the SSL negotiation process.
                  */
                 pollres = pqsecure_open_client(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /*
                      * At this point we should have no data already buffered.
                      * If we do, it was received before we performed the SSL
                      * handshake, so it wasn't encrypted and indeed may have
                      * been injected by a man-in-the-middle.
                      */
                     if (conn->inCursor != conn->inEnd)
                     {
                         libpq_append_conn_error(conn, "received unencrypted data after SSL response");
                         goto error_return;
                     }
  
                     /* SSL handshake done, ready to send startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 if (pollres == PGRES_POLLING_FAILED)
                 {
                     /*
                      * 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')
                         {
                             libpq_append_conn_error(conn, "server doesn't support GSSAPI encryption, but it was required");
                             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')
                     {
                         libpq_append_conn_error(conn, "received invalid response to GSSAPI negotiation: %c",
                                            gss_ok);
                         goto error_return;
                     }
                 }
  
                 /* Begin or continue GSSAPI negotiation */
                 pollres = pqsecure_open_gss(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /*
                      * At this point we should have no data already buffered.
                      * If we do, it was received before we performed the GSS
                      * handshake, so it wasn't encrypted and indeed may have
                      * been injected by a man-in-the-middle.
                      */
                     if (conn->inCursor != conn->inEnd)
                     {
                         libpq_append_conn_error(conn, "received unencrypted data after GSSAPI encryption response");
                         goto error_return;
                     }
  
                     /* All set for startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 else if (pollres == PGRES_POLLING_FAILED &&
                          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, NegotiateProtocolVersion, or an error here.
                  * Anything else probably means it's not Postgres on the other
                  * end at all.
                  */
                 if (!(beresp == 'R' || beresp == 'v' || beresp == 'E'))
                 {
                     libpq_append_conn_error(conn, "expected authentication request from server, but received %c",
                                        beresp);
                     goto error_return;
                 }
  
                 /* Read message length word */
                 if (pqGetInt(&msgLength, 4, conn))
                 {
                     /* We'll come back when there is more data */
                     return PGRES_POLLING_READING;
                 }
  
                 /*
                  * Try to validate message length before using it.
                  * Authentication requests can't be very large, although GSS
                  * auth requests may not be that small.  Same for
                  * NegotiateProtocolVersion.  Errors can be a
                  * little larger, but not huge.  If we see a large apparent
                  * length in an error, it means we're really talking to a
                  * pre-3.0-protocol server; cope.  (Before version 14, the
                  * server also used the old protocol for errors that happened
                  * before processing the startup packet.)
                  */
                 if ((beresp == 'R' || beresp == 'v') && (msgLength < 8 || msgLength > 2000))
                 {
                     libpq_append_conn_error(conn, "expected authentication request from server, but received %c",
                                        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;
                 }
                 else if (beresp == 'v')
                 {
                     if (pqGetNegotiateProtocolVersion3(conn))
                     {
                         goto error_return;
                     }
                     /* OK, we read the message; mark data consumed */
                     conn->inStart = conn->inCursor;
                     goto error_return;
                 }
  
                 /* It is an authentication request. */
                 conn->auth_req_received = true;
  
                 /* Get the type of request. */
                 if (pqGetInt((int *) &areq, 4, conn))
                 {
                     goto error_return;
                 }
                 msgLength -= 4;
  
                 /*
                  * Process the rest of the authentication request message, and
                  * respond to it if necessary.
                  *
                  * Note that conn->pghost must be non-NULL if we are going to
                  * avoid the Kerberos code doing a hostname look-up.
                  */
                 res = pg_fe_sendauth(areq, msgLength, conn);
  
                 /* 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)
                         libpq_append_conn_error(conn, "unexpected message from server during startup");
                     else if (conn->send_appname &&
                              (conn->appname || conn->fbappname))
                     {
                         /*
                          * If we tried to send application_name, check to see
                          * if the error is about that --- pre-9.0 servers will
                          * reject it at this stage of the process.  If so,
                          * close the connection and retry without sending
                          * application_name.  We could possibly get a false
                          * SQLSTATE match here and retry uselessly, but there
                          * seems no great harm in that; we'll just get the
                          * same error again if it's unrelated.
                          */
                         const char *sqlstate;
  
                         sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
                         if (sqlstate &&
                             strcmp(sqlstate, ERRCODE_APPNAME_UNKNOWN) == 0)
                         {
                             PQclear(res);
                             conn->send_appname = false;
                             need_new_connection = true;
                             goto keep_going;
                         }
                     }
  
                     /*
                      * if the resultStatus is FATAL, then conn->errorMessage
                      * already has a copy of the error; needn't copy it back.
                      * But add a newline if it's not there already, since
                      * postmaster error messages may not have one.
                      */
                     if (conn->errorMessage.len <= 0 ||
                         conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
                         appendPQExpBufferChar(&conn->errorMessage, '\n');
                     PQclear(res);
                     goto error_return;
                 }
  
                 /* Almost there now ... */
                 conn->status = CONNECTION_CHECK_TARGET;
                 goto keep_going;
             }
  
         case CONNECTION_CHECK_TARGET:
             {
                 /*
                  * If a read-write, read-only, primary, or standby connection
                  * is required, see if we have one.
                  */
                 if (conn->target_server_type == SERVER_TYPE_READ_WRITE ||
                     conn->target_server_type == SERVER_TYPE_READ_ONLY)
                 {
                     bool        read_only_server;
  
                     /*
                      * If the server didn't report
                      * "default_transaction_read_only" or "in_hot_standby" at
                      * startup, we must determine its state by sending the
                      * query "SHOW transaction_read_only".  This GUC exists in
                      * all server versions that support 3.0 protocol.
                      */
                     if (conn->default_transaction_read_only == PG_BOOL_UNKNOWN ||
                         conn->in_hot_standby == PG_BOOL_UNKNOWN)
                     {
                         /*
                          * We use PQsendQueryContinue so that
                          * conn->errorMessage does not get cleared.  We need
                          * to preserve any error messages related to previous
                          * hosts we have tried and failed to connect to.
                          */
                         conn->status = CONNECTION_OK;
                         if (!PQsendQueryContinue(conn,
                                                  "SHOW transaction_read_only"))
                             goto error_return;
                         /* We'll return to this state when we have the answer */
                         conn->status = CONNECTION_CHECK_WRITABLE;
                         return PGRES_POLLING_READING;
                     }
  
                     /* OK, we can make the test */
                     read_only_server =
                         (conn->default_transaction_read_only == PG_BOOL_YES ||
                          conn->in_hot_standby == PG_BOOL_YES);
  
                     if ((conn->target_server_type == SERVER_TYPE_READ_WRITE) ?
                         read_only_server : !read_only_server)
                     {
                         /* Wrong server state, reject and try the next host */
                         if (conn->target_server_type == SERVER_TYPE_READ_WRITE)
                             libpq_append_conn_error(conn, "session is read-only");
                         else
                             libpq_append_conn_error(conn, "session is not read-only");
  
                         /* Close connection politely. */
                         conn->status = CONNECTION_OK;
                         sendTerminateConn(conn);
  
                         /*
                          * Try next host if any, but we don't want to consider
                          * additional addresses for this host.
                          */
                         conn->try_next_host = true;
                         goto keep_going;
                     }
                 }
                 else if (conn->target_server_type == SERVER_TYPE_PRIMARY ||
                          conn->target_server_type == SERVER_TYPE_STANDBY ||
                          conn->target_server_type == SERVER_TYPE_PREFER_STANDBY)
                 {
                     /*
                      * If the server didn't report "in_hot_standby" at
                      * startup, we must determine its state by sending the
                      * query "SELECT pg_catalog.pg_is_in_recovery()".  Servers
                      * before 9.0 don't have that function, but by the same
                      * token they don't have any standby mode, so we may just
                      * assume the result.
                      */
                     if (conn->sversion < 90000)
                         conn->in_hot_standby = PG_BOOL_NO;
  
                     if (conn->in_hot_standby == PG_BOOL_UNKNOWN)
                     {
                         /*
                          * We use PQsendQueryContinue so that
                          * conn->errorMessage does not get cleared.  We need
                          * to preserve any error messages related to previous
                          * hosts we have tried and failed to connect to.
                          */
                         conn->status = CONNECTION_OK;
                         if (!PQsendQueryContinue(conn,
                                                  "SELECT pg_catalog.pg_is_in_recovery()"))
                             goto error_return;
                         /* We'll return to this state when we have the answer */
                         conn->status = CONNECTION_CHECK_STANDBY;
                         return PGRES_POLLING_READING;
                     }
  
                     /* OK, we can make the test */
                     if ((conn->target_server_type == SERVER_TYPE_PRIMARY) ?
                         (conn->in_hot_standby == PG_BOOL_YES) :
                         (conn->in_hot_standby == PG_BOOL_NO))
                     {
                         /* Wrong server state, reject and try the next host */
                         if (conn->target_server_type == SERVER_TYPE_PRIMARY)
                             libpq_append_conn_error(conn, "server is in hot standby mode");
                         else
                             libpq_append_conn_error(conn, "server is not in hot standby mode");
  
                         /* Close connection politely. */
                         conn->status = CONNECTION_OK;
                         sendTerminateConn(conn);
  
                         /*
                          * Try next host if any, but we don't want to consider
                          * additional addresses for this host.
                          */
                         conn->try_next_host = true;
                         goto keep_going;
                     }
                 }
  
                 /* 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).
                  */
                 pqClearConnErrorState(conn);
  
                 /* We are open for business! */
                 conn->status = CONNECTION_OK;
                 return PGRES_POLLING_OK;
             }
  
         case CONNECTION_CONSUME:
             {
                 /*
                  * This state just makes sure the connection is idle after
                  * we've obtained the result of a SHOW or SELECT query.  Once
                  * we're clear, return to CONNECTION_CHECK_TARGET state to
                  * decide what to do next.  We must transiently set status =
                  * CONNECTION_OK in order to use the result-consuming
                  * subroutines.
                  */
                 conn->status = CONNECTION_OK;
                 if (!PQconsumeInput(conn))
                     goto error_return;
  
                 if (PQisBusy(conn))
                 {
                     conn->status = CONNECTION_CONSUME;
                     return PGRES_POLLING_READING;
                 }
  
                 /* Call PQgetResult() again until we get a NULL result */
                 res = PQgetResult(conn);
                 if (res != NULL)
                 {
                     PQclear(res);
                     conn->status = CONNECTION_CONSUME;
                     return PGRES_POLLING_READING;
                 }
  
                 conn->status = CONNECTION_CHECK_TARGET;
                 goto keep_going;
             }
  
         case CONNECTION_CHECK_WRITABLE:
             {
                 /*
                  * Waiting for result of "SHOW transaction_read_only".  We
                  * must transiently set status = CONNECTION_OK in order to use
                  * the result-consuming subroutines.
                  */
                 conn->status = CONNECTION_OK;
                 if (!PQconsumeInput(conn))
                     goto error_return;
  
                 if (PQisBusy(conn))
                 {
                     conn->status = CONNECTION_CHECK_WRITABLE;
                     return PGRES_POLLING_READING;
                 }
  
                 res = PQgetResult(conn);
                 if (res && PQresultStatus(res) == PGRES_TUPLES_OK &&
                     PQntuples(res) == 1)
                 {
                     char       *val = PQgetvalue(res, 0, 0);
  
                     /*
                      * "transaction_read_only = on" proves that at least one
                      * of default_transaction_read_only and in_hot_standby is
                      * on, but we don't actually know which.  We don't care
                      * though for the purpose of identifying a read-only
                      * session, so satisfy the CONNECTION_CHECK_TARGET code by
                      * claiming they are both on.  On the other hand, if it's
                      * a read-write session, they are certainly both off.
                      */
                     if (strncmp(val, "on", 2) == 0)
                     {
                         conn->default_transaction_read_only = PG_BOOL_YES;
                         conn->in_hot_standby = PG_BOOL_YES;
                     }
                     else
                     {
                         conn->default_transaction_read_only = PG_BOOL_NO;
                         conn->in_hot_standby = PG_BOOL_NO;
                     }
                     PQclear(res);
  
                     /* Finish reading messages before continuing */
                     conn->status = CONNECTION_CONSUME;
                     goto keep_going;
                 }
  
                 /* Something went wrong with "SHOW transaction_read_only". */
                 PQclear(res);
  
                 /* Append error report to conn->errorMessage. */
                 libpq_append_conn_error(conn, "\"%s\" failed",
                                   "SHOW transaction_read_only");
  
                 /* Close connection politely. */
                 conn->status = CONNECTION_OK;
                 sendTerminateConn(conn);
  
                 /* Try next host. */
                 conn->try_next_host = true;
                 goto keep_going;
             }
  
         case CONNECTION_CHECK_STANDBY:
             {
                 /*
                  * Waiting for result of "SELECT pg_is_in_recovery()".  We
                  * must transiently set status = CONNECTION_OK in order to use
                  * the result-consuming subroutines.
                  */
                 conn->status = CONNECTION_OK;
                 if (!PQconsumeInput(conn))
                     goto error_return;
  
                 if (PQisBusy(conn))
                 {
                     conn->status = CONNECTION_CHECK_STANDBY;
                     return PGRES_POLLING_READING;
                 }
  
                 res = PQgetResult(conn);
                 if (res && PQresultStatus(res) == PGRES_TUPLES_OK &&
                     PQntuples(res) == 1)
                 {
                     char       *val = PQgetvalue(res, 0, 0);
  
                     if (strncmp(val, "t", 1) == 0)
                         conn->in_hot_standby = PG_BOOL_YES;
                     else
                         conn->in_hot_standby = PG_BOOL_NO;
                     PQclear(res);
  
                     /* Finish reading messages before continuing */
                     conn->status = CONNECTION_CONSUME;
                     goto keep_going;
                 }
  
                 /* Something went wrong with "SELECT pg_is_in_recovery()". */
                 PQclear(res);
  
                 /* Append error report to conn->errorMessage. */
                 libpq_append_conn_error(conn, "\"%s\" failed",
                                   "SELECT pg_is_in_recovery()");
  
                 /* Close connection politely. */
                 conn->status = CONNECTION_OK;
                 sendTerminateConn(conn);
  
                 /* Try next host. */
                 conn->try_next_host = true;
                 goto keep_going;
             }
  
         default:
             libpq_append_conn_error(conn,
                                "invalid connection state %d, probably indicative of memory corruption",
                               conn->status);
             goto error_return;
     }
  
     /* Unreachable */
  
 error_return:
  
     /*
      * We used to close the socket at this point, but that makes it awkward
      * for those above us if they wish to remove this socket from their own
      * records (an fd_set for example).  We'll just have this socket closed
      * when PQfinish is called (which is compulsory even after an error, since
      * the connection structure must be freed).
      */
     conn->status = CONNECTION_BAD;
     return PGRES_POLLING_FAILED;
 }

References SockAddr::addr, pg_conn::addr_cur, pg_conn::addrlist, pg_conn::addrlist_family, appendPQExpBufferChar(), pg_conn::appname, Assert(), pg_conn::asyncStatus, AUTH_REQ_OK, pg_conn::auth_req_received, CHT_HOST_ADDRESS, CHT_HOST_NAME, CHT_UNIX_SOCKET, conn, 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(), EnvironmentOptions, ERRCODE_APPNAME_UNKNOWN, ERRCODE_CANNOT_CONNECT_NOW, pg_conn::errorMessage, EWOULDBLOCK, pg_conn::fbappname, free, 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, pg_conn::laddr, pg_conn::last_sqlstate, PQExpBufferData::len, libpq_append_conn_error(), MAXPGPATH, MemSet, pg_conn::nconnhost, NEGOTIATE_GSS_CODE, NEGOTIATE_SSL_CODE, parse_int_param(), PG_BOOL_NO, PG_BOOL_UNKNOWN, PG_BOOL_YES, PG_DIAG_SQLSTATE, pg_fe_getusername(), 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(), pqClearConnErrorState, PQconsumeInput(), pqDropConnection(), pqDropServerData(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetNegotiateProtocolVersion3(), 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, res, 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(), val, pg_conn::whichhost, and pg_conn::xactStatus.

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

◆ PQconnectStart()

PGconn* PQconnectStart ( const char * conninfo )

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

 {
     PGconn     *conn;
  
     /*
      * Allocate memory for the conn structure.  Note that we also expect this
      * to initialize conn->errorMessage to empty.  All subsequent steps during
      * connection initialization will only append to that buffer.
      */
     conn = 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;
 }

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

Referenced by PQconnectdb(), and PQping().

◆ PQconnectStartParams()

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

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

 {
     PGconn     *conn;
     PQconninfoOption *connOptions;
  
     /*
      * Allocate memory for the conn structure.  Note that we also expect this
      * to initialize conn->errorMessage to empty.  All subsequent steps during
      * connection initialization will only append to that buffer.
      */
     conn = 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;
 }

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

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

◆ PQconninfo()

PQconninfoOption* PQconninfo ( PGconn * conn )

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

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

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

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

◆ PQconninfoFree()

void PQconninfoFree ( PQconninfoOption * connOptions )

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

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

References free, and option::val.

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

◆ PQconninfoParse()

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

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

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

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

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

◆ PQconsumeInput()

int PQconsumeInput ( PGconn * conn )

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

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

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

Referenced by advanceConnectionState(), CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), do_sql_command_end(), 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().

◆ PQcopyResult()

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

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

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

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

Referenced by pqRowProcessor().

◆ PQdb()

char* PQdb ( const PGconn * conn )

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

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

References conn, and pg_conn::dbName.

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

◆ PQdefaultSSLKeyPassHook_OpenSSL()

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

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

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

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

Referenced by PQssl_passwd_cb().

◆ PQdescribePortal()

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

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

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

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

◆ PQdescribePrepared()

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

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

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

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

Referenced by DescribeQuery(), and ECPGdescribe().

◆ PQdisplayTuples()

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

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

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

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

◆ PQdsplen()

int PQdsplen	(	const char *	s,
		int	encoding
	)

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

 {
     return pg_encoding_dsplen(encoding, s);
 }

References encoding, and pg_encoding_dsplen().

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

◆ PQencryptPassword()

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

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

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

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

◆ PQencryptPasswordConn()

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

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

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

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

Referenced by exec_command_password(), and main().

◆ PQendcopy()

int PQendcopy ( PGconn * conn )

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

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

References conn, and pqEndcopy3().

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

◆ PQenterPipelineMode()

int PQenterPipelineMode ( PGconn * conn )

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

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

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

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

◆ PQenv2encoding()

int PQenv2encoding ( void )

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

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

References encoding, pg_char_to_encoding(), PG_SQL_ASCII, and generate_unaccent_rules::str.

Referenced by main().

◆ PQerrorMessage()

char* PQerrorMessage ( const PGconn * conn )

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

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

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

Referenced by _doSetSessionAuth(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), AcceptResult(), advanceConnectionState(), BaseBackup(), check_loadable_libraries(), check_prepare_conn(), CheckCopyStreamStop(), cluster_one_database(), compile_database_list(), compile_relation_list_one_db(), connect_pg_server(), ConnectDatabase(), connectDatabase(), connectToServer(), CopyStreamPoll(), CopyStreamReceive(), CreateReplicationSlot(), dblink_connect(), dblink_error_message(), dblink_get_conn(), dblink_res_error(), dblink_send_query(), DescribeQuery(), die_on_query_failure(), do_connect(), do_lo_export(), do_lo_import(), do_lo_unlink(), doConnect(), DropReplicationSlot(), dump_lo_buf(), dumpBlobs(), dumpTableData_copy(), ecpg_check_PQresult(), ecpg_raise_backend(), ECPGconnect(), EndDBCopyMode(), exec_command_password(), ExecQueryAndProcessResults(), executeCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlCommandBuf(), executeStatement(), GetConnection(), GetSlotInformation(), GetTableInfo(), handleCopyIn(), handleCopyOut(), HandleEndOfCopyStream(), initGenerateDataClientSide(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_send(), libpqrcv_startstreaming(), main(), my_truncate(), overwrite(), pgfdw_cancel_query(), pgfdw_report_error(), pickout(), process_queued_fetch_requests(), process_result(), ProcessXLogDataMsg(), psql_get_variable(), readCommandResponse(), ReceiveCopyData(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_command(), run_permutation(), run_reindex_command(), run_vacuum_command(), RunIdentifySystem(), sendCommand(), sendFeedback(), SendQuery(), sql_conn(), sql_exec(), start_postmaster(), StartRestoreBlob(), storeQueryResult(), StreamLogicalLog(), TableCommandResultHandler(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), test_uniqviol(), threadRun(), try_complete_step(), tryExecuteStatement(), vacuumlo(), verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ PQescapeBytea()

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

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

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

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ LIBPQ_HAS_PIPELINING

◆ LIBPQ_HAS_SSL_LIBRARY_DETECTION

◆ LIBPQ_HAS_TRACE_FLAGS

◆ PG_COPYRES_ATTRS

◆ PG_COPYRES_EVENTS

◆ PG_COPYRES_NOTICEHOOKS

◆ PG_COPYRES_TUPLES

◆ PQ_QUERY_PARAM_MAX_LIMIT

◆ PQfreeNotify

◆ PQnoPasswordSupplied

◆ PQsetdb

◆ PQTRACE_REGRESS_MODE

◆ PQTRACE_SUPPRESS_TIMESTAMPS

Typedef Documentation

◆ PGcancel

◆ PGconn

◆ PGnotify

◆ PGresAttDesc

◆ PGresult

◆ pgthreadlock_t

◆ pqbool

◆ PQconninfoOption

◆ PQnoticeProcessor

◆ PQnoticeReceiver

◆ PQprintOpt

◆ PQsslKeyPassHook_OpenSSL_type

Enumeration Type Documentation

◆ ConnStatusType

◆ ExecStatusType

◆ PGContextVisibility

◆ PGPing

◆ PGpipelineStatus

◆ PGTransactionStatusType

◆ PGVerbosity

◆ PostgresPollingStatusType

Function Documentation

◆ lo_close()

◆ lo_creat()

◆ lo_create()

◆ lo_export()

◆ lo_import()

◆ lo_import_with_oid()

◆ lo_lseek()

◆ lo_lseek64()

◆ lo_open()

◆ lo_read()

◆ lo_tell()

◆ lo_tell64()

◆ lo_truncate()

◆ lo_truncate64()

◆ lo_unlink()

◆ lo_write()

◆ pg_char_to_encoding()

◆ pg_encoding_to_char()

◆ pg_valid_server_encoding_id()

◆ PQbackendPID()

◆ PQbinaryTuples()

◆ PQcancel()

◆ PQclear()

◆ PQclientEncoding()

◆ PQcmdStatus()

◆ PQcmdTuples()

◆ PQconndefaults()

◆ PQconnectdb()

◆ PQconnectdbParams()

◆ PQconnectionNeedsPassword()

◆ PQconnectionUsedPassword()

◆ PQconnectPoll()

◆ PQconnectStart()

◆ PQconnectStartParams()

◆ PQconninfo()

◆ PQconninfoFree()

◆ PQconninfoParse()

◆ PQconsumeInput()