#include "postgres_fe.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
#include <netdb.h>
#include <time.h>
#include <unistd.h>
#include "common/ip.h"
#include "common/link-canary.h"
#include "common/scram-common.h"
#include "common/string.h"
#include "fe-auth.h"
#include "libpq-fe.h"
#include "libpq-int.h"
#include "mb/pg_wchar.h"
#include "pg_config_paths.h"
#include "port/pg_bswap.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <pthread.h>

Include dependency graph for fe-connect.c:

Data Structures
struct	_internalPQconninfoOption

Macros
#define	PGPASSFILE ".pgpass"

#define	ERRCODE_APPNAME_UNKNOWN "42704"

#define	ERRCODE_INVALID_PASSWORD "28P01"

#define	ERRCODE_CANNOT_CONNECT_NOW "57P03"

#define	DefaultHost "localhost"

#define	DefaultOption ""

#define	DefaultChannelBinding "disable"

#define	DefaultTargetSessionAttrs "any"

#define	DefaultLoadBalanceHosts "disable"

#define	DefaultSSLMode "disable"

#define	DefaultSSLCertMode "disable"

#define	DefaultGSSMode "disable"

#define	MAX_ERRLEN 30000

Typedefs
typedef struct _internalPQconninfoOption	internalPQconninfoOption

Functions
static bool	connectOptions1 (PGconn conn, const char conninfo)

static bool	connectOptions2 (PGconn *conn)

static int	connectDBStart (PGconn *conn)

static int	connectDBComplete (PGconn *conn)

static PGPing	internal_ping (PGconn *conn)

static PGconn *	makeEmptyPGconn (void)

static void	pqFreeCommandQueue (PGcmdQueueEntry *queue)

static bool	fillPGconn (PGconn conn, PQconninfoOption connOptions)

static void	freePGconn (PGconn *conn)

static void	closePGconn (PGconn *conn)

static void	release_conn_addrinfo (PGconn *conn)

static int	store_conn_addrinfo (PGconn conn, struct addrinfo addrlist)

static void	sendTerminateConn (PGconn *conn)

static PQconninfoOption *	conninfo_init (PQExpBuffer errorMessage)

static PQconninfoOption *	parse_connection_string (const char *connstr, PQExpBuffer errorMessage, bool use_defaults)

static int	uri_prefix_length (const char *connstr)

static bool	recognized_connection_string (const char *connstr)

static PQconninfoOption *	conninfo_parse (const char *conninfo, PQExpBuffer errorMessage, bool use_defaults)

static PQconninfoOption *	conninfo_array_parse (const char const keywords, const char const values, PQExpBuffer errorMessage, bool use_defaults, int expand_dbname)

static bool	conninfo_add_defaults (PQconninfoOption *options, PQExpBuffer errorMessage)

static PQconninfoOption *	conninfo_uri_parse (const char *uri, PQExpBuffer errorMessage, bool use_defaults)

static bool	conninfo_uri_parse_options (PQconninfoOption options, const char uri, PQExpBuffer errorMessage)

static bool	conninfo_uri_parse_params (char params, PQconninfoOption connOptions, PQExpBuffer errorMessage)

static char *	conninfo_uri_decode (const char *str, PQExpBuffer errorMessage)

static bool	get_hexdigit (char digit, int *value)

static const char *	conninfo_getval (PQconninfoOption connOptions, const char keyword)

static PQconninfoOption *	conninfo_storeval (PQconninfoOption connOptions, const char keyword, const char *value, PQExpBuffer errorMessage, bool ignoreMissing, bool uri_decode)

static PQconninfoOption *	conninfo_find (PQconninfoOption connOptions, const char keyword)

static void	defaultNoticeReceiver (void arg, const PGresult res)

static void	defaultNoticeProcessor (void arg, const char message)

static int	parseServiceInfo (PQconninfoOption *options, PQExpBuffer errorMessage)

static int	parseServiceFile (const char serviceFile, const char service, PQconninfoOption options, PQExpBuffer errorMessage, bool group_found)

static char *	pwdfMatchesString (char buf, const char token)

static char *	passwordFromFile (const char hostname, const char port, const char dbname, const char username, const char *pgpassfile)

static void	pgpassfileWarning (PGconn *conn)

static void	default_threadlock (int acquire)

static bool	sslVerifyProtocolVersion (const char *version)

static bool	sslVerifyProtocolRange (const char min, const char max)

static bool	parse_int_param (const char value, int result, PGconn conn, const char context)

void	pqDropConnection (PGconn *conn, bool flushInput)

static void	pqDropServerData (PGconn *conn)

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

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

PGconn *	PQconnectdb (const char *conninfo)

PGPing	PQping (const char *conninfo)

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

PGconn *	PQconnectStart (const char *conninfo)

static int	count_comma_separated_elems (const char *input)

static char *	parse_comma_separated_list (char *startptr, bool more)

static void	libpq_prng_init (PGconn *conn)

PQconninfoOption *	PQconndefaults (void)

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

static int	connectNoDelay (PGconn *conn)

static void	getHostaddr (PGconn conn, char host_addr, int host_addr_len)

static void	emitHostIdentityInfo (PGconn conn, const char host_addr)

static void	connectFailureMessage (PGconn *conn, int errorno)

static int	useKeepalives (PGconn *conn)

static int	setKeepalivesIdle (PGconn *conn)

static int	setKeepalivesInterval (PGconn *conn)

static int	setKeepalivesCount (PGconn *conn)

static int	setTCPUserTimeout (PGconn *conn)

PostgresPollingStatusType	PQconnectPoll (PGconn *conn)

void	PQfinish (PGconn *conn)

void	PQreset (PGconn *conn)

int	PQresetStart (PGconn *conn)

PostgresPollingStatusType	PQresetPoll (PGconn *conn)

PGcancel *	PQgetCancel (PGconn *conn)

void	PQfreeCancel (PGcancel *cancel)

static bool	optional_setsockopt (int fd, int protoid, int optid, int value)

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

int	PQrequestCancel (PGconn *conn)

int	pqPacketSend (PGconn conn, char pack_type, const void buf, size_t buf_len)

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

PQconninfoOption *	PQconninfo (PGconn *conn)

void	PQconninfoFree (PQconninfoOption *connOptions)

char *	PQdb (const PGconn *conn)

char *	PQuser (const PGconn *conn)

char *	PQpass (const PGconn *conn)

char *	PQhost (const PGconn *conn)

char *	PQhostaddr (const PGconn *conn)

char *	PQport (const PGconn *conn)

char *	PQtty (const PGconn *conn)

char *	PQoptions (const PGconn *conn)

ConnStatusType	PQstatus (const PGconn *conn)

PGTransactionStatusType	PQtransactionStatus (const PGconn *conn)

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

int	PQprotocolVersion (const PGconn *conn)

int	PQserverVersion (const PGconn *conn)

char *	PQerrorMessage (const PGconn *conn)

int	PQsocket (const PGconn *conn)

int	PQbackendPID (const PGconn *conn)

PGpipelineStatus	PQpipelineStatus (const PGconn *conn)

int	PQconnectionNeedsPassword (const PGconn *conn)

int	PQconnectionUsedPassword (const PGconn *conn)

int	PQconnectionUsedGSSAPI (const PGconn *conn)

int	PQclientEncoding (const PGconn *conn)

int	PQsetClientEncoding (PGconn conn, const char encoding)

PGVerbosity	PQsetErrorVerbosity (PGconn *conn, PGVerbosity verbosity)

PGContextVisibility	PQsetErrorContextVisibility (PGconn *conn, PGContextVisibility show_context)

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

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

bool	pqGetHomeDirectory (char *buf, int bufsize)

pgthreadlock_t	PQregisterThreadLock (pgthreadlock_t newhandler)

Variables
static const internalPQconninfoOption	PQconninfoOptions []

static const PQEnvironmentOption	EnvironmentOptions []

static const char	uri_designator [] = "postgresql://"

static const char	short_uri_designator [] = "postgres://"

pgthreadlock_t	pg_g_threadlock = default_threadlock

Macro Definition Documentation

◆ DefaultChannelBinding

#define DefaultChannelBinding "disable"

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

◆ DefaultGSSMode

#define DefaultGSSMode "disable"

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

◆ DefaultHost

#define DefaultHost "localhost"

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

◆ DefaultLoadBalanceHosts

#define DefaultLoadBalanceHosts "disable"

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

◆ DefaultOption

#define DefaultOption ""

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

◆ DefaultSSLCertMode

#define DefaultSSLCertMode "disable"

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

◆ DefaultSSLMode

#define DefaultSSLMode "disable"

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

◆ DefaultTargetSessionAttrs

#define DefaultTargetSessionAttrs "any"

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

◆ ERRCODE_APPNAME_UNKNOWN

#define ERRCODE_APPNAME_UNKNOWN "42704"

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

◆ ERRCODE_CANNOT_CONNECT_NOW

#define ERRCODE_CANNOT_CONNECT_NOW "57P03"

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

◆ ERRCODE_INVALID_PASSWORD

#define ERRCODE_INVALID_PASSWORD "28P01"

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

◆ MAX_ERRLEN

#define MAX_ERRLEN 30000

◆ PGPASSFILE

#define PGPASSFILE ".pgpass"

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

Typedef Documentation

◆ internalPQconninfoOption

typedef struct _internalPQconninfoOption internalPQconninfoOption

Function Documentation

◆ closePGconn()

static void closePGconn ( PGconn * conn )

static

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

 {
     /*
      * If possible, send Terminate message to close the connection politely.
      */
     sendTerminateConn(conn);
  
     /*
      * Must reset the blocking status so a possible reconnect will work.
      *
      * Don't call PQsetnonblocking() because it will fail if it's unable to
      * flush the connection.
      */
     conn->nonblocking = false;
  
     /*
      * Close the connection, reset all transient state, flush I/O buffers.
      * Note that this includes clearing conn's error state; we're no longer
      * interested in any failures associated with the old connection, and we
      * want a clean slate for any new connection attempt.
      */
     pqDropConnection(conn, true);
     conn->status = CONNECTION_BAD;  /* Well, not really _bad_ - just absent */
     conn->asyncStatus = PGASYNC_IDLE;
     conn->xactStatus = PQTRANS_IDLE;
     conn->pipelineStatus = PQ_PIPELINE_OFF;
     pqClearAsyncResult(conn);   /* deallocate result */
     pqClearConnErrorState(conn);
     release_conn_addrinfo(conn);
  
     /* Reset all state obtained from server, too */
     pqDropServerData(conn);
 }

References pg_conn::asyncStatus, conn, CONNECTION_BAD, pg_conn::nonblocking, PGASYNC_IDLE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqClearAsyncResult(), pqClearConnErrorState, pqDropConnection(), pqDropServerData(), PQTRANS_IDLE, release_conn_addrinfo(), sendTerminateConn(), pg_conn::status, and pg_conn::xactStatus.

Referenced by PQfinish(), PQreset(), and PQresetStart().

◆ connectDBComplete()

static int connectDBComplete ( PGconn * conn )

static

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

 {
     PostgresPollingStatusType flag = PGRES_POLLING_WRITING;
     time_t      finish_time = ((time_t) -1);
     int         timeout = 0;
     int         last_whichhost = -2;    /* certainly different from whichhost */
     int         last_whichaddr = -2;    /* certainly different from whichaddr */
  
     if (conn == NULL || conn->status == CONNECTION_BAD)
         return 0;
  
     /*
      * Set up a time limit, if connect_timeout isn't zero.
      */
     if (conn->connect_timeout != NULL)
     {
         if (!parse_int_param(conn->connect_timeout, &timeout, conn,
                              "connect_timeout"))
         {
             /* mark the connection as bad to report the parsing failure */
             conn->status = CONNECTION_BAD;
             return 0;
         }
  
         if (timeout > 0)
         {
             /*
              * Rounding could cause connection to fail unexpectedly quickly;
              * to prevent possibly waiting hardly-at-all, insist on at least
              * two seconds.
              */
             if (timeout < 2)
                 timeout = 2;
         }
         else                    /* negative means 0 */
             timeout = 0;
     }
  
     for (;;)
     {
         int         ret = 0;
  
         /*
          * (Re)start the connect_timeout timer if it's active and we are
          * considering a different host than we were last time through.  If
          * we've already succeeded, though, needn't recalculate.
          */
         if (flag != PGRES_POLLING_OK &&
             timeout > 0 &&
             (conn->whichhost != last_whichhost ||
              conn->whichaddr != last_whichaddr))
         {
             finish_time = time(NULL) + timeout;
             last_whichhost = conn->whichhost;
             last_whichaddr = conn->whichaddr;
         }
  
         /*
          * Wait, if necessary.  Note that the initial state (just after
          * PQconnectStart) is to wait for the socket to select for writing.
          */
         switch (flag)
         {
             case PGRES_POLLING_OK:
                 return 1;       /* success! */
  
             case PGRES_POLLING_READING:
                 ret = pqWaitTimed(1, 0, conn, finish_time);
                 if (ret == -1)
                 {
                     /* hard failure, eg select() problem, aborts everything */
                     conn->status = CONNECTION_BAD;
                     return 0;
                 }
                 break;
  
             case PGRES_POLLING_WRITING:
                 ret = pqWaitTimed(0, 1, conn, finish_time);
                 if (ret == -1)
                 {
                     /* hard failure, eg select() problem, aborts everything */
                     conn->status = CONNECTION_BAD;
                     return 0;
                 }
                 break;
  
             default:
                 /* Just in case we failed to set it in PQconnectPoll */
                 conn->status = CONNECTION_BAD;
                 return 0;
         }
  
         if (ret == 1)           /* connect_timeout elapsed */
         {
             /*
              * Give up on current server/address, try the next one.
              */
             conn->try_next_addr = true;
             conn->status = CONNECTION_NEEDED;
         }
  
         /*
          * Now try to advance the state machine.
          */
         flag = PQconnectPoll(conn);
     }
 }

References conn, pg_conn::connect_timeout, CONNECTION_BAD, CONNECTION_NEEDED, flag(), parse_int_param(), PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PQconnectPoll(), pqWaitTimed(), pg_conn::status, pg_conn::try_next_addr, pg_conn::whichaddr, and pg_conn::whichhost.

Referenced by internal_ping(), PQconnectdb(), PQconnectdbParams(), PQreset(), and PQsetdbLogin().

◆ connectDBStart()

static int connectDBStart ( PGconn * conn )

static

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

 {
     if (!conn)
         return 0;
  
     if (!conn->options_valid)
         goto connect_errReturn;
  
     /*
      * Check for bad linking to backend-internal versions of src/common
      * functions (see comments in link-canary.c for the reason we need this).
      * Nobody but developers should see this message, so we don't bother
      * translating it.
      */
     if (!pg_link_canary_is_frontend())
     {
         appendPQExpBufferStr(&conn->errorMessage,
                              "libpq is incorrectly linked to backend functions\n");
         goto connect_errReturn;
     }
  
     /* Ensure our buffers are empty */
     conn->inStart = conn->inCursor = conn->inEnd = 0;
     conn->outCount = 0;
  
     /*
      * Set up to try to connect to the first host.  (Setting whichhost = -1 is
      * a bit of a cheat, but PQconnectPoll will advance it to 0 before
      * anything else looks at it.)
      */
     conn->whichhost = -1;
     conn->try_next_addr = false;
     conn->try_next_host = true;
     conn->status = CONNECTION_NEEDED;
  
     /* Also reset the target_server_type state if needed */
     if (conn->target_server_type == SERVER_TYPE_PREFER_STANDBY_PASS2)
         conn->target_server_type = SERVER_TYPE_PREFER_STANDBY;
  
     /*
      * The code for processing CONNECTION_NEEDED state is in PQconnectPoll(),
      * so that it can easily be re-executed if needed again during the
      * asynchronous startup process.  However, we must run it once here,
      * because callers expect a success return from this routine to mean that
      * we are in PGRES_POLLING_WRITING connection state.
      */
     if (PQconnectPoll(conn) == PGRES_POLLING_WRITING)
         return 1;
  
 connect_errReturn:
  
     /*
      * If we managed to open a socket, close it immediately rather than
      * waiting till PQfinish.  (The application cannot have gotten the socket
      * from PQsocket yet, so this doesn't risk breaking anything.)
      */
     pqDropConnection(conn, true);
     conn->status = CONNECTION_BAD;
     return 0;
 }

References appendPQExpBufferStr(), conn, CONNECTION_BAD, CONNECTION_NEEDED, pg_conn::errorMessage, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, pg_conn::options_valid, pg_conn::outCount, pg_link_canary_is_frontend(), PGRES_POLLING_WRITING, PQconnectPoll(), pqDropConnection(), SERVER_TYPE_PREFER_STANDBY, SERVER_TYPE_PREFER_STANDBY_PASS2, pg_conn::status, pg_conn::target_server_type, pg_conn::try_next_addr, pg_conn::try_next_host, and pg_conn::whichhost.

Referenced by PQconnectStart(), PQconnectStartParams(), PQreset(), PQresetStart(), and PQsetdbLogin().

◆ connectFailureMessage()

static void connectFailureMessage	(	PGconn *	conn,
		int	errorno
	)

static

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

 {
     char        sebuf[PG_STRERROR_R_BUFLEN];
  
     appendPQExpBuffer(&conn->errorMessage,
                       "%s\n",
                       SOCK_STRERROR(errorno, sebuf, sizeof(sebuf)));
  
     if (conn->raddr.addr.ss_family == AF_UNIX)
         libpq_append_conn_error(conn, "\tIs the server running locally and accepting connections on that socket?");
     else
         libpq_append_conn_error(conn, "\tIs the server running on that host and accepting TCP/IP connections?");
 }

References SockAddr::addr, appendPQExpBuffer(), conn, pg_conn::errorMessage, libpq_append_conn_error(), PG_STRERROR_R_BUFLEN, pg_conn::raddr, and SOCK_STRERROR.

Referenced by PQconnectPoll().

◆ connectNoDelay()

static int connectNoDelay ( PGconn * conn )

static

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

 {
 #ifdef  TCP_NODELAY
     int         on = 1;
  
     if (setsockopt(conn->sock, IPPROTO_TCP, TCP_NODELAY,
                    (char *) &on,
                    sizeof(on)) < 0)
     {
         char        sebuf[PG_STRERROR_R_BUFLEN];
  
         libpq_append_conn_error(conn, "could not set socket to TCP no delay mode: %s",
                                 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
         return 0;
     }
 #endif
  
     return 1;
 }

References conn, libpq_append_conn_error(), PG_STRERROR_R_BUFLEN, pg_conn::sock, SOCK_ERRNO, and SOCK_STRERROR.

Referenced by PQconnectPoll().

◆ connectOptions1()

static bool connectOptions1	(	PGconn *	conn,
		const char *	conninfo
	)

static

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

 {
     PQconninfoOption *connOptions;
  
     /*
      * Parse the conninfo string
      */
     connOptions = parse_connection_string(conninfo, &conn->errorMessage, true);
     if (connOptions == NULL)
     {
         conn->status = CONNECTION_BAD;
         /* errorMessage is already set */
         return false;
     }
  
     /*
      * Move option values into conn structure
      */
     if (!fillPGconn(conn, connOptions))
     {
         conn->status = CONNECTION_BAD;
         PQconninfoFree(connOptions);
         return false;
     }
  
     /*
      * Free the option info - all is in conn now
      */
     PQconninfoFree(connOptions);
  
     return true;
 }

References conn, CONNECTION_BAD, pg_conn::errorMessage, fillPGconn(), parse_connection_string(), PQconninfoFree(), and pg_conn::status.

Referenced by PQconnectStart(), and PQsetdbLogin().

◆ connectOptions2()

static bool connectOptions2 ( PGconn * conn )

static

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

 {
     int         i;
  
     /*
      * Allocate memory for details about each host to which we might possibly
      * try to connect.  For that, count the number of elements in the hostaddr
      * or host options.  If neither is given, assume one host.
      */
     conn->whichhost = 0;
     if (conn->pghostaddr && conn->pghostaddr[0] != '\0')
         conn->nconnhost = count_comma_separated_elems(conn->pghostaddr);
     else if (conn->pghost && conn->pghost[0] != '\0')
         conn->nconnhost = count_comma_separated_elems(conn->pghost);
     else
         conn->nconnhost = 1;
     conn->connhost = (pg_conn_host *)
         calloc(conn->nconnhost, sizeof(pg_conn_host));
     if (conn->connhost == NULL)
         goto oom_error;
  
     /*
      * We now have one pg_conn_host structure per possible host.  Fill in the
      * host and hostaddr fields for each, by splitting the parameter strings.
      */
     if (conn->pghostaddr != NULL && conn->pghostaddr[0] != '\0')
     {
         char       *s = conn->pghostaddr;
         bool        more = true;
  
         for (i = 0; i < conn->nconnhost && more; i++)
         {
             conn->connhost[i].hostaddr = parse_comma_separated_list(&s, &more);
             if (conn->connhost[i].hostaddr == NULL)
                 goto oom_error;
         }
  
         /*
          * If hostaddr was given, the array was allocated according to the
          * number of elements in the hostaddr list, so it really should be the
          * right size.
          */
         Assert(!more);
         Assert(i == conn->nconnhost);
     }
  
     if (conn->pghost != NULL && conn->pghost[0] != '\0')
     {
         char       *s = conn->pghost;
         bool        more = true;
  
         for (i = 0; i < conn->nconnhost && more; i++)
         {
             conn->connhost[i].host = parse_comma_separated_list(&s, &more);
             if (conn->connhost[i].host == NULL)
                 goto oom_error;
         }
  
         /* Check for wrong number of host items. */
         if (more || i != conn->nconnhost)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "could not match %d host names to %d hostaddr values",
                                     count_comma_separated_elems(conn->pghost), conn->nconnhost);
             return false;
         }
     }
  
     /*
      * Now, for each host slot, identify the type of address spec, and fill in
      * the default address if nothing was given.
      */
     for (i = 0; i < conn->nconnhost; i++)
     {
         pg_conn_host *ch = &conn->connhost[i];
  
         if (ch->hostaddr != NULL && ch->hostaddr[0] != '\0')
             ch->type = CHT_HOST_ADDRESS;
         else if (ch->host != NULL && ch->host[0] != '\0')
         {
             ch->type = CHT_HOST_NAME;
             if (is_unixsock_path(ch->host))
                 ch->type = CHT_UNIX_SOCKET;
         }
         else
         {
             free(ch->host);
  
             /*
              * This bit selects the default host location.  If you change
              * this, see also pg_regress.
              */
             if (DEFAULT_PGSOCKET_DIR[0])
             {
                 ch->host = strdup(DEFAULT_PGSOCKET_DIR);
                 ch->type = CHT_UNIX_SOCKET;
             }
             else
             {
                 ch->host = strdup(DefaultHost);
                 ch->type = CHT_HOST_NAME;
             }
             if (ch->host == NULL)
                 goto oom_error;
         }
     }
  
     /*
      * Next, work out the port number corresponding to each host name.
      *
      * Note: unlike the above for host names, this could leave the port fields
      * as null or empty strings.  We will substitute DEF_PGPORT whenever we
      * read such a port field.
      */
     if (conn->pgport != NULL && conn->pgport[0] != '\0')
     {
         char       *s = conn->pgport;
         bool        more = true;
  
         for (i = 0; i < conn->nconnhost && more; i++)
         {
             conn->connhost[i].port = parse_comma_separated_list(&s, &more);
             if (conn->connhost[i].port == NULL)
                 goto oom_error;
         }
  
         /*
          * If exactly one port was given, use it for every host.  Otherwise,
          * there must be exactly as many ports as there were hosts.
          */
         if (i == 1 && !more)
         {
             for (i = 1; i < conn->nconnhost; i++)
             {
                 conn->connhost[i].port = strdup(conn->connhost[0].port);
                 if (conn->connhost[i].port == NULL)
                     goto oom_error;
             }
         }
         else if (more || i != conn->nconnhost)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "could not match %d port numbers to %d hosts",
                                     count_comma_separated_elems(conn->pgport), conn->nconnhost);
             return false;
         }
     }
  
     /*
      * If user name was not given, fetch it.  (Most likely, the fetch will
      * fail, since the only way we get here is if pg_fe_getauthname() failed
      * during conninfo_add_defaults().  But now we want an error message.)
      */
     if (conn->pguser == NULL || conn->pguser[0] == '\0')
     {
         free(conn->pguser);
         conn->pguser = pg_fe_getauthname(&conn->errorMessage);
         if (!conn->pguser)
         {
             conn->status = CONNECTION_BAD;
             return false;
         }
     }
  
     /*
      * If database name was not given, default it to equal user name
      */
     if (conn->dbName == NULL || conn->dbName[0] == '\0')
     {
         free(conn->dbName);
         conn->dbName = strdup(conn->pguser);
         if (!conn->dbName)
             goto oom_error;
     }
  
     /*
      * If password was not given, try to look it up in password file.  Note
      * that the result might be different for each host/port pair.
      */
     if (conn->pgpass == NULL || conn->pgpass[0] == '\0')
     {
         /* If password file wasn't specified, use ~/PGPASSFILE */
         if (conn->pgpassfile == NULL || conn->pgpassfile[0] == '\0')
         {
             char        homedir[MAXPGPATH];
  
             if (pqGetHomeDirectory(homedir, sizeof(homedir)))
             {
                 free(conn->pgpassfile);
                 conn->pgpassfile = malloc(MAXPGPATH);
                 if (!conn->pgpassfile)
                     goto oom_error;
                 snprintf(conn->pgpassfile, MAXPGPATH, "%s/%s",
                          homedir, PGPASSFILE);
             }
         }
  
         if (conn->pgpassfile != NULL && conn->pgpassfile[0] != '\0')
         {
             for (i = 0; i < conn->nconnhost; i++)
             {
                 /*
                  * Try to get a password for this host from file.  We use host
                  * for the hostname search key if given, else hostaddr (at
                  * least one of them is guaranteed nonempty by now).
                  */
                 const char *pwhost = conn->connhost[i].host;
  
                 if (pwhost == NULL || pwhost[0] == '\0')
                     pwhost = conn->connhost[i].hostaddr;
  
                 conn->connhost[i].password =
                     passwordFromFile(pwhost,
                                      conn->connhost[i].port,
                                      conn->dbName,
                                      conn->pguser,
                                      conn->pgpassfile);
             }
         }
     }
  
     /*
      * parse and validate require_auth option
      */
     if (conn->require_auth && conn->require_auth[0])
     {
         char       *s = conn->require_auth;
         bool        first,
                     more;
         bool        negated = false;
  
         /*
          * By default, start from an empty set of allowed options and add to
          * it.
          */
         conn->auth_required = true;
         conn->allowed_auth_methods = 0;
  
         for (first = true, more = true; more; first = false)
         {
             char       *method,
                        *part;
             uint32      bits;
  
             part = parse_comma_separated_list(&s, &more);
             if (part == NULL)
                 goto oom_error;
  
             /*
              * Check for negation, e.g. '!password'. If one element is
              * negated, they all have to be.
              */
             method = part;
             if (*method == '!')
             {
                 if (first)
                 {
                     /*
                      * Switch to a permissive set of allowed options, and
                      * subtract from it.
                      */
                     conn->auth_required = false;
                     conn->allowed_auth_methods = -1;
                 }
                 else if (!negated)
                 {
                     conn->status = CONNECTION_BAD;
                     libpq_append_conn_error(conn, "negative require_auth method \"%s\" cannot be mixed with non-negative methods",
                                             method);
  
                     free(part);
                     return false;
                 }
  
                 negated = true;
                 method++;
             }
             else if (negated)
             {
                 conn->status = CONNECTION_BAD;
                 libpq_append_conn_error(conn, "require_auth method \"%s\" cannot be mixed with negative methods",
                                         method);
  
                 free(part);
                 return false;
             }
  
             if (strcmp(method, "password") == 0)
             {
                 bits = (1 << AUTH_REQ_PASSWORD);
             }
             else if (strcmp(method, "md5") == 0)
             {
                 bits = (1 << AUTH_REQ_MD5);
             }
             else if (strcmp(method, "gss") == 0)
             {
                 bits = (1 << AUTH_REQ_GSS);
                 bits |= (1 << AUTH_REQ_GSS_CONT);
             }
             else if (strcmp(method, "sspi") == 0)
             {
                 bits = (1 << AUTH_REQ_SSPI);
                 bits |= (1 << AUTH_REQ_GSS_CONT);
             }
             else if (strcmp(method, "scram-sha-256") == 0)
             {
                 /* This currently assumes that SCRAM is the only SASL method. */
                 bits = (1 << AUTH_REQ_SASL);
                 bits |= (1 << AUTH_REQ_SASL_CONT);
                 bits |= (1 << AUTH_REQ_SASL_FIN);
             }
             else if (strcmp(method, "none") == 0)
             {
                 /*
                  * Special case: let the user explicitly allow (or disallow)
                  * connections where the server does not send an explicit
                  * authentication challenge, such as "trust" and "cert" auth.
                  */
                 if (negated)    /* "!none" */
                 {
                     if (conn->auth_required)
                         goto duplicate;
  
                     conn->auth_required = true;
                 }
                 else            /* "none" */
                 {
                     if (!conn->auth_required)
                         goto duplicate;
  
                     conn->auth_required = false;
                 }
  
                 free(part);
                 continue;       /* avoid the bitmask manipulation below */
             }
             else
             {
                 conn->status = CONNECTION_BAD;
                 libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                         "require_auth", method);
  
                 free(part);
                 return false;
             }
  
             /* Update the bitmask. */
             if (negated)
             {
                 if ((conn->allowed_auth_methods & bits) == 0)
                     goto duplicate;
  
                 conn->allowed_auth_methods &= ~bits;
             }
             else
             {
                 if ((conn->allowed_auth_methods & bits) == bits)
                     goto duplicate;
  
                 conn->allowed_auth_methods |= bits;
             }
  
             free(part);
             continue;
  
     duplicate:
  
             /*
              * A duplicated method probably indicates a typo in a setting
              * where typos are extremely risky.
              */
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "require_auth method \"%s\" is specified more than once",
                                     part);
  
             free(part);
             return false;
         }
     }
  
     /*
      * validate channel_binding option
      */
     if (conn->channel_binding)
     {
         if (strcmp(conn->channel_binding, "disable") != 0
             && strcmp(conn->channel_binding, "prefer") != 0
             && strcmp(conn->channel_binding, "require") != 0)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                     "channel_binding", conn->channel_binding);
             return false;
         }
     }
     else
     {
         conn->channel_binding = strdup(DefaultChannelBinding);
         if (!conn->channel_binding)
             goto oom_error;
     }
  
 #ifndef USE_SSL
  
     /*
      * sslrootcert=system is not supported. Since setting this changes the
      * default sslmode, check this _before_ we validate sslmode, to avoid
      * confusing the user with errors for an option they may not have set.
      */
     if (conn->sslrootcert
         && strcmp(conn->sslrootcert, "system") == 0)
     {
         conn->status = CONNECTION_BAD;
         libpq_append_conn_error(conn, "%s value \"%s\" invalid when SSL support is not compiled in",
                                 "sslrootcert", conn->sslrootcert);
         return false;
     }
 #endif
  
     /*
      * validate sslmode option
      */
     if (conn->sslmode)
     {
         if (strcmp(conn->sslmode, "disable") != 0
             && strcmp(conn->sslmode, "allow") != 0
             && strcmp(conn->sslmode, "prefer") != 0
             && strcmp(conn->sslmode, "require") != 0
             && strcmp(conn->sslmode, "verify-ca") != 0
             && strcmp(conn->sslmode, "verify-full") != 0)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                     "sslmode", conn->sslmode);
             return false;
         }
  
 #ifndef USE_SSL
         switch (conn->sslmode[0])
         {
             case 'a':           /* "allow" */
             case 'p':           /* "prefer" */
  
                 /*
                  * warn user that an SSL connection will never be negotiated
                  * since SSL was not compiled in?
                  */
                 break;
  
             case 'r':           /* "require" */
             case 'v':           /* "verify-ca" or "verify-full" */
                 conn->status = CONNECTION_BAD;
                 libpq_append_conn_error(conn, "%s value \"%s\" invalid when SSL support is not compiled in",
                                         "sslmode", conn->sslmode);
                 return false;
         }
 #endif
     }
     else
     {
         conn->sslmode = strdup(DefaultSSLMode);
         if (!conn->sslmode)
             goto oom_error;
     }
  
 #ifdef USE_SSL
  
     /*
      * If sslrootcert=system, make sure our chosen sslmode is compatible.
      */
     if (conn->sslrootcert
         && strcmp(conn->sslrootcert, "system") == 0
         && strcmp(conn->sslmode, "verify-full") != 0)
     {
         conn->status = CONNECTION_BAD;
         libpq_append_conn_error(conn, "weak sslmode \"%s\" may not be used with sslrootcert=system (use \"verify-full\")",
                                 conn->sslmode);
         return false;
     }
 #endif
  
     /*
      * Validate TLS protocol versions for ssl_min_protocol_version and
      * ssl_max_protocol_version.
      */
     if (!sslVerifyProtocolVersion(conn->ssl_min_protocol_version))
     {
         conn->status = CONNECTION_BAD;
         libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                 "ssl_min_protocol_version",
                                 conn->ssl_min_protocol_version);
         return false;
     }
     if (!sslVerifyProtocolVersion(conn->ssl_max_protocol_version))
     {
         conn->status = CONNECTION_BAD;
         libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                 "ssl_max_protocol_version",
                                 conn->ssl_max_protocol_version);
         return false;
     }
  
     /*
      * Check if the range of SSL protocols defined is correct.  This is done
      * at this early step because this is independent of the SSL
      * implementation used, and this avoids unnecessary cycles with an
      * already-built SSL context when the connection is being established, as
      * it would be doomed anyway.
      */
     if (!sslVerifyProtocolRange(conn->ssl_min_protocol_version,
                                 conn->ssl_max_protocol_version))
     {
         conn->status = CONNECTION_BAD;
         libpq_append_conn_error(conn, "invalid SSL protocol version range");
         return false;
     }
  
     /*
      * validate sslcertmode option
      */
     if (conn->sslcertmode)
     {
         if (strcmp(conn->sslcertmode, "disable") != 0 &&
             strcmp(conn->sslcertmode, "allow") != 0 &&
             strcmp(conn->sslcertmode, "require") != 0)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                     "sslcertmode", conn->sslcertmode);
             return false;
         }
 #ifndef USE_SSL
         if (strcmp(conn->sslcertmode, "require") == 0)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "%s value \"%s\" invalid when SSL support is not compiled in",
                                     "sslcertmode", conn->sslcertmode);
             return false;
         }
 #endif
 #ifndef HAVE_SSL_CTX_SET_CERT_CB
  
         /*
          * Without a certificate callback, the current implementation can't
          * figure out if a certificate was actually requested, so "require" is
          * useless.
          */
         if (strcmp(conn->sslcertmode, "require") == 0)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "%s value \"%s\" is not supported (check OpenSSL version)",
                                     "sslcertmode", conn->sslcertmode);
             return false;
         }
 #endif
     }
     else
     {
         conn->sslcertmode = strdup(DefaultSSLCertMode);
         if (!conn->sslcertmode)
             goto oom_error;
     }
  
     /*
      * validate gssencmode option
      */
     if (conn->gssencmode)
     {
         if (strcmp(conn->gssencmode, "disable") != 0 &&
             strcmp(conn->gssencmode, "prefer") != 0 &&
             strcmp(conn->gssencmode, "require") != 0)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "invalid %s value: \"%s\"", "gssencmode", conn->gssencmode);
             return false;
         }
 #ifndef ENABLE_GSS
         if (strcmp(conn->gssencmode, "require") == 0)
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "gssencmode value \"%s\" invalid when GSSAPI support is not compiled in",
                                     conn->gssencmode);
             return false;
         }
 #endif
     }
     else
     {
         conn->gssencmode = strdup(DefaultGSSMode);
         if (!conn->gssencmode)
             goto oom_error;
     }
  
     /*
      * validate target_session_attrs option, and set target_server_type
      */
     if (conn->target_session_attrs)
     {
         if (strcmp(conn->target_session_attrs, "any") == 0)
             conn->target_server_type = SERVER_TYPE_ANY;
         else if (strcmp(conn->target_session_attrs, "read-write") == 0)
             conn->target_server_type = SERVER_TYPE_READ_WRITE;
         else if (strcmp(conn->target_session_attrs, "read-only") == 0)
             conn->target_server_type = SERVER_TYPE_READ_ONLY;
         else if (strcmp(conn->target_session_attrs, "primary") == 0)
             conn->target_server_type = SERVER_TYPE_PRIMARY;
         else if (strcmp(conn->target_session_attrs, "standby") == 0)
             conn->target_server_type = SERVER_TYPE_STANDBY;
         else if (strcmp(conn->target_session_attrs, "prefer-standby") == 0)
             conn->target_server_type = SERVER_TYPE_PREFER_STANDBY;
         else
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                     "target_session_attrs",
                                     conn->target_session_attrs);
             return false;
         }
     }
     else
         conn->target_server_type = SERVER_TYPE_ANY;
  
     /*
      * validate load_balance_hosts option, and set load_balance_type
      */
     if (conn->load_balance_hosts)
     {
         if (strcmp(conn->load_balance_hosts, "disable") == 0)
             conn->load_balance_type = LOAD_BALANCE_DISABLE;
         else if (strcmp(conn->load_balance_hosts, "random") == 0)
             conn->load_balance_type = LOAD_BALANCE_RANDOM;
         else
         {
             conn->status = CONNECTION_BAD;
             libpq_append_conn_error(conn, "invalid %s value: \"%s\"",
                                     "load_balance_hosts",
                                     conn->load_balance_hosts);
             return false;
         }
     }
     else
         conn->load_balance_type = LOAD_BALANCE_DISABLE;
  
     if (conn->load_balance_type == LOAD_BALANCE_RANDOM)
     {
         libpq_prng_init(conn);
  
         /*
          * This is the "inside-out" variant of the Fisher-Yates shuffle
          * algorithm. Notionally, we append each new value to the array and
          * then swap it with a randomly-chosen array element (possibly
          * including itself, else we fail to generate permutations with the
          * last integer last).  The swap step can be optimized by combining it
          * with the insertion.
          */
         for (i = 1; i < conn->nconnhost; i++)
         {
             int         j = pg_prng_uint64_range(&conn->prng_state, 0, i);
             pg_conn_host temp = conn->connhost[j];
  
             conn->connhost[j] = conn->connhost[i];
             conn->connhost[i] = temp;
         }
     }
  
     /*
      * Resolve special "auto" client_encoding from the locale
      */
     if (conn->client_encoding_initial &&
         strcmp(conn->client_encoding_initial, "auto") == 0)
     {
         free(conn->client_encoding_initial);
         conn->client_encoding_initial = strdup(pg_encoding_to_char(pg_get_encoding_from_locale(NULL, true)));
         if (!conn->client_encoding_initial)
             goto oom_error;
     }
  
     /*
      * Only if we get this far is it appropriate to try to connect. (We need a
      * state flag, rather than just the boolean result of this function, in
      * case someone tries to PQreset() the PGconn.)
      */
     conn->options_valid = true;
  
     return true;
  
 oom_error:
     conn->status = CONNECTION_BAD;
     libpq_append_conn_error(conn, "out of memory");
     return false;
 }

References pg_conn::allowed_auth_methods, Assert(), AUTH_REQ_GSS, AUTH_REQ_GSS_CONT, AUTH_REQ_MD5, AUTH_REQ_PASSWORD, AUTH_REQ_SASL, AUTH_REQ_SASL_CONT, AUTH_REQ_SASL_FIN, AUTH_REQ_SSPI, pg_conn::auth_required, calloc, pg_conn::channel_binding, CHT_HOST_ADDRESS, CHT_HOST_NAME, CHT_UNIX_SOCKET, pg_conn::client_encoding_initial, conn, CONNECTION_BAD, pg_conn::connhost, count_comma_separated_elems(), pg_conn::dbName, DEFAULT_PGSOCKET_DIR, DefaultChannelBinding, DefaultGSSMode, DefaultHost, DefaultSSLCertMode, DefaultSSLMode, pg_conn::errorMessage, free, pg_conn::gssencmode, pg_conn_host::host, pg_conn_host::hostaddr, i, is_unixsock_path(), j, libpq_append_conn_error(), libpq_prng_init(), LOAD_BALANCE_DISABLE, pg_conn::load_balance_hosts, LOAD_BALANCE_RANDOM, pg_conn::load_balance_type, malloc, MAXPGPATH, pg_conn::nconnhost, pg_conn::options_valid, parse_comma_separated_list(), pg_conn_host::password, passwordFromFile(), pg_encoding_to_char(), pg_fe_getauthname(), pg_get_encoding_from_locale(), pg_prng_uint64_range(), pg_conn::pghost, pg_conn::pghostaddr, pg_conn::pgpass, PGPASSFILE, pg_conn::pgpassfile, pg_conn::pgport, pg_conn::pguser, pg_conn_host::port, pqGetHomeDirectory(), pg_conn::prng_state, pg_conn::require_auth, SERVER_TYPE_ANY, SERVER_TYPE_PREFER_STANDBY, SERVER_TYPE_PRIMARY, SERVER_TYPE_READ_ONLY, SERVER_TYPE_READ_WRITE, SERVER_TYPE_STANDBY, snprintf, pg_conn::ssl_max_protocol_version, pg_conn::ssl_min_protocol_version, pg_conn::sslcertmode, pg_conn::sslmode, pg_conn::sslrootcert, sslVerifyProtocolRange(), sslVerifyProtocolVersion(), pg_conn::status, pg_conn::target_server_type, pg_conn::target_session_attrs, pg_conn_host::type, and pg_conn::whichhost.

Referenced by PQconnectStart(), PQconnectStartParams(), and PQsetdbLogin().

◆ conninfo_add_defaults()

static bool conninfo_add_defaults	(	PQconninfoOption *	options,
		PQExpBuffer	errorMessage
	)

static

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

 {
     PQconninfoOption *option;
     PQconninfoOption *sslmode_default = NULL,
                *sslrootcert = NULL;
     char       *tmp;
  
     /*
      * If there's a service spec, use it to obtain any not-explicitly-given
      * parameters.  Ignore error if no error message buffer is passed because
      * there is no way to pass back the failure message.
      */
     if (parseServiceInfo(options, errorMessage) != 0 && errorMessage)
         return false;
  
     /*
      * Get the fallback resources for parameters not specified in the conninfo
      * string nor the service.
      */
     for (option = options; option->keyword != NULL; option++)
     {
         if (strcmp(option->keyword, "sslrootcert") == 0)
             sslrootcert = option;   /* save for later */
  
         if (option->val != NULL)
             continue;           /* Value was in conninfo or service */
  
         /*
          * Try to get the environment variable fallback
          */
         if (option->envvar != NULL)
         {
             if ((tmp = getenv(option->envvar)) != NULL)
             {
                 option->val = strdup(tmp);
                 if (!option->val)
                 {
                     if (errorMessage)
                         libpq_append_error(errorMessage, "out of memory");
                     return false;
                 }
                 continue;
             }
         }
  
         /*
          * Interpret the deprecated PGREQUIRESSL environment variable.  Per
          * tradition, translate values starting with "1" to sslmode=require,
          * and ignore other values.  Given both PGREQUIRESSL=1 and PGSSLMODE,
          * PGSSLMODE takes precedence; the opposite was true before v9.3.
          */
         if (strcmp(option->keyword, "sslmode") == 0)
         {
             const char *requiresslenv = getenv("PGREQUIRESSL");
  
             if (requiresslenv != NULL && requiresslenv[0] == '1')
             {
                 option->val = strdup("require");
                 if (!option->val)
                 {
                     if (errorMessage)
                         libpq_append_error(errorMessage, "out of memory");
                     return false;
                 }
                 continue;
             }
  
             /*
              * sslmode is not specified. Let it be filled in with the compiled
              * default for now, but if sslrootcert=system, we'll override the
              * default later before returning.
              */
             sslmode_default = option;
         }
  
         /*
          * No environment variable specified or the variable isn't set - try
          * compiled-in default
          */
         if (option->compiled != NULL)
         {
             option->val = strdup(option->compiled);
             if (!option->val)
             {
                 if (errorMessage)
                     libpq_append_error(errorMessage, "out of memory");
                 return false;
             }
             continue;
         }
  
         /*
          * Special handling for "user" option.  Note that if pg_fe_getauthname
          * fails, we just leave the value as NULL; there's no need for this to
          * be an error condition if the caller provides a user name.  The only
          * reason we do this now at all is so that callers of PQconndefaults
          * will see a correct default (barring error, of course).
          */
         if (strcmp(option->keyword, "user") == 0)
         {
             option->val = pg_fe_getauthname(NULL);
             continue;
         }
     }
  
     /*
      * Special handling for sslrootcert=system with no sslmode explicitly
      * defined. In this case we want to strengthen the default sslmode to
      * verify-full.
      */
     if (sslmode_default && sslrootcert)
     {
         if (sslrootcert->val && strcmp(sslrootcert->val, "system") == 0)
         {
             free(sslmode_default->val);
  
             sslmode_default->val = strdup("verify-full");
             if (!sslmode_default->val)
             {
                 if (errorMessage)
                     libpq_append_error(errorMessage, "out of memory");
                 return false;
             }
         }
     }
  
     return true;
 }

References free, libpq_append_error(), parseServiceInfo(), pg_fe_getauthname(), option::val, and _PQconninfoOption::val.

Referenced by conninfo_array_parse(), conninfo_parse(), conninfo_uri_parse(), and PQconndefaults().

◆ conninfo_array_parse()

static PQconninfoOption * conninfo_array_parse	(	const char const	keywords,
		const char const	values,
		PQExpBuffer	errorMessage,
		bool	use_defaults,
		int	expand_dbname
	)

static

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

 {
     PQconninfoOption *options;
     PQconninfoOption *dbname_options = NULL;
     PQconninfoOption *option;
     int         i = 0;
  
     /*
      * If expand_dbname is non-zero, check keyword "dbname" to see if val is
      * actually a recognized connection string.
      */
     while (expand_dbname && keywords[i])
     {
         const char *pname = keywords[i];
         const char *pvalue = values[i];
  
         /* first find "dbname" if any */
         if (strcmp(pname, "dbname") == 0 && pvalue)
         {
             /*
              * If value is a connection string, parse it, but do not use
              * defaults here -- those get picked up later. We only want to
              * override for those parameters actually passed.
              */
             if (recognized_connection_string(pvalue))
             {
                 dbname_options = parse_connection_string(pvalue, errorMessage, false);
                 if (dbname_options == NULL)
                     return NULL;
             }
             break;
         }
         ++i;
     }
  
     /* Make a working copy of PQconninfoOptions */
     options = conninfo_init(errorMessage);
     if (options == NULL)
     {
         PQconninfoFree(dbname_options);
         return NULL;
     }
  
     /* Parse the keywords/values arrays */
     i = 0;
     while (keywords[i])
     {
         const char *pname = keywords[i];
         const char *pvalue = values[i];
  
         if (pvalue != NULL && pvalue[0] != '\0')
         {
             /* Search for the param record */
             for (option = options; option->keyword != NULL; option++)
             {
                 if (strcmp(option->keyword, pname) == 0)
                     break;
             }
  
             /* Check for invalid connection option */
             if (option->keyword == NULL)
             {
                 libpq_append_error(errorMessage, "invalid connection option \"%s\"", pname);
                 PQconninfoFree(options);
                 PQconninfoFree(dbname_options);
                 return NULL;
             }
  
             /*
              * If we are on the first dbname parameter, and we have a parsed
              * connection string, copy those parameters across, overriding any
              * existing previous settings.
              */
             if (strcmp(pname, "dbname") == 0 && dbname_options)
             {
                 PQconninfoOption *str_option;
  
                 for (str_option = dbname_options; str_option->keyword != NULL; str_option++)
                 {
                     if (str_option->val != NULL)
                     {
                         int         k;
  
                         for (k = 0; options[k].keyword; k++)
                         {
                             if (strcmp(options[k].keyword, str_option->keyword) == 0)
                             {
                                 free(options[k].val);
                                 options[k].val = strdup(str_option->val);
                                 if (!options[k].val)
                                 {
                                     libpq_append_error(errorMessage, "out of memory");
                                     PQconninfoFree(options);
                                     PQconninfoFree(dbname_options);
                                     return NULL;
                                 }
                                 break;
                             }
                         }
                     }
                 }
  
                 /*
                  * Forget the parsed connection string, so that any subsequent
                  * dbname parameters will not be expanded.
                  */
                 PQconninfoFree(dbname_options);
                 dbname_options = NULL;
             }
             else
             {
                 /*
                  * Store the value, overriding previous settings
                  */
                 free(option->val);
                 option->val = strdup(pvalue);
                 if (!option->val)
                 {
                     libpq_append_error(errorMessage, "out of memory");
                     PQconninfoFree(options);
                     PQconninfoFree(dbname_options);
                     return NULL;
                 }
             }
         }
         ++i;
     }
     PQconninfoFree(dbname_options);
  
     /*
      * Add in defaults if the caller wants that.
      */
     if (use_defaults)
     {
         if (!conninfo_add_defaults(options, errorMessage))
         {
             PQconninfoFree(options);
             return NULL;
         }
     }
  
     return options;
 }

References conninfo_add_defaults(), conninfo_init(), free, i, _PQconninfoOption::keyword, libpq_append_error(), options, parse_connection_string(), PQconninfoFree(), recognized_connection_string(), option::val, val, _PQconninfoOption::val, and values.

Referenced by PQconnectStartParams().

◆ conninfo_find()

static PQconninfoOption * conninfo_find	(	PQconninfoOption *	connOptions,
		const char *	keyword
	)

static

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

 {
     PQconninfoOption *option;
  
     for (option = connOptions; option->keyword != NULL; option++)
     {
         if (strcmp(option->keyword, keyword) == 0)
             return option;
     }
  
     return NULL;
 }

Referenced by conninfo_getval(), and conninfo_storeval().

◆ conninfo_getval()

static const char * conninfo_getval	(	PQconninfoOption *	connOptions,
		const char *	keyword
	)

static

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

 {
     PQconninfoOption *option;
  
     option = conninfo_find(connOptions, keyword);
  
     return option ? option->val : NULL;
 }

References conninfo_find(), and option::val.

Referenced by fillPGconn(), and parseServiceInfo().

◆ conninfo_init()

static PQconninfoOption * conninfo_init ( PQExpBuffer errorMessage )

static

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

 {
     PQconninfoOption *options;
     PQconninfoOption *opt_dest;
     const internalPQconninfoOption *cur_opt;
  
     /*
      * Get enough memory for all options in PQconninfoOptions, even if some
      * end up being filtered out.
      */
     options = (PQconninfoOption *) malloc(sizeof(PQconninfoOption) * sizeof(PQconninfoOptions) / sizeof(PQconninfoOptions[0]));
     if (options == NULL)
     {
         libpq_append_error(errorMessage, "out of memory");
         return NULL;
     }
     opt_dest = options;
  
     for (cur_opt = PQconninfoOptions; cur_opt->keyword; cur_opt++)
     {
         /* Only copy the public part of the struct, not the full internal */
         memcpy(opt_dest, cur_opt, sizeof(PQconninfoOption));
         opt_dest++;
     }
     MemSet(opt_dest, 0, sizeof(PQconninfoOption));
  
     return options;
 }

References _internalPQconninfoOption::keyword, libpq_append_error(), malloc, MemSet, options, and PQconninfoOptions.

Referenced by conninfo_array_parse(), conninfo_parse(), conninfo_uri_parse(), PQconndefaults(), and PQconninfo().

◆ conninfo_parse()

static PQconninfoOption * conninfo_parse	(	const char *	conninfo,
		PQExpBuffer	errorMessage,
		bool	use_defaults
	)

static

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

 {
     char       *pname;
     char       *pval;
     char       *buf;
     char       *cp;
     char       *cp2;
     PQconninfoOption *options;
  
     /* Make a working copy of PQconninfoOptions */
     options = conninfo_init(errorMessage);
     if (options == NULL)
         return NULL;
  
     /* Need a modifiable copy of the input string */
     if ((buf = strdup(conninfo)) == NULL)
     {
         libpq_append_error(errorMessage, "out of memory");
         PQconninfoFree(options);
         return NULL;
     }
     cp = buf;
  
     while (*cp)
     {
         /* Skip blanks before the parameter name */
         if (isspace((unsigned char) *cp))
         {
             cp++;
             continue;
         }
  
         /* Get the parameter name */
         pname = cp;
         while (*cp)
         {
             if (*cp == '=')
                 break;
             if (isspace((unsigned char) *cp))
             {
                 *cp++ = '\0';
                 while (*cp)
                 {
                     if (!isspace((unsigned char) *cp))
                         break;
                     cp++;
                 }
                 break;
             }
             cp++;
         }
  
         /* Check that there is a following '=' */
         if (*cp != '=')
         {
             libpq_append_error(errorMessage,
                                "missing \"=\" after \"%s\" in connection info string",
                                pname);
             PQconninfoFree(options);
             free(buf);
             return NULL;
         }
         *cp++ = '\0';
  
         /* Skip blanks after the '=' */
         while (*cp)
         {
             if (!isspace((unsigned char) *cp))
                 break;
             cp++;
         }
  
         /* Get the parameter value */
         pval = cp;
  
         if (*cp != '\'')
         {
             cp2 = pval;
             while (*cp)
             {
                 if (isspace((unsigned char) *cp))
                 {
                     *cp++ = '\0';
                     break;
                 }
                 if (*cp == '\\')
                 {
                     cp++;
                     if (*cp != '\0')
                         *cp2++ = *cp++;
                 }
                 else
                     *cp2++ = *cp++;
             }
             *cp2 = '\0';
         }
         else
         {
             cp2 = pval;
             cp++;
             for (;;)
             {
                 if (*cp == '\0')
                 {
                     libpq_append_error(errorMessage, "unterminated quoted string in connection info string");
                     PQconninfoFree(options);
                     free(buf);
                     return NULL;
                 }
                 if (*cp == '\\')
                 {
                     cp++;
                     if (*cp != '\0')
                         *cp2++ = *cp++;
                     continue;
                 }
                 if (*cp == '\'')
                 {
                     *cp2 = '\0';
                     cp++;
                     break;
                 }
                 *cp2++ = *cp++;
             }
         }
  
         /*
          * Now that we have the name and the value, store the record.
          */
         if (!conninfo_storeval(options, pname, pval, errorMessage, false, false))
         {
             PQconninfoFree(options);
             free(buf);
             return NULL;
         }
     }
  
     /* Done with the modifiable input string */
     free(buf);
  
     /*
      * Add in defaults if the caller wants that.
      */
     if (use_defaults)
     {
         if (!conninfo_add_defaults(options, errorMessage))
         {
             PQconninfoFree(options);
             return NULL;
         }
     }
  
     return options;
 }

References buf, conninfo_add_defaults(), conninfo_init(), conninfo_storeval(), free, libpq_append_error(), options, and PQconninfoFree().

Referenced by parse_connection_string().

◆ conninfo_storeval()

static PQconninfoOption * conninfo_storeval	(	PQconninfoOption *	connOptions,
		const char *	keyword,
		const char *	value,
		PQExpBuffer	errorMessage,
		bool	ignoreMissing,
		bool	uri_decode
	)

static

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

 {
     PQconninfoOption *option;
     char       *value_copy;
  
     /*
      * For backwards compatibility, requiressl=1 gets translated to
      * sslmode=require, and requiressl=0 gets translated to sslmode=prefer
      * (which is the default for sslmode).
      */
     if (strcmp(keyword, "requiressl") == 0)
     {
         keyword = "sslmode";
         if (value[0] == '1')
             value = "require";
         else
             value = "prefer";
     }
  
     option = conninfo_find(connOptions, keyword);
     if (option == NULL)
     {
         if (!ignoreMissing)
             libpq_append_error(errorMessage,
                                "invalid connection option \"%s\"",
                                keyword);
         return NULL;
     }
  
     if (uri_decode)
     {
         value_copy = conninfo_uri_decode(value, errorMessage);
         if (value_copy == NULL)
             /* conninfo_uri_decode already set an error message */
             return NULL;
     }
     else
     {
         value_copy = strdup(value);
         if (value_copy == NULL)
         {
             libpq_append_error(errorMessage, "out of memory");
             return NULL;
         }
     }
  
     free(option->val);
     option->val = value_copy;
  
     return option;
 }

References conninfo_find(), conninfo_uri_decode(), free, libpq_append_error(), option::val, and value.

Referenced by conninfo_parse(), conninfo_uri_parse_options(), conninfo_uri_parse_params(), and PQconninfo().

◆ conninfo_uri_decode()

static char * conninfo_uri_decode	(	const char *	str,
		PQExpBuffer	errorMessage
	)

static

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

 {
     char       *buf;
     char       *p;
     const char *q = str;
  
     buf = malloc(strlen(str) + 1);
     if (buf == NULL)
     {
         libpq_append_error(errorMessage, "out of memory");
         return NULL;
     }
     p = buf;
  
     for (;;)
     {
         if (*q != '%')
         {
             /* copy and check for NUL terminator */
             if (!(*(p++) = *(q++)))
                 break;
         }
         else
         {
             int         hi;
             int         lo;
             int         c;
  
             ++q;                /* skip the percent sign itself */
  
             /*
              * Possible EOL will be caught by the first call to
              * get_hexdigit(), so we never dereference an invalid q pointer.
              */
             if (!(get_hexdigit(*q++, &hi) && get_hexdigit(*q++, &lo)))
             {
                 libpq_append_error(errorMessage,
                                    "invalid percent-encoded token: \"%s\"",
                                    str);
                 free(buf);
                 return NULL;
             }
  
             c = (hi << 4) | lo;
             if (c == 0)
             {
                 libpq_append_error(errorMessage,
                                    "forbidden value %%00 in percent-encoded value: \"%s\"",
                                    str);
                 free(buf);
                 return NULL;
             }
             *(p++) = c;
         }
     }
  
     return buf;
 }

References buf, free, get_hexdigit(), libpq_append_error(), malloc, and generate_unaccent_rules::str.

Referenced by conninfo_storeval(), and conninfo_uri_parse_params().

◆ conninfo_uri_parse()

static PQconninfoOption * conninfo_uri_parse	(	const char *	uri,
		PQExpBuffer	errorMessage,
		bool	use_defaults
	)

static

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

 {
     PQconninfoOption *options;
  
     /* Make a working copy of PQconninfoOptions */
     options = conninfo_init(errorMessage);
     if (options == NULL)
         return NULL;
  
     if (!conninfo_uri_parse_options(options, uri, errorMessage))
     {
         PQconninfoFree(options);
         return NULL;
     }
  
     /*
      * Add in defaults if the caller wants that.
      */
     if (use_defaults)
     {
         if (!conninfo_add_defaults(options, errorMessage))
         {
             PQconninfoFree(options);
             return NULL;
         }
     }
  
     return options;
 }

References conninfo_add_defaults(), conninfo_init(), conninfo_uri_parse_options(), options, and PQconninfoFree().

Referenced by parse_connection_string().

◆ conninfo_uri_parse_options()

static bool conninfo_uri_parse_options	(	PQconninfoOption *	options,
		const char *	uri,
		PQExpBuffer	errorMessage
	)

static

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

 {
     int         prefix_len;
     char       *p;
     char       *buf = NULL;
     char       *start;
     char        prevchar = '\0';
     char       *user = NULL;
     char       *host = NULL;
     bool        retval = false;
     PQExpBufferData hostbuf;
     PQExpBufferData portbuf;
  
     initPQExpBuffer(&hostbuf);
     initPQExpBuffer(&portbuf);
     if (PQExpBufferDataBroken(hostbuf) || PQExpBufferDataBroken(portbuf))
     {
         libpq_append_error(errorMessage, "out of memory");
         goto cleanup;
     }
  
     /* need a modifiable copy of the input URI */
     buf = strdup(uri);
     if (buf == NULL)
     {
         libpq_append_error(errorMessage, "out of memory");
         goto cleanup;
     }
     start = buf;
  
     /* Skip the URI prefix */
     prefix_len = uri_prefix_length(uri);
     if (prefix_len == 0)
     {
         /* Should never happen */
         libpq_append_error(errorMessage,
                            "invalid URI propagated to internal parser routine: \"%s\"",
                            uri);
         goto cleanup;
     }
     start += prefix_len;
     p = start;
  
     /* Look ahead for possible user credentials designator */
     while (*p && *p != '@' && *p != '/')
         ++p;
     if (*p == '@')
     {
         /*
          * Found username/password designator, so URI should be of the form
          * "scheme://user[:password]@[netloc]".
          */
         user = start;
  
         p = user;
         while (*p != ':' && *p != '@')
             ++p;
  
         /* Save last char and cut off at end of user name */
         prevchar = *p;
         *p = '\0';
  
         if (*user &&
             !conninfo_storeval(options, "user", user,
                                errorMessage, false, true))
             goto cleanup;
  
         if (prevchar == ':')
         {
             const char *password = p + 1;
  
             while (*p != '@')
                 ++p;
             *p = '\0';
  
             if (*password &&
                 !conninfo_storeval(options, "password", password,
                                    errorMessage, false, true))
                 goto cleanup;
         }
  
         /* Advance past end of parsed user name or password token */
         ++p;
     }
     else
     {
         /*
          * No username/password designator found.  Reset to start of URI.
          */
         p = start;
     }
  
     /*
      * There may be multiple netloc[:port] pairs, each separated from the next
      * by a comma.  When we initially enter this loop, "p" has been
      * incremented past optional URI credential information at this point and
      * now points at the "netloc" part of the URI.  On subsequent loop
      * iterations, "p" has been incremented past the comma separator and now
      * points at the start of the next "netloc".
      */
     for (;;)
     {
         /*
          * Look for IPv6 address.
          */
         if (*p == '[')
         {
             host = ++p;
             while (*p && *p != ']')
                 ++p;
             if (!*p)
             {
                 libpq_append_error(errorMessage,
                                    "end of string reached when looking for matching \"]\" in IPv6 host address in URI: \"%s\"",
                                    uri);
                 goto cleanup;
             }
             if (p == host)
             {
                 libpq_append_error(errorMessage,
                                    "IPv6 host address may not be empty in URI: \"%s\"",
                                    uri);
                 goto cleanup;
             }
  
             /* Cut off the bracket and advance */
             *(p++) = '\0';
  
             /*
              * The address may be followed by a port specifier or a slash or a
              * query or a separator comma.
              */
             if (*p && *p != ':' && *p != '/' && *p != '?' && *p != ',')
             {
                 libpq_append_error(errorMessage,
                                    "unexpected character \"%c\" at position %d in URI (expected \":\" or \"/\"): \"%s\"",
                                    *p, (int) (p - buf + 1), uri);
                 goto cleanup;
             }
         }
         else
         {
             /* not an IPv6 address: DNS-named or IPv4 netloc */
             host = p;
  
             /*
              * Look for port specifier (colon) or end of host specifier
              * (slash) or query (question mark) or host separator (comma).
              */
             while (*p && *p != ':' && *p != '/' && *p != '?' && *p != ',')
                 ++p;
         }
  
         /* Save the hostname terminator before we null it */
         prevchar = *p;
         *p = '\0';
  
         appendPQExpBufferStr(&hostbuf, host);
  
         if (prevchar == ':')
         {
             const char *port = ++p; /* advance past host terminator */
  
             while (*p && *p != '/' && *p != '?' && *p != ',')
                 ++p;
  
             prevchar = *p;
             *p = '\0';
  
             appendPQExpBufferStr(&portbuf, port);
         }
  
         if (prevchar != ',')
             break;
         ++p;                    /* advance past comma separator */
         appendPQExpBufferChar(&hostbuf, ',');
         appendPQExpBufferChar(&portbuf, ',');
     }
  
     /* Save final values for host and port. */
     if (PQExpBufferDataBroken(hostbuf) || PQExpBufferDataBroken(portbuf))
         goto cleanup;
     if (hostbuf.data[0] &&
         !conninfo_storeval(options, "host", hostbuf.data,
                            errorMessage, false, true))
         goto cleanup;
     if (portbuf.data[0] &&
         !conninfo_storeval(options, "port", portbuf.data,
                            errorMessage, false, true))
         goto cleanup;
  
     if (prevchar && prevchar != '?')
     {
         const char *dbname = ++p;   /* advance past host terminator */
  
         /* Look for query parameters */
         while (*p && *p != '?')
             ++p;
  
         prevchar = *p;
         *p = '\0';
  
         /*
          * Avoid setting dbname to an empty string, as it forces the default
          * value (username) and ignores $PGDATABASE, as opposed to not setting
          * it at all.
          */
         if (*dbname &&
             !conninfo_storeval(options, "dbname", dbname,
                                errorMessage, false, true))
             goto cleanup;
     }
  
     if (prevchar)
     {
         ++p;                    /* advance past terminator */
  
         if (!conninfo_uri_parse_params(p, options, errorMessage))
             goto cleanup;
     }
  
     /* everything parsed okay */
     retval = true;
  
 cleanup:
     termPQExpBuffer(&hostbuf);
     termPQExpBuffer(&portbuf);
     free(buf);
     return retval;
 }

References appendPQExpBufferChar(), appendPQExpBufferStr(), buf, cleanup(), conninfo_storeval(), conninfo_uri_parse_params(), PQExpBufferData::data, dbname, free, initPQExpBuffer(), libpq_append_error(), password, port, PQExpBufferDataBroken, termPQExpBuffer(), uri_prefix_length(), and user.

Referenced by conninfo_uri_parse().

◆ conninfo_uri_parse_params()

static bool conninfo_uri_parse_params	(	char *	params,
		PQconninfoOption *	connOptions,
		PQExpBuffer	errorMessage
	)

static

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

 {
     while (*params)
     {
         char       *keyword = params;
         char       *value = NULL;
         char       *p = params;
         bool        malloced = false;
         int         oldmsglen;
  
         /*
          * Scan the params string for '=' and '&', marking the end of keyword
          * and value respectively.
          */
         for (;;)
         {
             if (*p == '=')
             {
                 /* Was there '=' already? */
                 if (value != NULL)
                 {
                     libpq_append_error(errorMessage,
                                        "extra key/value separator \"=\" in URI query parameter: \"%s\"",
                                        keyword);
                     return false;
                 }
                 /* Cut off keyword, advance to value */
                 *p++ = '\0';
                 value = p;
             }
             else if (*p == '&' || *p == '\0')
             {
                 /*
                  * If not at the end, cut off value and advance; leave p
                  * pointing to start of the next parameter, if any.
                  */
                 if (*p != '\0')
                     *p++ = '\0';
                 /* Was there '=' at all? */
                 if (value == NULL)
                 {
                     libpq_append_error(errorMessage,
                                        "missing key/value separator \"=\" in URI query parameter: \"%s\"",
                                        keyword);
                     return false;
                 }
                 /* Got keyword and value, go process them. */
                 break;
             }
             else
                 ++p;            /* Advance over all other bytes. */
         }
  
         keyword = conninfo_uri_decode(keyword, errorMessage);
         if (keyword == NULL)
         {
             /* conninfo_uri_decode already set an error message */
             return false;
         }
         value = conninfo_uri_decode(value, errorMessage);
         if (value == NULL)
         {
             /* conninfo_uri_decode already set an error message */
             free(keyword);
             return false;
         }
         malloced = true;
  
         /*
          * Special keyword handling for improved JDBC compatibility.
          */
         if (strcmp(keyword, "ssl") == 0 &&
             strcmp(value, "true") == 0)
         {
             free(keyword);
             free(value);
             malloced = false;
  
             keyword = "sslmode";
             value = "require";
         }
  
         /*
          * Store the value if the corresponding option exists; ignore
          * otherwise.  At this point both keyword and value are not
          * URI-encoded.
          */
         oldmsglen = errorMessage->len;
         if (!conninfo_storeval(connOptions, keyword, value,
                                errorMessage, true, false))
         {
             /* Insert generic message if conninfo_storeval didn't give one. */
             if (errorMessage->len == oldmsglen)
                 libpq_append_error(errorMessage,
                                    "invalid URI query parameter: \"%s\"",
                                    keyword);
             /* And fail. */
             if (malloced)
             {
                 free(keyword);
                 free(value);
             }
             return false;
         }
  
         if (malloced)
         {
             free(keyword);
             free(value);
         }
  
         /* Proceed to next key=value pair, if any */
         params = p;
     }
  
     return true;
 }

References conninfo_storeval(), conninfo_uri_decode(), free, PQExpBufferData::len, libpq_append_error(), and value.

Referenced by conninfo_uri_parse_options().

◆ count_comma_separated_elems()

static int count_comma_separated_elems ( const char * input )

static

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

 {
     int         n;
  
     n = 1;
     for (; *input != '\0'; input++)
     {
         if (*input == ',')
             n++;
     }
  
     return n;
 }

References input.

Referenced by connectOptions2().

◆ default_threadlock()

static void default_threadlock ( int acquire )

static

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

 {
 #ifndef WIN32
     static pthread_mutex_t singlethread_lock = PTHREAD_MUTEX_INITIALIZER;
 #else
     static pthread_mutex_t singlethread_lock = NULL;
     static long mutex_initlock = 0;
  
     if (singlethread_lock == NULL)
     {
         while (InterlockedExchange(&mutex_initlock, 1) == 1)
              /* loop, another thread own the lock */ ;
         if (singlethread_lock == NULL)
         {
             if (pthread_mutex_init(&singlethread_lock, NULL))
                 Assert(false);
         }
         InterlockedExchange(&mutex_initlock, 0);
     }
 #endif
     if (acquire)
     {
         if (pthread_mutex_lock(&singlethread_lock))
             Assert(false);
     }
     else
     {
         if (pthread_mutex_unlock(&singlethread_lock))
             Assert(false);
     }
 }

References Assert(), pthread_mutex_init(), pthread_mutex_lock(), and pthread_mutex_unlock().

Referenced by PQregisterThreadLock().

◆ defaultNoticeProcessor()

static void defaultNoticeProcessor	(	void *	arg,
		const char *	message
	)

static

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

 {
     (void) arg;                 /* not used */
     /* Note: we expect the supplied string to end with a newline already. */
     fprintf(stderr, "%s", message);
 }

References arg, and fprintf.

Referenced by makeEmptyPGconn().

◆ defaultNoticeReceiver()

static void defaultNoticeReceiver	(	void *	arg,
		const PGresult *	res
	)

static

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

 {
     (void) arg;                 /* not used */
     if (res->noticeHooks.noticeProc != NULL)
         res->noticeHooks.noticeProc(res->noticeHooks.noticeProcArg,
                                     PQresultErrorMessage(res));
 }

References arg, pg_result::noticeHooks, PGNoticeHooks::noticeProc, PGNoticeHooks::noticeProcArg, PQresultErrorMessage(), and res.

Referenced by makeEmptyPGconn().

◆ emitHostIdentityInfo()

static void emitHostIdentityInfo	(	PGconn *	conn,
		const char *	host_addr
	)

static

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

 {
     if (conn->raddr.addr.ss_family == AF_UNIX)
     {
         char        service[NI_MAXHOST];
  
         pg_getnameinfo_all(&conn->raddr.addr, conn->raddr.salen,
                            NULL, 0,
                            service, sizeof(service),
                            NI_NUMERICSERV);
         appendPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("connection to server on socket \"%s\" failed: "),
                           service);
     }
     else
     {
         const char *displayed_host;
         const char *displayed_port;
  
         /* To which host and port were we actually connecting? */
         if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS)
             displayed_host = conn->connhost[conn->whichhost].hostaddr;
         else
             displayed_host = conn->connhost[conn->whichhost].host;
         displayed_port = conn->connhost[conn->whichhost].port;
         if (displayed_port == NULL || displayed_port[0] == '\0')
             displayed_port = DEF_PGPORT_STR;
  
         /*
          * If the user did not supply an IP address using 'hostaddr', and
          * 'host' was missing or does not match our lookup, display the
          * looked-up IP address.
          */
         if (conn->connhost[conn->whichhost].type != CHT_HOST_ADDRESS &&
             host_addr[0] &&
             strcmp(displayed_host, host_addr) != 0)
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("connection to server at \"%s\" (%s), port %s failed: "),
                               displayed_host, host_addr,
                               displayed_port);
         else
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("connection to server at \"%s\", port %s failed: "),
                               displayed_host,
                               displayed_port);
     }
 }

References SockAddr::addr, appendPQExpBuffer(), CHT_HOST_ADDRESS, conn, pg_conn::connhost, pg_conn::errorMessage, pg_conn_host::host, pg_conn_host::hostaddr, libpq_gettext, pg_getnameinfo_all(), pg_conn_host::port, pg_conn::raddr, SockAddr::salen, pg_conn_host::type, and pg_conn::whichhost.

Referenced by PQconnectPoll().

◆ fillPGconn()

static bool fillPGconn	(	PGconn *	conn,
		PQconninfoOption *	connOptions
	)

static

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

 {
     const internalPQconninfoOption *option;
  
     for (option = PQconninfoOptions; option->keyword; option++)
     {
         if (option->connofs >= 0)
         {
             const char *tmp = conninfo_getval(connOptions, option->keyword);
  
             if (tmp)
             {
                 char      **connmember = (char **) ((char *) conn + option->connofs);
  
                 free(*connmember);
                 *connmember = strdup(tmp);
                 if (*connmember == NULL)
                 {
                     libpq_append_conn_error(conn, "out of memory");
                     return false;
                 }
             }
         }
     }
  
     return true;
 }

References conn, conninfo_getval(), free, libpq_append_conn_error(), and PQconninfoOptions.

Referenced by connectOptions1(), and PQconnectStartParams().

◆ freePGconn()

static void freePGconn ( PGconn * conn )

static

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

 {
     /* let any event procs clean up their state data */
     for (int i = 0; i < conn->nEvents; i++)
     {
         PGEventConnDestroy evt;
  
         evt.conn = conn;
         (void) conn->events[i].proc(PGEVT_CONNDESTROY, &evt,
                                     conn->events[i].passThrough);
         free(conn->events[i].name);
     }
  
     /* clean up pg_conn_host structures */
     for (int i = 0; i < conn->nconnhost; ++i)
     {
         free(conn->connhost[i].host);
         free(conn->connhost[i].hostaddr);
         free(conn->connhost[i].port);
         if (conn->connhost[i].password != NULL)
         {
             explicit_bzero(conn->connhost[i].password, strlen(conn->connhost[i].password));
             free(conn->connhost[i].password);
         }
     }
     free(conn->connhost);
  
     free(conn->client_encoding_initial);
     free(conn->events);
     free(conn->pghost);
     free(conn->pghostaddr);
     free(conn->pgport);
     free(conn->connect_timeout);
     free(conn->pgtcp_user_timeout);
     free(conn->pgoptions);
     free(conn->appname);
     free(conn->fbappname);
     free(conn->dbName);
     free(conn->replication);
     free(conn->pguser);
     if (conn->pgpass)
     {
         explicit_bzero(conn->pgpass, strlen(conn->pgpass));
         free(conn->pgpass);
     }
     free(conn->pgpassfile);
     free(conn->channel_binding);
     free(conn->keepalives);
     free(conn->keepalives_idle);
     free(conn->keepalives_interval);
     free(conn->keepalives_count);
     free(conn->sslmode);
     free(conn->sslcert);
     free(conn->sslkey);
     if (conn->sslpassword)
     {
         explicit_bzero(conn->sslpassword, strlen(conn->sslpassword));
         free(conn->sslpassword);
     }
     free(conn->sslcertmode);
     free(conn->sslrootcert);
     free(conn->sslcrl);
     free(conn->sslcrldir);
     free(conn->sslcompression);
     free(conn->sslsni);
     free(conn->requirepeer);
     free(conn->require_auth);
     free(conn->ssl_min_protocol_version);
     free(conn->ssl_max_protocol_version);
     free(conn->gssencmode);
     free(conn->krbsrvname);
     free(conn->gsslib);
     free(conn->gssdelegation);
     free(conn->connip);
     /* Note that conn->Pfdebug is not ours to close or free */
     free(conn->write_err_msg);
     free(conn->inBuffer);
     free(conn->outBuffer);
     free(conn->rowBuf);
     free(conn->target_session_attrs);
     free(conn->load_balance_hosts);
     termPQExpBuffer(&conn->errorMessage);
     termPQExpBuffer(&conn->workBuffer);
  
     free(conn);
 }

References pg_conn::appname, pg_conn::channel_binding, pg_conn::client_encoding_initial, conn, PGEventConnDestroy::conn, pg_conn::connect_timeout, pg_conn::connhost, pg_conn::connip, pg_conn::dbName, pg_conn::errorMessage, pg_conn::events, explicit_bzero(), pg_conn::fbappname, free, pg_conn::gssdelegation, pg_conn::gssencmode, pg_conn::gsslib, pg_conn_host::host, pg_conn_host::hostaddr, i, pg_conn::inBuffer, pg_conn::keepalives, pg_conn::keepalives_count, pg_conn::keepalives_idle, pg_conn::keepalives_interval, pg_conn::krbsrvname, pg_conn::load_balance_hosts, PGEvent::name, pg_conn::nconnhost, pg_conn::nEvents, pg_conn::outBuffer, PGEvent::passThrough, pg_conn_host::password, PGEVT_CONNDESTROY, pg_conn::pghost, pg_conn::pghostaddr, pg_conn::pgoptions, pg_conn::pgpass, pg_conn::pgpassfile, pg_conn::pgport, pg_conn::pgtcp_user_timeout, pg_conn::pguser, pg_conn_host::port, PGEvent::proc, pg_conn::replication, pg_conn::require_auth, pg_conn::requirepeer, pg_conn::rowBuf, pg_conn::ssl_max_protocol_version, pg_conn::ssl_min_protocol_version, pg_conn::sslcert, pg_conn::sslcertmode, pg_conn::sslcompression, pg_conn::sslcrl, pg_conn::sslcrldir, pg_conn::sslkey, pg_conn::sslmode, pg_conn::sslpassword, pg_conn::sslrootcert, pg_conn::sslsni, pg_conn::target_session_attrs, termPQExpBuffer(), pg_conn::workBuffer, and pg_conn::write_err_msg.

Referenced by makeEmptyPGconn(), and PQfinish().

◆ get_hexdigit()

static bool get_hexdigit	(	char	digit,
		int *	value
	)

static

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

 {
     if ('0' <= digit && digit <= '9')
         *value = digit - '0';
     else if ('A' <= digit && digit <= 'F')
         *value = digit - 'A' + 10;
     else if ('a' <= digit && digit <= 'f')
         *value = digit - 'a' + 10;
     else
         return false;
  
     return true;
 }

References value.

Referenced by conninfo_uri_decode().

◆ getHostaddr()

static void getHostaddr	(	PGconn *	conn,
		char *	host_addr,
		int	host_addr_len
	)

static

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

 {
     struct sockaddr_storage *addr = &conn->raddr.addr;
  
     if (addr->ss_family == AF_INET)
     {
         if (pg_inet_net_ntop(AF_INET,
                              &((struct sockaddr_in *) addr)->sin_addr.s_addr,
                              32,
                              host_addr, host_addr_len) == NULL)
             host_addr[0] = '\0';
     }
     else if (addr->ss_family == AF_INET6)
     {
         if (pg_inet_net_ntop(AF_INET6,
                              &((struct sockaddr_in6 *) addr)->sin6_addr.s6_addr,
                              128,
                              host_addr, host_addr_len) == NULL)
             host_addr[0] = '\0';
     }
     else
         host_addr[0] = '\0';
 }

References SockAddr::addr, conn, pg_inet_net_ntop(), and pg_conn::raddr.

Referenced by PQconnectPoll().

◆ internal_ping()

static PGPing internal_ping ( PGconn * conn )

static

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

 {
     /* Say "no attempt" if we never got to PQconnectPoll */
     if (!conn || !conn->options_valid)
         return PQPING_NO_ATTEMPT;
  
     /* Attempt to complete the connection */
     if (conn->status != CONNECTION_BAD)
         (void) connectDBComplete(conn);
  
     /* Definitely OK if we succeeded */
     if (conn->status != CONNECTION_BAD)
         return PQPING_OK;
  
     /*
      * Here begins the interesting part of "ping": determine the cause of the
      * failure in sufficient detail to decide what to return.  We do not want
      * to report that the server is not up just because we didn't have a valid
      * password, for example.  In fact, any sort of authentication request
      * implies the server is up.  (We need this check since the libpq side of
      * things might have pulled the plug on the connection before getting an
      * error as such from the postmaster.)
      */
     if (conn->auth_req_received)
         return PQPING_OK;
  
     /*
      * If we failed to get any ERROR response from the postmaster, report
      * PQPING_NO_RESPONSE.  This result could be somewhat misleading for a
      * pre-7.4 server, since it won't send back a SQLSTATE, but those are long
      * out of support.  Another corner case where the server could return a
      * failure without a SQLSTATE is fork failure, but PQPING_NO_RESPONSE
      * isn't totally unreasonable for that anyway.  We expect that every other
      * failure case in a modern server will produce a report with a SQLSTATE.
      *
      * NOTE: whenever we get around to making libpq generate SQLSTATEs for
      * client-side errors, we should either not store those into
      * last_sqlstate, or add an extra flag so we can tell client-side errors
      * apart from server-side ones.
      */
     if (strlen(conn->last_sqlstate) != 5)
         return PQPING_NO_RESPONSE;
  
     /*
      * Report PQPING_REJECT if server says it's not accepting connections.
      */
     if (strcmp(conn->last_sqlstate, ERRCODE_CANNOT_CONNECT_NOW) == 0)
         return PQPING_REJECT;
  
     /*
      * Any other SQLSTATE can be taken to indicate that the server is up.
      * Presumably it didn't like our username, password, or database name; or
      * perhaps it had some transient failure, but that should not be taken as
      * meaning "it's down".
      */
     return PQPING_OK;
 }

References pg_conn::auth_req_received, conn, connectDBComplete(), CONNECTION_BAD, ERRCODE_CANNOT_CONNECT_NOW, pg_conn::last_sqlstate, pg_conn::options_valid, PQPING_NO_ATTEMPT, PQPING_NO_RESPONSE, PQPING_OK, PQPING_REJECT, and pg_conn::status.

Referenced by PQping(), and PQpingParams().

◆ libpq_prng_init()

static void libpq_prng_init ( PGconn * conn )

static

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

 {
     uint64      rseed;
     struct timeval tval = {0};
  
     if (pg_prng_strong_seed(&conn->prng_state))
         return;
  
     gettimeofday(&tval, NULL);
  
     rseed = ((uintptr_t) conn) ^
         ((uint64) getpid()) ^
         ((uint64) tval.tv_usec) ^
         ((uint64) tval.tv_sec);
  
     pg_prng_seed(&conn->prng_state, rseed);
 }

References conn, gettimeofday(), pg_prng_seed(), pg_prng_strong_seed, and pg_conn::prng_state.

Referenced by connectOptions2().

◆ makeEmptyPGconn()

static PGconn * makeEmptyPGconn ( void )

static

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

 {
     PGconn     *conn;
  
 #ifdef WIN32
  
     /*
      * Make sure socket support is up and running in this process.
      *
      * Note: the Windows documentation says that we should eventually do a
      * matching WSACleanup() call, but experience suggests that that is at
      * least as likely to cause problems as fix them.  So we don't.
      */
     static bool wsastartup_done = false;
  
     if (!wsastartup_done)
     {
         WSADATA     wsaData;
  
         if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
             return NULL;
         wsastartup_done = true;
     }
  
     /* Forget any earlier error */
     WSASetLastError(0);
 #endif                          /* WIN32 */
  
     conn = (PGconn *) malloc(sizeof(PGconn));
     if (conn == NULL)
         return conn;
  
     /* Zero all pointers and booleans */
     MemSet(conn, 0, sizeof(PGconn));
  
     /* install default notice hooks */
     conn->noticeHooks.noticeRec = defaultNoticeReceiver;
     conn->noticeHooks.noticeProc = defaultNoticeProcessor;
  
     conn->status = CONNECTION_BAD;
     conn->asyncStatus = PGASYNC_IDLE;
     conn->pipelineStatus = PQ_PIPELINE_OFF;
     conn->xactStatus = PQTRANS_IDLE;
     conn->options_valid = false;
     conn->nonblocking = false;
     conn->client_encoding = PG_SQL_ASCII;
     conn->std_strings = false;  /* unless server says differently */
     conn->default_transaction_read_only = PG_BOOL_UNKNOWN;
     conn->in_hot_standby = PG_BOOL_UNKNOWN;
     conn->scram_sha_256_iterations = SCRAM_SHA_256_DEFAULT_ITERATIONS;
     conn->verbosity = PQERRORS_DEFAULT;
     conn->show_context = PQSHOW_CONTEXT_ERRORS;
     conn->sock = PGINVALID_SOCKET;
     conn->Pfdebug = NULL;
  
     /*
      * We try to send at least 8K at a time, which is the usual size of pipe
      * buffers on Unix systems.  That way, when we are sending a large amount
      * of data, we avoid incurring extra kernel context swaps for partial
      * bufferloads.  The output buffer is initially made 16K in size, and we
      * try to dump it after accumulating 8K.
      *
      * With the same goal of minimizing context swaps, the input buffer will
      * be enlarged anytime it has less than 8K free, so we initially allocate
      * twice that.
      */
     conn->inBufSize = 16 * 1024;
     conn->inBuffer = (char *) malloc(conn->inBufSize);
     conn->outBufSize = 16 * 1024;
     conn->outBuffer = (char *) malloc(conn->outBufSize);
     conn->rowBufLen = 32;
     conn->rowBuf = (PGdataValue *) malloc(conn->rowBufLen * sizeof(PGdataValue));
     initPQExpBuffer(&conn->errorMessage);
     initPQExpBuffer(&conn->workBuffer);
  
     if (conn->inBuffer == NULL ||
         conn->outBuffer == NULL ||
         conn->rowBuf == NULL ||
         PQExpBufferBroken(&conn->errorMessage) ||
         PQExpBufferBroken(&conn->workBuffer))
     {
         /* out of memory already :-( */
         freePGconn(conn);
         conn = NULL;
     }
  
     return conn;
 }

References pg_conn::asyncStatus, pg_conn::client_encoding, conn, CONNECTION_BAD, pg_conn::default_transaction_read_only, defaultNoticeProcessor(), defaultNoticeReceiver(), pg_conn::errorMessage, freePGconn(), pg_conn::in_hot_standby, pg_conn::inBuffer, pg_conn::inBufSize, initPQExpBuffer(), malloc, MemSet, pg_conn::nonblocking, pg_conn::noticeHooks, PGNoticeHooks::noticeProc, PGNoticeHooks::noticeRec, pg_conn::options_valid, pg_conn::outBuffer, pg_conn::outBufSize, pg_conn::Pfdebug, PG_BOOL_UNKNOWN, PG_SQL_ASCII, PGASYNC_IDLE, PGINVALID_SOCKET, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PQERRORS_DEFAULT, PQExpBufferBroken, PQSHOW_CONTEXT_ERRORS, PQTRANS_IDLE, pg_conn::rowBuf, pg_conn::rowBufLen, SCRAM_SHA_256_DEFAULT_ITERATIONS, pg_conn::scram_sha_256_iterations, pg_conn::show_context, pg_conn::sock, pg_conn::status, pg_conn::std_strings, pg_conn::verbosity, pg_conn::workBuffer, and pg_conn::xactStatus.

Referenced by PQconnectStart(), PQconnectStartParams(), and PQsetdbLogin().

◆ optional_setsockopt()

static bool optional_setsockopt	(	int	fd,
		int	protoid,
		int	optid,
		int	value
	)

static

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

 {
     if (value < 0)
         return true;
     if (setsockopt(fd, protoid, optid, (char *) &value, sizeof(value)) < 0)
         return false;
     return true;
 }

References fd(), and value.

Referenced by PQcancel().

◆ parse_comma_separated_list()

static char* parse_comma_separated_list	(	char **	startptr,
		bool *	more
	)

static

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

 {
     char       *p;
     char       *s = *startptr;
     char       *e;
     int         len;
  
     /*
      * Search for the end of the current element; a comma or end-of-string
      * acts as a terminator.
      */
     e = s;
     while (*e != '\0' && *e != ',')
         ++e;
     *more = (*e == ',');
  
     len = e - s;
     p = (char *) malloc(sizeof(char) * (len + 1));
     if (p)
     {
         memcpy(p, s, len);
         p[len] = '\0';
     }
     *startptr = e + 1;
  
     return p;
 }

References len, and malloc.

Referenced by connectOptions2().

◆ parse_connection_string()

static PQconninfoOption * parse_connection_string	(	const char *	connstr,
		PQExpBuffer	errorMessage,
		bool	use_defaults
	)

static

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

 {
     /* Parse as URI if connection string matches URI prefix */
     if (uri_prefix_length(connstr) != 0)
         return conninfo_uri_parse(connstr, errorMessage, use_defaults);
  
     /* Parse as default otherwise */
     return conninfo_parse(connstr, errorMessage, use_defaults);
 }

References conninfo_parse(), conninfo_uri_parse(), connstr, and uri_prefix_length().

Referenced by connectOptions1(), conninfo_array_parse(), and PQconninfoParse().

◆ parse_int_param()

static bool parse_int_param	(	const char *	value,
		int *	result,
		PGconn *	conn,
		const char *	context
	)

static

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

 {
     char       *end;
     long        numval;
  
     Assert(value != NULL);
  
     *result = 0;
  
     /* strtol(3) skips leading whitespaces */
     errno = 0;
     numval = strtol(value, &end, 10);
  
     /*
      * If no progress was done during the parsing or an error happened, fail.
      * This tests properly for overflows of the result.
      */
     if (value == end || errno != 0 || numval != (int) numval)
         goto error;
  
     /*
      * Skip any trailing whitespace; if anything but whitespace remains before
      * the terminating character, fail
      */
     while (*end != '\0' && isspace((unsigned char) *end))
         end++;
  
     if (*end != '\0')
         goto error;
  
     *result = numval;
     return true;
  
 error:
     libpq_append_conn_error(conn, "invalid integer value \"%s\" for connection option \"%s\"",
                             value, context);
     return false;
 }

References Assert(), conn, error(), libpq_append_conn_error(), and value.

Referenced by connectDBComplete(), PQconnectPoll(), PQgetCancel(), setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), and setTCPUserTimeout().

◆ parseServiceFile()

static int parseServiceFile	(	const char *	serviceFile,
		const char *	service,
		PQconninfoOption *	options,
		PQExpBuffer	errorMessage,
		bool *	group_found
	)

static

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

 {
     int         result = 0,
                 linenr = 0,
                 i;
     FILE       *f;
     char       *line;
     char        buf[1024];
  
     *group_found = false;
  
     f = fopen(serviceFile, "r");
     if (f == NULL)
     {
         libpq_append_error(errorMessage, "service file \"%s\" not found", serviceFile);
         return 1;
     }
  
     while ((line = fgets(buf, sizeof(buf), f)) != NULL)
     {
         int         len;
  
         linenr++;
  
         if (strlen(line) >= sizeof(buf) - 1)
         {
             libpq_append_error(errorMessage,
                                "line %d too long in service file \"%s\"",
                                linenr,
                                serviceFile);
             result = 2;
             goto exit;
         }
  
         /* ignore whitespace at end of line, especially the newline */
         len = strlen(line);
         while (len > 0 && isspace((unsigned char) line[len - 1]))
             line[--len] = '\0';
  
         /* ignore leading whitespace too */
         while (*line && isspace((unsigned char) line[0]))
             line++;
  
         /* ignore comments and empty lines */
         if (line[0] == '\0' || line[0] == '#')
             continue;
  
         /* Check for right groupname */
         if (line[0] == '[')
         {
             if (*group_found)
             {
                 /* end of desired group reached; return success */
                 goto exit;
             }
  
             if (strncmp(line + 1, service, strlen(service)) == 0 &&
                 line[strlen(service) + 1] == ']')
                 *group_found = true;
             else
                 *group_found = false;
         }
         else
         {
             if (*group_found)
             {
                 /*
                  * Finally, we are in the right group and can parse the line
                  */
                 char       *key,
                            *val;
                 bool        found_keyword;
  
 #ifdef USE_LDAP
                 if (strncmp(line, "ldap", 4) == 0)
                 {
                     int         rc = ldapServiceLookup(line, options, errorMessage);
  
                     /* if rc = 2, go on reading for fallback */
                     switch (rc)
                     {
                         case 0:
                             goto exit;
                         case 1:
                         case 3:
                             result = 3;
                             goto exit;
                         case 2:
                             continue;
                     }
                 }
 #endif
  
                 key = line;
                 val = strchr(line, '=');
                 if (val == NULL)
                 {
                     libpq_append_error(errorMessage,
                                        "syntax error in service file \"%s\", line %d",
                                        serviceFile,
                                        linenr);
                     result = 3;
                     goto exit;
                 }
                 *val++ = '\0';
  
                 if (strcmp(key, "service") == 0)
                 {
                     libpq_append_error(errorMessage,
                                        "nested service specifications not supported in service file \"%s\", line %d",
                                        serviceFile,
                                        linenr);
                     result = 3;
                     goto exit;
                 }
  
                 /*
                  * Set the parameter --- but don't override any previous
                  * explicit setting.
                  */
                 found_keyword = false;
                 for (i = 0; options[i].keyword; i++)
                 {
                     if (strcmp(options[i].keyword, key) == 0)
                     {
                         if (options[i].val == NULL)
                             options[i].val = strdup(val);
                         if (!options[i].val)
                         {
                             libpq_append_error(errorMessage, "out of memory");
                             result = 3;
                             goto exit;
                         }
                         found_keyword = true;
                         break;
                     }
                 }
  
                 if (!found_keyword)
                 {
                     libpq_append_error(errorMessage,
                                        "syntax error in service file \"%s\", line %d",
                                        serviceFile,
                                        linenr);
                     result = 3;
                     goto exit;
                 }
             }
         }
     }
  
 exit:
     fclose(f);
  
     return result;
 }

References buf, exit(), i, sort-test::key, len, libpq_append_error(), and val.

Referenced by parseServiceInfo().

◆ parseServiceInfo()

static int parseServiceInfo	(	PQconninfoOption *	options,
		PQExpBuffer	errorMessage
	)

static

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

 {
     const char *service = conninfo_getval(options, "service");
     char        serviceFile[MAXPGPATH];
     char       *env;
     bool        group_found = false;
     int         status;
     struct stat stat_buf;
  
     /*
      * We have to special-case the environment variable PGSERVICE here, since
      * this is and should be called before inserting environment defaults for
      * other connection options.
      */
     if (service == NULL)
         service = getenv("PGSERVICE");
  
     /* If no service name given, nothing to do */
     if (service == NULL)
         return 0;
  
     /*
      * Try PGSERVICEFILE if specified, else try ~/.pg_service.conf (if that
      * exists).
      */
     if ((env = getenv("PGSERVICEFILE")) != NULL)
         strlcpy(serviceFile, env, sizeof(serviceFile));
     else
     {
         char        homedir[MAXPGPATH];
  
         if (!pqGetHomeDirectory(homedir, sizeof(homedir)))
             goto next_file;
         snprintf(serviceFile, MAXPGPATH, "%s/%s", homedir, ".pg_service.conf");
         if (stat(serviceFile, &stat_buf) != 0)
             goto next_file;
     }
  
     status = parseServiceFile(serviceFile, service, options, errorMessage, &group_found);
     if (group_found || status != 0)
         return status;
  
 next_file:
  
     /*
      * This could be used by any application so we can't use the binary
      * location to find our config files.
      */
     snprintf(serviceFile, MAXPGPATH, "%s/pg_service.conf",
              getenv("PGSYSCONFDIR") ? getenv("PGSYSCONFDIR") : SYSCONFDIR);
     if (stat(serviceFile, &stat_buf) != 0)
         goto last_file;
  
     status = parseServiceFile(serviceFile, service, options, errorMessage, &group_found);
     if (status != 0)
         return status;
  
 last_file:
     if (!group_found)
     {
         libpq_append_error(errorMessage, "definition of service \"%s\" not found", service);
         return 3;
     }
  
     return 0;
 }

References conninfo_getval(), libpq_append_error(), MAXPGPATH, parseServiceFile(), pqGetHomeDirectory(), snprintf, stat, and strlcpy().

Referenced by conninfo_add_defaults().

◆ passwordFromFile()

static char * passwordFromFile	(	const char *	hostname,
		const char *	port,
		const char *	dbname,
		const char *	username,
		const char *	pgpassfile
	)

static

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

 {
     FILE       *fp;
     struct stat stat_buf;
     PQExpBufferData buf;
  
     if (dbname == NULL || dbname[0] == '\0')
         return NULL;
  
     if (username == NULL || username[0] == '\0')
         return NULL;
  
     /* 'localhost' matches pghost of '' or the default socket directory */
     if (hostname == NULL || hostname[0] == '\0')
         hostname = DefaultHost;
     else if (is_unixsock_path(hostname))
  
         /*
          * We should probably use canonicalize_path(), but then we have to
          * bring path.c into libpq, and it doesn't seem worth it.
          */
         if (strcmp(hostname, DEFAULT_PGSOCKET_DIR) == 0)
             hostname = DefaultHost;
  
     if (port == NULL || port[0] == '\0')
         port = DEF_PGPORT_STR;
  
     /* If password file cannot be opened, ignore it. */
     if (stat(pgpassfile, &stat_buf) != 0)
         return NULL;
  
 #ifndef WIN32
     if (!S_ISREG(stat_buf.st_mode))
     {
         fprintf(stderr,
                 libpq_gettext("WARNING: password file \"%s\" is not a plain file\n"),
                 pgpassfile);
         return NULL;
     }
  
     /* If password file is insecure, alert the user and ignore it. */
     if (stat_buf.st_mode & (S_IRWXG | S_IRWXO))
     {
         fprintf(stderr,
                 libpq_gettext("WARNING: password file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n"),
                 pgpassfile);
         return NULL;
     }
 #else
  
     /*
      * On Win32, the directory is protected, so we don't have to check the
      * file.
      */
 #endif
  
     fp = fopen(pgpassfile, "r");
     if (fp == NULL)
         return NULL;
  
     /* Use an expansible buffer to accommodate any reasonable line length */
     initPQExpBuffer(&buf);
  
     while (!feof(fp) && !ferror(fp))
     {
         /* Make sure there's a reasonable amount of room in the buffer */
         if (!enlargePQExpBuffer(&buf, 128))
             break;
  
         /* Read some data, appending it to what we already have */
         if (fgets(buf.data + buf.len, buf.maxlen - buf.len, fp) == NULL)
             break;
         buf.len += strlen(buf.data + buf.len);
  
         /* If we don't yet have a whole line, loop around to read more */
         if (!(buf.len > 0 && buf.data[buf.len - 1] == '\n') && !feof(fp))
             continue;
  
         /* ignore comments */
         if (buf.data[0] != '#')
         {
             char       *t = buf.data;
             int         len;
  
             /* strip trailing newline and carriage return */
             len = pg_strip_crlf(t);
  
             if (len > 0 &&
                 (t = pwdfMatchesString(t, hostname)) != NULL &&
                 (t = pwdfMatchesString(t, port)) != NULL &&
                 (t = pwdfMatchesString(t, dbname)) != NULL &&
                 (t = pwdfMatchesString(t, username)) != NULL)
             {
                 /* Found a match. */
                 char       *ret,
                            *p1,
                            *p2;
  
                 ret = strdup(t);
  
                 fclose(fp);
                 explicit_bzero(buf.data, buf.maxlen);
                 termPQExpBuffer(&buf);
  
                 if (!ret)
                 {
                     /* Out of memory. XXX: an error message would be nice. */
                     return NULL;
                 }
  
                 /* De-escape password. */
                 for (p1 = p2 = ret; *p1 != ':' && *p1 != '\0'; ++p1, ++p2)
                 {
                     if (*p1 == '\\' && p1[1] != '\0')
                         ++p1;
                     *p2 = *p1;
                 }
                 *p2 = '\0';
  
                 return ret;
             }
         }
  
         /* No match, reset buffer to prepare for next line. */
         buf.len = 0;
     }
  
     fclose(fp);
     explicit_bzero(buf.data, buf.maxlen);
     termPQExpBuffer(&buf);
     return NULL;
 }

References buf, dbname, DEFAULT_PGSOCKET_DIR, DefaultHost, enlargePQExpBuffer(), explicit_bzero(), fprintf, hostname, initPQExpBuffer(), is_unixsock_path(), len, libpq_gettext, p2, pg_strip_crlf(), port, pwdfMatchesString(), S_IRWXG, S_IRWXO, S_ISREG, stat::st_mode, stat, termPQExpBuffer(), and username.

Referenced by connectOptions2().

◆ pgpassfileWarning()

static void pgpassfileWarning ( PGconn * conn )

static

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

 {
     /* If it was 'invalid authorization', add pgpassfile mention */
     /* only works with >= 9.0 servers */
     if (conn->password_needed &&
         conn->connhost[conn->whichhost].password != NULL &&
         conn->result)
     {
         const char *sqlstate = PQresultErrorField(conn->result,
                                                   PG_DIAG_SQLSTATE);
  
         if (sqlstate && strcmp(sqlstate, ERRCODE_INVALID_PASSWORD) == 0)
             libpq_append_conn_error(conn, "password retrieved from file \"%s\"",
                                     conn->pgpassfile);
     }
 }

References conn, pg_conn::connhost, ERRCODE_INVALID_PASSWORD, libpq_append_conn_error(), pg_conn_host::password, pg_conn::password_needed, PG_DIAG_SQLSTATE, pg_conn::pgpassfile, PQresultErrorField(), pg_conn::result, and pg_conn::whichhost.

Referenced by PQconnectPoll().

◆ PQbackendPID()

int PQbackendPID ( const PGconn * conn )

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

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

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

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

◆ PQcancel()

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

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

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

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

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

◆ PQclientEncoding()

int PQclientEncoding ( const PGconn * conn )

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

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

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

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

◆ PQconndefaults()

PQconninfoOption* PQconndefaults ( void )

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

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

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

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

◆ PQconnectdb()

PGconn* PQconnectdb ( const char * conninfo )

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

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

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

Referenced by get_db_conn(), and main().

◆ PQconnectdbParams()

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

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

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

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

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

◆ PQconnectionNeedsPassword()

int PQconnectionNeedsPassword ( const PGconn * conn )

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

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

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

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

◆ PQconnectionUsedGSSAPI()

int PQconnectionUsedGSSAPI ( const PGconn * conn )

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

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

References conn, and pg_conn::gssapi_used.

Referenced by dblink_security_check(), and pgfdw_security_check().

◆ PQconnectionUsedPassword()

int PQconnectionUsedPassword ( const PGconn * conn )

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

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

References conn, and pg_conn::password_needed.

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

◆ PQconnectPoll()

PostgresPollingStatusType PQconnectPoll ( PGconn * conn )

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

 {
     bool        reset_connection_state_machine = false;
     bool        need_new_connection = false;
     PGresult   *res;
     char        sebuf[PG_STRERROR_R_BUFLEN];
     int         optval;
  
     if (conn == NULL)
         return PGRES_POLLING_FAILED;
  
     /* Get the new data */
     switch (conn->status)
     {
             /*
              * We really shouldn't have been polled in these two cases, but we
              * can handle it.
              */
         case CONNECTION_BAD:
             return PGRES_POLLING_FAILED;
         case CONNECTION_OK:
             return PGRES_POLLING_OK;
  
             /* These are reading states */
         case CONNECTION_AWAITING_RESPONSE:
         case CONNECTION_AUTH_OK:
         case CONNECTION_CHECK_WRITABLE:
         case CONNECTION_CONSUME:
         case CONNECTION_CHECK_STANDBY:
             {
                 /* Load waiting data */
                 int         n = pqReadData(conn);
  
                 if (n < 0)
                     goto error_return;
                 if (n == 0)
                     return PGRES_POLLING_READING;
  
                 break;
             }
  
             /* These are writing states, so we just proceed. */
         case CONNECTION_STARTED:
         case CONNECTION_MADE:
             break;
  
             /* Special cases: proceed without waiting. */
         case CONNECTION_SSL_STARTUP:
         case CONNECTION_NEEDED:
         case CONNECTION_GSS_STARTUP:
         case CONNECTION_CHECK_TARGET:
             break;
  
         default:
             libpq_append_conn_error(conn, "invalid connection state, probably indicative of memory corruption");
             goto error_return;
     }
  
  
 keep_going:                     /* We will come back to here until there is
                                  * nothing left to do. */
  
     /* Time to advance to next address, or next host if no more addresses? */
     if (conn->try_next_addr)
     {
         if (conn->whichaddr < conn->naddr)
         {
             conn->whichaddr++;
             reset_connection_state_machine = true;
         }
         else
             conn->try_next_host = true;
         conn->try_next_addr = false;
     }
  
     /* Time to advance to next connhost[] entry? */
     if (conn->try_next_host)
     {
         pg_conn_host *ch;
         struct addrinfo hint;
         struct addrinfo *addrlist;
         int         thisport;
         int         ret;
         char        portstr[MAXPGPATH];
  
         if (conn->whichhost + 1 < conn->nconnhost)
             conn->whichhost++;
         else
         {
             /*
              * Oops, no more hosts.
              *
              * If we are trying to connect in "prefer-standby" mode, then drop
              * the standby requirement and start over.
              *
              * Otherwise, an appropriate error message is already set up, so
              * we just need to set the right status.
              */
             if (conn->target_server_type == SERVER_TYPE_PREFER_STANDBY &&
                 conn->nconnhost > 0)
             {
                 conn->target_server_type = SERVER_TYPE_PREFER_STANDBY_PASS2;
                 conn->whichhost = 0;
             }
             else
                 goto error_return;
         }
  
         /* Drop any address info for previous host */
         release_conn_addrinfo(conn);
  
         /*
          * Look up info for the new host.  On failure, log the problem in
          * conn->errorMessage, then loop around to try the next host.  (Note
          * we don't clear try_next_host until we've succeeded.)
          */
         ch = &conn->connhost[conn->whichhost];
  
         /* Initialize hint structure */
         MemSet(&hint, 0, sizeof(hint));
         hint.ai_socktype = SOCK_STREAM;
         hint.ai_family = AF_UNSPEC;
  
         /* Figure out the port number we're going to use. */
         if (ch->port == NULL || ch->port[0] == '\0')
             thisport = DEF_PGPORT;
         else
         {
             if (!parse_int_param(ch->port, &thisport, conn, "port"))
                 goto error_return;
  
             if (thisport < 1 || thisport > 65535)
             {
                 libpq_append_conn_error(conn, "invalid port number: \"%s\"", ch->port);
                 goto keep_going;
             }
         }
         snprintf(portstr, sizeof(portstr), "%d", thisport);
  
         /* Use pg_getaddrinfo_all() to resolve the address */
         switch (ch->type)
         {
             case CHT_HOST_NAME:
                 ret = pg_getaddrinfo_all(ch->host, portstr, &hint,
                                          &addrlist);
                 if (ret || !addrlist)
                 {
                     libpq_append_conn_error(conn, "could not translate host name \"%s\" to address: %s",
                                             ch->host, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
  
             case CHT_HOST_ADDRESS:
                 hint.ai_flags = AI_NUMERICHOST;
                 ret = pg_getaddrinfo_all(ch->hostaddr, portstr, &hint,
                                          &addrlist);
                 if (ret || !addrlist)
                 {
                     libpq_append_conn_error(conn, "could not parse network address \"%s\": %s",
                                             ch->hostaddr, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
  
             case CHT_UNIX_SOCKET:
                 hint.ai_family = AF_UNIX;
                 UNIXSOCK_PATH(portstr, thisport, ch->host);
                 if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
                 {
                     libpq_append_conn_error(conn, "Unix-domain socket path \"%s\" is too long (maximum %d bytes)",
                                             portstr,
                                             (int) (UNIXSOCK_PATH_BUFLEN - 1));
                     goto keep_going;
                 }
  
                 /*
                  * NULL hostname tells pg_getaddrinfo_all to parse the service
                  * name as a Unix-domain socket path.
                  */
                 ret = pg_getaddrinfo_all(NULL, portstr, &hint,
                                          &addrlist);
                 if (ret || !addrlist)
                 {
                     libpq_append_conn_error(conn, "could not translate Unix-domain socket path \"%s\" to address: %s",
                                             portstr, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
         }
  
         /*
          * Store a copy of the addrlist in private memory so we can perform
          * randomization for load balancing.
          */
         ret = store_conn_addrinfo(conn, addrlist);
         pg_freeaddrinfo_all(hint.ai_family, addrlist);
         if (ret)
             goto error_return;  /* message already logged */
  
         /*
          * If random load balancing is enabled we shuffle the addresses.
          */
         if (conn->load_balance_type == LOAD_BALANCE_RANDOM)
         {
             /*
              * This is the "inside-out" variant of the Fisher-Yates shuffle
              * algorithm. Notionally, we append each new value to the array
              * and then swap it with a randomly-chosen array element (possibly
              * including itself, else we fail to generate permutations with
              * the last integer last).  The swap step can be optimized by
              * combining it with the insertion.
              *
              * We don't need to initialize conn->prng_state here, because that
              * already happened in connectOptions2.
              */
             for (int i = 1; i < conn->naddr; i++)
             {
                 int         j = pg_prng_uint64_range(&conn->prng_state, 0, i);
                 AddrInfo    temp = conn->addr[j];
  
                 conn->addr[j] = conn->addr[i];
                 conn->addr[i] = temp;
             }
         }
  
         reset_connection_state_machine = true;
         conn->try_next_host = false;
     }
  
     /* Reset connection state machine? */
     if (reset_connection_state_machine)
     {
         /*
          * (Re) initialize our connection control variables for a set of
          * connection attempts to a single server address.  These variables
          * must persist across individual connection attempts, but we must
          * reset them when we start to consider a new server.
          */
         conn->pversion = PG_PROTOCOL(3, 0);
         conn->send_appname = true;
 #ifdef USE_SSL
         /* initialize these values based on SSL mode */
         conn->allow_ssl_try = (conn->sslmode[0] != 'd');    /* "disable" */
         conn->wait_ssl_try = (conn->sslmode[0] == 'a'); /* "allow" */
 #endif
 #ifdef ENABLE_GSS
         conn->try_gss = (conn->gssencmode[0] != 'd');   /* "disable" */
 #endif
  
         reset_connection_state_machine = false;
         need_new_connection = true;
     }
  
     /* Force a new connection (perhaps to the same server as before)? */
     if (need_new_connection)
     {
         /* Drop any existing connection */
         pqDropConnection(conn, true);
  
         /* Reset all state obtained from old server */
         pqDropServerData(conn);
  
         /* Drop any PGresult we might have, too */
         conn->asyncStatus = PGASYNC_IDLE;
         conn->xactStatus = PQTRANS_IDLE;
         conn->pipelineStatus = PQ_PIPELINE_OFF;
         pqClearAsyncResult(conn);
  
         /* Reset conn->status to put the state machine in the right state */
         conn->status = CONNECTION_NEEDED;
  
         need_new_connection = false;
     }
  
     /* Now try to advance the state machine for this connection */
     switch (conn->status)
     {
         case CONNECTION_NEEDED:
             {
                 /*
                  * Try to initiate a connection to one of the addresses
                  * returned by pg_getaddrinfo_all().  conn->whichaddr is the
                  * next one to try.
                  *
                  * The extra level of braces here is historical.  It's not
                  * worth reindenting this whole switch case to remove 'em.
                  */
                 {
                     char        host_addr[NI_MAXHOST];
                     int         sock_type;
                     AddrInfo   *addr_cur;
  
                     /*
                      * Advance to next possible host, if we've tried all of
                      * the addresses for the current host.
                      */
                     if (conn->whichaddr == conn->naddr)
                     {
                         conn->try_next_host = true;
                         goto keep_going;
                     }
                     addr_cur = &conn->addr[conn->whichaddr];
  
                     /* Remember current address for possible use later */
                     memcpy(&conn->raddr, &addr_cur->addr, sizeof(SockAddr));
  
                     /*
                      * Set connip, too.  Note we purposely ignore strdup
                      * failure; not a big problem if it fails.
                      */
                     if (conn->connip != NULL)
                     {
                         free(conn->connip);
                         conn->connip = NULL;
                     }
                     getHostaddr(conn, host_addr, NI_MAXHOST);
                     if (host_addr[0])
                         conn->connip = strdup(host_addr);
  
                     /* Try to create the socket */
                     sock_type = SOCK_STREAM;
 #ifdef SOCK_CLOEXEC
  
                     /*
                      * Atomically mark close-on-exec, if possible on this
                      * platform, so that there isn't a window where a
                      * subprogram executed by another thread inherits the
                      * socket.  See fallback code below.
                      */
                     sock_type |= SOCK_CLOEXEC;
 #endif
 #ifdef SOCK_NONBLOCK
  
                     /*
                      * We might as well skip a system call for nonblocking
                      * mode too, if we can.
                      */
                     sock_type |= SOCK_NONBLOCK;
 #endif
                     conn->sock = socket(addr_cur->family, sock_type, 0);
                     if (conn->sock == PGINVALID_SOCKET)
                     {
                         int         errorno = SOCK_ERRNO;
  
                         /*
                          * Silently ignore socket() failure if we have more
                          * addresses to try; this reduces useless chatter in
                          * cases where the address list includes both IPv4 and
                          * IPv6 but kernel only accepts one family.
                          */
                         if (conn->whichaddr < conn->naddr ||
                             conn->whichhost + 1 < conn->nconnhost)
                         {
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                         emitHostIdentityInfo(conn, host_addr);
                         libpq_append_conn_error(conn, "could not create socket: %s",
                                                 SOCK_STRERROR(errorno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
                     /*
                      * Once we've identified a target address, all errors
                      * except the preceding socket()-failure case should be
                      * prefixed with host-identity information.  (If the
                      * connection succeeds, the contents of conn->errorMessage
                      * won't matter, so this is harmless.)
                      */
                     emitHostIdentityInfo(conn, host_addr);
  
                     /*
                      * Select socket options: no delay of outgoing data for
                      * TCP sockets, nonblock mode, close-on-exec.  Try the
                      * next address if any of this fails.
                      */
                     if (addr_cur->family != AF_UNIX)
                     {
                         if (!connectNoDelay(conn))
                         {
                             /* error message already created */
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
 #ifndef SOCK_NONBLOCK
                     if (!pg_set_noblock(conn->sock))
                     {
                         libpq_append_conn_error(conn, "could not set socket to nonblocking mode: %s",
                                                 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
 #endif
  
 #ifndef SOCK_CLOEXEC
 #ifdef F_SETFD
                     if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
                     {
                         libpq_append_conn_error(conn, "could not set socket to close-on-exec mode: %s",
                                                 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
 #endif                          /* F_SETFD */
 #endif
  
                     if (addr_cur->family != AF_UNIX)
                     {
 #ifndef WIN32
                         int         on = 1;
 #endif
                         int         usekeepalives = useKeepalives(conn);
                         int         err = 0;
  
                         if (usekeepalives < 0)
                         {
                             libpq_append_conn_error(conn, "keepalives parameter must be an integer");
                             err = 1;
                         }
                         else if (usekeepalives == 0)
                         {
                             /* Do nothing */
                         }
 #ifndef WIN32
                         else if (setsockopt(conn->sock,
                                             SOL_SOCKET, SO_KEEPALIVE,
                                             (char *) &on, sizeof(on)) < 0)
                         {
                             libpq_append_conn_error(conn, "%s(%s) failed: %s",
                                                     "setsockopt",
                                                     "SO_KEEPALIVE",
                                                     SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                             err = 1;
                         }
                         else if (!setKeepalivesIdle(conn)
                                  || !setKeepalivesInterval(conn)
                                  || !setKeepalivesCount(conn))
                             err = 1;
 #else                           /* WIN32 */
 #ifdef SIO_KEEPALIVE_VALS
                         else if (!prepKeepalivesWin32(conn))
                             err = 1;
 #endif                          /* SIO_KEEPALIVE_VALS */
 #endif                          /* WIN32 */
                         else if (!setTCPUserTimeout(conn))
                             err = 1;
  
                         if (err)
                         {
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
  
                     /*----------
                      * We have three methods of blocking SIGPIPE during
                      * send() calls to this socket:
                      *
                      *  - setsockopt(sock, SO_NOSIGPIPE)
                      *  - send(sock, ..., MSG_NOSIGNAL)
                      *  - setting the signal mask to SIG_IGN during send()
                      *
                      * The third method requires three syscalls per send,
                      * so we prefer either of the first two, but they are
                      * less portable.  The state is tracked in the following
                      * members of PGconn:
                      *
                      * conn->sigpipe_so     - we have set up SO_NOSIGPIPE
                      * conn->sigpipe_flag   - we're specifying MSG_NOSIGNAL
                      *
                      * If we can use SO_NOSIGPIPE, then set sigpipe_so here
                      * and we're done.  Otherwise, set sigpipe_flag so that
                      * we will try MSG_NOSIGNAL on sends.  If we get an error
                      * with MSG_NOSIGNAL, we'll clear that flag and revert to
                      * signal masking.
                      *----------
                      */
                     conn->sigpipe_so = false;
 #ifdef MSG_NOSIGNAL
                     conn->sigpipe_flag = true;
 #else
                     conn->sigpipe_flag = false;
 #endif                          /* MSG_NOSIGNAL */
  
 #ifdef SO_NOSIGPIPE
                     optval = 1;
                     if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
                                    (char *) &optval, sizeof(optval)) == 0)
                     {
                         conn->sigpipe_so = true;
                         conn->sigpipe_flag = false;
                     }
 #endif                          /* SO_NOSIGPIPE */
  
                     /*
                      * Start/make connection.  This should not block, since we
                      * are in nonblock mode.  If it does, well, too bad.
                      */
                     if (connect(conn->sock, (struct sockaddr *) &addr_cur->addr.addr,
                                 addr_cur->addr.salen) < 0)
                     {
                         if (SOCK_ERRNO == EINPROGRESS ||
 #ifdef WIN32
                             SOCK_ERRNO == EWOULDBLOCK ||
 #endif
                             SOCK_ERRNO == EINTR)
                         {
                             /*
                              * This is fine - we're in non-blocking mode, and
                              * the connection is in progress.  Tell caller to
                              * wait for write-ready on socket.
                              */
                             conn->status = CONNECTION_STARTED;
                             return PGRES_POLLING_WRITING;
                         }
                         /* otherwise, trouble */
                     }
                     else
                     {
                         /*
                          * Hm, we're connected already --- seems the "nonblock
                          * connection" wasn't.  Advance the state machine and
                          * go do the next stuff.
                          */
                         conn->status = CONNECTION_STARTED;
                         goto keep_going;
                     }
  
                     /*
                      * This connection failed.  Add the error report to
                      * conn->errorMessage, then try the next address if any.
                      */
                     connectFailureMessage(conn, SOCK_ERRNO);
                     conn->try_next_addr = true;
                     goto keep_going;
                 }
             }
  
         case CONNECTION_STARTED:
             {
                 socklen_t   optlen = sizeof(optval);
  
                 /*
                  * Write ready, since we've made it here, so the connection
                  * has been made ... or has failed.
                  */
  
                 /*
                  * Now check (using getsockopt) that there is not an error
                  * state waiting for us on the socket.
                  */
  
                 if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
                                (char *) &optval, &optlen) == -1)
                 {
                     libpq_append_conn_error(conn, "could not get socket error status: %s",
                                             SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
                 else if (optval != 0)
                 {
                     /*
                      * When using a nonblocking connect, we will typically see
                      * connect failures at this point, so provide a friendly
                      * error message.
                      */
                     connectFailureMessage(conn, optval);
  
                     /*
                      * Try the next address if any, just as in the case where
                      * connect() returned failure immediately.
                      */
                     conn->try_next_addr = true;
                     goto keep_going;
                 }
  
                 /* Fill in the client address */
                 conn->laddr.salen = sizeof(conn->laddr.addr);
                 if (getsockname(conn->sock,
                                 (struct sockaddr *) &conn->laddr.addr,
                                 &conn->laddr.salen) < 0)
                 {
                     libpq_append_conn_error(conn, "could not get client address from socket: %s",
                                             SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
  
                 /*
                  * Make sure we can write before advancing to next step.
                  */
                 conn->status = CONNECTION_MADE;
                 return PGRES_POLLING_WRITING;
             }
  
         case CONNECTION_MADE:
             {
                 char       *startpacket;
                 int         packetlen;
  
                 /*
                  * Implement requirepeer check, if requested and it's a
                  * Unix-domain socket.
                  */
                 if (conn->requirepeer && conn->requirepeer[0] &&
                     conn->raddr.addr.ss_family == AF_UNIX)
                 {
 #ifndef WIN32
                     char       *remote_username;
 #endif
                     uid_t       uid;
                     gid_t       gid;
  
                     errno = 0;
                     if (getpeereid(conn->sock, &uid, &gid) != 0)
                     {
                         /*
                          * Provide special error message if getpeereid is a
                          * stub
                          */
                         if (errno == ENOSYS)
                             libpq_append_conn_error(conn, "requirepeer parameter is not supported on this platform");
                         else
                             libpq_append_conn_error(conn, "could not get peer credentials: %s",
                                                     strerror_r(errno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
 #ifndef WIN32
                     remote_username = pg_fe_getusername(uid,
                                                         &conn->errorMessage);
                     if (remote_username == NULL)
                         goto error_return;  /* message already logged */
  
                     if (strcmp(remote_username, conn->requirepeer) != 0)
                     {
                         libpq_append_conn_error(conn, "requirepeer specifies \"%s\", but actual peer user name is \"%s\"",
                                                 conn->requirepeer, remote_username);
                         free(remote_username);
                         goto error_return;
                     }
                     free(remote_username);
 #else                           /* WIN32 */
                     /* should have failed with ENOSYS above */
                     Assert(false);
 #endif                          /* WIN32 */
                 }
  
                 if (conn->raddr.addr.ss_family == AF_UNIX)
                 {
                     /* Don't request SSL or GSSAPI over Unix sockets */
 #ifdef USE_SSL
                     conn->allow_ssl_try = false;
 #endif
 #ifdef ENABLE_GSS
                     conn->try_gss = false;
 #endif
                 }
  
 #ifdef ENABLE_GSS
  
                 /*
                  * If GSSAPI encryption is enabled, then call
                  * pg_GSS_have_cred_cache() which will return true if we can
                  * acquire credentials (and give us a handle to use in
                  * conn->gcred), and then send a packet to the server asking
                  * for GSSAPI Encryption (and skip past SSL negotiation and
                  * regular startup below).
                  */
                 if (conn->try_gss && !conn->gctx)
                     conn->try_gss = pg_GSS_have_cred_cache(&conn->gcred);
                 if (conn->try_gss && !conn->gctx)
                 {
                     ProtocolVersion pv = pg_hton32(NEGOTIATE_GSS_CODE);
  
                     if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                     {
                         libpq_append_conn_error(conn, "could not send GSSAPI negotiation packet: %s",
                                                 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
                     /* Ok, wait for response */
                     conn->status = CONNECTION_GSS_STARTUP;
                     return PGRES_POLLING_READING;
                 }
                 else if (!conn->gctx && conn->gssencmode[0] == 'r')
                 {
                     libpq_append_conn_error(conn,
                                             "GSSAPI encryption required but was impossible (possibly no credential cache, no server support, or using a local socket)");
                     goto error_return;
                 }
 #endif
  
 #ifdef USE_SSL
  
                 /*
                  * Enable the libcrypto callbacks before checking if SSL needs
                  * to be done.  This is done before sending the startup packet
                  * as depending on the type of authentication done, like MD5
                  * or SCRAM that use cryptohashes, the callbacks would be
                  * required even without a SSL connection
                  */
                 if (pqsecure_initialize(conn, false, true) < 0)
                     goto error_return;
  
                 /*
                  * If SSL is enabled and we haven't already got encryption of
                  * some sort running, request SSL instead of sending the
                  * startup message.
                  */
                 if (conn->allow_ssl_try && !conn->wait_ssl_try &&
                     !conn->ssl_in_use
 #ifdef ENABLE_GSS
                     && !conn->gssenc
 #endif
                     )
                 {
                     ProtocolVersion pv;
  
                     /*
                      * Send the SSL request packet.
                      *
                      * Theoretically, this could block, but it really
                      * shouldn't since we only got here if the socket is
                      * write-ready.
                      */
                     pv = pg_hton32(NEGOTIATE_SSL_CODE);
                     if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                     {
                         libpq_append_conn_error(conn, "could not send SSL negotiation packet: %s",
                                                 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
                     /* Ok, wait for response */
                     conn->status = CONNECTION_SSL_STARTUP;
                     return PGRES_POLLING_READING;
                 }
 #endif                          /* USE_SSL */
  
                 /*
                  * Build the startup packet.
                  */
                 startpacket = pqBuildStartupPacket3(conn, &packetlen,
                                                     EnvironmentOptions);
                 if (!startpacket)
                 {
                     libpq_append_conn_error(conn, "out of memory");
                     goto error_return;
                 }
  
                 /*
                  * Send the startup packet.
                  *
                  * Theoretically, this could block, but it really shouldn't
                  * since we only got here if the socket is write-ready.
                  */
                 if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
                 {
                     libpq_append_conn_error(conn, "could not send startup packet: %s",
                                             SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     free(startpacket);
                     goto error_return;
                 }
  
                 free(startpacket);
  
                 conn->status = CONNECTION_AWAITING_RESPONSE;
                 return PGRES_POLLING_READING;
             }
  
             /*
              * Handle SSL negotiation: wait for postmaster messages and
              * respond as necessary.
              */
         case CONNECTION_SSL_STARTUP:
             {
 #ifdef USE_SSL
                 PostgresPollingStatusType pollres;
  
                 /*
                  * On first time through, get the postmaster's response to our
                  * SSL negotiation packet.
                  */
                 if (!conn->ssl_in_use)
                 {
                     /*
                      * We use pqReadData here since it has the logic to
                      * distinguish no-data-yet from connection closure. Since
                      * conn->ssl isn't set, a plain recv() will occur.
                      */
                     char        SSLok;
                     int         rdresult;
  
                     rdresult = pqReadData(conn);
                     if (rdresult < 0)
                     {
                         /* errorMessage is already filled in */
                         goto error_return;
                     }
                     if (rdresult == 0)
                     {
                         /* caller failed to wait for data */
                         return PGRES_POLLING_READING;
                     }
                     if (pqGetc(&SSLok, conn) < 0)
                     {
                         /* should not happen really */
                         return PGRES_POLLING_READING;
                     }
                     if (SSLok == 'S')
                     {
                         /* mark byte consumed */
                         conn->inStart = conn->inCursor;
  
                         /*
                          * Set up global SSL state if required.  The crypto
                          * state has already been set if libpq took care of
                          * doing that, so there is no need to make that happen
                          * again.
                          */
                         if (pqsecure_initialize(conn, true, false) != 0)
                             goto error_return;
                     }
                     else if (SSLok == 'N')
                     {
                         /* mark byte consumed */
                         conn->inStart = conn->inCursor;
                         /* OK to do without SSL? */
                         if (conn->sslmode[0] == 'r' ||  /* "require" */
                             conn->sslmode[0] == 'v')    /* "verify-ca" or
                                                          * "verify-full" */
                         {
                             /* Require SSL, but server does not want it */
                             libpq_append_conn_error(conn, "server does not support SSL, but SSL was required");
                             goto error_return;
                         }
                         /* Otherwise, proceed with normal startup */
                         conn->allow_ssl_try = false;
                         /* We can proceed using this connection */
                         conn->status = CONNECTION_MADE;
                         return PGRES_POLLING_WRITING;
                     }
                     else if (SSLok == 'E')
                     {
                         /*
                          * Server failure of some sort, such as failure to
                          * fork a backend process.  We need to process and
                          * report the error message, which might be formatted
                          * according to either protocol 2 or protocol 3.
                          * Rather than duplicate the code for that, we flip
                          * into AWAITING_RESPONSE state and let the code there
                          * deal with it.  Note we have *not* consumed the "E"
                          * byte here.
                          */
                         conn->status = CONNECTION_AWAITING_RESPONSE;
                         goto keep_going;
                     }
                     else
                     {
                         libpq_append_conn_error(conn, "received invalid response to SSL negotiation: %c",
                                                 SSLok);
                         goto error_return;
                     }
                 }
  
                 /*
                  * Begin or continue the SSL negotiation process.
                  */
                 pollres = pqsecure_open_client(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /*
                      * At this point we should have no data already buffered.
                      * If we do, it was received before we performed the SSL
                      * handshake, so it wasn't encrypted and indeed may have
                      * been injected by a man-in-the-middle.
                      */
                     if (conn->inCursor != conn->inEnd)
                     {
                         libpq_append_conn_error(conn, "received unencrypted data after SSL response");
                         goto error_return;
                     }
  
                     /* SSL handshake done, ready to send startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 if (pollres == PGRES_POLLING_FAILED)
                 {
                     /*
                      * Failed ... if sslmode is "prefer" then do a non-SSL
                      * retry
                      */
                     if (conn->sslmode[0] == 'p' /* "prefer" */
                         && conn->allow_ssl_try  /* redundant? */
                         && !conn->wait_ssl_try) /* redundant? */
                     {
                         /* only retry once */
                         conn->allow_ssl_try = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
                     /* Else it's a hard failure */
                     goto error_return;
                 }
                 /* Else, return POLLING_READING or POLLING_WRITING status */
                 return pollres;
 #else                           /* !USE_SSL */
                 /* can't get here */
                 goto error_return;
 #endif                          /* USE_SSL */
             }
  
         case CONNECTION_GSS_STARTUP:

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DefaultChannelBinding

◆ DefaultGSSMode

◆ DefaultHost

◆ DefaultLoadBalanceHosts

◆ DefaultOption

◆ DefaultSSLCertMode

◆ DefaultSSLMode

◆ DefaultTargetSessionAttrs

◆ ERRCODE_APPNAME_UNKNOWN

◆ ERRCODE_CANNOT_CONNECT_NOW

◆ ERRCODE_INVALID_PASSWORD

◆ MAX_ERRLEN

◆ PGPASSFILE

Typedef Documentation

◆ internalPQconninfoOption

Function Documentation

◆ closePGconn()

◆ connectDBComplete()

◆ connectDBStart()

◆ connectFailureMessage()

◆ connectNoDelay()

◆ connectOptions1()

◆ connectOptions2()

◆ conninfo_add_defaults()

◆ conninfo_array_parse()

◆ conninfo_find()

◆ conninfo_getval()

◆ conninfo_init()

◆ conninfo_parse()

◆ conninfo_storeval()

◆ conninfo_uri_decode()

◆ conninfo_uri_parse()

◆ conninfo_uri_parse_options()

◆ conninfo_uri_parse_params()

◆ count_comma_separated_elems()

◆ default_threadlock()

◆ defaultNoticeProcessor()

◆ defaultNoticeReceiver()

◆ emitHostIdentityInfo()

◆ fillPGconn()

◆ freePGconn()

◆ get_hexdigit()

◆ getHostaddr()

◆ internal_ping()

◆ libpq_prng_init()

◆ makeEmptyPGconn()

◆ optional_setsockopt()

◆ parse_comma_separated_list()

◆ parse_connection_string()

◆ parse_int_param()

◆ parseServiceFile()

◆ parseServiceInfo()

◆ passwordFromFile()

◆ pgpassfileWarning()

◆ PQbackendPID()

◆ PQcancel()

◆ PQclientEncoding()

◆ PQconndefaults()

◆ PQconnectdb()

◆ PQconnectdbParams()

◆ PQconnectionNeedsPassword()

◆ PQconnectionUsedGSSAPI()

◆ PQconnectionUsedPassword()

◆ PQconnectPoll()