home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / unix / volume03 / sndml.mds < prev    next >
Encoding:
Internet Message Format  |  1988-09-11  |  53.0 KB
  1. From: Bruce Israel <talcott!mimsy.umd.edu:gymble!israel>
  2. Subject: translation tables in sendmail
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 3, Issue 31
  7. Submitted by: Bruce Israel <talcott!mimsy.umd.edu:gymble!israel>
  8.  
  9.  
  10. Here are my modifications to sendmail that I announced recently.  I
  11. am posting these due to the number of requests.  These modifications
  12. allow translations to be used in the sendmail.cf file, such as
  13. pathalias information and other stuff.  Run the shar in a clean
  14. directory and then read the README.  Enjoy.
  15.  
  16. Bruce Israel
  17.  
  18. University of Maryland, Computer Science Dept.
  19. {rlgvax,seismo}!umcp-cs!israel (Usenet)    israel@Maryland (Arpanet)
  20.  
  21. : Run this shell script with "sh" not "csh"
  22. PATH=:/bin:/usr/bin:/usr/ucb
  23. export PATH
  24. all=FALSE
  25. if [ x$1 = x-a ]; then
  26.     all=TRUE
  27. fi
  28. /bin/echo 'Extracting 4.2diffs'
  29. sed 's/^X//' <<'//go.sysin dd *' >4.2diffs
  30. diff -c main.c.old main.c
  31. *** /usr/4.2/src/usr.lib/sendmail/src/main.c    Sun Sep 25 21:06:10 1983
  32. --- /usr/israel/sendmail/src/main.c    Wed Mar  6 15:45:26 1985
  33. ***************
  34. *** 695,700 ****
  35. --- 695,707 ----
  36.       '*', MATCHZANY,    '+', MATCHANY,    '-', MATCHONE,    '=', MATCHCLASS,
  37.       '~', MATCHNCLASS,
  38.   
  39. + #ifdef ROUTING    /* ******************************** */
  40. + 
  41. +     /* for RHS translation table */
  42. +     '&', EQUIVREPL,
  43. + 
  44. + #endif ROUTING    /* ******************************** */
  45. + 
  46.       /* these are RHS metasymbols */
  47.       '#', CANONNET,    '@', CANONHOST,    ':', CANONUSER,    '>', CALLSUBR,
  48.   
  49. ***************
  50. *** 808,813 ****
  51. --- 815,822 ----
  52.       union frz fhdr;
  53.       extern char edata;
  54.       extern char Version[];
  55. +      extern char **environ;
  56. +      char    **envsave;
  57.   
  58.       if (freezefile == NULL)
  59.           return (FALSE);
  60. ***************
  61. *** 835,840 ****
  62. --- 844,855 ----
  63.           (void) close(f);
  64.           return (FALSE);
  65.       }
  66. +  /**
  67. +   **  Arrrrg!  Since the pointer to the environment is in BSS, and our
  68. +   **  bss get's blasted over when the freeze file is read in, we need to
  69. +   **  save and restore the environ pointer for getenv()
  70. +   **/
  71. +      envsave = environ;        /* save pointer to environment */
  72.   
  73.       /* now read in the freeze file */
  74.       if (read(f, (char *) &edata, fhdr.frzinfo.frzbrk - &edata) !=
  75. ***************
  76. *** 844,849 ****
  77. --- 859,866 ----
  78.           write(2, "Cannot read freeze file\n", 24);
  79.           _exit(EX_SOFTWARE);
  80.       }
  81. + 
  82. +      environ = envsave;
  83.   
  84.       (void) close(f);
  85.       return (TRUE);
  86. diff -c parseaddr.c.old parseaddr.c
  87. *** /usr/4.2/src/usr.lib/sendmail/src/parseaddr.c    Mon Jul 25 23:20:46 1983
  88. --- /usr/israel/sendmail/src/parseaddr.c    Thu Oct 31 17:45:31 1985
  89. ***************
  90. *** 2,7 ****
  91. --- 2,9 ----
  92.   
  93.   SCCSID(@(#)parseaddr.c    4.1        7/25/83);
  94.   
  95. + char **copyplist();
  96. + 
  97.   /*
  98.   **  PARSEADDR -- Parse an address
  99.   **
  100. ***************
  101. *** 204,214 ****
  102. --- 206,241 ----
  103.   
  104.   char    *DelimChar;        /* set to point to the delimiter */
  105.   
  106. + #ifdef ROUTING    /* ******************************** */
  107. + 
  108. + char **prescan1();
  109. + 
  110. + #endif ROUTING    /* ******************************** */
  111. + 
  112.   char **
  113.   prescan(addr, delim)
  114.       char *addr;
  115.       char delim;
  116.   {
  117. +     static char buf[MAXNAME+MAXATOM];
  118. +     static char *av[MAXATOM+1];
  119. + 
  120. + #ifdef ROUTING    /* ******************************** */
  121. + 
  122. +     return(prescan1(addr,delim,buf,av,sizeof buf));
  123. + }
  124. + 
  125. + char **
  126. + prescan1(addr,delim,buf,av,bufsize)
  127. +     char *addr;
  128. +     char delim;
  129. +     char buf[];
  130. +     char *av[];
  131. +     int  bufsize;
  132. + {
  133. + 
  134. + #endif ROUTING    /* ******************************** */
  135. + 
  136.       register char *p;
  137.       register char *q;
  138.       register int c;
  139. ***************
  140. *** 219,226 ****
  141.       char *tok;
  142.       int state;
  143.       int newstate;
  144. -     static char buf[MAXNAME+MAXATOM];
  145. -     static char *av[MAXATOM+1];
  146.   
  147.       q = buf;
  148.       bslashmode = FALSE;
  149. --- 246,251 ----
  150. ***************
  151. *** 249,255 ****
  152.               if (c != NOCHAR)
  153.               {
  154.                   /* squirrel it away */
  155. !                 if (q >= &buf[sizeof buf - 5])
  156.                   {
  157.                       usrerr("Address too long");
  158.                       DelimChar = p;
  159. --- 274,280 ----
  160.               if (c != NOCHAR)
  161.               {
  162.                   /* squirrel it away */
  163. !                 if (q >= &buf[bufsize - 5])
  164.                   {
  165.                       usrerr("Address too long");
  166.                       DelimChar = p;
  167. ***************
  168. *** 396,401 ****
  169. --- 421,429 ----
  170.       }
  171.       if (c == MATCHCLASS || c == MATCHREPL || c == MATCHNCLASS)
  172.           return (ONE);
  173. + #ifdef ROUTING    /* ******************************** */
  174. +     if (c == EQUIVREPL) return (ONE);
  175. + #endif ROUTING    /* ******************************** */
  176.       if (c == '"')
  177.           return (QST);
  178.       if (!isascii(c))
  179. ***************
  180. *** 442,447 ****
  181. --- 470,478 ----
  182.   {
  183.       char    **first;    /* first token matched */
  184.       char    **last;        /* last token matched */
  185. + #ifdef ROUTING    /* ******************************** */
  186. +     char    *equiv;        /* equivalence name for match */
  187. + #endif ROUTING    /* ******************************** */
  188.   };
  189.   
  190.   # define MAXMATCH    9    /* max params per rewrite */
  191. ***************
  192. *** 528,533 ****
  193. --- 559,571 ----
  194.                   else if (*rp == MATCHNCLASS)
  195.                       goto backup;
  196.   
  197. + #ifdef ROUTING    /* ******************************** */
  198. + 
  199. +                 mlp -> equiv = getequiv(rp[1],s);
  200. + 
  201. + #endif ROUTING    /* ******************************** */
  202. + 
  203. + 
  204.                   /* explicit fall-through */
  205.   
  206.                 case MATCHONE:
  207. ***************
  208. *** 536,541 ****
  209. --- 574,582 ----
  210.                   mlp->first = avp;
  211.                   mlp->last = avp++;
  212.                   mlp++;
  213. + #ifdef ROUTING    /* ******************************** */
  214. +                 mlp -> equiv = NULL;
  215. + #endif ROUTING    /* ******************************** */
  216.                   break;
  217.   
  218.                 case MATCHZANY:
  219. ***************
  220. *** 543,548 ****
  221. --- 584,592 ----
  222.                   mlp->first = avp;
  223.                   mlp->last = avp - 1;
  224.                   mlp++;
  225. + #ifdef ROUTING    /* ******************************** */
  226. +                 mlp -> equiv = NULL;
  227. + #endif ROUTING    /* ******************************** */
  228.                   break;
  229.   
  230.                 default:
  231. ***************
  232. *** 576,581 ****
  233. --- 620,628 ----
  234.                   {
  235.                       /* back out binding */
  236.                       mlp--;
  237. + #ifdef ROUTING    /* ******************************** */
  238. +                     mlp -> equiv = NULL;
  239. + #endif ROUTING    /* ******************************** */
  240.                   }
  241.               }
  242.   
  243. ***************
  244. *** 630,636 ****
  245.               register char **pp;
  246.   
  247.               rp = *rvp;
  248. !             if (*rp != MATCHREPL)
  249.               {
  250.                   if (avp >= &npvp[MAXATOM])
  251.                   {
  252. --- 677,687 ----
  253.               register char **pp;
  254.   
  255.               rp = *rvp;
  256. !             if (*rp != MATCHREPL
  257. ! #ifdef ROUTING    /* ******************************** */
  258. !              && *rp != EQUIVREPL
  259. ! #endif ROUTING    /* ******************************** */
  260. !                         )
  261.               {
  262.                   if (avp >= &npvp[MAXATOM])
  263.                   {
  264. ***************
  265. *** 641,651 ****
  266. --- 692,722 ----
  267.                   continue;
  268.               }
  269.   
  270. + #ifdef ROUTING    /* ******************************** */
  271. + 
  272. +             /* if the $& is not followed by a digit, put the
  273. +                '&' on the output string. */
  274. + 
  275. +             if (*rp == EQUIVREPL && (rp[1] < '1' || rp[1] > '9'))
  276. +             {
  277. +                 *avp++ = "&";
  278. +                 continue;
  279. +             }
  280. + 
  281. + #endif ROUTING    /* ******************************** */
  282. + 
  283.               /* substitute from LHS */
  284.               m = &mlist[rp[1] - '1'];
  285.   # ifdef DEBUG
  286.               if (tTd(21, 15))
  287.               {
  288. + #ifdef ROUTING    /* ******************************** */
  289. +                 if (*rp == EQUIVREPL) {
  290. +                     printf("$&%c:%x=\"%s\"\n",
  291. +                     rp[1], *m->equiv, *m->equiv);
  292. +                 }
  293. +                 else {
  294. + #endif ROUTING    /* ******************************** */
  295.                   printf("$%c:", rp[1]);
  296.                   pp = m->first;
  297.                   while (pp <= m->last)
  298. ***************
  299. *** 655,662 ****
  300.                       printf("%s\"", *pp++);
  301.                   }
  302.                   printf("\n");
  303. !             }
  304.   # endif DEBUG
  305.               pp = m->first;
  306.               while (pp <= m->last)
  307.               {
  308. --- 726,763 ----
  309.                       printf("%s\"", *pp++);
  310.                   }
  311.                   printf("\n");
  312. ! #ifdef ROUTING    /* ******************************** */
  313. !                 }
  314. ! #endif ROUTING    /* ******************************** */
  315. !             };
  316.   # endif DEBUG
  317. + 
  318. + #ifdef ROUTING    /* ******************************** */
  319. + 
  320. +               if (*rp == EQUIVREPL) {
  321. +                 char buf[1024];
  322. +             char *av[MAXATOM+1];
  323. +             char *Dchar = DelimChar; /* save! */
  324. +     
  325. +             pp = copyplist(prescan1(m -> equiv,
  326. +                 '\0',buf,av,sizeof buf),TRUE);
  327. + 
  328. +             /* restore saved version, recursive */
  329. +             DelimChar = Dchar;
  330. + 
  331. +             while (*pp)
  332. +             {
  333. +                 if (avp >= &npvp[MAXATOM])
  334. +                 {
  335. +                 syserr("rewrite: expansion too long");
  336. +                 return;
  337. +                 }
  338. +                 *avp++ = *pp++;
  339. +             }
  340. +               }
  341. +               else
  342. +               {
  343. + #endif ROUTING    /* ******************************** */
  344.               pp = m->first;
  345.               while (pp <= m->last)
  346.               {
  347. ***************
  348. *** 667,672 ****
  349. --- 768,776 ----
  350.                   }
  351.                   *avp++ = *pp++;
  352.               }
  353. + #ifdef ROUTING    /* ******************************** */
  354. +               }
  355. + #endif ROUTING    /* ******************************** */
  356.           }
  357.           *avp++ = NULL;
  358.           if (**npvp == CALLSUBR)
  359. diff -c readcf.c.old readcf.c
  360. *** /usr/4.2/src/usr.lib/sendmail/src/readcf.c    Sun Sep 25 21:06:11 1983
  361. --- /usr/israel/sendmail/src/readcf.c    Fri Feb  1 17:59:14 1985
  362. ***************
  363. *** 110,119 ****
  364.                   rwp->r_lhs = copyplist(rwp->r_lhs, TRUE);
  365.   
  366.               /* expand and save the RHS */
  367. !             while (*++p == '\t')
  368.                   continue;
  369.               q = p;
  370. !             while (*p != '\0' && *p != '\t')
  371.                   p++;
  372.               *p = '\0';
  373.               expand(q, exbuf, &exbuf[sizeof exbuf], CurEnv);
  374. --- 110,119 ----
  375.                   rwp->r_lhs = copyplist(rwp->r_lhs, TRUE);
  376.   
  377.               /* expand and save the RHS */
  378. !             while (*++p == '\t' || *p == ' ')
  379.                   continue;
  380.               q = p;
  381. !             while (*p != '\0' && *p != '\t' && *p != ' ')
  382.                   p++;
  383.               *p = '\0';
  384.               expand(q, exbuf, &exbuf[sizeof exbuf], CurEnv);
  385. ***************
  386. *** 140,165 ****
  387.               (void) chompheader(&buf[1], TRUE);
  388.               break;
  389.   
  390. -           case 'C':        /* word class */
  391.             case 'F':        /* word class from file */
  392. !             /* read list of words from argument or file */
  393. !             if (buf[0] == 'F')
  394.               {
  395. !                 /* read from file */
  396. !                 for (p = &buf[2]; *p != '\0' && !isspace(*p); p++)
  397. !                     continue;
  398. !                 if (*p == '\0')
  399. !                     p = "%s";
  400. !                 else
  401. !                 {
  402. !                     *p = '\0';
  403. !                     while (isspace(*++p))
  404. !                         continue;
  405. !                 }
  406. !                 fileclass(buf[1], &buf[2], p);
  407. !                 break;
  408.               }
  409.   
  410.               /* scan the list of words and set class for all */
  411.               for (p = &buf[2]; *p != '\0'; )
  412.               {
  413. --- 140,161 ----
  414.               (void) chompheader(&buf[1], TRUE);
  415.               break;
  416.   
  417.             case 'F':        /* word class from file */
  418. ! 
  419. !                 /* read from file */
  420. !             for (p = &buf[2]; *p != '\0' && !isspace(*p); p++)
  421. !                 continue;
  422. !             if (*p == '\0') p = "%s";
  423. !             else
  424.               {
  425. !                 *p = '\0';
  426. !                 while (isspace(*++p)) continue;
  427.               }
  428. +             fileclass(buf[1], &buf[2], p);
  429. +             break;
  430.   
  431. +           case 'C':        /* word class */
  432. + 
  433.               /* scan the list of words and set class for all */
  434.               for (p = &buf[2]; *p != '\0'; )
  435.               {
  436. ***************
  437. *** 179,184 ****
  438. --- 175,221 ----
  439.               }
  440.               break;
  441.   
  442. + 
  443. + #ifdef ROUTING    /* ******************************** */
  444. + 
  445. +           case 'E':        /* word equivalence class */
  446. + 
  447. +             /* scan the list of words as a <word, translation>
  448. +                pair, and set class for all */
  449. + 
  450. +             for (p = &buf[2]; *p != '\0'; )
  451. +             {
  452. +                 register char *wd;
  453. +                 register char *wd2;
  454. +                 char delim;
  455. +                 STAB *s;
  456. + 
  457. +                 while (*p != '\0' && isspace(*p))
  458. +                     p++;
  459. +                 wd = p;
  460. +                 while (*p != '\0' && !isspace(*p))
  461. +                     p++;
  462. +                 delim = *p;
  463. +                 *p = '\0';
  464. +                 if (wd[0] != '\0')
  465. +                     s = setclass(buf[1], wd);
  466. +                 *p = delim;
  467. + 
  468. +                 while (*p != '\0' && isspace(*p))
  469. +                     p++;
  470. +                 wd2 = p;
  471. +                 while (*p != '\0' && !isspace(*p))
  472. +                     p++;
  473. +                 delim = *p;
  474. +                 *p = '\0';
  475. +                 if (*wd != NULL)
  476. +                     makeequiv(buf[1],wd2,s);
  477. +                 *p = delim;
  478. +             }
  479. +             break;
  480. + 
  481. + #endif ROUTING    /* ******************************** */
  482. + 
  483.             case 'M':        /* define mailer */
  484.               makemailer(&buf[1], safe);
  485.               break;
  486. ***************
  487. *** 269,274 ****
  488. --- 306,322 ----
  489.   **
  490.   **        puts all lines in filename that match a scanf into
  491.   **            the named class.
  492. + **
  493. + **    Comment: equivalence class modification
  494. + **        fileclass has been modified so that if you use a format
  495. + **        string returning two strings, i.e.:
  496. + **
  497. + **        FN/usr/lib/net-gateways "%s%s"
  498. + **
  499. + **        it will store the second name as a name translation of
  500. + **        the first, accessable through the $&<digit> macro.
  501. + **                        - BNI 9/5/84
  502. + **
  503.   */
  504.   
  505.   fileclass(class, filename, fmt)
  506. ***************
  507. *** 279,284 ****
  508. --- 327,338 ----
  509.       register FILE *f;
  510.       char buf[MAXLINE];
  511.   
  512. + #ifdef DEBUG
  513. +     if (tTd(86,5))
  514. +         printf("fileclass: class = %c, file = %s, fmt = \"%s\".\n"
  515. +             , class, filename, fmt);
  516. + #endif DEBUG
  517. + 
  518.       f = fopen(filename, "r");
  519.       if (f == NULL)
  520.       {
  521. ***************
  522. *** 291,300 ****
  523. --- 345,391 ----
  524.           register STAB *s;
  525.           char wordbuf[MAXNAME+1];
  526.   
  527. + #ifdef ROUTING    /* ******************************** */
  528. +         char word2[MAXNAME+1];
  529. +         int ssc;
  530. + #ifdef DEBUG
  531. +         if (tTd(86,11))
  532. +             printf("fileclass: got line '%s'.\n",buf);
  533. + #endif DEBUG
  534. +         word2[0] = '\0';
  535. +         
  536. +         if ((ssc=sscanf(buf, fmt, wordbuf, word2, 0)) < 1) {
  537. + #ifdef DEBUG
  538. +             if(tTd(86,8))
  539. +                   printf("fileclass: found nothing on line.\n");
  540. + #endif DEBUG
  541. +             continue;
  542. +         }
  543. + #ifdef DEBUG
  544. +         if (tTd(86,8))
  545. +             if (*word2)
  546. +                 printf("fileclass: found word translation '%s' --> '%s'.\n",
  547. +                 wordbuf,word2);
  548. +             else printf("fileclass: found word '%s'.\n",wordbuf);
  549. + #endif DEBUG
  550. + 
  551. + #else ROUTING    /* ******************************** */
  552. + 
  553.           if (sscanf(buf, fmt, wordbuf) != 1)
  554.               continue;
  555. + 
  556. + #endif ROUTING    /* ******************************** */
  557. + 
  558.           s = stab(wordbuf, ST_CLASS, ST_ENTER);
  559.           setbitn(class, s->s_class);
  560. + 
  561. + #ifdef ROUTING    /* ******************************** */
  562. + 
  563. +         if (*word2 != NULL)
  564. +             makeequiv(class,word2,s);
  565. + 
  566. + #endif ROUTING    /* ******************************** */
  567. + 
  568.       }
  569.   
  570.       (void) fclose(f);
  571. ***************
  572. *** 805,816 ****
  573.   **        word -- the word to enter
  574.   **
  575.   **    Returns:
  576. ! **        none.
  577.   **
  578.   **    Side Effects:
  579.   **        puts the word into the symbol table.
  580.   */
  581.   
  582.   setclass(class, word)
  583.       int class;
  584.       char *word;
  585. --- 896,915 ----
  586.   **        word -- the word to enter
  587.   **
  588.   **    Returns:
  589. ! **        a pointer to the symbol table entry created.
  590. ! **        - changed from 'no return value' 9/5/84 - BNI
  591.   **
  592.   **    Side Effects:
  593.   **        puts the word into the symbol table.
  594.   */
  595.   
  596. + 
  597. + #ifdef ROUTING    /* ******************************** */
  598. + 
  599. + STAB *
  600. + 
  601. + #endif ROUTING    /* ******************************** */
  602. + 
  603.   setclass(class, word)
  604.       int class;
  605.       char *word;
  606. ***************
  607. *** 819,822 ****
  608. --- 918,926 ----
  609.   
  610.       s = stab(word, ST_CLASS, ST_ENTER);
  611.       setbitn(class, s->s_class);
  612. + 
  613. + #ifdef ROUTING    /* ******************************** */
  614. +     return (s);
  615. + #endif ROUTING    /* ******************************** */
  616. + 
  617.   }
  618. diff -c stab.c.old stab.c
  619. *** /usr/4.2/src/usr.lib/sendmail/src/stab.c    Mon Jul 25 23:18:41 1983
  620. --- /usr/israel/sendmail/src/stab.c    Fri Feb  1 17:00:59 1985
  621. ***************
  622. *** 106,108 ****
  623. --- 106,185 ----
  624.   
  625.       return (s);
  626.   }
  627. + 
  628. + #ifdef ROUTING    /* ******************************** */
  629. + 
  630. + /*
  631. + **  MAKEEQUIV -- make a name equivalence entry
  632. + **
  633. + **    Parameters:
  634. + **        class -- the class the equivalence is in.
  635. + **        name  -- The name to be translated into.
  636. + **        s     -- a symbol table entry to the orginal name.
  637. + **
  638. + **    Returns:
  639. + **        none.
  640. + **
  641. + **    Side Effects:
  642. + **        none.
  643. + **
  644. + **    Author:
  645. + **        Bruce Israel  --  9/4/84.
  646. + **
  647. + */
  648. + 
  649. + makeequiv(class,name,s)
  650. + char class;
  651. + char *name;
  652. + STAB *s;
  653. + {
  654. +     EQUIV *eq;
  655. + 
  656. + #ifdef DEBUG
  657. +     if (tTd(87,5))
  658. +         printf("makeequiv: defining '%s' --> '%s' in class '%c'.\n",
  659. +             s -> s_name, name, class);
  660. + #endif DEBUG
  661. + 
  662. +     eq = (EQUIV *) xalloc(sizeof *eq);
  663. +     eq -> class = class;
  664. +     eq -> equivname = newstr(name);
  665. +     eq -> next = s ->s_equiv;
  666. +     s -> s_equiv = eq;
  667. + }
  668. + 
  669. +  /*
  670. + **  GETQUIV -- get a name equivalence for a class
  671. + **
  672. + **    Parameters:
  673. + **        class -- the class the equivalence is in.
  674. + **        s     -- The symbol table entry of the word.
  675. + **
  676. + **    Returns:
  677. + **        a pointer to a string containing the translation
  678. + **        name. If the symbol table entry has no translation
  679. + **        name, the original name will be returned.
  680. + **
  681. + **    Side Effects:
  682. + **        none.
  683. + **
  684. + **    Author:
  685. + **        Bruce Israel  --  9/4/84.
  686. + **
  687. + */
  688. + 
  689. + char *getequiv(class,s)
  690. + char class;
  691. + STAB *s;
  692. + {
  693. +     EQUIV *eq;
  694. + 
  695. +     eq = s -> s_equiv;
  696. +     while (eq != NULL) {
  697. +         if (eq -> class == class) return (eq -> equivname);
  698. +         eq = eq -> next;
  699. +     }
  700. +     return(s -> s_name);
  701. + }
  702. + 
  703. + #endif ROUTING    /* ******************************** */
  704. diff -c sendmail.h.old sendmail.h
  705. *** /usr/4.2/src/usr.lib/sendmail/src/sendmail.h    Sun Sep 25 21:06:12 1983
  706. --- /usr/israel/sendmail/src/sendmail.h    Fri Feb  1 17:00:42 1985
  707. ***************
  708. *** 2,9 ****
  709.   **  SENDMAIL.H -- Global definitions for sendmail.
  710.   */
  711.   
  712.   
  713. - 
  714.   # ifdef _DEFINE
  715.   # define EXTERN
  716.   # ifndef lint
  717. --- 2,9 ----
  718.   **  SENDMAIL.H -- Global definitions for sendmail.
  719.   */
  720.   
  721. + # define ROUTING    /* Mods for equivalence name classes - BNI 9/5/84 */
  722.   
  723.   # ifdef _DEFINE
  724.   # define EXTERN
  725.   # ifndef lint
  726. ***************
  727. *** 290,299 ****
  728. --- 290,319 ----
  729.   # define CONDIF        '\031'    /* conditional if-then */
  730.   # define CONDELSE    '\032'    /* conditional else */
  731.   # define CONDFI        '\033'    /* conditional fi */
  732. + 
  733. + #ifdef ROUTING    /* ******************************** */
  734. + 
  735. + # define EQUIVREPL    '\034'    /* equivalence class replacement */
  736. + 
  737. + #endif ROUTING    /* ******************************** */
  738. + 
  739.    /*
  740.   **  Symbol table definitions
  741.   */
  742.   
  743. + #ifdef ROUTING    /* ******************************** */
  744. + 
  745. + struct equivstr
  746. + {
  747. +     char        class;        /* class the name belongs in */
  748. +     char        *equivname;    /* translated version of name */
  749. +     struct equivstr    *next;        /* next item on equivalence list */
  750. + };
  751. + 
  752. + typedef struct equivstr EQUIV;
  753. + 
  754. + #endif ROUTING    /* ******************************** */
  755. + 
  756.   struct symtab
  757.   {
  758.       char        *s_name;    /* name to be entered */
  759. ***************
  760. *** 306,311 ****
  761. --- 326,334 ----
  762.           MAILER    *sv_mailer;    /* pointer to mailer */
  763.           char    *sv_alias;    /* alias */
  764.       }    s_value;
  765. + #ifdef ROUTING    /* ******************************** */
  766. +     EQUIV        *s_equiv;    /* pointer to equivalence names list */
  767. + #endif ROUTING    /* ******************************** */
  768.   };
  769.   
  770.   typedef struct symtab    STAB;
  771. ***************
  772. *** 323,328 ****
  773. --- 346,358 ----
  774.   # define s_alias    s_value.sv_alias
  775.   
  776.   extern STAB    *stab();
  777. + 
  778. + #ifdef ROUTING    /* ******************************** */
  779. + 
  780. + STAB    *setclass();
  781. + char    *getequiv();
  782. + 
  783. + #endif ROUTING    /* ******************************** */
  784.   
  785.   /* opcodes to stab */
  786.   # define ST_FIND    0    /* find entry */
  787. //go.sysin dd *
  788. if [ `wc -c < 4.2diffs` != 17321 ]; then
  789.     made=FALSE
  790.     /bin/echo 'error transmitting "4.2diffs" --'
  791.     /bin/echo 'length should be 17321, not' `wc -c < 4.2diffs`
  792. else
  793.     made=TRUE
  794. fi
  795. if [ $made = TRUE ]; then
  796.     /bin/chmod 644 4.2diffs
  797.     /bin/echo -n '    '; /bin/ls -ld 4.2diffs
  798. fi
  799. /bin/echo 'Extracting 4.3diffs'
  800. sed 's/^X//' <<'//go.sysin dd *' >4.3diffs
  801. RCS file: RCS/main.c,v
  802. retrieving revision 1.1
  803. diff -c -r1.1 main.c
  804. *** /tmp/,RCSt1001795    Thu Oct 31 18:03:04 1985
  805. --- main.c    Fri Oct 18 19:39:15 1985
  806. ***************
  807. *** 778,783 ****
  808. --- 778,784 ----
  809.   
  810.       /* these are RHS metasymbols */
  811.       '#', CANONNET,    '@', CANONHOST,    ':', CANONUSER,    '>', CALLSUBR,
  812. +     '&', EQUIVREPL,
  813.   
  814.       /* the conditional operations */
  815.       '?', CONDIF,    '|', CONDELSE,    '.', CONDFI,
  816. ===================================================================
  817. RCS file: RCS/parseaddr.c,v
  818. retrieving revision 1.1
  819. diff -c -r1.1 parseaddr.c
  820. *** /tmp/,RCSt1001795    Thu Oct 31 18:03:12 1985
  821. --- parseaddr.c    Fri Oct 18 19:39:19 1985
  822. ***************
  823. *** 213,218 ****
  824. --- 213,222 ----
  825.   **
  826.   **    Side Effects:
  827.   **        none.
  828. + **
  829. + **    N.B.: prescan's work is all done by the internal routine
  830. + **    _prescan, which merely has one additional parameter:
  831. + **        av -- place to put the pointers.
  832.   */
  833.   
  834.   /* states and character types */
  835. ***************
  836. *** 250,255 ****
  837. --- 254,272 ----
  838.       char delim;
  839.       char pvpbuf[];
  840.   {
  841. +     static char *av[MAXATOM+1];
  842. +     char **_prescan();
  843. + 
  844. +     return (_prescan(addr, delim, pvpbuf, av));
  845. + }
  846. + 
  847. + static char **
  848. + _prescan(addr, delim, pvpbuf, av)
  849. +     char *addr;
  850. +     char delim;
  851. +     char pvpbuf[];
  852. +     char *av[];
  853. + {
  854.       register char *p;
  855.       register char *q;
  856.       register int c;
  857. ***************
  858. *** 260,266 ****
  859.       char *tok;
  860.       int state;
  861.       int newstate;
  862. -     static char *av[MAXATOM+1];
  863.       extern int errno;
  864.   
  865.       /* make sure error messages don't have garbage on them */
  866. --- 277,282 ----
  867. ***************
  868. *** 443,449 ****
  869.           expand("\001o", buf, &buf[sizeof buf - 1], CurEnv);
  870.           (void) strcat(buf, DELIMCHARS);
  871.       }
  872. !     if (c == MATCHCLASS || c == MATCHREPL || c == MATCHNCLASS)
  873.           return (ONE);
  874.       if (c == '"')
  875.           return (QST);
  876. --- 459,466 ----
  877.           expand("\001o", buf, &buf[sizeof buf - 1], CurEnv);
  878.           (void) strcat(buf, DELIMCHARS);
  879.       }
  880. !     if (c == MATCHCLASS || c == MATCHREPL || c == MATCHNCLASS ||
  881. !         c == EQUIVREPL)
  882.           return (ONE);
  883.       if (c == '"')
  884.           return (QST);
  885. ***************
  886. *** 491,496 ****
  887. --- 508,514 ----
  888.   {
  889.       char    **first;    /* first token matched */
  890.       char    **last;        /* last token matched */
  891. +     char    *equiv;        /* equivalence name for match */ /* XXX */
  892.   };
  893.   
  894.   # define MAXMATCH    9    /* max params per rewrite */
  895. ***************
  896. *** 576,582 ****
  897.                   }
  898.                   else if (*rp == MATCHNCLASS)
  899.                       goto backup;
  900. ! 
  901.                   /* explicit fall-through */
  902.   
  903.                 case MATCHONE:
  904. --- 594,604 ----
  905.                   }
  906.                   else if (*rp == MATCHNCLASS)
  907.                       goto backup;
  908. !                 /*
  909. !                  * XXX    Should only note equiv parameters
  910. !                  *    here, and do translation later.
  911. !                  */
  912. !                 mlp->equiv = getequiv(rp[1], s);
  913.                   /* explicit fall-through */
  914.   
  915.                 case MATCHONE:
  916. ***************
  917. *** 585,590 ****
  918. --- 607,613 ----
  919.                   mlp->first = avp;
  920.                   mlp->last = avp++;
  921.                   mlp++;
  922. +                 mlp->equiv = NULL;
  923.                   break;
  924.   
  925.                 case MATCHZANY:
  926. ***************
  927. *** 592,597 ****
  928. --- 615,621 ----
  929.                   mlp->first = avp;
  930.                   mlp->last = avp - 1;
  931.                   mlp++;
  932. +                 mlp->equiv = NULL;
  933.                   break;
  934.   
  935.                 default:
  936. ***************
  937. *** 625,630 ****
  938. --- 649,655 ----
  939.                   {
  940.                       /* back out binding */
  941.                       mlp--;
  942. +                     mlp->equiv = NULL;
  943.                   }
  944.               }
  945.   
  946. ***************
  947. *** 679,689 ****
  948.               register char **pp;
  949.   
  950.               rp = *rvp;
  951. !             if (*rp == MATCHREPL)
  952.               {
  953.                   /* substitute from LHS */
  954.                   m = &mlist[rp[1] - '1'];
  955. !                 if (m >= mlp)
  956.                   {
  957.                       syserr("rewrite: ruleset %d: replacement out of bounds", ruleset);
  958.                       return;
  959. --- 704,714 ----
  960.               register char **pp;
  961.   
  962.               rp = *rvp;
  963. !             if (*rp == MATCHREPL || *rp == EQUIVREPL)
  964.               {
  965.                   /* substitute from LHS */
  966.                   m = &mlist[rp[1] - '1'];
  967. !                 if (rp[1] < '1' || rp[1] > '9' || m >= mlp)
  968.                   {
  969.                       syserr("rewrite: ruleset %d: replacement out of bounds", ruleset);
  970.                       return;
  971. ***************
  972. *** 691,697 ****
  973.   # ifdef DEBUG
  974.                   if (tTd(21, 15))
  975.                   {
  976. !                     printf("$%c:", rp[1]);
  977.                       pp = m->first;
  978.                       while (pp <= m->last)
  979.                       {
  980. --- 716,725 ----
  981.   # ifdef DEBUG
  982.                   if (tTd(21, 15))
  983.                   {
  984. !                     if (*rp == EQUIVREPL)
  985. !                         printf("$&%c:", rp[1]);
  986. !                     else
  987. !                         printf("$%c:", rp[1]);
  988.                       pp = m->first;
  989.                       while (pp <= m->last)
  990.                       {
  991. ***************
  992. *** 699,716 ****
  993.                           (void) fflush(stdout);
  994.                           printf("%s\"", *pp++);
  995.                       }
  996.                       printf("\n");
  997.                   }
  998.   # endif DEBUG
  999. !                 pp = m->first;
  1000. !                 while (pp <= m->last)
  1001.                   {
  1002. !                     if (avp >= &npvp[MAXATOM])
  1003.                       {
  1004. !                         syserr("rewrite: expansion too long");
  1005. !                         return;
  1006.                       }
  1007. !                     *avp++ = *pp++;
  1008.                   }
  1009.               }
  1010.               else
  1011. --- 727,770 ----
  1012.                           (void) fflush(stdout);
  1013.                           printf("%s\"", *pp++);
  1014.                       }
  1015. +                     if (*rp == EQUIVREPL)
  1016. +                         printf(" => \"%s\"",
  1017. +                             m->equiv);
  1018.                       printf("\n");
  1019.                   }
  1020.   # endif DEBUG
  1021. !                 if (*rp == EQUIVREPL)
  1022.                   {
  1023. !                     char equivbuf[PSBUFSIZE];
  1024. !                     char *equivav[MAXATOM+1];
  1025. !                     char *saveDelim = DelimChar;
  1026. !                     extern char **copyplist();
  1027. ! 
  1028. !                     /*
  1029. !                      * XXX    waste of memory!
  1030. !                      */
  1031. !                     pp = copyplist(_prescan(m->equiv,
  1032. !                                 '\0',
  1033. !                                 equivbuf,
  1034. !                                 equivav),
  1035. !                             TRUE);
  1036. !                     DelimChar = saveDelim;
  1037. !                     while (*pp)
  1038.                       {
  1039. !                         if (avp >= &npvp[MAXATOM])
  1040. !                             goto toolong;
  1041. !                         *avp++ = *pp++;
  1042.                       }
  1043. !                 }
  1044. !                 else
  1045. !                 {
  1046. !                     pp = m->first;
  1047. !                     while (pp <= m->last)
  1048. !                     {
  1049. !                         if (avp >= &npvp[MAXATOM])
  1050. !                             goto toolong;
  1051. !                         *avp++ = *pp++;
  1052. !                     }
  1053.                   }
  1054.               }
  1055.               else
  1056. ===================================================================
  1057. RCS file: RCS/readcf.c,v
  1058. retrieving revision 1.1
  1059. diff -c -r1.1 readcf.c
  1060. *** /tmp/,RCSt1001795    Thu Oct 31 18:03:23 1985
  1061. --- readcf.c    Fri Oct 18 19:39:22 1985
  1062. ***************
  1063. *** 164,189 ****
  1064.               (void) chompheader(&buf[1], TRUE);
  1065.               break;
  1066.   
  1067. -           case 'C':        /* word class */
  1068.             case 'F':        /* word class from file */
  1069.               /* read list of words from argument or file */
  1070. !             if (buf[0] == 'F')
  1071.               {
  1072. !                 /* read from file */
  1073. !                 for (p = &buf[2]; *p != '\0' && !isspace(*p); p++)
  1074.                       continue;
  1075. -                 if (*p == '\0')
  1076. -                     p = "%s";
  1077. -                 else
  1078. -                 {
  1079. -                     *p = '\0';
  1080. -                     while (isspace(*++p))
  1081. -                         continue;
  1082. -                 }
  1083. -                 fileclass(buf[1], &buf[2], p);
  1084. -                 break;
  1085.               }
  1086.   
  1087.               /* scan the list of words and set class for all */
  1088.               for (p = &buf[2]; *p != '\0'; )
  1089.               {
  1090. --- 164,186 ----
  1091.               (void) chompheader(&buf[1], TRUE);
  1092.               break;
  1093.   
  1094.             case 'F':        /* word class from file */
  1095.               /* read list of words from argument or file */
  1096. !             /* read from file */
  1097. !             for (p = &buf[2]; *p != '\0' && !isspace(*p); p++)
  1098. !                 continue;
  1099. !             if (*p == '\0')
  1100. !                 p = "%s";
  1101. !             else
  1102.               {
  1103. !                 *p = '\0';
  1104. !                 while (isspace(*++p))
  1105.                       continue;
  1106.               }
  1107. +             fileclass(buf[1], &buf[2], p);
  1108. +             break;
  1109.   
  1110. +           case 'C':        /* word class */
  1111.               /* scan the list of words and set class for all */
  1112.               for (p = &buf[2]; *p != '\0'; )
  1113.               {
  1114. ***************
  1115. *** 203,208 ****
  1116. --- 200,247 ----
  1117.               }
  1118.               break;
  1119.   
  1120. + /* BEGIN STRANGE */
  1121. + /* Do we actually use this??? */
  1122. +           case 'E':        /* word equivalence class */
  1123. +             for (p = &buf[2]; *p != '\0'; )
  1124. +             {
  1125. +                 register char *wd;
  1126. +                 register char *eqwd;
  1127. +                 char delim;
  1128. +                 register STAB *s;
  1129. + 
  1130. +                 while (*p != '\0' && isspace(*p))
  1131. +                     p++;
  1132. +                 wd = p;
  1133. +                 while (*p != '\0' && !isspace(*p))
  1134. +                     p++;
  1135. +                 delim = *p;
  1136. +                 *p = '\0';
  1137. +                 if (wd[0] == 0)
  1138. +                 {
  1139. +                     *p = delim;
  1140. +                     break;
  1141. +                 }
  1142. +                 /*
  1143. +                  * Cannot use setclass here as we
  1144. +                  * need the sym entry
  1145. +                  */
  1146. +                 s = stab(wd, ST_CLASS, ST_ENTER);
  1147. +                 setbitn(buf[1], s->s_class);
  1148. +                 *p = delim;
  1149. +                 while (*p != '\0' && isspace(*p))
  1150. +                     p++;
  1151. +                 eqwd = p;
  1152. +                 while (*p != '\0' && !isspace(*p))
  1153. +                     p++;
  1154. +                 delim = *p;
  1155. +                 *p = 0;
  1156. +                 makeequiv(buf[1], eqwd, s);
  1157. +                 *p = delim;
  1158. +             }
  1159. +             break;
  1160. + /* END STRANGE */
  1161. + 
  1162.             case 'M':        /* define mailer */
  1163.               makemailer(&buf[1]);
  1164.               break;
  1165. ***************
  1166. *** 314,324 ****
  1167.       {
  1168.           register STAB *s;
  1169.           char wordbuf[MAXNAME+1];
  1170. ! 
  1171. !         if (sscanf(buf, fmt, wordbuf) != 1)
  1172.               continue;
  1173.           s = stab(wordbuf, ST_CLASS, ST_ENTER);
  1174.           setbitn(class, s->s_class);
  1175.       }
  1176.   
  1177.       (void) fclose(f);
  1178. --- 353,382 ----
  1179.       {
  1180.           register STAB *s;
  1181.           char wordbuf[MAXNAME+1];
  1182. !         char equivbuf[MAXNAME+1];
  1183. !         int nscanned;
  1184. !         
  1185. !         if ((nscanned = sscanf(buf, fmt, wordbuf, equivbuf)) < 1)
  1186. !         {
  1187. ! #ifdef DEBUG
  1188. !             if (tTd(86, 8))
  1189. !                 printf("fileclass: found nothing on line.\n");
  1190. ! #endif DEBUG
  1191.               continue;
  1192. +         }
  1193. + #ifdef DEBUG
  1194. +         if (tTd(86, 8))
  1195. +         {
  1196. +             printf("fileclass: found word \"%s\"", wordbuf);
  1197. +             if (nscanned > 1)
  1198. +                 printf(" => \"%s\"", equivbuf);
  1199. +             printf(".\n");
  1200. +         }
  1201. + #endif DEBUG
  1202.           s = stab(wordbuf, ST_CLASS, ST_ENTER);
  1203.           setbitn(class, s->s_class);
  1204. +         if (nscanned > 1)
  1205. +             makeequiv(class, equivbuf, s);
  1206.       }
  1207.   
  1208.       (void) fclose(f);
  1209. ===================================================================
  1210. RCS file: RCS/sendmail.h,v
  1211. retrieving revision 1.1
  1212. diff -c -r1.1 sendmail.h
  1213. *** /tmp/,RCSt1001795    Thu Oct 31 18:03:32 1985
  1214. --- sendmail.h    Sat Oct 19 03:03:24 1985
  1215. ***************
  1216. *** 57,64 ****
  1217. --- 57,69 ----
  1218.   #define BYTEBITS    8    /* number of bits in a byte */
  1219.   
  1220.   /* internal macros */
  1221. + #if BYTEBITS == 8 && (defined(vax) || defined(mc68000) || defined(ns32000))
  1222. + #define _BITWORD(bit)    ((bit) >> 5)
  1223. + #define    _BITBIT(bit)    (1 << ((bit) & (BYTEBITS * sizeof (int) - 1)))
  1224. + #else BYTEBITS == 8
  1225.   #define _BITWORD(bit)    (bit / (BYTEBITS * sizeof (int)))
  1226.   #define _BITBIT(bit)    (1 << (bit % (BYTEBITS * sizeof (int))))
  1227. + #endif BYTEBITS == 8
  1228.   
  1229.   typedef int    BITMAP[BITMAPBYTES / sizeof (int)];
  1230.   
  1231. ***************
  1232. *** 321,326 ****
  1233. --- 326,334 ----
  1234.   # define HOSTBEGIN    '\035'    /* hostname lookup begin */
  1235.   # define HOSTEND    '\036'    /* hostname lookup end */
  1236.   
  1237. + /* canonicalization */
  1238. + # define EQUIVREPL    '\037'    /* equivalence class replacement */
  1239. + 
  1240.   /* \001 is also reserved as the macro expansion character */
  1241.    /*
  1242.   **  Information about hosts that we have looked up recently.
  1243. ***************
  1244. *** 352,357 ****
  1245. --- 360,379 ----
  1246.   **  Symbol table definitions
  1247.   */
  1248.   
  1249. + /*
  1250. +  * The canonicalizing operator $&n looks up names and replacements.
  1251. +  * The replacment name(s) for a name are stored in the following
  1252. +  * linked list, which is then attached to the symbol table entry.
  1253. +  */
  1254. + struct equivstr
  1255. + {
  1256. +     char        class;        /* class the replacement is in */
  1257. +     char        *equivname;    /* the replacement name */
  1258. +     struct equivstr *next;        /* linked list */
  1259. + };
  1260. + 
  1261. + typedef struct equivstr EQUIV;
  1262. + 
  1263.   struct symtab
  1264.   {
  1265.       char        *s_name;    /* name to be entered */
  1266. ***************
  1267. *** 367,372 ****
  1268. --- 389,395 ----
  1269.           HOSTINFO    sv_host;    /* host information */
  1270.   # endif HOSTINFO
  1271.       }    s_value;
  1272. +     EQUIV        *s_equiv;    /* list of replacements */
  1273.   };
  1274.   
  1275.   typedef struct symtab    STAB;
  1276. ***************
  1277. *** 386,391 ****
  1278. --- 409,415 ----
  1279.   # define s_host        s_value.sv_host
  1280.   
  1281.   extern STAB    *stab();
  1282. + extern char    *getequiv();
  1283.   
  1284.   /* opcodes to stab */
  1285.   # define ST_FIND    0    /* find entry */
  1286. ===================================================================
  1287. RCS file: RCS/stab.c,v
  1288. retrieving revision 1.1
  1289. diff -c -r1.1 stab.c
  1290. *** /tmp/,RCSt1001795    Thu Oct 31 18:03:39 1985
  1291. --- stab.c    Fri Oct 18 19:39:27 1985
  1292. ***************
  1293. *** 118,120 ****
  1294. --- 118,221 ----
  1295.   
  1296.       return (s);
  1297.   }
  1298. + 
  1299. +  /*
  1300. + **  MAKEEQUIV -- make a name equivalence entry
  1301. + **
  1302. + **    Parameters:
  1303. + **        class -- the class the equivalence is in.
  1304. + **        name -- the replacement (new) name.
  1305. + **        s -- the symbol table entry of the source (old) name.
  1306. + **
  1307. + **    Returns:
  1308. + **        none.
  1309. + **
  1310. + **    Side Effects:
  1311. + **        Updates the equivalences attached to `s'.
  1312. + **
  1313. + **    Author:
  1314. + **        Bruce Israel -- 9/4/84.
  1315. + **        Fixes 17 Oct 1985, Chris Torek
  1316. + */
  1317. + 
  1318. + makeequiv(class, name, s)
  1319. +     register int class;
  1320. +     char *name;
  1321. +     register STAB *s;
  1322. + {
  1323. +     register EQUIV *eq;
  1324. + 
  1325. +     for (eq = s->s_equiv; eq != NULL; eq = eq->next)
  1326. +     {
  1327. +         if (eq->class != class)
  1328. +             continue;
  1329. + 
  1330. +         /*
  1331. +          * To replace, or to reject: that is the question.
  1332. +          * Whether 'tis nobler to suffer the slings and
  1333. +          * arrows of outrageous remappings, or, by opposing,
  1334. +          * to end them.  ...Chris
  1335. +          */
  1336. + #ifdef DEBUG
  1337. +         if (tTd(87, 5))
  1338. +             printf("makeequiv: attempt to replace \"%s\" => \"%s\" (class %c)\n\twith  => \"%s\" (ignored).\n",
  1339. +                 s->s_name, eq->equivname, class, name);
  1340. + #endif DEBUG
  1341. + #ifdef notdef
  1342. +         free(eq->equivname);
  1343. +         eq->equivname = newstr(name);
  1344. + #endif notdef
  1345. +         return;
  1346. +     }
  1347. +     eq = (EQUIV *)xalloc(sizeof *eq);
  1348. +     eq->class = class;
  1349. +     eq->equivname = newstr(name);
  1350. +     eq->next = s->s_equiv;
  1351. +     s->s_equiv = eq;
  1352. + }
  1353. + 
  1354. +  /*
  1355. + **  GETEQUIV -- get the replacement name for a stab entry given a
  1356. + **  class.
  1357. + **
  1358. + **    Parameters:
  1359. + **        class -- the replacement class.
  1360. + **        s -- the old name.
  1361. + **
  1362. + **    Returns:
  1363. + **        a pointer to a string containing the new name.
  1364. + **        If the symbol table entry has no translation
  1365. + **        name, the original name will be returned.
  1366. + **
  1367. + **    Side Effects:
  1368. + **        none.
  1369. + **
  1370. + **    Author:
  1371. + **        Bruce Israel -- 9/4/84.
  1372. + */
  1373. + 
  1374. + char *
  1375. + getequiv(class, s)
  1376. +     register int  class;
  1377. +     register STAB *s;
  1378. + {
  1379. +     register EQUIV *eq;
  1380. + 
  1381. +     for (eq = s->s_equiv; eq != NULL; eq = eq->next)
  1382. +     {
  1383. +         if (eq->class != class)
  1384. +             continue;
  1385. + #ifdef DEBUG
  1386. +         if (tTd(87, 5))
  1387. +             printf("getequiv: \"%s\" => \"%s\" (class %c).\n",
  1388. +                 s->s_name, eq->equivname, class);
  1389. + #endif DEBUG
  1390. +         return (eq->equivname);
  1391. +     }
  1392. + #ifdef DEBUG
  1393. +     if (tTd(87, 5))
  1394. +         printf("getequiv: \"%s\" not mapped in class %c; unchanged.\n",
  1395. +             s->s_name);
  1396. + #endif DEBUG
  1397. +     return (s->s_name);
  1398. + }
  1399. //go.sysin dd *
  1400. if [ `wc -c < 4.3diffs` != 13636 ]; then
  1401.     made=FALSE
  1402.     /bin/echo 'error transmitting "4.3diffs" --'
  1403.     /bin/echo 'length should be 13636, not' `wc -c < 4.3diffs`
  1404. else
  1405.     made=TRUE
  1406. fi
  1407. if [ $made = TRUE ]; then
  1408.     /bin/chmod 644 4.3diffs
  1409.     /bin/echo -n '    '; /bin/ls -ld 4.3diffs
  1410. fi
  1411. /bin/echo 'Extracting README'
  1412. sed 's/^X//' <<'//go.sysin dd *' >README
  1413. This documents the University of Maryland modifications to sendmail to
  1414. allow translation tables to be used in sendmail.cf.
  1415.  
  1416. There are 5 files here.  They are:
  1417.  
  1418. 4.2diffs
  1419. 4.3diffs - these are diff -c listings for the changes to the sendmail
  1420.     source.  The changes exist in 5 files, parseaddr.c (the meat
  1421.     of the changes), readcf.c, stab.c main.c and sendmail.h.
  1422.  
  1423. mimsy.cf - The standard University of Maryland .cf file.  This file is
  1424.     almost completely host independent, with only the real name, UUCP
  1425.     name, and valid local domain definitions hardcoded into Define's.
  1426.     Any other system information has been moved to files in the
  1427.     directory /usr/lib/hostnames/.
  1428.  
  1429. host-doc - This documents the various files in /usr/lib/hostnames/
  1430.     that are used by the sendmail.cf file.  It is intended to be a
  1431.     README for that directory.
  1432.  
  1433. names - this is a shell script that makes a translation table for all
  1434.     local network users.  It has hard-coded into it all machines on
  1435.     the local network, and when run on a machine, builds a file of
  1436.     accounts and aliases on the local network but NOT on the current
  1437.     host.  This file is used by the .cf file to route mail to users on
  1438.     the local net.  In this fashion, if JOE has an account on one
  1439.     local machine, mail to JOE@<any-local-machine> will get to him.
  1440.     If JOE has an account on multiple machines, it will route his
  1441.     mail to one of them and assume that he has a .forward.  Note
  1442.     that this requires that names on local network machines be unique
  1443.     (i.e. two different people would not be given the same account).
  1444.  
  1445. - How to use these mods -
  1446.  
  1447. After installing the source mods, you will have a sendmail executable
  1448. that has this extra feature of translation tables.  In normal
  1449. sendmails, you use the 'C' and 'F' commands in the .cf file to define
  1450. classes (C for classes define in the .cf file, and F for classes
  1451. defined in an external file).  Translation tables are defined with
  1452. the 'E' and 'F' commands.  A class is a list of items.  A translation
  1453. class is a list of pairs, items and the translated version of the
  1454. item.  i.e. a translation file for some uucp sites to be routed (i.e.
  1455. pathalias stuff) could look like:
  1456.  
  1457. seismo    umcp-cs!seismo
  1458. chimera    gymble!harvard!chimera
  1459. godot    gymble!harvard!think
  1460. elsie    elsie
  1461. ihnp4    umcp-cs!seismo!ihnp4
  1462.  
  1463. To read in a translation table from a file, use 'F' like always but
  1464. give a format string with two %s's in it, i.e.
  1465.  
  1466. FU/usr/lib/hostnames/uucp-routing %s%s
  1467.  
  1468. and both the name and its translation would be read in.  The 'E'
  1469. command is like 'C'.  It reads pairs of items on the current line (and
  1470. continuation lines) and groups them together.  i.e. a list of people
  1471. and the machine that they use might be:
  1472.  
  1473. EPjoe site1 bill site2 john site1 ed site3
  1474.  
  1475. E was added for orthogonality with C, and is unused in the sample
  1476. sendmail.cf file enclosed.
  1477.  
  1478. Accessing Translations
  1479.  
  1480. Normally in sendmail you use $<number> in a RHS to access items
  1481. matched on the LHS.  If you want the translation instead, follow the $
  1482. with an &, i.e. $&3.  For example, rules using the above classes might
  1483. look like:
  1484.  
  1485. R$=U!$+        $:$&1!$2    Expand UUCP paths from file
  1486. R$=P        $1@$&1        Route mail for users to their machine
  1487.  
  1488. Notice that both $num and $&num can be used together.  If a
  1489. class was not specified as a translation table, then the translation
  1490. of any item in that class is equivalent to the item itself.
  1491.  
  1492. For more information, see the examples in mimsy.cf or send mail to
  1493. israel@mimsy.umd.edu (Arpanet) or seismo!umcp-cs!israel (Usenet).
  1494.  
  1495. Enjoy.
  1496. //go.sysin dd *
  1497. if [ `wc -c < README` != 3527 ]; then
  1498.     made=FALSE
  1499.     /bin/echo 'error transmitting "README" --'
  1500.     /bin/echo 'length should be 3527, not' `wc -c < README`
  1501. else
  1502.     made=TRUE
  1503. fi
  1504. if [ $made = TRUE ]; then
  1505.     /bin/chmod 644 README
  1506.     /bin/echo -n '    '; /bin/ls -ld README
  1507. fi
  1508. /bin/echo 'Extracting host-doc'
  1509. sed 's/^X//' <<'//go.sysin dd *' >host-doc
  1510. This file documents the directory /usr/lib/hostnames that is
  1511. frequently used in sendmail.cf.  It is intended to be a README for
  1512. that directory.
  1513.  
  1514. This directory contains all routing tables for sendmail.  The different files
  1515. are used to route mail to different hosts on various nets.  The files are:
  1516.  
  1517. combined-hosts    This file contains sites that are known to be on both the
  1518.         arpanet and USEnet.  For such sites, mail is routed via
  1519.         the ARPAnet if a specific delivery method (i.e. .UUCP) is
  1520.         not specified.
  1521.  
  1522. csnet        This file contains the list of CSNet Phonenet sites.  It is
  1523.         in the form '<alias> <real-name>'.
  1524.  
  1525. cur-site    Aliases for the local site.
  1526.  
  1527. locals        Aliases for all local area network sites.  Lines are of
  1528.         the form '<site-alias> <real-site-name>'.
  1529.  
  1530. mailhosts    list of users and mailing lists on the other machines of
  1531.         the local network.  Lines are of the form:
  1532.         <name> <name>@<site>
  1533.         This file is created by the 'names' executable nightly.
  1534.  
  1535. relays        list of domains and an accessible host that knows how
  1536.         to relay all mail intended for that domain.  For
  1537.         example, 'csnet csnet-relay.arpa'.
  1538.  
  1539. specials    list of hosts that need to be specially processed, and
  1540.         the real way to get to that host.  This can be used for
  1541.         defining special, non-arpanet hosts or hosts who need
  1542.         a special path (like if a connection is broken).  Each
  1543.         line is '<site> <real-site-with-routing>'.  For example:
  1544.         if ARPASITE's arpanet connection is down indefinitely, you
  1545.         might put in: 'ARPASITE ARPASITE.uucp@ARPANEIGHBOR.uucp' and
  1546.         then mail will be routed to ARPANEIGHBOR via UUCP and then
  1547.         to ARPASITE.  Because of the purpose of this file, any
  1548.         path in here overrides all other paths (including user
  1549.         specified paths).
  1550.  
  1551. uucp-direct    List of sites that this site talks to directly via UUCP.
  1552.  
  1553. uucp-routing    List of UUCPnet sites that we know how to route to.
  1554.         Lines are of the form '<name> <route>!<name>'.
  1555. //go.sysin dd *
  1556. if [ `wc -c < host-doc` != 1903 ]; then
  1557.     made=FALSE
  1558.     /bin/echo 'error transmitting "host-doc" --'
  1559.     /bin/echo 'length should be 1903, not' `wc -c < host-doc`
  1560. else
  1561.     made=TRUE
  1562. fi
  1563. if [ $made = TRUE ]; then
  1564.     /bin/chmod 644 host-doc
  1565.     /bin/echo -n '    '; /bin/ls -ld host-doc
  1566. fi
  1567. /bin/echo 'Extracting mimsy.cf'
  1568. sed 's/^X//' <<'//go.sysin dd *' >mimsy.cf
  1569. ############################################################
  1570. ############################################################
  1571. #####
  1572. #####        SENDMAIL CONFIGURATION FILE
  1573. #####
  1574. #####        @(#) U of Maryland, October 1985
  1575. #####               - Bruce Israel israel@mimsy.umd.edu,
  1576. #####                              umcp-cs!israel
  1577. #####
  1578. ############################################################
  1579. ############################################################
  1580.  
  1581.  
  1582.  
  1583. ############################################################
  1584. ###    local info
  1585. ############################################################
  1586.  
  1587. # load to start queuing.  (busted--never queue.  MDW 8/3/84)
  1588. Ox50
  1589.  
  1590. # UUCP name
  1591. DUumcp-cs
  1592. CU$U
  1593.  
  1594. Dwmimsy
  1595.  
  1596. # internet hostname for current host - put into a file for portability
  1597. Fw/usr/lib/hostnames/cur-site
  1598. DA$w
  1599.  
  1600. # domain
  1601. DDumd.edu
  1602. CDumd.edu arpa csnet uucp
  1603.  
  1604. # official hostname
  1605. Dj$w.$D
  1606.  
  1607. # csnet names
  1608. FC/usr/lib/hostnames/csnet %s%s
  1609.  
  1610. # domain relays, (domain relay-site)
  1611. FR/usr/lib/hostnames/relays %s%s
  1612.  
  1613. # UUCP hosts that we talk directly to 
  1614. FW/usr/lib/hostnames/uucp-direct
  1615.  
  1616. # users mailhosts, local network people (user user@real-host)
  1617. FH/usr/lib/hostnames/mailhosts %s%s
  1618.  
  1619. # local network sites (site-alias real-site-name)
  1620. FL/usr/lib/hostnames/locals %s%s
  1621.  
  1622. # uucp routing table (site uucp-path!site)
  1623. FP/usr/lib/hostnames/uucp-routing %s%s
  1624. FP/usr/lib/hostnames/uucp-direct
  1625.  
  1626. # combination uucp/arpanet hosts, all local hosts are networked
  1627. FX/usr/lib/hostnames/combined-hosts
  1628. FX/usr/lib/hostnames/locals %s
  1629.  
  1630. # Hosts to handle specially (site override-path)
  1631. FS/usr/lib/hostnames/specials %s%s
  1632.  
  1633. ############################################################
  1634. #
  1635. #    General configuration information
  1636. #
  1637. #    This information is basically just "boiler-plate"; it must be
  1638. #    there, but is essentially constant.
  1639. #
  1640. #    Information in this file should be independent of location --
  1641. #    i.e., although there are some policy decisions made, they are
  1642. #    not specific to Berkeley per se.
  1643. #
  1644. #        @(#)base.m4    4.3        8/30/83
  1645. #
  1646. ############################################################
  1647.  
  1648. #    @(#)version.m4    4.7        8/31/83
  1649.  
  1650. DV4.7
  1651.  
  1652. ##########################
  1653. ###   Special macros   ###
  1654. ##########################
  1655.  
  1656. # my name
  1657. DnMAILER-DAEMON
  1658. # UNIX header format
  1659. DlFrom $g  $d  $y
  1660. # delimiter (operator) characters
  1661. Do.:%@!^=/[]
  1662. # format of a total name
  1663. # yucky style... Dq$g$?x ($x)$.
  1664. Dq$?x$x $.<$g>
  1665. # SMTP login message
  1666. De$j Sendmail $v/$V (with U of MD hacks) ready at $b
  1667.  
  1668. # forwarding host -- redefine this if you can't talk to the relay directly
  1669. DF$R
  1670.  
  1671. ###################
  1672. ###   Options   ###
  1673. ###################
  1674.  
  1675. # location of alias file
  1676. OA/usr/lib/aliases
  1677. # default delivery mode (deliver in background)
  1678. Odbackground
  1679. # (don't) connect to "expensive" mailers
  1680. #Oc
  1681. # temporary file mode
  1682. OF0644
  1683. # default GID
  1684. Og1
  1685. # location of help file
  1686. OH/usr/lib/sendmail.hf
  1687. # log level
  1688. OL9
  1689. # default messages to old style
  1690. Oo
  1691. # queue directory
  1692. OQ/usr/spool/mqueue
  1693. # read timeout -- violates protocols
  1694. Or2h
  1695. # status file
  1696. OS/usr/lib/sendmail.st
  1697. # queue up everything before starting transmission
  1698. Os
  1699. # default timeout interval
  1700. OT9d
  1701. # time zone names (V6 only)
  1702. OtEST,EDT
  1703. # default UID
  1704. Ou1
  1705.  
  1706. ###############################
  1707. ###   Message precedences   ###
  1708. ###############################
  1709.  
  1710. Pfirst-class=0
  1711. Pspecial-delivery=100
  1712. Pjunk=-100
  1713.  
  1714. #########################
  1715. ###   Trusted users   ###
  1716. #########################
  1717.  
  1718. Troot
  1719. Tdaemon
  1720. Tuucp
  1721. Tmark
  1722. Tisrael
  1723. Tnetwork
  1724. Ttewok
  1725.  
  1726. #############################
  1727. ###   Format of headers   ###
  1728. #############################
  1729.  
  1730. H?P?Return-Path: <$g>
  1731. HReceived: $?sfrom $s $.by $j ($v/$V)
  1732.     id $i; $b
  1733. H?D?Resent-Date: $a
  1734. H?D?Date: $a
  1735. H?F?Resent-From: $q
  1736. H?F?From: $q
  1737. H?x?Full-Name: $x
  1738. HSubject:
  1739. # HPosted-Date: $a
  1740. # H?l?Received-Date: $b
  1741. H?M?Resent-Message-Id: <$t.$i@$j>
  1742. H?M?Message-Id: <$t.$i@$j>
  1743.  
  1744. ###########################
  1745. ###   Rewriting rules   ###
  1746. ###########################
  1747.  
  1748.  
  1749. ################################
  1750. #  Sender Field Pre-rewriting  #
  1751. ################################
  1752. S1
  1753. #R$*<$*>$*        $1$2$3                defocus
  1754.  
  1755. ###################################
  1756. #  Recipient Field Pre-rewriting  #
  1757. ###################################
  1758. S2
  1759. #R$*<$*>$*        $1$2$3                defocus
  1760.  
  1761. #################################
  1762. #  Final Output Post-rewriting  #
  1763. #################################
  1764. S4
  1765.  
  1766. R@            $@                handle <> error addr
  1767.  
  1768. # externalize local domain info
  1769. R$*<$*LOCAL>$*        $1<$2$D>$3            change local info
  1770. R$*<$+>$*        $1$2$3                defocus
  1771. R@$+:$+:$+        $@@$1,$2:$3            <route-addr> canonical
  1772.  
  1773. # UUCP must always be presented in old form
  1774. R$+@$-.UUCP        $2!$1                u@h.UUCP => h!u
  1775.  
  1776. # delete duplicate local names -- mostly for arpaproto.mc
  1777. R$+%$=w@$=w        $1@$3                u%UCB@UCB => u@UCB
  1778. R$+%$=w@$=w.$=D        $1@$3.ARPA            u%UCB@UCB => u@UCB
  1779.  
  1780. ###########################
  1781. #  Name Canonicalization  #
  1782. ###########################
  1783. S3
  1784.  
  1785. # handle "from:<>" special case
  1786. R<>            $@@                turn into magic token
  1787.  
  1788. # basic textual canonicalization
  1789. R$*<$+>$*        $2                basic RFC821/822 parsing
  1790. R$+ at $+        $1@$2                "at" -> "@" for RFC 822
  1791. R$*<$*>$*        $1$2$3                in case recursive
  1792.  
  1793. # make sure <@a,@b,@c:user@d> syntax is easy to parse -- undone later
  1794. R@$+,$+            @$1:$2                change all "," to ":"
  1795.  
  1796. # localize and dispose of domain-based addresses
  1797. R@$+:$+            $@$>6<@$1>:$2            handle <route-addr>
  1798.  
  1799. # more miscellaneous cleanup
  1800. R$+:$*;@$+        $@$>6$1:$2;@$3            list syntax
  1801. R$+@$+            $:$1<@$2>            focus on domain
  1802. R$+<$+@$+>        $1$2<@$3>            move gaze right
  1803. R$+<@$+>        $@$>6$1<@$2>            already canonical
  1804.  
  1805. # convert old-style addresses to a domain-based address
  1806. R$+%$+            $@$>6$1<@$2>            user%host
  1807. R$-:$+            $@$>6$2<@$1>            host:user
  1808. R$-.$+            $@$>6$2<@$1>            host.user
  1809. R$+^$+            $1!$2                convert ^ to !
  1810. R$-!$+            $@$>6$2<@$1.UUCP>        resolve uucp names
  1811. R$-=$+            $@$>6$2<@$1.BITNET>        resolve bitnet names
  1812. R$*            $@$>6$1            process everything else
  1813.  
  1814. ############################################################
  1815. ############################################################
  1816. #####
  1817. #####        RULESET ZERO PREAMBLE
  1818. #####
  1819. #####    The beginning of ruleset zero is constant through all
  1820. #####    configurations.
  1821. #####
  1822. #####        @(#)zerobase.m4    4.1        7/25/83
  1823. #####
  1824. ############################################################
  1825. ############################################################
  1826.  
  1827. S0
  1828.  
  1829. # first make canonical
  1830. R$*<$*>$*        $1$2$3                defocus
  1831. R$+            $:$>3$1                make canonical
  1832.  
  1833. # handle special cases.....
  1834. R@            $#local$:MAILER-DAEMON        handle <> form
  1835. R$*<@[$+]>$*        $#tcp$@[$2]$:$1@[$2]$3        numeric internet spec
  1836.  
  1837. # arrange for local names to be fully qualified
  1838. R$*<$+.ARPA.LOCAL>$*    $1<$2.ARPA>$3            because ARPA is a host
  1839.  
  1840. # now delete the local info
  1841. R$*<$*$=w.LOCAL>$*    $1<$2>$4            thishost.LOCAL
  1842. R$*<$*$=w.ARPA>$*    $1<$2>$4            thishost.ARPA
  1843. R$*<$*$=w.UUCP>$*    $1<$2>$4            thishost.UUCP
  1844. R$*<$*$=w>$*        $1<$2>$4            thishost
  1845. R$*<$*.>$*        $1<$2>$3            drop trailing dot
  1846. R<@>:$*            $@$>0$1                retry after route strip
  1847. R$*<@>            $@$>0$1                strip null trash & retry
  1848.  
  1849. ##################################
  1850. #  End of ruleset zero preamble  #
  1851. ##################################
  1852.  
  1853.  
  1854. ################################################
  1855. ###  Machine dependent part of ruleset zero  ###
  1856. ################################################
  1857.  
  1858. # Do host routing
  1859.  
  1860. R$+<@$=w.$=D>    $#local$:$1    If local host, deliver
  1861. R$+<@$=w.$D>    $#local$:$1    If local host, deliver
  1862. R$+<@$=w>    $#local$:$1    If local host, deliver
  1863.  
  1864. # Do UUCP delivery for known UUCP sites
  1865. R<@$=W.UUCP>$+        $#uucp$@$1$:$2            @host.UUCP: ...
  1866. R$+<@$=W.UUCP>        $#uucp$@$2$:$1            user@host.UUCP
  1867. R$+<@$-.UUCP>        $:$1<@$2.ARPA>            if not uucp, try net
  1868.  
  1869. # resolve ARPA names we can handle locally
  1870. R$*<@$-.ARPA>$*        $#tcp$@$2$:$1<@$2.ARPA>$3    remove ARPA domain
  1871. R$*<@$+>$*        $#tcp$@$2$:$1<@$2>$3        deliver w/ domain
  1872.  
  1873. # catch whatever may have fallen thru the cracks.
  1874. R$+%$+            $:$>28$1%$2            if it still has @ or %,
  1875. R$+@$+            $:$>28$1@$2             then retry after doing
  1876. R$+<@$+>        $@$>0$1<@$2>             simple re-canon.
  1877.  
  1878. # remaining names must be local
  1879. R$+            $#local$:$1            everything else
  1880.  
  1881. ############################################################
  1882. ############################################################
  1883. #####
  1884. #####        Local and Program Mailer specification
  1885. #####
  1886. #####        @(#)localm.m4    4.1        7/25/83
  1887. #####
  1888. ############################################################
  1889. ############################################################
  1890.  
  1891. Mlocal,    P=/bin/mail, F=lsDFMmn, S=10, R=20, A=mail -d $u
  1892.  
  1893. # 4.3 should be:
  1894. #Mlocal,    P=/bin/mail, F=rlsDFMmn, S=10, R=20, A=mail -d $u
  1895.  
  1896. Mprog,    P=/bin/sh,   F=lsDFMe,   S=10, R=20, A=sh -c $u
  1897.  
  1898. S10
  1899. R@            MAILER-DAEMON            errors to mailer-daemon
  1900.  
  1901. ############################################################
  1902. ############################################################
  1903. #####
  1904. #####        Arpanet TCP Mailer specification
  1905. #####
  1906. #####        @(#)tcpm.m4    4.1        7/25/83
  1907. #####
  1908. ############################################################
  1909. ############################################################
  1910.  
  1911. Mtcp,    P=[IPC], F=msDFMueXL, S=14, R=14, A=IPC $h, E=\r\n
  1912.  
  1913. # 4.3 version is:
  1914. #Mtcp,    P=[IPC], F=mDFMueXL, S=14, R=14, A=IPC $h, E=\r\n
  1915.  
  1916. S14
  1917.  
  1918. # pass <route-addr>'s through
  1919. R<@$+>$*        $@<@$1>$2            resolve <route-addr>
  1920.  
  1921. # map colons to dots everywhere.....
  1922. R$*:$*            $1.$2                map colons to dots
  1923.  
  1924. # handle the simple case....
  1925. R$+<@$-.ARPA>        $@$1<@$2.ARPA>            user@host.ARPA
  1926.  
  1927. # output local hosts in user%host@mimsy syntax
  1928. R$+<@LOCAL>        $@$1<@$A>            local names
  1929. R$+<@$+.LOCAL>        $@$1%$2<@$A>            local hosts
  1930.  
  1931. # handle other external cases
  1932. R$+<@$->        $@$1<@$2>            no .ARPA on simple names
  1933. R$+<@$+.$-.ARPA>    $@$1%$2<@$3.ARPA>        approximate something
  1934. R$+<@[$+]>        $@$1<@[$2]>            already ok
  1935.  
  1936. # convert remaining addresses to old format and externalize appropriately
  1937. R$+            $:$>5$1                => old format
  1938. R$-:$+            $@$1.$2<@$A>            convert berk hosts
  1939. R$+<@$+>        $@$1<@$2>            don't pessmize
  1940. R$+            $:$1<@$w.$D>            tack on our hostname
  1941.  
  1942.  
  1943. #####################################################
  1944. #  General code to convert back to old style names  #
  1945. #####################################################
  1946. S5
  1947.  
  1948. R$+<@$-.LOCAL>        $2:$1                u@h.LOCAL => h:u
  1949. R$+<@$-.UUCP>        $2!$1                u@host.UUCP => host!u
  1950. R$+@$+.ARPA        $1@$2                u@host.ARPA => u@host
  1951.  
  1952.  
  1953. Muucp,    P=/usr/bin/uux, F=sDFMhuU, S=13, R=23, M=100000,
  1954.     A=uux - -r $h!rmail ($u)
  1955.  
  1956. # 4.3 version is:
  1957. #Muucp,    P=/usr/bin/uux, F=sDFMmhuU, S=13, R=23, M=100000,
  1958. #    A=uux - -r -z -a$g $h!rmail ($u)
  1959.  
  1960. S13
  1961. R$+            $:$>5$1                convert to old style
  1962. R$=w!$+            $2                strip local name
  1963. R$*<@$->$*        $1<@$2.ARPA>$3            resolve abbreviations
  1964. R$+            $:$U!$1                stick on our host name
  1965. # R$=w!$=R:$+        $:$1!$3                ucbvax!ucbvax:xxx
  1966.  
  1967. S23
  1968. R$+            $:$>5$1                convert to old style
  1969. R$*<@$->$*        $1<@$2.ARPA>$3            resolve abbreviations
  1970.  
  1971. #
  1972. # S6 - Fully qualify all addresses.
  1973. #
  1974. # This ruleset is the last thing that Ruleset 3 calls before returning.
  1975. # it fully qualifies all addresses by making sure that the proper host
  1976. # and domain names are present.  It handles domainifying, mail host
  1977. # routing, and UUCP, csnet, and bitnet routing in the following way:
  1978. #
  1979. # 1) if the address is for an account on another machine on the local
  1980. #    network, it appends the appropriate host of the account.
  1981. # 2) local accounts have the local hostname added, and all local
  1982. #    network machines have the network domain appended.
  1983. # 3) destinations that are handled by relays, i.e. csnet and bitnet
  1984. #    domains, are forwarded to the correct relay machine.
  1985. # 4) addresses destined for a UUCP host have the explicit route
  1986. #    to that host added.
  1987. # 5) any remaining addresses without domains are assumed to be
  1988. #    ARPAnet hosts.
  1989.  
  1990. S6
  1991.  
  1992. # source routing - don't process address at all
  1993.  
  1994. R<@$-.$+>:$*        $@<@$1.$2>:$3
  1995. R<@$*>:$*        $@<@$1.arpa>:$2
  1996.  
  1997. # Handle special hosts.  (i.e. Hosts that need special handling,
  1998. #  such as broken connections, or overriding paths.
  1999.  
  2000. R$*<@$=S$*>        $>28$1%$&2    match on hostname only, ignoring domain
  2001.  
  2002. # local
  2003.  
  2004. R$+<@$=w.$=D>        $:$>29$1    remove all local hosts,
  2005. R$+<@$=w.$D>        $:$>29$1      with any real local
  2006. R$+<@$=w>        $:$>29$1      domain.
  2007.  
  2008. R$*            $:$>28$1    put back in canonical
  2009.  
  2010. # expand mailhosts
  2011. R$=H            $:$>28$&1    modify to mailhost address
  2012.  
  2013. R$-            $@$1<@$w.$D>    if no host, then local (fully qual)
  2014.  
  2015. # add local domain if needed
  2016. R$+<@$=L>        $@$1<@$&2.$D>    if local net host, use local domain
  2017. R$+<@$=L.$=D>        $@$1<@$&2.$D>    if local net host, use local domain
  2018.  
  2019. # do relayed domain
  2020. R$*<@$=C>        $:$1<@$&2.CSNET>    add domain to csnet sites
  2021. R$*<@$+.$=R>        $@$1%$2.$3<@$&3>    if relayed domain, use relay
  2022.  
  2023. # ARPAize appropriate hosts
  2024. R$+<@$=X>        $@$1<@$2.ARPA>        if uucp and arpa, use arpa
  2025.  
  2026. # route known UUCP hosts
  2027. R$+<@$=P>        $:$>29$&2!$1        if unknown but UUCP, use route
  2028. R$+<@$=P.UUCP>        $:$>29$&2!$1        if known but UUCP, use route
  2029.  
  2030. # add ARPA domain to domainless hosts
  2031.  
  2032. R$*<@$->        $@$1<@$2.ARPA>        If still domainless, then ARPA
  2033. R$*<$*>            $@$1<$2>        Return if canonical
  2034.  
  2035. R$*!!$*            $1!$2            Eliminate all double-bangs
  2036. R$-!$+            $@$2<@$1.UUCP>        convert non-can. UUCP to canon.
  2037.  
  2038. # S29 - recursively remove all local host names with either the proper
  2039. #    domain, an ARPA domain, or no domain.
  2040.  
  2041. S29
  2042.  
  2043. R$+@$=w.$=D        $@$>29$1
  2044. R$+@$=w.$D        $@$>29$1
  2045. R$+@$=w            $@$>29$1
  2046.  
  2047. R$+%$=w.$=D        $@$>29$1
  2048. R$+%$=w.$D        $@$>29$1
  2049. R$+%$=w            $@$>29$1
  2050.  
  2051. R$=w!$+            $@$>29$2
  2052.  
  2053. # convert any non-canonical to canonical
  2054.  
  2055. S28
  2056. R$*<@$*>        $@$1<@$2>        Already canonical, accept
  2057.  
  2058. R$*%$*            $1@$2            Convert all %'s to @'s
  2059. R$*@$*@$*        $1%$2@$3        Convert all but last back
  2060.  
  2061. R$*@$*            $@$1<@$2>        make into canonical
  2062. //go.sysin dd *
  2063. if [ `wc -c < mimsy.cf` != 13094 ]; then
  2064.     made=FALSE
  2065.     /bin/echo 'error transmitting "mimsy.cf" --'
  2066.     /bin/echo 'length should be 13094, not' `wc -c < mimsy.cf`
  2067. else
  2068.     made=TRUE
  2069. fi
  2070. if [ $made = TRUE ]; then
  2071.     /bin/chmod 644 mimsy.cf
  2072.     /bin/echo -n '    '; /bin/ls -ld mimsy.cf
  2073. fi
  2074. /bin/echo 'Extracting names'
  2075. sed 's/^X//' <<'//go.sysin dd *' >names
  2076. #! /bin/csh -f
  2077. #
  2078. # names - generate a list of aliases on the current host for addresses
  2079. #    that are on the local network but NOT on the current host.
  2080. #    these will be used by the mail system so that any addresses on
  2081. #    the local network appear to be addresses local to the current
  2082. #    host.
  2083. #
  2084. #    method: all addresses on the local net are processed thru
  2085. #      getting their aliases and passwd files.
  2086. #      aliases on any machine take priority over accounts anywhere.
  2087. #      current machine takes priority over other machines.
  2088. #
  2089. # temp files:    uniq - unique names in list (for eliminating repeats)
  2090. #        list - generated list
  2091. #        tmp1,2 - intermediate processing files
  2092. #
  2093. # set the machines on the local network here (in order of priority).
  2094. set locals = (mimsy tove gymble gyre brilig)
  2095. #
  2096. set uniq = /tmp/names.u.$$ list = /tmp/names.l.$$
  2097. set tmp1 = /tmp/names.1.$$ tmp2 = /tmp/names.2.$$
  2098. cp /dev/null $list
  2099. cp /dev/null $uniq
  2100. foreach file ( /usr/lib/aliases /etc/passwd )
  2101. # process current host addresses from $file first
  2102.     awk -F: '{print $1}' < $file | grep -v "#" | grep -v '^$' | \
  2103.         sort | uniq> $tmp1
  2104. # put current host addresses into uniq file ONLY.  That way they won't be
  2105. # generated from another machine, and the mail system will get them itself
  2106. # from local files.
  2107.     cat $tmp1 $uniq | sort -o $uniq
  2108.     foreach host ( $locals )
  2109.         set work = tmp/$host.$file:t
  2110.         rcp ${host}:${file} $work
  2111. # get name from file, ignoring comments and blank lines
  2112.         awk -F: '{print $1}' <$work | grep -v "#" | \
  2113.         grep -v '^$' | sort | uniq > $tmp1
  2114. # get only names that haven't already been used (i.e. $tmp1 - $uniq)
  2115.         comm -13 $uniq $tmp1 > $tmp2
  2116. # add new names to list with host, and to unique names list
  2117.         awk '{print $1 " " $1 "@'$host'" }' < $tmp2 >> $list
  2118.         cat $tmp2 $uniq | sort -o $uniq
  2119.     end
  2120. end
  2121. sort $list
  2122. rm -f $uniq $list $tmp1 $tmp2
  2123. //go.sysin dd *
  2124. if [ `wc -c < names` != 1834 ]; then
  2125.     made=FALSE
  2126.     /bin/echo 'error transmitting "names" --'
  2127.     /bin/echo 'length should be 1834, not' `wc -c < names`
  2128. else
  2129.     made=TRUE
  2130. fi
  2131. if [ $made = TRUE ]; then
  2132.     /bin/chmod 755 names
  2133.     /bin/echo -n '    '; /bin/ls -ld names
  2134. fi
  2135.  
  2136.