| blob | 5add6f4ebb3b1ed0cb795f08287848a470005751 |
1 /*-------------------------------------------------------------------------
2 *
3 * fe-connect.c
4 * functions related to setting up a connection to the backend
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/interfaces/libpq/fe-connect.c
12 *
13 *-------------------------------------------------------------------------
14 */
18 #include <sys/stat.h>
19 #include <fcntl.h>
20 #include <ctype.h>
21 #include <netdb.h>
22 #include <time.h>
23 #include <unistd.h>
36 #ifdef WIN32
38 #ifdef _WIN32_IE
39 #undef _WIN32_IE
40 #endif
41 #define _WIN32_IE 0x0500
42 #ifdef near
43 #undef near
44 #endif
45 #define near
46 #include <shlobj.h>
47 #include <mstcpip.h>
48 #else
49 #include <sys/socket.h>
50 #include <netdb.h>
51 #include <netinet/in.h>
52 #include <netinet/tcp.h>
53 #endif
55 #ifdef WIN32
57 #else
58 #include <pthread.h>
59 #endif
61 #ifdef USE_LDAP
62 #ifdef WIN32
63 #include <winldap.h>
64 #else
65 /* OpenLDAP deprecates RFC 1823, but we want standard conformance */
66 #define LDAP_DEPRECATED 1
67 #include <ldap.h>
69 #endif
71 PQExpBuffer errorMessage);
72 #endif
74 #ifndef WIN32
76 #else
78 #endif
80 /*
81 * Pre-9.0 servers will return this SQLSTATE if asked to set
82 * application_name in a startup packet. We hard-wire the value rather
83 * than looking into errcodes.h since it reflects historical behavior
84 * rather than that of the current code.
85 */
88 /* This is part of the protocol so just define it */
90 /* This too */
93 /*
94 * Cope with the various platform-specific ways to spell TCP keepalive socket
95 * options. This doesn't cover Windows, which as usual does its own thing.
96 */
97 #if defined(TCP_KEEPIDLE)
98 /* TCP_KEEPIDLE is the name of this option on Linux and *BSD */
99 #define PG_TCP_KEEPALIVE_IDLE TCP_KEEPIDLE
101 #elif defined(TCP_KEEPALIVE_THRESHOLD)
102 /* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris >= 11 */
103 #define PG_TCP_KEEPALIVE_IDLE TCP_KEEPALIVE_THRESHOLD
105 #elif defined(TCP_KEEPALIVE) && defined(__darwin__)
106 /* TCP_KEEPALIVE is the name of this option on macOS */
107 /* Caution: Solaris has this symbol but it means something different */
108 #define PG_TCP_KEEPALIVE_IDLE TCP_KEEPALIVE
110 #endif
112 /*
113 * fall back options if they are not specified by arguments or defined
114 * by environment variables
115 */
118 #ifdef USE_SSL
120 #else
122 #endif
125 #ifdef USE_SSL
128 #else
131 #endif
132 #ifdef ENABLE_GSS
135 #else
137 #endif
139 /* ----------
140 * Definition of the conninfo parameters and their fallback resources.
141 *
142 * If Environment-Var and Compiled-in are specified as NULL, no
143 * fallback is available. If after all no value can be determined
144 * for an option, an error is returned.
145 *
146 * The value for the username is treated specially in conninfo_add_defaults.
147 * If the value is not obtained any other way, the username is determined
148 * by pg_fe_getauthname().
149 *
150 * The Label and Disp-Char entries are provided for applications that
151 * want to use PQconndefaults() to create a generic database connection
152 * dialog. Disp-Char is defined as follows:
153 * "" Normal input field
154 * "*" Password field - hide value
155 * "D" Debug option - don't show by default
156 *
157 * PQconninfoOptions[] is a constant static array that we use to initialize
158 * a dynamically allocated working copy. All the "val" fields in
159 * PQconninfoOptions[] *must* be NULL. In a working copy, non-null "val"
160 * fields point to malloc'd strings that should be freed when the working
161 * array is freed (see PQconninfoFree).
162 *
163 * The first part of each struct is identical to the one in libpq-fe.h,
164 * which is required since we memcpy() data between the two!
165 * ----------
166 */
168 {
175 * connect dialog. Values are: "" Display
176 * entered value as is "*" Password field -
177 * hide value "D" Debug option - don't show
178 * by default */
180 /* ---
181 * Anything above this comment must be synchronized with
182 * PQconninfoOption in libpq-fe.h, since we memcpy() data
183 * between them!
184 * ---
185 */
265 /*
266 * ssl options are allowed even without client SSL support because the
267 * client can still handle SSL modes "disable" and "allow". Other
268 * parameters have no effect on non-SSL connections, so there is no reason
269 * to exclude them since none of them are mandatory.
270 */
327 /*
328 * As with SSL, all GSS options are exposed even in builds that don't have
329 * support.
330 */
335 /* Kerberos and GSSAPI authentication support specifying the service name */
362 /* Terminating entry --- MUST BE LAST */
365 };
368 {
369 /* common user-interface settings */
370 {
372 },
373 {
375 },
376 /* internal performance-related settings */
377 {
379 },
380 {
381 NULL, NULL
382 }
383 };
385 /* The connection URI must start with either of the following designators: */
413 PQExpBuffer errorMessage);
420 PQExpBuffer errorMessage);
433 PQExpBuffer errorMessage);
437 PQExpBuffer errorMessage,
448 /* global variable because fe-auth.c needs to access it */
452 /*
453 * pqDropConnection
454 *
455 * Close any physical connection to the server, and reset associated
456 * state inside the connection object. We don't release state that
457 * would be needed to reconnect, though, nor local state that might still
458 * be useful later.
459 *
460 * We can always flush the output buffer, since there's no longer any hope
461 * of sending that data. However, unprocessed input data might still be
462 * valuable, so the caller must tell us whether to flush that or not.
463 */
464 void
466 {
467 /* Drop any SSL state */
470 /* Close the socket itself */
475 /* Optionally discard any unread data */
479 /* Always discard any unsent data */
482 /* Likewise, discard any pending pipelined commands */
488 /* Free authentication/encryption state */
489 #ifdef ENABLE_GSS
490 {
491 OM_uint32 min_s;
494 {
497 }
503 {
506 }
508 {
511 }
513 {
516 }
518 }
519 #endif
520 #ifdef ENABLE_SSPI
522 {
525 }
527 {
531 }
533 {
537 }
539 #endif
541 {
544 }
545 }
547 /*
548 * pqFreeCommandQueue
549 * Free all the entries of PGcmdQueueEntry queue passed.
550 */
551 static void
553 {
555 {
561 }
562 }
564 /*
565 * pqDropServerData
566 *
567 * Clear all connection state data that was received from (or deduced about)
568 * the server. This is essential to do between connection attempts to
569 * different servers, else we may incorrectly hold over some data from the
570 * old server.
571 *
572 * It would be better to merge this into pqDropConnection, perhaps, but
573 * right now we cannot because that function is called immediately on
574 * detection of connection loss (cf. pqReadData, for instance). This data
575 * should be kept until we are actually starting a new connection.
576 */
577 static void
579 {
583 /* Forget pending notifies */
586 {
591 }
594 /* Reset ParameterStatus data, as well as variables deduced from it */
597 {
602 }
611 /* Drop large-object lookup data */
615 /* Reset assorted other per-connection state */
626 }
629 /*
630 * Connecting to a Database
631 *
632 * There are now six different ways a user of this API can connect to the
633 * database. Two are not recommended for use in new code, because of their
634 * lack of extensibility with respect to the passing of options to the
635 * backend. These are PQsetdb and PQsetdbLogin (the former now being a macro
636 * to the latter).
637 *
638 * If it is desired to connect in a synchronous (blocking) manner, use the
639 * function PQconnectdb or PQconnectdbParams. The former accepts a string of
640 * option = value pairs (or a URI) which must be parsed; the latter takes two
641 * NULL terminated arrays instead.
642 *
643 * To connect in an asynchronous (non-blocking) manner, use the functions
644 * PQconnectStart or PQconnectStartParams (which differ in the same way as
645 * PQconnectdb and PQconnectdbParams) and PQconnectPoll.
646 *
647 * Internally, the static functions connectDBStart, connectDBComplete
648 * are part of the connection procedure.
649 */
651 /*
652 * PQconnectdbParams
653 *
654 * establishes a connection to a postgres backend through the postmaster
655 * using connection information in two arrays.
656 *
657 * The keywords array is defined as
658 *
659 * const char *params[] = {"option1", "option2", NULL}
660 *
661 * The values array is defined as
662 *
663 * const char *values[] = {"value1", "value2", NULL}
664 *
665 * Returns a PGconn* which is needed for all subsequent libpq calls, or NULL
666 * if a memory allocation failed.
667 * If the status field of the connection returned is CONNECTION_BAD,
668 * then some fields may be null'ed out instead of having valid values.
669 *
670 * You should call PQfinish (if conn is not NULL) regardless of whether this
671 * call succeeded.
672 */
673 PGconn *
677 {
684 }
686 /*
687 * PQpingParams
688 *
689 * check server status, accepting parameters identical to PQconnectdbParams
690 */
691 PGPing
695 {
697 PGPing ret;
703 }
705 /*
706 * PQconnectdb
707 *
708 * establishes a connection to a postgres backend through the postmaster
709 * using connection information in a string.
710 *
711 * The conninfo string is either a whitespace-separated list of
712 *
713 * option = value
714 *
715 * definitions or a URI (refer to the documentation for details.) Value
716 * might be a single value containing no whitespaces or a single quoted
717 * string. If a single quote should appear anywhere in the value, it must be
718 * escaped with a backslash like \'
719 *
720 * Returns a PGconn* which is needed for all subsequent libpq calls, or NULL
721 * if a memory allocation failed.
722 * If the status field of the connection returned is CONNECTION_BAD,
723 * then some fields may be null'ed out instead of having valid values.
724 *
725 * You should call PQfinish (if conn is not NULL) regardless of whether this
726 * call succeeded.
727 */
728 PGconn *
730 {
737 }
739 /*
740 * PQping
741 *
742 * check server status, accepting parameters identical to PQconnectdb
743 */
744 PGPing
746 {
748 PGPing ret;
754 }
756 /*
757 * PQconnectStartParams
758 *
759 * Begins the establishment of a connection to a postgres backend through the
760 * postmaster using connection information in a struct.
761 *
762 * See comment for PQconnectdbParams for the definition of the string format.
763 *
764 * Returns a PGconn*. If NULL is returned, a malloc error has occurred, and
765 * you should not attempt to proceed with this connection. If the status
766 * field of the connection returned is CONNECTION_BAD, an error has
767 * occurred. In this case you should call PQfinish on the result, (perhaps
768 * inspecting the error message first). Other fields of the structure may not
769 * be valid if that occurs. If the status field is not CONNECTION_BAD, then
770 * this stage has succeeded - call PQconnectPoll, using select(2) to see when
771 * this is necessary.
772 *
773 * See PQconnectPoll for more info.
774 */
775 PGconn *
779 {
783 /*
784 * Allocate memory for the conn structure. Note that we also expect this
785 * to initialize conn->errorMessage to empty. All subsequent steps during
786 * connection initialization will only append to that buffer.
787 */
792 /*
793 * Parse the conninfo arrays
794 */
799 {
801 /* errorMessage is already set */
803 }
805 /*
806 * Move option values into conn structure
807 */
809 {
812 }
814 /*
815 * Free the option info - all is in conn now
816 */
819 /*
820 * Compute derived options
821 */
825 /*
826 * Connect to the database
827 */
829 {
830 /* Just in case we failed to set it in connectDBStart */
832 }
835 }
837 /*
838 * PQconnectStart
839 *
840 * Begins the establishment of a connection to a postgres backend through the
841 * postmaster using connection information in a string.
842 *
843 * See comment for PQconnectdb for the definition of the string format.
844 *
845 * Returns a PGconn*. If NULL is returned, a malloc error has occurred, and
846 * you should not attempt to proceed with this connection. If the status
847 * field of the connection returned is CONNECTION_BAD, an error has
848 * occurred. In this case you should call PQfinish on the result, (perhaps
849 * inspecting the error message first). Other fields of the structure may not
850 * be valid if that occurs. If the status field is not CONNECTION_BAD, then
851 * this stage has succeeded - call PQconnectPoll, using select(2) to see when
852 * this is necessary.
853 *
854 * See PQconnectPoll for more info.
855 */
856 PGconn *
858 {
861 /*
862 * Allocate memory for the conn structure. Note that we also expect this
863 * to initialize conn->errorMessage to empty. All subsequent steps during
864 * connection initialization will only append to that buffer.
865 */
870 /*
871 * Parse the conninfo string
872 */
876 /*
877 * Compute derived options
878 */
882 /*
883 * Connect to the database
884 */
886 {
887 /* Just in case we failed to set it in connectDBStart */
889 }
892 }
894 /*
895 * Move option values into conn structure
896 *
897 * Don't put anything cute here --- intelligence should be in
898 * connectOptions2 ...
899 *
900 * Returns true on success. On failure, returns false and sets error message.
901 */
902 static bool
904 {
908 {
910 {
914 {
920 {
923 }
924 }
925 }
926 }
929 }
931 /*
932 * connectOptions1
933 *
934 * Internal subroutine to set up connection parameters given an already-
935 * created PGconn and a conninfo string. Derived settings should be
936 * processed by calling connectOptions2 next. (We split them because
937 * PQsetdbLogin overrides defaults in between.)
938 *
939 * Returns true if OK, false if trouble (in which case errorMessage is set
940 * and so is conn->status).
941 */
942 static bool
944 {
947 /*
948 * Parse the conninfo string
949 */
952 {
954 /* errorMessage is already set */
956 }
958 /*
959 * Move option values into conn structure
960 */
962 {
966 }
968 /*
969 * Free the option info - all is in conn now
970 */
974 }
976 /*
977 * Count the number of elements in a simple comma-separated list.
978 */
979 static int
981 {
986 {
988 n++;
989 }
992 }
994 /*
995 * Parse a simple comma-separated list.
996 *
997 * On each call, returns a malloc'd copy of the next element, and sets *more
998 * to indicate whether there are any more elements in the list after this,
999 * and updates *startptr to point to the next element, if any.
1000 *
1001 * On out of memory, returns NULL.
1002 */
1005 {
1011 /*
1012 * Search for the end of the current element; a comma or end-of-string
1013 * acts as a terminator.
1014 */
1023 {
1026 }
1030 }
1032 /*
1033 * Initializes the prng_state field of the connection. We want something
1034 * unpredictable, so if possible, use high-quality random bits for the
1035 * seed. Otherwise, fall back to a seed based on the connection address,
1036 * timestamp and PID.
1037 */
1038 static void
1040 {
1041 uint64 rseed;
1055 }
1057 /*
1058 * connectOptions2
1059 *
1060 * Compute derived connection options after absorbing all user-supplied info.
1061 *
1062 * Returns true if OK, false if trouble (in which case errorMessage is set
1063 * and so is conn->status).
1064 */
1065 static bool
1067 {
1070 /*
1071 * Allocate memory for details about each host to which we might possibly
1072 * try to connect. For that, count the number of elements in the hostaddr
1073 * or host options. If neither is given, assume one host.
1074 */
1080 else
1087 /*
1088 * We now have one pg_conn_host structure per possible host. Fill in the
1089 * host and hostaddr fields for each, by splitting the parameter strings.
1090 */
1092 {
1097 {
1101 }
1103 /*
1104 * If hostaddr was given, the array was allocated according to the
1105 * number of elements in the hostaddr list, so it really should be the
1106 * right size.
1107 */
1110 }
1113 {
1118 {
1122 }
1124 /* Check for wrong number of host items. */
1126 {
1131 }
1132 }
1134 /*
1135 * Now, for each host slot, identify the type of address spec, and fill in
1136 * the default address if nothing was given.
1137 */
1139 {
1145 {
1149 }
1150 else
1151 {
1154 /*
1155 * This bit selects the default host location. If you change
1156 * this, see also pg_regress.
1157 */
1159 {
1162 }
1163 else
1164 {
1167 }
1170 }
1171 }
1173 /*
1174 * Next, work out the port number corresponding to each host name.
1175 *
1176 * Note: unlike the above for host names, this could leave the port fields
1177 * as null or empty strings. We will substitute DEF_PGPORT whenever we
1178 * read such a port field.
1179 */
1181 {
1186 {
1190 }
1192 /*
1193 * If exactly one port was given, use it for every host. Otherwise,
1194 * there must be exactly as many ports as there were hosts.
1195 */
1197 {
1199 {
1203 }
1204 }
1206 {
1211 }
1212 }
1214 /*
1215 * If user name was not given, fetch it. (Most likely, the fetch will
1216 * fail, since the only way we get here is if pg_fe_getauthname() failed
1217 * during conninfo_add_defaults(). But now we want an error message.)
1218 */
1220 {
1224 {
1227 }
1228 }
1230 /*
1231 * If database name was not given, default it to equal user name
1232 */
1234 {
1239 }
1241 /*
1242 * If password was not given, try to look it up in password file. Note
1243 * that the result might be different for each host/port pair.
1244 */
1246 {
1247 /* If password file wasn't specified, use ~/PGPASSFILE */
1249 {
1253 {
1260 }
1261 }
1264 {
1266 {
1267 /*
1268 * Try to get a password for this host from file. We use host
1269 * for the hostname search key if given, else hostaddr (at
1270 * least one of them is guaranteed nonempty by now).
1271 */
1283 }
1284 }
1285 }
1287 /*
1288 * parse and validate require_auth option
1289 */
1291 {
1294 more;
1297 /*
1298 * By default, start from an empty set of allowed options and add to
1299 * it.
1300 */
1305 {
1308 uint32 bits;
1314 /*
1315 * Check for negation, e.g. '!password'. If one element is
1316 * negated, they all have to be.
1317 */
1320 {
1322 {
1323 /*
1324 * Switch to a permissive set of allowed options, and
1325 * subtract from it.
1326 */
1329 }
1331 {
1333 libpq_append_conn_error(conn, "negative require_auth method \"%s\" cannot be mixed with non-negative methods",
1334 method);
1338 }
1341 method++;
1342 }
1344 {
1346 libpq_append_conn_error(conn, "require_auth method \"%s\" cannot be mixed with negative methods",
1347 method);
1351 }
1354 {
1356 }
1358 {
1360 }
1362 {
1365 }
1367 {
1370 }
1372 {
1373 /* This currently assumes that SCRAM is the only SASL method. */
1377 }
1379 {
1380 /*
1381 * Special case: let the user explicitly allow (or disallow)
1382 * connections where the server does not send an explicit
1383 * authentication challenge, such as "trust" and "cert" auth.
1384 */
1386 {
1391 }
1393 {
1398 }
1402 }
1403 else
1404 {
1411 }
1413 /* Update the bitmask. */
1415 {
1420 }
1421 else
1422 {
1427 }
1432 duplicate:
1434 /*
1435 * A duplicated method probably indicates a typo in a setting
1436 * where typos are extremely risky.
1437 */
1440 part);
1444 }
1445 }
1447 /*
1448 * validate channel_binding option
1449 */
1451 {
1455 {
1460 }
1461 }
1462 else
1463 {
1467 }
1469 #ifndef USE_SSL
1471 /*
1472 * sslrootcert=system is not supported. Since setting this changes the
1473 * default sslmode, check this _before_ we validate sslmode, to avoid
1474 * confusing the user with errors for an option they may not have set.
1475 */
1478 {
1483 }
1484 #endif
1486 /*
1487 * validate sslmode option
1488 */
1490 {
1497 {
1502 }
1504 #ifndef USE_SSL
1506 {
1510 /*
1511 * warn user that an SSL connection will never be negotiated
1512 * since SSL was not compiled in?
1513 */
1522 }
1523 #endif
1524 }
1525 else
1526 {
1530 }
1532 #ifdef USE_SSL
1534 /*
1535 * If sslrootcert=system, make sure our chosen sslmode is compatible.
1536 */
1540 {
1542 libpq_append_conn_error(conn, "weak sslmode \"%s\" may not be used with sslrootcert=system (use \"verify-full\")",
1545 }
1546 #endif
1548 /*
1549 * Validate TLS protocol versions for ssl_min_protocol_version and
1550 * ssl_max_protocol_version.
1551 */
1553 {
1559 }
1561 {
1567 }
1569 /*
1570 * Check if the range of SSL protocols defined is correct. This is done
1571 * at this early step because this is independent of the SSL
1572 * implementation used, and this avoids unnecessary cycles with an
1573 * already-built SSL context when the connection is being established, as
1574 * it would be doomed anyway.
1575 */
1578 {
1582 }
1584 /*
1585 * validate sslcertmode option
1586 */
1588 {
1592 {
1597 }
1598 #ifndef USE_SSL
1600 {
1605 }
1606 #endif
1607 #ifndef HAVE_SSL_CTX_SET_CERT_CB
1609 /*
1610 * Without a certificate callback, the current implementation can't
1611 * figure out if a certificate was actually requested, so "require" is
1612 * useless.
1613 */
1615 {
1620 }
1621 #endif
1622 }
1623 else
1624 {
1628 }
1630 /*
1631 * validate gssencmode option
1632 */
1634 {
1638 {
1642 }
1643 #ifndef ENABLE_GSS
1645 {
1647 libpq_append_conn_error(conn, "gssencmode value \"%s\" invalid when GSSAPI support is not compiled in",
1650 }
1651 #endif
1652 }
1653 else
1654 {
1658 }
1660 /*
1661 * validate target_session_attrs option, and set target_server_type
1662 */
1664 {
1677 else
1678 {
1684 }
1685 }
1686 else
1689 /*
1690 * validate load_balance_hosts option, and set load_balance_type
1691 */
1693 {
1698 else
1699 {
1705 }
1706 }
1707 else
1711 {
1714 /*
1715 * This is the "inside-out" variant of the Fisher-Yates shuffle
1716 * algorithm. Notionally, we append each new value to the array and
1717 * then swap it with a randomly-chosen array element (possibly
1718 * including itself, else we fail to generate permutations with the
1719 * last integer last). The swap step can be optimized by combining it
1720 * with the insertion.
1721 */
1723 {
1729 }
1730 }
1732 /*
1733 * Resolve special "auto" client_encoding from the locale
1734 */
1737 {
1739 conn->client_encoding_initial = strdup(pg_encoding_to_char(pg_get_encoding_from_locale(NULL, true)));
1742 }
1744 /*
1745 * Only if we get this far is it appropriate to try to connect. (We need a
1746 * state flag, rather than just the boolean result of this function, in
1747 * case someone tries to PQreset() the PGconn.)
1748 */
1753 oom_error:
1757 }
1759 /*
1760 * PQconndefaults
1761 *
1762 * Construct a default connection options array, which identifies all the
1763 * available options and shows any default values that are available from the
1764 * environment etc. On error (eg out of memory), NULL is returned.
1765 *
1766 * Using this function, an application may determine all possible options
1767 * and their current default values.
1768 *
1769 * NOTE: as of PostgreSQL 7.0, the returned array is dynamically allocated
1770 * and should be freed when no longer needed via PQconninfoFree(). (In prior
1771 * versions, the returned array was static, but that's not thread-safe.)
1772 * Pre-7.0 applications that use this function will see a small memory leak
1773 * until they are updated to call PQconninfoFree.
1774 */
1775 PQconninfoOption *
1777 {
1778 PQExpBufferData errorBuf;
1781 /* We don't actually report any errors here, but callees want a buffer */
1788 {
1789 /* pass NULL errorBuf to ignore errors */
1791 {
1794 }
1795 }
1799 }
1801 /* ----------------
1802 * PQsetdbLogin
1803 *
1804 * establishes a connection to a postgres backend through the postmaster
1805 * at the specified host and port.
1806 *
1807 * returns a PGconn* which is needed for all subsequent libpq calls
1808 *
1809 * if the status field of the connection returned is CONNECTION_BAD,
1810 * then only the errorMessage is likely to be useful.
1811 * ----------------
1812 */
1813 PGconn *
1817 {
1820 /*
1821 * Allocate memory for the conn structure. Note that we also expect this
1822 * to initialize conn->errorMessage to empty. All subsequent steps during
1823 * connection initialization will only append to that buffer.
1824 */
1829 /*
1830 * If the dbName parameter contains what looks like a connection string,
1831 * parse it into conn struct using connectOptions1.
1832 */
1834 {
1837 }
1838 else
1839 {
1840 /*
1841 * Old-style path: first, parse an empty conninfo string in order to
1842 * set up the same defaults that PQconnectdb() would use.
1843 */
1847 /* Insert dbName parameter value into struct */
1849 {
1854 }
1855 }
1857 /*
1858 * Insert remaining parameters into struct, overriding defaults (as well
1859 * as any conflicting data from dbName taken as a conninfo).
1860 */
1862 {
1867 }
1870 {
1875 }
1878 {
1883 }
1886 {
1891 }
1894 {
1899 }
1901 /*
1902 * Compute derived options
1903 */
1907 /*
1908 * Connect to the database
1909 */
1915 oom_error:
1919 }
1922 /* ----------
1923 * connectNoDelay -
1924 * Sets the TCP_NODELAY socket option.
1925 * Returns 1 if successful, 0 if not.
1926 * ----------
1927 */
1928 static int
1930 {
1931 #ifdef TCP_NODELAY
1937 {
1943 }
1944 #endif
1947 }
1949 /* ----------
1950 * Write currently connected IP address into host_addr (of len host_addr_len).
1951 * If unable to, set it to the empty string.
1952 * ----------
1953 */
1954 static void
1956 {
1960 {
1966 }
1968 {
1974 }
1975 else
1977 }
1979 /*
1980 * emitHostIdentityInfo -
1981 * Speculatively append "connection to server so-and-so failed: " to
1982 * conn->errorMessage once we've identified the current connection target
1983 * address. This ensures that any subsequent error message will be properly
1984 * attributed to the server we couldn't connect to. conn->raddr must be
1985 * valid, and the result of getHostaddr() must be supplied.
1986 */
1987 static void
1989 {
1991 {
1997 NI_NUMERICSERV);
2000 service);
2001 }
2002 else
2003 {
2007 /* To which host and port were we actually connecting? */
2010 else
2016 /*
2017 * If the user did not supply an IP address using 'hostaddr', and
2018 * 'host' was missing or does not match our lookup, display the
2019 * looked-up IP address.
2020 */
2027 displayed_port);
2028 else
2031 displayed_host,
2032 displayed_port);
2033 }
2034 }
2036 /* ----------
2037 * connectFailureMessage -
2038 * create a friendly error message on connection failure,
2039 * using the given errno value. Use this for error cases that
2040 * imply that there's no server there.
2041 * ----------
2042 */
2043 static void
2045 {
2053 libpq_append_conn_error(conn, "\tIs the server running locally and accepting connections on that socket?");
2054 else
2055 libpq_append_conn_error(conn, "\tIs the server running on that host and accepting TCP/IP connections?");
2056 }
2058 /*
2059 * Should we use keepalives? Returns 1 if yes, 0 if no, and -1 if
2060 * conn->keepalives is set to a value which is not parseable as an
2061 * integer.
2062 */
2063 static int
2065 {
2075 }
2077 #ifndef WIN32
2078 /*
2079 * Set the keepalive idle timer.
2080 */
2081 static int
2083 {
2095 #ifdef PG_TCP_KEEPALIVE_IDLE
2098 {
2103 PG_TCP_KEEPALIVE_IDLE_STR,
2106 }
2107 #endif
2110 }
2112 /*
2113 * Set the keepalive interval.
2114 */
2115 static int
2117 {
2129 #ifdef TCP_KEEPINTVL
2132 {
2140 }
2141 #endif
2144 }
2146 /*
2147 * Set the count of lost keepalive packets that will trigger a connection
2148 * break.
2149 */
2150 static int
2152 {
2164 #ifdef TCP_KEEPCNT
2167 {
2175 }
2176 #endif
2179 }
2181 #ifdef SIO_KEEPALIVE_VALS
2182 /*
2183 * Enable keepalives and set the keepalive values on Win32,
2184 * where they are always set in one batch.
2185 *
2186 * CAUTION: This needs to be signal safe, since it's used by PQcancel.
2187 */
2188 int
2190 {
2192 DWORD retsize;
2204 SIO_KEEPALIVE_VALS,
2207 NULL,
2210 NULL,
2211 NULL)
2215 }
2217 static int
2219 {
2233 {
2238 }
2240 }
2244 /*
2245 * Set the TCP user timeout.
2246 */
2247 static int
2249 {
2262 #ifdef TCP_USER_TIMEOUT
2265 {
2273 }
2274 #endif
2277 }
2279 /* ----------
2280 * connectDBStart -
2281 * Begin the process of making a connection to the backend.
2282 *
2283 * Returns 1 if successful, 0 if not.
2284 * ----------
2285 */
2286 static int
2288 {
2295 /*
2296 * Check for bad linking to backend-internal versions of src/common
2297 * functions (see comments in link-canary.c for the reason we need this).
2298 * Nobody but developers should see this message, so we don't bother
2299 * translating it.
2300 */
2302 {
2306 }
2308 /* Ensure our buffers are empty */
2312 /*
2313 * Set up to try to connect to the first host. (Setting whichhost = -1 is
2314 * a bit of a cheat, but PQconnectPoll will advance it to 0 before
2315 * anything else looks at it.)
2316 */
2322 /* Also reset the target_server_type state if needed */
2326 /*
2327 * The code for processing CONNECTION_NEEDED state is in PQconnectPoll(),
2328 * so that it can easily be re-executed if needed again during the
2329 * asynchronous startup process. However, we must run it once here,
2330 * because callers expect a success return from this routine to mean that
2331 * we are in PGRES_POLLING_WRITING connection state.
2332 */
2336 connect_errReturn:
2338 /*
2339 * If we managed to open a socket, close it immediately rather than
2340 * waiting till PQfinish. (The application cannot have gotten the socket
2341 * from PQsocket yet, so this doesn't risk breaking anything.)
2342 */
2346 }
2349 /*
2350 * connectDBComplete
2351 *
2352 * Block and complete a connection.
2353 *
2354 * Returns 1 on success, 0 on failure.
2355 */
2356 static int
2358 {
2368 /*
2369 * Set up a time limit, if connect_timeout isn't zero.
2370 */
2372 {
2375 {
2376 /* mark the connection as bad to report the parsing failure */
2379 }
2382 {
2383 /*
2384 * Rounding could cause connection to fail unexpectedly quickly;
2385 * to prevent possibly waiting hardly-at-all, insist on at least
2386 * two seconds.
2387 */
2390 }
2393 }
2396 {
2399 /*
2400 * (Re)start the connect_timeout timer if it's active and we are
2401 * considering a different host than we were last time through. If
2402 * we've already succeeded, though, needn't recalculate.
2403 */
2408 {
2412 }
2414 /*
2415 * Wait, if necessary. Note that the initial state (just after
2416 * PQconnectStart) is to wait for the socket to select for writing.
2417 */
2419 {
2426 {
2427 /* hard failure, eg select() problem, aborts everything */
2430 }
2436 {
2437 /* hard failure, eg select() problem, aborts everything */
2440 }
2444 /* Just in case we failed to set it in PQconnectPoll */
2447 }
2450 {
2451 /*
2452 * Give up on current server/address, try the next one.
2453 */
2456 }
2458 /*
2459 * Now try to advance the state machine.
2460 */
2462 }
2463 }
2465 /* ----------------
2466 * PQconnectPoll
2467 *
2468 * Poll an asynchronous connection.
2469 *
2470 * Returns a PostgresPollingStatusType.
2471 * Before calling this function, use select(2) to determine when data
2472 * has arrived..
2473 *
2474 * You must call PQfinish whether or not this fails.
2475 *
2476 * This function and PQconnectStart are intended to allow connections to be
2477 * made without blocking the execution of your program on remote I/O. However,
2478 * there are a number of caveats:
2479 *
2480 * o If you call PQtrace, ensure that the stream object into which you trace
2481 * will not block.
2482 * o If you do not supply an IP address for the remote host (i.e. you
2483 * supply a host name instead) then PQconnectStart will block on
2484 * getaddrinfo. You will be fine if using Unix sockets (i.e. by
2485 * supplying neither a host name nor a host address).
2486 * o If your backend wants to use Kerberos authentication then you must
2487 * supply both a host name and a host address, otherwise this function
2488 * may block on gethostname.
2489 *
2490 * ----------------
2491 */
2492 PostgresPollingStatusType
2494 {
2504 /* Get the new data */
2506 {
2507 /*
2508 * We really shouldn't have been polled in these two cases, but we
2509 * can handle it.
2510 */
2516 /* These are reading states */
2522 {
2523 /* Load waiting data */
2532 }
2534 /* These are writing states, so we just proceed. */
2539 /* Special cases: proceed without waiting. */
2547 libpq_append_conn_error(conn, "invalid connection state, probably indicative of memory corruption");
2549 }
2553 * nothing left to do. */
2555 /* Time to advance to next address, or next host if no more addresses? */
2557 {
2559 {
2562 }
2563 else
2566 }
2568 /* Time to advance to next connhost[] entry? */
2570 {
2580 else
2581 {
2582 /*
2583 * Oops, no more hosts.
2584 *
2585 * If we are trying to connect in "prefer-standby" mode, then drop
2586 * the standby requirement and start over.
2587 *
2588 * Otherwise, an appropriate error message is already set up, so
2589 * we just need to set the right status.
2590 */
2593 {
2596 }
2597 else
2599 }
2601 /* Drop any address info for previous host */
2604 /*
2605 * Look up info for the new host. On failure, log the problem in
2606 * conn->errorMessage, then loop around to try the next host. (Note
2607 * we don't clear try_next_host until we've succeeded.)
2608 */
2611 /* Initialize hint structure */
2616 /* Figure out the port number we're going to use. */
2619 else
2620 {
2625 {
2628 }
2629 }
2632 /* Use pg_getaddrinfo_all() to resolve the address */
2634 {
2639 {
2643 }
2651 {
2655 }
2662 {
2664 portstr,
2667 }
2669 /*
2670 * NULL hostname tells pg_getaddrinfo_all to parse the service
2671 * name as a Unix-domain socket path.
2672 */
2676 {
2677 libpq_append_conn_error(conn, "could not translate Unix-domain socket path \"%s\" to address: %s",
2680 }
2682 }
2684 /*
2685 * Store a copy of the addrlist in private memory so we can perform
2686 * randomization for load balancing.
2687 */
2693 /*
2694 * If random load balancing is enabled we shuffle the addresses.
2695 */
2697 {
2698 /*
2699 * This is the "inside-out" variant of the Fisher-Yates shuffle
2700 * algorithm. Notionally, we append each new value to the array
2701 * and then swap it with a randomly-chosen array element (possibly
2702 * including itself, else we fail to generate permutations with
2703 * the last integer last). The swap step can be optimized by
2704 * combining it with the insertion.
2705 *
2706 * We don't need to initialize conn->prng_state here, because that
2707 * already happened in connectOptions2.
2708 */
2710 {
2716 }
2717 }
2721 }
2723 /* Reset connection state machine? */
2725 {
2726 /*
2727 * (Re) initialize our connection control variables for a set of
2728 * connection attempts to a single server address. These variables
2729 * must persist across individual connection attempts, but we must
2730 * reset them when we start to consider a new server.
2731 */
2734 #ifdef USE_SSL
2735 /* initialize these values based on SSL mode */
2738 #endif
2739 #ifdef ENABLE_GSS
2741 #endif
2745 }
2747 /* Force a new connection (perhaps to the same server as before)? */
2749 {
2750 /* Drop any existing connection */
2753 /* Reset all state obtained from old server */
2756 /* Drop any PGresult we might have, too */
2762 /* Reset conn->status to put the state machine in the right state */
2766 }
2768 /* Now try to advance the state machine for this connection */
2770 {
2772 {
2773 /*
2774 * Try to initiate a connection to one of the addresses
2775 * returned by pg_getaddrinfo_all(). conn->whichaddr is the
2776 * next one to try.
2777 *
2778 * The extra level of braces here is historical. It's not
2779 * worth reindenting this whole switch case to remove 'em.
2780 */
2781 {
2786 /*
2787 * Advance to next possible host, if we've tried all of
2788 * the addresses for the current host.
2789 */
2791 {
2794 }
2797 /* Remember current address for possible use later */
2800 /*
2801 * Set connip, too. Note we purposely ignore strdup
2802 * failure; not a big problem if it fails.
2803 */
2805 {
2808 }
2813 /* Try to create the socket */
2815 #ifdef SOCK_CLOEXEC
2817 /*
2818 * Atomically mark close-on-exec, if possible on this
2819 * platform, so that there isn't a window where a
2820 * subprogram executed by another thread inherits the
2821 * socket. See fallback code below.
2822 */
2824 #endif
2825 #ifdef SOCK_NONBLOCK
2827 /*
2828 * We might as well skip a system call for nonblocking
2829 * mode too, if we can.
2830 */
2832 #endif
2835 {
2838 /*
2839 * Silently ignore socket() failure if we have more
2840 * addresses to try; this reduces useless chatter in
2841 * cases where the address list includes both IPv4 and
2842 * IPv6 but kernel only accepts one family.
2843 */
2846 {
2849 }
2854 }
2856 /*
2857 * Once we've identified a target address, all errors
2858 * except the preceding socket()-failure case should be
2859 * prefixed with host-identity information. (If the
2860 * connection succeeds, the contents of conn->errorMessage
2861 * won't matter, so this is harmless.)
2862 */
2865 /*
2866 * Select socket options: no delay of outgoing data for
2867 * TCP sockets, nonblock mode, close-on-exec. Try the
2868 * next address if any of this fails.
2869 */
2871 {
2873 {
2874 /* error message already created */
2877 }
2878 }
2879 #ifndef SOCK_NONBLOCK
2881 {
2886 }
2887 #endif
2889 #ifndef SOCK_CLOEXEC
2890 #ifdef F_SETFD
2892 {
2897 }
2899 #endif
2902 {
2903 #ifndef WIN32
2905 #endif
2910 {
2913 }
2915 {
2916 /* Do nothing */
2917 }
2918 #ifndef WIN32
2922 {
2928 }
2934 #ifdef SIO_KEEPALIVE_VALS
2943 {
2946 }
2947 }
2949 /*----------
2950 * We have three methods of blocking SIGPIPE during
2951 * send() calls to this socket:
2952 *
2953 * - setsockopt(sock, SO_NOSIGPIPE)
2954 * - send(sock, ..., MSG_NOSIGNAL)
2955 * - setting the signal mask to SIG_IGN during send()
2956 *
2957 * The third method requires three syscalls per send,
2958 * so we prefer either of the first two, but they are
2959 * less portable. The state is tracked in the following
2960 * members of PGconn:
2961 *
2962 * conn->sigpipe_so - we have set up SO_NOSIGPIPE
2963 * conn->sigpipe_flag - we're specifying MSG_NOSIGNAL
2964 *
2965 * If we can use SO_NOSIGPIPE, then set sigpipe_so here
2966 * and we're done. Otherwise, set sigpipe_flag so that
2967 * we will try MSG_NOSIGNAL on sends. If we get an error
2968 * with MSG_NOSIGNAL, we'll clear that flag and revert to
2969 * signal masking.
2970 *----------
2971 */
2973 #ifdef MSG_NOSIGNAL
2975 #else
2979 #ifdef SO_NOSIGPIPE
2983 {
2986 }
2989 /*
2990 * Start/make connection. This should not block, since we
2991 * are in nonblock mode. If it does, well, too bad.
2992 */
2995 {
2997 #ifdef WIN32
2999 #endif
3001 {
3002 /*
3003 * This is fine - we're in non-blocking mode, and
3004 * the connection is in progress. Tell caller to
3005 * wait for write-ready on socket.
3006 */
3009 }
3010 /* otherwise, trouble */
3011 }
3012 else
3013 {
3014 /*
3015 * Hm, we're connected already --- seems the "nonblock
3016 * connection" wasn't. Advance the state machine and
3017 * go do the next stuff.
3018 */
3021 }
3023 /*
3024 * This connection failed. Add the error report to
3025 * conn->errorMessage, then try the next address if any.
3026 */
3030 }
3031 }
3034 {
3037 /*
3038 * Write ready, since we've made it here, so the connection
3039 * has been made ... or has failed.
3040 */
3042 /*
3043 * Now check (using getsockopt) that there is not an error
3044 * state waiting for us on the socket.
3045 */
3049 {
3053 }
3055 {
3056 /*
3057 * When using a nonblocking connect, we will typically see
3058 * connect failures at this point, so provide a friendly
3059 * error message.
3060 */
3063 /*
3064 * Try the next address if any, just as in the case where
3065 * connect() returned failure immediately.
3066 */
3069 }
3071 /* Fill in the client address */
3076 {
3080 }
3082 /*
3083 * Make sure we can write before advancing to next step.
3084 */
3087 }
3090 {
3094 /*
3095 * Implement requirepeer check, if requested and it's a
3096 * Unix-domain socket.
3097 */
3100 {
3101 #ifndef WIN32
3103 #endif
3104 uid_t uid;
3105 gid_t gid;
3109 {
3110 /*
3111 * Provide special error message if getpeereid is a
3112 * stub
3113 */
3116 else
3120 }
3122 #ifndef WIN32
3129 {
3130 libpq_append_conn_error(conn, "requirepeer specifies \"%s\", but actual peer user name is \"%s\"",
3134 }
3137 /* should have failed with ENOSYS above */
3140 }
3143 {
3144 /* Don't request SSL or GSSAPI over Unix sockets */
3145 #ifdef USE_SSL
3147 #endif
3148 #ifdef ENABLE_GSS
3150 #endif
3151 }
3153 #ifdef ENABLE_GSS
3155 /*
3156 * If GSSAPI encryption is enabled, then call
3157 * pg_GSS_have_cred_cache() which will return true if we can
3158 * acquire credentials (and give us a handle to use in
3159 * conn->gcred), and then send a packet to the server asking
3160 * for GSSAPI Encryption (and skip past SSL negotiation and
3161 * regular startup below).
3162 */
3166 {
3170 {
3174 }
3176 /* Ok, wait for response */
3179 }
3181 {
3183 "GSSAPI encryption required but was impossible (possibly no credential cache, no server support, or using a local socket)");
3185 }
3186 #endif
3188 #ifdef USE_SSL
3190 /*
3191 * Enable the libcrypto callbacks before checking if SSL needs
3192 * to be done. This is done before sending the startup packet
3193 * as depending on the type of authentication done, like MD5
3194 * or SCRAM that use cryptohashes, the callbacks would be
3195 * required even without a SSL connection
3196 */
3200 /*
3201 * If SSL is enabled and we haven't already got encryption of
3202 * some sort running, request SSL instead of sending the
3203 * startup message.
3204 */
3207 #ifdef ENABLE_GSS
3209 #endif
3210 )
3211 {
3212 ProtocolVersion pv;
3214 /*
3215 * Send the SSL request packet.
3216 *
3217 * Theoretically, this could block, but it really
3218 * shouldn't since we only got here if the socket is
3219 * write-ready.
3220 */
3223 {
3227 }
3228 /* Ok, wait for response */
3231 }
3234 /*
3235 * Build the startup packet.
3236 */
3238 EnvironmentOptions);
3240 {
3243 }
3245 /*
3246 * Send the startup packet.
3247 *
3248 * Theoretically, this could block, but it really shouldn't
3249 * since we only got here if the socket is write-ready.
3250 */
3252 {
3257 }
3263 }
3265 /*
3266 * Handle SSL negotiation: wait for postmaster messages and
3267 * respond as necessary.
3268 */
3270 {
3271 #ifdef USE_SSL
3272 PostgresPollingStatusType pollres;
3274 /*
3275 * On first time through, get the postmaster's response to our
3276 * SSL negotiation packet.
3277 */
3279 {
3280 /*
3281 * We use pqReadData here since it has the logic to
3282 * distinguish no-data-yet from connection closure. Since
3283 * conn->ssl isn't set, a plain recv() will occur.
3284 */
3290 {
3291 /* errorMessage is already filled in */
3293 }
3295 {
3296 /* caller failed to wait for data */
3298 }
3300 {
3301 /* should not happen really */
3303 }
3305 {
3306 /* mark byte consumed */
3309 /*
3310 * Set up global SSL state if required. The crypto
3311 * state has already been set if libpq took care of
3312 * doing that, so there is no need to make that happen
3313 * again.
3314 */
3317 }
3319 {
3320 /* mark byte consumed */
3322 /* OK to do without SSL? */
3325 * "verify-full" */
3326 {
3327 /* Require SSL, but server does not want it */
3330 }
3331 /* Otherwise, proceed with normal startup */
3333 /* We can proceed using this connection */
3336 }
3338 {
3339 /*
3340 * Server failure of some sort, such as failure to
3341 * fork a backend process. We need to process and
3342 * report the error message, which might be formatted
3343 * according to either protocol 2 or protocol 3.
3344 * Rather than duplicate the code for that, we flip
3345 * into AWAITING_RESPONSE state and let the code there
3346 * deal with it. Note we have *not* consumed the "E"
3347 * byte here.
3348 */
3351 }
3352 else
3353 {
3355 SSLok);
3357 }
3358 }
3360 /*
3361 * Begin or continue the SSL negotiation process.
3362 */
3365 {
3366 /*
3367 * At this point we should have no data already buffered.
3368 * If we do, it was received before we performed the SSL
3369 * handshake, so it wasn't encrypted and indeed may have
3370 * been injected by a man-in-the-middle.
3371 */
3373 {
3376 }
3378 /* SSL handshake done, ready to send startup packet */
3381 }
3383 {
3384 /*
3385 * Failed ... if sslmode is "prefer" then do a non-SSL
3386 * retry
3387 */
3391 {
3392 /* only retry once */
3396 }
3397 /* Else it's a hard failure */
3399 }
3400 /* Else, return POLLING_READING or POLLING_WRITING status */
3403 /* can't get here */
3406 }
3409 {
3410 #ifdef ENABLE_GSS
3411 PostgresPollingStatusType pollres;
3413 /*
3414 * If we haven't yet, get the postmaster's response to our
3415 * negotiation packet
3416 */
3418 {
3423 /* pqReadData fills in error message */
3426 /* caller failed to wait for data */
3429 /* shouldn't happen... */
3433 {
3434 /*
3435 * Server failure of some sort. Assume it's a
3436 * protocol version support failure, and let's see if
3437 * we can't recover (if it's not, we'll get a better
3438 * error message on retry). Server gets fussy if we
3439 * don't hang up the socket, though.
3440 */
3444 }
3446 /* mark byte consumed */
3450 {
3451 /* Server doesn't want GSSAPI; fall back if we can */
3453 {
3454 libpq_append_conn_error(conn, "server doesn't support GSSAPI encryption, but it was required");
3456 }
3459 /* We can proceed using this connection */
3462 }
3464 {
3466 gss_ok);
3468 }
3469 }
3471 /* Begin or continue GSSAPI negotiation */
3474 {
3475 /*
3476 * At this point we should have no data already buffered.
3477 * If we do, it was received before we performed the GSS
3478 * handshake, so it wasn't encrypted and indeed may have
3479 * been injected by a man-in-the-middle.
3480 */
3482 {
3485 }
3487 /* All set for startup packet */
3490 }
3492 {
3494 {
3495 /*
3496 * We failed, but we can retry on "prefer". Have to
3497 * drop the current connection to do so, though.
3498 */
3502 }
3503 /* Else it's a hard failure */
3505 }
3506 /* Else, return POLLING_READING or POLLING_WRITING status */
3509 /* unreachable */
3512 }
3514 /*
3515 * Handle authentication exchange: wait for postmaster messages
3516 * and respond as necessary.
3517 */
3519 {
3523 AuthRequest areq;
3526 /*
3527 * Scan the message from current point (note that if we find
3528 * the message is incomplete, we will return without advancing
3529 * inStart, and resume here next time).
3530 */
3533 /* Read type byte */
3535 {
3536 /* We'll come back when there is more data */
3538 }
3540 /*
3541 * Validate message type: we expect only an authentication
3542 * request, NegotiateProtocolVersion, or an error here.
3543 * Anything else probably means it's not Postgres on the other
3544 * end at all.
3545 */
3549 {
3551 beresp);
3553 }
3555 /* Read message length word */
3557 {
3558 /* We'll come back when there is more data */
3560 }
3562 /*
3563 * Try to validate message length before using it.
3564 *
3565 * Authentication requests can't be very large, although GSS
3566 * auth requests may not be that small. Same for
3567 * NegotiateProtocolVersion.
3568 *
3569 * Errors can be a little larger, but not huge. If we see a
3570 * large apparent length in an error, it means we're really
3571 * talking to a pre-3.0-protocol server; cope. (Before
3572 * version 14, the server also used the old protocol for
3573 * errors that happened before processing the startup packet.)
3574 */
3577 {
3580 }
3583 {
3586 }
3588 #define MAX_ERRLEN 30000
3591 {
3592 /* Handle error from a pre-3.0 server */
3595 {
3596 /*
3597 * We may not have authenticated the server yet, so
3598 * don't let the buffer grow forever.
3599 */
3602 {
3605 }
3607 /* We'll come back when there is more data */
3609 }
3610 /* OK, we read the message; mark data consumed */
3613 /*
3614 * Before 7.2, the postmaster didn't always end its
3615 * messages with a newline, so add one if needed to
3616 * conform to libpq conventions.
3617 */
3620 {
3622 }
3625 }
3626 #undef MAX_ERRLEN
3628 /*
3629 * Can't process if message body isn't all here yet.
3630 *
3631 * After this check passes, any further EOF during parsing
3632 * implies that the server sent a bad/truncated message.
3633 * Reading more bytes won't help in that case, so don't return
3634 * PGRES_POLLING_READING after this point.
3635 */
3639 {
3640 /*
3641 * Before returning, try to enlarge the input buffer if
3642 * needed to hold the whole message; see notes in
3643 * pqParseInput3.
3644 */
3646 conn))
3648 /* We'll come back when there is more data */
3650 }
3652 /* Handle errors. */
3654 {
3656 {
3659 }
3660 /* OK, we read the message; mark data consumed */
3663 /*
3664 * If error is "cannot connect now", try the next host if
3665 * any (but we don't want to consider additional addresses
3666 * for this host, nor is there much point in changing SSL
3667 * or GSS mode). This is helpful when dealing with
3668 * standby servers that might not be in hot-standby state.
3669 */
3672 {
3675 }
3677 /* Check to see if we should mention pgpassfile */
3680 #ifdef ENABLE_GSS
3682 /*
3683 * If gssencmode is "prefer" and we're using GSSAPI, retry
3684 * without it.
3685 */
3687 {
3688 /* only retry once */
3692 }
3693 #endif
3695 #ifdef USE_SSL
3697 /*
3698 * if sslmode is "allow" and we haven't tried an SSL
3699 * connection already, then retry with an SSL connection
3700 */
3705 {
3706 /* only retry once */
3710 }
3712 /*
3713 * if sslmode is "prefer" and we're in an SSL connection,
3714 * then do a non-SSL retry
3715 */
3720 {
3721 /* only retry once */
3725 }
3726 #endif
3729 }
3731 {
3733 {
3736 }
3737 /* OK, we read the message; mark data consumed */
3740 }
3742 /* It is an authentication request. */
3745 /* Get the type of request. */
3747 {
3748 /* can't happen because we checked the length already */
3751 }
3754 /*
3755 * Process the rest of the authentication request message, and
3756 * respond to it if necessary.
3757 *
3758 * Note that conn->pghost must be non-NULL if we are going to
3759 * avoid the Kerberos code doing a hostname look-up.
3760 */
3763 /* OK, we have processed the message; mark data consumed */
3769 /*
3770 * Just make sure that any data sent by pg_fe_sendauth is
3771 * flushed out. Although this theoretically could block, it
3772 * really shouldn't since we don't send large auth responses.
3773 */
3778 {
3779 /* We are done with authentication exchange */
3782 /*
3783 * Set asyncStatus so that PQgetResult will think that
3784 * what comes back next is the result of a query. See
3785 * below.
3786 */
3788 }
3790 /* Look to see if we have more data yet. */
3792 }
3795 {
3796 /*
3797 * Now we expect to hear from the backend. A ReadyForQuery
3798 * message indicates that startup is successful, but we might
3799 * also get an Error message indicating failure. (Notice
3800 * messages indicating nonfatal warnings are also allowed by
3801 * the protocol, as are ParameterStatus and BackendKeyData
3802 * messages.) Easiest way to handle this is to let
3803 * PQgetResult() read the messages. We just have to fake it
3804 * out about the state of the connection, by setting
3805 * asyncStatus = PGASYNC_BUSY (done above).
3806 */
3813 /*
3814 * NULL return indicating we have gone to IDLE state is
3815 * expected
3816 */
3818 {
3823 {
3824 /*
3825 * If we tried to send application_name, check to see
3826 * if the error is about that --- pre-9.0 servers will
3827 * reject it at this stage of the process. If so,
3828 * close the connection and retry without sending
3829 * application_name. We could possibly get a false
3830 * SQLSTATE match here and retry uselessly, but there
3831 * seems no great harm in that; we'll just get the
3832 * same error again if it's unrelated.
3833 */
3839 {
3844 }
3845 }
3847 /*
3848 * if the resultStatus is FATAL, then conn->errorMessage
3849 * already has a copy of the error; needn't copy it back.
3850 * But add a newline if it's not there already, since
3851 * postmaster error messages may not have one.
3852 */
3858 }
3860 /* Almost there now ... */
3863 }
3866 {
3867 /*
3868 * If a read-write, read-only, primary, or standby connection
3869 * is required, see if we have one.
3870 */
3873 {
3876 /*
3877 * If the server didn't report
3878 * "default_transaction_read_only" or "in_hot_standby" at
3879 * startup, we must determine its state by sending the
3880 * query "SHOW transaction_read_only". This GUC exists in
3881 * all server versions that support 3.0 protocol.
3882 */
3885 {
3886 /*
3887 * We use PQsendQueryContinue so that
3888 * conn->errorMessage does not get cleared. We need
3889 * to preserve any error messages related to previous
3890 * hosts we have tried and failed to connect to.
3891 */
3896 /* We'll return to this state when we have the answer */
3899 }
3901 /* OK, we can make the test */
3902 read_only_server =
3908 {
3909 /* Wrong server state, reject and try the next host */
3912 else
3915 /* Close connection politely. */
3919 /*
3920 * Try next host if any, but we don't want to consider
3921 * additional addresses for this host.
3922 */
3925 }
3926 }
3930 {
3931 /*
3932 * If the server didn't report "in_hot_standby" at
3933 * startup, we must determine its state by sending the
3934 * query "SELECT pg_catalog.pg_is_in_recovery()". Servers
3935 * before 9.0 don't have that function, but by the same
3936 * token they don't have any standby mode, so we may just
3937 * assume the result.
3938 */
3943 {
3944 /*
3945 * We use PQsendQueryContinue so that
3946 * conn->errorMessage does not get cleared. We need
3947 * to preserve any error messages related to previous
3948 * hosts we have tried and failed to connect to.
3949 */
3954 /* We'll return to this state when we have the answer */
3957 }
3959 /* OK, we can make the test */
3963 {
3964 /* Wrong server state, reject and try the next host */
3967 else
3970 /* Close connection politely. */
3974 /*
3975 * Try next host if any, but we don't want to consider
3976 * additional addresses for this host.
3977 */
3980 }
3981 }
3983 /* We can release the address list now. */
3986 /*
3987 * Contents of conn->errorMessage are no longer interesting
3988 * (and it seems some clients expect it to be empty after a
3989 * successful connection).
3990 */
3993 /* We are open for business! */
3996 }
3999 {
4000 /*
4001 * This state just makes sure the connection is idle after
4002 * we've obtained the result of a SHOW or SELECT query. Once
4003 * we're clear, return to CONNECTION_CHECK_TARGET state to
4004 * decide what to do next. We must transiently set status =
4005 * CONNECTION_OK in order to use the result-consuming
4006 * subroutines.
4007 */
4013 {
4016 }
4018 /* Call PQgetResult() again until we get a NULL result */
4021 {
4025 }
4029 }
4032 {
4033 /*
4034 * Waiting for result of "SHOW transaction_read_only". We
4035 * must transiently set status = CONNECTION_OK in order to use
4036 * the result-consuming subroutines.
4037 */
4043 {
4046 }
4051 {
4054 /*
4055 * "transaction_read_only = on" proves that at least one
4056 * of default_transaction_read_only and in_hot_standby is
4057 * on, but we don't actually know which. We don't care
4058 * though for the purpose of identifying a read-only
4059 * session, so satisfy the CONNECTION_CHECK_TARGET code by
4060 * claiming they are both on. On the other hand, if it's
4061 * a read-write session, they are certainly both off.
4062 */
4064 {
4067 }
4068 else
4069 {
4072 }
4075 /* Finish reading messages before continuing */
4078 }
4080 /* Something went wrong with "SHOW transaction_read_only". */
4083 /* Append error report to conn->errorMessage. */
4087 /* Close connection politely. */
4091 /* Try next host. */
4094 }
4097 {
4098 /*
4099 * Waiting for result of "SELECT pg_is_in_recovery()". We
4100 * must transiently set status = CONNECTION_OK in order to use
4101 * the result-consuming subroutines.
4102 */
4108 {
4111 }
4116 {
4121 else
4125 /* Finish reading messages before continuing */
4128 }
4130 /* Something went wrong with "SELECT pg_is_in_recovery()". */
4133 /* Append error report to conn->errorMessage. */
4137 /* Close connection politely. */
4141 /* Try next host. */
4144 }
4151 }
4153 /* Unreachable */
4155 error_return:
4157 /*
4158 * We used to close the socket at this point, but that makes it awkward
4159 * for those above us if they wish to remove this socket from their own
4160 * records (an fd_set for example). We'll just have this socket closed
4161 * when PQfinish is called (which is compulsory even after an error, since
4162 * the connection structure must be freed).
4163 */
4166 }
4169 /*
4170 * internal_ping
4171 * Determine if a server is running and if we can connect to it.
4172 *
4173 * The argument is a connection that's been started, but not completed.
4174 */
4175 static PGPing
4177 {
4178 /* Say "no attempt" if we never got to PQconnectPoll */
4182 /* Attempt to complete the connection */
4186 /* Definitely OK if we succeeded */
4190 /*
4191 * Here begins the interesting part of "ping": determine the cause of the
4192 * failure in sufficient detail to decide what to return. We do not want
4193 * to report that the server is not up just because we didn't have a valid
4194 * password, for example. In fact, any sort of authentication request
4195 * implies the server is up. (We need this check since the libpq side of
4196 * things might have pulled the plug on the connection before getting an
4197 * error as such from the postmaster.)
4198 */
4202 /*
4203 * If we failed to get any ERROR response from the postmaster, report
4204 * PQPING_NO_RESPONSE. This result could be somewhat misleading for a
4205 * pre-7.4 server, since it won't send back a SQLSTATE, but those are long
4206 * out of support. Another corner case where the server could return a
4207 * failure without a SQLSTATE is fork failure, but PQPING_NO_RESPONSE
4208 * isn't totally unreasonable for that anyway. We expect that every other
4209 * failure case in a modern server will produce a report with a SQLSTATE.
4210 *
4211 * NOTE: whenever we get around to making libpq generate SQLSTATEs for
4212 * client-side errors, we should either not store those into
4213 * last_sqlstate, or add an extra flag so we can tell client-side errors
4214 * apart from server-side ones.
4215 */
4219 /*
4220 * Report PQPING_REJECT if server says it's not accepting connections.
4221 */
4225 /*
4226 * Any other SQLSTATE can be taken to indicate that the server is up.
4227 * Presumably it didn't like our username, password, or database name; or
4228 * perhaps it had some transient failure, but that should not be taken as
4229 * meaning "it's down".
4230 */
4232 }
4235 /*
4236 * makeEmptyPGconn
4237 * - create a PGconn data structure with (as yet) no interesting data
4238 */
4241 {
4244 #ifdef WIN32
4246 /*
4247 * Make sure socket support is up and running in this process.
4248 *
4249 * Note: the Windows documentation says that we should eventually do a
4250 * matching WSACleanup() call, but experience suggests that that is at
4251 * least as likely to cause problems as fix them. So we don't.
4252 */
4256 {
4257 WSADATA wsaData;
4262 }
4264 /* Forget any earlier error */
4272 /* Zero all pointers and booleans */
4275 /* install default notice hooks */
4295 /*
4296 * We try to send at least 8K at a time, which is the usual size of pipe
4297 * buffers on Unix systems. That way, when we are sending a large amount
4298 * of data, we avoid incurring extra kernel context swaps for partial
4299 * bufferloads. The output buffer is initially made 16K in size, and we
4300 * try to dump it after accumulating 8K.
4301 *
4302 * With the same goal of minimizing context swaps, the input buffer will
4303 * be enlarged anytime it has less than 8K free, so we initially allocate
4304 * twice that.
4305 */
4320 {
4321 /* out of memory already :-( */
4324 }
4327 }
4329 /*
4330 * freePGconn
4331 * - free an idle (closed) PGconn data structure
4332 *
4333 * NOTE: this should not overlap any functionality with closePGconn().
4334 * Clearing/resetting of transient state belongs there; what we do here is
4335 * release data that is to be held for the life of the PGconn structure.
4336 * If a value ought to be cleared/freed during PQreset(), do it there not here.
4337 */
4338 static void
4340 {
4341 /* let any event procs clean up their state data */
4343 {
4344 PGEventConnDestroy evt;
4350 }
4368 {
4371 }
4382 {
4385 }
4401 /* Note that conn->Pfdebug is not ours to close or free */
4412 }
4414 /*
4415 * pqReleaseConnHosts
4416 * - Free the host list in the PGconn.
4417 */
4418 void
4420 {
4422 {
4424 {
4429 {
4433 }
4434 }
4436 }
4437 }
4439 /*
4440 * store_conn_addrinfo
4441 * - copy addrinfo to PGconn object
4442 *
4443 * Copies the addrinfos from addrlist to the PGconn object such that the
4444 * addrinfos can be manipulated by libpq. Returns a positive integer on
4445 * failure, otherwise zero.
4446 */
4447 static int
4449 {
4456 {
4459 }
4463 {
4466 }
4470 {
4477 }
4480 }
4482 /*
4483 * release_conn_addrinfo
4484 * - Free any addrinfo list in the PGconn.
4485 */
4486 static void
4488 {
4490 {
4493 }
4494 }
4496 /*
4497 * sendTerminateConn
4498 * - Send a terminate message to backend.
4499 */
4500 static void
4502 {
4503 /*
4504 * Note that the protocol doesn't allow us to send Terminate messages
4505 * during the startup phase.
4506 */
4508 {
4509 /*
4510 * Try to send "close connection" message to backend. Ignore any
4511 * error.
4512 */
4516 }
4517 }
4519 /*
4520 * closePGconn
4521 * - properly close a connection to the backend
4522 *
4523 * This should reset or release all transient state, but NOT the connection
4524 * parameters. On exit, the PGconn should be in condition to start a fresh
4525 * connection with the same parameters (see PQreset()).
4526 */
4527 static void
4529 {
4530 /*
4531 * If possible, send Terminate message to close the connection politely.
4532 */
4535 /*
4536 * Must reset the blocking status so a possible reconnect will work.
4537 *
4538 * Don't call PQsetnonblocking() because it will fail if it's unable to
4539 * flush the connection.
4540 */
4543 /*
4544 * Close the connection, reset all transient state, flush I/O buffers.
4545 * Note that this includes clearing conn's error state; we're no longer
4546 * interested in any failures associated with the old connection, and we
4547 * want a clean slate for any new connection attempt.
4548 */
4558 /* Reset all state obtained from server, too */
4560 }
4562 /*
4563 * PQfinish: properly close a connection to the backend. Also frees
4564 * the PGconn data structure so it shouldn't be re-used after this.
4565 */
4566 void
4568 {
4570 {
4573 }
4574 }
4576 /*
4577 * PQreset: resets the connection to the backend by closing the
4578 * existing connection and creating a new one.
4579 */
4580 void
4582 {
4584 {
4588 {
4589 /*
4590 * Notify event procs of successful reset.
4591 */
4595 {
4596 PGEventConnReset evt;
4601 }
4602 }
4603 }
4604 }
4607 /*
4608 * PQresetStart:
4609 * resets the connection to the backend
4610 * closes the existing connection and makes a new one
4611 * Returns 1 on success, 0 on failure.
4612 */
4613 int
4615 {
4617 {
4621 }
4624 }
4627 /*
4628 * PQresetPoll:
4629 * resets the connection to the backend
4630 * closes the existing connection and makes a new one
4631 */
4632 PostgresPollingStatusType
4634 {
4636 {
4640 {
4641 /*
4642 * Notify event procs of successful reset.
4643 */
4647 {
4648 PGEventConnReset evt;
4653 }
4654 }
4657 }
4660 }
4662 /*
4663 * pqPacketSend() -- convenience routine to send a message to server.
4664 *
4665 * pack_type: the single-byte message type code. (Pass zero for startup
4666 * packets, which have no message type code.)
4667 *
4668 * buf, buf_len: contents of message. The given length includes only what
4669 * is in buf; the message type and message length fields are added here.
4670 *
4671 * RETURNS: STATUS_ERROR if the write fails, STATUS_OK otherwise.
4672 * SIDE_EFFECTS: may block.
4673 */
4674 int
4677 {
4678 /* Start the message. */
4682 /* Send the message body. */
4686 /* Finish the message. */
4690 /* Flush to ensure backend gets it. */
4695 }
4697 #ifdef USE_LDAP
4700 #define LDAP_DEF_PORT 389
4701 #define PGLDAP_TIMEOUT 2
4707 /*
4708 * ldapServiceLookup
4709 *
4710 * Search the LDAP URL passed as first argument, treat the result as a
4711 * string of connection options that are parsed and added to the array of
4712 * options passed as second argument.
4713 *
4714 * LDAP URLs must conform to RFC 1959 without escape sequences.
4715 * ldap://host:port/dn?attributes?scope?filter?extensions
4716 *
4717 * Returns
4718 * 0 if the lookup was successful,
4719 * 1 if the connection to the LDAP server could be established but
4720 * the search was unsuccessful,
4721 * 2 if a connection could not be established, and
4722 * 3 if a fatal error occurred.
4723 *
4724 * An error message is appended to *errorMessage for return codes 1 and 3.
4725 */
4726 static int
4728 PQExpBuffer errorMessage)
4729 {
4731 scope,
4732 rc,
4733 size,
4734 state,
4735 oldstate,
4736 i;
4737 #ifndef WIN32
4739 #endif
4761 {
4764 }
4766 /*
4767 * Parse URL components, check for correctness. Basically, url has '\0'
4768 * placed at component boundaries and variables are pointed at each
4769 * component.
4770 */
4773 {
4778 }
4780 /* hostname */
4785 /* dn, "distinguished name" */
4788 {
4791 purl);
4794 }
4798 /* attribute */
4800 {
4803 purl);
4806 }
4810 /* scope */
4812 {
4815 purl);
4818 }
4822 /* filter */
4824 {
4827 purl);
4830 }
4836 /* port number? */
4838 {
4846 {
4849 purl);
4852 }
4854 }
4856 /* Allow only one attribute */
4858 {
4861 purl);
4864 }
4866 /* set scope */
4873 else
4874 {
4877 purl);
4880 }
4882 /* initialize LDAP structure */
4884 {
4888 }
4890 /*
4891 * Perform an explicit anonymous bind.
4892 *
4893 * LDAP does not require that an anonymous bind is performed explicitly,
4894 * but we want to distinguish between the case where LDAP bind does not
4895 * succeed within PGLDAP_TIMEOUT seconds (return 2 to continue parsing the
4896 * service control file) and the case where querying the LDAP server fails
4897 * (return 1 to end parsing).
4898 *
4899 * Unfortunately there is no way of setting a timeout that works for both
4900 * Windows and OpenLDAP.
4901 */
4902 #ifdef WIN32
4903 /* the nonstandard ldap_connect function performs an anonymous bind */
4905 {
4906 /* error or timeout in ldap_connect */
4910 }
4912 /* in OpenLDAP, use the LDAP_OPT_NETWORK_TIMEOUT option */
4914 {
4918 }
4920 /* anonymous bind */
4922 {
4923 /* error or network timeout */
4927 }
4929 /* wait some time for the connection to succeed */
4933 {
4934 /* error or timeout */
4940 }
4943 /* reset timeout */
4946 {
4950 }
4953 /* search */
4957 {
4964 }
4966 /* complain if there was not exactly one result */
4968 {
4971 else
4977 }
4979 /* get entry */
4981 {
4982 /* should never happen */
4988 }
4990 /* get values */
4992 {
4998 }
5004 {
5009 }
5011 /* concatenate values into a single string with newline terminators */
5016 {
5021 }
5024 {
5028 }
5034 /* parse result string */
5037 {
5039 {
5042 {
5045 }
5049 {
5052 }
5054 {
5057 optname);
5060 }
5062 {
5065 }
5069 {
5071 }
5073 {
5076 optname);
5079 }
5083 {
5087 }
5089 {
5092 }
5094 {
5097 }
5101 {
5104 }
5108 {
5111 }
5114 else
5121 }
5124 {
5127 {
5129 {
5131 {
5134 {
5138 }
5139 }
5142 }
5143 }
5145 {
5149 }
5152 }
5154 }
5159 {
5163 }
5166 }
5170 /*
5171 * parseServiceInfo: if a service name has been given, look it up and absorb
5172 * connection options from it into *options.
5173 *
5174 * Returns 0 on success, nonzero on failure. On failure, if errorMessage
5175 * isn't null, also store an error message there. (Note: the only reason
5176 * this function and related ones don't dump core on errorMessage == NULL
5177 * is the undocumented fact that appendPQExpBuffer does nothing when passed
5178 * a null PQExpBuffer pointer.)
5179 */
5180 static int
5182 {
5190 /*
5191 * We have to special-case the environment variable PGSERVICE here, since
5192 * this is and should be called before inserting environment defaults for
5193 * other connection options.
5194 */
5198 /* If no service name given, nothing to do */
5202 /*
5203 * Try PGSERVICEFILE if specified, else try ~/.pg_service.conf (if that
5204 * exists).
5205 */
5208 else
5209 {
5217 }
5223 next_file:
5225 /*
5226 * This could be used by any application so we can't use the binary
5227 * location to find our config files.
5228 */
5238 last_file:
5240 {
5243 }
5246 }
5248 static int
5252 PQExpBuffer errorMessage,
5254 {
5257 i;
5266 {
5269 }
5272 {
5275 linenr++;
5278 {
5281 linenr,
5282 serviceFile);
5285 }
5287 /* ignore whitespace at end of line, especially the newline */
5292 /* ignore leading whitespace too */
5294 line++;
5296 /* ignore comments and empty lines */
5300 /* Check for right groupname */
5302 {
5304 {
5305 /* end of desired group reached; return success */
5307 }
5312 else
5314 }
5315 else
5316 {
5318 {
5319 /*
5320 * Finally, we are in the right group and can parse the line
5321 */
5326 #ifdef USE_LDAP
5328 {
5331 /* if rc = 2, go on reading for fallback */
5333 {
5342 }
5343 }
5344 #endif
5349 {
5352 serviceFile,
5353 linenr);
5356 }
5360 {
5363 serviceFile,
5364 linenr);
5367 }
5369 /*
5370 * Set the parameter --- but don't override any previous
5371 * explicit setting.
5372 */
5375 {
5377 {
5381 {
5385 }
5388 }
5389 }
5392 {
5395 serviceFile,
5396 linenr);
5399 }
5400 }
5401 }
5402 }
5404 exit:
5408 }
5411 /*
5412 * PQconninfoParse
5413 *
5414 * Parse a string like PQconnectdb() would do and return the
5415 * resulting connection options array. NULL is returned on failure.
5416 * The result contains only options specified directly in the string,
5417 * not any possible default values.
5418 *
5419 * If errmsg isn't NULL, *errmsg is set to NULL on success, or a malloc'd
5420 * string on failure (use PQfreemem to free it). In out-of-memory conditions
5421 * both *errmsg and the result could be NULL.
5422 *
5423 * NOTE: the returned array is dynamically allocated and should
5424 * be freed when no longer needed via PQconninfoFree().
5425 */
5426 PQconninfoOption *
5428 {
5429 PQExpBufferData errorBuf;
5440 else
5443 }
5445 /*
5446 * Build a working copy of the constant PQconninfoOptions array.
5447 */
5450 {
5455 /*
5456 * Get enough memory for all options in PQconninfoOptions, even if some
5457 * end up being filtered out.
5458 */
5459 options = (PQconninfoOption *) malloc(sizeof(PQconninfoOption) * sizeof(PQconninfoOptions) / sizeof(PQconninfoOptions[0]));
5461 {
5464 }
5468 {
5469 /* Only copy the public part of the struct, not the full internal */
5471 opt_dest++;
5472 }
5476 }
5478 /*
5479 * Connection string parser
5480 *
5481 * Returns a malloc'd PQconninfoOption array, if parsing is successful.
5482 * Otherwise, NULL is returned and an error message is added to errorMessage.
5483 *
5484 * If use_defaults is true, default values are filled in (from a service file,
5485 * environment variables, etc).
5486 */
5490 {
5491 /* Parse as URI if connection string matches URI prefix */
5495 /* Parse as default otherwise */
5497 }
5499 /*
5500 * Checks if connection string starts with either of the valid URI prefix
5501 * designators.
5502 *
5503 * Returns the URI prefix length, 0 if the string doesn't contain a URI prefix.
5504 *
5505 * XXX this is duplicated in psql/common.c.
5506 */
5507 static int
5509 {
5519 }
5521 /*
5522 * Recognized connection string either starts with a valid URI prefix or
5523 * contains a "=" in it.
5524 *
5525 * Must be consistent with parse_connection_string: anything for which this
5526 * returns true should at least look like it's parseable by that routine.
5527 *
5528 * XXX this is duplicated in psql/common.c
5529 */
5530 static bool
5532 {
5534 }
5536 /*
5537 * Subroutine for parse_connection_string
5538 *
5539 * Deal with a string containing key=value pairs.
5540 */
5544 {
5552 /* Make a working copy of PQconninfoOptions */
5557 /* Need a modifiable copy of the input string */
5559 {
5563 }
5567 {
5568 /* Skip blanks before the parameter name */
5570 {
5571 cp++;
5573 }
5575 /* Get the parameter name */
5578 {
5582 {
5585 {
5588 cp++;
5589 }
5591 }
5592 cp++;
5593 }
5595 /* Check that there is a following '=' */
5597 {
5600 pname);
5604 }
5607 /* Skip blanks after the '=' */
5609 {
5612 cp++;
5613 }
5615 /* Get the parameter value */
5619 {
5622 {
5624 {
5627 }
5629 {
5630 cp++;
5633 }
5634 else
5636 }
5638 }
5639 else
5640 {
5642 cp++;
5644 {
5646 {
5651 }
5653 {
5654 cp++;
5658 }
5660 {
5662 cp++;
5664 }
5666 }
5667 }
5669 /*
5670 * Now that we have the name and the value, store the record.
5671 */
5673 {
5677 }
5678 }
5680 /* Done with the modifiable input string */
5683 /*
5684 * Add in defaults if the caller wants that.
5685 */
5687 {
5689 {
5692 }
5693 }
5696 }
5698 /*
5699 * Conninfo array parser routine
5700 *
5701 * If successful, a malloc'd PQconninfoOption array is returned.
5702 * If not successful, NULL is returned and an error message is
5703 * appended to errorMessage.
5704 * Defaults are supplied (from a service file, environment variables, etc)
5705 * for unspecified options, but only if use_defaults is true.
5706 *
5707 * If expand_dbname is non-zero, and the value passed for the first occurrence
5708 * of "dbname" keyword is a connection string (as indicated by
5709 * recognized_connection_string) then parse and process it, overriding any
5710 * previously processed conflicting keywords. Subsequent keywords will take
5711 * precedence, however. In-tree programs generally specify expand_dbname=true,
5712 * so command-line arguments naming a database can use a connection string.
5713 * Some code acquires arbitrary database names from known-literal sources like
5714 * PQdb(), PQconninfoParse() and pg_database.datname. When connecting to such
5715 * a database, in-tree code first wraps the name in a connection string.
5716 */
5721 {
5727 /*
5728 * If expand_dbname is non-zero, check keyword "dbname" to see if val is
5729 * actually a recognized connection string.
5730 */
5732 {
5736 /* first find "dbname" if any */
5738 {
5739 /*
5740 * If value is a connection string, parse it, but do not use
5741 * defaults here -- those get picked up later. We only want to
5742 * override for those parameters actually passed.
5743 */
5745 {
5749 }
5751 }
5753 }
5755 /* Make a working copy of PQconninfoOptions */
5758 {
5761 }
5763 /* Parse the keywords/values arrays */
5766 {
5771 {
5772 /* Search for the param record */
5774 {
5777 }
5779 /* Check for invalid connection option */
5781 {
5786 }
5788 /*
5789 * If we are on the first dbname parameter, and we have a parsed
5790 * connection string, copy those parameters across, overriding any
5791 * existing previous settings.
5792 */
5794 {
5798 {
5800 {
5804 {
5806 {
5810 {
5815 }
5817 }
5818 }
5819 }
5820 }
5822 /*
5823 * Forget the parsed connection string, so that any subsequent
5824 * dbname parameters will not be expanded.
5825 */
5828 }
5829 else
5830 {
5831 /*
5832 * Store the value, overriding previous settings
5833 */
5837 {
5842 }
5843 }
5844 }
5846 }
5849 /*
5850 * Add in defaults if the caller wants that.
5851 */
5853 {
5855 {
5858 }
5859 }
5862 }
5864 /*
5865 * Add the default values for any unspecified options to the connection
5866 * options array.
5867 *
5868 * Defaults are obtained from a service file, environment variables, etc.
5869 *
5870 * Returns true if successful, otherwise false; errorMessage, if supplied,
5871 * is filled in upon failure. Note that failure to locate a default value
5872 * is not an error condition here --- we just leave the option's value as
5873 * NULL.
5874 */
5875 static bool
5877 {
5883 /*
5884 * If there's a service spec, use it to obtain any not-explicitly-given
5885 * parameters. Ignore error if no error message buffer is passed because
5886 * there is no way to pass back the failure message.
5887 */
5891 /*
5892 * Get the fallback resources for parameters not specified in the conninfo
5893 * string nor the service.
5894 */
5896 {
5903 /*
5904 * Try to get the environment variable fallback
5905 */
5907 {
5909 {
5912 {
5916 }
5918 }
5919 }
5921 /*
5922 * Interpret the deprecated PGREQUIRESSL environment variable. Per
5923 * tradition, translate values starting with "1" to sslmode=require,
5924 * and ignore other values. Given both PGREQUIRESSL=1 and PGSSLMODE,
5925 * PGSSLMODE takes precedence; the opposite was true before v9.3.
5926 */
5928 {
5932 {
5935 {
5939 }
5941 }
5943 /*
5944 * sslmode is not specified. Let it be filled in with the compiled
5945 * default for now, but if sslrootcert=system, we'll override the
5946 * default later before returning.
5947 */
5949 }
5951 /*
5952 * No environment variable specified or the variable isn't set - try
5953 * compiled-in default
5954 */
5956 {
5959 {
5963 }
5965 }
5967 /*
5968 * Special handling for "user" option. Note that if pg_fe_getauthname
5969 * fails, we just leave the value as NULL; there's no need for this to
5970 * be an error condition if the caller provides a user name. The only
5971 * reason we do this now at all is so that callers of PQconndefaults
5972 * will see a correct default (barring error, of course).
5973 */
5975 {
5978 }
5979 }
5981 /*
5982 * Special handling for sslrootcert=system with no sslmode explicitly
5983 * defined. In this case we want to strengthen the default sslmode to
5984 * verify-full.
5985 */
5987 {
5989 {
5994 {
5998 }
5999 }
6000 }
6003 }
6005 /*
6006 * Subroutine for parse_connection_string
6007 *
6008 * Deal with a URI connection string.
6009 */
6013 {
6016 /* Make a working copy of PQconninfoOptions */
6022 {
6025 }
6027 /*
6028 * Add in defaults if the caller wants that.
6029 */
6031 {
6033 {
6036 }
6037 }
6040 }
6042 /*
6043 * conninfo_uri_parse_options
6044 * Actual URI parser.
6045 *
6046 * If successful, returns true while the options array is filled with parsed
6047 * options from the URI.
6048 * If not successful, returns false and fills errorMessage accordingly.
6049 *
6050 * Parses the connection URI string in 'uri' according to the URI syntax (RFC
6051 * 3986):
6052 *
6053 * postgresql://[user[:password]@][netloc][:port][/dbname][?param1=value1&...]
6054 *
6055 * where "netloc" is a hostname, an IPv4 address, or an IPv6 address surrounded
6056 * by literal square brackets. As an extension, we also allow multiple
6057 * netloc[:port] specifications, separated by commas:
6058 *
6059 * postgresql://[user[:password]@][netloc][:port][,...][/dbname][?param1=value1&...]
6060 *
6061 * Any of the URI parts might use percent-encoding (%xy).
6062 */
6063 static bool
6065 PQExpBuffer errorMessage)
6066 {
6075 PQExpBufferData hostbuf;
6076 PQExpBufferData portbuf;
6081 {
6084 }
6086 /* need a modifiable copy of the input URI */
6089 {
6092 }
6095 /* Skip the URI prefix */
6098 {
6099 /* Should never happen */
6102 uri);
6104 }
6108 /* Look ahead for possible user credentials designator */
6112 {
6113 /*
6114 * Found username/password designator, so URI should be of the form
6115 * "scheme://user[:password]@[netloc]".
6116 */
6123 /* Save last char and cut off at end of user name */
6133 {
6144 }
6146 /* Advance past end of parsed user name or password token */
6148 }
6149 else
6150 {
6151 /*
6152 * No username/password designator found. Reset to start of URI.
6153 */
6155 }
6157 /*
6158 * There may be multiple netloc[:port] pairs, each separated from the next
6159 * by a comma. When we initially enter this loop, "p" has been
6160 * incremented past optional URI credential information at this point and
6161 * now points at the "netloc" part of the URI. On subsequent loop
6162 * iterations, "p" has been incremented past the comma separator and now
6163 * points at the start of the next "netloc".
6164 */
6166 {
6167 /*
6168 * Look for IPv6 address.
6169 */
6171 {
6176 {
6179 uri);
6181 }
6183 {
6186 uri);
6188 }
6190 /* Cut off the bracket and advance */
6193 /*
6194 * The address may be followed by a port specifier or a slash or a
6195 * query or a separator comma.
6196 */
6198 {
6203 }
6204 }
6205 else
6206 {
6207 /* not an IPv6 address: DNS-named or IPv4 netloc */
6210 /*
6211 * Look for port specifier (colon) or end of host specifier
6212 * (slash) or query (question mark) or host separator (comma).
6213 */
6216 }
6218 /* Save the hostname terminator before we null it */
6225 {
6235 }
6242 }
6244 /* Save final values for host and port. */
6257 {
6260 /* Look for query parameters */
6267 /*
6268 * Avoid setting dbname to an empty string, as it forces the default
6269 * value (username) and ignores $PGDATABASE, as opposed to not setting
6270 * it at all.
6271 */
6276 }
6279 {
6284 }
6286 /* everything parsed okay */
6289 cleanup:
6294 }
6296 /*
6297 * Connection URI parameters parser routine
6298 *
6299 * If successful, returns true while connOptions is filled with parsed
6300 * parameters. Otherwise, returns false and fills errorMessage appropriately.
6301 *
6302 * Destructively modifies 'params' buffer.
6303 */
6304 static bool
6307 PQExpBuffer errorMessage)
6308 {
6310 {
6317 /*
6318 * Scan the params string for '=' and '&', marking the end of keyword
6319 * and value respectively.
6320 */
6322 {
6324 {
6325 /* Was there '=' already? */
6327 {
6330 keyword);
6332 }
6333 /* Cut off keyword, advance to value */
6336 }
6338 {
6339 /*
6340 * If not at the end, cut off value and advance; leave p
6341 * pointing to start of the next parameter, if any.
6342 */
6345 /* Was there '=' at all? */
6347 {
6350 keyword);
6352 }
6353 /* Got keyword and value, go process them. */
6355 }
6356 else
6358 }
6362 {
6363 /* conninfo_uri_decode already set an error message */
6365 }
6368 {
6369 /* conninfo_uri_decode already set an error message */
6372 }
6375 /*
6376 * Special keyword handling for improved JDBC compatibility.
6377 */
6380 {
6387 }
6389 /*
6390 * Store the value if the corresponding option exists; ignore
6391 * otherwise. At this point both keyword and value are not
6392 * URI-encoded.
6393 */
6397 {
6398 /* Insert generic message if conninfo_storeval didn't give one. */
6402 keyword);
6403 /* And fail. */
6405 {
6408 }
6410 }
6413 {
6416 }
6418 /* Proceed to next key=value pair, if any */
6420 }
6423 }
6425 /*
6426 * Connection URI decoder routine
6427 *
6428 * If successful, returns the malloc'd decoded string.
6429 * If not successful, returns NULL and fills errorMessage accordingly.
6430 *
6431 * The string is decoded by replacing any percent-encoded tokens with
6432 * corresponding characters, while preserving any non-encoded characters. A
6433 * percent-encoded token is a character triplet: a percent sign, followed by a
6434 * pair of hexadecimal digits (0-9A-F), where lower- and upper-case letters are
6435 * treated identically.
6436 */
6439 {
6446 {
6449 }
6453 {
6455 {
6456 /* copy and check for NUL terminator */
6459 }
6460 else
6461 {
6468 /*
6469 * Possible EOL will be caught by the first call to
6470 * get_hexdigit(), so we never dereference an invalid q pointer.
6471 */
6473 {
6476 str);
6479 }
6483 {
6486 str);
6489 }
6491 }
6492 }
6495 }
6497 /*
6498 * Convert hexadecimal digit character to its integer value.
6499 *
6500 * If successful, returns true and value is filled with digit's base 16 value.
6501 * If not successful, returns false.
6502 *
6503 * Lower- and upper-case letters in the range A-F are treated identically.
6504 */
6505 static bool
6507 {
6514 else
6518 }
6520 /*
6521 * Find an option value corresponding to the keyword in the connOptions array.
6522 *
6523 * If successful, returns a pointer to the corresponding option's value.
6524 * If not successful, returns NULL.
6525 */
6529 {
6535 }
6537 /*
6538 * Store a (new) value for an option corresponding to the keyword in
6539 * connOptions array.
6540 *
6541 * If uri_decode is true, the value is URI-decoded. The keyword is always
6542 * assumed to be non URI-encoded.
6543 *
6544 * If successful, returns a pointer to the corresponding PQconninfoOption,
6545 * which value is replaced with a strdup'd copy of the passed value string.
6546 * The existing value for the option is free'd before replacing, if any.
6547 *
6548 * If not successful, returns NULL and fills errorMessage accordingly.
6549 * However, if the reason of failure is an invalid keyword being passed and
6550 * ignoreMissing is true, errorMessage will be left untouched.
6551 */
6557 {
6561 /*
6562 * For backwards compatibility, requiressl=1 gets translated to
6563 * sslmode=require, and requiressl=0 gets translated to sslmode=prefer
6564 * (which is the default for sslmode).
6565 */
6567 {
6571 else
6573 }
6577 {
6581 keyword);
6583 }
6586 {
6589 /* conninfo_uri_decode already set an error message */
6591 }
6592 else
6593 {
6596 {
6599 }
6600 }
6606 }
6608 /*
6609 * Find a PQconninfoOption option corresponding to the keyword in the
6610 * connOptions array.
6611 *
6612 * If successful, returns a pointer to the corresponding PQconninfoOption
6613 * structure.
6614 * If not successful, returns NULL.
6615 */
6618 {
6622 {
6625 }
6628 }
6631 /*
6632 * Return the connection options used for the connection
6633 */
6634 PQconninfoOption *
6636 {
6637 PQExpBufferData errorBuf;
6643 /*
6644 * We don't actually report any errors here, but callees want a buffer,
6645 * and we prefer not to trash the conn's errorMessage.
6646 */
6654 {
6658 {
6669 }
6670 }
6675 }
6678 void
6680 {
6687 }
6690 /* =========== accessor functions for PGconn ========= */
6693 {
6697 }
6701 {
6705 }
6709 {
6718 /* Historically we've returned "" not NULL for no password specified */
6722 }
6726 {
6731 {
6732 /*
6733 * Return the verbatim host value provided by user, or hostaddr in its
6734 * lack.
6735 */
6742 }
6745 }
6749 {
6753 /* Return the parsed IP address */
6758 }
6762 {
6770 }
6772 /*
6773 * No longer does anything, but the function remains for API backwards
6774 * compatibility.
6775 */
6778 {
6782 }
6786 {
6790 }
6792 ConnStatusType
6794 {
6798 }
6800 PGTransactionStatusType
6802 {
6808 }
6812 {
6818 {
6821 }
6823 }
6825 int
6827 {
6833 }
6835 int
6837 {
6843 }
6847 {
6851 /*
6852 * The errorMessage buffer might be marked "broken" due to having
6853 * previously failed to allocate enough memory for the message. In that
6854 * case, tell the application we ran out of memory.
6855 */
6860 }
6862 /*
6863 * In Windows, socket values are unsigned, and an invalid socket value
6864 * (INVALID_SOCKET) is ~0, which equals -1 in comparisons (with no compiler
6865 * warning). Ideally we would return an unsigned value for PQsocket() on
6866 * Windows, but that would cause the function's return value to differ from
6867 * Unix, so we just return -1 for invalid sockets.
6868 * http://msdn.microsoft.com/en-us/library/windows/desktop/cc507522%28v=vs.85%29.aspx
6869 * http://stackoverflow.com/questions/10817252/why-is-invalid-socket-defined-as-0-in-winsock2-h-c
6870 */
6871 int
6873 {
6877 }
6879 int
6881 {
6885 }
6887 PGpipelineStatus
6889 {
6894 }
6896 int
6898 {
6907 else
6909 }
6911 int
6913 {
6918 else
6920 }
6922 int
6924 {
6929 else
6931 }
6933 int
6935 {
6939 }
6941 int
6943 {
6955 /* Resolve special "auto" value from the locale */
6959 /* check query buffer overflow */
6963 /* ok, now send a query */
6971 else
6972 {
6973 /*
6974 * We rely on the backend to report the parameter value, and we'll
6975 * change state at that time.
6976 */
6978 }
6981 }
6983 PGVerbosity
6985 {
6986 PGVerbosity old;
6993 }
6995 PGContextVisibility
6997 {
6998 PGContextVisibility old;
7005 }
7007 PQnoticeReceiver
7009 {
7010 PQnoticeReceiver old;
7017 {
7020 }
7022 }
7024 PQnoticeProcessor
7026 {
7027 PQnoticeProcessor old;
7034 {
7037 }
7039 }
7041 /*
7042 * The default notice message receiver just gets the standard notice text
7043 * and sends it to the notice processor. This two-level setup exists
7044 * mostly for backwards compatibility; perhaps we should deprecate use of
7045 * PQsetNoticeProcessor?
7046 */
7047 static void
7049 {
7054 }
7056 /*
7057 * The default notice message processor just prints the
7058 * message on stderr. Applications can override this if they
7059 * want the messages to go elsewhere (a window, for example).
7060 * Note that simply discarding notices is probably a bad idea.
7061 */
7062 static void
7064 {
7066 /* Note: we expect the supplied string to end with a newline already. */
7068 }
7070 /*
7071 * returns a pointer to the next token or NULL if the current
7072 * token doesn't match
7073 */
7076 {
7088 {
7090 {
7091 tbuf++;
7093 }
7100 {
7101 tbuf++;
7102 ttok++;
7103 }
7104 else
7106 }
7108 }
7110 /* Get a password from the password file. Return value is malloc'd. */
7114 {
7117 PQExpBufferData buf;
7125 /* 'localhost' matches pghost of '' or the default socket directory */
7130 /*
7131 * We should probably use canonicalize_path(), but then we have to
7132 * bring path.c into libpq, and it doesn't seem worth it.
7133 */
7140 /* If password file cannot be opened, ignore it. */
7144 #ifndef WIN32
7146 {
7149 pgpassfile);
7151 }
7153 /* If password file is insecure, alert the user and ignore it. */
7155 {
7157 libpq_gettext("WARNING: password file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n"),
7158 pgpassfile);
7160 }
7161 #else
7163 /*
7164 * On Win32, the directory is protected, so we don't have to check the
7165 * file.
7166 */
7167 #endif
7173 /* Use an expansible buffer to accommodate any reasonable line length */
7177 {
7178 /* Make sure there's a reasonable amount of room in the buffer */
7182 /* Read some data, appending it to what we already have */
7187 /* If we don't yet have a whole line, loop around to read more */
7191 /* ignore comments */
7193 {
7197 /* strip trailing newline and carriage return */
7205 {
7206 /* Found a match. */
7218 {
7219 /* Out of memory. XXX: an error message would be nice. */
7221 }
7223 /* De-escape password. */
7225 {
7229 }
7233 }
7234 }
7236 /* No match, reset buffer to prepare for next line. */
7238 }
7244 }
7247 /*
7248 * If the connection failed due to bad password, we should mention
7249 * if we got the password from the pgpassfile.
7250 */
7251 static void
7253 {
7254 /* If it was 'invalid authorization', add pgpassfile mention */
7255 /* only works with >= 9.0 servers */
7259 {
7261 PG_DIAG_SQLSTATE);
7266 }
7267 }
7269 /*
7270 * Check if the SSL protocol value given in input is valid or not.
7271 * This is used as a sanity check routine for the connection parameters
7272 * ssl_min_protocol_version and ssl_max_protocol_version.
7273 */
7274 static bool
7276 {
7277 /*
7278 * An empty string and a NULL value are considered valid as it is
7279 * equivalent to ignoring the parameter.
7280 */
7290 /* anything else is wrong */
7292 }
7295 /*
7296 * Ensure that the SSL protocol range given in input is correct. The check
7297 * is performed on the input string to keep it TLS backend agnostic. Input
7298 * to this function is expected verified with sslVerifyProtocolVersion().
7299 */
7300 static bool
7302 {
7306 /* If at least one of the bounds is not set, the range is valid */
7310 /*
7311 * If the minimum version is the lowest one we accept, then all options
7312 * for the maximum are valid.
7313 */
7317 /*
7318 * The minimum bound is valid, and cannot be TLSv1, so using TLSv1 for the
7319 * maximum is incorrect.
7320 */
7324 /*
7325 * At this point we know that we have a mix of TLSv1.1 through 1.3
7326 * versions.
7327 */
7332 }
7335 /*
7336 * Obtain user's home directory, return in given buffer
7337 *
7338 * On Unix, this actually returns the user's home directory. On Windows
7339 * it returns the PostgreSQL-specific application data folder.
7340 *
7341 * This is essentially the same as get_home_path(), but we don't use that
7342 * because we don't want to pull path.c into libpq (it pollutes application
7343 * namespace).
7344 *
7345 * Returns true on success, false on failure to obtain the directory name.
7346 *
7347 * CAUTION: although in most situations failure is unexpected, there are users
7348 * who like to run applications in a home-directory-less environment. On
7349 * failure, you almost certainly DO NOT want to report an error. Just act as
7350 * though whatever file you were hoping to find in the home directory isn't
7351 * there (which it isn't).
7352 */
7353 bool
7355 {
7356 #ifndef WIN32
7364 #else
7372 #endif
7373 }
7375 /*
7376 * Parse and try to interpret "value" as an integer value, and if successful,
7377 * store it in *result, complaining if there is any trailing garbage or an
7378 * overflow. This allows any number of leading and trailing whitespaces.
7379 */
7380 bool
7383 {
7391 /* strtol(3) skips leading whitespaces */
7395 /*
7396 * If no progress was done during the parsing or an error happened, fail.
7397 * This tests properly for overflows of the result.
7398 */
7402 /*
7403 * Skip any trailing whitespace; if anything but whitespace remains before
7404 * the terminating character, fail
7405 */
7407 end++;
7415 error:
7419 }
7421 /*
7422 * To keep the API consistent, the locking stubs are always provided, even
7423 * if they are not required.
7424 *
7425 * Since we neglected to provide any error-return convention in the
7426 * pgthreadlock_t API, we can't do much except Assert upon failure of any
7427 * mutex primitive. Fortunately, such failures appear to be nonexistent in
7428 * the field.
7429 */
7431 static void
7433 {
7434 #ifndef WIN32
7436 #else
7441 {
7445 {
7448 }
7450 }
7451 #endif
7453 {
7456 }
7457 else
7458 {
7461 }
7462 }
7464 pgthreadlock_t
7466 {
7471 else
7475 }