git.marmaro.de Git - mmh/blob - sbr/mts.c

   1
   2 /*
   3  * mts.c -- definitions for the mail transport system
   4  *
   5  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   6  * COPYRIGHT file in the root directory of the nmh distribution for
   7  * complete copyright information.
   8  */
   9
  10 #include <h/mh.h>   /* for snprintf() */
  11 #include <h/nmh.h>
  12 #include <h/utils.h>
  13
  14 #define nmhetcdir(file) NMHETCDIR#file
  15
  16 #include <ctype.h>
  17 #include <stdio.h>
  18 #include <h/mts.h>
  19 #include <pwd.h>
  20 #include <sys/socket.h>
  21 #include <netdb.h>
  22
  23 /*
  24  * static prototypes
  25  */
  26 static char *tailor_value (unsigned char *);
  27 static void getuserinfo (void);
  28 static const char *get_mtsconf_pathname(void);
  29 static const char *get_mtsuserconf_pathname(void);
  30 static void mts_read_conf_file (FILE *fp);
  31
  32 /*
  33  * *mmdfldir and *uucpldir are the maildrop directories.  If maildrops
  34  * are kept in the user's home directory, then these should be empty
  35  * strings.  In this case, the appropriate ...lfil array should contain
  36  * the name of the file in the user's home directory.  Usually, this is
  37  * something like ".mail".
  38  */
  39
  40 /*
  41  * nmh mail transport interface customization file
  42  */
  43 static char *mtsconf = nmhetcdir(/mts.conf);
  44
  45 static char *localname   = "";
  46 static char *localdomain = "";
  47 static char *systemname  = "";
  48
  49 char *mmdfldir = MAILSPOOL;
  50 char *mmdflfil = "";
  51 char *uucpldir = "/usr/spool/mail";
  52 char *uucplfil = "";
  53
  54 char *mmdlm1 = "\001\001\001\001\n";
  55 char *mmdlm2 = "\001\001\001\001\n";
  56
  57 /* Cache the username, fullname, and mailbox of the user */
  58 static char username[BUFSIZ];
  59 static char fullname[BUFSIZ];
  60 static char localmbox[BUFSIZ];
  61
  62 /*
  63  * MTS specific variables
  64  */
  65 static char *sm_method = "smtp";
  66 int  sm_mts    = MTS_SMTP;
  67 char *sendmail = SENDMAILPATH;
  68
  69 /*
  70  * SMTP/POP stuff
  71  */
  72 char *clientname = NULL;
  73 char *servers    = "localhost";
  74 char *pophost    = "";
  75
  76 /*
  77  * Global MailDelivery file
  78  */
  79 char *maildelivery = nmhetcdir(/maildelivery);
  80
  81
  82 /*
  83  * Aliasing Facility (doesn't belong here)
  84  */
  85 int Everyone = NOTOK;
  86 static char *everyone = "-1";
  87 char *NoShell = "";
  88
  89 /*
  90  * Customize the MTS settings for nmh by adjusting
  91  * the file mts.conf in the nmh etc directory.
  92  */
  93
  94 struct bind {
  95     char *keyword;
  96     char **value;
  97 };
  98
  99 static struct bind binds[] = {
 100     { "localname", &localname },
 101     { "localdomain", &localdomain },
 102     { "systemname", &systemname },
 103     { "mmdfldir", &mmdfldir },
 104     { "mmdflfil", &mmdflfil },
 105     { "uucpldir", &uucpldir },
 106     { "uucplfil", &uucplfil },
 107     { "mmdelim1", &mmdlm1 },
 108     { "mmdelim2", &mmdlm2 },
 109     { "mts",      &sm_method },
 110     { "sendmail", &sendmail  },
 111     { "clientname",  &clientname },
 112     { "servers", &servers },
 113     { "pophost", &pophost },
 114
 115     { "maildelivery", &maildelivery },
 116     { "everyone", &everyone },
 117     { "noshell", &NoShell },
 118     { NULL, NULL }
 119 };
 120
 121
 122 /*
 123  * Read the configuration file for the nmh interface
 124  * to the mail transport system (MTS).
 125  */
 126
 127 void
 128 mts_init (char *name)
 129 {
 130     const char *cp;
 131     FILE *fp;
 132     static int inited = 0;
 133     NMH_UNUSED (name);
 134
 135     if (inited++ || (fp = fopen (get_mtsconf_pathname(), "r")) == NULL)
 136         return;
 137     mts_read_conf_file(fp);
 138     fclose (fp);
 139
 140     cp = get_mtsuserconf_pathname();
 141     if (cp != NULL &&
 142             ((fp = fopen (get_mtsuserconf_pathname(), "r")) != NULL)) {
 143         mts_read_conf_file(fp);
 144         fclose (fp);
 145     }
 146
 147     Everyone = atoi (everyone);
 148
 149     if (strcmp(sm_method, "smtp") == 0)
 150         sm_mts = MTS_SMTP;
 151     else if (strcmp(sm_method, "sendmail") == 0)
 152         sm_mts = MTS_SENDMAIL;
 153     else {
 154         advise(NULL, "unsupported \"mts\" value in mts.conf: %s", sm_method);
 155         sm_mts = MTS_SMTP;
 156     }
 157 }
 158
 159
 160 #define QUOTE   '\\'
 161
 162 /*
 163  * Convert escaped values, malloc some new space,
 164  * and copy string to malloc'ed memory.
 165  */
 166
 167 static char *
 168 tailor_value (unsigned char *s)
 169 {
 170     int i, r;
 171     char *bp;
 172     char buffer[BUFSIZ];
 173     size_t len;
 174
 175     for (bp = buffer; *s; bp++, s++) {
 176         if (*s != QUOTE) {
 177             *bp = *s;
 178         } else {
 179             switch (*++s) {
 180                 case 'b': *bp = '\b'; break;
 181                 case 'f': *bp = '\f'; break;
 182                 case 'n': *bp = '\n'; break;
 183                 case 't': *bp = '\t'; break;
 184
 185                 case 0: s--;
 186                 case QUOTE:
 187                     *bp = QUOTE;
 188                     break;
 189
 190                 default:
 191                     if (!isdigit (*s)) {
 192                         *bp++ = QUOTE;
 193                         *bp = *s;
 194                     }
 195                     r = *s != '0' ? 10 : 8;
 196                     for (i = 0; isdigit (*s); s++)
 197                         i = i * r + *s - '0';
 198                     s--;
 199                     *bp = toascii (i);
 200                     break;
 201             }
 202         }
 203     }
 204     *bp = 0;
 205
 206     len = strlen (buffer) + 1;
 207     bp = mh_xmalloc (len);
 208     memcpy (bp, buffer, len);
 209
 210     return bp;
 211 }
 212
 213 /*
 214  * Get the fully qualified name of the local host.
 215  *
 216  * If flag is 0, then use anything out of mts.conf (like localname).
 217  * If flag is 1, then only use the "proper" local hostname.
 218  */
 219
 220 char *
 221 LocalName (int flag)
 222 {
 223     static char buffer0[BUFSIZ] = "";
 224     static char buffer1[BUFSIZ] = "";
 225     static char *buffer[] = { buffer0, buffer1 };
 226     char *buf;
 227     struct addrinfo hints, *res;
 228
 229     if (flag < 0 || flag > 1)
 230         return NULL;
 231
 232     buf = buffer[flag];
 233
 234     /* check if we have cached the local name */
 235     if (buf[0])
 236         return buf;
 237
 238     mts_init ("mts");
 239
 240     /* check if the mts.conf file specifies a "localname" */
 241     if (*localname && flag == 0) {
 242         strncpy (buf, localname, sizeof(buffer0));
 243     } else {
 244         memset(buf, 0, sizeof(buffer0));
 245         /* first get our local name */
 246         gethostname (buf, sizeof(buffer0) - 1);
 247         /* now fully qualify our name */
 248
 249         memset(&hints, 0, sizeof(hints));
 250         hints.ai_flags = AI_CANONNAME;
 251         hints.ai_family = PF_UNSPEC;
 252         if (getaddrinfo(buf, NULL, &hints, &res) == 0) {
 253             strncpy(buf, res->ai_canonname, sizeof(buffer0) - 1);
 254             freeaddrinfo(res);
 255         }
 256     }
 257
 258     /*
 259      * If the mts.conf file specifies a "localdomain",
 260      * we append that now.  This should rarely be needed.
 261      */
 262     if (*localdomain) {
 263         strcat (buf, ".");
 264         strcat (buf, localdomain);
 265     }
 266
 267     return buf;
 268 }
 269
 270
 271 /*
 272  * This is only for UUCP mail.  It gets the hostname
 273  * as part of the UUCP "domain".
 274  */
 275
 276 char *
 277 SystemName (void)
 278 {
 279     static char buffer[BUFSIZ] = "";
 280
 281     /* check if we have cached the system name */
 282     if (buffer[0])
 283         return buffer;
 284
 285     mts_init ("mts");
 286
 287     /* check if mts.conf file specifies a "systemname" */
 288     if (*systemname) {
 289         strncpy (buffer, systemname, sizeof(buffer));
 290         return buffer;
 291     }
 292
 293     gethostname (buffer, sizeof(buffer));
 294
 295     return buffer;
 296 }
 297
 298
 299 /*
 300  * Get the username of current user
 301  */
 302
 303 char *
 304 getusername (void)
 305 {
 306     if (username[0] == '\0')
 307         getuserinfo();
 308
 309     return username;
 310 }
 311
 312
 313 /*
 314  * Get full name of current user (typically from GECOS
 315  * field of password file).
 316  */
 317
 318 char *
 319 getfullname (void)
 320 {
 321     if (username[0] == '\0')
 322         getuserinfo();
 323
 324     return fullname;
 325 }
 326
 327
 328 /*
 329  * Get the full local mailbox name.  This is in the form:
 330  *
 331  * User Name <user@name.com>
 332  */
 333
 334 char *
 335 getlocalmbox (void)
 336 {
 337     if (username[0] == '\0')
 338         getuserinfo();
 339
 340     return localmbox;
 341 }
 342
 343 /*
 344  * Find the user's username and full name, and cache them.
 345  */
 346
 347 static void
 348 getuserinfo (void)
 349 {
 350     register unsigned char *cp;
 351     register char *np;
 352     register struct passwd *pw;
 353
 354     if ((pw = getpwuid (getuid ())) == NULL
 355             || pw->pw_name == NULL
 356             || *pw->pw_name == '\0') {
 357         strncpy (username, "unknown", sizeof(username));
 358         snprintf (fullname, sizeof(fullname), "The Unknown User-ID (%d)",
 359                 (int) getuid ());
 360         return;
 361     }
 362
 363
 364     /* username */
 365     /* If there's a Local-Mailbox profile component, try to extract
 366        the username from it.  But don't try very hard, this assumes
 367        the very simple User Name <user@name.com> form.
 368        Note that post(8) and whom(1) use context_foil (), so they
 369        won't see the profile component. */
 370     if ((np = context_find("Local-Mailbox")) != NULL) {
 371         char *left_angle_bracket = strchr (np, '<');
 372         char *at_sign = strchr (np, '@');
 373         char *right_angle_bracket = strchr (np, '>');
 374
 375         strncpy(localmbox, np, sizeof(localmbox));
 376
 377         if (left_angle_bracket  &&  at_sign  &&  right_angle_bracket) {
 378             if (at_sign > left_angle_bracket  &&
 379                 at_sign - left_angle_bracket < BUFSIZ) {
 380                 strncpy(username, left_angle_bracket + 1,
 381                         at_sign - left_angle_bracket - 1);
 382             }
 383         }
 384     }
 385
 386     if (username[0] == '\0') {
 387         strncpy (username, pw->pw_name, sizeof(username));
 388     }
 389
 390     username[sizeof(username) - 1] = '\0';
 391
 392     escape_local_part(username, sizeof(username));
 393
 394
 395     /* fullname */
 396     np = pw->pw_gecos;
 397
 398     /* Get the user's real name from the GECOS field.  Stop once we hit a ',',
 399        which some OSes use to separate other 'finger' information in the GECOS
 400        field, like phone number. */
 401     for (cp = fullname; *np != '\0' && *np != ','; *cp++ = *np++)
 402         continue;
 403     *cp = '\0';
 404
 405     /* The $SIGNATURE environment variable overrides the GECOS field's idea of
 406        your real name. If SIGNATURE isn't set, use the Signature profile
 407        setting if it exists. */
 408     if ((cp = getenv ("SIGNATURE")) && *cp)
 409         strncpy (fullname, cp, sizeof(fullname));
 410     else if ((cp = context_find("Signature")))
 411         strncpy (fullname, cp, sizeof(fullname));
 412
 413     fullname[sizeof(fullname) - 1] = '\0';
 414
 415     escape_display_name(fullname, sizeof(fullname));
 416
 417
 418     /* localmbox, if not using Local-Mailbox */
 419     if (localmbox[0] == '\0') {
 420         snprintf(localmbox, sizeof(localmbox), "%s <%s@%s>", fullname,
 421                  username, LocalName(0));
 422     }
 423
 424     localmbox[sizeof(localmbox) - 1] = '\0';
 425 }
 426
 427 static const char*
 428 get_mtsconf_pathname (void)
 429 {
 430     const char *cp = getenv ( "MHMTSCONF" );
 431     if (cp != NULL && *cp != '\0') {
 432         return cp;
 433     }
 434     return mtsconf;
 435 }
 436
 437 static const char*
 438 get_mtsuserconf_pathname (void)
 439 {
 440     const char *cp = getenv ( "MHMTSUSERCONF" );
 441     if (cp != NULL && *cp != '\0') {
 442         return cp;
 443     }
 444     return NULL;
 445 }
 446
 447 static void
 448 mts_read_conf_file (FILE *fp)
 449 {
 450     unsigned char *bp;
 451     char *cp, buffer[BUFSIZ];
 452     struct bind *b;
 453
 454     while (fgets (buffer, sizeof(buffer), fp)) {
 455         if (!(cp = strchr(buffer, '\n')))
 456             break;
 457         *cp = 0;
 458         if (*buffer == '#' || *buffer == '\0')
 459             continue;
 460         if (!(bp = strchr(buffer, ':')))
 461             break;
 462         *bp++ = 0;
 463         while (isspace (*bp))
 464             *bp++ = 0;
 465
 466         for (b = binds; b->keyword; b++)
 467             if (!strcmp (buffer, b->keyword))
 468                 break;
 469         if (b->keyword && (cp = tailor_value (bp)))
 470             *b->value = cp;
 471     }
 472 }