![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hinit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / uuconf|
Return to hinit.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / uuconf |
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.