diplodocus.org Git - nmh/blob - sbr/mts.c

   1
   2 /*
   3  * mts.c -- definitions for the mail transport system
   4  *
   5  * $Id$
   6  *
   7  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   8  * COPYRIGHT file in the root directory of the nmh distribution for
   9  * complete copyright information.
  10  */
  11
  12 #include <h/mh.h>   /* for snprintf() */
  13 #include <h/nmh.h>
  14 #include <h/utils.h>
  15
  16 #define nmhetcdir(file) NMHETCDIR#file
  17
  18 #include <ctype.h>
  19 #include <stdio.h>
  20 #include <h/mts.h>
  21 #include <pwd.h>
  22 #include <netdb.h>
  23
  24 #ifdef HAVE_SYS_UTSNAME_H
  25 # include <sys/utsname.h>
  26 #endif
  27
  28 #define NOTOK   (-1)
  29 #define OK        0
  30
  31 /*
  32  * static prototypes
  33  */
  34 static char *tailor_value (unsigned char *);
  35 static void getuserinfo (void);
  36
  37 /*
  38  * *mmdfldir and *uucpldir are the maildrop directories.  If maildrops
  39  * are kept in the user's home directory, then these should be empty
  40  * strings.  In this case, the appropriate ...lfil array should contain
  41  * the name of the file in the user's home directory.  Usually, this is
  42  * something like ".mail".
  43  */
  44
  45 /*
  46  * nmh mail transport interface customization file
  47  */
  48 static char *mtsconf = nmhetcdir(/mts.conf);
  49
  50 static char *localname   = "";
  51 static char *localdomain = "";
  52 static char *systemname  = "";
  53
  54 char *mmdfldir = MAILSPOOL;
  55 char *mmdflfil = "";
  56 char *uucpldir = "/usr/spool/mail";
  57 char *uucplfil = "";
  58
  59 char *mmdlm1 = "\001\001\001\001\n";
  60 char *mmdlm2 = "\001\001\001\001\n";
  61
  62 /* Cache the username and fullname of the user */
  63 static char username[BUFSIZ];
  64 static char fullname[BUFSIZ];
  65
  66 /* Variables for username masquerading: */
  67        boolean  draft_from_masquerading = FALSE;  /* also used from post.c */
  68 static boolean  mmailid_masquerading = FALSE;
  69        boolean  username_extension_masquerading = FALSE;  /* " from addrsbr.c */
  70 static char*    masquerade = "";
  71
  72 /*
  73  * MTS specific variables
  74  */
  75 #if defined(SMTPMTS)
  76 static char *sm_method = "smtp";
  77 int  sm_mts    = MTS_SMTP;
  78 char *hostable = nmhetcdir(/hosts);
  79 char *sendmail = SENDMAILPATH;
  80 #endif
  81
  82 /*
  83  * SMTP/POP stuff
  84  */
  85 char *clientname = NULL;
  86 char *servers    = "localhost \01localnet";
  87 char *pophost    = "";
  88
  89 /*
  90  * BBoards-specific variables
  91  */
  92 char *bb_domain = "";
  93
  94
  95 /*
  96  * POP BBoards-specific variables
  97  */
  98 #ifdef  BPOP
  99 char *popbbhost = "";
 100 char *popbbuser = "";
 101 char *popbblist = nmhetcdir(/hosts.popbb);
 102 #endif /* BPOP */
 103
 104 /*
 105  * Global MailDelivery file
 106  */
 107 char *maildelivery = nmhetcdir(/maildelivery);
 108
 109
 110 /*
 111  * Aliasing Facility (doesn't belong here)
 112  */
 113 int Everyone = NOTOK;
 114 static char *everyone = "-1";
 115 char *NoShell = "";
 116
 117 /*
 118  * Customize the MTS settings for nmh by adjusting
 119  * the file mts.conf in the nmh etc directory.
 120  */
 121
 122 struct bind {
 123     char *keyword;
 124     char **value;
 125 };
 126
 127 static struct bind binds[] = {
 128     { "localname", &localname },
 129     { "localdomain", &localdomain },
 130     { "systemname", &systemname },
 131     { "mmdfldir", &mmdfldir },
 132     { "mmdflfil", &mmdflfil },
 133     { "uucpldir", &uucpldir },
 134     { "uucplfil", &uucplfil },
 135     { "mmdelim1", &mmdlm1 },
 136     { "mmdelim2", &mmdlm2 },
 137     { "masquerade", &masquerade },
 138
 139 #if defined(SMTPMTS)
 140     { "mts",      &sm_method },
 141     { "hostable", &hostable  },
 142     { "sendmail", &sendmail  },
 143 #endif
 144
 145     { "clientname",  &clientname },
 146     { "servers", &servers },
 147     { "pophost", &pophost },
 148     { "bbdomain", &bb_domain },
 149
 150 #ifdef BPOP
 151     { "popbbhost", &popbbhost },
 152     { "popbbuser", &popbbuser },
 153     { "popbblist", &popbblist },
 154 #endif
 155
 156 #ifdef NNTP
 157     { "nntphost", &popbbhost },
 158 #endif
 159
 160     { "maildelivery", &maildelivery },
 161     { "everyone", &everyone },
 162     { "noshell", &NoShell },
 163     { NULL, NULL }
 164 };
 165
 166
 167 /*
 168  * Read the configuration file for the nmh interface
 169  * to the mail transport system (MTS).
 170  */
 171
 172 void
 173 mts_init (char *name)
 174 {
 175     unsigned char *bp;
 176     char *cp, buffer[BUFSIZ];
 177     struct bind *b;
 178     FILE *fp;
 179     static int inited = 0;
 180
 181     if (inited++ || (fp = fopen (mtsconf, "r")) == NULL)
 182         return;
 183
 184     while (fgets (buffer, sizeof(buffer), fp)) {
 185         if (!(cp = strchr(buffer, '\n')))
 186             break;
 187         *cp = 0;
 188         if (*buffer == '#' || *buffer == '\0')
 189             continue;
 190         if (!(bp = strchr(buffer, ':')))
 191             break;
 192         *bp++ = 0;
 193         while (isspace (*bp))
 194             *bp++ = 0;
 195
 196         for (b = binds; b->keyword; b++)
 197             if (!strcmp (buffer, b->keyword))
 198                 break;
 199         if (b->keyword && (cp = tailor_value (bp)))
 200             *b->value = cp;
 201     }
 202
 203     fclose (fp);
 204
 205     Everyone = atoi (everyone);
 206
 207     if (strstr(masquerade, "draft_from") != NULL)
 208         draft_from_masquerading = TRUE;
 209
 210     if (strstr(masquerade, "mmailid") != NULL)
 211         mmailid_masquerading = TRUE;
 212
 213     if (strstr(masquerade, "username_extension") != NULL)
 214         username_extension_masquerading = TRUE;
 215
 216 #ifdef SMTPMTS
 217     if (strcmp(sm_method, "smtp") == 0)
 218         sm_mts = MTS_SMTP;
 219     else if (strcmp(sm_method, "sendmail") == 0)
 220         sm_mts = MTS_SENDMAIL;
 221     else {
 222         advise(NULL, "unsupported \"mts\" value in mts.conf: %s", sm_method);
 223         sm_mts = MTS_SMTP;
 224     }
 225 #endif
 226 }
 227
 228
 229 #define QUOTE   '\\'
 230
 231 /*
 232  * Convert escaped values, malloc some new space,
 233  * and copy string to malloc'ed memory.
 234  */
 235
 236 static char *
 237 tailor_value (unsigned char *s)
 238 {
 239     int i, r;
 240     char *bp;
 241     char buffer[BUFSIZ];
 242     size_t len;
 243
 244     for (bp = buffer; *s; bp++, s++) {
 245         if (*s != QUOTE) {
 246             *bp = *s;
 247         } else {
 248             switch (*++s) {
 249                 case 'b': *bp = '\b'; break;
 250                 case 'f': *bp = '\f'; break;
 251                 case 'n': *bp = '\n'; break;
 252                 case 't': *bp = '\t'; break;
 253
 254                 case 0: s--;
 255                 case QUOTE:
 256                     *bp = QUOTE;
 257                     break;
 258
 259                 default:
 260                     if (!isdigit (*s)) {
 261                         *bp++ = QUOTE;
 262                         *bp = *s;
 263                     }
 264                     r = *s != '0' ? 10 : 8;
 265                     for (i = 0; isdigit (*s); s++)
 266                         i = i * r + *s - '0';
 267                     s--;
 268                     *bp = toascii (i);
 269                     break;
 270             }
 271         }
 272     }
 273     *bp = 0;
 274
 275     len = strlen (buffer) + 1;
 276     bp = mh_xmalloc (len);
 277     memcpy (bp, buffer, len);
 278
 279     return bp;
 280 }
 281
 282 /*
 283  * Get the fully qualified name of the local host.
 284  */
 285
 286 char *
 287 LocalName (void)
 288 {
 289     static char buffer[BUFSIZ] = "";
 290     struct hostent *hp;
 291
 292 #ifdef HAVE_UNAME
 293     struct utsname name;
 294 #endif
 295
 296     /* check if we have cached the local name */
 297     if (buffer[0])
 298         return buffer;
 299
 300     mts_init ("mts");
 301
 302     /* check if the mts.conf file specifies a "localname" */
 303     if (*localname) {
 304         strncpy (buffer, localname, sizeof(buffer));
 305     } else {
 306 #ifdef HAVE_UNAME
 307         /* first get our local name */
 308         uname (&name);
 309         strncpy (buffer, name.nodename, sizeof(buffer));
 310 #else
 311         /* first get our local name */
 312         gethostname (buffer, sizeof(buffer));
 313 #endif
 314 #ifdef HAVE_SETHOSTENT
 315         sethostent (1);
 316 #endif
 317         /* now fully qualify our name */
 318         if ((hp = gethostbyname (buffer)))
 319             strncpy (buffer, hp->h_name, sizeof(buffer));
 320     }
 321
 322     /*
 323      * If the mts.conf file specifies a "localdomain",
 324      * we append that now.  This should rarely be needed.
 325      */
 326     if (*localdomain) {
 327         strcat (buffer, ".");
 328         strcat (buffer, localdomain);
 329     }
 330
 331     return buffer;
 332 }
 333
 334
 335 /*
 336  * This is only for UUCP mail.  It gets the hostname
 337  * as part of the UUCP "domain".
 338  */
 339
 340 char *
 341 SystemName (void)
 342 {
 343     static char buffer[BUFSIZ] = "";
 344
 345 #ifdef HAVE_UNAME
 346     struct utsname name;
 347 #endif
 348
 349     /* check if we have cached the system name */
 350     if (buffer[0])
 351         return buffer;
 352
 353     mts_init ("mts");
 354
 355     /* check if mts.conf file specifies a "systemname" */
 356     if (*systemname) {
 357         strncpy (buffer, systemname, sizeof(buffer));
 358         return buffer;
 359     }
 360
 361 #ifdef HAVE_UNAME
 362     uname (&name);
 363     strncpy (buffer, name.nodename, sizeof(buffer));
 364 #else
 365     gethostname (buffer, sizeof(buffer));
 366 #endif
 367
 368     return buffer;
 369 }
 370
 371
 372 /*
 373  * Get the username of current user
 374  */
 375
 376 char *
 377 getusername (void)
 378 {
 379     if (username[0] == '\0')
 380         getuserinfo();
 381
 382     return username;
 383 }
 384
 385
 386 /*
 387  * Get full name of current user (typically from GECOS
 388  * field of password file).
 389  */
 390
 391 char *
 392 getfullname (void)
 393 {
 394     if (username[0] == '\0')
 395         getuserinfo();
 396
 397     return fullname;
 398 }
 399
 400
 401 /*
 402  * Find the user's username and full name, and cache them.
 403  * Also, handle "mmailid" username masquerading controlled from the GECOS field
 404  * of the passwd file.
 405  */
 406
 407 static void
 408 getuserinfo (void)
 409 {
 410     register unsigned char *cp;
 411     register char *np;
 412     register struct passwd *pw;
 413
 414 #ifdef KPOP
 415     uid_t uid;
 416
 417     uid = getuid ();
 418     if (uid == geteuid () && (cp = getenv ("USER")) != NULL
 419         && (pw = getpwnam (cp)) != NULL)
 420       strncpy (username, cp, sizeof(username));
 421     else if ((pw = getpwuid (uid)) == NULL
 422              || pw->pw_name == NULL
 423              || *pw->pw_name == '\0') {
 424 #else /* KPOP */
 425     if ((pw = getpwuid (getuid ())) == NULL
 426             || pw->pw_name == NULL
 427             || *pw->pw_name == '\0') {
 428 #endif /* KPOP */
 429         strncpy (username, "unknown", sizeof(username));
 430         snprintf (fullname, sizeof(fullname), "The Unknown User-ID (%d)",
 431                 (int) getuid ());
 432         return;
 433     }
 434
 435     np = pw->pw_gecos;
 436
 437     /* Get the user's real name from the GECOS field.  Stop once we hit a ',',
 438        which some OSes use to separate other 'finger' information in the GECOS
 439        field, like phone number.  Also, if mmailid masquerading is turned on due
 440        to "mmailid" appearing on the "masquerade:" line of mts.conf, stop if we
 441        hit a '<' (which should precede any ','s). */
 442 #ifndef BSD42
 443     if (mmailid_masquerading)
 444         /* Stop at ',' or '<'. */
 445         for (cp = fullname; *np != '\0' && *np != ',' && *np != '<';
 446              *cp++ = *np++)
 447             continue;
 448     else
 449         /* Allow '<' as a legal character of the user's name.  This code is
 450            basically a duplicate of the code above the "else" -- we don't
 451            collapse it down to one copy and put the mmailid_masquerading check
 452            inside the loop with "(x ? y : z)" because that's inefficient and the
 453            value'll never change while it's in there. */
 454         for (cp = fullname; *np != '\0' && *np != ',';
 455              *cp++ = *np++)
 456             continue;
 457 #else /* BSD42 */
 458     /* On BSD(-derived) systems, the system utilities that deal with the GECOS
 459        field (finger, mail, sendmail, etc.) translate any '&' character in it to
 460        the login name, with the first letter capitalized.  So, for instance,
 461        fingering a user "bob" with the GECOS field "& Jones" would reveal him to
 462        be "In real life: Bob Jones".  Surprisingly, though, the OS doesn't do
 463        the translation for you, so we have to do it manually here. */
 464     if (mmailid_masquerading)
 465         /* Stop at ',' or '<'. */
 466         for (cp = fullname;
 467              *np != '\0' && *np != ',' && *np != '<';) {
 468             if (*np == '&')     {       /* blech! */
 469                 strcpy (cp, pw->pw_name);
 470                 *cp = toupper(*cp);
 471                 while (*cp)
 472                     cp++;
 473                 np++;
 474             } else {
 475                 *cp++ = *np++;
 476             }
 477         }
 478     else
 479         /* Allow '<' as a legal character of the user's name.  This code is
 480            basically a duplicate of the code above the "else" -- we don't
 481            collapse it down to one copy and put the mmailid_masquerading check
 482            inside the loop with "(x ? y : z)" because that's inefficient and the
 483            value'll never change while it's in there. */
 484         for (cp = fullname;
 485              *np != '\0' && *np != ',';) {
 486             if (*np == '&')     {       /* blech! */
 487                 strcpy (cp, pw->pw_name);
 488                 *cp = toupper(*cp);
 489                 while (*cp)
 490                     cp++;
 491                 np++;
 492             } else {
 493                 *cp++ = *np++;
 494             }
 495         }
 496 #endif /* BSD42 */
 497     *cp = '\0';
 498
 499     if (mmailid_masquerading) {
 500         /* Do mmailid processing.  The GECOS field should have the form
 501            "Full Name <fakeusername>".  For instance,
 502            "Dan Harkless <Dan.Harkless>".  Naturally, you'll want your MTA to
 503            have an alias (e.g. in /etc/aliases) from "fakeusername" to your
 504            account name.  */
 505         if (*np)
 506             np++;
 507         for (cp = username; *np && *np != '>'; *cp++ = *np++)
 508             continue;
 509         *cp = '\0';
 510     }
 511     if (!mmailid_masquerading || *np == '\0')
 512         strncpy (username, pw->pw_name, sizeof(username));
 513
 514     /* The $SIGNATURE environment variable overrides the GECOS field's idea of
 515        your real name. */
 516     if ((cp = getenv ("SIGNATURE")) && *cp)
 517         strncpy (fullname, cp, sizeof(fullname));
 518
 519     if (strchr(fullname, '.')) {                /*  quote any .'s */
 520         char tmp[BUFSIZ];
 521
 522         /* should quote "'s too */
 523         snprintf (tmp, sizeof(tmp), "\"%s\"", fullname);
 524         strncpy (fullname, tmp, sizeof(fullname));
 525     }
 526
 527     return;
 528 }