PostgreSQL Source Code git master
libpq-fe.h File Reference
#include <stdio.h>
#include "postgres_ext.h"
Include dependency graph for libpq-fe.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

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

Macros

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

Typedefs

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

Enumerations

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

Functions

PGconnPQconnectStart (const char *conninfo)
 
PGconnPQconnectStartParams (const char *const *keywords, const char *const *values, int expand_dbname)
 
PostgresPollingStatusType PQconnectPoll (PGconn *conn)
 
PGconnPQconnectdb (const char *conninfo)
 
PGconnPQconnectdbParams (const char *const *keywords, const char *const *values, int expand_dbname)
 
PGconnPQsetdbLogin (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)
 
PQconninfoOptionPQconndefaults (void)
 
PQconninfoOptionPQconninfoParse (const char *conninfo, char **errmsg)
 
PQconninfoOptionPQconninfo (PGconn *conn)
 
void PQconninfoFree (PQconninfoOption *connOptions)
 
int PQresetStart (PGconn *conn)
 
PostgresPollingStatusType PQresetPoll (PGconn *conn)
 
void PQreset (PGconn *conn)
 
PGcancelConnPQcancelCreate (PGconn *conn)
 
int PQcancelStart (PGcancelConn *cancelConn)
 
int PQcancelBlocking (PGcancelConn *cancelConn)
 
PostgresPollingStatusType PQcancelPoll (PGcancelConn *cancelConn)
 
ConnStatusType PQcancelStatus (const PGcancelConn *cancelConn)
 
int PQcancelSocket (const PGcancelConn *cancelConn)
 
char * PQcancelErrorMessage (const PGcancelConn *cancelConn)
 
void PQcancelReset (PGcancelConn *cancelConn)
 
void PQcancelFinish (PGcancelConn *cancelConn)
 
PGcancelPQgetCancel (PGconn *conn)
 
void PQfreeCancel (PGcancel *cancel)
 
int PQcancel (PGcancel *cancel, char *errbuf, int errbufsize)
 
int PQrequestCancel (PGconn *conn)
 
char * PQdb (const PGconn *conn)
 
char * PQservice (const PGconn *conn)
 
char * PQuser (const PGconn *conn)
 
char * PQpass (const PGconn *conn)
 
char * PQhost (const PGconn *conn)
 
char * PQhostaddr (const PGconn *conn)
 
char * PQport (const PGconn *conn)
 
char * PQtty (const PGconn *conn)
 
char * PQoptions (const PGconn *conn)
 
ConnStatusType PQstatus (const PGconn *conn)
 
PGTransactionStatusType PQtransactionStatus (const PGconn *conn)
 
const char * PQparameterStatus (const PGconn *conn, const char *paramName)
 
int PQprotocolVersion (const PGconn *conn)
 
int PQfullProtocolVersion (const PGconn *conn)
 
int PQserverVersion (const PGconn *conn)
 
char * PQerrorMessage (const PGconn *conn)
 
int PQsocket (const PGconn *conn)
 
int PQbackendPID (const PGconn *conn)
 
PGpipelineStatus PQpipelineStatus (const PGconn *conn)
 
int PQconnectionNeedsPassword (const PGconn *conn)
 
int PQconnectionUsedPassword (const PGconn *conn)
 
int PQconnectionUsedGSSAPI (const PGconn *conn)
 
int PQclientEncoding (const PGconn *conn)
 
int PQsetClientEncoding (PGconn *conn, const char *encoding)
 
int PQsslInUse (PGconn *conn)
 
void * PQsslStruct (PGconn *conn, const char *struct_name)
 
const char * PQsslAttribute (PGconn *conn, const char *attribute_name)
 
const char *const * PQsslAttributeNames (PGconn *conn)
 
void * PQgetssl (PGconn *conn)
 
void PQinitSSL (int do_init)
 
void PQinitOpenSSL (int do_ssl, int do_crypto)
 
int PQgssEncInUse (PGconn *conn)
 
void * PQgetgssctx (PGconn *conn)
 
PGVerbosity PQsetErrorVerbosity (PGconn *conn, PGVerbosity verbosity)
 
PGContextVisibility PQsetErrorContextVisibility (PGconn *conn, PGContextVisibility show_context)
 
PQnoticeReceiver PQsetNoticeReceiver (PGconn *conn, PQnoticeReceiver proc, void *arg)
 
PQnoticeProcessor PQsetNoticeProcessor (PGconn *conn, PQnoticeProcessor proc, void *arg)
 
pgthreadlock_t PQregisterThreadLock (pgthreadlock_t newhandler)
 
void PQtrace (PGconn *conn, FILE *debug_port)
 
void PQuntrace (PGconn *conn)
 
void PQsetTraceFlags (PGconn *conn, int flags)
 
PGresultPQexec (PGconn *conn, const char *query)
 
PGresultPQexecParams (PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
 
PGresultPQprepare (PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
 
PGresultPQexecPrepared (PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
 
int PQsendQuery (PGconn *conn, const char *query)
 
int PQsendQueryParams (PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
 
int PQsendPrepare (PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
 
int PQsendQueryPrepared (PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
 
int PQsetSingleRowMode (PGconn *conn)
 
int PQsetChunkedRowsMode (PGconn *conn, int chunkSize)
 
PGresultPQgetResult (PGconn *conn)
 
int PQisBusy (PGconn *conn)
 
int PQconsumeInput (PGconn *conn)
 
int PQenterPipelineMode (PGconn *conn)
 
int PQexitPipelineMode (PGconn *conn)
 
int PQpipelineSync (PGconn *conn)
 
int PQsendFlushRequest (PGconn *conn)
 
int PQsendPipelineSync (PGconn *conn)
 
PGnotifyPQnotifies (PGconn *conn)
 
int PQputCopyData (PGconn *conn, const char *buffer, int nbytes)
 
int PQputCopyEnd (PGconn *conn, const char *errormsg)
 
int PQgetCopyData (PGconn *conn, char **buffer, int async)
 
int PQgetline (PGconn *conn, char *buffer, int length)
 
int PQputline (PGconn *conn, const char *string)
 
int PQgetlineAsync (PGconn *conn, char *buffer, int bufsize)
 
int PQputnbytes (PGconn *conn, const char *buffer, int nbytes)
 
int PQendcopy (PGconn *conn)
 
int PQsetnonblocking (PGconn *conn, int arg)
 
int PQisnonblocking (const PGconn *conn)
 
int PQisthreadsafe (void)
 
PGPing PQping (const char *conninfo)
 
PGPing PQpingParams (const char *const *keywords, const char *const *values, int expand_dbname)
 
int PQflush (PGconn *conn)
 
PGresultPQfn (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)
 
PGresultPQdescribePrepared (PGconn *conn, const char *stmt)
 
PGresultPQdescribePortal (PGconn *conn, const char *portal)
 
int PQsendDescribePrepared (PGconn *conn, const char *stmt)
 
int PQsendDescribePortal (PGconn *conn, const char *portal)
 
PGresultPQclosePrepared (PGconn *conn, const char *stmt)
 
PGresultPQclosePortal (PGconn *conn, const char *portal)
 
int PQsendClosePrepared (PGconn *conn, const char *stmt)
 
int PQsendClosePortal (PGconn *conn, const char *portal)
 
void PQclear (PGresult *res)
 
void PQfreemem (void *ptr)
 
PGresultPQmakeEmptyPGresult (PGconn *conn, ExecStatusType status)
 
PGresultPQcopyResult (const PGresult *src, int flags)
 
int PQsetResultAttrs (PGresult *res, int numAttributes, PGresAttDesc *attDescs)
 
void * PQresultAlloc (PGresult *res, size_t nBytes)
 
size_t PQresultMemorySize (const PGresult *res)
 
int PQsetvalue (PGresult *res, int tup_num, int field_num, char *value, int len)
 
size_t PQescapeStringConn (PGconn *conn, char *to, const char *from, size_t length, int *error)
 
char * PQescapeLiteral (PGconn *conn, const char *str, size_t len)
 
char * PQescapeIdentifier (PGconn *conn, const char *str, size_t len)
 
unsigned char * PQescapeByteaConn (PGconn *conn, const unsigned char *from, size_t from_length, size_t *to_length)
 
unsigned char * PQunescapeBytea (const unsigned char *strtext, size_t *retbuflen)
 
size_t PQescapeString (char *to, const char *from, size_t length)
 
unsigned char * PQescapeBytea (const unsigned char *from, size_t from_length, size_t *to_length)
 
void PQprint (FILE *fout, const PGresult *res, const PQprintOpt *po)
 
void PQdisplayTuples (const PGresult *res, FILE *fp, int fillAlign, const char *fieldSep, int printHeader, int quiet)
 
void PQprintTuples (const PGresult *res, FILE *fout, int PrintAttNames, int TerseOutput, int colWidth)
 
int lo_open (PGconn *conn, Oid lobjId, int mode)
 
int lo_close (PGconn *conn, int fd)
 
int lo_read (PGconn *conn, int fd, char *buf, size_t len)
 
int lo_write (PGconn *conn, int fd, const char *buf, size_t len)
 
int lo_lseek (PGconn *conn, int fd, int offset, int whence)
 
pg_int64 lo_lseek64 (PGconn *conn, int fd, pg_int64 offset, int whence)
 
Oid lo_creat (PGconn *conn, int mode)
 
Oid lo_create (PGconn *conn, Oid lobjId)
 
int lo_tell (PGconn *conn, int fd)
 
pg_int64 lo_tell64 (PGconn *conn, int fd)
 
int lo_truncate (PGconn *conn, int fd, size_t len)
 
int lo_truncate64 (PGconn *conn, int fd, pg_int64 len)
 
int lo_unlink (PGconn *conn, Oid lobjId)
 
Oid lo_import (PGconn *conn, const char *filename)
 
Oid lo_import_with_oid (PGconn *conn, const char *filename, Oid lobjId)
 
int lo_export (PGconn *conn, Oid lobjId, const char *filename)
 
int PQlibVersion (void)
 
int PQsocketPoll (int sock, int forRead, int forWrite, pg_usec_time_t end_time)
 
pg_usec_time_t PQgetCurrentTimeUSec (void)
 
int PQmblen (const char *s, int encoding)
 
int PQmblenBounded (const char *s, int encoding)
 
int PQdsplen (const char *s, int encoding)
 
int PQenv2encoding (void)
 
char * PQencryptPassword (const char *passwd, const char *user)
 
char * PQencryptPasswordConn (PGconn *conn, const char *passwd, const char *user, const char *algorithm)
 
PGresultPQchangePassword (PGconn *conn, const char *user, const char *passwd)
 
void PQsetAuthDataHook (PQauthDataHook_type hook)
 
PQauthDataHook_type PQgetAuthDataHook (void)
 
int PQdefaultAuthDataHook (PGauthData type, PGconn *conn, void *data)
 
int pg_char_to_encoding (const char *name)
 
const char * pg_encoding_to_char (int encoding)
 
int pg_valid_server_encoding_id (int encoding)
 
PQsslKeyPassHook_OpenSSL_type PQgetSSLKeyPassHook_OpenSSL (void)
 
void PQsetSSLKeyPassHook_OpenSSL (PQsslKeyPassHook_OpenSSL_type hook)
 
int PQdefaultSSLKeyPassHook_OpenSSL (char *buf, int size, PGconn *conn)
 

Macro Definition Documentation

◆ LIBPQ_HAS_ASYNC_CANCEL

#define LIBPQ_HAS_ASYNC_CANCEL   1

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

◆ LIBPQ_HAS_CHANGE_PASSWORD

#define LIBPQ_HAS_CHANGE_PASSWORD   1

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

◆ LIBPQ_HAS_CHUNK_MODE

#define LIBPQ_HAS_CHUNK_MODE   1

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

◆ LIBPQ_HAS_CLOSE_PREPARED

#define LIBPQ_HAS_CLOSE_PREPARED   1

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

◆ LIBPQ_HAS_FULL_PROTOCOL_VERSION

#define LIBPQ_HAS_FULL_PROTOCOL_VERSION   1

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

◆ LIBPQ_HAS_PIPELINING

#define LIBPQ_HAS_PIPELINING   1

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

◆ LIBPQ_HAS_PROMPT_OAUTH_DEVICE

#define LIBPQ_HAS_PROMPT_OAUTH_DEVICE   1

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

◆ LIBPQ_HAS_SEND_PIPELINE_SYNC

#define LIBPQ_HAS_SEND_PIPELINE_SYNC   1

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

◆ LIBPQ_HAS_SOCKET_POLL

#define LIBPQ_HAS_SOCKET_POLL   1

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

◆ LIBPQ_HAS_SSL_LIBRARY_DETECTION

#define LIBPQ_HAS_SSL_LIBRARY_DETECTION   1

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

◆ LIBPQ_HAS_TRACE_FLAGS

#define LIBPQ_HAS_TRACE_FLAGS   1

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

◆ PG_COPYRES_ATTRS

#define PG_COPYRES_ATTRS   0x01

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

◆ PG_COPYRES_EVENTS

#define PG_COPYRES_EVENTS   0x04

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

◆ PG_COPYRES_NOTICEHOOKS

#define PG_COPYRES_NOTICEHOOKS   0x08

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

◆ PG_COPYRES_TUPLES

#define PG_COPYRES_TUPLES   0x02 /* Implies PG_COPYRES_ATTRS */

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

◆ PQ_QUERY_PARAM_MAX_LIMIT

#define PQ_QUERY_PARAM_MAX_LIMIT   65535

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

◆ PQfreeNotify

#define PQfreeNotify (   ptr)    PQfreemem(ptr)

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

◆ PQnoPasswordSupplied

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

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

◆ PQsetdb

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

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

◆ PQTRACE_REGRESS_MODE

#define PQTRACE_REGRESS_MODE   (1<<1)

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

◆ PQTRACE_SUPPRESS_TIMESTAMPS

#define PQTRACE_SUPPRESS_TIMESTAMPS   (1<<0)

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

◆ SOCKTYPE

#define SOCKTYPE   int

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

Typedef Documentation

◆ pg_usec_time_t

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

◆ PGcancel

typedef struct pg_cancel PGcancel

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

◆ PGcancelConn

typedef struct pg_cancel_conn PGcancelConn

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

◆ PGconn

typedef struct pg_conn PGconn

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

◆ PGnotify

typedef struct pgNotify PGnotify

◆ PGoauthBearerRequest

◆ PGpromptOAuthDevice

◆ PGresAttDesc

typedef struct pgresAttDesc PGresAttDesc

◆ PGresult

typedef struct pg_result PGresult

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

◆ pgthreadlock_t

typedef void(* pgthreadlock_t) (int acquire)

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

◆ PQauthDataHook_type

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

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

◆ pqbool

typedef char pqbool

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

◆ PQconninfoOption

◆ PQnoticeProcessor

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

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

◆ PQnoticeReceiver

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

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

◆ PQprintOpt

typedef struct _PQprintOpt PQprintOpt

◆ PQsslKeyPassHook_OpenSSL_type

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

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

Enumeration Type Documentation

◆ ConnStatusType

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

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

82{
85 /* Non-blocking mode only below here */
86
87 /*
88 * The existence of these should never be relied upon - they should only
89 * be used for user feedback or similar purposes.
90 */
91 CONNECTION_STARTED, /* Waiting for connection to be made. */
92 CONNECTION_MADE, /* Connection OK; waiting to send. */
93 CONNECTION_AWAITING_RESPONSE, /* Waiting for a response from the
94 * postmaster. */
95 CONNECTION_AUTH_OK, /* Received authentication; waiting for
96 * backend startup. */
97 CONNECTION_SETENV, /* This state is no longer used. */
98 CONNECTION_SSL_STARTUP, /* Performing SSL handshake. */
99 CONNECTION_NEEDED, /* Internal state: connect() needed. */
100 CONNECTION_CHECK_WRITABLE, /* Checking if session is read-write. */
101 CONNECTION_CONSUME, /* Consuming any extra messages. */
102 CONNECTION_GSS_STARTUP, /* Negotiating GSSAPI. */
103 CONNECTION_CHECK_TARGET, /* Internal state: checking target server
104 * properties. */
105 CONNECTION_CHECK_STANDBY, /* Checking if server is in standby mode. */
106 CONNECTION_ALLOCATED, /* Waiting for connection attempt to be
107 * started. */
108 CONNECTION_AUTHENTICATING, /* Authentication is in progress with some
109 * external system. */
ConnStatusType
Definition: libpq-fe.h:82
@ CONNECTION_CONSUME
Definition: libpq-fe.h:101
@ CONNECTION_AUTHENTICATING
Definition: libpq-fe.h:108
@ CONNECTION_CHECK_STANDBY
Definition: libpq-fe.h:105
@ CONNECTION_STARTED
Definition: libpq-fe.h:91
@ CONNECTION_AWAITING_RESPONSE
Definition: libpq-fe.h:93
@ CONNECTION_MADE
Definition: libpq-fe.h:92
@ CONNECTION_CHECK_WRITABLE
Definition: libpq-fe.h:100
@ CONNECTION_BAD
Definition: libpq-fe.h:84
@ CONNECTION_OK
Definition: libpq-fe.h:83
@ CONNECTION_GSS_STARTUP
Definition: libpq-fe.h:102
@ CONNECTION_ALLOCATED
Definition: libpq-fe.h:106
@ CONNECTION_SSL_STARTUP
Definition: libpq-fe.h:98
@ CONNECTION_AUTH_OK
Definition: libpq-fe.h:95
@ CONNECTION_CHECK_TARGET
Definition: libpq-fe.h:103
@ CONNECTION_NEEDED
Definition: libpq-fe.h:99
@ CONNECTION_SETENV
Definition: libpq-fe.h:97

◆ ExecStatusType

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

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

122{
123 PGRES_EMPTY_QUERY = 0, /* empty query string was executed */
124 PGRES_COMMAND_OK, /* a query command that doesn't return
125 * anything was executed properly by the
126 * backend */
127 PGRES_TUPLES_OK, /* a query command that returns tuples was
128 * executed properly by the backend, PGresult
129 * contains the result tuples */
130 PGRES_COPY_OUT, /* Copy Out data transfer in progress */
131 PGRES_COPY_IN, /* Copy In data transfer in progress */
132 PGRES_BAD_RESPONSE, /* an unexpected response was recv'd from the
133 * backend */
134 PGRES_NONFATAL_ERROR, /* notice or warning message */
135 PGRES_FATAL_ERROR, /* query failed */
136 PGRES_COPY_BOTH, /* Copy In/Out data transfer in progress */
137 PGRES_SINGLE_TUPLE, /* single tuple from larger resultset */
138 PGRES_PIPELINE_SYNC, /* pipeline synchronization point */
139 PGRES_PIPELINE_ABORTED, /* Command didn't run because of an abort
140 * earlier in a pipeline */
141 PGRES_TUPLES_CHUNK /* chunk of tuples from larger resultset */
ExecStatusType
Definition: libpq-fe.h:122
@ PGRES_COPY_IN
Definition: libpq-fe.h:131
@ PGRES_COPY_BOTH
Definition: libpq-fe.h:136
@ PGRES_COMMAND_OK
Definition: libpq-fe.h:124
@ PGRES_TUPLES_CHUNK
Definition: libpq-fe.h:141
@ PGRES_FATAL_ERROR
Definition: libpq-fe.h:135
@ PGRES_SINGLE_TUPLE
Definition: libpq-fe.h:137
@ PGRES_COPY_OUT
Definition: libpq-fe.h:130
@ PGRES_EMPTY_QUERY
Definition: libpq-fe.h:123
@ PGRES_PIPELINE_SYNC
Definition: libpq-fe.h:138
@ PGRES_BAD_RESPONSE
Definition: libpq-fe.h:132
@ PGRES_PIPELINE_ABORTED
Definition: libpq-fe.h:139
@ PGRES_NONFATAL_ERROR
Definition: libpq-fe.h:134
@ PGRES_TUPLES_OK
Definition: libpq-fe.h:127

◆ PGauthData

enum PGauthData
Enumerator
PQAUTHDATA_PROMPT_OAUTH_DEVICE 
PQAUTHDATA_OAUTH_BEARER_TOKEN 

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

192{
193 PQAUTHDATA_PROMPT_OAUTH_DEVICE, /* user must visit a device-authorization
194 * URL */
195 PQAUTHDATA_OAUTH_BEARER_TOKEN, /* server requests an OAuth Bearer token */
196} PGauthData;
PGauthData
Definition: libpq-fe.h:192
@ PQAUTHDATA_PROMPT_OAUTH_DEVICE
Definition: libpq-fe.h:193
@ PQAUTHDATA_OAUTH_BEARER_TOKEN
Definition: libpq-fe.h:195

◆ PGContextVisibility

Enumerator
PQSHOW_CONTEXT_NEVER 
PQSHOW_CONTEXT_ERRORS 
PQSHOW_CONTEXT_ALWAYS 

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

162{
163 PQSHOW_CONTEXT_NEVER, /* never show CONTEXT field */
164 PQSHOW_CONTEXT_ERRORS, /* show CONTEXT for errors only (default) */
165 PQSHOW_CONTEXT_ALWAYS /* always show CONTEXT field */
PGContextVisibility
Definition: libpq-fe.h:162
@ PQSHOW_CONTEXT_NEVER
Definition: libpq-fe.h:163
@ PQSHOW_CONTEXT_ALWAYS
Definition: libpq-fe.h:165
@ PQSHOW_CONTEXT_ERRORS
Definition: libpq-fe.h:164

◆ PGPing

enum PGPing
Enumerator
PQPING_OK 
PQPING_REJECT 
PQPING_NO_RESPONSE 
PQPING_NO_ATTEMPT 

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

174{
175 PQPING_OK, /* server is accepting connections */
176 PQPING_REJECT, /* server is alive but rejecting connections */
177 PQPING_NO_RESPONSE, /* could not establish connection */
178 PQPING_NO_ATTEMPT /* connection not attempted (bad params) */
179} PGPing;
PGPing
Definition: libpq-fe.h:174
@ PQPING_OK
Definition: libpq-fe.h:175
@ PQPING_REJECT
Definition: libpq-fe.h:176
@ PQPING_NO_RESPONSE
Definition: libpq-fe.h:177
@ PQPING_NO_ATTEMPT
Definition: libpq-fe.h:178

◆ PGpipelineStatus

Enumerator
PQ_PIPELINE_OFF 
PQ_PIPELINE_ON 
PQ_PIPELINE_ABORTED 

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

185{
PGpipelineStatus
Definition: libpq-fe.h:185
@ PQ_PIPELINE_OFF
Definition: libpq-fe.h:186
@ PQ_PIPELINE_ABORTED
Definition: libpq-fe.h:188
@ PQ_PIPELINE_ON
Definition: libpq-fe.h:187

◆ PGTransactionStatusType

Enumerator
PQTRANS_IDLE 
PQTRANS_ACTIVE 
PQTRANS_INTRANS 
PQTRANS_INERROR 
PQTRANS_UNKNOWN 

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

145{
146 PQTRANS_IDLE, /* connection idle */
147 PQTRANS_ACTIVE, /* command in progress */
148 PQTRANS_INTRANS, /* idle, within transaction block */
149 PQTRANS_INERROR, /* idle, within failed transaction */
150 PQTRANS_UNKNOWN /* cannot determine status */
PGTransactionStatusType
Definition: libpq-fe.h:145
@ PQTRANS_INTRANS
Definition: libpq-fe.h:148
@ PQTRANS_IDLE
Definition: libpq-fe.h:146
@ PQTRANS_ACTIVE
Definition: libpq-fe.h:147
@ PQTRANS_UNKNOWN
Definition: libpq-fe.h:150
@ PQTRANS_INERROR
Definition: libpq-fe.h:149

◆ PGVerbosity

Enumerator
PQERRORS_TERSE 
PQERRORS_DEFAULT 
PQERRORS_VERBOSE 
PQERRORS_SQLSTATE 

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

154{
155 PQERRORS_TERSE, /* single-line error messages */
156 PQERRORS_DEFAULT, /* recommended style */
157 PQERRORS_VERBOSE, /* all the facts, ma'am */
158 PQERRORS_SQLSTATE /* only error severity and SQLSTATE code */
PGVerbosity
Definition: libpq-fe.h:154
@ PQERRORS_VERBOSE
Definition: libpq-fe.h:157
@ PQERRORS_DEFAULT
Definition: libpq-fe.h:156
@ PQERRORS_TERSE
Definition: libpq-fe.h:155
@ PQERRORS_SQLSTATE
Definition: libpq-fe.h:158

◆ PostgresPollingStatusType

Enumerator
PGRES_POLLING_FAILED 
PGRES_POLLING_READING 
PGRES_POLLING_WRITING 
PGRES_POLLING_OK 
PGRES_POLLING_ACTIVE 

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

113{
115 PGRES_POLLING_READING, /* These two indicate that one may */
116 PGRES_POLLING_WRITING, /* use select before polling again. */
118 PGRES_POLLING_ACTIVE /* unused; keep for backwards compatibility */
PostgresPollingStatusType
Definition: libpq-fe.h:113
@ PGRES_POLLING_ACTIVE
Definition: libpq-fe.h:118
@ PGRES_POLLING_OK
Definition: libpq-fe.h:117
@ PGRES_POLLING_READING
Definition: libpq-fe.h:115
@ PGRES_POLLING_WRITING
Definition: libpq-fe.h:116
@ PGRES_POLLING_FAILED
Definition: libpq-fe.h:114

Function Documentation

◆ lo_close()

int lo_close ( PGconn conn,
int  fd 
)

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

97{
98 PQArgBlock argv[1];
99 PGresult *res;
100 int retval;
101 int result_len;
102
103 if (lo_initialize(conn) < 0)
104 return -1;
105
106 argv[0].isint = 1;
107 argv[0].len = 4;
108 argv[0].u.integer = fd;
110 &retval, &result_len, 1, argv, 1);
112 {
113 PQclear(res);
114 return retval;
115 }
116 else
117 {
118 PQclear(res);
119 return -1;
120 }
121}
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:3411
void PQclear(PGresult *res)
Definition: fe-exec.c:721
PGresult * PQfn(PGconn *conn, int fnid, int *result_buf, int *result_len, int result_is_int, const PQArgBlock *args, int nargs)
Definition: fe-exec.c:2980
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:843
static int fd(const char *x, int i)
Definition: preproc-init.c:105
PGconn * conn
Definition: streamutil.c:52
int isint
Definition: libpq-fe.h:292
int integer
Definition: libpq-fe.h:296
union PQArgBlock::@189 u
Oid fn_lo_close
Definition: libpq-int.h:289
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:559

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

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

◆ lo_creat()

Oid lo_creat ( PGconn conn,
int  mode 
)

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

439{
440 PQArgBlock argv[1];
441 PGresult *res;
442 int retval;
443 int result_len;
444
445 if (lo_initialize(conn) < 0)
446 return InvalidOid;
447
448 argv[0].isint = 1;
449 argv[0].len = 4;
450 argv[0].u.integer = mode;
452 &retval, &result_len, 1, argv, 1);
454 {
455 PQclear(res);
456 return (Oid) retval;
457 }
458 else
459 {
460 PQclear(res);
461 return InvalidOid;
462 }
463}
static PgChecksumMode mode
Definition: pg_checksums.c:55
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
Oid fn_lo_creat
Definition: libpq-int.h:290

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

Referenced by importFile(), and lo_import_internal().

◆ lo_create()

Oid lo_create ( PGconn conn,
Oid  lobjId 
)

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

475{
476 PQArgBlock argv[1];
477 PGresult *res;
478 int retval;
479 int result_len;
480
481 if (lo_initialize(conn) < 0)
482 return InvalidOid;
483
484 /* Must check this on-the-fly because it's not there pre-8.1 */
485 if (conn->lobjfuncs->fn_lo_create == 0)
486 {
487 libpq_append_conn_error(conn, "cannot determine OID of function %s",
488 "lo_create");
489 return InvalidOid;
490 }
491
492 argv[0].isint = 1;
493 argv[0].len = 4;
494 argv[0].u.integer = lobjId;
496 &retval, &result_len, 1, argv, 1);
498 {
499 PQclear(res);
500 return (Oid) retval;
501 }
502 else
503 {
504 PQclear(res);
505 return InvalidOid;
506 }
507}
void libpq_append_conn_error(PGconn *conn, const char *fmt,...)
Definition: fe-misc.c:1381
Oid fn_lo_create
Definition: libpq-int.h:291

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

Referenced by lo_import_internal(), and StartRestoreLO().

◆ lo_export()

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

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

749{
750 int result = 1;
751 int fd;
752 int nbytes,
753 tmp;
754 char buf[LO_BUFSIZE];
755 int lobj;
756 char sebuf[PG_STRERROR_R_BUFLEN];
757
758 /*
759 * open the large object.
760 */
761 lobj = lo_open(conn, lobjId, INV_READ);
762 if (lobj == -1)
763 {
764 /* we assume lo_open() already set a suitable error message */
765 return -1;
766 }
767
768 /*
769 * create the file to be written to
770 */
771 fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, 0666);
772 if (fd < 0)
773 {
774 /* We must do lo_close before setting the errorMessage */
775 int save_errno = errno;
776
777 (void) lo_close(conn, lobj);
778 /* deliberately overwrite any error from lo_close */
780 libpq_append_conn_error(conn, "could not open file \"%s\": %s",
781 filename,
782 strerror_r(save_errno, sebuf, sizeof(sebuf)));
783 return -1;
784 }
785
786 /*
787 * read in from the large object and write to the file
788 */
789 while ((nbytes = lo_read(conn, lobj, buf, LO_BUFSIZE)) > 0)
790 {
791 tmp = write(fd, buf, nbytes);
792 if (tmp != nbytes)
793 {
794 /* We must do lo_close before setting the errorMessage */
795 int save_errno = errno;
796
797 (void) lo_close(conn, lobj);
798 (void) close(fd);
799 /* deliberately overwrite any error from lo_close */
801 libpq_append_conn_error(conn, "could not write to file \"%s\": %s",
802 filename,
803 strerror_r(save_errno, sebuf, sizeof(sebuf)));
804 return -1;
805 }
806 }
807
808 /*
809 * If lo_read() failed, we are now in an aborted transaction so there's no
810 * need for lo_close(); furthermore, if we tried it we'd overwrite the
811 * useful error result with a useless one. So skip lo_close() if we got a
812 * failure result.
813 */
814 if (nbytes < 0 ||
815 lo_close(conn, lobj) != 0)
816 {
817 /* assume lo_read() or lo_close() left a suitable error message */
818 result = -1;
819 }
820
821 /* if we already failed, don't overwrite that msg with a close error */
822 if (close(fd) != 0 && result >= 0)
823 {
824 libpq_append_conn_error(conn, "could not write to file \"%s\": %s",
825 filename, strerror_r(errno, sebuf, sizeof(sebuf)));
826 result = -1;
827 }
828
829 return result;
830}
#define PG_BINARY
Definition: c.h:1244
int lo_close(PGconn *conn, int fd)
Definition: fe-lobj.c:96
#define LO_BUFSIZE
Definition: fe-lobj.c:42
int lo_read(PGconn *conn, int fd, char *buf, size_t len)
Definition: fe-lobj.c:245
int lo_open(PGconn *conn, Oid lobjId, int mode)
Definition: fe-lobj.c:57
#define close(a)
Definition: win32.h:12
#define write(a, b, c)
Definition: win32.h:14
#define INV_READ
Definition: libpq-fs.h:22
#define pqClearConnErrorState(conn)
Definition: libpq-int.h:907
static char * filename
Definition: pg_dumpall.c:124
static char * buf
Definition: pg_test_fsync.c:72
#define PG_STRERROR_R_BUFLEN
Definition: port.h:257
#define strerror_r
Definition: port.h:256

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

Referenced by do_lo_export(), and main().

◆ lo_import()

Oid lo_import ( PGconn conn,
const char *  filename 
)

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

627{
629}
static Oid lo_import_internal(PGconn *conn, const char *filename, Oid oid)
Definition: fe-lobj.c:647

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

Referenced by do_lo_import(), and main().

◆ lo_import_with_oid()

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

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

642{
643 return lo_import_internal(conn, filename, lobjId);
644}

References conn, filename, and lo_import_internal().

◆ lo_lseek()

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

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

345{
346 PQArgBlock argv[3];
347 PGresult *res;
348 int retval;
349 int result_len;
350
351 if (lo_initialize(conn) < 0)
352 return -1;
353
354 argv[0].isint = 1;
355 argv[0].len = 4;
356 argv[0].u.integer = fd;
357
358 argv[1].isint = 1;
359 argv[1].len = 4;
360 argv[1].u.integer = offset;
361
362 argv[2].isint = 1;
363 argv[2].len = 4;
364 argv[2].u.integer = whence;
365
367 &retval, &result_len, 1, argv, 3);
369 {
370 PQclear(res);
371 return retval;
372 }
373 else
374 {
375 PQclear(res);
376 return -1;
377 }
378}
Oid fn_lo_lseek
Definition: libpq-int.h:293

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

Referenced by overwrite(), and pickout().

◆ lo_lseek64()

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

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

386{
387 PQArgBlock argv[3];
388 PGresult *res;
389 pg_int64 retval;
390 int result_len;
391
392 if (lo_initialize(conn) < 0)
393 return -1;
394
395 if (conn->lobjfuncs->fn_lo_lseek64 == 0)
396 {
397 libpq_append_conn_error(conn, "cannot determine OID of function %s",
398 "lo_lseek64");
399 return -1;
400 }
401
402 argv[0].isint = 1;
403 argv[0].len = 4;
404 argv[0].u.integer = fd;
405
406 offset = lo_hton64(offset);
407 argv[1].isint = 0;
408 argv[1].len = 8;
409 argv[1].u.ptr = (int *) &offset;
410
411 argv[2].isint = 1;
412 argv[2].len = 4;
413 argv[2].u.integer = whence;
414
416 (void *) &retval, &result_len, 0, argv, 3);
417 if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
418 {
419 PQclear(res);
420 return lo_ntoh64(retval);
421 }
422 else
423 {
424 PQclear(res);
425 return -1;
426 }
427}
static pg_int64 lo_ntoh64(pg_int64 net64)
Definition: fe-lobj.c:1048
static pg_int64 lo_hton64(pg_int64 host64)
Definition: fe-lobj.c:1023
int64_t pg_int64
Definition: postgres_ext.h:48
int * ptr
Definition: libpq-fe.h:295
Oid fn_lo_lseek64
Definition: libpq-int.h:294

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

Referenced by overwrite(), and pickout().

◆ lo_open()

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

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

58{
59 int fd;
60 int result_len;
61 PQArgBlock argv[2];
62 PGresult *res;
63
64 if (lo_initialize(conn) < 0)
65 return -1;
66
67 argv[0].isint = 1;
68 argv[0].len = 4;
69 argv[0].u.integer = lobjId;
70
71 argv[1].isint = 1;
72 argv[1].len = 4;
73 argv[1].u.integer = mode;
74
75 res = PQfn(conn, conn->lobjfuncs->fn_lo_open, &fd, &result_len, 1, argv, 2);
77 {
78 PQclear(res);
79 return fd;
80 }
81 else
82 {
83 PQclear(res);
84 return -1;
85 }
86}
Oid fn_lo_open
Definition: libpq-int.h:288

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

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

◆ lo_read()

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

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

246{
247 PQArgBlock argv[2];
248 PGresult *res;
249 int result_len;
250
251 if (lo_initialize(conn) < 0)
252 return -1;
253
254 /*
255 * Long ago, somebody thought it'd be a good idea to declare this function
256 * as taking size_t ... but the underlying backend function only accepts a
257 * signed int32 length. So throw error if the given value overflows
258 * int32.
259 */
260 if (len > (size_t) INT_MAX)
261 {
262 libpq_append_conn_error(conn, "argument of lo_read exceeds integer range");
263 return -1;
264 }
265
266 argv[0].isint = 1;
267 argv[0].len = 4;
268 argv[0].u.integer = fd;
269
270 argv[1].isint = 1;
271 argv[1].len = 4;
272 argv[1].u.integer = (int) len;
273
275 (void *) buf, &result_len, 0, argv, 2);
277 {
278 PQclear(res);
279 return result_len;
280 }
281 else
282 {
283 PQclear(res);
284 return -1;
285 }
286}
const void size_t len
Oid fn_lo_read
Definition: libpq-int.h:299

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

Referenced by lo_export().

◆ lo_tell()

int lo_tell ( PGconn conn,
int  fd 
)

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

516{
517 int retval;
518 PQArgBlock argv[1];
519 PGresult *res;
520 int result_len;
521
522 if (lo_initialize(conn) < 0)
523 return -1;
524
525 argv[0].isint = 1;
526 argv[0].len = 4;
527 argv[0].u.integer = fd;
528
530 &retval, &result_len, 1, argv, 1);
532 {
533 PQclear(res);
534 return retval;
535 }
536 else
537 {
538 PQclear(res);
539 return -1;
540 }
541}
Oid fn_lo_tell
Definition: libpq-int.h:295

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

◆ lo_tell64()

pg_int64 lo_tell64 ( PGconn conn,
int  fd 
)

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

549{
550 pg_int64 retval;
551 PQArgBlock argv[1];
552 PGresult *res;
553 int result_len;
554
555 if (lo_initialize(conn) < 0)
556 return -1;
557
558 if (conn->lobjfuncs->fn_lo_tell64 == 0)
559 {
560 libpq_append_conn_error(conn, "cannot determine OID of function %s",
561 "lo_tell64");
562 return -1;
563 }
564
565 argv[0].isint = 1;
566 argv[0].len = 4;
567 argv[0].u.integer = fd;
568
570 (void *) &retval, &result_len, 0, argv, 1);
571 if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
572 {
573 PQclear(res);
574 return lo_ntoh64(retval);
575 }
576 else
577 {
578 PQclear(res);
579 return -1;
580 }
581}
Oid fn_lo_tell64
Definition: libpq-int.h:296

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

Referenced by pickout().

◆ lo_truncate()

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

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

132{
133 PQArgBlock argv[2];
134 PGresult *res;
135 int retval;
136 int result_len;
137
138 if (lo_initialize(conn) < 0)
139 return -1;
140
141 /* Must check this on-the-fly because it's not there pre-8.3 */
142 if (conn->lobjfuncs->fn_lo_truncate == 0)
143 {
144 libpq_append_conn_error(conn, "cannot determine OID of function %s",
145 "lo_truncate");
146 return -1;
147 }
148
149 /*
150 * Long ago, somebody thought it'd be a good idea to declare this function
151 * as taking size_t ... but the underlying backend function only accepts a
152 * signed int32 length. So throw error if the given value overflows
153 * int32. (A possible alternative is to automatically redirect the call
154 * to lo_truncate64; but if the caller wanted to rely on that backend
155 * function being available, he could have called lo_truncate64 for
156 * himself.)
157 */
158 if (len > (size_t) INT_MAX)
159 {
160 libpq_append_conn_error(conn, "argument of lo_truncate exceeds integer range");
161 return -1;
162 }
163
164 argv[0].isint = 1;
165 argv[0].len = 4;
166 argv[0].u.integer = fd;
167
168 argv[1].isint = 1;
169 argv[1].len = 4;
170 argv[1].u.integer = (int) len;
171
173 &retval, &result_len, 1, argv, 2);
174
176 {
177 PQclear(res);
178 return retval;
179 }
180 else
181 {
182 PQclear(res);
183 return -1;
184 }
185}
Oid fn_lo_truncate
Definition: libpq-int.h:297

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

◆ lo_truncate64()

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

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

196{
197 PQArgBlock argv[2];
198 PGresult *res;
199 int retval;
200 int result_len;
201
202 if (lo_initialize(conn) < 0)
203 return -1;
204
206 {
207 libpq_append_conn_error(conn, "cannot determine OID of function %s",
208 "lo_truncate64");
209 return -1;
210 }
211
212 argv[0].isint = 1;
213 argv[0].len = 4;
214 argv[0].u.integer = fd;
215
216 len = lo_hton64(len);
217 argv[1].isint = 0;
218 argv[1].len = 8;
219 argv[1].u.ptr = (int *) &len;
220
222 &retval, &result_len, 1, argv, 2);
223
225 {
226 PQclear(res);
227 return retval;
228 }
229 else
230 {
231 PQclear(res);
232 return -1;
233 }
234}
Oid fn_lo_truncate64
Definition: libpq-int.h:298

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

Referenced by my_truncate().

◆ lo_unlink()

int lo_unlink ( PGconn conn,
Oid  lobjId 
)

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

590{
591 PQArgBlock argv[1];
592 PGresult *res;
593 int result_len;
594 int retval;
595
596 if (lo_initialize(conn) < 0)
597 return -1;
598
599 argv[0].isint = 1;
600 argv[0].len = 4;
601 argv[0].u.integer = lobjId;
602
604 &retval, &result_len, 1, argv, 1);
606 {
607 PQclear(res);
608 return retval;
609 }
610 else
611 {
612 PQclear(res);
613 return -1;
614 }
615}
Oid fn_lo_unlink
Definition: libpq-int.h:292

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

Referenced by do_lo_unlink(), and vacuumlo().

◆ lo_write()

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

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

296{
297 PQArgBlock argv[2];
298 PGresult *res;
299 int result_len;
300 int retval;
301
302 if (lo_initialize(conn) < 0)
303 return -1;
304
305 /*
306 * Long ago, somebody thought it'd be a good idea to declare this function
307 * as taking size_t ... but the underlying backend function only accepts a
308 * signed int32 length. So throw error if the given value overflows
309 * int32.
310 */
311 if (len > (size_t) INT_MAX)
312 {
313 libpq_append_conn_error(conn, "argument of lo_write exceeds integer range");
314 return -1;
315 }
316
317 argv[0].isint = 1;
318 argv[0].len = 4;
319 argv[0].u.integer = fd;
320
321 argv[1].isint = 0;
322 argv[1].len = (int) len;
323 argv[1].u.ptr = (int *) unconstify(char *, buf);
324
326 &retval, &result_len, 1, argv, 2);
328 {
329 PQclear(res);
330 return retval;
331 }
332 else
333 {
334 PQclear(res);
335 return -1;
336 }
337}
#define unconstify(underlying_type, expr)
Definition: c.h:1216
Oid fn_lo_write
Definition: libpq-int.h:300

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

Referenced by lo_import_internal().

◆ pg_char_to_encoding()

int pg_char_to_encoding ( const char *  name)

Definition at line 549 of file encnames.c.

550{
551 unsigned int nel = lengthof(pg_encname_tbl);
552 const pg_encname *base = pg_encname_tbl,
553 *last = base + nel - 1,
554 *position;
555 int result;
556 char buff[NAMEDATALEN],
557 *key;
558
559 if (name == NULL || *name == '\0')
560 return -1;
561
562 if (strlen(name) >= NAMEDATALEN)
563 return -1; /* it's certainly not in the table */
564
566
567 while (last >= base)
568 {
569 position = base + ((last - base) >> 1);
570 result = key[0] - position->name[0];
571
572 if (result == 0)
573 {
574 result = strcmp(key, position->name);
575 if (result == 0)
576 return position->encoding;
577 }
578 if (result < 0)
579 last = position - 1;
580 else
581 base = position + 1;
582 }
583 return -1;
584}
#define lengthof(array)
Definition: c.h:759
static char * clean_encoding_name(const char *key, char *newkey)
Definition: encnames.c:524
static const pg_encname pg_encname_tbl[]
Definition: encnames.c:39
#define NAMEDATALEN
const char * name

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

Referenced by pg_valid_client_encoding(), and pg_valid_server_encoding().

◆ pg_encoding_to_char()

const char * pg_encoding_to_char ( int  encoding)

Definition at line 587 of file encnames.c.

588{
590 {
592
593 Assert(encoding == p->encoding);
594 return p->name;
595 }
596 return "";
597}
const pg_enc2name pg_enc2name_tbl[]
Definition: encnames.c:308
Assert(PointerIsAligned(start, uint64))
int32 encoding
Definition: pg_database.h:41
#define PG_VALID_ENCODING(_enc)
Definition: pg_wchar.h:287
pg_enc encoding
Definition: pg_wchar.h:342
const char * name
Definition: pg_wchar.h:341

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

◆ pg_valid_server_encoding_id()

int pg_valid_server_encoding_id ( int  encoding)

Definition at line 513 of file encnames.c.

514{
516}
#define PG_VALID_BE_ENCODING(_enc)
Definition: pg_wchar.h:281

References encoding, and PG_VALID_BE_ENCODING.

◆ PQbackendPID()

int PQbackendPID ( const PGconn conn)

◆ PQbinaryTuples()

int PQbinaryTuples ( const PGresult res)

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

3498{
3499 if (!res)
3500 return 0;
3501 return res->binary;
3502}
int binary
Definition: libpq-int.h:184

References pg_result::binary.

Referenced by HandleCopyResult().

◆ PQcancel()

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

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

464{
465 int save_errno = SOCK_ERRNO;
466 pgsocket tmpsock = PGINVALID_SOCKET;
467 int maxlen;
468 struct
469 {
470 uint32 packetlen;
472 } crp;
473
474 if (!cancel)
475 {
476 strlcpy(errbuf, "PQcancel() -- no cancel object supplied", errbufsize);
477 /* strlcpy probably doesn't change errno, but be paranoid */
478 SOCK_ERRNO_SET(save_errno);
479 return false;
480 }
481
482 /*
483 * We need to open a temporary connection to the postmaster. Do this with
484 * only kernel calls.
485 */
486 if ((tmpsock = socket(cancel->raddr.addr.ss_family, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
487 {
488 strlcpy(errbuf, "PQcancel() -- socket() failed: ", errbufsize);
489 goto cancel_errReturn;
490 }
491
492 /*
493 * Since this connection will only be used to send a single packet of
494 * data, we don't need NODELAY. We also don't set the socket to
495 * nonblocking mode, because the API definition of PQcancel requires the
496 * cancel to be sent in a blocking way.
497 *
498 * We do set socket options related to keepalives and other TCP timeouts.
499 * This ensures that this function does not block indefinitely when
500 * reasonable keepalive and timeout settings have been provided.
501 */
502 if (cancel->raddr.addr.ss_family != AF_UNIX &&
503 cancel->keepalives != 0)
504 {
505#ifndef WIN32
506 if (!optional_setsockopt(tmpsock, SOL_SOCKET, SO_KEEPALIVE, 1))
507 {
508 strlcpy(errbuf, "PQcancel() -- setsockopt(SO_KEEPALIVE) failed: ", errbufsize);
509 goto cancel_errReturn;
510 }
511
512#ifdef PG_TCP_KEEPALIVE_IDLE
513 if (!optional_setsockopt(tmpsock, IPPROTO_TCP, PG_TCP_KEEPALIVE_IDLE,
514 cancel->keepalives_idle))
515 {
516 strlcpy(errbuf, "PQcancel() -- setsockopt(" PG_TCP_KEEPALIVE_IDLE_STR ") failed: ", errbufsize);
517 goto cancel_errReturn;
518 }
519#endif
520
521#ifdef TCP_KEEPINTVL
522 if (!optional_setsockopt(tmpsock, IPPROTO_TCP, TCP_KEEPINTVL,
523 cancel->keepalives_interval))
524 {
525 strlcpy(errbuf, "PQcancel() -- setsockopt(TCP_KEEPINTVL) failed: ", errbufsize);
526 goto cancel_errReturn;
527 }
528#endif
529
530#ifdef TCP_KEEPCNT
531 if (!optional_setsockopt(tmpsock, IPPROTO_TCP, TCP_KEEPCNT,
532 cancel->keepalives_count))
533 {
534 strlcpy(errbuf, "PQcancel() -- setsockopt(TCP_KEEPCNT) failed: ", errbufsize);
535 goto cancel_errReturn;
536 }
537#endif
538
539#else /* WIN32 */
540
541#ifdef SIO_KEEPALIVE_VALS
542 if (!pqSetKeepalivesWin32(tmpsock,
543 cancel->keepalives_idle,
544 cancel->keepalives_interval))
545 {
546 strlcpy(errbuf, "PQcancel() -- WSAIoctl(SIO_KEEPALIVE_VALS) failed: ", errbufsize);
547 goto cancel_errReturn;
548 }
549#endif /* SIO_KEEPALIVE_VALS */
550#endif /* WIN32 */
551
552 /* TCP_USER_TIMEOUT works the same way on Unix and Windows */
553#ifdef TCP_USER_TIMEOUT
554 if (!optional_setsockopt(tmpsock, IPPROTO_TCP, TCP_USER_TIMEOUT,
555 cancel->pgtcp_user_timeout))
556 {
557 strlcpy(errbuf, "PQcancel() -- setsockopt(TCP_USER_TIMEOUT) failed: ", errbufsize);
558 goto cancel_errReturn;
559 }
560#endif
561 }
562
563retry3:
564 if (connect(tmpsock, (struct sockaddr *) &cancel->raddr.addr,
565 cancel->raddr.salen) < 0)
566 {
567 if (SOCK_ERRNO == EINTR)
568 /* Interrupted system call - we'll just try again */
569 goto retry3;
570 strlcpy(errbuf, "PQcancel() -- connect() failed: ", errbufsize);
571 goto cancel_errReturn;
572 }
573
574 /* Create and send the cancel request packet. */
575
576 crp.packetlen = pg_hton32((uint32) sizeof(crp));
577 crp.cp.cancelRequestCode = (MsgType) pg_hton32(CANCEL_REQUEST_CODE);
578 crp.cp.backendPID = pg_hton32(cancel->be_pid);
579 crp.cp.cancelAuthCode = pg_hton32(cancel->be_key);
580
581retry4:
582 if (send(tmpsock, (char *) &crp, sizeof(crp), 0) != (int) sizeof(crp))
583 {
584 if (SOCK_ERRNO == EINTR)
585 /* Interrupted system call - we'll just try again */
586 goto retry4;
587 strlcpy(errbuf, "PQcancel() -- send() failed: ", errbufsize);
588 goto cancel_errReturn;
589 }
590
591 /*
592 * Wait for the postmaster to close the connection, which indicates that
593 * it's processed the request. Without this delay, we might issue another
594 * command only to find that our cancel zaps that command instead of the
595 * one we thought we were canceling. Note we don't actually expect this
596 * read to obtain any data, we are just waiting for EOF to be signaled.
597 */
598retry5:
599 if (recv(tmpsock, (char *) &crp, 1, 0) < 0)
600 {
601 if (SOCK_ERRNO == EINTR)
602 /* Interrupted system call - we'll just try again */
603 goto retry5;
604 /* we ignore other error conditions */
605 }
606
607 /* All done */
608 closesocket(tmpsock);
609 SOCK_ERRNO_SET(save_errno);
610 return true;
611
612cancel_errReturn:
613
614 /*
615 * Make sure we don't overflow the error buffer. Leave space for the \n at
616 * the end, and for the terminating zero.
617 */
618 maxlen = errbufsize - strlen(errbuf) - 2;
619 if (maxlen >= 0)
620 {
621 /*
622 * We can't invoke strerror here, since it's not signal-safe. Settle
623 * for printing the decimal value of errno. Even that has to be done
624 * the hard way.
625 */
626 int val = SOCK_ERRNO;
627 char buf[32];
628 char *bufp;
629
630 bufp = buf + sizeof(buf) - 1;
631 *bufp = '\0';
632 do
633 {
634 *(--bufp) = (val % 10) + '0';
635 val /= 10;
636 } while (val > 0);
637 bufp -= 6;
638 memcpy(bufp, "error ", 6);
639 strncat(errbuf, bufp, maxlen);
640 strcat(errbuf, "\n");
641 }
642 if (tmpsock != PGINVALID_SOCKET)
643 closesocket(tmpsock);
644 SOCK_ERRNO_SET(save_errno);
645 return false;
646}
uint32_t uint32
Definition: c.h:502
static bool optional_setsockopt(int fd, int protoid, int optid, int value)
Definition: fe-cancel.c:431
long val
Definition: informix.c:689
#define SOCK_ERRNO
Definition: libpq-int.h:955
#define SOCK_ERRNO_SET(e)
Definition: libpq-int.h:957
#define pg_hton32(x)
Definition: pg_bswap.h:121
int pgsocket
Definition: port.h:29
#define PGINVALID_SOCKET
Definition: port.h:31
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
#define closesocket
Definition: port.h:377
#define CANCEL_REQUEST_CODE
Definition: pqcomm.h:133
ProtocolVersion MsgType
Definition: pqcomm.h:102
struct sockaddr_storage addr
Definition: pqcomm.h:32
socklen_t salen
Definition: pqcomm.h:33
int pgtcp_user_timeout
Definition: fe-cancel.c:45
int keepalives_interval
Definition: fe-cancel.c:48
int keepalives_idle
Definition: fe-cancel.c:47
int keepalives_count
Definition: fe-cancel.c:50
SockAddr raddr
Definition: fe-cancel.c:42
int be_pid
Definition: fe-cancel.c:43
int keepalives
Definition: fe-cancel.c:46
int be_key
Definition: fe-cancel.c:44
#define EINTR
Definition: win32_port.h:364
#define recv(s, buf, len, flags)
Definition: win32_port.h:504
#define send(s, buf, len, flags)
Definition: win32_port.h:505
#define socket(af, type, protocol)
Definition: win32_port.h:498
#define connect(s, name, namelen)
Definition: win32_port.h:502

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

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

◆ PQcancelBlocking()

int PQcancelBlocking ( PGcancelConn cancelConn)

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

172{
174 return 0;
175 return pqConnectDBComplete(&cancelConn->conn);
176}
static PGcancel *volatile cancelConn
Definition: cancel.c:43
int PQcancelStart(PGcancelConn *cancelConn)
Definition: fe-cancel.c:185
int pqConnectDBComplete(PGconn *conn)
Definition: fe-connect.c:2716

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

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

◆ PQcancelCreate()

PGcancelConn * PQcancelCreate ( PGconn conn)

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

66{
68 pg_conn_host originalHost;
69
70 if (cancelConn == NULL)
71 return NULL;
72
73 /* Check we have an open connection */
74 if (!conn)
75 {
76 libpq_append_conn_error(cancelConn, "connection pointer is NULL");
77 return (PGcancelConn *) cancelConn;
78 }
79
81 {
82 libpq_append_conn_error(cancelConn, "connection not open");
83 return (PGcancelConn *) cancelConn;
84 }
85
86 /*
87 * Indicate that this connection is used to send a cancellation
88 */
89 cancelConn->cancelRequest = true;
90
92 return (PGcancelConn *) cancelConn;
93
94 /*
95 * Compute derived options
96 */
98 return (PGcancelConn *) cancelConn;
99
100 /*
101 * Copy cancellation token data from the original connection
102 */
105
106 /*
107 * Cancel requests should not iterate over all possible hosts. The request
108 * needs to be sent to the exact host and address that the original
109 * connection used. So we manually create the host and address arrays with
110 * a single element after freeing the host array that we generated from
111 * the connection options.
112 */
114 cancelConn->nconnhost = 1;
115 cancelConn->naddr = 1;
116
117 cancelConn->connhost = calloc(cancelConn->nconnhost, sizeof(pg_conn_host));
118 if (!cancelConn->connhost)
119 goto oom_error;
120
121 originalHost = conn->connhost[conn->whichhost];
122 if (originalHost.host)
123 {
124 cancelConn->connhost[0].host = strdup(originalHost.host);
125 if (!cancelConn->connhost[0].host)
126 goto oom_error;
127 }
128 if (originalHost.hostaddr)
129 {
130 cancelConn->connhost[0].hostaddr = strdup(originalHost.hostaddr);
131 if (!cancelConn->connhost[0].hostaddr)
132 goto oom_error;
133 }
134 if (originalHost.port)
135 {
136 cancelConn->connhost[0].port = strdup(originalHost.port);
137 if (!cancelConn->connhost[0].port)
138 goto oom_error;
139 }
140 if (originalHost.password)
141 {
142 cancelConn->connhost[0].password = strdup(originalHost.password);
143 if (!cancelConn->connhost[0].password)
144 goto oom_error;
145 }
146
147 cancelConn->addr = calloc(cancelConn->naddr, sizeof(AddrInfo));
148 if (!cancelConn->addr)
149 goto oom_error;
150
151 cancelConn->addr[0].addr = conn->raddr;
152 cancelConn->addr[0].family = conn->raddr.addr.ss_family;
153
155 return (PGcancelConn *) cancelConn;
156
157oom_error:
158 cancelConn->status = CONNECTION_BAD;
159 libpq_append_conn_error(cancelConn, "out of memory");
160 return (PGcancelConn *) cancelConn;
161}
bool pqConnectOptions2(PGconn *conn)
Definition: fe-connect.c:1219
void pqReleaseConnHosts(PGconn *conn)
Definition: fe-connect.c:5061
PGconn * pqMakeEmptyPGconn(void)
Definition: fe-connect.c:4871
bool pqCopyPGconn(PGconn *srcConn, PGconn *dstConn)
Definition: fe-connect.c:1004
#define calloc(a, b)
Definition: header.h:55
char * host
Definition: libpq-int.h:366
char * password
Definition: libpq-int.h:369
char * port
Definition: libpq-int.h:368
char * hostaddr
Definition: libpq-int.h:367
pgsocket sock
Definition: libpq-int.h:501
int be_key
Definition: libpq-int.h:551
SockAddr raddr
Definition: libpq-int.h:504
int whichhost
Definition: libpq-int.h:483
pg_conn_host * connhost
Definition: libpq-int.h:484

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

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

◆ PQcancelErrorMessage()

char * PQcancelErrorMessage ( const PGcancelConn cancelConn)

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

307{
308 return PQerrorMessage(&cancelConn->conn);
309}
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:7553

References cancelConn, and PQerrorMessage().

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

◆ PQcancelFinish()

void PQcancelFinish ( PGcancelConn cancelConn)

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

335{
336 PQfinish(&cancelConn->conn);
337}
void PQfinish(PGconn *conn)
Definition: fe-connect.c:5224

References cancelConn, and PQfinish().

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

◆ PQcancelPoll()

PostgresPollingStatusType PQcancelPoll ( PGcancelConn cancelConn)

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

208{
209 PGconn *conn = &cancelConn->conn;
210 int n;
211
212 /*
213 * We leave most of the connection establishment to PQconnectPoll, since
214 * it's very similar to normal connection establishment. But once we get
215 * to the CONNECTION_AWAITING_RESPONSE we need to start doing our own
216 * thing.
217 */
219 {
220 return PQconnectPoll(conn);
221 }
222
223 /*
224 * At this point we are waiting on the server to close the connection,
225 * which is its way of communicating that the cancel has been handled.
226 */
227
228 n = pqReadData(conn);
229
230 if (n == 0)
232
233#ifndef WIN32
234
235 /*
236 * If we receive an error report it, but only if errno is non-zero.
237 * Otherwise we assume it's an EOF, which is what we expect from the
238 * server.
239 *
240 * We skip this for Windows, because Windows is a bit special in its EOF
241 * behaviour for TCP. Sometimes it will error with an ECONNRESET when
242 * there is a clean connection closure. See these threads for details:
243 * https://www.postgresql.org/message-id/flat/90b34057-4176-7bb0-0dbb-9822a5f6425b%40greiz-reinsdorf.de
244 *
245 * https://www.postgresql.org/message-id/flat/CA%2BhUKG%2BOeoETZQ%3DQw5Ub5h3tmwQhBmDA%3DnuNO3KG%3DzWfUypFAw%40mail.gmail.com
246 *
247 * PQcancel ignores such errors and reports success for the cancellation
248 * anyway, so even if this is not always correct we do the same here.
249 */
250 if (n < 0 && errno != 0)
251 {
254 }
255#endif
256
257 /*
258 * We don't expect any data, only connection closure. So if we strangely
259 * do receive some data we consider that an error.
260 */
261 if (n > 0)
262 {
263 libpq_append_conn_error(conn, "unexpected response from server");
266 }
267
268 /*
269 * Getting here means that we received an EOF, which is what we were
270 * expecting -- the cancel request has completed.
271 */
272 cancelConn->conn.status = CONNECTION_OK;
274 return PGRES_POLLING_OK;
275}
PostgresPollingStatusType PQconnectPoll(PGconn *conn)
Definition: fe-connect.c:2842
int pqReadData(PGconn *conn)
Definition: fe-misc.c:580
void resetPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:146
PQExpBufferData errorMessage
Definition: libpq-int.h:671

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

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

◆ PQcancelReset()

void PQcancelReset ( PGcancelConn cancelConn)

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

319{
321 cancelConn->conn.status = CONNECTION_ALLOCATED;
322 cancelConn->conn.whichhost = 0;
323 cancelConn->conn.whichaddr = 0;
324 cancelConn->conn.try_next_host = false;
325 cancelConn->conn.try_next_addr = false;
326}
void pqClosePGconn(PGconn *conn)
Definition: fe-connect.c:5177

References cancelConn, CONNECTION_ALLOCATED, and pqClosePGconn().

Referenced by test_cancel().

◆ PQcancelSocket()

int PQcancelSocket ( const PGcancelConn cancelConn)

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

295{
296 return PQsocket(&cancelConn->conn);
297}
int PQsocket(const PGconn *conn)
Definition: fe-connect.c:7579

References cancelConn, and PQsocket().

Referenced by libpqsrv_cancel(), and test_cancel().

◆ PQcancelStart()

int PQcancelStart ( PGcancelConn cancelConn)

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

186{
187 if (!cancelConn || cancelConn->conn.status == CONNECTION_BAD)
188 return 0;
189
190 if (cancelConn->conn.status != CONNECTION_ALLOCATED)
191 {
193 "cancel request is already being sent on this connection");
194 cancelConn->conn.status = CONNECTION_BAD;
195 return 0;
196 }
197
198 return pqConnectDBStart(&cancelConn->conn);
199}
int pqConnectDBStart(PGconn *conn)
Definition: fe-connect.c:2638

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

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

◆ PQcancelStatus()

ConnStatusType PQcancelStatus ( const PGcancelConn cancelConn)

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

284{
285 return PQstatus(&cancelConn->conn);
286}
ConnStatusType PQstatus(const PGconn *conn)
Definition: fe-connect.c:7490

References cancelConn, and PQstatus().

Referenced by test_cancel().

◆ PQchangePassword()

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

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

1532{
1533 char *encrypted_password = PQencryptPasswordConn(conn, passwd,
1534 user, NULL);
1535
1536 if (!encrypted_password)
1537 {
1538 /* PQencryptPasswordConn() already registered the error */
1539 return NULL;
1540 }
1541 else
1542 {
1543 char *fmtpw = PQescapeLiteral(conn, encrypted_password,
1544 strlen(encrypted_password));
1545
1546 /* no longer needed, so clean up now */
1547 PQfreemem(encrypted_password);
1548
1549 if (!fmtpw)
1550 {
1551 /* PQescapeLiteral() already registered the error */
1552 return NULL;
1553 }
1554 else
1555 {
1556 char *fmtuser = PQescapeIdentifier(conn, user, strlen(user));
1557
1558 if (!fmtuser)
1559 {
1560 /* PQescapeIdentifier() already registered the error */
1561 PQfreemem(fmtpw);
1562 return NULL;
1563 }
1564 else
1565 {
1567 PGresult *res;
1568
1570 printfPQExpBuffer(&buf, "ALTER USER %s PASSWORD %s",
1571 fmtuser, fmtpw);
1572
1573 res = PQexec(conn, buf.data);
1574
1575 /* clean up */
1577 PQfreemem(fmtuser);
1578 PQfreemem(fmtpw);
1579
1580 return res;
1581 }
1582 }
1583 }
1584}
char * PQencryptPasswordConn(PGconn *conn, const char *passwd, const char *user, const char *algorithm)
Definition: fe-auth.c:1406
void PQfreemem(void *ptr)
Definition: fe-exec.c:4032
char * PQescapeLiteral(PGconn *conn, const char *str, size_t len)
Definition: fe-exec.c:4363
PGresult * PQexec(PGconn *conn, const char *query)
Definition: fe-exec.c:2262
char * PQescapeIdentifier(PGconn *conn, const char *str, size_t len)
Definition: fe-exec.c:4369
static char * user
Definition: pg_regress.c:119
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:235
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:90
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:129

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

Referenced by exec_command_password().

◆ PQclear()

void PQclear ( PGresult res)

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

722{
723 PGresult_data *block;
724 int i;
725
726 /* As a convenience, do nothing for a NULL pointer */
727 if (!res)
728 return;
729 /* Also, do nothing if the argument is OOM_result */
730 if ((const PGresult *) res == &OOM_result)
731 return;
732
733 /* Close down any events we may have */
734 for (i = 0; i < res->nEvents; i++)
735 {
736 /* only send DESTROY to successfully-initialized event procs */
737 if (res->events[i].resultInitialized)
738 {
740
741 evt.result = res;
742 (void) res->events[i].proc(PGEVT_RESULTDESTROY, &evt,
743 res->events[i].passThrough);
744 }
745 free(res->events[i].name);
746 }
747
748 free(res->events);
749
750 /* Free all the subsidiary blocks */
751 while ((block = res->curBlock) != NULL)
752 {
753 res->curBlock = block->next;
754 free(block);
755 }
756
757 /* Free the top-level tuple pointer array */
758 free(res->tuples);
759
760 /* zero out the pointer fields to catch programming errors */
761 res->attDescs = NULL;
762 res->tuples = NULL;
763 res->paramDescs = NULL;
764 res->errFields = NULL;
765 res->events = NULL;
766 res->nEvents = 0;
767 /* res->curBlock was zeroed out earlier */
768
769 /* Free the PGresult structure itself */
770 free(res);
771}
static const PGresult OOM_result
Definition: fe-exec.c:49
#define free(a)
Definition: header.h:65
int i
Definition: isn.c:74
@ PGEVT_RESULTDESTROY
Definition: libpq-events.h:34
void * passThrough
Definition: libpq-int.h:167
char * name
Definition: libpq-int.h:166
PGEventProc proc
Definition: libpq-int.h:165
bool resultInitialized
Definition: libpq-int.h:169
int nEvents
Definition: libpq-int.h:193
PGresAttValue ** tuples
Definition: libpq-int.h:177
PGresAttDesc * attDescs
Definition: libpq-int.h:176
PGMessageField * errFields
Definition: libpq-int.h:202
PGresParamDesc * paramDescs
Definition: libpq-int.h:181
PGEvent * events
Definition: libpq-int.h:192
PGresult_data * curBlock
Definition: libpq-int.h:213
PGresult_data * next
Definition: libpq-int.h:110

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

Referenced by _check_database_version(), _doSetSessionAuth(), _printTableAccessMethodNoStorage(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), add_tablespace_footer(), addFooterToPublicationDesc(), advanceConnectionState(), append_depends_on_extension(), appendQualifiedRelation(), BaseBackup(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), buildShSecLabels(), check_and_drop_existing_subscriptions(), check_and_drop_publications(), check_for_connection_status(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_is_install_user(), check_loadable_libraries(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), check_prepare_conn(), check_publisher(), check_subscriber(), ClearOrSaveResult(), close_cursor(), cluster_all_databases(), collectBinaryUpgradeClassOids(), collectComments(), collectRoleNames(), collectSecLabels(), collectSequences(), compile_database_list(), compile_relation_list_one_db(), confirm_query_canceled_impl(), connect_database(), ConnectDatabase(), connectDatabase(), connectToServer(), convertTSFunction(), create_cursor(), create_logical_replication_slot(), create_logical_replication_slots(), create_new_objects(), create_publication(), create_subscription(), CreateReplicationSlot(), createViewAsClause(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), dblink_res_error(), dblink_res_internalerror(), deallocate_one(), deallocate_query(), describeAccessMethods(), describeAggregates(), describeConfigurationParameters(), describeFunctions(), describeOneTableDetails(), describeOneTSConfig(), describeOneTSParser(), describeOperators(), describePublications(), DescribeQuery(), describeRoleGrants(), describeRoles(), describeSubscriptions(), describeTableDetails(), describeTablespaces(), describeTypes(), descriptor_free(), discardAbortedPipelineResults(), discardUntilSync(), do_lo_import(), do_sql_command_end(), drop_existing_subscriptions(), drop_failover_replication_slots(), drop_publication(), drop_replication_slot(), dropDBs(), DropReplicationSlot(), dropRoles(), dropTablespaces(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpCompositeType(), dumpConversion(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpDomain(), dumpEnumType(), dumpForeignServer(), dumpFunc(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRelationStats(), dumpRoleGUCPrivs(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSearchPath(), dumpSequence(), dumpSequenceData(), dumpStatisticsExt(), dumpTable(), dumpTableAttach(), 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(), enable_subscription(), EndDBCopyMode(), exec_command_password(), execute_foreign_modify(), executeCommand(), executeMaintenanceCommand(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlStatement(), executeStatement(), expand_dbname_patterns(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), fail_lo_xact(), fetch_more_data(), finish_lo_xact(), generate_object_name(), get_create_object_cmd(), get_db_infos(), get_language_name(), get_loadable_libraries(), get_next_possible_free_pg_type_oid(), get_parallel_tabidx_list(), get_parallel_tables_list(), get_primary_sysid(), get_remote_estimate(), get_returning_data(), get_subscription_count(), get_synchronized_snapshot(), get_table_relkind(), get_tablespace_paths(), get_template0_info(), getAccessMethods(), getAdditionalACLs(), getAggregates(), getCasts(), getCollations(), GetConnection(), getConstraints(), getConversions(), getCopyStart(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFormattedTypeName(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getParamDescriptions(), getPartitioningInfo(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRowDescriptions(), getRules(), GetSlotInformation(), getSubscriptions(), getSubscriptionTables(), getTableAttrs(), GetTableInfo(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), handleCopyIn(), HandleCopyResult(), HandleEndOfCopyStream(), init_libpq_conn(), initPopulateTable(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_alter_slot(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_PQexec(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_startstreaming(), libpqsrv_get_result_last(), listAllDbs(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtendedStats(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listLargeObjects(), 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(), objectDescription(), old_9_6_invalidate_hash_indexes(), permissionsList(), pgfdw_cancel_query_end(), pgfdw_exec_cleanup_query_end(), pgfdw_finish_pre_commit_cleanup(), pgfdw_get_cleanup_result(), pgfdw_report_error(), pgfdw_xact_callback(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresEndDirectModify(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), postgresReScanForeignScan(), pqClearAsyncResult(), PQconnectPoll(), PQcopyResult(), PQencryptPasswordConn(), pqEndcopy3(), PQexecFinish(), PQexecStart(), pqGetErrorNotice3(), pqInternalNotice(), PQmakeEmptyPGresult(), PQsetClientEncoding(), prepare_common(), prepare_foreign_modify(), prepareCommand(), process_query_result(), process_queued_fetch_requests(), process_result(), processExtensionTables(), processQueryResult(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), reindex_all_databases(), retrieve_objects(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), SendQuery(), server_is_in_recovery(), set_frozenxids(), set_locale_and_encoding(), set_replication_progress(), set_restrict_relation_kind(), setup_connection(), setup_publisher(), sql_conn(), sql_exec(), start_lo_xact(), store_returning_result(), storeQueryResult(), StreamLogicalLog(), TableCommandResultHandler(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), try_complete_step(), tryExecuteStatement(), vacuum_all_databases(), vacuumlo(), and wait_for_connection_state().

◆ PQclientEncoding()

◆ PQclosePortal()

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

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

2540{
2541 if (!PQexecStart(conn))
2542 return NULL;
2543 if (!PQsendTypedCommand(conn, PqMsg_Close, 'P', portal))
2544 return NULL;
2545 return PQexecFinish(conn);
2546}
static PGresult * PQexecFinish(PGconn *conn)
Definition: fe-exec.c:2410
static int PQsendTypedCommand(PGconn *conn, char command, char type, const char *target)
Definition: fe-exec.c:2589
static bool PQexecStart(PGconn *conn)
Definition: fe-exec.c:2344
#define PqMsg_Close
Definition: protocol.h:20

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

Referenced by test_prepared().

◆ PQclosePrepared()

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

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

2522{
2523 if (!PQexecStart(conn))
2524 return NULL;
2526 return NULL;
2527 return PQexecFinish(conn);
2528}
#define stmt
Definition: indent_codes.h:59

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

Referenced by test_prepared().

◆ PQcmdStatus()

char * PQcmdStatus ( PGresult res)

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

3753{
3754 if (!res)
3755 return NULL;
3756 return res->cmdStatus;
3757}
char cmdStatus[CMDSTATUS_LEN]
Definition: libpq-int.h:183

References pg_result::cmdStatus.

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

◆ PQcmdTuples()

char * PQcmdTuples ( PGresult res)

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

3823{
3824 char *p,
3825 *c;
3826
3827 if (!res)
3828 return "";
3829
3830 if (strncmp(res->cmdStatus, "INSERT ", 7) == 0)
3831 {
3832 p = res->cmdStatus + 7;
3833 /* INSERT: skip oid and space */
3834 while (*p && *p != ' ')
3835 p++;
3836 if (*p == 0)
3837 goto interpret_error; /* no space? */
3838 p++;
3839 }
3840 else if (strncmp(res->cmdStatus, "SELECT ", 7) == 0 ||
3841 strncmp(res->cmdStatus, "DELETE ", 7) == 0 ||
3842 strncmp(res->cmdStatus, "UPDATE ", 7) == 0)
3843 p = res->cmdStatus + 7;
3844 else if (strncmp(res->cmdStatus, "FETCH ", 6) == 0 ||
3845 strncmp(res->cmdStatus, "MERGE ", 6) == 0)
3846 p = res->cmdStatus + 6;
3847 else if (strncmp(res->cmdStatus, "MOVE ", 5) == 0 ||
3848 strncmp(res->cmdStatus, "COPY ", 5) == 0)
3849 p = res->cmdStatus + 5;
3850 else
3851 return "";
3852
3853 /* check that we have an integer (at least one digit, nothing else) */
3854 for (c = p; *c; c++)
3855 {
3856 if (!isdigit((unsigned char) *c))
3857 goto interpret_error;
3858 }
3859 if (c == p)
3860 goto interpret_error;
3861
3862 return p;
3863
3864interpret_error:
3866 "could not interpret result from server: %s",
3867 res->cmdStatus);
3868 return "";
3869}
void pqInternalNotice(const PGNoticeHooks *hooks, const char *fmt,...)
Definition: fe-exec.c:938
char * c
PGNoticeHooks noticeHooks
Definition: libpq-int.h:191

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

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

◆ PQconndefaults()

PQconninfoOption * PQconndefaults ( void  )

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

2128{
2129 PQExpBufferData errorBuf;
2130 PQconninfoOption *connOptions;
2131
2132 /* We don't actually report any errors here, but callees want a buffer */
2133 initPQExpBuffer(&errorBuf);
2134 if (PQExpBufferDataBroken(errorBuf))
2135 return NULL; /* out of memory already :-( */
2136
2137 connOptions = conninfo_init(&errorBuf);
2138 if (connOptions != NULL)
2139 {
2140 /* pass NULL errorBuf to ignore errors */
2141 if (!conninfo_add_defaults(connOptions, NULL))
2142 {
2143 PQconninfoFree(connOptions);
2144 connOptions = NULL;
2145 }
2146 }
2147
2148 termPQExpBuffer(&errorBuf);
2149 return connOptions;
2150}
static PQconninfoOption * conninfo_init(PQExpBuffer errorMessage)
Definition: fe-connect.c:6106
static bool conninfo_add_defaults(PQconninfoOption *options, PQExpBuffer errorMessage)
Definition: fe-connect.c:6533
void PQconninfoFree(PQconninfoOption *connOptions)
Definition: fe-connect.c:7368
#define PQExpBufferDataBroken(buf)
Definition: pqexpbuffer.h:67

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

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

◆ PQconnectdb()

PGconn * PQconnectdb ( const char *  conninfo)

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

793{
794 PGconn *conn = PQconnectStart(conninfo);
795
796 if (conn && conn->status != CONNECTION_BAD)
798
799 return conn;
800}
PGconn * PQconnectStart(const char *conninfo)
Definition: fe-connect.c:920

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

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

◆ PQconnectdbParams()

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

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

740{
741 PGconn *conn = PQconnectStartParams(keywords, values, expand_dbname);
742
743 if (conn && conn->status != CONNECTION_BAD)
745
746 return conn;
747}
static Datum values[MAXATTR]
Definition: bootstrap.c:151
PGconn * PQconnectStartParams(const char *const *keywords, const char *const *values, int expand_dbname)
Definition: fe-connect.c:839
static const JsonPathKeyword keywords[]

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

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

◆ PQconnectionNeedsPassword()

int PQconnectionNeedsPassword ( const PGconn conn)

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

7607{
7608 char *password;
7609
7610 if (!conn)
7611 return false;
7612 password = PQpass(conn);
7613 if (conn->password_needed &&
7614 (password == NULL || password[0] == '\0'))
7615 return true;
7616 else
7617 return false;
7618}
char * PQpass(const PGconn *conn)
Definition: fe-connect.c:7405
static char * password
Definition: streamutil.c:51
bool password_needed
Definition: libpq-int.h:508

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

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

◆ PQconnectionUsedGSSAPI()

int PQconnectionUsedGSSAPI ( const PGconn conn)

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

7633{
7634 if (!conn)
7635 return false;
7636 if (conn->gssapi_used)
7637 return true;
7638 else
7639 return false;
7640}
bool gssapi_used
Definition: libpq-int.h:509

References conn, and pg_conn::gssapi_used.

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

◆ PQconnectionUsedPassword()

int PQconnectionUsedPassword ( const PGconn conn)

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

7622{
7623 if (!conn)
7624 return false;
7625 if (conn->password_needed)
7626 return true;
7627 else
7628 return false;
7629}

References conn, and pg_conn::password_needed.

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

◆ PQconnectPoll()

PostgresPollingStatusType PQconnectPoll ( PGconn conn)

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

2843{
2844 bool reset_connection_state_machine = false;
2845 bool need_new_connection = false;
2846 PGresult *res;
2847 char sebuf[PG_STRERROR_R_BUFLEN];
2848 int optval;
2849
2850 if (conn == NULL)
2851 return PGRES_POLLING_FAILED;
2852
2853 /* Get the new data */
2854 switch (conn->status)
2855 {
2856 /*
2857 * We really shouldn't have been polled in these two cases, but we
2858 * can handle it.
2859 */
2860 case CONNECTION_BAD:
2861 return PGRES_POLLING_FAILED;
2862 case CONNECTION_OK:
2863 return PGRES_POLLING_OK;
2864
2865 /* These are reading states */
2867 case CONNECTION_AUTH_OK:
2869 case CONNECTION_CONSUME:
2871 {
2872 /* Load waiting data */
2873 int n = pqReadData(conn);
2874
2875 if (n < 0)
2876 goto error_return;
2877 if (n == 0)
2878 return PGRES_POLLING_READING;
2879
2880 break;
2881 }
2882
2883 /* These are writing states, so we just proceed. */
2884 case CONNECTION_STARTED:
2885 case CONNECTION_MADE:
2886 break;
2887
2888 /* Special cases: proceed without waiting. */
2890 case CONNECTION_NEEDED:
2894 break;
2895
2896 default:
2897 libpq_append_conn_error(conn, "invalid connection state, probably indicative of memory corruption");
2898 goto error_return;
2899 }
2900
2901
2902keep_going: /* We will come back to here until there is
2903 * nothing left to do. */
2904
2905 /* Time to advance to next address, or next host if no more addresses? */
2906 if (conn->try_next_addr)
2907 {
2908 if (conn->whichaddr < conn->naddr)
2909 {
2910 conn->whichaddr++;
2911 reset_connection_state_machine = true;
2912 }
2913 else
2914 conn->try_next_host = true;
2915 conn->try_next_addr = false;
2916 }
2917
2918 /* Time to advance to next connhost[] entry? */
2919 if (conn->try_next_host)
2920 {
2921 pg_conn_host *ch;
2922 struct addrinfo hint;
2923 struct addrinfo *addrlist;
2924 int thisport;
2925 int ret;
2926 char portstr[MAXPGPATH];
2927
2928 if (conn->whichhost + 1 < conn->nconnhost)
2929 conn->whichhost++;
2930 else
2931 {
2932 /*
2933 * Oops, no more hosts.
2934 *
2935 * If we are trying to connect in "prefer-standby" mode, then drop
2936 * the standby requirement and start over. Don't do this for
2937 * cancel requests though, since we are certain the list of
2938 * servers won't change as the target_server_type option is not
2939 * applicable to those connections.
2940 *
2941 * Otherwise, an appropriate error message is already set up, so
2942 * we just need to set the right status.
2943 */
2945 conn->nconnhost > 0 &&
2947 {
2949 conn->whichhost = 0;
2950 }
2951 else
2952 goto error_return;
2953 }
2954
2955 /* Drop any address info for previous host */
2957
2958 /*
2959 * Look up info for the new host. On failure, log the problem in
2960 * conn->errorMessage, then loop around to try the next host. (Note
2961 * we don't clear try_next_host until we've succeeded.)
2962 */
2963 ch = &conn->connhost[conn->whichhost];
2964
2965 /* Initialize hint structure */
2966 MemSet(&hint, 0, sizeof(hint));
2967 hint.ai_socktype = SOCK_STREAM;
2968 hint.ai_family = AF_UNSPEC;
2969
2970 /* Figure out the port number we're going to use. */
2971 if (ch->port == NULL || ch->port[0] == '\0')
2972 thisport = DEF_PGPORT;
2973 else
2974 {
2975 if (!pqParseIntParam(ch->port, &thisport, conn, "port"))
2976 goto error_return;
2977
2978 if (thisport < 1 || thisport > 65535)
2979 {
2980 libpq_append_conn_error(conn, "invalid port number: \"%s\"", ch->port);
2981 goto keep_going;
2982 }
2983 }
2984 snprintf(portstr, sizeof(portstr), "%d", thisport);
2985
2986 /* Use pg_getaddrinfo_all() to resolve the address */
2987 switch (ch->type)
2988 {
2989 case CHT_HOST_NAME:
2990 ret = pg_getaddrinfo_all(ch->host, portstr, &hint,
2991 &addrlist);
2992 if (ret || !addrlist)
2993 {
2994 libpq_append_conn_error(conn, "could not translate host name \"%s\" to address: %s",
2995 ch->host, gai_strerror(ret));
2996 goto keep_going;
2997 }
2998 break;
2999
3000 case CHT_HOST_ADDRESS:
3001 hint.ai_flags = AI_NUMERICHOST;
3002 ret = pg_getaddrinfo_all(ch->hostaddr, portstr, &hint,
3003 &addrlist);
3004 if (ret || !addrlist)
3005 {
3006 libpq_append_conn_error(conn, "could not parse network address \"%s\": %s",
3007 ch->hostaddr, gai_strerror(ret));
3008 goto keep_going;
3009 }
3010 break;
3011
3012 case CHT_UNIX_SOCKET:
3013 hint.ai_family = AF_UNIX;
3014 UNIXSOCK_PATH(portstr, thisport, ch->host);
3015 if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
3016 {
3017 libpq_append_conn_error(conn, "Unix-domain socket path \"%s\" is too long (maximum %d bytes)",
3018 portstr,
3019 (int) (UNIXSOCK_PATH_BUFLEN - 1));
3020 goto keep_going;
3021 }
3022
3023 /*
3024 * NULL hostname tells pg_getaddrinfo_all to parse the service
3025 * name as a Unix-domain socket path.
3026 */
3027 ret = pg_getaddrinfo_all(NULL, portstr, &hint,
3028 &addrlist);
3029 if (ret || !addrlist)
3030 {
3031 libpq_append_conn_error(conn, "could not translate Unix-domain socket path \"%s\" to address: %s",
3032 portstr, gai_strerror(ret));
3033 goto keep_going;
3034 }
3035 break;
3036 }
3037
3038 /*
3039 * Store a copy of the addrlist in private memory so we can perform
3040 * randomization for load balancing.
3041 */
3042 ret = store_conn_addrinfo(conn, addrlist);
3043 pg_freeaddrinfo_all(hint.ai_family, addrlist);
3044 if (ret)
3045 goto error_return; /* message already logged */
3046
3047 /*
3048 * If random load balancing is enabled we shuffle the addresses.
3049 */
3051 {
3052 /*
3053 * This is the "inside-out" variant of the Fisher-Yates shuffle
3054 * algorithm. Notionally, we append each new value to the array
3055 * and then swap it with a randomly-chosen array element (possibly
3056 * including itself, else we fail to generate permutations with
3057 * the last integer last). The swap step can be optimized by
3058 * combining it with the insertion.
3059 *
3060 * We don't need to initialize conn->prng_state here, because that
3061 * already happened in pqConnectOptions2.
3062 */
3063 for (int i = 1; i < conn->naddr; i++)
3064 {
3065 int j = pg_prng_uint64_range(&conn->prng_state, 0, i);
3066 AddrInfo temp = conn->addr[j];
3067
3068 conn->addr[j] = conn->addr[i];
3069 conn->addr[i] = temp;
3070 }
3071 }
3072
3073 reset_connection_state_machine = true;
3074 conn->try_next_host = false;
3075 }
3076
3077 /* Reset connection state machine? */
3078 if (reset_connection_state_machine)
3079 {
3080 /*
3081 * (Re) initialize our connection control variables for a set of
3082 * connection attempts to a single server address. These variables
3083 * must persist across individual connection attempts, but we must
3084 * reset them when we start to consider a new server.
3085 */
3086 conn->pversion = PG_PROTOCOL(3, 0);
3087 conn->send_appname = true;
3091 reset_connection_state_machine = false;
3092 need_new_connection = true;
3093 }
3094
3095 /* Force a new connection (perhaps to the same server as before)? */
3096 if (need_new_connection)
3097 {
3098 /* Drop any existing connection */
3099 pqDropConnection(conn, true);
3100
3101 /* Reset all state obtained from old server */
3103
3104 /* Drop any PGresult we might have, too */
3109
3110 /* Reset conn->status to put the state machine in the right state */
3112
3113 need_new_connection = false;
3114 }
3115
3116 /*
3117 * Decide what to do next, if server rejects SSL or GSS negotiation, but
3118 * the connection is still valid. If there are no options left, error out
3119 * with 'msg'.
3120 */
3121#define ENCRYPTION_NEGOTIATION_FAILED(msg) \
3122 do { \
3123 switch (encryption_negotiation_failed(conn)) \
3124 { \
3125 case 0: \
3126 libpq_append_conn_error(conn, (msg)); \
3127 goto error_return; \
3128 case 1: \
3129 conn->status = CONNECTION_MADE; \
3130 return PGRES_POLLING_WRITING; \
3131 case 2: \
3132 need_new_connection = true; \
3133 goto keep_going; \
3134 } \
3135 } while(0);
3136
3137 /*
3138 * Decide what to do next, if connection fails. If there are no options
3139 * left, return with an error. The error message has already been written
3140 * to the connection's error buffer.
3141 */
3142#define CONNECTION_FAILED() \
3143 do { \
3144 if (connection_failed(conn)) \
3145 { \
3146 need_new_connection = true; \
3147 goto keep_going; \
3148 } \
3149 else \
3150 goto error_return; \
3151 } while(0);
3152
3153 /* Now try to advance the state machine for this connection */
3154 switch (conn->status)
3155 {
3156 case CONNECTION_NEEDED:
3157 {
3158 /*
3159 * Try to initiate a connection to one of the addresses
3160 * returned by pg_getaddrinfo_all(). conn->whichaddr is the
3161 * next one to try.
3162 *
3163 * The extra level of braces here is historical. It's not
3164 * worth reindenting this whole switch case to remove 'em.
3165 */
3166 {
3167 char host_addr[NI_MAXHOST];
3168 int sock_type;
3169 AddrInfo *addr_cur;
3170
3171 /*
3172 * Advance to next possible host, if we've tried all of
3173 * the addresses for the current host.
3174 */
3175 if (conn->whichaddr == conn->naddr)
3176 {
3177 conn->try_next_host = true;
3178 goto keep_going;
3179 }
3180 addr_cur = &conn->addr[conn->whichaddr];
3181
3182 /* Remember current address for possible use later */
3183 memcpy(&conn->raddr, &addr_cur->addr, sizeof(SockAddr));
3184
3185#ifdef ENABLE_GSS
3186
3187 /*
3188 * Before establishing the connection, check if it's
3189 * doomed to fail because gssencmode='require' but GSSAPI
3190 * is not available.
3191 */
3192 if (conn->gssencmode[0] == 'r')
3193 {
3194 if (conn->raddr.addr.ss_family == AF_UNIX)
3195 {
3197 "GSSAPI encryption required but it is not supported over a local socket");
3198 goto error_return;
3199 }
3200 if (conn->gcred == GSS_C_NO_CREDENTIAL)
3201 {
3202 if (!pg_GSS_have_cred_cache(&conn->gcred))
3203 {
3205 "GSSAPI encryption required but no credential cache");
3206 goto error_return;
3207 }
3208 }
3209 }
3210#endif
3211
3212 /*
3213 * Choose the encryption method to try first. Do this
3214 * before establishing the connection, so that if none of
3215 * the modes allowed by the connections options are
3216 * available, we can error out before establishing the
3217 * connection.
3218 */
3220 goto error_return;
3221
3222 /*
3223 * Set connip, too. Note we purposely ignore strdup
3224 * failure; not a big problem if it fails.
3225 */
3226 if (conn->connip != NULL)
3227 {
3228 free(conn->connip);
3229 conn->connip = NULL;
3230 }
3231 getHostaddr(conn, host_addr, NI_MAXHOST);
3232 if (host_addr[0])
3233 conn->connip = strdup(host_addr);
3234
3235 /* Try to create the socket */
3236 sock_type = SOCK_STREAM;
3237#ifdef SOCK_CLOEXEC
3238
3239 /*
3240 * Atomically mark close-on-exec, if possible on this
3241 * platform, so that there isn't a window where a
3242 * subprogram executed by another thread inherits the
3243 * socket. See fallback code below.
3244 */
3245 sock_type |= SOCK_CLOEXEC;
3246#endif
3247#ifdef SOCK_NONBLOCK
3248
3249 /*
3250 * We might as well skip a system call for nonblocking
3251 * mode too, if we can.
3252 */
3253 sock_type |= SOCK_NONBLOCK;
3254#endif
3255 conn->sock = socket(addr_cur->family, sock_type, 0);
3256 if (conn->sock == PGINVALID_SOCKET)
3257 {
3258 int errorno = SOCK_ERRNO;
3259
3260 /*
3261 * Silently ignore socket() failure if we have more
3262 * addresses to try; this reduces useless chatter in
3263 * cases where the address list includes both IPv4 and
3264 * IPv6 but kernel only accepts one family.
3265 */
3266 if (conn->whichaddr < conn->naddr ||
3267 conn->whichhost + 1 < conn->nconnhost)
3268 {
3269 conn->try_next_addr = true;
3270 goto keep_going;
3271 }
3272 emitHostIdentityInfo(conn, host_addr);
3273 libpq_append_conn_error(conn, "could not create socket: %s",
3274 SOCK_STRERROR(errorno, sebuf, sizeof(sebuf)));
3275 goto error_return;
3276 }
3277
3278 /*
3279 * Once we've identified a target address, all errors
3280 * except the preceding socket()-failure case should be
3281 * prefixed with host-identity information. (If the
3282 * connection succeeds, the contents of conn->errorMessage
3283 * won't matter, so this is harmless.)
3284 */
3285 emitHostIdentityInfo(conn, host_addr);
3286
3287 /*
3288 * Select socket options: no delay of outgoing data for
3289 * TCP sockets, nonblock mode, close-on-exec. Try the
3290 * next address if any of this fails.
3291 */
3292 if (addr_cur->family != AF_UNIX)
3293 {
3294 if (!connectNoDelay(conn))
3295 {
3296 /* error message already created */
3297 conn->try_next_addr = true;
3298 goto keep_going;
3299 }
3300 }
3301#ifndef SOCK_NONBLOCK
3302 if (!pg_set_noblock(conn->sock))
3303 {
3304 libpq_append_conn_error(conn, "could not set socket to nonblocking mode: %s",
3305 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3306 conn->try_next_addr = true;
3307 goto keep_going;
3308 }
3309#endif
3310
3311#ifndef SOCK_CLOEXEC
3312#ifdef F_SETFD
3313 if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
3314 {
3315 libpq_append_conn_error(conn, "could not set socket to close-on-exec mode: %s",
3316 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3317 conn->try_next_addr = true;
3318 goto keep_going;
3319 }
3320#endif /* F_SETFD */
3321#endif
3322
3323 if (addr_cur->family != AF_UNIX)
3324 {
3325#ifndef WIN32
3326 int on = 1;
3327#endif
3328 int usekeepalives = useKeepalives(conn);
3329 int err = 0;
3330
3331 if (usekeepalives < 0)
3332 {
3333 /* error is already reported */
3334 err = 1;
3335 }
3336 else if (usekeepalives == 0)
3337 {
3338 /* Do nothing */
3339 }
3340#ifndef WIN32
3341 else if (setsockopt(conn->sock,
3342 SOL_SOCKET, SO_KEEPALIVE,
3343 (char *) &on, sizeof(on)) < 0)
3344 {
3345 libpq_append_conn_error(conn, "%s(%s) failed: %s",
3346 "setsockopt",
3347 "SO_KEEPALIVE",
3348 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3349 err = 1;
3350 }
3351 else if (!setKeepalivesIdle(conn)
3354 err = 1;
3355#else /* WIN32 */
3356#ifdef SIO_KEEPALIVE_VALS
3357 else if (!prepKeepalivesWin32(conn))
3358 err = 1;
3359#endif /* SIO_KEEPALIVE_VALS */
3360#endif /* WIN32 */
3361 else if (!setTCPUserTimeout(conn))
3362 err = 1;
3363
3364 if (err)
3365 {
3366 conn->try_next_addr = true;
3367 goto keep_going;
3368 }
3369 }
3370
3371 /*----------
3372 * We have three methods of blocking SIGPIPE during
3373 * send() calls to this socket:
3374 *
3375 * - setsockopt(sock, SO_NOSIGPIPE)
3376 * - send(sock, ..., MSG_NOSIGNAL)
3377 * - setting the signal mask to SIG_IGN during send()
3378 *
3379 * The third method requires three syscalls per send,
3380 * so we prefer either of the first two, but they are
3381 * less portable. The state is tracked in the following
3382 * members of PGconn:
3383 *
3384 * conn->sigpipe_so - we have set up SO_NOSIGPIPE
3385 * conn->sigpipe_flag - we're specifying MSG_NOSIGNAL
3386 *
3387 * If we can use SO_NOSIGPIPE, then set sigpipe_so here
3388 * and we're done. Otherwise, set sigpipe_flag so that
3389 * we will try MSG_NOSIGNAL on sends. If we get an error
3390 * with MSG_NOSIGNAL, we'll clear that flag and revert to
3391 * signal masking.
3392 *----------
3393 */
3394 conn->sigpipe_so = false;
3395#ifdef MSG_NOSIGNAL
3396 conn->sigpipe_flag = true;
3397#else
3398 conn->sigpipe_flag = false;
3399#endif /* MSG_NOSIGNAL */
3400
3401#ifdef SO_NOSIGPIPE
3402 optval = 1;
3403 if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
3404 (char *) &optval, sizeof(optval)) == 0)
3405 {
3406 conn->sigpipe_so = true;
3407 conn->sigpipe_flag = false;
3408 }
3409#endif /* SO_NOSIGPIPE */
3410
3411 /*
3412 * Start/make connection. This should not block, since we
3413 * are in nonblock mode. If it does, well, too bad.
3414 */
3415 if (connect(conn->sock, (struct sockaddr *) &addr_cur->addr.addr,
3416 addr_cur->addr.salen) < 0)
3417 {
3418 if (SOCK_ERRNO == EINPROGRESS ||
3419#ifdef WIN32
3421#endif
3422 SOCK_ERRNO == EINTR)
3423 {
3424 /*
3425 * This is fine - we're in non-blocking mode, and
3426 * the connection is in progress. Tell caller to
3427 * wait for write-ready on socket.
3428 */
3430 return PGRES_POLLING_WRITING;
3431 }
3432 /* otherwise, trouble */
3433 }
3434 else
3435 {
3436 /*
3437 * Hm, we're connected already --- seems the "nonblock
3438 * connection" wasn't. Advance the state machine and
3439 * go do the next stuff.
3440 */
3442 goto keep_going;
3443 }
3444
3445 /*
3446 * This connection failed. Add the error report to
3447 * conn->errorMessage, then try the next address if any.
3448 */
3450 conn->try_next_addr = true;
3451 goto keep_going;
3452 }
3453 }
3454
3455 case CONNECTION_STARTED:
3456 {
3457 socklen_t optlen = sizeof(optval);
3458
3459 /*
3460 * Write ready, since we've made it here, so the connection
3461 * has been made ... or has failed.
3462 */
3463
3464 /*
3465 * Now check (using getsockopt) that there is not an error
3466 * state waiting for us on the socket.
3467 */
3468
3469 if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
3470 (char *) &optval, &optlen) == -1)
3471 {
3472 libpq_append_conn_error(conn, "could not get socket error status: %s",
3473 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3474 goto error_return;
3475 }
3476 else if (optval != 0)
3477 {
3478 /*
3479 * When using a nonblocking connect, we will typically see
3480 * connect failures at this point, so provide a friendly
3481 * error message.
3482 */
3483 connectFailureMessage(conn, optval);
3484
3485 /*
3486 * Try the next address if any, just as in the case where
3487 * connect() returned failure immediately.
3488 */
3489 conn->try_next_addr = true;
3490 goto keep_going;
3491 }
3492
3493 /* Fill in the client address */
3494 conn->laddr.salen = sizeof(conn->laddr.addr);
3495 if (getsockname(conn->sock,
3496 (struct sockaddr *) &conn->laddr.addr,
3497 &conn->laddr.salen) < 0)
3498 {
3499 libpq_append_conn_error(conn, "could not get client address from socket: %s",
3500 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3501 goto error_return;
3502 }
3503
3504 /*
3505 * Implement requirepeer check, if requested and it's a
3506 * Unix-domain socket.
3507 */
3508 if (conn->requirepeer && conn->requirepeer[0] &&
3509 conn->raddr.addr.ss_family == AF_UNIX)
3510 {
3511#ifndef WIN32
3512 char *remote_username;
3513#endif
3514 uid_t uid;
3515 gid_t gid;
3516
3517 errno = 0;
3518 if (getpeereid(conn->sock, &uid, &gid) != 0)
3519 {
3520 /*
3521 * Provide special error message if getpeereid is a
3522 * stub
3523 */
3524 if (errno == ENOSYS)
3525 libpq_append_conn_error(conn, "requirepeer parameter is not supported on this platform");
3526 else
3527 libpq_append_conn_error(conn, "could not get peer credentials: %s",
3528 strerror_r(errno, sebuf, sizeof(sebuf)));
3529 goto error_return;
3530 }
3531
3532#ifndef WIN32
3533 remote_username = pg_fe_getusername(uid,
3534 &conn->errorMessage);
3535 if (remote_username == NULL)
3536 goto error_return; /* message already logged */
3537
3538 if (strcmp(remote_username, conn->requirepeer) != 0)
3539 {
3540 libpq_append_conn_error(conn, "requirepeer specifies \"%s\", but actual peer user name is \"%s\"",
3541 conn->requirepeer, remote_username);
3542 free(remote_username);
3543 goto error_return;
3544 }
3545 free(remote_username);
3546#else /* WIN32 */
3547 /* should have failed with ENOSYS above */
3548 Assert(false);
3549#endif /* WIN32 */
3550 }
3551
3552 /*
3553 * Make sure we can write before advancing to next step.
3554 */
3556 return PGRES_POLLING_WRITING;
3557 }
3558
3559 case CONNECTION_MADE:
3560 {
3561 char *startpacket;
3562 int packetlen;
3563
3564#ifdef ENABLE_GSS
3565
3566 /*
3567 * If GSSAPI encryption is enabled, send a packet to the
3568 * server asking for GSSAPI Encryption and proceed with GSSAPI
3569 * handshake. We will come back here after GSSAPI encryption
3570 * has been established, with conn->gctx set.
3571 */
3572 if (conn->current_enc_method == ENC_GSSAPI && !conn->gctx)
3573 {
3575
3576 if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
3577 {
3578 libpq_append_conn_error(conn, "could not send GSSAPI negotiation packet: %s",
3579 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3580 goto error_return;
3581 }
3582
3583 /* Ok, wait for response */
3585 return PGRES_POLLING_READING;
3586 }
3587#endif
3588
3589#ifdef USE_SSL
3590
3591 /*
3592 * If SSL is enabled, start the SSL negotiation. We will come
3593 * back here after SSL encryption has been established, with
3594 * ssl_in_use set.
3595 */
3597 {
3598 /*
3599 * If traditional postgres SSL negotiation is used, send
3600 * the SSL request. In direct negotiation, jump straight
3601 * into the SSL handshake.
3602 */
3603 if (conn->sslnegotiation[0] == 'p')
3604 {
3605 ProtocolVersion pv;
3606
3607 /*
3608 * Send the SSL request packet.
3609 *
3610 * Theoretically, this could block, but it really
3611 * shouldn't since we only got here if the socket is
3612 * write-ready.
3613 */
3615 if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
3616 {
3617 libpq_append_conn_error(conn, "could not send SSL negotiation packet: %s",
3618 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3619 goto error_return;
3620 }
3621 /* Ok, wait for response */
3623 return PGRES_POLLING_READING;
3624 }
3625 else
3626 {
3627 Assert(conn->sslnegotiation[0] == 'd');
3629 return PGRES_POLLING_WRITING;
3630 }
3631 }
3632#endif /* USE_SSL */
3633
3634 /*
3635 * For cancel requests this is as far as we need to go in the
3636 * connection establishment. Now we can actually send our
3637 * cancellation request.
3638 */
3639 if (conn->cancelRequest)
3640 {
3641 CancelRequestPacket cancelpacket;
3642
3643 packetlen = sizeof(cancelpacket);
3645 cancelpacket.backendPID = pg_hton32(conn->be_pid);
3646 cancelpacket.cancelAuthCode = pg_hton32(conn->be_key);
3647 if (pqPacketSend(conn, 0, &cancelpacket, packetlen) != STATUS_OK)
3648 {
3649 libpq_append_conn_error(conn, "could not send cancel packet: %s",
3650 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3651 goto error_return;
3652 }
3654 return PGRES_POLLING_READING;
3655 }
3656
3657 /*
3658 * We have now established encryption, or we are happy to
3659 * proceed without.
3660 */
3661
3662 /* Build the startup packet. */
3663 startpacket = pqBuildStartupPacket3(conn, &packetlen,
3665 if (!startpacket)
3666 {
3667 libpq_append_conn_error(conn, "out of memory");
3668 goto error_return;
3669 }
3670
3671 /*
3672 * Send the startup packet.
3673 *
3674 * Theoretically, this could block, but it really shouldn't
3675 * since we only got here if the socket is write-ready.
3676 */
3677 if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
3678 {
3679 libpq_append_conn_error(conn, "could not send startup packet: %s",
3680 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
3681 free(startpacket);
3682 goto error_return;
3683 }
3684
3685 free(startpacket);
3686
3688 return PGRES_POLLING_READING;
3689 }
3690
3691 /*
3692 * Handle SSL negotiation: wait for postmaster messages and
3693 * respond as necessary.
3694 */
3696 {
3697#ifdef USE_SSL
3699
3700 /*
3701 * On first time through with traditional SSL negotiation, get
3702 * the postmaster's response to our SSLRequest packet. With
3703 * sslnegotiation='direct', go straight to initiating SSL.
3704 */
3705 if (!conn->ssl_in_use && conn->sslnegotiation[0] == 'p')
3706 {
3707 /*
3708 * We use pqReadData here since it has the logic to
3709 * distinguish no-data-yet from connection closure. Since
3710 * conn->ssl isn't set, a plain recv() will occur.
3711 */
3712 char SSLok;
3713 int rdresult;
3714
3715 rdresult = pqReadData(conn);
3716 if (rdresult < 0)
3717 {
3718 /* errorMessage is already filled in */
3719 goto error_return;
3720 }
3721 if (rdresult == 0)
3722 {
3723 /* caller failed to wait for data */
3724 return PGRES_POLLING_READING;
3725 }
3726 if (pqGetc(&SSLok, conn) < 0)
3727 {
3728 /* should not happen really */
3729 return PGRES_POLLING_READING;
3730 }
3731 if (SSLok == 'S')
3732 {
3733 if (conn->Pfdebug)
3734 pqTraceOutputCharResponse(conn, "SSLResponse",
3735 SSLok);
3736 /* mark byte consumed */
3738 }
3739 else if (SSLok == 'N')
3740 {
3741 if (conn->Pfdebug)
3742 pqTraceOutputCharResponse(conn, "SSLResponse",
3743 SSLok);
3744 /* mark byte consumed */
3746
3747 /*
3748 * The connection is still valid, so if it's OK to
3749 * continue without SSL, we can proceed using this
3750 * connection. Otherwise return with an error.
3751 */
3752 ENCRYPTION_NEGOTIATION_FAILED(libpq_gettext("server does not support SSL, but SSL was required"));
3753 }
3754 else if (SSLok == 'E')
3755 {
3756 /*
3757 * Server failure of some sort, such as failure to
3758 * fork a backend process. Don't bother retrieving
3759 * the error message; we should not trust it as the
3760 * server has not been authenticated yet.
3761 */
3762 libpq_append_conn_error(conn, "server sent an error response during SSL exchange");
3763 goto error_return;
3764 }
3765 else
3766 {
3767 libpq_append_conn_error(conn, "received invalid response to SSL negotiation: %c",
3768 SSLok);
3769 goto error_return;
3770 }
3771 }
3772
3773 /*
3774 * Begin or continue the SSL negotiation process.
3775 */
3776 pollres = pqsecure_open_client(conn);
3777 if (pollres == PGRES_POLLING_OK)
3778 {
3779 /*
3780 * At this point we should have no data already buffered.
3781 * If we do, it was received before we performed the SSL
3782 * handshake, so it wasn't encrypted and indeed may have
3783 * been injected by a man-in-the-middle.
3784 */
3785 if (conn->inCursor != conn->inEnd)
3786 {
3787 libpq_append_conn_error(conn, "received unencrypted data after SSL response");
3788 goto error_return;
3789 }
3790
3791 /* SSL handshake done, ready to send startup packet */
3793 return PGRES_POLLING_WRITING;
3794 }
3795 if (pollres == PGRES_POLLING_FAILED)
3796 {
3797 /*
3798 * SSL handshake failed. We will retry with a plaintext
3799 * connection, if permitted by sslmode.
3800 */
3802 }
3803 /* Else, return POLLING_READING or POLLING_WRITING status */
3804 return pollres;
3805#else /* !USE_SSL */
3806 /* can't get here */
3807 goto error_return;
3808#endif /* USE_SSL */
3809 }
3810
3812 {
3813#ifdef ENABLE_GSS
3815
3816 /*
3817 * If we haven't yet, get the postmaster's response to our
3818 * negotiation packet
3819 */
3820 if (!conn->gctx)
3821 {
3822 char gss_ok;
3823 int rdresult = pqReadData(conn);
3824
3825 if (rdresult < 0)
3826 /* pqReadData fills in error message */
3827 goto error_return;
3828 else if (rdresult == 0)
3829 /* caller failed to wait for data */
3830 return PGRES_POLLING_READING;
3831 if (pqGetc(&gss_ok, conn) < 0)
3832 /* shouldn't happen... */
3833 return PGRES_POLLING_READING;
3834
3835 if (gss_ok == 'E')
3836 {
3837 /*
3838 * Server failure of some sort, possibly protocol
3839 * version support failure. Don't bother retrieving
3840 * the error message; we should not trust it anyway as
3841 * the server has not authenticated yet.
3842 *
3843 * Note that unlike on an error response to
3844 * SSLRequest, we allow falling back to SSL or
3845 * plaintext connection here. GSS support was
3846 * introduced in PostgreSQL version 12, so an error
3847 * response might mean that we are connecting to a
3848 * pre-v12 server.
3849 */
3850 libpq_append_conn_error(conn, "server sent an error response during GSS encryption exchange");
3852 }
3853
3854 /* mark byte consumed */
3856
3857 if (gss_ok == 'N')
3858 {
3859 if (conn->Pfdebug)
3860 pqTraceOutputCharResponse(conn, "GSSENCResponse",
3861 gss_ok);
3862
3863 /*
3864 * The connection is still valid, so if it's OK to
3865 * continue without GSS, we can proceed using this
3866 * connection. Otherwise return with an error.
3867 */
3868 ENCRYPTION_NEGOTIATION_FAILED(libpq_gettext("server doesn't support GSSAPI encryption, but it was required"));
3869 }
3870 else if (gss_ok != 'G')
3871 {
3872 libpq_append_conn_error(conn, "received invalid response to GSSAPI negotiation: %c",
3873 gss_ok);
3874 goto error_return;
3875 }
3876
3877 if (conn->Pfdebug)
3878 pqTraceOutputCharResponse(conn, "GSSENCResponse",
3879 gss_ok);
3880 }
3881
3882 /* Begin or continue GSSAPI negotiation */
3883 pollres = pqsecure_open_gss(conn);
3884 if (pollres == PGRES_POLLING_OK)
3885 {
3886 /*
3887 * At this point we should have no data already buffered.
3888 * If we do, it was received before we performed the GSS
3889 * handshake, so it wasn't encrypted and indeed may have
3890 * been injected by a man-in-the-middle.
3891 */
3892 if (conn->inCursor != conn->inEnd)
3893 {
3894 libpq_append_conn_error(conn, "received unencrypted data after GSSAPI encryption response");
3895 goto error_return;
3896 }
3897
3898 /* All set for startup packet */
3900 return PGRES_POLLING_WRITING;
3901 }
3902 else if (pollres == PGRES_POLLING_FAILED)
3903 {
3904 /*
3905 * GSS handshake failed. We will retry with an SSL or
3906 * plaintext connection, if permitted by the options.
3907 */
3909 }
3910 /* Else, return POLLING_READING or POLLING_WRITING status */
3911 return pollres;
3912#else /* !ENABLE_GSS */
3913 /* unreachable */
3914 goto error_return;
3915#endif /* ENABLE_GSS */
3916 }
3917
3918 /*
3919 * Handle authentication exchange: wait for postmaster messages
3920 * and respond as necessary.
3921 */
3923 {
3924 char beresp;
3925 int msgLength;
3926 int avail;
3927 AuthRequest areq;
3928 int res;
3929 bool async;
3930
3931 /*
3932 * Scan the message from current point (note that if we find
3933 * the message is incomplete, we will return without advancing
3934 * inStart, and resume here next time).
3935 */
3937
3938 /* Read type byte */
3939 if (pqGetc(&beresp, conn))
3940 {
3941 /* We'll come back when there is more data */
3942 return PGRES_POLLING_READING;
3943 }
3944
3945 /*
3946 * Validate message type: we expect only an authentication
3947 * request, NegotiateProtocolVersion, or an error here.
3948 * Anything else probably means it's not Postgres on the other
3949 * end at all.
3950 */
3951 if (beresp != PqMsg_AuthenticationRequest &&
3952 beresp != PqMsg_ErrorResponse &&
3954 {
3955 libpq_append_conn_error(conn, "expected authentication request from server, but received %c",
3956 beresp);
3957 goto error_return;
3958 }
3959
3960 /* Read message length word */
3961 if (pqGetInt(&msgLength, 4, conn))
3962 {
3963 /* We'll come back when there is more data */
3964 return PGRES_POLLING_READING;
3965 }
3966
3967 /*
3968 * Try to validate message length before using it.
3969 *
3970 * Authentication requests can't be very large, although GSS
3971 * auth requests may not be that small. Same for
3972 * NegotiateProtocolVersion.
3973 *
3974 * Errors can be a little larger, but not huge. If we see a
3975 * large apparent length in an error, it means we're really
3976 * talking to a pre-3.0-protocol server; cope. (Before
3977 * version 14, the server also used the old protocol for
3978 * errors that happened before processing the startup packet.)
3979 */
3980 if (beresp == PqMsg_AuthenticationRequest &&
3981 (msgLength < 8 || msgLength > 2000))
3982 {
3983 libpq_append_conn_error(conn, "received invalid authentication request");
3984 goto error_return;
3985 }
3986 if (beresp == PqMsg_NegotiateProtocolVersion &&
3987 (msgLength < 8 || msgLength > 2000))
3988 {
3989 libpq_append_conn_error(conn, "received invalid protocol negotiation message");
3990 goto error_return;
3991 }
3992
3993#define MAX_ERRLEN 30000
3994 if (beresp == PqMsg_ErrorResponse &&
3995 (msgLength < 8 || msgLength > MAX_ERRLEN))
3996 {
3997 /* Handle error from a pre-3.0 server */
3998 conn->inCursor = conn->inStart + 1; /* reread data */
4000 {
4001 /*
4002 * We may not have authenticated the server yet, so
4003 * don't let the buffer grow forever.
4004 */
4005 avail = conn->inEnd - conn->inCursor;
4006 if (avail > MAX_ERRLEN)
4007 {
4008 libpq_append_conn_error(conn, "received invalid error message");
4009 goto error_return;
4010 }
4011
4012 /* We'll come back when there is more data */
4013 return PGRES_POLLING_READING;
4014 }
4015 /* OK, we read the message; mark data consumed */
4017
4018 /*
4019 * Before 7.2, the postmaster didn't always end its
4020 * messages with a newline, so add one if needed to
4021 * conform to libpq conventions.
4022 */
4023 if (conn->errorMessage.len == 0 ||
4024 conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
4025 {
4027 }
4028
4029 goto error_return;
4030 }
4031#undef MAX_ERRLEN
4032
4033 /*
4034 * Can't process if message body isn't all here yet.
4035 *
4036 * After this check passes, any further EOF during parsing
4037 * implies that the server sent a bad/truncated message.
4038 * Reading more bytes won't help in that case, so don't return
4039 * PGRES_POLLING_READING after this point.
4040 */
4041 msgLength -= 4;
4042 avail = conn->inEnd - conn->inCursor;
4043 if (avail < msgLength)
4044 {
4045 /*
4046 * Before returning, try to enlarge the input buffer if
4047 * needed to hold the whole message; see notes in
4048 * pqParseInput3.
4049 */
4050 if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
4051 conn))
4052 goto error_return;
4053 /* We'll come back when there is more data */
4054 return PGRES_POLLING_READING;
4055 }
4056
4057 /* Handle errors. */
4058 if (beresp == PqMsg_ErrorResponse)
4059 {
4060 if (pqGetErrorNotice3(conn, true))
4061 {
4062 libpq_append_conn_error(conn, "received invalid error message");
4063 goto error_return;
4064 }
4065 /* OK, we read the message; mark data consumed */
4067
4068 /*
4069 * If error is "cannot connect now", try the next host if
4070 * any (but we don't want to consider additional addresses
4071 * for this host, nor is there much point in changing SSL
4072 * or GSS mode). This is helpful when dealing with
4073 * standby servers that might not be in hot-standby state.
4074 */
4075 if (strcmp(conn->last_sqlstate,
4077 {
4078 conn->try_next_host = true;
4079 goto keep_going;
4080 }
4081
4082 /* Check to see if we should mention pgpassfile */
4084
4086 }
4087 else if (beresp == PqMsg_NegotiateProtocolVersion)
4088 {
4090 {
4091 libpq_append_conn_error(conn, "received invalid protocol negotiation message");
4092 goto error_return;
4093 }
4094 /* OK, we read the message; mark data consumed */
4096 goto error_return;
4097 }
4098
4099 /* It is an authentication request. */
4100 conn->auth_req_received = true;
4101
4102 /* Get the type of request. */
4103 if (pqGetInt((int *) &areq, 4, conn))
4104 {
4105 /* can't happen because we checked the length already */
4106 libpq_append_conn_error(conn, "received invalid authentication request");
4107 goto error_return;
4108 }
4109 msgLength -= 4;
4110
4111 /*
4112 * Process the rest of the authentication request message, and
4113 * respond to it if necessary.
4114 *
4115 * Note that conn->pghost must be non-NULL if we are going to
4116 * avoid the Kerberos code doing a hostname look-up.
4117 */
4118 res = pg_fe_sendauth(areq, msgLength, conn, &async);
4119
4120 if (async && (res == STATUS_OK))
4121 {
4122 /*
4123 * We'll come back later once we're ready to respond.
4124 * Don't consume the request yet.
4125 */
4127 goto keep_going;
4128 }
4129
4130 /*
4131 * OK, we have processed the message; mark data consumed. We
4132 * don't call pqParseDone here because we already traced this
4133 * message inside pg_fe_sendauth.
4134 */
4136
4137 if (res != STATUS_OK)
4138 {
4139 /*
4140 * OAuth connections may perform two-step discovery, where
4141 * the first connection is a dummy.
4142 */
4144 {
4145 need_new_connection = true;
4146 goto keep_going;
4147 }
4148
4149 goto error_return;
4150 }
4151
4152 /*
4153 * Just make sure that any data sent by pg_fe_sendauth is
4154 * flushed out. Although this theoretically could block, it
4155 * really shouldn't since we don't send large auth responses.
4156 */
4157 if (pqFlush(conn))
4158 goto error_return;
4159
4160 if (areq == AUTH_REQ_OK)
4161 {
4162 /* We are done with authentication exchange */
4164
4165 /*
4166 * Set asyncStatus so that PQgetResult will think that
4167 * what comes back next is the result of a query. See
4168 * below.
4169 */
4171 }
4172
4173 /* Look to see if we have more data yet. */
4174 goto keep_going;
4175 }
4176
4178 {
4180
4182 {
4183 /* programmer error; should not happen */
4185 "internal error: async authentication has no handler");
4186 goto error_return;
4187 }
4188
4189 /* Drive some external authentication work. */
4190 status = conn->async_auth(conn);
4191
4192 if (status == PGRES_POLLING_FAILED)
4193 goto error_return;
4194
4195 if (status == PGRES_POLLING_OK)
4196 {
4197 /* Done. Tear down the async implementation. */
4199 conn->cleanup_async_auth = NULL;
4200
4201 /*
4202 * Cleanup must unset altsock, both as an indication that
4203 * it's been released, and to stop pqSocketCheck from
4204 * looking at the wrong socket after async auth is done.
4205 */
4207 {
4208 Assert(false);
4210 "internal error: async cleanup did not release polling socket");
4211 goto error_return;
4212 }
4213
4214 /*
4215 * Reenter the authentication exchange with the server. We
4216 * didn't consume the message that started external
4217 * authentication, so it'll be reprocessed as if we just
4218 * received it.
4219 */
4221
4222 goto keep_going;
4223 }
4224
4225 /*
4226 * Caller needs to poll some more. conn->async_auth() should
4227 * have assigned an altsock to poll on.
4228 */
4230 {
4231 Assert(false);
4233 "internal error: async authentication did not set a socket for polling");
4234 goto error_return;
4235 }
4236
4237 return status;
4238 }
4239
4240 case CONNECTION_AUTH_OK:
4241 {
4242 /*
4243 * Now we expect to hear from the backend. A ReadyForQuery
4244 * message indicates that startup is successful, but we might
4245 * also get an Error message indicating failure. (Notice
4246 * messages indicating nonfatal warnings are also allowed by
4247 * the protocol, as are ParameterStatus and BackendKeyData
4248 * messages.) Easiest way to handle this is to let
4249 * PQgetResult() read the messages. We just have to fake it
4250 * out about the state of the connection, by setting
4251 * asyncStatus = PGASYNC_BUSY (done above).
4252 */
4253
4254 if (PQisBusy(conn))
4255 return PGRES_POLLING_READING;
4256
4257 res = PQgetResult(conn);
4258
4259 /*
4260 * NULL return indicating we have gone to IDLE state is
4261 * expected
4262 */
4263 if (res)
4264 {
4265 if (res->resultStatus != PGRES_FATAL_ERROR)
4266 libpq_append_conn_error(conn, "unexpected message from server during startup");
4267 else if (conn->send_appname &&
4268 (conn->appname || conn->fbappname))
4269 {
4270 /*
4271 * If we tried to send application_name, check to see
4272 * if the error is about that --- pre-9.0 servers will
4273 * reject it at this stage of the process. If so,
4274 * close the connection and retry without sending
4275 * application_name. We could possibly get a false
4276 * SQLSTATE match here and retry uselessly, but there
4277 * seems no great harm in that; we'll just get the
4278 * same error again if it's unrelated.
4279 */
4280 const char *sqlstate;
4281
4282 sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
4283 if (sqlstate &&
4284 strcmp(sqlstate, ERRCODE_APPNAME_UNKNOWN) == 0)
4285 {
4286 PQclear(res);
4287 conn->send_appname = false;
4288 need_new_connection = true;
4289 goto keep_going;
4290 }
4291 }
4292
4293 /*
4294 * if the resultStatus is FATAL, then conn->errorMessage
4295 * already has a copy of the error; needn't copy it back.
4296 * But add a newline if it's not there already, since
4297 * postmaster error messages may not have one.
4298 */
4299 if (conn->errorMessage.len <= 0 ||
4300 conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
4302 PQclear(res);
4303 goto error_return;
4304 }
4305
4306 /* Almost there now ... */
4308 goto keep_going;
4309 }
4310
4312 {
4313 /*
4314 * If a read-write, read-only, primary, or standby connection
4315 * is required, see if we have one.
4316 */
4319 {
4320 bool read_only_server;
4321
4322 /*
4323 * If the server didn't report
4324 * "default_transaction_read_only" or "in_hot_standby" at
4325 * startup, we must determine its state by sending the
4326 * query "SHOW transaction_read_only". This GUC exists in
4327 * all server versions that support 3.0 protocol.
4328 */
4331 {
4332 /*
4333 * We use PQsendQueryContinue so that
4334 * conn->errorMessage does not get cleared. We need
4335 * to preserve any error messages related to previous
4336 * hosts we have tried and failed to connect to.
4337 */
4340 "SHOW transaction_read_only"))
4341 goto error_return;
4342 /* We'll return to this state when we have the answer */
4344 return PGRES_POLLING_READING;
4345 }
4346
4347 /* OK, we can make the test */
4348 read_only_server =
4351
4353 read_only_server : !read_only_server)
4354 {
4355 /* Wrong server state, reject and try the next host */
4357 libpq_append_conn_error(conn, "session is read-only");
4358 else
4359 libpq_append_conn_error(conn, "session is not read-only");
4360
4361 /* Close connection politely. */
4364
4365 /*
4366 * Try next host if any, but we don't want to consider
4367 * additional addresses for this host.
4368 */
4369 conn->try_next_host = true;
4370 goto keep_going;
4371 }
4372 }
4376 {
4377 /*
4378 * If the server didn't report "in_hot_standby" at
4379 * startup, we must determine its state by sending the
4380 * query "SELECT pg_catalog.pg_is_in_recovery()". Servers
4381 * before 9.0 don't have that function, but by the same
4382 * token they don't have any standby mode, so we may just
4383 * assume the result.
4384 */
4385 if (conn->sversion < 90000)
4387
4389 {
4390 /*
4391 * We use PQsendQueryContinue so that
4392 * conn->errorMessage does not get cleared. We need
4393 * to preserve any error messages related to previous
4394 * hosts we have tried and failed to connect to.
4395 */
4398 "SELECT pg_catalog.pg_is_in_recovery()"))
4399 goto error_return;
4400 /* We'll return to this state when we have the answer */
4402 return PGRES_POLLING_READING;
4403 }
4404
4405 /* OK, we can make the test */
4409 {
4410 /* Wrong server state, reject and try the next host */
4412 libpq_append_conn_error(conn, "server is in hot standby mode");
4413 else
4414 libpq_append_conn_error(conn, "server is not in hot standby mode");
4415
4416 /* Close connection politely. */
4419
4420 /*
4421 * Try next host if any, but we don't want to consider
4422 * additional addresses for this host.
4423 */
4424 conn->try_next_host = true;
4425 goto keep_going;
4426 }
4427 }
4428
4429 /* Don't hold onto any OAuth tokens longer than necessary. */
4431
4432 /*
4433 * For non cancel requests we can release the address list
4434 * now. For cancel requests we never actually resolve
4435 * addresses and instead the addrinfo exists for the lifetime
4436 * of the connection.
4437 */
4438 if (!conn->cancelRequest)
4440
4441 /*
4442 * Contents of conn->errorMessage are no longer interesting
4443 * (and it seems some clients expect it to be empty after a
4444 * successful connection).
4445 */
4447
4448 /* We are open for business! */
4450 return PGRES_POLLING_OK;
4451 }
4452
4453 case CONNECTION_CONSUME:
4454 {
4455 /*
4456 * This state just makes sure the connection is idle after
4457 * we've obtained the result of a SHOW or SELECT query. Once
4458 * we're clear, return to CONNECTION_CHECK_TARGET state to
4459 * decide what to do next. We must transiently set status =
4460 * CONNECTION_OK in order to use the result-consuming
4461 * subroutines.
4462 */
4464 if (!PQconsumeInput(conn))
4465 goto error_return;
4466
4467 if (PQisBusy(conn))
4468 {
4470 return PGRES_POLLING_READING;
4471 }
4472
4473 /* Call PQgetResult() again until we get a NULL result */
4474 res = PQgetResult(conn);
4475 if (res != NULL)
4476 {
4477 PQclear(res);
4479 return PGRES_POLLING_READING;
4480 }
4481
4483 goto keep_going;
4484 }
4485
4487 {
4488 /*
4489 * Waiting for result of "SHOW transaction_read_only". We
4490 * must transiently set status = CONNECTION_OK in order to use
4491 * the result-consuming subroutines.
4492 */
4494 if (!PQconsumeInput(conn))
4495 goto error_return;
4496
4497 if (PQisBusy(conn))
4498 {
4500 return PGRES_POLLING_READING;
4501 }
4502
4503 res = PQgetResult(conn);
4504 if (res && PQresultStatus(res) == PGRES_TUPLES_OK &&
4505 PQntuples(res) == 1)
4506 {
4507 char *val = PQgetvalue(res, 0, 0);
4508
4509 /*
4510 * "transaction_read_only = on" proves that at least one
4511 * of default_transaction_read_only and in_hot_standby is
4512 * on, but we don't actually know which. We don't care
4513 * though for the purpose of identifying a read-only
4514 * session, so satisfy the CONNECTION_CHECK_TARGET code by
4515 * claiming they are both on. On the other hand, if it's
4516 * a read-write session, they are certainly both off.
4517 */
4518 if (strncmp(val, "on", 2) == 0)
4519 {
4522 }
4523 else
4524 {
4527 }
4528 PQclear(res);
4529
4530 /* Finish reading messages before continuing */
4532 goto keep_going;
4533 }
4534
4535 /* Something went wrong with "SHOW transaction_read_only". */
4536 PQclear(res);
4537
4538 /* Append error report to conn->errorMessage. */
4539 libpq_append_conn_error(conn, "\"%s\" failed",
4540 "SHOW transaction_read_only");
4541
4542 /* Close connection politely. */
4545
4546 /* Try next host. */
4547 conn->try_next_host = true;
4548 goto keep_going;
4549 }
4550
4552 {
4553 /*
4554 * Waiting for result of "SELECT pg_is_in_recovery()". We
4555 * must transiently set status = CONNECTION_OK in order to use
4556 * the result-consuming subroutines.
4557 */
4559 if (!PQconsumeInput(conn))
4560 goto error_return;
4561
4562 if (PQisBusy(conn))
4563 {
4565 return PGRES_POLLING_READING;
4566 }
4567
4568 res = PQgetResult(conn);
4569 if (res && PQresultStatus(res) == PGRES_TUPLES_OK &&
4570 PQntuples(res) == 1)
4571 {
4572 char *val = PQgetvalue(res, 0, 0);
4573
4574 if (strncmp(val, "t", 1) == 0)
4576 else
4578 PQclear(res);
4579
4580 /* Finish reading messages before continuing */
4582 goto keep_going;
4583 }
4584
4585 /* Something went wrong with "SELECT pg_is_in_recovery()". */
4586 PQclear(res);
4587
4588 /* Append error report to conn->errorMessage. */
4589 libpq_append_conn_error(conn, "\"%s\" failed",
4590 "SELECT pg_is_in_recovery()");
4591
4592 /* Close connection politely. */
4595
4596 /* Try next host. */
4597 conn->try_next_host = true;
4598 goto keep_going;
4599 }
4600
4601 default:
4603 "invalid connection state %d, probably indicative of memory corruption",
4604 conn->status);
4605 goto error_return;
4606 }
4607
4608 /* Unreachable */
4609
4610error_return:
4611
4612 /*
4613 * We used to close the socket at this point, but that makes it awkward
4614 * for those above us if they wish to remove this socket from their own
4615 * records (an fd_set for example). We'll just have this socket closed
4616 * when PQfinish is called (which is compulsory even after an error, since
4617 * the connection structure must be freed).
4618 */
4620 return PGRES_POLLING_FAILED;
4621}
#define STATUS_OK
Definition: c.h:1140
#define MemSet(start, val, len)
Definition: c.h:991
void err(int eval, const char *fmt,...)
Definition: err.c:43
const pg_fe_sasl_mech pg_oauth_mech
Definition: fe-auth-oauth.c:35
void pqClearOAuthToken(PGconn *conn)
int pg_fe_sendauth(AuthRequest areq, int payloadlen, PGconn *conn, bool *async)
Definition: fe-auth.c:1066
char * pg_fe_getusername(uid_t user_id, PQExpBuffer errorMessage)
Definition: fe-auth.c:1286
#define MAX_ERRLEN
void pqDropConnection(PGconn *conn, bool flushInput)
Definition: fe-connect.c:505
static const PQEnvironmentOption EnvironmentOptions[]
Definition: fe-connect.c:399
#define CONNECTION_FAILED()
static void sendTerminateConn(PGconn *conn)
Definition: fe-connect.c:5143
static int setKeepalivesCount(PGconn *conn)
Definition: fe-connect.c:2502
static int useKeepalives(PGconn *conn)
Definition: fe-connect.c:2415
static int store_conn_addrinfo(PGconn *conn, struct addrinfo *addrlist)
Definition: fe-connect.c:5090
static void connectFailureMessage(PGconn *conn, int errorno)
Definition: fe-connect.c:2395
static void release_conn_addrinfo(PGconn *conn)
Definition: fe-connect.c:5129
#define ERRCODE_APPNAME_UNKNOWN
Definition: fe-connect.c:89
static int setKeepalivesInterval(PGconn *conn)
Definition: fe-connect.c:2467
static int setKeepalivesIdle(PGconn *conn)
Definition: fe-connect.c:2433
bool pqParseIntParam(const char *value, int *result, PGconn *conn, const char *context)
Definition: fe-connect.c:8111
static void pgpassfileWarning(PGconn *conn)
Definition: fe-connect.c:7968
static void emitHostIdentityInfo(PGconn *conn, const char *host_addr)
Definition: fe-connect.c:2339
static int setTCPUserTimeout(PGconn *conn)
Definition: fe-connect.c:2599
static void pqDropServerData(PGconn *conn)
Definition: fe-connect.c:631
static int connectNoDelay(PGconn *conn)
Definition: fe-connect.c:2280
static void getHostaddr(PGconn *conn, char *host_addr, int host_addr_len)
Definition: fe-connect.c:2306
#define ERRCODE_CANNOT_CONNECT_NOW
Definition: fe-connect.c:94
#define ENCRYPTION_NEGOTIATION_FAILED(msg)
static bool init_allowed_encryption_methods(PGconn *conn)
Definition: fe-connect.c:4627
int pqPacketSend(PGconn *conn, char pack_type, const void *buf, size_t buf_len)
Definition: fe-connect.c:5332
int PQsendQueryContinue(PGconn *conn, const char *query)
Definition: fe-exec.c:1422
char * PQgetvalue(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3876
PGresult * PQgetResult(PGconn *conn)
Definition: fe-exec.c:2062
int PQntuples(const PGresult *res)
Definition: fe-exec.c:3481
int PQconsumeInput(PGconn *conn)
Definition: fe-exec.c:1984
void pqClearAsyncResult(PGconn *conn)
Definition: fe-exec.c:779
char * PQresultErrorField(const PGresult *res, int fieldcode)
Definition: fe-exec.c:3466
int PQisBusy(PGconn *conn)
Definition: fe-exec.c:2031
bool pg_GSS_have_cred_cache(gss_cred_id_t *cred_out)
int pqFlush(PGconn *conn)
Definition: fe-misc.c:968
void pqParseDone(PGconn *conn, int newInStart)
Definition: fe-misc.c:443
int pqGetc(char *result, PGconn *conn)
Definition: fe-misc.c:77
int pqGetInt(int *result, size_t bytes, PGconn *conn)
Definition: fe-misc.c:216
int pqCheckInBufferSpace(size_t bytes_needed, PGconn *conn)
Definition: fe-misc.c:351
int pqGets_append(PQExpBuffer buf, PGconn *conn)
Definition: fe-misc.c:142
char * pqBuildStartupPacket3(PGconn *conn, int *packetlen, const PQEnvironmentOption *options)
int pqGetNegotiateProtocolVersion3(PGconn *conn)
int pqGetErrorNotice3(PGconn *conn, bool isError)
Definition: fe-protocol3.c:878
PostgresPollingStatusType pqsecure_open_gss(PGconn *conn)
PostgresPollingStatusType pqsecure_open_client(PGconn *conn)
Definition: fe-secure.c:138
void pqTraceOutputCharResponse(PGconn *conn, const char *responseType, char response)
Definition: fe-trace.c:915
void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai)
Definition: ip.c:82
int pg_getaddrinfo_all(const char *hostname, const char *servname, const struct addrinfo *hintp, struct addrinfo **result)
Definition: ip.c:53
int j
Definition: isn.c:75
@ PGASYNC_IDLE
Definition: libpq-int.h:223
@ PGASYNC_BUSY
Definition: libpq-int.h:224
#define libpq_gettext(x)
Definition: libpq-int.h:934
@ LOAD_BALANCE_RANDOM
Definition: libpq-int.h:258
#define SOCK_STRERROR
Definition: libpq-int.h:956
#define ENC_GSSAPI
Definition: libpq-int.h:239
#define ENC_SSL
Definition: libpq-int.h:240
@ CHT_UNIX_SOCKET
Definition: libpq-int.h:319
@ CHT_HOST_ADDRESS
Definition: libpq-int.h:318
@ CHT_HOST_NAME
Definition: libpq-int.h:317
@ PG_BOOL_YES
Definition: libpq-int.h:265
@ PG_BOOL_NO
Definition: libpq-int.h:266
@ PG_BOOL_UNKNOWN
Definition: libpq-int.h:264
@ SERVER_TYPE_STANDBY
Definition: libpq-int.h:249
@ SERVER_TYPE_PRIMARY
Definition: libpq-int.h:248
@ SERVER_TYPE_READ_WRITE
Definition: libpq-int.h:246
@ SERVER_TYPE_PREFER_STANDBY_PASS2
Definition: libpq-int.h:251
@ SERVER_TYPE_PREFER_STANDBY
Definition: libpq-int.h:250
@ SERVER_TYPE_READ_ONLY
Definition: libpq-int.h:247
#define MAXPGPATH
uint64 pg_prng_uint64_range(pg_prng_state *state, uint64 rmin, uint64 rmax)
Definition: pg_prng.c:144
static char portstr[16]
Definition: pg_regress.c:116
bool pg_set_noblock(pgsocket sock)
Definition: noblock.c:25
#define snprintf
Definition: port.h:239
unsigned int socklen_t
Definition: port.h:40
int getpeereid(int sock, uid_t *uid, gid_t *gid)
Definition: getpeereid.c:33
#define PG_DIAG_SQLSTATE
Definition: postgres_ext.h:57
#define UNIXSOCK_PATH(path, port, sockdir)
Definition: pqcomm.h:44
#define UNIXSOCK_PATH_BUFLEN
Definition: pqcomm.h:60
#define NEGOTIATE_GSS_CODE
Definition: pqcomm.h:168
#define NEGOTIATE_SSL_CODE
Definition: pqcomm.h:167
uint32 ProtocolVersion
Definition: pqcomm.h:100
uint32 AuthRequest
Definition: pqcomm.h:122
#define PG_PROTOCOL(m, n)
Definition: pqcomm.h:90
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition: pqexpbuffer.c:378
#define AUTH_REQ_OK
Definition: protocol.h:74
#define PqMsg_AuthenticationRequest
Definition: protocol.h:50
#define PqMsg_NegotiateProtocolVersion
Definition: protocol.h:59
#define PqMsg_ErrorResponse
Definition: protocol.h:44
const char * gai_strerror(int ecode)
int family
Definition: pqcomm.h:38
SockAddr addr
Definition: pqcomm.h:39
MsgType cancelRequestCode
Definition: pqcomm.h:138
uint32 backendPID
Definition: pqcomm.h:139
uint32 cancelAuthCode
Definition: pqcomm.h:140
pg_conn_host_type type
Definition: libpq-int.h:365
SockAddr laddr
Definition: libpq-int.h:503
bool try_next_host
Definition: libpq-int.h:538
AddrInfo * addr
Definition: libpq-int.h:541
uint8 failed_enc_methods
Definition: libpq-int.h:604
char * sslnegotiation
Definition: libpq-int.h:412
bool sigpipe_flag
Definition: libpq-int.h:511
int nconnhost
Definition: libpq-int.h:482
ProtocolVersion pversion
Definition: libpq-int.h:505
bool send_appname
Definition: libpq-int.h:543
PGTransactionStatusType xactStatus
Definition: libpq-int.h:466
const pg_fe_sasl_mech * sasl
Definition: libpq-int.h:599
bool cancelRequest
Definition: libpq-int.h:436
int inCursor
Definition: libpq-int.h:567
PGTernaryBool in_hot_standby
Definition: libpq-int.h:556
void(* cleanup_async_auth)(PGconn *conn)
Definition: libpq-int.h:529
int inEnd
Definition: libpq-int.h:568
char * fbappname
Definition: libpq-int.h:396
uint8 current_enc_method
Definition: libpq-int.h:605
int naddr
Definition: libpq-int.h:539
int inStart
Definition: libpq-int.h:566
char * connip
Definition: libpq-int.h:485
int sversion
Definition: libpq-int.h:506
bool auth_req_received
Definition: libpq-int.h:507
bool oauth_want_retry
Definition: libpq-int.h:449
PGTernaryBool default_transaction_read_only
Definition: libpq-int.h:555
bool sigpipe_so
Definition: libpq-int.h:510
int whichaddr
Definition: libpq-int.h:540
char * appname
Definition: libpq-int.h:395
pg_prng_state prng_state
Definition: libpq-int.h:560
char * gssencmode
Definition: libpq-int.h:423
pgsocket altsock
Definition: libpq-int.h:530
PostgresPollingStatusType(* async_auth)(PGconn *conn)
Definition: libpq-int.h:528
char last_sqlstate[6]
Definition: libpq-int.h:467
PGAsyncStatusType asyncStatus
Definition: libpq-int.h:465
PGLoadBalanceType load_balance_type
Definition: libpq-int.h:535
PGpipelineStatus pipelineStatus
Definition: libpq-int.h:471
uint8 allowed_enc_methods
Definition: libpq-int.h:603
PGTargetServerType target_server_type
Definition: libpq-int.h:534
FILE * Pfdebug
Definition: libpq-int.h:452
bool try_next_addr
Definition: libpq-int.h:537
char * requirepeer
Definition: libpq-int.h:422
bool ssl_in_use
Definition: libpq-int.h:608
#define EWOULDBLOCK
Definition: win32_port.h:370
#define EINPROGRESS
Definition: win32_port.h:376
int gid_t
Definition: win32_port.h:235
int uid_t
Definition: win32_port.h:234

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

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

◆ PQconnectStart()

PGconn * PQconnectStart ( const char *  conninfo)

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

921{
922 PGconn *conn;
923
924 /*
925 * Allocate memory for the conn structure. Note that we also expect this
926 * to initialize conn->errorMessage to empty. All subsequent steps during
927 * connection initialization will only append to that buffer.
928 */
930 if (conn == NULL)
931 return NULL;
932
933 /*
934 * Parse the conninfo string
935 */
936 if (!connectOptions1(conn, conninfo))
937 return conn;
938
939 /*
940 * Compute derived options
941 */
943 return conn;
944
945 /*
946 * Connect to the database
947 */
949 {
950 /* Just in case we failed to set it in pqConnectDBStart */
952 }
953
954 return conn;
955}
static bool connectOptions1(PGconn *conn, const char *conninfo)
Definition: fe-connect.c:1045

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

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

◆ PQconnectStartParams()

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

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

842{
843 PGconn *conn;
844 PQconninfoOption *connOptions;
845
846 /*
847 * Allocate memory for the conn structure. Note that we also expect this
848 * to initialize conn->errorMessage to empty. All subsequent steps during
849 * connection initialization will only append to that buffer.
850 */
852 if (conn == NULL)
853 return NULL;
854
855 /*
856 * Parse the conninfo arrays
857 */
858 connOptions = conninfo_array_parse(keywords, values,
860 true, expand_dbname);
861 if (connOptions == NULL)
862 {
864 /* errorMessage is already set */
865 return conn;
866 }
867
868 /*
869 * Move option values into conn structure
870 */
871 if (!fillPGconn(conn, connOptions))
872 {
873 PQconninfoFree(connOptions);
874 return conn;
875 }
876
877 /*
878 * Free the option info - all is in conn now
879 */
880 PQconninfoFree(connOptions);
881
882 /*
883 * Compute derived options
884 */
886 return conn;
887
888 /*
889 * Connect to the database
890 */
892 {
893 /* Just in case we failed to set it in pqConnectDBStart */
895 }
896
897 return conn;
898}
static PQconninfoOption * conninfo_array_parse(const char *const *keywords, const char *const *values, PQExpBuffer errorMessage, bool use_defaults, int expand_dbname)
Definition: fe-connect.c:6375
static bool fillPGconn(PGconn *conn, PQconninfoOption *connOptions)
Definition: fe-connect.c:966

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

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

◆ PQconninfo()

PQconninfoOption * PQconninfo ( PGconn conn)

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

7325{
7326 PQExpBufferData errorBuf;
7327 PQconninfoOption *connOptions;
7328
7329 if (conn == NULL)
7330 return NULL;
7331
7332 /*
7333 * We don't actually report any errors here, but callees want a buffer,
7334 * and we prefer not to trash the conn's errorMessage.
7335 */
7336 initPQExpBuffer(&errorBuf);
7337 if (PQExpBufferDataBroken(errorBuf))
7338 return NULL; /* out of memory already :-( */
7339
7340 connOptions = conninfo_init(&errorBuf);
7341
7342 if (connOptions != NULL)
7343 {
7345
7346 for (option = PQconninfoOptions; option->keyword; option++)
7347 {
7348 char **connmember;
7349
7350 if (option->connofs < 0)
7351 continue;
7352
7353 connmember = (char **) ((char *) conn + option->connofs);
7354
7355 if (*connmember)
7356 conninfo_storeval(connOptions, option->keyword, *connmember,
7357 &errorBuf, true, false);
7358 }
7359 }
7360
7361 termPQExpBuffer(&errorBuf);
7362
7363 return connOptions;
7364}
static PQconninfoOption * conninfo_storeval(PQconninfoOption *connOptions, const char *keyword, const char *value, PQExpBuffer errorMessage, bool ignoreMissing, bool uri_decode)
Definition: fe-connect.c:7242
static const internalPQconninfoOption PQconninfoOptions[]
Definition: fe-connect.c:193

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

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

◆ PQconninfoFree()

◆ PQconninfoParse()

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

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

6085{
6086 PQExpBufferData errorBuf;
6087 PQconninfoOption *connOptions;
6088
6089 if (errmsg)
6090 *errmsg = NULL; /* default */
6091 initPQExpBuffer(&errorBuf);
6092 if (PQExpBufferDataBroken(errorBuf))
6093 return NULL; /* out of memory already :-( */
6094 connOptions = parse_connection_string(conninfo, &errorBuf, false);
6095 if (connOptions == NULL && errmsg)
6096 *errmsg = errorBuf.data;
6097 else
6098 termPQExpBuffer(&errorBuf);
6099 return connOptions;
6100}
int errmsg(const char *fmt,...)
Definition: elog.c:1070
static PQconninfoOption * parse_connection_string(const char *connstr, PQExpBuffer errorMessage, bool use_defaults)
Definition: fe-connect.c:6145

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

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

◆ PQconsumeInput()

int PQconsumeInput ( PGconn conn)

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

1985{
1986 if (!conn)
1987 return 0;
1988
1989 /*
1990 * for non-blocking connections try to flush the send-queue, otherwise we
1991 * may never get a response for something that may not have already been
1992 * sent because it's in our write buffer!
1993 */
1994 if (pqIsnonblocking(conn))
1995 {
1996 if (pqFlush(conn) < 0)
1997 return 0;
1998 }
1999
2000 /*
2001 * Load more data, if available. We do this no matter what state we are
2002 * in, since we are probably getting called because the application wants
2003 * to get rid of a read-select condition. Note that we will NOT block
2004 * waiting for more input.
2005 */
2006 if (pqReadData(conn) < 0)
2007 return 0;
2008
2009 /* Parsing of the data waits till later. */
2010 return 1;
2011}
#define pqIsnonblocking(conn)
Definition: libpq-int.h:923

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

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

◆ PQcopyResult()

PGresult * PQcopyResult ( const PGresult src,
int  flags 
)

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

319{
320 PGresult *dest;
321 int i;
322
323 if (!src)
324 return NULL;
325
327 if (!dest)
328 return NULL;
329
330 /* Always copy these over. Is cmdStatus really useful here? */
331 dest->client_encoding = src->client_encoding;
332 strcpy(dest->cmdStatus, src->cmdStatus);
333
334 /* Wants attrs? */
335 if (flags & (PG_COPYRES_ATTRS | PG_COPYRES_TUPLES))
336 {
338 {
339 PQclear(dest);
340 return NULL;
341 }
342 }
343
344 /* Wants to copy tuples? */
345 if (flags & PG_COPYRES_TUPLES)
346 {
347 int tup,
348 field;
349
350 for (tup = 0; tup < src->ntups; tup++)
351 {
352 for (field = 0; field < src->numAttributes; field++)
353 {
354 if (!PQsetvalue(dest, tup, field,
355 src->tuples[tup][field].value,
356 src->tuples[tup][field].len))
357 {
358 PQclear(dest);
359 return NULL;
360 }
361 }
362 }
363 }
364
365 /* Wants to copy notice hooks? */
366 if (flags & PG_COPYRES_NOTICEHOOKS)
367 dest->noticeHooks = src->noticeHooks;
368
369 /* Wants to copy PGEvents? */
370 if ((flags & PG_COPYRES_EVENTS) && src->nEvents > 0)
371 {
372 dest->events = dupEvents(src->events, src->nEvents,
373 &dest->memorySize);
374 if (!dest->events)
375 {
376 PQclear(dest);
377 return NULL;
378 }
379 dest->nEvents = src->nEvents;
380 }
381
382 /* Okay, trigger PGEVT_RESULTCOPY event */
383 for (i = 0; i < dest->nEvents; i++)
384 {
385 /* We don't fire events that had some previous failure */
386 if (src->events[i].resultInitialized)
387 {
389
390 evt.src = src;
391 evt.dest = dest;
392 if (dest->events[i].proc(PGEVT_RESULTCOPY, &evt,
393 dest->events[i].passThrough))
394 dest->events[i].resultInitialized = true;
395 }
396 }
397
398 return dest;
399}
int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs)
Definition: fe-exec.c:249
PGresult * PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status)
Definition: fe-exec.c:159
static PGEvent * dupEvents(PGEvent *events, int count, size_t *memSize)
Definition: fe-exec.c:408
int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len)
Definition: fe-exec.c:452
@ PGEVT_RESULTCOPY
Definition: libpq-events.h:33
#define PG_COPYRES_TUPLES
Definition: libpq-fe.h:69
#define PG_COPYRES_ATTRS
Definition: libpq-fe.h:68
#define PG_COPYRES_EVENTS
Definition: libpq-fe.h:70
#define PG_COPYRES_NOTICEHOOKS
Definition: libpq-fe.h:71
const PGresult * src
Definition: libpq-events.h:60
PGresult * dest
Definition: libpq-events.h:61
int ntups
Definition: libpq-int.h:174
int numAttributes
Definition: libpq-int.h:175
int client_encoding
Definition: libpq-int.h:194
char * value
Definition: libpq-int.h:143

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

Referenced by pqRowProcessor().

◆ PQdb()

◆ PQdefaultAuthDataHook()

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

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

1602{
1603 return 0; /* handle nothing */
1604}

Referenced by PQsetAuthDataHook().

◆ PQdefaultSSLKeyPassHook_OpenSSL()

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

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

1843{
1844 if (conn && conn->sslpassword)
1845 {
1846 if (strlen(conn->sslpassword) + 1 > size)
1847 fprintf(stderr, libpq_gettext("WARNING: sslpassword truncated\n"));
1848 strncpy(buf, conn->sslpassword, size);
1849 buf[size - 1] = '\0';
1850 return strlen(buf);
1851 }
1852 else
1853 {
1854 buf[0] = '\0';
1855 return 0;
1856 }
1857}
#define fprintf(file, fmt, msg)
Definition: cubescan.l:21
char * sslpassword
Definition: libpq-int.h:416

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

Referenced by PQssl_passwd_cb().

◆ PQdescribePortal()

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

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

2475{
2476 if (!PQexecStart(conn))
2477 return NULL;
2478 if (!PQsendTypedCommand(conn, PqMsg_Describe, 'P', portal))
2479 return NULL;
2480 return PQexecFinish(conn);
2481}
#define PqMsg_Describe
Definition: protocol.h:21

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

Referenced by test_prepared().

◆ PQdescribePrepared()

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

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

2456{
2457 if (!PQexecStart(conn))
2458 return NULL;
2460 return NULL;
2461 return PQexecFinish(conn);
2462}

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

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

◆ PQdisplayTuples()

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

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

581{
582#define DEFAULT_FIELD_SEP " "
583
584 int i,
585 j;
586 int nFields;
587 int nTuples;
588 int *fLength = NULL;
589
590 if (fieldSep == NULL)
591 fieldSep = DEFAULT_FIELD_SEP;
592
593 /* Get some useful info about the results */
594 nFields = PQnfields(res);
595 nTuples = PQntuples(res);
596
597 if (fp == NULL)
598 fp = stdout;
599
600 /* Figure the field lengths to align to */
601 /* will be somewhat time consuming for very large results */
602 if (fillAlign)
603 {
604 fLength = (int *) malloc(nFields * sizeof(int));
605 if (!fLength)
606 {
607 fprintf(stderr, libpq_gettext("out of memory\n"));
608 return;
609 }
610
611 for (j = 0; j < nFields; j++)
612 {
613 fLength[j] = strlen(PQfname(res, j));
614 for (i = 0; i < nTuples; i++)
615 {
616 int flen = PQgetlength(res, i, j);
617
618 if (flen > fLength[j])
619 fLength[j] = flen;
620 }
621 }
622 }
623
624 if (printHeader)
625 {
626 /* first, print out the attribute names */
627 for (i = 0; i < nFields; i++)
628 {
629 fputs(PQfname(res, i), fp);
630 if (fillAlign)
631 fill(strlen(PQfname(res, i)), fLength[i], ' ', fp);
632 fputs(fieldSep, fp);
633 }
634 fprintf(fp, "\n");
635
636 /* Underline the attribute names */
637 for (i = 0; i < nFields; i++)
638 {
639 if (fillAlign)
640 fill(0, fLength[i], '-', fp);
641 fputs(fieldSep, fp);
642 }
643 fprintf(fp, "\n");
644 }
645
646 /* next, print out the instances */
647 for (i = 0; i < nTuples; i++)
648 {
649 for (j = 0; j < nFields; j++)
650 {
651 fprintf(fp, "%s", PQgetvalue(res, i, j));
652 if (fillAlign)
653 fill(strlen(PQgetvalue(res, i, j)), fLength[j], ' ', fp);
654 fputs(fieldSep, fp);
655 }
656 fprintf(fp, "\n");
657 }
658
659 if (!quiet)
660 fprintf(fp, "\nQuery returned %d row%s.\n", PQntuples(res),
661 (PQntuples(res) == 1) ? "" : "s");
662
663 fflush(fp);
664
665 free(fLength);
666}
int PQgetlength(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3887
char * PQfname(const PGresult *res, int field_num)
Definition: fe-exec.c:3567
int PQnfields(const PGresult *res)
Definition: fe-exec.c:3489
static void fill(int length, int max, char filler, FILE *fp)
Definition: fe-print.c:755
#define DEFAULT_FIELD_SEP
#define malloc(a)
Definition: header.h:50

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

◆ PQdsplen()

int PQdsplen ( const char *  s,
int  encoding 
)

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

1254{
1255 return pg_encoding_dsplen(encoding, s);
1256}
int pg_encoding_dsplen(int encoding, const char *mbstr)
Definition: wchar.c:2137

References encoding, and pg_encoding_dsplen().

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

◆ PQencryptPassword()

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

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

1364{
1365 char *crypt_pwd;
1366 const char *errstr = NULL;
1367
1368 crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
1369 if (!crypt_pwd)
1370 return NULL;
1371
1372 if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd, &errstr))
1373 {
1374 free(crypt_pwd);
1375 return NULL;
1376 }
1377
1378 return crypt_pwd;
1379}
#define MD5_PASSWD_LEN
Definition: md5.h:26
bool pg_md5_encrypt(const char *passwd, const char *salt, size_t salt_len, char *buf, const char **errstr)
Definition: md5_common.c:145

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

◆ PQencryptPasswordConn()

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

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

1408{
1409#define MAX_ALGORITHM_NAME_LEN 50
1410 char algobuf[MAX_ALGORITHM_NAME_LEN + 1];
1411 char *crypt_pwd = NULL;
1412
1413 if (!conn)
1414 return NULL;
1415
1417
1418 /* If no algorithm was given, ask the server. */
1419 if (algorithm == NULL)
1420 {
1421 PGresult *res;
1422 char *val;
1423
1424 res = PQexec(conn, "show password_encryption");
1425 if (res == NULL)
1426 {
1427 /* PQexec() should've set conn->errorMessage already */
1428 return NULL;
1429 }
1430 if (PQresultStatus(res) != PGRES_TUPLES_OK)
1431 {
1432 /* PQexec() should've set conn->errorMessage already */
1433 PQclear(res);
1434 return NULL;
1435 }
1436 if (PQntuples(res) != 1 || PQnfields(res) != 1)
1437 {
1438 PQclear(res);
1439 libpq_append_conn_error(conn, "unexpected shape of result set returned for SHOW");
1440 return NULL;
1441 }
1442 val = PQgetvalue(res, 0, 0);
1443
1444 if (strlen(val) > MAX_ALGORITHM_NAME_LEN)
1445 {
1446 PQclear(res);
1447 libpq_append_conn_error(conn, "\"password_encryption\" value too long");
1448 return NULL;
1449 }
1450 strcpy(algobuf, val);
1451 PQclear(res);
1452
1453 algorithm = algobuf;
1454 }
1455
1456 /*
1457 * Also accept "on" and "off" as aliases for "md5", because
1458 * password_encryption was a boolean before PostgreSQL 10. We refuse to
1459 * send the password in plaintext even if it was "off".
1460 */
1461 if (strcmp(algorithm, "on") == 0 ||
1462 strcmp(algorithm, "off") == 0)
1463 algorithm = "md5";
1464
1465 /*
1466 * Ok, now we know what algorithm to use
1467 */
1468 if (strcmp(algorithm, "scram-sha-256") == 0)
1469 {
1470 const char *errstr = NULL;
1471
1472 crypt_pwd = pg_fe_scram_build_secret(passwd,
1474 &errstr);
1475 if (!crypt_pwd)
1476 libpq_append_conn_error(conn, "could not encrypt password: %s", errstr);
1477 }
1478 else if (strcmp(algorithm, "md5") == 0)
1479 {
1480 crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
1481 if (crypt_pwd)
1482 {
1483 const char *errstr = NULL;
1484
1485 if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd, &errstr))
1486 {
1487 libpq_append_conn_error(conn, "could not encrypt password: %s", errstr);
1488 free(crypt_pwd);
1489 crypt_pwd = NULL;
1490 }
1491 }
1492 else
1493 libpq_append_conn_error(conn, "out of memory");
1494 }
1495 else
1496 {
1497 libpq_append_conn_error(conn, "unrecognized password encryption algorithm \"%s\"",
1498 algorithm);
1499 return NULL;
1500 }
1501
1502 return crypt_pwd;
1503}
char * pg_fe_scram_build_secret(const char *password, int iterations, const char **errstr)
#define MAX_ALGORITHM_NAME_LEN
int scram_sha_256_iterations
Definition: libpq-int.h:601

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

Referenced by main(), and PQchangePassword().

◆ PQendcopy()

int PQendcopy ( PGconn conn)

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

2950{
2951 if (!conn)
2952 return 0;
2953
2954 return pqEndcopy3(conn);
2955}
int pqEndcopy3(PGconn *conn)

References conn, and pqEndcopy3().

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

◆ PQenterPipelineMode()

int PQenterPipelineMode ( PGconn conn)

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

3043{
3044 if (!conn)
3045 return 0;
3046
3047 /* succeed with no action if already in pipeline mode */
3049 return 1;
3050
3052 {
3053 libpq_append_conn_error(conn, "cannot enter pipeline mode, connection not idle");
3054 return 0;
3055 }
3056
3058
3059 return 1;
3060}

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

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

◆ PQenv2encoding()

int PQenv2encoding ( void  )

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

1263{
1264 char *str;
1265 int encoding = PG_SQL_ASCII;
1266
1267 str = getenv("PGCLIENTENCODING");
1268 if (str && *str != '\0')
1269 {
1271 if (encoding < 0)
1273 }
1274 return encoding;
1275}
const char * str
@ PG_SQL_ASCII
Definition: pg_wchar.h:226
#define pg_char_to_encoding
Definition: pg_wchar.h:629

References encoding, pg_char_to_encoding, PG_SQL_ASCII, and str.

Referenced by main().

◆ PQerrorMessage()

char * PQerrorMessage ( const PGconn conn)

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

7554{
7555 if (!conn)
7556 return libpq_gettext("connection pointer is NULL\n");
7557
7558 /*
7559 * The errorMessage buffer might be marked "broken" due to having
7560 * previously failed to allocate enough memory for the message. In that
7561 * case, tell the application we ran out of memory.
7562 */
7564 return libpq_gettext("out of memory\n");
7565
7566 return conn->errorMessage.data;
7567}
#define PQExpBufferBroken(str)
Definition: pqexpbuffer.h:59

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

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

◆ PQescapeBytea()

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

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

4529{
4530 return PQescapeByteaInternal(NULL, from, from_length, to_length,
4532 false /* can't use hex */ );
4533}
static unsigned char * PQescapeByteaInternal(PGconn *conn, const unsigned char *from, size_t from_length, size_t *to_length, bool std_strings, bool use_hex)
Definition: fe-exec.c:4416
static bool static_std_strings
Definition: fe-exec.c:60

References PQescapeByteaInternal(), and static_std_strings.

◆ PQescapeByteaConn()

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

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

4515{
4516 if (!conn)
4517 return NULL;
4518
4519 if (conn->cmd_queue_head == NULL)
4521
4522 return PQescapeByteaInternal(conn, from, from_length, to_length,
4524 (conn->sversion >= 90000));
4525}
bool std_strings
Definition: libpq-int.h:554
PGcmdQueueEntry * cmd_queue_head
Definition: libpq-int.h:491

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

◆ PQescapeIdentifier()

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

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

4370{
4371 return PQescapeInternal(conn, str, len, true);
4372}
static char * PQescapeInternal(PGconn *conn, const char *str, size_t len, bool as_ident)
Definition: fe-exec.c:4213

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

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

◆ PQescapeLiteral()

◆ PQescapeString()

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

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

4199{
4200 return PQescapeStringInternal(NULL, to, from, length, NULL,
4203}
static size_t PQescapeStringInternal(PGconn *conn, char *to, const char *from, size_t length, int *error, int encoding, bool std_strings)
Definition: fe-exec.c:4071
static int static_client_encoding
Definition: fe-exec.c:59

References PQescapeStringInternal(), static_client_encoding, and static_std_strings.

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

◆ PQescapeStringConn()

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

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

4179{
4180 if (!conn)
4181 {
4182 /* force empty-string result */
4183 *to = '\0';
4184 if (error)
4185 *error = 1;
4186 return 0;
4187 }
4188
4189 if (conn->cmd_queue_head == NULL)
4191
4192 return PQescapeStringInternal(conn, to, from, length, error,
4194 conn->std_strings);
4195}
static void error(void)
Definition: sql-dyntest.c:147

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

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

◆ PQexec()

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

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

2263{
2264 if (!PQexecStart(conn))
2265 return NULL;
2266 if (!PQsendQuery(conn, query))
2267 return NULL;
2268 return PQexecFinish(conn);
2269}
int PQsendQuery(PGconn *conn, const char *query)
Definition: fe-exec.c:1416

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

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

◆ PQexecParams()

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

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

2284{
2285 if (!PQexecStart(conn))
2286 return NULL;
2287 if (!PQsendQueryParams(conn, command,
2288 nParams, paramTypes, paramValues, paramLengths,
2289 paramFormats, resultFormat))
2290 return NULL;
2291 return PQexecFinish(conn);
2292}
int PQsendQueryParams(PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
Definition: fe-exec.c:1492

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

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

◆ PQexecPrepared()

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

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

2330{
2331 if (!PQexecStart(conn))
2332 return NULL;
2333 if (!PQsendQueryPrepared(conn, stmtName,
2334 nParams, paramValues, paramLengths,
2335 paramFormats, resultFormat))
2336 return NULL;
2337 return PQexecFinish(conn);
2338}
int PQsendQueryPrepared(PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
Definition: fe-exec.c:1633

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

Referenced by ecpg_execute(), and try_complete_step().

◆ PQexitPipelineMode()

int PQexitPipelineMode ( PGconn conn)

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

3074{
3075 if (!conn)
3076 return 0;
3077
3081 conn->cmd_queue_head == NULL)
3082 return 1;
3083
3084 switch (conn->asyncStatus)
3085 {
3086 case PGASYNC_READY:
3087 case PGASYNC_READY_MORE:
3088 /* there are some uncollected results */
3089 libpq_append_conn_error(conn, "cannot exit pipeline mode with uncollected results");
3090 return 0;
3091
3092 case PGASYNC_BUSY:
3093 libpq_append_conn_error(conn, "cannot exit pipeline mode while busy");
3094 return 0;
3095
3096 case PGASYNC_IDLE:
3098 /* OK */
3099 break;
3100
3101 case PGASYNC_COPY_IN:
3102 case PGASYNC_COPY_OUT:
3103 case PGASYNC_COPY_BOTH:
3104 libpq_append_conn_error(conn, "cannot exit pipeline mode while in COPY");
3105 }
3106
3107 /* still work to process */
3108 if (conn->cmd_queue_head != NULL)
3109 {
3110 libpq_append_conn_error(conn, "cannot exit pipeline mode with uncollected results");
3111 return 0;
3112 }
3113
3116
3117 /* Flush any pending data in out buffer */
3118 if (pqFlush(conn) < 0)
3119 return 0; /* error message is setup already */
3120 return 1;
3121}
@ PGASYNC_COPY_OUT
Definition: libpq-int.h:231
@ PGASYNC_READY_MORE
Definition: libpq-int.h:227
@ PGASYNC_READY
Definition: libpq-int.h:225
@ PGASYNC_COPY_BOTH
Definition: libpq-int.h:232
@ PGASYNC_COPY_IN
Definition: libpq-int.h:230
@ PGASYNC_PIPELINE_IDLE
Definition: libpq-int.h:233

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

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

◆ PQfformat()

int PQfformat ( const PGresult res,
int  field_num 
)

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

3709{
3710 if (!check_field_number(res, field_num))
3711 return 0;
3712 if (res->attDescs)
3713 return res->attDescs[field_num].format;
3714 else
3715 return 0;
3716}
static int check_field_number(const PGresult *res, int field_num)
Definition: fe-exec.c:3510

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

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

◆ PQfinish()

void PQfinish ( PGconn conn)

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

5225{
5226 if (conn)
5227 {
5230 }
5231}
static void freePGconn(PGconn *conn)
Definition: fe-connect.c:4971

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

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

◆ PQflush()

◆ PQfmod()

int PQfmod ( const PGresult res,
int  field_num 
)

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

3742{
3743 if (!check_field_number(res, field_num))
3744 return 0;
3745 if (res->attDescs)
3746 return res->attDescs[field_num].atttypmod;
3747 else
3748 return 0;
3749}
int atttypmod
Definition: libpq-fe.h:312

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

Referenced by DescribeQuery(), and ECPGget_desc().

◆ PQfn()

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

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

2987{
2988 *result_len = 0;
2989
2990 if (!conn)
2991 return NULL;
2992
2993 /*
2994 * Since this is the beginning of a query cycle, reset the error state.
2995 * However, in pipeline mode with something already queued, the error
2996 * buffer belongs to that command and we shouldn't clear it.
2997 */
2998 if (conn->cmd_queue_head == NULL)
3000
3002 {
3003 libpq_append_conn_error(conn, "%s not allowed in pipeline mode", "PQfn");
3004 return NULL;
3005 }
3006
3009 {
3010 libpq_append_conn_error(conn, "connection in wrong state");
3011 return NULL;
3012 }
3013
3014 return pqFunctionCall3(conn, fnid,
3015 result_buf, result_len,
3016 result_is_int,
3017 args, nargs);
3018}
PGresult * pqFunctionCall3(PGconn *conn, Oid fnid, int *result_buf, int *actual_result_len, int result_is_int, const PQArgBlock *args, int nargs)
#define pgHavePendingResult(conn)
Definition: libpq-int.h:916

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

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

◆ PQfname()

char * PQfname ( const PGresult res,
int  field_num 
)

◆ PQfnumber()

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

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

3590{
3591 char *field_case;
3592 bool in_quotes;
3593 bool all_lower = true;
3594 const char *iptr;
3595 char *optr;
3596 int i;
3597
3598 if (!res)
3599 return -1;
3600
3601 /*
3602 * Note: it is correct to reject a zero-length input string; the proper
3603 * input to match a zero-length field name would be "".
3604 */
3605 if (field_name == NULL ||
3606 field_name[0] == '\0' ||
3607 res->attDescs == NULL)
3608 return -1;
3609
3610 /*
3611 * Check if we can avoid the strdup() and related work because the
3612 * passed-in string wouldn't be changed before we do the check anyway.
3613 */
3614 for (iptr = field_name; *iptr; iptr++)
3615 {
3616 char c = *iptr;
3617
3618 if (c == '"' || c != pg_tolower((unsigned char) c))
3619 {
3620 all_lower = false;
3621 break;
3622 }
3623 }
3624
3625 if (all_lower)
3626 for (i = 0; i < res->numAttributes; i++)
3627 if (strcmp(field_name, res->attDescs[i].name) == 0)
3628 return i;
3629
3630 /* Fall through to the normal check if that didn't work out. */
3631
3632 /*
3633 * Note: this code will not reject partially quoted strings, eg
3634 * foo"BAR"foo will become fooBARfoo when it probably ought to be an error
3635 * condition.
3636 */
3637 field_case = strdup(field_name);
3638 if (field_case == NULL)
3639 return -1; /* grotty */
3640
3641 in_quotes = false;
3642 optr = field_case;
3643 for (iptr = field_case; *iptr; iptr++)
3644 {
3645 char c = *iptr;
3646
3647 if (in_quotes)
3648 {
3649 if (c == '"')
3650 {
3651 if (iptr[1] == '"')
3652 {
3653 /* doubled quotes become a single quote */
3654 *optr++ = '"';
3655 iptr++;
3656 }
3657 else
3658 in_quotes = false;
3659 }
3660 else
3661 *optr++ = c;
3662 }
3663 else if (c == '"')
3664 in_quotes = true;
3665 else
3666 {
3667 c = pg_tolower((unsigned char) c);
3668 *optr++ = c;
3669 }
3670 }
3671 *optr = '\0';
3672
3673 for (i = 0; i < res->numAttributes; i++)
3674 {
3675 if (strcmp(field_case, res->attDescs[i].name) == 0)
3676 {
3677 free(field_case);
3678 return i;
3679 }
3680 }
3681 free(field_case);
3682 return -1;
3683}
unsigned char pg_tolower(unsigned char ch)
Definition: pgstrcasecmp.c:122

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

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

◆ PQfreeCancel()

void PQfreeCancel ( PGcancel cancel)

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

418{
419 free(cancel);
420}

References free.

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

◆ PQfreemem()

◆ PQfsize()

int PQfsize ( const PGresult res,
int  field_num 
)

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

3731{
3732 if (!check_field_number(res, field_num))
3733 return 0;
3734 if (res->attDescs)
3735 return res->attDescs[field_num].typlen;
3736 else
3737 return 0;
3738}

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

Referenced by ecpg_build_compat_sqlda(), and ECPGget_desc().

◆ PQftable()

Oid PQftable ( const PGresult res,
int  field_num 
)

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

3687{
3688 if (!check_field_number(res, field_num))
3689 return InvalidOid;
3690 if (res->attDescs)
3691 return res->attDescs[field_num].tableid;
3692 else
3693 return InvalidOid;
3694}

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

◆ PQftablecol()

int PQftablecol ( const PGresult res,
int  field_num 
)

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

3698{
3699 if (!check_field_number(res, field_num))
3700 return 0;
3701 if (res->attDescs)
3702 return res->attDescs[field_num].columnid;
3703 else
3704 return 0;
3705}
int columnid
Definition: libpq-fe.h:308

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

◆ PQftype()

Oid PQftype ( const PGresult res,
int  field_num 
)

◆ PQfullProtocolVersion()

int PQfullProtocolVersion ( const PGconn conn)

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

7534{
7535 if (!conn)
7536 return 0;
7537 if (conn->status == CONNECTION_BAD)
7538 return 0;
7540}
#define PG_PROTOCOL_FULL(v)
Definition: pqcomm.h:89

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

◆ PQgetAuthDataHook()

PQauthDataHook_type PQgetAuthDataHook ( void  )

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

1590{
1591 return PQauthDataHook;
1592}
PQauthDataHook_type PQauthDataHook
Definition: fe-auth.c:1586

References PQauthDataHook.

◆ PQgetCancel()

PGcancel * PQgetCancel ( PGconn conn)

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

350{
351 PGcancel *cancel;
352
353 if (!conn)
354 return NULL;
355
356 if (conn->sock == PGINVALID_SOCKET)
357 return NULL;
358
359 cancel = malloc(sizeof(PGcancel));
360 if (cancel == NULL)
361 return NULL;
362
363 memcpy(&cancel->raddr, &conn->raddr, sizeof(SockAddr));
364 cancel->be_pid = conn->be_pid;
365 cancel->be_key = conn->be_key;
366 /* We use -1 to indicate an unset connection option */
367 cancel->pgtcp_user_timeout = -1;
368 cancel->keepalives = -1;
369 cancel->keepalives_idle = -1;
370 cancel->keepalives_interval = -1;
371 cancel->keepalives_count = -1;
372 if (conn->pgtcp_user_timeout != NULL)
373 {
375 &cancel->pgtcp_user_timeout,
376 conn, "tcp_user_timeout"))
377 goto fail;
378 }
379 if (conn->keepalives != NULL)
380 {
382 &cancel->keepalives,
383 conn, "keepalives"))
384 goto fail;
385 }
386 if (conn->keepalives_idle != NULL)
387 {
389 &cancel->keepalives_idle,
390 conn, "keepalives_idle"))
391 goto fail;
392 }
393 if (conn->keepalives_interval != NULL)
394 {
396 &cancel->keepalives_interval,
397 conn, "keepalives_interval"))
398 goto fail;
399 }
400 if (conn->keepalives_count != NULL)
401 {
403 &cancel->keepalives_count,
404 conn, "keepalives_count"))
405 goto fail;
406 }
407
408 return cancel;
409
410fail:
411 free(cancel);
412 return NULL;
413}
char * keepalives_idle
Definition: libpq-int.h:406
char * keepalives
Definition: libpq-int.h:405
char * keepalives_interval
Definition: libpq-int.h:407
char * pgtcp_user_timeout
Definition: libpq-int.h:392
char * keepalives_count
Definition: libpq-int.h:409

References pg_cancel::be_key, pg_conn::be_key, pg_cancel::be_pid, pg_conn::be_pid, conn, free, pg_cancel::keepalives, pg_conn::keepalives, pg_cancel::keepalives_count, pg_conn::keepalives_count, pg_cancel::keepalives_idle, pg_conn::keepalives_idle, pg_cancel::keepalives_interval, pg_conn::keepalives_interval, malloc, PGINVALID_SOCKET, pg_cancel::pgtcp_user_timeout, pg_conn::pgtcp_user_timeout, pqParseIntParam(), pg_cancel::raddr, pg_conn::raddr, and pg_conn::sock.

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

◆ PQgetCopyData()

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

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

2817{
2818 *buffer = NULL; /* for all failure cases */
2819 if (!conn)
2820 return -2;
2823 {
2824 libpq_append_conn_error(conn, "no COPY in progress");
2825 return -2;
2826 }
2827 return pqGetCopyData3(conn, buffer, async);
2828}
int pqGetCopyData3(PGconn *conn, char **buffer, int async)

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

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

◆ PQgetCurrentTimeUSec()

pg_usec_time_t PQgetCurrentTimeUSec ( void  )

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

1210{
1211 struct timeval tval;
1212
1213 gettimeofday(&tval, NULL);
1214 return (pg_usec_time_t) tval.tv_sec * 1000000 + tval.tv_usec;
1215}
pg_int64 pg_usec_time_t
Definition: libpq-fe.h:237
int gettimeofday(struct timeval *tp, void *tzp)

References gettimeofday().

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

◆ PQgetgssctx()

void * PQgetgssctx ( PGconn conn)

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

725{
726 if (!conn)
727 return NULL;
728
729 return conn->gctx;
730}

References conn.

◆ PQgetisnull()

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

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

3902{
3903 if (!check_tuple_field_number(res, tup_num, field_num))
3904 return 1; /* pretend it is null */
3905 if (res->tuples[tup_num][field_num].len == NULL_LEN)
3906 return 1;
3907 else
3908 return 0;
3909}
static int check_tuple_field_number(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3525
#define NULL_LEN
Definition: libpq-int.h:138

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

Referenced by addFooterToPublicationDesc(), BaseBackup(), compile_database_list(), compile_relation_list_one_db(), describeOneTableDetails(), determineNotNullFlags(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpDatabase(), dumpDomain(), dumpFunc(), dumpRangeType(), dumpRelationStats(), dumpRoleMembership(), dumpRoles(), dumpTableData_insert(), ecpg_get_data(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), ECPGget_desc(), ExecQueryTuples(), get_template0_info(), getAggregates(), getExtendedStatistics(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getLOs(), getNamespaces(), getPolicies(), getProcLangs(), getPublicationTables(), GetSlotInformation(), getSubscriptions(), getSubscriptionTables(), getTableAttrs(), GetTableInfo(), getTables(), getTSDictionaries(), getTypes(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_create_slot(), libpqrcv_processTuples(), listTSConfigsVerbose(), listTSParsersVerbose(), make_tuple_from_result_row(), materializeResult(), postgresImportForeignSchema(), printCrosstab(), printQuery(), PrintResultInCrosstab(), process_queued_fetch_requests(), retrieve_objects(), run_simple_query(), RunIdentifySystem(), sqlda_common_total_size(), StoreQueryTuple(), storeRow(), and verify_heap_slot_handler().

◆ PQgetlength()

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

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

3888{
3889 if (!check_tuple_field_number(res, tup_num, field_num))
3890 return 0;
3891 if (res->tuples[tup_num][field_num].len != NULL_LEN)
3892 return res->tuples[tup_num][field_num].len;
3893 else
3894 return 0;
3895}

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

Referenced by createViewAsClause(), do_field(), ecpg_get_data(), ecpg_store_result(), ECPGget_desc(), libpq_fetch_file(), libpqrcv_readtimelinehistoryfile(), PQdisplayTuples(), process_queued_fetch_requests(), and show_binary_results().

◆ PQgetline()

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

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

2855{
2856 if (!buffer || length <= 0)
2857 return EOF;
2858 *buffer = '\0';
2859 /* length must be at least 3 to hold the \. terminator! */
2860 if (length < 3)
2861 return EOF;
2862
2863 if (!conn)
2864 return EOF;
2865
2866 return pqGetline3(conn, buffer, length);
2867}
int pqGetline3(PGconn *conn, char *s, int maxlen)

References conn, and pqGetline3().

◆ PQgetlineAsync()

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

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

2902{
2903 if (!conn)
2904 return -1;
2905
2906 return pqGetlineAsync3(conn, buffer, bufsize);
2907}
int pqGetlineAsync3(PGconn *conn, char *buffer, int bufsize)
#define bufsize
Definition: indent_globs.h:36

References bufsize, conn, and pqGetlineAsync3().

Referenced by pqGetline3().

◆ PQgetResult()

PGresult * PQgetResult ( PGconn conn)

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

2063{
2064 PGresult *res;
2065
2066 if (!conn)
2067 return NULL;
2068
2069 /* Parse any available data, if our state permits. */
2071
2072 /* If not ready to return something, block until we are. */
2073 while (conn->asyncStatus == PGASYNC_BUSY)
2074 {
2075 int flushResult;
2076
2077 /*
2078 * If data remains unsent, send it. Else we might be waiting for the
2079 * result of a command the backend hasn't even got yet.
2080 */
2081 while ((flushResult = pqFlush(conn)) > 0)
2082 {
2083 if (pqWait(false, true, conn))
2084 {
2085 flushResult = -1;
2086 break;
2087 }
2088 }
2089
2090 /*
2091 * Wait for some more data, and load it. (Note: if the connection has
2092 * been lost, pqWait should return immediately because the socket
2093 * should be read-ready, either with the last server data or with an
2094 * EOF indication. We expect therefore that this won't result in any
2095 * undue delay in reporting a previous write failure.)
2096 */
2097 if (flushResult ||
2098 pqWait(true, false, conn) ||
2099 pqReadData(conn) < 0)
2100 {
2101 /* Report the error saved by pqWait or pqReadData */
2104 return pqPrepareAsyncResult(conn);
2105 }
2106
2107 /* Parse it. */
2109
2110 /*
2111 * If we had a write error, but nothing above obtained a query result
2112 * or detected a read error, report the write error.
2113 */
2115 {
2118 return pqPrepareAsyncResult(conn);
2119 }
2120 }
2121
2122 /* Return the appropriate thing. */
2123 switch (conn->asyncStatus)
2124 {
2125 case PGASYNC_IDLE:
2126 res = NULL; /* query is complete */
2127 break;
2130
2131 /*
2132 * We're about to return the NULL that terminates the round of
2133 * results from the current query; prepare to send the results of
2134 * the next query, if any, when we're called next. If there's no
2135 * next element in the command queue, this gets us in IDLE state.
2136 */
2138 res = NULL; /* query is complete */
2139 break;
2140
2141 case PGASYNC_READY:
2143
2144 /*
2145 * Normally pqPrepareAsyncResult will have left conn->result
2146 * empty. Otherwise, "res" must be a not-full PGRES_TUPLES_CHUNK
2147 * result, which we want to return to the caller while staying in
2148 * PGASYNC_READY state. Then the next call here will return the
2149 * empty PGRES_TUPLES_OK result that was restored from
2150 * saved_result, after which we can proceed.
2151 */
2152 if (conn->result)
2153 {
2155 break;
2156 }
2157
2158 /* Advance the queue as appropriate */
2161
2163 {
2164 /*
2165 * We're about to send the results of the current query. Set
2166 * us idle now, and ...
2167 */
2169
2170 /*
2171 * ... in cases when we're sending a pipeline-sync result,
2172 * move queue processing forwards immediately, so that next
2173 * time we're called, we're prepared to return the next result
2174 * received from the server. In all other cases, leave the
2175 * queue state change for next time, so that a terminating
2176 * NULL result is sent.
2177 *
2178 * (In other words: we don't return a NULL after a pipeline
2179 * sync.)
2180 */
2183 }
2184 else
2185 {
2186 /* Set the state back to BUSY, allowing parsing to proceed. */
2188 }
2189 break;
2190 case PGASYNC_READY_MORE:
2192 /* Set the state back to BUSY, allowing parsing to proceed. */
2194 break;
2195 case PGASYNC_COPY_IN:
2197 break;
2198 case PGASYNC_COPY_OUT:
2200 break;
2201 case PGASYNC_COPY_BOTH:
2203 break;
2204 default:
2205 libpq_append_conn_error(conn, "unexpected asyncStatus: %d", (int) conn->asyncStatus);
2207 conn->asyncStatus = PGASYNC_IDLE; /* try to restore valid state */
2209 break;
2210 }
2211
2212 /* Time to fire PGEVT_RESULTCREATE events, if there are any */
2213 if (res && res->nEvents > 0)
2214 (void) PQfireResultCreateEvents(conn, res);
2215
2216 return res;
2217}
PGresult * pqPrepareAsyncResult(PGconn *conn)
Definition: fe-exec.c:851
static void pqSaveWriteError(PGconn *conn)
Definition: fe-exec.c:820
void pqCommandQueueAdvance(PGconn *conn, bool isReadyForQuery, bool gotSync)
Definition: fe-exec.c:3142
void pqSaveErrorResult(PGconn *conn)
Definition: fe-exec.c:803
static PGresult * getCopyResult(PGconn *conn, ExecStatusType copytype)
Definition: fe-exec.c:2224
static void parseInput(PGconn *conn)
Definition: fe-exec.c:2020
static void pqPipelineProcessQueue(PGconn *conn)
Definition: fe-exec.c:3180
int pqWait(int forRead, int forWrite, PGconn *conn)
Definition: fe-misc.c:993
int PQfireResultCreateEvents(PGconn *conn, PGresult *res)
Definition: libpq-events.c:185
bool write_failed
Definition: libpq-int.h:512
PGresult * result
Definition: libpq-int.h:594
ExecStatusType resultStatus
Definition: libpq-int.h:182

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

Referenced by advanceConnectionState(), BaseBackup(), ClearOrSaveAllResults(), confirm_query_canceled_impl(), consumeQueryResult(), discardAbortedPipelineResults(), discardUntilSync(), dumpTableData_copy(), ecpg_process_output(), EndDBCopyMode(), ExecQueryAndProcessResults(), handleCopyIn(), handleCopyOut(), HandleEndOfCopyStream(), libpqrcv_PQgetResult(), libpqsrv_get_result(), pgfdw_finish_pre_commit_cleanup(), pgfdw_get_cleanup_result(), PQconnectPoll(), pqEndcopy3(), PQexecFinish(), PQexecStart(), process_query_result(), process_queued_fetch_requests(), process_result(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), StreamLogicalLog(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), test_uniqviol(), try_complete_step(), and wait_on_slots().

◆ PQgetssl()

void * PQgetssl ( PGconn conn)

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

1565{
1566 if (!conn)
1567 return NULL;
1568 return conn->ssl;
1569}

References conn.

◆ PQgetSSLKeyPassHook_OpenSSL()

PQsslKeyPassHook_OpenSSL_type PQgetSSLKeyPassHook_OpenSSL ( void  )

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

1861{
1862 return PQsslKeyPassHook;
1863}
static PQsslKeyPassHook_OpenSSL_type PQsslKeyPassHook

References PQsslKeyPassHook.

◆ PQgetvalue()

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

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

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

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

Referenced by _check_database_version(), add_tablespace_footer(), addFooterToPublicationDesc(), append_depends_on_extension(), appendQualifiedRelation(), BaseBackup(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), check_and_drop_existing_subscriptions(), check_and_drop_publications(), check_for_connection_status(), check_for_pg_role_prefix(), check_is_install_user(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), check_publisher(), check_subscriber(), cluster_all_databases(), collectBinaryUpgradeClassOids(), collectComments(), collectRoleNames(), collectSecLabels(), collectSequences(), compile_database_list(), compile_relation_list_one_db(), convertTSFunction(), create_logical_replication_slot(), createViewAsClause(), describeOneTableDetails(), describePublications(), describeRoles(), describeTableDetails(), determineNotNullFlags(), do_field(), drop_failover_replication_slots(), dropDBs(), dropRoles(), dropTablespaces(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpDomain(), dumpEnumType(), dumpForeignServer(), dumpFunc(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRelationStats(), dumpRoleGUCPrivs(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSearchPath(), dumpSequence(), dumpSequenceData(), dumpStatisticsExt(), dumpTable(), dumpTableAttach(), dumpTableData_insert(), dumpTableSchema(), dumpTablespaces(), dumpTSConfig(), dumpTSDictionary(), dumpUserConfig(), dumpUserMappings(), ecpg_get_data(), ecpg_is_type_an_array(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), ecpg_store_result(), emitShSecLabels(), exec_command_password(), ExecQueryTuples(), expand_dbname_patterns(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), generate_object_name(), get_create_object_cmd(), get_db_infos(), get_language_name(), get_loadable_libraries(), get_next_possible_free_pg_type_oid(), get_parallel_tabidx_list(), get_parallel_tables_list(), get_primary_sysid(), get_remote_estimate(), get_subscription_count(), get_synchronized_snapshot(), get_table_relkind(), get_tablespace_paths(), get_template0_info(), getAccessMethods(), getAdditionalACLs(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFormattedTypeName(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPartitioningInfo(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRules(), GetSlotInformation(), getSubscriptions(), getSubscriptionTables(), getTableAttrs(), GetTableInfo(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_identify_system(), libpqrcv_processTuples(), libpqrcv_readtimelinehistoryfile(), listExtensionContents(), listSchemas(), listTSConfigsVerbose(), listTSParsersVerbose(), lo_initialize(), lookup_object_oid(), main(), make_tuple_from_result_row(), materializeResult(), old_9_6_invalidate_hash_indexes(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), PQconnectPoll(), PQdisplayTuples(), PQencryptPasswordConn(), PQprintTuples(), printCrosstab(), printQuery(), PrintResultInCrosstab(), process_data_type_check(), process_extension_updates(), process_incompat_polymorphics(), process_isn_and_int8_passing_mismatch(), process_old_cluster_logical_slot_infos(), process_old_sub_state_check(), process_queued_fetch_requests(), process_rel_infos(), process_result(), process_user_defined_encoding_conversions(), process_user_defined_postfix_ops(), process_with_oids_check(), processExtensionTables(), readCommandResponse(), ReadEndOfStreamingResult(), ReceiveXlogStream(), reindex_all_databases(), retrieve_objects(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_simple_query(), RunIdentifySystem(), server_is_in_recovery(), set_frozenxids(), set_replication_progress(), show_binary_results(), sql_exec(), sqlda_common_total_size(), StoreQueryTuple(), storeRow(), test_pipeline_abort(), test_singlerowmode(), test_transaction(), try_complete_step(), vacuum_all_databases(), vacuumlo(), verify_heap_slot_handler(), and wait_for_connection_state().

◆ PQgssEncInUse()

int PQgssEncInUse ( PGconn conn)

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

737{
738 if (!conn || !conn->gctx)
739 return 0;
740
741 return conn->gssenc;
742}

References conn.

Referenced by printGSSInfo().

◆ PQhost()

char * PQhost ( const PGconn conn)

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

7423{
7424 if (!conn)
7425 return NULL;
7426
7427 if (conn->connhost != NULL)
7428 {
7429 /*
7430 * Return the verbatim host value provided by user, or hostaddr in its
7431 * lack.
7432 */
7433 if (conn->connhost[conn->whichhost].host != NULL &&
7434 conn->connhost[conn->whichhost].host[0] != '\0')
7435 return conn->connhost[conn->whichhost].host;
7436 else if (conn->connhost[conn->whichhost].hostaddr != NULL &&
7437 conn->connhost[conn->whichhost].hostaddr[0] != '\0')
7439 }
7440
7441 return "";
7442}

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

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

◆ PQhostaddr()

char * PQhostaddr ( const PGconn conn)

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

7446{
7447 if (!conn)
7448 return NULL;
7449
7450 /* Return the parsed IP address */
7451 if (conn->connhost != NULL && conn->connip != NULL)
7452 return conn->connip;
7453
7454 return "";
7455}

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

Referenced by do_connect(), and exec_command_conninfo().

◆ PQinitOpenSSL()

void PQinitOpenSSL ( int  do_ssl,
int  do_crypto 
)

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

130{
131 /* no-op */
132}

◆ PQinitSSL()

void PQinitSSL ( int  do_init)

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

118{
119 /* no-op */
120}

◆ PQisBusy()

int PQisBusy ( PGconn conn)

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

2032{
2033 if (!conn)
2034 return false;
2035
2036 /* Parse any available data, if our state permits. */
2038
2039 /*
2040 * PQgetResult will return immediately in all states except BUSY. Also,
2041 * if we've detected read EOF and dropped the connection, we can expect
2042 * that PQgetResult will fail immediately. Note that we do *not* check
2043 * conn->write_failed here --- once that's become set, we know we have
2044 * trouble, but we need to keep trying to read until we have a complete
2045 * server message or detect read EOF.
2046 */
2048}

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

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

◆ PQisnonblocking()

int PQisnonblocking ( const PGconn conn)

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

3984{
3985 if (!conn || conn->status == CONNECTION_BAD)
3986 return false;
3987 return pqIsnonblocking(conn);
3988}

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

Referenced by test_disallowed_in_pipeline(), and test_simple_pipeline().

◆ PQisthreadsafe()

int PQisthreadsafe ( void  )

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

3993{
3994 return true;
3995}

◆ PQlibVersion()

int PQlibVersion ( void  )

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

64{
65 return PG_VERSION_NUM;
66}

◆ PQmakeEmptyPGresult()

PGresult * PQmakeEmptyPGresult ( PGconn conn,
ExecStatusType  status 
)

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

160{
161 PGresult *result;
162
163 result = (PGresult *) malloc(sizeof(PGresult));
164 if (!result)
165 return NULL;
166
167 result->ntups = 0;
168 result->numAttributes = 0;
169 result->attDescs = NULL;
170 result->tuples = NULL;
171 result->tupArrSize = 0;
172 result->numParameters = 0;
173 result->paramDescs = NULL;
174 result->resultStatus = status;
175 result->cmdStatus[0] = '\0';
176 result->binary = 0;
177 result->events = NULL;
178 result->nEvents = 0;
179 result->errMsg = NULL;
180 result->errFields = NULL;
181 result->errQuery = NULL;
182 result->null_field[0] = '\0';
183 result->curBlock = NULL;
184 result->curOffset = 0;
185 result->spaceLeft = 0;
186 result->memorySize = sizeof(PGresult);
187
188 if (conn)
189 {
190 /* copy connection data we might need for operations on PGresult */
191 result->noticeHooks = conn->noticeHooks;
193
194 /* consider copying conn's errorMessage */
195 switch (status)
196 {
198 case PGRES_COMMAND_OK:
199 case PGRES_TUPLES_OK:
200 case PGRES_COPY_OUT:
201 case PGRES_COPY_IN:
202 case PGRES_COPY_BOTH:
205 /* non-error cases */
206 break;
207 default:
208 /* we intentionally do not use or modify errorReported here */
209 pqSetResultError(result, &conn->errorMessage, 0);
210 break;
211 }
212
213 /* copy events last; result must be valid if we need to PQclear */
214 if (conn->nEvents > 0)
215 {
216 result->events = dupEvents(conn->events, conn->nEvents,
217 &result->memorySize);
218 if (!result->events)
219 {
220 PQclear(result);
221 return NULL;
222 }
223 result->nEvents = conn->nEvents;
224 }
225 }
226 else
227 {
228 /* defaults... */
229 result->noticeHooks.noticeRec = NULL;
230 result->noticeHooks.noticeRecArg = NULL;
231 result->noticeHooks.noticeProc = NULL;
232 result->noticeHooks.noticeProcArg = NULL;
234 }
235
236 return result;
237}
void pqSetResultError(PGresult *res, PQExpBuffer errorMessage, int offset)
Definition: fe-exec.c:692
struct pg_result PGresult
Definition: libpq-fe.h:213
void * noticeProcArg
Definition: libpq-int.h:160
PQnoticeReceiver noticeRec
Definition: libpq-int.h:157
PQnoticeProcessor noticeProc
Definition: libpq-int.h:159
void * noticeRecArg
Definition: libpq-int.h:158
int nEvents
Definition: libpq-int.h:460
PGNoticeHooks noticeHooks
Definition: libpq-int.h:456
PGEvent * events
Definition: libpq-int.h:459
size_t memorySize
Definition: libpq-int.h:217
int curOffset
Definition: libpq-int.h:214
char null_field[1]
Definition: libpq-int.h:206
char * errMsg
Definition: libpq-int.h:201
int numParameters
Definition: libpq-int.h:180
int spaceLeft
Definition: libpq-int.h:215
int tupArrSize
Definition: libpq-int.h:179
char * errQuery
Definition: libpq-int.h:203

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

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

◆ PQmblen()

int PQmblen ( const char *  s,
int  encoding 
)

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

1234{
1235 return pg_encoding_mblen(encoding, s);
1236}
int pg_encoding_mblen(int encoding, const char *mbstr)
Definition: wchar.c:2116

References encoding, and pg_encoding_mblen().

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

◆ PQmblenBounded()

int PQmblenBounded ( const char *  s,
int  encoding 
)

◆ PQnfields()

◆ PQnotifies()

PGnotify * PQnotifies ( PGconn conn)

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

2668{
2669 PGnotify *event;
2670
2671 if (!conn)
2672 return NULL;
2673
2674 /* Parse any available data to see if we can extract NOTIFY messages. */
2676
2677 event = conn->notifyHead;
2678 if (event)
2679 {
2680 conn->notifyHead = event->next;
2681 if (!conn->notifyHead)
2682 conn->notifyTail = NULL;
2683 event->next = NULL; /* don't let app see the internal state */
2684 }
2685 return event;
2686}
struct pgNotify * next
Definition: libpq-fe.h:233
PGnotify * notifyHead
Definition: libpq-int.h:478
PGnotify * notifyTail
Definition: libpq-int.h:479

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

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

◆ PQnparams()

int PQnparams ( const PGresult res)

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

3916{
3917 if (!res)
3918 return 0;
3919 return res->numParameters;
3920}

References pg_result::numParameters.

◆ PQntuples()

int PQntuples ( const PGresult res)

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

3482{
3483 if (!res)
3484 return 0;
3485 return res->ntups;
3486}

References pg_result::ntups.

Referenced by add_tablespace_footer(), addFooterToPublicationDesc(), append_depends_on_extension(), appendQualifiedRelation(), BaseBackup(), buildMatViewRefreshDependencies(), check_and_drop_existing_subscriptions(), check_and_drop_publications(), check_for_connection_status(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_is_install_user(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), cluster_all_databases(), collectBinaryUpgradeClassOids(), collectComments(), collectRoleNames(), collectSecLabels(), collectSequences(), compile_database_list(), compile_relation_list_one_db(), create_publication(), CreateReplicationSlot(), createViewAsClause(), describeOneTableDetails(), describePublications(), describeRoles(), describeTableDetails(), drop_failover_replication_slots(), dropDBs(), DropReplicationSlot(), dropRoles(), dropTablespaces(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpEnumType(), dumpOpclass(), dumpOpfamily(), dumpRelationStats(), dumpRoleGUCPrivs(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSequence(), dumpSequenceData(), dumpTable(), dumpTableData_insert(), dumpTablespaces(), dumpTSConfig(), dumpUserConfig(), dumpUserMappings(), ecpg_is_type_an_array(), ecpg_process_output(), ecpg_store_result(), ECPGget_desc(), emitShSecLabels(), ExecQueryAndProcessResults(), ExecQueryTuples(), execute_dml_stmt(), execute_foreign_modify(), ExecuteSqlQueryForSingleRow(), expand_dbname_patterns(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), fetch_more_data(), generate_object_name(), get_create_object_cmd(), get_db_infos(), get_loadable_libraries(), get_parallel_tabidx_list(), get_parallel_tables_list(), get_primary_sysid(), get_tablespace_paths(), get_template0_info(), getAccessMethods(), getAdditionalACLs(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPartitioningInfo(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRules(), GetSlotInformation(), getSubscriptions(), getSubscriptionTables(), getTableAttrs(), GetTableInfo(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_endstreaming(), libpqrcv_identify_system(), libpqrcv_processTuples(), libpqrcv_readtimelinehistoryfile(), listDbRoleSettings(), listExtensionContents(), listSchemas(), listTables(), listTSConfigsVerbose(), listTSParsersVerbose(), lo_initialize(), lookup_object_oid(), main(), make_tuple_from_result_row(), materializeResult(), old_9_6_invalidate_hash_indexes(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), PQconnectPoll(), PQdisplayTuples(), PQencryptPasswordConn(), PQprint(), PQprintTuples(), printCrosstab(), printQuery(), PrintResultInCrosstab(), process_data_type_check(), process_extension_updates(), process_incompat_polymorphics(), process_isn_and_int8_passing_mismatch(), process_loadable_libraries(), process_old_cluster_logical_slot_infos(), process_old_sub_state_check(), process_queued_fetch_requests(), process_rel_infos(), process_user_defined_encoding_conversions(), process_user_defined_postfix_ops(), process_with_oids_check(), processExtensionTables(), readCommandResponse(), ReadEndOfStreamingResult(), ReceiveXlogStream(), reindex_all_databases(), retrieve_objects(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_simple_query(), RunIdentifySystem(), set_frozenxids(), set_replication_progress(), show_binary_results(), sql_exec(), StoreQueryTuple(), storeRow(), test_pipeline_abort(), test_singlerowmode(), test_transaction(), try_complete_step(), vacuum_all_databases(), vacuumlo(), verify_btree_slot_handler(), verify_heap_slot_handler(), and wait_for_connection_state().

◆ PQoidStatus()

char * PQoidStatus ( const PGresult res)

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

3766{
3767 /*
3768 * This must be enough to hold the result. Don't laugh, this is better
3769 * than what this function used to do.
3770 */
3771 static char buf[24];
3772
3773 size_t len;
3774
3775 if (!res || strncmp(res->cmdStatus, "INSERT ", 7) != 0)
3776 return "";
3777
3778 len = strspn(res->cmdStatus + 7, "0123456789");
3779 if (len > sizeof(buf) - 1)
3780 len = sizeof(buf) - 1;
3781 memcpy(buf, res->cmdStatus + 7, len);
3782 buf[len] = '\0';
3783
3784 return buf;
3785}

References buf, pg_result::cmdStatus, and len.

◆ PQoidValue()

Oid PQoidValue ( const PGresult res)

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

3794{
3795 char *endptr = NULL;
3796 unsigned long result;
3797
3798 if (!res ||
3799 strncmp(res->cmdStatus, "INSERT ", 7) != 0 ||
3800 res->cmdStatus[7] < '0' ||
3801 res->cmdStatus[7] > '9')
3802 return InvalidOid;
3803
3804 result = strtoul(res->cmdStatus + 7, &endptr, 10);
3805
3806 if (!endptr || (*endptr != ' ' && *endptr != '\0'))
3807 return InvalidOid;
3808 else
3809 return (Oid) result;
3810}

References pg_result::cmdStatus, and InvalidOid.

Referenced by ecpg_process_output(), and PrintQueryStatus().

◆ PQoptions()

char * PQoptions ( const PGconn conn)

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

7483{
7484 if (!conn)
7485 return NULL;
7486 return conn->pgoptions;
7487}
char * pgoptions
Definition: libpq-int.h:394

References conn, and pg_conn::pgoptions.

Referenced by exec_command_conninfo().

◆ PQparameterStatus()

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

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

7509{
7510 const pgParameterStatus *pstatus;
7511
7512 if (!conn || !paramName)
7513 return NULL;
7514 for (pstatus = conn->pstatus; pstatus != NULL; pstatus = pstatus->next)
7515 {
7516 if (strcmp(pstatus->name, paramName) == 0)
7517 return pstatus->value;
7518 }
7519 return NULL;
7520}
struct pgParameterStatus * next
Definition: libpq-int.h:279
pgParameterStatus * pstatus
Definition: libpq-int.h:552

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

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

◆ PQparamtype()

Oid PQparamtype ( const PGresult res,
int  param_num 
)

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

3927{
3928 if (!check_param_number(res, param_num))
3929 return InvalidOid;
3930 if (res->paramDescs)
3931 return res->paramDescs[param_num].typid;
3932 else
3933 return InvalidOid;
3934}
static int check_param_number(const PGresult *res, int param_num)
Definition: fe-exec.c:3548

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

◆ PQpass()

char * PQpass ( const PGconn conn)

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

7406{
7407 char *password = NULL;
7408
7409 if (!conn)
7410 return NULL;
7411 if (conn->connhost != NULL)
7413 if (password == NULL)
7414 password = conn->pgpass;
7415 /* Historically we've returned "" not NULL for no password specified */
7416 if (password == NULL)
7417 password = "";
7418 return password;
7419}
char * pgpass
Definition: libpq-int.h:401

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

Referenced by ConnectDatabase(), and PQconnectionNeedsPassword().

◆ PQping()

PGPing PQping ( const char *  conninfo)

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

809{
810 PGconn *conn = PQconnectStart(conninfo);
811 PGPing ret;
812
813 ret = internal_ping(conn);
814 PQfinish(conn);
815
816 return ret;
817}
static PGPing internal_ping(PGconn *conn)
Definition: fe-connect.c:4807

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

◆ PQpingParams()

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

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

758{
759 PGconn *conn = PQconnectStartParams(keywords, values, expand_dbname);
760 PGPing ret;
761
762 ret = internal_ping(conn);
763 PQfinish(conn);
764
765 return ret;
766}

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

Referenced by main(), and regression_main().

◆ PQpipelineStatus()

◆ PQpipelineSync()

int PQpipelineSync ( PGconn conn)

◆ PQport()

char * PQport ( const PGconn conn)

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

7459{
7460 if (!conn)
7461 return NULL;
7462
7463 if (conn->connhost != NULL)
7464 return conn->connhost[conn->whichhost].port;
7465
7466 return "";
7467}

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

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

◆ PQprepare()

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

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

2309{
2310 if (!PQexecStart(conn))
2311 return NULL;
2312 if (!PQsendPrepare(conn, stmtName, query, nParams, paramTypes))
2313 return NULL;
2314 return PQexecFinish(conn);
2315}
int PQsendPrepare(PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
Definition: fe-exec.c:1536

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

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

◆ PQprint()

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

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

69{
70 int nFields;
71
72 nFields = PQnfields(res);
73
74 if (nFields > 0)
75 { /* only print rows with at least 1 field. */
76 int i,
77 j;
78 int nTups;
79 int *fieldMax = NULL; /* in case we don't use them */
80 unsigned char *fieldNotNum = NULL;
81 char *border = NULL;
82 char **fields = NULL;
83 const char **fieldNames = NULL;
84 int fieldMaxLen = 0;
85 int numFieldName;
86 int fs_len = strlen(po->fieldSep);
87 int total_line_length = 0;
88 bool usePipe = false;
89 char *pagerenv;
90
91#if !defined(WIN32)
92 sigset_t osigset;
93 bool sigpipe_masked = false;
94 bool sigpipe_pending;
95#endif
96
97#ifdef TIOCGWINSZ
98 struct winsize screen_size;
99#else
100 struct winsize
101 {
102 int ws_row;
103 int ws_col;
104 } screen_size;
105#endif
106
107 nTups = PQntuples(res);
108 fieldNames = (const char **) calloc(nFields, sizeof(char *));
109 fieldNotNum = (unsigned char *) calloc(nFields, 1);
110 fieldMax = (int *) calloc(nFields, sizeof(int));
111 if (!fieldNames || !fieldNotNum || !fieldMax)
112 {
113 fprintf(stderr, libpq_gettext("out of memory\n"));
114 goto exit;
115 }
116 for (numFieldName = 0;
117 po->fieldName && po->fieldName[numFieldName];
118 numFieldName++)
119 ;
120 for (j = 0; j < nFields; j++)
121 {
122 int len;
123 const char *s = (j < numFieldName && po->fieldName[j][0]) ?
124 po->fieldName[j] : PQfname(res, j);
125
126 fieldNames[j] = s;
127 len = s ? strlen(s) : 0;
128 fieldMax[j] = len;
129 len += fs_len;
130 if (len > fieldMaxLen)
131 fieldMaxLen = len;
132 total_line_length += len;
133 }
134
135 total_line_length += nFields * strlen(po->fieldSep) + 1;
136
137 if (fout == NULL)
138 fout = stdout;
139 if (po->pager && fout == stdout && isatty(fileno(stdin)) &&
140 isatty(fileno(stdout)))
141 {
142 /*
143 * If we think there'll be more than one screen of output, try to
144 * pipe to the pager program.
145 */
146#ifdef TIOCGWINSZ
147 if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) == -1 ||
148 screen_size.ws_col == 0 ||
149 screen_size.ws_row == 0)
150 {
151 screen_size.ws_row = 24;
152 screen_size.ws_col = 80;
153 }
154#else
155 screen_size.ws_row = 24;
156 screen_size.ws_col = 80;
157#endif
158
159 /*
160 * Since this function is no longer used by psql, we don't examine
161 * PSQL_PAGER. It's possible that the hypothetical external users
162 * of the function would like that to happen, but in the name of
163 * backwards compatibility, we'll stick to just examining PAGER.
164 */
165 pagerenv = getenv("PAGER");
166 /* if PAGER is unset, empty or all-white-space, don't use pager */
167 if (pagerenv != NULL &&
168 strspn(pagerenv, " \t\r\n") != strlen(pagerenv) &&
169 !po->html3 &&
170 ((po->expanded &&
171 nTups * (nFields + 1) >= screen_size.ws_row) ||
172 (!po->expanded &&
173 nTups * (total_line_length / screen_size.ws_col + 1) *
174 (1 + (po->standard != 0)) >= screen_size.ws_row -
175 (po->header != 0) *
176 (total_line_length / screen_size.ws_col + 1) * 2
177 - (po->header != 0) * 2 /* row count and newline */
178 )))
179 {
180 fflush(NULL);
181 fout = popen(pagerenv, "w");
182 if (fout)
183 {
184 usePipe = true;
185#ifndef WIN32
186 if (pq_block_sigpipe(&osigset, &sigpipe_pending) == 0)
187 sigpipe_masked = true;
188#endif /* WIN32 */
189 }
190 else
191 fout = stdout;
192 }
193 }
194
195 if (!po->expanded && (po->align || po->html3))
196 {
197 fields = (char **) calloc((size_t) nTups + 1,
198 nFields * sizeof(char *));
199 if (!fields)
200 {
201 fprintf(stderr, libpq_gettext("out of memory\n"));
202 goto exit;
203 }
204 }
205 else if (po->header && !po->html3)
206 {
207 if (po->expanded)
208 {
209 if (po->align)
210 fprintf(fout, libpq_gettext("%-*s%s Value\n"),
211 fieldMaxLen - fs_len, libpq_gettext("Field"), po->fieldSep);
212 else
213 fprintf(fout, libpq_gettext("%s%sValue\n"), libpq_gettext("Field"), po->fieldSep);
214 }
215 else
216 {
217 int len = 0;
218
219 for (j = 0; j < nFields; j++)
220 {
221 const char *s = fieldNames[j];
222
223 fputs(s, fout);
224 len += strlen(s) + fs_len;
225 if ((j + 1) < nFields)
226 fputs(po->fieldSep, fout);
227 }
228 fputc('\n', fout);
229 for (len -= fs_len; len--; fputc('-', fout));
230 fputc('\n', fout);
231 }
232 }
233 if (po->expanded && po->html3)
234 {
235 if (po->caption)
236 fprintf(fout, "<center><h2>%s</h2></center>\n", po->caption);
237 else
238 fprintf(fout,
239 "<center><h2>"
240 "Query retrieved %d rows * %d fields"
241 "</h2></center>\n",
242 nTups, nFields);
243 }
244 for (i = 0; i < nTups; i++)
245 {
246 if (po->expanded)
247 {
248 if (po->html3)
249 fprintf(fout,
250 "<table %s><caption align=\"top\">%d</caption>\n",
251 po->tableOpt ? po->tableOpt : "", i);
252 else
253 fprintf(fout, libpq_gettext("-- RECORD %d --\n"), i);
254 }
255 for (j = 0; j < nFields; j++)
256 {
257 if (!do_field(po, res, i, j, fs_len, fields, nFields,
258 fieldNames, fieldNotNum,
259 fieldMax, fieldMaxLen, fout))
260 goto exit;
261 }
262 if (po->html3 && po->expanded)
263 fputs("</table>\n", fout);
264 }
265 if (!po->expanded && (po->align || po->html3))
266 {
267 if (po->html3)
268 {
269 if (po->header)
270 {
271 if (po->caption)
272 fprintf(fout,
273 "<table %s><caption align=\"top\">%s</caption>\n",
274 po->tableOpt ? po->tableOpt : "",
275 po->caption);
276 else
277 fprintf(fout,
278 "<table %s><caption align=\"top\">"
279 "Retrieved %d rows * %d fields"
280 "</caption>\n",
281 po->tableOpt ? po->tableOpt : "", nTups, nFields);
282 }
283 else
284 fprintf(fout, "<table %s>", po->tableOpt ? po->tableOpt : "");
285 }
286 if (po->header)
287 border = do_header(fout, po, nFields, fieldMax, fieldNames,
288 fieldNotNum, fs_len, res);
289 for (i = 0; i < nTups; i++)
290 output_row(fout, po, nFields, fields,
291 fieldNotNum, fieldMax, border, i);
292 }
293 if (po->header && !po->html3)
294 fprintf(fout, "(%d row%s)\n\n", PQntuples(res),
295 (PQntuples(res) == 1) ? "" : "s");
296 if (po->html3 && !po->expanded)
297 fputs("</table>\n", fout);
298
299exit:
300 free(fieldMax);
301 free(fieldNotNum);
302 free(border);
303 if (fields)
304 {
305 /* if calloc succeeded, this shouldn't overflow size_t */
306 size_t numfields = ((size_t) nTups + 1) * (size_t) nFields;
307
308 while (numfields-- > 0)
309 free(fields[numfields]);
310 free(fields);
311 }
312 free(fieldNames);
313 if (usePipe)
314 {
315#ifdef WIN32
316 _pclose(fout);
317#else
318 pclose(fout);
319
320 /* we can't easily verify if EPIPE occurred, so say it did */
321 if (sigpipe_masked)
322 pq_reset_sigpipe(&osigset, sigpipe_pending, true);
323#endif /* WIN32 */
324 }
325 }
326}
static char * do_header(FILE *fout, const PQprintOpt *po, const int nFields, int *fieldMax, const char **fieldNames, unsigned char *fieldNotNum, const int fs_len, const PGresult *res)
Definition: fe-print.c:445
static bool do_field(const PQprintOpt *po, const PGresult *res, const int i, const int j, const int fs_len, char **fields, const int nFields, const char **fieldNames, unsigned char *fieldNotNum, int *fieldMax, const int fieldMaxLen, FILE *fout)
Definition: fe-print.c:330
static void output_row(FILE *fout, const PQprintOpt *po, const int nFields, char **fields, unsigned char *fieldNotNum, int *fieldMax, char *border, const int row_index)
Definition: fe-print.c:531
void pq_reset_sigpipe(sigset_t *osigset, bool sigpipe_pending, bool got_epipe)
Definition: fe-secure.c:554
int pq_block_sigpipe(sigset_t *osigset, bool *sigpipe_pending)
Definition: fe-secure.c:504
pqbool align
Definition: libpq-fe.h:249
pqbool pager
Definition: libpq-fe.h:253
pqbool standard
Definition: libpq-fe.h:250
pqbool html3
Definition: libpq-fe.h:251
char * caption
Definition: libpq-fe.h:256
pqbool header
Definition: libpq-fe.h:248
pqbool expanded
Definition: libpq-fe.h:252
char * fieldSep
Definition: libpq-fe.h:254
char ** fieldName
Definition: libpq-fe.h:257
char * tableOpt
Definition: libpq-fe.h:255

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

Referenced by printResultSet().

◆ PQprintTuples()

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

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

677{
678 int nFields;
679 int nTups;
680 int i,
681 j;
682 char formatString[80];
683 char *tborder = NULL;
684
685 nFields = PQnfields(res);
686 nTups = PQntuples(res);
687
688 if (colWidth > 0)
689 sprintf(formatString, "%%s %%-%ds", colWidth);
690 else
691 sprintf(formatString, "%%s %%s");
692
693 if (nFields > 0)
694 { /* only print rows with at least 1 field. */
695
696 if (!TerseOutput)
697 {
698 int width;
699
700 width = nFields * 14;
701 tborder = (char *) malloc(width + 1);
702 if (!tborder)
703 {
704 fprintf(stderr, libpq_gettext("out of memory\n"));
705 return;
706 }
707 for (i = 0; i < width; i++)
708 tborder[i] = '-';
709 tborder[width] = '\0';
710 fprintf(fout, "%s\n", tborder);
711 }
712
713 for (i = 0; i < nFields; i++)
714 {
715 if (PrintAttNames)
716 {
717 fprintf(fout, formatString,
718 TerseOutput ? "" : "|",
719 PQfname(res, i));
720 }
721 }
722
723 if (PrintAttNames)
724 {
725 if (TerseOutput)
726 fprintf(fout, "\n");
727 else
728 fprintf(fout, "|\n%s\n", tborder);
729 }
730
731 for (i = 0; i < nTups; i++)
732 {
733 for (j = 0; j < nFields; j++)
734 {
735 const char *pval = PQgetvalue(res, i, j);
736
737 fprintf(fout, formatString,
738 TerseOutput ? "" : "|",
739 pval ? pval : "");
740 }
741 if (TerseOutput)
742 fprintf(fout, "\n");
743 else
744 fprintf(fout, "|\n%s\n", tborder);
745 }
746 }
747
748 free(tborder);
749}
#define sprintf
Definition: port.h:241

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

◆ PQprotocolVersion()

int PQprotocolVersion ( const PGconn conn)

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

7524{
7525 if (!conn)
7526 return 0;
7527 if (conn->status == CONNECTION_BAD)
7528 return 0;
7530}
#define PG_PROTOCOL_MAJOR(v)
Definition: pqcomm.h:87

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

Referenced by exec_command_conninfo(), and handleCopyIn().

◆ PQputCopyData()

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

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

2696{
2697 if (!conn)
2698 return -1;
2701 {
2702 libpq_append_conn_error(conn, "no COPY in progress");
2703 return -1;
2704 }
2705
2706 /*
2707 * Process any NOTICE or NOTIFY messages that might be pending in the
2708 * input buffer. Since the server might generate many notices during the
2709 * COPY, we want to clean those out reasonably promptly to prevent
2710 * indefinite expansion of the input buffer. (Note: the actual read of
2711 * input data into the input buffer happens down inside pqSendSome, but
2712 * it's not authorized to get rid of the data again.)
2713 */
2715
2716 if (nbytes > 0)
2717 {
2718 /*
2719 * Try to flush any previously sent data in preference to growing the
2720 * output buffer. If we can't enlarge the buffer enough to hold the
2721 * data, return 0 in the nonblock case, else hard error. (For
2722 * simplicity, always assume 5 bytes of overhead.)
2723 */
2724 if ((conn->outBufSize - conn->outCount - 5) < nbytes)
2725 {
2726 if (pqFlush(conn) < 0)
2727 return -1;
2728 if (pqCheckOutBufferSpace(conn->outCount + 5 + (size_t) nbytes,
2729 conn))
2730 return pqIsnonblocking(conn) ? 0 : -1;
2731 }
2732 /* Send the data (too simple to delegate to fe-protocol files) */
2733 if (pqPutMsgStart(PqMsg_CopyData, conn) < 0 ||
2734 pqPutnchar(buffer, nbytes, conn) < 0 ||
2735 pqPutMsgEnd(conn) < 0)
2736 return -1;
2737 }
2738 return 1;
2739}
int pqCheckOutBufferSpace(size_t bytes_needed, PGconn *conn)
Definition: fe-misc.c:287
int pqPutMsgStart(char msg_type, PGconn *conn)
Definition: fe-misc.c:473
int pqPutnchar(const char *s, size_t len, PGconn *conn)
Definition: fe-misc.c:202
int pqPutMsgEnd(PGconn *conn)
Definition: fe-misc.c:532
#define PqMsg_CopyData
Definition: protocol.h:65
int outBufSize
Definition: libpq-int.h:572
int outCount
Definition: libpq-int.h:573

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

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

◆ PQputCopyEnd()

int PQputCopyEnd ( PGconn conn,
const char *  errormsg 
)

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

2750{
2751 if (!conn)
2752 return -1;
2755 {
2756 libpq_append_conn_error(conn, "no COPY in progress");
2757 return -1;
2758 }
2759
2760 /*
2761 * Send the COPY END indicator. This is simple enough that we don't
2762 * bother delegating it to the fe-protocol files.
2763 */
2764 if (errormsg)
2765 {
2766 /* Send COPY FAIL */
2767 if (pqPutMsgStart(PqMsg_CopyFail, conn) < 0 ||
2768 pqPuts(errormsg, conn) < 0 ||
2769 pqPutMsgEnd(conn) < 0)
2770 return -1;
2771 }
2772 else
2773 {
2774 /* Send COPY DONE */
2775 if (pqPutMsgStart(PqMsg_CopyDone, conn) < 0 ||
2776 pqPutMsgEnd(conn) < 0)
2777 return -1;
2778 }
2779
2780 /*
2781 * If we sent the COPY command in extended-query mode, we must issue a
2782 * Sync as well.
2783 */
2784 if (conn->cmd_queue_head &&
2786 {
2787 if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
2788 pqPutMsgEnd(conn) < 0)
2789 return -1;
2790 }
2791
2792 /* Return to active duty */
2795 else
2797
2798 /* Try to flush data */
2799 if (pqFlush(conn) < 0)
2800 return -1;
2801
2802 return 1;
2803}
int pqPuts(const char *s, PGconn *conn)
Definition: fe-misc.c:152
@ PGQUERY_SIMPLE
Definition: libpq-int.h:328
#define PqMsg_CopyDone
Definition: protocol.h:64
#define PqMsg_Sync
Definition: protocol.h:27
#define PqMsg_CopyFail
Definition: protocol.h:29
PGQueryClass queryclass
Definition: libpq-int.h:353

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

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

◆ PQputline()

int PQputline ( PGconn conn,
const char *  string 
)

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

2919{
2920 return PQputnbytes(conn, string, strlen(string));
2921}
int PQputnbytes(PGconn *conn, const char *buffer, int nbytes)
Definition: fe-exec.c:2928

References conn, and PQputnbytes().

Referenced by initPopulateTable().

◆ PQputnbytes()

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

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

2929{
2930 if (PQputCopyData(conn, buffer, nbytes) > 0)
2931 return 0;
2932 else
2933 return EOF;
2934}
int PQputCopyData(PGconn *conn, const char *buffer, int nbytes)
Definition: fe-exec.c:2695

References conn, and PQputCopyData().

Referenced by PQputline().

◆ PQregisterThreadLock()

pgthreadlock_t PQregisterThreadLock ( pgthreadlock_t  newhandler)

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

8180{
8182
8183 if (newhandler)
8184 pg_g_threadlock = newhandler;
8185 else
8187
8188 return prev;
8189}
static void default_threadlock(int acquire)
Definition: fe-connect.c:8162
pgthreadlock_t pg_g_threadlock
Definition: fe-connect.c:489
void(* pgthreadlock_t)(int acquire)
Definition: libpq-fe.h:468

References default_threadlock(), and pg_g_threadlock.

◆ PQrequestCancel()

int PQrequestCancel ( PGconn conn)

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

662{
663 int r;
664 PGcancel *cancel;
665
666 /* Check we have an open connection */
667 if (!conn)
668 return false;
669
670 if (conn->sock == PGINVALID_SOCKET)
671 {
673 "PQrequestCancel() -- connection is not open\n",
676 conn->errorReported = 0;
677
678 return false;
679 }
680
681 cancel = PQgetCancel(conn);
682 if (cancel)
683 {
684 r = PQcancel(cancel, conn->errorMessage.data,
686 PQfreeCancel(cancel);
687 }
688 else
689 {
690 strlcpy(conn->errorMessage.data, "out of memory",
692 r = false;
693 }
694
695 if (!r)
696 {
698 conn->errorReported = 0;
699 }
700
701 return r;
702}
PGcancel * PQgetCancel(PGconn *conn)
Definition: fe-cancel.c:349
int PQcancel(PGcancel *cancel, char *errbuf, int errbufsize)
Definition: fe-cancel.c:463
void PQfreeCancel(PGcancel *cancel)
Definition: fe-cancel.c:417
int errorReported
Definition: libpq-int.h:672

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

Referenced by test_cancel().

◆ PQreset()

void PQreset ( PGconn conn)

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

5239{
5240 if (conn)
5241 {
5243
5245 {
5246 /*
5247 * Notify event procs of successful reset.
5248 */
5249 int i;
5250
5251 for (i = 0; i < conn->nEvents; i++)
5252 {
5253 PGEventConnReset evt;
5254
5255 evt.conn = conn;
5256 (void) conn->events[i].proc(PGEVT_CONNRESET, &evt,
5258 }
5259 }
5260 }
5261}
@ PGEVT_CONNRESET
Definition: libpq-events.h:30

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

Referenced by CheckConnection().

◆ PQresetPoll()

PostgresPollingStatusType PQresetPoll ( PGconn conn)

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

5291{
5292 if (conn)
5293 {
5295
5296 if (status == PGRES_POLLING_OK)
5297 {
5298 /*
5299 * Notify event procs of successful reset.
5300 */
5301 int i;
5302
5303 for (i = 0; i < conn->nEvents; i++)
5304 {
5305 PGEventConnReset evt;
5306
5307 evt.conn = conn;
5308 (void) conn->events[i].proc(PGEVT_CONNRESET, &evt,
5310 }
5311 }
5312
5313 return status;
5314 }
5315
5316 return PGRES_POLLING_FAILED;
5317}

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

◆ PQresetStart()

int PQresetStart ( PGconn conn)

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

5272{
5273 if (conn)
5274 {
5276
5277 return pqConnectDBStart(conn);
5278 }
5279
5280 return 0;
5281}

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

◆ PQresStatus()

char * PQresStatus ( ExecStatusType  status)

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

3420{
3421 if ((unsigned int) status >= lengthof(pgresStatus))
3422 return libpq_gettext("invalid ExecStatusType code");
3423 return pgresStatus[status];
3424}
char *const pgresStatus[]
Definition: fe-exec.c:32

References lengthof, libpq_gettext, and pgresStatus.

Referenced by BaseBackup(), process_result(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), and try_complete_step().

◆ PQresultAlloc()

void * PQresultAlloc ( PGresult res,
size_t  nBytes 
)

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

544{
545 /* Fail if argument is NULL or OOM_result */
546 if (!res || (const PGresult *) res == &OOM_result)
547 return NULL;
548
549 return pqResultAlloc(res, nBytes, true);
550}
void * pqResultAlloc(PGresult *res, size_t nBytes, bool isBinary)
Definition: fe-exec.c:563

References OOM_result, and pqResultAlloc().

Referenced by PQsetResultAttrs().

◆ PQresultErrorField()

char * PQresultErrorField ( const PGresult res,
int  fieldcode 
)

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

3467{
3468 PGMessageField *pfield;
3469
3470 if (!res)
3471 return NULL;
3472 for (pfield = res->errFields; pfield != NULL; pfield = pfield->next)
3473 {
3474 if (pfield->code == fieldcode)
3475 return pfield->contents;
3476 }
3477 return NULL;
3478}
struct pgMessageField * next
Definition: libpq-int.h:149
char contents[FLEXIBLE_ARRAY_MEMBER]
Definition: libpq-int.h:151

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

Referenced by BaseBackup(), confirm_query_canceled_impl(), CreateReplicationSlot(), dblink_res_error(), ecpg_raise_backend(), ECPGnoticeReceiver(), GetTableInfo(), libpqrcv_exec(), minimal_error_message(), pgfdw_report_error(), pgpassfileWarning(), pqBuildErrorMessage3(), PQconnectPoll(), readCommandResponse(), SetResultVariables(), should_processing_continue(), TableCommandResultHandler(), test_pipeline_abort(), and try_complete_step().

◆ PQresultErrorMessage()

◆ PQresultMemorySize()

size_t PQresultMemorySize ( const PGresult res)

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

664{
665 if (!res)
666 return 0;
667 return res->memorySize;
668}

References pg_result::memorySize.

◆ PQresultStatus()

ExecStatusType PQresultStatus ( const PGresult res)

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

3412{
3413 if (!res)
3414 return PGRES_FATAL_ERROR;
3415 return res->resultStatus;
3416}

References PGRES_FATAL_ERROR, and pg_result::resultStatus.

Referenced by _doSetSessionAuth(), _printTableAccessMethodNoStorage(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), AcceptResult(), advanceConnectionState(), BaseBackup(), check_and_drop_existing_subscriptions(), check_and_drop_publications(), check_loadable_libraries(), check_prepare_conn(), check_publisher(), check_subscriber(), ClearOrSaveResult(), close_cursor(), compile_database_list(), compile_relation_list_one_db(), confirm_query_canceled_impl(), connect_database(), create_cursor(), create_logical_replication_slot(), create_publication(), create_subscription(), CreateReplicationSlot(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), dblink_record_internal(), deallocate_query(), DescribeQuery(), discardAbortedPipelineResults(), discardUntilSync(), do_sql_command_end(), drop_existing_subscriptions(), drop_failover_replication_slots(), drop_publication(), drop_replication_slot(), DropReplicationSlot(), dumpTableData_copy(), ecpg_check_PQresult(), ecpg_is_type_an_array(), ecpg_process_output(), enable_subscription(), EndDBCopyMode(), exec_command_password(), ExecQueryAndProcessResults(), execute_dml_stmt(), execute_foreign_modify(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), fetch_more_data(), generate_object_name(), get_create_object_cmd(), get_primary_sysid(), get_remote_estimate(), get_table_relkind(), GetConnection(), GetSlotInformation(), GetTableInfo(), handleCopyIn(), handleCopyOut(), HandleCopyResult(), HandleEndOfCopyStream(), init_libpq_conn(), initPopulateTable(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_alter_slot(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_PQexec(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_startstreaming(), libpqsrv_get_result_last(), lo_close(), lo_creat(), lo_create(), 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(), pgfdw_exec_cleanup_query_end(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), postgresReScanForeignScan(), PQconnectPoll(), PQencryptPasswordConn(), prepare_foreign_modify(), prepareCommand(), PrintQueryResult(), PrintQueryStatus(), PrintResultInCrosstab(), process_query_result(), process_queued_fetch_requests(), process_result(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), SendQuery(), server_is_in_recovery(), set_replication_progress(), setup_publisher(), should_processing_continue(), sql_conn(), sql_exec(), storeQueryResult(), StreamLogicalLog(), TableCommandResultHandler(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), test_uniqviol(), try_complete_step(), tryExecuteStatement(), vacuumlo(), verify_btree_slot_handler(), verify_heap_slot_handler(), and wait_for_connection_state().

◆ PQresultVerboseErrorMessage()

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

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

3438{
3439 PQExpBufferData workBuf;
3440
3441 /*
3442 * Because the caller is expected to free the result string, we must
3443 * strdup any constant result. We use plain strdup and document that
3444 * callers should expect NULL if out-of-memory.
3445 */
3446 if (!res ||
3449 return strdup(libpq_gettext("PGresult is not an error result\n"));
3450
3451 initPQExpBuffer(&workBuf);
3452
3453 pqBuildErrorMessage3(&workBuf, res, verbosity, show_context);
3454
3455 /* If insufficient memory to format the message, fail cleanly */
3456 if (PQExpBufferDataBroken(workBuf))
3457 {
3458 termPQExpBuffer(&workBuf);
3459 return strdup(libpq_gettext("out of memory\n"));
3460 }
3461
3462 return workBuf.data;
3463}
void pqBuildErrorMessage3(PQExpBuffer msg, const PGresult *res, PGVerbosity verbosity, PGContextVisibility show_context)

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

Referenced by exec_command_errverbose().

◆ PQsendClosePortal()

int PQsendClosePortal ( PGconn conn,
const char *  portal 
)

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

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

References conn, PqMsg_Close, and PQsendTypedCommand().

Referenced by test_prepared().

◆ PQsendClosePrepared()

int PQsendClosePrepared ( PGconn conn,
const char *  stmt 
)

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

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

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

Referenced by ExecQueryAndProcessResults(), and test_prepared().

◆ PQsendDescribePortal()

int PQsendDescribePortal ( PGconn conn,
const char *  portal 
)

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

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

References conn, PqMsg_Describe, and PQsendTypedCommand().

Referenced by test_prepared().

◆ PQsendDescribePrepared()

int PQsendDescribePrepared ( PGconn conn,
const char *  stmt 
)

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

2492{
2494}

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

Referenced by test_prepared().

◆ PQsendFlushRequest()

int PQsendFlushRequest ( PGconn conn)

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

3372{
3373 if (!conn)
3374 return 0;
3375
3376 /* Don't try to send if we know there's no live connection. */
3377 if (conn->status != CONNECTION_OK)
3378 {
3379 libpq_append_conn_error(conn, "no connection to the server");
3380 return 0;
3381 }
3382
3383 /* Can't send while already busy, either, unless enqueuing for later */
3384 if (conn->asyncStatus != PGASYNC_IDLE &&
3386 {
3387 libpq_append_conn_error(conn, "another command is already in progress");
3388 return 0;
3389 }
3390
3391 if (pqPutMsgStart(PqMsg_Flush, conn) < 0 ||
3392 pqPutMsgEnd(conn) < 0)
3393 {
3394 return 0;
3395 }
3396
3397 /*
3398 * Give the data a push (in pipeline mode, only if we're past the size
3399 * threshold). In nonblock mode, don't complain if we're unable to send
3400 * it all; PQgetResult() will do any additional flushing needed.
3401 */
3402 if (pqPipelineFlush(conn) < 0)
3403 return 0;
3404
3405 return 1;
3406}
static int pqPipelineFlush(PGconn *conn)
Definition: fe-exec.c:4016
#define PqMsg_Flush
Definition: protocol.h:24

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

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

◆ PQsendPipelineSync()

int PQsendPipelineSync ( PGconn conn)

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

3283{
3284 return pqPipelineSyncInternal(conn, false);
3285}

References conn, and pqPipelineSyncInternal().

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

◆ PQsendPrepare()

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

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

1539{
1540 PGcmdQueueEntry *entry = NULL;
1541
1542 if (!PQsendQueryStart(conn, true))
1543 return 0;
1544
1545 /* check the arguments */
1546 if (!stmtName)
1547 {
1548 libpq_append_conn_error(conn, "statement name is a null pointer");
1549 return 0;
1550 }
1551 if (!query)
1552 {
1553 libpq_append_conn_error(conn, "command string is a null pointer");
1554 return 0;
1555 }
1556 if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
1557 {
1558 libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
1560 return 0;
1561 }
1562
1563 entry = pqAllocCmdQueueEntry(conn);
1564 if (entry == NULL)
1565 return 0; /* error msg already set */
1566
1567 /* construct the Parse message */
1568 if (pqPutMsgStart(PqMsg_Parse, conn) < 0 ||
1569 pqPuts(stmtName, conn) < 0 ||
1570 pqPuts(query, conn) < 0)
1571 goto sendFailed;
1572
1573 if (nParams > 0 && paramTypes)
1574 {
1575 int i;
1576
1577 if (pqPutInt(nParams, 2, conn) < 0)
1578 goto sendFailed;
1579 for (i = 0; i < nParams; i++)
1580 {
1581 if (pqPutInt(paramTypes[i], 4, conn) < 0)
1582 goto sendFailed;
1583 }
1584 }
1585 else
1586 {
1587 if (pqPutInt(0, 2, conn) < 0)
1588 goto sendFailed;
1589 }
1590 if (pqPutMsgEnd(conn) < 0)
1591 goto sendFailed;
1592
1593 /* Add a Sync, unless in pipeline mode. */
1595 {
1596 if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
1597 pqPutMsgEnd(conn) < 0)
1598 goto sendFailed;
1599 }
1600
1601 /* remember we are doing just a Parse */
1602 entry->queryclass = PGQUERY_PREPARE;
1603
1604 /* and remember the query text too, if possible */
1605 /* if insufficient memory, query just winds up NULL */
1606 entry->query = strdup(query);
1607
1608 /*
1609 * Give the data a push (in pipeline mode, only if we're past the size
1610 * threshold). In nonblock mode, don't complain if we're unable to send
1611 * it all; PQgetResult() will do any additional flushing needed.
1612 */
1613 if (pqPipelineFlush(conn) < 0)
1614 goto sendFailed;
1615
1616 /* OK, it's launched! */
1618
1619 return 1;
1620
1621sendFailed:
1623 /* error message should be set up already */
1624 return 0;
1625}
static PGcmdQueueEntry * pqAllocCmdQueueEntry(PGconn *conn)
Definition: fe-exec.c:1306
static void pqAppendCmdQueueEntry(PGconn *conn, PGcmdQueueEntry *entry)
Definition: fe-exec.c:1339
static bool PQsendQueryStart(PGconn *conn, bool newQuery)
Definition: fe-exec.c:1673
static void pqRecycleCmdQueueEntry(PGconn *conn, PGcmdQueueEntry *entry)
Definition: fe-exec.c:1386
int pqPutInt(int value, size_t bytes, PGconn *conn)
Definition: fe-misc.c:253
#define PQ_QUERY_PARAM_MAX_LIMIT
Definition: libpq-fe.h:507
@ PGQUERY_PREPARE
Definition: libpq-int.h:330
#define PqMsg_Parse
Definition: protocol.h:25

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

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

◆ PQsendQuery()

◆ PQsendQueryParams()

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

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

1500{
1501 if (!PQsendQueryStart(conn, true))
1502 return 0;
1503
1504 /* check the arguments */
1505 if (!command)
1506 {
1507 libpq_append_conn_error(conn, "command string is a null pointer");
1508 return 0;
1509 }
1510 if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
1511 {
1512 libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
1514 return 0;
1515 }
1516
1517 return PQsendQueryGuts(conn,
1518 command,
1519 "", /* use unnamed statement */
1520 nParams,
1521 paramTypes,
1522 paramValues,
1523 paramLengths,
1524 paramFormats,
1525 resultFormat);
1526}
static int PQsendQueryGuts(PGconn *conn, const char *command, const char *stmtName, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
Definition: fe-exec.c:1757

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

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

◆ PQsendQueryPrepared()

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

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

1640{
1641 if (!PQsendQueryStart(conn, true))
1642 return 0;
1643
1644 /* check the arguments */
1645 if (!stmtName)
1646 {
1647 libpq_append_conn_error(conn, "statement name is a null pointer");
1648 return 0;
1649 }
1650 if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
1651 {
1652 libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
1654 return 0;
1655 }
1656
1657 return PQsendQueryGuts(conn,
1658 NULL, /* no command to parse */
1659 stmtName,
1660 nParams,
1661 NULL, /* no param types */
1662 paramValues,
1663 paramLengths,
1664 paramFormats,
1665 resultFormat);
1666}

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

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

◆ PQserverVersion()

◆ PQservice()

char * PQservice ( const PGconn conn)

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

7390{
7391 if (!conn)
7392 return NULL;
7393 return conn->pgservice;
7394}
char * pgservice
Definition: libpq-int.h:399

References conn, and pg_conn::pgservice.

Referenced by get_prompt(), and SyncVariables().

◆ PQsetAuthDataHook()

void PQsetAuthDataHook ( PQauthDataHook_type  hook)

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

1596{
1597 PQauthDataHook = hook ? hook : PQdefaultAuthDataHook;
1598}
int PQdefaultAuthDataHook(PGauthData type, PGconn *conn, void *data)
Definition: fe-auth.c:1601

References PQauthDataHook, and PQdefaultAuthDataHook().

Referenced by main().

◆ PQsetChunkedRowsMode()

int PQsetChunkedRowsMode ( PGconn conn,
int  chunkSize 
)

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

1966{
1967 if (chunkSize > 0 && canChangeResultMode(conn))
1968 {
1969 conn->partialResMode = true;
1970 conn->singleRowMode = false;
1971 conn->maxChunkSize = chunkSize;
1972 return 1;
1973 }
1974 else
1975 return 0;
1976}
static bool canChangeResultMode(PGconn *conn)
Definition: fe-exec.c:1925
int maxChunkSize
Definition: libpq-int.h:474
bool singleRowMode
Definition: libpq-int.h:473
bool partialResMode
Definition: libpq-int.h:472

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

Referenced by ExecQueryAndProcessResults(), and test_singlerowmode().

◆ PQsetClientEncoding()

int PQsetClientEncoding ( PGconn conn,
const char *  encoding 
)

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

7652{
7653 char qbuf[128];
7654 static const char query[] = "set client_encoding to '%s'";
7655 PGresult *res;
7656 int status;
7657
7658 if (!conn || conn->status != CONNECTION_OK)
7659 return -1;
7660
7661 if (!encoding)
7662 return -1;
7663
7664 /* Resolve special "auto" value from the locale */
7665 if (strcmp(encoding, "auto") == 0)
7667
7668 /* check query buffer overflow */
7669 if (sizeof(qbuf) < (sizeof(query) + strlen(encoding)))
7670 return -1;
7671
7672 /* ok, now send a query */
7673 sprintf(qbuf, query, encoding);
7674 res = PQexec(conn, qbuf);
7675
7676 if (res == NULL)
7677 return -1;
7678 if (res->resultStatus != PGRES_COMMAND_OK)
7679 status = -1;
7680 else
7681 {
7682 /*
7683 * We rely on the backend to report the parameter value, and we'll
7684 * change state at that time.
7685 */
7686 status = 0; /* everything is ok */
7687 }
7688 PQclear(res);
7689 return status;
7690}
#define pg_encoding_to_char
Definition: pg_wchar.h:630
int pg_get_encoding_from_locale(const char *ctype, bool write_message)
Definition: chklocale.c:301

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

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

◆ PQsetdbLogin()

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

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

2168{
2169 PGconn *conn;
2170
2171 /*
2172 * Allocate memory for the conn structure. Note that we also expect this
2173 * to initialize conn->errorMessage to empty. All subsequent steps during
2174 * connection initialization will only append to that buffer.
2175 */
2177 if (conn == NULL)
2178 return NULL;
2179
2180 /*
2181 * If the dbName parameter contains what looks like a connection string,
2182 * parse it into conn struct using connectOptions1.
2183 */
2185 {
2187 return conn;
2188 }
2189 else
2190 {
2191 /*
2192 * Old-style path: first, parse an empty conninfo string in order to
2193 * set up the same defaults that PQconnectdb() would use.
2194 */
2195 if (!connectOptions1(conn, ""))
2196 return conn;
2197
2198 /* Insert dbName parameter value into struct */
2199 if (dbName && dbName[0] != '\0')
2200 {
2201 free(conn->dbName);
2202 conn->dbName = strdup(dbName);
2203 if (!conn->dbName)
2204 goto oom_error;
2205 }
2206 }
2207
2208 /*
2209 * Insert remaining parameters into struct, overriding defaults (as well
2210 * as any conflicting data from dbName taken as a conninfo).
2211 */
2212 if (pghost && pghost[0] != '\0')
2213 {
2214 free(conn->pghost);
2215 conn->pghost = strdup(pghost);
2216 if (!conn->pghost)
2217 goto oom_error;
2218 }
2219
2220 if (pgport && pgport[0] != '\0')
2221 {
2222 free(conn->pgport);
2223 conn->pgport = strdup(pgport);
2224 if (!conn->pgport)
2225 goto oom_error;
2226 }
2227
2228 if (pgoptions && pgoptions[0] != '\0')
2229 {
2231 conn->pgoptions = strdup(pgoptions);
2232 if (!conn->pgoptions)
2233 goto oom_error;
2234 }
2235
2236 if (login && login[0] != '\0')
2237 {
2238 free(conn->pguser);
2239 conn->pguser = strdup(login);
2240 if (!conn->pguser)
2241 goto oom_error;
2242 }
2243
2244 if (pwd && pwd[0] != '\0')
2245 {
2246 free(conn->pgpass);
2247 conn->pgpass = strdup(pwd);
2248 if (!conn->pgpass)
2249 goto oom_error;
2250 }
2251
2252 /*
2253 * Compute derived options
2254 */
2255 if (!pqConnectOptions2(conn))
2256 return conn;
2257
2258 /*
2259 * Connect to the database
2260 */
2262 (void) pqConnectDBComplete(conn);
2263
2264 return conn;
2265
2266oom_error:
2268 libpq_append_conn_error(conn, "out of memory");
2269 return conn;
2270}
static bool recognized_connection_string(const char *connstr)
Definition: fe-connect.c:6188
static const char * pghost
Definition: pgbench.c:295
static const char * pgport
Definition: pgbench.c:296
static const char * dbName
Definition: pgbench.c:298
char * pghost
Definition: libpq-int.h:381
char * pguser
Definition: libpq-int.h:400
char * pgport
Definition: libpq-int.h:389

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

◆ PQsetErrorContextVisibility()

PGContextVisibility PQsetErrorContextVisibility ( PGconn conn,
PGContextVisibility  show_context 
)

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

7706{
7708
7709 if (!conn)
7710 return PQSHOW_CONTEXT_ERRORS;
7711 old = conn->show_context;
7712 conn->show_context = show_context;
7713 return old;
7714}
PGContextVisibility show_context
Definition: libpq-int.h:558

References conn, PQSHOW_CONTEXT_ERRORS, and pg_conn::show_context.

Referenced by show_context_hook(), and SyncVariables().

◆ PQsetErrorVerbosity()

PGVerbosity PQsetErrorVerbosity ( PGconn conn,
PGVerbosity  verbosity 
)

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

7694{
7695 PGVerbosity old;
7696
7697 if (!conn)
7698 return PQERRORS_DEFAULT;
7699 old = conn->verbosity;
7700 conn->verbosity = verbosity;
7701 return old;
7702}
PGVerbosity verbosity
Definition: libpq-int.h:557

References conn, PQERRORS_DEFAULT, and pg_conn::verbosity.

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

◆ PQsetnonblocking()

int PQsetnonblocking ( PGconn conn,
int  arg 
)

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

3945{
3946 bool barg;
3947
3948 if (!conn || conn->status == CONNECTION_BAD)
3949 return -1;
3950
3951 barg = (arg ? true : false);
3952
3953 /* early out if the socket is already in the state requested */
3954 if (barg == conn->nonblocking)
3955 return 0;
3956
3957 /*
3958 * to guarantee constancy for flushing/query/result-polling behavior we
3959 * need to flush the send queue at this point in order to guarantee proper
3960 * behavior. this is ok because either they are making a transition _from_
3961 * or _to_ blocking mode, either way we can block them.
3962 *
3963 * Clear error state in case pqFlush adds to it, unless we're actively
3964 * pipelining, in which case it seems best not to.
3965 */
3966 if (conn->cmd_queue_head == NULL)
3968
3969 /* if we are going from blocking to non-blocking flush here */
3970 if (pqFlush(conn))
3971 return -1;
3972
3973 conn->nonblocking = barg;
3974
3975 return 0;
3976}
return true
Definition: isn.c:127
void * arg
bool nonblocking
Definition: libpq-int.h:469

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

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

◆ PQsetNoticeProcessor()

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

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

7735{
7737
7738 if (conn == NULL)
7739 return NULL;
7740
7742 if (proc)
7743 {
7744 conn->noticeHooks.noticeProc = proc;
7746 }
7747 return old;
7748}
void(* PQnoticeProcessor)(void *arg, const char *message)
Definition: libpq-fe.h:241

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

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

◆ PQsetNoticeReceiver()

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

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

7718{
7719 PQnoticeReceiver old;
7720
7721 if (conn == NULL)
7722 return NULL;
7723
7724 old = conn->noticeHooks.noticeRec;
7725 if (proc)
7726 {
7727 conn->noticeHooks.noticeRec = proc;
7729 }
7730 return old;
7731}
void(* PQnoticeReceiver)(void *arg, const PGresult *res)
Definition: libpq-fe.h:240

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

Referenced by ECPGconnect().

◆ PQsetResultAttrs()

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

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

250{
251 int i;
252
253 /* Fail if argument is NULL or OOM_result */
254 if (!res || (const PGresult *) res == &OOM_result)
255 return false;
256
257 /* If attrs already exist, they cannot be overwritten. */
258 if (res->numAttributes > 0)
259 return false;
260
261 /* ignore no-op request */
262 if (numAttributes <= 0 || !attDescs)
263 return true;
264
265 res->attDescs = (PGresAttDesc *)
266 PQresultAlloc(res, numAttributes * sizeof(PGresAttDesc));
267
268 if (!res->attDescs)
269 return false;
270
271 res->numAttributes = numAttributes;
272 memcpy(res->attDescs, attDescs, numAttributes * sizeof(PGresAttDesc));
273
274 /* deep-copy the attribute names, and determine format */
275 res->binary = 1;
276 for (i = 0; i < res->numAttributes; i++)
277 {
278 if (res->attDescs[i].name)
279 res->attDescs[i].name = pqResultStrdup(res, res->attDescs[i].name);
280 else
281 res->attDescs[i].name = res->null_field;
282
283 if (!res->attDescs[i].name)
284 return false;
285
286 if (res->attDescs[i].format == 0)
287 res->binary = 0;
288 }
289
290 return true;
291}
void * PQresultAlloc(PGresult *res, size_t nBytes)
Definition: fe-exec.c:543
char * pqResultStrdup(PGresult *res, const char *str)
Definition: fe-exec.c:675

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

Referenced by PQcopyResult().

◆ PQsetSingleRowMode()

int PQsetSingleRowMode ( PGconn conn)

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

1949{
1951 {
1952 conn->partialResMode = true;
1953 conn->singleRowMode = true;
1954 conn->maxChunkSize = 1;
1955 return 1;
1956 }
1957 else
1958 return 0;
1959}

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

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

◆ PQsetSSLKeyPassHook_OpenSSL()

void PQsetSSLKeyPassHook_OpenSSL ( PQsslKeyPassHook_OpenSSL_type  hook)

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

1867{
1868 PQsslKeyPassHook = hook;
1869}

References PQsslKeyPassHook.

◆ PQsetTraceFlags()

void PQsetTraceFlags ( PGconn conn,
int  flags 
)

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

65{
66 if (conn == NULL)
67 return;
68 /* If PQtrace() failed, do nothing. */
69 if (conn->Pfdebug == NULL)
70 return;
71 conn->traceFlags = flags;
72}
int traceFlags
Definition: libpq-int.h:453

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

Referenced by main().

◆ PQsetvalue()

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

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

453{
454 PGresAttValue *attval;
455 const char *errmsg = NULL;
456
457 /* Fail if argument is NULL or OOM_result */
458 if (!res || (const PGresult *) res == &OOM_result)
459 return false;
460
461 /* Invalid field_num? */
462 if (!check_field_number(res, field_num))
463 return false;
464
465 /* Invalid tup_num, must be <= ntups */
466 if (tup_num < 0 || tup_num > res->ntups)
467 {
469 "row number %d is out of range 0..%d",
470 tup_num, res->ntups);
471 return false;
472 }
473
474 /* need to allocate a new tuple? */
475 if (tup_num == res->ntups)
476 {
477 PGresAttValue *tup;
478 int i;
479
480 tup = (PGresAttValue *)
481 pqResultAlloc(res, res->numAttributes * sizeof(PGresAttValue),
482 true);
483
484 if (!tup)
485 goto fail;
486
487 /* initialize each column to NULL */
488 for (i = 0; i < res->numAttributes; i++)
489 {
490 tup[i].len = NULL_LEN;
491 tup[i].value = res->null_field;
492 }
493
494 /* add it to the array */
495 if (!pqAddTuple(res, tup, &errmsg))
496 goto fail;
497 }
498
499 attval = &res->tuples[tup_num][field_num];
500
501 /* treat either NULL_LEN or NULL value pointer as a NULL field */
502 if (len == NULL_LEN || value == NULL)
503 {
504 attval->len = NULL_LEN;
505 attval->value = res->null_field;
506 }
507 else if (len <= 0)
508 {
509 attval->len = 0;
510 attval->value = res->null_field;
511 }
512 else
513 {
514 attval->value = (char *) pqResultAlloc(res, len + 1, true);
515 if (!attval->value)
516 goto fail;
517 attval->len = len;
518 memcpy(attval->value, value, len);
519 attval->value[len] = '\0';
520 }
521
522 return true;
523
524 /*
525 * Report failure via pqInternalNotice. If preceding code didn't provide
526 * an error message, assume "out of memory" was meant.
527 */
528fail:
529 if (!errmsg)
530 errmsg = libpq_gettext("out of memory");
531 pqInternalNotice(&res->noticeHooks, "%s", errmsg);
532
533 return false;
534}
static bool pqAddTuple(PGresult *res, PGresAttValue *tup, const char **errmsgp)
Definition: fe-exec.c:993
static struct @165 value

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

Referenced by PQcopyResult().

◆ PQsocket()

◆ PQsocketPoll()

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

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

1116{
1117 /* We use poll(2) if available, otherwise select(2) */
1118#ifdef HAVE_POLL
1119 struct pollfd input_fd;
1120 int timeout_ms;
1121
1122 if (!forRead && !forWrite)
1123 return 0;
1124
1125 input_fd.fd = sock;
1126 input_fd.events = POLLERR;
1127 input_fd.revents = 0;
1128
1129 if (forRead)
1130 input_fd.events |= POLLIN;
1131 if (forWrite)
1132 input_fd.events |= POLLOUT;
1133
1134 /* Compute appropriate timeout interval */
1135 if (end_time == -1)
1136 timeout_ms = -1;
1137 else if (end_time == 0)
1138 timeout_ms = 0;
1139 else
1140 {
1142
1143 if (end_time > now)
1144 timeout_ms = (end_time - now) / 1000;
1145 else
1146 timeout_ms = 0;
1147 }
1148
1149 return poll(&input_fd, 1, timeout_ms);
1150#else /* !HAVE_POLL */
1151
1152 fd_set input_mask;
1153 fd_set output_mask;
1154 fd_set except_mask;
1155 struct timeval timeout;
1156 struct timeval *ptr_timeout;
1157
1158 if (!forRead && !forWrite)
1159 return 0;
1160
1161 FD_ZERO(&input_mask);
1162 FD_ZERO(&output_mask);
1163 FD_ZERO(&except_mask);
1164 if (forRead)
1165 FD_SET(sock, &input_mask);
1166
1167 if (forWrite)
1168 FD_SET(sock, &output_mask);
1169 FD_SET(sock, &except_mask);
1170
1171 /* Compute appropriate timeout interval */
1172 if (end_time == -1)
1173 ptr_timeout = NULL;
1174 else if (end_time == 0)
1175 {
1176 timeout.tv_sec = 0;
1177 timeout.tv_usec = 0;
1178 ptr_timeout = &timeout;
1179 }
1180 else
1181 {
1183
1184 if (end_time > now)
1185 {
1186 timeout.tv_sec = (end_time - now) / 1000000;
1187 timeout.tv_usec = (end_time - now) % 1000000;
1188 }
1189 else
1190 {
1191 timeout.tv_sec = 0;
1192 timeout.tv_usec = 0;
1193 }
1194 ptr_timeout = &timeout;
1195 }
1196
1197 return select(sock + 1, &input_mask, &output_mask,
1198 &except_mask, ptr_timeout);
1199#endif /* HAVE_POLL */
1200}
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1608
pg_usec_time_t PQgetCurrentTimeUSec(void)
Definition: fe-misc.c:1209
static int64 end_time
Definition: pgbench.c:176
#define select(n, r, w, e, timeout)
Definition: win32_port.h:503

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

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

◆ PQsslAttribute()

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

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

1610{
1611 if (!conn)
1612 {
1613 /* PQsslAttribute(NULL, "library") reports the default SSL library */
1614 if (strcmp(attribute_name, "library") == 0)
1615 return "OpenSSL";
1616 return NULL;
1617 }
1618
1619 /* All attributes read as NULL for a non-encrypted connection */
1620 if (conn->ssl == NULL)
1621 return NULL;
1622
1623 if (strcmp(attribute_name, "library") == 0)
1624 return "OpenSSL";
1625
1626 if (strcmp(attribute_name, "key_bits") == 0)
1627 {
1628 static char sslbits_str[12];
1629 int sslbits;
1630
1631 SSL_get_cipher_bits(conn->ssl, &sslbits);
1632 snprintf(sslbits_str, sizeof(sslbits_str), "%d", sslbits);
1633 return sslbits_str;
1634 }
1635
1636 if (strcmp(attribute_name, "cipher") == 0)
1637 return SSL_get_cipher(conn->ssl);
1638
1639 if (strcmp(attribute_name, "compression") == 0)
1640 return SSL_get_current_compression(conn->ssl) ? "on" : "off";
1641
1642 if (strcmp(attribute_name, "protocol") == 0)
1643 return SSL_get_version(conn->ssl);
1644
1645 if (strcmp(attribute_name, "alpn") == 0)
1646 {
1647 const unsigned char *data;
1648 unsigned int len;
1649 static char alpn_str[256]; /* alpn doesn't support longer than 255
1650 * bytes */
1651
1652 SSL_get0_alpn_selected(conn->ssl, &data, &len);
1653 if (data == NULL || len == 0 || len > sizeof(alpn_str) - 1)
1654 return "";
1655 memcpy(alpn_str, data, len);
1656 alpn_str[len] = 0;
1657 return alpn_str;
1658 }
1659
1660 return NULL; /* unknown attribute */
1661}
const void * data

References conn, data, len, and snprintf.

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

◆ PQsslAttributeNames()

const char *const * PQsslAttributeNames ( PGconn conn)

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

1583{
1584 static const char *const openssl_attrs[] = {
1585 "library",
1586 "key_bits",
1587 "cipher",
1588 "compression",
1589 "protocol",
1590 "alpn",
1591 NULL
1592 };
1593 static const char *const empty_attrs[] = {NULL};
1594
1595 if (!conn)
1596 {
1597 /* Return attributes of default SSL library */
1598 return openssl_attrs;
1599 }
1600
1601 /* No attrs for unencrypted connection */
1602 if (conn->ssl == NULL)
1603 return empty_attrs;
1604
1605 return openssl_attrs;
1606}

References conn.

◆ PQsslInUse()

int PQsslInUse ( PGconn conn)

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

104{
105 if (!conn)
106 return 0;
107 return conn->ssl_in_use;
108}

References conn, and pg_conn::ssl_in_use.

Referenced by exec_command_conninfo(), and printSSLInfo().

◆ PQsslStruct()

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

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

1573{
1574 if (!conn)
1575 return NULL;
1576 if (strcmp(struct_name, "OpenSSL") == 0)
1577 return conn->ssl;
1578 return NULL;
1579}

References conn.

◆ PQstatus()

◆ PQtrace()

void PQtrace ( PGconn conn,
FILE *  debug_port 
)

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

36{
37 if (conn == NULL)
38 return;
40 if (debug_port == NULL)
41 return;
42
43 conn->Pfdebug = debug_port;
44 conn->traceFlags = 0;
45}
void PQuntrace(PGconn *conn)
Definition: fe-trace.c:49

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

Referenced by main().

◆ PQtransactionStatus()

◆ PQtty()

char * PQtty ( const PGconn conn)

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

7475{
7476 if (!conn)
7477 return NULL;
7478 return "";
7479}

References conn.

◆ PQunescapeBytea()

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

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

4554{
4555 size_t strtextlen,
4556 buflen;
4557 unsigned char *buffer,
4558 *tmpbuf;
4559 size_t i,
4560 j;
4561
4562 if (strtext == NULL)
4563 return NULL;
4564
4565 strtextlen = strlen((const char *) strtext);
4566
4567 if (strtext[0] == '\\' && strtext[1] == 'x')
4568 {
4569 const unsigned char *s;
4570 unsigned char *p;
4571
4572 buflen = (strtextlen - 2) / 2;
4573 /* Avoid unportable malloc(0) */
4574 buffer = (unsigned char *) malloc(buflen > 0 ? buflen : 1);
4575 if (buffer == NULL)
4576 return NULL;
4577
4578 s = strtext + 2;
4579 p = buffer;
4580 while (*s)
4581 {
4582 char v1,
4583 v2;
4584
4585 /*
4586 * Bad input is silently ignored. Note that this includes
4587 * whitespace between hex pairs, which is allowed by byteain.
4588 */
4589 v1 = get_hex(*s++);
4590 if (!*s || v1 == (char) -1)
4591 continue;
4592 v2 = get_hex(*s++);
4593 if (v2 != (char) -1)
4594 *p++ = (v1 << 4) | v2;
4595 }
4596
4597 buflen = p - buffer;
4598 }
4599 else
4600 {
4601 /*
4602 * Length of input is max length of output, but add one to avoid
4603 * unportable malloc(0) if input is zero-length.
4604 */
4605 buffer = (unsigned char *) malloc(strtextlen + 1);
4606 if (buffer == NULL)
4607 return NULL;
4608
4609 for (i = j = 0; i < strtextlen;)
4610 {
4611 switch (strtext[i])
4612 {
4613 case '\\':
4614 i++;
4615 if (strtext[i] == '\\')
4616 buffer[j++] = strtext[i++];
4617 else
4618 {
4619 if ((ISFIRSTOCTDIGIT(strtext[i])) &&
4620 (ISOCTDIGIT(strtext[i + 1])) &&
4621 (ISOCTDIGIT(strtext[i + 2])))
4622 {
4623 int byte;
4624
4625 byte = OCTVAL(strtext[i++]);
4626 byte = (byte << 3) + OCTVAL(strtext[i++]);
4627 byte = (byte << 3) + OCTVAL(strtext[i++]);
4628 buffer[j++] = byte;
4629 }
4630 }
4631
4632 /*
4633 * Note: if we see '\' followed by something that isn't a
4634 * recognized escape sequence, we loop around having done
4635 * nothing except advance i. Therefore the something will
4636 * be emitted as ordinary data on the next cycle. Corner
4637 * case: '\' at end of string will just be discarded.
4638 */
4639 break;
4640
4641 default:
4642 buffer[j++] = strtext[i++];
4643 break;
4644 }
4645 }
4646 buflen = j; /* buflen is the length of the dequoted data */
4647 }
4648
4649 /* Shrink the buffer to be no larger than necessary */
4650 /* +1 avoids unportable behavior when buflen==0 */
4651 tmpbuf = realloc(buffer, buflen + 1);
4652
4653 /* It would only be a very brain-dead realloc that could fail, but... */
4654 if (!tmpbuf)
4655 {
4656 free(buffer);
4657 return NULL;
4658 }
4659
4660 *retbuflen = buflen;
4661 return tmpbuf;
4662}
static char get_hex(char c)
Definition: fe-exec.c:4389
#define ISOCTDIGIT(CH)
Definition: fe-exec.c:4537
#define OCTVAL(CH)
Definition: fe-exec.c:4538
#define ISFIRSTOCTDIGIT(CH)
Definition: fe-exec.c:4536
#define realloc(a, b)
Definition: header.h:60
static StringInfoData tmpbuf
Definition: walsender.c:171

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

◆ PQuntrace()

void PQuntrace ( PGconn conn)

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

50{
51 if (conn == NULL)
52 return;
53 if (conn->Pfdebug)
54 {
55 fflush(conn->Pfdebug);
56 conn->Pfdebug = NULL;
57 }
58
59 conn->traceFlags = 0;
60}

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

Referenced by PQtrace().

◆ PQuser()

char * PQuser ( const PGconn conn)

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

7398{
7399 if (!conn)
7400 return NULL;
7401 return conn->pguser;
7402}

References conn, and pg_conn::pguser.

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