![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uux.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|
Return to uux.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* uux.c
2: Prepare to execute a command on a remote system.
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 uux_rcsid[] = "$Id: uux.c,v 1.1 93/07/30 08:00:09 bin Exp Locker: bin $";
30: #endif
31:
32: #include "uudefs.h"
33: #include "uuconf.h"
34: #include "system.h"
35: #include "sysdep.h"
36: #include "getopt.h"
37:
38: #include <ctype.h>
39: #include <errno.h>
40:
41: /* These character lists should, perhaps, be in sysdep.h. */
42:
43: /* This is the list of shell metacharacters that we check for. If one
44: of these is present, we request uuxqt to execute the command with
45: /bin/sh. Otherwise we let it execute using execve. */
46:
47: #define ZSHELLCHARS "\"'`*?[;&()|<>\\$"
48:
49: /* This is the list of word separators. We break filename arguments
50: at these characters. */
51: #define ZSHELLSEPS ";&*|<> \t"
52:
53: /* This is the list of word separators without the redirection
54: operators. */
55: #define ZSHELLNONREDIRSEPS ";&*| \t"
56:
57: /* The program name. */
58: char abProgram[] = "uux";
59:
60: /* The name of the execute file. */
61: const char *zXxqt_name;
62:
63: /* The execute file we are creating. */
64: static FILE *eXxqt_file;
65:
66: /* A list of commands to be spooled. */
67: static struct scmd *pasXcmds;
68: static int cXcmds;
69:
70: /* A file to close if we're forced to exit. */
71: static FILE *eXclose;
72:
73: /* Local functions. */
74: static void uxusage P((void));
75: static void uxadd_xqt_line P((int bchar, const char *z1, const char *z2));
76: static void uxadd_send_file P((const char *zfrom, const char *zto,
77: const char *zoptions, const char *ztemp,
78: const char *zforward,
79: const struct uuconf_system *qxqtsys,
80: const char *zxqtloc,
81: int bgrade));
82: static void uxcopy_stdin P((FILE *e));
83: static void uxrecord_file P((const char *zfile));
84: static void uxabort P((void));
85:
86: /* Long getopt options. */
87: static const struct option asXlongopts[] = { { NULL, 0, NULL, 0 } };
88:
89: /* The main routine. */
90:
91: int
92: main (argc, argv)
93: int argc;
94: char **argv;
95: {
96: /* -a: requestor address for status reports. */
97: const char *zrequestor = NULL;
98: /* -b: if true, return standard input on error. */
99: boolean fretstdin = FALSE;
100: /* -c,-C: if true, copy to spool directory. */
101: boolean fcopy = FALSE;
102: /* -c: set if -c appears explicitly; if it and -l appear, then if the
103: link fails we don't copy the file. */
104: boolean fdontcopy = FALSE;
105: /* -I: configuration file name. */
106: const char *zconfig = NULL;
107: /* -j: output job id. */
108: boolean fjobid = FALSE;
109: /* -g: job grade. */
110: char bgrade = BDEFAULT_UUX_GRADE;
111: /* -l: link file to spool directory. */
112: boolean flink = FALSE;
113: /* -n: do not notify upon command completion. */
114: boolean fno_ack = FALSE;
115: /* -p: read standard input for command standard input. */
116: boolean fread_stdin = FALSE;
117: /* -r: do not start uucico when finished. */
118: boolean fuucico = TRUE;
119: /* -s: report status to named file. */
120: const char *zstatus_file = NULL;
121: /* -W: only expand local file names. */
122: boolean fexpand = TRUE;
123: /* -z: report status only on error. */
124: boolean ferror_ack = FALSE;
125: int iopt;
126: pointer puuconf;
127: int iuuconf;
128: const char *zlocalname;
129: const char *zxqtloc;
130: int i;
131: size_t clen;
132: char *zargs;
133: char *zarg;
134: char *zcmd;
135: const char *zsys;
136: char *zexclam;
137: boolean fgetcwd;
138: const char *zuser;
139: struct uuconf_system sxqtsys;
140: boolean fxqtlocal;
141: char *zforward;
142: char **pzargs;
143: int calloc_args;
144: int cargs;
145: char abxqt_tname[CFILE_NAME_LEN];
146: char abxqt_xname[CFILE_NAME_LEN];
147: const char *zinput_from;
148: const char *zinput_to;
149: const char *zinput_temp;
150: boolean finputcopied;
151: char *zcall_system;
152: boolean fcall_any;
153: struct uuconf_system slocalsys;
154: boolean fneedshell;
155: char *zfullcmd;
156: boolean fexit;
157:
158: /* We need to be able to read a single - as an option, which getopt
159: won't do. So that we can still use getopt, we run through the
160: options looking for an option "-"; if we find one we change it to
161: "-p", which is equivalent to "-". */
162: for (i = 1; i < argc; i++)
163: {
164: if (argv[i][0] != '-')
165: break;
166: if (argv[i][1] == '\0')
167: argv[i] = zbufcpy ("-p");
168: else
169: {
170: const char *z;
171:
172: for (z = argv[i] + 1; *z != '\0'; z++)
173: {
174: /* If the option takes an argument, and the argument is
175: not appended, then skip the next argument. */
176: if (*z == 'a' || *z == 'g' || *z == 'I'
177: || *z == 's' || *z == 'x')
178: {
179: if (z[1] == '\0')
180: i++;
181: break;
182: }
183: }
184: }
185: }
186:
187: /* The leading + in the getopt string means to stop processing
188: options as soon as a non-option argument is seen. */
189: while ((iopt = getopt_long (argc, argv, "+a:bcCg:I:jlnprs:Wx:z",
190: asXlongopts, (int *) NULL)) != EOF)
191: {
192: switch (iopt)
193: {
194: case 'a':
195: /* Set requestor name: mail address to which status reports
196: should be sent. */
197: zrequestor = optarg;
198: break;
199:
200: case 'b':
201: /* Return standard input on error. */
202: fretstdin = TRUE;
203: break;
204:
205: case 'c':
206: /* Do not copy local files to spool directory. */
207: fcopy = FALSE;
208: fdontcopy = TRUE;
209: break;
210:
211: case 'C':
212: /* Copy local files to spool directory. */
213: fcopy = TRUE;
214: break;
215:
216: case 'I':
217: /* Configuration file name. */
218: if (fsysdep_other_config (optarg))
219: zconfig = optarg;
220: break;
221:
222: case 'j':
223: /* Output jobid. */
224: fjobid = TRUE;
225: break;
226:
227: case 'g':
228: /* Set job grade. */
229: bgrade = optarg[0];
230: break;
231:
232: case 'l':
233: /* Link file to spool directory. */
234: flink = TRUE;
235: break;
236:
237: case 'n':
238: /* Do not notify upon command completion. */
239: fno_ack = TRUE;
240: break;
241:
242: case 'p':
243: /* Read standard input for command standard input. */
244: fread_stdin = TRUE;
245: break;
246:
247: case 'r':
248: /* Do not start uucico when finished. */
249: fuucico = FALSE;
250: break;
251:
252: case 's':
253: /* Report status to named file. */
254: zstatus_file = optarg;
255: break;
256:
257: case 'W':
258: /* Only expand local file names. */
259: fexpand = FALSE;
260: break;
261:
262: case 'x':
263: #if DEBUG > 1
264: /* Set debugging level. */
265: iDebug |= idebug_parse (optarg);
266: #endif
267: break;
268:
269: case 'z':
270: /* Report status only on error. */
271: ferror_ack = TRUE;
272: break;
273:
274: case 0:
275: /* Long option found and flag set. */
276: break;
277:
278: default:
279: uxusage ();
280: break;
281: }
282: }
283:
284: if (! UUCONF_GRADE_LEGAL (bgrade))
285: {
286: ulog (LOG_ERROR, "Ignoring illegal grade");
287: bgrade = BDEFAULT_UUX_GRADE;
288: }
289:
290: if (optind == argc)
291: uxusage ();
292:
293: iuuconf = uuconf_init (&puuconf, (const char *) NULL, zconfig);
294: if (iuuconf != UUCONF_SUCCESS)
295: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
296:
297: #if DEBUG > 1
298: {
299: const char *zdebug;
300:
301: iuuconf = uuconf_debuglevel (puuconf, &zdebug);
302: if (iuuconf != UUCONF_SUCCESS)
303: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
304: if (zdebug != NULL)
305: iDebug |= idebug_parse (zdebug);
306: }
307: #endif
308:
309: /* The command and files arguments could be quoted in any number of
310: ways, so we split them apart ourselves. We do this before
311: calling usysdep_initialize because we want to set fgetcwd
312: correctly. */
313: clen = 1;
314: for (i = optind; i < argc; i++)
315: clen += strlen (argv[i]) + 1;
316:
317: zargs = zbufalc (clen);
318: *zargs = '\0';
319: for (i = optind; i < argc; i++)
320: {
321: strcat (zargs, argv[i]);
322: strcat (zargs, " ");
323: }
324:
325: /* The first argument is the command to execute. */
326: clen = strcspn (zargs, ZSHELLSEPS);
327: zcmd = zbufalc (clen + 1);
328: strncpy (zcmd, zargs, clen);
329: zcmd[clen] = '\0';
330: zargs += clen;
331:
332: /* Split the arguments out into an array. We break the arguments
333: into alternating sequences of characters not in ZSHELLSEPS
334: and characters in ZSHELLSEPS. We remove whitespace. We
335: separate the redirection characters '>' and '<' into their
336: own arguments to make them easier to process below. */
337: calloc_args = 10;
338: pzargs = (char **) xmalloc (calloc_args * sizeof (char *));
339: cargs = 0;
340:
341: for (zarg = strtok (zargs, " \t");
342: zarg != NULL;
343: zarg = strtok ((char *) NULL, " \t"))
344: {
345: while (*zarg != '\0')
346: {
347: if (cargs + 1 >= calloc_args)
348: {
349: calloc_args += 10;
350: pzargs = (char **) xrealloc ((pointer) pzargs,
351: calloc_args * sizeof (char *));
352: }
353:
354: clen = strcspn (zarg, ZSHELLSEPS);
355: if (clen > 0)
356: {
357: pzargs[cargs] = zbufalc (clen + 1);
358: memcpy (pzargs[cargs], zarg, clen);
359: pzargs[cargs][clen] = '\0';
360: ++cargs;
361: zarg += clen;
362: }
363:
364: /* We deliberately separate '>' and '<' out. */
365: if (*zarg != '\0')
366: {
367: clen = strspn (zarg, ZSHELLNONREDIRSEPS);
368: if (clen == 0)
369: clen = 1;
370: pzargs[cargs] = zbufalc (clen + 1);
371: memcpy (pzargs[cargs], zarg, clen);
372: pzargs[cargs][clen] = '\0';
373: ++cargs;
374: zarg += clen;
375: }
376: }
377: }
378:
379: /* Now look through the arguments to see if we are going to need the
380: current working directory. We don't try to make a precise
381: determination, just a conservative one. The basic idea is that
382: we don't want to get the cwd for 'foo!rmail - user' (note that we
383: don't examine the command itself). */
384: fgetcwd = FALSE;
385: for (i = 0; i < cargs; i++)
386: {
387: if (pzargs[i][0] == '(')
388: continue;
389: zexclam = strrchr (pzargs[i], '!');
390: if (zexclam != NULL && fsysdep_needs_cwd (zexclam + 1))
391: {
392: fgetcwd = TRUE;
393: break;
394: }
395: if ((pzargs[i][0] == '<' || pzargs[i][0] == '>')
396: && i + 1 < cargs
397: && strchr (pzargs[i + 1], '!') == NULL
398: && fsysdep_needs_cwd (pzargs[i + 1]))
399: {
400: fgetcwd = TRUE;
401: break;
402: }
403: }
404:
405: #ifdef SIGINT
406: usysdep_signal (SIGINT);
407: #endif
408: #ifdef SIGHUP
409: usysdep_signal (SIGHUP);
410: #endif
411: #ifdef SIGQUIT
412: usysdep_signal (SIGQUIT);
413: #endif
414: #ifdef SIGTERM
415: usysdep_signal (SIGTERM);
416: #endif
417: #ifdef SIGPIPE
418: usysdep_signal (SIGPIPE);
419: #endif
420:
421: usysdep_initialize (puuconf, INIT_SUID | (fgetcwd ? INIT_GETCWD : 0));
422:
423: ulog_fatal_fn (uxabort);
424:
425: zuser = zsysdep_login_name ();
426:
427: /* Get the local system name. */
428: iuuconf = uuconf_localname (puuconf, &zlocalname);
429: if (iuuconf == UUCONF_NOT_FOUND)
430: {
431: zlocalname = zsysdep_localname ();
432: if (zlocalname == NULL)
433: exit (EXIT_FAILURE);
434: }
435: else if (iuuconf != UUCONF_SUCCESS)
436: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
437:
438: /* Get the local system information. */
439: iuuconf = uuconf_system_info (puuconf, zlocalname, &slocalsys);
440: if (iuuconf != UUCONF_SUCCESS)
441: {
442: if (iuuconf != UUCONF_NOT_FOUND)
443: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
444: iuuconf = uuconf_system_local (puuconf, &slocalsys);
445: if (iuuconf != UUCONF_SUCCESS)
446: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
447: }
448:
449: /* Figure out which system the command is to be executed on. Some
450: mailers apparently pass local!rmail, so we must explicitly check
451: for that. */
452: zexclam = strchr (zcmd, '!');
453: while (zexclam != NULL)
454: {
455: *zexclam = '\0';
456: if (strcmp (zcmd, zlocalname) == 0)
457: ;
458: else if (slocalsys.uuconf_pzalias == NULL)
459: break;
460: else
461: {
462: char **pzal;
463:
464: for (pzal = slocalsys.uuconf_pzalias; *pzal != NULL; pzal++)
465: if (strcmp (zcmd, *pzal) == 0)
466: break;
467: if (*pzal == NULL)
468: break;
469: }
470: zcmd = zexclam + 1;
471: zexclam = strchr (zcmd, '!');
472: }
473: if (zexclam == NULL)
474: {
475: zsys = zlocalname;
476: fxqtlocal = TRUE;
477: zforward = NULL;
478: }
479: else
480: {
481: zsys = zcmd;
482: zcmd = zexclam + 1;
483: fxqtlocal = FALSE;
484:
485: /* See if we must forward this command through other systems
486: (e.g. uux a!b!cmd). */
487: zexclam = strrchr (zcmd, '!');
488: if (zexclam == NULL)
489: zforward = NULL;
490: else
491: {
492: clen = zexclam - zcmd;
493: zforward = zbufalc (clen);
494: memcpy (zforward, zcmd, clen);
495: zforward[clen] = '\0';
496: zcmd = zexclam + 1;
497: }
498: }
499:
500: if (fxqtlocal)
501: sxqtsys = slocalsys;
502: else
503: {
504: iuuconf = uuconf_system_info (puuconf, zsys, &sxqtsys);
505: if (iuuconf != UUCONF_SUCCESS)
506: {
507: if (iuuconf != UUCONF_NOT_FOUND)
508: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
509: if (! funknown_system (puuconf, zsys, &sxqtsys))
510: ulog (LOG_FATAL, "%s: System not found", zsys);
511: }
512: }
513:
514: /* Get the local name the remote system know us as. */
515: zxqtloc = sxqtsys.uuconf_zlocalname;
516: if (zxqtloc == NULL)
517: zxqtloc = zlocalname;
518:
519: /* We can send this as an E command if the execution is on a
520: different, directly connected, system and the only file used is
521: the standard input and comes from this system. This is true of
522: the common cases of rmail and rnews. We get an execute file name
523: here in case we need it. */
524: if (fxqtlocal)
525: zXxqt_name = zsysdep_xqt_file_name ();
526: else
527: zXxqt_name = zsysdep_data_file_name (&sxqtsys, zxqtloc, bgrade, TRUE,
528: abxqt_tname, (char *) NULL,
529: abxqt_xname);
530: if (zXxqt_name == NULL)
531: uxabort ();
532:
533: uxrecord_file (zXxqt_name);
534:
535: /* Look through the arguments. Any argument containing an
536: exclamation point character is interpreted as a file name, and is
537: sent to the appropriate system. */
538: zinput_from = NULL;
539: zinput_to = NULL;
540: zinput_temp = NULL;
541: finputcopied = FALSE;
542: zcall_system = NULL;
543: fcall_any = FALSE;
544:
545: for (i = 0; i < cargs; i++)
546: {
547: const char *zsystem;
548: char *zfile;
549: char *zforw;
550: boolean finput, foutput;
551: boolean flocal, fonxqt;
552:
553: /* Check for a parenthesized argument; remove the parentheses
554: and otherwise ignore it (this is how an exclamation point is
555: quoted). */
556: if (pzargs[i][0] == '(')
557: {
558: clen = strlen (pzargs[i]);
559: if (pzargs[i][clen - 1] != ')')
560: ulog (LOG_ERROR, "Mismatched parentheses");
561: else
562: pzargs[i][clen - 1] = '\0';
563: ++pzargs[i];
564: continue;
565: }
566:
567: /* Check whether we are doing a redirection. */
568: finput = FALSE;
569: foutput = FALSE;
570: if (i + 1 < cargs)
571: {
572: if (pzargs[i][0] == '<')
573: finput = TRUE;
574: else if (pzargs[i][0] == '>')
575: foutput = TRUE;
576: if (finput || foutput)
577: {
578: pzargs[i] = NULL;
579: i++;
580: }
581: }
582:
583: zexclam = strchr (pzargs[i], '!');
584:
585: /* If there is no exclamation point and no redirection, this
586: argument is left untouched. */
587: if (zexclam == NULL && ! finput && ! foutput)
588: continue;
589:
590: /* Get the system name and file name for this file. */
591: if (zexclam == NULL)
592: {
593: zsystem = zlocalname;
594: zfile = pzargs[i];
595: flocal = TRUE;
596: zforw = NULL;
597: }
598: else
599: {
600: *zexclam = '\0';
601: zsystem = pzargs[i];
602: if (*zsystem != '\0')
603: flocal = FALSE;
604: else
605: {
606: zsystem = zlocalname;
607: flocal = TRUE;
608: }
609: zfile = zexclam + 1;
610: zexclam = strrchr (zfile, '!');
611: if (zexclam == NULL)
612: zforw = NULL;
613: else
614: {
615: if (flocal)
616: ulog (LOG_FATAL, "!%s: Can't figure out where to get file",
617: zfile);
618: *zexclam = '\0';
619: zforw = zfile;
620: zfile = zexclam + 1;
621: }
622: }
623:
624: /* Check if the file is already on the execution system. */
625: if (flocal)
626: fonxqt = fxqtlocal;
627: else if (fxqtlocal)
628: fonxqt = FALSE;
629: else if (zforward == NULL ? zforw != NULL : zforw == NULL)
630: fonxqt = FALSE;
631: else if (zforward != NULL
632: && zforw != NULL
633: && strcmp (zforward, zforw) != 0)
634: fonxqt = FALSE;
635: else if (strcmp (zsystem, sxqtsys.uuconf_zname) == 0)
636: fonxqt = TRUE;
637: else if (sxqtsys.uuconf_pzalias == NULL)
638: fonxqt = FALSE;
639: else
640: {
641: char **pzal;
642:
643: fonxqt = FALSE;
644: for (pzal = sxqtsys.uuconf_pzalias; *pzal != NULL; pzal++)
645: {
646: if (strcmp (zsystem, *pzal) == 0)
647: {
648: fonxqt = TRUE;
649: break;
650: }
651: }
652: }
653:
654: /* Turn the file into an absolute path. */
655: if (flocal)
656: zfile = zsysdep_local_file_cwd (zfile, sxqtsys.uuconf_zpubdir);
657: else if (fexpand)
658: zfile = zsysdep_add_cwd (zfile);
659: if (zfile == NULL)
660: uxabort ();
661:
662: /* Check for output redirection. */
663: if (foutput)
664: {
665: if (flocal)
666: {
667: if (! fin_directory_list (zfile,
668: sxqtsys.uuconf_pzremote_receive,
669: sxqtsys.uuconf_zpubdir, TRUE,
670: FALSE, (const char *) NULL))
671: ulog (LOG_FATAL, "Not permitted to create %s", zfile);
672: }
673:
674: /* There are various cases of output redirection.
675:
676: uux cmd >out: The command is executed on the local
677: system, and the output file is placed on the local
678: system (fonxqt is TRUE).
679:
680: uux cmd >a!out: The command is executed on the local
681: system, and the output file is sent to a.
682:
683: uux a!cmd >out: The command is executed on a, and the
684: output file is returned to the local system (flocal
685: is TRUE).
686:
687: uux a!cmd >a!out: The command is executed on a, and the
688: output file is left on a (fonxqt is TRUE).
689:
690: uux a!cmd >b!out: The command is executed on a, and the
691: output file is sent to b; traditionally, I believe
692: that b is relative to a, rather than to the local
693: system. However, this essentially contradicts the
694: previous two cases, in which the output file is
695: relative to the local system.
696:
697: Now, the cases that we don't handle.
698:
699: uux cmd >a!b!out: The command is executed on the local
700: system, and the output file is sent to b via a. This
701: requires the local uuxqt to support forwarding of the
702: output file.
703:
704: uux a!b!cmd >out: The command is executed on b, which is
705: reached via a. Probably the output file is intended
706: for the local system, in which case the uuxqt on b
707: must support forwarding of the output file.
708:
709: uux a!b!cmd >c!out: Is c relative to b or to the local
710: system? If it's relative to b this is easy to
711: handle. Otherwise, we must arrange for the file to
712: be sent back to the local system and for the local
713: system to send it on to c.
714:
715: There are many variations of the last case. It's not at
716: all clear to me how they should be handled. */
717: if (zforward != NULL || zforw != NULL)
718: ulog (LOG_FATAL, "May not forward standard output");
719:
720: if (fonxqt)
721: uxadd_xqt_line ('O', zfile, (const char *) NULL);
722: else if (flocal)
723: uxadd_xqt_line ('O', zfile, zxqtloc);
724: else
725: uxadd_xqt_line ('O', zfile, zsystem);
726: pzargs[i] = NULL;
727: continue;
728: }
729:
730: if (finput)
731: {
732: if (fread_stdin)
733: ulog (LOG_FATAL, "Standard input specified twice");
734: pzargs[i] = NULL;
735: }
736:
737: if (flocal)
738: {
739: char *zuse;
740: char *zdata;
741: char abtname[CFILE_NAME_LEN];
742: char abdname[CFILE_NAME_LEN];
743:
744: /* It's a local file. If requested by -C, copy the file to
745: the spool directory. If requested by -l, link the file
746: to the spool directory; if the link fails, we copy the
747: file, unless -c was explictly used. If the execution is
748: occurring on the local system, we force the copy as well,
749: because otherwise we would have to have some way to tell
750: uuxqt not to move the file. If the file is being shipped
751: to another system, we must set up a transfer request.
752: First make sure the user has legitimate access, since we
753: are running setuid. */
754: if (! fsysdep_access (zfile))
755: uxabort ();
756:
757: zdata = zsysdep_data_file_name (&sxqtsys, zxqtloc, bgrade, FALSE,
758: abtname, abdname, (char *) NULL);
759: if (zdata == NULL)
760: uxabort ();
761:
762: if (fcopy || flink || fxqtlocal)
763: {
764: boolean fdid;
765:
766: uxrecord_file (zdata);
767:
768: fdid = FALSE;
769: if (flink)
770: {
771: boolean fworked;
772:
773: if (! fsysdep_link (zfile, zdata, &fworked))
774: uxabort ();
775:
776: if (fworked)
777: fdid = TRUE;
778: else if (fdontcopy)
779: ulog (LOG_FATAL, "%s: Can't link to spool directory",
780: zfile);
781: }
782:
783: if (! fdid)
784: {
785: openfile_t efile;
786:
787: efile = esysdep_user_fopen (zfile, TRUE, TRUE);
788: if (! ffileisopen (efile))
789: uxabort ();
790: if (! fcopy_open_file (efile, zdata, FALSE, TRUE))
791: uxabort ();
792: (void) ffileclose (efile);
793: }
794:
795: zuse = abtname;
796: }
797: else
798: {
799: /* We don't actually use the spool file name, but we
800: need a name to use as the destination. */
801: ubuffree (zdata);
802: /* Make sure the daemon can access the file. */
803: if (! fsysdep_daemon_access (zfile))
804: uxabort ();
805: if (! fin_directory_list (zfile, sxqtsys.uuconf_pzlocal_send,
806: sxqtsys.uuconf_zpubdir, TRUE,
807: TRUE, zuser))
808: ulog (LOG_FATAL, "Not permitted to send from %s",
809: zfile);
810:
811: zuse = zfile;
812: }
813:
814: if (fxqtlocal)
815: {
816: if (finput)
817: uxadd_xqt_line ('I', zuse, (char *) NULL);
818: else
819: pzargs[i] = zuse;
820: }
821: else
822: {
823: finputcopied = fcopy || flink;
824:
825: if (finput)
826: {
827: zinput_from = zuse;
828: zinput_to = zbufcpy (abdname);
829: zinput_temp = zbufcpy (abtname);
830: }
831: else
832: {
833: char *zbase;
834:
835: uxadd_send_file (zuse, abdname,
836: finputcopied ? "C" : "c",
837: abtname, zforward, &sxqtsys,
838: zxqtloc, bgrade);
839: zbase = zsysdep_base_name (zfile);
840: if (zbase == NULL)
841: uxabort ();
842: uxadd_xqt_line ('F', abdname, zbase);
843: pzargs[i] = zbase;
844: }
845: }
846: }
847: else if (fonxqt)
848: {
849: /* The file is already on the system where the command is to
850: be executed. */
851: if (finput)
852: uxadd_xqt_line ('I', zfile, (const char *) NULL);
853: else
854: pzargs[i] = zfile;
855: }
856: else
857: {
858: struct uuconf_system sfromsys;
859: char abtname[CFILE_NAME_LEN];
860: struct scmd s;
861: char *zjobid;
862:
863: /* We need to request a remote file. */
864: iuuconf = uuconf_system_info (puuconf, zsystem, &sfromsys);
865: if (iuuconf != UUCONF_SUCCESS)
866: {
867: if (iuuconf != UUCONF_NOT_FOUND)
868: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
869: if (! funknown_system (puuconf, zsystem, &sfromsys))
870: ulog (LOG_FATAL, "%s: System not found", zsystem);
871: }
872:
873: if (fonxqt)
874: {
875: /* The file is already on the system where the command is to
876: be executed. */
877: if (finput)
878: uxadd_xqt_line ('I', zfile, (const char *) NULL);
879: else
880: pzargs[i] = zfile;
881: }
882: else
883: {
884: char *zdata;
885:
886: if (! sfromsys.uuconf_fcall_transfer
887: && ! sfromsys.uuconf_fcalled_transfer)
888: ulog (LOG_FATAL,
889: "Not permitted to transfer files to or from %s",
890: sfromsys.uuconf_zname);
891:
892: if (zforw != NULL)
893: {
894: /* This is ``uux cmd a!b!file''. To make this work,
895: we would have to be able to set up a request to a
896: to fetch file from b and send it to us. But it
897: turns out that that will not work, because when a
898: sends us the file we will put it in a's spool
899: directory, not the local system spool directory.
900: So we won't have any way to find it. This is not
901: a conceptual problem, and it could doubtless be
902: solved. Please feel free to solve it and send me
903: the solution. */
904: ulog (LOG_FATAL, "File forwarding not supported");
905: }
906:
907: /* We must request the file from the remote system to
908: this one. */
909: zdata = zsysdep_data_file_name (&slocalsys, zxqtloc, bgrade,
910: FALSE, abtname, (char *) NULL,
911: (char *) NULL);
912: if (zdata == NULL)
913: uxabort ();
914: ubuffree (zdata);
915:
916: /* Request the file. The special option '9' is a signal
917: to uucico that it's OK to receive a file into the
918: spool directory; normally such requests are rejected.
919: This privilege is easy to abuse. */
920: s.bcmd = 'R';
921: s.pseq = NULL;
922: s.zfrom = zfile;
923: s.zto = zbufcpy (abtname);
924: s.zuser = zuser;
925: s.zoptions = "9";
926: s.ztemp = "";
927: s.imode = 0600;
928: s.znotify = "";
929: s.cbytes = -1;
930: s.zcmd = NULL;
931: s.ipos = 0;
932:
933: zjobid = zsysdep_spool_commands (&sfromsys, bgrade, 1, &s);
934: if (zjobid == NULL)
935: uxabort ();
936:
937: if (fjobid)
938: printf ("%s\n", zjobid);
939:
940: ubuffree (zjobid);
941:
942: if (fcall_any)
943: {
944: ubuffree (zcall_system);
945: zcall_system = NULL;
946: }
947: else
948: {
949: fcall_any = TRUE;
950: zcall_system = zbufcpy (sfromsys.uuconf_zname);
951: }
952:
953: if (fxqtlocal)
954: {
955: /* Tell the command execution to wait until the file
956: has been received, and tell it the real file
957: name. */
958: if (finput)
959: {
960: uxadd_xqt_line ('F', abtname, (char *) NULL);
961: uxadd_xqt_line ('I', abtname, (char *) NULL);
962: }
963: else
964: {
965: char *zbase;
966:
967: zbase = zsysdep_base_name (zfile);
968: if (zbase == NULL)
969: uxabort ();
970: uxadd_xqt_line ('F', abtname, zbase);
971: pzargs[i] = zbase;
972: }
973: }
974: else
975: {
976: char abxtname[CFILE_NAME_LEN];
977: char *zbase;
978: char *zxqt;
979: FILE *e;
980:
981: /* Now we must arrange to forward the file on to the
982: execution system. We need to get a name to give
983: the file on the execution system (abxtname). */
984: zdata = zsysdep_data_file_name (&sxqtsys, zxqtloc,
985: bgrade, TRUE, abxtname,
986: (char *) NULL,
987: (char *) NULL);
988: if (zdata == NULL)
989: uxabort ();
990: ubuffree (zdata);
991:
992: zbase = zsysdep_base_name (zfile);
993: if (zbase == NULL)
994: uxabort ();
995:
996: zxqt = zsysdep_xqt_file_name ();
997: if (zxqt == NULL)
998: uxabort ();
999: e = esysdep_fopen (zxqt, FALSE, FALSE, TRUE);
1000: if (e == NULL)
1001: uxabort ();
1002: uxrecord_file (zxqt);
1003:
1004: fprintf (e, "U %s %s\n", zsysdep_login_name (),
1005: zlocalname);
1006: fprintf (e, "F %s %s\n", abtname, zbase);
1007: fprintf (e, "C uucp -C -W -d -g %c %s %s!", bgrade,
1008: zbase, sxqtsys.uuconf_zname);
1009: if (zforward != NULL)
1010: fprintf (e, "%s!", zforward);
1011: fprintf (e, "%s\n", abxtname);
1012:
1013: if (fclose (e) != 0)
1014: ulog (LOG_FATAL, "fclose: %s", strerror (errno));
1015:
1016: if (finput)
1017: {
1018: uxadd_xqt_line ('F', abxtname, (char *) NULL);
1019: uxadd_xqt_line ('I', abxtname, (char *) NULL);
1020: ubuffree (zbase);
1021: }
1022: else
1023: {
1024: uxadd_xqt_line ('F', abxtname, zbase);
1025: pzargs[i] = zbase;
1026: }
1027: }
1028: }
1029:
1030: (void) uuconf_system_free (puuconf, &sfromsys);
1031: }
1032: }
1033:
1034: /* If standard input is to be read from the stdin of uux, we read it
1035: here into a temporary file and send it to the execute system. */
1036: if (fread_stdin)
1037: {
1038: char *zdata;
1039: char abtname[CFILE_NAME_LEN];
1040: char abdname[CFILE_NAME_LEN];
1041: FILE *e;
1042:
1043: zdata = zsysdep_data_file_name (&sxqtsys, zxqtloc, bgrade, FALSE,
1044: abtname, abdname, (char *) NULL);
1045: if (zdata == NULL)
1046: uxabort ();
1047:
1048: e = esysdep_fopen (zdata, FALSE, FALSE, TRUE);
1049: if (e == NULL)
1050: uxabort ();
1051:
1052: eXclose = e;
1053: uxrecord_file (zdata);
1054:
1055: uxcopy_stdin (e);
1056:
1057: eXclose = NULL;
1058: if (fclose (e) != 0)
1059: ulog (LOG_FATAL, "fclose: %s", strerror (errno));
1060:
1061: if (fxqtlocal)
1062: uxadd_xqt_line ('I', abtname, (const char *) NULL);
1063: else
1064: {
1065: zinput_from = zbufcpy (abtname);
1066: zinput_to = zbufcpy (abdname);
1067: zinput_temp = zinput_from;
1068: finputcopied = TRUE;
1069: }
1070: }
1071:
1072: /* If we are returning standard input, or we're putting the status
1073: in a file, we can't use an E command. */
1074: if (fretstdin)
1075: uxadd_xqt_line ('B', (const char *) NULL, (const char *) NULL);
1076:
1077: if (zstatus_file != NULL)
1078: uxadd_xqt_line ('M', zstatus_file, (const char *) NULL);
1079:
1080: /* Get the complete command line, and decide whether the command
1081: needs to be executed by the shell. */
1082: fneedshell = FALSE;
1083:
1084: if (zcmd[strcspn (zcmd, ZSHELLCHARS)] != '\0')
1085: fneedshell = TRUE;
1086:
1087: clen = strlen (zcmd) + 1;
1088: for (i = 0; i < cargs; i++)
1089: {
1090: if (pzargs[i] != NULL)
1091: {
1092: clen += strlen (pzargs[i]) + 1;
1093: if (pzargs[i][strcspn (pzargs[i], ZSHELLCHARS)] != '\0')
1094: fneedshell = TRUE;
1095: }
1096: }
1097:
1098: zfullcmd = zbufalc (clen);
1099:
1100: strcpy (zfullcmd, zcmd);
1101: for (i = 0; i < cargs; i++)
1102: {
1103: if (pzargs[i] != NULL)
1104: {
1105: strcat (zfullcmd, " ");
1106: strcat (zfullcmd, pzargs[i]);
1107: }
1108: }
1109:
1110: /* If we haven't written anything to the execution file yet, and we
1111: have a standard input file, and we're not forwarding, then every
1112: other option can be handled in an E command. */
1113: if (eXxqt_file == NULL && zinput_from != NULL && zforward == NULL)
1114: {
1115: struct scmd s;
1116: char aboptions[10];
1117: char *zoptions;
1118:
1119: /* Set up an E command. */
1120: s.bcmd = 'E';
1121: s.pseq = NULL;
1122: s.zuser = zuser;
1123: s.zfrom = zinput_from;
1124: s.zto = zinput_to;
1125: s.zoptions = aboptions;
1126: zoptions = aboptions;
1127: *zoptions++ = finputcopied ? 'C' : 'c';
1128: if (fno_ack)
1129: *zoptions++ = 'N';
1130: if (ferror_ack)
1131: *zoptions++ = 'Z';
1132: if (zrequestor != NULL)
1133: *zoptions++ = 'R';
1134: if (fneedshell)
1135: *zoptions++ = 'e';
1136: *zoptions = '\0';
1137: s.ztemp = zinput_temp;
1138: s.imode = 0666;
1139: if (zrequestor == NULL)
1140: zrequestor = "\"\"";
1141: s.znotify = zrequestor;
1142: s.cbytes = -1;
1143: s.zcmd = zfullcmd;
1144: s.ipos = 0;
1145:
1146: ++cXcmds;
1147: pasXcmds = (struct scmd *) xrealloc ((pointer) pasXcmds,
1148: cXcmds * sizeof (struct scmd));
1149: pasXcmds[cXcmds - 1] = s;
1150: }
1151: else
1152: {
1153: /* Finish up the execute file. */
1154: uxadd_xqt_line ('U', zuser, zxqtloc);
1155: if (zinput_from != NULL)
1156: {
1157: uxadd_xqt_line ('F', zinput_to, (char *) NULL);
1158: uxadd_xqt_line ('I', zinput_to, (char *) NULL);
1159: uxadd_send_file (zinput_from, zinput_to,
1160: finputcopied ? "C" : "c",
1161: zinput_temp, zforward, &sxqtsys, zxqtloc,
1162: bgrade);
1163: }
1164: if (fno_ack)
1165: uxadd_xqt_line ('N', (const char *) NULL, (const char *) NULL);
1166: if (ferror_ack)
1167: uxadd_xqt_line ('Z', (const char *) NULL, (const char *) NULL);
1168: if (zrequestor != NULL)
1169: uxadd_xqt_line ('R', zrequestor, (const char *) NULL);
1170: if (fneedshell)
1171: uxadd_xqt_line ('e', (const char *) NULL, (const char *) NULL);
1172: uxadd_xqt_line ('C', zfullcmd, (const char *) NULL);
1173: if (fclose (eXxqt_file) != 0)
1174: ulog (LOG_FATAL, "fclose: %s", strerror (errno));
1175: eXxqt_file = NULL;
1176:
1177: /* If the execution is to occur on another system, we must now
1178: arrange to copy the execute file to this system. */
1179: if (! fxqtlocal)
1180: uxadd_send_file (abxqt_tname, abxqt_xname, "C", abxqt_tname,
1181: zforward, &sxqtsys, zxqtloc, bgrade);
1182: }
1183:
1184: /* If we got a signal, get out before spooling anything. */
1185: if (FGOT_SIGNAL ())
1186: uxabort ();
1187:
1188: /* From here on in, it's too late. We don't call uxabort. */
1189: if (cXcmds > 0)
1190: {
1191: char *zjobid;
1192:
1193: if (! sxqtsys.uuconf_fcall_transfer
1194: && ! sxqtsys.uuconf_fcalled_transfer)
1195: ulog (LOG_FATAL, "Not permitted to transfer files to or from %s",
1196: sxqtsys.uuconf_zname);
1197:
1198: zjobid = zsysdep_spool_commands (&sxqtsys, bgrade, cXcmds, pasXcmds);
1199: if (zjobid == NULL)
1200: {
1201: ulog_close ();
1202: usysdep_exit (FALSE);
1203: }
1204:
1205: if (fjobid)
1206: printf ("%s\n", zjobid);
1207:
1208: ubuffree (zjobid);
1209:
1210: if (fcall_any)
1211: {
1212: ubuffree (zcall_system);
1213: zcall_system = NULL;
1214: }
1215: else
1216: {
1217: fcall_any = TRUE;
1218: zcall_system = zbufcpy (sxqtsys.uuconf_zname);
1219: }
1220: }
1221:
1222: /* If all that worked, make a log file entry. All log file reports
1223: up to this point went to stderr. */
1224: ulog_to_file (puuconf, TRUE);
1225: ulog_system (sxqtsys.uuconf_zname);
1226: ulog_user (zuser);
1227:
1228: ulog (LOG_NORMAL, "Queuing %s", zfullcmd);
1229:
1230: ulog_close ();
1231:
1232: if (! fuucico)
1233: fexit = TRUE;
1234: else
1235: {
1236: if (zcall_system != NULL)
1237: fexit = fsysdep_run ("uucico", "-s", zcall_system);
1238: else if (fcall_any)
1239: fexit = fsysdep_run ("uucico", "-r1", (const char *) NULL);
1240: else
1241: fexit = TRUE;
1242: }
1243:
1244: usysdep_exit (fexit);
1245:
1246: /* Avoid error about not returning a value. */
1247: return 0;
1248: }
1249:
1250: /* Report command usage. */
1251:
1252: static void
1253: uxusage ()
1254: {
1255: fprintf (stderr,
1256: "Taylor UUCP version %s, copyright (C) 1991, 1992 Ian Lance Taylor\n",
1257: VERSION);
1258: fprintf (stderr,
1259: "Usage: uux [options] [-] command\n");
1260: fprintf (stderr,
1261: " -,-p: Read standard input for standard input of command\n");
1262: fprintf (stderr,
1263: " -c: Do not copy local files to spool directory (default)\n");
1264: fprintf (stderr,
1265: " -C: Copy local files to spool directory\n");
1266: fprintf (stderr,
1267: " -l: link local files to spool directory\n");
1268: fprintf (stderr,
1269: " -g grade: Set job grade (must be alphabetic)\n");
1270: fprintf (stderr,
1271: " -n: Do not report completion status\n");
1272: fprintf (stderr,
1273: " -z: Report completion status only on error\n");
1274: fprintf (stderr,
1275: " -r: Do not start uucico daemon\n");
1276: fprintf (stderr,
1277: " -a address: Address to mail status report to\n");
1278: fprintf (stderr,
1279: " -b: Return standard input with status report\n");
1280: fprintf (stderr,
1281: " -s file: Report completion status to file\n");
1282: fprintf (stderr,
1283: " -j: Report job id\n");
1284: fprintf (stderr,
1285: " -x debug: Set debugging level\n");
1286: #if HAVE_TAYLOR_CONFIG
1287: fprintf (stderr,
1288: " -I file: Set configuration file to use\n");
1289: #endif /* HAVE_TAYLOR_CONFIG */
1290: exit (EXIT_FAILURE);
1291: }
1292:
1293: /* Add a line to the execute file. */
1294:
1295: static void
1296: uxadd_xqt_line (bchar, z1, z2)
1297: int bchar;
1298: const char *z1;
1299: const char *z2;
1300: {
1301: if (eXxqt_file == NULL)
1302: {
1303: eXxqt_file = esysdep_fopen (zXxqt_name, FALSE, FALSE, TRUE);
1304: if (eXxqt_file == NULL)
1305: uxabort ();
1306: }
1307:
1308: if (z1 == NULL)
1309: fprintf (eXxqt_file, "%c\n", bchar);
1310: else if (z2 == NULL)
1311: fprintf (eXxqt_file, "%c %s\n", bchar, z1);
1312: else
1313: fprintf (eXxqt_file, "%c %s %s\n", bchar, z1, z2);
1314: }
1315:
1316: /* Add a file to be sent to the execute system. */
1317:
1318: static void
1319: uxadd_send_file (zfrom, zto, zoptions, ztemp, zforward, qxqtsys, zxqtloc,
1320: bgrade)
1321: const char *zfrom;
1322: const char *zto;
1323: const char *zoptions;
1324: const char *ztemp;
1325: const char *zforward;
1326: const struct uuconf_system *qxqtsys;
1327: const char *zxqtloc;
1328: int bgrade;
1329: {
1330: struct scmd s;
1331:
1332: if (zforward != NULL)
1333: {
1334: char *zbase;
1335: char *zxqt;
1336: char abtname[CFILE_NAME_LEN];
1337: char abdname[CFILE_NAME_LEN];
1338: char abxname[CFILE_NAME_LEN];
1339: FILE *e;
1340:
1341: /* We want to forward this file through the first execution
1342: system to other systems. We set up a remote execution of
1343: uucp to forward the file. */
1344: zbase = zsysdep_base_name (zfrom);
1345: if (zbase == NULL)
1346: uxabort ();
1347:
1348: zxqt = zsysdep_data_file_name (qxqtsys, zxqtloc, bgrade, TRUE, abtname,
1349: abdname, abxname);
1350: if (zxqt == NULL)
1351: uxabort ();
1352: e = esysdep_fopen (zxqt, FALSE, FALSE, TRUE);
1353: if (e == NULL)
1354: uxabort ();
1355: uxrecord_file (zxqt);
1356:
1357: fprintf (e, "U %s %s\n", zsysdep_login_name (), zxqtloc);
1358: fprintf (e, "F %s %s\n", abdname, zbase);
1359: fprintf (e, "C uucp -C -W -d -g %c %s %s!%s\n",
1360: bgrade, zbase, zforward, zto);
1361:
1362: ubuffree (zbase);
1363:
1364: if (fclose (e) != 0)
1365: ulog (LOG_FATAL, "fclose: %s", strerror (errno));
1366:
1367: /* Send the execution file. */
1368: s.bcmd = 'S';
1369: s.pseq = NULL;
1370: s.zfrom = zbufcpy (abtname);
1371: s.zto = zbufcpy (abxname);
1372: s.zuser = zsysdep_login_name ();
1373: s.zoptions = "C";
1374: s.ztemp = s.zfrom;
1375: s.imode = 0666;
1376: s.znotify = NULL;
1377: s.cbytes = -1;
1378: s.zcmd = NULL;
1379: s.ipos = 0;
1380:
1381: ++cXcmds;
1382: pasXcmds = (struct scmd *) xrealloc ((pointer) pasXcmds,
1383: cXcmds * sizeof (struct scmd));
1384: pasXcmds[cXcmds - 1] = s;
1385:
1386: /* Send the data file to abdname where the execution file will
1387: expect it. */
1388: zto = abdname;
1389: }
1390:
1391: s.bcmd = 'S';
1392: s.pseq = NULL;
1393: s.zfrom = zbufcpy (zfrom);
1394: s.zto = zbufcpy (zto);
1395: s.zuser = zsysdep_login_name ();
1396: s.zoptions = zbufcpy (zoptions);
1397: s.ztemp = zbufcpy (ztemp);
1398: s.imode = 0666;
1399: s.znotify = "";
1400: s.cbytes = -1;
1401: s.zcmd = NULL;
1402: s.ipos = 0;
1403:
1404: ++cXcmds;
1405: pasXcmds = (struct scmd *) xrealloc ((pointer) pasXcmds,
1406: cXcmds * sizeof (struct scmd));
1407: pasXcmds[cXcmds - 1] = s;
1408: }
1409:
1410: /* Copy stdin to a file. This is a separate function because it may
1411: call setjmp. */
1412:
1413: static void
1414: uxcopy_stdin (e)
1415: FILE *e;
1416: {
1417: CATCH_PROTECT size_t cread;
1418: char ab[1024];
1419:
1420: do
1421: {
1422: size_t cwrite;
1423:
1424: /* I want to use fread here, but there is a bug in some versions
1425: of SVR4 which causes fread to return less than a complete
1426: buffer even if EOF has not been reached. This is not online
1427: time, so speed is not critical, but it's still quite annoying
1428: to have to use an inefficient algorithm. */
1429: cread = 0;
1430: if (fsysdep_catch ())
1431: {
1432: usysdep_start_catch ();
1433:
1434: while (cread < sizeof (ab))
1435: {
1436: int b;
1437:
1438: if (FGOT_SIGNAL ())
1439: uxabort ();
1440:
1441: /* There's an unimportant race here. If the user hits
1442: ^C between the FGOT_SIGNAL we just did and the time
1443: we enter getchar, we won't know about the signal
1444: (unless we're doing a longjmp, but we normally
1445: aren't). It's not a big problem, because the user
1446: can just hit ^C again. */
1447: b = getchar ();
1448: if (b == EOF)
1449: break;
1450: ab[cread] = b;
1451: ++cread;
1452: }
1453: }
1454:
1455: usysdep_end_catch ();
1456:
1457: if (FGOT_SIGNAL ())
1458: uxabort ();
1459:
1460: if (cread > 0)
1461: {
1462: cwrite = fwrite (ab, sizeof (char), cread, e);
1463: if (cwrite != cread)
1464: ulog (LOG_FATAL, "fwrite: Wrote %d when attempted %d",
1465: (int) cwrite, (int) cread);
1466: }
1467: }
1468: while (cread == sizeof ab);
1469: }
1470:
1471: /* Keep track of all files we have created so that we can delete them
1472: if we get a signal. The argument will be on the heap. */
1473:
1474: static int cXfiles;
1475: static const char **pXaz;
1476:
1477: static void
1478: uxrecord_file (zfile)
1479: const char *zfile;
1480: {
1481: pXaz = (const char **) xrealloc ((pointer) pXaz,
1482: (cXfiles + 1) * sizeof (const char *));
1483: pXaz[cXfiles] = zfile;
1484: ++cXfiles;
1485: }
1486:
1487: /* Delete all the files we have recorded and exit. */
1488:
1489: static void
1490: uxabort ()
1491: {
1492: int i;
1493:
1494: if (eXxqt_file != NULL)
1495: (void) fclose (eXxqt_file);
1496: if (eXclose != NULL)
1497: (void) fclose (eXclose);
1498: for (i = 0; i < cXfiles; i++)
1499: (void) remove (pXaz[i]);
1500: ulog_close ();
1501: usysdep_exit (FALSE);
1502: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.