libexec/dma/dma.c

   1 /*
   2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Simon 'corecode' Schubert <corecode@fs.ei.tum.de>.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "dfcompat.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/types.h>
  39 #include <sys/queue.h>
  40 #include <sys/stat.h>
  41 #include <sys/time.h>
  42 #include <sys/wait.h>
  43
  44 #include <dirent.h>
  45 #include <err.h>
  46 #include <errno.h>
  47 #include <fcntl.h>
  48 #include <inttypes.h>
  49 #include <paths.h>
  50 #include <pwd.h>
  51 #include <signal.h>
  52 #include <stdarg.h>
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <syslog.h>
  57 #include <unistd.h>
  58
  59 #include "dma.h"
  60
  61
  62 static void deliver(struct qitem *);
  63
  64 struct aliases aliases = LIST_HEAD_INITIALIZER(aliases);
  65 struct strlist tmpfs = SLIST_HEAD_INITIALIZER(tmpfs);
  66 struct authusers authusers = LIST_HEAD_INITIALIZER(authusers);
  67 char username[USERNAME_SIZE];
  68 uid_t useruid;
  69 const char *logident_base;
  70 char errmsg[ERRMSG_SIZE];
  71
  72 static int daemonize = 1;
  73
  74 struct config config = {
  75         .smarthost      = NULL,
  76         .port           = 25,
  77         .aliases        = "/etc/aliases",
  78         .spooldir       = "/var/spool/dma",
  79         .authpath       = NULL,
  80         .certfile       = NULL,
  81         .features       = 0,
  82         .mailname       = NULL,
  83         .masquerade_host = NULL,
  84         .masquerade_user = NULL,
  85 };
  86
  87
  88 static void
  89 sighup_handler(int signo)
  90 {
  91         (void)signo;    /* so that gcc doesn't complain */
  92 }
  93
  94 static char *
  95 set_from(struct queue *queue, const char *osender)
  96 {
  97         char *sender;
  98
  99         if (osender) {
 100                 sender = strdup(osender);
 101                 if (sender == NULL)
 102                         return (NULL);
 103         } else if (getenv("EMAIL") != NULL) {
 104                 sender = strdup(getenv("EMAIL"));
 105                 if (sender == NULL)
 106                         return (NULL);
 107         } else {
 108                 const char *from_user = username;
 109                 const char *from_host = hostname();
 110
 111                 if (config.masquerade_user)
 112                         from_user = config.masquerade_user;
 113                 if (config.masquerade_host)
 114                         from_host = config.masquerade_host;
 115                 if (asprintf(&sender, "%s@%s", from_user, from_host) <= 0)
 116                         return (NULL);
 117         }
 118
 119         if (strchr(sender, '\n') != NULL) {
 120                 errno = EINVAL;
 121                 return (NULL);
 122         }
 123
 124         queue->sender = sender;
 125         return (sender);
 126 }
 127
 128 static int
 129 read_aliases(void)
 130 {
 131         yyin = fopen(config.aliases, "r");
 132         if (yyin == NULL) {
 133                 /*
 134                  * Non-existing aliases file is not a fatal error
 135                  */
 136                 if (errno == ENOENT)
 137                         return (0);
 138                 /* Other problems are. */
 139                 return (-1);
 140         }
 141         if (yyparse())
 142                 return (-1);    /* fatal error, probably malloc() */
 143         fclose(yyin);
 144         return (0);
 145 }
 146
 147 static int
 148 do_alias(struct queue *queue, const char *addr)
 149 {
 150         struct alias *al;
 151         struct stritem *sit;
 152         int aliased = 0;
 153
 154         LIST_FOREACH(al, &aliases, next) {
 155                 if (strcmp(al->alias, addr) != 0)
 156                         continue;
 157                 SLIST_FOREACH(sit, &al->dests, next) {
 158                         if (add_recp(queue, sit->str, EXPAND_ADDR) != 0)
 159                                 return (-1);
 160                 }
 161                 aliased = 1;
 162         }
 163
 164         return (aliased);
 165 }
 166
 167 int
 168 add_recp(struct queue *queue, const char *str, int expand)
 169 {
 170         struct qitem *it, *tit;
 171         struct passwd *pw;
 172         char *host;
 173         int aliased = 0;
 174
 175         it = calloc(1, sizeof(*it));
 176         if (it == NULL)
 177                 return (-1);
 178         it->addr = strdup(str);
 179         if (it->addr == NULL)
 180                 return (-1);
 181
 182         it->sender = queue->sender;
 183         host = strrchr(it->addr, '@');
 184         if (host != NULL &&
 185             (strcmp(host + 1, hostname()) == 0 ||
 186              strcmp(host + 1, "localhost") == 0)) {
 187                 *host = 0;
 188         }
 189         LIST_FOREACH(tit, &queue->queue, next) {
 190                 /* weed out duplicate dests */
 191                 if (strcmp(tit->addr, it->addr) == 0) {
 192                         free(it->addr);
 193                         free(it);
 194                         return (0);
 195                 }
 196         }
 197         LIST_INSERT_HEAD(&queue->queue, it, next);
 198         if (strrchr(it->addr, '@') == NULL) {
 199                 it->remote = 0;
 200                 if (expand) {
 201                         aliased = do_alias(queue, it->addr);
 202                         if (!aliased && expand == EXPAND_WILDCARD)
 203                                 aliased = do_alias(queue, "*");
 204                         if (aliased < 0)
 205                                 return (-1);
 206                         if (aliased) {
 207                                 LIST_REMOVE(it, next);
 208                         } else {
 209                                 /* Local destination, check */
 210                                 pw = getpwnam(it->addr);
 211                                 if (pw == NULL)
 212                                         goto out;
 213                                 /* XXX read .forward */
 214                                 endpwent();
 215                         }
 216                 }
 217         } else {
 218                 it->remote = 1;
 219         }
 220
 221         return (0);
 222
 223 out:
 224         free(it->addr);
 225         free(it);
 226         return (-1);
 227 }
 228
 229 static struct qitem *
 230 go_background(struct queue *queue)
 231 {
 232         struct sigaction sa;
 233         struct qitem *it;
 234         pid_t pid;
 235
 236         if (daemonize && daemon(0, 0) != 0) {
 237                 syslog(LOG_ERR, "can not daemonize: %m");
 238                 exit(1);
 239         }
 240         daemonize = 0;
 241
 242         bzero(&sa, sizeof(sa));
 243         sa.sa_handler = SIG_IGN;
 244         sigaction(SIGCHLD, &sa, NULL);
 245
 246         LIST_FOREACH(it, &queue->queue, next) {
 247                 /* No need to fork for the last dest */
 248                 if (LIST_NEXT(it, next) == NULL)
 249                         goto retit;
 250
 251                 pid = fork();
 252                 switch (pid) {
 253                 case -1:
 254                         syslog(LOG_ERR, "can not fork: %m");
 255                         exit(1);
 256                         break;
 257
 258                 case 0:
 259                         /*
 260                          * Child:
 261                          *
 262                          * return and deliver mail
 263                          */
 264 retit:
 265                         /*
 266                          * If necessary, acquire the queue and * mail files.
 267                          * If this fails, we probably were raced by another
 268                          * process.
 269                          */
 270                         setlogident("%s", it->queueid);
 271                         if (acquirespool(it) < 0)
 272                                 exit(1);
 273                         dropspool(queue, it);
 274                         return (it);
 275
 276                 default:
 277                         /*
 278                          * Parent:
 279                          *
 280                          * fork next child
 281                          */
 282                         break;
 283                 }
 284         }
 285
 286         syslog(LOG_CRIT, "reached dead code");
 287         exit(1);
 288 }
 289
 290 static void
 291 deliver(struct qitem *it)
 292 {
 293         int error;
 294         unsigned int backoff = MIN_RETRY;
 295         struct timeval now;
 296         struct stat st;
 297
 298         snprintf(errmsg, sizeof(errmsg), "unknown bounce reason");
 299
 300 retry:
 301         syslog(LOG_INFO, "trying delivery");
 302
 303         if (it->remote)
 304                 error = deliver_remote(it);
 305         else
 306                 error = deliver_local(it);
 307
 308         switch (error) {
 309         case 0:
 310                 delqueue(it);
 311                 syslog(LOG_INFO, "delivery successful");
 312                 exit(0);
 313
 314         case 1:
 315                 if (stat(it->queuefn, &st) != 0) {
 316                         syslog(LOG_ERR, "lost queue file `%s'", it->queuefn);
 317                         exit(1);
 318                 }
 319                 if (gettimeofday(&now, NULL) == 0 &&
 320                     (now.tv_sec - st.st_mtim.tv_sec > MAX_TIMEOUT)) {
 321                         snprintf(errmsg, sizeof(errmsg),
 322                                  "Could not deliver for the last %d seconds. Giving up.",
 323                                  MAX_TIMEOUT);
 324                         goto bounce;
 325                 }
 326                 if (sleep(backoff) == 0) {
 327                         /* pick the next backoff between [1.5, 2.5) times backoff */
 328                         backoff = backoff + backoff / 2 + random() % backoff;
 329                         if (backoff > MAX_RETRY)
 330                                 backoff = MAX_RETRY;
 331                 }
 332                 goto retry;
 333
 334         case -1:
 335         default:
 336                 break;
 337         }
 338
 339 bounce:
 340         bounce(it, errmsg);
 341         /* NOTREACHED */
 342 }
 343
 344 void
 345 run_queue(struct queue *queue)
 346 {
 347         struct qitem *it;
 348
 349         if (LIST_EMPTY(&queue->queue))
 350                 return;
 351
 352         it = go_background(queue);
 353         deliver(it);
 354         /* NOTREACHED */
 355 }
 356
 357 static void
 358 show_queue(struct queue *queue)
 359 {
 360         struct qitem *it;
 361         int locked = 0; /* XXX */
 362
 363         if (LIST_EMPTY(&queue->queue)) {
 364                 printf("Mail queue is empty\n");
 365                 return;
 366         }
 367
 368         LIST_FOREACH(it, &queue->queue, next) {
 369                 printf("ID\t: %s%s\n"
 370                        "From\t: %s\n"
 371                        "To\t: %s\n",
 372                        it->queueid,
 373                        locked ? "*" : "",
 374                        it->sender, it->addr);
 375
 376                 if (LIST_NEXT(it, next) != NULL)
 377                         printf("--\n");
 378         }
 379 }
 380
 381 /*
 382  * TODO:
 383  *
 384  * - alias processing
 385  * - use group permissions
 386  * - proper sysexit codes
 387  */
 388
 389 int
 390 main(int argc, char **argv)
 391 {
 392         struct sigaction act;
 393         char *sender = NULL;
 394         struct queue queue;
 395         int i, ch;
 396         int nodot = 0, doqueue = 0, showq = 0, queue_only = 0;
 397         int recp_from_header = 0;
 398
 399         set_username();
 400
 401         /*
 402          * We never run as root.  If called by root, drop permissions
 403          * to the mail user.
 404          */
 405         if (geteuid() == 0 || getuid() == 0) {
 406                 struct passwd *pw;
 407
 408                 pw = getpwnam(DMA_ROOT_USER);
 409                 if (pw == NULL)
 410                         err(1, "cannot drop root privileges");
 411
 412                 if (setuid(pw->pw_uid) != 0)
 413                         err(1, "cannot drop root privileges");
 414
 415                 if (geteuid() == 0 || getuid() == 0)
 416                         errx(1, "cannot drop root privileges");
 417         }
 418
 419         atexit(deltmp);
 420         init_random();
 421
 422         bzero(&queue, sizeof(queue));
 423         LIST_INIT(&queue.queue);
 424
 425         if (strcmp(argv[0], "mailq") == 0) {
 426                 argv++; argc--;
 427                 showq = 1;
 428                 if (argc != 0)
 429                         errx(1, "invalid arguments");
 430                 goto skipopts;
 431         }
 432
 433         opterr = 0;
 434         while ((ch = getopt(argc, argv, ":A:b:B:C:d:Df:F:h:iL:N:no:O:q:r:R:tUV:vX:")) != -1) {
 435                 switch (ch) {
 436                 case 'A':
 437                         /* -AX is being ignored, except for -A{c,m} */
 438                         if (optarg[0] == 'c' || optarg[0] == 'm') {
 439                                 break;
 440                         }
 441                         /* else FALLTRHOUGH */
 442                 case 'b':
 443                         /* -bX is being ignored, except for -bp */
 444                         if (optarg[0] == 'p') {
 445                                 showq = 1;
 446                                 break;
 447                         } else if (optarg[0] == 'q') {
 448                                 queue_only = 1;
 449                                 break;
 450                         }
 451                         /* else FALLTRHOUGH */
 452                 case 'D':
 453                         daemonize = 0;
 454                         break;
 455                 case 'L':
 456                         logident_base = optarg;
 457                         break;
 458                 case 'f':
 459                 case 'r':
 460                         sender = optarg;
 461                         break;
 462
 463                 case 't':
 464                         recp_from_header = 1;
 465                         break;
 466
 467                 case 'o':
 468                         /* -oX is being ignored, except for -oi */
 469                         if (optarg[0] != 'i')
 470                                 break;
 471                         /* else FALLTRHOUGH */
 472                 case 'O':
 473                         break;
 474                 case 'i':
 475                         nodot = 1;
 476                         break;
 477
 478                 case 'q':
 479                         doqueue = 1;
 480                         break;
 481
 482                 /* Ignored options */
 483                 case 'B':
 484                 case 'C':
 485                 case 'd':
 486                 case 'F':
 487                 case 'h':
 488                 case 'N':
 489                 case 'n':
 490                 case 'R':
 491                 case 'U':
 492                 case 'V':
 493                 case 'v':
 494                 case 'X':
 495                         break;
 496
 497                 case ':':
 498                         if (optopt == 'q') {
 499                                 doqueue = 1;
 500                                 break;
 501                         }
 502                         /* FALLTHROUGH */
 503
 504                 default:
 505                         fprintf(stderr, "invalid argument: `-%c'\n", optopt);
 506                         exit(1);
 507                 }
 508         }
 509         argc -= optind;
 510         argv += optind;
 511         opterr = 1;
 512
 513         if (argc != 0 && (showq || doqueue))
 514                 errx(1, "sending mail and queue operations are mutually exclusive");
 515
 516         if (showq + doqueue > 1)
 517                 errx(1, "conflicting queue operations");
 518
 519 skipopts:
 520         if (logident_base == NULL)
 521                 logident_base = "dma";
 522         setlogident(NULL);
 523
 524         act.sa_handler = sighup_handler;
 525         act.sa_flags = 0;
 526         sigemptyset(&act.sa_mask);
 527         if (sigaction(SIGHUP, &act, NULL) != 0)
 528                 syslog(LOG_WARNING, "can not set signal handler: %m");
 529
 530         parse_conf(CONF_PATH "/dma.conf");
 531
 532         if (config.authpath != NULL)
 533                 parse_authfile(config.authpath);
 534
 535         if (showq) {
 536                 if (load_queue(&queue) < 0)
 537                         errlog(1, "can not load queue");
 538                 show_queue(&queue);
 539                 return (0);
 540         }
 541
 542         if (doqueue) {
 543                 if (load_queue(&queue) < 0)
 544                         errlog(1, "can not load queue");
 545                 run_queue(&queue);
 546                 return (0);
 547         }
 548
 549         if (read_aliases() != 0)
 550                 errlog(1, "can not read aliases file `%s'", config.aliases);
 551
 552         if ((sender = set_from(&queue, sender)) == NULL)
 553                 errlog(1, NULL);
 554
 555         if (newspoolf(&queue) != 0)
 556                 errlog(1, "can not create temp file");
 557
 558         setlogident("%s", queue.id);
 559
 560         for (i = 0; i < argc; i++) {
 561                 if (add_recp(&queue, argv[i], EXPAND_WILDCARD) != 0)
 562                         errlogx(1, "invalid recipient `%s'", argv[i]);
 563         }
 564
 565         if (LIST_EMPTY(&queue.queue) && !recp_from_header)
 566                 errlogx(1, "no recipients");
 567
 568         if (readmail(&queue, nodot, recp_from_header) != 0)
 569                 errlog(1, "can not read mail");
 570
 571         if (LIST_EMPTY(&queue.queue))
 572                 errlogx(1, "no recipients");
 573
 574         if (linkspool(&queue) != 0)
 575                 errlog(1, "can not create spools");
 576
 577         /* From here on the mail is safe. */
 578
 579         if (config.features & DEFER || queue_only)
 580                 return (0);
 581
 582         run_queue(&queue);
 583
 584         /* NOTREACHED */
 585         return (0);
 586 }