![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to system.h 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 system.h CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* system.h
2: Header file for system dependent stuff in the Taylor UUCP package.
3: This file is not itself system dependent.
4:
5: Copyright (C) 1991, 1992 Ian Lance Taylor
6:
7: This file is part of the Taylor UUCP package.
8:
9: This program is free software; you can redistribute it and/or
10: modify it under the terms of the GNU General Public License as
11: published by the Free Software Foundation; either version 2 of the
12: License, or (at your option) any later version.
13:
14: This program is distributed in the hope that it will be useful, but
15: WITHOUT ANY WARRANTY; without even the implied warranty of
16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17: General Public License for more details.
18:
19: You should have received a copy of the GNU General Public License
20: along with this program; if not, write to the Free Software
21: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22:
23: The author of the program may be contacted at [email protected] or
24: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
25: */
26:
27: #ifndef SYSTEM_H
28:
29: #define SYSTEM_H
30:
31: #if ANSI_C
32: /* These structures are used in prototypes but are not defined in this
33: header file. */
34: struct tm;
35: struct uuconf_system;
36: struct uuconf_port;
37: struct sconnection;
38: struct sstatus;
39: struct scmd;
40: #endif
41:
42: /* Any function which returns an error should also report an error
43: message, unless otherwise indicated.
44:
45: Any function that returns a char *, rather than a const char *, is
46: returning a pointer to a buffer allocated by zbufalc which must be
47: freed using ubuffree, unless otherwise indicated. */
48:
49: /* The maximum length of a remote system name. */
50: extern size_t cSysdep_max_name_len;
51:
52: /* Initialize. If something goes wrong, this routine should just
53: exit. The flag argument is 0, or a combination of any of the
54: following flags. */
55:
56: /* This program needs to know the current working directory. This is
57: used because on Unix it can be expensive to determine the current
58: working directory (some versions of getcwd fork a process), but in
59: most cases we don't need to know it. However, we are going to
60: chdir to the spool directory (unless INIT_CHDIR is set), so we have
61: to get the cwd now if we are ever going to get it. Both uucp and
62: uux use the function fsysdep_needs_cwd to determine whether they
63: will need the current working directory, and pass the argument to
64: usysdep_initialize appropriately. There's probably a cleaner way
65: to handle this, but this will suffice for now. */
66: #define INIT_GETCWD (01)
67:
68: /* This program should not chdir to the spool directory. This may
69: only make sense on Unix. It is set by cu. */
70: #define INIT_NOCHDIR (02)
71:
72: /* This program needs special access to the spool directories. That
73: means, on Unix, this program is normally installed setuid. */
74: #define INIT_SUID (04)
75:
76: extern void usysdep_initialize P((pointer puuconf, int iflags));
77:
78: /* Exit the program. The fsuccess argument indicates whether to
79: return an indication of success or failure to the outer
80: environment. This routine should not return. */
81: extern void usysdep_exit P((boolean fsuccess));
82:
83: /* Called when a non-standard configuration file is being used, to
84: avoid handing out privileged access. If it returns FALSE, default
85: configuration file will be used. This is called before the
86: usysdep_initialize function is called. */
87: extern boolean fsysdep_other_config P((const char *));
88:
89: /* Detach from the controlling terminal. This probably only makes
90: sense on Unix. It is called by uucico to try to get the modem port
91: as a controlling terminal. It is also called by uucico before it
92: starts up uuxqt, so that uuxqt will be a complete daemon. */
93: extern void usysdep_detach P((void));
94:
95: /* Get the local node name if it is not specified in the configuration
96: files. Returns NULL on error; otherwise the return value should
97: point to a static buffer. */
98: extern const char *zsysdep_localname P((void));
99:
100: /* Get the login name. This is used when uucico is started up with no
101: arguments in slave mode, which causes it to assume that somebody
102: has logged in. It also used by uucp and uux for recording the user
103: name. This may not return NULL. The return value should point to
104: a static buffer. */
105: extern const char *zsysdep_login_name P((void));
106:
107: /* Set a signal handler for a signal. If the signal occurs, the
108: appropriate element of afSignal should be set to the signal number
109: (see the declaration of afSignal in uucp.h). This routine might be
110: able to just use signal, but Unix requires more complex handling.
111: This is called before usysdep_initialize. */
112: extern void usysdep_signal P((int isig));
113:
114: /* Catch a signal. This is actually defined as a macro in the system
115: dependent header file, and the prototype here just indicates how it
116: should be called. It is called before a routine which must exit if
117: a signal occurs, and is expected to set do a setjmp (which is why
118: it must be a macro). It is actually only called in one place in
119: the system independent code, before the call to read stdin in uux.
120: This is needed to handle 4.2 BSD restartable system calls, which
121: require a longjmp. On systems which don't need to do
122: setjmp/longjmp around system calls, this can be redefined in
123: sysdep.h to TRUE. It should return TRUE if the routine should
124: proceed, or FALSE if a signal occurred. After having this return
125: TRUE, usysdep_start_catch should be used to start catching the
126: signal; this basically tells the signal handler that it's OK to do
127: the longjmp, if fsysdep_catch did not already do so. */
128: #ifndef fsysdep_catch
129: extern boolean fsysdep_catch P((void));
130: #endif
131:
132: /* Start catching a signal. This is called after fsysdep_catch to
133: tell the signal handler to go ahead and do the longjmp. This may
134: be implemented as a macro in sysdep.h. */
135: #ifndef usysdep_start_catch
136: extern void usysdep_start_catch P((void));
137: #endif
138:
139: /* Stop catching a signal. This is called when it is no longer
140: necessary for fsysdep_catch to handle signals. This may be
141: implemented as a macro in sysdep.h. */
142: #ifndef usysdep_end_catch
143: extern void usysdep_end_catch P((void));
144: #endif
145:
146: /* Link two files. On Unix this should attempt the link. If it
147: succeeds it should return TRUE with *pfworked set to TRUE. If the
148: link fails because it must go across a device, it should return
149: TRUE with *pfworked set to FALSE. If the link fails for some other
150: reason, it should log an error message and return FALSE. On a
151: system which does not support links to files, this should just
152: return TRUE with *pfworked set to FALSE. */
153: extern boolean fsysdep_link P((const char *zfrom, const char *zto,
154: boolean *pfworked));
155:
156: /* Get the port name. This is used when uucico is started up in slave
157: mode to figure out which port was used to call in so that it can
158: determine any appropriate protocol parameters. This may return
159: NULL if the port cannot be determined, which will just mean that no
160: protocol parameters are applied. The name returned should be the
161: sort of name that would appear in the port file. This should set
162: *pftcp_port to TRUE if it can determine that the port is a TCP
163: connection rather than a normal serial port. The return value (if
164: not NULL) should point to a static buffer. */
165: extern const char *zsysdep_port_name P((boolean *pftcp_port));
166:
167: /* Expand a file name on the local system. On Unix, if the zfile
168: argument begins with ~user/ it goes in that users home directory,
169: and if it begins with ~/ it goes in the public directory (the
170: public directory is passed to this routine, since each system may
171: have its own public directory). Similar conventions may be
172: desirable on other systems. This should always return an absolute
173: path name, probably in the public directory. It should return NULL
174: on error; otherwise the return value should be allocated using
175: zbufcpy or zbufalc. */
176: extern char *zsysdep_local_file P((const char *zname,
177: const char *zpubdir));
178:
179: /* Return whether a file name is in a directory, and check for read or
180: write access. This should check whether zfile is within zdir (or
181: is zdir itself). If it is not, it should return FALSE. If zfile
182: is in zdir, then fcheck indicates whether further checking should
183: be done. If fcheck is FALSE, no further checking is done.
184: Otherwise, if freadable is TRUE the user zuser should have search
185: access to all directories from zdir down to zfile and should have
186: read access on zfile itself (if zfile does not exist, or is not a
187: regular file, this function may return FALSE but does not have to).
188: If freadable is FALSE, the user zuser should have search access to
189: all directories from zdir down to zfile and should have write
190: access on zfile (which may be a directory, or may not actually
191: exist, which is acceptable). The zuser argument may be NULL, in
192: which case the check should be made for any user, not just zuser.
193: There is no way for this function to return error. */
194: extern boolean fsysdep_in_directory P((const char *zfile,
195: const char *zdir,
196: boolean fcheck,
197: boolean freadable,
198: const char *zuser));
199:
200: /* Return TRUE if a file exists, FALSE otherwise. There is no way to
201: return error. */
202: extern boolean fsysdep_file_exists P((const char *zfile));
203:
204: /* Start up a program. The code expects fsysdep_run to return after
205: doing a fork, but at least for now everything will work fine if it
206: does not (on a system which does not support forking). The three
207: string arguments may be catenated together to form the program to
208: execute; I did it this way to make it easy to call execl(2), and
209: because I never needed more than two arguments. The program will
210: always be "uucico" or "uuxqt". The return value will be passed
211: directly to usysdep_exit, and should be TRUE on success, FALSE on
212: error. */
213: extern boolean fsysdep_run P((const char *zprogram, const char *zarg1,
214: const char *zarg2));
215:
216: /* Send a mail message. This function will be passed an array of
217: strings. All necessary newlines are already included; the strings
218: should simply be concatenated together to form the mail message.
219: It should return FALSE on error, although the return value is often
220: ignored. */
221: extern boolean fsysdep_mail P((const char *zto, const char *zsubject,
222: int cstrs, const char **paz));
223:
224: /* Get the time in seconds since some epoch. The actual epoch is
225: unimportant, so long as the time values are consistent across
226: program executions and the value is never negative. If the
227: pimicros argument is not NULL, it should be set to the number of
228: microseconds (if this is not available, *pimicros should be set to
229: zero). */
230: extern long ixsysdep_time P((long *pimicros));
231:
232: /* Get the time in seconds and microseconds (millionths of a second)
233: since some epoch. The actual epoch is not important, and it may
234: change in between program invocations; this is provided because on
235: Unix the times function may be used. If microseconds can not be
236: determined, *pimicros can just be set to zero. */
237: extern long ixsysdep_process_time P((long *pimicros));
238:
239: /* Parse the value returned by ixsysdep_time into a struct tm. I
240: assume that this structure is defined in <time.h>. This is
241: basically just localtime, except that the ANSI function takes a
242: time_t which may not be what is returned by ixsysdep_time. */
243: extern void usysdep_localtime P((long itime, struct tm *q));
244:
245: /* Sleep for a number of seconds. */
246: extern void usysdep_sleep P((int cseconds));
247:
248: /* Pause for half a second, or 1 second if subsecond sleeps are not
249: possible. */
250: extern void usysdep_pause P((void));
251:
252: /* Lock a remote system. This should return FALSE if the system is
253: already locked (no error should be reported). */
254: extern boolean fsysdep_lock_system P((const struct uuconf_system *qsys));
255:
256: /* Unlock a remote system. This should return FALSE on error
257: (although the return value is generally ignored). */
258: extern boolean fsysdep_unlock_system P((const struct uuconf_system *qsys));
259:
260: /* Get the conversation sequence number for a remote system, and
261: increment it for next time. This should return -1 on error. */
262: extern long ixsysdep_get_sequence P((const struct uuconf_system *qsys));
263:
264: /* Get the status of a remote system. This should return FALSE on
265: error. Otherwise it should set *qret to the status. If no status
266: information is available, this should set *qret to sensible values
267: and return TRUE. If pfnone is not NULL, then it should be set to
268: TRUE if no status information was available or FALSE otherwise. */
269: extern boolean fsysdep_get_status P((const struct uuconf_system *qsys,
270: struct sstatus *qret,
271: boolean *pfnone));
272:
273: /* Set the status of a remote system. This should return FALSE on
274: error. The system will be locked before this call is made. */
275: extern boolean fsysdep_set_status P((const struct uuconf_system *qsys,
276: const struct sstatus *qset));
277:
278: /* See whether a remote system is permitted to log in. This is just
279: to support the remote.unknown shell script for HDB. The zscript
280: argument is the script name, as return by uuconf_remote_unknown.
281: The zsystem argument is the name given by the remote system. If
282: the system is not permitted to log in, this function should log an
283: error and return FALSE. */
284: extern boolean fsysdep_unknown_caller P((const char *zscript,
285: const char *zsystem));
286:
287: /* Check whether there is work for a remote system. It should return
288: TRUE if there is work, FALSE otherwise; there is no way to indicate
289: an error. */
290: extern boolean fsysdep_has_work P((const struct uuconf_system *qsys));
291:
292: /* Initialize the work scan. This will be called before
293: fsysdep_get_work. The bgrade argument is the minimum grade of
294: execution files that should be considered (e.g. a bgrade of 'd'
295: will allow all grades from 'A' to 'Z' and 'a' to 'd'). This
296: function should return FALSE on error. */
297: extern boolean fsysdep_get_work_init P((const struct uuconf_system *qsys,
298: int bgrade));
299:
300: /* Get the next command to be executed for a remote system. The
301: bgrade argument will be the same as for fsysdep_get_work_init;
302: probably only one of these functions will use it, namely the
303: function for which it is more convenient. This should return FALSE
304: on error. The structure pointed to by qcmd should be filled in.
305: The strings may point into a static buffer; they will be copied out
306: if necessary. If there is no more work, this should set qcmd->bcmd
307: to 'H' and return TRUE. This should set qcmd->pseq to something
308: which can be passed to fsysdep_did_work to remove the job from the
309: queue when it has been completed. This may set qcmd->bcmd to 'P'
310: to represent a poll file; the main code will just pass the pseq
311: element of such a structure to fsysdep_did_work if the system is
312: called. */
313: extern boolean fsysdep_get_work P((const struct uuconf_system *qsys,
314: int bgrade, struct scmd *qcmd));
315:
316: /* Remove a job from the work queue. This must also remove the
317: temporary file used for a send command, if there is one. It should
318: return FALSE on error. */
319: extern boolean fsysdep_did_work P((pointer pseq));
320:
321: /* Save the temporary file for a send command. This function should
322: return a string that will be put into a mail message. On success
323: this string should say something like ``The file has been saved as
324: ...''. On failure it could say something like ``The file could not
325: be saved because ...''. If there is no temporary file, or for some
326: reason it's not appropriate to include a message, this function
327: should just return NULL. This function is used when a file send
328: fails for some reason, to make sure that we don't completely lost
329: the file. */
330: extern const char *zsysdep_save_temp_file P((pointer pseq));
331:
332: /* Cleanup anything left over by fsysdep_get_work_init and
333: fsysdep_get_work. This may be called even though
334: fsysdep_get_work_init has not been. */
335: extern void usysdep_get_work_free P((const struct uuconf_system *qsys));
336:
337: /* Add a base name to a file if it is a directory. If zfile names a
338: directory, then return a string naming a file within the directory
339: with the base file name of zname. This should return NULL on
340: error. */
341: extern char *zsysdep_add_base P((const char *zfile,
342: const char *zname));
343:
344: /* Get a file name from the spool directory. This should return NULL
345: on error. The pseq argument is TRUE if the file was found from
346: searching the work directory; this is, unfortunately, needed to
347: support SVR4 spool directories. */
348: extern char *zsysdep_spool_file_name P((const struct uuconf_system *qsys,
349: const char *zfile,
350: pointer pseq));
351:
352: /* Make necessary directories. This should create all non-existent
353: directories for a file. If the fpublic argument is TRUE, anybody
354: should be permitted to create and remove files in the directory;
355: otherwise anybody can list the directory, but only the UUCP system
356: can create and remove files. It should return FALSE on error. */
357: extern boolean fsysdep_make_dirs P((const char *zfile, boolean fpublic));
358:
359: /* Create a stdio file, setting appropriate protection. If the
360: fpublic argument is TRUE, the file is made publically accessible;
361: otherwise it is treated as a private data file. If the fappend
362: argument is TRUE, the file is opened in append mode; otherwise any
363: previously existing file of the same name is removed. If the
364: fmkdirs argument is TRUE, then any necessary directories should
365: also be created. On a system in which file protections are
366: unimportant and the necessary directories exist, this may be
367: implemented as
368:
369: fopen (zfile, fappend ? "a" : "w");
370:
371: */
372: extern FILE *esysdep_fopen P((const char *zfile, boolean fpublic,
373: boolean fappend, boolean fmkdirs));
374:
375: /* Open a file, using the access permission of the user who invoked
376: the program. The frd argument is TRUE if the file should be opened
377: for reading, and the fbinary argument is TRUE if the file should be
378: opened as a binary file (this is ignored on Unix, since there all
379: files are binary files). This returns an openfile_t, not a FILE *.
380: This is supposed to be able to open a file even if it can not be
381: read by the uucp user. This is not possible on some older Unix
382: systems. */
383: extern openfile_t esysdep_user_fopen P((const char *zfile,
384: boolean frd, boolean fbinary));
385:
386: /* Open a file to send to another system; the qsys argument is the
387: system the file is being sent to. If fcheck is TRUE, it should
388: make sure that the file is readable by zuser (if zuser is NULL the
389: file must be readable by anybody). This is to eliminate a window
390: between fsysdep_in_directory and esysdep_open_send. If an error
391: occurs, it should return EFILECLOSED. */
392: extern openfile_t esysdep_open_send P((const struct uuconf_system *qsys,
393: const char *zname,
394: boolean fcheck,
395: const char *zuser));
396:
397: /* Return a temporary file name to receive into. This file will be
398: opened by esysdep_open_receive. The qsys argument is the system
399: the file is coming from, the zto argument is the name the file will
400: have after it has been fully received, and the ztemp argument, if
401: it is not NULL, is from the command sent by the remote system. The
402: return value must be freed using ubuffree. The function should
403: return NULL on error. */
404: extern char *zsysdep_receive_temp P((const struct uuconf_system *qsys,
405: const char *zfile,
406: const char *ztemp));
407:
408: /* Open a file to receive from another system. The zreceive argument
409: is the return value of zsysdep_receive_temp with the same qsys,
410: zfile and ztemp arguments. If the function can determine that this
411: file has already been partially received, it should set *pcrestart
412: to the number of bytes that have been received. If the file has
413: not been partially received, *pcrestart should be set to -1. The
414: function should return EFILECLOSED on error. After the file is
415: written, fsysdep_move_file will be called to move the file to its
416: final destination, and to set the correct file mode. */
417: extern openfile_t esysdep_open_receive P((const struct uuconf_system *qsys,
418: const char *zto,
419: const char *ztemp,
420: const char *zreceive,
421: long *pcrestart));
422:
423: /* Move a file. This is used to move a received file to its final
424: location. The zto argument is the file to create. The zorig
425: argument is the name of the file to move. If fmkdirs is TRUE, then
426: any necessary directories are created; fpublic indicates whether
427: they should be publically writeable or not. If fcheck is TRUE,
428: this should make sure the directory is writeable by the user zuser
429: (if zuser is NULL, then it must be writeable by any user); this is
430: to avoid a window of vulnerability between fsysdep_in_directory and
431: fsysdep_move_file. This function should return FALSE on error; the
432: zorig file should be removed even if an error occurs. */
433: extern boolean fsysdep_move_file P((const char *zorig, const char *zto,
434: boolean fmkdirs, boolean fpublic,
435: boolean fcheck, const char *zuser));
436:
437: /* Change the mode of a file. The imode argument is a Unix mode.
438: This should return FALSE on error. */
439: extern boolean fsysdep_change_mode P((const char *zfile,
440: unsigned int imode));
441:
442: /* Truncate a file which we are receiving into. This may be done by
443: closing the original file, removing it and reopening it. This
444: should return FALSE on error. */
445: extern openfile_t esysdep_truncate P((openfile_t e, const char *zname));
446:
447: /* It is possible for the acknowledgement of a received file to be
448: lost. The sending system will then now know that the file was
449: correctly received, and will send it again. This can be a problem
450: particularly with protocols which support channels, since they may
451: send several small files in a single window, all of which may be
452: received correctly although the sending system never sees the
453: acknowledgement. If these files involve an execution, the
454: execution will happen twice, which will be bad.
455:
456: This function is called when a file is completely received. It is
457: supposed to try and remember the reception, in case the connection
458: is lost. It is passed the system, the file name to receive to, and
459: the temporary file name from the sending system. It should return
460: FALSE on error. */
461: extern boolean fsysdep_remember_reception P((const struct uuconf_system *qsys,
462: const char *zto,
463: const char *ztemp));
464:
465: /* This function is called to see if a file has already been received
466: successfully. It gets the same arguments as
467: fsysdep_remember_reception. It should return TRUE if the file was
468: already received, FALSE otherwise. There is no way to report
469: error. */
470: extern boolean fsysdep_already_received P((const struct uuconf_system *qsys,
471: const char *zto,
472: const char *ztemp));
473:
474: /* This function is called when it is no longer necessary to remember
475: that a file has been received. This will be called when the
476: protocol knows that the receive message has been acknowledged. It
477: gets the same arguments as fsysdep_remember_reception. it should
478: return FALSE on error. */
479: extern boolean fsysdep_forget_reception P((const struct uuconf_system *qsys,
480: const char *zto,
481: const char *ztemp));
482:
483: /* Start expanding a wildcarded file name. This should return FALSE
484: on error; otherwise subsequent calls to zsysdep_wildcard should
485: return file names. */
486: extern boolean fsysdep_wildcard_start P((const char *zfile));
487:
488: /* Get the next wildcard name. This should return NULL when there are
489: no more names to return. The return value should be freed using
490: ubuffree. The argument should be the same as that to
491: fsysdep_wildcard_start. There is no way to return error. */
492: extern char *zsysdep_wildcard P((const char *zfile));
493:
494: /* Finish getting wildcard names. This may be called before or after
495: zsysdep_wildcard has returned NULL. It should return FALSE on
496: error. */
497: extern boolean fsysdep_wildcard_end P((void));
498:
499: /* Prepare to execute a bunch of file transfer requests. This should
500: make an entry in the spool directory so that the next time uucico
501: is started up it will transfer these files. The bgrade argument
502: specifies the grade of the commands. The commands themselves are
503: in the pascmds array, which has ccmds entries. The function should
504: return NULL on error, or the jobid on success. The jobid is a
505: string that may be printed or passed to fsysdep_kill_job and
506: related functions, but is otherwise uninterpreted. */
507: extern char *zsysdep_spool_commands P((const struct uuconf_system *qsys,
508: int bgrade, int ccmds,
509: const struct scmd *pascmds));
510:
511: /* Get a file name to use for a data file to be copied to another
512: system. The ztname, zdname and zxname arguments will all either be
513: NULL or point to an array of CFILE_NAME_LEN characters in length.
514: The ztname array should be set to a temporary file name that could
515: be passed to zsysdep_spool_file_name to retrieve the return value
516: of this function; this will be appropriate for the temporary name
517: in a send request. The zdname array should be set to a data file
518: name that is appropriate for the spool directory of the other
519: system; this will be appropriate for the name of the destination
520: file in a send request of a data file for an execution of some
521: sort. The zxname array should be set to an execute file name that
522: is appropriate for the other system. The zlocalname argument is
523: the name of the local system as seen by the remote system, the
524: bgrade argument is the grade, and fxqt is TRUE if this file is
525: going to become an execution file. This should return NULL on
526: error. */
527: #define CFILE_NAME_LEN (15)
528:
529: extern char *zsysdep_data_file_name P((const struct uuconf_system *qsys,
530: const char *zlocalname,
531: int bgrade, boolean fxqt,
532: char *ztname, char *zdname,
533: char *zxname));
534:
535: /* Get a name for a local execute file. This is used by uux for a
536: local command with remote files. Returns NULL on error. */
537: extern char *zsysdep_xqt_file_name P((void));
538:
539: /* Beginning getting execute files. To get a list of execute files,
540: first fsysdep_get_xqt_init is called, then zsysdep_get_xqt is
541: called several times until it returns NULL, then finally
542: usysdep_get_xqt_free is called. */
543: extern boolean fsysdep_get_xqt_init P((void));
544:
545: /* Get the next execute file. This should return NULL when finished
546: (with *pferr set to FALSE). On an error this should return NULL
547: with *pferr set to TRUE. This should set *pzsystem to the name of
548: the system for which the execute file was created. Both the return
549: value and *pzsystem should be freed using ubuffree. */
550: extern char *zsysdep_get_xqt P((char **pzsystem,
551: boolean *pferr));
552:
553: /* Clean up after getting execute files. */
554: extern void usysdep_get_xqt_free P((void));
555:
556: /* Get the absolute pathname of a command to execute. This is given
557: the legal list of commands (which may be the special case "ALL")
558: and the path. It must return an absolute pathname to the command.
559: If it gets an error it should set *pferr to TRUE and return NULL;
560: if the command is not found it should set *pferr to FALSE and
561: return NULL. */
562: extern char *zsysdep_find_command P((const char *zcmd, char **pzcmds,
563: char **pzpath, boolean *pferr));
564:
565: /* Expand file names for uuxqt. This exists because uuxqt on Unix has
566: to expand file names which begin with a ~. It does not want to
567: expand any other type of file name, and it turns a double ~ into a
568: single one without expanding. If this returns NULL, the file does
569: not need to be changed; otherwise it returns a zbufalc'ed string.
570: There is no way to report error. */
571: extern char *zsysdep_xqt_local_file P((const struct uuconf_system *qsys,
572: const char *zfile));
573:
574: #if ! ALLOW_FILENAME_ARGUMENTS
575: /* Check an argument to an execution command to make sure that it
576: doesn't refer to a file name that may not be accessed. This should
577: check the argument to see if it is a filename. If it is, it should
578: either reject it out of hand or it should call fin_directory_list
579: on the file with both qsys->zremote_receive and qsys->zremote_send.
580: If the file is rejected, it should log an error and return FALSE.
581: Otherwise it should return TRUE. */
582: extern boolean fsysdep_xqt_check_file P((const struct uuconf_system *qsys,
583: const char *zfile));
584: #endif /* ! ALLOW_FILENAME_ARGUMENTS */
585:
586: /* Run an execute file. The arguments are:
587:
588: qsys -- system for which execute file was created
589: zuser -- user who requested execution
590: pazargs -- list of arguments to command (element 0 is command)
591: zfullcmd -- command and arguments stuck together in one string
592: zinput -- file name for standard input (may be NULL)
593: zoutput -- file name for standard output (may be NULL)
594: fshell -- if TRUE, use /bin/sh to execute file
595: ilock -- return value of ixsysdep_lock_uuxqt
596: pzerror -- set to name of standard error file
597: pftemp -- set to TRUE if error is temporary, FALSE otherwise
598:
599: If fshell is TRUE, the command should be executed with /bin/sh
600: (obviously, this can only really be done on Unix systems). If an
601: error occurs this should return FALSE and set *pftemp
602: appropriately. *pzerror should be freed using ubuffree. */
603: extern boolean fsysdep_execute P((const struct uuconf_system *qsys,
604: const char *zuser,
605: const char **pazargs,
606: const char *zfullcmd,
607: const char *zinput,
608: const char *zoutput,
609: boolean fshell,
610: int ilock,
611: char **pzerror,
612: boolean *pftemp));
613:
614: /* Lock for uuxqt execution. If the cmaxuuxqts argument is not zero,
615: this should make sure that no more than cmaxuuxqts uuxqt processes
616: are running at once. Also, only one uuxqt may execute a particular
617: command (specified by the -c option) at a time. If zcmd is not
618: NULL, it is a command that must be locked. This should return a
619: nonnegative number which will be passed to other routines,
620: including fsysdep_unlock_uuxqt, or -1 on error. */
621: extern int ixsysdep_lock_uuxqt P((const char *zcmd,
622: int cmaxuuxqts));
623:
624: /* Unlock a uuxqt process. This is passed the return value of
625: ixsysdep_lock_uuxqt, as well as the arguments passed to
626: ixsysdep_lock_uuxqt. It may return FALSE on error, but at present
627: the return value is ignored. */
628: extern boolean fsysdep_unlock_uuxqt P((int iseq, const char *zcmd,
629: int cmaxuuxqts));
630:
631: /* See whether a particular uuxqt command is locked. This should
632: return TRUE if the command is locked (because ixsysdep_lock_uuxqt
633: was called with it as an argument), FALSE otherwise. There is no
634: way to return error. */
635: extern boolean fsysdep_uuxqt_locked P((const char *zcmd));
636:
637: /* Lock an execute file in order to execute it. This should return
638: FALSE if the execute file is already locked. There is no way to
639: return error. */
640: extern boolean fsysdep_lock_uuxqt_file P((const char *zfile));
641:
642: /* Unlock an execute file. This should return FALSE on error. */
643: extern boolean fsysdep_unlock_uuxqt_file P((const char *zfile));
644:
645: /* Lock the execution directory. The ilock argument is the return
646: value of ixsysdep_lock_uuxqt. This should return FALSE if the
647: directory is already locked. There is no way to return error. */
648: extern boolean fsysdep_lock_uuxqt_dir P((int ilock));
649:
650: /* Remove all files in the execution directory, and unlock it. This
651: should return FALSE on error. */
652: extern boolean fsysdep_unlock_uuxqt_dir P((int ilock));
653:
654: /* Move files into or out of the execution directory. The code will
655: already have checked that all the files exist. The elements in the
656: pzfrom array will be complete filenames, and the elements in the
657: pzto array will be either NULL (in which case the file should not
658: be moved) or simple base names. If fto is TRUE, the files in
659: pzfrom should be moved to pzto; otherwise, the files in pzto should
660: be moved to pzfrom (this is used if a temporary failure occurs, in
661: which case the execution will be retried later). If pzinput and
662: *pzinput are not NULL, then it is the name of the standard input
663: file; if it is the same as any element of pzfrom, then *pzinput
664: should be set to the zbufcpy of the corresponding pzto value, if
665: any. */
666: extern boolean fsysdep_move_uuxqt_files P((int cfiles,
667: const char *const *pzfrom,
668: const char *const *pzto,
669: boolean fto, int ilock,
670: char **pzinput));
671:
672: /* Expand a file name on the local system, defaulting to the current
673: directory. This is just like zsysdep_local_file, except that
674: relative files are placed in the working directory the program
675: started in rather than in the public directory. This should return
676: NULL on error. */
677: extern char *zsysdep_local_file_cwd P((const char *zname,
678: const char *zpubdir));
679:
680: /* Add the working directory to a file name. The named file is
681: actually on a remote system. If the file already has a directory,
682: it should not be changed. This should return NULL on error. */
683: extern char *zsysdep_add_cwd P((const char *zfile));
684:
685: /* See whether a file name will need the current working directory
686: when zsysdep_local_file_cwd or zsysdep_add_cwd is called on it.
687: This will be called before usysdep_initialize. It should just
688: check whether the argument is an absolute path. See the comment
689: above usysdep_initialize in this file for an explanation of why
690: things are done this way. */
691: extern boolean fsysdep_needs_cwd P((const char *zfile));
692:
693: /* Get the base name of a file. The file will be a local file name,
694: and this function should return the base file name, ideally in a
695: form which will make sense on most systems; it will be used if the
696: destination of a uucp is a directory. */
697: extern char *zsysdep_base_name P((const char *zfile));
698:
699: /* Return a filename within a directory. */
700: extern char *zsysdep_in_dir P((const char *zdir, const char *zfile));
701:
702: /* Get the mode of a file. This should return a Unix style file mode.
703: It should return 0 on error. */
704: extern unsigned int ixsysdep_file_mode P((const char *zfile));
705:
706: /* See whether the user has access to a file. This is called by uucp
707: and uux to prevent copying of a file which uucp can read but the
708: user cannot. If access is denied, this should log an error message
709: and return FALSE. */
710: extern boolean fsysdep_access P((const char *zfile));
711:
712: /* See whether the daemon has access to a file. This is called by
713: uucp and uux when a file is queued up for transfer without being
714: copied into the spool directory. It is merely an early error
715: check, as the daemon would of course discover the error itself when
716: it tried the transfer. If access would be denied, this should log
717: an error message and return FALSE. */
718: extern boolean fsysdep_daemon_access P((const char *zfile));
719:
720: /* Translate a destination from system!user to a place in the public
721: directory where uupick will get the file. On Unix this produces
722: system!~/receive/user/localname, and that's probably what it has to
723: produce on any other system as well. Returns NULL on a usage
724: error, or otherwise returns string allocated by zbufcpy. */
725: extern char *zsysdep_uuto P((const char *zdest,
726: const char *zlocalname));
727:
728: /* Return TRUE if a pathname exists and is a directory. */
729: extern boolean fsysdep_directory P((const char *zpath));
730:
731: /* Walk a directory tree. The zdir argument is the directory to walk.
732: The pufn argument is a function to call on each regular file in the
733: tree. The first argument to pufn should be the full filename; the
734: second argument to pufn should be the filename relative to zdir;
735: the third argument to pufn should be the pinfo argument to
736: usysdep_walk_tree. The usysdep_walk_tree function should return
737: FALSE on error. */
738: extern boolean usysdep_walk_tree P((const char *zdir,
739: void (*pufn) P((const char *zfull,
740: const char *zrelative,
741: pointer pinfo)),
742: pointer pinfo));
743:
744: /* Return the jobid of a work file, given the sequence value. On
745: error this should log an error and return NULL. The jobid is a
746: string which may be printed out and read in and passed to
747: fsysdep_kill_job, etc., but is not otherwise interpreted. */
748: extern char *zsysdep_jobid P((const struct uuconf_system *qsys,
749: pointer pseq));
750:
751: /* See whether the current user is permitted to kill jobs submitted by
752: another user. This should return TRUE if permission is granted,
753: FALSE otherwise. */
754: extern boolean fsysdep_privileged P((void));
755:
756: /* Kill a job, given the jobid. This should remove all associated
757: files and in general eliminate the job completely. On error it
758: should log an error message and return FALSE. */
759: extern boolean fsysdep_kill_job P((pointer puuconf,
760: const char *zjobid));
761:
762: /* Rejuvenate a job, given the jobid. If possible, this should update
763: the time associated with the job such that it will not be
764: eliminated by uustat -K or similar programs that check the creation
765: time. This should affect the return value of ixsysdep_work_time.
766: On error it should log an error message and return FALSE. */
767: extern boolean fsysdep_rejuvenate_job P((pointer puuconf,
768: const char *zjobid));
769:
770: /* Get the time a job was queued, given the sequence number. There is
771: no way to indicate error. The return value must use the same epoch
772: as ixsysdep_time. */
773: extern long ixsysdep_work_time P((const struct uuconf_system *qsys,
774: pointer pseq));
775:
776: /* Get the time a file was created. This is called by uustat on
777: execution files. There is no way to indicate error. The return
778: value must use the same epoch as ixsysdep_time. */
779: extern long ixsysdep_file_time P((const char *zfile));
780:
781: /* Get the size in bytes of a file. If this file does not exist, this
782: should not give an error message, but should return -1. If some
783: other error occurs, this should return -2. */
784: extern long csysdep_size P((const char *zfile));
785:
786: /* Return the amount of free space on the containing the given file
787: name (the file may or may not exist). If the amount of free space
788: cannot be determined, the function should return -1. */
789: extern long csysdep_bytes_free P((const char *zfile));
790:
791: /* Start getting status information for all systems with available
792: status information. There may be status information for unknown
793: systems, which is why this series of functions is used. The phold
794: argument is used to pass information around, to possibly avoid the
795: use of static variables. On error this should log an error and
796: return FALSE. */
797: extern boolean fsysdep_all_status_init P((pointer *phold));
798:
799: /* Get status information for the next system. This should return the
800: system name and fill in the qstat argument. The phold argument
801: will be that set by fsysdep_all_status_init. On error this should
802: log an error, set *pferr to TRUE, and return NULL. */
803: extern char *zsysdep_all_status P((pointer phold, boolean *pferr,
804: struct sstatus *qstat));
805:
806: /* Free up anything allocated by fsysdep_all_status_init and
807: zsysdep_all_status. The phold argument is that set by
808: fsysdep_all_status_init. */
809: extern void usysdep_all_status_free P((pointer phold));
810:
811: /* Display the process status of all processes holding lock files.
812: This is uustat -p. The return value is passed to usysdep_exit. */
813: extern boolean fsysdep_lock_status P((void));
814:
815: /* Return TRUE if the user has legitimate access to the port. This is
816: used by cu to control whether the user can open a port directly,
817: rather than merely being able to dial out on it. Opening a port
818: directly allows the modem to be reprogrammed. */
819: extern boolean fsysdep_port_access P((struct uuconf_port *qport));
820:
821: /* Return whether the given port could be named by the given line. On
822: Unix, the line argument would be something like "ttyd0", and this
823: function should return TRUE if the named port is "/dev/ttyd0". */
824: extern boolean fsysdep_port_is_line P((struct uuconf_port *qport,
825: const char *zline));
826:
827: /* Set the terminal into raw mode. In this mode no input characters
828: should be treated specially, and characters should be made
829: available as they are typed. The original terminal mode should be
830: saved, so that it can be restored by fsysdep_terminal_restore. If
831: flocalecho is TRUE, then local echoing should still be done;
832: otherwise echoing should be disabled. This function returns FALSE
833: on error. */
834: extern boolean fsysdep_terminal_raw P((boolean flocalecho));
835:
836: /* Restore the terminal back to the original setting, before
837: fsysdep_terminal_raw was called. Returns FALSE on error. */
838: extern boolean fsysdep_terminal_restore P((void));
839:
840: /* Read a line from the terminal. The fsysdep_terminal_raw function
841: will have been called. This should print the zprompt argument
842: (unless it is NULL) and return the line, allocated by zbufcpy, or
843: NULL on error. */
844: extern char *zsysdep_terminal_line P((const char *zprompt));
845:
846: /* Write a line to the terminal, ending with a newline. This is
847: basically just puts (zline, stdout), except that the terminal will
848: be in raw mode, so on ASCII Unix systems the line needs to end with
849: \r\n. */
850: extern boolean fsysdep_terminal_puts P((const char *zline));
851:
852: /* If faccept is TRUE, permit the user to generate signals from the
853: terminal. If faccept is FALSE, turn signals off again. After
854: fsysdep_terminal_raw is called, signals should be off. Return
855: FALSE on error. */
856: extern boolean fsysdep_terminal_signals P((boolean faccept));
857:
858: /* The cu program expects the system dependent code to handle the
859: details of copying data from the communications port to the
860: terminal. This should be set up by fsysdep_cu_init, and done while
861: fsysdep_cu is called. It is permissible to do it on a continual
862: basis (on Unix a subprocess handles it) so long as the copying can
863: be stopped by the fsysdep_cu_copy function.
864:
865: The fsysdep_cu_init function does any system dependent
866: initialization needed for this. */
867: extern boolean fsysdep_cu_init P((struct sconnection *qconn));
868:
869: /* Copy all data from the communications port to the terminal, and all
870: data from the terminal to the communications port. Keep this up
871: until the escape character *zCuvar_escape is seen. Set *pbcmd to
872: the character following the escape character; after the escape
873: character, zlocalname should be printed, possibly after a delay.
874: If two escape characters are entered in sequence, this function
875: should send a single escape character to the port, and not return.
876: Returns FALSE on error. */
877: extern boolean fsysdep_cu P((struct sconnection *qconn,
878: char *pbcmd,
879: const char *zlocalname));
880:
881: /* If fcopy is TRUE, start copying data from the communications port
882: to the terminal. If fcopy is FALSE, stop copying data. This
883: function may be called several times during a cu session. It
884: should return FALSE on error. */
885: extern boolean fsysdep_cu_copy P((boolean fcopy));
886:
887: /* Stop copying data from the communications port to the terminal, and
888: generally clean up after fsysdep_cu_init and fsysdep_cu. Returns
889: FALSE on error. */
890: extern boolean fsysdep_cu_finish P((void));
891:
892: /* Run a shell command. If zcmd is NULL, or *zcmd == '\0', just
893: start up a shell. The second argument is one of the following
894: values. This should return FALSE on error. */
895: enum tshell_cmd
896: {
897: /* Attach stdin and stdout to the terminal. */
898: SHELL_NORMAL,
899: /* Attach stdout to the communications port, stdin to the terminal. */
900: SHELL_STDOUT_TO_PORT,
901: /* Attach stdin to the communications port, stdout to the terminal. */
902: SHELL_STDIN_FROM_PORT,
903: /* Attach both stdin and stdout to the communications port. */
904: SHELL_STDIO_ON_PORT
905: };
906:
907: extern boolean fsysdep_shell P((struct sconnection *qconn,
908: const char *zcmd,
909: enum tshell_cmd tcmd));
910:
911: /* Change directory. If zdir is NULL, or *zdir == '\0', change to the
912: user's home directory. Return FALSE on error. */
913: extern boolean fsysdep_chdir P((const char *zdir));
914:
915: /* Suspend the current process. This is only expected to work on Unix
916: versions that support SIGTSTP. In general, people can just shell
917: out. */
918: extern boolean fsysdep_suspend P((void));
919:
920: /* Start getting files for uupick. The zsystem argument may be NULL
921: to get files from all systems, or it may specify a particular
922: system. The zpubdir argument is the public directory to use. This
923: returns FALSE on error. */
924: extern boolean fsysdep_uupick_init P((const char *zsystem,
925: const char *zpubdir));
926:
927: /* Get the next file for uupick. This returns the basic file name.
928: It sets *pzfull to the full name, and *pzfrom to the name of the
929: system which sent this file over; both should be freed using
930: ubuffree. *pzfull should be passed to ubuffree after it is no
931: longer needed. The zsystem and zpubdir arguments should be the
932: same as the arguments to fsysdep_uupick_init. This returns NULL
933: when all files been returned. */
934: extern char *zsysdep_uupick P((const char *zsystem, const char *zpubdir,
935: char **pzfrom, char **pzfull));
936:
937: /* Clean up after getting files for uupick. */
938: extern boolean fsysdep_uupick_free P((const char *zsystem,
939: const char *zpubdir));
940:
941: /* Translate a local file name for uupick. On Unix this is just like
942: zsysdep_local_file_cwd except that a file beginning with ~/ is
943: placed in the user's home directory rather than in the public
944: directory. */
945: extern char *zsysdep_uupick_local_file P((const char *zfile));
946:
947: /* Remove a directory and all the files in it. */
948: extern boolean fsysdep_rmdir P((const char *zdir));
949:
950: #endif /* ! defined (SYSTEM_H) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.