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 static int doqueue = 0;
  74
  75 struct config config = {
  76         .smarthost      = NULL,
  77         .port           = 25,
  78         .aliases        = "/etc/aliases",
  79         .spooldir       = "/var/spool/dma",
  80         .authpath       = NULL,
  81         .certfile       = NULL,
  82         .features       = 0,
  83         .mailname       = NULL,
  84         .masquerade_host = NULL,
  85         .masquerade_user = NULL,
  86 };
  87
  88
  89 static void
  90 sighup_handler(int signo)
  91 {
  92         (void)signo;    /* so that gcc doesn't complain */
  93 }
  94
  95 static char *
  96 set_from(struct queue *queue, const char *osender)
  97 {
  98         const char *addr;
  99         char *sender;
 100
 101         if (osender) {
 102                 addr = osender;
 103         } else if (getenv("EMAIL") != NULL) {
 104                 addr = getenv("EMAIL");
 105         } else {
 106                 if (config.masquerade_user)
 107                         addr = config.masquerade_user;
 108                 else
 109                         addr = username;
 110         }
 111
 112         if (!strchr(addr, '@')) {
 113                 const char *from_host = hostname();
 114
 115                 if (config.masquerade_host)
 116                         from_host = config.masquerade_host;
 117
 118                 if (asprintf(&sender, "%s@%s", addr, from_host) <= 0)
 119                         return (NULL);
 120         } else {
 121                 sender = strdup(addr);
 122                 if (sender == NULL)
 123                         return (NULL);
 124         }
 125
 126         if (strchr(sender, '\n') != NULL) {
 127                 errno = EINVAL;
 128                 return (NULL);
 129         }
 130
 131         queue->sender = sender;
 132         return (sender);
 133 }
 134
 135 static int
 136 read_aliases(void)
 137 {
 138         yyin = fopen(config.aliases, "r");
 139         if (yyin == NULL) {
 140                 /*
 141                  * Non-existing aliases file is not a fatal error
 142                  */
 143                 if (errno == ENOENT)
 144                         return (0);
 145                 /* Other problems are. */
 146                 return (-1);
 147         }
 148         if (yyparse())
 149                 return (-1);    /* fatal error, probably malloc() */
 150         fclose(yyin);
 151         return (0);
 152 }
 153
 154 static int
 155 do_alias(struct queue *queue, const char *addr)
 156 {
 157         struct alias *al;
 158         struct stritem *sit;
 159         int aliased = 0;
 160
 161         LIST_FOREACH(al, &aliases, next) {
 162                 if (strcmp(al->alias, addr) != 0)
 163                         continue;
 164                 SLIST_FOREACH(sit, &al->dests, next) {
 165                         if (add_recp(queue, sit->str, EXPAND_ADDR) != 0)
 166                                 return (-1);
 167                 }
 168                 aliased = 1;
 169         }
 170
 171         return (aliased);
 172 }
 173
 174 int
 175 add_recp(struct queue *queue, const char *str, int expand)
 176 {
 177         struct qitem *it, *tit;
 178         struct passwd *pw;
 179         char *host;
 180         int aliased = 0;
 181
 182         it = calloc(1, sizeof(*it));
 183         if (it == NULL)
 184                 return (-1);
 185         it->addr = strdup(str);
 186         if (it->addr == NULL)
 187                 return (-1);
 188
 189         it->sender = queue->sender;
 190         host = strrchr(it->addr, '@');
 191         if (host != NULL &&
 192             (strcmp(host + 1, hostname()) == 0 ||
 193              strcmp(host + 1, "localhost") == 0)) {
 194                 *host = 0;
 195         }
 196         LIST_FOREACH(tit, &queue->queue, next) {
 197                 /* weed out duplicate dests */
 198                 if (strcmp(tit->addr, it->addr) == 0) {
 199                         free(it->addr);
 200                         free(it);
 201                         return (0);
 202                 }
 203         }
 204         LIST_INSERT_HEAD(&queue->queue, it, next);
 205
 206         /**
 207          * Do local delivery if there is no @.
 208          * Do not do local delivery when NULLCLIENT is set.
 209          */
 210         if (strrchr(it->addr, '@') == NULL && (config.features & NULLCLIENT) == 0) {
 211                 it->remote = 0;
 212                 if (expand) {
 213                         aliased = do_alias(queue, it->addr);
 214                         if (!aliased && expand == EXPAND_WILDCARD)
 215                                 aliased = do_alias(queue, "*");
 216                         if (aliased < 0)
 217                                 return (-1);
 218                         if (aliased) {
 219                                 LIST_REMOVE(it, next);
 220                         } else {
 221                                 /* Local destination, check */
 222                                 pw = getpwnam(it->addr);
 223                                 if (pw == NULL)
 224                                         goto out;
 225                                 /* XXX read .forward */
 226                                 endpwent();
 227                         }
 228                 }
 229         } else {
 230                 it->remote = 1;
 231         }
 232
 233         return (0);
 234
 235 out:
 236         free(it->addr);
 237         free(it);
 238         return (-1);
 239 }
 240
 241 static struct qitem *
 242 go_background(struct queue *queue)
 243 {
 244         struct sigaction sa;
 245         struct qitem *it;
 246         pid_t pid;
 247
 248         if (daemonize && daemon(0, 0) != 0) {
 249                 syslog(LOG_ERR, "can not daemonize: %m");
 250                 exit(1);
 251         }
 252         daemonize = 0;
 253
 254         bzero(&sa, sizeof(sa));
 255         sa.sa_handler = SIG_IGN;
 256         sigaction(SIGCHLD, &sa, NULL);
 257
 258         LIST_FOREACH(it, &queue->queue, next) {
 259                 /* No need to fork for the last dest */
 260                 if (LIST_NEXT(it, next) == NULL)
 261                         goto retit;
 262
 263                 pid = fork();
 264                 switch (pid) {
 265                 case -1:
 266                         syslog(LOG_ERR, "can not fork: %m");
 267                         exit(1);
 268                         break;
 269
 270                 case 0:
 271                         /*
 272                          * Child:
 273                          *
 274                          * return and deliver mail
 275                          */
 276 retit:
 277                         /*
 278                          * If necessary, acquire the queue and * mail files.
 279                          * If this fails, we probably were raced by another
 280                          * process.  It is okay to be raced if we're supposed
 281                          * to flush the queue.
 282                          */
 283                         setlogident("%s", it->queueid);
 284                         switch (acquirespool(it)) {
 285                         case 0:
 286                                 break;
 287                         case 1:
 288                                 if (doqueue)
 289                                         exit(0);
 290                                 syslog(LOG_WARNING, "could not lock queue file");
 291                                 exit(1);
 292                         default:
 293                                 exit(1);
 294                         }
 295                         dropspool(queue, it);
 296                         return (it);
 297
 298                 default:
 299                         /*
 300                          * Parent:
 301                          *
 302                          * fork next child
 303                          */
 304                         break;
 305                 }
 306         }
 307
 308         syslog(LOG_CRIT, "reached dead code");
 309         exit(1);
 310 }
 311
 312 static void
 313 deliver(struct qitem *it)
 314 {
 315         int error;
 316         unsigned int backoff = MIN_RETRY, slept;
 317         struct timeval now;
 318         struct stat st;
 319
 320         snprintf(errmsg, sizeof(errmsg), "unknown bounce reason");
 321
 322 retry:
 323         syslog(LOG_INFO, "trying delivery");
 324
 325         if (it->remote)
 326                 error = deliver_remote(it);
 327         else
 328                 error = deliver_local(it);
 329
 330         switch (error) {
 331         case 0:
 332                 delqueue(it);
 333                 syslog(LOG_INFO, "delivery successful");
 334                 exit(0);
 335
 336         case 1:
 337                 if (stat(it->queuefn, &st) != 0) {
 338                         syslog(LOG_ERR, "lost queue file `%s'", it->queuefn);
 339                         exit(1);
 340                 }
 341                 if (gettimeofday(&now, NULL) == 0 &&
 342                     (now.tv_sec - st.st_mtim.tv_sec > MAX_TIMEOUT)) {
 343                         snprintf(errmsg, sizeof(errmsg),
 344                                  "Could not deliver for the last %d seconds. Giving up.",
 345                                  MAX_TIMEOUT);
 346                         goto bounce;
 347                 }
 348                 for (slept = 0; slept < backoff;) {
 349                         slept += SLEEP_TIMEOUT - sleep(SLEEP_TIMEOUT);
 350                         if (flushqueue_since(slept)) {
 351                                 backoff = MIN_RETRY;
 352                                 goto retry;
 353                         }
 354                 }
 355                 if (slept >= backoff) {
 356                         /* pick the next backoff between [1.5, 2.5) times backoff */
 357                         backoff = backoff + backoff / 2 + random() % backoff;
 358                         if (backoff > MAX_RETRY)
 359                                 backoff = MAX_RETRY;
 360                 }
 361                 goto retry;
 362
 363         case -1:
 364         default:
 365                 break;
 366         }
 367
 368 bounce:
 369         bounce(it, errmsg);
 370         /* NOTREACHED */
 371 }
 372
 373 void
 374 run_queue(struct queue *queue)
 375 {
 376         struct qitem *it;
 377
 378         if (LIST_EMPTY(&queue->queue))
 379                 return;
 380
 381         it = go_background(queue);
 382         deliver(it);
 383         /* NOTREACHED */
 384 }
 385
 386 static void
 387 show_queue(struct queue *queue)
 388 {
 389         struct qitem *it;
 390         int locked = 0; /* XXX */
 391
 392         if (LIST_EMPTY(&queue->queue)) {
 393                 printf("Mail queue is empty\n");
 394                 return;
 395         }
 396
 397         LIST_FOREACH(it, &queue->queue, next) {
 398                 printf("ID\t: %s%s\n"
 399                        "From\t: %s\n"
 400                        "To\t: %s\n",
 401                        it->queueid,
 402                        locked ? "*" : "",
 403                        it->sender, it->addr);
 404
 405                 if (LIST_NEXT(it, next) != NULL)
 406                         printf("--\n");
 407         }
 408 }
 409
 410 /*
 411  * TODO:
 412  *
 413  * - alias processing
 414  * - use group permissions
 415  * - proper sysexit codes
 416  */
 417
 418 int
 419 main(int argc, char **argv)
 420 {
 421         struct sigaction act;
 422         char *sender = NULL;
 423         struct queue queue;
 424         int i, ch;
 425         int nodot = 0, showq = 0, queue_only = 0;
 426         int recp_from_header = 0;
 427
 428         set_username();
 429
 430         /*
 431          * We never run as root.  If called by root, drop permissions
 432          * to the mail user.
 433          */
 434         if (geteuid() == 0 || getuid() == 0) {
 435                 struct passwd *pw;
 436
 437                 errno = 0;
 438                 pw = getpwnam(DMA_ROOT_USER);
 439                 if (pw == NULL) {
 440                         if (errno == 0)
 441                                 errx(1, "user '%s' not found", DMA_ROOT_USER);
 442                         else
 443                                 err(1, "cannot drop root privileges");
 444                 }
 445
 446                 if (setuid(pw->pw_uid) != 0)
 447                         err(1, "cannot drop root privileges");
 448
 449                 if (geteuid() == 0 || getuid() == 0)
 450                         errx(1, "cannot drop root privileges");
 451         }
 452
 453         atexit(deltmp);
 454         init_random();
 455
 456         bzero(&queue, sizeof(queue));
 457         LIST_INIT(&queue.queue);
 458
 459         if (strcmp(argv[0], "mailq") == 0) {
 460                 argv++; argc--;
 461                 showq = 1;
 462                 if (argc != 0)
 463                         errx(1, "invalid arguments");
 464                 goto skipopts;
 465         } else if (strcmp(argv[0], "newaliases") == 0) {
 466                 logident_base = "dma";
 467                 setlogident(NULL);
 468
 469                 if (read_aliases() != 0)
 470                         errx(1, "could not parse aliases file `%s'", config.aliases);
 471                 exit(0);
 472         }
 473
 474         opterr = 0;
 475         while ((ch = getopt(argc, argv, ":A:b:B:C:d:Df:F:h:iL:N:no:O:q:r:R:tUV:vX:")) != -1) {
 476                 switch (ch) {
 477                 case 'A':
 478                         /* -AX is being ignored, except for -A{c,m} */
 479                         if (optarg[0] == 'c' || optarg[0] == 'm') {
 480                                 break;
 481                         }
 482                         /* else FALLTRHOUGH */
 483                 case 'b':
 484                         /* -bX is being ignored, except for -bp */
 485                         if (optarg[0] == 'p') {
 486                                 showq = 1;
 487                                 break;
 488                         } else if (optarg[0] == 'q') {
 489                                 queue_only = 1;
 490                                 break;
 491                         }
 492                         /* else FALLTRHOUGH */
 493                 case 'D':
 494                         daemonize = 0;
 495                         break;
 496                 case 'L':
 497                         logident_base = optarg;
 498                         break;
 499                 case 'f':
 500                 case 'r':
 501                         sender = optarg;
 502                         break;
 503
 504                 case 't':
 505                         recp_from_header = 1;
 506                         break;
 507
 508                 case 'o':
 509                         /* -oX is being ignored, except for -oi */
 510                         if (optarg[0] != 'i')
 511                                 break;
 512                         /* else FALLTRHOUGH */
 513                 case 'O':
 514                         break;
 515                 case 'i':
 516                         nodot = 1;
 517                         break;
 518
 519                 case 'q':
 520                         /* Don't let getopt slup up other arguments */
 521                         if (optarg && *optarg == '-')
 522                                 optind--;
 523                         doqueue = 1;
 524                         break;
 525
 526                 /* Ignored options */
 527                 case 'B':
 528                 case 'C':
 529                 case 'd':
 530                 case 'F':
 531                 case 'h':
 532                 case 'N':
 533                 case 'n':
 534                 case 'R':
 535                 case 'U':
 536                 case 'V':
 537                 case 'v':
 538                 case 'X':
 539                         break;
 540
 541                 case ':':
 542                         if (optopt == 'q') {
 543                                 doqueue = 1;
 544                                 break;
 545                         }
 546                         /* FALLTHROUGH */
 547
 548                 default:
 549                         fprintf(stderr, "invalid argument: `-%c'\n", optopt);
 550                         exit(1);
 551                 }
 552         }
 553         argc -= optind;
 554         argv += optind;
 555         opterr = 1;
 556
 557         if (argc != 0 && (showq || doqueue))
 558                 errx(1, "sending mail and queue operations are mutually exclusive");
 559
 560         if (showq + doqueue > 1)
 561                 errx(1, "conflicting queue operations");
 562
 563 skipopts:
 564         if (logident_base == NULL)
 565                 logident_base = "dma";
 566         setlogident(NULL);
 567
 568         act.sa_handler = sighup_handler;
 569         act.sa_flags = 0;
 570         sigemptyset(&act.sa_mask);
 571         if (sigaction(SIGHUP, &act, NULL) != 0)
 572                 syslog(LOG_WARNING, "can not set signal handler: %m");
 573
 574         parse_conf(CONF_PATH "/dma.conf");
 575
 576         if (config.authpath != NULL)
 577                 parse_authfile(config.authpath);
 578
 579         if (showq) {
 580                 if (load_queue(&queue) < 0)
 581                         errlog(1, "can not load queue");
 582                 show_queue(&queue);
 583                 return (0);
 584         }
 585
 586         if (doqueue) {
 587                 flushqueue_signal();
 588                 if (load_queue(&queue) < 0)
 589                         errlog(1, "can not load queue");
 590                 run_queue(&queue);
 591                 return (0);
 592         }
 593
 594         if (read_aliases() != 0)
 595                 errlog(1, "could not parse aliases file `%s'", config.aliases);
 596
 597         if ((sender = set_from(&queue, sender)) == NULL)
 598                 errlog(1, NULL);
 599
 600         if (newspoolf(&queue) != 0)
 601                 errlog(1, "can not create temp file in `%s'", config.spooldir);
 602
 603         setlogident("%s", queue.id);
 604
 605         for (i = 0; i < argc; i++) {
 606                 if (add_recp(&queue, argv[i], EXPAND_WILDCARD) != 0)
 607                         errlogx(1, "invalid recipient `%s'", argv[i]);
 608         }
 609
 610         if (LIST_EMPTY(&queue.queue) && !recp_from_header)
 611                 errlogx(1, "no recipients");
 612
 613         if (readmail(&queue, nodot, recp_from_header) != 0)
 614                 errlog(1, "can not read mail");
 615
 616         if (LIST_EMPTY(&queue.queue))
 617                 errlogx(1, "no recipients");
 618
 619         if (linkspool(&queue) != 0)
 620                 errlog(1, "can not create spools");
 621
 622         /* From here on the mail is safe. */
 623
 624         if (config.features & DEFER || queue_only)
 625                 return (0);
 626
 627         run_queue(&queue);
 628
 629         /* NOTREACHED */
 630         return (0);
 631 }