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

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 }

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 }

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)

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)

void	PQtrace (PGconn conn, FILE debug_port)

void	PQuntrace (PGconn *conn)

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

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

pgthreadlock_t	PQregisterThreadLock (pgthreadlock_t newhandler)

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)

PGnotify *	PQnotifies (PGconn *conn)

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

int	PQputCopyEnd (PGconn conn, const char errormsg)

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

int	PQgetline (PGconn conn, char string, int length)

int	PQputline (PGconn conn, const char string)

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

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

int	PQendcopy (PGconn *conn)

int	PQsetnonblocking (PGconn *conn, int arg)

int	PQisnonblocking (const PGconn *conn)

int	PQisthreadsafe (void)

PGPing	PQping (const char *conninfo)

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

int	PQflush (PGconn *conn)

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

ExecStatusType	PQresultStatus (const PGresult *res)

char *	PQresStatus (ExecStatusType status)

char *	PQresultErrorMessage (const PGresult *res)

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

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

int	PQntuples (const PGresult *res)

int	PQnfields (const PGresult *res)

int	PQbinaryTuples (const PGresult *res)

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

int	PQfnumber (const PGresult res, const char field_name)

Oid	PQftable (const PGresult *res, int field_num)

int	PQftablecol (const PGresult *res, int field_num)

int	PQfformat (const PGresult *res, int field_num)

Oid	PQftype (const PGresult *res, int field_num)

int	PQfsize (const PGresult *res, int field_num)

int	PQfmod (const PGresult *res, int field_num)

char *	PQcmdStatus (PGresult *res)

char *	PQoidStatus (const PGresult *res)

Oid	PQoidValue (const PGresult *res)

char *	PQcmdTuples (PGresult *res)

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

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

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

int	PQnparams (const PGresult *res)

Oid	PQparamtype (const PGresult *res, int param_num)

PGresult *	PQdescribePrepared (PGconn conn, const char stmt)

PGresult *	PQdescribePortal (PGconn conn, const char portal)

int	PQsendDescribePrepared (PGconn conn, const char stmt)

int	PQsendDescribePortal (PGconn conn, const char portal)

void	PQclear (PGresult *res)

void	PQfreemem (void *ptr)

PGresult *	PQmakeEmptyPGresult (PGconn *conn, ExecStatusType status)

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

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

void *	PQresultAlloc (PGresult *res, size_t nBytes)

size_t	PQresultMemorySize (const PGresult *res)

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

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

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

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

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

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

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

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

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

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

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

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

int	lo_close (PGconn *conn, int fd)

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

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

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

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

Oid	lo_creat (PGconn *conn, int mode)

Oid	lo_create (PGconn *conn, Oid lobjId)

int	lo_tell (PGconn *conn, int fd)

pg_int64	lo_tell64 (PGconn *conn, int fd)

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

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

int	lo_unlink (PGconn *conn, Oid lobjId)

Oid	lo_import (PGconn conn, const char filename)

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

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

int	PQlibVersion (void)

int	PQmblen (const char *s, int encoding)

int	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

◆ PG_COPYRES_ATTRS

#define PG_COPYRES_ATTRS 0x01

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

Referenced by PQcopyResult(), and pqRowProcessor().

◆ PG_COPYRES_EVENTS

#define PG_COPYRES_EVENTS 0x04

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

Referenced by PQcopyResult(), and pqRowProcessor().

◆ PG_COPYRES_NOTICEHOOKS

#define PG_COPYRES_NOTICEHOOKS 0x08

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

Referenced by PQcopyResult(), and pqRowProcessor().

◆ PG_COPYRES_TUPLES

#define PG_COPYRES_TUPLES 0x02 /* Implies PG_COPYRES_ATTRS */

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

Referenced by PQcopyResult().

◆ PQfreeNotify

#define PQfreeNotify ( ptr ) PQfreemem(ptr)

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

◆ PQnoPasswordSupplied

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

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

Referenced by pg_fe_sendauth(), and pg_SASL_init().

◆ PQsetdb

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

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

Referenced by main().

Typedef Documentation

◆ PGcancel

typedef struct pg_cancel PGcancel

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

◆ PGconn

typedef struct pg_conn PGconn

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

◆ PGnotify

typedef struct pgNotify PGnotify

◆ PGresAttDesc

typedef struct pgresAttDesc PGresAttDesc

◆ PGresult

typedef struct pg_result PGresult

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

◆ pgthreadlock_t

typedef void(* pgthreadlock_t) (int acquire)

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

◆ pqbool

typedef char pqbool

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

◆ PQconninfoOption

typedef struct _PQconninfoOption PQconninfoOption

◆ PQnoticeProcessor

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

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

◆ PQnoticeReceiver

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

Definition at line 174 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 623 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

Definition at line 47 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,          /* Negotiating environment. */
     CONNECTION_SSL_STARTUP,     /* Negotiating SSL. */
     CONNECTION_NEEDED,          /* Internal state: connect() needed */
     CONNECTION_CHECK_WRITABLE,  /* Check if we could make a writable
                                  * connection. */
     CONNECTION_CONSUME,         /* Wait for any pending message and consume
                                  * them. */
     CONNECTION_GSS_STARTUP,     /* Negotiating GSSAPI. */
     CONNECTION_CHECK_TARGET     /* Check if we have a proper target connection */
 } 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

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

◆ PGContextVisibility

enum PGContextVisibility

Enumerator
PQSHOW_CONTEXT_NEVER
PQSHOW_CONTEXT_ERRORS
PQSHOW_CONTEXT_ALWAYS

Definition at line 120 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 132 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;

◆ PGTransactionStatusType

enum PGTransactionStatusType

Enumerator
PQTRANS_IDLE
PQTRANS_ACTIVE
PQTRANS_INTRANS
PQTRANS_INERROR
PQTRANS_UNKNOWN

Definition at line 103 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 112 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 74 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 99 of file fe-lobj.c.

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

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

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

◆ lo_creat()

Oid lo_creat	(	PGconn *	conn,
		int	mode
	)

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

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

Referenced by importFile(), and lo_import_internal().

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

◆ lo_create()

Oid lo_create	(	PGconn *	conn,
		Oid	lobjId
	)

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

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

Referenced by lo_import_internal(), and StartRestoreBlob().

 {
     PQArgBlock  argv[1];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         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)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("cannot determine OID of function lo_create\n"));
         return InvalidOid;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = lobjId;
     res = PQfn(conn, conn->lobjfuncs->fn_lo_create,
                &retval, &result_len, 1, argv, 1);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return (Oid) retval;
     }
     else
     {
         PQclear(res);
         return InvalidOid;
     }
 }

◆ lo_export()

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

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

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

Referenced by do_lo_export(), and main().

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

◆ lo_import()

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

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

References InvalidOid, and lo_import_internal().

Referenced by do_lo_import(), and main().

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

◆ lo_import_with_oid()

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

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

References lo_import_internal().

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

◆ lo_lseek()

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

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

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

Referenced by overwrite(), and pickout().

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

◆ lo_lseek64()

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

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

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

Referenced by overwrite(), and pickout().

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

◆ lo_open()

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

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

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

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

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

◆ lo_read()

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

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

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

Referenced by lo_export().

 {
     PQArgBlock  argv[2];
     PGresult   *res;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         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)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("argument of lo_read exceeds integer range\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     argv[1].isint = 1;
     argv[1].len = 4;
     argv[1].u.integer = (int) len;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_read,
                (void *) buf, &result_len, 0, argv, 2);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return result_len;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

◆ lo_tell()

int lo_tell	(	PGconn *	conn,
		int	fd
	)

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

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

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

◆ lo_tell64()

pg_int64 lo_tell64	(	PGconn *	conn,
		int	fd
	)

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

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

Referenced by pickout().

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

◆ lo_truncate()

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

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

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

 {
     PQArgBlock  argv[2];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         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)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("cannot determine OID of function lo_truncate\n"));
         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)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("argument of lo_truncate exceeds integer range\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     argv[1].isint = 1;
     argv[1].len = 4;
     argv[1].u.integer = (int) len;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate,
                &retval, &result_len, 1, argv, 2);
 
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

◆ lo_truncate64()

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

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

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

Referenced by my_truncate().

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

◆ lo_unlink()

int lo_unlink	(	PGconn *	conn,
		Oid	lobjId
	)

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

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

Referenced by do_lo_unlink(), and vacuumlo().

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

◆ lo_write()

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

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

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

Referenced by lo_import_internal().

 {
     PQArgBlock  argv[2];
     PGresult   *res;
     int         result_len;
     int         retval;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         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)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("argument of lo_write exceeds integer range\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     argv[1].isint = 0;
     argv[1].len = (int) len;
     argv[1].u.ptr = (int *) unconstify(char *, buf);
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_write,
                &retval, &result_len, 1, argv, 2);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

◆ pg_char_to_encoding()

int pg_char_to_encoding ( const char * name )

Definition at line 550 of file encnames.c.

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

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

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

◆ pg_encoding_to_char()

const char* pg_encoding_to_char ( int encoding )

Definition at line 588 of file encnames.c.

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

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

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

◆ pg_valid_server_encoding_id()

int pg_valid_server_encoding_id ( int encoding )

Definition at line 514 of file encnames.c.

References PG_VALID_BE_ENCODING.

Referenced by setup_locale_encoding().

 {
     return PG_VALID_BE_ENCODING(encoding);
 }

◆ PQbackendPID()

int PQbackendPID ( const PGconn * conn )

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

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

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

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

◆ PQbinaryTuples()

int PQbinaryTuples ( const PGresult * res )

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

References pg_result::binary.

Referenced by ProcessResult().

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

◆ PQcancel()

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

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

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

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

 {
     if (!cancel)
     {
         strlcpy(errbuf, "PQcancel() -- no cancel object supplied", errbufsize);
         return false;
     }
 
     return internal_cancel(&cancel->raddr, cancel->be_pid, cancel->be_key,
                            errbuf, errbufsize);
 }

◆ PQclear()

void PQclear ( PGresult * res )

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

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

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

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

◆ PQclientEncoding()

int PQclientEncoding ( const PGconn * conn )

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

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

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

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

◆ PQcmdStatus()

char* PQcmdStatus ( PGresult * res )

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

References pg_result::cmdStatus.

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

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

◆ PQcmdTuples()

char* PQcmdTuples ( PGresult * res )

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

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

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

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

◆ PQconndefaults()

PQconninfoOption* PQconndefaults ( void )

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

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

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

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

◆ PQconnectdb()

PGconn* PQconnectdb ( const char * conninfo )

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

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

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

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

◆ PQconnectdbParams()

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

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

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

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

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

◆ PQconnectionNeedsPassword()

int PQconnectionNeedsPassword ( const PGconn * conn )

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

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

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

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

◆ PQconnectionUsedPassword()

int PQconnectionUsedPassword ( const PGconn * conn )

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

References pg_conn::password_needed.

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

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

◆ PQconnectPoll()

PostgresPollingStatusType PQconnectPoll ( PGconn * conn )

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

References SockAddr::addr, pg_conn::addr_cur, pg_conn::addrlist, pg_conn::addrlist_family, addrinfo::ai_addr, addrinfo::ai_addrlen, addrinfo::ai_family, addrinfo::ai_flags, addrinfo::ai_next, AI_NUMERICHOST, addrinfo::ai_socktype, appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), pg_conn::appname, Assert, pg_conn::asyncStatus, AUTH_REQ_MD5, AUTH_REQ_OK, pg_conn::auth_req_received, CHT_HOST_ADDRESS, CHT_HOST_NAME, CHT_UNIX_SOCKET, connect, connectFailureMessage(), CONNECTION_AUTH_OK, CONNECTION_AWAITING_RESPONSE, CONNECTION_BAD, CONNECTION_CHECK_TARGET, CONNECTION_CHECK_WRITABLE, CONNECTION_CONSUME, CONNECTION_GSS_STARTUP, CONNECTION_MADE, CONNECTION_NEEDED, CONNECTION_OK, CONNECTION_SETENV, CONNECTION_SSL_STARTUP, CONNECTION_STARTED, connectNoDelay(), pg_conn::connhost, pg_conn::connip, PQExpBufferData::data, EINPROGRESS, EINTR, EnvironmentOptions, ERRCODE_APPNAME_UNKNOWN, pg_conn::errorMessage, EWOULDBLOCK, pg_conn::fbappname, free, gai_strerror, getHostaddr(), getpeereid(), pg_conn::gssencmode, pg_conn_host::host, pg_conn_host::hostaddr, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, IS_AF_UNIX, pg_conn::laddr, PQExpBufferData::len, libpq_gettext, MAXPGPATH, MemSet, pg_conn::nconnhost, NEGOTIATE_GSS_CODE, NEGOTIATE_SSL_CODE, pg_conn::next_eo, NI_MAXHOST, parse_int_param(), PG_DIAG_SQLSTATE, pg_fe_sendauth(), pg_getaddrinfo_all(), pg_GSS_have_cred_cache(), pg_hton32, PG_PROTOCOL, PG_PROTOCOL_MAJOR, 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_host::port, pqBuildStartupPacket2(), pqBuildStartupPacket3(), pqCheckInBufferSpace(), PQclear(), pqClearAsyncResult(), PQconsumeInput(), pqDropConnection(), pqDropServerData(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetpwuid(), PQgetResult(), pqGets_append(), PQgetvalue(), PQisBusy(), PQntuples(), pqPacketSend(), pqReadData(), PQresultErrorField(), PQresultStatus(), pqsecure_initialize(), pqsecure_open_client(), pqsecure_open_gss(), PQsendQuery(), pqSetenvPoll(), PQTRANS_IDLE, printfPQExpBuffer(), pg_conn::pversion, pg_conn::raddr, release_conn_addrinfo(), pg_conn::requirepeer, restoreErrorMessage(), pg_result::resultStatus, SockAddr::salen, saveErrorMessage(), pg_conn::send_appname, sendTerminateConn(), pg_conn::setenv_state, SETENV_STATE_CLIENT_ENCODING_SEND, 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_session_attrs, termPQExpBuffer(), pg_conn::try_next_addr, pg_conn::try_next_host, pg_conn_host::type, UNIXSOCK_PATH, UNIXSOCK_PATH_BUFLEN, useKeepalives(), _internalPQconninfoOption::val, pg_conn::whichhost, and pg_conn::xactStatus.

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

 {
     bool        reset_connection_state_machine = false;
     bool        need_new_connection = false;
     PGresult   *res;
     char        sebuf[PG_STRERROR_R_BUFLEN];
     int         optval;
     PQExpBufferData savedMessage;
 
     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:
             {
                 /* 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;
 
             /* We allow pqSetenvPoll to decide whether to proceed. */
         case CONNECTION_SETENV:
             break;
 
             /* Special cases: proceed without waiting. */
         case CONNECTION_SSL_STARTUP:
         case CONNECTION_NEEDED:
         case CONNECTION_CHECK_WRITABLE:
         case CONNECTION_CONSUME:
         case CONNECTION_GSS_STARTUP:
             break;
 
         default:
             appendPQExpBufferStr(&conn->errorMessage,
                                  libpq_gettext("invalid connection state, probably indicative of memory corruption\n"));
             goto error_return;
     }
 
 
 keep_going:                     /* We will come back to here until there is
                                  * nothing left to do. */
 
     /* Time to advance to next address, or next host if no more addresses? */
     if (conn->try_next_addr)
     {
         if (conn->addr_cur && conn->addr_cur->ai_next)
         {
             conn->addr_cur = conn->addr_cur->ai_next;
             reset_connection_state_machine = true;
         }
         else
             conn->try_next_host = true;
         conn->try_next_addr = false;
     }
 
     /* Time to advance to next connhost[] entry? */
     if (conn->try_next_host)
     {
         pg_conn_host *ch;
         struct addrinfo hint;
         int         thisport;
         int         ret;
         char        portstr[MAXPGPATH];
 
         if (conn->whichhost + 1 >= conn->nconnhost)
         {
             /*
              * Oops, no more hosts.  An appropriate error message is already
              * set up, so just set the right status.
              */
             goto error_return;
         }
         conn->whichhost++;
 
         /* Drop any address info for previous host */
         release_conn_addrinfo(conn);
 
         /*
          * Look up info for the new host.  On failure, log the problem in
          * conn->errorMessage, then loop around to try the next host.  (Note
          * we don't clear try_next_host until we've succeeded.)
          */
         ch = &conn->connhost[conn->whichhost];
 
         /* Initialize hint structure */
         MemSet(&hint, 0, sizeof(hint));
         hint.ai_socktype = SOCK_STREAM;
         conn->addrlist_family = hint.ai_family = AF_UNSPEC;
 
         /* Figure out the port number we're going to use. */
         if (ch->port == NULL || ch->port[0] == '\0')
             thisport = DEF_PGPORT;
         else
         {
             if (!parse_int_param(ch->port, &thisport, conn, "port"))
                 goto error_return;
 
             if (thisport < 1 || thisport > 65535)
             {
                 appendPQExpBuffer(&conn->errorMessage,
                                   libpq_gettext("invalid port number: \"%s\"\n"),
                                   ch->port);
                 goto keep_going;
             }
         }
         snprintf(portstr, sizeof(portstr), "%d", thisport);
 
         /* Use pg_getaddrinfo_all() to resolve the address */
         switch (ch->type)
         {
             case CHT_HOST_NAME:
                 ret = pg_getaddrinfo_all(ch->host, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not translate host name \"%s\" to address: %s\n"),
                                       ch->host, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
 
             case CHT_HOST_ADDRESS:
                 hint.ai_flags = AI_NUMERICHOST;
                 ret = pg_getaddrinfo_all(ch->hostaddr, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not parse network address \"%s\": %s\n"),
                                       ch->hostaddr, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
 
             case CHT_UNIX_SOCKET:
 #ifdef HAVE_UNIX_SOCKETS
                 conn->addrlist_family = hint.ai_family = AF_UNIX;
                 UNIXSOCK_PATH(portstr, thisport, ch->host);
                 if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("Unix-domain socket path \"%s\" is too long (maximum %d bytes)\n"),
                                       portstr,
                                       (int) (UNIXSOCK_PATH_BUFLEN - 1));
                     goto keep_going;
                 }
 
                 /*
                  * NULL hostname tells pg_getaddrinfo_all to parse the service
                  * name as a Unix-domain socket path.
                  */
                 ret = pg_getaddrinfo_all(NULL, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not translate Unix-domain socket path \"%s\" to address: %s\n"),
                                       portstr, gai_strerror(ret));
                     goto keep_going;
                 }
 #else
                 Assert(false);
 #endif
                 break;
         }
 
         /* OK, scan this addrlist for a working server address */
         conn->addr_cur = conn->addrlist;
         reset_connection_state_machine = true;
         conn->try_next_host = false;
     }
 
     /* Reset connection state machine? */
     if (reset_connection_state_machine)
     {
         /*
          * (Re) initialize our connection control variables for a set of
          * connection attempts to a single server address.  These variables
          * must persist across individual connection attempts, but we must
          * reset them when we start to consider a new server.
          */
         conn->pversion = PG_PROTOCOL(3, 0);
         conn->send_appname = true;
 #ifdef USE_SSL
         /* initialize these values based on SSL mode */
         conn->allow_ssl_try = (conn->sslmode[0] != 'd');    /* "disable" */
         conn->wait_ssl_try = (conn->sslmode[0] == 'a'); /* "allow" */
 #endif
 
         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;
         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 error msg */
                     memcpy(&conn->raddr.addr, addr_cur->ai_addr,
                            addr_cur->ai_addrlen);
                     conn->raddr.salen = addr_cur->ai_addrlen;
 
                     /* set connip */
                     if (conn->connip != NULL)
                     {
                         free(conn->connip);
                         conn->connip = NULL;
                     }
 
                     getHostaddr(conn, host_addr, NI_MAXHOST);
                     if (strlen(host_addr) > 0)
                         conn->connip = strdup(host_addr);
 
                     /*
                      * purposely ignore strdup failure; not a big problem if
                      * it fails anyway.
                      */
 
                     conn->sock = socket(addr_cur->ai_family, SOCK_STREAM, 0);
                     if (conn->sock == PGINVALID_SOCKET)
                     {
                         /*
                          * 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;
                         }
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not create socket: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
 
                     /*
                      * Select socket options: no delay of outgoing data for
                      * TCP sockets, nonblock mode, close-on-exec.  Try the
                      * next address if any of this fails.
                      */
                     if (!IS_AF_UNIX(addr_cur->ai_family))
                     {
                         if (!connectNoDelay(conn))
                         {
                             /* error message already created */
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
                     if (!pg_set_noblock(conn->sock))
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not set socket to nonblocking mode: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
 
 #ifdef F_SETFD
                     if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not set socket to close-on-exec mode: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
 #endif                          /* F_SETFD */
 
                     if (!IS_AF_UNIX(addr_cur->ai_family))
                     {
 #ifndef WIN32
                         int         on = 1;
 #endif
                         int         usekeepalives = useKeepalives(conn);
                         int         err = 0;
 
                         if (usekeepalives < 0)
                         {
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("keepalives parameter must be an integer\n"));
                             err = 1;
                         }
                         else if (usekeepalives == 0)
                         {
                             /* Do nothing */
                         }
 #ifndef WIN32
                         else if (setsockopt(conn->sock,
                                             SOL_SOCKET, SO_KEEPALIVE,
                                             (char *) &on, sizeof(on)) < 0)
                         {
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("setsockopt(%s) failed: %s\n"),
                                               "SO_KEEPALIVE",
                                               SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                             err = 1;
                         }
                         else if (!setKeepalivesIdle(conn)
                                  || !setKeepalivesInterval(conn)
                                  || !setKeepalivesCount(conn))
                             err = 1;
 #else                           /* WIN32 */
 #ifdef SIO_KEEPALIVE_VALS
                         else if (!setKeepalivesWin32(conn))
                             err = 1;
 #endif                          /* SIO_KEEPALIVE_VALS */
 #endif                          /* WIN32 */
                         else if (!setTCPUserTimeout(conn))
                             err = 1;
 
                         if (err)
                         {
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
 
                     /*----------
                      * We have three methods of blocking SIGPIPE during
                      * send() calls to this socket:
                      *
                      *  - setsockopt(sock, SO_NOSIGPIPE)
                      *  - send(sock, ..., MSG_NOSIGNAL)
                      *  - setting the signal mask to SIG_IGN during send()
                      *
                      * The third method requires three syscalls per send,
                      * so we prefer either of the first two, but they are
                      * less portable.  The state is tracked in the following
                      * members of PGconn:
                      *
                      * conn->sigpipe_so     - we have set up SO_NOSIGPIPE
                      * conn->sigpipe_flag   - we're specifying MSG_NOSIGNAL
                      *
                      * If we can use SO_NOSIGPIPE, then set sigpipe_so here
                      * and we're done.  Otherwise, set sigpipe_flag so that
                      * we will try MSG_NOSIGNAL on sends.  If we get an error
                      * with MSG_NOSIGNAL, we'll clear that flag and revert to
                      * signal masking.
                      *----------
                      */
                     conn->sigpipe_so = false;
 #ifdef MSG_NOSIGNAL
                     conn->sigpipe_flag = true;
 #else
                     conn->sigpipe_flag = false;
 #endif                          /* MSG_NOSIGNAL */
 
 #ifdef SO_NOSIGPIPE
                     optval = 1;
                     if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
                                    (char *) &optval, sizeof(optval)) == 0)
                     {
                         conn->sigpipe_so = true;
                         conn->sigpipe_flag = false;
                     }
 #endif                          /* SO_NOSIGPIPE */
 
                     /*
                      * Start/make connection.  This should not block, since we
                      * are in nonblock mode.  If it does, well, too bad.
                      */
                     if (connect(conn->sock, addr_cur->ai_addr,
                                 addr_cur->ai_addrlen) < 0)
                     {
                         if (SOCK_ERRNO == EINPROGRESS ||
 #ifdef WIN32
                             SOCK_ERRNO == EWOULDBLOCK ||
 #endif
                             SOCK_ERRNO == EINTR)
                         {
                             /*
                              * This is fine - we're in non-blocking mode, and
                              * the connection is in progress.  Tell caller to
                              * wait for write-ready on socket.
                              */
                             conn->status = CONNECTION_STARTED;
                             return PGRES_POLLING_WRITING;
                         }
                         /* otherwise, trouble */
                     }
                     else
                     {
                         /*
                          * Hm, we're connected already --- seems the "nonblock
                          * connection" wasn't.  Advance the state machine and
                          * go do the next stuff.
                          */
                         conn->status = CONNECTION_STARTED;
                         goto keep_going;
                     }
 
                     /*
                      * This connection failed.  Add the error report to
                      * conn->errorMessage, then try the next address if any.
                      */
                     connectFailureMessage(conn, SOCK_ERRNO);
                     conn->try_next_addr = true;
                     goto keep_going;
                 }
             }
 
         case CONNECTION_STARTED:
             {
                 ACCEPT_TYPE_ARG3 optlen = sizeof(optval);
 
                 /*
                  * Write ready, since we've made it here, so the connection
                  * has been made ... or has failed.
                  */
 
                 /*
                  * Now check (using getsockopt) that there is not an error
                  * state waiting for us on the socket.
                  */
 
                 if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
                                (char *) &optval, &optlen) == -1)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not get socket error status: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
                 else if (optval != 0)
                 {
                     /*
                      * When using a nonblocking connect, we will typically see
                      * connect failures at this point, so provide a friendly
                      * error message.
                      */
                     connectFailureMessage(conn, optval);
 
                     /*
                      * Try the next address if any, just as in the case where
                      * connect() returned failure immediately.
                      */
                     conn->try_next_addr = true;
                     goto keep_going;
                 }
 
                 /* Fill in the client address */
                 conn->laddr.salen = sizeof(conn->laddr.addr);
                 if (getsockname(conn->sock,
                                 (struct sockaddr *) &conn->laddr.addr,
                                 &conn->laddr.salen) < 0)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not get client address from socket: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
 
                 /*
                  * Make sure we can write before advancing to next step.
                  */
                 conn->status = CONNECTION_MADE;
                 return PGRES_POLLING_WRITING;
             }
 
         case CONNECTION_MADE:
             {
                 char       *startpacket;
                 int         packetlen;
 
                 /*
                  * Implement requirepeer check, if requested and it's a
                  * Unix-domain socket.
                  */
                 if (conn->requirepeer && conn->requirepeer[0] &&
                     IS_AF_UNIX(conn->raddr.addr.ss_family))
                 {
 #ifndef WIN32
                     char        pwdbuf[BUFSIZ];
                     struct passwd pass_buf;
                     struct passwd *pass;
                     int         passerr;
 #endif
                     uid_t       uid;
                     gid_t       gid;
 
                     errno = 0;
                     if (getpeereid(conn->sock, &uid, &gid) != 0)
                     {
                         /*
                          * Provide special error message if getpeereid is a
                          * stub
                          */
                         if (errno == ENOSYS)
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("requirepeer parameter is not supported on this platform\n"));
                         else
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("could not get peer credentials: %s\n"),
                                               strerror_r(errno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
 
 #ifndef WIN32
                     passerr = pqGetpwuid(uid, &pass_buf, pwdbuf, sizeof(pwdbuf), &pass);
                     if (pass == NULL)
                     {
                         if (passerr != 0)
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("could not look up local user ID %d: %s\n"),
                                               (int) uid,
                                               strerror_r(passerr, sebuf, sizeof(sebuf)));
                         else
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("local user with ID %d does not exist\n"),
                                               (int) uid);
                         goto error_return;
                     }
 
                     if (strcmp(pass->pw_name, conn->requirepeer) != 0)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n"),
                                           conn->requirepeer, pass->pw_name);
                         goto error_return;
                     }
 #else                           /* WIN32 */
                     /* should have failed with ENOSYS above */
                     Assert(false);
 #endif                          /* WIN32 */
                 }
 
                 if (IS_AF_UNIX(conn->raddr.addr.ss_family))
                 {
                     /* Don't request SSL or GSSAPI over Unix sockets */
 #ifdef USE_SSL
                     conn->allow_ssl_try = false;
 #endif
 #ifdef ENABLE_GSS
                     conn->try_gss = false;
 #endif
                 }
 
 #ifdef ENABLE_GSS
 
                 /*
                  * If GSSAPI encryption is enabled, then call
                  * pg_GSS_have_cred_cache() which will return true if we can
                  * acquire credentials (and give us a handle to use in
                  * conn->gcred), and then send a packet to the server asking
                  * for GSSAPI Encryption (and skip past SSL negotiation and
                  * regular startup below).
                  */
                 if (conn->try_gss && !conn->gctx)
                     conn->try_gss = pg_GSS_have_cred_cache(&conn->gcred);
                 if (conn->try_gss && !conn->gctx)
                 {
                     ProtocolVersion pv = pg_hton32(NEGOTIATE_GSS_CODE);
 
                     if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not send GSSAPI negotiation packet: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
 
                     /* Ok, wait for response */
                     conn->status = CONNECTION_GSS_STARTUP;
                     return PGRES_POLLING_READING;
                 }
                 else if (!conn->gctx && conn->gssencmode[0] == 'r')
                 {
                     appendPQExpBufferStr(&conn->errorMessage,
                                          libpq_gettext("GSSAPI encryption required but was impossible (possibly no credential cache, no server support, or using a local socket)\n"));
                     goto error_return;
                 }
 #endif
 
 #ifdef USE_SSL
 
                 /*
                  * If SSL is enabled and we haven't already got it running,
                  * request it instead of sending the startup message.
                  */
                 if (conn->allow_ssl_try && !conn->wait_ssl_try &&
                     !conn->ssl_in_use)
                 {
                     ProtocolVersion pv;
 
                     /*
                      * Send the SSL request packet.
                      *
                      * Theoretically, this could block, but it really
                      * shouldn't since we only got here if the socket is
                      * write-ready.
                      */
                     pv = pg_hton32(NEGOTIATE_SSL_CODE);
                     if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not send SSL negotiation packet: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
                     /* Ok, wait for response */
                     conn->status = CONNECTION_SSL_STARTUP;
                     return PGRES_POLLING_READING;
                 }
 #endif                          /* USE_SSL */
 
                 /*
                  * Build the startup packet.
                  */
                 if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                     startpacket = pqBuildStartupPacket3(conn, &packetlen,
                                                         EnvironmentOptions);
                 else
                     startpacket = pqBuildStartupPacket2(conn, &packetlen,
                                                         EnvironmentOptions);
                 if (!startpacket)
                 {
                     /*
                      * will not appendbuffer here, since it's likely to also
                      * run out of memory
                      */
                     printfPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("out of memory\n"));
                     goto error_return;
                 }
 
                 /*
                  * Send the startup packet.
                  *
                  * Theoretically, this could block, but it really shouldn't
                  * since we only got here if the socket is write-ready.
                  */
                 if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not send startup packet: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     free(startpacket);
                     goto error_return;
                 }
 
                 free(startpacket);
 
                 conn->status = CONNECTION_AWAITING_RESPONSE;
                 return PGRES_POLLING_READING;
             }
 
             /*
              * Handle SSL negotiation: wait for postmaster messages and
              * respond as necessary.
              */
         case CONNECTION_SSL_STARTUP:
             {
 #ifdef USE_SSL
                 PostgresPollingStatusType pollres;
 
                 /*
                  * On first time through, get the postmaster's response to our
                  * SSL negotiation packet.
                  */
                 if (!conn->ssl_in_use)
                 {
                     /*
                      * We use pqReadData here since it has the logic to
                      * distinguish no-data-yet from connection closure. Since
                      * conn->ssl isn't set, a plain recv() will occur.
                      */
                     char        SSLok;
                     int         rdresult;
 
                     rdresult = pqReadData(conn);
                     if (rdresult < 0)
                     {
                         /* errorMessage is already filled in */
                         goto error_return;
                     }
                     if (rdresult == 0)
                     {
                         /* caller failed to wait for data */
                         return PGRES_POLLING_READING;
                     }
                     if (pqGetc(&SSLok, conn) < 0)
                     {
                         /* should not happen really */
                         return PGRES_POLLING_READING;
                     }
                     if (SSLok == 'S')
                     {
                         /* mark byte consumed */
                         conn->inStart = conn->inCursor;
                         /* Set up global SSL state if required */
                         if (pqsecure_initialize(conn) != 0)
                             goto error_return;
                     }
                     else if (SSLok == 'N')
                     {
                         /* mark byte consumed */
                         conn->inStart = conn->inCursor;
                         /* OK to do without SSL? */
                         if (conn->sslmode[0] == 'r' ||  /* "require" */
                             conn->sslmode[0] == 'v')    /* "verify-ca" or
                                                          * "verify-full" */
                         {
                             /* Require SSL, but server does not want it */
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("server does not support SSL, but SSL was required\n"));
                             goto error_return;
                         }
                         /* Otherwise, proceed with normal startup */
                         conn->allow_ssl_try = false;
                         conn->status = CONNECTION_MADE;
                         return PGRES_POLLING_WRITING;
                     }
                     else if (SSLok == 'E')
                     {
                         /*
                          * Server failure of some sort, such as failure to
                          * fork a backend process.  We need to process and
                          * report the error message, which might be formatted
                          * according to either protocol 2 or protocol 3.
                          * Rather than duplicate the code for that, we flip
                          * into AWAITING_RESPONSE state and let the code there
                          * deal with it.  Note we have *not* consumed the "E"
                          * byte here.
                          */
                         conn->status = CONNECTION_AWAITING_RESPONSE;
                         goto keep_going;
                     }
                     else
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("received invalid response to SSL negotiation: %c\n"),
                                           SSLok);
                         goto error_return;
                     }
                 }
 
                 /*
                  * Begin or continue the SSL negotiation process.
                  */
                 pollres = pqsecure_open_client(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /* SSL handshake done, ready to send startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 if (pollres == PGRES_POLLING_FAILED)
                 {
                     /*
                      * Failed ... if sslmode is "prefer" then do a non-SSL
                      * retry
                      */
                     if (conn->sslmode[0] == 'p' /* "prefer" */
                         && conn->allow_ssl_try  /* redundant? */
                         && !conn->wait_ssl_try) /* redundant? */
                     {
                         /* only retry once */
                         conn->allow_ssl_try = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
                     /* Else it's a hard failure */
                     goto error_return;
                 }
                 /* Else, return POLLING_READING or POLLING_WRITING status */
                 return pollres;
 #else                           /* !USE_SSL */
                 /* can't get here */
                 goto error_return;
 #endif                          /* USE_SSL */
             }
 
         case CONNECTION_GSS_STARTUP:
             {
 #ifdef ENABLE_GSS
                 PostgresPollingStatusType pollres;
 
                 /*
                  * If we haven't yet, get the postmaster's response to our
                  * negotiation packet
                  */
                 if (conn->try_gss && !conn->gctx)
                 {
                     char        gss_ok;
                     int         rdresult = pqReadData(conn);
 
                     if (rdresult < 0)
                         /* pqReadData fills in error message */
                         goto error_return;
                     else if (rdresult == 0)
                         /* caller failed to wait for data */
                         return PGRES_POLLING_READING;
                     if (pqGetc(&gss_ok, conn) < 0)
                         /* shouldn't happen... */
                         return PGRES_POLLING_READING;
 
                     if (gss_ok == 'E')
                     {
                         /*
                          * Server failure of some sort.  Assume it's a
                          * protocol version support failure, and let's see if
                          * we can't recover (if it's not, we'll get a better
                          * error message on retry).  Server gets fussy if we
                          * don't hang up the socket, though.
                          */
                         conn->try_gss = false;
                         pqDropConnection(conn, true);
                         conn->status = CONNECTION_NEEDED;
                         goto keep_going;
                     }
 
                     /* mark byte consumed */
                     conn->inStart = conn->inCursor;
 
                     if (gss_ok == 'N')
                     {
                         /* Server doesn't want GSSAPI; fall back if we can */
                         if (conn->gssencmode[0] == 'r')
                         {
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("server doesn't support GSSAPI encryption, but it was required\n"));
                             goto error_return;
                         }
 
                         conn->try_gss = false;
                         conn->status = CONNECTION_MADE;
                         return PGRES_POLLING_WRITING;
                     }
                     else if (gss_ok != 'G')
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("received invalid response to GSSAPI negotiation: %c\n"),
                                           gss_ok);
                         goto error_return;
                     }
                 }
 
                 /* Begin or continue GSSAPI negotiation */
                 pollres = pqsecure_open_gss(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /* All set for startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 else if (pollres == PGRES_POLLING_FAILED &&
                          conn->gssencmode[0] == 'p')
                 {
                     /*
                      * We failed, but we can retry on "prefer".  Have to drop
                      * the current connection to do so, though.
                      */
                     conn->try_gss = false;
                     pqDropConnection(conn, true);
                     conn->status = CONNECTION_NEEDED;
                     goto keep_going;
                 }
                 return pollres;
 #else                           /* !ENABLE_GSS */
                 /* unreachable */
                 goto error_return;
 #endif                          /* ENABLE_GSS */
             }
 
             /*
              * Handle authentication exchange: wait for postmaster messages
              * and respond as necessary.
              */
         case CONNECTION_AWAITING_RESPONSE:
             {
                 char        beresp;
                 int         msgLength;
                 int         avail;
                 AuthRequest areq;
                 int         res;
 
                 /*
                  * Scan the message from current point (note that if we find
                  * the message is incomplete, we will return without advancing
                  * inStart, and resume here next time).
                  */
                 conn->inCursor = conn->inStart;
 
                 /* Read type byte */
                 if (pqGetc(&beresp, conn))
                 {
                     /* We'll come back when there is more data */
                     return PGRES_POLLING_READING;
                 }
 
                 /*
                  * Validate message type: we expect only an authentication
                  * request or an error here.  Anything else probably means
                  * it's not Postgres on the other end at all.
                  */
                 if (!(beresp == 'R' || beresp == 'E'))
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("expected authentication request from server, but received %c\n"),
                                       beresp);
                     goto error_return;
                 }
 
                 if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                 {
                     /* Read message length word */
                     if (pqGetInt(&msgLength, 4, conn))
                     {
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                 }
                 else
                 {
                     /* Set phony message length to disable checks below */
                     msgLength = 8;
                 }
 
                 /*
                  * Try to validate message length before using it.
                  * Authentication requests can't be very large, although GSS
                  * auth requests may not be that small.  Errors can be a
                  * little larger, but not huge.  If we see a large apparent
                  * length in an error, it means we're really talking to a
                  * pre-3.0-protocol server; cope.
                  */
                 if (beresp == 'R' && (msgLength < 8 || msgLength > 2000))
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("expected authentication request from server, but received %c\n"),
                                       beresp);
                     goto error_return;
                 }
 
                 if (beresp == 'E' && (msgLength < 8 || msgLength > 30000))
                 {
                     /* Handle error from a pre-3.0 server */
                     conn->inCursor = conn->inStart + 1; /* reread data */
                     if (pqGets_append(&conn->errorMessage, conn))
                     {
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                     /* OK, we read the message; mark data consumed */
                     conn->inStart = conn->inCursor;
 
                     /*
                      * The postmaster typically won't end its message with a
                      * newline, so add one to conform to libpq conventions.
                      */
                     appendPQExpBufferChar(&conn->errorMessage, '\n');
 
                     /*
                      * If we tried to open the connection in 3.0 protocol,
                      * fall back to 2.0 protocol.
                      */
                     if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                     {
                         conn->pversion = PG_PROTOCOL(2, 0);
                         need_new_connection = true;
                         goto keep_going;
                     }
 
                     goto error_return;
                 }
 
                 /*
                  * Can't process if message body isn't all here yet.
                  *
                  * (In protocol 2.0 case, we are assuming messages carry at
                  * least 4 bytes of data.)
                  */
                 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 (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                     {
                         if (pqGetErrorNotice3(conn, true))
                         {
                             /* We'll come back when there is more data */
                             return PGRES_POLLING_READING;
                         }
                     }
                     else
                     {
                         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;
 
                     /* 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')
                     {
                         OM_uint32   minor;
 
                         /* postmaster expects us to drop the connection */
                         conn->try_gss = false;
                         conn->gssenc = false;
                         gss_delete_sec_context(&minor, &conn->gctx, NULL);
                         pqDropConnection(conn, true);
                         conn->status = CONNECTION_NEEDED;
                         goto keep_going;
                     }
 #endif
 
 #ifdef USE_SSL
 
                     /*
                      * if sslmode is "allow" and we haven't tried an SSL
                      * connection already, then retry with an SSL connection
                      */
                     if (conn->sslmode[0] == 'a' /* "allow" */
                         && !conn->ssl_in_use
                         && conn->allow_ssl_try
                         && conn->wait_ssl_try)
                     {
                         /* only retry once */
                         conn->wait_ssl_try = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
 
                     /*
                      * if sslmode is "prefer" and we're in an SSL connection,
                      * then do a non-SSL retry
                      */
                     if (conn->sslmode[0] == 'p' /* "prefer" */
                         && conn->ssl_in_use
                         && conn->allow_ssl_try  /* redundant? */
                         && !conn->wait_ssl_try) /* redundant? */
                     {
                         /* only retry once */
                         conn->allow_ssl_try = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
 #endif
 
                     goto error_return;
                 }
 
                 /* It is an authentication request. */
                 conn->auth_req_received = true;
 
                 /* Get the type of request. */
                 if (pqGetInt((int *) &areq, 4, conn))
                 {
                     /* We'll come back when there are more data */
                     return PGRES_POLLING_READING;
                 }
                 msgLength -= 4;
 
                 /*
                  * Ensure the password salt is in the input buffer, if it's an
                  * MD5 request.  All the other authentication methods that
                  * contain extra data in the authentication request are only
                  * supported in protocol version 3, in which case we already
                  * read the whole message above.
                  */
                 if (areq == AUTH_REQ_MD5 && PG_PROTOCOL_MAJOR(conn->pversion) < 3)
                 {
                     msgLength += 4;
 
                     avail = conn->inEnd - conn->inCursor;
                     if (avail < 4)
                     {
                         /*
                          * 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) 4,
                                                  conn))
                             goto error_return;
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                 }
 
                 /*
                  * 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);
                 conn->errorMessage.len = strlen(conn->errorMessage.data);
 
                 /* OK, we have processed the message; mark data consumed */
                 conn->inStart = conn->inCursor;
 
                 if (res != STATUS_OK)
                     goto error_return;
 
                 /*
                  * Just make sure that any data sent by pg_fe_sendauth is
                  * flushed out.  Although this theoretically could block, it
                  * really shouldn't since we don't send large auth responses.
                  */
                 if (pqFlush(conn))
                     goto error_return;
 
                 if (areq == AUTH_REQ_OK)
                 {
                     /* We are done with authentication exchange */
                     conn->status = CONNECTION_AUTH_OK;
 
                     /*
                      * Set asyncStatus so that PQgetResult will think that
                      * what comes back next is the result of a query.  See
                      * below.
                      */
                     conn->asyncStatus = PGASYNC_BUSY;
                 }
 
                 /* Look to see if we have more data yet. */
                 goto keep_going;
             }
 
         case CONNECTION_AUTH_OK:
             {
                 /*
                  * Now we expect to hear from the backend. A ReadyForQuery
                  * message indicates that startup is successful, but we might
                  * also get an Error message indicating failure. (Notice
                  * messages indicating nonfatal warnings are also allowed by
                  * the protocol, as are ParameterStatus and BackendKeyData
                  * messages.) Easiest way to handle this is to let
                  * PQgetResult() read the messages. We just have to fake it
                  * out about the state of the connection, by setting
                  * asyncStatus = PGASYNC_BUSY (done above).
                  */
 
                 if (PQisBusy(conn))
                     return PGRES_POLLING_READING;
 
                 res = PQgetResult(conn);
 
                 /*
                  * NULL return indicating we have gone to IDLE state is
                  * expected
                  */
                 if (res)
                 {
                     if (res->resultStatus != PGRES_FATAL_ERROR)
                         appendPQExpBufferStr(&conn->errorMessage,
                                              libpq_gettext("unexpected message from server during startup\n"));
                     else if (conn->send_appname &&
                              (conn->appname || conn->fbappname))
                     {
                         /*
                          * If we tried to send application_name, check to see
                          * if the error is about that --- pre-9.0 servers will
                          * reject it at this stage of the process.  If so,
                          * close the connection and retry without sending
                          * application_name.  We could possibly get a false
                          * SQLSTATE match here and retry uselessly, but there
                          * seems no great harm in that; we'll just get the
                          * same error again if it's unrelated.
                          */
                         const char *sqlstate;
 
                         sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
                         if (sqlstate &&
                             strcmp(sqlstate, ERRCODE_APPNAME_UNKNOWN) == 0)
                         {
                             PQclear(res);
                             conn->send_appname = false;
                             need_new_connection = true;
                             goto keep_going;
                         }
                     }
 
                     /*
                      * if the resultStatus is FATAL, then conn->errorMessage
                      * already has a copy of the error; needn't copy it back.
                      * But add a newline if it's not there already, since
                      * postmaster error messages may not have one.
                      */
                     if (conn->errorMessage.len <= 0 ||
                         conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
                         appendPQExpBufferChar(&conn->errorMessage, '\n');
                     PQclear(res);
                     goto error_return;
                 }
 
                 /* Fire up post-connection housekeeping if needed */
                 if (PG_PROTOCOL_MAJOR(conn->pversion) < 3)
                 {
                     conn->status = CONNECTION_SETENV;
                     conn->setenv_state = SETENV_STATE_CLIENT_ENCODING_SEND;
                     conn->next_eo = EnvironmentOptions;
                     return PGRES_POLLING_WRITING;
                 }
 
                 /* Almost there now ... */
                 conn->status = CONNECTION_CHECK_TARGET;
                 goto keep_going;
             }
 
         case CONNECTION_CHECK_TARGET:
             {
                 /*
                  * If a read-write connection is required, see if we have one.
                  *
                  * Servers before 7.4 lack the transaction_read_only GUC, but
                  * by the same token they don't have any read-only mode, so we
                  * may just skip the test in that case.
                  */
                 if (conn->sversion >= 70400 &&
                     conn->target_session_attrs != NULL &&
                     strcmp(conn->target_session_attrs, "read-write") == 0)
                 {
                     /*
                      * Save existing error messages across the PQsendQuery
                      * attempt.  This is necessary because PQsendQuery is
                      * going to reset conn->errorMessage, so we would lose
                      * error messages related to previous hosts we have tried
                      * and failed to connect to.
                      */
                     if (!saveErrorMessage(conn, &savedMessage))
                         goto error_return;
 
                     conn->status = CONNECTION_OK;
                     if (!PQsendQuery(conn,
                                      "SHOW transaction_read_only"))
                     {
                         restoreErrorMessage(conn, &savedMessage);
                         goto error_return;
                     }
                     conn->status = CONNECTION_CHECK_WRITABLE;
                     restoreErrorMessage(conn, &savedMessage);
                     return PGRES_POLLING_READING;
                 }
 
                 /* We can release the address list now. */
                 release_conn_addrinfo(conn);
 
                 /* We are open for business! */
                 conn->status = CONNECTION_OK;
                 return PGRES_POLLING_OK;
             }
 
         case CONNECTION_SETENV:
             {
                 /*
                  * Do post-connection housekeeping (only needed in protocol
                  * 2.0).
                  *
                  * We pretend that the connection is OK for the duration of
                  * these queries.
                  */
                 conn->status = CONNECTION_OK;
 
                 switch (pqSetenvPoll(conn))
                 {
                     case PGRES_POLLING_OK:  /* Success */
                         break;
 
                     case PGRES_POLLING_READING: /* Still going */
                         conn->status = CONNECTION_SETENV;
                         return PGRES_POLLING_READING;
 
                     case PGRES_POLLING_WRITING: /* Still going */
                         conn->status = CONNECTION_SETENV;
                         return PGRES_POLLING_WRITING;
 
                     default:
                         goto error_return;
                 }
 
                 /* Almost there now ... */
                 conn->status = CONNECTION_CHECK_TARGET;
                 goto keep_going;
             }
 
         case CONNECTION_CONSUME:
             {
                 conn->status = CONNECTION_OK;
                 if (!PQconsumeInput(conn))
                     goto error_return;
 
                 if (PQisBusy(conn))
                 {
                     conn->status = CONNECTION_CONSUME;
                     return PGRES_POLLING_READING;
                 }
 
                 /*
                  * Call PQgetResult() again to consume NULL result.
                  */
                 res = PQgetResult(conn);
                 if (res != NULL)
                 {
                     PQclear(res);
                     conn->status = CONNECTION_CONSUME;
                     goto keep_going;
                 }
 
                 /* We can release the address list now. */
                 release_conn_addrinfo(conn);
 
                 /* We are open for business! */
                 conn->status = CONNECTION_OK;
                 return PGRES_POLLING_OK;
             }
         case CONNECTION_CHECK_WRITABLE:
             {
                 const char *displayed_host;
                 const char *displayed_port;
 
                 if (!saveErrorMessage(conn, &savedMessage))
                     goto error_return;
 
                 conn->status = CONNECTION_OK;
                 if (!PQconsumeInput(conn))
                 {
                     restoreErrorMessage(conn, &savedMessage);
                     goto error_return;
                 }
 
                 if (PQisBusy(conn))
                 {
                     conn->status = CONNECTION_CHECK_WRITABLE;
                     restoreErrorMessage(conn, &savedMessage);
                     return PGRES_POLLING_READING;
                 }
 
                 res = PQgetResult(conn);
                 if (res && (PQresultStatus(res) == PGRES_TUPLES_OK) &&
                     PQntuples(res) == 1)
                 {
                     char       *val;
 
                     val = PQgetvalue(res, 0, 0);
                     if (strncmp(val, "on", 2) == 0)
                     {
                         /* Not writable; fail this connection. */
                         PQclear(res);
                         restoreErrorMessage(conn, &savedMessage);
 
                         /* Append error report to conn->errorMessage. */
                         if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS)
                             displayed_host = conn->connhost[conn->whichhost].hostaddr;
                         else
                             displayed_host = conn->connhost[conn->whichhost].host;
                         displayed_port = conn->connhost[conn->whichhost].port;
                         if (displayed_port == NULL || displayed_port[0] == '\0')
                             displayed_port = DEF_PGPORT_STR;
 
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not make a writable "
                                                         "connection to server "
                                                         "\"%s:%s\"\n"),
                                           displayed_host, displayed_port);
 
                         /* 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;
                     }
 
                     /* Session is read-write, so we're good. */
                     PQclear(res);
                     termPQExpBuffer(&savedMessage);
 
                     /*
                      * Finish reading any remaining messages before being
                      * considered as ready.
                      */
                     conn->status = CONNECTION_CONSUME;
                     goto keep_going;
                 }
 
                 /*
                  * Something went wrong with "SHOW transaction_read_only". We
                  * should try next addresses.
                  */
                 if (res)
                     PQclear(res);
                 restoreErrorMessage(conn, &savedMessage);
 
                 /* Append error report to conn->errorMessage. */
                 if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS)
                     displayed_host = conn->connhost[conn->whichhost].hostaddr;
                 else
                     displayed_host = conn->connhost[conn->whichhost].host;
                 displayed_port = conn->connhost[conn->whichhost].port;
                 if (displayed_port == NULL || displayed_port[0] == '\0')
                     displayed_port = DEF_PGPORT_STR;
                 appendPQExpBuffer(&conn->errorMessage,
                                   libpq_gettext("test \"SHOW transaction_read_only\" failed "
                                                 "on server \"%s:%s\"\n"),
                                   displayed_host, displayed_port);
 
                 /* Close connection politely. */
                 conn->status = CONNECTION_OK;
                 sendTerminateConn(conn);
 
                 /* Try next address */
                 conn->try_next_addr = true;
                 goto keep_going;
             }
 
         default:
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("invalid connection state %d, "
                                             "probably indicative of memory corruption\n"),
                               conn->status);
             goto error_return;
     }
 
     /* Unreachable */
 
 error_return:
 
     /*
      * We used to close the socket at this point, but that makes it awkward
      * for those above us if they wish to remove this socket from their own
      * records (an fd_set for example).  We'll just have this socket closed
      * when PQfinish is called (which is compulsory even after an error, since
      * the connection structure must be freed).
      */
     conn->status = CONNECTION_BAD;
     return PGRES_POLLING_FAILED;
 }

◆ PQconnectStart()

PGconn* PQconnectStart ( const char * conninfo )

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

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

Referenced by PQconnectdb(), and PQping().

 {
     PGconn     *conn;
 
     /*
      * Allocate memory for the conn structure
      */
     conn = makeEmptyPGconn();
     if (conn == NULL)
         return NULL;
 
     /*
      * Parse the conninfo string
      */
     if (!connectOptions1(conn, conninfo))
         return conn;
 
     /*
      * Compute derived options
      */
     if (!connectOptions2(conn))
         return conn;
 
     /*
      * Connect to the database
      */
     if (!connectDBStart(conn))
     {
         /* Just in case we failed to set it in connectDBStart */
         conn->status = CONNECTION_BAD;
     }
 
     return conn;
 }

◆ PQconnectStartParams()

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

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

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

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

 {
     PGconn     *conn;
     PQconninfoOption *connOptions;
 
     /*
      * Allocate memory for the conn structure
      */
     conn = makeEmptyPGconn();
     if (conn == NULL)
         return NULL;
 
     /*
      * Parse the conninfo arrays
      */
     connOptions = conninfo_array_parse(keywords, values,
                                        &conn->errorMessage,
                                        true, expand_dbname);
     if (connOptions == NULL)
     {
         conn->status = CONNECTION_BAD;
         /* errorMessage is already set */
         return conn;
     }
 
     /*
      * Move option values into conn structure
      */
     if (!fillPGconn(conn, connOptions))
     {
         PQconninfoFree(connOptions);
         return conn;
     }
 
     /*
      * Free the option info - all is in conn now
      */
     PQconninfoFree(connOptions);
 
     /*
      * Compute derived options
      */
     if (!connectOptions2(conn))
         return conn;
 
     /*
      * Connect to the database
      */
     if (!connectDBStart(conn))
     {
         /* Just in case we failed to set it in connectDBStart */
         conn->status = CONNECTION_BAD;
     }
 
     return conn;
 }

◆ PQconninfo()

PQconninfoOption* PQconninfo ( PGconn * conn )

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

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

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

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

◆ PQconninfoFree()

void PQconninfoFree ( PQconninfoOption * connOptions )

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

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

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

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

◆ PQconninfoParse()

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

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

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

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

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

◆ PQconsumeInput()

int PQconsumeInput ( PGconn * conn )

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

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

Referenced by advanceConnectionState(), CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), ecpg_process_output(), libpqrcv_PQgetResult(), libpqrcv_receive(), main(), ParallelSlotsGetIdle(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PQconnectPoll(), PrintNotifications(), StreamLogicalLog(), and try_complete_step().

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

◆ PQcopyResult()

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

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

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

Referenced by pqRowProcessor().

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

◆ PQdb()

char* PQdb ( const PGconn * conn )

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

References pg_conn::dbName.

Referenced by _connectDB(), CloneArchive(), cluster_one_database(), ConnectDatabase(), do_connect(), exec_command_conninfo(), get_prompt(), GetTableInfo(), processQueryResult(), ReconnectToServer(), reindex_one_database(), run_reindex_command(), run_vacuum_command(), slashUsage(), SyncVariables(), vacuum_one_database(), and WriteHead().

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

◆ PQdefaultSSLKeyPassHook_OpenSSL()

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

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

References fprintf, libpq_gettext, and pg_conn::sslpassword.

Referenced by PQssl_passwd_cb().

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

◆ PQdescribePortal()

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

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

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

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

◆ PQdescribePrepared()

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

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

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

Referenced by DescribeQuery(), and ECPGdescribe().

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

◆ PQdisplayTuples()

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

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

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

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

◆ PQdsplen()

int PQdsplen	(	const char *	s,
		int	encoding
	)

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

References pg_encoding_dsplen().

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

 {
     return pg_encoding_dsplen(encoding, s);
 }

◆ PQencryptPassword()

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

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

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

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

◆ PQencryptPasswordConn()

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

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

References pg_conn::errorMessage, free, libpq_gettext, malloc, MAX_ALGORITHM_NAME_LEN, MD5_PASSWD_LEN, pg_fe_scram_build_secret(), pg_md5_encrypt(), PGRES_TUPLES_OK, PQclear(), PQexec(), PQgetvalue(), PQnfields(), PQntuples(), PQresultStatus(), printfPQExpBuffer(), and val.

Referenced by exec_command_password(), and main().

 {
 #define MAX_ALGORITHM_NAME_LEN 50
     char        algobuf[MAX_ALGORITHM_NAME_LEN + 1];
     char       *crypt_pwd = NULL;
 
     if (!conn)
         return NULL;
 
     /* 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);
             printfPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("unexpected shape of result set returned for SHOW\n"));
             return NULL;
         }
         val = PQgetvalue(res, 0, 0);
 
         if (strlen(val) > MAX_ALGORITHM_NAME_LEN)
         {
             PQclear(res);
             printfPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("password_encryption value too long\n"));
             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)
     {
         crypt_pwd = pg_fe_scram_build_secret(passwd);
     }
     else if (strcmp(algorithm, "md5") == 0)
     {
         crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
         if (crypt_pwd)
         {
             if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd))
             {
                 free(crypt_pwd);
                 crypt_pwd = NULL;
             }
         }
     }
     else
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("unrecognized password encryption algorithm \"%s\"\n"),
                           algorithm);
         return NULL;
     }
 
     if (!crypt_pwd)
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("out of memory\n"));
 
     return crypt_pwd;
 }

◆ PQendcopy()

int PQendcopy ( PGconn * conn )

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

References PG_PROTOCOL_MAJOR, pqEndcopy2(), pqEndcopy3(), and pg_conn::pversion.

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

 {
     if (!conn)
         return 0;
 
     if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
         return pqEndcopy3(conn);
     else
         return pqEndcopy2(conn);
 }

◆ PQenv2encoding()

int PQenv2encoding ( void )

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

References dgettext, dngettext, encoding, libpq_gettext, libpq_ngettext, pg_char_to_encoding(), PG_SQL_ASCII, PG_TEXTDOMAIN, and generate_unaccent_rules::str.

Referenced by main().

 {
     char       *str;
     int         encoding = PG_SQL_ASCII;

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ PG_COPYRES_ATTRS

◆ PG_COPYRES_EVENTS

◆ PG_COPYRES_NOTICEHOOKS

◆ PG_COPYRES_TUPLES

◆ PQfreeNotify

◆ PQnoPasswordSupplied

◆ PQsetdb

Typedef Documentation

◆ PGcancel

◆ PGconn

◆ PGnotify

◆ PGresAttDesc

◆ PGresult

◆ pgthreadlock_t

◆ pqbool

◆ PQconninfoOption

◆ PQnoticeProcessor

◆ PQnoticeReceiver

◆ PQprintOpt

◆ PQsslKeyPassHook_OpenSSL_type

Enumeration Type Documentation

◆ ConnStatusType

◆ ExecStatusType

◆ PGContextVisibility

◆ PGPing

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

◆ PQcopyResult()

◆ PQdb()

◆ PQdefaultSSLKeyPassHook_OpenSSL()

◆ PQdescribePortal()

◆ PQdescribePrepared()

◆ PQdisplayTuples()

◆ PQdsplen()