X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fserver_main.c;h=bdcdac46ed264fdeaf3b1f4bd31733560492235c;hb=dc3e3bac8c552a1dd0a371b8f68d011e3c20e5c4;hp=e770bc6f4e39a24813ae2f9e4d4b3832c78af9fa;hpb=f1393567e0749d502a544e2a4a4f2817651932c8;p=citadel.git diff --git a/citadel/server_main.c b/citadel/server_main.c index e770bc6f4..bdcdac46e 100644 --- a/citadel/server_main.c +++ b/citadel/server_main.c @@ -1,7 +1,23 @@ /* + * $Id$ + * * citserver's main() function lives here. + * + * Copyright (c) 1987-2010 by the citadel.org team * - * $Id$ + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "sysdep.h" @@ -37,22 +53,30 @@ #include #include #include -#ifdef HAVE_PTHREAD_H -#include -#endif +#include #ifdef HAVE_SYS_PRCTL_H #include #endif +#include #include "citadel.h" #include "server.h" #include "serv_extensions.h" #include "sysdep_decls.h" +#include "threads.h" #include "citserver.h" #include "support.h" #include "config.h" +#include "control.h" #include "database.h" +#include "user_ops.h" #include "housekeeping.h" -#include "tools.h" +#include "svn_revision.h" +#include "citadel_dirs.h" + +#include "context.h" + +#include "modules_init.h" +#include "ecrash.h" #ifdef HAVE_SYS_SELECT_H #include @@ -61,49 +85,68 @@ #ifndef HAVE_SNPRINTF #include "snprintf.h" #endif +const char *CitadelServiceUDS="citadel-UDS"; +const char *CitadelServiceTCP="citadel-TCP"; + + + +void go_threading(void); /* * Here's where it all begins. */ int main(int argc, char **argv) { - char tracefile[128]; /* Name of file to log traces to */ - int a, i; /* General-purpose variables */ - struct passwd *pw; + char facility[32]; + int a; /* General-purpose variables */ + struct passwd pw, *pwp = NULL; + char pwbuf[SIZ]; int drop_root_perms = 1; size_t size; - - /* specify default port name and trace file */ - strcpy(tracefile, ""); + int relh=0; + int home=0; + int dbg=0; + char relhome[PATH_MAX]=""; + char ctdldir[PATH_MAX]=CTDLDIR; +#ifdef HAVE_RUN_DIR + struct stat filestats; +#endif +#ifdef HAVE_BACKTRACE + eCrashParameters params; +// eCrashSymbolTable symbol_table; +#endif + +#ifdef HAVE_GC + GC_INIT(); + GC_find_leak = 1; +#endif + + /* initialise semaphores here. Patch by Matt and davew + * its called here as they are needed by CtdlLogPrintf for thread safety + */ + InitialiseSemaphores(); + /* initialize the master context */ InitializeMasterCC(); /* parse command-line arguments */ for (a=1; a= 0) { - openlog("citadel", LOG_PID, syslog_facility); - } + if (!strncmp(argv[a], "-l", 2)) { + safestrncpy(facility, &argv[a][2], sizeof(facility)); + syslog_facility = SyslogFacility(facility); + enable_syslog = 1; } /* run in the background if -d was specified */ else if (!strcmp(argv[a], "-d")) { - start_daemon( (strlen(tracefile) > 0) ? 0 : 1 ) ; + running_as_daemon = 1; + } + + /* run a few stats if -s was specified */ + else if (!strncmp(argv[a], "-s", 2)) { + statcount = atoi(&argv[a][2]); } /* -x specifies the desired logging level */ @@ -112,13 +155,28 @@ int main(int argc, char **argv) } else if (!strncmp(argv[a], "-h", 2)) { - safestrncpy(bbs_home_directory, &argv[a][2], - sizeof bbs_home_directory); - home_specified = 1; + relh=argv[a][2]!='/'; + if (!relh) safestrncpy(ctdl_home_directory, &argv[a][2], + sizeof ctdl_home_directory); + else + safestrncpy(relhome, &argv[a][2], + sizeof relhome); + home=1; + } + + else if (!strncmp(argv[a], "-t", 2)) { + if (freopen(&argv[a][2], "w", stderr) != stderr) + { + CtdlLogPrintf(CTDL_EMERG, + "unable to open your trace log [%s]: %s", + &argv[a][2], + strerror(errno)); + exit(1); + } } - else if (!strncmp(argv[a], "-f", 2)) { - do_defrag = 1; + else if (!strncmp(argv[a], "-D", 2)) { + dbg = 1; } /* -r tells the server not to drop root permissions. don't use @@ -129,35 +187,102 @@ int main(int argc, char **argv) /* any other parameter makes it crash and burn */ else { - lprintf(CTDL_EMERG, "citserver: usage: " - "citserver [-tTraceFile] " + CtdlLogPrintf(CTDL_EMERG, "citserver: usage: " + "citserver " "[-lLogFacility] " - "[-d] [-f]" + "[-d] [-D] [-s]" + " [-tTraceFile]" " [-xLogLevel] [-hHomeDir]\n"); exit(1); } } + calc_dirs_n_files(relh, home, relhome, ctdldir, dbg); + /* daemonize, if we were asked to */ + if (running_as_daemon) { + start_daemon(0); + drop_root_perms = 1; + } + +#ifdef HAVE_BACKTRACE + bzero(¶ms, sizeof(params)); + params.filename = file_pid_paniclog; + panic_fd=open(file_pid_paniclog, O_APPEND|O_CREAT|O_DIRECT); + params.filep = fopen(file_pid_paniclog, "a+"); + params.debugLevel = ECRASH_DEBUG_VERBOSE; + params.dumpAllThreads = TRUE; + params.useBacktraceSymbols = 1; + params.signals[0]=SIGSEGV; + params.signals[1]=SIGILL; + params.signals[2]=SIGBUS; + params.signals[3]=SIGABRT; + eCrash_Init(¶ms); + eCrash_RegisterThread("MasterThread", 0); +#endif + + /* Initialize the syslogger. Yes, we are really using 0 as the + * facility, because we are going to bitwise-OR the facility to + * the severity of each message, allowing us to write to other + * facilities when we need to... + */ + if (enable_syslog) { + openlog("citadel", LOG_NDELAY, 0); + setlogmask(LOG_UPTO(verbosity)); + } + /* Tell 'em who's in da house */ - lprintf(CTDL_NOTICE, "\n"); - lprintf(CTDL_NOTICE, "\n"); - lprintf(CTDL_NOTICE, - "*** Citadel server engine v%d.%02d ***\n", - (REV_LEVEL/100), (REV_LEVEL%100)); - lprintf(CTDL_NOTICE, - "Copyright (C) 1987-2004 by the Citadel development team.\n"); - lprintf(CTDL_NOTICE, - "This program is distributed under the terms of the GNU " - "General Public License.\n"); - lprintf(CTDL_NOTICE, "\n"); + CtdlLogPrintf(CTDL_NOTICE, "\n"); + CtdlLogPrintf(CTDL_NOTICE, "\n"); + CtdlLogPrintf(CTDL_NOTICE, + "*** Citadel server engine v%d.%02d (build %s) ***\n", + (REV_LEVEL/100), (REV_LEVEL%100), svn_revision()); + CtdlLogPrintf(CTDL_NOTICE, "Copyright (C) 1987-2010 by the Citadel development team.\n"); + CtdlLogPrintf(CTDL_NOTICE, "This program is distributed under the terms of the GNU " + "General Public License.\n"); + CtdlLogPrintf(CTDL_NOTICE, "\n"); + CtdlLogPrintf(CTDL_DEBUG, "Called as: %s\n", argv[0]); + CtdlLogPrintf(CTDL_INFO, "%s\n", libcitadel_version_string()); /* Load site-specific parameters, and set the ipgm secret */ - lprintf(CTDL_INFO, "Loading citadel.config\n"); + CtdlLogPrintf(CTDL_INFO, "Loading citadel.config\n"); get_config(); config.c_ipgm_secret = rand(); + + /* get_control() MUST MUST MUST be called BEFORE the databases are opened!! */ + CtdlLogPrintf(CTDL_INFO, "Acquiring control record\n"); + get_control(); + put_config(); +#ifdef HAVE_RUN_DIR + /* on some dists rundir gets purged on startup. so we need to recreate it. */ + + if (stat(ctdl_run_dir, &filestats)==-1){ +#ifdef HAVE_GETPWUID_R +#ifdef SOLARIS_GETPWUID + pwp = getpwuid_r(config.c_ctdluid, &pw, pwbuf, sizeof(pwbuf)); +#else // SOLARIS_GETPWUID + getpwuid_r(config.c_ctdluid, &pw, pwbuf, sizeof(pwbuf), &pwp); +#endif // SOLARIS_GETPWUID +#else // HAVE_GETPWUID_R + pwp = NULL; +#endif // HAVE_GETPWUID_R + + if ((mkdir(ctdl_run_dir, 0755) != 0) && (errno != EEXIST)) + CtdlLogPrintf(CTDL_EMERG, + "unable to create run directory [%s]: %s", + ctdl_run_dir, strerror(errno)); + + if (chown(ctdl_run_dir, config.c_ctdluid, (pwp==NULL)?-1:pw.pw_gid) != 0) + CtdlLogPrintf(CTDL_EMERG, + "unable to set the access rights for [%s]: %s", + ctdl_run_dir, strerror(errno)); + } + + +#endif + /* Initialize... */ init_sysdep(); @@ -166,14 +291,37 @@ int main(int argc, char **argv) */ master_startup(); + /* + * Check that the control record is correct and place sensible values if it isn't + */ + check_control(); + + /* + * Run any upgrade entry points + */ + CtdlLogPrintf(CTDL_INFO, "Upgrading modules.\n"); + upgrade_modules(); + +/** + * Load the user for the masterCC or create them if they don't exist + */ + if (CtdlGetUser(&masterCC.user, "SYS_Citadel")) + { + /** User doesn't exist. We can't use create user here as the user number needs to be 0 */ + strcpy (masterCC.user.fullname, "SYS_Citadel") ; + CtdlPutUser(&masterCC.user); + CtdlGetUser(&masterCC.user, "SYS_Citadel"); /** Just to be safe */ + } + /* * Bind the server to a Unix-domain socket. */ CtdlRegisterServiceHook(0, - "citadel.socket", + file_citadel_socket, citproto_begin_session, do_command_loop, - do_async_loop); + do_async_loop, + CitadelServiceUDS); /* * Bind the server to our favorite TCP port (usually 504). @@ -182,33 +330,67 @@ int main(int argc, char **argv) NULL, citproto_begin_session, do_command_loop, - do_async_loop); + do_async_loop, + CitadelServiceTCP); + + + /* * Load any server-side extensions available here. */ - lprintf(CTDL_INFO, "Initializing server extensions\n"); - size = strlen(bbs_home_directory) + 9; - initialize_server_extensions(); + CtdlLogPrintf(CTDL_INFO, "Initializing server extensions\n"); + size = strlen(ctdl_home_directory) + 9; + + initialise_modules(0); + + /* - * Now that we've bound the sockets, change to the BBS user id and its + * If we need host auth, start our chkpwd daemon. + */ + if (config.c_auth_mode == AUTHMODE_HOST) { + start_chkpwd_daemon(); + } + + + /* + * check, whether we're fired up another time after a crash. + * if, post an aide message, so the admin has a chance to react. + */ + checkcrash (); + + + /* + * Now that we've bound the sockets, change to the Citadel user id and its * corresponding group ids */ if (drop_root_perms) { - if ((pw = getpwuid(BBSUID)) == NULL) - lprintf(CTDL_CRIT, "WARNING: getpwuid(%ld): %s\n" - "Group IDs will be incorrect.\n", (long)BBSUID, + cdb_chmod_data(); /* make sure we own our data files */ + +#ifdef HAVE_GETPWUID_R +#ifdef SOLARIS_GETPWUID + pwp = getpwuid_r(config.c_ctdluid, &pw, pwbuf, sizeof(pwbuf)); +#else // SOLARIS_GETPWUID + getpwuid_r(config.c_ctdluid, &pw, pwbuf, sizeof(pwbuf), &pwp); +#endif // SOLARIS_GETPWUID +#else // HAVE_GETPWUID_R + pwp = NULL; +#endif // HAVE_GETPWUID_R + + if (pwp == NULL) + CtdlLogPrintf(CTDL_CRIT, "WARNING: getpwuid(%ld): %s\n" + "Group IDs will be incorrect.\n", (long)CTDLUID, strerror(errno)); else { - initgroups(pw->pw_name, pw->pw_gid); - if (setgid(pw->pw_gid)) - lprintf(CTDL_CRIT, "setgid(%ld): %s\n", (long)pw->pw_gid, + initgroups(pw.pw_name, pw.pw_gid); + if (setgid(pw.pw_gid)) + CtdlLogPrintf(CTDL_CRIT, "setgid(%ld): %s\n", (long)pw.pw_gid, strerror(errno)); } - lprintf(CTDL_INFO, "Changing uid to %ld\n", (long)BBSUID); - if (setuid(BBSUID) != 0) { - lprintf(CTDL_CRIT, "setuid() failed: %s\n", strerror(errno)); + CtdlLogPrintf(CTDL_INFO, "Changing uid to %ld\n", (long)CTDLUID); + if (setuid(CTDLUID) != 0) { + CtdlLogPrintf(CTDL_CRIT, "setuid() failed: %s\n", strerror(errno)); } #if defined (HAVE_SYS_PRCTL_H) && defined (PR_SET_DUMPABLE) prctl(PR_SET_DUMPABLE, 1); @@ -218,21 +400,9 @@ int main(int argc, char **argv) /* We want to check for idle sessions once per minute */ CtdlRegisterSessionHook(terminate_idle_sessions, EVT_TIMER); - /* - * Now create a bunch of worker threads. - */ - lprintf(CTDL_DEBUG, "Starting %d worker threads\n", config.c_min_workers-1); - begin_critical_section(S_WORKER_LIST); - for (i=0; i<(config.c_min_workers-1); ++i) { - create_worker(); - } - end_critical_section(S_WORKER_LIST); - - /* Now this thread can become a worker as well. */ - worker_thread(NULL); - - /* Server is exiting. Wait for workers to shutdown. */ - lprintf(CTDL_INFO, "Server is shutting down.\n"); - master_cleanup(); + go_threading(); + + + master_cleanup(exit_signal); return(0); }