Return to hosts.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / mh / mts / sendmail

Annotation of 43BSD/contrib/mh/mts/sendmail/hosts.c, revision 1.1.1.1

1.1       root        1: /* hosts.c - find out the official name of a host */
                      2: 
                      3: /* LINTLIBRARY */
                      4: 
                      5: /* In the SendMail world, we really don't know what the valid hosts are.
                      6:    We could poke around in the sendmail.cf file, but that still isn't a
                      7:    guarantee.  As a result, we'll say that everything is a valid host, and
                      8:    let SendMail worry about it. */
                      9: 
                     10: 
                     11: #include "../h/strings.h"
                     12: #include <stdio.h>
                     13: #include "../zotnet/mts.h"
                     14: #include <ctype.h>
                     15: #ifdef BSD42
                     16: #include <netdb.h>
                     17: #endif BSD42
                     18: 
                     19: 
                     20: #define        NOTOK   (-1)
                     21: 
                     22: 
                     23: static struct host {
                     24:     char   *h_name;
                     25:     char  **h_aliases;
                     26:     struct host   *h_next;
                     27: }                   hosts;
                     28: 
                     29: char   *getcpy ();
                     30: 
                     31: /*  */
                     32: 
                     33: char   *OfficialName (name)
                     34: register char   *name;
                     35: {
                     36:     register char  *p;
                     37:     char   *q,
                     38:             site[BUFSIZ];
                     39: #ifdef BSD42
                     40:     register struct hostent *hp;
                     41: #endif BSD42
                     42:     static char buffer[BUFSIZ];
                     43:     register char **r;
                     44:     register struct host   *h;
                     45: 
                     46:     for (p = name, q = site; *p; p++, q++)
                     47:        *q = isupper (*p) ? tolower (*p) : *p;
                     48:     *q = NULL;
                     49:     q = site;
                     50: 
                     51:     if (uleq (LocalName (), site))
                     52:        return LocalName ();
                     53: 
                     54: #ifdef BSD41A
                     55:     if (rhost (&q) != NOTOK) {
                     56:        (void) strcpy (buffer, q);
                     57:        free (q);
                     58:        return buffer;
                     59:     }
                     60: #endif BSD41A
                     61: #ifdef BSD42
                     62:     sethostent (1);
                     63:     if (hp = gethostbyname (q)) {
                     64:        (void) strcpy (buffer, hp -> h_name);
                     65:        return buffer;
                     66:     }
                     67: #endif BSD42
                     68: 
                     69:     if (hosts.h_name || init_hs ())
                     70:        for (h = hosts.h_next; h; h = h -> h_next)
                     71:            if (uleq (h -> h_name, q))
                     72:                return h -> h_name;
                     73:            else
                     74:                for (r = h -> h_aliases; *r; r++)
                     75:                    if (uleq (*r, q))
                     76:                        return h -> h_name;
                     77: 
                     78:     (void) strcpy (buffer, site);
                     79:     return buffer;
                     80: }
                     81: 
                     82: /*  */
                     83: 
                     84: /* Use hostable as an exception file for those hosts that aren't on the
                     85:    Internet (listed in /etc/hosts).  These are usually PhoneNet and UUCP
                     86:    sites. */
                     87: 
                     88: 
                     89: #define        NALIASES        50
                     90: 
                     91: static int  init_hs () {
                     92:     register char  *cp,
                     93:                    *dp,
                     94:                   **q,
                     95:                   **r;
                     96:     char    buffer[BUFSIZ],
                     97:            *aliases[NALIASES];
                     98:     register struct host   *h;
                     99:     register FILE  *fp;
                    100: 
                    101:     if ((fp = fopen (hostable, "r")) == NULL)
                    102:        return 0;
                    103: 
                    104:     h = &hosts;
                    105:     while (fgets (buffer, sizeof buffer, fp) != NULL) {
                    106:        if (cp = index (buffer, '#'))
                    107:            *cp = NULL;
                    108:        if (cp = index (buffer, '\n'))
                    109:            *cp = NULL;
                    110:        for (cp = buffer; *cp; cp++)
                    111:            if (isspace (*cp))
                    112:                *cp = ' ';
                    113:        for (cp = buffer; isspace (*cp); cp++)
                    114:            continue;
                    115:        if (*cp == NULL)
                    116:            continue;
                    117: 
                    118:        q = aliases;
                    119:        if (cp = index (dp = cp, ' ')) {
                    120:            *cp = NULL;
                    121:            for (cp++; *cp; cp++) {
                    122:                while (isspace (*cp))
                    123:                    cp++;
                    124:                if (*cp == NULL)
                    125:                    break;
                    126:                if (cp = index (*q++ = cp, ' '))
                    127:                    *cp = NULL;
                    128:                else
                    129:                    break;
                    130:                if (q >= aliases + NALIASES)
                    131:                    break;
                    132:            }
                    133:        }
                    134: 
                    135:        *q = NULL;
                    136: 
                    137:        h -> h_next = (struct host *) calloc (1, sizeof *h);
                    138:        h = h -> h_next;
                    139:        h -> h_name = getcpy (dp);
                    140:        r = h -> h_aliases =
                    141:                (char **) calloc ((unsigned) (q - aliases + 1), sizeof *q);
                    142:        for (q = aliases; *q; q++)
                    143:            *r++ = getcpy (*q);
                    144:        *r = NULL;
                    145:     }
                    146: 
                    147:     (void) fclose (fp);
                    148:     return 1;
                    149: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.