#include "postgres_fe.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.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 <netdb.h>
#include <netinet/in.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	DefaultSSLMode "disable"

#define	DefaultGSSMode "disable"

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 void	sendTerminateConn (PGconn *conn)

static PQconninfoOption *	conninfo_init (PQExpBuffer errorMessage)

static PQconninfoOption *	parse_connection_string (const char *conninfo, 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)

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)

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 bool	parse_int_param (const char value, int result, PGconn conn, const char context)

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	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 126 of file fe-connect.c.

◆ DefaultGSSMode

#define DefaultGSSMode "disable"

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

◆ DefaultHost

#define DefaultHost "localhost"

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

◆ DefaultOption

#define DefaultOption ""

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

◆ DefaultSSLMode

#define DefaultSSLMode "disable"

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

◆ DefaultTargetSessionAttrs

#define DefaultTargetSessionAttrs "any"

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

◆ ERRCODE_APPNAME_UNKNOWN

#define ERRCODE_APPNAME_UNKNOWN "42704"

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

◆ ERRCODE_CANNOT_CONNECT_NOW

#define ERRCODE_CANNOT_CONNECT_NOW "57P03"

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

◆ ERRCODE_INVALID_PASSWORD

#define ERRCODE_INVALID_PASSWORD "28P01"

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

◆ PGPASSFILE

#define PGPASSFILE ".pgpass"

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

Typedef Documentation

◆ internalPQconninfoOption

typedef struct _internalPQconninfoOption internalPQconninfoOption

Function Documentation

◆ closePGconn()

static void closePGconn ( PGconn * conn )

static

Definition at line 4222 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 2126 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 */
     struct addrinfo *last_addr_cur = NULL;
  
     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->addr_cur != last_addr_cur))
         {
             finish_time = time(NULL) + timeout;
             last_whichhost = conn->whichhost;
             last_addr_cur = conn->addr_cur;
         }
  
         /*
          * 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 pg_conn::addr_cur, 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, and pg_conn::whichhost.

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

◆ connectDBStart()

static int connectDBStart ( PGconn * conn )

static

Definition at line 2056 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 1757 of file fe-connect.c.

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

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

Referenced by PQconnectPoll().

◆ connectNoDelay()

static int connectNoDelay ( PGconn * conn )

static

Definition at line 1637 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];
  
         appendPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("could not set socket to TCP no delay mode: %s\n"),
                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
         return 0;
     }
 #endif
  
     return 1;
 }

References appendPQExpBuffer(), conn, pg_conn::errorMessage, libpq_gettext, 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 929 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 1027 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;
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("could not match %d host names to %d hostaddr values\n"),
                               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;
 #ifdef HAVE_UNIX_SOCKETS
             if (is_unixsock_path(ch->host))
                 ch->type = CHT_UNIX_SOCKET;
 #endif
         }
         else
         {
             if (ch->host)
                 free(ch->host);
  
             /*
              * This bit selects the default host location.  If you change
              * this, see also pg_regress.
              */
 #ifdef HAVE_UNIX_SOCKETS
             if (DEFAULT_PGSOCKET_DIR[0])
             {
                 ch->host = strdup(DEFAULT_PGSOCKET_DIR);
                 ch->type = CHT_UNIX_SOCKET;
             }
             else
 #endif
             {
                 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;
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("could not match %d port numbers to %d hosts\n"),
                               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')
     {
         if (conn->pguser)
             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')
     {
         if (conn->dbName)
             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)))
             {
                 if (conn->pgpassfile)
                     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);
             }
         }
     }
  
     /*
      * 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;
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("invalid %s value: \"%s\"\n"),
                               "channel_binding", conn->channel_binding);
             return false;
         }
     }
     else
     {
         conn->channel_binding = strdup(DefaultChannelBinding);
         if (!conn->channel_binding)
             goto oom_error;
     }
  
     /*
      * 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;
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("invalid %s value: \"%s\"\n"),
                               "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;
                 appendPQExpBuffer(&conn->errorMessage,
                                   libpq_gettext("sslmode value \"%s\" invalid when SSL support is not compiled in\n"),
                                   conn->sslmode);
                 return false;
         }
 #endif
     }
     else
     {
         conn->sslmode = strdup(DefaultSSLMode);
         if (!conn->sslmode)
             goto oom_error;
     }
  
     /*
      * 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;
         appendPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("invalid %s value: \"%s\"\n"),
                           "ssl_min_protocol_version",
                           conn->ssl_min_protocol_version);
         return false;
     }
     if (!sslVerifyProtocolVersion(conn->ssl_max_protocol_version))
     {
         conn->status = CONNECTION_BAD;
         appendPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("invalid %s value: \"%s\"\n"),
                           "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;
         appendPQExpBufferStr(&conn->errorMessage,
                              libpq_gettext("invalid SSL protocol version range\n"));
         return false;
     }
  
     /*
      * 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;
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("invalid %s value: \"%s\"\n"),
                               "gssencmode",
                               conn->gssencmode);
             return false;
         }
 #ifndef ENABLE_GSS
         if (strcmp(conn->gssencmode, "require") == 0)
         {
             conn->status = CONNECTION_BAD;
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("gssencmode value \"%s\" invalid when GSSAPI support is not compiled in\n"),
                               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;
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("invalid %s value: \"%s\"\n"),
                               "target_session_attrs",
                               conn->target_session_attrs);
             return false;
         }
     }
     else
         conn->target_server_type = SERVER_TYPE_ANY;
  
     /*
      * 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;
     appendPQExpBufferStr(&conn->errorMessage,
                          libpq_gettext("out of memory\n"));
     return false;
 }

References appendPQExpBuffer(), appendPQExpBufferStr(), Assert(), 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, DefaultSSLMode, pg_conn::errorMessage, free, pg_conn::gssencmode, pg_conn_host::host, pg_conn_host::hostaddr, i, is_unixsock_path(), libpq_gettext, 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_conn::pghost, pg_conn::pghostaddr, pg_conn::pgpass, PGPASSFILE, pg_conn::pgpassfile, pg_conn::pgport, pg_conn::pguser, pg_conn_host::port, pqGetHomeDirectory(), 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::sslmode, 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 5959 of file fe-connect.c.

 {
     PQconninfoOption *option;
     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 (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)
                         appendPQExpBufferStr(errorMessage,
                                              libpq_gettext("out of memory\n"));
                     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)
                         appendPQExpBufferStr(errorMessage,
                                              libpq_gettext("out of memory\n"));
                     return false;
                 }
                 continue;
             }
         }
  
         /*
          * 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)
                     appendPQExpBufferStr(errorMessage,
                                          libpq_gettext("out of memory\n"));
                 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;
         }
     }
  
     return true;
 }

References appendPQExpBufferStr(), libpq_gettext, parseServiceInfo(), pg_fe_getauthname(), and option::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 5795 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)
             {
                 appendPQExpBuffer(errorMessage,
                                   libpq_gettext("invalid connection option \"%s\"\n"),
                                   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)
                             {
                                 if (options[k].val)
                                     free(options[k].val);
                                 options[k].val = strdup(str_option->val);
                                 if (!options[k].val)
                                 {
                                     appendPQExpBufferStr(errorMessage,
                                                          libpq_gettext("out of memory\n"));
                                     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
                  */
                 if (option->val)
                     free(option->val);
                 option->val = strdup(pvalue);
                 if (!option->val)
                 {
                     appendPQExpBufferStr(errorMessage,
                                          libpq_gettext("out of memory\n"));
                     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 appendPQExpBuffer(), appendPQExpBufferStr(), conninfo_add_defaults(), conninfo_init(), free, i, _PQconninfoOption::keyword, libpq_gettext, 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 6674 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 6583 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 5523 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)
     {
         appendPQExpBufferStr(errorMessage,
                              libpq_gettext("out of memory\n"));
         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 appendPQExpBufferStr(), _internalPQconninfoOption::keyword, libpq_gettext, 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 5617 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)
     {
         appendPQExpBufferStr(errorMessage,
                              libpq_gettext("out of memory\n"));
         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 != '=')
         {
             appendPQExpBuffer(errorMessage,
                               libpq_gettext("missing \"=\" after \"%s\" in connection info string\n"),
                               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')
                 {
                     appendPQExpBufferStr(errorMessage,
                                          libpq_gettext("unterminated quoted string in connection info string\n"));
                     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 appendPQExpBuffer(), appendPQExpBufferStr(), buf, conninfo_add_defaults(), conninfo_init(), conninfo_storeval(), free, libpq_gettext, 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 6609 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)
             appendPQExpBuffer(errorMessage,
                               libpq_gettext("invalid connection option \"%s\"\n"),
                               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)
         {
             appendPQExpBufferStr(errorMessage, libpq_gettext("out of memory\n"));
             return NULL;
         }
     }
  
     if (option->val)
         free(option->val);
     option->val = value_copy;
  
     return option;
 }

References appendPQExpBuffer(), appendPQExpBufferStr(), conninfo_find(), conninfo_uri_decode(), free, libpq_gettext, 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 6494 of file fe-connect.c.

 {
     char       *buf;
     char       *p;
     const char *q = str;
  
     buf = malloc(strlen(str) + 1);
     if (buf == NULL)
     {
         appendPQExpBufferStr(errorMessage, libpq_gettext("out of memory\n"));
         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)))
             {
                 appendPQExpBuffer(errorMessage,
                                   libpq_gettext("invalid percent-encoded token: \"%s\"\n"),
                                   str);
                 free(buf);
                 return NULL;
             }
  
             c = (hi << 4) | lo;
             if (c == 0)
             {
                 appendPQExpBuffer(errorMessage,
                                   libpq_gettext("forbidden value %%00 in percent-encoded value: \"%s\"\n"),
                                   str);
                 free(buf);
                 return NULL;
             }
             *(p++) = c;
         }
     }
  
     return buf;
 }

References appendPQExpBuffer(), appendPQExpBufferStr(), buf, free, get_hexdigit(), libpq_gettext, 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 6064 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 6117 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))
     {
         appendPQExpBufferStr(errorMessage,
                              libpq_gettext("out of memory\n"));
         goto cleanup;
     }
  
     /* need a modifiable copy of the input URI */
     buf = strdup(uri);
     if (buf == NULL)
     {
         appendPQExpBufferStr(errorMessage,
                              libpq_gettext("out of memory\n"));
         goto cleanup;
     }
     start = buf;
  
     /* Skip the URI prefix */
     prefix_len = uri_prefix_length(uri);
     if (prefix_len == 0)
     {
         /* Should never happen */
         appendPQExpBuffer(errorMessage,
                           libpq_gettext("invalid URI propagated to internal parser routine: \"%s\"\n"),
                           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)
             {
                 appendPQExpBuffer(errorMessage,
                                   libpq_gettext("end of string reached when looking for matching \"]\" in IPv6 host address in URI: \"%s\"\n"),
                                   uri);
                 goto cleanup;
             }
             if (p == host)
             {
                 appendPQExpBuffer(errorMessage,
                                   libpq_gettext("IPv6 host address may not be empty in URI: \"%s\"\n"),
                                   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 != ',')
             {
                 appendPQExpBuffer(errorMessage,
                                   libpq_gettext("unexpected character \"%c\" at position %d in URI (expected \":\" or \"/\"): \"%s\"\n"),
                                   *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);
     if (buf)
         free(buf);
     return retval;
 }

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), buf, cleanup(), conninfo_storeval(), conninfo_uri_parse_params(), PQExpBufferData::data, dbname, free, initPQExpBuffer(), libpq_gettext, 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 6361 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)
                 {
                     appendPQExpBuffer(errorMessage,
                                       libpq_gettext("extra key/value separator \"=\" in URI query parameter: \"%s\"\n"),
                                       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)
                 {
                     appendPQExpBuffer(errorMessage,
                                       libpq_gettext("missing key/value separator \"=\" in URI query parameter: \"%s\"\n"),
                                       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)
                 appendPQExpBuffer(errorMessage,
                                   libpq_gettext("invalid URI query parameter: \"%s\"\n"),
                                   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 appendPQExpBuffer(), conninfo_storeval(), conninfo_uri_decode(), free, PQExpBufferData::len, libpq_gettext, 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 966 of file fe-connect.c.

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

Referenced by connectOptions2().

◆ default_threadlock()

static void default_threadlock ( int acquire )

static

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

 {
 #ifdef ENABLE_THREAD_SAFETY
 #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);
     }
 #endif
 }

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 7114 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 7099 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 1699 of file fe-connect.c.

 {
 #ifdef HAVE_UNIX_SOCKETS
     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
 #endif                          /* HAVE_UNIX_SOCKETS */
     {
         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, NI_MAXHOST, NI_NUMERICSERV, 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 887 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);
  
                 if (*connmember)
                     free(*connmember);
                 *connmember = strdup(tmp);
                 if (*connmember == NULL)
                 {
                     appendPQExpBufferStr(&conn->errorMessage,
                                          libpq_gettext("out of memory\n"));
                     return false;
                 }
             }
         }
     }
  
     return true;
 }

References appendPQExpBufferStr(), conn, conninfo_getval(), pg_conn::errorMessage, free, libpq_gettext, and PQconninfoOptions.

Referenced by connectOptions1(), and PQconnectStartParams().

◆ freePGconn()

static void freePGconn ( PGconn * conn )

static

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

 {
     int         i;
  
     /* let any event procs clean up their state data */
     for (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 */
     if (conn->connhost != NULL)
     {
         for (i = 0; i < conn->nconnhost; ++i)
         {
             if (conn->connhost[i].host != NULL)
                 free(conn->connhost[i].host);
             if (conn->connhost[i].hostaddr != NULL)
                 free(conn->connhost[i].hostaddr);
             if (conn->connhost[i].port != NULL)
                 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);
     }
  
     if (conn->client_encoding_initial)
         free(conn->client_encoding_initial);
     if (conn->events)
         free(conn->events);
     if (conn->pghost)
         free(conn->pghost);
     if (conn->pghostaddr)
         free(conn->pghostaddr);
     if (conn->pgport)
         free(conn->pgport);
     if (conn->connect_timeout)
         free(conn->connect_timeout);
     if (conn->pgtcp_user_timeout)
         free(conn->pgtcp_user_timeout);
     if (conn->pgoptions)
         free(conn->pgoptions);
     if (conn->appname)
         free(conn->appname);
     if (conn->fbappname)
         free(conn->fbappname);
     if (conn->dbName)
         free(conn->dbName);
     if (conn->replication)
         free(conn->replication);
     if (conn->pguser)
         free(conn->pguser);
     if (conn->pgpass)
     {
         explicit_bzero(conn->pgpass, strlen(conn->pgpass));
         free(conn->pgpass);
     }
     if (conn->pgpassfile)
         free(conn->pgpassfile);
     if (conn->channel_binding)
         free(conn->channel_binding);
     if (conn->keepalives)
         free(conn->keepalives);
     if (conn->keepalives_idle)
         free(conn->keepalives_idle);
     if (conn->keepalives_interval)
         free(conn->keepalives_interval);
     if (conn->keepalives_count)
         free(conn->keepalives_count);
     if (conn->sslmode)
         free(conn->sslmode);
     if (conn->sslcert)
         free(conn->sslcert);
     if (conn->sslkey)
         free(conn->sslkey);
     if (conn->sslpassword)
     {
         explicit_bzero(conn->sslpassword, strlen(conn->sslpassword));
         free(conn->sslpassword);
     }
     if (conn->sslrootcert)
         free(conn->sslrootcert);
     if (conn->sslcrl)
         free(conn->sslcrl);
     if (conn->sslcrldir)
         free(conn->sslcrldir);
     if (conn->sslcompression)
         free(conn->sslcompression);
     if (conn->sslsni)
         free(conn->sslsni);
     if (conn->requirepeer)
         free(conn->requirepeer);
     if (conn->ssl_min_protocol_version)
         free(conn->ssl_min_protocol_version);
     if (conn->ssl_max_protocol_version)
         free(conn->ssl_max_protocol_version);
     if (conn->gssencmode)
         free(conn->gssencmode);
     if (conn->krbsrvname)
         free(conn->krbsrvname);
     if (conn->gsslib)
         free(conn->gsslib);
     if (conn->connip)
         free(conn->connip);
     /* Note that conn->Pfdebug is not ours to close or free */
     if (conn->write_err_msg)
         free(conn->write_err_msg);
     if (conn->inBuffer)
         free(conn->inBuffer);
     if (conn->outBuffer)
         free(conn->outBuffer);
     if (conn->rowBuf)
         free(conn->rowBuf);
     if (conn->target_session_attrs)
         free(conn->target_session_attrs);
     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::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, 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::requirepeer, pg_conn::rowBuf, pg_conn::ssl_max_protocol_version, pg_conn::ssl_min_protocol_version, pg_conn::sslcert, 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 6562 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 1664 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';
     }
 #ifdef HAVE_IPV6
     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';
     }
 #endif
     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 3883 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().

◆ makeEmptyPGconn()

static PGconn * makeEmptyPGconn ( void )

static

Definition at line 3947 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->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, 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 4449 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 990 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 *	conninfo,
		PQExpBuffer	errorMessage,
		bool	use_defaults
	)

static

Definition at line 5563 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 1800 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:
     appendPQExpBuffer(&conn->errorMessage,
                       libpq_gettext("invalid integer value \"%s\" for connection option \"%s\"\n"),
                       value, context);
     return false;
 }

References appendPQExpBuffer(), Assert(), conn, error(), pg_conn::errorMessage, libpq_gettext, 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 5321 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)
     {
         appendPQExpBuffer(errorMessage, libpq_gettext("service file \"%s\" not found\n"),
                           serviceFile);
         return 1;
     }
  
     while ((line = fgets(buf, sizeof(buf), f)) != NULL)
     {
         int         len;
  
         linenr++;
  
         if (strlen(line) >= sizeof(buf) - 1)
         {
             appendPQExpBuffer(errorMessage,
                               libpq_gettext("line %d too long in service file \"%s\"\n"),
                               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)
                 {
                     appendPQExpBuffer(errorMessage,
                                       libpq_gettext("syntax error in service file \"%s\", line %d\n"),
                                       serviceFile,
                                       linenr);
                     result = 3;
                     goto exit;
                 }
                 *val++ = '\0';
  
                 if (strcmp(key, "service") == 0)
                 {
                     appendPQExpBuffer(errorMessage,
                                       libpq_gettext("nested service specifications not supported in service file \"%s\", line %d\n"),
                                       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)
                         {
                             appendPQExpBufferStr(errorMessage,
                                                  libpq_gettext("out of memory\n"));
                             result = 3;
                             goto exit;
                         }
                         found_keyword = true;
                         break;
                     }
                 }
  
                 if (!found_keyword)
                 {
                     appendPQExpBuffer(errorMessage,
                                       libpq_gettext("syntax error in service file \"%s\", line %d\n"),
                                       serviceFile,
                                       linenr);
                     result = 3;
                     goto exit;
                 }
             }
         }
     }
  
 exit:
     fclose(f);
  
     return result;
 }

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

Referenced by parseServiceInfo().

◆ parseServiceInfo()

static int parseServiceInfo	(	PQconninfoOption *	options,
		PQExpBuffer	errorMessage
	)

static

Definition at line 5252 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)
     {
         appendPQExpBuffer(errorMessage,
                           libpq_gettext("definition of service \"%s\" not found\n"), service);
         return 3;
     }
  
     return 0;
 }

References appendPQExpBuffer(), conninfo_getval(), libpq_gettext, MAXPGPATH, parseServiceFile(), pqGetHomeDirectory(), snprintf, stat, status(), 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 7163 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 7303 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)
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("password retrieved from file \"%s\"\n"),
                               conn->pgpassfile);
     }
 }

References appendPQExpBuffer(), conn, pg_conn::connhost, ERRCODE_INVALID_PASSWORD, pg_conn::errorMessage, libpq_gettext, 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 6942 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 4481 of file fe-connect.c.

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

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

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

◆ PQclientEncoding()

int PQclientEncoding ( const PGconn * conn )

Definition at line 6985 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 1477 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 713 of file fe-connect.c.

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

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

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

◆ PQconnectdbParams()

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

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

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

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

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

◆ PQconnectionNeedsPassword()

int PQconnectionNeedsPassword ( const PGconn * conn )

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

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

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

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

◆ PQconnectionUsedPassword()

int PQconnectionUsedPassword ( const PGconn * conn )

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

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

References conn, and pg_conn::password_needed.

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

◆ PQconnectPoll()

PostgresPollingStatusType PQconnectPoll ( PGconn * conn )

Definition at line 2262 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:
             appendPQExpBufferStr(&conn->errorMessage,
                                  libpq_gettext("invalid connection state, probably indicative of memory corruption\n"));
             goto error_return;
     }
  
  
 keep_going:                     /* We will come back to here until there is
                                  * nothing left to do. */
  
     /* Time to advance to next address, or next host if no more addresses? */
     if (conn->try_next_addr)
     {
         if (conn->addr_cur && conn->addr_cur->ai_next)
         {
             conn->addr_cur = conn->addr_cur->ai_next;
             reset_connection_state_machine = true;
         }
         else
             conn->try_next_host = true;
         conn->try_next_addr = false;
     }
  
     /* Time to advance to next connhost[] entry? */
     if (conn->try_next_host)
     {
         pg_conn_host *ch;
         struct addrinfo hint;
         int         thisport;
         int         ret;
         char        portstr[MAXPGPATH];
  
         if (conn->whichhost + 1 < conn->nconnhost)
             conn->whichhost++;
         else
         {
             /*
              * Oops, no more hosts.
              *
              * If we are trying to connect in "prefer-standby" mode, then drop
              * the standby requirement and start over.
              *
              * Otherwise, an appropriate error message is already set up, so
              * we just need to set the right status.
              */
             if (conn->target_server_type == SERVER_TYPE_PREFER_STANDBY &&
                 conn->nconnhost > 0)
             {
                 conn->target_server_type = SERVER_TYPE_PREFER_STANDBY_PASS2;
                 conn->whichhost = 0;
             }
             else
                 goto error_return;
         }
  
         /* Drop any address info for previous host */
         release_conn_addrinfo(conn);
  
         /*
          * Look up info for the new host.  On failure, log the problem in
          * conn->errorMessage, then loop around to try the next host.  (Note
          * we don't clear try_next_host until we've succeeded.)
          */
         ch = &conn->connhost[conn->whichhost];
  
         /* Initialize hint structure */
         MemSet(&hint, 0, sizeof(hint));
         hint.ai_socktype = SOCK_STREAM;
         conn->addrlist_family = hint.ai_family = AF_UNSPEC;
  
         /* Figure out the port number we're going to use. */
         if (ch->port == NULL || ch->port[0] == '\0')
             thisport = DEF_PGPORT;
         else
         {
             if (!parse_int_param(ch->port, &thisport, conn, "port"))
                 goto error_return;
  
             if (thisport < 1 || thisport > 65535)
             {
                 appendPQExpBuffer(&conn->errorMessage,
                                   libpq_gettext("invalid port number: \"%s\"\n"),
                                   ch->port);
                 goto keep_going;
             }
         }
         snprintf(portstr, sizeof(portstr), "%d", thisport);
  
         /* Use pg_getaddrinfo_all() to resolve the address */
         switch (ch->type)
         {
             case CHT_HOST_NAME:
                 ret = pg_getaddrinfo_all(ch->host, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not translate host name \"%s\" to address: %s\n"),
                                       ch->host, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
  
             case CHT_HOST_ADDRESS:
                 hint.ai_flags = AI_NUMERICHOST;
                 ret = pg_getaddrinfo_all(ch->hostaddr, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not parse network address \"%s\": %s\n"),
                                       ch->hostaddr, gai_strerror(ret));
                     goto keep_going;
                 }
                 break;
  
             case CHT_UNIX_SOCKET:
 #ifdef HAVE_UNIX_SOCKETS
                 conn->addrlist_family = hint.ai_family = AF_UNIX;
                 UNIXSOCK_PATH(portstr, thisport, ch->host);
                 if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("Unix-domain socket path \"%s\" is too long (maximum %d bytes)\n"),
                                       portstr,
                                       (int) (UNIXSOCK_PATH_BUFLEN - 1));
                     goto keep_going;
                 }
  
                 /*
                  * NULL hostname tells pg_getaddrinfo_all to parse the service
                  * name as a Unix-domain socket path.
                  */
                 ret = pg_getaddrinfo_all(NULL, portstr, &hint,
                                          &conn->addrlist);
                 if (ret || !conn->addrlist)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not translate Unix-domain socket path \"%s\" to address: %s\n"),
                                       portstr, gai_strerror(ret));
                     goto keep_going;
                 }
 #else
                 Assert(false);
 #endif
                 break;
         }
  
         /* OK, scan this addrlist for a working server address */
         conn->addr_cur = conn->addrlist;
         reset_connection_state_machine = true;
         conn->try_next_host = false;
     }
  
     /* Reset connection state machine? */
     if (reset_connection_state_machine)
     {
         /*
          * (Re) initialize our connection control variables for a set of
          * connection attempts to a single server address.  These variables
          * must persist across individual connection attempts, but we must
          * reset them when we start to consider a new server.
          */
         conn->pversion = PG_PROTOCOL(3, 0);
         conn->send_appname = true;
 #ifdef USE_SSL
         /* initialize these values based on SSL mode */
         conn->allow_ssl_try = (conn->sslmode[0] != 'd');    /* "disable" */
         conn->wait_ssl_try = (conn->sslmode[0] == 'a'); /* "allow" */
 #endif
 #ifdef ENABLE_GSS
         conn->try_gss = (conn->gssencmode[0] != 'd');   /* "disable" */
 #endif
  
         reset_connection_state_machine = false;
         need_new_connection = true;
     }
  
     /* Force a new connection (perhaps to the same server as before)? */
     if (need_new_connection)
     {
         /* Drop any existing connection */
         pqDropConnection(conn, true);
  
         /* Reset all state obtained from old server */
         pqDropServerData(conn);
  
         /* Drop any PGresult we might have, too */
         conn->asyncStatus = PGASYNC_IDLE;
         conn->xactStatus = PQTRANS_IDLE;
         conn->pipelineStatus = PQ_PIPELINE_OFF;
         pqClearAsyncResult(conn);
  
         /* Reset conn->status to put the state machine in the right state */
         conn->status = CONNECTION_NEEDED;
  
         need_new_connection = false;
     }
  
     /* Now try to advance the state machine for this connection */
     switch (conn->status)
     {
         case CONNECTION_NEEDED:
             {
                 /*
                  * Try to initiate a connection to one of the addresses
                  * returned by pg_getaddrinfo_all().  conn->addr_cur is the
                  * next one to try.
                  *
                  * The extra level of braces here is historical.  It's not
                  * worth reindenting this whole switch case to remove 'em.
                  */
                 {
                     struct addrinfo *addr_cur = conn->addr_cur;
                     char        host_addr[NI_MAXHOST];
  
                     /*
                      * Advance to next possible host, if we've tried all of
                      * the addresses for the current host.
                      */
                     if (addr_cur == NULL)
                     {
                         conn->try_next_host = true;
                         goto keep_going;
                     }
  
                     /* Remember current address for possible use later */
                     memcpy(&conn->raddr.addr, addr_cur->ai_addr,
                            addr_cur->ai_addrlen);
                     conn->raddr.salen = addr_cur->ai_addrlen;
  
                     /*
                      * Set connip, too.  Note we purposely ignore strdup
                      * failure; not a big problem if it fails.
                      */
                     if (conn->connip != NULL)
                     {
                         free(conn->connip);
                         conn->connip = NULL;
                     }
                     getHostaddr(conn, host_addr, NI_MAXHOST);
                     if (host_addr[0])
                         conn->connip = strdup(host_addr);
  
                     /* Try to create the socket */
                     conn->sock = socket(addr_cur->ai_family, SOCK_STREAM, 0);
                     if (conn->sock == PGINVALID_SOCKET)
                     {
                         int         errorno = SOCK_ERRNO;
  
                         /*
                          * Silently ignore socket() failure if we have more
                          * addresses to try; this reduces useless chatter in
                          * cases where the address list includes both IPv4 and
                          * IPv6 but kernel only accepts one family.
                          */
                         if (addr_cur->ai_next != NULL ||
                             conn->whichhost + 1 < conn->nconnhost)
                         {
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                         emitHostIdentityInfo(conn, host_addr);
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not create socket: %s\n"),
                                           SOCK_STRERROR(errorno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
                     /*
                      * Once we've identified a target address, all errors
                      * except the preceding socket()-failure case should be
                      * prefixed with host-identity information.  (If the
                      * connection succeeds, the contents of conn->errorMessage
                      * won't matter, so this is harmless.)
                      */
                     emitHostIdentityInfo(conn, host_addr);
  
                     /*
                      * Select socket options: no delay of outgoing data for
                      * TCP sockets, nonblock mode, close-on-exec.  Try the
                      * next address if any of this fails.
                      */
                     if (addr_cur->ai_family != AF_UNIX)
                     {
                         if (!connectNoDelay(conn))
                         {
                             /* error message already created */
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
                     if (!pg_set_noblock(conn->sock))
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not set socket to nonblocking mode: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
  
 #ifdef F_SETFD
                     if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not set socket to close-on-exec mode: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         conn->try_next_addr = true;
                         goto keep_going;
                     }
 #endif                          /* F_SETFD */
  
                     if (addr_cur->ai_family != AF_UNIX)
                     {
 #ifndef WIN32
                         int         on = 1;
 #endif
                         int         usekeepalives = useKeepalives(conn);
                         int         err = 0;
  
                         if (usekeepalives < 0)
                         {
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("keepalives parameter must be an integer\n"));
                             err = 1;
                         }
                         else if (usekeepalives == 0)
                         {
                             /* Do nothing */
                         }
 #ifndef WIN32
                         else if (setsockopt(conn->sock,
                                             SOL_SOCKET, SO_KEEPALIVE,
                                             (char *) &on, sizeof(on)) < 0)
                         {
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("%s(%s) failed: %s\n"),
                                               "setsockopt",
                                               "SO_KEEPALIVE",
                                               SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                             err = 1;
                         }
                         else if (!setKeepalivesIdle(conn)
                                  || !setKeepalivesInterval(conn)
                                  || !setKeepalivesCount(conn))
                             err = 1;
 #else                           /* WIN32 */
 #ifdef SIO_KEEPALIVE_VALS
                         else if (!prepKeepalivesWin32(conn))
                             err = 1;
 #endif                          /* SIO_KEEPALIVE_VALS */
 #endif                          /* WIN32 */
                         else if (!setTCPUserTimeout(conn))
                             err = 1;
  
                         if (err)
                         {
                             conn->try_next_addr = true;
                             goto keep_going;
                         }
                     }
  
                     /*----------
                      * We have three methods of blocking SIGPIPE during
                      * send() calls to this socket:
                      *
                      *  - setsockopt(sock, SO_NOSIGPIPE)
                      *  - send(sock, ..., MSG_NOSIGNAL)
                      *  - setting the signal mask to SIG_IGN during send()
                      *
                      * The third method requires three syscalls per send,
                      * so we prefer either of the first two, but they are
                      * less portable.  The state is tracked in the following
                      * members of PGconn:
                      *
                      * conn->sigpipe_so     - we have set up SO_NOSIGPIPE
                      * conn->sigpipe_flag   - we're specifying MSG_NOSIGNAL
                      *
                      * If we can use SO_NOSIGPIPE, then set sigpipe_so here
                      * and we're done.  Otherwise, set sigpipe_flag so that
                      * we will try MSG_NOSIGNAL on sends.  If we get an error
                      * with MSG_NOSIGNAL, we'll clear that flag and revert to
                      * signal masking.
                      *----------
                      */
                     conn->sigpipe_so = false;
 #ifdef MSG_NOSIGNAL
                     conn->sigpipe_flag = true;
 #else
                     conn->sigpipe_flag = false;
 #endif                          /* MSG_NOSIGNAL */
  
 #ifdef SO_NOSIGPIPE
                     optval = 1;
                     if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
                                    (char *) &optval, sizeof(optval)) == 0)
                     {
                         conn->sigpipe_so = true;
                         conn->sigpipe_flag = false;
                     }
 #endif                          /* SO_NOSIGPIPE */
  
                     /*
                      * Start/make connection.  This should not block, since we
                      * are in nonblock mode.  If it does, well, too bad.
                      */
                     if (connect(conn->sock, addr_cur->ai_addr,
                                 addr_cur->ai_addrlen) < 0)
                     {
                         if (SOCK_ERRNO == EINPROGRESS ||
 #ifdef WIN32
                             SOCK_ERRNO == EWOULDBLOCK ||
 #endif
                             SOCK_ERRNO == EINTR)
                         {
                             /*
                              * This is fine - we're in non-blocking mode, and
                              * the connection is in progress.  Tell caller to
                              * wait for write-ready on socket.
                              */
                             conn->status = CONNECTION_STARTED;
                             return PGRES_POLLING_WRITING;
                         }
                         /* otherwise, trouble */
                     }
                     else
                     {
                         /*
                          * Hm, we're connected already --- seems the "nonblock
                          * connection" wasn't.  Advance the state machine and
                          * go do the next stuff.
                          */
                         conn->status = CONNECTION_STARTED;
                         goto keep_going;
                     }
  
                     /*
                      * This connection failed.  Add the error report to
                      * conn->errorMessage, then try the next address if any.
                      */
                     connectFailureMessage(conn, SOCK_ERRNO);
                     conn->try_next_addr = true;
                     goto keep_going;
                 }
             }
  
         case CONNECTION_STARTED:
             {
                 socklen_t   optlen = sizeof(optval);
  
                 /*
                  * Write ready, since we've made it here, so the connection
                  * has been made ... or has failed.
                  */
  
                 /*
                  * Now check (using getsockopt) that there is not an error
                  * state waiting for us on the socket.
                  */
  
                 if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
                                (char *) &optval, &optlen) == -1)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not get socket error status: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
                 else if (optval != 0)
                 {
                     /*
                      * When using a nonblocking connect, we will typically see
                      * connect failures at this point, so provide a friendly
                      * error message.
                      */
                     connectFailureMessage(conn, optval);
  
                     /*
                      * Try the next address if any, just as in the case where
                      * connect() returned failure immediately.
                      */
                     conn->try_next_addr = true;
                     goto keep_going;
                 }
  
                 /* Fill in the client address */
                 conn->laddr.salen = sizeof(conn->laddr.addr);
                 if (getsockname(conn->sock,
                                 (struct sockaddr *) &conn->laddr.addr,
                                 &conn->laddr.salen) < 0)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not get client address from socket: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
  
                 /*
                  * Make sure we can write before advancing to next step.
                  */
                 conn->status = CONNECTION_MADE;
                 return PGRES_POLLING_WRITING;
             }
  
         case CONNECTION_MADE:
             {
                 char       *startpacket;
                 int         packetlen;
  
                 /*
                  * Implement requirepeer check, if requested and it's a
                  * Unix-domain socket.
                  */
                 if (conn->requirepeer && conn->requirepeer[0] &&
                     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)
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("requirepeer parameter is not supported on this platform\n"));
                         else
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("could not get peer credentials: %s\n"),
                                               strerror_r(errno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
 #ifndef WIN32
                     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)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n"),
                                           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)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not send GSSAPI negotiation packet: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
  
                     /* Ok, wait for response */
                     conn->status = CONNECTION_GSS_STARTUP;
                     return PGRES_POLLING_READING;
                 }
                 else if (!conn->gctx && conn->gssencmode[0] == 'r')
                 {
                     appendPQExpBufferStr(&conn->errorMessage,
                                          libpq_gettext("GSSAPI encryption required but was impossible (possibly no credential cache, no server support, or using a local socket)\n"));
                     goto error_return;
                 }
 #endif
  
 #ifdef USE_SSL
  
                 /*
                  * 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)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not send SSL negotiation packet: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
                     /* Ok, wait for response */
                     conn->status = CONNECTION_SSL_STARTUP;
                     return PGRES_POLLING_READING;
                 }
 #endif                          /* USE_SSL */
  
                 /*
                  * Build the startup packet.
                  */
                 startpacket = pqBuildStartupPacket3(conn, &packetlen,
                                                     EnvironmentOptions);
                 if (!startpacket)
                 {
                     appendPQExpBufferStr(&conn->errorMessage,
                                          libpq_gettext("out of memory\n"));
                     goto error_return;
                 }
  
                 /*
                  * Send the startup packet.
                  *
                  * Theoretically, this could block, but it really shouldn't
                  * since we only got here if the socket is write-ready.
                  */
                 if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not send startup packet: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     free(startpacket);
                     goto error_return;
                 }
  
                 free(startpacket);
  
                 conn->status = CONNECTION_AWAITING_RESPONSE;
                 return PGRES_POLLING_READING;
             }
  
             /*
              * Handle SSL negotiation: wait for postmaster messages and
              * respond as necessary.
              */
         case CONNECTION_SSL_STARTUP:
             {
 #ifdef USE_SSL
                 PostgresPollingStatusType pollres;
  
                 /*
                  * On first time through, get the postmaster's response to our
                  * SSL negotiation packet.
                  */
                 if (!conn->ssl_in_use)
                 {
                     /*
                      * We use pqReadData here since it has the logic to
                      * distinguish no-data-yet from connection closure. Since
                      * conn->ssl isn't set, a plain recv() will occur.
                      */
                     char        SSLok;
                     int         rdresult;
  
                     rdresult = pqReadData(conn);
                     if (rdresult < 0)
                     {
                         /* errorMessage is already filled in */
                         goto error_return;
                     }
                     if (rdresult == 0)
                     {
                         /* caller failed to wait for data */
                         return PGRES_POLLING_READING;
                     }
                     if (pqGetc(&SSLok, conn) < 0)
                     {
                         /* should not happen really */
                         return PGRES_POLLING_READING;
                     }
                     if (SSLok == 'S')
                     {
                         /* mark byte consumed */
                         conn->inStart = conn->inCursor;
  
                         /*
                          * Set up global SSL state if required.  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 */
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("server does not support SSL, but SSL was required\n"));
                             goto error_return;
                         }
                         /* Otherwise, proceed with normal startup */
                         conn->allow_ssl_try = false;
                         /* 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
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("received invalid response to SSL negotiation: %c\n"),
                                           SSLok);
                         goto error_return;
                     }
                 }
  
                 /*
                  * Begin or continue the SSL negotiation process.
                  */
                 pollres = pqsecure_open_client(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /*
                      * 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)
                     {
                         appendPQExpBufferStr(&conn->errorMessage,
                                              libpq_gettext("received unencrypted data after SSL response\n"));
                         goto error_return;
                     }
  
                     /* SSL handshake done, ready to send startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 if (pollres == PGRES_POLLING_FAILED)
                 {
                     /*
                      * Failed ... if sslmode is "prefer" then do a non-SSL
                      * retry
                      */
                     if (conn->sslmode[0] == 'p' /* "prefer" */
                         && conn->allow_ssl_try  /* redundant? */
                         && !conn->wait_ssl_try) /* redundant? */
                     {
                         /* only retry once */
                         conn->allow_ssl_try = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
                     /* Else it's a hard failure */
                     goto error_return;
                 }
                 /* Else, return POLLING_READING or POLLING_WRITING status */
                 return pollres;
 #else                           /* !USE_SSL */
                 /* can't get here */
                 goto error_return;
 #endif                          /* USE_SSL */
             }
  
         case CONNECTION_GSS_STARTUP:
             {
 #ifdef ENABLE_GSS
                 PostgresPollingStatusType pollres;
  
                 /*
                  * If we haven't yet, get the postmaster's response to our
                  * negotiation packet
                  */
                 if (conn->try_gss && !conn->gctx)
                 {
                     char        gss_ok;
                     int         rdresult = pqReadData(conn);
  
                     if (rdresult < 0)
                         /* pqReadData fills in error message */
                         goto error_return;
                     else if (rdresult == 0)
                         /* caller failed to wait for data */
                         return PGRES_POLLING_READING;
                     if (pqGetc(&gss_ok, conn) < 0)
                         /* shouldn't happen... */
                         return PGRES_POLLING_READING;
  
                     if (gss_ok == 'E')
                     {
                         /*
                          * Server failure of some sort.  Assume it's a
                          * protocol version support failure, and let's see if
                          * we can't recover (if it's not, we'll get a better
                          * error message on retry).  Server gets fussy if we
                          * don't hang up the socket, though.
                          */
                         conn->try_gss = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
  
                     /* mark byte consumed */
                     conn->inStart = conn->inCursor;
  
                     if (gss_ok == 'N')
                     {
                         /* Server doesn't want GSSAPI; fall back if we can */
                         if (conn->gssencmode[0] == 'r')
                         {
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("server doesn't support GSSAPI encryption, but it was required\n"));
                             goto error_return;
                         }
  
                         conn->try_gss = false;
                         /* We can proceed using this connection */
                         conn->status = CONNECTION_MADE;
                         return PGRES_POLLING_WRITING;
                     }
                     else if (gss_ok != 'G')
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("received invalid response to GSSAPI negotiation: %c\n"),
                                           gss_ok);
                         goto error_return;
                     }
                 }
  
                 /* Begin or continue GSSAPI negotiation */
                 pollres = pqsecure_open_gss(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /*
                      * At this point we should have no data already buffered.
                      * If we do, it was received before we performed the GSS
                      * handshake, so it wasn't encrypted and indeed may have
                      * been injected by a man-in-the-middle.
                      */
                     if (conn->inCursor != conn->inEnd)
                     {
                         appendPQExpBufferStr(&conn->errorMessage,
                                              libpq_gettext("received unencrypted data after GSSAPI encryption response\n"));
                         goto error_return;
                     }
  
                     /* All set for startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 else if (pollres == PGRES_POLLING_FAILED &&
                          conn->gssencmode[0] == 'p')
                 {
                     /*
                      * We failed, but we can retry on "prefer".  Have to drop
                      * the current connection to do so, though.
                      */
                     conn->try_gss = false;
                     need_new_connection = true;
                     goto keep_going;
                 }
                 return pollres;
 #else                           /* !ENABLE_GSS */
                 /* unreachable */
                 goto error_return;
 #endif                          /* ENABLE_GSS */
             }
  
             /*
              * Handle authentication exchange: wait for postmaster messages
              * and respond as necessary.
              */
         case CONNECTION_AWAITING_RESPONSE:
             {
                 char        beresp;
                 int         msgLength;
                 int         avail;
                 AuthRequest areq;
                 int         res;
  
                 /*
                  * Scan the message from current point (note that if we find
                  * the message is incomplete, we will return without advancing
                  * inStart, and resume here next time).
                  */
                 conn->inCursor = conn->inStart;
  
                 /* Read type byte */
                 if (pqGetc(&beresp, conn))
                 {
                     /* We'll come back when there is more data */
                     return PGRES_POLLING_READING;
                 }
  
                 /*
                  * Validate message type: we expect only an authentication
                  * request or an error here.  Anything else probably means
                  * it's not Postgres on the other end at all.
                  */
                 if (!(beresp == 'R' || beresp == 'E'))
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("expected authentication request from server, but received %c\n"),
                                       beresp);
                     goto error_return;
                 }
  
                 /* Read message length word */
                 if (pqGetInt(&msgLength, 4, conn))
                 {
                     /* We'll come back when there is more data */
                     return PGRES_POLLING_READING;
                 }
  
                 /*
                  * Try to validate message length before using it.
                  * Authentication requests can't be very large, although GSS
                  * auth requests may not be that small.  Errors can be a
                  * little larger, but not huge.  If we see a large apparent
                  * length in an error, it means we're really talking to a
                  * pre-3.0-protocol server; cope.  (Before version 14, the
                  * server also used the old protocol for errors that happened
                  * before processing the startup packet.)
                  */
                 if (beresp == 'R' && (msgLength < 8 || msgLength > 2000))
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("expected authentication request from server, but received %c\n"),
                                       beresp);
                     goto error_return;
                 }
  
                 if (beresp == 'E' && (msgLength < 8 || msgLength > 30000))
                 {
                     /* Handle error from a pre-3.0 server */
                     conn->inCursor = conn->inStart + 1; /* reread data */
                     if (pqGets_append(&conn->errorMessage, conn))
                     {
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                     /* OK, we read the message; mark data consumed */
                     conn->inStart = conn->inCursor;
  
                     /*
                      * Before 7.2, the postmaster didn't always end its
                      * messages with a newline, so add one if needed to
                      * conform to libpq conventions.
                      */
                     if (conn->errorMessage.len == 0 ||
                         conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
                     {
                         appendPQExpBufferChar(&conn->errorMessage, '\n');
                     }
  
                     goto error_return;
                 }
  
                 /*
                  * Can't process if message body isn't all here yet.
                  */
                 msgLength -= 4;
                 avail = conn->inEnd - conn->inCursor;
                 if (avail < msgLength)
                 {
                     /*
                      * Before returning, try to enlarge the input buffer if
                      * needed to hold the whole message; see notes in
                      * pqParseInput3.
                      */
                     if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
                                              conn))
                         goto error_return;
                     /* We'll come back when there is more data */
                     return PGRES_POLLING_READING;
                 }
  
                 /* Handle errors. */
                 if (beresp == 'E')
                 {
                     if (pqGetErrorNotice3(conn, true))
                     {
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                     /* OK, we read the message; mark data consumed */
                     conn->inStart = conn->inCursor;
  
                     /*
                      * If error is "cannot connect now", try the next host if
                      * any (but we don't want to consider additional addresses
                      * for this host, nor is there much point in changing SSL
                      * or GSS mode).  This is helpful when dealing with
                      * standby servers that might not be in hot-standby state.
                      */
                     if (strcmp(conn->last_sqlstate,
                                ERRCODE_CANNOT_CONNECT_NOW) == 0)
                     {
                         conn->try_next_host = true;
                         goto keep_going;
                     }
  
                     /* Check to see if we should mention pgpassfile */
                     pgpassfileWarning(conn);
  
 #ifdef ENABLE_GSS
  
                     /*
                      * If gssencmode is "prefer" and we're using GSSAPI, retry
                      * without it.
                      */
                     if (conn->gssenc && conn->gssencmode[0] == 'p')
                     {
                         /* only retry once */
                         conn->try_gss = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
 #endif
  
 #ifdef USE_SSL
  
                     /*
                      * if sslmode is "allow" and we haven't tried an SSL
                      * connection already, then retry with an SSL connection
                      */
                     if (conn->sslmode[0] == 'a' /* "allow" */
                         && !conn->ssl_in_use
                         && conn->allow_ssl_try
                         && conn->wait_ssl_try)
                     {
                         /* only retry once */
                         conn->wait_ssl_try = false;
                         need_new_connection = true;
                         goto keep_going;
                     }
  
                     /*
                      * if sslmode is "prefer" and we're in an SSL connection,
                      * then do a non-SSL retry
                      */
                     if (conn->sslmode[0] == 'p' /* "prefer" */
                         && conn->ssl_in_use
                         && conn->allow_ssl_try  /* redundant? */
                         && !conn->wait_ssl_try) /* redundant? */
                     {
                         /* only retry once */
                         

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DefaultChannelBinding

◆ DefaultGSSMode

◆ DefaultHost

◆ DefaultOption

◆ DefaultSSLMode

◆ DefaultTargetSessionAttrs

◆ ERRCODE_APPNAME_UNKNOWN

◆ ERRCODE_CANNOT_CONNECT_NOW

◆ ERRCODE_INVALID_PASSWORD

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

◆ makeEmptyPGconn()

◆ optional_setsockopt()

◆ parse_comma_separated_list()

◆ parse_connection_string()

◆ parse_int_param()

◆ parseServiceFile()

◆ parseServiceInfo()

◆ passwordFromFile()

◆ pgpassfileWarning()

◆ PQbackendPID()

◆ PQcancel()

◆ PQclientEncoding()

◆ PQconndefaults()

◆ PQconnectdb()

◆ PQconnectdbParams()

◆ PQconnectionNeedsPassword()

◆ PQconnectionUsedPassword()

◆ PQconnectPoll()