Annotation of 42BSD/old/berknet/config.h, revision 1.1.1.1

1.1       root        1: /*     @(#)config.h    4.4     (Berkeley)      1/5/83  */
                      2: 
                      3: /*
                      4:        These are machine-configuration dependent
                      5:        tables.  To add a machine, be sure to update all
                      6:        these tables, add the "ifdef" entry in "mach.h",
                      7:        and add config? to gothru() in sub.c.
                      8:        For Berkeley, this file corresponds to the following network:
                      9: 
                     10:        The tables must be consistent.
                     11: 
                     12: 
                     13:        For RAND, these tables are:
                     14: 
                     15:                VAX (C) ---------GRAPHICS (A)------- TP (B)
                     16: 
                     17:        For NOSC, these tables are:
                     18: 
                     19:                   FCCMM ------ ATTS ------ MSSF ------ CCMM
                     20:                                / \
                     21:                               /   \
                     22:                              /     \
                     23:                             /       \
                     24:                OT34 ---- GATE40    ING70
                     25:                            |
                     26:                            |
                     27:                           PWB
                     28: 
                     29: 
                     30: 
                     31: */
                     32: # ifdef RAND
                     33: /* GRAPHICS = A */
                     34: char configA[] = {             /* to get to i, config[i] */
                     35:        'a','b','c',000,000,            /* a,b,c,d,e */
                     36:        000,000,000,000,000,            /* f,g,h,i,j */
                     37:        000,000,000,000,000,            /* k,l,m,n,o */
                     38:        000,000,000,000,000,            /* p,q,r,s,t */
                     39:        000,000,000,000,000,            /* u,v,w,x,y */
                     40:        000,0                           /* z */
                     41:        };
                     42: /* TP = B */
                     43: char configB[] = {             /* to get to i, config[i] */
                     44:        'a','b','a',000,000,            /* a,b,c,d,e */
                     45:        000,000,000,000,000,            /* f,g,h,i,j */
                     46:        000,000,000,000,000,            /* k,l,m,n,o */
                     47:        000,000,000,000,000,            /* p,q,r,s,t */
                     48:        000,000,000,000,000,            /* u,v,w,x,y */
                     49:        000,0                           /* z */
                     50:        };
                     51: /* VAX = C */
                     52: char configC[] = {             /* to get to i, config[i] */
                     53:        'a','a','c',000,000,            /* a,b,c,d,e */
                     54:        000,000,000,000,000,            /* f,g,h,i,j */
                     55:        000,000,000,000,000,            /* k,l,m,n,o */
                     56:        000,000,000,000,000,            /* p,q,r,s,t */
                     57:        000,000,000,000,000,            /* u,v,w,x,y */
                     58:        000,0                           /* z */
                     59:        };
                     60: /* if machtype is
                     61:        M_CC            netlpr will do lpr w/o an acct.
                     62:                        Will pre-encrypt the password.
                     63:        M_INGRES        will allow higher file lengths.
                     64:        M_OTHER         will give no unusual effects.
                     65: (when in doubt, machtype should be M_OTHER)
                     66: */
                     67: char machtype[]= {
                     68:        M_OTHER,M_OTHER,M_OTHER,0,0,    /* a,b,c,d,e */
                     69:        0, 0, 0, 0, 0,                  /* f,g,h,i,j */
                     70:        0, 0, 0, 0, 0,                  /* k,l,m,n,o */
                     71:        0, 0, 0, 0, 0,                  /* p,q,r,s,t */
                     72:        0, 0, 0, 0, 0,                  /* u,v,w,x,y */
                     73:        0, 0};                          /* z */
                     74: 
                     75: /* this is basically the default machine for each local machine */
                     76: char remtable[] = {
                     77:        'b','a','a',000,000,            /* a,b,c,d,e */
                     78:        000,000,000,000,000,            /* f,g,h,i,j */
                     79:        000,000,000,000,000,            /* k,l,m,n,o */
                     80:        000,000,000,000,000,            /* p,q,r,s,t */
                     81:        000,000,000,000,000,            /* u,v,w,x,y */
                     82:        000,0                           /* z */
                     83:        };
                     84: /* bad login names */
                     85: struct bstruct btable[] = {
                     86:        0,0 };
                     87: /* this table shows the correspondence between
                     88:    machine names like 'Cory' and their internal
                     89:    names, like 'y' */
                     90: static struct tt {
                     91:        char *bigname;
                     92:        char lname;
                     93:        } table[] = {
                     94:        "Graphics",     'a',
                     95:        "TP",           'b',
                     96:        "VAX",          'c',
                     97:        0,              0
                     98:        };
                     99: /* end of Rand definitions */
                    100: 
                    101: # endif RAND
                    102: 
                    103: # ifdef NOSC
                    104: /* Naval Ocean Systems Center */
                    105: 
                    106: /* atts (a) */
                    107: char configA[] = {             /* to get to i, config[i] */
                    108:        'a',000,'m',000,000,            /* a,b,c,d,e */
                    109:        'f','g',000,'i',000,            /* f,g,h,i,j */
                    110:        000,000,'m',000,'g',            /* k,l,m,n,o */
                    111:        'g',000,000,000,000,            /* p,q,r,s,t */
                    112:        000,000,000,000,000,            /* u,v,w,x,y */
                    113:        000,0                           /* z */
                    114:        };
                    115: 
                    116: /* ccmm (c) */
                    117: char configC[] = {             /* to get to i, config[i] */
                    118:        'm',000,'c',000,000,            /* a,b,c,d,e */
                    119:        'm','m',000,'m',000,            /* f,g,h,i,j */
                    120:        000,000,'m',000,'m',            /* k,l,m,n,o */
                    121:        'm',000,000,000,000,            /* p,q,r,s,t */
                    122:        000,000,000,000,000,            /* u,v,w,x,y */
                    123:        000,0                           /* z */
                    124:        };
                    125: 
                    126: /* ccmm (f) */
                    127: char configF[] = {             /* to get to i, config[i] */
                    128:        'a',000,'c',000,000,            /* a,b,c,d,e */
                    129:        'f','a',000,'a',000,            /* f,g,h,i,j */
                    130:        000,000,'a',000,'a',            /* k,l,a,n,o */
                    131:        'a',000,000,000,000,            /* p,q,r,s,t */
                    132:        000,000,000,000,000,            /* u,v,w,x,y */
                    133:        000,0                           /* z */
                    134:        };
                    135: 
                    136: /* mssf (m) */
                    137: char configM[] = {             /* to get to i, config[i] */
                    138:        'a',000,'c',000,000,            /* a,b,c,d,e */
                    139:        'a','a',000,'a',000,            /* f,g,h,i,j */
                    140:        000,000,'m',000,'a',            /* k,l,m,n,o */
                    141:        'a',000,000,000,000,            /* p,q,r,s,t */
                    142:        000,000,000,000,000,            /* u,v,w,x,y */
                    143:        000,0                           /* z */
                    144:        };
                    145: 
                    146: /* ingres (i) proposed */
                    147: char configI[] = {             /* to get to i, config[i] */
                    148:        'a',000,'a',000,000,            /* a,b,c,d,e */
                    149:        'a','a',000,'i',000,            /* f,g,h,i,j */
                    150:        000,000,'a',000,'a',            /* k,l,m,n,o */
                    151:        'a',000,000,000,000,            /* p,q,r,s,t */
                    152:        000,000,000,000,000,            /* u,v,w,x,y */
                    153:        000,0                           /* z */
                    154:        };
                    155: 
                    156: /* nosc-cc gateway 40 (g) */
                    157: char configG[] = {             /* to get to i, config[i] */
                    158:        'a',000,'a',000,000,            /* a,b,c,d,e */
                    159:        'a','g',000,'a',000,            /* f,g,h,i,j */
                    160:        000,000,'a',000,'g',            /* k,l,m,n,o */
                    161:        'p',000,000,000,000,            /* p,q,r,s,t */
                    162:        000,000,000,000,000,            /* u,v,w,x,y */
                    163:        000,0                           /* z */
                    164:        };
                    165: 
                    166: /* ocean tech 34 (o) */
                    167: char configO[] = {             /* to get to i, config[i] */
                    168:        'g',000,'g',000,000,            /* a,b,c,d,e */
                    169:        'g','g',000,'g',000,            /* f,g,h,i,j */
                    170:        000,000,'g',000,'o',            /* k,l,m,n,o */
                    171:        'g',000,000,000,000,            /* p,q,r,s,t */
                    172:        000,000,000,000,000,            /* u,v,w,x,y */
                    173:        000,0                           /* z */
                    174:        };
                    175: 
                    176: /* pwb at nosc (p) */
                    177: char configP[] = {             /* to get to i, config[i] */
                    178:        'g',000,'g',000,000,            /* a,b,c,d,e */
                    179:        'g','g',000,'g',000,            /* f,g,h,i,j */
                    180:        000,000,'g',000,'g',            /* k,l,m,n,o */
                    181:        'p',000,000,000,000,            /* p,q,r,s,t */
                    182:        000,000,000,000,000,            /* u,v,w,x,y */
                    183:        000,0                           /* z */
                    184:        };
                    185: 
                    186: /* this table is used by netlpr to do lpr w/o an acct
                    187:    and by net and netdaemon to do pre-emption */
                    188: /* sub.c uses the table in initdaemon to check machine
                    189:    type - errormsg may be ignored */
                    190: char machtype[]= {
                    191:        M_CC, 0,M_OTHER, 0, 0,          /* a,b,c,d,e */
                    192:        M_OTHER,M_OTHER, 0,M_INGRES, 0, /* f,g,h,i,j */
                    193:        0, 0,M_CC, 0,M_OTHER,           /* k,l,m,n,o */
                    194:        M_OTHER, 0, 0, 0, 0,            /* p,q,r,s,t */
                    195:        0, 0, 0, 0, 0,                  /* u,v,w,x,y */
                    196:        0};                             /* z */
                    197: /* this is basically the default machine for each local machine */
                    198: char remtable[] = {
                    199:        'm',000,'m',000,000,            /* a,b,c,d,e */
                    200:        'a','a',000,'a',000,            /* f,g,h,i,j */
                    201:        000,000,'a',000,'g',            /* k,l,m,n,o */
                    202:        'g',000,000,000,000,            /* p,q,r,s,t */
                    203:        000,000,000,000,000,            /* u,v,w,x,y */
                    204:        000,0                           /* z */
                    205:        };
                    206: /* bad login names */
                    207: struct bstruct btable[] = {
                    208:        "op", 'a',
                    209:        0,0 };
                    210: /* this table shows the correspondence between
                    211:    machine names like 'Cory' and their internal
                    212:    names, like 'y' */
                    213: static struct tt {
                    214:        char *bigname;
                    215:        char lname;
                    216:        } table[] = {
                    217:        "ATTS",         'a',
                    218:        "CCMM",         'c',
                    219:        "FCCMM",        'f',
                    220:        "MSSF",         'm',
                    221:        "INGRES",       'i',
                    222:        "GATEWAY",      'g',
                    223:        "OT34",         'o',
                    224:        "PWB",          'p',
                    225:        0, 0 };
                    226: 
                    227: # endif NOSC
                    228: 
                    229: # ifdef BERKELEY
                    230: /* Berkeley definitions */
                    231: 
                    232: /* Computer Center A Machine (A) */
                    233: char configA[] = {             /* to get to i, config[i] */
                    234:        'a','c','c','c','c',            /* a,b,c,d,e */
                    235:        'c','c','c','c','c',            /* f,g,h,i,j */
                    236:        'c','c','c','c','c',            /* k,l,m,n,o */
                    237:        'c',000,'c','c','c',            /* p,q,r,s,t */
                    238:        'c','c','c','c','c',            /* u,v,w,x,y */
                    239:        'c',0                           /* z */
                    240:        };
                    241: /* Computer Center B Machine (B) */
                    242: char configB[] = {             /* to get to i, config[i] */
                    243:        'e','b','e','e','e',            /* a,b,c,d,e */
                    244:        'e','e','e','e','e',            /* f,g,h,i,j */
                    245:        'e','e','e','e','e',            /* k,l,m,n,o */
                    246:        'e',000,'e','e','e',            /* p,q,r,s,t */
                    247:        'e','e','e','e','e',            /* u,v,w,x,y */
                    248:        'e',0                           /* z */
                    249:        };
                    250: /* Computer Center C Machine (C) */
                    251: char configC[] = {             /* to get to i, config[i] */
                    252:        'a','e','c','g','e',            /* a,b,c,d,e */
                    253:        'g','g','g','g','g',            /* f,g,h,i,j */
                    254:        'g','g','g','g','g',            /* k,l,m,n,o */
                    255:        'g',000,'g','e','g',            /* p,q,r,s,t */
                    256:        'g','g','g','g','g',            /* u,v,w,x,y */
                    257:        'g',0                           /* z */
                    258:        };
                    259: /* Computer Center D Machine (D) */
                    260: char configD[] = {             /* to get to i, config[i] */
                    261:        'g','g','g','d','g',            /* a,b,c,d,e */
                    262:        'g','g','g','g','g',            /* f,g,h,i,j */
                    263:        'g','g','g','g','g',            /* k,l,m,n,o */
                    264:        'g',000,'g','g','g',            /* p,q,r,s,t */
                    265:        'g','g','g','g','g',            /* u,v,w,x,y */
                    266:        'g',0                           /* z */
                    267:        };
                    268: /* Computer Center E Machine (E) */
                    269: char configE[] = {             /* to get to i, config[i] */
                    270:        'c','b','c','c','e',            /* a,b,c,d,e */
                    271:        'c','c','c','c','c',            /* f,g,h,i,j */
                    272:        'c','c','c','c','c',            /* k,l,m,n,o */
                    273:        'c',000,'c','s','c',            /* p,q,r,s,t */
                    274:        'c','c','c','c','c',            /* u,v,w,x,y */
                    275:        'c',0                           /* z */
                    276:        };
                    277: /* Computer Center F Machine (F) */
                    278: char configF[] = {             /* to get to i, config[i] */
                    279:        'g','g','g','g','g',            /* a,b,c,d,e */
                    280:        'f','g','g','g','g',            /* f,g,h,i,j */
                    281:        'g','g','g','g','g',            /* k,l,m,n,o */
                    282:        'g',000,'g','g','g',            /* p,q,r,s,t */
                    283:        'g','g','g','g','g',            /* u,v,w,x,y */
                    284:        'g',0                           /* z */
                    285:        };
                    286: /* Computer Center G Machine (G) */
                    287: char configG[] = {             /* to get to i, config[i] */
                    288:        'c','c','c','d','c',            /* a,b,c,d,e */
                    289:        'f','g','h','k','k',            /* f,g,h,i,j */
                    290:        'k','k','k','k','k',            /* k,l,m,n,o */
                    291:        'k',000,'k','c','k',            /* p,q,r,s,t */
                    292:        'k','k','k','k','k',            /* u,v,w,x,y */
                    293:        'k',0                           /* z */
                    294:        };
                    295: /* Computer Center H Machine (H) */
                    296: char configH[] = {             /* to get to i, config[i] */
                    297:        'g','g','g','g','g',            /* a,b,c,d,e */
                    298:        'g','g','h','g','g',            /* f,g,h,i,j */
                    299:        'g','g','g','g','g',            /* k,l,m,n,o */
                    300:        'g',000,'g','g','g',            /* p,q,r,s,t */
                    301:        'g','g','g','g','g',            /* u,v,w,x,y */
                    302:        'g',0                           /* z */
                    303:        };
                    304: /* Project INGRES 11/70 (Ing70) */
                    305: char configI[] = {             /* to get to i, config[i] */
                    306:        'j','j','j','j','j',            /* a,b,c,d,e */
                    307:        'j','j','j','i','j',            /* f,g,h,i,j */
                    308:        'j','j','j','j','j',            /* k,l,m,n,o */
                    309:        'j',000,'j','j','j',            /* p,q,r,s,t */
                    310:        'j','j','j','j','j',            /* u,v,w,x,y */
                    311:        'j',0                           /* z */
                    312:        };
                    313: /* Project INGRES VAX (IngVAX) */
                    314: char configJ[] = {             /* to get to i, config[i] */
                    315:        'k','k','k','k','k',            /* a,b,c,d,e */
                    316:        'k','k','k','i','j',            /* f,g,h,i,j */
                    317:        'k','k','k','k','k',            /* k,l,m,n,o */
                    318:        'k',000,'k','k','k',            /* p,q,r,s,t */
                    319:        'k','k','k','k','k',            /* u,v,w,x,y */
                    320:        'k',0                           /* z */
                    321:        };
                    322: /* UUCP gateway VAX (ucbvax) */
                    323: char configK[] = {             /* to get to i, config[i] */
                    324:        'g','g','g','g','g',            /* a,b,c,d,e */
                    325:        'g','g','g','j','j',            /* f,g,h,i,j */
                    326:        'k','p','p','n','p',            /* k,l,m,n,o */
                    327:        'p','g','r','g','t',            /* p,q,r,s,t */
                    328:        'u','v','w','x','y',            /* u,v,w,x,y */
                    329:        'p',0                           /* z */
                    330:        };
                    331: /* Brodersen EECS VLSI VAX (VLSI) */
                    332: char configL[] = {             /* to get to i, config[i] */
                    333:        'm','m','m','m','m',            /* a,b,c,d,e */
                    334:        'm','m','m','m','m',            /* f,g,h,i,j */
                    335:        'm','l','m','m','m',            /* k,l,m,n,o */
                    336:        'm',000,'m','m','m',            /* p,q,r,s,t */
                    337:        'm','m','m','m','m',            /* u,v,w,x,y */
                    338:        'm',0                           /* z */
                    339:        };
                    340: /* Sakrison's Image Project VAX (Image) */
                    341: char configM[] = {             /* to get to i, config[i] */
                    342:        'o','o','o','o','o',            /* a,b,c,d,e */
                    343:        'o','o','o','o','o',            /* f,g,h,i,j */
                    344:        'o','l','m','o','o',            /* k,l,m,n,o */
                    345:        'o',000,'o','o','o',            /* p,q,r,s,t */
                    346:        'o','o','o','o','o',            /* u,v,w,x,y */
                    347:        'o',0                           /* z */
                    348:        };
                    349: /* Fatemans Applied Math VAX (Kim) */
                    350: char configN[] = {             /* to get to i, config[i] */
                    351:        'k','k','k','k','k',            /* a,b,c,d,e */
                    352:        'k','k','k','k','k',            /* f,g,h,i,j */
                    353:        'k','k','k','n','k',            /* k,l,m,n,o */
                    354:        'k',000,'k','k','k',            /* p,q,r,s,t */
                    355:        'k','k','k','k','k',            /* u,v,w,x,y */
                    356:        'k',0                           /* z */
                    357:        };
                    358: /* Pfeister - Pollack - Sangiovanni Optimization VAX (ESVAX) */
                    359: char configO[] = {             /* to get to i, config[i] */
                    360:        'p','p','p','p','p',            /* a,b,c,d,e */
                    361:        'p','p','p','p','p',            /* f,g,h,i,j */
                    362:        'p','m','m','p','o',            /* k,l,m,n,o */
                    363:        'p',000,'p','p','p',            /* p,q,r,s,t */
                    364:        'p','p','p','p','p',            /* u,v,w,x,y */
                    365:        'z',0                           /* z */
                    366:        };
                    367: /* Newton's CAD machine (VAX 11/780) */
                    368: char configP[] = {             /* to get to i, config[i] */
                    369:        'k','k','k','k','k',            /* a,b,c,d,e */
                    370:        'k','k','k','k','k',            /* f,g,h,i,j */
                    371:        'k','o','o','k','o',            /* k,l,m,n,o */
                    372:        'p',000,'k','k','k',            /* p,q,r,s,t */
                    373:        'k','k','k','k','k',            /* u,v,w,x,y */
                    374:        'o',0                           /* z */
                    375:        };
                    376: /* Fabry's ARPA support VAX - ARPAVAX */
                    377: char configR[] = {             /* to get to i, config[i] */
                    378:        'k','k','k','k','k',            /* a,b,c,d,e */
                    379:        'k','k','k','k','k',            /* f,g,h,i,j */
                    380:        'k','k','k','k','k',            /* k,l,m,n,o */
                    381:        'k',000,'r','k','k',            /* p,q,r,s,t */
                    382:        'k','k','k','k','k',            /* u,v,w,x,y */
                    383:        'k',0                           /* z */
                    384:        };
                    385: /* Survey Research Center 11/40 (SRC) */
                    386: char configS[] = {             /* to get to i, config[i] */
                    387:        'e','e','e','e','e',            /* a,b,c,d,e */
                    388:        'e','e','e','e','e',            /* f,g,h,i,j */
                    389:        'e','e','e','e','e',            /* k,l,m,n,o */
                    390:        'e',000,'e','s','e',            /* p,q,r,s,t */
                    391:        'e','e','e','e','e',            /* u,v,w,x,y */
                    392:        'e',0                           /* z */
                    393:        };
                    394: /* Math-Stat Departement machine 11-45 (MathStat) */
                    395: char configT[] = {             /* to get to i, config[i] */
                    396:        'k','k','k','k','k',            /* a,b,c,d,e */
                    397:        'k','k','k','k','k',            /* f,g,h,i,j */
                    398:        'k','k','k','k','k',            /* k,l,m,n,o */
                    399:        'k',000,'k','k','t',            /* p,q,r,s,t */
                    400:        'k','k','k','k','k',            /* u,v,w,x,y */
                    401:        'k',0                           /* z */
                    402:        };
                    403: /* ARPANET gateway (ucbc70) */
                    404: char configU[] = {             /* to get to i, config[i] */
                    405:        'k','k','k','k','k',            /* a,b,c,d,e */
                    406:        'k','k','k','k','k',            /* f,g,h,i,j */
                    407:        'k','k','k','k','k',            /* k,l,m,n,o */
                    408:        'k',000,'k','k','k',            /* p,q,r,s,t */
                    409:        'u','k','k','k','k',            /* u,v,w,x,p */
                    410:        'k',0                           /* z */
                    411:        };
                    412: /* EECS Research (Fateman - Ernie) VAX (CSVAX) */
                    413: char configV[] = {             /* to get to i, config[i] */
                    414:        'k','k','k','k','k',            /* a,b,c,d,e */
                    415:        'k','k','k','k','k',            /* f,g,h,i,j */
                    416:        'k','k','k','k','k',            /* k,l,m,n,o */
                    417:        'k',000,'k','k','k',            /* p,q,r,s,t */
                    418:        'k','v','k','k','k',            /* u,v,w,x,p */
                    419:        'k',0                           /* z */
                    420:        };
                    421: /* Statistics VAX 11/780 (ucbstatvax) */
                    422: char configW[] = {             /* to get to i, config[i] */
                    423:        'k','k','k','k','k',            /* a,b,c,d,e */
                    424:        'k','k','k','k','k',            /* f,g,h,i,j */
                    425:        'k','k','k','k','k',            /* k,l,m,n,o */
                    426:        'k',000,'k','k','k',            /* p,q,r,s,t */
                    427:        'k','k','w','k','k',            /* u,v,w,x,p */
                    428:        'k',0                           /* z */
                    429:        };
                    430: /* Undergraduate Computing Facility Onyx Computer */
                    431: char configX[] = {             /* to get to i, config[i] */
                    432:        'k','k','k','k','k',            /* a,b,c,d,e */
                    433:        'k','k','k','k','k',            /* f,g,h,i,j */
                    434:        'k','k','k','k','k',            /* k,l,m,n,o */
                    435:        'k',000,'k','k','k',            /* p,q,r,s,t */
                    436:        'k','k','k','x','k',            /* u,v,w,x,y */
                    437:        'k',0                           /* z */
                    438:        };
                    439: /* EECS Instructional 11/70 (199 Cory) (Cory) */
                    440: char configY[] = {             /* to get to i, config[i] */
                    441:        'k','k','k','k','k',            /* a,b,c,d,e */
                    442:        'k','k','k','k','k',            /* f,g,h,i,j */
                    443:        'k','k','k','k','k',            /* k,l,m,n,o */
                    444:        'k',000,'k','k','k',            /* p,q,r,s,t */
                    445:        'k','k','k','k','y',            /* u,v,w,x,y */
                    446:        'k',0                           /* z */
                    447:        };
                    448: /* EECS Departmental 11/40  (EECS40) */
                    449: char configZ[] = {             /* to get to i, config[i] */
                    450:        'o','o','o','o','o',            /* a,b,c,d,e */
                    451:        'o','o','o','o','o',            /* f,g,h,i,j */
                    452:        'o','o','o','o','o',            /* k,l,m,n,o */
                    453:        'o',000,'o','o','o',            /* p,q,r,s,t */
                    454:        'o','o','o','o','o',            /* u,v,w,x,y */
                    455:        'z',0                           /* z */
                    456:        };
                    457: /* if machtype is
                    458:        M_CC            netlpr will do lpr w/o an acct.
                    459:                        Will pre-encrypt the password.
                    460:        M_INGRES        will allow higher file lengths.
                    461:        M_OTHER         will give no unusual effects.
                    462: (when in doubt, machtype should be M_OTHER)
                    463: */
                    464: char machtype[]= {
                    465:        M_CC, M_CC, M_CC, M_CC, M_CC,                   /* a,b,c,d,e */
                    466:        M_CC, M_CC, M_CC, M_INGRES, M_INGRES,           /* f,g,h,i,j */
                    467:        M_OTHER, M_OTHER, M_OTHER, M_OTHER, M_OTHER,    /* k,l,m,n,o */
                    468:        M_OTHER, 0, M_OTHER, M_OTHER, M_OTHER,          /* p,q,r,s,t */
                    469:        M_OTHER, M_OTHER, M_OTHER, M_OTHER, M_OTHER,    /* u,v,w,x,y */
                    470:        M_OTHER, 0};                                    /* z */
                    471: 
                    472: /* this is basically the default machine for each local machine */
                    473: char remtable[] = {
                    474:        'c','e','g','g','c',            /* a,b,c,d,e */
                    475:        'g','k','g','j','k',            /* f,g,h,i,j */
                    476:        'u','m','o','k','p',            /* k,l,m,n,o */
                    477:        'k',000,'k','e','k',            /* p,q,r,s,t */
                    478:        'k','k','k','k','k',            /* u,v,w,x,y */
                    479:        'o',0                           /* z */
                    480:        };
                    481: /* bad login names */
                    482: struct bstruct btable[] = {
                    483:        "op", 'a',
                    484:        0,0 };
                    485: /* this table shows the correspondence between
                    486:    machine names like 'Cory' and their internal names, like 'y' */
                    487: static struct tt {
                    488:        char *bigname;
                    489:        char lname;
                    490:        } table[] = {
                    491:        "A",            'a',
                    492:        "ucbcfo-a",     'a',
                    493:        "cfo-a",        'a',
                    494:        "B",            'b',
                    495:        "ucbcfo-b",     'b',
                    496:        "cfo-b",        'b',
                    497:        "C",            'c',
                    498:        "ucbcfo-c",     'c',
                    499:        "cfo-c",        'c',
                    500:        "D",            'd',
                    501:        "ucbcfo-d",     'd',
                    502:        "cfo-d",        'd',
                    503:        "E",            'e',
                    504:        "ucbcfo-e",     'e',
                    505:        "cfo-e",        'e',
                    506:        "F",            'f',
                    507:        "ucbcfo-f",     'f',
                    508:        "cfo-f",        'f',
                    509:        "G",            'g',
                    510:        "ucbcfo-g",     'g',
                    511:        "cfo-g",        'g',
                    512:        "H",            'h',
                    513:        "ucbcfo-h",     'h',
                    514:        "cfo-h",        'h',
                    515:        "ucbjade",      'h',
                    516:        "jade",         'h',
                    517:        "Ing70",        'i',
                    518:        "ucberl70",     'i',
                    519:        "erl70",        'i',
                    520:        "IngVAX",       'j',
                    521:        "ucbingres",    'j',
                    522:        "ingres",       'j',
                    523:        "ucbvax",       'k',
                    524:        "vax",          'k',
                    525:        "ucboz",        'l',
                    526:        "oz",           'l',
                    527:        "VLSI",         'l',
                    528:        "ucbmedea",     'm',
                    529:        "medea",        'm',
                    530:        "Image",        'm',
                    531:        "Kim",          'n',
                    532:        "ucbkim",       'n',
                    533:        "kim",          'n',
                    534:        "ESVAX",        'o',
                    535:        "ucbesvax",     'o',
                    536:        "ucbcad",       'p',
                    537:        "ucbcoke",      'p',
                    538:        "coke",         'p',
                    539:        "cad",          'p',
                    540:        "ARPAVAX",      'r',
                    541:        "ucbarpa",      'r',
                    542:        "arpa",         'r',
                    543:        "SRC",          's',
                    544:        "ucbsrc",       's',
                    545:        "MathStat",     't',
                    546:        "ucbmathstat",  't',
                    547:        "ucbc70",       'u',
                    548:        "c70",          'u',
                    549:        "CSVAX",        'v',
                    550:        "ucbernie",     'v',
                    551:        "ernie",        'v',
                    552:        "ucbstatvax",   'w',
                    553:        "statvax",      'w',
                    554:        "ucbonyx",      'x',
                    555:        "onyx",         'x',
                    556:        "Cory",         'y',
                    557:        "ucbcory",      'y',
                    558:        "ucbear",       'z',
                    559:        "ear",          'z',
                    560:        "earvax",       'z',
                    561:        "EECS40",       'z',
                    562:        0,              0
                    563:        };
                    564: # endif

unix.superglobalmegacorp.com

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