daemon/main.c

   1 /*
   2  *  Dolda Connect - Modular multiuser Direct Connect-style client
   3  *  Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <stdio.h>
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <locale.h>
  25 #include <signal.h>
  26 #include <getopt.h>
  27 #include <time.h>
  28 #include <pwd.h>
  29 #include <grp.h>
  30 #include <sys/wait.h>
  31 #include <stdarg.h>
  32 #include <fcntl.h>
  33 #include <sys/select.h>
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38 #include "utils.h"
  39 #include "log.h"
  40 #include "conf.h"
  41 #include "module.h"
  42 #include "net.h"
  43 #include "client.h"
  44 #include "sysevents.h"
  45 #include "auth.h"
  46
  47 #ifdef HAVE_KEYUTILS
  48 #include <keyutils.h>
  49 #endif
  50
  51 struct module *modchain = NULL;
  52 static struct timer *timers = NULL;
  53 static struct child *children = NULL;
  54 volatile int running;
  55 volatile int reinit;
  56 static volatile int childrendone = 0;
  57
  58 struct timer *timercallback(double at, void (*func)(int, void *), void *data)
  59 {
  60     struct timer *new;
  61
  62     new = smalloc(sizeof(*new));
  63     new->at = at;
  64     new->func = func;
  65     new->data = data;
  66     new->next = timers;
  67     new->prev = NULL;
  68     if(timers != NULL)
  69         timers->prev = new;
  70     timers = new;
  71     return(new);
  72 }
  73
  74 void canceltimer(struct timer *timer)
  75 {
  76     if(timer->next != NULL)
  77         timer->next->prev = timer->prev;
  78     if(timer->prev != NULL)
  79         timer->prev->next = timer->next;
  80     if(timer == timers)
  81         timers = timer->next;
  82     timer->func(1, timer->data);
  83     free(timer);
  84 }
  85
  86 void childcallback(pid_t pid, void (*func)(pid_t, int, void *), void *data)
  87 {
  88     struct child *new;
  89
  90     new = smalloc(sizeof(*new));
  91     new->pid = pid;
  92     new->callback = func;
  93     new->data = data;
  94     new->finished = 0;
  95     new->prev = NULL;
  96     new->next = children;
  97     if(children != NULL)
  98         children->prev = new;
  99     children = new;
 100 }
 101
 102 static void preinit(int hup)
 103 {
 104     struct module *mod;
 105
 106     for(mod = modchain; mod != NULL; mod = mod->next)
 107     {
 108         if(mod->preinit)
 109             mod->preinit(hup);
 110         if(!hup && ((mod->conf.vars != NULL) || (mod->conf.cmds != NULL)))
 111             confregmod(&mod->conf);
 112     }
 113 }
 114
 115 static void init(int hup)
 116 {
 117     struct module *mod;
 118
 119     for(mod = modchain; mod != NULL; mod = mod->next)
 120     {
 121         if(mod->init && mod->init(hup))
 122         {
 123             flog(LOG_CRIT, "initialization of \"%s\" failed", mod->name);
 124             exit(1);
 125         }
 126     }
 127 }
 128
 129 static void terminate(void)
 130 {
 131     struct module *mod;
 132
 133     for(mod = modchain; mod != NULL; mod = mod->next)
 134     {
 135         if(mod->terminate)
 136             mod->terminate();
 137     }
 138 }
 139
 140 static void handler(int signum)
 141 {
 142     pid_t pid;
 143     int status;
 144     struct child *child;
 145     FILE *dumpfile;
 146     extern int numfnetnodes, numtransfers, numdcpeers;
 147
 148     switch(signum)
 149     {
 150     case SIGHUP:
 151         reinit = 1;
 152         break;
 153     case SIGINT:
 154     case SIGTERM:
 155         running = 0;
 156         break;
 157     case SIGCHLD:
 158         while((pid = waitpid(-1, &status, WNOHANG)) > 0)
 159         {
 160             for(child = children; child != NULL; child = child->next)
 161             {
 162                 if(child->pid == pid)
 163                 {
 164                     child->finished = 1;
 165                     child->status = status;
 166                 }
 167             }
 168             childrendone = 1;
 169         }
 170         break;
 171     case SIGUSR1:
 172         flog(LOG_NOTICE, "forking and dumping core upon SIGUSR1");
 173         if(fork() == 0)
 174             abort();
 175         break;
 176     case SIGUSR2:
 177         flog(LOG_NOTICE, "dumping memstats to /tmp/dc-mem upon SIGUSR2");
 178         if((dumpfile = fopen("/tmp/dc-mem", "w")) == NULL) {
 179             flog(LOG_ERR, "could not dump stats: %s", strerror(errno));
 180             break;
 181         }
 182         fprintf(dumpfile, "%i %i %i\n", numfnetnodes, numtransfers, numdcpeers);
 183         fclose(dumpfile);
 184         break;
 185     }
 186 }
 187
 188 pid_t forksess(uid_t user, struct authhandle *auth, void (*ccbfunc)(pid_t, int, void *), void *data, ...)
 189 {
 190     int i, o;
 191     int cpipe[2];
 192     struct
 193     {
 194         int tfd;
 195         int fd;
 196     } *files;
 197     int maxfd, type, numfiles;
 198     int acc;
 199     int *ibuf;
 200     struct passwd *pwent;
 201     pid_t pid;
 202     char *buf;
 203     va_list args;
 204     sigset_t sigset;
 205     int ret, status;
 206
 207     if((pwent = getpwuid(user)) == NULL)
 208     {
 209         flog(LOG_WARNING, "no passwd entry for uid %i, cannot fork session", user);
 210         errno = EACCES;
 211         return(-1);
 212     }
 213     if((geteuid() != 0) && (user != geteuid()))
 214     {
 215         flog(LOG_WARNING, "cannot fork non-owning session when not running as root (EUID is %i, target UID is %i)", geteuid(), user);
 216         errno = EPERM;
 217         return(-1);
 218     }
 219     va_start(args, data);
 220     numfiles = 0;
 221     files = NULL;
 222     maxfd = 0;
 223     while((type = va_arg(args, int)) != FD_END)
 224     {
 225         files = srealloc(files, sizeof(*files) * (numfiles + 1));
 226         files[numfiles].fd = va_arg(args, int);
 227         if(files[numfiles].fd > maxfd)
 228             maxfd = files[numfiles].fd;
 229         acc = va_arg(args, int);
 230         if(type == FD_PIPE)
 231         {
 232             if(pipe(cpipe) < 0)
 233             {
 234                 flog(LOG_CRIT, "could not create pipe(!): %s", strerror(errno));
 235                 for(i = 0; i < numfiles; i++)
 236                     close(files[i].tfd);
 237                 return(-1);
 238             }
 239             ibuf = va_arg(args, int *);
 240             if(acc == O_WRONLY)
 241             {
 242                 *ibuf = cpipe[1];
 243                 files[numfiles].tfd = cpipe[0];
 244             } else {
 245                 *ibuf = cpipe[0];
 246                 files[numfiles].tfd = cpipe[1];
 247             }
 248         } else if(type == FD_FILE) {
 249             buf = va_arg(args, char *);
 250             if((files[numfiles].tfd = open(buf, acc)) < 0)
 251             {
 252                 flog(LOG_CRIT, "could not open file \"%s\": %s", buf, strerror(errno));
 253                 for(i = 0; i < numfiles; i++)
 254                     close(files[i].tfd);
 255                 return(-1);
 256             }
 257         }
 258         if(files[numfiles].tfd > maxfd)
 259             maxfd = files[numfiles].tfd;
 260         numfiles++;
 261     }
 262     va_end(args);
 263     sigemptyset(&sigset);
 264     sigaddset(&sigset, SIGCHLD);
 265     sigprocmask(SIG_BLOCK, &sigset, NULL);
 266     if((pid = fork()) < 0)
 267     {
 268         flog(LOG_WARNING, "could not fork(!) in forksess(): %s", strerror(errno));
 269         for(i = 0; i < numfiles; i++)
 270             close(files[i].tfd);
 271         sigprocmask(SIG_UNBLOCK, &sigset, NULL);
 272     }
 273     if(pid == 0)
 274     {
 275         sigprocmask(SIG_UNBLOCK, &sigset, NULL);
 276         signal(SIGPIPE, SIG_DFL);
 277         signal(SIGCHLD, SIG_DFL);
 278         signal(SIGINT, SIG_DFL);
 279         signal(SIGTERM, SIG_DFL);
 280         signal(SIGHUP, SIG_DFL);
 281         for(i = 0; i < numfiles; i++)
 282         {
 283             if(dup2(files[i].tfd, maxfd + i + 1) < 0)
 284                 exit(127);
 285             files[i].tfd = maxfd + i + 1;
 286         }
 287         for(i = 0; i < numfiles; i++)
 288         {
 289             if(dup2(files[i].tfd, files[i].fd) < 0)
 290                 exit(127);
 291         }
 292         initlog();
 293         for(i = 0; i < FD_SETSIZE; i++)
 294         {
 295             if(i <= maxfd)
 296             {
 297                 for(o = 0; o < numfiles; o++)
 298                 {
 299                     if(i == files[o].fd)
 300                         break;
 301                 }
 302                 if(o == numfiles)
 303                     close(i);
 304             } else {
 305                 close(i);
 306             }
 307         }
 308         setpgid(0, 0);
 309         signal(SIGHUP, SIG_IGN);
 310         errno = 0;
 311 #ifdef HAVE_KEYUTILS
 312         keyctl_join_session_keyring(NULL);
 313         keyctl_chown(KEY_SPEC_SESSION_KEYRING, pwent->pw_uid, pwent->pw_gid);
 314 #endif
 315         if((authopensess(auth)) != AUTH_SUCCESS)
 316         {
 317             flog(LOG_WARNING, "could not open session for user %s: %s", pwent->pw_name, (errno == 0)?"Unknown error - should be logged above":strerror(errno));
 318             exit(127);
 319         }
 320         if((pid = fork()) < 0)
 321         {
 322             authclosesess(auth);
 323             exit(127);
 324         }
 325         if(pid == 0)
 326         {
 327             if(geteuid() == 0)
 328             {
 329                 if(initgroups(pwent->pw_name, pwent->pw_gid))
 330                 {
 331                     flog(LOG_WARNING, "could not initgroups: %s", strerror(errno));
 332                     exit(127);
 333                 }
 334                 if(setgid(pwent->pw_gid))
 335                 {
 336                     flog(LOG_WARNING, "could not setgid: %s", strerror(errno));
 337                     exit(127);
 338                 }
 339                 if(setuid(pwent->pw_uid))
 340                 {
 341                     flog(LOG_WARNING, "could not setuid: %s", strerror(errno));
 342                     exit(127);
 343                 }
 344                 putenv(sprintf2("HOME=%s", pwent->pw_dir));
 345                 putenv(sprintf2("SHELL=%s", pwent->pw_shell));
 346                 putenv(sprintf2("PATH=%s/bin:/usr/local/bin:/bin:/usr/bin", pwent->pw_dir));
 347             }
 348             putenv(sprintf2("USER=%s", pwent->pw_name));
 349             putenv(sprintf2("LOGNAME=%s", pwent->pw_name));
 350             chdir(pwent->pw_dir);
 351             return(0);
 352         }
 353         for(i = 0; i < numfiles; i++)
 354             close(files[i].fd);
 355         while(((ret = waitpid(pid, &status, 0)) != pid) && (ret >= 0));
 356         authclosesess(auth);
 357         if(ret < 0)
 358         {
 359             flog(LOG_WARNING, "waitpid(%i) said \"%s\"", pid, strerror(errno));
 360             exit(127);
 361         }
 362         if(!WIFEXITED(status))
 363             exit(127);
 364         exit(WEXITSTATUS(status));
 365     }
 366     for(i = 0; i < numfiles; i++)
 367         close(files[i].tfd);
 368     if(files != NULL)
 369         free(files);
 370     if(ccbfunc != NULL)
 371         childcallback(pid, ccbfunc, data);
 372     sigprocmask(SIG_UNBLOCK, &sigset, NULL);
 373     return(pid);
 374 }
 375
 376 int main(int argc, char **argv)
 377 {
 378     int c;
 379     int nofork;
 380     char *configfile;
 381     char *pidfile;
 382     FILE *pfstream, *confstream;
 383     int delay, immsyslog;
 384     struct module *mod;
 385     struct timer *timer;
 386     struct child *child;
 387     double now;
 388
 389     now = ntime();
 390     immsyslog = nofork = 0;
 391     syslogfac = LOG_DAEMON;
 392     configfile = NULL;
 393     pidfile = NULL;
 394     while((c = getopt(argc, argv, "p:C:f:hnsV")) != -1)
 395     {
 396         switch(c)
 397         {
 398         case 'p':
 399             pidfile = optarg;
 400             break;
 401         case 'C':
 402             configfile = optarg;
 403             break;
 404         case 'f':
 405             if(!strcmp(optarg, "auth"))
 406                 syslogfac = LOG_AUTH;
 407             else if(!strcmp(optarg, "authpriv"))
 408                 syslogfac = LOG_AUTHPRIV;
 409             else if(!strcmp(optarg, "cron"))
 410                 syslogfac = LOG_CRON;
 411             else if(!strcmp(optarg, "daemon"))
 412                 syslogfac = LOG_DAEMON;
 413             else if(!strcmp(optarg, "ftp"))
 414                 syslogfac = LOG_FTP;
 415             else if(!strcmp(optarg, "kern"))
 416                 syslogfac = LOG_KERN;
 417             else if(!strcmp(optarg, "lpr"))
 418                 syslogfac = LOG_LPR;
 419             else if(!strcmp(optarg, "mail"))
 420                 syslogfac = LOG_MAIL;
 421             else if(!strcmp(optarg, "news"))
 422                 syslogfac = LOG_NEWS;
 423             else if(!strcmp(optarg, "syslog"))
 424                 syslogfac = LOG_SYSLOG;
 425             else if(!strcmp(optarg, "user"))
 426                 syslogfac = LOG_USER;
 427             else if(!strcmp(optarg, "uucp"))
 428                 syslogfac = LOG_UUCP;
 429             else if(!strncmp(optarg, "local", 5) && (strlen(optarg) == 6))
 430                 syslogfac = LOG_LOCAL0 + (optarg[5] - '0');
 431             else
 432                 fprintf(stderr, "unknown syslog facility %s, using daemon\n", optarg);
 433             break;
 434         case 'n':
 435             nofork = 1;
 436             break;
 437         case 's':
 438             immsyslog = 1;
 439             break;
 440         case 'V':
 441             printf("%s", RELEASEINFO);
 442             exit(0);
 443         case 'h':
 444         case ':':
 445         case '?':
 446         default:
 447             printf("usage: doldacond [-hnsV] [-C configfile] [-p pidfile] [-f facility]\n");
 448             exit(c != 'h');
 449         }
 450     }
 451     setlocale(LC_ALL, "");
 452     initlog();
 453     if(immsyslog)
 454     {
 455         logtosyslog = 1;
 456         logtostderr = 0;
 457     }
 458     signal(SIGPIPE, SIG_IGN);
 459     signal(SIGHUP, handler);
 460     signal(SIGINT, handler);
 461     signal(SIGTERM, handler);
 462     signal(SIGCHLD, handler);
 463     signal(SIGUSR1, handler);
 464     signal(SIGUSR2, handler);
 465     preinit(0);
 466     if(configfile == NULL)
 467     {
 468         if((configfile = findfile("doldacond.conf", NULL, 0)) == NULL)
 469         {
 470             flog(LOG_CRIT, "could not find a configuration file");
 471             exit(1);
 472         }
 473     }
 474     pfstream = NULL;
 475     if(pidfile != NULL)
 476     {
 477         if((pfstream = fopen(pidfile, "w")) == NULL)
 478         {
 479             flog(LOG_CRIT, "could not open specified PID file %s: %s", pidfile, strerror(errno));
 480             exit(1);
 481         }
 482     }
 483     if((confstream = fopen(configfile, "r")) == NULL)
 484     {
 485         flog(LOG_CRIT, "could not open configuration file %s: %s", configfile, strerror(errno));
 486         exit(1);
 487     }
 488     readconfig(confstream);
 489     fclose(confstream);
 490     init(0);
 491     if(!nofork)
 492     {
 493         logtosyslog = 1;
 494         daemon(0, 0);
 495         flog(LOG_INFO, "daemonized");
 496         logtostderr = 0;
 497     }
 498     if(pfstream != NULL) {
 499         fprintf(pfstream, "%i\n", getpid());
 500         fclose(pfstream);
 501     }
 502     flog(LOG_INFO, "startup took %f seconds", ntime() - now);
 503     running = 1;
 504     reinit = 0;
 505     while(running)
 506     {
 507         if(reinit)
 508         {
 509             if((confstream = fopen(configfile, "r")) == NULL)
 510             {
 511                 flog(LOG_ERR, "could not open configuration file %s: %s (ignoring HUP)", configfile, strerror(errno));
 512             } else {
 513                 preinit(1);
 514                 readconfig(confstream);
 515                 fclose(confstream);
 516                 init(1);
 517             }
 518             reinit = 0;
 519         }
 520         delay = 1000; /* -1; */
 521         for(mod = modchain; mod != NULL; mod = mod->next)
 522         {
 523             if(mod->run && mod->run())
 524                 delay = 0;
 525         }
 526         if(!running)
 527             delay = 0;
 528         if(delay != 0)
 529         {
 530             now = ntime();
 531             for(timer = timers; timer != NULL; timer = timer->next)
 532             {
 533                 if((delay == -1) || ((int)((timer->at - now) * 1000.0) < delay))
 534                     delay = (int)((timer->at - now) * 1000.0);
 535             }
 536         }
 537         if(childrendone)
 538         {
 539             delay = 0;
 540             childrendone = 0;
 541         }
 542         pollsocks(delay);
 543         now = ntime();
 544         do
 545         {
 546             for(timer = timers; timer != NULL; timer = timer->next)
 547             {
 548                 if(now < timer->at)
 549                     continue;
 550                 if(timer->prev != NULL)
 551                     timer->prev->next = timer->next;
 552                 if(timer->next != NULL)
 553                     timer->next->prev = timer->prev;
 554                 if(timer == timers)
 555                     timers = timer->next;
 556                 timer->func(0, timer->data);
 557                 free(timer);
 558                 break;
 559             }
 560         } while(timer != NULL);
 561         do
 562         {
 563             for(child = children; child != NULL; child = child->next)
 564             {
 565                 if(child->finished)
 566                 {
 567                     child->callback(child->pid, child->status, child->data);
 568                     if(child == children)
 569                         children = child->next;
 570                     if(child->prev != NULL)
 571                         child->prev->next = child->next;
 572                     if(child->next != NULL)
 573                         child->next->prev = child->prev;
 574                     free(child);
 575                     break;
 576                 }
 577             }
 578         } while(child != NULL);
 579     }
 580     flog(LOG_INFO, "terminating...");
 581     terminate();
 582     if(pidfile != NULL)
 583         unlink(pidfile);
 584     return(0);
 585 }