47 #include <openssl/conf.h>
48 #include <openssl/dh.h>
49 #ifndef OPENSSL_NO_ECDH
50 #include <openssl/ec.h>
52 #include <openssl/x509v3.h>
68 static int verify_cb(
int ok, X509_STORE_CTX *ctx);
71 const unsigned char **out,
72 unsigned char *outlen,
73 const unsigned char *in,
101 int ssl_ver_min = -1;
102 int ssl_ver_max = -1;
107 #ifdef HAVE_OPENSSL_INIT_SSL
108 OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, NULL);
110 OPENSSL_config(NULL);
112 SSL_load_error_strings();
127 context = SSL_CTX_new(SSLv23_method());
131 (
errmsg(
"could not create SSL context: %s",
140 SSL_CTX_set_mode(
context, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
145 (*openssl_tls_init_hook) (
context, isServerStart);
156 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
157 errmsg(
"could not load server certificate file \"%s\": %s",
170 if (SSL_CTX_use_PrivateKey_file(
context,
172 SSL_FILETYPE_PEM) != 1)
176 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
177 errmsg(
"private key file \"%s\" cannot be reloaded because it requires a passphrase",
181 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
182 errmsg(
"could not load private key file \"%s\": %s",
187 if (SSL_CTX_check_private_key(
context) != 1)
190 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
191 errmsg(
"check of private key failed: %s",
200 if (ssl_ver_min == -1)
204 (
errmsg(
"\"%s\" setting \"%s\" not supported by this build",
205 "ssl_min_protocol_version",
214 (
errmsg(
"could not set minimum SSL protocol version")));
223 if (ssl_ver_max == -1)
227 (
errmsg(
"\"%s\" setting \"%s\" not supported by this build",
228 "ssl_max_protocol_version",
237 (
errmsg(
"could not set maximum SSL protocol version")));
250 if (ssl_ver_min > ssl_ver_max)
253 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
254 errmsg(
"could not set SSL protocol version range"),
255 errdetail(
"\"%s\" cannot be higher than \"%s\"",
256 "ssl_min_protocol_version",
257 "ssl_max_protocol_version")));
271 #ifdef HAVE_SSL_CTX_SET_NUM_TICKETS
272 SSL_CTX_set_num_tickets(
context, 0);
274 SSL_CTX_set_options(
context, SSL_OP_NO_TICKET);
278 SSL_CTX_set_session_cache_mode(
context, SSL_SESS_CACHE_OFF);
281 SSL_CTX_set_options(
context, SSL_OP_NO_COMPRESSION);
291 #ifdef SSL_OP_NO_RENEGOTIATION
292 SSL_CTX_set_options(
context, SSL_OP_NO_RENEGOTIATION);
294 #ifdef SSL_OP_NO_CLIENT_RENEGOTIATION
295 SSL_CTX_set_options(
context, SSL_OP_NO_CLIENT_RENEGOTIATION);
308 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
309 errmsg(
"could not set the cipher list (no valid ciphers available)")));
315 SSL_CTX_set_options(
context, SSL_OP_CIPHER_SERVER_PREFERENCE);
322 STACK_OF(X509_NAME) * root_cert_list;
325 (root_cert_list = SSL_load_client_CA_file(
ssl_ca_file)) == NULL)
328 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
329 errmsg(
"could not load root certificate file \"%s\": %s",
341 SSL_CTX_set_client_CA_list(
context, root_cert_list);
350 SSL_VERIFY_CLIENT_ONCE),
361 X509_STORE *cvstore = SSL_CTX_get_cert_store(
context);
366 if (X509_STORE_load_locations(cvstore,
371 X509_STORE_set_flags(cvstore,
372 X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
377 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
378 errmsg(
"could not load SSL certificate revocation list file \"%s\": %s",
385 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
386 errmsg(
"could not load SSL certificate revocation list directory \"%s\": %s",
393 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
394 errmsg(
"could not load SSL certificate revocation list file \"%s\" or directory \"%s\": %s",
414 ssl_loaded_verify_locations =
true;
416 ssl_loaded_verify_locations =
false;
433 ssl_loaded_verify_locations =
false;
443 bool give_proto_hint;
451 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
452 errmsg(
"could not initialize SSL connection: SSL context not set up")));
465 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
466 errmsg(
"could not initialize SSL connection: %s",
473 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
474 errmsg(
"could not set SSL socket: %s",
478 port->ssl_in_use =
true;
492 r = SSL_accept(
port->ssl);
495 err = SSL_get_error(
port->ssl, r);
505 ecode = ERR_get_error();
508 case SSL_ERROR_WANT_READ:
509 case SSL_ERROR_WANT_WRITE:
518 if (
err == SSL_ERROR_WANT_READ)
524 WAIT_EVENT_SSL_OPEN_SERVER);
526 case SSL_ERROR_SYSCALL:
527 if (r < 0 && errno != 0)
530 errmsg(
"could not accept SSL connection: %m")));
533 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
534 errmsg(
"could not accept SSL connection: EOF detected")));
537 switch (ERR_GET_REASON(ecode))
552 case SSL_R_NO_PROTOCOLS_AVAILABLE:
553 case SSL_R_UNSUPPORTED_PROTOCOL:
554 case SSL_R_BAD_PROTOCOL_VERSION_NUMBER:
555 case SSL_R_UNKNOWN_PROTOCOL:
556 case SSL_R_UNKNOWN_SSL_VERSION:
557 case SSL_R_UNSUPPORTED_SSL_VERSION:
558 case SSL_R_WRONG_SSL_VERSION:
559 case SSL_R_WRONG_VERSION_NUMBER:
560 case SSL_R_TLSV1_ALERT_PROTOCOL_VERSION:
561 #ifdef SSL_R_VERSION_TOO_HIGH
562 case SSL_R_VERSION_TOO_HIGH:
564 #ifdef SSL_R_VERSION_TOO_LOW
565 case SSL_R_VERSION_TOO_LOW:
567 give_proto_hint =
true;
570 give_proto_hint =
false;
574 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
575 errmsg(
"could not accept SSL connection: %s",
579 errhint(
"This may indicate that the client does not support any SSL protocol version between %s and %s.",
582 MIN_OPENSSL_TLS_VERSION,
585 MAX_OPENSSL_TLS_VERSION) : 0));
588 case SSL_ERROR_ZERO_RETURN:
590 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
591 errmsg(
"could not accept SSL connection: EOF detected")));
595 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
596 errmsg(
"unrecognized SSL error code: %d",
604 port->alpn_used =
false;
606 const unsigned char *selected;
609 SSL_get0_alpn_selected(
port->ssl, &selected, &
len);
612 if (selected != NULL)
617 port->alpn_used =
true;
623 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
624 errmsg(
"received SSL connection request with unexpected ALPN protocol")));
630 port->peer = SSL_get_peer_certificate(
port->ssl);
633 port->peer_cn = NULL;
634 port->peer_dn = NULL;
635 port->peer_cert_valid =
false;
636 if (
port->peer != NULL)
639 X509_NAME *x509name = X509_get_subject_name(
port->peer);
642 BUF_MEM *bio_buf = NULL;
644 len = X509_NAME_get_text_by_NID(x509name, NID_commonName, NULL, 0);
650 r = X509_NAME_get_text_by_NID(x509name, NID_commonName, peer_cn,
664 if (
len != strlen(peer_cn))
667 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
668 errmsg(
"SSL certificate's common name contains embedded null")));
673 port->peer_cn = peer_cn;
676 bio = BIO_new(BIO_s_mem());
679 if (
port->peer_cn != NULL)
682 port->peer_cn = NULL;
694 if (X509_NAME_print_ex(bio, x509name, 0, XN_FLAG_RFC2253) == -1 ||
695 BIO_get_mem_ptr(bio, &bio_buf) <= 0)
698 if (
port->peer_cn != NULL)
701 port->peer_cn = NULL;
706 memcpy(peer_dn, bio_buf->data, bio_buf->length);
707 len = bio_buf->length;
710 if (
len != strlen(peer_dn))
713 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
714 errmsg(
"SSL certificate's distinguished name contains embedded null")));
716 if (
port->peer_cn != NULL)
719 port->peer_cn = NULL;
724 port->peer_dn = peer_dn;
726 port->peer_cert_valid =
true;
737 SSL_shutdown(
port->ssl);
740 port->ssl_in_use =
false;
745 X509_free(
port->peer);
752 port->peer_cn = NULL;
758 port->peer_dn = NULL;
771 n = SSL_read(
port->ssl, ptr,
len);
772 err = SSL_get_error(
port->ssl, n);
773 ecode = (
err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
779 case SSL_ERROR_WANT_READ:
784 case SSL_ERROR_WANT_WRITE:
789 case SSL_ERROR_SYSCALL:
791 if (n != -1 || errno == 0)
799 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
804 case SSL_ERROR_ZERO_RETURN:
810 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
811 errmsg(
"unrecognized SSL error code: %d",
830 n = SSL_write(
port->ssl, ptr,
len);
831 err = SSL_get_error(
port->ssl, n);
832 ecode = (
err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
838 case SSL_ERROR_WANT_READ:
843 case SSL_ERROR_WANT_WRITE:
848 case SSL_ERROR_SYSCALL:
856 if (n != -1 || errno == 0)
864 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
869 case SSL_ERROR_ZERO_RETURN:
880 (
errcode(ERRCODE_PROTOCOL_VIOLATION),
881 errmsg(
"unrecognized SSL error code: %d",
917 BIO_clear_retry_flags(h);
923 BIO_set_retry_read(h);
937 BIO_clear_retry_flags(h);
943 BIO_set_retry_write(h);
955 BIO_METHOD *biom = (BIO_METHOD *) BIO_s_socket();
956 #ifdef HAVE_BIO_METH_NEW
959 my_bio_index = BIO_get_new_index();
960 if (my_bio_index == -1)
962 my_bio_index |= (BIO_TYPE_DESCRIPTOR | BIO_TYPE_SOURCE_SINK);
963 my_bio_methods = BIO_meth_new(my_bio_index,
"PostgreSQL backend socket");
971 !BIO_meth_set_create(
my_bio_methods, BIO_meth_get_create(biom)) ||
972 !BIO_meth_set_destroy(
my_bio_methods, BIO_meth_get_destroy(biom)) ||
973 !BIO_meth_set_callback_ctrl(
my_bio_methods, BIO_meth_get_callback_ctrl(biom)))
997 BIO_METHOD *bio_method;
1000 if (bio_method == NULL)
1002 SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
1005 bio = BIO_new(bio_method);
1009 SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
1012 BIO_set_app_data(bio,
port);
1014 BIO_set_fd(bio,
fd, BIO_NOCLOSE);
1015 SSL_set_bio(
port->ssl, bio, bio);
1040 errmsg(
"could not open DH parameters file \"%s\": %m",
1045 dh = PEM_read_DHparams(fp, NULL, NULL, NULL);
1051 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1052 errmsg(
"could not load DH parameters file: %s",
1058 if (DH_check(dh, &codes) == 0)
1061 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1062 errmsg(
"invalid DH parameters: %s",
1067 if (codes & DH_CHECK_P_NOT_PRIME)
1070 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1071 errmsg(
"invalid DH parameters: p is not prime")));
1075 if ((codes & DH_NOT_SUITABLE_GENERATOR) &&
1076 (codes & DH_CHECK_P_NOT_SAFE_PRIME))
1079 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1080 errmsg(
"invalid DH parameters: neither suitable generator or safe prime")));
1104 dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
1121 const char *prompt =
"Enter PEM pass phrase:";
1157 size_t namelen = strlen(
name);
1158 char *truncated =
name;
1175 truncated[0] = truncated[1] = truncated[2] =
'.';
1199 const char *errstring;
1210 depth = X509_STORE_CTX_get_error_depth(ctx);
1211 errcode = X509_STORE_CTX_get_error(ctx);
1212 errstring = X509_verify_cert_error_string(
errcode);
1216 _(
"Client certificate verification failed at depth %d: %s."),
1219 cert = X509_STORE_CTX_get_current_cert(ctx);
1247 sn = X509_get_serialNumber(cert);
1248 b = ASN1_INTEGER_to_BN(sn, NULL);
1249 serialno = BN_bn2dec(
b);
1253 _(
"Failed certificate data (unverified): subject \"%s\", serial number %s, issuer \"%s\"."),
1254 sub_prepared, serialno ? serialno :
_(
"unknown"),
1258 OPENSSL_free(serialno);
1259 pfree(iss_prepared);
1260 pfree(sub_prepared);
1278 desc = SSL_state_string_long(ssl);
1282 case SSL_CB_HANDSHAKE_START:
1286 case SSL_CB_HANDSHAKE_DONE:
1290 case SSL_CB_ACCEPT_LOOP:
1294 case SSL_CB_ACCEPT_EXIT:
1298 case SSL_CB_CONNECT_LOOP:
1302 case SSL_CB_CONNECT_EXIT:
1306 case SSL_CB_READ_ALERT:
1310 case SSL_CB_WRITE_ALERT:
1326 const unsigned char **out,
1327 unsigned char *outlen,
1328 const unsigned char *in,
1339 Assert(userdata != NULL);
1344 retval = SSL_select_next_proto((
unsigned char **) out, outlen,
1347 if (*out == NULL || *outlen >
sizeof(
alpn_protos) || *outlen <= 0)
1348 return SSL_TLSEXT_ERR_NOACK;
1350 if (retval == OPENSSL_NPN_NEGOTIATED)
1351 return SSL_TLSEXT_ERR_OK;
1358 return SSL_TLSEXT_ERR_ALERT_FATAL;
1381 SSL_CTX_set_options(
context, SSL_OP_SINGLE_DH_USE);
1390 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1391 errmsg(
"DH: could not load DH parameters")));
1395 if (SSL_CTX_set_tmp_dh(
context, dh) != 1)
1398 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1399 errmsg(
"DH: could not set DH parameters: %s",
1417 #ifndef OPENSSL_NO_ECDH
1425 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1430 ecdh = EC_KEY_new_by_curve_name(nid);
1434 (
errcode(ERRCODE_CONFIG_FILE_ERROR),
1435 errmsg(
"ECDH: could not create key")));
1439 SSL_CTX_set_options(
context, SSL_OP_SINGLE_ECDH_USE);
1440 SSL_CTX_set_tmp_ecdh(
context, ecdh);
1459 const char *errreason;
1460 static char errbuf[36];
1463 return _(
"no SSL error reported");
1464 errreason = ERR_reason_error_string(ecode);
1465 if (errreason != NULL)
1474 #ifdef ERR_SYSTEM_ERROR
1475 if (ERR_SYSTEM_ERROR(ecode))
1476 return strerror(ERR_GET_REASON(ecode));
1480 snprintf(errbuf,
sizeof(errbuf),
_(
"SSL error code %lu"), ecode);
1491 SSL_get_cipher_bits(
port->ssl, &bits);
1502 return SSL_get_version(
port->ssl);
1511 return SSL_get_cipher(
port->ssl);
1539 ASN1_INTEGER *serial;
1543 serial = X509_get_serialNumber(
port->peer);
1544 b = ASN1_INTEGER_to_BN(serial, NULL);
1560 const EVP_MD *algo_type = NULL;
1561 unsigned char hash[EVP_MAX_MD_SIZE];
1562 unsigned int hash_size;
1566 server_cert = SSL_get_certificate(
port->ssl);
1567 if (server_cert == NULL)
1575 #if HAVE_X509_GET_SIGNATURE_INFO
1576 if (!X509_get_signature_info(server_cert, &algo_nid, NULL, NULL, NULL))
1578 if (!OBJ_find_sigid_algs(X509_get_signature_nid(server_cert),
1581 elog(
ERROR,
"could not determine server certificate signature algorithm");
1593 algo_type = EVP_sha256();
1596 algo_type = EVP_get_digestbynid(algo_nid);
1597 if (algo_type == NULL)
1598 elog(
ERROR,
"could not find digest for NID %s",
1599 OBJ_nid2sn(algo_nid));
1604 if (!X509_digest(server_cert, algo_type,
hash, &hash_size))
1605 elog(
ERROR,
"could not generate server certificate hash");
1607 cert_hash =
palloc(hash_size);
1608 memcpy(cert_hash,
hash, hash_size);
1621 BIO *membuf = BIO_new(BIO_s_mem());
1624 count = X509_NAME_entry_count(
name);
1627 const char *field_name;
1636 (
errcode(ERRCODE_OUT_OF_MEMORY),
1637 errmsg(
"could not create BIO")));
1639 (void) BIO_set_close(membuf, BIO_CLOSE);
1640 for (
i = 0;
i < count;
i++)
1642 e = X509_NAME_get_entry(
name,
i);
1643 nid = OBJ_obj2nid(X509_NAME_ENTRY_get_object(
e));
1644 if (nid == NID_undef)
1646 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1647 errmsg(
"could not get NID for ASN1_OBJECT object")));
1648 v = X509_NAME_ENTRY_get_data(
e);
1649 field_name = OBJ_nid2sn(nid);
1650 if (field_name == NULL)
1651 field_name = OBJ_nid2ln(nid);
1652 if (field_name == NULL)
1654 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1655 errmsg(
"could not convert NID %d to an ASN1_OBJECT structure", nid)));
1656 BIO_printf(membuf,
"/%s=", field_name);
1657 ASN1_STRING_print_ex(membuf, v,
1658 ((ASN1_STRFLGS_RFC2253 & ~ASN1_STRFLGS_ESC_MSB)
1659 | ASN1_STRFLGS_UTF8_CONVERT));
1664 BIO_write(membuf, &nullterm, 1);
1665 size = BIO_get_mem_data(membuf, &sp);
1671 if (BIO_free(membuf) != 1)
1672 elog(
ERROR,
"could not free OpenSSL BIO structure");
1699 return TLS1_VERSION;
1701 #ifdef TLS1_1_VERSION
1702 return TLS1_1_VERSION;
1707 #ifdef TLS1_2_VERSION
1708 return TLS1_2_VERSION;
1713 #ifdef TLS1_3_VERSION
1714 return TLS1_3_VERSION;
1743 return "(unrecognized)";
bool check_ssl_key_file_permissions(const char *ssl_key_file, bool isServerStart)
int run_ssl_passphrase_command(const char *prompt, bool is_server_start, char *buf, int size)
static const char * ssl_protocol_version_to_string(int v)
static const char * cert_errdetail
const char * be_tls_get_version(Port *port)
static void info_cb(const SSL *ssl, int type, int args)
static const char * SSLerrmessage(unsigned long ecode)
void be_tls_destroy(void)
int be_tls_init(bool isServerStart)
openssl_tls_init_hook_typ openssl_tls_init_hook
int be_tls_get_cipher_bits(Port *port)
int be_tls_open_server(Port *port)
char * be_tls_get_certificate_hash(Port *port, size_t *len)
static int alpn_cb(SSL *ssl, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *userdata)
static DH * load_dh_buffer(const char *buffer, size_t len)
static BIO_METHOD * my_bio_methods
static int dummy_ssl_passwd_cb(char *buf, int size, int rwflag, void *userdata)
static int my_SSL_set_fd(Port *port, int fd)
static void default_openssl_tls_init(SSL_CTX *context, bool isServerStart)
static char * prepare_cert_name(char *name)
void be_tls_get_peer_serial(Port *port, char *ptr, size_t len)
static int ssl_protocol_version_to_openssl(int v)
static BIO_METHOD * my_BIO_s_socket(void)
static bool initialize_dh(SSL_CTX *context, bool isServerStart)
void be_tls_close(Port *port)
void be_tls_get_peer_issuer_name(Port *port, char *ptr, size_t len)
ssize_t be_tls_read(Port *port, void *ptr, size_t len, int *waitfor)
static char * X509_NAME_to_cstring(X509_NAME *name)
ssize_t be_tls_write(Port *port, void *ptr, size_t len, int *waitfor)
static int ssl_external_passwd_cb(char *buf, int size, int rwflag, void *userdata)
static SSL_CTX * SSL_context
static bool ssl_is_server_start
const char * be_tls_get_cipher(Port *port)
static bool SSL_initialized
static int verify_cb(int ok, X509_STORE_CTX *ctx)
static bool initialize_ecdh(SSL_CTX *context, bool isServerStart)
static bool dummy_ssl_passwd_cb_called
static DH * load_dh_file(char *filename, bool isServerStart)
static const unsigned char alpn_protos[]
static int my_sock_write(BIO *h, const char *buf, int size)
void be_tls_get_peer_subject_name(Port *port, char *ptr, size_t len)
static int my_sock_read(BIO *h, char *buf, int size)
char * ssl_dh_params_file
int ssl_min_protocol_version
ssize_t secure_raw_read(Port *port, void *ptr, size_t len)
bool SSLPreferServerCiphers
int ssl_max_protocol_version
char * ssl_passphrase_command
bool ssl_passphrase_command_supports_reload
ssize_t secure_raw_write(Port *port, const void *ptr, size_t len)
#define unconstify(underlying_type, expr)
#define Assert(condition)
static void PGresult * res
int errcode_for_socket_access(void)
int errmsg_internal(const char *fmt,...)
int errdetail_internal(const char *fmt,...)
int errcode_for_file_access(void)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
void err(int eval, const char *fmt,...)
FILE * AllocateFile(const char *name, const char *mode)
const char * GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
int WaitLatchOrSocket(Latch *latch, int wakeEvents, pgsocket sock, long timeout, uint32 wait_event_info)
#define WL_SOCKET_READABLE
#define WL_EXIT_ON_PM_DEATH
#define WL_SOCKET_WRITEABLE
char * pg_any_to_server(const char *s, int len, int encoding)
char * pstrdup(const char *in)
void pfree(void *pointer)
MemoryContext TopMemoryContext
void * MemoryContextAlloc(MemoryContext context, Size size)
size_t strlcpy(char *dst, const char *src, size_t siz)
#define PG_ALPN_PROTOCOL_VECTOR
static int fd(const char *x, int i)
int SSL_CTX_set_max_proto_version(SSL_CTX *ctx, int version)
int SSL_CTX_set_min_proto_version(SSL_CTX *ctx, int version)
static unsigned hash(unsigned *uv, int n)
static pg_noinline void Size size
char * pg_clean_ascii(const char *str, int alloc_flags)
void appendStringInfo(StringInfo str, const char *fmt,...)
void appendStringInfoChar(StringInfo str, char ch)
void initStringInfo(StringInfo str)