/*-------------------------------------------------------------------------

*

* fe-connect.c

* functions related to setting up a connection to the backend

*

* Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group

* Portions Copyright (c) 1994, Regents of the University of California

*

*

* IDENTIFICATION

* src/interfaces/libpq/fe-connect.c

*

*-------------------------------------------------------------------------

*/

#include "postgres_fe.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <ctype.h>

#include <time.h>

#include <unistd.h>

#include "libpq-fe.h"

#include "libpq-int.h"

#include "fe-auth.h"

#include "pg_config_paths.h"

#ifdef WIN32

#include "win32.h"

#ifdef _WIN32_IE

#undef _WIN32_IE

#endif

#define _WIN32_IE 0x0500

#ifdef near

#undef near

#endif

#define near

#include <shlobj.h>

#ifdef WIN32_ONLY_COMPILER /* mstcpip.h is missing on mingw */

#include <mstcpip.h>

#endif

#else

#include <sys/socket.h>

#include <netdb.h>

#include <netinet/in.h>

#ifdef HAVE_NETINET_TCP_H

#include <netinet/tcp.h>

#endif

#include <arpa/inet.h>

#endif

#ifdef ENABLE_THREAD_SAFETY

#ifdef WIN32

#include "pthread-win32.h"

#else

#include <pthread.h>

#endif

#endif

#ifdef USE_LDAP

#ifdef WIN32

#include <winldap.h>

#else

/* OpenLDAP deprecates RFC 1823, but we want standard conformance */

#define LDAP_DEPRECATED 1

#include <ldap.h>

typedef struct timeval LDAP_TIMEVAL;

#endif

static int ldapServiceLookup(const char *purl, PQconninfoOption *options,

PQExpBuffer errorMessage);

#endif

#include "libpq/ip.h"

#include "mb/pg_wchar.h"

#ifndef FD_CLOEXEC

#define FD_CLOEXEC 1

#endif

#ifndef WIN32

#define PGPASSFILE ".pgpass"

#else

#define PGPASSFILE "pgpass.conf"

#endif

/*

* Pre-9.0 servers will return this SQLSTATE if asked to set

* application_name in a startup packet. We hard-wire the value rather

* than looking into errcodes.h since it reflects historical behavior

* rather than that of the current code.

*/

#define ERRCODE_APPNAME_UNKNOWN "42704"

/* This is part of the protocol so just define it */

#define ERRCODE_INVALID_PASSWORD "28P01"

/* This too */

#define ERRCODE_CANNOT_CONNECT_NOW "57P03"

/*

* fall back options if they are not specified by arguments or defined

* by environment variables

*/

#define DefaultHost "localhost"

#define DefaultTty ""

#define DefaultOption ""

#define DefaultAuthtype ""

#define DefaultPassword ""

#ifdef USE_SSL

#define DefaultSSLMode "prefer"

#else

#define DefaultSSLMode "disable"

#endif

/* ----------

* Definition of the conninfo parameters and their fallback resources.

*

* If Environment-Var and Compiled-in are specified as NULL, no

* fallback is available. If after all no value can be determined

* for an option, an error is returned.

*

* The value for the username is treated specially in conninfo_add_defaults.

* If the value is not obtained any other way, the username is determined

* by pg_fe_getauthname().

*

* The Label and Disp-Char entries are provided for applications that

* want to use PQconndefaults() to create a generic database connection

* dialog. Disp-Char is defined as follows:

* "" Normal input field

* "*" Password field - hide value

* "D" Debug option - don't show by default

*

* PQconninfoOptions[] is a constant static array that we use to initialize

* a dynamically allocated working copy. All the "val" fields in

* PQconninfoOptions[] *must* be NULL. In a working copy, non-null "val"

* fields point to malloc'd strings that should be freed when the working

* array is freed (see PQconninfoFree).

*

* The first part of each struct is identical to the one in libpq-fe.h,

* which is required since we memcpy() data between the two!

* ----------

*/

typedef struct _internalPQconninfoOption

{

char *keyword; /* The keyword of the option */

char *envvar; /* Fallback environment variable name */

char *compiled; /* Fallback compiled in default value */

char *val; /* Option's current value, or NULL */

char *label; /* Label for field in connect dialog */

char *dispchar; /* Indicates how to display this field in a

* connect dialog. Values are: "" Display

* entered value as is "*" Password field -

* hide value "D" Debug option - don't show

* by default */

int dispsize; /* Field size in characters for dialog */

/* ---

* Anything above this comment must be synchronized with

* PQconninfoOption in libpq-fe.h, since we memcpy() data

* between them!

* ---

*/

off_t connofs; /* Offset into PGconn struct, -1 if not there */

} internalPQconninfoOption;

static const internalPQconninfoOption PQconninfoOptions[] = {

/*

* "authtype" is no longer used, so mark it "don't show". We keep it in

* the array so as not to reject conninfo strings from old apps that might

* still try to set it.

*/

{"authtype", "PGAUTHTYPE", DefaultAuthtype, NULL,

"Database-Authtype", "D", 20, -1},

{"service", "PGSERVICE", NULL, NULL,

"Database-Service", "", 20, -1},

{"user", "PGUSER", NULL, NULL,

"Database-User", "", 20,

offsetof(struct pg_conn, pguser)},

{"password", "PGPASSWORD", NULL, NULL,

"Database-Password", "*", 20,

offsetof(struct pg_conn, pgpass)},

{"connect_timeout", "PGCONNECT_TIMEOUT", NULL, NULL,

"Connect-timeout", "", 10, /* strlen(INT32_MAX) == 10 */

offsetof(struct pg_conn, connect_timeout)},

{"dbname", "PGDATABASE", NULL, NULL,

"Database-Name", "", 20,

offsetof(struct pg_conn, dbName)},

{"host", "PGHOST", NULL, NULL,

"Database-Host", "", 40,

offsetof(struct pg_conn, pghost)},

{"hostaddr", "PGHOSTADDR", NULL, NULL,

"Database-Host-IP-Address", "", 45,

offsetof(struct pg_conn, pghostaddr)},

{"port", "PGPORT", DEF_PGPORT_STR, NULL,

"Database-Port", "", 6,

offsetof(struct pg_conn, pgport)},

{"client_encoding", "PGCLIENTENCODING", NULL, NULL,

"Client-Encoding", "", 10,

offsetof(struct pg_conn, client_encoding_initial)},

/*

* "tty" is no longer used either, but keep it present for backwards

* compatibility.

*/

{"tty", "PGTTY", DefaultTty, NULL,

"Backend-Debug-TTY", "D", 40,

offsetof(struct pg_conn, pgtty)},

{"options", "PGOPTIONS", DefaultOption, NULL,

"Backend-Debug-Options", "D", 40,

offsetof(struct pg_conn, pgoptions)},

{"application_name", "PGAPPNAME", NULL, NULL,

"Application-Name", "", 64,

offsetof(struct pg_conn, appname)},

{"fallback_application_name", NULL, NULL, NULL,

"Fallback-Application-Name", "", 64,

offsetof(struct pg_conn, fbappname)},

{"keepalives", NULL, NULL, NULL,

"TCP-Keepalives", "", 1, /* should be just '0' or '1' */

offsetof(struct pg_conn, keepalives)},

{"keepalives_idle", NULL, NULL, NULL,

"TCP-Keepalives-Idle", "", 10, /* strlen(INT32_MAX) == 10 */

offsetof(struct pg_conn, keepalives_idle)},

{"keepalives_interval", NULL, NULL, NULL,

"TCP-Keepalives-Interval", "", 10, /* strlen(INT32_MAX) == 10 */

offsetof(struct pg_conn, keepalives_interval)},

{"keepalives_count", NULL, NULL, NULL,

"TCP-Keepalives-Count", "", 10, /* strlen(INT32_MAX) == 10 */

offsetof(struct pg_conn, keepalives_count)},

/*

* ssl options are allowed even without client SSL support because the

* client can still handle SSL modes "disable" and "allow". Other

* parameters have no effect on non-SSL connections, so there is no reason

* to exclude them since none of them are mandatory.

*/

{"sslmode", "PGSSLMODE", DefaultSSLMode, NULL,

"SSL-Mode", "", 12, /* sizeof("verify-full") == 12 */

offsetof(struct pg_conn, sslmode)},

{"sslcompression", "PGSSLCOMPRESSION", "1", NULL,

"SSL-Compression", "", 1,

offsetof(struct pg_conn, sslcompression)},

{"sslcert", "PGSSLCERT", NULL, NULL,

"SSL-Client-Cert", "", 64,

offsetof(struct pg_conn, sslcert)},

{"sslkey", "PGSSLKEY", NULL, NULL,

"SSL-Client-Key", "", 64,

offsetof(struct pg_conn, sslkey)},

{"sslrootcert", "PGSSLROOTCERT", NULL, NULL,

"SSL-Root-Certificate", "", 64,

offsetof(struct pg_conn, sslrootcert)},

{"sslcrl", "PGSSLCRL", NULL, NULL,

"SSL-Revocation-List", "", 64,

offsetof(struct pg_conn, sslcrl)},

{"requirepeer", "PGREQUIREPEER", NULL, NULL,

"Require-Peer", "", 10,

offsetof(struct pg_conn, requirepeer)},

#if defined(ENABLE_GSS) || defined(ENABLE_SSPI)

/* Kerberos and GSSAPI authentication support specifying the service name */

{"krbsrvname", "PGKRBSRVNAME", PG_KRB_SRVNAM, NULL,

"Kerberos-service-name", "", 20,

offsetof(struct pg_conn, krbsrvname)},

#endif

#if defined(ENABLE_GSS) && defined(ENABLE_SSPI)

/*

* GSSAPI and SSPI both enabled, give a way to override which is used by

* default

*/

{"gsslib", "PGGSSLIB", NULL, NULL,

"GSS-library", "", 7, /* sizeof("gssapi") = 7 */

offsetof(struct pg_conn, gsslib)},

#endif

{"replication", NULL, NULL, NULL,

"Replication", "D", 5,

offsetof(struct pg_conn, replication)},

/* Terminating entry --- MUST BE LAST */

{NULL, NULL, NULL, NULL,

NULL, NULL, 0}

};

static const PQEnvironmentOption EnvironmentOptions[] =

{

/* common user-interface settings */

{

"PGDATESTYLE", "datestyle"

},

{

"PGTZ", "timezone"

},

/* internal performance-related settings */

{

"PGGEQO", "geqo"

},

{

NULL, NULL

}

};

/* The connection URI must start with either of the following designators: */

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

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

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 bool fillPGconn(PGconn *conn, PQconninfoOption *connOptions);

static void freePGconn(PGconn *conn);

static void closePGconn(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, char *token);

static char *PasswordFromFile(char *hostname, char *port, char *dbname,

char *username);

static bool getPgPassFilename(char *pgpassfile);

static void dot_pg_pass_warning(PGconn *conn);

static void default_threadlock(int acquire);

/* global variable because fe-auth.c needs to access it */

pgthreadlock_t pg_g_threadlock = default_threadlock;

/*

* pqDropConnection

*

* Close any physical connection to the server, and reset associated

* state inside the connection object. We don't release state that

* would be needed to reconnect, though.

*/

void

pqDropConnection(PGconn *conn)

{

/* Drop any SSL state */

pqsecure_close(conn);

/* Close the socket itself */

if (conn->sock != PGINVALID_SOCKET)

closesocket(conn->sock);

conn->sock = PGINVALID_SOCKET;

/* Discard any unread/unsent data */

conn->inStart = conn->inCursor = conn->inEnd = 0;

conn->outCount = 0;

}

/*

* Connecting to a Database

*

* There are now six different ways a user of this API can connect to the

* database. Two are not recommended for use in new code, because of their

* lack of extensibility with respect to the passing of options to the

* backend. These are PQsetdb and PQsetdbLogin (the former now being a macro

* to the latter).

*

* If it is desired to connect in a synchronous (blocking) manner, use the

* function PQconnectdb or PQconnectdbParams. The former accepts a string of

* option = value pairs (or a URI) which must be parsed; the latter takes two

* NULL terminated arrays instead.

*

* To connect in an asynchronous (non-blocking) manner, use the functions

* PQconnectStart or PQconnectStartParams (which differ in the same way as

* PQconnectdb and PQconnectdbParams) and PQconnectPoll.

*

* Internally, the static functions connectDBStart, connectDBComplete

* are part of the connection procedure.

*/

/*

* PQconnectdbParams

*

* establishes a connection to a postgres backend through the postmaster

* using connection information in two arrays.

*

* The keywords array is defined as

*

* const char *params[] = {"option1", "option2", NULL}

*

* The values array is defined as

*

* const char *values[] = {"value1", "value2", NULL}

*

* Returns a PGconn* which is needed for all subsequent libpq calls, or NULL

* if a memory allocation failed.

* If the status field of the connection returned is CONNECTION_BAD,

* then some fields may be null'ed out instead of having valid values.

*

* You should call PQfinish (if conn is not NULL) regardless of whether this

* call succeeded.

*/

PGconn *

PQconnectdbParams(const char *const * keywords,

const char *const * values,

int expand_dbname)

{

PGconn *conn = PQconnectStartParams(keywords, values, expand_dbname);

if (conn && conn->status != CONNECTION_BAD)

(void) connectDBComplete(conn);

return conn;

}

/*

* PQpingParams

*

* check server status, accepting parameters identical to PQconnectdbParams

*/

PGPing

PQpingParams(const char *const * keywords,

const char *const * values,

int expand_dbname)

{

PGconn *conn = PQconnectStartParams(keywords, values, expand_dbname);

PGPing ret;

ret = internal_ping(conn);

PQfinish(conn);

return ret;

}

/*

* PQconnectdb

*

* establishes a connection to a postgres backend through the postmaster

* using connection information in a string.

*

* The conninfo string is either a whitespace-separated list of

*

* option = value

*

* definitions or a URI (refer to the documentation for details.) Value

* might be a single value containing no whitespaces or a single quoted

* string. If a single quote should appear anywhere in the value, it must be

* escaped with a backslash like \'

*

* Returns a PGconn* which is needed for all subsequent libpq calls, or NULL

* if a memory allocation failed.

* If the status field of the connection returned is CONNECTION_BAD,

* then some fields may be null'ed out instead of having valid values.

*

* You should call PQfinish (if conn is not NULL) regardless of whether this

* call succeeded.

*/

PGconn *

PQconnectdb(const char *conninfo)

{

PGconn *conn = PQconnectStart(conninfo);

if (conn && conn->status != CONNECTION_BAD)

(void) connectDBComplete(conn);

return conn;

}

/*

* PQping

*

* check server status, accepting parameters identical to PQconnectdb

*/

PGPing

PQping(const char *conninfo)

{

PGconn *conn = PQconnectStart(conninfo);

PGPing ret;

ret = internal_ping(conn);

PQfinish(conn);

return ret;

}

/*

* PQconnectStartParams

*

* Begins the establishment of a connection to a postgres backend through the

* postmaster using connection information in a struct.

*

* See comment for PQconnectdbParams for the definition of the string format.

*

* Returns a PGconn*. If NULL is returned, a malloc error has occurred, and

* you should not attempt to proceed with this connection. If the status

* field of the connection returned is CONNECTION_BAD, an error has

* occurred. In this case you should call PQfinish on the result, (perhaps

* inspecting the error message first). Other fields of the structure may not

* be valid if that occurs. If the status field is not CONNECTION_BAD, then

* this stage has succeeded - call PQconnectPoll, using select(2) to see when

* this is necessary.

*

* See PQconnectPoll for more info.

*/

PGconn *

PQconnectStartParams(const char *const * keywords,

const char *const * values,

int expand_dbname)

{

PGconn *conn;

PQconninfoOption *connOptions;

/*

* Allocate memory for the conn structure

*/

conn = makeEmptyPGconn();

if (conn == NULL)

return NULL;

/*

* Parse the conninfo arrays

*/

connOptions = conninfo_array_parse(keywords, values,

&conn->errorMessage,

true, expand_dbname);

if (connOptions == NULL)

{

conn->status = CONNECTION_BAD;

/* errorMessage is already set */

return conn;

}

/*

* Move option values into conn structure

*/

if (!fillPGconn(conn, connOptions))

{

PQconninfoFree(connOptions);

return conn;

}

/*

* Free the option info - all is in conn now

*/

PQconninfoFree(connOptions);

/*

* Compute derived options

*/

if (!connectOptions2(conn))

return conn;

/*

* Connect to the database

*/

if (!connectDBStart(conn))

{

/* Just in case we failed to set it in connectDBStart */

conn->status = CONNECTION_BAD;

}

return conn;

}

/*

* PQconnectStart

*

* Begins the establishment of a connection to a postgres backend through the

* postmaster using connection information in a string.

*

* See comment for PQconnectdb for the definition of the string format.

*

* Returns a PGconn*. If NULL is returned, a malloc error has occurred, and

* you should not attempt to proceed with this connection. If the status

* field of the connection returned is CONNECTION_BAD, an error has

* occurred. In this case you should call PQfinish on the result, (perhaps

* inspecting the error message first). Other fields of the structure may not

* be valid if that occurs. If the status field is not CONNECTION_BAD, then

* this stage has succeeded - call PQconnectPoll, using select(2) to see when

* this is necessary.

*

* See PQconnectPoll for more info.

*/

PGconn *

PQconnectStart(const char *conninfo)

{

PGconn *conn;

/*

* Allocate memory for the conn structure

*/

conn = makeEmptyPGconn();

if (conn == NULL)

return NULL;

/*

* Parse the conninfo string

*/

if (!connectOptions1(conn, conninfo))

return conn;

/*

* Compute derived options

*/

if (!connectOptions2(conn))

return conn;

/*

* Connect to the database

*/

if (!connectDBStart(conn))

{

/* Just in case we failed to set it in connectDBStart */

conn->status = CONNECTION_BAD;

}

return conn;

}

/*

* Move option values into conn structure

*

* Don't put anything cute here --- intelligence should be in

* connectOptions2 ...

*

* Returns true on success. On failure, returns false and sets error message.

*/

static bool

fillPGconn(PGconn *conn, PQconninfoOption *connOptions)

{

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)

{

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext("out of memory\n"));

return false;

}

}

}

}

return true;

}

/*

* connectOptions1

*

* Internal subroutine to set up connection parameters given an already-

* created PGconn and a conninfo string. Derived settings should be

* processed by calling connectOptions2 next. (We split them because

* PQsetdbLogin overrides defaults in between.)

*

* Returns true if OK, false if trouble (in which case errorMessage is set

* and so is conn->status).

*/

static bool

connectOptions1(PGconn *conn, const char *conninfo)

{

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;

}

/*

* connectOptions2

*

* Compute derived connection options after absorbing all user-supplied info.

*

* Returns true if OK, false if trouble (in which case errorMessage is set

* and so is conn->status).

*/

static bool

connectOptions2(PGconn *conn)

{

/*

* 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;

}

/*

* Supply default password if none given

*/

if (conn->pgpass == NULL || conn->pgpass[0] == '\0')

{

if (conn->pgpass)

free(conn->pgpass);

conn->pgpass = PasswordFromFile(conn->pghost, conn->pgport,

conn->dbName, conn->pguser);

if (conn->pgpass == NULL)

{

conn->pgpass = strdup(DefaultPassword);

if (!conn->pgpass)

goto oom_error;

}

else

conn->dot_pgpass_used = true;

}

/*

* Allow unix socket specification in the host name

*/

if (conn->pghost && is_absolute_path(conn->pghost))

{

if (conn->pgunixsocket)

free(conn->pgunixsocket);

conn->pgunixsocket = conn->pghost;

conn->pghost = NULL;

}

/*

* 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;

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext("invalid sslmode value: \"%s\"\n"),

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;

printfPQExpBuffer(&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;

}

/*

* 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;

printfPQExpBuffer(&conn->errorMessage,

libpq_gettext("out of memory\n"));

return false;

}

/*

* PQconndefaults

*

* Construct a default connection options array, which identifies all the

* available options and shows any default values that are available from the

* environment etc. On error (eg out of memory), NULL is returned.

*

* Using this function, an application may determine all possible options

* and their current default values.

*

* NOTE: as of PostgreSQL 7.0, the returned array is dynamically allocated

* and should be freed when no longer needed via PQconninfoFree(). (In prior

* versions, the returned array was static, but that's not thread-safe.)

* Pre-7.0 applications that use this function will see a small memory leak

* until they are updated to call PQconninfoFree.

*/

PQconninfoOption *

PQconndefaults(void)

{

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;

}

/* ----------------

* PQsetdbLogin

*

* establishes a connection to a postgres backend through the postmaster

* at the specified host and port.

*

* returns a PGconn* which is needed for all subsequent libpq calls

*

* if the status field of the connection returned is CONNECTION_BAD,

* then only the errorMessage is likely to be useful.

* ----------------

*/

PGconn *

PQsetdbLogin(const char *pghost, const char *pgport, const char *pgoptions,

const char *pgtty, const char *dbName, const char *login,

const char *pwd)

{

PGconn *conn;

/*

* Allocate memory for the conn structure

*/

conn = makeEmptyPGconn();

if (conn == NULL)

return NULL;

/*

* If the dbName parameter contains what looks like a connection string,

* parse it into conn struct using connectOptions1.

*/

if (dbName && recognized_connection_string(dbName))

{

if (!connectOptions1(conn, dbName))

return conn;

}

else

{

/*

* Old-style path: first, parse an empty conninfo string in order to

* set up the same defaults that PQconnectdb() would use.

*/

if (!connectOptions1(conn, ""))

return conn;

/* Insert dbName parameter value into struct */

if (dbName && dbName[0] != '\0')

{

if (conn->dbName)

free(conn->dbName);

conn->dbName = strdup(dbName);

if (!conn->dbName)

goto oom_error;

}

}

/*

* Insert remaining parameters into struct, overriding defaults (as well