![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rdlocs.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 rdlocs.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / uuconf |
1.1 root 1: /* rdlocs.c
2: Get the locations of systems in the 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_rdlocs_rcsid[] = "$Id: rdlocs.c,v 1.1 93/07/30 08:07:28 bin Exp Locker: bin $";
30: #endif
31:
32: #include <errno.h>
33:
34: static int itsystem P((pointer pglobal, int argc, char **argv,
35: pointer pvar, pointer pinfo));
36: static int itcalled_login P((pointer pglobal, int argc, char **argv,
37: pointer pvar, pointer pinfo));
38: static int itmyname P((pointer pglobal, int argc, char **argv,
39: pointer pvar, pointer pinfo));
40:
41: /* This code scans through the Taylor UUCP system files in order to
42: locate each system and to gather the login restrictions (since this
43: information is held in additional arguments to the "called-login"
44: command, it can appear anywhere in the systems files). It also
45: records whether any "myname" appears, as an optimization for
46: uuconf_taylor_localname.
47:
48: This table is used to dispatch the appropriate commands. Most
49: commands are simply ignored. Note that this is a uuconf_cmdtab,
50: not a cmdtab_offset. */
51:
52: static const struct uuconf_cmdtab asTcmds[] =
53: {
54: { "system", UUCONF_CMDTABTYPE_FN | 2, NULL, itsystem },
55: { "alias", UUCONF_CMDTABTYPE_FN | 2, (pointer) asTcmds, itsystem },
56: { "called-login", UUCONF_CMDTABTYPE_FN | 0, NULL, itcalled_login },
57: { "myname", UUCONF_CMDTABTYPE_FN | 2, NULL, itmyname },
58: { NULL, 0, NULL, NULL }
59: };
60:
61: /* This structure is used to pass information into the command table
62: functions. */
63:
64: struct sinfo
65: {
66: /* The sys file name. */
67: const char *zname;
68: /* The open sys file. */
69: FILE *e;
70: /* The list of locations we are building. */
71: struct stsysloc *qlocs;
72: /* The list of validation restrictions we are building. */
73: struct svalidate *qvals;
74: };
75:
76: /* Look through the sys files to find the location and names of all
77: the systems. Since we're scanning the sys files, we also record
78: the validation information specified by the additional arguments to
79: the called-login command. We don't use uuconf_cmd_file to avoid
80: the overhead of breaking the line up into arguments if not
81: necessary. */
82:
83: int
84: _uuconf_iread_locations (qglobal)
85: struct sglobal *qglobal;
86: {
87: char *zline;
88: size_t cline;
89: struct sinfo si;
90: int iret;
91: char **pz;
92:
93: if (qglobal->qprocess->fread_syslocs)
94: return UUCONF_SUCCESS;
95:
96: zline = NULL;
97: cline = 0;
98:
99: si.qlocs = NULL;
100: si.qvals = NULL;
101:
102: iret = UUCONF_SUCCESS;
103:
104: for (pz = qglobal->qprocess->pzsysfiles; *pz != NULL; pz++)
105: {
106: FILE *e;
107: int cchars;
108:
109: qglobal->ilineno = 0;
110:
111: e = fopen (*pz, "r");
112: if (e == NULL)
113: {
114: if (FNO_SUCH_FILE ())
115: continue;
116: qglobal->ierrno = errno;
117: iret = UUCONF_FOPEN_FAILED | UUCONF_ERROR_ERRNO;
118: break;
119: }
120:
121: #ifdef CLOSE_ON_EXEC
122: CLOSE_ON_EXEC (e);
123: #endif
124:
125: si.zname = *pz;
126: si.e = e;
127:
128: while ((cchars = _uuconf_getline (qglobal, &zline, &cline, e)) > 0)
129: {
130: char *zcmd;
131:
132: ++qglobal->ilineno;
133:
134: zcmd = zline + strspn (zline, " \t");
135: if (strncasecmp (zcmd, "system", sizeof "system" - 1) == 0
136: || strncasecmp (zcmd, "alias", sizeof "alias" - 1) == 0
137: || strncasecmp (zcmd, "called-login",
138: sizeof "called-login" - 1) == 0
139: || strncasecmp (zcmd, "myname", sizeof "myname" - 1) == 0)
140: {
141: iret = uuconf_cmd_line ((pointer) qglobal, zline, asTcmds,
142: (pointer) &si, (uuconf_cmdtabfn) NULL,
143: 0, qglobal->pblock);
144: if ((iret & UUCONF_CMDTABRET_KEEP) != 0)
145: {
146: iret &=~ UUCONF_CMDTABRET_KEEP;
147: zline = NULL;
148: cline = 0;
149: }
150: if (iret != UUCONF_SUCCESS)
151: {
152: iret &=~ UUCONF_CMDTABRET_EXIT;
153: break;
154: }
155: }
156: }
157:
158: if (iret != UUCONF_SUCCESS)
159: break;
160: }
161:
162: if (zline != NULL)
163: free ((pointer) zline);
164:
165: if (iret != UUCONF_SUCCESS)
166: {
167: qglobal->zfilename = *pz;
168: iret |= UUCONF_ERROR_FILENAME | UUCONF_ERROR_LINENO;
169: if (UUCONF_ERROR_VALUE (iret) != UUCONF_MALLOC_FAILED)
170: qglobal->qprocess->fread_syslocs = TRUE;
171: }
172: else
173: {
174: qglobal->qprocess->qsyslocs = si.qlocs;
175: qglobal->qprocess->qvalidate = si.qvals;
176: qglobal->qprocess->fread_syslocs = TRUE;
177: }
178:
179: return iret;
180: }
181:
182: /* Handle a "system" or "alias" command by recording the file and
183: location. If pvar is not NULL, this is an "alias" command. */
184:
185: /*ARGSUSED*/
186: static int
187: itsystem (pglobal, argc, argv, pvar, pinfo)
188: pointer pglobal;
189: int argc;
190: char **argv;
191: pointer pvar;
192: pointer pinfo;
193: {
194: struct sglobal *qglobal = (struct sglobal *) pglobal;
195: struct sinfo *qinfo = (struct sinfo *) pinfo;
196: struct stsysloc *q;
197: size_t csize;
198:
199: q = (struct stsysloc *) uuconf_malloc (qglobal->pblock,
200: sizeof (struct stsysloc));
201: if (q == NULL)
202: {
203: qglobal->ierrno = errno;
204: return (UUCONF_MALLOC_FAILED
205: | UUCONF_ERROR_ERRNO
206: | UUCONF_CMDTABRET_EXIT);
207: }
208:
209: csize = strlen (argv[1]) + 1;
210: q->zname = uuconf_malloc (qglobal->pblock, csize);
211: if (q->zname == NULL)
212: {
213: qglobal->ierrno = errno;
214: return (UUCONF_MALLOC_FAILED
215: | UUCONF_ERROR_ERRNO
216: | UUCONF_CMDTABRET_EXIT);
217: }
218:
219: q->qnext = qinfo->qlocs;
220: memcpy ((pointer) q->zname, (pointer) argv[1], csize);
221: q->falias = pvar != NULL;
222: q->zfile = qinfo->zname;
223: q->e = qinfo->e;
224: q->iloc = ftell (qinfo->e);
225: q->ilineno = qglobal->ilineno;
226:
227: qinfo->qlocs = q;
228:
229: return UUCONF_CMDTABRET_CONTINUE;
230: }
231:
232: /* Handle the "called-login" command. This just records any extra
233: arguments, so that uuconf_validate can check them later if
234: necessary. */
235:
236: /*ARGSUSED*/
237: static int
238: itcalled_login (pglobal, argc, argv, pvar, pinfo)
239: pointer pglobal;
240: int argc;
241: char **argv;
242: pointer pvar;
243: pointer pinfo;
244: {
245: struct sglobal *qglobal = (struct sglobal *) pglobal;
246: struct sinfo *qinfo = (struct sinfo *) pinfo;
247: register struct svalidate *qval;
248: int i;
249:
250: if (argc <= 2)
251: return UUCONF_CMDTABRET_CONTINUE;
252:
253: for (qval = qinfo->qvals; qval != NULL; qval = qval->qnext)
254: if (strcmp (argv[1], qval->zlogname) == 0)
255: break;
256:
257: if (qval == NULL)
258: {
259: qval = (struct svalidate *) uuconf_malloc (qglobal->pblock,
260: sizeof (struct svalidate));
261: if (qval == NULL)
262: {
263: qglobal->ierrno = errno;
264: return (UUCONF_MALLOC_FAILED
265: | UUCONF_ERROR_ERRNO
266: | UUCONF_CMDTABRET_EXIT);
267: }
268:
269: qval->qnext = qinfo->qvals;
270: qval->zlogname = argv[1];
271: qval->pzmachines = NULL;
272:
273: qinfo->qvals = qval;
274: }
275:
276: for (i = 2; i < argc; i++)
277: {
278: int iret;
279:
280: iret = _uuconf_iadd_string (qglobal, argv[i], FALSE, TRUE,
281: &qval->pzmachines, qglobal->pblock);
282: if (iret != UUCONF_SUCCESS)
283: return iret | UUCONF_CMDTABRET_EXIT;
284: }
285:
286: return UUCONF_CMDTABRET_KEEP;
287: }
288:
289: /* Handle the "myname" command by simply recording that it appears.
290: This information is used by uuconf_taylor_localname. */
291:
292: /*ARGSUSED*/
293: static int
294: itmyname (pglobal, argc, argv, pvar, pinfo)
295: pointer pglobal;
296: int argc;
297: char **argv;
298: pointer pvar;
299: pointer pinfo;
300: {
301: struct sglobal *qglobal = (struct sglobal *) pglobal;
302:
303: qglobal->qprocess->fuses_myname = TRUE;
304: return UUCONF_CMDTABRET_CONTINUE;
305: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.