usr/src/cmd/bnu/sysfiles.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28
  29 #include "uucp.h"
  30
  31 #include <unistd.h>
  32 #include "sysfiles.h"
  33 #include <sys/stropts.h>
  34
  35 /*
  36  * manage systems files (Systems, Devices, and Dialcodes families).
  37  *
  38  * also manage new file Devconfig, allows per-device setup.
  39  * present use is to specify what streams modules to push/pop for
  40  * AT&T TLI/streams network.
  41  *
  42  * TODO:
  43  *    call bsfix()?
  44  *    combine the 3 versions of everything (sys, dev, and dial) into one.
  45  *    allow arbitrary classes of service.
  46  *    need verifysys() for uucheck.
  47  *    nameserver interface?
  48  *    pass sysname (or 0) to getsysline().  (might want reg. exp. or NS processing
  49  */
  50
  51 /* private variables */
  52 static void tokenize(), nameparse(), setfile(), setioctl(),
  53         scansys(), scancfg(), setconfig();
  54 static int namematch(), nextdialers(), nextdevices(), nextsystems(), getaline();
  55
  56 /* pointer arrays might be dynamically allocated */
  57 static char *Systems[64] = {0}; /* list of Systems files */
  58 static char *Devices[64] = {0}; /* list of Devices files */
  59 static char *Dialers[64] = {0}; /* list of Dialers files */
  60 static char *Pops[64] = {0};    /* list of STREAMS modules to be popped */
  61 static char *Pushes[64] = {0};  /* list of STREAMS modules to be pushed */
  62
  63 static int nsystems;            /* index into list of Systems files */
  64 static int ndevices;            /* index into list of Devices files */
  65 static int ndialers;            /* index into list of Dialers files */
  66 static int npops;               /* index into list of STREAMS modules */
  67                                                         /*to be popped */
  68 static int npushes;             /* index into list of STREAMS modules */
  69                                                         /*to be pushed */
  70
  71 GLOBAL unsigned connecttime = CONNECTTIME;
  72 GLOBAL unsigned expecttime = EXPECTTIME;
  73 GLOBAL unsigned msgtime = MSGTIME;
  74
  75 static FILE *fsystems;
  76 static FILE *fdevices;
  77 static FILE *fdialers;
  78
  79 static char errformat[BUFSIZ];
  80
  81 /* this might be dynamically allocated */
  82 #define NTOKENS 16
  83 static char *tokens[NTOKENS], **tokptr;
  84
  85 /* export these */
  86 EXTERN void sysreset(), devreset(), dialreset(), setdevcfg(), setservice();
  87 EXTERN char *strsave();
  88
  89 /* import these */
  90 extern char *strcpy(), *strtok(), *strchr(), *strsave();
  91 EXTERN int eaccess();
  92
  93 /*
  94  * setservice init's Systems, Devices, Dialers lists from Sysfiles
  95  */
  96 GLOBAL void
  97 setservice(service)
  98 char *service;
  99 {
 100         char    *prev = _uu_setlocale(LC_ALL, "C");
 101
 102         setconfig();
 103         scansys(service);
 104         (void) _uu_resetlocale(LC_ALL, prev);
 105         return;
 106 }
 107
 108 /*
 109  * setdevcfg init's Pops, Pushes lists from Devconfig
 110  */
 111
 112 GLOBAL void
 113 setdevcfg(service, device)
 114 char *service, *device;
 115 {
 116         char    *prev = _uu_setlocale(LC_ALL, "C");
 117
 118         scancfg(service, device);
 119         (void) _uu_resetlocale(LC_ALL, prev);
 120         return;
 121 }
 122
 123 /*      administrative files access */
 124 GLOBAL int
 125 sysaccess(type)
 126 int type;
 127 {
 128         switch (type) {
 129
 130         case ACCESS_SYSTEMS:
 131                 return(access(Systems[nsystems], R_OK));
 132         case ACCESS_DEVICES:
 133                 return(access(Devices[ndevices], R_OK));
 134         case ACCESS_DIALERS:
 135                 return(access(Dialers[ndialers], R_OK));
 136         case EACCESS_SYSTEMS:
 137                 return(eaccess(Systems[nsystems], R_OK));
 138         case EACCESS_DEVICES:
 139                 return(eaccess(Devices[ndevices], R_OK));
 140         case EACCESS_DIALERS:
 141                 return(eaccess(Dialers[ndialers], R_OK));
 142         default:
 143                 (void)sprintf(errformat, "bad access type %d", type);
 144                 logent(errformat, "sysaccess");
 145                 return(FAIL);
 146         }
 147 }
 148
 149
 150 /*
 151  * read Sysfiles, set up lists of Systems/Devices/Dialers file names.
 152  * allow multiple entries for a given service, allow a service
 153  * type to describe resources more than once, e.g., systems=foo:baz systems=bar.
 154  */
 155 static void
 156 scansys(service)
 157 char *service;
 158 {       FILE *f;
 159         char *tok, buf[BUFSIZ];
 160
 161         Systems[0] = Devices[0] = Dialers[0] = NULL;
 162         if ((f = fopen(SYSFILES, "r")) != 0) {
 163                 while (getaline(f, buf) > 0) {
 164                         /* got a (logical) line from Sysfiles */
 165                         /* strtok's of this buf continue in tokenize() */
 166                         tok = strtok(buf, " \t");
 167                         if (namematch("service=", tok, service)) {
 168                                 tokenize();
 169                                 nameparse();
 170                         }
 171                 }
 172                 (void) fclose(f);
 173         }
 174
 175         /* if didn't find entries in Sysfiles, use defaults */
 176         if (Systems[0] == NULL) {
 177                 Systems[0] = strsave(SYSTEMS);
 178                 ASSERT(Systems[0] != NULL, Ct_ALLOCATE, "scansys: Systems", 0);
 179                 Systems[1] = NULL;
 180         }
 181         if (Devices[0] == NULL) {
 182                 Devices[0] = strsave(DEVICES);
 183                 ASSERT(Devices[0] != NULL, Ct_ALLOCATE, "scansys: Devices", 0);
 184                 Devices[1] = NULL;
 185         }
 186         if (Dialers[0] == NULL) {
 187                 Dialers[0] = strsave(DIALERS);
 188                 ASSERT(Dialers[0] != NULL, Ct_ALLOCATE, "scansys: Dialers", 0);
 189                 Dialers[1] = NULL;
 190         }
 191         return;
 192 }
 193
 194
 195 /*
 196  * read Devconfig.  allow multiple entries for a given service, allow a service
 197  * type to describe resources more than once, e.g., push=foo:baz push=bar.
 198  */
 199 static void
 200 scancfg(service, device)
 201 char *service, *device;
 202 {       FILE *f;
 203         char *tok, buf[BUFSIZ];
 204
 205         /* (re)initialize device-specific information */
 206
 207         npops = npushes = 0;
 208         Pops[0] = Pushes[0] = NULL;
 209         connecttime = CONNECTTIME;
 210         expecttime = EXPECTTIME;
 211         msgtime = MSGTIME;
 212
 213         if ((f = fopen(DEVCONFIG, "r")) != 0) {
 214                 while (getaline(f, buf) > 0) {
 215                         /* got a (logical) line from Devconfig */
 216                         /* strtok's of this buf continue in tokenize() */
 217                         tok = strtok(buf, " \t");
 218                         if (namematch("service=", tok, service)) {
 219                                 tok = strtok((char *)0, " \t");
 220                                 if ( namematch("device=", tok, device)) {
 221                                         tokenize();
 222                                         nameparse();
 223                                 }
 224                         }
 225                 }
 226                 (void) fclose(f);
 227         }
 228
 229         return;
 230
 231 }
 232
 233 /*
 234  *  given a file pointer and buffer, construct logical line in buffer
 235  *  (i.e., concatenate lines ending in '\').  return length of line
 236  *  ASSUMES that buffer is BUFSIZ long!
 237  */
 238
 239 static int
 240 getaline(f, line)
 241 FILE *f;
 242 char *line;
 243 {       char *lptr, *lend;
 244
 245         lptr = line;
 246         while (fgets(lptr, (line + BUFSIZ) - lptr, f) != NULL) {
 247                 lend = lptr + strlen(lptr);
 248                 if (lend == lptr || lend[-1] != '\n')
 249                         /* empty buf or line too long! */
 250                         break;
 251                 *--lend = '\0'; /* lop off ending '\n' */
 252                 if ( lend == line ) /* empty line - ignore */
 253                         continue;
 254                 lptr = lend;
 255                 if (lend[-1] != '\\')
 256                         break;
 257                 /* continuation */
 258                 lend[-1] = ' ';
 259         }
 260         return(lptr - line);
 261 }
 262
 263 /*
 264  * given a label (e.g., "service=", "device="), a name ("cu", "uucico"),
 265  *  and a line:  if line begins with the label and if the name appears
 266  * in a colon-separated list of names following the label, return true;
 267  * else return false
 268  */
 269 static int
 270 namematch(label, line, name)
 271 char *label, *line, *name;
 272 {       char *lend;
 273
 274         if (strncmp(label, line, strlen(label)) != SAME) {
 275                 return(FALSE);  /* probably a comment line */
 276         }
 277         line += strlen(label);
 278         if (*line == '\0')
 279                 return(FALSE);
 280         /*
 281          * can't use strtok() in the following because scansys(),
 282          * scancfg() do an initializing call to strtok() before
 283          * coming here and then CONTINUE calling strtok() in tokenize(),
 284          * after returning from namematch().
 285          */
 286         while ((lend = strchr(line, ':')) != NULL) {
 287                 *lend = '\0';
 288                 if (strcmp(line, name) == SAME)
 289                         return(TRUE);
 290                 line = lend+1;
 291         }
 292         return(strcmp(line, name) == SAME);
 293 }
 294
 295 /*
 296  * tokenize() continues pulling tokens out of a buffer -- the
 297  * initializing call to strtok must have been made before calling
 298  * tokenize() -- and starts stuffing 'em into tokptr.
 299  */
 300 static void
 301 tokenize()
 302 {       char *tok;
 303
 304         tokptr = tokens;
 305         while ((tok = strtok((char *) NULL, " \t")) != NULL) {
 306                 *tokptr++ = tok;
 307                 if (tokptr - tokens >= NTOKENS)
 308                         break;
 309         }
 310         *tokptr = NULL;
 311         return;
 312 }
 313
 314 /*
 315  * look at top token in array: should be line of the form
 316  *      name=item1:item2:item3...
 317  * if name is one we recognize, then call set[file|ioctl] to set up
 318  * corresponding list.  otherwise, log bad name.
 319  */
 320 static void
 321 nameparse()
 322 {       char **line, *equals;
 323         int temp;
 324
 325 #define setuint(a,b,c) a = ( ((temp = atoi(b)) <= 0) ? (c) : temp )
 326
 327         for (line = tokens; (line - tokens) < NTOKENS && *line; line++) {
 328                 equals = strchr(*line, '=');
 329                 if (equals == NULL)
 330                         continue;       /* may be meaningful someday? */
 331                 *equals = '\0';
 332                 /* ignore entry with empty rhs */
 333                 if (*++equals == '\0')
 334                         continue;
 335                 if (strcmp(*line, "systems") == SAME)
 336                         setfile(Systems, equals);
 337                 else if (strcmp(*line, "devices") == SAME)
 338                         setfile(Devices, equals);
 339                 else if (strcmp(*line, "dialers") == SAME)
 340                         setfile(Dialers, equals);
 341                 else if (strcmp(*line, "pop") == SAME)
 342                         setioctl(Pops, equals);
 343                 else if (strcmp(*line, "push") == SAME)
 344                         setioctl(Pushes, equals);
 345                 else if (strcmp(*line, "connecttime") == SAME)
 346                         setuint(connecttime, equals, CONNECTTIME);
 347                 else if (strcmp(*line, "expecttime") == SAME)
 348                         setuint(expecttime, equals, EXPECTTIME);
 349                 else if (strcmp(*line, "msgtime") == SAME)
 350                         setuint(msgtime, equals, MSGTIME);
 351                 else {
 352                         (void)sprintf(errformat,"unrecognized label %s",*line);
 353                         logent(errformat, "Sysfiles|Devconfig");
 354                 }
 355         }
 356         return;
 357 }
 358
 359 /*
 360  * given the list for a particular type (systems, devices,...)
 361  * and a line of colon-separated files, add 'em to list
 362  */
 363
 364 static void
 365 setfile(type, line)
 366 char **type, *line;
 367 {       char **tptr, *tok;
 368         char expandpath[BUFSIZ];
 369
 370         if (*line == 0)
 371                 return;
 372         tptr = type;
 373         while (*tptr)           /* skip over existing entries to*/
 374                 tptr++;         /* concatenate multiple entries */
 375
 376         for (tok = strtok(line, ":"); tok != NULL;
 377         tok = strtok((char *) NULL, ":")) {
 378                 expandpath[0] = '\0';
 379                 if ( *tok != '/' )
 380                         /* by default, file names are relative to SYSDIR */
 381                         sprintf(expandpath, "%s/", SYSDIR);
 382                 strcat(expandpath, tok);
 383                 if (eaccess(expandpath, R_OK) != 0)
 384                         /* if we can't read it, no point in adding to list */
 385                         continue;
 386                 *tptr = strsave(expandpath);
 387                 ASSERT(*tptr != NULL, Ct_ALLOCATE, "setfile: tptr", 0);
 388                 tptr++;
 389         }
 390         return;
 391 }
 392
 393 /*
 394  * given the list for a particular ioctl (push, pop)
 395  * and a line of colon-separated modules, add 'em to list
 396  */
 397
 398 static void
 399 setioctl(type, line)
 400 char **type, *line;
 401 {       char **tptr, *tok;
 402
 403         if (*line == 0)
 404                 return;
 405         tptr = type;
 406         while (*tptr)           /* skip over existing entries to*/
 407                 tptr++;         /* concatenate multiple entries */
 408         for (tok = strtok(line, ":"); tok != NULL;
 409         tok = strtok((char *) NULL, ":")) {
 410                 *tptr = strsave(tok);
 411                 ASSERT(*tptr != NULL, Ct_ALLOCATE, "setioctl: tptr", 0);
 412                 tptr++;
 413         }
 414         return;
 415 }
 416
 417 /*
 418  * reset Systems files
 419  */
 420 GLOBAL void
 421 sysreset()
 422 {
 423         if (fsystems)
 424                 fclose(fsystems);
 425         fsystems = NULL;
 426         nsystems = 0;
 427         devreset();
 428         return;
 429 }
 430
 431 /*
 432  * reset Devices files
 433  */
 434 GLOBAL void
 435 devreset()
 436 {
 437         if (fdevices)
 438                 fclose(fdevices);
 439         fdevices = NULL;
 440         ndevices = 0;
 441         dialreset();
 442         return;
 443 }
 444
 445 /*
 446  * reset Dialers files
 447  */
 448 GLOBAL void
 449 dialreset()
 450 {
 451         if (fdialers)
 452                 fclose(fdialers);
 453         fdialers = NULL;
 454         ndialers = 0;
 455         return;
 456 }
 457
 458 /*
 459  * get next line from Systems file
 460  * return TRUE if successful, FALSE if not
 461  */
 462 GLOBAL int
 463 getsysline(buf, len)
 464 char *buf;
 465 {
 466         char    *prev = _uu_setlocale(LC_ALL, "C");
 467
 468         if (Systems[0] == NULL)
 469                 /* not initialized via setservice() - use default */
 470                 setservice("uucico");
 471
 472         /* initialize devices and dialers whenever a new line is read */
 473         /* from systems */
 474         devreset();
 475         if (fsystems == NULL)
 476                 if (nextsystems() == FALSE) {
 477                         (void) _uu_resetlocale(LC_ALL, prev);
 478                         return(FALSE);
 479                 }
 480
 481         ASSERT(len >= BUFSIZ, "BUFFER TOO SMALL", "getsysline", 0);
 482         for(;;) {
 483                 while (getaline(fsystems, buf) != NULL)
 484                     if ((*buf != '#') && (*buf != ' ') &&
 485                         (*buf != '\t') && (*buf != '\n')) {
 486                         (void) _uu_resetlocale(LC_ALL, prev);
 487                         return(TRUE);
 488                 }
 489                 if (nextsystems() == FALSE) {
 490                         (void) _uu_resetlocale(LC_ALL, prev);
 491                         return(FALSE);
 492                 }
 493         }
 494 }
 495
 496 /*
 497  * move to next systems file.  return TRUE if successful, FALSE if not
 498  */
 499 static int
 500 nextsystems()
 501 {
 502         devreset();
 503
 504         if (fsystems != NULL) {
 505                 (void) fclose(fsystems);
 506                 nsystems++;
 507         } else {
 508                 nsystems = 0;
 509         }
 510         for ( ; Systems[nsystems] != NULL; nsystems++)
 511                 if ((fsystems = fopen(Systems[nsystems], "r")) != NULL)
 512                         return(TRUE);
 513         return(FALSE);
 514 }
 515
 516 /*
 517  * get next line from Devices file
 518  * return TRUE if successful, FALSE if not
 519  */
 520 GLOBAL int
 521 getdevline(buf, len)
 522 char *buf;
 523 {
 524         char    *prev = _uu_setlocale(LC_ALL, "C");
 525
 526         if (Devices[0] == NULL)
 527                 /* not initialized via setservice() - use default */
 528                 setservice("uucico");
 529
 530         if (fdevices == NULL)
 531                 if (nextdevices() == FALSE) {
 532                         (void) _uu_resetlocale(LC_ALL, prev);
 533                         return(FALSE);
 534                 }
 535         for(;;) {
 536                 if (fgets(buf, len, fdevices) != NULL) {
 537                         (void) _uu_resetlocale(LC_ALL, prev);
 538                         return(TRUE);
 539                 }
 540                 if (nextdevices() == FALSE) {
 541                         (void) _uu_resetlocale(LC_ALL, prev);
 542                         return(FALSE);
 543                 }
 544         }
 545 }
 546
 547 /*
 548  * move to next devices file.  return TRUE if successful, FALSE if not
 549  */
 550 static int
 551 nextdevices()
 552 {
 553         if (fdevices != NULL) {
 554                 (void) fclose(fdevices);
 555                 ndevices++;
 556         } else {
 557                 ndevices = 0;
 558         }
 559         for ( ; Devices[ndevices] != NULL; ndevices++)
 560                 if ((fdevices = fopen(Devices[ndevices], "r")) != NULL)
 561                         return(TRUE);
 562         return(FALSE);
 563 }
 564
 565
 566 /*
 567  * get next line from Dialers file
 568  * return TRUE if successful, FALSE if not
 569  */
 570
 571 GLOBAL int
 572 getdialline(buf, len)
 573 char *buf;
 574 {
 575         char    *prev = _uu_setlocale(LC_ALL, "C");
 576
 577         if (Dialers[0] == NULL)
 578                 /* not initialized via setservice() - use default */
 579                 setservice("uucico");
 580
 581         if (fdialers == NULL)
 582                 if (nextdialers() == FALSE) {
 583                         (void) _uu_resetlocale(LC_ALL, prev);
 584                         return(FALSE);
 585                 }
 586         for(;;) {
 587                 if (fgets(buf, len, fdialers) != NULL) {
 588                         (void) _uu_resetlocale(LC_ALL, prev);
 589                         return(TRUE);
 590                 }
 591                 if (nextdialers() == FALSE) {
 592                         (void) _uu_resetlocale(LC_ALL, prev);
 593                         return(FALSE);
 594                 }
 595         }
 596 }
 597
 598 /*
 599  * move to next dialers file.  return TRUE if successful, FALSE if not
 600  */
 601 static int
 602 nextdialers()
 603 {
 604         if (fdialers) {
 605                 (void) fclose(fdialers);
 606                 ndialers++;
 607         } else {
 608                 ndialers = 0;
 609         }
 610
 611         for ( ; Dialers[ndialers] != NULL; ndialers++)
 612                 if ((fdialers = fopen(Dialers[ndialers], "r")) != NULL)
 613                         return(TRUE);
 614         return(FALSE);
 615 }
 616
 617 /*
 618  * get next module to be popped
 619  * return TRUE if successful, FALSE if not
 620  */
 621 static int
 622 getpop(buf, len, optional)
 623 char *buf;
 624 int len, *optional;
 625 {
 626         int slen;
 627
 628         if ( Pops[0] == NULL || Pops[npops] == NULL )
 629                 return(FALSE);
 630
 631         /*      if the module name is enclosed in parentheses,  */
 632         /*      is optional. set flag & strip parens            */
 633         slen = strlen(Pops[npops]) - 1;
 634         if ( Pops[npops][0] == '('  && Pops[npops][slen] == ')' ) {
 635                 *optional = 1;
 636                 len = ( slen < len ? slen : len );
 637                 strncpy(buf, &(Pops[npops++][1]), len);
 638         } else {
 639                 *optional = 0;
 640                 strncpy(buf, Pops[npops++], len);
 641         }
 642         buf[len-1] = '\0';
 643         return(TRUE);
 644 }
 645
 646 /*
 647  * get next module to be pushed
 648  * return TRUE if successful, FALSE if not
 649  */
 650 static int
 651 getpush(buf, len)
 652 char *buf;
 653 int len;
 654 {
 655         if ( Pushes[0] == NULL || Pushes[npushes] == NULL )
 656                 return(FALSE);
 657         strncpy(buf, Pushes[npushes++], len);
 658         return(TRUE);
 659 }
 660
 661 /*
 662  * pop/push requested modules
 663  * return TRUE if successful, FALSE if not
 664  */
 665 GLOBAL int
 666 pop_push(fd)
 667 int fd;
 668 {
 669     char        strmod[FMNAMESZ], onstream[FMNAMESZ];
 670     int         optional;
 671     char        *prev = _uu_setlocale(LC_ALL, "C");
 672
 673     /*  check for streams modules to pop        */
 674     while ( getpop(strmod, sizeof(strmod), &optional) ) {
 675         DEBUG(5, (optional ? "pop_push: optionally POPing %s\n"
 676                            : "pop_push: POPing %s\n" ), strmod);
 677         if ( ioctl(fd, I_LOOK, onstream) == -1 ) {
 678             DEBUG(5, "pop_push: I_LOOK on fd %d failed ", fd);
 679             DEBUG(5, "errno %d\n", errno);
 680             (void) _uu_resetlocale(LC_ALL, prev);
 681             return(FALSE);
 682         }
 683         if ( strcmp(strmod, onstream) != SAME ) {
 684             if ( optional )
 685                 continue;
 686             DEBUG(5, "pop_push: I_POP: %s not there\n", strmod);
 687             (void) _uu_resetlocale(LC_ALL, prev);
 688             return(FALSE);
 689         }
 690         if ( ioctl(fd, I_POP, 0) == -1 ) {
 691             DEBUG(5, "pop_push: I_POP on fd %d failed ", fd);
 692             DEBUG(5, "errno %d\n", errno);
 693             (void) _uu_resetlocale(LC_ALL, prev);
 694             return(FALSE);
 695         }
 696     }
 697
 698     /*  check for streams modules to push       */
 699     while ( getpush(strmod, sizeof(strmod)) ) {
 700         DEBUG(5, "pop_push: PUSHing %s\n", strmod);
 701         if ( ioctl(fd, I_PUSH, strmod) == -1 ) {
 702             DEBUG(5, "pop_push: I_PUSH on fd %d failed ", fd);
 703             DEBUG(5, "errno %d\n", errno);
 704             (void) _uu_resetlocale(LC_ALL, prev);
 705             return(FALSE);
 706         }
 707     }
 708     (void) _uu_resetlocale(LC_ALL, prev);
 709     return(TRUE);
 710 }
 711
 712 /*
 713  *      return name of currently open Systems file
 714  */
 715 GLOBAL char *
 716 currsys()
 717 {
 718         return(Systems[nsystems]);
 719 }
 720
 721 /*
 722  *      return name of currently open Devices file
 723  */
 724 GLOBAL char *
 725 currdev()
 726 {
 727         return(Devices[ndevices]);
 728 }
 729
 730 /*
 731  *      return name of currently open Dialers file
 732  */
 733 GLOBAL char *
 734 currdial()
 735 {
 736         return(Dialers[ndialers]);
 737 }
 738
 739 /*
 740  * set configuration parameters provided in Config file
 741  */
 742 static void
 743 setconfig()
 744 {
 745     FILE *f;
 746     char buf[BUFSIZ];
 747     char *tok;
 748     extern char _ProtoCfg[];
 749
 750     if ((f = fopen(CONFIG, "r")) != 0) {
 751         while (getaline(f, buf) > 0) {
 752             /* got a (logical) line from Config file */
 753             tok = strtok(buf, " \t");
 754             if ( (tok != NULL) && (*tok != '#') ) {
 755                 /* got a token */
 756
 757                 /* this probably should be table driven when
 758                  * the list of configurable parameters grows.
 759                  */
 760                 if (strncmp("Protocol=", tok, strlen("Protocol=")) == SAME) {
 761                     tok += strlen("Protocol=");
 762                     if ( *tok != '\0' ) {
 763                         if ( _ProtoCfg[0] != '\0' ) {
 764                             DEBUG(7, "Protocol string %s ", tok);
 765                             DEBUG(7, "overrides %s\n", _ProtoCfg);
 766                         }
 767                         strcpy(_ProtoCfg, tok);
 768                     }
 769                 } else {
 770                     DEBUG(7, "Unknown configuration parameter %s\n", tok);
 771                 }
 772             }
 773         }
 774     }
 775 }