home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / uucp / Uucp.framework / uudefs.h < prev   
Encoding:
C/C++ Source or Header  |  1995-08-20  |  15.2 KB  |  450 lines
  1. /* uudefs.h
  2.    Miscellaneous definitions for the UUCP package.
  3.  
  4.    Copyright (C) 1991, 1992, 1993, 1995 Ian Lance Taylor
  5.  
  6.    This file is part of the Taylor UUCP package.
  7.  
  8.    This program is free software; you can redistribute it and/or
  9.    modify it under the terms of the GNU General Public License as
  10.    published by the Free Software Foundation; either version 2 of the
  11.    License, or (at your option) any later version.
  12.  
  13.    This program is distributed in the hope that it will be useful, but
  14.    WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.    General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU General Public License
  19.    along with this program; if not, write to the Free Software
  20.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21.  
  22.    The author of the program may be contacted at ian@airs.com or
  23.    c/o Cygnus Support, 48 Grove Street, Somerville, MA 02144.
  24.    */
  25.  
  26. #if ANSI_C
  27. /* These structures are used in prototypes but are not defined in this
  28.    header file.  */
  29. struct uuconf_system;
  30. struct uuconf_timespan;
  31. #endif
  32.  
  33. /* The tlog enumeration holds the different types of logging.  */
  34. enum tlog
  35. {
  36.   /* Normal log entry.  */
  37.   LOG_NORMAL,
  38.   /* Error log entry.  */
  39.   LOG_ERROR,
  40.   /* Fatal log entry.  */
  41.   LOG_FATAL
  42. #if DEBUG > 1
  43.     ,
  44.   /* Debugging log entry.  */
  45.   LOG_DEBUG,
  46.   /* Start debugging log entry.  */
  47.   LOG_DEBUG_START,
  48.   /* Continue debugging log entry.  */
  49.   LOG_DEBUG_CONTINUE,
  50.   /* End debugging log entry.  */
  51.   LOG_DEBUG_END
  52. #endif
  53. };
  54.  
  55. /* The tstatus_type enumeration holds the kinds of status information
  56.    we put in the status file.  The order of entries here corresponds
  57.    to the order of entries in the azStatus array.  */
  58. enum tstatus_type
  59. {
  60.   /* Conversation complete.  */
  61.   STATUS_COMPLETE,
  62.   /* Port unavailable.  */
  63.   STATUS_PORT_FAILED,
  64.   /* Dial failed.  */
  65.   STATUS_DIAL_FAILED,
  66.   /* Login failed.  */
  67.   STATUS_LOGIN_FAILED,
  68.   /* Handshake failed.  */
  69.   STATUS_HANDSHAKE_FAILED,
  70.   /* Failed after logging in.  */
  71.   STATUS_FAILED,
  72.   /* Talking to remote system.  */
  73.   STATUS_TALKING,
  74.   /* Wrong time to call.  */
  75.   STATUS_WRONG_TIME,
  76.   /* Number of status values.  */
  77.   STATUS_VALUES
  78. };
  79.  
  80. /* An array to convert status entries to strings.  If more status entries
  81.    are added, this array must be extended.  */
  82. extern const char *azStatus[];
  83.  
  84. /* The sstatus structure holds the contents of a system status file.  */
  85. struct sstatus
  86. {
  87.   /* Current status of conversation.  */
  88.   enum tstatus_type ttype;
  89.   /* Number of failed retries.  */
  90.   int cretries;
  91.   /* Time of last call in seconds since epoch (determined by
  92.      ixsysdep_time).  */
  93.   long ilast;
  94.   /* Number of seconds until a retry is permitted.  */
  95.   int cwait;
  96.   /* String in status file.  Only used when reading status file, not
  97.      when writing.  May be NULL.  Should be freed with ubuffree.  */
  98.   char *zstring;
  99. };
  100.  
  101. /* How long we have to wait for the next call, given the number of retries
  102.    we have already made.  This should probably be configurable.  */
  103. #define CRETRY_WAIT(c) ((c) * 10 * 60)
  104.  
  105. /* The scmd structure holds a complete UUCP command.  */
  106. struct scmd
  107. {
  108.   /* Command ('S' for send, 'R' for receive, 'X' for execute, 'E' for
  109.      simple execution, 'H' for hangup, 'Y' for hangup confirm, 'N' for
  110.      hangup deny).  */
  111.   char bcmd;
  112.   /* Grade of the command ('\0' if from remote system).  */
  113.   char bgrade;
  114.   /* Sequence handle for fsysdep_did_work.  */
  115.   pointer pseq;
  116.   /* File name to transfer from.  */
  117.   const char *zfrom;
  118.   /* File name to transfer to.  */
  119.   const char *zto;
  120.   /* User who requested transfer.  */
  121.   const char *zuser;
  122.   /* Options.  */
  123.   const char *zoptions;
  124.   /* Temporary file name ('S' and 'E').  */
  125.   const char *ztemp;
  126.   /* Mode to give newly created file ('S' and 'E').  */
  127.   unsigned int imode;
  128.   /* User to notify on remote system (optional; 'S' and 'E').  */
  129.   const char *znotify;
  130.   /* File size (-1 if not supplied) ('S', 'E' and 'R').  */
  131.   long cbytes;
  132.   /* Command to execute ('E').  */
  133.   const char *zcmd;
  134.   /* Position to restart from ('R').  */
  135.   long ipos;
  136. };
  137.  
  138. #if DEBUG > 1
  139.  
  140. /* We allow independent control over several different types of
  141.    debugging output, using a bit string with individual bits dedicated
  142.    to particular debugging types.  */
  143.  
  144. /* The bit string is stored in iDebug.  */
  145. extern int iDebug;
  146.  
  147. /* Debug abnormal events.  */
  148. #define DEBUG_ABNORMAL (01)
  149. /* Debug chat scripts.  */
  150. #define DEBUG_CHAT (02)
  151. /* Debug initial handshake.  */
  152. #define DEBUG_HANDSHAKE (04)
  153. /* Debug UUCP protocol.  */
  154. #define DEBUG_UUCP_PROTO (010)
  155. /* Debug protocols.  */
  156. #define DEBUG_PROTO (020)
  157. /* Debug port actions.  */
  158. #define DEBUG_PORT (040)
  159. /* Debug configuration files.  */
  160. #define DEBUG_CONFIG (0100)
  161. /* Debug spool directory actions.  */
  162. #define DEBUG_SPOOLDIR (0200)
  163. /* Debug executions.  */
  164. #define DEBUG_EXECUTE (0400)
  165. /* Debug incoming data.  */
  166. #define DEBUG_INCOMING (01000)
  167. /* Debug outgoing data.  */
  168. #define DEBUG_OUTGOING (02000)
  169.  
  170. /* Maximum possible value for iDebug.  */
  171. #define DEBUG_MAX (03777)
  172.  
  173. /* Intializer for array of debug names.  The index of the name in the
  174.    array is the corresponding bit position in iDebug.  We only check
  175.    for prefixes, so these names only need to be long enough to
  176.    distinguish each name from every other.  The last entry must be
  177.    NULL.  The string "all" is also recognized to turn on all
  178.    debugging.  */
  179. #define DEBUG_NAMES \
  180.   { "a", "ch", "h", "u", "pr", "po", "co", "s", "e", "i", "o", NULL }
  181.  
  182. /* The prefix to use to turn off all debugging.  */
  183. #define DEBUG_NONE "n"
  184.  
  185. /* Check whether a particular type of debugging is being done.  */
  186. #define FDEBUGGING(i) ((iDebug & (i)) != 0)
  187.  
  188. /* These macros are used to output debugging information.  I use
  189.    several different macros depending on the number of arguments
  190.    because no macro can take a variable number of arguments and I
  191.    don't want to use double parentheses.  */
  192. #define DEBUG_MESSAGE0(i, z) \
  193.   do { if (FDEBUGGING (i)) ulog (LOG_DEBUG, (z)); } while (0)
  194. #define DEBUG_MESSAGE1(i, z, a1) \
  195.   do { if (FDEBUGGING (i)) ulog (LOG_DEBUG, (z), (a1)); } while (0)
  196. #define DEBUG_MESSAGE2(i, z, a1, a2) \
  197.   do { if (FDEBUGGING (i)) ulog (LOG_DEBUG, (z), (a1), (a2)); } while (0)
  198. #define DEBUG_MESSAGE3(i, z, a1, a2, a3) \
  199.   do \
  200.     { \
  201.       if (FDEBUGGING (i)) \
  202.     ulog (LOG_DEBUG, (z), (a1), (a2), (a3)); \
  203.     } \
  204.   while (0)
  205. #define DEBUG_MESSAGE4(i, z, a1, a2, a3, a4) \
  206.   do \
  207.     { \
  208.       if (FDEBUGGING (i)) \
  209.     ulog (LOG_DEBUG, (z), (a1), (a2), (a3), (a4)); \
  210.     } \
  211.   while (0)
  212.  
  213. #else /* DEBUG <= 1 */
  214.  
  215. /* If debugging information is not being compiled, provide versions of
  216.    the debugging macros which just disappear.  */
  217. #define DEBUG_MESSAGE0(i, z)
  218. #define DEBUG_MESSAGE1(i, z, a1)
  219. #define DEBUG_MESSAGE2(i, z, a1, a2)
  220. #define DEBUG_MESSAGE3(i, z, a1, a2, a3)
  221. #define DEBUG_MESSAGE4(i, z, a1, a2, a3, a4)
  222.  
  223. #endif /* DEBUG <= 1 */
  224.  
  225. /* Functions.  */
  226.  
  227. /* Given an unknown system name, return information for an unknown
  228.    system.  If unknown systems are not permitted, this returns FALSE.
  229.    Otherwise, it translates the name as necessary for the spool
  230.    directory, and fills in *qsys.  */
  231. extern boolean funknown_system P((pointer puuconf, const char *zsystem,
  232.                   struct uuconf_system *qsys));
  233.  
  234. /* See whether a file belongs in the spool directory.  */
  235. extern boolean fspool_file P((const char *zfile));
  236.  
  237. /* See if the current time matches a time span.  If not, return FALSE.
  238.    Otherwise, return TRUE and set *pival and *pcretry to the values
  239.    from the matching element of the span.  */
  240. extern boolean ftimespan_match P((const struct uuconf_timespan *qspan,
  241.                   long *pival, int *pcretry));
  242.  
  243. /* Remove all occurrences of the local system name followed by an
  244.    exclamation point from the start of the argument.  Return the
  245.    possibly shortened argument.  */
  246. extern char *zremove_local_sys P((struct uuconf_system *qlocalsys,
  247.                   char *z));
  248.  
  249. /* Determine the maximum size that may ever be transferred, given a
  250.    timesize span.  If there are any time gaps larger than 1 hour not
  251.    described by the timesize span, this returns -1.  Otherwise it
  252.    returns the largest size that may be transferred at some time.  */
  253. extern long cmax_size_ever P((const struct uuconf_timespan *qtimesize));
  254.  
  255. /* Send mail about a file transfer.  */
  256. extern boolean fmail_transfer P((boolean fok, const char *zuser,
  257.                  const char *zmail, const char *zwhy,
  258.                  const char *zfrom, const char *zfromsys,
  259.                  const char *zto, const char *ztosys,
  260.                  const char *zsaved));
  261.  
  262. /* See whether a file is in one of a list of directories.  The zpubdir
  263.    argument is used to pass the directory names to zsysdep_local_file.
  264.    If fcheck is FALSE, this does not check accessibility.  Otherwise,
  265.    if freadable is TRUE, the user zuser must have read access to the
  266.    file and all appropriate directories; if freadable is FALSE zuser
  267.    must have write access to the appropriate directories.  The zuser
  268.    argument may be NULL, in which case all users must have the
  269.    appropriate access (this is used for a remote request).  */
  270. extern boolean fin_directory_list P((const char *zfile,
  271.                      char **pzdirs,
  272.                      const char *zpubdir,
  273.                      boolean fcheck,
  274.                      boolean freadable,
  275.                      const char *zuser));
  276.  
  277. /* Parse a command string.  */
  278. extern boolean fparse_cmd P((char *zcmd, struct scmd *qcmd));
  279.  
  280. /* Make a log entry.  */
  281. #ifdef __GNUC__
  282. #define GNUC_VERSION __GNUC__
  283. #else
  284. #define GNUC_VERSION 0
  285. #endif
  286.  
  287. #if ANSI_C && HAVE_VFPRINTF
  288. extern void ulog P((enum tlog ttype, const char *zfmt, ...))
  289. #if GNUC_VERSION > 1
  290.      __attribute__ ((format (printf, 2, 3)))
  291. #endif
  292.      ;
  293. #else
  294. extern void ulog ();
  295. #endif
  296.  
  297. #undef GNUC_VERSION
  298.  
  299. /* Report an error returned by one of the uuconf routines.  */
  300. extern void ulog_uuconf P((enum tlog ttype, pointer puuconf,
  301.                int iuuconf));
  302.  
  303. /* Set the function to call if a fatal error occurs.  */
  304. extern void ulog_fatal_fn P((void (*pfn) P((void))));
  305.  
  306. /* If ffile is TRUE, send log entries to the log file rather than to
  307.    stderr.  */
  308. extern void ulog_to_file P((pointer puuconf, boolean ffile));
  309.  
  310. /* Set the ID number used by the logging functions.  */
  311. extern void ulog_id P((int iid));
  312.  
  313. /* Set the system name used by the logging functions.  */
  314. extern void ulog_system P((const char *zsystem));
  315.  
  316. /* Set the system and user name used by the logging functions.  */
  317. extern void ulog_user P((const char *zuser));
  318.  
  319. /* Set the device name used by the logging functions.  */
  320. extern void ulog_device P((const char *zdevice));
  321.  
  322. /* Close the log file.  */
  323. extern void ulog_close P((void));
  324.  
  325. /* Make an entry in the statistics file.  */
  326. extern void ustats P((boolean fsucceeded, const char *zuser,
  327.               const char *zsystem, boolean fsent,
  328.               long cbytes, long csecs, long cmicros,
  329.               boolean fcaller));
  330.  
  331. /* Close the statistics file.  */
  332. extern void ustats_close P((void));
  333.  
  334. #if DEBUG > 1
  335. /* A debugging routine to output a buffer.  This outputs zhdr, the
  336.    buffer length clen, and the contents of the buffer in quotation
  337.    marks.  */
  338. extern void udebug_buffer P((const char *zhdr, const char *zbuf,
  339.                  size_t clen));
  340.  
  341. /* A debugging routine to make a readable version of a character.
  342.    This takes a buffer at least 5 bytes long, and returns the length
  343.    of the string it put into it (not counting the null byte).  */
  344. extern size_t cdebug_char P((char *z, int ichar));
  345.  
  346. /* Parse a debugging option string.  This can either be a number or a
  347.    comma separated list of debugging names.  This returns a value for
  348.    iDebug.  */
  349. extern int idebug_parse P((const char *));
  350.  
  351. #endif /* DEBUG <= 1 */
  352.  
  353. /* Copy one file to another.  */
  354. extern boolean fcopy_file P((const char *zfrom, const char *zto,
  355.                  boolean fpublic, boolean fmkdirs,
  356.                  boolean fsignals));
  357.  
  358. /* Copy an open file to another.  */
  359. extern boolean fcopy_open_file P((openfile_t efrom, const char *zto,
  360.                   boolean fpublic, boolean fmkdirs,
  361.                   boolean fsignals));
  362.  
  363. /* Translate escape sequences in a buffer, leaving the result in the
  364.    same buffer and returning the length.  */
  365. extern size_t cescape P((char *zbuf));
  366.  
  367. /* Get a buffer to hold a string of a given size.  The buffer should
  368.    be freed with ubuffree.  */
  369. extern char *zbufalc P((size_t csize));
  370.  
  371. /* Call zbufalc to allocate a buffer and copy a string into it.  */
  372. extern char *zbufcpy P((const char *z));
  373.  
  374. /* Free up a buffer returned by zbufalc or zbufcpy.  */
  375. extern void ubuffree P((char *z));
  376.  
  377. /* Allocate memory without fail.  */
  378. extern pointer xmalloc P((size_t));
  379.  
  380. /* Realloc memory without fail.  */
  381. extern pointer xrealloc P((pointer, size_t));
  382.  
  383. /* Free memory (accepts NULL pointers, which some libraries erroneously
  384.    do not).  */
  385. extern void xfree P((pointer));
  386.  
  387. /* Global variables.  */
  388.  
  389. /* The name of the program being run.  Set from argv[0].  */
  390. extern const char *zProgram;
  391.  
  392. /* When a signal occurs, the signal handlers sets the appropriate
  393.    element of the arrays afSignal and afLog_signal to TRUE.  The
  394.    afSignal array is used to check whether a signal occurred.  The
  395.    afLog_signal array tells ulog to log the signal; ulog will clear
  396.    the element after logging it, which means that if a signal comes in
  397.    at just the right moment it will not be logged.  It will always be
  398.    recorded in afSignal, though.  At the moment we handle 5 signals:
  399.    SIGHUP, SIGINT, SIGQUIT, SIGTERM and SIGPIPE (the Unix code also
  400.    handles SIGALRM).  If we want to handle more, the afSignal array
  401.    must be extended; I see little point to handling any of the other
  402.    ANSI C or POSIX signals, as they are either unlikely to occur
  403.    (SIGABRT, SIGUSR1) or nearly impossible to handle cleanly (SIGILL,
  404.    SIGSEGV).  SIGHUP is only logged if fLog_sighup is TRUE.  */
  405. #define INDEXSIG_SIGHUP (0)
  406. #define INDEXSIG_SIGINT (1)
  407. #define INDEXSIG_SIGQUIT (2)
  408. #define INDEXSIG_SIGTERM (3)
  409. #define INDEXSIG_SIGPIPE (4)
  410. #define INDEXSIG_COUNT (5)
  411.  
  412. extern volatile sig_atomic_t afSignal[INDEXSIG_COUNT];
  413. extern volatile sig_atomic_t afLog_signal[INDEXSIG_COUNT];
  414. extern boolean fLog_sighup;
  415.  
  416. /* The names of the signals to use in error messages, as an
  417.    initializer for an array.  */
  418. #define INDEXSIG_NAMES \
  419.   { "hangup", "interrupt", "quit", "termination", "SIGPIPE" }
  420.  
  421. /* Check to see whether we've received a signal.  It would be nice if
  422.    we could use a single variable for this, but we sometimes want to
  423.    clear our knowledge of a signal and that would cause race
  424.    conditions (clearing a single element of the array is not a race
  425.    assuming that we don't care about a particular signal, even if it
  426.    occurs after we've examined the array).  */
  427. #define FGOT_SIGNAL() \
  428.   (afSignal[INDEXSIG_SIGHUP] || afSignal[INDEXSIG_SIGINT] \
  429.    || afSignal[INDEXSIG_SIGQUIT] || afSignal[INDEXSIG_SIGTERM] \
  430.    || afSignal[INDEXSIG_SIGPIPE])
  431.  
  432. /* If we get a SIGINT in uucico, we continue the current communication
  433.    session but don't start any new ones.  This macros checks for any
  434.    signal other than SIGINT, which means we should get out
  435.    immediately.  */
  436. #define FGOT_QUIT_SIGNAL() \
  437.   (afSignal[INDEXSIG_SIGHUP] || afSignal[INDEXSIG_SIGQUIT] \
  438.    || afSignal[INDEXSIG_SIGTERM] || afSignal[INDEXSIG_SIGPIPE])
  439.  
  440. /* Device name to log.  This is set by fconn_open.  It may be NULL.  */
  441. extern char *zLdevice;
  442.  
  443. /* If not NULL, ulog calls this function before outputting anything.
  444.    This is used to support cu.  */
  445. extern void (*pfLstart) P((void));
  446.  
  447. /* If not NULL, ulog calls this function after outputting everything.
  448.    This is used to support cu.  */
  449. extern void (*pfLend) P((void));
  450.