![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tinit.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 tinit.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / uuconf |
1.1 root 1: /* tinit.c
2: Initialize for reading Taylor UUCP 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_tinit_rcsid[] = "$Id: tinit.c,v 1.1 93/07/30 08:08:00 bin Exp Locker: bin $";
30: #endif
31:
32: #include <errno.h>
33:
34: /* Local functions. */
35:
36: static int itset_default P((struct sglobal *qglobal, char ***ppzvar,
37: const char *zfile));
38: static int itadd P((pointer pglobal, int argc, char **argv, pointer pvar,
39: pointer pinfo));
40: static int itunknown P((pointer pglobal, int argc, char **argv, pointer pvar,
41: pointer pinfo));
42: static int itprogram P((pointer pglobal, int argc, char **argv, pointer pvar,
43: pointer pinfo));
44:
45: static const struct cmdtab_offset asCmds[] =
46: {
47: { "nodename", UUCONF_CMDTABTYPE_STRING,
48: offsetof (struct sprocess, zlocalname), NULL },
49: { "hostname", UUCONF_CMDTABTYPE_STRING,
50: offsetof (struct sprocess, zlocalname), NULL },
51: { "uuname", UUCONF_CMDTABTYPE_STRING,
52: offsetof (struct sprocess, zlocalname), NULL },
53: { "spool", UUCONF_CMDTABTYPE_STRING,
54: offsetof (struct sprocess, zspooldir), NULL },
55: { "pubdir", UUCONF_CMDTABTYPE_STRING,
56: offsetof (struct sprocess, zpubdir), NULL },
57: { "lockdir", UUCONF_CMDTABTYPE_STRING,
58: offsetof (struct sprocess, zlockdir), NULL },
59: { "logfile", UUCONF_CMDTABTYPE_STRING,
60: offsetof (struct sprocess, zlogfile), NULL },
61: { "statfile", UUCONF_CMDTABTYPE_STRING,
62: offsetof (struct sprocess, zstatsfile), NULL },
63: { "debugfile", UUCONF_CMDTABTYPE_STRING,
64: offsetof (struct sprocess, zdebugfile), NULL },
65: { "debug", UUCONF_CMDTABTYPE_STRING,
66: offsetof (struct sprocess, zdebug), NULL },
67: { "max-uuxqts", UUCONF_CMDTABTYPE_INT,
68: offsetof (struct sprocess, cmaxuuxqts), NULL },
69: { "sysfile", UUCONF_CMDTABTYPE_FN | 0,
70: offsetof (struct sprocess, pzsysfiles), itadd },
71: { "portfile", UUCONF_CMDTABTYPE_FN | 0,
72: offsetof (struct sprocess, pzportfiles), itadd },
73: { "dialfile", UUCONF_CMDTABTYPE_FN | 0,
74: offsetof (struct sprocess, pzdialfiles), itadd },
75: { "dialcodefile", UUCONF_CMDTABTYPE_FN | 0,
76: offsetof (struct sprocess, pzdialcodefiles), itadd },
77: { "callfile", UUCONF_CMDTABTYPE_FN | 0,
78: offsetof (struct sprocess, pzcallfiles), itadd },
79: { "passwdfile", UUCONF_CMDTABTYPE_FN | 0,
80: offsetof (struct sprocess, pzpwdfiles), itadd },
81: { "unknown", UUCONF_CMDTABTYPE_FN, offsetof (struct sprocess, qunknown),
82: itunknown },
83: { "v2-files", UUCONF_CMDTABTYPE_BOOLEAN,
84: offsetof (struct sprocess, fv2), NULL },
85: { "hdb-files", UUCONF_CMDTABTYPE_BOOLEAN,
86: offsetof (struct sprocess, fhdb), NULL },
87: { "bnu-files", UUCONF_CMDTABTYPE_BOOLEAN,
88: offsetof (struct sprocess, fhdb), NULL },
89: { "timetable", UUCONF_CMDTABTYPE_FN | 3,
90: offsetof (struct sprocess, pztimetables), _uuconf_itimetable },
91: { NULL, 0, 0, NULL }
92: };
93:
94: #define CCMDS (sizeof asCmds / sizeof asCmds[0])
95:
96: /* This structure is used to pass information into the command table
97: functions. */
98:
99: struct sinfo
100: {
101: /* The program name. */
102: const char *zname;
103: /* A pointer to the command table being used, passed to isystem so
104: it can call uuconf_cmd_args. */
105: struct uuconf_cmdtab *qcmds;
106: };
107:
108: /* Initialize the routines which read the Taylor UUCP configuration
109: files. */
110:
111: int
112: uuconf_taylor_init (ppglobal, zprogram, zname)
113: pointer *ppglobal;
114: const char *zprogram;
115: const char *zname;
116: {
117: struct sglobal **pqglobal = (struct sglobal **) ppglobal;
118: int iret;
119: char *zcopy;
120: struct sglobal *qglobal;
121: boolean fdefault;
122: FILE *e;
123: struct sinfo si;
124:
125: if (*pqglobal == NULL)
126: {
127: iret = _uuconf_iinit_global (pqglobal);
128: if (iret != UUCONF_SUCCESS)
129: return iret;
130: }
131:
132: qglobal = *pqglobal;
133:
134: if (zname != NULL)
135: {
136: size_t csize;
137:
138: csize = strlen (zname) + 1;
139: zcopy = uuconf_malloc (qglobal->pblock, csize);
140: if (zcopy == NULL)
141: {
142: qglobal->ierrno = errno;
143: return UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
144: }
145: memcpy ((pointer) zcopy, (pointer) zname, csize);
146: fdefault = FALSE;
147: }
148: else
149: {
150: zcopy = uuconf_malloc (qglobal->pblock,
151: sizeof NEWCONFIGLIB + sizeof CONFIGFILE - 1);
152: if (zcopy == NULL)
153: {
154: qglobal->ierrno = errno;
155: return UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
156: }
157: memcpy ((pointer) zcopy, (pointer) NEWCONFIGLIB,
158: sizeof NEWCONFIGLIB - 1);
159: memcpy ((pointer) (zcopy + sizeof NEWCONFIGLIB - 1),
160: (pointer) CONFIGFILE, sizeof CONFIGFILE);
161: fdefault = TRUE;
162: }
163:
164: qglobal->qprocess->zconfigfile = zcopy;
165:
166: e = fopen (zcopy, "r");
167: if (e == NULL)
168: {
169: if (! fdefault)
170: {
171: qglobal->ierrno = errno;
172: qglobal->zfilename = zcopy;
173: return (UUCONF_FOPEN_FAILED
174: | UUCONF_ERROR_ERRNO
175: | UUCONF_ERROR_FILENAME);
176: }
177:
178: /* There is no config file, so just use the default values. */
179: }
180: else
181: {
182: struct uuconf_cmdtab as[CCMDS];
183:
184: _uuconf_ucmdtab_base (asCmds, CCMDS, (char *) qglobal->qprocess,
185: as);
186:
187: if (zprogram == NULL)
188: zprogram = "uucp";
189:
190: si.zname = zprogram;
191: si.qcmds = as;
192: iret = uuconf_cmd_file (qglobal, e, as, (pointer) &si, itprogram,
193: UUCONF_CMDTABFLAG_BACKSLASH,
194: qglobal->pblock);
195:
196: (void) fclose (e);
197:
198: if (iret != UUCONF_SUCCESS)
199: {
200: qglobal->zfilename = zcopy;
201: return iret | UUCONF_ERROR_FILENAME;
202: }
203: }
204:
205: /* Get the defaults for the file names. */
206:
207: iret = itset_default (qglobal, &qglobal->qprocess->pzsysfiles, SYSFILE);
208: if (iret != UUCONF_SUCCESS)
209: return iret;
210: iret = itset_default (qglobal, &qglobal->qprocess->pzportfiles, PORTFILE);
211: if (iret != UUCONF_SUCCESS)
212: return iret;
213: iret = itset_default (qglobal, &qglobal->qprocess->pzdialfiles, DIALFILE);
214: if (iret != UUCONF_SUCCESS)
215: return iret;
216: iret = itset_default (qglobal, &qglobal->qprocess->pzdialcodefiles,
217: DIALCODEFILE);
218: if (iret != UUCONF_SUCCESS)
219: return iret;
220: iret = itset_default (qglobal, &qglobal->qprocess->pzpwdfiles, PASSWDFILE);
221: if (iret != UUCONF_SUCCESS)
222: return iret;
223: iret = itset_default (qglobal, &qglobal->qprocess->pzcallfiles, CALLFILE);
224: if (iret != UUCONF_SUCCESS)
225: return iret;
226:
227: return UUCONF_SUCCESS;
228: }
229:
230: /* Add new strings to a variable. */
231:
232: /*ARGSUSED*/
233: static int
234: itadd (pglobal, argc, argv, pvar, pinfo)
235: pointer pglobal;
236: int argc;
237: char **argv;
238: pointer pvar;
239: pointer pinfo;
240: {
241: struct sglobal *qglobal = (struct sglobal *) pglobal;
242: char ***ppz = (char ***) pvar;
243: int i;
244: int iret;
245:
246: if (argc == 1)
247: {
248: iret = _uuconf_iadd_string (qglobal, NULL, FALSE, FALSE, ppz,
249: qglobal->pblock);
250: if (iret != UUCONF_SUCCESS)
251: return iret;
252: }
253: else
254: {
255: for (i = 1; i < argc; i++)
256: {
257: iret = _uuconf_iadd_string (qglobal, argv[i], TRUE, FALSE, ppz,
258: qglobal->pblock);
259: if (iret != UUCONF_SUCCESS)
260: return iret;
261: }
262: }
263:
264: return UUCONF_CMDTABRET_CONTINUE;
265: }
266:
267: /* Handle an "unknown" command. We accumulate this into a linked
268: list, and only parse them later in uuconf_unknown_system_info. */
269:
270: /*ARGSUSED*/
271: static int
272: itunknown (pglobal, argc, argv, pvar, pinfo)
273: pointer pglobal;
274: int argc;
275: char **argv;
276: pointer pvar;
277: pointer pinfo;
278: {
279: struct sglobal *qglobal = (struct sglobal *) pglobal;
280: struct sunknown **pq = (struct sunknown **) pvar;
281: struct sunknown *q;
282:
283: q = (struct sunknown *) uuconf_malloc (qglobal->pblock,
284: sizeof (struct sunknown));
285: if (q == NULL)
286: {
287: qglobal->ierrno = errno;
288: return (UUCONF_MALLOC_FAILED
289: | UUCONF_ERROR_ERRNO
290: | UUCONF_CMDTABRET_EXIT);
291: }
292: q->qnext = NULL;
293: q->ilineno = qglobal->ilineno;
294: q->cargs = argc - 1;
295: q->pzargs = (char **) uuconf_malloc (qglobal->pblock,
296: (argc - 1) * sizeof (char *));
297: if (q->pzargs == NULL)
298: {
299: qglobal->ierrno = errno;
300: return (UUCONF_MALLOC_FAILED
301: | UUCONF_ERROR_ERRNO
302: | UUCONF_CMDTABRET_EXIT);
303: }
304: memcpy ((pointer) q->pzargs, (pointer) (argv + 1),
305: (argc - 1) * sizeof (char *));
306:
307: while (*pq != NULL)
308: pq = &(*pq)->qnext;
309:
310: *pq = q;
311:
312: return UUCONF_CMDTABRET_KEEP;
313: }
314:
315: /* If we encounter an unknown command, see if it is the program with
316: which we were invoked. If it was, pass the remaining arguments
317: back through the table. */
318:
319: /*ARGSUSED*/
320: static int
321: itprogram (pglobal, argc, argv, pvar, pinfo)
322: pointer pglobal;
323: int argc;
324: char **argv;
325: pointer pvar;
326: pointer pinfo;
327: {
328: struct sglobal *qglobal = (struct sglobal *) pglobal;
329: struct sinfo *qinfo = (struct sinfo *) pinfo;
330:
331: if (argc <= 1
332: || strcasecmp (qinfo->zname, argv[0]) != 0)
333: return UUCONF_CMDTABRET_CONTINUE;
334:
335: return uuconf_cmd_args (pglobal, argc - 1, argv + 1, qinfo->qcmds,
336: (pointer) NULL, (uuconf_cmdtabfn) NULL, 0,
337: qglobal->pblock);
338: }
339:
340: /* If a filename was not set by the configuration file, add in the
341: default value. */
342:
343: static int
344: itset_default (qglobal, ppzvar, zfile)
345: struct sglobal *qglobal;
346: char ***ppzvar;
347: const char *zfile;
348: {
349: size_t clen;
350: char *zadd;
351:
352: if (*ppzvar != NULL)
353: return UUCONF_SUCCESS;
354:
355: clen = strlen (zfile);
356: zadd = (char *) uuconf_malloc (qglobal->pblock,
357: sizeof NEWCONFIGLIB + clen);
358: if (zadd == NULL)
359: {
360: qglobal->ierrno = errno;
361: return UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
362: }
363:
364: memcpy ((pointer) zadd, (pointer) NEWCONFIGLIB, sizeof NEWCONFIGLIB - 1);
365: memcpy ((pointer) (zadd + sizeof NEWCONFIGLIB - 1), (pointer) zfile,
366: clen + 1);
367:
368: return _uuconf_iadd_string (qglobal, zadd, FALSE, FALSE, ppzvar,
369: qglobal->pblock);
370: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.