Return to hinit.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / uuconf

Annotation of coherent/g/usr/lib/uucp/tay104/uuconf/hinit.c, revision 1.1

1.1     ! root        1: /* hinit.c
        !             2:    Initialize for reading HDB configuration files.
        !             3: 
        !             4:    Copyright (C) 1992 Ian Lance Taylor
        !             5: 
        !             6:    This file is part of the Taylor UUCP uuconf library.
        !             7: 
        !             8:    This library is free software; you can redistribute it and/or
        !             9:    modify it under the terms of the GNU Library General Public License
        !            10:    as published by the Free Software Foundation; either version 2 of
        !            11:    the License, or (at your option) any later version.
        !            12: 
        !            13:    This library is distributed in the hope that it will be useful, but
        !            14:    WITHOUT ANY WARRANTY; without even the implied warranty of
        !            15:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            16:    Library General Public License for more details.
        !            17: 
        !            18:    You should have received a copy of the GNU Library General Public
        !            19:    License along with this library; if not, write to the Free Software
        !            20:    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
        !            21: 
        !            22:    The author of the program may be contacted at [email protected] or
        !            23:    c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
        !            24:    */
        !            25: 
        !            26: #include "uucnfi.h"
        !            27: 
        !            28: #if USE_RCS_ID
        !            29: const char _uuconf_hinit_rcsid[] = "$Id: hinit.c,v 1.1 93/07/30 08:07:14 bin Exp Locker: bin $";
        !            30: #endif
        !            31: 
        !            32: #include <errno.h>
        !            33: #include <ctype.h>
        !            34: 
        !            35: /* Avoid replicating OLDCONFIGLIB several times if not necessary.  */
        !            36: static const char abHoldconfiglib[] = OLDCONFIGLIB;
        !            37: 
        !            38: /* Initialize the routines which read HDB configuration files.  */
        !            39: 
        !            40: int
        !            41: uuconf_hdb_init (ppglobal, zprogram)
        !            42:      pointer *ppglobal;
        !            43:      const char *zprogram;
        !            44: {
        !            45:   struct sglobal **pqglobal = (struct sglobal **) ppglobal;
        !            46:   int iret;
        !            47:   struct sglobal *qglobal;
        !            48:   pointer pblock;
        !            49:   char abdialcodes[sizeof OLDCONFIGLIB + sizeof HDB_DIALCODES - 1];
        !            50:   char *zsys;
        !            51:   FILE *e;
        !            52: 
        !            53:   if (*pqglobal == NULL)
        !            54:     {
        !            55:       iret = _uuconf_iinit_global (pqglobal);
        !            56:       if (iret != UUCONF_SUCCESS)
        !            57:        return iret;
        !            58:     }
        !            59: 
        !            60:   qglobal = *pqglobal;
        !            61:   pblock = qglobal->pblock;
        !            62: 
        !            63:   if (zprogram == NULL
        !            64:       || strcmp (zprogram, "uucp") == 0)
        !            65:     zprogram = "uucico";
        !            66: 
        !            67:   /* Add the Dialcodes file to the global list.  */
        !            68:   memcpy ((pointer) abdialcodes, (pointer) abHoldconfiglib,
        !            69:          sizeof OLDCONFIGLIB - 1);
        !            70:   memcpy ((pointer) (abdialcodes + sizeof OLDCONFIGLIB - 1),
        !            71:          (pointer) HDB_DIALCODES, sizeof HDB_DIALCODES);
        !            72:   iret = _uuconf_iadd_string (qglobal, abdialcodes, TRUE, FALSE,
        !            73:                              &qglobal->qprocess->pzdialcodefiles,
        !            74:                              pblock);
        !            75:   if (iret != UUCONF_SUCCESS)
        !            76:     return iret;
        !            77: 
        !            78:   /* Read the Sysfiles file.  We allocate the name on the heap rather
        !            79:      than the stack so that we can return it in
        !            80:      qerr->uuconf_zfilename.  */
        !            81: 
        !            82:   zsys = uuconf_malloc (pblock,
        !            83:                        sizeof OLDCONFIGLIB + sizeof HDB_SYSFILES - 1);
        !            84:   if (zsys == NULL)
        !            85:     {
        !            86:       qglobal->ierrno = errno;
        !            87:       return UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
        !            88:     }
        !            89:   memcpy ((pointer) zsys, (pointer) abHoldconfiglib, sizeof OLDCONFIGLIB - 1);
        !            90:   memcpy ((pointer) (zsys + sizeof OLDCONFIGLIB - 1), (pointer) HDB_SYSFILES,
        !            91:          sizeof HDB_SYSFILES);
        !            92: 
        !            93:   iret = UUCONF_SUCCESS;
        !            94: 
        !            95:   e = fopen (zsys, "r");
        !            96:   if (e == NULL)
        !            97:     uuconf_free (pblock, zsys);
        !            98:   else
        !            99:     {
        !           100:       char *zline;
        !           101:       size_t cline;
        !           102:       char **pzargs;
        !           103:       size_t cargs;
        !           104:       char **pzcolon;
        !           105:       size_t ccolon;
        !           106:       int cchars;
        !           107: 
        !           108:       zline = NULL;
        !           109:       cline = 0;
        !           110:       pzargs = NULL;
        !           111:       cargs = 0;
        !           112:       pzcolon = NULL;
        !           113:       ccolon = 0;
        !           114: 
        !           115:       qglobal->ilineno = 0;
        !           116: 
        !           117:       while (iret == UUCONF_SUCCESS
        !           118:             && (cchars = _uuconf_getline (qglobal, &zline, &cline, e)) > 0)
        !           119:        {
        !           120:          int ctypes, cnames;
        !           121:          int i;
        !           122: 
        !           123:          ++qglobal->ilineno;
        !           124: 
        !           125:          --cchars;
        !           126:          if (zline[cchars] == '\n')
        !           127:            zline[cchars] = '\0';
        !           128:          if (isspace (BUCHAR (zline[0])) || zline[0] == '#')
        !           129:            continue;
        !           130: 
        !           131:          ctypes = _uuconf_istrsplit (zline, '\0', &pzargs, &cargs);
        !           132:          if (ctypes < 0)
        !           133:            {
        !           134:              qglobal->ierrno = errno;
        !           135:              iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
        !           136:              break;
        !           137:            }
        !           138: 
        !           139:          if (ctypes == 0)
        !           140:            continue;
        !           141: 
        !           142:          if (strncmp (pzargs[0], "service=", sizeof "service=" - 1) != 0)
        !           143:            {
        !           144:              iret = UUCONF_SYNTAX_ERROR;
        !           145:              break;
        !           146:            }
        !           147:          pzargs[0] += sizeof "service=" - 1;
        !           148: 
        !           149:          cnames = _uuconf_istrsplit (pzargs[0], ':', &pzcolon, &ccolon);
        !           150:          if (cnames < 0)
        !           151:            {
        !           152:              qglobal->ierrno = errno;
        !           153:              iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
        !           154:              break;
        !           155:            }
        !           156: 
        !           157:          for (i = 0; i < cnames; i++)
        !           158:            if (strcmp (zprogram, pzcolon[i]) == 0)
        !           159:              break;
        !           160: 
        !           161:          if (i >= cnames)
        !           162:            continue;
        !           163: 
        !           164:          for (i = 1; i < ctypes && iret == UUCONF_SUCCESS; i++)
        !           165:            {
        !           166:              char ***ppz;
        !           167:              int cfiles, ifile;
        !           168:              
        !           169:              if (strncmp (pzargs[i], "systems=", sizeof "systems=" - 1)
        !           170:                  == 0)
        !           171:                {
        !           172:                  ppz = &qglobal->qprocess->pzhdb_systems;
        !           173:                  pzargs[i] += sizeof "systems=" - 1;
        !           174:                }
        !           175:              else if (strncmp (pzargs[i], "devices=", sizeof "devices=" - 1)
        !           176:                       == 0)
        !           177:                {
        !           178:                  ppz = &qglobal->qprocess->pzhdb_devices;
        !           179:                  pzargs[i] += sizeof "devices=" - 1;
        !           180:                }
        !           181:              else if (strncmp (pzargs[i], "dialers=", sizeof "dialers=" - 1)
        !           182:                       == 0)
        !           183:                {
        !           184:                  ppz = &qglobal->qprocess->pzhdb_dialers;
        !           185:                  pzargs[i] += sizeof "dialers=" - 1;
        !           186:                }
        !           187:              else
        !           188:                {
        !           189:                  iret = UUCONF_SYNTAX_ERROR;
        !           190:                  break;
        !           191:                }
        !           192: 
        !           193:              cfiles = _uuconf_istrsplit (pzargs[i], ':', &pzcolon, &ccolon);
        !           194:              if (cfiles < 0)
        !           195:                {
        !           196:                  qglobal->ierrno = errno;
        !           197:                  iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
        !           198:                  break;
        !           199:                }
        !           200: 
        !           201:              for (ifile = 0;
        !           202:                   ifile < cfiles && iret == UUCONF_SUCCESS;
        !           203:                   ifile++)
        !           204:                {
        !           205:                  /* Looking for a leading '/' is Unix dependent, and
        !           206:                     should probably be changed.  */
        !           207:                  if (pzcolon[ifile][0] == '/')
        !           208:                    iret = _uuconf_iadd_string (qglobal, pzcolon[ifile], TRUE,
        !           209:                                                FALSE, ppz, pblock);
        !           210:                  else
        !           211:                    {
        !           212:                      char *zdir;
        !           213:                      size_t clen;
        !           214: 
        !           215:                      clen = strlen (pzcolon[ifile]);
        !           216:                      zdir = (char *) uuconf_malloc (pblock,
        !           217:                                                     (sizeof OLDCONFIGLIB
        !           218:                                                      + sizeof HDB_SEPARATOR
        !           219:                                                      + clen
        !           220:                                                      - 1));
        !           221:                      if (zdir == NULL)
        !           222:                        {
        !           223:                          qglobal->ierrno = errno;
        !           224:                          iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
        !           225:                          break;
        !           226:                        }
        !           227:                      memcpy ((pointer) zdir, (pointer) abHoldconfiglib,
        !           228:                              sizeof OLDCONFIGLIB - 1);
        !           229:                      memcpy ((pointer) (zdir + sizeof OLDCONFIGLIB - 1),
        !           230:                              HDB_SEPARATOR, sizeof HDB_SEPARATOR - 1);
        !           231:                      memcpy ((pointer) (zdir
        !           232:                                         + sizeof OLDCONFIGLIB - 1
        !           233:                                         + sizeof HDB_SEPARATOR - 1),
        !           234:                              (pointer) pzcolon[ifile], clen + 1);
        !           235:                      iret = _uuconf_iadd_string (qglobal, zdir, FALSE, FALSE,
        !           236:                                                  ppz, pblock);
        !           237:                    }
        !           238:                }
        !           239:            }
        !           240:        }
        !           241: 
        !           242:       (void) fclose (e);
        !           243:       if (zline != NULL)
        !           244:        free ((pointer) zline);
        !           245:       if (pzargs != NULL)
        !           246:        free ((pointer) pzargs);
        !           247:       if (pzcolon != NULL)
        !           248:        free ((pointer) pzcolon);
        !           249: 
        !           250:       if (iret != UUCONF_SUCCESS)
        !           251:        {
        !           252:          qglobal->zfilename = zsys;
        !           253:          return iret | UUCONF_ERROR_FILENAME | UUCONF_ERROR_LINENO;
        !           254:        }
        !           255:     }
        !           256: 
        !           257:   if (qglobal->qprocess->pzhdb_systems == NULL)
        !           258:     {
        !           259:       char ab[sizeof OLDCONFIGLIB + sizeof HDB_SYSTEMS - 1];
        !           260: 
        !           261:       memcpy ((pointer) ab, (pointer) abHoldconfiglib,
        !           262:              sizeof OLDCONFIGLIB - 1);
        !           263:       memcpy ((pointer) (ab + sizeof OLDCONFIGLIB - 1),
        !           264:              (pointer) HDB_SYSTEMS, sizeof HDB_SYSTEMS);
        !           265:       iret = _uuconf_iadd_string (qglobal, ab, TRUE, FALSE,
        !           266:                                  &qglobal->qprocess->pzhdb_systems,
        !           267:                                  pblock);
        !           268:     }
        !           269:   if (qglobal->qprocess->pzhdb_devices == NULL && iret == UUCONF_SUCCESS)
        !           270:     {
        !           271:       char ab[sizeof OLDCONFIGLIB + sizeof HDB_DEVICES - 1];
        !           272: 
        !           273:       memcpy ((pointer) ab, (pointer) abHoldconfiglib,
        !           274:              sizeof OLDCONFIGLIB - 1);
        !           275:       memcpy ((pointer) (ab + sizeof OLDCONFIGLIB - 1),
        !           276:              (pointer) HDB_DEVICES, sizeof HDB_DEVICES);
        !           277:       iret = _uuconf_iadd_string (qglobal, ab, TRUE, FALSE,
        !           278:                                  &qglobal->qprocess->pzhdb_devices,
        !           279:                                  pblock);
        !           280:     }
        !           281:   if (qglobal->qprocess->pzhdb_dialers == NULL && iret == UUCONF_SUCCESS)
        !           282:     {
        !           283:       char ab[sizeof OLDCONFIGLIB + sizeof HDB_DIALERS - 1];
        !           284: 
        !           285:       memcpy ((pointer) ab, (pointer) abHoldconfiglib,
        !           286:              sizeof OLDCONFIGLIB - 1);
        !           287:       memcpy ((pointer) (ab + sizeof OLDCONFIGLIB - 1),
        !           288:              (pointer) HDB_DIALERS, sizeof HDB_DIALERS);
        !           289:       iret = _uuconf_iadd_string (qglobal, ab, TRUE, FALSE,
        !           290:                                  &qglobal->qprocess->pzhdb_dialers,
        !           291:                                  pblock);
        !           292:     }
        !           293: 
        !           294:   return iret;
        !           295: }

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