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
 

Macros

#define PG_COPYRES_ATTRS   0x01
 
#define PG_COPYRES_TUPLES   0x02 /* Implies PG_COPYRES_ATTRS */
 
#define PG_COPYRES_EVENTS   0x04
 
#define PG_COPYRES_NOTICEHOOKS   0x08
 
#define PQsetdb(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME)   PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, NULL, NULL)
 
#define PQfreeNotify(ptr)   PQfreemem(ptr)
 
#define PQnoPasswordSupplied   "fe_sendauth: no password supplied\n"
 

Typedefs

typedef struct pg_conn PGconn
 
typedef struct pg_result PGresult
 
typedef struct pg_cancel PGcancel
 
typedef struct pgNotify PGnotify
 
typedef void(* PQnoticeReceiver) (void *arg, const PGresult *res)
 
typedef void(* PQnoticeProcessor) (void *arg, const char *message)
 
typedef char pqbool
 
typedef struct _PQprintOpt PQprintOpt
 
typedef struct _PQconninfoOption PQconninfoOption
 
typedef struct pgresAttDesc PGresAttDesc
 
typedef void(* pgthreadlock_t) (int acquire)
 

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
}
 
enum  PostgresPollingStatusType {
  PGRES_POLLING_FAILED = 0, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PGRES_POLLING_OK,
  PGRES_POLLING_ACTIVE
}
 
enum  ExecStatusType {
  PGRES_EMPTY_QUERY = 0, PGRES_COMMAND_OK, PGRES_TUPLES_OK, PGRES_COPY_OUT,
  PGRES_COPY_IN, PGRES_BAD_RESPONSE, PGRES_NONFATAL_ERROR, PGRES_FATAL_ERROR,
  PGRES_COPY_BOTH, PGRES_SINGLE_TUPLE
}
 
enum  PGTransactionStatusType {
  PQTRANS_IDLE, PQTRANS_ACTIVE, PQTRANS_INTRANS, PQTRANS_INERROR,
  PQTRANS_UNKNOWN
}
 
enum  PGVerbosity { PQERRORS_TERSE, PQERRORS_DEFAULT, PQERRORS_VERBOSE }
 
enum  PGContextVisibility { PQSHOW_CONTEXT_NEVER, PQSHOW_CONTEXT_ERRORS, PQSHOW_CONTEXT_ALWAYS }
 
enum  PGPing { PQPING_OK, PQPING_REJECT, PQPING_NO_RESPONSE, PQPING_NO_ATTEMPT }
 

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)
 
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 * PQuser (const PGconn *conn)
 
char * PQpass (const PGconn *conn)
 
char * PQhost (const PGconn *conn)
 
char * PQport (const PGconn *conn)
 
char * PQtty (const PGconn *conn)
 
char * PQoptions (const PGconn *conn)
 
ConnStatusType PQstatus (const PGconn *conn)
 
PGTransactionStatusType PQtransactionStatus (const PGconn *conn)
 
const char * PQparameterStatus (const PGconn *conn, const char *paramName)
 
int PQprotocolVersion (const PGconn *conn)
 
int PQserverVersion (const PGconn *conn)
 
char * PQerrorMessage (const PGconn *conn)
 
int PQsocket (const PGconn *conn)
 
int PQbackendPID (const PGconn *conn)
 
int PQconnectionNeedsPassword (const PGconn *conn)
 
int PQconnectionUsedPassword (const PGconn *conn)
 
int PQclientEncoding (const PGconn *conn)
 
int PQsetClientEncoding (PGconn *conn, const char *encoding)
 
int PQsslInUse (PGconn *conn)
 
void * PQsslStruct (PGconn *conn, const char *struct_name)
 
const char * PQsslAttribute (PGconn *conn, const char *attribute_name)
 
const char *const * PQsslAttributeNames (PGconn *conn)
 
void * PQgetssl (PGconn *conn)
 
void PQinitSSL (int do_init)
 
void PQinitOpenSSL (int do_ssl, int do_crypto)
 
PGVerbosity PQsetErrorVerbosity (PGconn *conn, PGVerbosity verbosity)
 
PGContextVisibility PQsetErrorContextVisibility (PGconn *conn, PGContextVisibility show_context)
 
void PQtrace (PGconn *conn, FILE *debug_port)
 
void PQuntrace (PGconn *conn)
 
PQnoticeReceiver PQsetNoticeReceiver (PGconn *conn, PQnoticeReceiver proc, void *arg)
 
PQnoticeProcessor PQsetNoticeProcessor (PGconn *conn, PQnoticeProcessor proc, void *arg)
 
pgthreadlock_t PQregisterThreadLock (pgthreadlock_t newhandler)
 
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)
 
PGresultPQgetResult (PGconn *conn)
 
int PQisBusy (PGconn *conn)
 
int PQconsumeInput (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 *string, int length)
 
int PQputline (PGconn *conn, const char *string)
 
int PQgetlineAsync (PGconn *conn, char *buffer, int bufsize)
 
int PQputnbytes (PGconn *conn, const char *buffer, int nbytes)
 
int PQendcopy (PGconn *conn)
 
int PQsetnonblocking (PGconn *conn, int arg)
 
int PQisnonblocking (const PGconn *conn)
 
int PQisthreadsafe (void)
 
PGPing PQping (const char *conninfo)
 
PGPing PQpingParams (const char *const *keywords, const char *const *values, int expand_dbname)
 
int PQflush (PGconn *conn)
 
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)
 
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)
 
int PQsetvalue (PGresult *res, int tup_num, int field_num, char *value, int len)
 
size_t PQescapeStringConn (PGconn *conn, char *to, const char *from, size_t length, int *error)
 
char * PQescapeLiteral (PGconn *conn, const char *str, size_t len)
 
char * PQescapeIdentifier (PGconn *conn, const char *str, size_t len)
 
unsigned char * PQescapeByteaConn (PGconn *conn, const unsigned char *from, size_t from_length, size_t *to_length)
 
unsigned char * PQunescapeBytea (const unsigned char *strtext, size_t *retbuflen)
 
size_t PQescapeString (char *to, const char *from, size_t length)
 
unsigned char * PQescapeBytea (const unsigned char *from, size_t from_length, size_t *to_length)
 
void PQprint (FILE *fout, const PGresult *res, const PQprintOpt *ps)
 
void PQdisplayTuples (const PGresult *res, FILE *fp, int fillAlign, const char *fieldSep, int printHeader, int quiet)
 
void PQprintTuples (const PGresult *res, FILE *fout, int printAttName, int terseOutput, int width)
 
int lo_open (PGconn *conn, Oid lobjId, int mode)
 
int lo_close (PGconn *conn, int fd)
 
int lo_read (PGconn *conn, int fd, char *buf, size_t len)
 
int lo_write (PGconn *conn, int fd, const char *buf, size_t len)
 
int lo_lseek (PGconn *conn, int fd, int offset, int whence)
 
pg_int64 lo_lseek64 (PGconn *conn, int fd, pg_int64 offset, int whence)
 
Oid lo_creat (PGconn *conn, int mode)
 
Oid lo_create (PGconn *conn, Oid lobjId)
 
int lo_tell (PGconn *conn, int fd)
 
pg_int64 lo_tell64 (PGconn *conn, int fd)
 
int lo_truncate (PGconn *conn, int fd, size_t len)
 
int lo_truncate64 (PGconn *conn, int fd, pg_int64 len)
 
int lo_unlink (PGconn *conn, Oid lobjId)
 
Oid lo_import (PGconn *conn, const char *filename)
 
Oid lo_import_with_oid (PGconn *conn, const char *filename, Oid lobjId)
 
int lo_export (PGconn *conn, Oid lobjId, const char *filename)
 
int PQlibVersion (void)
 
int PQmblen (const char *s, int encoding)
 
int PQdsplen (const char *s, int encoding)
 
int PQenv2encoding (void)
 
char * PQencryptPassword (const char *passwd, const char *user)
 
char * PQencryptPasswordConn (PGconn *conn, const char *passwd, const char *user, const char *algorithm)
 
int pg_char_to_encoding (const char *name)
 
const char * pg_encoding_to_char (int encoding)
 
int pg_valid_server_encoding_id (int encoding)
 

Macro Definition Documentation

◆ PG_COPYRES_ATTRS

#define PG_COPYRES_ATTRS   0x01

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

Referenced by PQcopyResult(), and pqRowProcessor().

◆ PG_COPYRES_EVENTS

#define PG_COPYRES_EVENTS   0x04

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

Referenced by PQcopyResult(), and pqRowProcessor().

◆ PG_COPYRES_NOTICEHOOKS

#define PG_COPYRES_NOTICEHOOKS   0x08

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

Referenced by PQcopyResult(), and pqRowProcessor().

◆ PG_COPYRES_TUPLES

#define PG_COPYRES_TUPLES   0x02 /* Implies PG_COPYRES_ATTRS */

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

Referenced by PQcopyResult().

◆ PQfreeNotify

#define PQfreeNotify (   ptr)    PQfreemem(ptr)

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

◆ PQnoPasswordSupplied

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

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

Referenced by pg_fe_sendauth(), and pg_SASL_init().

◆ PQsetdb

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

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

Referenced by main().

Typedef Documentation

◆ PGcancel

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

◆ PGconn

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

◆ PGnotify

◆ PGresAttDesc

◆ PGresult

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

◆ pgthreadlock_t

typedef void(* pgthreadlock_t) (int acquire)

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

◆ pqbool

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

◆ PQconninfoOption

◆ PQnoticeProcessor

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

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

◆ PQnoticeReceiver

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

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

◆ PQprintOpt

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 

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

48 {
51  /* Non-blocking mode only below here */
52 
53  /*
54  * The existence of these should never be relied upon - they should only
55  * be used for user feedback or similar purposes.
56  */
57  CONNECTION_STARTED, /* Waiting for connection to be made. */
58  CONNECTION_MADE, /* Connection OK; waiting to send. */
59  CONNECTION_AWAITING_RESPONSE, /* Waiting for a response from the
60  * postmaster. */
61  CONNECTION_AUTH_OK, /* Received authentication; waiting for
62  * backend startup. */
63  CONNECTION_SETENV, /* Negotiating environment. */
64  CONNECTION_SSL_STARTUP, /* Negotiating SSL. */
65  CONNECTION_NEEDED, /* Internal state: connect() needed */
66  CONNECTION_CHECK_WRITABLE, /* Check if we could make a writable
67  * connection. */
68  CONNECTION_CONSUME /* Wait for any pending message and consume
69  * them. */
ConnStatusType
Definition: libpq-fe.h:47

◆ ExecStatusType

Enumerator
PGRES_EMPTY_QUERY 
PGRES_COMMAND_OK 
PGRES_TUPLES_OK 
PGRES_COPY_OUT 
PGRES_COPY_IN 
PGRES_BAD_RESPONSE 
PGRES_NONFATAL_ERROR 
PGRES_FATAL_ERROR 
PGRES_COPY_BOTH 
PGRES_SINGLE_TUPLE 

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

83 {
84  PGRES_EMPTY_QUERY = 0, /* empty query string was executed */
85  PGRES_COMMAND_OK, /* a query command that doesn't return
86  * anything was executed properly by the
87  * backend */
88  PGRES_TUPLES_OK, /* a query command that returns tuples was
89  * executed properly by the backend, PGresult
90  * contains the result tuples */
91  PGRES_COPY_OUT, /* Copy Out data transfer in progress */
92  PGRES_COPY_IN, /* Copy In data transfer in progress */
93  PGRES_BAD_RESPONSE, /* an unexpected response was recv'd from the
94  * backend */
95  PGRES_NONFATAL_ERROR, /* notice or warning message */
96  PGRES_FATAL_ERROR, /* query failed */
97  PGRES_COPY_BOTH, /* Copy In/Out data transfer in progress */
98  PGRES_SINGLE_TUPLE /* single tuple from larger resultset */
ExecStatusType
Definition: libpq-fe.h:82

◆ PGContextVisibility

Enumerator
PQSHOW_CONTEXT_NEVER 
PQSHOW_CONTEXT_ERRORS 
PQSHOW_CONTEXT_ALWAYS 

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

118 {
119  PQSHOW_CONTEXT_NEVER, /* never show CONTEXT field */
120  PQSHOW_CONTEXT_ERRORS, /* show CONTEXT for errors only (default) */
121  PQSHOW_CONTEXT_ALWAYS /* always show CONTEXT field */
PGContextVisibility
Definition: libpq-fe.h:117

◆ PGPing

enum PGPing
Enumerator
PQPING_OK 
PQPING_REJECT 
PQPING_NO_RESPONSE 
PQPING_NO_ATTEMPT 

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

130 {
131  PQPING_OK, /* server is accepting connections */
132  PQPING_REJECT, /* server is alive but rejecting connections */
133  PQPING_NO_RESPONSE, /* could not establish connection */
134  PQPING_NO_ATTEMPT /* connection not attempted (bad params) */
135 } PGPing;
PGPing
Definition: libpq-fe.h:129

◆ PGTransactionStatusType

Enumerator
PQTRANS_IDLE 
PQTRANS_ACTIVE 
PQTRANS_INTRANS 
PQTRANS_INERROR 
PQTRANS_UNKNOWN 

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

102 {
103  PQTRANS_IDLE, /* connection idle */
104  PQTRANS_ACTIVE, /* command in progress */
105  PQTRANS_INTRANS, /* idle, within transaction block */
106  PQTRANS_INERROR, /* idle, within failed transaction */
107  PQTRANS_UNKNOWN /* cannot determine status */
PGTransactionStatusType
Definition: libpq-fe.h:101

◆ PGVerbosity

Enumerator
PQERRORS_TERSE 
PQERRORS_DEFAULT 
PQERRORS_VERBOSE 

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

111 {
112  PQERRORS_TERSE, /* single-line error messages */
113  PQERRORS_DEFAULT, /* recommended style */
114  PQERRORS_VERBOSE /* all the facts, ma'am */
115 } PGVerbosity;
PGVerbosity
Definition: libpq-fe.h:110

◆ PostgresPollingStatusType

Enumerator
PGRES_POLLING_FAILED 
PGRES_POLLING_READING 
PGRES_POLLING_WRITING 
PGRES_POLLING_OK 
PGRES_POLLING_ACTIVE 

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

73 {
75  PGRES_POLLING_READING, /* These two indicate that one may */
76  PGRES_POLLING_WRITING, /* use select before polling again. */
78  PGRES_POLLING_ACTIVE /* unused; keep for awhile for backwards
79  * compatibility */
PostgresPollingStatusType
Definition: libpq-fe.h:72

Function Documentation

◆ lo_close()

int lo_close ( PGconn conn,
int  fd 
)

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

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

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

100 {
101  PQArgBlock argv[1];
102  PGresult *res;
103  int retval;
104  int result_len;
105 
106  if (conn == NULL || conn->lobjfuncs == NULL)
107  {
108  if (lo_initialize(conn) < 0)
109  return -1;
110  }
111 
112  argv[0].isint = 1;
113  argv[0].len = 4;
114  argv[0].u.integer = fd;
115  res = PQfn(conn, conn->lobjfuncs->fn_lo_close,
116  &retval, &result_len, 1, argv, 1);
117  if (PQresultStatus(res) == PGRES_COMMAND_OK)
118  {
119  PQclear(res);
120  return retval;
121  }
122  else
123  {
124  PQclear(res);
125  return -1;
126  }
127 }
union PQArgBlock::@139 u
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
void PQclear(PGresult *res)
Definition: fe-exec.c:671
Oid fn_lo_close
Definition: libpq-int.h:268
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_creat()

Oid lo_creat ( PGconn conn,
int  mode 
)

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

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

Referenced by importFile(), and lo_import_internal().

466 {
467  PQArgBlock argv[1];
468  PGresult *res;
469  int retval;
470  int result_len;
471 
472  if (conn == NULL || conn->lobjfuncs == NULL)
473  {
474  if (lo_initialize(conn) < 0)
475  return InvalidOid;
476  }
477 
478  argv[0].isint = 1;
479  argv[0].len = 4;
480  argv[0].u.integer = mode;
481  res = PQfn(conn, conn->lobjfuncs->fn_lo_creat,
482  &retval, &result_len, 1, argv, 1);
483  if (PQresultStatus(res) == PGRES_COMMAND_OK)
484  {
485  PQclear(res);
486  return (Oid) retval;
487  }
488  else
489  {
490  PQclear(res);
491  return InvalidOid;
492  }
493 }
union PQArgBlock::@139 u
unsigned int Oid
Definition: postgres_ext.h:31
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:2607
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
#define InvalidOid
Definition: postgres_ext.h:36
void PQclear(PGresult *res)
Definition: fe-exec.c:671
Oid fn_lo_creat
Definition: libpq-int.h:269
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_create()

Oid lo_create ( PGconn conn,
Oid  lobjId 
)

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

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

Referenced by lo_import_internal(), and StartRestoreBlob().

505 {
506  PQArgBlock argv[1];
507  PGresult *res;
508  int retval;
509  int result_len;
510 
511  if (conn == NULL || conn->lobjfuncs == NULL)
512  {
513  if (lo_initialize(conn) < 0)
514  return InvalidOid;
515  }
516 
517  /* Must check this on-the-fly because it's not there pre-8.1 */
518  if (conn->lobjfuncs->fn_lo_create == 0)
519  {
521  libpq_gettext("cannot determine OID of function lo_create\n"));
522  return InvalidOid;
523  }
524 
525  argv[0].isint = 1;
526  argv[0].len = 4;
527  argv[0].u.integer = lobjId;
528  res = PQfn(conn, conn->lobjfuncs->fn_lo_create,
529  &retval, &result_len, 1, argv, 1);
530  if (PQresultStatus(res) == PGRES_COMMAND_OK)
531  {
532  PQclear(res);
533  return (Oid) retval;
534  }
535  else
536  {
537  PQclear(res);
538  return InvalidOid;
539  }
540 }
union PQArgBlock::@139 u
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
Oid fn_lo_create
Definition: libpq-int.h:270
unsigned int Oid
Definition: postgres_ext.h:31
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:2607
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
PQExpBufferData errorMessage
Definition: libpq-int.h:493
#define InvalidOid
Definition: postgres_ext.h:36
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
#define libpq_gettext(x)
Definition: libpq-int.h:685
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_export()

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

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

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

Referenced by do_lo_export(), and main().

785 {
786  int result = 1;
787  int fd;
788  int nbytes,
789  tmp;
790  char buf[LO_BUFSIZE];
791  int lobj;
792  char sebuf[256];
793 
794  /*
795  * open the large object.
796  */
797  lobj = lo_open(conn, lobjId, INV_READ);
798  if (lobj == -1)
799  {
800  /* we assume lo_open() already set a suitable error message */
801  return -1;
802  }
803 
804  /*
805  * create the file to be written to
806  */
807  fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, 0666);
808  if (fd < 0)
809  {
810  /* We must do lo_close before setting the errorMessage */
811  int save_errno = errno;
812 
813  (void) lo_close(conn, lobj);
815  libpq_gettext("could not open file \"%s\": %s\n"),
816  filename,
817  pqStrerror(save_errno, sebuf, sizeof(sebuf)));
818  return -1;
819  }
820 
821  /*
822  * read in from the large object and write to the file
823  */
824  while ((nbytes = lo_read(conn, lobj, buf, LO_BUFSIZE)) > 0)
825  {
826  tmp = write(fd, buf, nbytes);
827  if (tmp != nbytes)
828  {
829  /* We must do lo_close before setting the errorMessage */
830  int save_errno = errno;
831 
832  (void) lo_close(conn, lobj);
833  (void) close(fd);
835  libpq_gettext("could not write to file \"%s\": %s\n"),
836  filename,
837  pqStrerror(save_errno, sebuf, sizeof(sebuf)));
838  return -1;
839  }
840  }
841 
842  /*
843  * If lo_read() failed, we are now in an aborted transaction so there's no
844  * need for lo_close(); furthermore, if we tried it we'd overwrite the
845  * useful error result with a useless one. So skip lo_close() if we got a
846  * failure result.
847  */
848  if (nbytes < 0 ||
849  lo_close(conn, lobj) != 0)
850  {
851  /* assume lo_read() or lo_close() left a suitable error message */
852  result = -1;
853  }
854 
855  /* if we already failed, don't overwrite that msg with a close error */
856  if (close(fd) && result >= 0)
857  {
859  libpq_gettext("could not write to file \"%s\": %s\n"),
860  filename, pqStrerror(errno, sebuf, sizeof(sebuf)));
861  result = -1;
862  }
863 
864  return result;
865 }
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
#define write(a, b, c)
Definition: win32.h:14
char * pqStrerror(int errnum, char *strerrbuf, size_t buflen)
Definition: thread.c:61
static int fd(const char *x, int i)
Definition: preproc-init.c:105
#define PG_BINARY
Definition: c.h:1025
#define INV_READ
Definition: libpq-fs.h:22
int lo_close(PGconn *conn, int fd)
Definition: fe-lobj.c:99
static char * buf
Definition: pg_test_fsync.c:67
int lo_open(PGconn *conn, Oid lobjId, int mode)
Definition: fe-lobj.c:57
PQExpBufferData errorMessage
Definition: libpq-int.h:493
#define LO_BUFSIZE
Definition: fe-lobj.c:42
static char * filename
Definition: pg_dumpall.c:90
int lo_read(PGconn *conn, int fd, char *buf, size_t len)
Definition: fe-lobj.c:258
#define close(a)
Definition: win32.h:12
#define libpq_gettext(x)
Definition: libpq-int.h:685

◆ lo_import()

Oid lo_import ( PGconn conn,
const char *  filename 
)

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

References InvalidOid, and lo_import_internal().

Referenced by do_lo_import(), and main().

669 {
670  return lo_import_internal(conn, filename, InvalidOid);
671 }
static Oid lo_import_internal(PGconn *conn, const char *filename, Oid oid)
Definition: fe-lobj.c:689
#define InvalidOid
Definition: postgres_ext.h:36
static char * filename
Definition: pg_dumpall.c:90

◆ lo_import_with_oid()

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

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

References lo_import_internal().

684 {
685  return lo_import_internal(conn, filename, lobjId);
686 }
static Oid lo_import_internal(PGconn *conn, const char *filename, Oid oid)
Definition: fe-lobj.c:689
static char * filename
Definition: pg_dumpall.c:90

◆ lo_lseek()

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

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

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

Referenced by overwrite(), and pickout().

366 {
367  PQArgBlock argv[3];
368  PGresult *res;
369  int retval;
370  int result_len;
371 
372  if (conn == NULL || conn->lobjfuncs == NULL)
373  {
374  if (lo_initialize(conn) < 0)
375  return -1;
376  }
377 
378  argv[0].isint = 1;
379  argv[0].len = 4;
380  argv[0].u.integer = fd;
381 
382  argv[1].isint = 1;
383  argv[1].len = 4;
384  argv[1].u.integer = offset;
385 
386  argv[2].isint = 1;
387  argv[2].len = 4;
388  argv[2].u.integer = whence;
389 
390  res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek,
391  &retval, &result_len, 1, argv, 3);
392  if (PQresultStatus(res) == PGRES_COMMAND_OK)
393  {
394  PQclear(res);
395  return retval;
396  }
397  else
398  {
399  PQclear(res);
400  return -1;
401  }
402 }
union PQArgBlock::@139 u
Oid fn_lo_lseek
Definition: libpq-int.h:272
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_lseek64()

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

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

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

Referenced by overwrite(), and pickout().

410 {
411  PQArgBlock argv[3];
412  PGresult *res;
413  pg_int64 retval;
414  int result_len;
415 
416  if (conn == NULL || conn->lobjfuncs == NULL)
417  {
418  if (lo_initialize(conn) < 0)
419  return -1;
420  }
421 
422  if (conn->lobjfuncs->fn_lo_lseek64 == 0)
423  {
425  libpq_gettext("cannot determine OID of function lo_lseek64\n"));
426  return -1;
427  }
428 
429  argv[0].isint = 1;
430  argv[0].len = 4;
431  argv[0].u.integer = fd;
432 
433  offset = lo_hton64(offset);
434  argv[1].isint = 0;
435  argv[1].len = 8;
436  argv[1].u.ptr = (int *) &offset;
437 
438  argv[2].isint = 1;
439  argv[2].len = 4;
440  argv[2].u.integer = whence;
441 
442  res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek64,
443  (void *) &retval, &result_len, 0, argv, 3);
444  if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
445  {
446  PQclear(res);
447  return lo_ntoh64(retval);
448  }
449  else
450  {
451  PQclear(res);
452  return -1;
453  }
454 }
union PQArgBlock::@139 u
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
PG_INT64_TYPE pg_int64
Definition: postgres_ext.h:47
static pg_int64 lo_hton64(pg_int64 host64)
Definition: fe-lobj.c:1061
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
Oid fn_lo_lseek64
Definition: libpq-int.h:273
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int * ptr
Definition: libpq-fe.h:226
#define libpq_gettext(x)
Definition: libpq-int.h:685
int integer
Definition: libpq-fe.h:227
static pg_int64 lo_ntoh64(pg_int64 net64)
Definition: fe-lobj.c:1086
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_open()

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

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

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

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

58 {
59  int fd;
60  int result_len;
61  PQArgBlock argv[2];
62  PGresult *res;
63 
64  if (conn == NULL || conn->lobjfuncs == NULL)
65  {
66  if (lo_initialize(conn) < 0)
67  return -1;
68  }
69 
70  argv[0].isint = 1;
71  argv[0].len = 4;
72  argv[0].u.integer = lobjId;
73 
74  argv[1].isint = 1;
75  argv[1].len = 4;
76  argv[1].u.integer = mode;
77 
78  res = PQfn(conn, conn->lobjfuncs->fn_lo_open, &fd, &result_len, 1, argv, 2);
79  if (PQresultStatus(res) == PGRES_COMMAND_OK)
80  {
81  PQclear(res);
82  return fd;
83  }
84  else
85  {
86  PQclear(res);
87  return -1;
88  }
89 }
union PQArgBlock::@139 u
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
Oid fn_lo_open
Definition: libpq-int.h:267
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_read()

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

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

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

Referenced by lo_export().

259 {
260  PQArgBlock argv[2];
261  PGresult *res;
262  int result_len;
263 
264  if (conn == NULL || conn->lobjfuncs == NULL)
265  {
266  if (lo_initialize(conn) < 0)
267  return -1;
268  }
269 
270  /*
271  * Long ago, somebody thought it'd be a good idea to declare this function
272  * as taking size_t ... but the underlying backend function only accepts a
273  * signed int32 length. So throw error if the given value overflows
274  * int32.
275  */
276  if (len > (size_t) INT_MAX)
277  {
279  libpq_gettext("argument of lo_read exceeds integer range\n"));
280  return -1;
281  }
282 
283  argv[0].isint = 1;
284  argv[0].len = 4;
285  argv[0].u.integer = fd;
286 
287  argv[1].isint = 1;
288  argv[1].len = 4;
289  argv[1].u.integer = (int) len;
290 
291  res = PQfn(conn, conn->lobjfuncs->fn_lo_read,
292  (void *) buf, &result_len, 0, argv, 2);
293  if (PQresultStatus(res) == PGRES_COMMAND_OK)
294  {
295  PQclear(res);
296  return result_len;
297  }
298  else
299  {
300  PQclear(res);
301  return -1;
302  }
303 }
union PQArgBlock::@139 u
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
Oid fn_lo_read
Definition: libpq-int.h:278
static char * buf
Definition: pg_test_fsync.c:67
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
#define libpq_gettext(x)
Definition: libpq-int.h:685
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_tell()

int lo_tell ( PGconn conn,
int  fd 
)

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

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

549 {
550  int retval;
551  PQArgBlock argv[1];
552  PGresult *res;
553  int result_len;
554 
555  if (conn == NULL || conn->lobjfuncs == NULL)
556  {
557  if (lo_initialize(conn) < 0)
558  return -1;
559  }
560 
561  argv[0].isint = 1;
562  argv[0].len = 4;
563  argv[0].u.integer = fd;
564 
565  res = PQfn(conn, conn->lobjfuncs->fn_lo_tell,
566  &retval, &result_len, 1, argv, 1);
567  if (PQresultStatus(res) == PGRES_COMMAND_OK)
568  {
569  PQclear(res);
570  return retval;
571  }
572  else
573  {
574  PQclear(res);
575  return -1;
576  }
577 }
union PQArgBlock::@139 u
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
Oid fn_lo_tell
Definition: libpq-int.h:274
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_tell64()

pg_int64 lo_tell64 ( PGconn conn,
int  fd 
)

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

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

Referenced by pickout().

585 {
586  pg_int64 retval;
587  PQArgBlock argv[1];
588  PGresult *res;
589  int result_len;
590 
591  if (conn == NULL || conn->lobjfuncs == NULL)
592  {
593  if (lo_initialize(conn) < 0)
594  return -1;
595  }
596 
597  if (conn->lobjfuncs->fn_lo_tell64 == 0)
598  {
600  libpq_gettext("cannot determine OID of function lo_tell64\n"));
601  return -1;
602  }
603 
604  argv[0].isint = 1;
605  argv[0].len = 4;
606  argv[0].u.integer = fd;
607 
608  res = PQfn(conn, conn->lobjfuncs->fn_lo_tell64,
609  (void *) &retval, &result_len, 0, argv, 1);
610  if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
611  {
612  PQclear(res);
613  return lo_ntoh64(retval);
614  }
615  else
616  {
617  PQclear(res);
618  return -1;
619  }
620 }
union PQArgBlock::@139 u
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
PG_INT64_TYPE pg_int64
Definition: postgres_ext.h:47
Oid fn_lo_tell64
Definition: libpq-int.h:275
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
#define libpq_gettext(x)
Definition: libpq-int.h:685
int integer
Definition: libpq-fe.h:227
static pg_int64 lo_ntoh64(pg_int64 net64)
Definition: fe-lobj.c:1086
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_truncate()

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

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

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

138 {
139  PQArgBlock argv[2];
140  PGresult *res;
141  int retval;
142  int result_len;
143 
144  if (conn == NULL || conn->lobjfuncs == NULL)
145  {
146  if (lo_initialize(conn) < 0)
147  return -1;
148  }
149 
150  /* Must check this on-the-fly because it's not there pre-8.3 */
151  if (conn->lobjfuncs->fn_lo_truncate == 0)
152  {
154  libpq_gettext("cannot determine OID of function lo_truncate\n"));
155  return -1;
156  }
157 
158  /*
159  * Long ago, somebody thought it'd be a good idea to declare this function
160  * as taking size_t ... but the underlying backend function only accepts a
161  * signed int32 length. So throw error if the given value overflows
162  * int32. (A possible alternative is to automatically redirect the call
163  * to lo_truncate64; but if the caller wanted to rely on that backend
164  * function being available, he could have called lo_truncate64 for
165  * himself.)
166  */
167  if (len > (size_t) INT_MAX)
168  {
170  libpq_gettext("argument of lo_truncate exceeds integer range\n"));
171  return -1;
172  }
173 
174  argv[0].isint = 1;
175  argv[0].len = 4;
176  argv[0].u.integer = fd;
177 
178  argv[1].isint = 1;
179  argv[1].len = 4;
180  argv[1].u.integer = (int) len;
181 
182  res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate,
183  &retval, &result_len, 1, argv, 2);
184 
185  if (PQresultStatus(res) == PGRES_COMMAND_OK)
186  {
187  PQclear(res);
188  return retval;
189  }
190  else
191  {
192  PQclear(res);
193  return -1;
194  }
195 }
union PQArgBlock::@139 u
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
Oid fn_lo_truncate
Definition: libpq-int.h:276
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
#define libpq_gettext(x)
Definition: libpq-int.h:685
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_truncate64()

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

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

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

Referenced by my_truncate().

206 {
207  PQArgBlock argv[2];
208  PGresult *res;
209  int retval;
210  int result_len;
211 
212  if (conn == NULL || conn->lobjfuncs == NULL)
213  {
214  if (lo_initialize(conn) < 0)
215  return -1;
216  }
217 
218  if (conn->lobjfuncs->fn_lo_truncate64 == 0)
219  {
221  libpq_gettext("cannot determine OID of function lo_truncate64\n"));
222  return -1;
223  }
224 
225  argv[0].isint = 1;
226  argv[0].len = 4;
227  argv[0].u.integer = fd;
228 
229  len = lo_hton64(len);
230  argv[1].isint = 0;
231  argv[1].len = 8;
232  argv[1].u.ptr = (int *) &len;
233 
234  res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate64,
235  &retval, &result_len, 1, argv, 2);
236 
237  if (PQresultStatus(res) == PGRES_COMMAND_OK)
238  {
239  PQclear(res);
240  return retval;
241  }
242  else
243  {
244  PQclear(res);
245  return -1;
246  }
247 }
union PQArgBlock::@139 u
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
static pg_int64 lo_hton64(pg_int64 host64)
Definition: fe-lobj.c:1061
Oid fn_lo_truncate64
Definition: libpq-int.h:277
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int * ptr
Definition: libpq-fe.h:226
#define libpq_gettext(x)
Definition: libpq-int.h:685
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_unlink()

int lo_unlink ( PGconn conn,
Oid  lobjId 
)

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

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

Referenced by do_lo_unlink(), and vacuumlo().

629 {
630  PQArgBlock argv[1];
631  PGresult *res;
632  int result_len;
633  int retval;
634 
635  if (conn == NULL || conn->lobjfuncs == NULL)
636  {
637  if (lo_initialize(conn) < 0)
638  return -1;
639  }
640 
641  argv[0].isint = 1;
642  argv[0].len = 4;
643  argv[0].u.integer = lobjId;
644 
645  res = PQfn(conn, conn->lobjfuncs->fn_lo_unlink,
646  &retval, &result_len, 1, argv, 1);
647  if (PQresultStatus(res) == PGRES_COMMAND_OK)
648  {
649  PQclear(res);
650  return retval;
651  }
652  else
653  {
654  PQclear(res);
655  return -1;
656  }
657 }
union PQArgBlock::@139 u
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:2607
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
void PQclear(PGresult *res)
Definition: fe-exec.c:671
Oid fn_lo_unlink
Definition: libpq-int.h:271
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ lo_write()

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

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

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

Referenced by lo_import_internal().

313 {
314  PQArgBlock argv[2];
315  PGresult *res;
316  int result_len;
317  int retval;
318 
319  if (conn == NULL || conn->lobjfuncs == NULL)
320  {
321  if (lo_initialize(conn) < 0)
322  return -1;
323  }
324 
325  /*
326  * Long ago, somebody thought it'd be a good idea to declare this function
327  * as taking size_t ... but the underlying backend function only accepts a
328  * signed int32 length. So throw error if the given value overflows
329  * int32.
330  */
331  if (len > (size_t) INT_MAX)
332  {
334  libpq_gettext("argument of lo_write exceeds integer range\n"));
335  return -1;
336  }
337 
338  argv[0].isint = 1;
339  argv[0].len = 4;
340  argv[0].u.integer = fd;
341 
342  argv[1].isint = 0;
343  argv[1].len = (int) len;
344  argv[1].u.ptr = (int *) buf;
345 
346  res = PQfn(conn, conn->lobjfuncs->fn_lo_write,
347  &retval, &result_len, 1, argv, 2);
348  if (PQresultStatus(res) == PGRES_COMMAND_OK)
349  {
350  PQclear(res);
351  return retval;
352  }
353  else
354  {
355  PQclear(res);
356  return -1;
357  }
358 }
union PQArgBlock::@139 u
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
Oid fn_lo_write
Definition: libpq-int.h:279
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:2607
static int fd(const char *x, int i)
Definition: preproc-init.c:105
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
static char * buf
Definition: pg_test_fsync.c:67
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int isint
Definition: libpq-fe.h:223
PGlobjfuncs * lobjfuncs
Definition: libpq-int.h:426
int * ptr
Definition: libpq-fe.h:226
#define libpq_gettext(x)
Definition: libpq-int.h:685
int integer
Definition: libpq-fe.h:227
static int lo_initialize(PGconn *conn)
Definition: fe-lobj.c:876

◆ pg_char_to_encoding()

int pg_char_to_encoding ( const char *  name)

Definition at line 551 of file encnames.c.

References clean_encoding_name(), ereport, errcode(), errmsg(), ERROR, lengthof, NAMEDATALEN, and pg_encname_tbl.

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

552 {
553  unsigned int nel = lengthof(pg_encname_tbl);
554  const pg_encname *base = pg_encname_tbl,
555  *last = base + nel - 1,
556  *position;
557  int result;
558  char buff[NAMEDATALEN],
559  *key;
560 
561  if (name == NULL || *name == '\0')
562  return -1;
563 
564  if (strlen(name) >= NAMEDATALEN)
565  {
566 #ifdef FRONTEND
567  fprintf(stderr, "encoding name too long\n");
568  return -1;
569 #else
570  ereport(ERROR,
571  (errcode(ERRCODE_NAME_TOO_LONG),
572  errmsg("encoding name too long")));
573 #endif
574  }
575  key = clean_encoding_name(name, buff);
576 
577  while (last >= base)
578  {
579  position = base + ((last - base) >> 1);
580  result = key[0] - position->name[0];
581 
582  if (result == 0)
583  {
584  result = strcmp(key, position->name);
585  if (result == 0)
586  return position->encoding;
587  }
588  if (result < 0)
589  last = position - 1;
590  else
591  base = position + 1;
592  }
593  return -1;
594 }
int errcode(int sqlerrcode)
Definition: elog.c:575
#define lengthof(array)
Definition: c.h:600
#define NAMEDATALEN
#define ERROR
Definition: elog.h:43
static const pg_encname pg_encname_tbl[]
Definition: encnames.c:38
#define ereport(elevel, rest)
Definition: elog.h:122
const char * name
Definition: encode.c:521
int errmsg(const char *fmt,...)
Definition: elog.c:797
static char * clean_encoding_name(const char *key, char *newkey)
Definition: encnames.c:525

◆ pg_encoding_to_char()

const char* pg_encoding_to_char ( int  encoding)

◆ pg_valid_server_encoding_id()

int pg_valid_server_encoding_id ( int  encoding)

Definition at line 515 of file encnames.c.

References PG_VALID_BE_ENCODING.

Referenced by setup_locale_encoding().

516 {
518 }
static char * encoding
Definition: initdb.c:123
#define PG_VALID_BE_ENCODING(_enc)
Definition: pg_wchar.h:295

◆ PQbackendPID()

int PQbackendPID ( const PGconn conn)

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

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

Referenced by get_prompt(), and StartLogStreamer().

6133 {
6134  if (!conn || conn->status != CONNECTION_OK)
6135  return 0;
6136  return conn->be_pid;
6137 }
ConnStatusType status
Definition: libpq-int.h:379
int be_pid
Definition: libpq-int.h:419

◆ PQbinaryTuples()

int PQbinaryTuples ( const PGresult res)

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

References pg_result::binary.

Referenced by ProcessResult().

2741 {
2742  if (!res)
2743  return 0;
2744  return res->binary;
2745 }
int binary
Definition: libpq-int.h:179

◆ PQcancel()

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

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

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

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

3906 {
3907  if (!cancel)
3908  {
3909  strlcpy(errbuf, "PQcancel() -- no cancel object supplied", errbufsize);
3910  return false;
3911  }
3912 
3913  return internal_cancel(&cancel->raddr, cancel->be_pid, cancel->be_key,
3914  errbuf, errbufsize);
3915 }
static int internal_cancel(SockAddr *raddr, int be_pid, int be_key, char *errbuf, int errbufsize)
Definition: fe-connect.c:3801
int be_pid
Definition: libpq-int.h:506
int be_key
Definition: libpq-int.h:507
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
SockAddr raddr
Definition: libpq-int.h:505

◆ PQclear()

void PQclear ( PGresult res)

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

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

Referenced by _check_database_version(), _doSetSessionAuth(), _doSetWithOids(), _selectOutputSchema(), _selectTablespace(), add_tablespace_footer(), BaseBackup(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_rel_oid(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), buildShSecLabels(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_is_install_user(), check_loadable_libraries(), check_proper_datallowconn(), ClearOrSaveResult(), close_cursor(), cluster_all_databases(), convertTSFunction(), create_cursor(), CreateReplicationSlot(), createViewAsClause(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), dblink_res_error(), deallocate_one(), describeAccessMethods(), describeAggregates(), describeFunctions(), describeOneTableDetails(), describeOneTSConfig(), describeOneTSParser(), describeOperators(), describePublications(), DescribeQuery(), describeRoles(), describeSubscriptions(), describeTableDetails(), describeTablespaces(), describeTypes(), descriptor_free(), discard_response(), do_lo_import(), do_lo_list(), do_sql_command(), doCustom(), dropDBs(), DropReplicationSlot(), dropRoles(), dropTablespaces(), dumpAgg(), dumpBaseType(), dumpBlobs(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpCreateDB(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpDbRoleConfig(), dumpDomain(), dumpEnumType(), dumpFunc(), dumpGroups(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSequence(), dumpSequenceData(), dumpTable(), dumpTableData_copy(), dumpTableData_insert(), dumpTableSchema(), dumpTablespaces(), dumpTSConfig(), dumpTSDictionary(), dumpUserConfig(), dumpUserMappings(), ecpg_autostart_transaction(), ecpg_check_PQresult(), ecpg_is_type_an_array(), ecpg_process_output(), ECPGdescribe(), ECPGsetcommit(), ECPGtrans(), EndDBCopyMode(), exec_command_password(), ExecQueryUsingCursor(), executeCommand(), executeMaintenanceCommand(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlStatement(), executeStatement(), expand_schema_name_patterns(), expand_table_name_patterns(), fail_lo_xact(), fetch_more_data(), findLastBuiltinOid_V71(), finish_lo_xact(), get_create_object_cmd(), get_db_infos(), get_language_name(), get_loadable_libraries(), get_rel_infos(), get_remote_estimate(), get_returning_data(), get_synchronized_snapshot(), get_tablespace_paths(), getAccessMethods(), getAggregates(), getBlobs(), getCasts(), getCollations(), getConstraints(), getConversions(), getCopyStart(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFormattedTypeName(), getFuncs(), getIndexes(), getInherits(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getParamDescriptions(), getPolicies(), getProcLangs(), getPublications(), getPublicationTables(), GetQueryResult(), getRowDescriptions(), getRules(), getSubscriptions(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), handleCopyIn(), HandleEndOfCopyStream(), initGenerateData(), libpq_executeFileMap(), libpqConnect(), libpqGetFile(), libpqProcessFileList(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_PQexec(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_startstreaming(), listAllDbs(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listOneExtensionContents(), 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(), materializeQueryResult(), materializeResult(), new_9_0_populate_pg_largeobject_metadata(), objectDescription(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), permissionsList(), pg_attribute_noreturn(), pgfdw_cancel_query(), pgfdw_exec_cleanup_query(), pgfdw_get_cleanup_result(), pgfdw_get_result(), pgfdw_report_error(), pgfdw_xact_callback(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresEndDirectModify(), postgresEndForeignModify(), postgresExecForeignDelete(), postgresExecForeignInsert(), postgresExecForeignUpdate(), postgresImportForeignSchema(), postgresReScanForeignScan(), pqClearAsyncResult(), PQconnectPoll(), PQcopyResult(), PQencryptPasswordConn(), pqEndcopy2(), pqEndcopy3(), PQexecFinish(), PQexecStart(), pqGetErrorNotice2(), pqGetErrorNotice3(), pqInternalNotice(), PQmakeEmptyPGresult(), pqRowProcessor(), PQsetClientEncoding(), pqSetenvPoll(), prepare_common(), prepare_foreign_modify(), processExtensionTables(), ProcessResult(), PSQLexecWatch(), receiveFileChunks(), ReceiveXlogStream(), reindex_all_databases(), RetrieveWalSegSize(), run_permutation(), run_simple_query(), RunIdentifySystem(), sendCommand(), SendQuery(), set_frozenxids(), sql_exec(), start_lo_xact(), store_returning_result(), storeQueryResult(), StreamLogicalLog(), try_complete_step(), tryExecuteStatement(), vacuum_all_databases(), vacuum_one_database(), and vacuumlo().

672 {
673  PGresult_data *block;
674  int i;
675 
676  if (!res)
677  return;
678 
679  for (i = 0; i < res->nEvents; i++)
680  {
681  /* only send DESTROY to successfully-initialized event procs */
682  if (res->events[i].resultInitialized)
683  {
685 
686  evt.result = res;
687  (void) res->events[i].proc(PGEVT_RESULTDESTROY, &evt,
688  res->events[i].passThrough);
689  }
690  free(res->events[i].name);
691  }
692 
693  if (res->events)
694  free(res->events);
695 
696  /* Free all the subsidiary blocks */
697  while ((block = res->curBlock) != NULL)
698  {
699  res->curBlock = block->next;
700  free(block);
701  }
702 
703  /* Free the top-level tuple pointer array */
704  if (res->tuples)
705  free(res->tuples);
706 
707  /* zero out the pointer fields to catch programming errors */
708  res->attDescs = NULL;
709  res->tuples = NULL;
710  res->paramDescs = NULL;
711  res->errFields = NULL;
712  res->events = NULL;
713  res->nEvents = 0;
714  /* res->curBlock was zeroed out earlier */
715 
716  /* Free the PGresult structure itself */
717  free(res);
718 }
PGMessageField * errFields
Definition: libpq-int.h:197
bool resultInitialized
Definition: libpq-int.h:164
PGresult_data * next
Definition: libpq-int.h:105
int nEvents
Definition: libpq-int.h:188
PGresAttDesc * attDescs
Definition: libpq-int.h:171
PGresAttValue ** tuples
Definition: libpq-int.h:172
PGresult_data * curBlock
Definition: libpq-int.h:208
#define free(a)
Definition: header.h:65
PGresParamDesc * paramDescs
Definition: libpq-int.h:176
PGEventProc proc
Definition: libpq-int.h:160
int i
void * passThrough
Definition: libpq-int.h:162
PGEvent * events
Definition: libpq-int.h:187
char * name
Definition: libpq-int.h:161

◆ PQclientEncoding()

int PQclientEncoding ( const PGconn conn)

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

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

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

6167 {
6168  if (!conn || conn->status != CONNECTION_OK)
6169  return -1;
6170  return conn->client_encoding;
6171 }
ConnStatusType status
Definition: libpq-int.h:379
int client_encoding
Definition: libpq-int.h:422

◆ PQcmdStatus()

char* PQcmdStatus ( PGresult res)

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

References pg_result::cmdStatus.

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

2996 {
2997  if (!res)
2998  return NULL;
2999  return res->cmdStatus;
3000 }
char cmdStatus[CMDSTATUS_LEN]
Definition: libpq-int.h:178

◆ PQcmdTuples()

char* PQcmdTuples ( PGresult res)

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

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

Referenced by ecpg_process_output(), execute_dml_stmt(), postgresExecForeignDelete(), postgresExecForeignInsert(), postgresExecForeignUpdate(), and SetResultVariables().

3066 {
3067  char *p,
3068  *c;
3069 
3070  if (!res)
3071  return "";
3072 
3073  if (strncmp(res->cmdStatus, "INSERT ", 7) == 0)
3074  {
3075  p = res->cmdStatus + 7;
3076  /* INSERT: skip oid and space */
3077  while (*p && *p != ' ')
3078  p++;
3079  if (*p == 0)
3080  goto interpret_error; /* no space? */
3081  p++;
3082  }
3083  else if (strncmp(res->cmdStatus, "SELECT ", 7) == 0 ||
3084  strncmp(res->cmdStatus, "DELETE ", 7) == 0 ||
3085  strncmp(res->cmdStatus, "UPDATE ", 7) == 0)
3086  p = res->cmdStatus + 7;
3087  else if (strncmp(res->cmdStatus, "FETCH ", 6) == 0)
3088  p = res->cmdStatus + 6;
3089  else if (strncmp(res->cmdStatus, "MOVE ", 5) == 0 ||
3090  strncmp(res->cmdStatus, "COPY ", 5) == 0)
3091  p = res->cmdStatus + 5;
3092  else
3093  return "";
3094 
3095  /* check that we have an integer (at least one digit, nothing else) */
3096  for (c = p; *c; c++)
3097  {
3098  if (!isdigit((unsigned char) *c))
3099  goto interpret_error;
3100  }
3101  if (c == p)
3102  goto interpret_error;
3103 
3104  return p;
3105 
3106 interpret_error:
3108  "could not interpret result from server: %s",
3109  res->cmdStatus);
3110  return "";
3111 }
PGNoticeHooks noticeHooks
Definition: libpq-int.h:186
char * c
void pqInternalNotice(const PGNoticeHooks *hooks, const char *fmt,...)
Definition: fe-exec.c:822
char cmdStatus[CMDSTATUS_LEN]
Definition: libpq-int.h:178

◆ PQconndefaults()

PQconninfoOption* PQconndefaults ( void  )

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

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

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

1224 {
1225  PQExpBufferData errorBuf;
1226  PQconninfoOption *connOptions;
1227 
1228  /* We don't actually report any errors here, but callees want a buffer */
1229  initPQExpBuffer(&errorBuf);
1230  if (PQExpBufferDataBroken(errorBuf))
1231  return NULL; /* out of memory already :-( */
1232 
1233  connOptions = conninfo_init(&errorBuf);
1234  if (connOptions != NULL)
1235  {
1236  /* pass NULL errorBuf to ignore errors */
1237  if (!conninfo_add_defaults(connOptions, NULL))
1238  {
1239  PQconninfoFree(connOptions);
1240  connOptions = NULL;
1241  }
1242  }
1243 
1244  termPQExpBuffer(&errorBuf);
1245  return connOptions;
1246 }
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:128
static PQconninfoOption * conninfo_init(PQExpBuffer errorMessage)
Definition: fe-connect.c:4748
void PQconninfoFree(PQconninfoOption *connOptions)
Definition: fe-connect.c:5956
#define PQExpBufferDataBroken(buf)
Definition: pqexpbuffer.h:67
static bool conninfo_add_defaults(PQconninfoOption *options, PQExpBuffer errorMessage)
Definition: fe-connect.c:5184
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:89

◆ PQconnectdb()

PGconn* PQconnectdb ( const char *  conninfo)

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

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

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

586 {
587  PGconn *conn = PQconnectStart(conninfo);
588 
589  if (conn && conn->status != CONNECTION_BAD)
590  (void) connectDBComplete(conn);
591 
592  return conn;
593 }
PGconn * conn
Definition: streamutil.c:46
static int connectDBComplete(PGconn *conn)
Definition: fe-connect.c:1834
PGconn * PQconnectStart(const char *conninfo)
Definition: fe-connect.c:711
ConnStatusType status
Definition: libpq-int.h:379

◆ PQconnectdbParams()

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

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

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

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

532 {
533  PGconn *conn = PQconnectStartParams(keywords, values, expand_dbname);
534 
535  if (conn && conn->status != CONNECTION_BAD)
536  (void) connectDBComplete(conn);
537 
538  return conn;
539 
540 }
PGconn * conn
Definition: streamutil.c:46
static int connectDBComplete(PGconn *conn)
Definition: fe-connect.c:1834
ConnStatusType status
Definition: libpq-int.h:379
static Datum values[MAXATTR]
Definition: bootstrap.c:164
PGconn * PQconnectStartParams(const char *const *keywords, const char *const *values, int expand_dbname)
Definition: fe-connect.c:632

◆ PQconnectionNeedsPassword()

int PQconnectionNeedsPassword ( const PGconn conn)

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

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

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

6141 {
6142  char *password;
6143 
6144  if (!conn)
6145  return false;
6146  password = PQpass(conn);
6147  if (conn->password_needed &&
6148  (password == NULL || password[0] == '\0'))
6149  return true;
6150  else
6151  return false;
6152 }
static char password[100]
Definition: streamutil.c:45
bool password_needed
Definition: libpq-int.h:407
char * PQpass(const PGconn *conn)
Definition: fe-connect.c:5990

◆ PQconnectionUsedPassword()

int PQconnectionUsedPassword ( const PGconn conn)

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

References pg_conn::password_needed.

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

6156 {
6157  if (!conn)
6158  return false;
6159  if (conn->password_needed)
6160  return true;
6161  else
6162  return false;
6163 }
bool password_needed
Definition: libpq-int.h:407

◆ PQconnectPoll()

PostgresPollingStatusType PQconnectPoll ( PGconn conn)

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

References SockAddr::addr, pg_conn::addr_cur, pg_conn_host::addrlist, addrinfo::ai_addr, addrinfo::ai_addrlen, addrinfo::ai_family, addrinfo::ai_next, appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), pg_conn::appname, pg_conn::asyncStatus, AUTH_REQ_MD5, AUTH_REQ_OK, pg_conn::auth_req_received, CHT_HOST_ADDRESS, connect, connectFailureMessage(), CONNECTION_AUTH_OK, CONNECTION_AWAITING_RESPONSE, CONNECTION_BAD, CONNECTION_CHECK_WRITABLE, CONNECTION_CONSUME, CONNECTION_MADE, CONNECTION_NEEDED, CONNECTION_OK, CONNECTION_SETENV, CONNECTION_SSL_STARTUP, CONNECTION_STARTED, connectNoDelay(), pg_conn::connhost, PQExpBufferData::data, EINPROGRESS, EINTR, EnvironmentOptions, ERRCODE_APPNAME_UNKNOWN, pg_conn::errorMessage, EWOULDBLOCK, pg_conn::fbappname, free, getpeereid(), pg_conn_host::host, pg_conn_host::hostaddr, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, IS_AF_UNIX, pg_conn::laddr, PQExpBufferData::len, libpq_gettext, pg_conn::nconnhost, NEGOTIATE_SSL_CODE, pg_conn::next_eo, PG_DIAG_SQLSTATE, pg_fe_sendauth(), pg_hton32, PG_PROTOCOL, PG_PROTOCOL_MAJOR, pg_set_noblock(), PGASYNC_BUSY, PGINVALID_SOCKET, pgpassfileWarning(), PGRES_FATAL_ERROR, PGRES_POLLING_FAILED, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PGRES_TUPLES_OK, pg_conn_host::port, pqBuildStartupPacket2(), pqBuildStartupPacket3(), pqCheckInBufferSpace(), PQclear(), PQconsumeInput(), pqDropConnection(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetpwuid(), PQgetResult(), pqGets_append(), PQgetvalue(), PQisBusy(), PQntuples(), pqPacketSend(), pqReadData(), PQresultErrorField(), PQresultStatus(), pqsecure_initialize(), pqsecure_open_client(), PQsendQuery(), pqSetenvPoll(), pqStrerror(), printfPQExpBuffer(), pg_conn::pversion, pg_conn::raddr, release_all_addrinfo(), pg_conn::requirepeer, restoreErrorMessage(), pg_result::resultStatus, SockAddr::salen, saveErrorMessage(), pg_conn::send_appname, sendTerminateConn(), pg_conn::setenv_state, SETENV_STATE_CLIENT_ENCODING_SEND, setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), pg_conn::sigpipe_flag, pg_conn::sigpipe_so, pg_conn::sock, SOCK_ERRNO, SOCK_STRERROR, socket, pg_conn::ssl_in_use, pg_conn::sslmode, pg_conn::status, STATUS_OK, pg_conn::target_session_attrs, termPQExpBuffer(), pg_conn_host::type, useKeepalives(), _internalPQconninfoOption::val, and pg_conn::whichhost.

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

1997 {
1998  PGresult *res;
1999  char sebuf[256];
2000  int optval;
2001  PQExpBufferData savedMessage;
2002 
2003  if (conn == NULL)
2004  return PGRES_POLLING_FAILED;
2005 
2006  /* Get the new data */
2007  switch (conn->status)
2008  {
2009  /*
2010  * We really shouldn't have been polled in these two cases, but we
2011  * can handle it.
2012  */
2013  case CONNECTION_BAD:
2014  return PGRES_POLLING_FAILED;
2015  case CONNECTION_OK:
2016  return PGRES_POLLING_OK;
2017 
2018  /* These are reading states */
2020  case CONNECTION_AUTH_OK:
2021  {
2022  /* Load waiting data */
2023  int n = pqReadData(conn);
2024 
2025  if (n < 0)
2026  goto error_return;
2027  if (n == 0)
2028  return PGRES_POLLING_READING;
2029 
2030  break;
2031  }
2032 
2033  /* These are writing states, so we just proceed. */
2034  case CONNECTION_STARTED:
2035  case CONNECTION_MADE:
2036  break;
2037 
2038  /* We allow pqSetenvPoll to decide whether to proceed. */
2039  case CONNECTION_SETENV:
2040  break;
2041 
2042  /* Special cases: proceed without waiting. */
2044  case CONNECTION_NEEDED:
2046  case CONNECTION_CONSUME:
2047  break;
2048 
2049  default:
2051  libpq_gettext(
2052  "invalid connection state, "
2053  "probably indicative of memory corruption\n"
2054  ));
2055  goto error_return;
2056  }
2057 
2058 
2059 keep_going: /* We will come back to here until there is
2060  * nothing left to do. */
2061  switch (conn->status)
2062  {
2063  case CONNECTION_NEEDED:
2064  {
2065  /*
2066  * Try to initiate a connection to one of the addresses
2067  * returned by pg_getaddrinfo_all(). conn->addr_cur is the
2068  * next one to try. We fail when we run out of addresses.
2069  */
2070  for (;;)
2071  {
2072  struct addrinfo *addr_cur;
2073 
2074  /*
2075  * Advance to next possible host, if we've tried all of
2076  * the addresses for the current host.
2077  */
2078  if (conn->addr_cur == NULL)
2079  {
2080  if (++conn->whichhost >= conn->nconnhost)
2081  {
2082  conn->whichhost = 0;
2083  break;
2084  }
2085  conn->addr_cur =
2086  conn->connhost[conn->whichhost].addrlist;
2087  }
2088 
2089  /* Remember current address for possible error msg */
2090  addr_cur = conn->addr_cur;
2091  memcpy(&conn->raddr.addr, addr_cur->ai_addr,
2092  addr_cur->ai_addrlen);
2093  conn->raddr.salen = addr_cur->ai_addrlen;
2094 
2095  conn->sock = socket(addr_cur->ai_family, SOCK_STREAM, 0);
2096  if (conn->sock == PGINVALID_SOCKET)
2097  {
2098  /*
2099  * ignore socket() failure if we have more addresses
2100  * to try
2101  */
2102  if (addr_cur->ai_next != NULL ||
2103  conn->whichhost + 1 < conn->nconnhost)
2104  {
2105  conn->addr_cur = addr_cur->ai_next;
2106  continue;
2107  }
2109  libpq_gettext("could not create socket: %s\n"),
2110  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2111  break;
2112  }
2113 
2114  /*
2115  * Select socket options: no delay of outgoing data for
2116  * TCP sockets, nonblock mode, close-on-exec. Fail if any
2117  * of this fails.
2118  */
2119  if (!IS_AF_UNIX(addr_cur->ai_family))
2120  {
2121  if (!connectNoDelay(conn))
2122  {
2123  pqDropConnection(conn, true);
2124  conn->addr_cur = addr_cur->ai_next;
2125  continue;
2126  }
2127  }
2128  if (!pg_set_noblock(conn->sock))
2129  {
2131  libpq_gettext("could not set socket to nonblocking mode: %s\n"),
2132  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2133  pqDropConnection(conn, true);
2134  conn->addr_cur = addr_cur->ai_next;
2135  continue;
2136  }
2137 
2138 #ifdef F_SETFD
2139  if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
2140  {
2142  libpq_gettext("could not set socket to close-on-exec mode: %s\n"),
2143  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2144  pqDropConnection(conn, true);
2145  conn->addr_cur = addr_cur->ai_next;
2146  continue;
2147  }
2148 #endif /* F_SETFD */
2149 
2150  if (!IS_AF_UNIX(addr_cur->ai_family))
2151  {
2152 #ifndef WIN32
2153  int on = 1;
2154 #endif
2155  int usekeepalives = useKeepalives(conn);
2156  int err = 0;
2157 
2158  if (usekeepalives < 0)
2159  {
2161  libpq_gettext("keepalives parameter must be an integer\n"));
2162  err = 1;
2163  }
2164  else if (usekeepalives == 0)
2165  {
2166  /* Do nothing */
2167  }
2168 #ifndef WIN32
2169  else if (setsockopt(conn->sock,
2170  SOL_SOCKET, SO_KEEPALIVE,
2171  (char *) &on, sizeof(on)) < 0)
2172  {
2174  libpq_gettext("setsockopt(%s) failed: %s\n"),
2175  "SO_KEEPALIVE",
2176  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2177  err = 1;
2178  }
2179  else if (!setKeepalivesIdle(conn)
2180  || !setKeepalivesInterval(conn)
2181  || !setKeepalivesCount(conn))
2182  err = 1;
2183 #else /* WIN32 */
2184 #ifdef SIO_KEEPALIVE_VALS
2185  else if (!setKeepalivesWin32(conn))
2186  err = 1;
2187 #endif /* SIO_KEEPALIVE_VALS */
2188 #endif /* WIN32 */
2189 
2190  if (err)
2191  {
2192  pqDropConnection(conn, true);
2193  conn->addr_cur = addr_cur->ai_next;
2194  continue;
2195  }
2196  }
2197 
2198  /*----------
2199  * We have three methods of blocking SIGPIPE during
2200  * send() calls to this socket:
2201  *
2202  * - setsockopt(sock, SO_NOSIGPIPE)
2203  * - send(sock, ..., MSG_NOSIGNAL)
2204  * - setting the signal mask to SIG_IGN during send()
2205  *
2206  * The third method requires three syscalls per send,
2207  * so we prefer either of the first two, but they are
2208  * less portable. The state is tracked in the following
2209  * members of PGconn:
2210  *
2211  * conn->sigpipe_so - we have set up SO_NOSIGPIPE
2212  * conn->sigpipe_flag - we're specifying MSG_NOSIGNAL
2213  *
2214  * If we can use SO_NOSIGPIPE, then set sigpipe_so here
2215  * and we're done. Otherwise, set sigpipe_flag so that
2216  * we will try MSG_NOSIGNAL on sends. If we get an error
2217  * with MSG_NOSIGNAL, we'll clear that flag and revert to
2218  * signal masking.
2219  *----------
2220  */
2221  conn->sigpipe_so = false;
2222 #ifdef MSG_NOSIGNAL
2223  conn->sigpipe_flag = true;
2224 #else
2225  conn->sigpipe_flag = false;
2226 #endif /* MSG_NOSIGNAL */
2227 
2228 #ifdef SO_NOSIGPIPE
2229  optval = 1;
2230  if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
2231  (char *) &optval, sizeof(optval)) == 0)
2232  {
2233  conn->sigpipe_so = true;
2234  conn->sigpipe_flag = false;
2235  }
2236 #endif /* SO_NOSIGPIPE */
2237 
2238  /*
2239  * Start/make connection. This should not block, since we
2240  * are in nonblock mode. If it does, well, too bad.
2241  */
2242  if (connect(conn->sock, addr_cur->ai_addr,
2243  addr_cur->ai_addrlen) < 0)
2244  {
2245  if (SOCK_ERRNO == EINPROGRESS ||
2246 #ifdef WIN32
2247  SOCK_ERRNO == EWOULDBLOCK ||
2248 #endif
2249  SOCK_ERRNO == EINTR)
2250  {
2251  /*
2252  * This is fine - we're in non-blocking mode, and
2253  * the connection is in progress. Tell caller to
2254  * wait for write-ready on socket.
2255  */
2256  conn->status = CONNECTION_STARTED;
2257  return PGRES_POLLING_WRITING;
2258  }
2259  /* otherwise, trouble */
2260  }
2261  else
2262  {
2263  /*
2264  * Hm, we're connected already --- seems the "nonblock
2265  * connection" wasn't. Advance the state machine and
2266  * go do the next stuff.
2267  */
2268  conn->status = CONNECTION_STARTED;
2269  goto keep_going;
2270  }
2271 
2272  /*
2273  * This connection failed --- set up error report, then
2274  * close socket (do it this way in case close() affects
2275  * the value of errno...). We will ignore the connect()
2276  * failure and keep going if there are more addresses.
2277  */
2279  pqDropConnection(conn, true);
2280 
2281  /*
2282  * Try the next address, if any.
2283  */
2284  conn->addr_cur = addr_cur->ai_next;
2285  } /* loop over addresses */
2286 
2287  /*
2288  * Oops, no more addresses. An appropriate error message is
2289  * already set up, so just set the right status.
2290  */
2291  goto error_return;
2292  }
2293 
2294  case CONNECTION_STARTED:
2295  {
2296  ACCEPT_TYPE_ARG3 optlen = sizeof(optval);
2297 
2298  /*
2299  * Write ready, since we've made it here, so the connection
2300  * has been made ... or has failed.
2301  */
2302 
2303  /*
2304  * Now check (using getsockopt) that there is not an error
2305  * state waiting for us on the socket.
2306  */
2307 
2308  if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
2309  (char *) &optval, &optlen) == -1)
2310  {
2312  libpq_gettext("could not get socket error status: %s\n"),
2313  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2314  goto error_return;
2315  }
2316  else if (optval != 0)
2317  {
2318  /*
2319  * When using a nonblocking connect, we will typically see
2320  * connect failures at this point, so provide a friendly
2321  * error message.
2322  */
2323  connectFailureMessage(conn, optval);
2324  pqDropConnection(conn, true);
2325 
2326  /*
2327  * If more addresses remain, keep trying, just as in the
2328  * case where connect() returned failure immediately.
2329  */
2330  if (conn->addr_cur->ai_next != NULL ||
2331  conn->whichhost + 1 < conn->nconnhost)
2332  {
2333  conn->addr_cur = conn->addr_cur->ai_next;
2334  conn->status = CONNECTION_NEEDED;
2335  goto keep_going;
2336  }
2337  goto error_return;
2338  }
2339 
2340  /* Fill in the client address */
2341  conn->laddr.salen = sizeof(conn->laddr.addr);
2342  if (getsockname(conn->sock,
2343  (struct sockaddr *) &conn->laddr.addr,
2344  &conn->laddr.salen) < 0)
2345  {
2347  libpq_gettext("could not get client address from socket: %s\n"),
2348  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2349  goto error_return;
2350  }
2351 
2352  /*
2353  * Make sure we can write before advancing to next step.
2354  */
2355  conn->status = CONNECTION_MADE;
2356  return PGRES_POLLING_WRITING;
2357  }
2358 
2359  case CONNECTION_MADE:
2360  {
2361  char *startpacket;
2362  int packetlen;
2363 
2364 #ifdef HAVE_UNIX_SOCKETS
2365 
2366  /*
2367  * Implement requirepeer check, if requested and it's a
2368  * Unix-domain socket.
2369  */
2370  if (conn->requirepeer && conn->requirepeer[0] &&
2371  IS_AF_UNIX(conn->raddr.addr.ss_family))
2372  {
2373  char pwdbuf[BUFSIZ];
2374  struct passwd pass_buf;
2375  struct passwd *pass;
2376  int passerr;
2377  uid_t uid;
2378  gid_t gid;
2379 
2380  errno = 0;
2381  if (getpeereid(conn->sock, &uid, &gid) != 0)
2382  {
2383  /*
2384  * Provide special error message if getpeereid is a
2385  * stub
2386  */
2387  if (errno == ENOSYS)
2389  libpq_gettext("requirepeer parameter is not supported on this platform\n"));
2390  else
2392  libpq_gettext("could not get peer credentials: %s\n"),
2393  pqStrerror(errno, sebuf, sizeof(sebuf)));
2394  goto error_return;
2395  }
2396 
2397  passerr = pqGetpwuid(uid, &pass_buf, pwdbuf, sizeof(pwdbuf), &pass);
2398  if (pass == NULL)
2399  {
2400  if (passerr != 0)
2402  libpq_gettext("could not look up local user ID %d: %s\n"),
2403  (int) uid,
2404  pqStrerror(passerr, sebuf, sizeof(sebuf)));
2405  else
2407  libpq_gettext("local user with ID %d does not exist\n"),
2408  (int) uid);
2409  goto error_return;
2410  }
2411 
2412  if (strcmp(pass->pw_name, conn->requirepeer) != 0)
2413  {
2415  libpq_gettext("requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n"),
2416  conn->requirepeer, pass->pw_name);
2417  goto error_return;
2418  }
2419  }
2420 #endif /* HAVE_UNIX_SOCKETS */
2421 
2422 #ifdef USE_SSL
2423 
2424  /*
2425  * If SSL is enabled and we haven't already got it running,
2426  * request it instead of sending the startup message.
2427  */
2428  if (IS_AF_UNIX(conn->raddr.addr.ss_family))
2429  {
2430  /* Don't bother requesting SSL over a Unix socket */
2431  conn->allow_ssl_try = false;
2432  }
2433  if (conn->allow_ssl_try && !conn->wait_ssl_try &&
2434  !conn->ssl_in_use)
2435  {
2436  ProtocolVersion pv;
2437 
2438  /*
2439  * Send the SSL request packet.
2440  *
2441  * Theoretically, this could block, but it really
2442  * shouldn't since we only got here if the socket is
2443  * write-ready.
2444  */
2446  if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
2447  {
2449  libpq_gettext("could not send SSL negotiation packet: %s\n"),
2450  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2451  goto error_return;
2452  }
2453  /* Ok, wait for response */
2455  return PGRES_POLLING_READING;
2456  }
2457 #endif /* USE_SSL */
2458 
2459  /*
2460  * Build the startup packet.
2461  */
2462  if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
2463  startpacket = pqBuildStartupPacket3(conn, &packetlen,
2465  else
2466  startpacket = pqBuildStartupPacket2(conn, &packetlen,
2468  if (!startpacket)
2469  {
2470  /*
2471  * will not appendbuffer here, since it's likely to also
2472  * run out of memory
2473  */
2475  libpq_gettext("out of memory\n"));
2476  goto error_return;
2477  }
2478 
2479  /*
2480  * Send the startup packet.
2481  *
2482  * Theoretically, this could block, but it really shouldn't
2483  * since we only got here if the socket is write-ready.
2484  */
2485  if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
2486  {
2488  libpq_gettext("could not send startup packet: %s\n"),
2489  SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
2490  free(startpacket);
2491  goto error_return;
2492  }
2493 
2494  free(startpacket);
2495 
2497  return PGRES_POLLING_READING;
2498  }
2499 
2500  /*
2501  * Handle SSL negotiation: wait for postmaster messages and
2502  * respond as necessary.
2503  */
2505  {
2506 #ifdef USE_SSL
2507  PostgresPollingStatusType pollres;
2508 
2509  /*
2510  * On first time through, get the postmaster's response to our
2511  * SSL negotiation packet.
2512  */
2513  if (!conn->ssl_in_use)
2514  {
2515  /*
2516  * We use pqReadData here since it has the logic to
2517  * distinguish no-data-yet from connection closure. Since
2518  * conn->ssl isn't set, a plain recv() will occur.
2519  */
2520  char SSLok;
2521  int rdresult;
2522 
2523  rdresult = pqReadData(conn);
2524  if (rdresult < 0)
2525  {
2526  /* errorMessage is already filled in */
2527  goto error_return;
2528  }
2529  if (rdresult == 0)
2530  {
2531  /* caller failed to wait for data */
2532  return PGRES_POLLING_READING;
2533  }
2534  if (pqGetc(&SSLok, conn) < 0)
2535  {
2536  /* should not happen really */
2537  return PGRES_POLLING_READING;
2538  }
2539  if (SSLok == 'S')
2540  {
2541  /* mark byte consumed */
2542  conn->inStart = conn->inCursor;
2543  /* Set up global SSL state if required */
2544  if (pqsecure_initialize(conn) != 0)
2545  goto error_return;
2546  }
2547  else if (SSLok == 'N')
2548  {
2549  /* mark byte consumed */
2550  conn->inStart = conn->inCursor;
2551  /* OK to do without SSL? */
2552  if (conn->sslmode[0] == 'r' || /* "require" */
2553  conn->sslmode[0] == 'v') /* "verify-ca" or
2554  * "verify-full" */
2555  {
2556  /* Require SSL, but server does not want it */
2558  libpq_gettext("server does not support SSL, but SSL was required\n"));
2559  goto error_return;
2560  }
2561  /* Otherwise, proceed with normal startup */
2562  conn->allow_ssl_try = false;
2563  conn->status = CONNECTION_MADE;
2564  return PGRES_POLLING_WRITING;
2565  }
2566  else if (SSLok == 'E')
2567  {
2568  /*
2569  * Server failure of some sort, such as failure to
2570  * fork a backend process. We need to process and
2571  * report the error message, which might be formatted
2572  * according to either protocol 2 or protocol 3.
2573  * Rather than duplicate the code for that, we flip
2574  * into AWAITING_RESPONSE state and let the code there
2575  * deal with it. Note we have *not* consumed the "E"
2576  * byte here.
2577  */
2579  goto keep_going;
2580  }
2581  else
2582  {
2584  libpq_gettext("received invalid response to SSL negotiation: %c\n"),
2585  SSLok);
2586  goto error_return;
2587  }
2588  }
2589 
2590  /*
2591  * Begin or continue the SSL negotiation process.
2592  */
2593  pollres = pqsecure_open_client(conn);
2594  if (pollres == PGRES_POLLING_OK)
2595  {
2596  /* SSL handshake done, ready to send startup packet */
2597  conn->status = CONNECTION_MADE;
2598  return PGRES_POLLING_WRITING;
2599  }
2600  if (pollres == PGRES_POLLING_FAILED)
2601  {
2602  /*
2603  * Failed ... if sslmode is "prefer" then do a non-SSL
2604  * retry
2605  */
2606  if (conn->sslmode[0] == 'p' /* "prefer" */
2607  && conn->allow_ssl_try /* redundant? */
2608  && !conn->wait_ssl_try) /* redundant? */
2609  {
2610  /* only retry once */
2611  conn->allow_ssl_try = false;
2612  /* Must drop the old connection */
2613  pqDropConnection(conn, true);
2614  conn->status = CONNECTION_NEEDED;
2615  goto keep_going;
2616  }
2617  }
2618  return pollres;
2619 #else /* !USE_SSL */
2620  /* can't get here */
2621  goto error_return;
2622 #endif /* USE_SSL */
2623  }
2624 
2625  /*
2626  * Handle authentication exchange: wait for postmaster messages
2627  * and respond as necessary.
2628  */
2630  {
2631  char beresp;
2632  int msgLength;
2633  int avail;
2634  AuthRequest areq;
2635  int res;
2636 
2637  /*
2638  * Scan the message from current point (note that if we find
2639  * the message is incomplete, we will return without advancing
2640  * inStart, and resume here next time).
2641  */
2642  conn->inCursor = conn->inStart;
2643 
2644  /* Read type byte */
2645  if (pqGetc(&beresp, conn))
2646  {
2647  /* We'll come back when there is more data */
2648  return PGRES_POLLING_READING;
2649  }
2650 
2651  /*
2652  * Validate message type: we expect only an authentication
2653  * request or an error here. Anything else probably means
2654  * it's not Postgres on the other end at all.
2655  */
2656  if (!(beresp == 'R' || beresp == 'E'))
2657  {
2659  libpq_gettext(
2660  "expected authentication request from "
2661  "server, but received %c\n"),
2662  beresp);
2663  goto error_return;
2664  }
2665 
2666  if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
2667  {
2668  /* Read message length word */
2669  if (pqGetInt(&msgLength, 4, conn))
2670  {
2671  /* We'll come back when there is more data */
2672  return PGRES_POLLING_READING;
2673  }
2674  }
2675  else
2676  {
2677  /* Set phony message length to disable checks below */
2678  msgLength = 8;
2679  }
2680 
2681  /*
2682  * Try to validate message length before using it.
2683  * Authentication requests can't be very large, although GSS
2684  * auth requests may not be that small. Errors can be a
2685  * little larger, but not huge. If we see a large apparent
2686  * length in an error, it means we're really talking to a
2687  * pre-3.0-protocol server; cope.
2688  */
2689  if (beresp == 'R' && (msgLength < 8 || msgLength > 2000))
2690  {
2692  libpq_gettext(
2693  "expected authentication request from "
2694  "server, but received %c\n"),
2695  beresp);
2696  goto error_return;
2697  }
2698 
2699  if (beresp == 'E' && (msgLength < 8 || msgLength > 30000))
2700  {
2701  /* Handle error from a pre-3.0 server */
2702  conn->inCursor = conn->inStart + 1; /* reread data */
2703  if (pqGets_append(&conn->errorMessage, conn))
2704  {
2705  /* We'll come back when there is more data */
2706  return PGRES_POLLING_READING;
2707  }
2708  /* OK, we read the message; mark data consumed */
2709  conn->inStart = conn->inCursor;
2710 
2711  /*
2712  * The postmaster typically won't end its message with a
2713  * newline, so add one to conform to libpq conventions.
2714  */
2715  appendPQExpBufferChar(&conn->errorMessage, '\n');
2716 
2717  /*
2718  * If we tried to open the connection in 3.0 protocol,
2719  * fall back to 2.0 protocol.
2720  */
2721  if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
2722  {
2723  conn->pversion = PG_PROTOCOL(2, 0);
2724  /* Must drop the old connection */
2725  pqDropConnection(conn, true);
2726  conn->status = CONNECTION_NEEDED;
2727  goto keep_going;
2728  }
2729 
2730  goto error_return;
2731  }
2732 
2733  /*
2734  * Can't process if message body isn't all here yet.
2735  *
2736  * (In protocol 2.0 case, we are assuming messages carry at
2737  * least 4 bytes of data.)
2738  */
2739  msgLength -= 4;
2740  avail = conn->inEnd - conn->inCursor;
2741  if (avail < msgLength)
2742  {
2743  /*
2744  * Before returning, try to enlarge the input buffer if
2745  * needed to hold the whole message; see notes in
2746  * pqParseInput3.
2747  */
2748  if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
2749  conn))
2750  goto error_return;
2751  /* We'll come back when there is more data */
2752  return PGRES_POLLING_READING;
2753  }
2754 
2755  /* Handle errors. */
2756  if (beresp == 'E')
2757  {
2758  if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
2759  {
2760  if (pqGetErrorNotice3(conn, true))
2761  {
2762  /* We'll come back when there is more data */
2763  return PGRES_POLLING_READING;
2764  }
2765  }
2766  else
2767  {
2768  if (pqGets_append(&conn->errorMessage, conn))
2769  {
2770  /* We'll come back when there is more data */
2771  return PGRES_POLLING_READING;
2772  }
2773  }
2774  /* OK, we read the message; mark data consumed */
2775  conn->inStart = conn->inCursor;
2776 
2777 #ifdef USE_SSL
2778 
2779  /*
2780  * if sslmode is "allow" and we haven't tried an SSL
2781  * connection already, then retry with an SSL connection
2782  */
2783  if (conn->sslmode[0] == 'a' /* "allow" */
2784  && !conn->ssl_in_use
2785  && conn->allow_ssl_try
2786  && conn->wait_ssl_try)
2787  {
2788  /* only retry once */
2789  conn->wait_ssl_try = false;
2790  /* Must drop the old connection */
2791  pqDropConnection(conn, true);
2792  conn->status = CONNECTION_NEEDED;
2793  goto keep_going;
2794  }
2795 
2796  /*
2797  * if sslmode is "prefer" and we're in an SSL connection,
2798  * then do a non-SSL retry
2799  */
2800  if (conn->sslmode[0] == 'p' /* "prefer" */
2801  && conn->allow_ssl_try
2802  && !conn->wait_ssl_try) /* redundant? */
2803  {
2804  /* only retry once */
2805  conn->allow_ssl_try = false;
2806  /* Must drop the old connection */
2807  pqDropConnection(conn, true);
2808  conn->status = CONNECTION_NEEDED;
2809  goto keep_going;
2810  }
2811 #endif
2812 
2813  goto error_return;
2814  }
2815 
2816  /* It is an authentication request. */
2817  conn->auth_req_received = true;
2818 
2819  /* Get the type of request. */
2820  if (pqGetInt((int *) &areq, 4, conn))
2821  {
2822  /* We'll come back when there are more data */
2823  return PGRES_POLLING_READING;
2824  }
2825  msgLength -= 4;
2826 
2827  /*
2828  * Ensure the password salt is in the input buffer, if it's an
2829  * MD5 request. All the other authentication methods that
2830  * contain extra data in the authentication request are only
2831  * supported in protocol version 3, in which case we already
2832  * read the whole message above.
2833  */
2834  if (areq == AUTH_REQ_MD5 && PG_PROTOCOL_MAJOR(conn->pversion) < 3)
2835  {
2836  msgLength += 4;
2837 
2838  avail = conn->inEnd - conn->inCursor;
2839  if (avail < 4)
2840  {
2841  /*
2842  * Before returning, try to enlarge the input buffer
2843  * if needed to hold the whole message; see notes in
2844  * pqParseInput3.
2845  */
2846  if (pqCheckInBufferSpace(conn->inCursor + (size_t) 4,
2847  conn))
2848  goto error_return;
2849  /* We'll come back when there is more data */
2850  return PGRES_POLLING_READING;
2851  }
2852  }
2853 
2854  /*
2855  * Process the rest of the authentication request message, and
2856  * respond to it if necessary.
2857  *
2858  * Note that conn->pghost must be non-NULL if we are going to
2859  * avoid the Kerberos code doing a hostname look-up.
2860  */
2861  res = pg_fe_sendauth(areq, msgLength, conn);
2862  conn->errorMessage.len = strlen(conn->errorMessage.data);
2863 
2864  /* OK, we have processed the message; mark data consumed */
2865  conn->inStart = conn->inCursor;
2866 
2867  if (res != STATUS_OK)
2868  goto error_return;
2869 
2870  /*
2871  * Just make sure that any data sent by pg_fe_sendauth is
2872  * flushed out. Although this theoretically could block, it
2873  * really shouldn't since we don't send large auth responses.
2874  */
2875  if (pqFlush(conn))
2876  goto error_return;
2877 
2878  if (areq == AUTH_REQ_OK)
2879  {
2880  /* We are done with authentication exchange */
2881  conn->status = CONNECTION_AUTH_OK;
2882 
2883  /*
2884  * Set asyncStatus so that PQgetResult will think that
2885  * what comes back next is the result of a query. See
2886  * below.
2887  */
2888  conn->asyncStatus = PGASYNC_BUSY;
2889  }
2890 
2891  /* Look to see if we have more data yet. */
2892  goto keep_going;
2893  }
2894 
2895  case CONNECTION_AUTH_OK:
2896  {
2897  /*
2898  * Now we expect to hear from the backend. A ReadyForQuery
2899  * message indicates that startup is successful, but we might
2900  * also get an Error message indicating failure. (Notice
2901  * messages indicating nonfatal warnings are also allowed by
2902  * the protocol, as are ParameterStatus and BackendKeyData
2903  * messages.) Easiest way to handle this is to let
2904  * PQgetResult() read the messages. We just have to fake it
2905  * out about the state of the connection, by setting
2906  * asyncStatus = PGASYNC_BUSY (done above).
2907  */
2908 
2909  if (PQisBusy(conn))
2910  return PGRES_POLLING_READING;
2911 
2912  res = PQgetResult(conn);
2913 
2914  /*
2915  * NULL return indicating we have gone to IDLE state is
2916  * expected
2917  */
2918  if (res)
2919  {
2920  if (res->resultStatus != PGRES_FATAL_ERROR)
2922  libpq_gettext("unexpected message from server during startup\n"));
2923  else if (conn->send_appname &&
2924  (conn->appname || conn->fbappname))
2925  {
2926  /*
2927  * If we tried to send application_name, check to see
2928  * if the error is about that --- pre-9.0 servers will
2929  * reject it at this stage of the process. If so,
2930  * close the connection and retry without sending
2931  * application_name. We could possibly get a false
2932  * SQLSTATE match here and retry uselessly, but there
2933  * seems no great harm in that; we'll just get the
2934  * same error again if it's unrelated.
2935  */
2936  const char *sqlstate;
2937 
2938  sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
2939  if (sqlstate &&
2940  strcmp(sqlstate, ERRCODE_APPNAME_UNKNOWN) == 0)
2941  {
2942  PQclear(res);
2943  conn->send_appname = false;
2944  /* Must drop the old connection */
2945  pqDropConnection(conn, true);
2946  conn->status = CONNECTION_NEEDED;
2947  goto keep_going;
2948  }
2949  }
2950 
2951  /*
2952  * if the resultStatus is FATAL, then conn->errorMessage
2953  * already has a copy of the error; needn't copy it back.
2954  * But add a newline if it's not there already, since
2955  * postmaster error messages may not have one.
2956  */
2957  if (conn->errorMessage.len <= 0 ||
2958  conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
2959  appendPQExpBufferChar(&conn->errorMessage, '\n');
2960  PQclear(res);
2961  goto error_return;
2962  }
2963 
2964  /* Fire up post-connection housekeeping if needed */
2965  if (PG_PROTOCOL_MAJOR(conn->pversion) < 3)
2966  {
2967  conn->status = CONNECTION_SETENV;
2969  conn->next_eo = EnvironmentOptions;
2970  return PGRES_POLLING_WRITING;
2971  }
2972 
2973  /*
2974  * If a read-write connection is required, see if we have one.
2975  */
2976  if (conn->target_session_attrs != NULL &&
2977  strcmp(conn->target_session_attrs, "read-write") == 0)
2978  {
2979  /*
2980  * We are yet to make a connection. Save all existing
2981  * error messages until we make a successful connection
2982  * state. This is important because PQsendQuery is going
2983  * to reset conn->errorMessage and we will lose error
2984  * messages related to previous hosts we have tried to
2985  * connect and failed.
2986  */
2987  if (!saveErrorMessage(conn, &savedMessage))
2988  goto error_return;
2989 
2990  conn->status = CONNECTION_OK;
2991  if (!PQsendQuery(conn,
2992  "SHOW transaction_read_only"))
2993  {
2994  restoreErrorMessage(conn, &savedMessage);
2995  goto error_return;
2996  }
2998  restoreErrorMessage(conn, &savedMessage);
2999  return PGRES_POLLING_READING;
3000  }
3001 
3002  /* We can release the address lists now. */
3003  release_all_addrinfo(conn);
3004 
3005  /* We are open for business! */
3006  conn->status = CONNECTION_OK;
3007  return PGRES_POLLING_OK;
3008  }
3009 
3010  case CONNECTION_SETENV:
3011 
3012  /*
3013  * Do post-connection housekeeping (only needed in protocol 2.0).
3014  *
3015  * We pretend that the connection is OK for the duration of these
3016  * queries.
3017  */
3018  conn->status = CONNECTION_OK;
3019 
3020  switch (pqSetenvPoll(conn))
3021  {
3022  case PGRES_POLLING_OK: /* Success */
3023  break;
3024 
3025  case PGRES_POLLING_READING: /* Still going */
3026  conn->status = CONNECTION_SETENV;
3027  return PGRES_POLLING_READING;
3028 
3029  case PGRES_POLLING_WRITING: /* Still going */
3030  conn->status = CONNECTION_SETENV;
3031  return PGRES_POLLING_WRITING;
3032 
3033  default:
3034  goto error_return;
3035  }
3036 
3037  /*
3038  * If a read-write connection is requested check for same.
3039  */
3040  if (conn->target_session_attrs != NULL &&
3041  strcmp(conn->target_session_attrs, "read-write") == 0)
3042  {
3043  if (!saveErrorMessage(conn, &savedMessage))
3044  goto error_return;
3045 
3046  conn->status = CONNECTION_OK;
3047  if (!PQsendQuery(conn,
3048  "SHOW transaction_read_only"))
3049  {
3050  restoreErrorMessage(conn, &savedMessage);
3051  goto error_return;
3052  }
3054  restoreErrorMessage(conn, &savedMessage);
3055  return PGRES_POLLING_READING;
3056  }
3057 
3058  /* We can release the address lists now. */
3059  release_all_addrinfo(conn);
3060 
3061  /* We are open for business! */
3062  conn->status = CONNECTION_OK;
3063  return PGRES_POLLING_OK;
3064 
3065  case CONNECTION_CONSUME:
3066  {
3067  conn->status = CONNECTION_OK;
3068  if (!PQconsumeInput(conn))
3069  goto error_return;
3070 
3071  if (PQisBusy(conn))
3072  {
3073  conn->status = CONNECTION_CONSUME;
3074  restoreErrorMessage(conn, &savedMessage);
3075  return PGRES_POLLING_READING;
3076  }
3077 
3078  /*
3079  * Call PQgetResult() again to consume NULL result.
3080  */
3081  res = PQgetResult(conn);
3082  if (res != NULL)
3083  {
3084  PQclear(res);
3085  conn->status = CONNECTION_CONSUME;
3086  goto keep_going;
3087  }
3088 
3089  /* We are open for business! */
3090  conn->status = CONNECTION_OK;
3091  return PGRES_POLLING_OK;
3092  }
3094  {
3095  const char *displayed_host;
3096  const char *displayed_port;
3097 
3098  if (!saveErrorMessage(conn, &savedMessage))
3099  goto error_return;
3100 
3101  conn->status = CONNECTION_OK;
3102  if (!PQconsumeInput(conn))
3103  {
3104  restoreErrorMessage(conn, &savedMessage);
3105  goto error_return;
3106  }
3107 
3108  if (PQisBusy(conn))
3109  {
3111  restoreErrorMessage(conn, &savedMessage);
3112  return PGRES_POLLING_READING;
3113  }
3114 
3115  res = PQgetResult(conn);
3116  if (res && (PQresultStatus(res) == PGRES_TUPLES_OK) &&
3117  PQntuples(res) == 1)
3118  {
3119  char *val;
3120 
3121  val = PQgetvalue(res, 0, 0);
3122  if (strncmp(val, "on", 2) == 0)
3123  {
3124  const char *displayed_host;
3125  const char *displayed_port;
3126 
3127  if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS)
3128  displayed_host = conn->connhost[conn->whichhost].hostaddr;
3129  else
3130  displayed_host = conn->connhost[conn->whichhost].host;
3131  displayed_port = conn->connhost[conn->whichhost].port;
3132  if (displayed_port == NULL || displayed_port[0] == '\0')
3133  displayed_port = DEF_PGPORT_STR;
3134 
3135  PQclear(res);
3136  restoreErrorMessage(conn, &savedMessage);
3137 
3138  /* Not writable; close connection. */
3140  libpq_gettext("could not make a writable "
3141  "connection to server "
3142  "\"%s:%s\"\n"),
3143  displayed_host, displayed_port);
3144  conn->status = CONNECTION_OK;
3145  sendTerminateConn(conn);
3146  pqDropConnection(conn, true);
3147 
3148  /* Skip any remaining addresses for this host. */
3149  conn->addr_cur = NULL;
3150  if (conn->whichhost + 1 < conn->nconnhost)
3151  {
3152  conn->status = CONNECTION_NEEDED;
3153  goto keep_going;
3154  }
3155 
3156  /* No more addresses to try. So we fail. */
3157  goto error_return;
3158  }
3159  PQclear(res);
3160  termPQExpBuffer(&savedMessage);
3161 
3162  /* We can release the address lists now. */
3163  release_all_addrinfo(conn);
3164 
3165  /*
3166  * Finish reading any remaining messages before being
3167  * considered as ready.
3168  */
3169  conn->status = CONNECTION_CONSUME;
3170  goto keep_going;
3171  }
3172 
3173  /*
3174  * Something went wrong with "SHOW transaction_read_only". We
3175  * should try next addresses.
3176  */
3177  if (res)
3178  PQclear(res);
3179  restoreErrorMessage(conn, &savedMessage);
3180 
3181  if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS)
3182  displayed_host = conn->connhost[conn->whichhost].hostaddr;
3183  else
3184  displayed_host = conn->connhost[conn->whichhost].host;
3185  displayed_port = conn->connhost[conn->whichhost].port;
3186  if (displayed_port == NULL || displayed_port[0] == '\0')
3187  displayed_port = DEF_PGPORT_STR;
3189  libpq_gettext("test \"SHOW transaction_read_only\" failed "
3190  "on server \"%s:%s\"\n"),
3191  displayed_host, displayed_port);
3192  conn->status = CONNECTION_OK;
3193  sendTerminateConn(conn);
3194  pqDropConnection(conn, true);
3195 
3196  if (conn->addr_cur->ai_next != NULL ||
3197  conn->whichhost + 1 < conn->nconnhost)
3198  {
3199  conn->addr_cur = conn->addr_cur->ai_next;
3200  conn->status = CONNECTION_NEEDED;
3201  goto keep_going;
3202  }
3203 
3204  /* No more addresses to try. So we fail. */
3205  goto error_return;
3206  }
3207 
3208  default:
3210  libpq_gettext("invalid connection state %d, "
3211  "probably indicative of memory corruption\n"),
3212  conn->status);
3213  goto error_return;
3214  }
3215 
3216  /* Unreachable */
3217 
3218 error_return:
3219 
3220  pgpassfileWarning(conn);
3221 
3222  /*
3223  * We used to close the socket at this point, but that makes it awkward
3224  * for those above us if they wish to remove this socket from their own
3225  * records (an fd_set for example). We'll just have this socket closed
3226  * when PQfinish is called (which is compulsory even after an error, since
3227  * the connection structure must be freed).
3228  */
3229  conn->status = CONNECTION_BAD;
3230  return PGRES_POLLING_FAILED;
3231 }
int pqFlush(PGconn *conn)
Definition: fe-misc.c:961
bool sigpipe_flag
Definition: libpq-int.h:410
int inEnd
Definition: libpq-int.h:433
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
int inStart
Definition: libpq-int.h:431
struct addrinfo * addr_cur
Definition: libpq-int.h:413
char * PQgetvalue(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3118
static int connectNoDelay(PGconn *conn)
Definition: fe-connect.c:1390
int pg_fe_sendauth(AuthRequest areq, int payloadlen, PGconn *conn)
Definition: fe-auth.c:851
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:128
int getpeereid(int sock, uid_t *uid, gid_t *gid)
Definition: getpeereid.c:35
bool sigpipe_so
Definition: libpq-int.h:409
char * pqBuildStartupPacket2(PGconn *conn, int *packetlen, const PQEnvironmentOption *options)
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition: pqexpbuffer.c:385
#define AUTH_REQ_OK
Definition: pqcomm.h:165
int pqCheckInBufferSpace(size_t bytes_needed, PGconn *conn)
Definition: fe-misc.c:408
static void pgpassfileWarning(PGconn *conn)
Definition: fe-connect.c:6497
char * requirepeer
Definition: libpq-int.h:358
char * host
Definition: libpq-int.h:308
struct sockaddr_storage addr
Definition: pqcomm.h:64
char * pqStrerror(int errnum, char *strerrbuf, size_t buflen)
Definition: thread.c:61
static void release_all_addrinfo(PGconn *conn)
Definition: fe-connect.c:3521
static int setKeepalivesIdle(PGconn *conn)
Definition: fe-connect.c:1532
int pqGetInt(int *result, size_t bytes, PGconn *conn)
Definition: fe-misc.c:267
static bool saveErrorMessage(PGconn *conn, PQExpBuffer savedMessage)
Definition: fe-connect.c:1940
#define connect(s, name, namelen)
Definition: win32_port.h:446
static void sendTerminateConn(PGconn *conn)
Definition: fe-connect.c:3549
void pqDropConnection(PGconn *conn, bool flushInput)
Definition: fe-connect.c:424
#define PG_PROTOCOL_MAJOR(v)
Definition: pqcomm.h:104
int PQntuples(const PGresult *res)
Definition: fe-exec.c:2724
#define PG_DIAG_SQLSTATE
Definition: postgres_ext.h:57
uint32 AuthRequest
Definition: pqcomm.h:179
#define AUTH_REQ_MD5
Definition: pqcomm.h:170
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
pg_conn_host_type type
Definition: libpq-int.h:307
PostgresPollingStatusType pqSetenvPoll(PGconn *conn)
Definition: fe-protocol2.c:49
#define SOCK_STRERROR
Definition: libpq-int.h:699
int PQsendQuery(PGconn *conn, const char *query)
Definition: fe-exec.c:1183
PGAsyncStatusType asyncStatus
Definition: libpq-int.h:380
PGSetenvStatusType setenv_state
Definition: libpq-int.h:414
static int useKeepalives(PGconn *conn)
Definition: fe-connect.c:1514
#define pg_hton32(x)
Definition: pg_bswap.h:121
#define IS_AF_UNIX(fam)
Definition: ip.h:24
#define SOCK_ERRNO
Definition: libpq-int.h:698
int pqGetErrorNotice3(PGconn *conn, bool isError)
Definition: fe-protocol3.c:875
void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:262
#define ERRCODE_APPNAME_UNKNOWN
Definition: fe-connect.c:90
char * hostaddr
Definition: libpq-int.h:309
pg_conn_host * connhost
Definition: libpq-int.h:397
int pqReadData(PGconn *conn)
Definition: fe-misc.c:629
bool ssl_in_use
Definition: libpq-int.h:457
const PQEnvironmentOption * next_eo
Definition: libpq-int.h:415
static void restoreErrorMessage(PGconn *conn, PQExpBuffer savedMessage)
Definition: fe-connect.c:1960
char * appname
Definition: libpq-int.h:339
PostgresPollingStatusType pqsecure_open_client(PGconn *conn)
Definition: fe-secure.c:175
ACCEPT_TYPE_ARG3 salen
Definition: pqcomm.h:65
char * target_session_attrs
Definition: libpq-int.h:365
#define STATUS_OK
Definition: c.h:953
pgsocket sock
Definition: libpq-int.h:400
uint32 ProtocolVersion
Definition: pqcomm.h:113
int pqGetc(char *result, PGconn *conn)
Definition: fe-misc.c:94
static void connectFailureMessage(PGconn *conn, int errorno)
Definition: fe-connect.c:1418
#define socket(af, type, protocol)
Definition: win32_port.h:442
SockAddr raddr
Definition: libpq-int.h:403
#define PGINVALID_SOCKET
Definition: port.h:33
int pqsecure_initialize(PGconn *conn)
Definition: fe-secure.c:160
int PQconsumeInput(PGconn *conn)
Definition: fe-exec.c:1682
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition: pqexpbuffer.c:396
char * sslmode
Definition: libpq-int.h:352
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
#define free(a)
Definition: header.h:65
char * PQresultErrorField(const PGresult *res, int fieldcode)
Definition: fe-exec.c:2709
struct addrinfo * addrlist
Definition: libpq-int.h:315
bool pg_set_noblock(pgsocket sock)
Definition: noblock.c:25
int PQisBusy(PGconn *conn)
Definition: fe-exec.c:1732
char * pqBuildStartupPacket3(PGconn *conn, int *packetlen, const PQEnvironmentOption *options)
ProtocolVersion pversion
Definition: libpq-int.h:404
ConnStatusType status
Definition: libpq-int.h:379
bool auth_req_received
Definition: libpq-int.h:406
int uid_t
Definition: win32_port.h:241
static int setKeepalivesInterval(PGconn *conn)
Definition: fe-connect.c:1564
SockAddr laddr
Definition: libpq-int.h:402
PostgresPollingStatusType
Definition: libpq-fe.h:72
struct addrinfo * ai_next
Definition: getaddrinfo.h:107
int pqGetpwuid(uid_t uid, struct passwd *resultbuf, char *buffer, size_t buflen, struct passwd **result)
Definition: thread.c:95
int pqPacketSend(PGconn *conn, char pack_type, const void *buf, size_t buf_len)
Definition: fe-connect.c:3974
int gid_t
Definition: win32_port.h:242
#define EINPROGRESS
Definition: win32_port.h:346
char * fbappname
Definition: libpq-int.h:340
#define EWOULDBLOCK
Definition: win32_port.h:340
size_t ai_addrlen
Definition: getaddrinfo.h:104
int inCursor
Definition: libpq-int.h:432
#define EINTR
Definition: win32_port.h:334
char * port
Definition: libpq-int.h:310
#define NEGOTIATE_SSL_CODE
Definition: pqcomm.h:205
int nconnhost
Definition: libpq-int.h:395
#define PG_PROTOCOL(m, n)
Definition: pqcomm.h:106
int pqGets_append(PQExpBuffer buf, PGconn *conn)
Definition: fe-misc.c:169
long val
Definition: informix.c:689
PGresult * PQgetResult(PGconn *conn)
Definition: fe-exec.c:1753
struct sockaddr * ai_addr
Definition: getaddrinfo.h:105
static int setKeepalivesCount(PGconn *conn)
Definition: fe-connect.c:1597
int whichhost
Definition: libpq-int.h:396
#define libpq_gettext(x)
Definition: libpq-int.h:685
bool send_appname
Definition: libpq-int.h:416
static const PQEnvironmentOption EnvironmentOptions[]
Definition: fe-connect.c:331
int ai_family
Definition: getaddrinfo.h:101

◆ PQconnectStart()

PGconn* PQconnectStart ( const char *  conninfo)

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

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

Referenced by PQconnectdb(), and PQping().

712 {
713  PGconn *conn;
714 
715  /*
716  * Allocate memory for the conn structure
717  */
718  conn = makeEmptyPGconn();
719  if (conn == NULL)
720  return NULL;
721 
722  /*
723  * Parse the conninfo string
724  */
725  if (!connectOptions1(conn, conninfo))
726  return conn;
727 
728  /*
729  * Compute derived options
730  */
731  if (!connectOptions2(conn))
732  return conn;
733 
734  /*
735  * Connect to the database
736  */
737  if (!connectDBStart(conn))
738  {
739  /* Just in case we failed to set it in connectDBStart */
740  conn->status = CONNECTION_BAD;
741  }
742 
743  return conn;
744 }
static bool connectOptions1(PGconn *conn, const char *conninfo)
Definition: fe-connect.c:797
PGconn * conn
Definition: streamutil.c:46
static int connectDBStart(PGconn *conn)
Definition: fe-connect.c:1681
static PGconn * makeEmptyPGconn(void)
Definition: fe-connect.c:3306
ConnStatusType status
Definition: libpq-int.h:379
static bool connectOptions2(PGconn *conn)
Definition: fe-connect.c:895

◆ PQconnectStartParams()

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

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

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

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

635 {
636  PGconn *conn;
637  PQconninfoOption *connOptions;
638 
639  /*
640  * Allocate memory for the conn structure
641  */
642  conn = makeEmptyPGconn();
643  if (conn == NULL)
644  return NULL;
645 
646  /*
647  * Parse the conninfo arrays
648  */
649  connOptions = conninfo_array_parse(keywords, values,
650  &conn->errorMessage,
651  true, expand_dbname);
652  if (connOptions == NULL)
653  {
654  conn->status = CONNECTION_BAD;
655  /* errorMessage is already set */
656  return conn;
657  }
658 
659  /*
660  * Move option values into conn structure
661  */
662  if (!fillPGconn(conn, connOptions))
663  {
664  PQconninfoFree(connOptions);
665  return conn;
666  }
667 
668  /*
669  * Free the option info - all is in conn now
670  */
671  PQconninfoFree(connOptions);
672 
673  /*
674  * Compute derived options
675  */
676  if (!connectOptions2(conn))
677  return conn;
678 
679  /*
680  * Connect to the database
681  */
682  if (!connectDBStart(conn))
683  {
684  /* Just in case we failed to set it in connectDBStart */
685  conn->status = CONNECTION_BAD;
686  }
687 
688  return conn;
689 }
PGconn * conn
Definition: streamutil.c:46
static int connectDBStart(PGconn *conn)
Definition: fe-connect.c:1681
void PQconninfoFree(PQconninfoOption *connOptions)
Definition: fe-connect.c:5956
static PGconn * makeEmptyPGconn(void)
Definition: fe-connect.c:3306
PQExpBufferData errorMessage
Definition: libpq-int.h:493
static bool fillPGconn(PGconn *conn, PQconninfoOption *connOptions)
Definition: fe-connect.c:755
ConnStatusType status
Definition: libpq-int.h:379
static Datum values[MAXATTR]
Definition: bootstrap.c:164
static bool connectOptions2(PGconn *conn)
Definition: fe-connect.c:895
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:5020

◆ PQconninfo()

PQconninfoOption* PQconninfo ( PGconn conn)

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

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

Referenced by exec_command_conninfo(), GenerateRecoveryConf(), and libpqrcv_get_conninfo().

5916 {
5917  PQExpBufferData errorBuf;
5918  PQconninfoOption *connOptions;
5919 
5920  if (conn == NULL)
5921  return NULL;
5922 
5923  /* We don't actually report any errors here, but callees want a buffer */
5924  initPQExpBuffer(&errorBuf);
5925  if (PQExpBufferDataBroken(errorBuf))
5926  return NULL; /* out of memory already :-( */
5927 
5928  connOptions = conninfo_init(&errorBuf);
5929 
5930  if (connOptions != NULL)
5931  {
5933 
5934  for (option = PQconninfoOptions; option->keyword; option++)
5935  {
5936  char **connmember;
5937 
5938  if (option->connofs < 0)
5939  continue;
5940 
5941  connmember = (char **) ((char *) conn + option->connofs);
5942 
5943  if (*connmember)
5944  conninfo_storeval(connOptions, option->keyword, *connmember,
5945  &errorBuf, true, false);
5946  }
5947  }
5948 
5949  termPQExpBuffer(&errorBuf);
5950 
5951  return connOptions;
5952 }
static PQconninfoOption * conninfo_storeval(PQconninfoOption *connOptions, const char *keyword, const char *value, PQExpBuffer errorMessage, bool ignoreMissing, bool uri_decode)
Definition: fe-connect.c:5832
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:128
static PQconninfoOption * conninfo_init(PQExpBuffer errorMessage)
Definition: fe-connect.c:4748
static const internalPQconninfoOption PQconninfoOptions[]
Definition: fe-connect.c:181
#define PQExpBufferDataBroken(buf)
Definition: pqexpbuffer.h:67
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:89

◆ PQconninfoFree()

void PQconninfoFree ( PQconninfoOption connOptions)

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

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

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

5957 {
5959 
5960  if (connOptions == NULL)
5961  return;
5962 
5963  for (option = connOptions; option->keyword != NULL; option++)
5964  {
5965  if (option->val != NULL)
5966  free(option->val);
5967  }
5968  free(connOptions);
5969 }
#define free(a)
Definition: header.h:65

◆ PQconninfoParse()

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

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

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

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

4727 {
4728  PQExpBufferData errorBuf;
4729  PQconninfoOption *connOptions;
4730 
4731  if (errmsg)
4732  *errmsg = NULL; /* default */
4733  initPQExpBuffer(&errorBuf);
4734  if (PQExpBufferDataBroken(errorBuf))
4735  return NULL; /* out of memory already :-( */
4736  connOptions = parse_connection_string(conninfo, &errorBuf, false);
4737  if (connOptions == NULL && errmsg)
4738  *errmsg = errorBuf.data;
4739  else
4740  termPQExpBuffer(&errorBuf);
4741  return connOptions;
4742 }
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:128
static PQconninfoOption * parse_connection_string(const char *conninfo, PQExpBuffer errorMessage, bool use_defaults)
Definition: fe-connect.c:4788
#define PQExpBufferDataBroken(buf)
Definition: pqexpbuffer.h:67
int errmsg(const char *fmt,...)
Definition: elog.c:797
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:89

◆ PQconsumeInput()

int PQconsumeInput ( PGconn conn)

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

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

Referenced by CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), doCustom(), GetIdleSlot(), libpqrcv_PQexec(), libpqrcv_receive(), main(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PQconnectPoll(), StreamLogicalLog(), and try_complete_step().

1683 {
1684  if (!conn)
1685  return 0;
1686 
1687  /*
1688  * for non-blocking connections try to flush the send-queue, otherwise we
1689  * may never get a response for something that may not have already been
1690  * sent because it's in our write buffer!
1691  */
1692  if (pqIsnonblocking(conn))
1693  {
1694  if (pqFlush(conn) < 0)
1695  return 0;
1696  }
1697 
1698  /*
1699  * Load more data, if available. We do this no matter what state we are
1700  * in, since we are probably getting called because the application wants
1701  * to get rid of a read-select condition. Note that we will NOT block
1702  * waiting for more input.
1703  */
1704  if (pqReadData(conn) < 0)
1705  return 0;
1706 
1707  /* Parsing of the data waits till later. */
1708  return 1;
1709 }
int pqFlush(PGconn *conn)
Definition: fe-misc.c:961
#define pqIsnonblocking(conn)
Definition: libpq-int.h:679
int pqReadData(PGconn *conn)
Definition: fe-misc.c:629

◆ PQcopyResult()

PGresult* PQcopyResult ( const PGresult src,
int  flags 
)

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

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

Referenced by pqRowProcessor().

294 {
295  PGresult *dest;
296  int i;
297 
298  if (!src)
299  return NULL;
300 
301  dest = PQmakeEmptyPGresult(NULL, PGRES_TUPLES_OK);
302  if (!dest)
303  return NULL;
304 
305  /* Always copy these over. Is cmdStatus really useful here? */
306  dest->client_encoding = src->client_encoding;
307  strcpy(dest->cmdStatus, src->cmdStatus);
308 
309  /* Wants attrs? */
310  if (flags & (PG_COPYRES_ATTRS | PG_COPYRES_TUPLES))
311  {
312  if (!PQsetResultAttrs(dest, src->numAttributes, src->attDescs))
313  {
314  PQclear(dest);
315  return NULL;
316  }
317  }
318 
319  /* Wants to copy tuples? */
320  if (flags & PG_COPYRES_TUPLES)
321  {
322  int tup,
323  field;
324 
325  for (tup = 0; tup < src->ntups; tup++)
326  {
327  for (field = 0; field < src->numAttributes; field++)
328  {
329  if (!PQsetvalue(dest, tup, field,
330  src->tuples[tup][field].value,
331  src->tuples[tup][field].len))
332  {
333  PQclear(dest);
334  return NULL;
335  }
336  }
337  }
338  }
339 
340  /* Wants to copy notice hooks? */
341  if (flags & PG_COPYRES_NOTICEHOOKS)
342  dest->noticeHooks = src->noticeHooks;
343 
344  /* Wants to copy PGEvents? */
345  if ((flags & PG_COPYRES_EVENTS) && src->nEvents > 0)
346  {
347  dest->events = dupEvents(src->events, src->nEvents);
348  if (!dest->events)
349  {
350  PQclear(dest);
351  return NULL;
352  }
353  dest->nEvents = src->nEvents;
354  }
355 
356  /* Okay, trigger PGEVT_RESULTCOPY event */
357  for (i = 0; i < dest->nEvents; i++)
358  {
359  if (src->events[i].resultInitialized)
360  {
361  PGEventResultCopy evt;
362 
363  evt.src = src;
364  evt.dest = dest;
365  if (!dest->events[i].proc(PGEVT_RESULTCOPY, &evt,
366  dest->events[i].passThrough))
367  {
368  PQclear(dest);
369  return NULL;
370  }
371  dest->events[i].resultInitialized = true;
372  }
373  }
374 
375  return dest;
376 }
static PGEvent * dupEvents(PGEvent *events, int count)
Definition: fe-exec.c:384
const PGresult * src
Definition: libpq-events.h:60
bool resultInitialized
Definition: libpq-int.h:164
int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len)
Definition: fe-exec.c:424
int nEvents
Definition: libpq-int.h:188
PGresAttDesc * attDescs
Definition: libpq-int.h:171
#define PG_COPYRES_TUPLES
Definition: libpq-fe.h:35
PGresAttValue ** tuples
Definition: libpq-int.h:172
#define PG_COPYRES_EVENTS
Definition: libpq-fe.h:36
PGNoticeHooks noticeHooks
Definition: libpq-int.h:186
#define PG_COPYRES_NOTICEHOOKS
Definition: libpq-fe.h:37
int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs)
Definition: fe-exec.c:228
PGresult * PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status)
Definition: fe-exec.c:142
int numAttributes
Definition: libpq-int.h:170
#define PG_COPYRES_ATTRS
Definition: libpq-fe.h:34
void PQclear(PGresult *res)
Definition: fe-exec.c:671
int ntups
Definition: libpq-int.h:169
PGEventProc proc
Definition: libpq-int.h:160
char cmdStatus[CMDSTATUS_LEN]
Definition: libpq-int.h:178
int i
void * passThrough
Definition: libpq-int.h:162
char * value
Definition: libpq-int.h:138
PGEvent * events
Definition: libpq-int.h:187
PGresult * dest
Definition: libpq-events.h:61
int client_encoding
Definition: libpq-int.h:189

◆ PQdb()

◆ PQdescribePortal()

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

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

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

2134 {
2135  if (!PQexecStart(conn))
2136  return NULL;
2137  if (!PQsendDescribe(conn, 'P', portal))
2138  return NULL;
2139  return PQexecFinish(conn);
2140 }
static int PQsendDescribe(PGconn *conn, char desc_type, const char *desc_target)
Definition: fe-exec.c:2178
static PGresult * PQexecFinish(PGconn *conn)
Definition: fe-exec.c:2053
static bool PQexecStart(PGconn *conn)
Definition: fe-exec.c:1979

◆ PQdescribePrepared()

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

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

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

Referenced by DescribeQuery(), and ECPGdescribe().

2115 {
2116  if (!PQexecStart(conn))
2117  return NULL;
2118  if (!PQsendDescribe(conn, 'S', stmt))
2119  return NULL;
2120  return PQexecFinish(conn);
2121 }
static int PQsendDescribe(PGconn *conn, char desc_type, const char *desc_target)
Definition: fe-exec.c:2178
static PGresult * PQexecFinish(PGconn *conn)
Definition: fe-exec.c:2053
static bool PQexecStart(PGconn *conn)
Definition: fe-exec.c:1979

◆ PQdisplayTuples()

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

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

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

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

◆ PQdsplen()

int PQdsplen ( const char *  s,
int  encoding 
)

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

References pg_encoding_dsplen().

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

1191 {
1192  return pg_encoding_dsplen(encoding, s);
1193 }
int pg_encoding_dsplen(int encoding, const char *mbstr)
Definition: wchar.c:1796
static char * encoding
Definition: initdb.c:123

◆ PQencryptPassword()

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

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

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

1133 {
1134  char *crypt_pwd;
1135 
1136  crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
1137  if (!crypt_pwd)
1138  return NULL;
1139 
1140  if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd))
1141  {
1142  free(crypt_pwd);
1143  return NULL;
1144  }
1145 
1146  return crypt_pwd;
1147 }
#define malloc(a)
Definition: header.h:50
bool pg_md5_encrypt(const char *passwd, const char *salt, size_t salt_len, char *buf)
Definition: md5.c:323
#define MD5_PASSWD_LEN
Definition: md5.h:19
#define free(a)
Definition: header.h:65
static char * user
Definition: pg_regress.c:93

◆ PQencryptPasswordConn()

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

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

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

Referenced by exec_command_password(), and main().

1176 {
1177 #define MAX_ALGORITHM_NAME_LEN 50
1178  char algobuf[MAX_ALGORITHM_NAME_LEN + 1];
1179  char *crypt_pwd = NULL;
1180 
1181  if (!conn)
1182  return NULL;
1183 
1184  /* If no algorithm was given, ask the server. */
1185  if (algorithm == NULL)
1186  {
1187  PGresult *res;
1188  char *val;
1189 
1190  res = PQexec(conn, "show password_encryption");
1191  if (res == NULL)
1192  {
1193  /* PQexec() should've set conn->errorMessage already */
1194  return NULL;
1195  }
1196  if (PQresultStatus(res) != PGRES_TUPLES_OK)
1197  {
1198  /* PQexec() should've set conn->errorMessage already */
1199  PQclear(res);
1200  return NULL;
1201  }
1202  if (PQntuples(res) != 1 || PQnfields(res) != 1)
1203  {
1204  PQclear(res);
1206  libpq_gettext("unexpected shape of result set returned for SHOW\n"));
1207  return NULL;
1208  }
1209  val = PQgetvalue(res, 0, 0);
1210 
1211  if (strlen(val) > MAX_ALGORITHM_NAME_LEN)
1212  {
1213  PQclear(res);
1215  libpq_gettext("password_encryption value too long\n"));
1216  return NULL;
1217  }
1218  strcpy(algobuf, val);
1219  PQclear(res);
1220 
1221  algorithm = algobuf;
1222  }
1223 
1224  /*
1225  * Also accept "on" and "off" as aliases for "md5", because
1226  * password_encryption was a boolean before PostgreSQL 10. We refuse to
1227  * send the password in plaintext even if it was "off".
1228  */
1229  if (strcmp(algorithm, "on") == 0 ||
1230  strcmp(algorithm, "off") == 0)
1231  algorithm = "md5";
1232 
1233  /*
1234  * Ok, now we know what algorithm to use
1235  */
1236  if (strcmp(algorithm, "scram-sha-256") == 0)
1237  {
1238  crypt_pwd = pg_fe_scram_build_verifier(passwd);
1239  }
1240  else if (strcmp(algorithm, "md5") == 0)
1241  {
1242  crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
1243  if (crypt_pwd)
1244  {
1245  if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd))
1246  {
1247  free(crypt_pwd);
1248  crypt_pwd = NULL;
1249  }
1250  }
1251  }
1252  else
1253  {
1255  libpq_gettext("unrecognized password encryption algorithm \"%s\"\n"),
1256  algorithm);
1257  return NULL;
1258  }
1259 
1260  if (!crypt_pwd)
1262  libpq_gettext("out of memory\n"));
1263 
1264  return crypt_pwd;
1265 }
int PQnfields(const PGresult *res)
Definition: fe-exec.c:2732
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
char * PQgetvalue(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3118
int PQntuples(const PGresult *res)
Definition: fe-exec.c:2724
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:2647
#define malloc(a)
Definition: header.h:50
#define MAX_ALGORITHM_NAME_LEN
bool pg_md5_encrypt(const char *passwd, const char *salt, size_t salt_len, char *buf)
Definition: md5.c:323
PQExpBufferData errorMessage
Definition: libpq-int.h:493
void PQclear(PGresult *res)
Definition: fe-exec.c:671
#define MD5_PASSWD_LEN
Definition: md5.h:19
#define free(a)
Definition: header.h:65
char * pg_fe_scram_build_verifier(const char *password)
static char * user
Definition: pg_regress.c:93
PGresult * PQexec(PGconn *conn, const char *query)
Definition: fe-exec.c:1897
long val
Definition: informix.c:689
#define libpq_gettext(x)
Definition: libpq-int.h:685

◆ PQendcopy()

int PQendcopy ( PGconn conn)

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

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

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

2574 {
2575  if (!conn)
2576  return 0;
2577 
2578  if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
2579  return pqEndcopy3(conn);
2580  else
2581  return pqEndcopy2(conn);
2582 }
#define PG_PROTOCOL_MAJOR(v)
Definition: pqcomm.h:104
int pqEndcopy3(PGconn *conn)
ProtocolVersion pversion
Definition: libpq-int.h:404
int pqEndcopy2(PGconn *conn)

◆ PQenv2encoding()

int PQenv2encoding ( void  )

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

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

Referenced by main().

1200 {
1201  char *str;
1202  int encoding = PG_SQL_ASCII;
1203 
1204  str = getenv("PGCLIENTENCODING");
1205  if (str && *str != '\0')
1206  {
1207  encoding = pg_char_to_encoding(str);
1208  if (encoding < 0)
1209  encoding = PG_SQL_ASCII;
1210  }
1211  return encoding;
1212 }
int pg_char_to_encoding(const char *name)
Definition: encnames.c:551
static char * encoding
Definition: initdb.c:123

◆ PQerrorMessage()

char* PQerrorMessage ( const PGconn conn)

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

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

Referenced by _connectDB(), _doSetSessionAuth(), _doSetWithOids(), _selectOutputSchema(), _selectTablespace(), AcceptResult(), BaseBackup(), check_conn(), check_loadable_libraries(), CheckCopyStreamStop(), cluster_one_database(), connect_pg_server(), connectDatabase(), ConnectDatabase(), connectToServer(), CopyStreamPoll(), CopyStreamReceive(), CreateReplicationSlot(), dblink_connect(), dblink_error_message(), dblink_get_conn(), dblink_res_error(), dblink_send_query(), DescribeQuery(), die_on_query_failure(), do_connect(), do_lo_export(), do_lo_import(), do_lo_unlink(), doConnect(), doCustom(), DropReplicationSlot(), dumpBlobs(), dumpTableData_copy(), ecpg_check_PQresult(), ecpg_raise_backend(), ECPGconnect(), EndDBCopyMode(), exec_command_password(), executeCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlCommandBuf(), executeStatement(), fetch_file_range(), GetConnection(), GetQueryResult(), handleCopyIn(), handleCopyOut(), HandleEndOfCopyStream(), init_slot(), initGenerateData(), libpq_executeFileMap(), libpqConnect(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_send(), libpqrcv_startstreaming(), main(), my_truncate(), overwrite(), pg_attribute_noreturn(), pgfdw_report_error(), pickout(), ProcessXLogDataMsg(), psql_get_variable(), ReceiveAndUnpackTarFile(), receiveFileChunks(), ReceiveTarFile(), ReceiveXlogStream(), reindex_one_database(), reindex_system_catalogs(), RetrieveWalSegSize(), run_permutation(), run_vacuum_command(), RunIdentifySystem(), sendCommand(), sendFeedback(), SendQuery(), sql_conn(), sql_exec(), start_postmaster(), StartRestoreBlob(), storeQueryResult(), StreamLogicalLog(), threadRun(), try_complete_step(), tryExecuteStatement(), and vacuumlo().

6107 {
6108  if (!conn)
6109  return libpq_gettext("connection pointer is NULL\n");
6110 
6111  return conn->errorMessage.data;
6112 }
PQExpBufferData errorMessage
Definition: libpq-int.h:493
#define libpq_gettext(x)
Definition: libpq-int.h:685

◆ PQescapeBytea()

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

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

References PQescapeByteaInternal(), and static_std_strings.

3682 {
3683  return PQescapeByteaInternal(NULL, from, from_length, to_length,
3685  false /* can't use hex */ );
3686 }
static bool static_std_strings
Definition: fe-exec.c:51
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:3572

◆ PQescapeByteaConn()

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

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

References PQescapeByteaInternal(), pg_conn::std_strings, and pg_conn::sversion.

3672 {
3673  if (!conn)
3674  return NULL;
3675  return PQescapeByteaInternal(conn, from, from_length, to_length,
3676  conn->std_strings,
3677  (conn->sversion >= 90000));
3678 }
int sversion
Definition: libpq-int.h:405
bool std_strings
Definition: libpq-int.h:423
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:3572

◆ PQescapeIdentifier()

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

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

References PQescapeInternal().

Referenced by initCreatePKeys(), initCreateTables(), psql_get_variable(), stringlist_to_identifierstr(), and vacuumlo().

3526 {
3527  return PQescapeInternal(conn, str, len, true);
3528 }
static char * PQescapeInternal(PGconn *conn, const char *str, size_t len, bool as_ident)
Definition: fe-exec.c:3398

◆ PQescapeLiteral()

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

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

References PQescapeInternal().

Referenced by DescribeQuery(), libpqrcv_startstreaming(), and psql_get_variable().

3520 {
3521  return PQescapeInternal(conn, str, len, false);
3522 }
static char * PQescapeInternal(PGconn *conn, const char *str, size_t len, bool as_ident)
Definition: fe-exec.c:3398

◆ PQescapeString()

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

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

References PQescapeStringInternal(), static_client_encoding, and static_std_strings.

Referenced by get_comma_elts(), and quote_postgres().

3384 {
3385  return PQescapeStringInternal(NULL, to, from, length, NULL,
3388 }
static bool static_std_strings
Definition: fe-exec.c:51
int length(const List *list)
Definition: list.c:1271
static int static_client_encoding
Definition: fe-exec.c:50
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:3290

◆ PQescapeStringConn()

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

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

References pg_conn::client_encoding, PQescapeStringInternal(), and pg_conn::std_strings.

Referenced by appendStringLiteralConn(), BaseBackup(), check_loadable_libraries(), and do_lo_import().

3368 {
3369  if (!conn)
3370  {
3371  /* force empty-string result */
3372  *to = '\0';
3373  if (error)
3374  *error = 1;
3375  return 0;
3376  }
3377  return PQescapeStringInternal(conn, to, from, length, error,
3378  conn->client_encoding,
3379  conn->std_strings);
3380 }
int length(const List *list)
Definition: list.c:1271
static void error(void)
Definition: sql-dyntest.c:147
bool std_strings
Definition: libpq-int.h:423
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:3290
int client_encoding
Definition: libpq-int.h:422

◆ PQexec()

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

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

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

Referenced by _doSetSessionAuth(), _doSetWithOids(), _selectOutputSchema(), _selectTablespace(), check_loadable_libraries(), CreateReplicationSlot(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), deallocate_one(), DescribeQuery(), DropReplicationSlot(), ecpg_autostart_transaction(), ecpg_execute(), ecpg_is_type_an_array(), ECPGsetcommit(), ECPGtrans(), ExecQueryUsingCursor(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), get_create_object_cmd(), initGenerateData(), libpq_executeFileMap(), libpqConnect(), libpqProcessFileList(), lo_initialize(), lockTableForWorker(), lookup_object_oid(), main(), pgfdw_xact_callback(), PQencryptPasswordConn(), PQsetClientEncoding(), PSQLexec(), PSQLexecWatch(), ReceiveXlogStream(), RetrieveWalSegSize(), run_permutation(), run_simple_query(), RunIdentifySystem(), SendQuery(), sql_exec(), StreamLogicalLog(), tryExecuteStatement(), and vacuumlo().

1898 {
1899  if (!PQexecStart(conn))
1900  return NULL;
1901  if (!PQsendQuery(conn, query))
1902  return NULL;
1903  return PQexecFinish(conn);
1904 }
int PQsendQuery(PGconn *conn, const char *query)
Definition: fe-exec.c:1183
static PGresult * PQexecFinish(PGconn *conn)
Definition: fe-exec.c:2053
static bool PQexecStart(PGconn *conn)
Definition: fe-exec.c:1979

◆ 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 1911 of file fe-exec.c.

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

Referenced by ecpg_execute(), libpqGetFile(), and main().

1919 {
1920  if (!PQexecStart(conn))
1921  return NULL;
1922  if (!PQsendQueryParams(conn, command,
1923  nParams, paramTypes, paramValues, paramLengths,
1924  paramFormats, resultFormat))
1925  return NULL;
1926  return PQexecFinish(conn);
1927 }
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:1234
static PGresult * PQexecFinish(PGconn *conn)
Definition: fe-exec.c:2053
static bool PQexecStart(PGconn *conn)
Definition: fe-exec.c:1979

◆ 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 1958 of file fe-exec.c.

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

Referenced by ecpg_execute(), and try_complete_step().

1965 {
1966  if (!PQexecStart(conn))
1967  return NULL;
1968  if (!PQsendQueryPrepared(conn, stmtName,
1969  nParams, paramValues, paramLengths,
1970  paramFormats, resultFormat))
1971  return NULL;
1972  return PQexecFinish(conn);
1973 }
static PGresult * PQexecFinish(PGconn *conn)
Definition: fe-exec.c:2053
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:1376
static bool PQexecStart(PGconn *conn)
Definition: fe-exec.c:1979

◆ PQfformat()

int PQfformat ( const PGresult res,
int  field_num 
)

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

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

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

2952 {
2953  if (!check_field_number(res, field_num))
2954  return 0;
2955  if (res->attDescs)
2956  return res->attDescs[field_num].format;
2957  else
2958  return 0;
2959 }
PGresAttDesc * attDescs
Definition: libpq-int.h:171
static int check_field_number(const PGresult *res, int field_num)
Definition: fe-exec.c:2753

◆ PQfinish()

void PQfinish ( PGconn conn)

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

References closePGconn(), and freePGconn().

Referenced by _connectDB(), BaseBackup(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_is_install_user(), check_loadable_libraries(), check_proper_datallowconn(), CheckConnection(), cluster_all_databases(), cluster_one_database(), connect_pg_server(), connectDatabase(), ConnectDatabase(), connectToServer(), createNewConnection(), dblink_connect(), dblink_disconnect(), dblink_exec(), dblink_get_conn(), dblink_record_internal(), dblink_security_check(), disconnect_all(), disconnect_and_exit(), disconnect_pg_server(), DisconnectDatabase(), do_connect(), doConnect(), doCustom(), dumpCreateDB(), dumpTablespaces(), ecpg_finish(), executeCommand(), executeQuery(), executeQueryOrDie(), exit_nicely(), get_db_infos(), get_loadable_libraries(), get_rel_infos(), get_tablespace_paths(), GetConnection(), libpqrcv_disconnect(), LogStreamerMain(), main(), new_9_0_populate_pg_largeobject_metadata(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), PQping(), PQpingParams(), ReconnectToServer(), reindex_all_databases(), reindex_one_database(), reindex_system_catalogs(), run_vacuum_command(), runInitSteps(), set_frozenxids(), sql_conn(), sql_exec(), start_postmaster(), StreamLog(), StreamLogicalLog(), threadRun(), vacuum_all_databases(), and vacuumlo().

3630 {
3631  if (conn)
3632  {
3633  closePGconn(conn);
3634  freePGconn(conn);
3635  }
3636 }
static void closePGconn(PGconn *conn)
Definition: fe-connect.c:3576
static void freePGconn(PGconn *conn)
Definition: fe-connect.c:3402

◆ PQflush()

int PQflush ( PGconn conn)

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

References pqFlush().

Referenced by CheckCopyStreamStop(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), libpqrcv_send(), prepareToTerminate(), ProcessXLogDataMsg(), and sendFeedback().

3239 {
3240  return pqFlush(conn);
3241 }
int pqFlush(PGconn *conn)
Definition: fe-misc.c:961

◆ PQfmod()

int PQfmod ( const PGresult res,
int  field_num 
)

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

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

Referenced by DescribeQuery(), and ECPGget_desc().

2985 {
2986  if (!check_field_number(res, field_num))
2987  return 0;
2988  if (res->attDescs)
2989  return res->attDescs[field_num].atttypmod;
2990  else
2991  return 0;
2992 }
PGresAttDesc * attDescs
Definition: libpq-int.h:171
int atttypmod
Definition: libpq-fe.h:243
static int check_field_number(const PGresult *res, int field_num)
Definition: fe-exec.c:2753

◆ 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 2607 of file fe-exec.c.

References pg_conn::asyncStatus, pg_conn::errorMessage, libpq_gettext, PG_PROTOCOL_MAJOR, PGASYNC_IDLE, PGINVALID_SOCKET, pqFunctionCall2(), pqFunctionCall3(), printfPQExpBuffer(), pg_conn::pversion, resetPQExpBuffer(), pg_conn::result, 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().

2614 {
2615  *result_len = 0;
2616 
2617  if (!conn)
2618  return NULL;
2619 
2620  /* clear the error string */
2622 
2623  if (conn->sock == PGINVALID_SOCKET || conn->asyncStatus != PGASYNC_IDLE ||
2624  conn->result != NULL)
2625  {
2627  libpq_gettext("connection in wrong state\n"));
2628  return NULL;
2629  }
2630 
2631  if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
2632  return pqFunctionCall3(conn, fnid,
2633  result_buf, result_len,
2634  result_is_int,
2635  args, nargs);
2636  else
2637  return pqFunctionCall2(conn, fnid,
2638  result_buf, result_len,
2639  result_is_int,
2640  args, nargs);
2641 }
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:234
PGresult * pqFunctionCall2(PGconn *conn, Oid fnid, int *result_buf, int *actual_result_len, int result_is_int, const PQArgBlock *args, int nargs)