src/main.cc

   1 /*
   2  * DEBUG: section 01    Startup and Main Loop
   3  * AUTHOR: Harvest Derived
   4  *
   5  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   6  * ----------------------------------------------------------
   7  *
   8  *  Squid is the result of efforts by numerous individuals from
   9  *  the Internet community; see the CONTRIBUTORS file for full
  10  *  details.   Many organizations have provided support for Squid's
  11  *  development; see the SPONSORS file for full details.  Squid is
  12  *  Copyrighted (C) 2001 by the Regents of the University of
  13  *  California; see the COPYRIGHT file for full details.  Squid
  14  *  incorporates software developed and/or copyrighted by other
  15  *  sources; see the CREDITS file for full details.
  16  *
  17  *  This program is free software; you can redistribute it and/or modify
  18  *  it under the terms of the GNU General Public License as published by
  19  *  the Free Software Foundation; either version 2 of the License, or
  20  *  (at your option) any later version.
  21  *
  22  *  This program is distributed in the hope that it will be useful,
  23  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  *  GNU General Public License for more details.
  26  *
  27  *  You should have received a copy of the GNU General Public License
  28  *  along with this program; if not, write to the Free Software
  29  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  30  *
  31  */
  32
  33 #include "squid.h"
  34 #include "AccessLogEntry.h"
  35 #include "acl/Acl.h"
  36 #include "acl/Asn.h"
  37 #include "AuthReg.h"
  38 #include "base/RunnersRegistry.h"
  39 #include "base/Subscription.h"
  40 #include "base/TextException.h"
  41 #include "cache_cf.h"
  42 #include "carp.h"
  43 #include "client_db.h"
  44 #include "client_side.h"
  45 #include "comm.h"
  46 #include "ConfigParser.h"
  47 #include "CpuAffinity.h"
  48 #include "disk.h"
  49 #include "DiskIO/DiskIOModule.h"
  50 #include "errorpage.h"
  51 #include "event.h"
  52 #include "EventLoop.h"
  53 #include "ExternalACL.h"
  54 #include "fd.h"
  55 #include "format/Token.h"
  56 #include "fqdncache.h"
  57 #include "fs/Module.h"
  58 #include "FwdState.h"
  59 #include "globals.h"
  60 #include "htcp.h"
  61 #include "HttpHeader.h"
  62 #include "HttpReply.h"
  63 #include "icmp/IcmpSquid.h"
  64 #include "icmp/net_db.h"
  65 #include "ICP.h"
  66 #include "ident/Ident.h"
  67 #include "ip/tools.h"
  68 #include "ipc/Coordinator.h"
  69 #include "ipc/Kids.h"
  70 #include "ipc/Strand.h"
  71 #include "ipcache.h"
  72 #include "Mem.h"
  73 #include "MemPool.h"
  74 #include "mime.h"
  75 #include "neighbors.h"
  76 #include "parser/Tokenizer.h"
  77 #include "pconn.h"
  78 #include "peer_sourcehash.h"
  79 #include "peer_userhash.h"
  80 #include "PeerSelectState.h"
  81 #include "profiler/Profiler.h"
  82 #include "redirect.h"
  83 #include "refresh.h"
  84 #include "send-announce.h"
  85 #include "SquidConfig.h"
  86 #include "SquidDns.h"
  87 #include "SquidTime.h"
  88 #include "stat.h"
  89 #include "StatCounters.h"
  90 #include "Store.h"
  91 #include "store_log.h"
  92 #include "StoreFileSystem.h"
  93 #include "SwapDir.h"
  94 #include "tools.h"
  95 #include "unlinkd.h"
  96 #include "URL.h"
  97 #include "wccp.h"
  98 #include "wccp2.h"
  99 #include "WinSvc.h"
 100
 101 #if USE_ADAPTATION
 102 #include "adaptation/Config.h"
 103 #endif
 104 #if USE_ECAP
 105 #include "adaptation/ecap/Config.h"
 106 #endif
 107 #if ICAP_CLIENT
 108 #include "adaptation/icap/Config.h"
 109 #include "adaptation/icap/icap_log.h"
 110 #endif
 111 #if USE_AUTH
 112 #include "auth/Gadgets.h"
 113 #endif
 114 #if USE_DELAY_POOLS
 115 #include "ClientDelayConfig.h"
 116 #endif
 117 #if USE_DELAY_POOLS
 118 #include "DelayPools.h"
 119 #endif
 120 #if USE_LOADABLE_MODULES
 121 #include "LoadableModules.h"
 122 #endif
 123 #if USE_SSL_CRTD
 124 #include "ssl/certificate_db.h"
 125 #endif
 126 #if USE_OPENSSL
 127 #include "ssl/context_storage.h"
 128 #include "ssl/helper.h"
 129 #endif
 130 #if ICAP_CLIENT
 131 #include "adaptation/icap/Config.h"
 132 #endif
 133 #if USE_ECAP
 134 #include "adaptation/ecap/Config.h"
 135 #endif
 136 #if USE_ADAPTATION
 137 #include "adaptation/Config.h"
 138 #endif
 139 #if USE_SQUID_ESI
 140 #include "esi/Module.h"
 141 #endif
 142 #if SQUID_SNMP
 143 #include "snmp_core.h"
 144 #endif
 145
 146 #include <cerrno>
 147 #if HAVE_PATHS_H
 148 #include <paths.h>
 149 #endif
 150 #if HAVE_SYS_WAIT_H
 151 #include <sys/wait.h>
 152 #endif
 153
 154 #if USE_WIN32_SERVICE
 155 #include <process.h>
 156
 157 static int opt_install_service = FALSE;
 158 static int opt_remove_service = FALSE;
 159 static int opt_command_line = FALSE;
 160 void WIN32_svcstatusupdate(DWORD, DWORD);
 161 void WINAPI WIN32_svcHandler(DWORD);
 162 #endif
 163
 164 static int opt_signal_service = FALSE;
 165 static char *opt_syslog_facility = NULL;
 166 static int icpPortNumOverride = 1;      /* Want to detect "-u 0" */
 167 static int configured_once = 0;
 168 #if MALLOC_DBG
 169 static int malloc_debug_level = 0;
 170 #endif
 171 static volatile int do_reconfigure = 0;
 172 static volatile int do_rotate = 0;
 173 static volatile int do_shutdown = 0;
 174 static volatile int shutdown_status = 0;
 175
 176 static int RotateSignal = -1;
 177 static int ReconfigureSignal = -1;
 178 static int ShutdownSignal = -1;
 179
 180 static void mainRotate(void);
 181 static void mainReconfigureStart(void);
 182 static void mainReconfigureFinish(void*);
 183 static void mainInitialize(void);
 184 static void usage(void);
 185 static void mainParseOptions(int argc, char *argv[]);
 186 static void sendSignal(void);
 187 static void serverConnectionsOpen(void);
 188 static void serverConnectionsClose(void);
 189 static void watch_child(char **);
 190 static void setEffectiveUser(void);
 191 static void SquidShutdown(void);
 192 static void mainSetCwd(void);
 193 static int checkRunningPid(void);
 194
 195 #if !_SQUID_WINDOWS_
 196 static const char *squid_start_script = "squid_start";
 197 #endif
 198
 199 #if TEST_ACCESS
 200 #include "test_access.c"
 201 #endif
 202
 203 /** temporary thunk across to the unrefactored store interface */
 204
 205 class StoreRootEngine : public AsyncEngine
 206 {
 207
 208 public:
 209     int checkEvents(int timeout) {
 210         Store::Root().callback();
 211         return EVENT_IDLE;
 212     };
 213 };
 214
 215 class SignalEngine: public AsyncEngine
 216 {
 217
 218 public:
 219     virtual int checkEvents(int timeout);
 220
 221 private:
 222     static void StopEventLoop(void *) {
 223         if (EventLoop::Running)
 224             EventLoop::Running->stop();
 225     }
 226
 227     void doShutdown(time_t wait);
 228 };
 229
 230 int
 231 SignalEngine::checkEvents(int timeout)
 232 {
 233     PROF_start(SignalEngine_checkEvents);
 234
 235     if (do_reconfigure) {
 236         mainReconfigureStart();
 237         do_reconfigure = 0;
 238     } else if (do_rotate) {
 239         mainRotate();
 240         do_rotate = 0;
 241     } else if (do_shutdown) {
 242         doShutdown(do_shutdown > 0 ? (int) Config.shutdownLifetime : 0);
 243         do_shutdown = 0;
 244     }
 245     BroadcastSignalIfAny(DebugSignal);
 246     BroadcastSignalIfAny(RotateSignal);
 247     BroadcastSignalIfAny(ReconfigureSignal);
 248     BroadcastSignalIfAny(ShutdownSignal);
 249
 250     PROF_stop(SignalEngine_checkEvents);
 251     return EVENT_IDLE;
 252 }
 253
 254 void
 255 SignalEngine::doShutdown(time_t wait)
 256 {
 257     debugs(1, DBG_IMPORTANT, "Preparing for shutdown after " << statCounter.client_http.requests << " requests");
 258     debugs(1, DBG_IMPORTANT, "Waiting " << wait << " seconds for active connections to finish");
 259
 260     shutting_down = 1;
 261
 262 #if USE_WIN32_SERVICE
 263     WIN32_svcstatusupdate(SERVICE_STOP_PENDING, (wait + 1) * 1000);
 264 #endif
 265
 266     /* run the closure code which can be shared with reconfigure */
 267     serverConnectionsClose();
 268 #if USE_AUTH
 269     /* detach the auth components (only do this on full shutdown) */
 270     Auth::Scheme::FreeAll();
 271 #endif
 272
 273     RunRegisteredHere(RegisteredRunner::startShutdown);
 274     eventAdd("SquidShutdown", &StopEventLoop, this, (double) (wait + 1), 1, false);
 275 }
 276
 277 static void
 278 usage(void)
 279 {
 280     fprintf(stderr,
 281             "Usage: %s [-cdhvzCFNRVYX] [-n name] [-s | -l facility] [-f config-file] [-[au] port] [-k signal]"
 282 #if USE_WIN32_SERVICE
 283             "[-ir] [-O CommandLine]"
 284 #endif
 285             "\n"
 286             "       -a port   Specify HTTP port number (default: %d).\n"
 287             "       -d level  Write debugging to stderr also.\n"
 288             "       -f file   Use given config-file instead of\n"
 289             "                 %s\n"
 290             "       -h        Print help message.\n"
 291 #if USE_WIN32_SERVICE
 292             "       -i        Installs as a Windows Service (see -n option).\n"
 293 #endif
 294             "       -k reconfigure|rotate|shutdown|"
 295 #ifdef SIGTTIN
 296             "restart|"
 297 #endif
 298             "interrupt|kill|debug|check|parse\n"
 299             "                 Parse configuration file, then send signal to \n"
 300             "                 running copy (except -k parse) and exit.\n"
 301             "       -n name   Specify service name to use for service operations\n"
 302             "                 default is: " APP_SHORTNAME ".\n"
 303 #if USE_WIN32_SERVICE
 304             "       -r        Removes a Windows Service (see -n option).\n"
 305 #endif
 306             "       -s | -l facility\n"
 307             "                 Enable logging to syslog.\n"
 308             "       -u port   Specify ICP port number (default: %d), disable with 0.\n"
 309             "       -v        Print version.\n"
 310             "       -z        Create missing swap directories and then exit.\n"
 311             "       -C        Do not catch fatal signals.\n"
 312             "       -D        OBSOLETE. Scheduled for removal.\n"
 313             "       -F        Don't serve any requests until store is rebuilt.\n"
 314             "       -N        No daemon mode.\n"
 315 #if USE_WIN32_SERVICE
 316             "       -O options\n"
 317             "                 Set Windows Service Command line options in Registry.\n"
 318 #endif
 319             "       -R        Do not set REUSEADDR on port.\n"
 320             "       -S        Double-check swap during rebuild.\n"
 321             "       -X        Force full debugging.\n"
 322             "       -Y        Only return UDP_HIT or UDP_MISS_NOFETCH during fast reload.\n",
 323             APP_SHORTNAME, CACHE_HTTP_PORT, DefaultConfigFile, CACHE_ICP_PORT);
 324     exit(1);
 325 }
 326
 327 /**
 328  * Parse the parameters received via command line interface.
 329  *
 330  \param argc   Number of options received on command line
 331  \param argv   List of parameters received on command line
 332  */
 333 static void
 334 mainParseOptions(int argc, char *argv[])
 335 {
 336     extern char *optarg;
 337     int c;
 338
 339 #if USE_WIN32_SERVICE
 340     while ((c = getopt(argc, argv, "CDFNO:RSVYXa:d:f:hik:m::n:rsl:u:vz?")) != -1)
 341 #else
 342     while ((c = getopt(argc, argv, "CDFNRSYXa:d:f:hk:m::n:sl:u:vz?")) != -1)
 343 #endif
 344     {
 345
 346         switch (c) {
 347
 348         case 'C':
 349             /** \par C
 350              * Unset/disabel global option for catchign signals. opt_catch_signals */
 351             opt_catch_signals = 0;
 352             break;
 353
 354         case 'D':
 355             /** \par D
 356              * OBSOLETE: WAS: override to prevent optional startup DNS tests. */
 357             debugs(1,DBG_CRITICAL, "WARNING: -D command-line option is obsolete.");
 358             break;
 359
 360         case 'F':
 361             /** \par F
 362              * Set global option for foreground rebuild. opt_foreground_rebuild */
 363             opt_foreground_rebuild = 1;
 364             break;
 365
 366         case 'N':
 367             /** \par N
 368              * Set global option for 'no_daemon' mode. opt_no_daemon */
 369             opt_no_daemon = 1;
 370             break;
 371
 372 #if USE_WIN32_SERVICE
 373
 374         case 'O':
 375             /** \par O
 376              * Set global option. opt_command_lin and WIN32_Command_Line */
 377             opt_command_line = 1;
 378             WIN32_Command_Line = xstrdup(optarg);
 379             break;
 380 #endif
 381
 382         case 'R':
 383             /** \par R
 384              * Unset/disable global option opt_reuseaddr */
 385             opt_reuseaddr = 0;
 386             break;
 387
 388         case 'S':
 389             /** \par S
 390              * Set global option opt_store_doublecheck */
 391             opt_store_doublecheck = 1;
 392             break;
 393
 394         case 'X':
 395             /** \par X
 396              * Force full debugging */
 397             Debug::parseOptions("rotate=0 ALL,9");
 398             Debug::override_X = 1;
 399             sigusr2_handle(SIGUSR2);
 400             break;
 401
 402         case 'Y':
 403             /** \par Y
 404              * Set global option opt_reload_hit_only */
 405             opt_reload_hit_only = 1;
 406             break;
 407
 408 #if USE_WIN32_SERVICE
 409
 410         case 'i':
 411             /** \par i
 412              * Set global option opt_install_service (to TRUE) */
 413             opt_install_service = TRUE;
 414             break;
 415 #endif
 416
 417         case 'a':
 418             /** \par a
 419              * Add optional HTTP port as given following the option */
 420             add_http_port(optarg);
 421             break;
 422
 423         case 'd':
 424             /** \par d
 425              * Set global option Debug::log_stderr to the number given follwoign the option */
 426             Debug::log_stderr = atoi(optarg);
 427             break;
 428
 429         case 'f':
 430             /** \par f
 431              * Load the file given instead of the default squid.conf. */
 432             xfree(ConfigFile);
 433             ConfigFile = xstrdup(optarg);
 434             break;
 435
 436         case 'k':
 437             /** \par k
 438              * Run the administrative action given following the option */
 439
 440             /** \li When its an unknown option display the usage help. */
 441             if ((int) strlen(optarg) < 1)
 442                 usage();
 443
 444             if (!strncmp(optarg, "reconfigure", strlen(optarg)))
 445                 /** \li On reconfigure send SIGHUP. */
 446                 opt_send_signal = SIGHUP;
 447             else if (!strncmp(optarg, "rotate", strlen(optarg)))
 448                 /** \li On rotate send SIGQUIT or SIGUSR1. */
 449 #if defined(_SQUID_LINUX_THREADS_)
 450                 opt_send_signal = SIGQUIT;
 451 #else
 452                 opt_send_signal = SIGUSR1;
 453 #endif
 454
 455             else if (!strncmp(optarg, "debug", strlen(optarg)))
 456                 /** \li On debug send SIGTRAP or SIGUSR2. */
 457 #if defined(_SQUID_LINUX_THREADS_)
 458                 opt_send_signal = SIGTRAP;
 459 #else
 460                 opt_send_signal = SIGUSR2;
 461 #endif
 462
 463             else if (!strncmp(optarg, "shutdown", strlen(optarg)))
 464                 /** \li On shutdown send SIGTERM. */
 465                 opt_send_signal = SIGTERM;
 466             else if (!strncmp(optarg, "interrupt", strlen(optarg)))
 467                 /** \li On interrupt send SIGINT. */
 468                 opt_send_signal = SIGINT;
 469             else if (!strncmp(optarg, "kill", strlen(optarg)))
 470                 /** \li On kill send SIGKILL. */
 471                 opt_send_signal = SIGKILL;
 472
 473 #ifdef SIGTTIN
 474
 475             else if (!strncmp(optarg, "restart", strlen(optarg)))
 476                 /** \li On restart send SIGTTIN. (exit and restart by parent) */
 477                 opt_send_signal = SIGTTIN;
 478
 479 #endif
 480
 481             else if (!strncmp(optarg, "check", strlen(optarg)))
 482                 /** \li On check send 0 / SIGNULL. */
 483                 opt_send_signal = 0;    /* SIGNULL */
 484             else if (!strncmp(optarg, "parse", strlen(optarg)))
 485                 /** \li On parse set global flag to re-parse the config file only. */
 486                 opt_parse_cfg_only = 1;
 487             else
 488                 usage();
 489
 490             break;
 491
 492         case 'm':
 493             /** \par m
 494              * Set global malloc_debug_level to the value given following the option.
 495              * if none is given it toggles the xmalloc_trace option on/off */
 496             if (optarg) {
 497 #if MALLOC_DBG
 498                 malloc_debug_level = atoi(optarg);
 499 #else
 500                 fatal("Need to add -DMALLOC_DBG when compiling to use -mX option");
 501 #endif
 502
 503             }
 504             break;
 505
 506         case 'n':
 507             /** \par n
 508              * Set global option opt_signal_service (to true).
 509              * Stores the additional parameter given in global service_name */
 510             if (optarg && *optarg != '\0') {
 511                 const SBuf t(optarg);
 512                 ::Parser::Tokenizer tok(t);
 513                 const CharacterSet chr = CharacterSet::ALPHA+CharacterSet::DIGIT;
 514                 if (!tok.prefix(service_name, chr) || !tok.atEnd())
 515                     fatalf("Expected alphanumeric service name for the -n option but got: " SQUIDSBUFPH, SQUIDSBUFPRINT(service_name));
 516                 if (service_name.length() > 32)
 517                     fatalf("Service name (-n option) must be limited to 32 characters but got %u", service_name.length());
 518                 opt_signal_service = true;
 519             } else {
 520                 fatal("A service name is required for the -n option");
 521             }
 522             break;
 523
 524 #if USE_WIN32_SERVICE
 525
 526         case 'r':
 527             /** \par r
 528              * Set global option opt_remove_service (to TRUE) */
 529             opt_remove_service = TRUE;
 530
 531             break;
 532
 533 #endif
 534
 535         case 'l':
 536             /** \par l
 537              * Stores the syslog facility name in global opt_syslog_facility
 538              * then performs actions for -s option. */
 539             xfree(opt_syslog_facility); // ignore any previous options sent
 540             opt_syslog_facility = xstrdup(optarg);
 541
 542         case 's':
 543             /** \par s
 544              * Initialize the syslog for output */
 545 #if HAVE_SYSLOG
 546
 547             _db_set_syslog(opt_syslog_facility);
 548
 549             break;
 550
 551 #else
 552
 553             fatal("Logging to syslog not available on this platform");
 554
 555             /* NOTREACHED */
 556 #endif
 557
 558         case 'u':
 559             /** \par u
 560              * Store the ICP port number given in global option icpPortNumOverride
 561              * ensuring its a positive number. */
 562             icpPortNumOverride = atoi(optarg);
 563
 564             if (icpPortNumOverride < 0)
 565                 icpPortNumOverride = 0;
 566
 567             break;
 568
 569         case 'v':
 570             /** \par v
 571              * Display squid version and build information. Then exit. */
 572             printf("Squid Cache: Version %s\n" ,version_string);
 573             printf("Service Name: " SQUIDSBUFPH "\n", SQUIDSBUFPRINT(service_name));
 574             if (strlen(SQUID_BUILD_INFO))
 575                 printf("%s\n",SQUID_BUILD_INFO);
 576             printf( "configure options: %s\n", SQUID_CONFIGURE_OPTIONS);
 577
 578 #if USE_WIN32_SERVICE
 579
 580             printf("Compiled as Windows System Service.\n");
 581
 582 #endif
 583
 584             exit(0);
 585
 586             /* NOTREACHED */
 587
 588         case 'z':
 589             /** \par z
 590              * Set global option Debug::log_stderr and opt_create_swap_dirs */
 591             Debug::log_stderr = 1;
 592             opt_create_swap_dirs = 1;
 593             break;
 594
 595         case 'h':
 596
 597         case '?':
 598
 599         default:
 600             /** \par h,?, or unknown
 601              * \copydoc usage() */
 602             usage();
 603
 604             break;
 605         }
 606
 607     }
 608 }
 609
 610 /* ARGSUSED */
 611 void
 612 rotate_logs(int sig)
 613 {
 614     do_rotate = 1;
 615     RotateSignal = sig;
 616 #if !_SQUID_WINDOWS_
 617 #if !HAVE_SIGACTION
 618
 619     signal(sig, rotate_logs);
 620 #endif
 621 #endif
 622 }
 623
 624 /* ARGSUSED */
 625 void
 626 reconfigure(int sig)
 627 {
 628     do_reconfigure = 1;
 629     ReconfigureSignal = sig;
 630 #if !_SQUID_WINDOWS_
 631 #if !HAVE_SIGACTION
 632
 633     signal(sig, reconfigure);
 634 #endif
 635 #endif
 636 }
 637
 638 void
 639 shut_down(int sig)
 640 {
 641     do_shutdown = sig == SIGINT ? -1 : 1;
 642     ShutdownSignal = sig;
 643 #ifdef SIGTTIN
 644
 645     if (SIGTTIN == sig)
 646         shutdown_status = 1;
 647
 648 #endif
 649
 650     const pid_t ppid = getppid();
 651
 652     if (!IamMasterProcess() && ppid > 1) {
 653         // notify master that we are shutting down
 654         if (kill(ppid, SIGUSR1) < 0)
 655             debugs(1, DBG_IMPORTANT, "Failed to send SIGUSR1 to master process,"
 656                    " pid " << ppid << ": " << xstrerror());
 657     }
 658
 659 #if !_SQUID_WINDOWS_
 660 #if KILL_PARENT_OPT
 661
 662     if (!IamMasterProcess() && ppid > 1) {
 663         debugs(1, DBG_IMPORTANT, "Killing master process, pid " << ppid);
 664
 665         if (kill(ppid, sig) < 0)
 666             debugs(1, DBG_IMPORTANT, "kill " << ppid << ": " << xstrerror());
 667     }
 668
 669 #endif /* KILL_PARENT_OPT */
 670 #if SA_RESETHAND == 0
 671     signal(SIGTERM, SIG_DFL);
 672
 673     signal(SIGINT, SIG_DFL);
 674
 675 #endif
 676 #endif
 677 }
 678
 679 static void
 680 serverConnectionsOpen(void)
 681 {
 682     if (IamPrimaryProcess()) {
 683 #if USE_WCCP
 684         wccpConnectionOpen();
 685 #endif
 686
 687 #if USE_WCCPv2
 688
 689         wccp2ConnectionOpen();
 690 #endif
 691     }
 692     // start various proxying services if we are responsible for them
 693     if (IamWorkerProcess()) {
 694         clientOpenListenSockets();
 695         icpOpenPorts();
 696 #if USE_HTCP
 697         htcpOpenPorts();
 698 #endif
 699 #if SQUID_SNMP
 700         snmpOpenPorts();
 701 #endif
 702
 703         icmpEngine.Open();
 704         netdbInit();
 705         asnInit();
 706         ACL::Initialize();
 707         peerSelectInit();
 708
 709         carpInit();
 710 #if USE_AUTH
 711         peerUserHashInit();
 712 #endif
 713         peerSourceHashInit();
 714     }
 715 }
 716
 717 static void
 718 serverConnectionsClose(void)
 719 {
 720     assert(shutting_down || reconfiguring);
 721
 722     if (IamPrimaryProcess()) {
 723 #if USE_WCCP
 724
 725         wccpConnectionClose();
 726 #endif
 727 #if USE_WCCPv2
 728
 729         wccp2ConnectionClose();
 730 #endif
 731     }
 732     if (IamWorkerProcess()) {
 733         clientConnectionsClose();
 734         icpConnectionShutdown();
 735 #if USE_HTCP
 736         htcpSocketShutdown();
 737 #endif
 738
 739         icmpEngine.Close();
 740 #if SQUID_SNMP
 741         snmpClosePorts();
 742 #endif
 743
 744         asnFreeMemory();
 745     }
 746 }
 747
 748 static void
 749 mainReconfigureStart(void)
 750 {
 751     debugs(1, DBG_IMPORTANT, "Reconfiguring Squid Cache (version " << version_string << ")...");
 752     reconfiguring = 1;
 753
 754     // Initiate asynchronous closing sequence
 755     serverConnectionsClose();
 756     icpClosePorts();
 757 #if USE_HTCP
 758     htcpClosePorts();
 759 #endif
 760     dnsShutdown();
 761 #if USE_SSL_CRTD
 762     Ssl::Helper::GetInstance()->Shutdown();
 763 #endif
 764 #if USE_OPENSSL
 765     if (Ssl::CertValidationHelper::GetInstance())
 766         Ssl::CertValidationHelper::GetInstance()->Shutdown();
 767     Ssl::TheGlobalContextStorage.reconfigureStart();
 768 #endif
 769     redirectShutdown();
 770 #if USE_AUTH
 771     authenticateReset();
 772 #endif
 773     externalAclShutdown();
 774     storeDirCloseSwapLogs();
 775     storeLogClose();
 776     accessLogClose();
 777 #if ICAP_CLIENT
 778     icapLogClose();
 779 #endif
 780
 781     eventAdd("mainReconfigureFinish", &mainReconfigureFinish, NULL, 0, 1,
 782              false);
 783 }
 784
 785 static void
 786 mainReconfigureFinish(void *)
 787 {
 788     debugs(1, 3, "finishing reconfiguring");
 789
 790     errorClean();
 791     enter_suid();               /* root to read config file */
 792
 793     // we may have disabled the need for PURGE
 794     if (Config2.onoff.enable_purge)
 795         Config2.onoff.enable_purge = 2;
 796
 797     // parse the config returns a count of errors encountered.
 798     const int oldWorkers = Config.workers;
 799     if ( parseConfigFile(ConfigFile) != 0) {
 800         // for now any errors are a fatal condition...
 801         self_destruct();
 802     }
 803     if (oldWorkers != Config.workers) {
 804         debugs(1, DBG_CRITICAL, "WARNING: Changing 'workers' (from " <<
 805                oldWorkers << " to " << Config.workers <<
 806                ") requires a full restart. It has been ignored by reconfigure.");
 807         Config.workers = oldWorkers;
 808     }
 809
 810     RunRegisteredHere(RegisteredRunner::syncConfig);
 811
 812     if (IamPrimaryProcess())
 813         CpuAffinityCheck();
 814     CpuAffinityReconfigure();
 815
 816     setUmask(Config.umask);
 817     Mem::Report();
 818     setEffectiveUser();
 819     _db_init(Debug::cache_log, Debug::debugOptions);
 820     ipcache_restart();          /* clear stuck entries */
 821     fqdncache_restart();        /* sigh, fqdncache too */
 822     parseEtcHosts();
 823     errorInitialize();          /* reload error pages */
 824     accessLogInit();
 825
 826 #if USE_LOADABLE_MODULES
 827     LoadableModulesConfigure(Config.loadable_module_names);
 828 #endif
 829
 830 #if USE_ADAPTATION
 831     bool enableAdaptation = false;
 832 #if ICAP_CLIENT
 833     Adaptation::Icap::TheConfig.finalize();
 834     enableAdaptation = Adaptation::Icap::TheConfig.onoff || enableAdaptation;
 835 #endif
 836 #if USE_ECAP
 837     Adaptation::Ecap::TheConfig.finalize(); // must be after we load modules
 838     enableAdaptation = Adaptation::Ecap::TheConfig.onoff || enableAdaptation;
 839 #endif
 840     Adaptation::Config::Finalize(enableAdaptation);
 841 #endif
 842
 843 #if ICAP_CLIENT
 844     icapLogOpen();
 845 #endif
 846     storeLogOpen();
 847     dnsInit();
 848 #if USE_SSL_CRTD
 849     Ssl::Helper::GetInstance()->Init();
 850 #endif
 851 #if USE_OPENSSL
 852     if (Ssl::CertValidationHelper::GetInstance())
 853         Ssl::CertValidationHelper::GetInstance()->Init();
 854 #endif
 855
 856     redirectInit();
 857 #if USE_AUTH
 858     authenticateInit(&Auth::TheConfig);
 859 #endif
 860     externalAclInit();
 861
 862     if (IamPrimaryProcess()) {
 863 #if USE_WCCP
 864
 865         wccpInit();
 866 #endif
 867 #if USE_WCCPv2
 868
 869         wccp2Init();
 870 #endif
 871     }
 872
 873     serverConnectionsOpen();
 874
 875     neighbors_init();
 876
 877     storeDirOpenSwapLogs();
 878
 879     mimeInit(Config.mimeTablePathname);
 880
 881     if (unlinkdNeeded())
 882         unlinkdInit();
 883
 884 #if USE_DELAY_POOLS
 885     Config.ClientDelay.finalize();
 886 #endif
 887
 888     if (Config.onoff.announce) {
 889         if (!eventFind(start_announce, NULL))
 890             eventAdd("start_announce", start_announce, NULL, 3600.0, 1);
 891     } else {
 892         if (eventFind(start_announce, NULL))
 893             eventDelete(start_announce, NULL);
 894     }
 895
 896     writePidFile();             /* write PID file */
 897
 898     reconfiguring = 0;
 899 }
 900
 901 static void
 902 mainRotate(void)
 903 {
 904     icmpEngine.Close();
 905     redirectShutdown();
 906 #if USE_AUTH
 907     authenticateRotate();
 908 #endif
 909     externalAclShutdown();
 910
 911     _db_rotate_log();           /* cache.log */
 912     storeDirWriteCleanLogs(1);
 913     storeLogRotate();           /* store.log */
 914     accessLogRotate();          /* access.log */
 915 #if ICAP_CLIENT
 916     icapLogRotate();               /*icap.log*/
 917 #endif
 918     icmpEngine.Open();
 919     redirectInit();
 920 #if USE_AUTH
 921     authenticateInit(&Auth::TheConfig);
 922 #endif
 923     externalAclInit();
 924 }
 925
 926 static void
 927 setEffectiveUser(void)
 928 {
 929     keepCapabilities();
 930     leave_suid();               /* Run as non privilegied user */
 931 #if _SQUID_OS2_
 932
 933     return;
 934 #endif
 935
 936     if (geteuid() == 0) {
 937         debugs(0, DBG_CRITICAL, "Squid is not safe to run as root!  If you must");
 938         debugs(0, DBG_CRITICAL, "start Squid as root, then you must configure");
 939         debugs(0, DBG_CRITICAL, "it to run as a non-priveledged user with the");
 940         debugs(0, DBG_CRITICAL, "'cache_effective_user' option in the config file.");
 941         fatal("Don't run Squid as root, set 'cache_effective_user'!");
 942     }
 943 }
 944
 945 /// changes working directory, providing error reporting
 946 static bool
 947 mainChangeDir(const char *dir)
 948 {
 949     if (chdir(dir) == 0)
 950         return true;
 951
 952     debugs(50, DBG_CRITICAL, "cannot change current directory to " << dir <<
 953            ": " << xstrerror());
 954     return false;
 955 }
 956
 957 /// set the working directory.
 958 static void
 959 mainSetCwd(void)
 960 {
 961     static bool chrooted = false;
 962     if (Config.chroot_dir && !chrooted) {
 963         chrooted = true;
 964
 965         if (chroot(Config.chroot_dir) != 0)
 966             fatalf("chroot to %s failed: %s", Config.chroot_dir, xstrerror());
 967
 968         if (!mainChangeDir("/"))
 969             fatalf("chdir to / after chroot to %s failed", Config.chroot_dir);
 970     }
 971
 972     if (Config.coredump_dir && strcmp("none", Config.coredump_dir) != 0) {
 973         if (mainChangeDir(Config.coredump_dir)) {
 974             debugs(0, DBG_IMPORTANT, "Set Current Directory to " << Config.coredump_dir);
 975             return;
 976         }
 977     }
 978
 979     /* If we don't have coredump_dir or couldn't cd there, report current dir */
 980     char pathbuf[MAXPATHLEN];
 981     if (getcwd(pathbuf, MAXPATHLEN)) {
 982         debugs(0, DBG_IMPORTANT, "Current Directory is " << pathbuf);
 983     } else {
 984         debugs(50, DBG_CRITICAL, "WARNING: Can't find current directory, getcwd: " << xstrerror());
 985     }
 986 }
 987
 988 static void
 989 mainInitialize(void)
 990 {
 991     /* chroot if configured to run inside chroot */
 992     mainSetCwd();
 993
 994     if (opt_catch_signals) {
 995         squid_signal(SIGSEGV, death, SA_NODEFER | SA_RESETHAND);
 996         squid_signal(SIGBUS, death, SA_NODEFER | SA_RESETHAND);
 997     }
 998
 999     squid_signal(SIGPIPE, SIG_IGN, SA_RESTART);
1000     squid_signal(SIGCHLD, sig_child, SA_NODEFER | SA_RESTART);
1001
1002     setEffectiveUser();
1003
1004     if (icpPortNumOverride != 1)
1005         Config.Port.icp = (unsigned short) icpPortNumOverride;
1006
1007     _db_init(Debug::cache_log, Debug::debugOptions);
1008
1009     fd_open(fileno(debug_log), FD_LOG, Debug::cache_log);
1010
1011     debugs(1, DBG_CRITICAL, "Starting Squid Cache version " << version_string << " for " << CONFIG_HOST_TYPE << "...");
1012     debugs(1, DBG_CRITICAL, "Service Name: " << service_name);
1013
1014 #if _SQUID_WINDOWS_
1015     if (WIN32_run_mode == _WIN_SQUID_RUN_MODE_SERVICE) {
1016         debugs(1, DBG_CRITICAL, "Service command line is: " << WIN32_Service_Command_Line);
1017     } else
1018         debugs(1, DBG_CRITICAL, "Running on " << WIN32_OS_string);
1019 #endif
1020
1021     debugs(1, DBG_IMPORTANT, "Process ID " << getpid());
1022
1023     debugs(1, DBG_IMPORTANT, "Process Roles:" << ProcessRoles());
1024
1025     setSystemLimits();
1026     debugs(1, DBG_IMPORTANT, "With " << Squid_MaxFD << " file descriptors available");
1027
1028 #if _SQUID_WINDOWS_
1029
1030     debugs(1, DBG_IMPORTANT, "With " << _getmaxstdio() << " CRT stdio descriptors available");
1031
1032     if (WIN32_Socks_initialized)
1033         debugs(1, DBG_IMPORTANT, "Windows sockets initialized");
1034
1035     if (WIN32_OS_version > _WIN_OS_WINNT) {
1036         WIN32_IpAddrChangeMonitorInit();
1037     }
1038
1039 #endif
1040
1041     if (!configured_once)
1042         disk_init();            /* disk_init must go before ipcache_init() */
1043
1044     ipcache_init();
1045
1046     fqdncache_init();
1047
1048     parseEtcHosts();
1049
1050     dnsInit();
1051
1052 #if USE_SSL_CRTD
1053     Ssl::Helper::GetInstance()->Init();
1054 #endif
1055
1056 #if USE_OPENSSL
1057     if (!configured_once)
1058         Ssl::initialize_session_cache();
1059
1060     if (Ssl::CertValidationHelper::GetInstance())
1061         Ssl::CertValidationHelper::GetInstance()->Init();
1062 #endif
1063
1064     redirectInit();
1065 #if USE_AUTH
1066     authenticateInit(&Auth::TheConfig);
1067 #endif
1068     externalAclInit();
1069
1070     httpHeaderInitModule();     /* must go before any header processing (e.g. the one in errorInitialize) */
1071
1072     httpReplyInitModule();      /* must go before accepting replies */
1073
1074     errorInitialize();
1075
1076     accessLogInit();
1077
1078 #if ICAP_CLIENT
1079     icapLogOpen();
1080 #endif
1081
1082 #if USE_IDENT
1083     Ident::Init();
1084 #endif
1085
1086 #if SQUID_SNMP
1087
1088     snmpInit();
1089
1090 #endif
1091 #if MALLOC_DBG
1092
1093     malloc_debug(0, malloc_debug_level);
1094
1095 #endif
1096
1097     if (!configured_once) {
1098         if (unlinkdNeeded())
1099             unlinkdInit();
1100
1101         urlInitialize();
1102         statInit();
1103         storeInit();
1104         mainSetCwd();
1105         mimeInit(Config.mimeTablePathname);
1106         refreshInit();
1107 #if USE_DELAY_POOLS
1108         DelayPools::Init();
1109 #endif
1110
1111         FwdState::initModule();
1112         /* register the modules in the cache manager menus */
1113
1114         cbdataRegisterWithCacheManager();
1115         /* These use separate calls so that the comm loops can eventually
1116          * coexist.
1117          */
1118
1119         eventInit();
1120
1121         // TODO: pconn is a good candidate for new-style registration
1122         // PconnModule::GetInstance()->registerWithCacheManager();
1123         //   moved to PconnModule::PconnModule()
1124     }
1125
1126     if (IamPrimaryProcess()) {
1127 #if USE_WCCP
1128         wccpInit();
1129
1130 #endif
1131 #if USE_WCCPv2
1132
1133         wccp2Init();
1134
1135 #endif
1136     }
1137
1138     serverConnectionsOpen();
1139
1140     neighbors_init();
1141
1142     // neighborsRegisterWithCacheManager(); //moved to neighbors_init()
1143
1144     if (Config.chroot_dir)
1145         no_suid();
1146
1147     if (!configured_once)
1148         writePidFile();         /* write PID file */
1149
1150 #if defined(_SQUID_LINUX_THREADS_)
1151
1152     squid_signal(SIGQUIT, rotate_logs, SA_RESTART);
1153
1154     squid_signal(SIGTRAP, sigusr2_handle, SA_RESTART);
1155
1156 #else
1157
1158     squid_signal(SIGUSR1, rotate_logs, SA_RESTART);
1159
1160     squid_signal(SIGUSR2, sigusr2_handle, SA_RESTART);
1161
1162 #endif
1163
1164     squid_signal(SIGHUP, reconfigure, SA_RESTART);
1165
1166     squid_signal(SIGTERM, shut_down, SA_NODEFER | SA_RESETHAND | SA_RESTART);
1167
1168     squid_signal(SIGINT, shut_down, SA_NODEFER | SA_RESETHAND | SA_RESTART);
1169
1170 #ifdef SIGTTIN
1171
1172     squid_signal(SIGTTIN, shut_down, SA_NODEFER | SA_RESETHAND | SA_RESTART);
1173
1174 #endif
1175
1176     memCheckInit();
1177
1178 #if USE_LOADABLE_MODULES
1179     LoadableModulesConfigure(Config.loadable_module_names);
1180 #endif
1181
1182 #if USE_ADAPTATION
1183     bool enableAdaptation = false;
1184
1185     // We can remove this dependency on specific adaptation mechanisms
1186     // if we create a generic Registry of such mechanisms. Should we?
1187 #if ICAP_CLIENT
1188     Adaptation::Icap::TheConfig.finalize();
1189     enableAdaptation = Adaptation::Icap::TheConfig.onoff || enableAdaptation;
1190 #endif
1191 #if USE_ECAP
1192     Adaptation::Ecap::TheConfig.finalize(); // must be after we load modules
1193     enableAdaptation = Adaptation::Ecap::TheConfig.onoff || enableAdaptation;
1194 #endif
1195     // must be the last adaptation-related finalize
1196     Adaptation::Config::Finalize(enableAdaptation);
1197 #endif
1198
1199 #if USE_SQUID_ESI
1200     Esi::Init();
1201 #endif
1202
1203 #if USE_DELAY_POOLS
1204     Config.ClientDelay.finalize();
1205 #endif
1206
1207     if (!configured_once) {
1208         eventAdd("storeMaintain", Store::Maintain, NULL, 1.0, 1);
1209
1210         if (Config.onoff.announce)
1211             eventAdd("start_announce", start_announce, NULL, 3600.0, 1);
1212
1213         eventAdd("ipcache_purgelru", ipcache_purgelru, NULL, 10.0, 1);
1214
1215         eventAdd("fqdncache_purgelru", fqdncache_purgelru, NULL, 15.0, 1);
1216
1217 #if USE_XPROF_STATS
1218
1219         eventAdd("cpuProfiling", xprof_event, NULL, 1.0, 1);
1220
1221 #endif
1222
1223         eventAdd("memPoolCleanIdlePools", Mem::CleanIdlePools, NULL, 15.0, 1);
1224     }
1225
1226     configured_once = 1;
1227 }
1228
1229 /// unsafe main routine -- may throw
1230 int SquidMain(int argc, char **argv);
1231 /// unsafe main routine wrapper to catch exceptions
1232 static int SquidMainSafe(int argc, char **argv);
1233
1234 #if USE_WIN32_SERVICE
1235 /* When USE_WIN32_SERVICE is defined, the main function is placed in win32.cc */
1236 extern "C" void WINAPI
1237 SquidWinSvcMain(int argc, char **argv)
1238 {
1239     SquidMainSafe(argc, argv);
1240 }
1241 #else
1242 int
1243 main(int argc, char **argv)
1244 {
1245     return SquidMainSafe(argc, argv);
1246 }
1247 #endif
1248
1249 static int
1250 SquidMainSafe(int argc, char **argv)
1251 {
1252     try {
1253         return SquidMain(argc, argv);
1254     } catch (const std::exception &e) {
1255         debugs(1, DBG_CRITICAL, "FATAL: dying from an unhandled exception: " <<
1256                e.what());
1257         throw;
1258     } catch (...) {
1259         debugs(1, DBG_CRITICAL, "FATAL: dying from an unhandled exception.");
1260         throw;
1261     }
1262     return -1; // not reached
1263 }
1264
1265 /// computes name and ID for the current kid process
1266 static void
1267 ConfigureCurrentKid(const char *processName)
1268 {
1269     // kids are marked with parenthesis around their process names
1270     if (processName && processName[0] == '(') {
1271         if (const char *idStart = strrchr(processName, '-')) {
1272             KidIdentifier = atoi(idStart + 1);
1273             const size_t nameLen = idStart - (processName + 1);
1274             assert(nameLen < sizeof(TheKidName));
1275             xstrncpy(TheKidName, processName + 1, nameLen + 1);
1276             if (!strcmp(TheKidName, "squid-coord"))
1277                 TheProcessKind = pkCoordinator;
1278             else if (!strcmp(TheKidName, "squid"))
1279                 TheProcessKind = pkWorker;
1280             else if (!strcmp(TheKidName, "squid-disk"))
1281                 TheProcessKind = pkDisker;
1282             else
1283                 TheProcessKind = pkOther; // including coordinator
1284         }
1285     } else {
1286         xstrncpy(TheKidName, APP_SHORTNAME, sizeof(TheKidName));
1287         KidIdentifier = 0;
1288     }
1289 }
1290
1291 int
1292 SquidMain(int argc, char **argv)
1293 {
1294     ConfigureCurrentKid(argv[0]);
1295
1296     Debug::parseOptions(NULL);
1297     debug_log = stderr;
1298
1299 #if defined(SQUID_MAXFD_LIMIT)
1300
1301     if (SQUID_MAXFD_LIMIT < Squid_MaxFD)
1302         Squid_MaxFD = SQUID_MAXFD_LIMIT;
1303
1304 #endif
1305
1306     /* NOP under non-windows */
1307     int WIN32_init_err=0;
1308     if ((WIN32_init_err = WIN32_Subsystem_Init(&argc, &argv)))
1309         return WIN32_init_err;
1310
1311     /* call mallopt() before anything else */
1312 #if HAVE_MALLOPT
1313 #ifdef M_GRAIN
1314     /* Round up all sizes to a multiple of this */
1315     mallopt(M_GRAIN, 16);
1316
1317 #endif
1318 #ifdef M_MXFAST
1319     /* biggest size that is considered a small block */
1320     mallopt(M_MXFAST, 256);
1321
1322 #endif
1323 #ifdef M_NBLKS
1324     /* allocate this many small blocks at once */
1325     mallopt(M_NLBLKS, 32);
1326
1327 #endif
1328 #endif /* HAVE_MALLOPT */
1329
1330     squid_srandom(time(NULL));
1331
1332     getCurrentTime();
1333
1334     squid_start = current_time;
1335
1336     failure_notify = fatal_dump;
1337
1338 #if USE_WIN32_SERVICE
1339
1340     WIN32_svcstatusupdate(SERVICE_START_PENDING, 10000);
1341
1342 #endif
1343
1344     mainParseOptions(argc, argv);
1345
1346     if (opt_parse_cfg_only) {
1347         Debug::parseOptions("ALL,1");
1348     }
1349
1350 #if USE_WIN32_SERVICE
1351
1352     if (opt_install_service) {
1353         WIN32_InstallService();
1354         return 0;
1355     }
1356
1357     if (opt_remove_service) {
1358         WIN32_RemoveService();
1359         return 0;
1360     }
1361
1362     if (opt_command_line) {
1363         WIN32_SetServiceCommandLine();
1364         return 0;
1365     }
1366
1367 #endif
1368
1369     /* parse configuration file
1370      * note: in "normal" case this used to be called from mainInitialize() */
1371     {
1372         int parse_err;
1373
1374         if (!ConfigFile)
1375             ConfigFile = xstrdup(DefaultConfigFile);
1376
1377         assert(!configured_once);
1378
1379         Mem::Init();
1380
1381         storeFsInit();          /* required for config parsing */
1382
1383         /* TODO: call the FS::Clean() in shutdown to do Fs cleanups */
1384         Fs::Init();
1385
1386         /* May not be needed for parsing, have not audited for such */
1387         DiskIOModule::SetupAllModules();
1388
1389         /* Shouldn't be needed for config parsing, but have not audited for such */
1390         StoreFileSystem::SetupAllFs();
1391
1392         /* we may want the parsing process to set this up in the future */
1393         Store::Root(new StoreController);
1394         Auth::Init();      /* required for config parsing. NOP if !USE_AUTH */
1395         Ip::ProbeTransport(); // determine IPv4 or IPv6 capabilities before parsing.
1396
1397         Format::Token::Init(); // XXX: temporary. Use a runners registry of pre-parse runners instead.
1398
1399         parse_err = parseConfigFile(ConfigFile);
1400
1401         Mem::Report();
1402
1403         if (opt_parse_cfg_only || parse_err > 0)
1404             return parse_err;
1405     }
1406     setUmask(Config.umask);
1407     if (-1 == opt_send_signal)
1408         if (checkRunningPid())
1409             exit(0);
1410
1411 #if TEST_ACCESS
1412
1413     comm_init();
1414
1415     mainInitialize();
1416
1417     test_access();
1418
1419     return 0;
1420
1421 #endif
1422
1423     /* send signal to running copy and exit */
1424     if (opt_send_signal != -1) {
1425         /* chroot if configured to run inside chroot */
1426         mainSetCwd();
1427         if (Config.chroot_dir) {
1428             no_suid();
1429         } else {
1430             leave_suid();
1431         }
1432
1433         sendSignal();
1434         /* NOTREACHED */
1435     }
1436
1437     debugs(1,2, HERE << "Doing post-config initialization\n");
1438     leave_suid();
1439     RunRegisteredHere(RegisteredRunner::finalizeConfig);
1440     RunRegisteredHere(RegisteredRunner::claimMemoryNeeds);
1441     RunRegisteredHere(RegisteredRunner::useConfig);
1442     enter_suid();
1443
1444     if (!opt_no_daemon && Config.workers > 0)
1445         watch_child(argv);
1446
1447     if (opt_create_swap_dirs) {
1448         /* chroot if configured to run inside chroot */
1449         mainSetCwd();
1450
1451         setEffectiveUser();
1452         debugs(0, DBG_CRITICAL, "Creating missing swap directories");
1453         Store::Root().create();
1454
1455         return 0;
1456     }
1457
1458     if (IamPrimaryProcess())
1459         CpuAffinityCheck();
1460     CpuAffinityInit();
1461
1462     setMaxFD();
1463
1464     /* init comm module */
1465     comm_init();
1466
1467     if (opt_no_daemon) {
1468         /* we have to init fdstat here. */
1469         fd_open(0, FD_LOG, "stdin");
1470         fd_open(1, FD_LOG, "stdout");
1471         fd_open(2, FD_LOG, "stderr");
1472     }
1473
1474 #if USE_WIN32_SERVICE
1475
1476     WIN32_svcstatusupdate(SERVICE_START_PENDING, 10000);
1477
1478 #endif
1479
1480     mainInitialize();
1481
1482 #if USE_WIN32_SERVICE
1483
1484     WIN32_svcstatusupdate(SERVICE_RUNNING, 0);
1485
1486 #endif
1487
1488     /* main loop */
1489     EventLoop mainLoop;
1490
1491     SignalEngine signalEngine;
1492
1493     mainLoop.registerEngine(&signalEngine);
1494
1495     /* TODO: stop requiring the singleton here */
1496     mainLoop.registerEngine(EventScheduler::GetInstance());
1497
1498     StoreRootEngine store_engine;
1499
1500     mainLoop.registerEngine(&store_engine);
1501
1502     CommSelectEngine comm_engine;
1503
1504     mainLoop.registerEngine(&comm_engine);
1505
1506     mainLoop.setPrimaryEngine(&comm_engine);
1507
1508     /* use the standard time service */
1509     TimeEngine time_engine;
1510
1511     mainLoop.setTimeService(&time_engine);
1512
1513     if (IamCoordinatorProcess())
1514         AsyncJob::Start(Ipc::Coordinator::Instance());
1515     else if (UsingSmp() && (IamWorkerProcess() || IamDiskProcess()))
1516         AsyncJob::Start(new Ipc::Strand);
1517
1518     /* at this point we are finished the synchronous startup. */
1519     starting_up = 0;
1520
1521     mainLoop.run();
1522
1523     if (mainLoop.errcount == 10)
1524         fatal_dump("Event loop exited with failure.");
1525
1526     /* shutdown squid now */
1527     SquidShutdown();
1528
1529     /* NOTREACHED */
1530     return 0;
1531 }
1532
1533 static void
1534 sendSignal(void)
1535 {
1536     pid_t pid;
1537     debug_log = stderr;
1538
1539     if (strcmp(Config.pidFilename, "none") == 0) {
1540         debugs(0, DBG_IMPORTANT, "No pid_filename specified. Trusting you know what you are doing.");
1541     }
1542
1543     pid = readPidFile();
1544
1545     if (pid > 1) {
1546 #if USE_WIN32_SERVICE
1547         if (opt_signal_service) {
1548             WIN32_sendSignal(opt_send_signal);
1549             exit(0);
1550         } else {
1551             fprintf(stderr, "%s: ERROR: Could not send ", APP_SHORTNAME);
1552             fprintf(stderr, "signal to Squid Service:\n");
1553             fprintf(stderr, "missing -n command line switch.\n");
1554             exit(1);
1555         }
1556         /* NOTREACHED */
1557 #endif
1558
1559         if (kill(pid, opt_send_signal) &&
1560                 /* ignore permissions if just running check */
1561                 !(opt_send_signal == 0 && errno == EPERM)) {
1562             fprintf(stderr, "%s: ERROR: Could not send ", APP_SHORTNAME);
1563             fprintf(stderr, "signal %d to process %d: %s\n",
1564                     opt_send_signal, (int) pid, xstrerror());
1565             exit(1);
1566         }
1567     } else {
1568         if (opt_send_signal != SIGTERM) {
1569             fprintf(stderr, "%s: ERROR: No running copy\n", APP_SHORTNAME);
1570             exit(1);
1571         } else {
1572             fprintf(stderr, "%s: No running copy\n", APP_SHORTNAME);
1573             exit(0);
1574         }
1575     }
1576
1577     /* signal successfully sent */
1578     exit(0);
1579 }
1580
1581 #if !_SQUID_WINDOWS_
1582 /*
1583  * This function is run when Squid is in daemon mode, just
1584  * before the parent forks and starts up the child process.
1585  * It can be used for admin-specific tasks, such as notifying
1586  * someone that Squid is (re)started.
1587  */
1588 static void
1589 mainStartScript(const char *prog)
1590 {
1591     char script[MAXPATHLEN];
1592     char *t;
1593     size_t sl = 0;
1594     pid_t cpid;
1595     pid_t rpid;
1596     xstrncpy(script, prog, MAXPATHLEN);
1597
1598     if ((t = strrchr(script, '/'))) {
1599         *(++t) = '\0';
1600         sl = strlen(script);
1601     }
1602
1603     xstrncpy(&script[sl], squid_start_script, MAXPATHLEN - sl);
1604
1605     if ((cpid = fork()) == 0) {
1606         /* child */
1607         execl(script, squid_start_script, (char *)NULL);
1608         _exit(-1);
1609     } else {
1610         do {
1611 #if _SQUID_NEXT_
1612             union wait status;
1613             rpid = wait4(cpid, &status, 0, NULL);
1614 #else
1615
1616             int status;
1617             rpid = waitpid(cpid, &status, 0);
1618 #endif
1619
1620         } while (rpid != cpid);
1621     }
1622 }
1623
1624 #endif /* _SQUID_WINDOWS_ */
1625
1626 static int
1627 checkRunningPid(void)
1628 {
1629     // master process must start alone, but its kids processes may co-exist
1630     if (!IamMasterProcess())
1631         return 0;
1632
1633     pid_t pid;
1634
1635     if (!debug_log)
1636         debug_log = stderr;
1637
1638     pid = readPidFile();
1639
1640     if (pid < 2)
1641         return 0;
1642
1643     if (kill(pid, 0) < 0)
1644         return 0;
1645
1646     debugs(0, DBG_CRITICAL, "Squid is already running!  Process ID " <<  pid);
1647
1648     return 1;
1649 }
1650
1651 static void
1652 watch_child(char *argv[])
1653 {
1654 #if !_SQUID_WINDOWS_
1655     char *prog;
1656 #if _SQUID_NEXT_
1657
1658     union wait status;
1659 #else
1660
1661     int status;
1662 #endif
1663
1664     pid_t pid;
1665 #ifdef TIOCNOTTY
1666
1667     int i;
1668 #endif
1669
1670     int nullfd;
1671
1672     if (!IamMasterProcess())
1673         return;
1674
1675     openlog(APP_SHORTNAME, LOG_PID | LOG_NDELAY | LOG_CONS, LOG_LOCAL4);
1676
1677     if ((pid = fork()) < 0)
1678         syslog(LOG_ALERT, "fork failed: %s", xstrerror());
1679     else if (pid > 0)
1680         exit(0);
1681
1682     if (setsid() < 0)
1683         syslog(LOG_ALERT, "setsid failed: %s", xstrerror());
1684
1685     closelog();
1686
1687 #ifdef TIOCNOTTY
1688
1689     if ((i = open("/dev/tty", O_RDWR | O_TEXT)) >= 0) {
1690         ioctl(i, TIOCNOTTY, NULL);
1691         close(i);
1692     }
1693
1694 #endif
1695
1696     /*
1697      * RBCOLLINS - if cygwin stackdumps when squid is run without
1698      * -N, check the cygwin1.dll version, it needs to be AT LEAST
1699      * 1.1.3.  execvp had a bit overflow error in a loop..
1700      */
1701     /* Connect stdio to /dev/null in daemon mode */
1702     nullfd = open(_PATH_DEVNULL, O_RDWR | O_TEXT);
1703
1704     if (nullfd < 0)
1705         fatalf(_PATH_DEVNULL " %s\n", xstrerror());
1706
1707     dup2(nullfd, 0);
1708
1709     if (Debug::log_stderr < 0) {
1710         dup2(nullfd, 1);
1711         dup2(nullfd, 2);
1712     }
1713
1714     // handle shutdown notifications from kids
1715     squid_signal(SIGUSR1, sig_shutdown, SA_RESTART);
1716
1717     if (Config.workers > 128) {
1718         syslog(LOG_ALERT, "Suspiciously high workers value: %d",
1719                Config.workers);
1720         // but we keep going in hope that user knows best
1721     }
1722     TheKids.init();
1723
1724     syslog(LOG_NOTICE, "Squid Parent: will start %d kids", (int)TheKids.count());
1725
1726     // keep [re]starting kids until it is time to quit
1727     for (;;) {
1728         mainStartScript(argv[0]);
1729
1730         // start each kid that needs to be [re]started; once
1731         for (int i = TheKids.count() - 1; i >= 0; --i) {
1732             Kid& kid = TheKids.get(i);
1733             if (!kid.shouldRestart())
1734                 continue;
1735
1736             if ((pid = fork()) == 0) {
1737                 /* child */
1738                 openlog(APP_SHORTNAME, LOG_PID | LOG_NDELAY | LOG_CONS, LOG_LOCAL4);
1739                 prog = argv[0];
1740                 argv[0] = const_cast<char*>(kid.name().termedBuf());
1741                 execvp(prog, argv);
1742                 syslog(LOG_ALERT, "execvp failed: %s", xstrerror());
1743             }
1744
1745             kid.start(pid);
1746             syslog(LOG_NOTICE, "Squid Parent: %s process %d started",
1747                    kid.name().termedBuf(), pid);
1748         }
1749
1750         /* parent */
1751         openlog(APP_SHORTNAME, LOG_PID | LOG_NDELAY | LOG_CONS, LOG_LOCAL4);
1752
1753         squid_signal(SIGINT, SIG_IGN, SA_RESTART);
1754
1755 #if _SQUID_NEXT_
1756
1757         pid = wait3(&status, 0, NULL);
1758
1759 #else
1760
1761         pid = waitpid(-1, &status, 0);
1762
1763 #endif
1764         // Loop to collect all stopped kids before we go to sleep below.
1765         do {
1766             Kid* kid = TheKids.find(pid);
1767             if (kid) {
1768                 kid->stop(status);
1769                 if (kid->calledExit()) {
1770                     syslog(LOG_NOTICE,
1771                            "Squid Parent: %s process %d exited with status %d",
1772                            kid->name().termedBuf(),
1773                            kid->getPid(), kid->exitStatus());
1774                 } else if (kid->signaled()) {
1775                     syslog(LOG_NOTICE,
1776                            "Squid Parent: %s process %d exited due to signal %d with status %d",
1777                            kid->name().termedBuf(),
1778                            kid->getPid(), kid->termSignal(), kid->exitStatus());
1779                 } else {
1780                     syslog(LOG_NOTICE, "Squid Parent: %s process %d exited",
1781                            kid->name().termedBuf(), kid->getPid());
1782                 }
1783                 if (kid->hopeless()) {
1784                     syslog(LOG_NOTICE, "Squid Parent: %s process %d will not"
1785                            " be restarted due to repeated, frequent failures",
1786                            kid->name().termedBuf(), kid->getPid());
1787                 }
1788             } else {
1789                 syslog(LOG_NOTICE, "Squid Parent: unknown child process %d exited", pid);
1790             }
1791 #if _SQUID_NEXT_
1792         } while ((pid = wait3(&status, WNOHANG, NULL)) > 0);
1793 #else
1794         }
1795         while ((pid = waitpid(-1, &status, WNOHANG)) > 0);
1796 #endif
1797
1798         if (!TheKids.someRunning() && !TheKids.shouldRestartSome()) {
1799             leave_suid();
1800             // XXX: Master process has no main loop and, hence, should not call
1801             // RegisteredRunner::startShutdown which promises a loop iteration.
1802             RunRegisteredHere(RegisteredRunner::finishShutdown);
1803             enter_suid();
1804
1805             if (TheKids.someSignaled(SIGINT) || TheKids.someSignaled(SIGTERM)) {
1806                 syslog(LOG_ALERT, "Exiting due to unexpected forced shutdown");
1807                 exit(1);
1808             }
1809
1810             if (TheKids.allHopeless()) {
1811                 syslog(LOG_ALERT, "Exiting due to repeated, frequent failures");
1812                 exit(1);
1813             }
1814
1815             exit(0);
1816         }
1817
1818         squid_signal(SIGINT, SIG_DFL, SA_RESTART);
1819         sleep(3);
1820     }
1821
1822     /* NOTREACHED */
1823 #endif /* _SQUID_WINDOWS_ */
1824
1825 }
1826
1827 static void
1828 SquidShutdown()
1829 {
1830     /* XXX: This function is called after the main loop has quit, which
1831      * means that no AsyncCalls would be called, including close handlers.
1832      * TODO: We need to close/shut/free everything that needs calls before
1833      * exiting the loop.
1834      */
1835
1836 #if USE_WIN32_SERVICE
1837     WIN32_svcstatusupdate(SERVICE_STOP_PENDING, 10000);
1838 #endif
1839
1840     debugs(1, DBG_IMPORTANT, "Shutting down...");
1841     dnsShutdown();
1842 #if USE_SSL_CRTD
1843     Ssl::Helper::GetInstance()->Shutdown();
1844 #endif
1845 #if USE_OPENSSL
1846     if (Ssl::CertValidationHelper::GetInstance())
1847         Ssl::CertValidationHelper::GetInstance()->Shutdown();
1848 #endif
1849     redirectShutdown();
1850     externalAclShutdown();
1851     icpClosePorts();
1852 #if USE_HTCP
1853     htcpClosePorts();
1854 #endif
1855 #if SQUID_SNMP
1856     snmpClosePorts();
1857 #endif
1858 #if USE_WCCP
1859
1860     wccpConnectionClose();
1861 #endif
1862 #if USE_WCCPv2
1863
1864     wccp2ConnectionClose();
1865 #endif
1866
1867     releaseServerSockets();
1868     commCloseAllSockets();
1869
1870 #if USE_SQUID_ESI
1871     Esi::Clean();
1872 #endif
1873
1874 #if USE_DELAY_POOLS
1875     DelayPools::FreePools();
1876 #endif
1877 #if USE_AUTH
1878     authenticateReset();
1879 #endif
1880 #if USE_WIN32_SERVICE
1881
1882     WIN32_svcstatusupdate(SERVICE_STOP_PENDING, 10000);
1883 #endif
1884
1885     Store::Root().sync(); /* Flush pending object writes/unlinks */
1886
1887     unlinkdClose();       /* after sync/flush. NOP if !USE_UNLINKD */
1888
1889     storeDirWriteCleanLogs(0);
1890     PrintRusage();
1891     dumpMallocStats();
1892     Store::Root().sync();               /* Flush log writes */
1893     storeLogClose();
1894     accessLogClose();
1895     Store::Root().sync();               /* Flush log close */
1896     StoreFileSystem::FreeAllFs();
1897     DiskIOModule::FreeAllModules();
1898 #if LEAK_CHECK_MODE && 0 /* doesn't work at the moment */
1899
1900     configFreeMemory();
1901     storeFreeMemory();
1902     /*stmemFreeMemory(); */
1903     netdbFreeMemory();
1904     ipcacheFreeMemory();
1905     fqdncacheFreeMemory();
1906     asnFreeMemory();
1907     clientdbFreeMemory();
1908     httpHeaderCleanModule();
1909     statFreeMemory();
1910     eventFreeMemory();
1911     mimeFreeMemory();
1912     errorClean();
1913 #endif
1914     // clear StoreController
1915     Store::Root(NULL);
1916
1917     fdDumpOpen();
1918
1919     comm_exit();
1920
1921     RunRegisteredHere(RegisteredRunner::finishShutdown);
1922
1923     memClean();
1924
1925     if (IamPrimaryProcess()) {
1926         if (Config.pidFilename && strcmp(Config.pidFilename, "none") != 0) {
1927             enter_suid();
1928             safeunlink(Config.pidFilename, 0);
1929             leave_suid();
1930         }
1931     }
1932
1933     debugs(1, DBG_IMPORTANT, "Squid Cache (Version " << version_string << "): Exiting normally.");
1934
1935     /*
1936      * DPW 2006-10-23
1937      * We used to fclose(debug_log) here if it was set, but then
1938      * we forgot to set it to NULL.  That caused some coredumps
1939      * because exit() ends up calling a bunch of destructors and
1940      * such.   So rather than forcing the debug_log to close, we'll
1941      * leave it open so that those destructors can write some
1942      * debugging if necessary.  The file will be closed anyway when
1943      * the process truly exits.
1944      */
1945
1946     exit(shutdown_status);
1947 }
1948