Return to trans.h CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104

Annotation of coherent/g/usr/lib/uucp/tay104/trans.h, revision 1.1

1.1     ! root        1: /* trans.h
        !             2:    Header file for file and command transfer routines.
        !             3: 
        !             4:    Copyright (C) 1992 Ian Lance Taylor
        !             5: 
        !             6:    This file is part of the Taylor UUCP package.
        !             7: 
        !             8:    This program is free software; you can redistribute it and/or
        !             9:    modify it under the terms of the GNU General Public License as
        !            10:    published by the Free Software Foundation; either version 2 of the
        !            11:    License, or (at your option) any later version.
        !            12: 
        !            13:    This program is distributed in the hope that it will be useful, but
        !            14:    WITHOUT ANY WARRANTY; without even the implied warranty of
        !            15:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            16:    General Public License for more details.
        !            17: 
        !            18:    You should have received a copy of the GNU General Public License
        !            19:    along with this program; if not, write to the Free Software
        !            20:    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
        !            21: 
        !            22:    The author of the program may be contacted at [email protected] or
        !            23:    c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
        !            24:    */
        !            25: 
        !            26: /* The maximum possible number of channels.  */
        !            27: #define IMAX_CHAN (16)
        !            28: 
        !            29: /* The ifeatures field of the sdaemon structure is an or of the
        !            30:    following values.  These values are sent during the uucico
        !            31:    handshake, and MUST NOT CHANGE.  */
        !            32: 
        !            33: /* File size negotiation.  */
        !            34: #define FEATURE_SIZES (01)
        !            35: 
        !            36: /* File transfer restart.  */
        !            37: #define FEATURE_RESTART (02)
        !            38: 
        !            39: /* The E (execute) command.  */
        !            40: #define FEATURE_EXEC (04)
        !            41: 
        !            42: /* Version 1.03: requires decimal size in S and R command.  Needless
        !            43:    to say, this should not be used by any new programs.  */
        !            44: #define FEATURE_V103 (010)
        !            45: 
        !            46: /* SVR4 UUCP: expects dummy string between notify field and size field
        !            47:    in send command.  There is probably some meaning to this string,
        !            48:    but I don't know what it is.  If I ever find out, this flag will
        !            49:    still be used to indicate it.  */
        !            50: #define FEATURE_SVR4 (020)
        !            51: 
        !            52: /* This structure is used to hold information concerning the
        !            53:    communication link established with the remote system.  */
        !            54: 
        !            55: struct sdaemon
        !            56: {
        !            57:   /* Global uuconf pointer.  */
        !            58:   pointer puuconf;
        !            59:   /* Remote system information.  */
        !            60:   const struct uuconf_system *qsys;
        !            61:   /* Local name being used.  */
        !            62:   const char *zlocalname;
        !            63:   /* Connection structure.  */
        !            64:   struct sconnection *qconn;
        !            65:   /* Protocol being used.  */
        !            66:   const struct sprotocol *qproto;
        !            67:   /* The largest file size permitted for a local request.  */
        !            68:   long clocal_size;
        !            69:   /* The largest file size permitted for a remote request.  */
        !            70:   long cremote_size;
        !            71:   /* The largest file size that may ever be transferred.  */
        !            72:   long cmax_ever;
        !            73:   /* The remote system ulimit.  */
        !            74:   long cmax_receive;
        !            75:   /* Features supported by the remote side.  */
        !            76:   int ifeatures;
        !            77:   /* TRUE if we should request the remote side to hang up.  */
        !            78:   boolean frequest_hangup;
        !            79:   /* TRUE if the remote side requested a hangup.  */
        !            80:   boolean fhangup_requested;
        !            81:   /* TRUE if we are hanging up.  */
        !            82:   boolean fhangup;
        !            83:   /* TRUE if the local system is currently the master.  */
        !            84:   boolean fmaster;
        !            85:   /* TRUE if the local system placed the call.  */
        !            86:   boolean fcaller;
        !            87:   /* UUCONF_RELIABLE_* flags for the connection.  */
        !            88:   int ireliable;
        !            89:   /* If fcaller is FALSE, the lowest grade which may be transferred
        !            90:      during this call.  */
        !            91:   char bgrade;
        !            92: };
        !            93: 
        !            94: /* This structure is used to hold a file or command transfer which is
        !            95:    in progress.  */
        !            96: 
        !            97: struct stransfer
        !            98: {
        !            99:   /* Next file transfer in queue.  */
        !           100:   struct stransfer *qnext;
        !           101:   /* Previous file transfer in queue.  */
        !           102:   struct stransfer *qprev;
        !           103:   /* Points to the queue this structure is on.  */
        !           104:   struct stransfer **pqqueue;
        !           105:   /* The function to call to send some data.  */
        !           106:   boolean (*psendfn) P((struct stransfer *qtrans, struct sdaemon *qdaemon));
        !           107:   /* The function to call when data is received.  */
        !           108:   boolean (*precfn) P((struct stransfer *qtrans, struct sdaemon *qdaemon,
        !           109:                       const char *zdata, size_t cdata));
        !           110:   /* Type specific information.   */
        !           111:   pointer pinfo;
        !           112:   /* TRUE if we are sending the file e (this is used to avoid a call
        !           113:      to psendfn).  */
        !           114:   boolean fsendfile;
        !           115:   /* TRUE if we are receiving the file e (this is used to avoid a call
        !           116:      to precfn).  */
        !           117:   boolean frecfile;
        !           118:   /* The file to read or write.  */
        !           119:   openfile_t e;
        !           120:   /* The position we are at in the file.  */
        !           121:   long ipos;
        !           122:   /* TRUE if we are waiting for a command string.  */
        !           123:   boolean fcmd;
        !           124:   /* The command string we have so far.  */
        !           125:   char *zcmd;
        !           126:   /* The length of the command string we have so far.  */
        !           127:   size_t ccmd;
        !           128:   /* Local destination number.  */
        !           129:   int ilocal;
        !           130:   /* Remote destination number.  */
        !           131:   int iremote;
        !           132:   /* The command.  */
        !           133:   struct scmd s;
        !           134:   /* A message to log when work starts.  */
        !           135:   char *zlog;
        !           136:   /* The process time; imicros can be negative.  */
        !           137:   long isecs;
        !           138:   long imicros;
        !           139:   /* Number of bytes sent or received.  */
        !           140:   long cbytes;
        !           141: };
        !           142: 
        !           143: /* Reasons that a file transfer might fail.  */
        !           144: 
        !           145: enum tfailure
        !           146: {
        !           147:   /* No failure.  */
        !           148:   FAILURE_NONE,
        !           149:   /* No permission for operation.  */
        !           150:   FAILURE_PERM,
        !           151:   /* Can't open necessary file.  */
        !           152:   FAILURE_OPEN,
        !           153:   /* Not enough space to receive file.  */
        !           154:   FAILURE_SIZE,
        !           155:   /* File was received in a previous conversation.  */
        !           156:   FAILURE_RECEIVED
        !           157: };
        !           158: 
        !           159: /* The main loop which talks to the remote system, passing transfer
        !           160:    requests and file back and forth.  */
        !           161: extern boolean floop P((struct sdaemon *qdaemon));
        !           162: 
        !           163: /* Allocate a new transfer structure.  */
        !           164: extern struct stransfer *qtransalc P((struct scmd *qcmd));
        !           165: 
        !           166: /* Free a transfer structure.  */
        !           167: extern void utransfree P((struct stransfer *qtrans));
        !           168: 
        !           169: /* Queue up local requests.  If pfany is not NULL, this sets *pfany to
        !           170:    TRUE if there are, in fact, any local requests which can be done at
        !           171:    this point.  */
        !           172: extern boolean fqueue P((struct sdaemon *qdaemon, boolean *pfany));
        !           173: 
        !           174: /* Clear away any queued requests.  This may be called more than once
        !           175:    at the end of a call.  */
        !           176: extern void uclear_queue P((struct sdaemon *qdaemon));
        !           177: 
        !           178: /* Queue a new transfer request made by the local system.  */
        !           179: extern boolean fqueue_local P((struct sdaemon *qdaemon,
        !           180:                               struct stransfer *qtrans));
        !           181: 
        !           182: /* Queue a new transfer request made by the remote system.  */
        !           183: extern boolean fqueue_remote P((struct sdaemon *qdaemon,
        !           184:                                struct stransfer *qtrans));
        !           185: 
        !           186: /* Queue a transfer request which wants to send something.  */
        !           187: extern boolean fqueue_send P((struct sdaemon *qdaemon,
        !           188:                              struct stransfer *qtrans));
        !           189: 
        !           190: /* Queue a transfer request which wants to receiving something.  */
        !           191: extern boolean fqueue_receive P((struct sdaemon *qdaemon,
        !           192:                                 struct stransfer *qtrans));
        !           193: 
        !           194: /* Prepare to send a file by local or remote request.  */
        !           195: extern boolean flocal_send_file_init P((struct sdaemon *qdaemon,
        !           196:                                        struct scmd *qcmd));
        !           197: extern boolean fremote_send_file_init P((struct sdaemon *qdaemon,
        !           198:                                         struct scmd *qcmd,
        !           199:                                         int iremote));
        !           200: 
        !           201: /* Prepare to receive a file by local or remote request.  */
        !           202: extern boolean flocal_rec_file_init P((struct sdaemon *qdaemon,
        !           203:                                       struct scmd *qcmd));
        !           204: extern boolean fremote_rec_file_init P((struct sdaemon *qdaemon,
        !           205:                                        struct scmd *qcmd,
        !           206:                                        int iremote));
        !           207: 
        !           208: /* Prepare to request work by local or remote request.  */
        !           209: extern boolean flocal_xcmd_init P((struct sdaemon *qdaemon,
        !           210:                                   struct scmd *qcmd));
        !           211: extern boolean fremote_xcmd_init P((struct sdaemon *qdaemon,
        !           212:                                    struct scmd *qcmd,
        !           213:                                    int iremote));
        !           214: 
        !           215: /* We have lost the connection; record any in progress file transfers
        !           216:    in the statistics file and discard any temporary files.  */
        !           217: extern void ufailed P((struct sdaemon *qdaemon));
        !           218: 
        !           219: /* Check that there is enough disk space for a file receive.  Return
        !           220:    FALSE if there is not.  */
        !           221: extern boolean frec_check_free P((struct stransfer *qtrans,
        !           222:                                  long cfree_space));
        !           223: 
        !           224: /* Discard the temporary file being used to receive a file, if
        !           225:    appropriate.  */
        !           226: extern boolean frec_discard_temp P((struct sdaemon *qdaemon,
        !           227:                                    struct stransfer *qtrans));
        !           228: 
        !           229: /* Handle data received by a protocol.  This is called by the protocol
        !           230:    specific routines as data comes in.  The data is passed as two
        !           231:    buffers because that is convenient for packet based protocols, but
        !           232:    normally csecond will be 0.  The ilocal argument is the local
        !           233:    channel number, and the iremote argument is the remote channel
        !           234:    number.  Either may be -1, if the protocol does not have channels.
        !           235:    The ipos argument is the position in the file, if the protocol
        !           236:    knows it; for most protocols, this will be -1.  The fallacked
        !           237:    argument should be set to TRUE if the remote has acknowledged all
        !           238:    outstanding data; see uwindow_acked, below, for details. This will
        !           239:    set *pfexit to TRUE if there is something for the main loop to do.
        !           240:    A file is complete is when a zero length buffer is passed (cfirst
        !           241:    == 0).  A command is complete when data containing a null byte is
        !           242:    passed.  This will return FALSE on error.  If the protocol pfwait
        !           243:    entry point should exit and let the top level loop continue,
        !           244:    *pfexit will be set to TRUE (if pfexit is not NULL).  This will not
        !           245:    set *pfexit to FALSE, so the caller must do that.  */
        !           246: extern boolean fgot_data P((struct sdaemon *qdaemon,
        !           247:                            const char *zfirst, size_t cfirst,
        !           248:                            const char *zsecond, size_t csecond,
        !           249:                            int ilocal, int iremote,
        !           250:                            long ipos, boolean fallacked,
        !           251:                            boolean *pfexit));
        !           252: 
        !           253: /* This routine is called when an ack is sent for a file receive.  */
        !           254: extern void usent_receive_ack P((struct sdaemon *qdaemon,
        !           255:                                 struct stransfer *qtrans));
        !           256: 
        !           257: /* A protocol may call this routine to indicate the packets have been
        !           258:    acknowledged by the remote system.  If the fallacked argument is
        !           259:    TRUE, then all outstanding packets have been acknowledged; for
        !           260:    convenience, this may also be indicated by passing fallacked as
        !           261:    TRUE to fgot_data, above.  Otherwise this routine should be called
        !           262:    each time a complete window is acked by the remote system.  The
        !           263:    transfer code uses this information to keep track of when an
        !           264:    acknowledgement of a file receive has been seen by the other side,
        !           265:    so that file receives may be handled cleanly if the connection is
        !           266:    lost.  */
        !           267: extern void uwindow_acked P((struct sdaemon *qdaemon,
        !           268:                             boolean fallacked));

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.