path: root/gnu/libexec/uucp/common_sources/system.h

/* system.h
   Header file for system dependent stuff in the Taylor UUCP package.
   This file is not itself system dependent.

   Copyright (C) 1991, 1992, 1993, 1994, 1995 Ian Lance Taylor

   This file is part of the Taylor UUCP package.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

   The author of the program may be contacted at ian@airs.com or
   c/o Cygnus Support, 48 Grove Street, Somerville, MA 02144.
   */

#ifndef SYSTEM_H

#define SYSTEM_H

#if ANSI_C
/* These structures are used in prototypes but are not defined in this
   header file.  */
struct tm;
struct uuconf_system;
struct uuconf_port;
struct sconnection;
struct sstatus;
struct scmd;
#endif

/* Any function which returns an error should also report an error
   message, unless otherwise indicated.

   Any function that returns a char *, rather than a const char *, is
   returning a pointer to a buffer allocated by zbufalc which must be
   freed using ubuffree, unless otherwise indicated.  */

/* The maximum length of a remote system name.  */
extern size_t cSysdep_max_name_len;

/* Initialize.  If something goes wrong, this routine should just
   exit.  The flag argument is 0, or a combination of any of the
   following flags.  */

/* This program needs to know the current working directory.  This is
   used because on Unix it can be expensive to determine the current
   working directory (some versions of getcwd fork a process), but in
   most cases we don't need to know it.  However, we are going to
   chdir to the spool directory (unless INIT_CHDIR is set), so we have
   to get the cwd now if we are ever going to get it.  Both uucp and
   uux use the function fsysdep_needs_cwd to determine whether they
   will need the current working directory, and pass the argument to
   usysdep_initialize appropriately.  There's probably a cleaner way
   to handle this, but this will suffice for now.  */
#define INIT_GETCWD (01)

/* This program should not chdir to the spool directory.  This may
   only make sense on Unix.  It is set by cu.  */
#define INIT_NOCHDIR (02)

/* This program needs special access to the spool directories.  That
   means, on Unix, this program is normally installed setuid.  */
#define INIT_SUID (04)

/* Do not close all open descriptors.  This is not used by the UUCP
   code, but it is used by other programs which share some of the
   system dependent libraries.  */
#define INIT_NOCLOSE (010)

extern void usysdep_initialize P((pointer puuconf, int iflags));

/* Exit the program.  The fsuccess argument indicates whether to
   return an indication of success or failure to the outer
   environment.  This routine should not return.  */
extern void usysdep_exit P((boolean fsuccess));

/* Called when a non-standard configuration file is being used, to
   avoid handing out privileged access.  If it returns FALSE, default
   configuration file will be used.  This is called before the
   usysdep_initialize function is called.  */
extern boolean fsysdep_other_config P((const char *));

/* Detach from the controlling terminal.  This probably only makes
   sense on Unix.  It is called by uucico to try to get the modem port
   as a controlling terminal.  It is also called by uucico before it
   starts up uuxqt, so that uuxqt will be a complete daemon.  */
extern void usysdep_detach P((void));

/* Get the local node name if it is not specified in the configuration
   files.  Returns NULL on error; otherwise the return value should
   point to a static buffer.  */
extern const char *zsysdep_localname P((void));

/* Get the login name.  This is used when uucico is started up with no
   arguments in slave mode, which causes it to assume that somebody
   has logged in.  It also used by uucp and uux for recording the user
   name.  This may not return NULL.  The return value should point to
   a static buffer.  */
extern const char *zsysdep_login_name P((void));

/* Set a signal handler for a signal.  If the signal occurs, the
   appropriate element of afSignal should be set to the signal number
   (see the declaration of afSignal in uucp.h).  This routine might be
   able to just use signal, but Unix requires more complex handling.
   This is called before usysdep_initialize.  */
extern void usysdep_signal P((int isig));

/* Catch a signal.  This is actually defined as a macro in the system
   dependent header file, and the prototype here just indicates how it
   should be called.  It is called before a routine which must exit if
   a signal occurs, and is expected to set do a setjmp (which is why
   it must be a macro).  It is actually only called in one place in
   the system independent code, before the call to read stdin in uux.
   This is needed to handle 4.2 BSD restartable system calls, which
   require a longjmp.  On systems which don't need to do
   setjmp/longjmp around system calls, this can be redefined in
   sysdep.h to TRUE.  It should return TRUE if the routine should
   proceed, or FALSE if a signal occurred.  After having this return
   TRUE, usysdep_start_catch should be used to start catching the
   signal; this basically tells the signal handler that it's OK to do
   the longjmp, if fsysdep_catch did not already do so.  */
#ifndef fsysdep_catch
extern boolean fsysdep_catch P((void));
#endif

/* Start catching a signal.  This is called after fsysdep_catch to
   tell the signal handler to go ahead and do the longjmp.  This may
   be implemented as a macro in sysdep.h.  */
#ifndef usysdep_start_catch
extern void usysdep_start_catch P((void));
#endif

/* Stop catching a signal.  This is called when it is no longer
   necessary for fsysdep_catch to handle signals.  This may be
   implemented as a macro in sysdep.h.  */
#ifndef usysdep_end_catch
extern void usysdep_end_catch P((void));
#endif

/* Link two files.  On Unix this should attempt the link.  If it
   succeeds it should return TRUE with *pfworked set to TRUE.  If the
   link fails because it must go across a device, it should return
   TRUE with *pfworked set to FALSE.  If the link fails for some other
   reason, it should log an error message and return FALSE.  On a
   system which does not support links to files, this should just
   return TRUE with *pfworked set to FALSE.  */
extern boolean fsysdep_link P((const char *zfrom, const char *zto,
			       boolean *pfworked));

/* Get the port name.  This is used when uucico is started up in slave
   mode to figure out which port was used to call in so that it can
   determine any appropriate protocol parameters.  This may return
   NULL if the port cannot be determined, which will just mean that no
   protocol parameters are applied.  The name returned should be the
   sort of name that would appear in the port file.  This should set
   *pftcp_port to TRUE if it can determine that the port is a TCP
   connection rather than a normal serial port.  The return value (if
   not NULL) should point to a static buffer.  */
extern const char *zsysdep_port_name P((boolean *pftcp_port));

/* Expand a file name on the local system.  On Unix, if the zfile
   argument begins with ~user/ it goes in that users home directory,
   and if it begins with ~/ it goes in the public directory (the
   public directory is passed to this routine, since each system may
   have its own public directory).  Similar conventions may be
   desirable on other systems.  This should always return an absolute
   path name, probably in the public directory.  It should return NULL
   on error; otherwise the return value should be allocated using
   zbufcpy or zbufalc.  If pfbadname is not NULL, then if the function
   returns NULL *pfbadname should be set to TRUE if the error is just
   that the file name is badly specified; *pfbadname should be set to
   FALSE for some sort of internal error.  */
extern char *zsysdep_local_file P((const char *zname,
				   const char *zpubdir,
				   boolean *pfbadname));

/* Return whether a file name is in a directory, and check for read or
   write access.  This should check whether zfile is within zdir (or
   is zdir itself).  If it is not, it should return FALSE.  If zfile
   is in zdir, then fcheck indicates whether further checking should
   be done.  If fcheck is FALSE, no further checking is done.
   Otherwise, if freadable is TRUE the user zuser should have search
   access to all directories from zdir down to zfile and should have
   read access on zfile itself (if zfile does not exist, or is not a
   regular file, this function may return FALSE but does not have to).
   If freadable is FALSE, the user zuser should have search access to
   all directories from zdir down to zfile and should have write
   access on zfile (which may be a directory, or may not actually
   exist, which is acceptable).  The zuser argument may be NULL, in
   which case the check should be made for any user, not just zuser.
   There is no way for this function to return error.  */
extern boolean fsysdep_in_directory P((const char *zfile,
				       const char *zdir,
				       boolean fcheck,
				       boolean freadable,
				       const char *zuser));

/* Return TRUE if a file exists, FALSE otherwise.  There is no way to
   return error.  */
extern boolean fsysdep_file_exists P((const char *zfile));

/* Start up a program.  If the ffork argument is true, this should
   spawn a new process and return.  If the ffork argument is false,
   this may either return or not.  The three string arguments may be
   catenated together to form the program to execute; I did it this
   way to make it easy to call execl(2), and because I never needed
   more than two arguments.  The program will always be "uucico" or
   "uuxqt".  The return value should be TRUE on success, FALSE on
   error.  */
extern boolean fsysdep_run P((boolean ffork, const char *zprogram,
			      const char *zarg1, const char *zarg2));

/* Send a mail message.  This function will be passed an array of
   strings.  All necessary newlines are already included; the strings
   should simply be concatenated together to form the mail message.
   It should return FALSE on error, although the return value is often
   ignored.  */
extern boolean fsysdep_mail P((const char *zto, const char *zsubject,
			       int cstrs, const char **paz));

/* Get the time in seconds since some epoch.  The actual epoch is
   unimportant, so long as the time values are consistent across
   program executions and the value is never negative.  If the
   pimicros argument is not NULL, it should be set to the number of
   microseconds (if this is not available, *pimicros should be set to
   zero).  */
extern long ixsysdep_time P((long *pimicros));

/* Get the time in seconds and microseconds (millionths of a second)
   since some epoch.  The actual epoch is not important, and it may
   change in between program invocations; this is provided because on
   Unix the times function may be used.  If microseconds can not be
   determined, *pimicros can just be set to zero.  */
extern long ixsysdep_process_time P((long *pimicros));

/* Parse the value returned by ixsysdep_time into a struct tm.  I
   assume that this structure is defined in <time.h>.  This is
   basically just localtime, except that the ANSI function takes a
   time_t which may not be what is returned by ixsysdep_time.  */
extern void usysdep_localtime P((long itime, struct tm *q));

/* Sleep for a number of seconds.  */
extern void usysdep_sleep P((int cseconds));

/* Pause for half a second, or 1 second if subsecond sleeps are not
   possible.  */
extern void usysdep_pause P((void));

/* Lock a remote system.  This should return FALSE if the system is
   already locked (no error should be reported).  */
extern boolean fsysdep_lock_system P((const struct uuconf_system *qsys));

/* Unlock a remote system.  This should return FALSE on error
   (although the return value is generally ignored).  */
extern boolean fsysdep_unlock_system P((const struct uuconf_system *qsys));

/* Get the conversation sequence number for a remote system, and
   increment it for next time.  This should return -1 on error.  */
extern long ixsysdep_get_sequence P((const struct uuconf_system *qsys));

/* Get the status of a remote system.  This should return FALSE on
   error.  Otherwise it should set *qret to the status.  If no status
   information is available, this should set *qret to sensible values
   and return TRUE.  If pfnone is not NULL, then it should be set to
   TRUE if no status information was available or FALSE otherwise.  */
extern boolean fsysdep_get_status P((const struct uuconf_system *qsys,
				     struct sstatus *qret,
				     boolean *pfnone));

/* Set the status of a remote system.  This should return FALSE on
   error.  The system will be locked before this call is made.  */
extern boolean fsysdep_set_status P((const struct uuconf_system *qsys,
				     const struct sstatus *qset));

/* See whether a remote system is permitted to log in.  This is just
   to support the remote.unknown shell script for HDB.  The zscript
   argument is the script name, as return by uuconf_remote_unknown.
   The zsystem argument is the name given by the remote system.  If
   the system is not permitted to log in, this function should log an
   error and return FALSE.  */
extern boolean fsysdep_unknown_caller P((const char *zscript,
					 const char *zsystem));

/* Check whether there is work for a remote system.  It should return
   TRUE if there is work, FALSE otherwise; there is no way to indicate
   an error.  */
extern boolean fsysdep_has_work P((const struct uuconf_system *qsys));

/* Initialize the work scan.  This will be called before
   fsysdep_get_work.  The bgrade argument is the minimum grade of
   execution files that should be considered (e.g. a bgrade of 'd'
   will allow all grades from 'A' to 'Z' and 'a' to 'd').  This
   function should return FALSE on error.  */
extern boolean fsysdep_get_work_init P((const struct uuconf_system *qsys,
					int bgrade));

/* Get the next command to be executed for a remote system.  The
   bgrade argument will be the same as for fsysdep_get_work_init;
   probably only one of these functions will use it, namely the
   function for which it is more convenient.  This should return FALSE
   on error.  The structure pointed to by qcmd should be filled in.
   The strings may point into a static buffer; they will be copied out
   if necessary.  If there is no more work, this should set qcmd->bcmd
   to 'H' and return TRUE.  This should set qcmd->pseq to something
   which can be passed to fsysdep_did_work to remove the job from the
   queue when it has been completed.  This may set qcmd->bcmd to 'P'
   to represent a poll file; the main code will just pass the pseq
   element of such a structure to fsysdep_did_work if the system is
   called.  */
extern boolean fsysdep_get_work P((const struct uuconf_system *qsys,
				   int bgrade, struct scmd *qcmd));

/* Remove a job from the work queue.  This must also remove the
   temporary file used for a send command, if there is one.  It should
   return FALSE on error.  */
extern boolean fsysdep_did_work P((pointer pseq));

/* Save the temporary file for a send command.  This function should
   return a string that will be put into a mail message.  On success
   this string should say something like ``The file has been saved as
   ...''.  On failure it could say something like ``The file could not
   be saved because ...''.  If there is no temporary file, or for some
   reason it's not appropriate to include a message, this function
   should just return NULL.  This function is used when a file send
   fails for some reason, to make sure that we don't completely lost
   the file.  */
extern const char *zsysdep_save_temp_file P((pointer pseq));

/* Save a file in a location used to hold corrupt files.  This is
   called if a bad execution file is found by uuxqt.  This should
   return the new name of the file (allocated by zbufalc), or NULL if
   the move failed (in which the original file should remain).  */
extern char *zsysdep_save_corrupt_file P((const char *zfile));

/* Save a file in a location used to hold failed execution files.
   This is called if a uuxqt execution fails.  This should return the
   new name of the file (allocated by zbufalc), or NULL if the move
   failed (in which case the original file should remain).  */
extern char *zsysdep_save_failed_file P((const char *zfile));

/* Cleanup anything left over by fsysdep_get_work_init and
   fsysdep_get_work.  This may be called even though
   fsysdep_get_work_init has not been.  */
extern void usysdep_get_work_free P((const struct uuconf_system *qsys));

/* Add a base name to a file if it is a directory.  If zfile names a
   directory, then return a string naming a file within the directory
   with the base file name of zname.  This should return NULL on
   error.  */
extern char *zsysdep_add_base P((const char *zfile,
				 const char *zname));

/* Get a file name from the spool directory.  This should return NULL
   on error.  The pseq argument is TRUE if the file was found from
   searching the work directory; this is, unfortunately, needed to
   support SVR4 spool directories.  */
extern char *zsysdep_spool_file_name P((const struct uuconf_system *qsys,
					const char *zfile,
					pointer pseq));

/* Make necessary directories.  This should create all non-existent
   directories for a file.  If the fpublic argument is TRUE, anybody
   should be permitted to create and remove files in the directory;
   otherwise anybody can list the directory, but only the UUCP system
   can create and remove files.  It should return FALSE on error.  */
extern boolean fsysdep_make_dirs P((const char *zfile, boolean fpublic));

/* Create a stdio file, setting appropriate protection.  If the
   fpublic argument is TRUE, the file is made publically accessible;
   otherwise it is treated as a private data file.  If the fappend
   argument is TRUE, the file is opened in append mode; otherwise any
   previously existing file of the same name is removed.  If the
   fmkdirs argument is TRUE, then any necessary directories should
   also be created.  On a system in which file protections are
   unimportant and the necessary directories exist, this may be
   implemented as

   fopen (zfile, fappend ? "a" : "w");

   */
extern FILE *esysdep_fopen P((const char *zfile, boolean fpublic,
			      boolean fappend, boolean fmkdirs));

/* Open a file, using the access permission of the user who invoked
   the program.  The frd argument is TRUE if the file should be opened
   for reading, and the fbinary argument is TRUE if the file should be
   opened as a binary file (this is ignored on Unix, since there all
   files are binary files).  This returns an openfile_t, not a FILE *.
   This is supposed to be able to open a file even if it can not be
   read by the uucp user.  This is not possible on some older Unix
   systems.  */
extern openfile_t esysdep_user_fopen P((const char *zfile,
					boolean frd, boolean fbinary));

/* Open a file to send to another system; the qsys argument is the
   system the file is being sent to.  If fcheck is TRUE, it should
   make sure that the file is readable by zuser (if zuser is NULL the
   file must be readable by anybody).  This is to eliminate a window
   between fsysdep_in_directory and esysdep_open_send.  If an error
   occurs, it should return EFILECLOSED.  */
extern openfile_t esysdep_open_send P((const struct uuconf_system *qsys,
				       const char *zname,
				       boolean fcheck,
				       const char *zuser));

/* Return a temporary file name to receive into.  This file will be
   opened by esysdep_open_receive.  The qsys argument is the system
   the file is coming from, the zto argument is the name the file will
   have after it has been fully received, the ztemp argument, if it is
   not NULL, is from the command sent by the remote system, and the
   frestart argument is TRUE if the protocol and remote system permit
   file transfers to be restarted.  The return value must be freed
   using ubuffree.  The function should return NULL on error.  */
extern char *zsysdep_receive_temp P((const struct uuconf_system *qsys,
				     const char *zfile,
				     const char *ztemp,
				     boolean frestart));

/* Open a file to receive from another system.  The zreceive argument
   is the return value of zsysdep_receive_temp with the same qsys,
   zfile and ztemp arguments.  If the function can determine that this
   file has already been partially received, it should set *pcrestart
   to the number of bytes that have been received.  If the file has
   not been partially received, *pcrestart should be set to -1.
   pcrestart will be passed in as NULL if file restart is not
   supported by the protocol or the remote system.  The function
   should return EFILECLOSED on error.  After the file is written,
   fsysdep_move_file will be called to move the file to its final
   destination, and to set the correct file mode.  */
extern openfile_t esysdep_open_receive P((const struct uuconf_system *qsys,
					  const char *zto,
					  const char *ztemp,
					  const char *zreceive,
					  long *pcrestart));

/* Move a file.  This is used to move a received file to its final
   location.  The zto argument is the file to create.  The zorig
   argument is the name of the file to move.  If fmkdirs is TRUE, then
   any necessary directories are created; fpublic indicates whether
   they should be publically writeable or not.  If fcheck is TRUE,
   this should make sure the directory is writeable by the user zuser
   (if zuser is NULL, then it must be writeable by any user); this is
   to avoid a window of vulnerability between fsysdep_in_directory and
   fsysdep_move_file.  This function should return FALSE on error, in
   which case the zorig file should still exist.  */
extern boolean fsysdep_move_file P((const char *zorig, const char *zto,
				    boolean fmkdirs, boolean fpublic,
				    boolean fcheck, const char *zuser));

/* Change the mode of a file.  The imode argument is a Unix mode.
   This should return FALSE on error.  */
extern boolean fsysdep_change_mode P((const char *zfile,
				      unsigned int imode));

/* Truncate a file which we are receiving into.  This may be done by
   closing the original file, removing it and reopening it.  This
   should return FALSE on error.  */
extern openfile_t esysdep_truncate P((openfile_t e, const char *zname));

/* Sync a file to disk.  If this fails it should log an error using
   the zmsg parameter, and return FALSE.  This is controlled by the
   FSYNC_ON_CLOSE macro in policy.h.  */
extern boolean fsysdep_sync P((openfile_t e, const char *zmsg));

/* It is possible for the acknowledgement of a received file to be
   lost.  The sending system will then now know that the file was
   correctly received, and will send it again.  This can be a problem
   particularly with protocols which support channels, since they may
   send several small files in a single window, all of which may be
   received correctly although the sending system never sees the
   acknowledgement.  If these files involve an execution, the
   execution will happen twice, which will be bad.

   This function is called when a file is completely received.  It is
   supposed to try and remember the reception, in case the connection
   is lost.  It is passed the system, the file name to receive to, and
   the temporary file name from the sending system.  It should return
   FALSE on error.  */
extern boolean fsysdep_remember_reception P((const struct uuconf_system *qsys,
					     const char *zto,
					     const char *ztemp));

/* This function is called to see if a file has already been received
   successfully.  It gets the same arguments as
   fsysdep_remember_reception.  It should return TRUE if the file was
   already received, FALSE otherwise.  There is no way to report
   error.  */
extern boolean fsysdep_already_received P((const struct uuconf_system *qsys,
					   const char *zto,
					   const char *ztemp));

/* This function is called when it is no longer necessary to remember
   that a file has been received.  This will be called when the
   protocol knows that the receive message has been acknowledged.  It
   gets the same arguments as fsysdep_remember_reception.  it should
   return FALSE on error.  */
extern boolean fsysdep_forget_reception P((const struct uuconf_system *qsys,
					   const char *zto,
					   const char *ztemp));

/* Start expanding a wildcarded file name.  This should return FALSE
   on error; otherwise subsequent calls to zsysdep_wildcard should
   return file names.  */
extern boolean fsysdep_wildcard_start P((const char *zfile));

/* Get the next wildcard name.  This should return NULL when there are
   no more names to return.  The return value should be freed using
   ubuffree.  The argument should be the same as that to
   fsysdep_wildcard_start.  There is no way to return error.  */
extern char *zsysdep_wildcard P((const char *zfile));

/* Finish getting wildcard names.  This may be called before or after
   zsysdep_wildcard has returned NULL.  It should return FALSE on
   error.  */
extern boolean fsysdep_wildcard_end P((void));

/* Prepare to execute a bunch of file transfer requests.  This should
   make an entry in the spool directory so that the next time uucico
   is started up it will transfer these files.  The bgrade argument
   specifies the grade of the commands.  The commands themselves are
   in the pascmds array, which has ccmds entries.  The function should
   return NULL on error, or the jobid on success.  The jobid is a
   string that may be printed or passed to fsysdep_kill_job and
   related functions, but is otherwise uninterpreted.  */
extern char *zsysdep_spool_commands P((const struct uuconf_system *qsys,
				       int bgrade, int ccmds,
				       const struct scmd *pascmds));

/* Get a file name to use for a data file to be copied to another
   system.  The ztname, zdname and zxname arguments will all either be
   NULL or point to an array of CFILE_NAME_LEN characters in length.
   The ztname array should be set to a temporary file name that could
   be passed to zsysdep_spool_file_name to retrieve the return value
   of this function; this will be appropriate for the temporary name
   in a send request.  The zdname array should be set to a data file
   name that is appropriate for the spool directory of the other
   system; this will be appropriate for the name of the destination
   file in a send request of a data file for an execution of some
   sort.  The zxname array should be set to an execute file name that
   is appropriate for the other system.  The zlocalname argument is
   the name of the local system as seen by the remote system, the
   bgrade argument is the grade, and fxqt is TRUE if this file is
   going to become an execution file.  This should return NULL on
   error.  */
#define CFILE_NAME_LEN (15)

extern char *zsysdep_data_file_name P((const struct uuconf_system *qsys,
				       const char *zlocalname,
				       int bgrade, boolean fxqt,
				       char *ztname, char *zdname,
				       char *zxname));

/* Get a name for a local execute file.  This is used by uux for a
   local command with remote files.  Returns NULL on error.  */
extern char *zsysdep_xqt_file_name P((void));

/* Beginning getting execute files.  To get a list of execute files,
   first fsysdep_get_xqt_init is called, then zsysdep_get_xqt is
   called several times until it returns NULL, then finally
   usysdep_get_xqt_free is called.  If the zsystem argument is not
   NULL, it is the name of a system for which execution files are
   desired.  */
extern boolean fsysdep_get_xqt_init P((const char *zsystem));

/* Get the next execute file.  This should return NULL when finished
   (with *pferr set to FALSE).  The zsystem argument should be the
   same string as that passed to fsysdep_get_xqt_init.  On an error
   this should return NULL with *pferr set to TRUE.  This should set
   *pzsystem to the name of the system for which the execute file was
   created; this is not guaranteed to match the zsystem argument--that
   must be double checked by the caller.  Both the return value and
   *pzsystem should be freed using ubuffree.  */
extern char *zsysdep_get_xqt P((const char *zsystem, char **pzsystem,
				boolean *pferr));

/* Clean up after getting execute files.  The zsystem argument should
   be the same string as that passed to fsysdep_get_xqt_init.  */
extern void usysdep_get_xqt_free P((const char *zsystem));

/* Get the absolute pathname of a command to execute.  This is given
   the legal list of commands (which may be the special case "ALL")
   and the path.  It must return an absolute pathname to the command.
   If it gets an error it should set *pferr to TRUE and return NULL;
   if the command is not found it should set *pferr to FALSE and
   return NULL.  */
extern char *zsysdep_find_command P((const char *zcmd, char **pzcmds,
				     char **pzpath, boolean *pferr));

/* Expand file names for uuxqt.  This exists because uuxqt on Unix has
   to expand file names which begin with a ~.  It does not want to
   expand any other type of file name, and it turns a double ~ into a
   single one without expanding.  If this returns NULL, the file does
   not need to be changed; otherwise it returns a zbufalc'ed string.
   There is no way to report error.  */
extern char *zsysdep_xqt_local_file P((const struct uuconf_system *qsys,
				       const char *zfile));

#if ! ALLOW_FILENAME_ARGUMENTS
/* Check an argument to an execution command to make sure that it
   doesn't refer to a file name that may not be accessed.  This should
   check the argument to see if it is a filename.  If it is, it should
   either reject it out of hand or it should call fin_directory_list
   on the file with both qsys->zremote_receive and qsys->zremote_send.
   If the file is rejected, it should log an error and return FALSE.
   Otherwise it should return TRUE.  */
extern boolean fsysdep_xqt_check_file P((const struct uuconf_system *qsys,
					 const char *zfile));
#endif /* ! ALLOW_FILENAME_ARGUMENTS */

/* Run an execute file.  The arguments are:

   qsys -- system for which execute file was created
   zuser -- user who requested execution
   pazargs -- list of arguments to command (element 0 is command)
   zfullcmd -- command and arguments stuck together in one string
   zinput -- file name for standard input (may be NULL)
   zoutput -- file name for standard output (may be NULL)
   fshell -- if TRUE, use /bin/sh to execute file
   ilock -- return value of ixsysdep_lock_uuxqt
   pzerror -- set to name of standard error file
   pftemp -- set to TRUE if error is temporary, FALSE otherwise

   If fshell is TRUE, the command should be executed with /bin/sh
   (obviously, this can only really be done on Unix systems).  If an
   error occurs this should return FALSE and set *pftemp
   appropriately.  *pzerror should be freed using ubuffree.  */
extern boolean fsysdep_execute P((const struct uuconf_system *qsys,
				  const char *zuser,
				  const char **pazargs,
				  const char *zfullcmd,
				  const char *zinput,
				  const char *zoutput,
				  boolean fshell,
				  int ilock,
				  char **pzerror,
				  boolean *pftemp));

/* Lock for uuxqt execution.  If the cmaxuuxqts argument is not zero,
   this should make sure that no more than cmaxuuxqts uuxqt processes
   are running at once.  Also, only one uuxqt may execute a particular
   command (specified by the -c option) at a time.  If zcmd is not
   NULL, it is a command that must be locked.  This should return a
   nonnegative number which will be passed to other routines,
   including fsysdep_unlock_uuxqt, or -1 on error.  */
extern int ixsysdep_lock_uuxqt P((const char *zcmd,
				  int cmaxuuxqts));

/* Unlock a uuxqt process.  This is passed the return value of
   ixsysdep_lock_uuxqt, as well as the arguments passed to
   ixsysdep_lock_uuxqt.  It may return FALSE on error, but at present
   the return value is ignored.  */
extern boolean fsysdep_unlock_uuxqt P((int iseq, const char *zcmd,
				       int cmaxuuxqts));

/* See whether a particular uuxqt command is locked.  This should
   return TRUE if the command is locked (because ixsysdep_lock_uuxqt
   was called with it as an argument), FALSE otherwise.  There is no
   way to return error.  */
extern boolean fsysdep_uuxqt_locked P((const char *zcmd));

/* Lock an execute file in order to execute it.  This should return
   FALSE if the execute file is already locked.  There is no way to
   return error.  */
extern boolean fsysdep_lock_uuxqt_file P((const char *zfile));

/* Unlock an execute file.  This should return FALSE on error.  */
extern boolean fsysdep_unlock_uuxqt_file P((const char *zfile));

/* Lock the execution directory.  The ilock argument is the return
   value of ixsysdep_lock_uuxqt.  This should return FALSE if the
   directory is already locked.  There is no way to return error.  */
extern boolean fsysdep_lock_uuxqt_dir P((int ilock));

/* Remove all files in the execution directory, and unlock it.  This
   should return FALSE on error.  */
extern boolean fsysdep_unlock_uuxqt_dir P((int ilock));

/* Move files into or out of the execution directory.  The code will
   already have checked that all the files exist.  The elements in the
   pzfrom array will be complete filenames, and the elements in the
   pzto array will be either NULL (in which case the file should not
   be moved) or simple base names.  If fto is TRUE, the files in
   pzfrom should be moved to pzto; otherwise, the files in pzto should
   be moved to pzfrom (this is used if a temporary failure occurs, in
   which case the execution will be retried later).  If pzinput and
   *pzinput are not NULL, then it is the name of the standard input
   file; if it is the same as any element of pzfrom, then *pzinput
   should be set to the zbufcpy of the corresponding pzto value, if
   any.  */
extern boolean fsysdep_move_uuxqt_files P((int cfiles,
					   const char *const *pzfrom,
					   const char *const *pzto,
					   boolean fto, int ilock,
					   char **pzinput));

/* Expand a file name on the local system, defaulting to the current
   directory.  This is just like zsysdep_local_file, except that
   relative files are placed in the working directory the program
   started in rather than in the public directory.  This should return
   NULL on error.  */
extern char *zsysdep_local_file_cwd P((const char *zname,
				       const char *zpubdir,
				       boolean *pfbadname));

/* Add the working directory to a file name.  The named file is
   actually on a remote system.  If the file already has a directory,
   it should not be changed.  This should return NULL on error.  */
extern char *zsysdep_add_cwd P((const char *zfile));

/* See whether a file name will need the current working directory
   when zsysdep_local_file_cwd or zsysdep_add_cwd is called on it.
   This will be called before usysdep_initialize.  It should just
   check whether the argument is an absolute path.  See the comment
   above usysdep_initialize in this file for an explanation of why
   things are done this way.  */
extern boolean fsysdep_needs_cwd P((const char *zfile));

/* Get the base name of a file.  The file will be a local file name,
   and this function should return the base file name, ideally in a
   form which will make sense on most systems; it will be used if the
   destination of a uucp is a directory.  */
extern char *zsysdep_base_name P((const char *zfile));

/* Return a filename within a directory.  */
extern char *zsysdep_in_dir P((const char *zdir, const char *zfile));

/* Get the mode of a file.  This should return a Unix style file mode.
   It should return 0 on error.  */
extern unsigned int ixsysdep_file_mode P((const char *zfile));

/* See whether the user has access to a file.  This is called by uucp
   and uux to prevent copying of a file which uucp can read but the
   user cannot.  If access is denied, this should log an error message
   and return FALSE.  */
extern boolean fsysdep_access P((const char *zfile));

/* See whether the daemon has access to a file.  This is called by
   uucp and uux when a file is queued up for transfer without being
   copied into the spool directory.  It is merely an early error
   check, as the daemon would of course discover the error itself when
   it tried the transfer.  If access would be denied, this should log
   an error message and return FALSE.  */
extern boolean fsysdep_daemon_access P((const char *zfile));

/* Translate a destination from system!user to a place in the public
   directory where uupick will get the file.  On Unix this produces
   system!~/receive/user/localname, and that's probably what it has to
   produce on any other system as well.  Returns NULL on a usage
   error, or otherwise returns string allocated by zbufcpy.  */
extern char *zsysdep_uuto P((const char *zdest,
			     const char *zlocalname));

/* Return TRUE if a pathname exists and is a directory.  */
extern boolean fsysdep_directory P((const char *zpath));

/* Walk a directory tree.  The zdir argument is the directory to walk.
   The pufn argument is a function to call on each regular file in the
   tree.  The first argument to pufn should be the full filename; the
   second argument to pufn should be the filename relative to zdir;
   the third argument to pufn should be the pinfo argument to
   usysdep_walk_tree.  The usysdep_walk_tree function should return
   FALSE on error.  */
extern boolean usysdep_walk_tree P((const char *zdir,
				    void (*pufn) P((const char *zfull,
						    const char *zrelative,
						    pointer pinfo)),
				    pointer pinfo));

/* Return the jobid of a work file, given the sequence value.  On
   error this should log an error and return NULL.  The jobid is a
   string which may be printed out and read in and passed to
   fsysdep_kill_job, etc., but is not otherwise interpreted.  */
extern char *zsysdep_jobid P((const struct uuconf_system *qsys,
			      pointer pseq));

/* See whether the current user is privileged.  Privileged users are
   permitted to kill jobs submitted by another user, and they are
   permitted to use the -u argument to uucico; other uses of this call
   may be added later.  This should return TRUE if permission is
   granted, FALSE otherwise.  */
extern boolean fsysdep_privileged P((void));

/* Kill a job, given the jobid.  This should remove all associated
   files and in general eliminate the job completely.  On error it
   should log an error message and return FALSE.  */
extern boolean fsysdep_kill_job P((pointer puuconf,
				   const char *zjobid));

/* Rejuvenate a job, given the jobid.  If possible, this should update
   the time associated with the job such that it will not be
   eliminated by uustat -K or similar programs that check the creation
   time.  This should affect the return value of ixsysdep_work_time.
   On error it should log an error message and return FALSE.  */
extern boolean fsysdep_rejuvenate_job P((pointer puuconf,
					 const char *zjobid));

/* Get the time a job was queued, given the sequence number.  There is
   no way to indicate error.  The return value must use the same epoch
   as ixsysdep_time.  */
extern long ixsysdep_work_time P((const struct uuconf_system *qsys,
				  pointer pseq));

/* Get the time a file was created.  This is called by uustat on
   execution files.  There is no way to indicate error.  The return
   value must use the same epoch as ixsysdep_time.  */
extern long ixsysdep_file_time P((const char *zfile));

/* Touch a file to make it appear as though it was created at the
   current time.  This is called by uustat on execution files.  On
   error this should log an error message and return FALSE.  */
extern boolean fsysdep_touch_file P((const char *zfile));

/* Get the size in bytes of a file.  If this file does not exist, this
   should not give an error message, but should return -1.  If some
   other error occurs, this should return -2.  */
extern long csysdep_size P((const char *zfile));

/* Return the amount of free space on the containing the given file
   name (the file may or may not exist).  If the amount of free space
   cannot be determined, the function should return -1.  */
extern long csysdep_bytes_free P((const char *zfile));

/* Start getting status information for all systems with available
   status information.  There may be status information for unknown
   systems, which is why this series of functions is used.  The phold
   argument is used to pass information around, to possibly avoid the
   use of static variables.  On error this should log an error and
   return FALSE.  */
extern boolean fsysdep_all_status_init P((pointer *phold));

/* Get status information for the next system.  This should return the
   system name and fill in the qstat argument.  The phold argument
   will be that set by fsysdep_all_status_init.  On error this should
   log an error, set *pferr to TRUE, and return NULL.  */
extern char *zsysdep_all_status P((pointer phold, boolean *pferr,
				   struct sstatus *qstat));

/* Free up anything allocated by fsysdep_all_status_init and
   zsysdep_all_status.  The phold argument is that set by
   fsysdep_all_status_init.  */
extern void usysdep_all_status_free P((pointer phold));

/* Display the process status of all processes holding lock files.
   This is uustat -p.  The return value is passed to usysdep_exit.  */
extern boolean fsysdep_lock_status P((void));

/* Return TRUE if the user has legitimate access to the port.  This is
   used by cu to control whether the user can open a port directly,
   rather than merely being able to dial out on it.  Opening a port
   directly allows the modem to be reprogrammed.  */
extern boolean fsysdep_port_access P((struct uuconf_port *qport));

/* Return whether the given port could be named by the given line.  On
   Unix, the line argument would be something like "ttyd0", and this
   function should return TRUE if the named port is "/dev/ttyd0".  */
extern boolean fsysdep_port_is_line P((struct uuconf_port *qport,
				       const char *zline));

/* Set the terminal into raw mode.  In this mode no input characters
   should be treated specially, and characters should be made
   available as they are typed.  The original terminal mode should be
   saved, so that it can be restored by fsysdep_terminal_restore.  If
   flocalecho is TRUE, then local echoing should still be done;
   otherwise echoing should be disabled.  This function returns FALSE
   on error.  */
extern boolean fsysdep_terminal_raw P((boolean flocalecho));

/* Restore the terminal back to the original setting, before
   fsysdep_terminal_raw was called.  Returns FALSE on error.  */
extern boolean fsysdep_terminal_restore P((void));

/* Read a line from the terminal.  The fsysdep_terminal_raw function
   will have been called.  This should print the zprompt argument
   (unless it is NULL) and return the line, allocated by zbufcpy, or
   NULL on error.  */
extern char *zsysdep_terminal_line P((const char *zprompt));

/* Write a line to the terminal, ending with a newline.  This is
   basically just puts (zline, stdout), except that the terminal will
   be in raw mode, so on ASCII Unix systems the line needs to end with
   \r\n.  */
extern boolean fsysdep_terminal_puts P((const char *zline));

/* If faccept is TRUE, permit the user to generate signals from the
   terminal.  If faccept is FALSE, turn signals off again.  After
   fsysdep_terminal_raw is called, signals should be off.  Return
   FALSE on error.  */
extern boolean fsysdep_terminal_signals P((boolean faccept));

/* The cu program expects the system dependent code to handle the
   details of copying data from the communications port to the
   terminal.  This should be set up by fsysdep_cu_init, and done while
   fsysdep_cu is called.  It is permissible to do it on a continual
   basis (on Unix a subprocess handles it) so long as the copying can
   be stopped by the fsysdep_cu_copy function.

   The fsysdep_cu_init function does any system dependent
   initialization needed for this.  */
extern boolean fsysdep_cu_init P((struct sconnection *qconn));

/* Copy all data from the communications port to the terminal, and all
   data from the terminal to the communications port.  Keep this up
   until the escape character *zCuvar_escape is seen.  Set *pbcmd to
   the character following the escape character; after the escape
   character, zlocalname should be printed, possibly after a delay.
   If two escape characters are entered in sequence, this function
   should send a single escape character to the port, and not return.
   Returns FALSE on error.  */
extern boolean fsysdep_cu P((struct sconnection *qconn,
			     char *pbcmd,
			     const char *zlocalname));

/* If fcopy is TRUE, start copying data from the communications port
   to the terminal.  If fcopy is FALSE, stop copying data.  This
   function may be called several times during a cu session.  It
   should return FALSE on error.  */
extern boolean fsysdep_cu_copy P((boolean fcopy));

/* Stop copying data from the communications port to the terminal, and
   generally clean up after fsysdep_cu_init and fsysdep_cu.  Returns
   FALSE on error.  */
extern boolean fsysdep_cu_finish P((void));

/* Run a shell command.  If zcmd is NULL, or *zcmd == '\0', just
   start up a shell.  The second argument is one of the following
   values.  This should return FALSE on error.  */
enum tshell_cmd
{
  /* Attach stdin and stdout to the terminal.  */
  SHELL_NORMAL,
  /* Attach stdout to the communications port, stdin to the terminal.  */
  SHELL_STDOUT_TO_PORT,
  /* Attach stdin to the communications port, stdout to the terminal.  */
  SHELL_STDIN_FROM_PORT,
  /* Attach both stdin and stdout to the communications port.  */
  SHELL_STDIO_ON_PORT
};

extern boolean fsysdep_shell P((struct sconnection *qconn,
				const char *zcmd,
				enum tshell_cmd tcmd));

/* Change directory.  If zdir is NULL, or *zdir == '\0', change to the
   user's home directory.  Return FALSE on error.  */
extern boolean fsysdep_chdir P((const char *zdir));

/* Suspend the current process.  This is only expected to work on Unix
   versions that support SIGTSTP.  In general, people can just shell
   out.  */
extern boolean fsysdep_suspend P((void));

/* Start getting files for uupick.  The zsystem argument may be NULL
   to get files from all systems, or it may specify a particular
   system.  The zpubdir argument is the public directory to use.  This
   returns FALSE on error.  */
extern boolean fsysdep_uupick_init P((const char *zsystem,
				      const char *zpubdir));

/* Get the next file for uupick.  This returns the basic file name.
   It sets *pzfull to the full name, and *pzfrom to the name of the
   system which sent this file over; both should be freed using
   ubuffree.  *pzfull should be passed to ubuffree after it is no
   longer needed.  The zsystem and zpubdir arguments should be the
   same as the arguments to fsysdep_uupick_init.  This returns NULL
   when all files been returned.  */
extern char *zsysdep_uupick P((const char *zsystem, const char *zpubdir,
			       char **pzfrom, char **pzfull));

/* Clean up after getting files for uupick.  */
extern boolean fsysdep_uupick_free P((const char *zsystem,
				      const char *zpubdir));

/* Translate a local file name for uupick.  On Unix this is just like
   zsysdep_local_file_cwd except that a file beginning with ~/ is
   placed in the user's home directory rather than in the public
   directory.  */
extern char *zsysdep_uupick_local_file P((const char *zfile,
					  boolean *pfbadname));

/* Remove a directory and all the files in it.  */
extern boolean fsysdep_rmdir P((const char *zdir));

#endif /* ! defined (SYSTEM_H) */