home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume4 / uumail3 / part2 / alias.c next >
Encoding:
C/C++ Source or Header  |  1986-11-30  |  7.7 KB  |  363 lines
  1. #include "uuconf.h"
  2. static char rcsid[] = "$Header: alias.c,v 3.0 86/03/14 12:04:41 sob RELEASE_3 $";
  3. /***************************************************************************
  4. This work in its current form is Copyright 1986 Stan Barber
  5. with the exception of opath, gethostname and the original getpath which
  6. as far as I know are in the Public Domain. This software may be distributed
  7. freely as long as no profit is made from such distribution and this notice
  8. is reproducted in whole.
  9. ***************************************************************************
  10. This software is provided on an "as is" basis with no guarantee of 
  11. usefulness or correctness of operation for any purpose, intended or
  12. otherwise. The author is in no way liable for this software's performance
  13. or any damage it may cause to any data of any kind anywhere.
  14. ***************************************************************************/
  15. /* These routines based in part on the aliasing facility of MH Version 1.7 */
  16. /* $Log:    alias.c,v $
  17.  * Revision 3.0  86/03/14  12:04:41  sob
  18.  * Release of 3/15/86 --- 3rd Release
  19.  * 
  20.  * Revision 1.10  86/03/14  11:57:13  sob
  21.  * updated copyright
  22.  * 
  23.  * Revision 1.9  86/03/11  11:28:40  sob
  24.  * Added Copyright Notice
  25.  * 
  26.  * Revision 1.8  86/03/03  17:16:39  sob
  27.  * Added fixes provided by desint!geoff.
  28.  * Stan
  29.  * 
  30.  * Revision 1.7  86/02/26  03:07:20  sob
  31.  * This forward method seems to work. It is a bit awkward, but it does seem
  32.  * to work. We will freeze the release here.
  33.  * 
  34.  * Revision 1.6  86/02/24  12:46:31  sob
  35.  * Fixed some problems with .forward. Still not completely correct, but better.
  36.  * Stan
  37.  * 
  38.  * Revision 1.5  86/02/23  23:48:50  sob
  39.  * This version contains the first attempt to make .forwards work.
  40.  * Stan
  41.  * 
  42.  * Revision 1.4  86/02/23  23:01:12  sob
  43.  * This version will correctly make note of programs that can have output
  44.  * of uumail directly piped into (in place of mail or uux).
  45.  * 
  46.  * Revision 1.3  86/02/18  01:56:12  sob
  47.  * MH aliasing facility has been installed. Now comes time to test.
  48.  * Stan
  49.  * 
  50.  * Revision 1.2  86/02/17  18:42:47  sob
  51.  * First update to add linked list of addresses. Real aliasing to be
  52.  * added next.
  53.  * 
  54.  * Revision 1.1  86/02/10  16:54:12  sob
  55.  * Initial revision
  56.  * 
  57.  *
  58.  */
  59. #ifdef NOALIAS
  60. char *
  61. alias()
  62. {
  63.     return;
  64. }
  65. #else
  66. EXTERN struct mailname addrlist;
  67. #define GROUP "/etc/group"
  68. char *termptr;
  69.  
  70.  
  71. /* Conditional free -- perform a free call if the address passed
  72.  * is in free storage;  else NOP
  73.  */
  74.  
  75.  
  76. cndfree(addr)
  77. char *addr;
  78. {
  79.     extern char end;
  80.  
  81.     if(addr >= &end) free(addr);
  82. }
  83.  
  84. uleq(c1, c2)
  85. register char *c1, *c2;
  86. {
  87.     register int c;
  88.  
  89.     while(c = *c1++)
  90.         if((c|040) != (*c2|040))
  91.             return(0);
  92.         else
  93.             c2++;
  94.     return(*c2 == 0);
  95. }
  96.  
  97. char *parse(ptr, buf)
  98. register char *ptr;
  99. char *buf;
  100. {
  101.     register char *cp;
  102.  
  103.     cp = buf;
  104.     while(isspace(*ptr) || *ptr == ',' || *ptr == ':')
  105.         ptr++;
  106.     while(isalnum(*ptr) || *ptr == '/' || *ptr == '-' || *ptr == '.' || *ptr == '!' || *ptr == '@' || *ptr == '%')
  107.         *cp++ = *ptr++;
  108.     if(cp == buf) {
  109.         switch(*ptr) {
  110.         case '<':
  111.         case '|':
  112.         case '=':
  113.             *cp++ = *ptr++;
  114.         }
  115.     }
  116.     *cp = 0;
  117.     if(cp == buf)
  118.         return 0;
  119.     termptr = ptr;
  120.     return buf;
  121. }
  122. char *
  123. advance(ptr)
  124.     register char *ptr;
  125. {
  126.     return(termptr);
  127. }
  128.  
  129. alias()
  130. {
  131.     register char *cp, *pp;
  132.     register struct mailname *lp;
  133.     char line[256], pbuf[64];
  134.     FILE *a;
  135.  
  136.     if((a = fopen(AliasFile, "r")) == NULL)
  137.         return;
  138.     while(fgets(line, sizeof line, a)) {
  139.         if(line[0] == ';' || line[0] == '\n')   /* Comment Line */
  140.             continue;
  141.         if((pp = parse(line, pbuf)) == NULL) {
  142.         oops:       fprintf(stderr, "Bad alias file %s\n", AliasFile);
  143.             fprintf(stderr, "Line: %s", line);
  144.             exit(EX_OSFILE);
  145.         }
  146.         for(lp = &addrlist; lp->m_next; lp = lp->m_next) {
  147.             if(aleq(lp->m_next->m_name, pp)) {
  148.                 remove(lp);
  149.                 if(!(cp = advance(line)) ||
  150.                    !(pp = parse(cp, pbuf)))
  151.                     goto oops;
  152.                 switch(*pp) {
  153.                 case '<':       /* From file */
  154.                     cp = advance(cp);
  155.                     if((pp = parse(cp, pbuf)) == NULL)
  156.                         goto oops;
  157.                     addfile(pp);
  158.                     break;
  159.                 case '=':       /* UNIX group */
  160.                     cp = advance(cp);
  161.                     if((pp = parse(cp, pbuf)) == NULL)
  162.                         goto oops;
  163.                     addgroup(pp);
  164.                     break;
  165.                    case '|':    /* pipe through a program */
  166.                     cp = advance(cp);
  167.                     if ((pp=parse(cp,pbuf)) == NULL)
  168.                         goto oops;
  169.                     addprgm(pp);
  170.                     break;
  171.                 default:        /* Simple list */
  172.                     for(;;) {
  173.                         insert(pp);
  174.                         if(!(cp = advance(line)) ||
  175.                            !(pp = parse(cp, pbuf)))
  176.                             break;
  177.                     }
  178.                 }
  179.                 break;
  180.             }
  181.         }
  182.     }
  183. }
  184.  
  185.  
  186.  
  187.  
  188.  
  189. addfile(file)
  190.     char *file;
  191. {
  192.     register char *cp, *pp;
  193.     char line[128], pbuf[64];
  194.     FILE *f;
  195. #ifdef DEBUG
  196.     if (Debug >3) printf("addfile(%s)\n", file);          
  197. #endif
  198.     if((f = fopen(file, "r")) == NULL) {
  199.         fprintf(stderr, "Can't open ");
  200.         perror(file);
  201.         exit(EX_OSFILE);
  202.     }
  203.     while(fgets(line, sizeof line, f)) {
  204.         cp = line;
  205.         while(pp = parse(cp, pbuf)) {
  206.             insert(pp);
  207.             cp = advance(cp);
  208.         }
  209.     }
  210.     fclose(f);
  211. }
  212.  
  213. addgroup(group)
  214.     char *group;
  215. {
  216.     register char *cp, *pp;
  217.     int found = 0;
  218.     char line[128], pbuf[64], *rindex();
  219.     FILE *f;
  220. #ifdef DEBUG
  221.     if(Debug>3)printf("addgroup(%s)\n", group);        
  222. #endif
  223.     if((f = fopen(GROUP, "r")) == NULL) {
  224.         fprintf(stderr, "Can't open ");
  225.         perror(GROUP);
  226.         exit(EX_OSFILE);
  227.     }
  228.     while(fgets(line, sizeof line, f)) {
  229.         pp = parse(line, pbuf);
  230.         if(strcmp(pp, group) == 0) {
  231.             cp = rindex(line, ':');
  232.             while(pp = parse(cp, pbuf)) {
  233.                 insert(pp);
  234.                 cp = advance(cp);
  235.             }
  236.             found++;
  237.         }
  238.     }
  239.     if(!found) {
  240.         fprintf(stderr, "Group: %s non-existent\n", group);
  241.         exit(EX_DATAERR);
  242.     }
  243.     fclose(f);
  244. }
  245.  
  246. addprgm(name)
  247. char *name;
  248. {
  249.     register struct mailname *mp;
  250.     char * getcpy();
  251.     for(mp = &addrlist; mp->m_next; mp = mp->m_next)
  252.         if(uleq(name, mp->m_next->m_name))
  253.             return;         /* Don't insert existing name! */
  254.     mp->m_next = (struct mailname *) malloc(sizeof *mp->m_next);
  255.     mp = mp->m_next;
  256.     mp->m_next = 0;
  257.     mp->m_name = getcpy(name);
  258.     mp->m_pipe = 1;
  259. }    
  260. remove(mp)              /* Remove NEXT from argument node! */
  261.     register struct mailname *mp;
  262. {
  263.     register struct mailname *rp;
  264.  
  265.     rp = mp->m_next;
  266.     mp->m_next = rp->m_next;
  267.     cndfree(rp->m_name);
  268.     cndfree(rp);
  269. }
  270. insert(name)
  271.     char *name;
  272. {
  273.     register struct mailname *mp;
  274.     char *getcpy();
  275. #ifdef DEBUG
  276.     if(Debug>3)  printf("insert(%s)\n", name);   
  277. #endif
  278.     for(mp = &addrlist; mp->m_next; mp = mp->m_next)
  279.         if(uleq(name, mp->m_next->m_name))
  280.             return;         /* Don't insert existing name! */
  281.     mp->m_next = (struct mailname *) malloc(sizeof *mp->m_next);
  282.     mp = mp->m_next;
  283.     mp->m_next = 0;
  284.     mp->m_pipe=0;
  285.     mp->m_name = getcpy(name);
  286. }
  287.  
  288. aleq(string, aliasent)
  289.     register char *string, *aliasent;
  290. {
  291.     register int c;
  292.  
  293.     while(c = *string++)
  294.         if(*aliasent == '*')
  295.             return 1;
  296.         else if((c|040) != (*aliasent|040))
  297.             return(0);
  298.         else
  299.             aliasent++;
  300.     return(*aliasent == 0 | *aliasent == '*');
  301. }
  302.  
  303. forward()
  304. {
  305.  
  306.     FILE * fp;
  307.     struct passwd * pwd;
  308.     struct mailname *lp;
  309.     char forwardfile[BUFSIZ];
  310.     extern struct passwd * getpwnam ();
  311.  
  312.     for (lp = addrlist.m_next;lp;lp=lp->m_next){
  313.     if (index(lp->m_name,'!')) continue; /* not local */
  314.     if (index(lp->m_name,'@')) continue; /* ditto */
  315.     if (index(lp->m_name,'%')) continue; /* ditto */
  316.     if (index(lp->m_name,'/')) continue; /* filename */
  317.     if ((pwd = getpwnam(lp->m_name)) == NULL) continue;
  318.     sprintf(forwardfile,"%s/.forward",pwd->pw_dir);
  319.     if((fp=fopen(forwardfile,"r")) != NULL){
  320.             strcpy(lp->m_name,"");
  321.             addfile(forwardfile);
  322.         fclose(fp);
  323.         }
  324.     }
  325. }
  326. #endif
  327.  
  328.  
  329. /* add names to the address list */
  330.  
  331.  
  332. add(name, list)
  333. char *name;
  334. struct mailname *list;
  335. {
  336.     register struct mailname *mp;
  337.     char *getcpy();
  338.  
  339.     for(mp = list; mp->m_next; mp = mp->m_next)
  340.         ;
  341.     mp->m_next = (struct mailname *) malloc(sizeof *mp->m_next);
  342.     mp = mp->m_next;
  343.     mp->m_next = 0;
  344.     mp->m_pipe = 0;
  345.     mp->m_name = getcpy(name);
  346. }
  347.  
  348. char *getcpy(str)
  349. {
  350.     register char *cp;
  351.  
  352.     cp = (char *) malloc(strlen(str) + 1);
  353.     strcpy(cp, str);
  354.     return(cp);
  355. }
  356.  
  357.  
  358.  
  359.  
  360.  
  361.  
  362.  
  363.