Debian Codegraph @

src/backend/tcop/backend_startup.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * backend_startup.c
4 * Backend startup code
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/tcop/backend_startup.c
12 *
13 *-------------------------------------------------------------------------
14 */
15
16 #include "postgres.h"
17
18 #include <unistd.h>
19
20 #include "access/xlog.h"
21 #include "access/xlogrecovery.h"
22 #include "common/ip.h"
23 #include "common/string.h"
24 #include "libpq/libpq.h"
25 #include "libpq/libpq-be.h"
26 #include "libpq/pqformat.h"
27 #include "libpq/pqsignal.h"
28 #include "miscadmin.h"
29 #include "postmaster/postmaster.h"
30 #include "replication/walsender.h"
31 #include "storage/fd.h"
32 #include "storage/ipc.h"
33 #include "storage/procsignal.h"
34 #include "storage/proc.h"
35 #include "tcop/backend_startup.h"
36 #include "tcop/tcopprot.h"
37 #include "utils/builtins.h"
38 #include "utils/guc_hooks.h"
39 #include "utils/injection_point.h"
40 #include "utils/memutils.h"
41 #include "utils/ps_status.h"
42 #include "utils/timeout.h"
43 #include "utils/varlena.h"
44
45 /* GUCs */
46 bool Trace_connection_negotiation = false;
47 uint32 log_connections = 0;
48 char *log_connections_string = NULL;
49
50 /* Other globals */
51
52 /*
53 * ConnectionTiming stores timestamps of various points in connection
54 * establishment and setup.
55 * ready_for_use is initialized to a special value here so we can check if
56 * we've already set it before doing so in PostgresMain().
57 */
58 ConnectionTiming conn_timing = {.ready_for_use = TIMESTAMP_MINUS_INFINITY};
59
60 static void BackendInitialize(ClientSocket *client_sock, CAC_state cac);
61 static int ProcessSSLStartup(Port *port);
62 static int ProcessStartupPacket(Port *port, bool ssl_done, bool gss_done);
63 static void ProcessCancelRequestPacket(Port *port, void *pkt, int pktlen);
64 static void SendNegotiateProtocolVersion(List *unrecognized_protocol_options);
65 static void process_startup_packet_die(SIGNAL_ARGS);
66 static void StartupPacketTimeoutHandler(void);
67 static bool validate_log_connections_options(List *elemlist, uint32 *flags);
68
69 /*
70 * Entry point for a new backend process.
71 *
72 * Initialize the connection, read the startup packet, authenticate the
73 * client, and start the main processing loop.
74 */
75 void
76 BackendMain(const void *startup_data, size_t startup_data_len)
77 {
78 const BackendStartupData *bsdata = startup_data;
79
80 Assert(startup_data_len == sizeof(BackendStartupData));
81 Assert(MyClientSocket != NULL);
82
83 #ifdef EXEC_BACKEND
84
85 /*
86 * Need to reinitialize the SSL library in the backend, since the context
87 * structures contain function pointers and cannot be passed through the
88 * parameter file.
89 *
90 * If for some reason reload fails (maybe the user installed broken key
91 * files), soldier on without SSL; that's better than all connections
92 * becoming impossible.
93 *
94 * XXX should we do this in all child processes? For the moment it's
95 * enough to do it in backend children.
96 */
97 #ifdef USE_SSL
98 if (EnableSSL)
99 {
100 if (secure_initialize(false) == 0)
101 LoadedSSL = true;
102 else
103 ereport(LOG,
104 (errmsg("SSL configuration could not be loaded in child process")));
105 }
106 #endif
107 #endif
108
109 /* Perform additional initialization and collect startup packet */
110 BackendInitialize(MyClientSocket, bsdata->canAcceptConnections);
111
112 /*
113 * Create a per-backend PGPROC struct in shared memory. We must do this
114 * before we can use LWLocks or access any shared memory.
115 */
116 InitProcess();
117
118 /*
119 * Make sure we aren't in PostmasterContext anymore. (We can't delete it
120 * just yet, though, because InitPostgres will need the HBA data.)
121 */
122 MemoryContextSwitchTo(TopMemoryContext);
123
124 PostgresMain(MyProcPort->database_name, MyProcPort->user_name);
125 }
126
127
128 /*
129 * BackendInitialize -- initialize an interactive (postmaster-child)
130 * backend process, and collect the client's startup packet.
131 *
132 * returns: nothing. Will not return at all if there's any failure.
133 *
134 * Note: this code does not depend on having any access to shared memory.
135 * Indeed, our approach to SIGTERM/timeout handling *requires* that
136 * shared memory not have been touched yet; see comments within.
137 * In the EXEC_BACKEND case, we are physically attached to shared memory
138 * but have not yet set up most of our local pointers to shmem structures.
139 */
140 static void
141 BackendInitialize(ClientSocket *client_sock, CAC_state cac)
142 {
143 int status;
144 int ret;
145 Port *port;
146 char remote_host[NI_MAXHOST];
147 char remote_port[NI_MAXSERV];
148 StringInfoData ps_data;
149 MemoryContext oldcontext;
150
151 /* Tell fd.c about the long-lived FD associated with the client_sock */
152 ReserveExternalFD();
153
154 /*
155 * PreAuthDelay is a debugging aid for investigating problems in the
156 * authentication cycle: it can be set in postgresql.conf to allow time to
157 * attach to the newly-forked backend with a debugger. (See also
158 * PostAuthDelay, which we allow clients to pass through PGOPTIONS, but it
159 * is not honored until after authentication.)
160 */
161 if (PreAuthDelay > 0)
162 pg_usleep(PreAuthDelay * 1000000L);
163
164 /* This flag will remain set until InitPostgres finishes authentication */
165 ClientAuthInProgress = true; /* limit visibility of log messages */
166
167 /*
168 * Initialize libpq and enable reporting of ereport errors to the client.
169 * Must do this now because authentication uses libpq to send messages.
170 *
171 * The Port structure and all data structures attached to it are allocated
172 * in TopMemoryContext, so that they survive into PostgresMain execution.
173 * We need not worry about leaking this storage on failure, since we
174 * aren't in the postmaster process anymore.
175 */
176 oldcontext = MemoryContextSwitchTo(TopMemoryContext);
177 port = MyProcPort = pq_init(client_sock);
178 MemoryContextSwitchTo(oldcontext);
179
180 whereToSendOutput = DestRemote; /* now safe to ereport to client */
181
182 /* set these to empty in case they are needed before we set them up */
183 port->remote_host = "";
184 port->remote_port = "";
185
186 /*
187 * We arrange to do _exit(1) if we receive SIGTERM or timeout while trying
188 * to collect the startup packet; while SIGQUIT results in _exit(2).
189 * Otherwise the postmaster cannot shutdown the database FAST or IMMED
190 * cleanly if a buggy client fails to send the packet promptly.
191 *
192 * Exiting with _exit(1) is only possible because we have not yet touched
193 * shared memory; therefore no outside-the-process state needs to get
194 * cleaned up.
195 */
196 pqsignal(SIGTERM, process_startup_packet_die);
197 /* SIGQUIT handler was already set up by InitPostmasterChild */
198 InitializeTimeouts(); /* establishes SIGALRM handler */
199 sigprocmask(SIG_SETMASK, &StartupBlockSig, NULL);
200
201 /*
202 * Get the remote host name and port for logging and status display.
203 */
204 remote_host[0] = '\0';
205 remote_port[0] = '\0';
206 if ((ret = pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
207 remote_host, sizeof(remote_host),
208 remote_port, sizeof(remote_port),
209 (log_hostname ? 0 : NI_NUMERICHOST) | NI_NUMERICSERV)) != 0)
210 ereport(WARNING,
211 (errmsg_internal("pg_getnameinfo_all() failed: %s",
212 gai_strerror(ret))));
213
214 /*
215 * Save remote_host and remote_port in port structure (after this, they
216 * will appear in log_line_prefix data for log messages).
217 */
218 port->remote_host = MemoryContextStrdup(TopMemoryContext, remote_host);
219 port->remote_port = MemoryContextStrdup(TopMemoryContext, remote_port);
220
221 /* And now we can log that the connection was received, if enabled */
222 if (log_connections & LOG_CONNECTION_RECEIPT)
223 {
224 if (remote_port[0])
225 ereport(LOG,
226 (errmsg("connection received: host=%s port=%s",
227 remote_host,
228 remote_port)));
229 else
230 ereport(LOG,
231 (errmsg("connection received: host=%s",
232 remote_host)));
233 }
234
235 /* For testing client error handling */
236 #ifdef USE_INJECTION_POINTS
237 INJECTION_POINT("backend-initialize", NULL);
238 if (IS_INJECTION_POINT_ATTACHED("backend-initialize-v2-error"))
239 {
240 /*
241 * This simulates an early error from a pre-v14 server, which used the
242 * version 2 protocol for any errors that occurred before processing
243 * the startup packet.
244 */
245 FrontendProtocol = PG_PROTOCOL(2, 0);
246 elog(FATAL, "protocol version 2 error triggered");
247 }
248 #endif
249
250 /*
251 * If we did a reverse lookup to name, we might as well save the results
252 * rather than possibly repeating the lookup during authentication.
253 *
254 * Note that we don't want to specify NI_NAMEREQD above, because then we'd
255 * get nothing useful for a client without an rDNS entry. Therefore, we
256 * must check whether we got a numeric IPv4 or IPv6 address, and not save
257 * it into remote_hostname if so. (This test is conservative and might
258 * sometimes classify a hostname as numeric, but an error in that
259 * direction is safe; it only results in a possible extra lookup.)
260 */
261 if (log_hostname &&
262 ret == 0 &&
263 strspn(remote_host, "0123456789.") < strlen(remote_host) &&
264 strspn(remote_host, "0123456789ABCDEFabcdef:") < strlen(remote_host))
265 {
266 port->remote_hostname = MemoryContextStrdup(TopMemoryContext, remote_host);
267 }
268
269 /*
270 * Ready to begin client interaction. We will give up and _exit(1) after
271 * a time delay, so that a broken client can't hog a connection
272 * indefinitely. PreAuthDelay and any DNS interactions above don't count
273 * against the time limit.
274 *
275 * Note: AuthenticationTimeout is applied here while waiting for the
276 * startup packet, and then again in InitPostgres for the duration of any
277 * authentication operations. So a hostile client could tie up the
278 * process for nearly twice AuthenticationTimeout before we kick him off.
279 *
280 * Note: because PostgresMain will call InitializeTimeouts again, the
281 * registration of STARTUP_PACKET_TIMEOUT will be lost. This is okay
282 * since we never use it again after this function.
283 */
284 RegisterTimeout(STARTUP_PACKET_TIMEOUT, StartupPacketTimeoutHandler);
285 enable_timeout_after(STARTUP_PACKET_TIMEOUT, AuthenticationTimeout * 1000);
286
287 /* Handle direct SSL handshake */
288 status = ProcessSSLStartup(port);
289
290 /*
291 * Receive the startup packet (which might turn out to be a cancel request
292 * packet).
293 */
294 if (status == STATUS_OK)
295 status = ProcessStartupPacket(port, false, false);
296
297 /*
298 * If we're going to reject the connection due to database state, say so
299 * now instead of wasting cycles on an authentication exchange. (This also
300 * allows a pg_ping utility to be written.)
301 */
302 if (status == STATUS_OK)
303 {
304 switch (cac)
305 {
306 case CAC_STARTUP:
307 ereport(FATAL,
308 (errcode(ERRCODE_CANNOT_CONNECT_NOW),
309 errmsg("the database system is starting up")));
310 break;
311 case CAC_NOTHOTSTANDBY:
312 if (!EnableHotStandby)
313 ereport(FATAL,
314 (errcode(ERRCODE_CANNOT_CONNECT_NOW),
315 errmsg("the database system is not accepting connections"),
316 errdetail("Hot standby mode is disabled.")));
317 else if (reachedConsistency)
318 ereport(FATAL,
319 (errcode(ERRCODE_CANNOT_CONNECT_NOW),
320 errmsg("the database system is not yet accepting connections"),
321 errdetail("Recovery snapshot is not yet ready for hot standby."),
322 errhint("To enable hot standby, close write transactions with more than %d subtransactions on the primary server.",
323 PGPROC_MAX_CACHED_SUBXIDS)));
324 else
325 ereport(FATAL,
326 (errcode(ERRCODE_CANNOT_CONNECT_NOW),
327 errmsg("the database system is not yet accepting connections"),
328 errdetail("Consistent recovery state has not been yet reached.")));
329 break;
330 case CAC_SHUTDOWN:
331 ereport(FATAL,
332 (errcode(ERRCODE_CANNOT_CONNECT_NOW),
333 errmsg("the database system is shutting down")));
334 break;
335 case CAC_RECOVERY:
336 ereport(FATAL,
337 (errcode(ERRCODE_CANNOT_CONNECT_NOW),
338 errmsg("the database system is in recovery mode")));
339 break;
340 case CAC_TOOMANY:
341 ereport(FATAL,
342 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
343 errmsg("sorry, too many clients already")));
344 break;
345 case CAC_OK:
346 break;
347 }
348 }
349
350 /*
351 * Disable the timeout, and prevent SIGTERM again.
352 */
353 disable_timeout(STARTUP_PACKET_TIMEOUT, false);
354 sigprocmask(SIG_SETMASK, &BlockSig, NULL);
355
356 /*
357 * As a safety check that nothing in startup has yet performed
358 * shared-memory modifications that would need to be undone if we had
359 * exited through SIGTERM or timeout above, check that no on_shmem_exit
360 * handlers have been registered yet. (This isn't terribly bulletproof,
361 * since someone might misuse an on_proc_exit handler for shmem cleanup,
362 * but it's a cheap and helpful check. We cannot disallow on_proc_exit
363 * handlers unfortunately, since pq_init() already registered one.)
364 */
365 check_on_shmem_exit_lists_are_empty();
366
367 /*
368 * Stop here if it was bad or a cancel packet. ProcessStartupPacket
369 * already did any appropriate error reporting.
370 */
371 if (status != STATUS_OK)
372 proc_exit(0);
373
374 /*
375 * Now that we have the user and database name, we can set the process
376 * title for ps. It's good to do this as early as possible in startup.
377 */
378 initStringInfo(&ps_data);
379 if (am_walsender)
380 appendStringInfo(&ps_data, "%s ", GetBackendTypeDesc(B_WAL_SENDER));
381 appendStringInfo(&ps_data, "%s ", port->user_name);
382 if (port->database_name[0] != '\0')
383 appendStringInfo(&ps_data, "%s ", port->database_name);
384 appendStringInfoString(&ps_data, port->remote_host);
385 if (port->remote_port[0] != '\0')
386 appendStringInfo(&ps_data, "(%s)", port->remote_port);
387
388 init_ps_display(ps_data.data);
389 pfree(ps_data.data);
390
391 set_ps_display("initializing");
392 }
393
394 /*
395 * Check for a direct SSL connection.
396 *
397 * This happens before the startup packet so we are careful not to actually
398 * read any bytes from the stream if it's not a direct SSL connection.
399 */
400 static int
401 ProcessSSLStartup(Port *port)
402 {
403 int firstbyte;
404
405 Assert(!port->ssl_in_use);
406
407 pq_startmsgread();
408 firstbyte = pq_peekbyte();
409 pq_endmsgread();
410 if (firstbyte == EOF)
411 {
412 /*
413 * Like in ProcessStartupPacket, if we get no data at all, don't
414 * clutter the log with a complaint.
415 */
416 return STATUS_ERROR;
417 }
418
419 if (firstbyte != 0x16)
420 {
421 /* Not an SSL handshake message */
422 return STATUS_OK;
423 }
424
425 /*
426 * First byte indicates standard SSL handshake message
427 *
428 * (It can't be a Postgres startup length because in network byte order
429 * that would be a startup packet hundreds of megabytes long)
430 */
431
432 #ifdef USE_SSL
433 if (!LoadedSSL || port->laddr.addr.ss_family == AF_UNIX)
434 {
435 /* SSL not supported */
436 goto reject;
437 }
438
439 if (secure_open_server(port) == -1)
440 {
441 /*
442 * we assume secure_open_server() sent an appropriate TLS alert
443 * already
444 */
445 goto reject;
446 }
447 Assert(port->ssl_in_use);
448
449 if (!port->alpn_used)
450 {
451 ereport(COMMERROR,
452 (errcode(ERRCODE_PROTOCOL_VIOLATION),
453 errmsg("received direct SSL connection request without ALPN protocol negotiation extension")));
454 goto reject;
455 }
456
457 if (Trace_connection_negotiation)
458 ereport(LOG,
459 (errmsg("direct SSL connection accepted")));
460 return STATUS_OK;
461 #else
462 /* SSL not supported by this build */
463 goto reject;
464 #endif
465
466 reject:
467 if (Trace_connection_negotiation)
468 ereport(LOG,
469 (errmsg("direct SSL connection rejected")));
470 return STATUS_ERROR;
471 }
472
473 /*
474 * Read a client's startup packet and do something according to it.
475 *
476 * Returns STATUS_OK or STATUS_ERROR, or might call ereport(FATAL) and
477 * not return at all.
478 *
479 * (Note that ereport(FATAL) stuff is sent to the client, so only use it
480 * if that's what you want. Return STATUS_ERROR if you don't want to
481 * send anything to the client, which would typically be appropriate
482 * if we detect a communications failure.)
483 *
484 * Set ssl_done and/or gss_done when negotiation of an encrypted layer
485 * (currently, TLS or GSSAPI) is completed. A successful negotiation of either
486 * encryption layer sets both flags, but a rejected negotiation sets only the
487 * flag for that layer, since the client may wish to try the other one. We
488 * should make no assumption here about the order in which the client may make
489 * requests.
490 */
491 static int
492 ProcessStartupPacket(Port *port, bool ssl_done, bool gss_done)
493 {
494 int32 len;
495 char *buf;
496 ProtocolVersion proto;
497 MemoryContext oldcontext;
498
499 retry:
500 pq_startmsgread();
501
502 /*
503 * Grab the first byte of the length word separately, so that we can tell
504 * whether we have no data at all or an incomplete packet. (This might
505 * sound inefficient, but it's not really, because of buffering in
506 * pqcomm.c.)
507 */
508 if (pq_getbytes(&len, 1) == EOF)
509 {
510 /*
511 * If we get no data at all, don't clutter the log with a complaint;
512 * such cases often occur for legitimate reasons. An example is that
513 * we might be here after responding to NEGOTIATE_SSL_CODE, and if the
514 * client didn't like our response, it'll probably just drop the
515 * connection. Service-monitoring software also often just opens and
516 * closes a connection without sending anything. (So do port
517 * scanners, which may be less benign, but it's not really our job to
518 * notice those.)
519 */
520 return STATUS_ERROR;
521 }
522
523 if (pq_getbytes(((char *) &len) + 1, 3) == EOF)
524 {
525 /* Got a partial length word, so bleat about that */
526 if (!ssl_done && !gss_done)
527 ereport(COMMERROR,
528 (errcode(ERRCODE_PROTOCOL_VIOLATION),
529 errmsg("incomplete startup packet")));
530 return STATUS_ERROR;
531 }
532
533 len = pg_ntoh32(len);
534 len -= 4;
535
536 if (len < (int32) sizeof(ProtocolVersion) ||
537 len > MAX_STARTUP_PACKET_LENGTH)
538 {
539 ereport(COMMERROR,
540 (errcode(ERRCODE_PROTOCOL_VIOLATION),
541 errmsg("invalid length of startup packet")));
542 return STATUS_ERROR;
543 }
544
545 /*
546 * Allocate space to hold the startup packet, plus one extra byte that's
547 * initialized to be zero. This ensures we will have null termination of
548 * all strings inside the packet.
549 */
550 buf = palloc(len + 1);
551 buf[len] = '\0';
552
553 if (pq_getbytes(buf, len) == EOF)
554 {
555 ereport(COMMERROR,
556 (errcode(ERRCODE_PROTOCOL_VIOLATION),
557 errmsg("incomplete startup packet")));
558 return STATUS_ERROR;
559 }
560 pq_endmsgread();
561
562 /*
563 * The first field is either a protocol version number or a special
564 * request code.
565 */
566 port->proto = proto = pg_ntoh32(*((ProtocolVersion *) buf));
567
568 if (proto == CANCEL_REQUEST_CODE)
569 {
570 ProcessCancelRequestPacket(port, buf, len);
571 /* Not really an error, but we don't want to proceed further */
572 return STATUS_ERROR;
573 }
574
575 if (proto == NEGOTIATE_SSL_CODE && !ssl_done)
576 {
577 char SSLok;
578
579 #ifdef USE_SSL
580
581 /*
582 * No SSL when disabled or on Unix sockets.
583 *
584 * Also no SSL negotiation if we already have a direct SSL connection
585 */
586 if (!LoadedSSL || port->laddr.addr.ss_family == AF_UNIX || port->ssl_in_use)
587 SSLok = 'N';
588 else
589 SSLok = 'S'; /* Support for SSL */
590 #else
591 SSLok = 'N'; /* No support for SSL */
592 #endif
593
594 if (Trace_connection_negotiation)
595 {
596 if (SSLok == 'S')
597 ereport(LOG,
598 (errmsg("SSLRequest accepted")));
599 else
600 ereport(LOG,
601 (errmsg("SSLRequest rejected")));
602 }
603
604 while (secure_write(port, &SSLok, 1) != 1)
605 {
606 if (errno == EINTR)
607 continue; /* if interrupted, just retry */
608 ereport(COMMERROR,
609 (errcode_for_socket_access(),
610 errmsg("failed to send SSL negotiation response: %m")));
611 return STATUS_ERROR; /* close the connection */
612 }
613
614 #ifdef USE_SSL
615 if (SSLok == 'S' && secure_open_server(port) == -1)
616 return STATUS_ERROR;
617 #endif
618
619 /*
620 * At this point we should have no data already buffered. If we do,
621 * it was received before we performed the SSL handshake, so it wasn't
622 * encrypted and indeed may have been injected by a man-in-the-middle.
623 * We report this case to the client.
624 */
625 if (pq_buffer_remaining_data() > 0)
626 ereport(FATAL,
627 (errcode(ERRCODE_PROTOCOL_VIOLATION),
628 errmsg("received unencrypted data after SSL request"),
629 errdetail("This could be either a client-software bug or evidence of an attempted man-in-the-middle attack.")));
630
631 /*
632 * regular startup packet, cancel, etc packet should follow, but not
633 * another SSL negotiation request, and a GSS request should only
634 * follow if SSL was rejected (client may negotiate in either order)
635 */
636 ssl_done = true;
637 if (SSLok == 'S')
638 {
639 /*
640 * We are done with SSL and negotiated correctly, so consider the
641 * same for GSS.
642 */
643 gss_done = true;
644 }
645 goto retry;
646 }
647 else if (proto == NEGOTIATE_GSS_CODE && !gss_done)
648 {
649 char GSSok = 'N';
650
651 #ifdef ENABLE_GSS
652
653 /*
654 * No GSSAPI encryption when on Unix socket.
655 *
656 * Also no GSS negotiation if we already have a direct SSL connection.
657 */
658 if (port->laddr.addr.ss_family != AF_UNIX && !port->ssl_in_use)
659 GSSok = 'G';
660 #endif
661
662 if (Trace_connection_negotiation)
663 {
664 if (GSSok == 'G')
665 ereport(LOG,
666 (errmsg("GSSENCRequest accepted")));
667 else
668 ereport(LOG,
669 (errmsg("GSSENCRequest rejected")));
670 }
671
672 while (secure_write(port, &GSSok, 1) != 1)
673 {
674 if (errno == EINTR)
675 continue;
676 ereport(COMMERROR,
677 (errcode_for_socket_access(),
678 errmsg("failed to send GSSAPI negotiation response: %m")));
679 return STATUS_ERROR; /* close the connection */
680 }
681
682 #ifdef ENABLE_GSS
683 if (GSSok == 'G' && secure_open_gssapi(port) == -1)
684 return STATUS_ERROR;
685 #endif
686
687 /*
688 * At this point we should have no data already buffered. If we do,
689 * it was received before we performed the GSS handshake, so it wasn't
690 * encrypted and indeed may have been injected by a man-in-the-middle.
691 * We report this case to the client.
692 */
693 if (pq_buffer_remaining_data() > 0)
694 ereport(FATAL,
695 (errcode(ERRCODE_PROTOCOL_VIOLATION),
696 errmsg("received unencrypted data after GSSAPI encryption request"),
697 errdetail("This could be either a client-software bug or evidence of an attempted man-in-the-middle attack.")));
698
699 /*
700 * regular startup packet, cancel, etc packet should follow, but not
701 * another GSS negotiation request, and an SSL request should only
702 * follow if GSS was rejected (client may negotiate in either order)
703 */
704 gss_done = true;
705 if (GSSok == 'G')
706 {
707 /*
708 * We are done with GSS and negotiated correctly, so consider the
709 * same for SSL.
710 */
711 ssl_done = true;
712 }
713 goto retry;
714 }
715
716 /* Could add additional special packet types here */
717
718 /*
719 * Set FrontendProtocol now so that ereport() knows what format to send if
720 * we fail during startup. We use the protocol version requested by the
721 * client unless it's higher than the latest version we support. It's
722 * possible that error message fields might look different in newer
723 * protocol versions, but that's something those new clients should be
724 * able to deal with.
725 */
726 FrontendProtocol = Min(proto, PG_PROTOCOL_LATEST);
727
728 /* Check that the major protocol version is in range. */
729 if (PG_PROTOCOL_MAJOR(proto) < PG_PROTOCOL_MAJOR(PG_PROTOCOL_EARLIEST) ||
730 PG_PROTOCOL_MAJOR(proto) > PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST))
731 ereport(FATAL,
732 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
733 errmsg("unsupported frontend protocol %u.%u: server supports %u.0 to %u.%u",
734 PG_PROTOCOL_MAJOR(proto), PG_PROTOCOL_MINOR(proto),
735 PG_PROTOCOL_MAJOR(PG_PROTOCOL_EARLIEST),
736 PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST),
737 PG_PROTOCOL_MINOR(PG_PROTOCOL_LATEST))));
738
739 /*
740 * Now fetch parameters out of startup packet and save them into the Port
741 * structure.
742 */
743 oldcontext = MemoryContextSwitchTo(TopMemoryContext);
744
745 /* Handle protocol version 3 startup packet */
746 {
747 int32 offset = sizeof(ProtocolVersion);
748 List *unrecognized_protocol_options = NIL;
749
750 /*
751 * Scan packet body for name/option pairs. We can assume any string
752 * beginning within the packet body is null-terminated, thanks to
753 * zeroing extra byte above.
754 */
755 port->guc_options = NIL;
756
757 while (offset < len)
758 {
759 char *nameptr = buf + offset;
760 int32 valoffset;
761 char *valptr;
762
763 if (*nameptr == '\0')
764 break; /* found packet terminator */
765 valoffset = offset + strlen(nameptr) + 1;
766 if (valoffset >= len)
767 break; /* missing value, will complain below */
768 valptr = buf + valoffset;
769
770 if (strcmp(nameptr, "database") == 0)
771 port->database_name = pstrdup(valptr);
772 else if (strcmp(nameptr, "user") == 0)
773 port->user_name = pstrdup(valptr);
774 else if (strcmp(nameptr, "options") == 0)
775 port->cmdline_options = pstrdup(valptr);
776 else if (strcmp(nameptr, "replication") == 0)
777 {
778 /*
779 * Due to backward compatibility concerns the replication
780 * parameter is a hybrid beast which allows the value to be
781 * either boolean or the string 'database'. The latter
782 * connects to a specific database which is e.g. required for
783 * logical decoding while.
784 */
785 if (strcmp(valptr, "database") == 0)
786 {
787 am_walsender = true;
788 am_db_walsender = true;
789 }
790 else if (!parse_bool(valptr, &am_walsender))
791 ereport(FATAL,
792 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
793 errmsg("invalid value for parameter \"%s\": \"%s\"",
794 "replication",
795 valptr),
796 errhint("Valid values are: \"false\", 0, \"true\", 1, \"database\".")));
797 }
798 else if (strncmp(nameptr, "_pq_.", 5) == 0)
799 {
800 /*
801 * Any option beginning with _pq_. is reserved for use as a
802 * protocol-level option, but at present no such options are
803 * defined.
804 */
805 unrecognized_protocol_options =
806 lappend(unrecognized_protocol_options, pstrdup(nameptr));
807 }
808 else
809 {
810 /* Assume it's a generic GUC option */
811 port->guc_options = lappend(port->guc_options,
812 pstrdup(nameptr));
813 port->guc_options = lappend(port->guc_options,
814 pstrdup(valptr));
815
816 /*
817 * Copy application_name to port if we come across it. This
818 * is done so we can log the application_name in the
819 * connection authorization message. Note that the GUC would
820 * be used but we haven't gone through GUC setup yet.
821 */
822 if (strcmp(nameptr, "application_name") == 0)
823 {
824 port->application_name = pg_clean_ascii(valptr, 0);
825 }
826 }
827 offset = valoffset + strlen(valptr) + 1;
828 }
829
830 /*
831 * If we didn't find a packet terminator exactly at the end of the
832 * given packet length, complain.
833 */
834 if (offset != len - 1)
835 ereport(FATAL,
836 (errcode(ERRCODE_PROTOCOL_VIOLATION),
837 errmsg("invalid startup packet layout: expected terminator as last byte")));
838
839 /*
840 * If the client requested a newer protocol version or if the client
841 * requested any protocol options we didn't recognize, let them know
842 * the newest minor protocol version we do support and the names of
843 * any unrecognized options.
844 */
845 if (PG_PROTOCOL_MINOR(proto) > PG_PROTOCOL_MINOR(PG_PROTOCOL_LATEST) ||
846 unrecognized_protocol_options != NIL)
847 SendNegotiateProtocolVersion(unrecognized_protocol_options);
848 }
849
850 /* Check a user name was given. */
851 if (port->user_name == NULL || port->user_name[0] == '\0')
852 ereport(FATAL,
853 (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
854 errmsg("no PostgreSQL user name specified in startup packet")));
855
856 /* The database defaults to the user name. */
857 if (port->database_name == NULL || port->database_name[0] == '\0')
858 port->database_name = pstrdup(port->user_name);
859
860 /*
861 * Truncate given database and user names to length of a Postgres name.
862 * This avoids lookup failures when overlength names are given.
863 */
864 if (strlen(port->database_name) >= NAMEDATALEN)
865 port->database_name[NAMEDATALEN - 1] = '\0';
866 if (strlen(port->user_name) >= NAMEDATALEN)
867 port->user_name[NAMEDATALEN - 1] = '\0';
868
869 if (am_walsender)
870 MyBackendType = B_WAL_SENDER;
871 else
872 MyBackendType = B_BACKEND;
873
874 /*
875 * Normal walsender backends, e.g. for streaming replication, are not
876 * connected to a particular database. But walsenders used for logical
877 * replication need to connect to a specific database. We allow streaming
878 * replication commands to be issued even if connected to a database as it
879 * can make sense to first make a basebackup and then stream changes
880 * starting from that.
881 */
882 if (am_walsender && !am_db_walsender)
883 port->database_name[0] = '\0';
884
885 /*
886 * Done filling the Port structure
887 */
888 MemoryContextSwitchTo(oldcontext);
889
890 return STATUS_OK;
891 }
892
893 /*
894 * The client has sent a cancel request packet, not a normal
895 * start-a-new-connection packet. Perform the necessary processing. Nothing
896 * is sent back to the client.
897 */
898 static void
899 ProcessCancelRequestPacket(Port *port, void *pkt, int pktlen)
900 {
901 CancelRequestPacket *canc;
902 int len;
903
904 if (pktlen < offsetof(CancelRequestPacket, cancelAuthCode))
905 {
906 ereport(COMMERROR,
907 (errcode(ERRCODE_PROTOCOL_VIOLATION),
908 errmsg("invalid length of cancel request packet")));
909 return;
910 }
911 len = pktlen - offsetof(CancelRequestPacket, cancelAuthCode);
912 if (len == 0 || len > 256)
913 {
914 ereport(COMMERROR,
915 (errcode(ERRCODE_PROTOCOL_VIOLATION),
916 errmsg("invalid length of cancel key in cancel request packet")));
917 return;
918 }
919
920 canc = (CancelRequestPacket *) pkt;
921 SendCancelRequest(pg_ntoh32(canc->backendPID), canc->cancelAuthCode, len);
922 }
923
924 /*
925 * Send a NegotiateProtocolVersion to the client. This lets the client know
926 * that they have either requested a newer minor protocol version than we are
927 * able to speak, or at least one protocol option that we don't understand, or
928 * possibly both. FrontendProtocol has already been set to the version
929 * requested by the client or the highest version we know how to speak,
930 * whichever is older. If the highest version that we know how to speak is too
931 * old for the client, it can abandon the connection.
932 *
933 * We also include in the response a list of protocol options we didn't
934 * understand. This allows clients to include optional parameters that might
935 * be present either in newer protocol versions or third-party protocol
936 * extensions without fear of having to reconnect if those options are not
937 * understood, while at the same time making certain that the client is aware
938 * of which options were actually accepted.
939 */
940 static void
941 SendNegotiateProtocolVersion(List *unrecognized_protocol_options)
942 {
943 StringInfoData buf;
944 ListCell *lc;
945
946 pq_beginmessage(&buf, PqMsg_NegotiateProtocolVersion);
947 pq_sendint32(&buf, FrontendProtocol);
948 pq_sendint32(&buf, list_length(unrecognized_protocol_options));
949 foreach(lc, unrecognized_protocol_options)
950 pq_sendstring(&buf, lfirst(lc));
951 pq_endmessage(&buf);
952
953 /* no need to flush, some other message will follow */
954 }
955
956
957 /*
958 * SIGTERM while processing startup packet.
959 *
960 * Running proc_exit() from a signal handler would be quite unsafe.
961 * However, since we have not yet touched shared memory, we can just
962 * pull the plug and exit without running any atexit handlers.
963 *
964 * One might be tempted to try to send a message, or log one, indicating
965 * why we are disconnecting. However, that would be quite unsafe in itself.
966 * Also, it seems undesirable to provide clues about the database's state
967 * to a client that has not yet completed authentication, or even sent us
968 * a startup packet.
969 */
970 static void
971 process_startup_packet_die(SIGNAL_ARGS)
972 {
973 _exit(1);
974 }
975
976 /*
977 * Timeout while processing startup packet.
978 * As for process_startup_packet_die(), we exit via _exit(1).
979 */
980 static void
981 StartupPacketTimeoutHandler(void)
982 {
983 _exit(1);
984 }
985
986 /*
987 * Helper for the log_connections GUC check hook.
988 *
989 * `elemlist` is a listified version of the string input passed to the
990 * log_connections GUC check hook, check_log_connections().
991 * check_log_connections() is responsible for cleaning up `elemlist`.
992 *
993 * validate_log_connections_options() returns false if an error was
994 * encountered and the GUC input could not be validated and true otherwise.
995 *
996 * `flags` returns the flags that should be stored in the log_connections GUC
997 * by its assign hook.
998 */
999 static bool
1000 validate_log_connections_options(List *elemlist, uint32 *flags)
1001 {
1002 ListCell *l;
1003 char *item;
1004
1005 /*
1006 * For backwards compatibility, we accept these tokens by themselves.
1007 *
1008 * Prior to PostgreSQL 18, log_connections was a boolean GUC that accepted
1009 * any unambiguous substring of 'true', 'false', 'yes', 'no', 'on', and
1010 * 'off'. Since log_connections became a list of strings in 18, we only
1011 * accept complete option strings.
1012 */
1013 static const struct config_enum_entry compat_options[] = {
1014 {"off", 0},
1015 {"false", 0},
1016 {"no", 0},
1017 {"0", 0},
1018 {"on", LOG_CONNECTION_ON},
1019 {"true", LOG_CONNECTION_ON},
1020 {"yes", LOG_CONNECTION_ON},
1021 {"1", LOG_CONNECTION_ON},
1022 };
1023
1024 *flags = 0;
1025
1026 /* If an empty string was passed, we're done */
1027 if (list_length(elemlist) == 0)
1028 return true;
1029
1030 /*
1031 * Now check for the backwards compatibility options. They must always be
1032 * specified on their own, so we error out if the first option is a
1033 * backwards compatibility option and other options are also specified.
1034 */
1035 item = linitial(elemlist);
1036
1037 for (size_t i = 0; i < lengthof(compat_options); i++)
1038 {
1039 struct config_enum_entry option = compat_options[i];
1040
1041 if (pg_strcasecmp(item, option.name) != 0)
1042 continue;
1043
1044 if (list_length(elemlist) > 1)
1045 {
1046 GUC_check_errdetail("Cannot specify log_connections option \"%s\" in a list with other options.",
1047 item);
1048 return false;
1049 }
1050
1051 *flags = option.val;
1052 return true;
1053 }
1054
1055 /* Now check the aspect options. The empty string was already handled */
1056 foreach(l, elemlist)
1057 {
1058 static const struct config_enum_entry options[] = {
1059 {"receipt", LOG_CONNECTION_RECEIPT},
1060 {"authentication", LOG_CONNECTION_AUTHENTICATION},
1061 {"authorization", LOG_CONNECTION_AUTHORIZATION},
1062 {"setup_durations", LOG_CONNECTION_SETUP_DURATIONS},
1063 {"all", LOG_CONNECTION_ALL},
1064 };
1065
1066 item = lfirst(l);
1067 for (size_t i = 0; i < lengthof(options); i++)
1068 {
1069 struct config_enum_entry option = options[i];
1070
1071 if (pg_strcasecmp(item, option.name) == 0)
1072 {
1073 *flags |= option.val;
1074 goto next;
1075 }
1076 }
1077
1078 GUC_check_errdetail("Invalid option \"%s\".", item);
1079 return false;
1080
1081 next: ;
1082 }
1083
1084 return true;
1085 }
1086
1087
1088 /*
1089 * GUC check hook for log_connections
1090 */
1091 bool
1092 check_log_connections(char **newval, void **extra, GucSource source)
1093 {
1094 uint32 flags;
1095 char *rawstring;
1096 List *elemlist;
1097 bool success;
1098
1099 /* Need a modifiable copy of string */
1100 rawstring = pstrdup(*newval);
1101
1102 if (!SplitIdentifierString(rawstring, ',', &elemlist))
1103 {
1104 GUC_check_errdetail("Invalid list syntax in parameter \"%s\".", "log_connections");
1105 pfree(rawstring);
1106 list_free(elemlist);
1107 return false;
1108 }
1109
1110 /* Validation logic is all in the helper */
1111 success = validate_log_connections_options(elemlist, &flags);
1112
1113 /* Time for cleanup */
1114 pfree(rawstring);
1115 list_free(elemlist);
1116
1117 if (!success)
1118 return false;
1119
1120 /*
1121 * We succeeded, so allocate `extra` and save the flags there for use by
1122 * assign_log_connections().
1123 */
1124 *extra = guc_malloc(LOG, sizeof(int));
1125 if (!*extra)
1126 return false;
1127 *((int *) *extra) = flags;
1128
1129 return true;
1130 }
1131
1132 /*
1133 * GUC assign hook for log_connections
1134 */
1135 void
1136 assign_log_connections(const char *newval, void *extra)
1137 {
1138 log_connections = *((int *) extra);
1139 }