![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spool.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 / unix|
Return to spool.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix |
1.1 root 1: /* spool.c
2: Find a file in the spool directory.
3:
4: Copyright (C) 1991, 1992 Ian Lance Taylor
5:
6: This file is part of the Taylor UUCP package.
7:
8: This program is free software; you can redistribute it and/or
9: modify it under the terms of the GNU General Public License as
10: published by the Free Software Foundation; either version 2 of the
11: License, or (at your option) any later version.
12:
13: This program 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: General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with this program; 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 "uucp.h"
27:
28: #if USE_RCS_ID
29: const char spool_rcsid[] = "$Id: spool.c,v 1.1 93/07/30 08:03:28 bin Exp Locker: bin $";
30: #endif
31:
32: #include "uudefs.h"
33: #include "sysdep.h"
34: #include "system.h"
35:
36: /* There are several types of files that go in the spool directory,
37: and they go into various different subdirectories. Whenever the
38: system name LOCAL appears below, it means whatever the local system
39: name is.
40:
41: Command files
42: These contain instructions for uucico indicating what files to transfer
43: to and from what systems. Each line of a work file is a command
44: beginning with S, R or X.
45: #if ! SPOOLDIR_TAYLOR
46: They are named C.ssssssgqqqq, where ssssss is the system name to
47: transfer to or from, g is the grade and qqqq is the sequence number.
48: #if SPOOLDIR_V2
49: They are put in the spool directory.
50: #elif SPOOLDIR_BSD42 || SPOOLDIR_BSD43
51: They are put in the directory "C.".
52: #elif SPOOLDIR_HDB
53: They are put in a directory named for the system for which they were
54: created.
55: #elif SPOOLDIR_ULTRIX
56: If the directory sys/ssssss exists, they are put in the directory
57: sys/ssssss/C; otherwise, they are put in the directory sys/DEFAULT/C.
58: #endif
59: #elif SPOOLDIR_SVR4
60: They are put in the directory sys/g, where sys is the system name
61: and g is the grade.
62: #endif
63: #else SPOOLDIR_TAYLOR
64: They are named C.gqqqq, where g is the grade and qqqq is the sequence
65: number, and are placed in the directory ssssss/C. where ssssss is
66: the system name to transfer to or from.
67: #endif
68:
69: Data files
70: There are files to be transferred to other systems. Some files to
71: be transferred may not be in the spool directory, depending on how
72: uucp was invoked. Data files are named in work files, so it is
73: never necessary to look at them directly (except to remove old ones);
74: it is only necessary to create them. These means that the many
75: variations in naming are inconsequential.
76: #if ! SPOOLDIR_TAYLOR
77: They are named D.ssssssgqqqq where ssssss is a system name (which
78: may be LOCAL for locally initiated transfers or a remote system for
79: remotely initiated transfers, except that HDB appears to use the
80: system the file is being transferred to), g is the grade and qqqq
81: is the sequence number. Some systems use a trailing subjob ID
82: number, but we currently do not. The grade is not important, and
83: some systems do not use it. If the data file is to become an
84: execution file on another system the grade (if present) will be
85: 'X'. Otherwise Ultrix appears to use 'b'; the uux included with
86: gnuucp 1.0 appears to use 'S'; SCO does not appear to use a grade,
87: although it does use a subjob ID number.
88: #if SPOOLDIR_V2
89: They are put in the spool directory.
90: #elif SPOOLDIR_BSD42
91: If the name begins with D.LOCAL, the file is put in the directory
92: D.LOCAL. Otherwise the file is put in the directory D..
93: #elif SPOOLDIR_BSD43
94: If the name begins with D.LOCALX, the file is put in the directory
95: D.LOCALX. Otherwise if the name begins with D.LOCAL, the file is
96: put in the directory D.LOCAL Otherwise the file is put in the
97: directory "D.".
98: #elif SPOOLDIR_HDB
99: They are put in a directory named for the system for which they
100: were created.
101: #elif SPOOLDIR_ULTRIX
102: Say the file is being transferred to system REMOTE. If the
103: directory sys/REMOTE exists, then if the file begins with D.LOCALX
104: it is put in sys/REMOTE/D.LOCALX, if the file begins with D.LOCAL
105: it is put in sys/REMOTE/D.LOCAL, and otherwise it is put in
106: "sys/REMOTE/D.". If the directory sys/REMOTE does not exist, the
107: same applies except that DEFAULT is used instead of REMOTE.
108: #elif SPOOLDIR_SVR4
109: They are put in the directory sys/g, where sys is the system name
110: and g is the grade.
111: #endif
112: #else SPOOLDIR_TAYLOR
113: If the file is to become an executable file on another system it is
114: named D.Xqqqq, otherwise it is named D.qqqq where in both cases
115: qqqq is a sequence number. If the corresponding C. file is in
116: directory ssssss/C., a D.X file is placed in ssssss/D.X and a D.
117: file is placed in "ssssss/D.".
118: #endif
119:
120: Execute files
121: These are files that specify programs to be executed. They are
122: created by uux, perhaps as run on another system. These names are
123: important, because a file transfer done to an execute file name
124: causes an execution to occur. The name is X.ssssssgqqqq, where
125: ssssss is the requesting system, g is the grade, and qqqq is a
126: sequence number.
127: #if SPOOLDIR_V2 || SPOOLDIR_BSD42
128: These files are placed in the spool directory.
129: #elif SPOOLDIR_BSD43
130: These files are placed in the directory X..
131: #elif SPOOLDIR_HDB || SPOOLDIR_SVR4
132: These files are put in a directory named for the system for which
133: the files were created.
134: #elif SPOOLDIR_ULTRIX
135: If there is a spool directory (sys/ssssss) for the requesting
136: system, the files are placed in sys/ssssss/X.; otherwise, the files
137: are placed in "sys/DEFAULT/X.".
138: #elif SPOOLDIR_TAYLOR
139: The system name is automatically truncated to seven characters when
140: a file is created. The files are placed in the subdirectory X. of
141: a directory named for the system for which the files were created.
142: #endif
143:
144: Temporary receive files
145: These are used when receiving files from another system. They are
146: later renamed to the final name. The actual name is unimportant,
147: although it generally begins with TM..
148: #if SPOOLDIR_V2 || SPOOLDIR_BSD42
149: These files are placed in the spool directory.
150: #elif SPOOLDIR_BSD43 || SPOOLDIR_ULTRIX || SPOOLDIR_TAYLOR
151: These files are placed in the directory .Temp.
152: #elif SPOOLDIR_HDB || SPOOLDIR_SVR4
153: These files are placed in a directory named for the system for
154: which they were created.
155: #endif
156:
157: System status files
158: These are used to record when the last call was made to the system
159: and what the status is. They are used to prevent frequent recalls
160: to a system which is not responding. I will not attempt to
161: recreate the format of these exactly, since they are not all that
162: important. They will be put in the directory .Status, as in HDB,
163: and they use the system name as the name of the file.
164:
165: Sequence file
166: This is used to generate a unique sequence number. It contains an
167: ASCII number.
168: #if SPOOLDIR_V2 || SPOOLDIR_BSD42 || SPOOLDIR_BSD43
169: The file is named SEQF and is kept in the spool directory.
170: #elif SPOOLDIR_HDB || SPOOLDIR_SVR4
171: A separate sequence file is kept for each system in the directory
172: .Sequence with the name of the system.
173: #elif SPOOLDIR_ULTRIX
174: Each system with a file sys/ssssss has a sequence file in
175: sys/ssssss/.SEQF. Other systems use sys/DEFAULT/.SEQF.
176: #else SPOOLDIR_TAYLOR
177: A sequence file named SEQF is kept in the directory ssssss for each
178: system.
179: #endif
180: */
181:
182: /* Given the name of a file as specified in a UUCP command, and the
183: system for which this file has been created, return where to find
184: it in the spool directory. The file will begin with C. (a command
185: file), D. (a data file) or X. (an execution file). Under
186: SPOOLDIR_SVR4 we need to know the grade of the file created by the
187: local system; this is the bgrade argument, which is -1 for a file
188: from a remote system. */
189:
190: /*ARGSUSED*/
191: char *
192: zsfind_file (zsimple, zsystem, bgrade)
193: const char *zsimple;
194: const char *zsystem;
195: int bgrade;
196: {
197: if (! fspool_file (zsimple))
198: {
199: ulog (LOG_ERROR, "Unrecognized file name %s", zsimple);
200: return NULL;
201: }
202:
203: #if ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4 && ! SPOOLDIR_TAYLOR
204: if (*zsimple == 'X')
205: {
206: size_t clen;
207:
208: /* Files beginning with X. are execute files. It is important
209: for security reasons that we know the system which created
210: the X. file. This is easy under SPOOLDIR_HDB or
211: SPOOLDIR_SVR4 SPOOLDIR_TAYLOR, because the file will be in a
212: directory named for the system. Under other schemes, we must
213: get the system name from the X. file name. To prevent
214: security violations, we set the system name directly here;
215: this will cause problems if the maximum file name length is
216: too short, but hopefully no problem will occur since any
217: System V systems will be using HDB or SVR4 or TAYLOR. */
218: clen = strlen (zsimple);
219: if (clen <= 7 || strncmp (zsimple + 2, zsystem, clen - 7) != 0)
220: {
221: static char *zbuf;
222: static size_t cbuf;
223: size_t cwant;
224:
225: cwant = strlen (zsystem) + 8;
226: if (cwant > cbuf)
227: {
228: zbuf = (char *) xrealloc ((pointer) zbuf, cwant);
229: cbuf = cwant;
230: }
231: sprintf (zbuf, "X.%s%s", zsystem,
232: clen < 5 ? zsimple : zsimple + clen - 5);
233: zsimple = zbuf;
234: }
235: }
236: #endif /* ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4 && ! SPOOLDIR_TAYLOR */
237:
238: #if SPOOLDIR_V2
239: /* V2 never uses subdirectories. */
240: return zbufcpy (zsimple);
241: #endif /* SPOOLDIR_V2 */
242:
243: #if SPOOLDIR_HDB
244: /* HDB always uses the system name as a directory. */
245: return zsysdep_in_dir (zsystem, zsimple);
246: #endif /* SPOOLDIR_HDB */
247:
248: #if SPOOLDIR_SVR4
249: /* SVR4 uses grade directories within the system directory for local
250: command and data files. */
251: if (bgrade < 0 || *zsimple == 'X')
252: return zsysdep_in_dir (zsystem, zsimple);
253: else
254: {
255: char abgrade[2];
256:
257: abgrade[0] = bgrade;
258: abgrade[1] = '\0';
259: return zsappend3 (zsystem, abgrade, zsimple);
260: }
261: #endif /* SPOOLDIR_SVR4 */
262:
263: #if ! SPOOLDIR_V2 && ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4
264: switch (*zsimple)
265: {
266: case 'C':
267: #if SPOOLDIR_BSD42 || SPOOLDIR_BSD43
268: return zsysdep_in_dir ("C.", zsimple);
269: #endif /* SPOOLDIR_BSD42 || SPOOLDIR_BSD43 */
270: #if SPOOLDIR_ULTRIX
271: if (fsultrix_has_spool (zsystem))
272: return zsappend4 ("sys", zsystem, "C.", zsimple);
273: else
274: return zsappend4 ("sys", "DEFAULT", "C.", zsimple);
275: #endif /* SPOOLDIR_ULTRIX */
276: #if SPOOLDIR_TAYLOR
277: return zsappend3 (zsystem, "C.", zsimple);
278: #endif /* SPOOLDIR_TAYLOR */
279:
280: case 'D':
281: #if SPOOLDIR_BSD42 || SPOOLDIR_BSD43
282: {
283: size_t c;
284: boolean ftruncated;
285:
286: /* D.LOCAL in D.LOCAL/, others in D./. If BSD43, D.LOCALX in
287: D.LOCALX/. */
288: ftruncated = TRUE;
289: if (strncmp (zsimple + 2, zSlocalname, strlen (zSlocalname)) == 0)
290: {
291: c = strlen (zSlocalname);
292: ftruncated = FALSE;
293: }
294: else if (strncmp (zsimple + 2, zSlocalname, 7) == 0)
295: c = 7;
296: else if (strncmp (zsimple + 2, zSlocalname, 6) == 0)
297: c = 6;
298: else
299: c = 0;
300: #if SPOOLDIR_BSD43
301: if (c > 0 && zsimple[c + 2] == 'X')
302: c++;
303: #endif /* SPOOLDIR_BSD43 */
304: if (c > 0)
305: {
306: char *zalloc;
307:
308: zalloc = zbufalc (c + 3);
309: memcpy (zalloc, zsimple, c + 2);
310: zalloc[c + 2] = '\0';
311:
312: /* If we truncated the system name, and there is no existing
313: directory with the truncated name, then just use D.. */
314: if (! ftruncated || fsysdep_directory (zalloc))
315: {
316: char *zret;
317:
318: zret = zsysdep_in_dir (zalloc, zsimple);
319: ubuffree (zalloc);
320: return zret;
321: }
322: ubuffree (zalloc);
323: }
324: return zsysdep_in_dir ("D.", zsimple);
325: }
326: #endif /* SPOOLDIR_BSD42 || SPOOLDIR_BSD43 */
327: #if SPOOLDIR_ULTRIX
328: {
329: size_t c;
330: boolean ftruncated;
331: char *zfree;
332: const char *zdir;
333: char *zret;
334:
335: /* D.LOCALX in D.LOCALX/, D.LOCAL in D.LOCAL/, others in D./. */
336: ftruncated = TRUE;
337: if (strncmp (zsimple + 2, zSlocalname, strlen (zSlocalname)) == 0)
338: {
339: c = strlen (zSlocalname);
340: ftruncated = FALSE;
341: }
342: else if (strncmp (zsimple + 2, zSlocalname, 7) == 0)
343: c = 7;
344: else if (strncmp (zsimple + 2, zSlocalname, 6) == 0)
345: c = 6;
346: else
347: c = 0;
348: if (c > 0 && zsimple[c + 2] == 'X')
349: ++c;
350: if (c > 0)
351: {
352: zfree = zbufalc (c + 3);
353: memcpy (zfree, zsimple, c + 2);
354: zfree[c + 2] = '\0';
355: zdir = zfree;
356:
357: /* If we truncated the name, and there is no directory for
358: the truncated name, then don't use it. */
359: if (ftruncated)
360: {
361: char *zlook;
362:
363: zlook = zsappend3 ("sys",
364: (fsultrix_has_spool (zsystem)
365: ? zsystem
366: : "DEFAULT"),
367: zdir);
368: if (! fsysdep_directory (zlook))
369: zdir = "D.";
370: ubuffree (zlook);
371: }
372: }
373: else
374: {
375: zfree = NULL;
376: zdir = "D.";
377: }
378:
379: zret = zsappend4 ("sys",
380: (fsultrix_has_spool (zsystem)
381: ? zsystem
382: : "DEFAULT"),
383: zdir,
384: zsimple);
385: ubuffree (zfree);
386: return zret;
387: }
388: #endif /* SPOOLDIR_ULTRIX */
389: #if SPOOLDIR_TAYLOR
390: if (zsimple[2] == 'X')
391: return zsappend3 (zsystem, "D.X", zsimple);
392: else
393: return zsappend3 (zsystem, "D.", zsimple);
394: #endif /* SPOOLDIR_TAYLOR */
395:
396:
397: case 'X':
398: #if SPOOLDIR_BSD42
399: return zbufcpy (zsimple);
400: #endif
401: #if SPOOLDIR_BSD43
402: return zsysdep_in_dir ("X.", zsimple);
403: #endif
404: #if SPOOLDIR_ULTRIX
405: return zsappend4 ("sys",
406: (fsultrix_has_spool (zsystem)
407: ? zsystem
408: : "DEFAULT"),
409: "X.",
410: zsimple);
411: #endif
412: #if SPOOLDIR_TAYLOR
413: return zsappend3 (zsystem, "X.", zsimple);
414: #endif
415: }
416:
417: /* This is just to avoid warnings; it will never be executed. */
418: return NULL;
419: #endif /* ! SPOOLDIR_V2 && ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4 */
420: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.