home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / APPS / elm.lzh / ELM / SRC / DOMAINS.C < prev    next >
C/C++ Source or Header  |  1991-01-11  |  9KB  |  310 lines
  1.  
  2. static char rcsid[] = "@(#)$Id: domains.c,v 4.1.1.1 90/07/12 23:19:14 syd Exp $";
  3.  
  4. /*******************************************************************************
  5.  *  The Elm Mail System  -  $Revision: 4.1.1.1 $   $State: Exp $
  6.  *
  7.  *             Copyright (c) 1986, 1987 Dave Taylor
  8.  *             Copyright (c) 1988, 1989, 1990 USENET Community Trust
  9.  *******************************************************************************
  10.  * Bug reports, patches, comments, suggestions should be sent to:
  11.  *
  12.  *    Syd Weinstein, Elm Coordinator
  13.  *    elm@DSI.COM            dsinc!elm
  14.  *
  15.  *******************************************************************************
  16.  * $Log:    domains.c,v $
  17.  * Revision 4.1.1.1  90/07/12  23:19:14  syd
  18.  * Make domain name checking case independent
  19.  * From: Syd, reported by Steven Baur
  20.  * 
  21.  * Revision 4.1  90/04/28  22:42:44  syd
  22.  * checkin of Elm 2.3 as of Release PL0
  23.  * 
  24.  *
  25.  ******************************************************************************/
  26.  
  27. /** This file contains all the code dealing with the expansion of 
  28.     domain based addresses in Elm.  It uses the file "domains" as
  29.     defined in the sysdefs.h file.
  30.  
  31.     From a file format and idea in "uumail" - designed by Stan Barber.
  32. **/
  33.  
  34. #if defined(OPTIMIZE_RETURN) || !defined(DONT_TOUCH_ADDRESSES)
  35.  
  36. #include <ctype.h>
  37.  
  38. #include "headers.h"
  39.  
  40. #ifdef BSD
  41. # undef toupper
  42. # undef tolower
  43. #endif
  44.  
  45. /** define the various characters that we can encounter after a "%" sign
  46.     in the template file...
  47. **/
  48.  
  49. #define USERNAME    'U'    /* %U = the name of the remote user */
  50. #define RMTMNAME    'N'    /* %N = the remote machine name     */
  51. #define FULLNAME    'D'    /* %D = %N + domain info given      */
  52. #define NPATH        'R'    /* %R = path to %N from pathalias   */
  53. #define PPATH        'P'    /* %P = path to 'P' from pathalias  */
  54. #define OBSOLETE    'S'    /* %S = (used to be suffix string)  */
  55.  
  56. /** and finally some characters that are allowed in user/machine names **/
  57.  
  58. #define okay_others(c)    (c == '-' || c == '^' || c == '$' || c == '_')
  59.  
  60. /** and some allowed ONLY in the username field **/
  61.  
  62. #define special_chars(c)    (c == '%' || c == ':')
  63.  
  64. char *find_path_to(), *expand_domain(), *match_and_expand_domain();
  65. char *strcpy(), *strcat(), *strtok();
  66. void rewind();
  67.           
  68. open_domain_file()
  69. {
  70.     if ((domainfd = fopen(domains, "r")) == NULL) {
  71.       dprint(2, (debugfile,"Warning: can't open file %s as domains file\n", 
  72.         domains));
  73.     }
  74.     else {
  75.       dprint(3, (debugfile, 
  76.             "Opened '%s' as the domain database\n\n", domains));
  77.     }
  78.     
  79.     /* if it fails it'll instantiate domainfd to NULL which is
  80.        exactly what we want to have happen!! */
  81. }
  82.  
  83. char *expand_domain(buffer)
  84. char *buffer;
  85. {
  86.     /** Expand the address 'buffer' based on the domain information, 
  87.         if any.  Returns NULL if it can't expand it for any reason.
  88.     **/
  89.  
  90.     char name[NLEN], address[NLEN], domain[NLEN];
  91.     char *match_and_expand_domain();
  92.  
  93.     if (domainfd == NULL) return(NULL);    /* no file present! */
  94.  
  95.     if (explode(buffer, name, address, domain)) 
  96.       return( match_and_expand_domain(domain, name, address) );
  97.     else {    /* invalid format - not "user@host.domain" */
  98.       dprint(2,  (debugfile,
  99.          "Invalid format for domain expansion: %s (expand_domain)\n", 
  100.            buffer));
  101.       return(NULL);
  102.     }
  103. }    
  104.  
  105. int
  106. explode(buffer, name, address, domain)
  107. char *buffer, *name, *address, *domain;
  108. {
  109.     /** Break buffer, if in format name@machine.domain, into the
  110.         component parts, otherwise return ZERO and don't worry
  111.         about the values of the parameters!
  112.     **/
  113.     
  114.     register int i, j = 0;
  115.  
  116.     /** First get the name... **/
  117.  
  118.     for (i=0; buffer[i] != '@'; i++) {
  119.       if (! isalnum(buffer[i]) && ! okay_others(buffer[i]) && ! 
  120.         special_chars(buffer[i]))
  121.         return(0);            /* invalid character in string! */
  122.       name[i] = buffer[i];
  123.     }
  124.  
  125.     name[i++] = '\0';
  126.  
  127.     /** now let's get the machinename **/
  128.  
  129.     while (buffer[i] != '.') {
  130.       if (! isalnum(buffer[i]) && ! okay_others(buffer[i]))
  131.          return(0);            /* invalid character in string! */
  132.       address[j++] = buffer[i++];
  133.     }
  134.     address[j] = '\0';
  135.  
  136.     j = 0;
  137.  
  138.     /** finally let's get the domain information (there better be some!) **/
  139.  
  140.     while (buffer[i] != '\0') {
  141.       if (! isalnum(buffer[i]) && ! okay_others(buffer[i]) && 
  142.             buffer[i] != '.')
  143.         return(0);              /* an you fail again, bozo! */
  144.       domain[j++] = toupper(buffer[i]);
  145.       i++;
  146.     }
  147.  
  148.     domain[j] = '\0';
  149.     
  150.     return(j);        /* if j == 0 there's no domain info! */
  151. }
  152.         
  153. char *match_and_expand_domain(domain, name, machine)
  154. char *domain, *name, *machine;
  155. {
  156.     /** Given the domain, try to find it in the domain file and
  157.            if found expand the entry and return the result as a 
  158.         character string...
  159.     **/
  160.  
  161.     static char address[SLEN];
  162.     char   buffer[SLEN], domainbuff[NLEN];
  163.     char   field1[NLEN], field2[NLEN], field3[NLEN];
  164.     char   *path, *template, *expanded, *mydomain;
  165.     int    matched = 0, in_percent = 0;
  166.     register int j = 0;
  167.  
  168.     address[j] = '\0';
  169.  
  170.     domainbuff[0] = '\0';
  171.     mydomain = (char *) domainbuff;            /* set up buffer etc */
  172.  
  173.     do { 
  174.       rewind(domainfd);                   /* back to ground zero! */
  175.  
  176.       if (strlen(mydomain) > 0) {           /* already in a domain! */
  177.         mydomain++;                       /* skip leading '.' */
  178.         while (*mydomain != '.' && *mydomain != ',') 
  179.           mydomain++;                   /* next character   */
  180.         if (*mydomain == ',')
  181.           return (NULL);                /* didn't find domain!  */
  182.       }
  183.       else
  184.         sprintf(mydomain, "%s,", domain);        /* match ENTIRELY! */
  185.  
  186.     /* whip through file looking for the entry, please... */
  187.  
  188.     while (fgets(buffer, SLEN, domainfd) != NULL) {
  189.       if (buffer[0] == '#')                  /* skip comments */
  190.         continue;
  191.       if (strincmp(buffer, mydomain, strlen(mydomain)) == 0) { /* match? */
  192.          matched++;    /* Gotcha!  Remember this momentous event! */
  193.          break;
  194.       }
  195.     }
  196.  
  197.     if (! matched) 
  198.        continue;        /* Nothing.  Not a sausage!  Step through! */
  199.  
  200.     /** We've matched the domain! **/
  201.  
  202.     no_ret(buffer);
  203.  
  204.     (void) strtok(buffer, ",");    /* skip the domain info */
  205.  
  206.     strcpy(field1, strtok(NULL, ","));    /* fun         */
  207.     strcpy(field2, strtok(NULL, ","));    /*    stuff     */
  208.     strcpy(field3, strtok(NULL, ","));    /*       eh?    */
  209.     
  210.     path = (char *) NULL;
  211.  
  212.     /* now we merely need to figure out what permutation this is!
  213.       
  214.            Fields are null if they have only a blank in them or are null.
  215.            If fields 2 and 3 are null, use field 1 as the template.
  216.             --else--
  217.            If field 3 is null and 2 is not, use field 2 as the template.
  218.             --else--
  219.            Field 3 is the template. */
  220.          
  221.  
  222.     if (strcmp(field3," ") == 0 || field3[0] == '\0'){
  223.       if (strcmp(field2," ") == 0 || field2[0] == '\0')
  224.         template = (char *) field1;
  225.       else {
  226.         path     = (char *) field1;
  227.         template = (char *) field2;
  228.       }
  229.     }
  230.     else {
  231.       path     = (char *) field1;
  232.       template = (char *) field3;
  233.     }
  234.     dprint(1, (debugfile,
  235.       "-> %s\n-> %s\n-> %s\n", field1, field2, field3));
  236.     dprint(1, (debugfile,
  237.       "Path-> %s\nTemplate-> %s\n", path, template));
  238.  
  239.     if (strlen(path) > 0 && path[0] == '>') 
  240.        path++;    /* skip the '>' character, okay? */
  241.  
  242.     j = 0;             /* address is zero, right now, right?? */
  243.     address[j] = '\0';          /* make sure string is too! */
  244.  
  245.     for (; *template; template++) {
  246.       if (*template == '%') {
  247.         if (! in_percent)               /* just hit a NEW percent! */
  248.           in_percent = 1;
  249.         else {          /* just another percent sign on the wall... */
  250.           address[j++] = '%';
  251.           address[j] = '\0';             /* ALWAYS NULL terminate */
  252.           in_percent = 0;
  253.         }
  254.       }
  255.       else if (in_percent) {           /* Hey! a real command string */
  256.         in_percent = 0;
  257.         switch (*template) {
  258.           case USERNAME: strcat(address, name);        break;
  259.           case RMTMNAME: strcat(address, machine);        break;
  260.           case FULLNAME: strcat(address, machine);
  261.                  strcat(address, domain);        break;
  262.           case NPATH   : 
  263.  
  264.          if ((expanded = find_path_to(machine, FALSE)) == NULL) {
  265.             dprint(3, (debugfile,
  266.                 "\nCouldn't expand system path '%s' (%s)\n\n",
  267.                 machine, "domains"));
  268.                 error1("Couldn't find a path to %s!", machine);
  269.                 sleep(2);
  270.                 return(NULL);    /* failed!! */
  271.              }
  272.              strcat(address, expanded);    /* isn't this fun??? */
  273.  
  274.              break;
  275.  
  276.           case PPATH   : 
  277.  
  278.          if ((expanded = find_path_to(path, FALSE)) == NULL) {
  279.             dprint(3, (debugfile,
  280.             "\nCouldn't expand system path '%s' (%s)\n\n",
  281.             path, "domains"));
  282.                 error1("Couldn't find a path to %s!", path);
  283.                 sleep(2);
  284.                 return(NULL);    /* failed!! */
  285.              }
  286.              strcat(address, expanded);    /* isn't this fun??? */
  287.  
  288.              break;
  289.  
  290.           case OBSOLETE:    /* fall through.. */
  291.           default      : dprint(1, (debugfile,
  292.          "\nError: Bad sequence in template file for domain '%s': %%%c\n\n",
  293.             domain, *template));
  294.         }
  295.         j = strlen(address);
  296.       }
  297.       else {
  298.         address[j++] = *template;
  299.         address[j] = '\0';            /* null terminate */
  300.       }
  301.     }    
  302.  
  303.     address[j] = '\0';
  304.  
  305.     } while (strlen(address) < 1);
  306.  
  307.     return( (char *) address);
  308. }
  309. #endif
  310.