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

   1
   2 /*
   3  * addrsbr.c -- parse addresses 822-style
   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>
  11 #include <h/addrsbr.h>
  12 #include <h/mf.h>
  13 #include <h/mts.h>
  14 #include <h/utils.h>
  15
  16 /* High level parsing of addresses:
  17
  18    The routines in sbr/mf.c parse the syntactic representations of
  19    addresses.  The routines in sbr/addrsbr.c associate semantics with those
  20    addresses.
  21
  22    The comments below are left in for historical purposes; DUMB and
  23    REALLYDUMB are now the default in the code.
  24
  25    If #ifdef DUMB is in effect, a full 822-style parser is called
  26    for syntax recongition.  This breaks each address into its components.
  27    Note however that no semantics are assumed about the parts or their
  28    totality.  This means that implicit hostnames aren't made explicit,
  29    and explicit hostnames aren't expanded to their "official" represenations.
  30
  31    If DUMB is not in effect, then this module does some
  32    high-level thinking about what the addresses are.
  33
  34    1. for MMDF systems:
  35
  36         string%<uucp>@<local>   ->      string
  37
  38    2. for non-MMDF systems:
  39
  40         string@host.<uucp>      ->      host!string
  41
  42    3. for any system, an address interpreted relative to the local host:
  43
  44         string@<uucp>           ->      string
  45
  46    For cases (1) and (3) above, the leftmost host is extracted.  If it's not
  47    present, the local host is used.  If the tests above fail, the address is
  48    considered to be a real 822-style address.
  49
  50    If an explicit host is not present, then MH checks for a bang to indicate
  51    an explicit UUCP-style address.  If so, this is noted.  If not, the host is
  52    defaulted, typically to the local host.  The lack of an explicit host is
  53    also noted.
  54
  55    If an explicit 822-style host is present, then MH checks to see if it
  56    can expand this to the official name for the host.  If the hostname is
  57    unknown, the address is so typed.
  58
  59    To summarize, when we're all done, here's what MH knows about the address:
  60
  61    DUMB -       type:   local, uucp, or network
  62                 host:   not locally defaulted, not explicitly expanded
  63                 everything else
  64
  65    other -      type:   local, uucp, network, unknown
  66                 everything else
  67  */
  68
  69
  70 static int  ingrp = 0;
  71 static char *pers = NULL;
  72 static char *mbox = NULL;
  73 static char *host = NULL;
  74 static char *route = NULL;
  75 static char *grp = NULL;
  76 static char *note = NULL;
  77 static char err[BUFSIZ];
  78 static char adr[BUFSIZ];
  79 static int eai = 0;
  80
  81 void
  82 enable_eai() {
  83     eai = 1;
  84 }
  85
  86
  87 char *
  88 getname (const char *addrs)
  89 {
  90     struct adrx *ap;
  91     pers = mbox = host = route = grp = note = NULL;
  92     err[0] = '\0';
  93
  94     if ((ap = getadrx (addrs ? addrs : "", eai)) == NULL) {
  95         return NULL;
  96     }
  97
  98     strncpy (adr, ap->text, sizeof(adr));
  99     pers = ap->pers;
 100     mbox = ap->mbox;
 101     host = ap->host;
 102     route = ap->path;
 103     grp = ap->grp;
 104     ingrp = ap->ingrp;
 105     note = ap->note;
 106     if (ap->err && *ap->err)
 107         strncpy (err, ap->err, sizeof(err));
 108
 109     return adr;
 110 }
 111
 112
 113 struct mailname *
 114 getm (char *str, char *dfhost, int dftype, char *eresult, size_t eresultsize)
 115 {
 116     char *pp;
 117     struct mailname *mp;
 118
 119     if (err[0]) {
 120         if (eresult) {
 121             strncpy (eresult, err, eresultsize);
 122             eresult[eresultsize - 1] = '\0';
 123         }
 124         return NULL;
 125     }
 126     if (pers == NULL
 127             && mbox == NULL && host == NULL && route == NULL
 128             && grp == NULL) {
 129         if (eresult) {
 130             strncpy (eresult, "null address", eresultsize);
 131             eresult[eresultsize - 1] = '\0';
 132         }
 133         return NULL;
 134     }
 135     if (mbox == NULL && grp == NULL) {
 136         if (eresult) {
 137             strncpy (eresult, "no mailbox in address", eresultsize);
 138             eresult[eresultsize - 1] = '\0';
 139         }
 140         return NULL;
 141     }
 142
 143     if (dfhost == NULL) {
 144         dfhost = LocalName (0);
 145         dftype = LOCALHOST;
 146     }
 147
 148     NEW0(mp);
 149     mp->m_next = NULL;
 150     mp->m_text = getcpy (str);
 151     if (pers)
 152         mp->m_pers = mh_xstrdup(pers);
 153
 154     if (mbox == NULL) {
 155         mp->m_type = BADHOST;
 156         mp->m_nohost = 1;
 157         mp->m_ingrp = ingrp;
 158         mp->m_gname = getcpy (grp);
 159         if (note)
 160             mp->m_note = mh_xstrdup(note);
 161         return mp;
 162     }
 163
 164     if (host) {
 165         mp->m_mbox = getcpy (mbox);
 166         mp->m_host = mh_xstrdup(host);
 167         mp->m_type =
 168             strcasecmp (LocalName(0), mp->m_host) ? NETHOST : LOCALHOST;
 169     } else {
 170         if ((pp = strchr(mbox, '!'))) {
 171             *pp++ = '\0';
 172             mp->m_mbox = mh_xstrdup(pp);
 173             mp->m_host = getcpy (mbox);
 174             mp->m_type = UUCPHOST;
 175         } else {
 176             mp->m_nohost = 1;
 177             mp->m_mbox = getcpy (mbox);
 178             if (route == NULL && dftype == LOCALHOST) {
 179                 mp->m_host = NULL;
 180                 mp->m_type = dftype;
 181             } else {
 182                 mp->m_host = route ? NULL : getcpy (dfhost);
 183                 mp->m_type = route ? NETHOST : dftype;
 184             }
 185         }
 186     }
 187
 188     /* For alternate mailboxes, m_type gets overwritten in ismymbox ()
 189        to support wild-card matching. */
 190
 191     if (route)
 192         mp->m_path = mh_xstrdup(route);
 193     mp->m_ingrp = ingrp;
 194     if (grp)
 195         mp->m_gname = mh_xstrdup(grp);
 196     if (note)
 197         mp->m_note = mh_xstrdup(note);
 198
 199     return mp;
 200 }
 201
 202
 203 void
 204 mnfree (struct mailname *mp)
 205 {
 206     if (!mp)
 207         return;
 208
 209     mh_xfree(mp->m_text);
 210     mh_xfree(mp->m_pers);
 211     mh_xfree(mp->m_mbox);
 212     mh_xfree(mp->m_host);
 213     mh_xfree(mp->m_path);
 214     mh_xfree(mp->m_gname);
 215     mh_xfree(mp->m_note);
 216
 217     free(mp);
 218 }
 219
 220
 221 #define empty(s) ((s) ? (s) : "")
 222
 223 char *
 224 auxformat (struct mailname *mp, int extras)
 225 {
 226     static char addr[BUFSIZ];
 227     static char buffer[BUFSIZ];
 228
 229         if (mp->m_nohost)
 230             strncpy (addr, mp->m_mbox ? mp->m_mbox : "", sizeof(addr));
 231         else
 232
 233         if (mp->m_type != UUCPHOST) {
 234             if (mp->m_host)
 235                 snprintf (addr, sizeof(addr), "%s%s@%s", empty(mp->m_path),
 236                           empty(mp->m_mbox), mp->m_host);
 237             else snprintf (addr, sizeof(addr), "%s%s", empty(mp->m_path),
 238                            empty(mp->m_mbox));
 239         } else
 240             snprintf (addr, sizeof(addr), "%s!%s", mp->m_host, mp->m_mbox);
 241
 242     if (!extras)
 243         return addr;
 244
 245     if (mp->m_pers || mp->m_path) {
 246         if (mp->m_note)
 247             snprintf (buffer, sizeof(buffer), "%s %s <%s>",
 248                     legal_person (mp->m_pers ? mp->m_pers : mp->m_mbox),
 249                     mp->m_note, addr);
 250         else
 251             snprintf (buffer, sizeof(buffer), "%s <%s>",
 252                     legal_person (mp->m_pers ? mp->m_pers : mp->m_mbox),
 253                     addr);
 254     }
 255     else
 256         if (mp->m_note)
 257             snprintf (buffer, sizeof(buffer), "%s %s", addr, mp->m_note);
 258         else
 259             strncpy (buffer, addr, sizeof(buffer));
 260
 261     return buffer;
 262 }
 263
 264
 265 #define W_NIL   0x0000
 266 #define W_MBEG  0x0001
 267 #define W_MEND  0x0002
 268 #define W_MBOX  (W_MBEG | W_MEND)
 269 #define W_HBEG  0x0004
 270 #define W_HEND  0x0008
 271 #define W_HOST  (W_HBEG | W_HEND)
 272 #define WBITS   "\020\01MBEG\02MEND\03HBEG\04HEND"
 273
 274 /*
 275  * Check if this is my address
 276  */
 277
 278 int
 279 ismymbox (struct mailname *np)
 280 {
 281     int oops;
 282     int len, i;
 283     char *cp;
 284     char *pp;
 285     char buffer[BUFSIZ];
 286     struct mailname *mp;
 287     static char *am = NULL;
 288     static struct mailname mq;
 289     static int localmailbox = 0;
 290
 291     /*
 292      * If this is the first call, initialize
 293      * list of alternate mailboxes.
 294      */
 295     if (am == NULL) {
 296         mq.m_next = NULL;
 297         mq.m_mbox = getusername ();
 298
 299         if ((am = context_find ("local-mailbox"))) {
 300
 301             localmailbox++;
 302
 303             if ((cp = getname(am)) == NULL) {
 304                 inform("Unable to find address in local-mailbox, continuing...");
 305                 return 0;
 306             }
 307
 308             if ((mq.m_next = getm (cp, NULL, 0, NULL, 0)) == NULL) {
 309                 inform("invalid entry in local-mailbox: %s, continuing...", cp);
 310                 return 0;
 311             }
 312
 313             /* Sigh, it turns out that the address parser gets messed up
 314              * if you don't call getname() until it returns NULL. */
 315             while (getname(am) != NULL)
 316                 ;
 317         }
 318
 319         if ((am = context_find ("alternate-mailboxes")) == NULL)
 320             am = getusername();
 321         else {
 322             mp = mq.m_next ? mq.m_next : &mq;
 323             oops = 0;
 324             while ((cp = getname (am))) {
 325                 if ((mp->m_next = getm (cp, NULL, 0, NULL, 0)) == NULL) {
 326                     inform("illegal address: %s, continuing...", cp);
 327                     oops++;
 328                 } else {
 329                     mp = mp->m_next;
 330                     mp->m_type = W_NIL;
 331                     if (*mp->m_mbox == '*') {
 332                         mp->m_type |= W_MBEG;
 333                         mp->m_mbox++;
 334                     }
 335                     if (*(cp = mp->m_mbox + strlen (mp->m_mbox) - 1) == '*') {
 336                         mp->m_type |= W_MEND;
 337                         *cp = '\0';
 338                     }
 339                     if (mp->m_host) {
 340                         if (*mp->m_host == '*') {
 341                             mp->m_type |= W_HBEG;
 342                             mp->m_host++;
 343                         }
 344                         if (*(cp = mp->m_host + strlen (mp->m_host) - 1) == '*') {
 345                             mp->m_type |= W_HEND;
 346                             *cp = '\0';
 347                         }
 348                     }
 349                 }
 350             }
 351             if (oops)
 352                 inform("please fix the %s: entry in your %s file",
 353                         "alternate-mailboxes", mh_profile);
 354         }
 355
 356         if ((cp = getenv ("MHWDEBUG")) && *cp) {
 357             for (mp = &mq; mp; mp = mp->m_next) {
 358               fprintf (stderr, "Local- or Alternate-Mailbox: text=\"%s\" "
 359                        "mbox=\"%s\" host=\"%s\" %s\n",
 360                        mp->m_text ? mp->m_text : "", mp->m_mbox,
 361                        mp->m_host ? mp->m_host : "",
 362                        snprintb (buffer, sizeof(buffer), (unsigned) mp->m_type,
 363                                  WBITS));
 364             }
 365         }
 366     }
 367
 368     if (np == NULL) /* XXX */
 369         return 0;
 370
 371     /*
 372      * Don't perform this "local" test if we have a Local-Mailbox set
 373      */
 374
 375     if (! localmailbox)
 376         switch (np->m_type) {
 377             case NETHOST:
 378                 len = strlen (cp = LocalName (0));
 379                 if (!uprf (np->m_host, cp) || np->m_host[len] != '.')
 380                     break;
 381                 goto local_test;
 382
 383             case UUCPHOST:
 384                 if (strcasecmp (np->m_host, SystemName()))
 385                     break;
 386                     /* FALLTHRU */
 387             case LOCALHOST:
 388 local_test: ;
 389                 if (!strcasecmp (np->m_mbox, mq.m_mbox))
 390                     return 1;
 391                 break;
 392
 393             default:
 394                 break;
 395         }
 396
 397     /*
 398      * Now scan through list of alternate
 399      * mailboxes, and check for a match.
 400      */
 401     for (mp = &mq; mp->m_next;) {
 402         mp = mp->m_next;
 403         if (!np->m_mbox)
 404             continue;
 405         if ((len = strlen (cp = np->m_mbox))
 406                 < (i = strlen (pp = mp->m_mbox)))
 407             continue;
 408         switch (mp->m_type & W_MBOX) {
 409             case W_NIL:
 410                 if (strcasecmp (cp, pp))
 411                     continue;
 412                 break;
 413             case W_MBEG:
 414                 if (strcasecmp (cp + len - i, pp))
 415                     continue;
 416                 break;
 417             case W_MEND:
 418                 if (!uprf (cp, pp))
 419                     continue;
 420                 break;
 421             case W_MBEG | W_MEND:
 422                 if (stringdex (pp, cp) < 0)
 423                     continue;
 424                 break;
 425         }
 426
 427         if (mp->m_nohost)
 428             return 1;
 429         if (np->m_host == NULL || mp->m_host == NULL)
 430             continue;
 431         if ((len = strlen (cp = np->m_host))
 432                 < (i = strlen (pp = mp->m_host)))
 433             continue;
 434         switch (mp->m_type & W_HOST) {
 435             case W_NIL:
 436                 if (strcasecmp (cp, pp))
 437                     continue;
 438                 break;
 439             case W_HBEG:
 440                 if (strcasecmp (cp + len - i, pp))
 441                     continue;
 442                 break;
 443             case W_HEND:
 444                 if (!uprf (cp, pp))
 445                     continue;
 446                 break;
 447             case W_HBEG | W_HEND:
 448                 if (stringdex (pp, cp) < 0)
 449                     continue;
 450                 break;
 451         }
 452         return 1;
 453     }
 454
 455     return 0;
 456 }