开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
postmaster.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：41k
源码类别：

数据库系统

开发平台：

Unix_Linux

postmaster.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * postmaster.c
  4.  *   This program acts as a clearing house for requests to the
  5.  *   POSTGRES system. Frontend programs send a startup message
  6.  *   to the Postmaster and the postmaster uses the info in the
  7.  *   message to setup a backend process.
  8.  *
  9.  * Copyright (c) 1994, Regents of the University of California
  10.  *
  11.  *
  12.  * IDENTIFICATION
  13.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.108 1999/07/07 17:17:48 momjian Exp $
  14.  *
  15.  * NOTES
  16.  *
  17.  * Initialization:
  18.  * The Postmaster sets up a few shared memory data structures
  19.  * for the backends.  It should at the very least initialize the
  20.  * lock manager.
  21.  *
  22.  * Synchronization:
  23.  * The Postmaster shares memory with the backends and will have to lock
  24.  * the shared memory it accesses. The Postmaster should never block
  25.  * on messages from clients.
  26.  *
  27.  * Garbage Collection:
  28.  * The Postmaster cleans up after backends if they have an emergency
  29.  * exit and/or core dump.
  30.  *
  31.  * Communication:
  32.  *
  33.  *-------------------------------------------------------------------------
  34.  */
  35.  /* moved here to prevent double define */
  36. #include <sys/param.h> /* for MAXHOSTNAMELEN on most */
  37. #ifdef HAVE_NETDB_H
  38. #include <netdb.h> /* for MAXHOSTNAMELEN on some */
  39. #endif
  41. #ifndef MAXHOSTNAMELEN
  42. #define MAXHOSTNAMELEN 256
  43. #endif
  45. #include "postgres.h"
  47. #include <signal.h>
  48. #include <string.h>
  49. #include <stdlib.h>
  50. #include <time.h>
  52. #if !defined(NO_UNISTD_H)
  53. #include <unistd.h>
  54. #endif  /* !NO_UNISTD_H */
  56. #include <ctype.h>
  57. #include <sys/types.h> /* for fd_set stuff */
  58. #include <sys/stat.h> /* for umask */
  59. #include <sys/time.h>
  60. #include <sys/socket.h>
  61. #ifdef HAVE_LIMITS_H
  62. #include <limits.h>
  63. #else
  64. #include <values.h>
  65. #endif
  66. #include <sys/wait.h>
  68. #include <errno.h>
  69. #include <fcntl.h>
  70. #include <stdio.h>
  72. #ifdef HAVE_SYS_SELECT_H
  73. #include <sys/select.h>
  74. #endif
  76. #ifdef __CYGWIN32__
  77. #include <getopt.h>
  78. #endif
  80. #include "storage/ipc.h"
  81. #include "libpq/libpq.h"
  82. #include "libpq/auth.h"
  83. #include "libpq/pqcomm.h"
  84. #include "libpq/pqsignal.h"
  85. #include "libpq/crypt.h"
  86. #include "miscadmin.h"
  87. #include "version.h"
  88. #include "lib/dllist.h"
  89. #include "tcop/tcopprot.h"
  90. #include "commands/async.h"
  91. #include "nodes/nodes.h"
  92. #include "utils/mcxt.h"
  93. #include "storage/proc.h"
  94. #include "utils/elog.h"
  95. #ifndef HAVE_GETHOSTNAME
  96. #include "port-protos.h" /* For gethostname() */
  97. #endif
  98. #include "storage/fd.h"
  99. #include "utils/trace.h"
  101. #if !defined(MAXINT)
  102. #define MAXINT    INT_MAX
  103. #endif
  105. #define INVALID_SOCK (-1)
  106. #define ARGV_SIZE 64
  108.  /*
  109.   * Max time in seconds for socket to linger (close() to block) waiting
  110.   * for frontend to retrieve its message from us.
  111.   */
  113. /*
  114.  * Info for garbage collection.  Whenever a process dies, the Postmaster
  115.  * cleans up after it. Currently, NO information is required for cleanup,
  116.  * but I left this structure around in case that changed.
  117.  */
  118. typedef struct bkend
  119. {
  120. int pid; /* process id of backend */
  121. long cancel_key; /* cancel key for cancels for this backend */
  122. } Backend;
  124. Port    *MyBackendPort = NULL;
  126. /* list of active backends.  For garbage collection only now. */
  128. static Dllist *BackendList;
  130. /* list of ports associated with still open, but incomplete connections */
  131. static Dllist *PortList;
  133. static unsigned short PostPortName = 0;
  134. static short ActiveBackends = FALSE;
  136.  /*
  137.   * This is a boolean indicating that there is at least one backend that
  138.   * is accessing the current shared memory and semaphores. Between the
  139.   * time that we start up, or throw away shared memory segments and start
  140.   * over, and the time we generate the next backend (because we received a
  141.   * connection request), it is false. Other times, it is true.
  142.   */
  143. static short shmem_seq = 0;
  145.  /*
  146.   * This is a sequence number that indicates how many times we've had to
  147.   * throw away the shared memory and start over because we doubted its
  148.   * integrity. It starts off at zero and is incremented every time we
  149.   * start over.  We use this to ensure that we use a new IPC shared memory
  150.   * key for the new shared memory segment in case the old segment isn't
  151.   * entirely gone yet.
  152.   *
  153.   * The sequence actually cycles back to 0 after 9, so pathologically there
  154.   * could be an IPC failure if 10 sets of backends are all stuck and won't
  155.   * release IPC resources.
  156.   */
  158. static IpcMemoryKey ipc_key;
  160.  /*
  161.   * This is the base IPC shared memory key.  Other keys are generated by
  162.   * adding to this.
  163.   */
  165. static int MaxBackends = DEF_MAXBACKENDS;
  167.  /*
  168.   * MaxBackends is the actual limit on the number of backends we will
  169.   * start. The default is established by configure, but it can be
  170.   * readjusted from 1..MAXBACKENDS with the postmaster -N switch. Note
  171.   * that a larger MaxBackends value will increase the size of the shared
  172.   * memory area as well as cause the postmaster to grab more kernel
  173.   * semaphores, even if you never actually use that many backends.
  174.   */
  176. static int NextBackendTag = MAXINT; /* XXX why count down not up? */
  177. static char *progname = (char *) NULL;
  178. static char **real_argv;
  179. static int real_argc;
  181. /*
  182.  * Default Values
  183.  */
  184. static char Execfile[MAXPATHLEN] = "";
  186. static int ServerSock_INET = INVALID_SOCK; /* stream socket server */
  188. #ifndef __CYGWIN32__
  189. static int ServerSock_UNIX = INVALID_SOCK; /* stream socket server */
  191. #endif
  193. /*
  194.  * Set by the -o option
  195.  */
  196. static char ExtraOptions[MAXPATHLEN] = "";
  198. /*
  199.  * These globals control the behavior of the postmaster in case some
  200.  * backend dumps core. Normally, it kills all peers of the dead backend
  201.  * and reinitializes shared memory.  By specifying -s or -n, we can have
  202.  * the postmaster stop (rather than kill) peers and not reinitialize
  203.  * shared data structures.
  204.  */
  205. static bool Reinit = true;
  206. static int SendStop = false;
  208. static bool NetServer = false; /* if not zero, postmaster listen for
  209.  * non-local connections */
  212. /*
  213.  * GH: For !HAVE_SIGPROCMASK (NEXTSTEP), TRH implemented an
  214.  * alternative interface.
  215.  */
  216. #ifdef HAVE_SIGPROCMASK
  217. static sigset_t oldsigmask,
  218. newsigmask;
  220. #else
  221. static int orgsigmask = sigblock(0);
  223. #endif
  225. /*
  226.  * State for assigning random salts and cancel keys.
  227.  * Also, the global MyCancelKey passes the cancel key assigned to a given
  228.  * backend from the postmaster to that backend (via fork).
  229.  */
  231. static unsigned int random_seed = 0;
  233. extern char *optarg;
  234. extern int optind,
  235. opterr;
  238. /*
  239.  * postmaster.c - function prototypes
  240.  */
  241. static void pmdaemonize(void);
  242. static Port *ConnCreate(int serverFd);
  243. static void reset_shared(unsigned short port);
  244. static void pmdie(SIGNAL_ARGS);
  245. static void reaper(SIGNAL_ARGS);
  246. static void dumpstatus(SIGNAL_ARGS);
  247. static void CleanupProc(int pid, int exitstatus);
  248. static int DoBackend(Port *port);
  249. static void ExitPostmaster(int status);
  250. static void usage(const char *);
  251. static int ServerLoop(void);
  252. static int BackendStartup(Port *port);
  253. static int readStartupPacket(void *arg, PacketLen len, void *pkt);
  254. static int processCancelRequest(Port *port, PacketLen len, void *pkt);
  255. static int initMasks(fd_set *rmask, fd_set *wmask);
  256. static long PostmasterRandom(void);
  257. static void RandomSalt(char *salt);
  258. static void SignalChildren(SIGNAL_ARGS);
  259. static int CountChildren(void);
  261. #ifdef CYR_RECODE
  262. void GetCharSetByHost(char *, int, char *);
  264. #endif
  266. #ifdef USE_ASSERT_CHECKING
  267. int assert_enabled = 1;
  269. #endif
  271. static void
  272. checkDataDir(const char *DataDir, bool *DataDirOK)
  273. {
  274. if (DataDir == NULL)
  275. {
  276. fprintf(stderr, "%s does not know where to find the database system "
  277. "data.  You must specify the directory that contains the "
  278. "database system either by specifying the -D invocation "
  279.  "option or by setting the PGDATA environment variable.nn",
  280. progname);
  281. *DataDirOK = false;
  282. }
  283. else
  284. {
  285. char path[MAXPATHLEN];
  286. FILE    *fp;
  288. sprintf(path, "%s%cbase%ctemplate1%cpg_class",
  289. DataDir, SEP_CHAR, SEP_CHAR, SEP_CHAR);
  290. #ifndef __CYGWIN32__
  291. fp = AllocateFile(path, "r");
  292. #else
  293. fp = AllocateFile(path, "rb");
  294. #endif
  295. if (fp == NULL)
  296. {
  297. fprintf(stderr, "%s does not find the database system.  "
  298. "Expected to find it "
  299.    "in the PGDATA directory "%s", but unable to open file "
  300. "with pathname "%s".nn",
  301. progname, DataDir, path);
  302. *DataDirOK = false;
  303. }
  304. else
  305. {
  306. char    *reason;
  308. /* reason ValidatePgVersion failed.  NULL if didn't */
  310. FreeFile(fp);
  312. ValidatePgVersion(DataDir, &reason);
  313. if (reason)
  314. {
  315. fprintf(stderr,
  316. "Database system in directory %s "
  317. "is not compatible with this version of "
  318. "Postgres, or we are unable to read the "
  319. "PG_VERSION file.  "
  320. "Explanation from ValidatePgVersion: %snn",
  321. DataDir, reason);
  322. free(reason);
  323. *DataDirOK = false;
  324. }
  325. else
  326. *DataDirOK = true;
  327. }
  328. }
  329. }
  331. int
  332. PostmasterMain(int argc, char *argv[])
  333. {
  334. extern int NBuffers; /* from buffer/bufmgr.c */
  335. int opt;
  336. char    *hostName;
  337. int status;
  338. int silentflag = 0;
  339. bool DataDirOK; /* We have a usable PGDATA value */
  340. char hostbuf[MAXHOSTNAMELEN];
  341. int nonblank_argc;
  343. /*
  344.  * We need three params so we can display status.  If we don't get
  345.  * them from the user, let's make them ourselves.
  346.  */
  347. if (argc < 5)
  348. {
  349. int i;
  350. char    *new_argv[6];
  352. for (i = 0; i < argc; i++)
  353. new_argv[i] = argv[i];
  354. for (; i < 5; i++)
  355. new_argv[i] = "";
  356. new_argv[5] = NULL;
  358. if (!Execfile[0] && FindExec(Execfile, argv[0], "postmaster") < 0)
  359. {
  360. fprintf(stderr, "%s: could not find postmaster to execute...n",
  361. argv[0]);
  362. exit(1);
  363. }
  364. new_argv[0] = Execfile;
  366. execv(new_argv[0], new_argv);
  368. /* How did we get here, error! */
  369. perror(new_argv[0]);
  370. fprintf(stderr, "PostmasterMain execv failed on %sn", argv[0]);
  371. exit(1);
  372. }
  374. progname = argv[0];
  375. real_argv = argv;
  376. real_argc = argc;
  378. /*
  379.  * don't process any dummy args we placed at the end for status
  380.  * display
  381.  */
  382. for (nonblank_argc = argc; nonblank_argc > 0; nonblank_argc--)
  383. if (argv[nonblank_argc - 1] != NULL && argv[nonblank_argc - 1][0] != '')
  384. break;
  386. /*
  387.  * for security, no dir or file created can be group or other
  388.  * accessible
  389.  */
  390. umask((mode_t) 0077);
  392. if (!(hostName = getenv("PGHOST")))
  393. {
  394. if (gethostname(hostbuf, MAXHOSTNAMELEN) < 0)
  395. strcpy(hostbuf, "localhost");
  396. hostName = hostbuf;
  397. }
  399. MyProcPid = getpid();
  400. DataDir = getenv("PGDATA"); /* default value */
  402. opterr = 0;
  403. while ((opt = getopt(nonblank_argc, argv, "A:a:B:b:D:dim:MN:no:p:Ss")) != EOF)
  404. {
  405. switch (opt)
  406. {
  407. case 'A':
  408. #ifndef USE_ASSERT_CHECKING
  409. fprintf(stderr, "Assert checking is not enabledn");
  410. #else
  412. /*
  413.  * Pass this option also to each backend.
  414.  */
  415. assert_enabled = atoi(optarg);
  416. strcat(ExtraOptions, " -A ");
  417. strcat(ExtraOptions, optarg);
  418. #endif
  419. break;
  420. case 'a':
  421. /* Can no longer set authentication method. */
  422. break;
  423. case 'B':
  425. /*
  426.  * The number of buffers to create.  Setting this option
  427.  * means we have to start each backend with a -B # to make
  428.  * sure they know how many buffers were allocated.
  429.  */
  430. NBuffers = atoi(optarg);
  431. strcat(ExtraOptions, " -B ");
  432. strcat(ExtraOptions, optarg);
  433. break;
  434. case 'b':
  435. /* Set the backend executable file to use. */
  436. if (!ValidateBinary(optarg))
  437. strcpy(Execfile, optarg);
  438. else
  439. {
  440. fprintf(stderr, "%s: invalid backend "%s"n",
  441. progname, optarg);
  442. exit(2);
  443. }
  444. break;
  445. case 'D':
  446. /* Set PGDATA from the command line. */
  447. DataDir = optarg;
  448. break;
  449. case 'd':
  451. /*
  452.  * Turn on debugging for the postmaster and the backend
  453.  * servers descended from it.
  454.  */
  455. if ((optind < nonblank_argc) && *argv[optind] != '-')
  456. {
  457. DebugLvl = atoi(argv[optind]);
  458. optind++;
  459. }
  460. else
  461. DebugLvl = 1;
  462. pg_options[TRACE_VERBOSE] = DebugLvl;
  463. break;
  464. case 'i':
  465. NetServer = true;
  466. break;
  467. case 'm':
  468. /* Multiplexed backends no longer supported. */
  469. break;
  470. case 'M':
  472. /*
  473.  * ignore this flag.  This may be passed in because the
  474.  * program was run as 'postgres -M' instead of
  475.  * 'postmaster'
  476.  */
  477. break;
  478. case 'N':
  480. /*
  481.  * The max number of backends to start. Can't set to less
  482.  * than 1 or more than compiled-in limit.
  483.  */
  484. MaxBackends = atoi(optarg);
  485. if (MaxBackends < 1)
  486. MaxBackends = 1;
  487. if (MaxBackends > MAXBACKENDS)
  488. MaxBackends = MAXBACKENDS;
  489. break;
  490. case 'n':
  491. /* Don't reinit shared mem after abnormal exit */
  492. Reinit = false;
  493. break;
  494. case 'o':
  496. /*
  497.  * Other options to pass to the backend on the command
  498.  * line -- useful only for debugging.
  499.  */
  500. strcat(ExtraOptions, " ");
  501. strcat(ExtraOptions, optarg);
  502. break;
  503. case 'p':
  504. /* Set PGPORT by hand. */
  505. PostPortName = (unsigned short) atoi(optarg);
  506. break;
  507. case 'S':
  509. /*
  510.  * Start in 'S'ilent mode (disassociate from controlling
  511.  * tty). You may also think of this as 'S'ysV mode since
  512.  * it's most badly needed on SysV-derived systems like
  513.  * SVR4 and HP-UX.
  514.  */
  515. silentflag = 1;
  516. break;
  517. case 's':
  519. /*
  520.  * In the event that some backend dumps core, send
  521.  * SIGSTOP, rather than SIGUSR1, to all its peers. This
  522.  * lets the wily post_hacker collect core dumps from
  523.  * everyone.
  524.  */
  525. SendStop = true;
  526. break;
  527. default:
  528. /* usage() never returns */
  529. usage(progname);
  530. break;
  531. }
  532. }
  534. /*
  535.  * Select default values for switches where needed
  536.  */
  537. if (PostPortName == 0)
  538. PostPortName = (unsigned short)pq_getport();
  540. /*
  541.  * Check for invalid combinations of switches
  542.  */
  543. if (NBuffers < 2 * MaxBackends || NBuffers < 16)
  544. {
  545. /* Do not accept -B so small that backends are likely to starve for
  546.  * lack of buffers.  The specific choices here are somewhat arbitrary.
  547.  */
  548. fprintf(stderr, "%s: -B must be at least twice -N and at least 16.n",
  549. progname);
  550. exit(1);
  551. }
  553. checkDataDir(DataDir, &DataDirOK); /* issues error messages */
  554. if (!DataDirOK)
  555. {
  556. fprintf(stderr, "No data directory -- can't proceed.n");
  557. exit(2);
  558. }
  560. if (!Execfile[0] && FindExec(Execfile, argv[0], "postgres") < 0)
  561. {
  562. fprintf(stderr, "%s: could not find backend to execute...n",
  563. argv[0]);
  564. exit(1);
  565. }
  567. if (NetServer)
  568. {
  569. status = StreamServerPort(hostName, PostPortName, &ServerSock_INET);
  570. if (status != STATUS_OK)
  571. {
  572. fprintf(stderr, "%s: cannot create INET stream portn",
  573. progname);
  574. exit(1);
  575. }
  576. }
  577. #ifndef __CYGWIN32__
  578. status = StreamServerPort(NULL, PostPortName, &ServerSock_UNIX);
  579. if (status != STATUS_OK)
  580. {
  581. fprintf(stderr, "%s: cannot create UNIX stream portn",
  582. progname);
  583. exit(1);
  584. }
  585. #endif
  586. /* set up shared memory and semaphores */
  587. EnableMemoryContext(TRUE);
  588. reset_shared(PostPortName);
  590. /*
  591.  * Initialize the list of active backends. This list is only used for
  592.  * garbage collecting the backend processes.
  593.  */
  594. BackendList = DLNewList();
  595. PortList = DLNewList();
  597. if (silentflag)
  598. pmdaemonize();
  600. /*
  601.  * Set up signal handlers for the postmaster process.
  602.  */
  604. pqsignal(SIGHUP, pmdie); /* send SIGHUP, don't die */
  605. pqsignal(SIGINT, pmdie); /* die */
  606. pqsignal(SIGQUIT, pmdie); /* send SIGTERM and die */
  607. pqsignal(SIGTERM, pmdie); /* send SIGTERM,SIGKILL and die */
  608. pqsignal(SIGPIPE, SIG_IGN); /* ignored */
  609. pqsignal(SIGUSR1, pmdie); /* send SIGUSR1 and die */
  610. pqsignal(SIGUSR2, pmdie); /* send SIGUSR2, don't die */
  611. pqsignal(SIGCHLD, reaper); /* handle child termination */
  612. pqsignal(SIGTTIN, SIG_IGN); /* ignored */
  613. pqsignal(SIGTTOU, SIG_IGN); /* ignored */
  614. pqsignal(SIGWINCH, dumpstatus); /* dump port status */
  616. status = ServerLoop();
  618. ExitPostmaster(status != STATUS_OK);
  619. return 0; /* not reached */
  620. }
  622. static void
  623. pmdaemonize(void)
  624. {
  625. int i;
  627. if (fork())
  628. _exit(0);
  629. /* GH: If there's no setsid(), we hopefully don't need silent mode.
  630.  * Until there's a better solution.
  631.  */
  632. #ifdef HAVE_SETSID
  633. if (setsid() < 0)
  634. {
  635. fprintf(stderr, "%s: ", progname);
  636. perror("cannot disassociate from controlling TTY");
  637. exit(1);
  638. }
  639. #endif
  640. #ifndef __CYGWIN32__
  641. i = open(NULL_DEV, O_RDWR);
  642. #else
  643. i = open(NULL_DEV, O_RDWR | O_BINARY);
  644. #endif
  645. dup2(i, 0);
  646. dup2(i, 1);
  647. dup2(i, 2);
  648. close(i);
  649. }
  651. static void
  652. usage(const char *progname)
  653. {
  654. fprintf(stderr, "usage: %s [options]n", progname);
  655. #ifdef USE_ASSERT_CHECKING
  656. fprintf(stderr, "t-A [1|0]tenable/disable runtime assert checkingn");
  657. #endif
  658. fprintf(stderr, "t-B nbufstset number of shared buffersn");
  659. fprintf(stderr, "t-D datadirtset data directoryn");
  660. fprintf(stderr, "t-S ttsilent mode (disassociate from tty)n");
  661. fprintf(stderr, "t-a systemtuse this authentication systemn");
  662. fprintf(stderr, "t-b backendtuse a specific backend server executablen");
  663. fprintf(stderr, "t-d [1|2|3]tset debugging leveln");
  664. fprintf(stderr, "t-i ttlisten on TCP/IP sockets as well as Unix domain socketn");
  665. fprintf(stderr, "t-N nprocstset max number of backends (1..%d, default %d)n",
  666. MAXBACKENDS, DEF_MAXBACKENDS);
  667. fprintf(stderr, "t-n ttdon't reinitialize shared memory after abnormal exitn");
  668. fprintf(stderr, "t-o optiontpass 'option' to each backend serversn");
  669. fprintf(stderr, "t-p porttspecify port for postmaster to listen onn");
  670. fprintf(stderr, "t-s ttsend SIGSTOP to all backend servers if one diesn");
  671. exit(1);
  672. }
  674. static int
  675. ServerLoop(void)
  676. {
  677. fd_set readmask,
  678. writemask;
  679. int nSockets;
  680. Dlelem    *curr;
  681. struct timeval now,
  682. later;
  683. struct timezone tz;
  685. gettimeofday(&now, &tz);
  687. nSockets = initMasks(&readmask, &writemask);
  689. #ifdef HAVE_SIGPROCMASK
  690. sigprocmask(0, NULL, &oldsigmask);
  691. sigemptyset(&newsigmask);
  692. sigaddset(&newsigmask, SIGCHLD);
  693. #endif
  695. for (;;)
  696. {
  697. Port    *port;
  698. fd_set rmask,
  699. wmask;
  701. #ifdef HAVE_SIGPROCMASK
  702. sigprocmask(SIG_SETMASK, &oldsigmask, 0);
  703. #else
  704. sigsetmask(orgsigmask);
  705. #endif
  707. memmove((char *) &rmask, (char *) &readmask, sizeof(fd_set));
  708. memmove((char *) &wmask, (char *) &writemask, sizeof(fd_set));
  709. if (select(nSockets, &rmask, &wmask, (fd_set *) NULL,
  710.    (struct timeval *) NULL) < 0)
  711. {
  712. if (errno == EINTR)
  713. continue;
  714. fprintf(stderr, "%s: ServerLoop: select failed: %sn",
  715. progname, strerror(errno));
  716. return STATUS_ERROR;
  717. }
  719. /*
  720.  * Select a random seed at the time of first receiving a request.
  721.  */
  722. while (random_seed == 0)
  723. {
  724. gettimeofday(&later, &tz);
  726. /*
  727.  * We are not sure how much precision is in tv_usec, so we
  728.  * swap the nibbles of 'later' and XOR them with 'now'. On the
  729.  * off chance that the result is 0, we loop until it isn't.
  730.  */
  731. random_seed = now.tv_usec ^
  732. ((later.tv_usec << 16) |
  733.  ((later.tv_usec >> 16) & 0xffff));
  734. }
  736. /*
  737.  * [TRH] To avoid race conditions, block SIGCHLD signals while we
  738.  * are handling the request. (both reaper() and ConnCreate()
  739.  * manipulate the BackEnd list, and reaper() calls free() which is
  740.  * usually non-reentrant.)
  741.  */
  742. #ifdef HAVE_SIGPROCMASK
  743. sigprocmask(SIG_BLOCK, &newsigmask, &oldsigmask);
  744. #else
  745. sigblock(sigmask(SIGCHLD)); /* XXX[TRH] portability */
  746. #endif
  748. /* new connection pending on our well-known port's socket */
  750. #ifndef __CYGWIN32__
  751. if (ServerSock_UNIX != INVALID_SOCK &&
  752. FD_ISSET(ServerSock_UNIX, &rmask) &&
  753. (port = ConnCreate(ServerSock_UNIX)) != NULL)
  754. PacketReceiveSetup(&port->pktInfo,
  755.    readStartupPacket,
  756.    (void *) port);
  757. #endif
  759. if (ServerSock_INET != INVALID_SOCK &&
  760. FD_ISSET(ServerSock_INET, &rmask) &&
  761. (port = ConnCreate(ServerSock_INET)) != NULL)
  762. PacketReceiveSetup(&port->pktInfo,
  763.    readStartupPacket,
  764.    (void *) port);
  766. /* Build up new masks for select(). */
  768. nSockets = initMasks(&readmask, &writemask);
  770. curr = DLGetHead(PortList);
  772. while (curr)
  773. {
  774. Port    *port = (Port *) DLE_VAL(curr);
  775. int status = STATUS_OK;
  776. Dlelem    *next;
  778. if (FD_ISSET(port->sock, &rmask))
  779. {
  780. if (DebugLvl > 1)
  781. fprintf(stderr, "%s: ServerLoop:tthandling reading %dn",
  782. progname, port->sock);
  784. if (PacketReceiveFragment(&port->pktInfo, port->sock) != STATUS_OK)
  785. status = STATUS_ERROR;
  786. }
  788. if (FD_ISSET(port->sock, &wmask))
  789. {
  790. if (DebugLvl > 1)
  791. fprintf(stderr, "%s: ServerLoop:tthandling writing %dn",
  792. progname, port->sock);
  794. if (PacketSendFragment(&port->pktInfo, port->sock) != STATUS_OK)
  795. status = STATUS_ERROR;
  796. }
  798. /* Get this before the connection might be closed. */
  800. next = DLGetSucc(curr);
  802. /*
  803.  * If there is no error and no outstanding data transfer going
  804.  * on, then the authentication handshake must be complete to
  805.  * the postmaster's satisfaction.  So, start the backend.
  806.  */
  808. if (status == STATUS_OK && port->pktInfo.state == Idle)
  809. {
  810. /* Can't start backend if max backend count is exceeded. */
  811. if (CountChildren() >= MaxBackends)
  812. PacketSendError(&port->pktInfo,
  813. "Sorry, too many clients already");
  814. else
  815. {
  817. /*
  818.  * If the backend start fails then keep the connection
  819.  * open to report it.  Otherwise, pretend there is an
  820.  * error to close the connection which will now be
  821.  * managed by the backend.
  822.  */
  823. if (BackendStartup(port) != STATUS_OK)
  824. PacketSendError(&port->pktInfo,
  825. "Backend startup failed");
  826. else
  827. status = STATUS_ERROR;
  828. }
  829. }
  831. /* Close the connection if required. */
  833. if (status != STATUS_OK)
  834. {
  835. StreamClose(port->sock);
  836. DLRemove(curr);
  837. free(port);
  838. DLFreeElem(curr);
  839. }
  840. else
  841. {
  842. /* Set the masks for this connection. */
  844. if (nSockets <= port->sock)
  845. nSockets = port->sock + 1;
  847. if (port->pktInfo.state == WritingPacket)
  848. FD_SET(port->sock, &writemask);
  849. else
  850. FD_SET(port->sock, &readmask);
  851. }
  853. curr = next;
  854. }
  855. }
  856. }
  859. /*
  860.  * Initialise the read and write masks for select() for the well-known ports
  861.  * we are listening on.  Return the number of sockets to listen on.
  862.  */
  864. static int
  865. initMasks(fd_set *rmask, fd_set *wmask)
  866. {
  867. int nsocks = -1;
  869. FD_ZERO(rmask);
  870. FD_ZERO(wmask);
  872. #ifndef __CYGWIN32__
  873. if (ServerSock_UNIX != INVALID_SOCK)
  874. {
  875. FD_SET(ServerSock_UNIX, rmask);
  877. if (ServerSock_UNIX > nsocks)
  878. nsocks = ServerSock_UNIX;
  879. }
  880. #endif
  882. if (ServerSock_INET != INVALID_SOCK)
  883. {
  884. FD_SET(ServerSock_INET, rmask);
  886. if (ServerSock_INET > nsocks)
  887. nsocks = ServerSock_INET;
  888. }
  890. return nsocks + 1;
  891. }
  894. /*
  895.  * Called when the startup packet has been read.
  896.  */
  898. static int
  899. readStartupPacket(void *arg, PacketLen len, void *pkt)
  900. {
  901. Port    *port;
  902. StartupPacket *si;
  904. port = (Port *) arg;
  905. si = (StartupPacket *) pkt;
  907. /*
  908.  * The first field is either a protocol version number or a special
  909.  * request code.
  910.  */
  912. port->proto = ntohl(si->protoVersion);
  914. if (port->proto == CANCEL_REQUEST_CODE)
  915. return processCancelRequest(port, len, pkt);
  917. /* Could add additional special packet types here */
  919. /* Check we can handle the protocol the frontend is using. */
  921. if (PG_PROTOCOL_MAJOR(port->proto) < PG_PROTOCOL_MAJOR(PG_PROTOCOL_EARLIEST) ||
  922. PG_PROTOCOL_MAJOR(port->proto) > PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST) ||
  923. (PG_PROTOCOL_MAJOR(port->proto) == PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST) &&
  924.  PG_PROTOCOL_MINOR(port->proto) > PG_PROTOCOL_MINOR(PG_PROTOCOL_LATEST)))
  925. {
  926. PacketSendError(&port->pktInfo, "Unsupported frontend protocol.");
  927. return STATUS_OK; /* don't close the connection yet */
  928. }
  930. /*
  931.  * Get the parameters from the startup packet as C strings.  The
  932.  * packet destination was cleared first so a short packet has zeros
  933.  * silently added and a long packet is silently truncated.
  934.  */
  936. StrNCpy(port->database, si->database, sizeof(port->database) - 1);
  937. StrNCpy(port->user, si->user, sizeof(port->user) - 1);
  938. StrNCpy(port->options, si->options, sizeof(port->options) - 1);
  939. StrNCpy(port->tty, si->tty, sizeof(port->tty) - 1);
  941. /* The database defaults to the user name. */
  943. if (port->database[0] == '')
  944. StrNCpy(port->database, si->user, sizeof(port->database) - 1);
  946. /* Check a user name was given. */
  948. if (port->user[0] == '')
  949. {
  950. PacketSendError(&port->pktInfo,
  951. "No Postgres username specified in startup packet.");
  952. return STATUS_OK; /* don't close the connection yet */
  953. }
  955. /* Start the authentication itself. */
  957. be_recvauth(port);
  959. return STATUS_OK; /* don't close the connection yet */
  960. }
  963. /*
  964.  * The client has sent a cancel request packet, not a normal
  965.  * start-a-new-backend packet. Perform the necessary processing.
  966.  * Note that in any case, we return STATUS_ERROR to close the
  967.  * connection immediately. Nothing is sent back to the client.
  968.  */
  970. static int
  971. processCancelRequest(Port *port, PacketLen len, void *pkt)
  972. {
  973. CancelRequestPacket *canc = (CancelRequestPacket *) pkt;
  974. int backendPID;
  975. long cancelAuthCode;
  976. Dlelem    *curr;
  977. Backend    *bp;
  979. backendPID = (int) ntohl(canc->backendPID);
  980. cancelAuthCode = (long) ntohl(canc->cancelAuthCode);
  982. /* See if we have a matching backend */
  984. for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  985. {
  986. bp = (Backend *) DLE_VAL(curr);
  987. if (bp->pid == backendPID)
  988. {
  989. if (bp->cancel_key == cancelAuthCode)
  990. {
  991. /* Found a match; signal that backend to cancel current op */
  992. if (DebugLvl)
  993. fprintf(stderr, "%s: processCancelRequest: sending SIGINT to process %dn",
  994. progname, bp->pid);
  995. kill(bp->pid, SIGINT);
  996. }
  997. else
  998. {
  999. /* Right PID, wrong key: no way, Jose */
  1000. if (DebugLvl)
  1001. fprintf(stderr, "%s: processCancelRequest: bad key in cancel request for process %dn",
  1002. progname, bp->pid);
  1003. }
  1004. return STATUS_ERROR;
  1005. }
  1006. }
  1008. /* No matching backend */
  1009. if (DebugLvl)
  1010. fprintf(stderr, "%s: processCancelRequest: bad PID in cancel request for process %dn",
  1011. progname, backendPID);
  1013. return STATUS_ERROR;
  1014. }
  1017. /*
  1018.  * ConnCreate -- create a local connection data structure
  1019.  */
  1020. static Port *
  1021. ConnCreate(int serverFd)
  1022. {
  1023. Port    *port;
  1026. if (!(port = (Port *) calloc(1, sizeof(Port))))
  1027. {
  1028. fprintf(stderr, "%s: ConnCreate: malloc failedn",
  1029. progname);
  1030. ExitPostmaster(1);
  1031. }
  1033. if (StreamConnection(serverFd, port) != STATUS_OK)
  1034. {
  1035. StreamClose(port->sock);
  1036. free(port);
  1037. port = NULL;
  1038. }
  1039. else
  1040. {
  1041. DLAddHead(PortList, DLNewElem(port));
  1042. RandomSalt(port->salt);
  1043. port->pktInfo.state = Idle;
  1044. }
  1046. return port;
  1047. }
  1049. /*
  1050.  * reset_shared -- reset shared memory and semaphores
  1051.  */
  1052. static void
  1053. reset_shared(unsigned short port)
  1054. {
  1055. ipc_key = port * 1000 + shmem_seq * 100;
  1056. CreateSharedMemoryAndSemaphores(ipc_key, MaxBackends);
  1057. ActiveBackends = FALSE;
  1058. shmem_seq += 1;
  1059. if (shmem_seq >= 10)
  1060. shmem_seq -= 10;
  1061. }
  1063. /*
  1064.  * pmdie -- signal handler for cleaning up after a kill signal.
  1065.  */
  1066. static void
  1067. pmdie(SIGNAL_ARGS)
  1068. {
  1069. int i;
  1071. TPRINTF(TRACE_VERBOSE, "pmdie %d", postgres_signal_arg);
  1073. /*
  1074.  * Kill self and/or children processes depending on signal number.
  1075.  */
  1076. switch (postgres_signal_arg)
  1077. {
  1078. case SIGHUP:
  1079. /* Send SIGHUP to all children (update options flags) */
  1080. SignalChildren(SIGHUP);
  1081. /* Don't die */
  1082. return;
  1083. case SIGINT:
  1084. /* Die without killing children */
  1085. break;
  1086. case SIGQUIT:
  1087. /* Shutdown all children with SIGTERM */
  1088. SignalChildren(SIGTERM);
  1089. /* Don't die */
  1090. return;
  1091. case SIGTERM:
  1092. /* Shutdown all children with SIGTERM and SIGKILL, then die */
  1093. SignalChildren(SIGTERM);
  1094. for (i = 0; i < 10; i++)
  1095. {
  1096. if (!DLGetHead(BackendList))
  1097. break;
  1098. sleep(1);
  1099. }
  1100. if (DLGetHead(BackendList))
  1101. SignalChildren(SIGKILL);
  1102. break;
  1103. case SIGUSR1:
  1104. /* Quick die all children with SIGUSR1 and die */
  1105. SignalChildren(SIGUSR1);
  1106. break;
  1107. case SIGUSR2:
  1108. /* Send SIGUSR2 to all children (AsyncNotifyHandler) */
  1109. SignalChildren(SIGUSR2);
  1110. /* Don't die */
  1111. return;
  1112. }
  1114. /* exit postmaster */
  1115. proc_exit(0);
  1116. }
  1118. /*
  1119.  * Reaper -- signal handler to cleanup after a backend (child) dies.
  1120.  */
  1121. static void
  1122. reaper(SIGNAL_ARGS)
  1123. {
  1124. /* GH: replace waitpid for !HAVE_WAITPID. Does this work ? */
  1125. #ifdef HAVE_WAITPID
  1126. int status; /* backend exit status */
  1128. #else
  1129. union wait statusp; /* backend exit status */
  1131. #endif
  1132. int pid; /* process id of dead backend */
  1134. if (DebugLvl)
  1135. fprintf(stderr, "%s: reaping dead processes...n",
  1136. progname);
  1137. #ifdef HAVE_WAITPID
  1138. while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
  1139. {
  1140. CleanupProc(pid, status);
  1141. pqsignal(SIGCHLD, reaper);
  1142. }
  1143. #else
  1144. while ((pid = wait3(&statusp, WNOHANG, NULL)) > 0)
  1145. {
  1146. CleanupProc(pid, statusp.w_status);
  1147. pqsignal(SIGCHLD, reaper);
  1148. }
  1149. #endif
  1150. }
  1152. /*
  1153.  * CleanupProc -- cleanup after terminated backend.
  1154.  *
  1155.  * Remove all local state associated with backend.
  1156.  *
  1157.  * Dillon's note: should log child's exit status in the system log.
  1158.  */
  1159. static void
  1160. CleanupProc(int pid,
  1161. int exitstatus) /* child's exit status. */
  1162. {
  1163. Dlelem    *prev,
  1164.    *curr;
  1165. Backend    *bp;
  1166. int sig;
  1168. if (DebugLvl)
  1169. {
  1170. fprintf(stderr, "%s: CleanupProc: pid %d exited with status %dn",
  1171. progname, pid, exitstatus);
  1172. }
  1174. /*
  1175.  * If a backend dies in an ugly way (i.e. exit status not 0) then we
  1176.  * must signal all other backends to quickdie. If exit status is zero
  1177.  * we assume everything is hunky dory and simply remove the backend
  1178.  * from the active backend list.
  1179.  */
  1180. if (!exitstatus)
  1181. {
  1182. curr = DLGetHead(BackendList);
  1183. while (curr)
  1184. {
  1185. bp = (Backend *) DLE_VAL(curr);
  1186. if (bp->pid == pid)
  1187. {
  1188. DLRemove(curr);
  1189. free(bp);
  1190. DLFreeElem(curr);
  1191. break;
  1192. }
  1193. curr = DLGetSucc(curr);
  1194. }
  1196. ProcRemove(pid);
  1198. return;
  1199. }
  1201. curr = DLGetHead(BackendList);
  1202. while (curr)
  1203. {
  1204. bp = (Backend *) DLE_VAL(curr);
  1206. /* -----------------
  1207.  * SIGUSR1 is the special signal that says exit
  1208.  * without proc_exit and let the user know what's going on.
  1209.  * ProcSemaphoreKill() cleans up the backends semaphore.  If
  1210.  * SendStop is set (-s on command line), then we send a SIGSTOP so
  1211.  * that we can core dumps from all backends by hand.
  1212.  * -----------------
  1213.  */
  1214. sig = (SendStop) ? SIGSTOP : SIGUSR1;
  1215. if (bp->pid != pid)
  1216. {
  1217. if (DebugLvl)
  1218. fprintf(stderr, "%s: CleanupProc: sending %s to process %dn",
  1219. progname,
  1220. (sig == SIGUSR1)
  1221. ? "SIGUSR1" : "SIGSTOP",
  1222. bp->pid);
  1223. kill(bp->pid, sig);
  1224. }
  1225. ProcRemove(bp->pid);
  1227. prev = DLGetPred(curr);
  1228. DLRemove(curr);
  1229. free(bp);
  1230. DLFreeElem(curr);
  1231. if (!prev)
  1232. { /* removed head */
  1233. curr = DLGetHead(BackendList);
  1234. continue;
  1235. }
  1236. curr = DLGetSucc(prev);
  1237. }
  1239. /*
  1240.  * Nothing up my sleeve here, ActiveBackends means that since the last
  1241.  * time we recreated shared memory and sems another frontend has
  1242.  * requested and received a connection and I have forked off another
  1243.  * backend.  This prevents me from reinitializing shared stuff more
  1244.  * than once for the set of backends that caused the failure and were
  1245.  * killed off.
  1246.  */
  1247. if (ActiveBackends == TRUE && Reinit)
  1248. {
  1249. if (DebugLvl)
  1250. fprintf(stderr, "%s: CleanupProc: reinitializing shared memory and semaphoresn",
  1251. progname);
  1252. shmem_exit(0);
  1253. reset_shared(PostPortName);
  1254. }
  1255. }
  1257. /*
  1258.  * Send a signal to all chidren processes.
  1259.  */
  1260. static void
  1261. SignalChildren(int signal)
  1262. {
  1263. Dlelem    *curr,
  1264.    *next;
  1265. Backend    *bp;
  1266. int mypid = getpid();
  1268. curr = DLGetHead(BackendList);
  1269. while (curr)
  1270. {
  1271. next = DLGetSucc(curr);
  1272. bp = (Backend *) DLE_VAL(curr);
  1274. if (bp->pid != mypid)
  1275. {
  1276. TPRINTF(TRACE_VERBOSE,
  1277. "SignalChildren: sending signal %d to process %d",
  1278. signal, bp->pid);
  1279. kill(bp->pid, signal);
  1280. }
  1282. curr = next;
  1283. }
  1284. }
  1286. /*
  1287.  * BackendStartup -- start backend process
  1288.  *
  1289.  * returns: STATUS_ERROR if the fork/exec failed, STATUS_OK
  1290.  * otherwise.
  1291.  *
  1292.  */
  1293. static int
  1294. BackendStartup(Port *port)
  1295. {
  1296. Backend    *bn; /* for backend cleanup */
  1297. int pid,
  1298. i;
  1300. #ifdef CYR_RECODE
  1301. #define NR_ENVIRONMENT_VBL 6
  1302. char ChTable[80];
  1304. #else
  1305. #define NR_ENVIRONMENT_VBL 5
  1306. #endif
  1308. static char envEntry[NR_ENVIRONMENT_VBL][2 * ARGV_SIZE];
  1310. for (i = 0; i < NR_ENVIRONMENT_VBL; ++i)
  1311. MemSet(envEntry[i], 0, 2 * ARGV_SIZE);
  1313. /*
  1314.  * Set up the necessary environment variables for the backend This
  1315.  * should really be some sort of message....
  1316.  */
  1317. sprintf(envEntry[0], "POSTPORT=%d", PostPortName);
  1318. putenv(envEntry[0]);
  1319. sprintf(envEntry[1], "POSTID=%d", NextBackendTag);
  1320. putenv(envEntry[1]);
  1321. sprintf(envEntry[2], "PG_USER=%s", port->user);
  1322. putenv(envEntry[2]);
  1323. if (!getenv("PGDATA"))
  1324. {
  1325. sprintf(envEntry[3], "PGDATA=%s", DataDir);
  1326. putenv(envEntry[3]);
  1327. }
  1328. sprintf(envEntry[4], "IPC_KEY=%d", ipc_key);
  1329. putenv(envEntry[4]);
  1331. #ifdef CYR_RECODE
  1332. GetCharSetByHost(ChTable, port->raddr.in.sin_addr.s_addr, DataDir);
  1333. if (*ChTable != '')
  1334. {
  1335. sprintf(envEntry[5], "PG_RECODETABLE=%s", ChTable);
  1336. putenv(envEntry[5]);
  1337. }
  1338. #endif
  1340. /*
  1341.  * Compute the cancel key that will be assigned to this backend. The
  1342.  * backend will have its own copy in the forked-off process' value of
  1343.  * MyCancelKey, so that it can transmit the key to the frontend.
  1344.  */
  1345. MyCancelKey = PostmasterRandom();
  1347. if (DebugLvl > 2)
  1348. {
  1349. char   **p;
  1350. extern char **environ;
  1352. fprintf(stderr, "%s: BackendStartup: environ dump:n",
  1353. progname);
  1354. fprintf(stderr, "-----------------------------------------n");
  1355. for (p = environ; *p; ++p)
  1356. fprintf(stderr, "t%sn", *p);
  1357. fprintf(stderr, "-----------------------------------------n");
  1358. }
  1360. /*
  1361.  * Flush stdio channels just before fork, to avoid double-output
  1362.  * problems. Ideally we'd use fflush(NULL) here, but there are still a
  1363.  * few non-ANSI stdio libraries out there (like SunOS 4.1.x) that
  1364.  * coredump if we do. Presently stdout and stderr are the only stdio
  1365.  * output channels used by the postmaster, so fflush'ing them should
  1366.  * be sufficient.
  1367.  */
  1368. fflush(stdout);
  1369. fflush(stderr);
  1371. if ((pid = fork()) == 0)
  1372. { /* child */
  1373. if (DoBackend(port))
  1374. {
  1375. fprintf(stderr, "%s child[%d]: BackendStartup: backend startup failedn",
  1376. progname, (int) getpid());
  1377. exit(1);
  1378. }
  1379. else
  1380. exit(0);
  1381. }
  1383. /* in parent */
  1384. if (pid < 0)
  1385. {
  1386. fprintf(stderr, "%s: BackendStartup: fork failed: %sn",
  1387. progname, strerror(errno));
  1388. return STATUS_ERROR;
  1389. }
  1391. if (DebugLvl)
  1392. fprintf(stderr, "%s: BackendStartup: pid %d user %s db %s socket %dn",
  1393. progname, pid, port->user, port->database,
  1394. port->sock);
  1396. /* Generate a new backend tag for every backend we start */
  1398. /*
  1399.  * XXX theoretically this could wrap around, if you have the patience
  1400.  * to start 2^31 backends ...
  1401.  */
  1402. NextBackendTag -= 1;
  1404. /*
  1405.  * Everything's been successful, it's safe to add this backend to our
  1406.  * list of backends.
  1407.  */
  1408. if (!(bn = (Backend *) calloc(1, sizeof(Backend))))
  1409. {
  1410. fprintf(stderr, "%s: BackendStartup: malloc failedn",
  1411. progname);
  1412. ExitPostmaster(1);
  1413. }
  1415. bn->pid = pid;
  1416. bn->cancel_key = MyCancelKey;
  1417. DLAddHead(BackendList, DLNewElem(bn));
  1419. ActiveBackends = TRUE;
  1421. return STATUS_OK;
  1422. }
  1424. /*
  1425.  * split_opts -- split a string of options and append it to an argv array
  1426.  *
  1427.  * NB: the string is destructively modified!
  1428.  *
  1429.  * Since no current POSTGRES arguments require any quoting characters,
  1430.  * we can use the simple-minded tactic of assuming each set of space-
  1431.  * delimited characters is a separate argv element.
  1432.  *
  1433.  * If you don't like that, well, we *used* to pass the whole option string
  1434.  * as ONE argument to execl(), which was even less intelligent...
  1435.  */
  1436. static void
  1437. split_opts(char **argv, int *argcp, char *s)
  1438. {
  1439. int i = *argcp;
  1441. while (s && *s)
  1442. {
  1443. while (isspace(*s))
  1444. ++s;
  1445. if (*s == '')
  1446. break;
  1447. argv[i++] = s;
  1448. while (*s && !isspace(*s))
  1449. ++s;
  1450. if (*s)
  1451. *s++ = '';
  1452. }
  1454. *argcp = i;
  1455. }
  1457. /*
  1458.  * DoBackend -- set up the backend's argument list and invoke backend main().
  1459.  *
  1460.  * This used to perform an execv() but we no longer exec the backend;
  1461.  * it's the same executable as the postmaster.
  1462.  *
  1463.  * returns:
  1464.  * Shouldn't return at all.
  1465.  * If PostgresMain() fails, return status.
  1466.  */
  1467. static int
  1468. DoBackend(Port *port)
  1469. {
  1470. char    *av[ARGV_SIZE * 2];
  1471. int ac = 0;
  1472. char execbuf[MAXPATHLEN];
  1473. char debugbuf[ARGV_SIZE];
  1474. char protobuf[ARGV_SIZE];
  1475. char dbbuf[ARGV_SIZE];
  1476. char optbuf[ARGV_SIZE];
  1477. char ttybuf[ARGV_SIZE];
  1478. int i;
  1479. struct timeval now;
  1480. struct timezone tz;
  1482. /*
  1483.  * Let's clean up ourselves as the postmaster child
  1484.  */
  1486. /* We don't want the postmaster's proc_exit() handlers */
  1487. on_exit_reset();
  1489. /* ----------------
  1490.  * register signal handlers.
  1491.  * Thanks to the postmaster, these are currently blocked.
  1492.  * ----------------
  1493.  */
  1494. pqsignal(SIGINT, die);
  1496. pqsignal(SIGHUP, die);
  1497. pqsignal(SIGTERM, die);
  1498. pqsignal(SIGPIPE, die);
  1499. pqsignal(SIGUSR1, quickdie);
  1500. pqsignal(SIGUSR2, Async_NotifyHandler);
  1501. pqsignal(SIGFPE, FloatExceptionHandler);
  1503. pqsignal(SIGCHLD, SIG_DFL);
  1504. pqsignal(SIGTTIN, SIG_DFL);
  1505. pqsignal(SIGTTOU, SIG_DFL);
  1506. pqsignal(SIGCONT, SIG_DFL);
  1508. /* OK, let's unblock our signals, all together now... */
  1509. sigprocmask(SIG_SETMASK, &oldsigmask, 0);
  1511. /* Close the postmaster sockets */
  1512. if (NetServer)
  1513. StreamClose(ServerSock_INET);
  1514. #ifndef __CYGWIN32__
  1515. StreamClose(ServerSock_UNIX);
  1516. #endif
  1518. /* Save port etc. for ps status */
  1519. MyProcPort = port;
  1521. MyProcPid = getpid();
  1523. /*
  1524.  * Don't want backend to be able to see the postmaster random number
  1525.  * generator state.  We have to clobber the static random_seed *and*
  1526.  * start a new random sequence in the random() library function.
  1527.  */
  1528. random_seed = 0;
  1529. gettimeofday(&now, &tz);
  1530. srandom(now.tv_usec);
  1532. /* ----------------
  1533.  * Now, build the argv vector that will be given to PostgresMain.
  1534.  *
  1535.  * The layout of the command line is
  1536.  * postgres [secure switches] -p databasename [insecure switches]
  1537.  * where the switches after -p come from the client request.
  1538.  * ----------------
  1539.  */
  1541. StrNCpy(execbuf, Execfile, MAXPATHLEN);
  1542. av[ac++] = execbuf;
  1544. /*
  1545.  * We need to set our argv[0] to an absolute path name because some
  1546.  * OS's use this for dynamic loading, like BSDI.  Without it, when we
  1547.  * change directories to the database dir, the dynamic loader can't
  1548.  * find the base executable and fails. Another advantage is that this
  1549.  * changes the 'ps' displayed process name on some platforms.  It does
  1550.  * on BSDI.  That's a big win.
  1551.  */
  1553. #ifndef linux
  1555. /*
  1556.  * This doesn't work on linux and overwrites the only valid pointer to
  1557.  * the argv buffer.  See PS_INIT_STATUS macro.
  1558.  */
  1559. real_argv[0] = Execfile;
  1560. #endif
  1562. /*
  1563.  * Pass the requested debugging level along to the backend.  We
  1564.  * decrement by one; level one debugging in the postmaster traces
  1565.  * postmaster connection activity, and levels two and higher are
  1566.  * passed along to the backend.  This allows us to watch only the
  1567.  * postmaster or the postmaster and the backend.
  1568.  */
  1569. if (DebugLvl > 1)
  1570. {
  1571. sprintf(debugbuf, "-d%d", DebugLvl);
  1572. av[ac++] = debugbuf;
  1573. }
  1575. /*
  1576.  * Pass any backend switches specified with -o in the postmaster's own
  1577.  * command line.  We assume these are secure. (It's OK to mangle
  1578.  * ExtraOptions since we are now in the child process; this won't
  1579.  * change the postmaster's copy.)
  1580.  */
  1581. split_opts(av, &ac, ExtraOptions);
  1583. /* Tell the backend what protocol the frontend is using. */
  1584. sprintf(protobuf, "-v%u", port->proto);
  1585. av[ac++] = protobuf;
  1587. /*
  1588.  * Tell the backend it is being called from the postmaster, and which
  1589.  * database to use.  -p marks the end of secure switches.
  1590.  */
  1591. av[ac++] = "-p";
  1593. StrNCpy(dbbuf, port->database, ARGV_SIZE);
  1594. av[ac++] = dbbuf;
  1596. /*
  1597.  * Pass the (insecure) option switches from the connection request.
  1598.  */
  1599. StrNCpy(optbuf, port->options, ARGV_SIZE);
  1600. split_opts(av, &ac, optbuf);
  1602. /*
  1603.  * Pass the (insecure) debug output file request.
  1604.  *
  1605.  * NOTE: currently, this is useless code, since the backend will not
  1606.  * honor an insecure -o switch.  I left it here since the backend
  1607.  * could be modified to allow insecure -o, given adequate checking
  1608.  * that the specified filename is something safe to write on.
  1609.  */
  1610. if (port->tty[0])
  1611. {
  1612. StrNCpy(ttybuf, port->tty, ARGV_SIZE);
  1613. av[ac++] = "-o";
  1614. av[ac++] = ttybuf;
  1615. }
  1617. av[ac] = (char *) NULL;
  1619. if (DebugLvl > 1)
  1620. {
  1621. fprintf(stderr, "%s child[%d]: starting with (",
  1622. progname, MyProcPid);
  1623. for (i = 0; i < ac; ++i)
  1624. fprintf(stderr, "%s ", av[i]);
  1625. fprintf(stderr, ")n");
  1626. }
  1628. return (PostgresMain(ac, av, real_argc, real_argv));
  1629. }
  1631. /*
  1632.  * ExitPostmaster -- cleanup
  1633.  */
  1634. static void
  1635. ExitPostmaster(int status)
  1636. {
  1637. /* should cleanup shared memory and kill all backends */
  1639. /*
  1640.  * Not sure of the semantics here. When the Postmaster dies, should
  1641.  * the backends all be killed? probably not.
  1642.  */
  1643. if (ServerSock_INET != INVALID_SOCK)
  1644. StreamClose(ServerSock_INET);
  1645. #ifndef __CYGWIN32__
  1646. if (ServerSock_UNIX != INVALID_SOCK)
  1647. StreamClose(ServerSock_UNIX);
  1648. #endif
  1649. proc_exit(status);
  1650. }
  1652. static void
  1653. dumpstatus(SIGNAL_ARGS)
  1654. {
  1655. Dlelem    *curr = DLGetHead(PortList);
  1657. while (curr)
  1658. {
  1659. Port    *port = DLE_VAL(curr);
  1661. fprintf(stderr, "%s: dumpstatus:n", progname);
  1662. fprintf(stderr, "tsock %dn", port->sock);
  1663. curr = DLGetSucc(curr);
  1664. }
  1665. }
  1667. /*
  1668.  * CharRemap
  1669.  */
  1670. static char
  1671. CharRemap(long int ch)
  1672. {
  1674. if (ch < 0)
  1675. ch = -ch;
  1677. ch = ch % 62;
  1678. if (ch < 26)
  1679. return 'A' + ch;
  1681. ch -= 26;
  1682. if (ch < 26)
  1683. return 'a' + ch;
  1685. ch -= 26;
  1686. return '0' + ch;
  1687. }
  1689. /*
  1690.  * RandomSalt
  1691.  */
  1692. static void
  1693. RandomSalt(char *salt)
  1694. {
  1695. long rand = PostmasterRandom();
  1697. *salt = CharRemap(rand % 62);
  1698. *(salt + 1) = CharRemap(rand / 62);
  1699. }
  1701. /*
  1702.  * PostmasterRandom
  1703.  */
  1704. static long
  1705. PostmasterRandom(void)
  1706. {
  1708. static bool initialized = false;
  1710. if (!initialized)
  1711. {
  1712. Assert(random_seed != 0 && !IsUnderPostmaster);
  1713. srandom(random_seed);
  1714. initialized = true;
  1715. }
  1717. return random() ^ random_seed;
  1718. }
  1720. /*
  1721.  * Count up number of child processes.
  1722.  */
  1723. static int
  1724. CountChildren(void)
  1725. {
  1726. Dlelem    *curr;
  1727. Backend    *bp;
  1728. int mypid = getpid();
  1729. int cnt = 0;
  1731. for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  1732. {
  1733. bp = (Backend *) DLE_VAL(curr);
  1734. if (bp->pid != mypid)
  1735. cnt++;
  1736. }
  1737. return cnt;
  1738. }