; 0001 MODULE KERMSG (IDENT = '1.0.001' ; 0002 ) = ; 0003 BEGIN ; 0004 ; 0005 SWITCHES LANGUAGE (COMMON); ; 0006 ; 0007 !++ ; 0008 ! FACILITY: ; 0009 ! KERMIT-32/36 ; 0010 ! ; 0011 ! ABSTRACT: ; 0012 ! KERMSG is the message processing routines for KERMIT-32/36. ; 0013 ! This module is written in common BLISS, so that it can be ; 0014 ! transported for the DECsystem-10 and VAX/VMS systems. ; 0015 ! ; 0016 ! ENVIRONMENT: ; 0017 ! User mode ; 0018 ! ; 0019 ! AUTHOR: Robert C. McQueen, CREATION DATE: 24-January-1983 ; 0020 ! ; 0021 ! MODIFIED BY: ; 0022 ! ; 0023 !-- ; 0024 ; 0025 %SBTTL 'Table of Contents' ; 0026 %SBTTL 'Revision History' ; 0027 ; 0028 !++ ; 0029 ! Start of version 1. ; 0030 ! ; 0031 ! 1.0.000 Create this program. ; 0032 !-- ; 0033 ; 0034 %SBTTL 'Interface requirements' ; 0035 ; 0036 !++ ; 0037 ! Interface requirements ; 0038 ! ; 0039 ! The following routines and data locations are rquired for a correct ; 0040 ! implementation of KERMIT. ; 0041 ! ; 0042 ! File routines: ; 0043 ! ; 0044 ! FILE_OPEN (Function) ; 0045 ! This routine will open a file for reading or writting. It ; 0046 ! will assume that FILE_SIZE contains the number of bytes ; 0047 ! and FILE_NAME contains the file name of length FILE_SIZE. ; 0048 ! The function that is passed is either FNC_READ or FNC_WRITE. ; 0049 ! ; 0050 ! FILE_CLOSE () ; 0051 ! This routine will close the currently open file. This ; 0052 ! routine will return the status of the operation. ; 0053 ! ; 0054 ! FILE_DUMP () ; 0055 ! This routine will cause the current record to be written to ; 0056 ! the file, this routine will only handle binary files if the ; 0057 ! low level I/O routines are record oriented. Otherwise it is ; 0058 ! not needed. ; 0059 ! ; 0060 ! GET_FILE (Character) ; 0061 ! This routine will get a character from the currently open file ; 0062 ! and store it in the location specified by "Character". There ; 0063 ! will be a true/false value returned by the routine to determine ; 0064 ! if there was an error. ; 0065 ! ; 0066 ! PUT_FILE (Character) ; 0067 ! This routine will output a character to the currently open ; 0068 ! file. It will return a true/false value to determine if the ; 0069 ! routine was successful. ; 0070 ! ; 0071 ! NEXT_FILE () ; 0072 ! This routine will advance to the next file. This routine ; 0073 ! will return false if there are no more files to process. ; 0074 ! ; 0075 ! Communications line routines: ; 0076 ! ; 0077 ! RECEIVE ; 0078 ! This routine will receive a message from the remote Kermit. ; 0079 ! ; 0080 ! SEND ; 0081 ! This routine will send a message to the remote Kermit. ; 0082 ! ; 0083 ! Operating system routines: ; 0084 ! ; 0085 ! DISMISS (Seconds) ; 0086 ! This routine will cause Kermit to sleep for the specified ; 0087 ! number of seconds. It is used to handle the DELAY parameter. ; 0088 ! ; 0089 ! SYS_LOGOUT () ; 0090 ! Log the job off of the system. (Kill the process). ; 0091 ! ; 0092 ! Error processing: ; 0093 ! ; 0094 ! KRM_ERROR (Error parameter) ; 0095 ! This routine will cause an error message to be issued. ; 0096 ! The error parameter is defined by KERERR. This may cause ; 0097 ! SND_ERROR to be called to send an "E" message to the remote. ; 0098 ! ; 0099 ! Terminal I/O routines: ; 0100 ! ; 0101 ! TT_CHAR (Character) ; 0102 ! This routine will cause a character to be output to ; 0103 ! the terminal. This routine is called only if the terminal ; 0104 ! and communications line are different. ; 0105 ! ; 0106 ! TT_CRLF () ; 0107 ! This routine will cause a carriage-return line-feed to be ; 0108 ! output to the terminal. This routine is called only if the ; 0109 ! terminal and communications line are different. ; 0110 ! ; 0111 ! TT_NUMBER (Value) ; 0112 ! This routine will output a three digit number to the terminal. ; 0113 ! This routine is called only if the terminal and communications ; 0114 ! line are different. ; 0115 ! ; 0116 ! TT_QCHAR (Character) ; 0117 ! This routine will output a quoted character. This routine is ; 0118 ! similar to TT_CHAR. ; 0119 ! ; 0120 ! TT_TEXT (ASCIZ string) ; 0121 ! This routine will output an ASCIZ string to the terminal. ; 0122 ! This routine is called only if the terminal and communications ; 0123 ! line are different. ; 0124 ! ; 0125 ! ; 0126 ! ENTRY POINTS ; 0127 ! ; 0128 ! KERMSG contains the following entry points for the KERMIT. ; 0129 ! ; 0130 ! SERVER () ; 0131 ! This routine will cause KERMIT go enter server mode. ; 0132 ! ; 0133 ! SEND_SWITCH () ; 0134 ! This routine will send a file. It expects that the user ; 0135 ! has stored the text of the file name into FILE_NAME and ; 0136 ! the length of the text into FILE_SIZE. ; 0137 ! ; 0138 ! REC_SWITCH () ; 0139 ! This routine will receive a file. It expects that the default ; 0140 ! file name is set up in FILE_NAME and the length is in ; 0141 ! FILE_SIZE. ; 0142 ! ; 0143 ! ; 0144 ! GLOBAL Storage ; 0145 ! ; 0146 ! The following are the global storage locations that are used to interface ; 0147 ! to KERMSG. These locations contains the various send and receive parameters. ; 0148 ! ; 0149 ! Receive parameters: ; 0150 ! ; 0151 ! RCV_PKT_SIZE ; 0152 ! Receive packet size. ; 0153 ! RCV_NPAD ; 0154 ! Padding length ; 0155 ! RCV_PADCHAR ; 0156 ! Padding character ; 0157 ! RCV_TIMEOUT ; 0158 ! Time out ; 0159 ! RCV_EOL ; 0160 ! End of line character ; 0161 ! RCV_QUOTE_CHR ; 0162 ! Quote character ; 0163 ! RCV_8QUOTE_CHR ; 0164 ! 8-bit quoting character ; 0165 ! ; 0166 ! Send parameters: ; 0167 ! ; 0168 ! SND_PKT_SIZE ; 0169 ! Send packet size ; 0170 ! SND_NPAD ; 0171 ! Padding length ; 0172 ! SND_PADCHAR ; 0173 ! Padding character ; 0174 ! SND_TIMEOUT ; 0175 ! Time out ; 0176 ! SND_EOL ; 0177 ! End of line character ; 0178 ! SND_QUOTE_CHR ; 0179 ! Quote character ; 0180 ! SND_8QUOTE_CHR ; 0181 ! 8-bit quoting character ; 0182 ! ; 0183 ! Statistics: ; 0184 ! ; 0185 ! SND_TOTAL_CHARS ; 0186 ! Total characters sent ; 0187 ! RCV_TOTAL_CHARS ; 0188 ! Total characters received ; 0189 ! SND_DATA_CHARS ; 0190 ! Total number of data characters sent ; 0191 ! RCV_DATA_CHARS ; 0192 ! Total number of data characters received ; 0193 ! ; 0194 ! Misc constants: ; 0195 ! ; 0196 ! FILE_NAME ; 0197 ! Vector containing the ASCII characters of the file name. ; 0198 ! FILE_SIZE ; 0199 ! Number of characters in the FILE_NAME vector. ; 0200 ! DELAY ; 0201 ! Amount of time to delay ; 0202 ! DEBUG_FLAG ; 0203 ! Debugging mode on/off ; 0204 ! WARN_FLAG ; 0205 ! File warning flag ; 0206 ! ECHO_FLAG ; 0207 ! Local echo flag ; 0208 ! CONNECT_FLAG ; 0209 ! Connected flag; True if terminal and SET LINE are the same ; 0210 ! PARITY_TYPE ; 0211 ! Type of parity to use if 8-bit mode. ; 0212 ! ; 0213 !-- ; 0214 ; 0215 %SBTTL 'Declarations -- Forward definitions' ; 0216 ! ; 0217 ! ; 0218 ! Forward definitions ; 0219 ! ; 0220 ; 0221 FORWARD ROUTINE ; 0222 ; 0223 ! Send processing routines ; 0224 ; 0225 SEND_SWITCH, ! Major send routine ; 0226 SEND_DATA, ! Send data to the micro ; 0227 SEND_FILE, ! Send file name ; 0228 SEND_EOF, ! Send EOF ; 0229 SEND_INIT, ! Send initialization msg ; 0230 SEND_BREAK, ! Send break end of transmission ; 0231 SND_ERROR : NOVALUE, ! Send an error to the remote ; 0232 ; 0233 ! Receive processing routines ; 0234 ; 0235 REC_SWITCH, ! Receive main loop ; 0236 REC_SWITCH_WORKER, ! Worker routine for REC_SWITCH and SERVER ; 0237 REC_INIT, ! Receive initialization ; 0238 REC_FILE, ! Receive file information ; 0239 REC_DATA, ! Receive data ; 0240 ; 0241 ! Server processing routines ; 0242 ; 0243 SERVER_GENERIC, ! Process generic KERMIT commands ; 0244 ! ; 0245 ! Statistic gathering routines ; 0246 ; 0247 INIT_STATS : NOVALUE, ! Initialize the stats area ; 0248 ; 0249 ! Low level send/receive routines ; 0250 ; 0251 SET_SEND_INIT : NOVALUE, ! Set up the MSG_SND_INIT parameters. ; 0252 PRS_SEND_INIT : NOVALUE, ! Parse MSG_SND_INIT parameters. ; 0253 SEND_PACKET, ! Send a packet to the remote ; 0254 REC_MESSAGE, ! Receive a message with retry processing ; 0255 REC_PACKET, ! Receive a packet from the remote ; 0256 ; 0257 ! Utility routines ; 0258 ; 0259 BFR_EMPTY, ! Empty the data buffer ; 0260 BFR_FILL, ! Fill the data buffer from a file ; 0261 CLEAR : NOVALUE, ! Clear the message buffer. ; 0262 ! ; 0263 ! Debugging routines ; 0264 ! ; 0265 DBG_MESSAGE : NOVALUE, ! Type out a formatted message ; 0266 DBG_SEND : NOVALUE, ! Send message debugging routine ; 0267 DBG_RECEIVE : NOVALUE; ! Receive message debugging routine ; 0268 %SBTTL 'Require files' ; 0269 ; 0270 ! ; 0271 ! ; 0272 ! ; 0273 ! REQUIRE FILES: ; 0274 ! ; 0275 ; L 0276 %IF %BLISS (BLISS32) ; 0277 %THEN ; 0278 ; 0279 LIBRARY 'SYS$LIBRARY:STARLET'; ; 0280 ; 0281 %FI ! End of %IF %BLISS(BLISS32) ; 0282 ; 0283 REQUIRE 'KERCOM'; ; 0440 ; 0441 REQUIRE 'KERERR'; ; 0490 ; 0491 %SBTTL 'Macro definitions' ; 0492 ! ; 0493 ! MACROS: ; 0494 ! ; 0495 ; 0496 MACRO ; M 0497 CTL (C) = ; 0498 C XOR %O'100'%, ; M 0499 CHAR (C) = ; 0500 C + %O'40'%, ; M 0501 UNCHAR (C) = ; 0502 C - %O'40'%; ; 0503 ; 0504 %SBTTL 'KERMIT Protocol Definitions' ; 0505 ; 0506 !++ ; 0507 ! The following describes the various items that are found in the ; 0508 ! KERMIT messages. A complete and through desription of the protocol can be ; 0509 ! found in the KERMIT PROTOCOL MANUAL. ; 0510 ! ; 0511 ! ; 0512 ! All KERMIT messages have the following format: ; 0513 ! ; 0514 ! ; 0515 ! ; 0516 ! ; 0517 ! Predefined as SOH (Control-A, octal 001). ; 0518 ! ; 0519 ! ; 0520 ! Count of the number of characters following this position. ; 0521 ! Character counts of ONLY 0 to 94 are valid. ; 0522 ! ; 0523 ! ; 0524 ! Packet sequence number, modulo 100 (octal). ; 0525 ! ; 0526 ! ; 0527 ! This field contains the message dependent information. There can ; 0528 ! be multiple fields in this section. See the KERMIT Protocol document ; 0529 ! for a complete description of this. ; 0530 ! ; 0531 ! ; 0532 ! Checksum of the packet. ; 0533 ! ; 0534 ! ; 0535 ! End of line. Any line terminator that may be required by the host. ; 0536 !-- ; 0537 ; 0538 %SBTTL 'KERMIT Protocol Definitions -- Packet offsets' ; 0539 ; 0540 !++ ; 0541 ! The following define the various offsets of the standard KERMIT ; 0542 ! packets. ; 0543 !-- ; 0544 ; 0545 LITERAL ; 0546 PKT_MARK = 0, ! ; 0547 PKT_COUNT = 1, ! ; 0548 PKT_SEQ = 2, ! ; 0549 PKT_TYPE = 3, ! ; 0550 PKT_MSG = 4, ! ; 0551 PKT_MAX_MSG = 94 - 5, ! Maximum size of the message dependent ; 0552 ! information ; 0553 PKT_CHKSUM = 0, ! offset from end of ; 0554 ! Message dependent information ; 0555 PKT_EOL = 1, ! offset from end of data ; 0556 PKT_OVR_HEAD_B = 2, ! Header overhead ; 0557 PKT_OVR_HEAD_E = 1, ! Overhead at the end ; 0558 PKT_OVR_HEAD = 3, ! Overhead added to data length ; 0559 PKT_TOT_OVR_HEAD = 6; ! Total overhead of the message ; 0560 ; 0561 %SBTTL 'KERMIT Protocol Definitions -- Message dependent field' ; 0562 ; 0563 !++ ; 0564 ! The MESSAGE-DEPENDENT information field of the message contains at ; 0565 ! least one part. That is the type of message. The remainder of the message ; 0566 ! MESSAGE-DEPENDENT field is different depending on the message. ; 0567 ! ; 0568 ! ; 0569 ! ; 0570 ! ; 0571 ! The type defines the type of message that is being processed. ; 0572 ! ; 0573 !-- ; 0574 ; 0575 ! Protocol version 1.0 message types ; 0576 ; 0577 LITERAL ; 0578 MSG_DATA = %C'D', ! Data packet ; 0579 MSG_ACK = %C'Y', ! Acknowledgement ; 0580 MSG_NAK = %C'N', ! Negative acknowledgement ; 0581 MSG_SND_INIT = %C'S', ! Send initiate ; 0582 MSG_BREAK = %C'B', ! Break transmission ; 0583 MSG_FILE = %C'F', ! File header ; 0584 MSG_EOF = %C'Z', ! End of file (EOF) ; 0585 MSG_ERROR = %C'E'; ! Error ; 0586 ; 0587 ! Protocol version 2.0 message types ; 0588 ; 0589 LITERAL ; 0590 MSG_RCV_INIT = %C'R', ! Receive initiate ; 0591 MSG_COMMAND = %C'C', ! Host command ; 0592 MSG_KERMIT = %C'G'; ! Generic KERMIT command. ; 0593 ; 0594 !++ ; 0595 ! Generic KERMIT commands ; 0596 !-- ; 0597 ; 0598 LITERAL ; 0599 MSG_GEN_LOGIN = %C'I', ! Login ; 0600 MSG_GEN_EXIT = %C'F', ! Finish (exit to OS) ; 0601 MSG_GEN_CONNECT = %C'C', ! Connect to a directory ; 0602 MSG_GEN_LOGOUT = %C'L', ! Logout ; 0603 MSG_GEN_DIRECTORY = %C'D', ! Directory ; 0604 MSG_GEN_DISK_USAGE = %C'U', ! Disk usage ; 0605 MSG_GEN_DELETE = %C'E', ! Delete a file ; 0606 MSG_GEN_TYPE = %C'T', ! Type a file specification ; 0607 MSG_GEN_SUBMIT = %C'S', ! Submit ; 0608 MSG_GEN_PRINT = %C'P', ! Print ; 0609 MSG_GEN_WHO = %C'W', ! Who's logged in ; 0610 MSG_GEN_SEND = %C'M', ! Send a message to a user ; 0611 MSG_GEN_HELP = %C'H', ! Help ; 0612 MSG_GEN_QUERY = %C'Q'; ! Query status ; 0613 ; 0614 %SBTTL 'KERMIT Protocol Definitions -- SEND initiate packet' ; 0615 ; 0616 !++ ; 0617 ! ; 0618 ! The following describes the send initiate packet. All fields in the message ; 0619 ! data area are optional. ; 0620 ! ; 0621 ! <"S"> ; 0622 ! <8-bit-quote> ; 0623 ! ; 0624 ! BUFSIZ ; 0625 ! Sending Kermit's maximum buffer size. ; 0626 ! ; 0627 ! Timeout ; 0628 ! Number of seconds after which the sending Kermit wishes to be timed out ; 0629 ! ; 0630 ! Npad ; 0631 ! Number of padding caracters the sending Kermit needs preceding each ; 0632 ! packet. ; 0633 ! ; 0634 ! PAD ; 0635 ! Padding character. ; 0636 ! ; 0637 ! EOL ; 0638 ! A line terminator required on all packets set by the receiving ; 0639 ! Kermit. ; 0640 ! ; 0641 ! Quote ; 0642 ! The printable ASCII characer the sending Kermit will use when quoting ; 0643 ! the control cahracters. Default is "#". ; 0644 ! ; 0645 ! 8-bit-quote ; 0646 ! Specify quoting mecanism for 8-bit quantities. A quoting mecanism is ; 0647 ! mecessary when sending to hosts which prevent the use of the 8th bit ; 0648 ! for data. When elected, the quoting mechanism will be used by both ; 0649 ! hosts, and the quote character must be in the range of 41-76 or 140-176 ; 0650 ! octal, but different from the control-quoting character. This field is ; 0651 ! interpreted as follows: ; 0652 ! ; 0653 ! "Y" - I agree to 8-bit quoting if you request it. ; 0654 ! "N" - I will not do 8-bit quoting. ; 0655 ! "&" - (or any other character in the range of 41-76 or 140-176) I want ; 0656 ! to do 8-bit quoting using this character (it will be done if the ; 0657 ! other Kermit puts a "Y" in this field. ; 0658 ! Anything else: Quoting will not be done. ; 0659 ! ; 0660 ! Fields 8 to 11 reserved. ; 0661 !-- ; 0662 ; 0663 LITERAL ; 0664 P_SI_BUFSIZ = 0, ! Buffersize ; 0665 MY_PKT_SIZE = 80, ! My packet size ; 0666 P_SI_TIMOUT = 1, ! Time out ; 0667 MY_TIME_OUT = 15, ! My time out ; 0668 P_SI_NPAD = 2, ! Number of padding characters ; 0669 MY_NPAD = 0, ! Amount of padding I require ; 0670 P_SI_PAD = 3, ! Padding character ; 0671 MY_PAD_CHAR = 0, ! My pad character ; 0672 P_SI_EOL = 4, ! End of line character ; 0673 MY_EOL_CHAR = %O'015', ! My EOL cahracter ; 0674 P_SI_QUOTE = 5, ! Quote character ; 0675 MY_QUOTE_CHAR = %C'#', ! My quoting character ; 0676 P_SI_8QUOTE = 6, ! 8-bit quote ; 0677 MY_8BIT_QUOTE = %C'N', ! Don't do it ; 0678 P_SI_LENGTH = 7; ! Length of the message ; 0679 ; 0680 %SBTTL 'KERMIT Protocol States' ; 0681 ; 0682 !++ ; 0683 ! The following are the various states that KERMIT can be in. ; 0684 ! The state transitions are defined in the KERMIT Protocol manual. ; 0685 !-- ; 0686 ; 0687 LITERAL ; 0688 STATE_MIN = 0, ! Min state number ; 0689 STATE_START = 0, ! Start state ; 0690 STATE_S = 1, ! Send init state ; 0691 STATE_SF = 2, ! Send file header ; 0692 STATE_SD = 3, ! Send file data packet ; 0693 STATE_SZ = 4, ! Send EOF packet ; 0694 STATE_SB = 5, ! Send break ; 0695 STATE_R = 6, ! Receive state (wait for send-init) ; 0696 STATE_RF = 7, ! Receive file header packet ; 0697 STATE_RD = 8, ! Receive file data packet ; 0698 STATE_C = 9, ! Send complete ; 0699 STATE_A = 10, ! Abort ; 0700 STATE_MAX = 10; ! Max state number ; 0701 ; 0702 %SBTTL 'Storage - Global' ; 0703 ! ; 0704 ! OWN STORAGE: ; 0705 ! ; 0706 ; 0707 GLOBAL ; 0708 ! ; 0709 ! Receive parameters ; 0710 ! ; 0711 RCV_PKT_SIZE, ! Receive packet size ; 0712 RCV_NPAD, ! Padding length ; 0713 RCV_PADCHAR, ! Padding character ; 0714 RCV_TIMEOUT, ! Time out ; 0715 RCV_EOL, ! EOL character ; 0716 RCV_QUOTE_CHR, ! Quote character ; 0717 RCV_8QUOTE_CHR, ! 8-bit quoting character ; 0718 ! ; 0719 ! Send parameters ; 0720 ! ; 0721 SND_PKT_SIZE, ! Send packet size ; 0722 SND_NPAD, ! Padding length ; 0723 SND_PADCHAR, ! Padding character ; 0724 SND_TIMEOUT, ! Time out ; 0725 SND_EOL, ! EOL character ; 0726 SND_QUOTE_CHR, ! Quote character ; 0727 SND_8QUOTE_CHR, ! 8-bit quoting character ; 0728 ! ; 0729 ! Statistics ; 0730 ! ; 0731 SND_TOTAL_CHARS, ! Total characters sent ; 0732 RCV_TOTAL_CHARS, ! Total characters received ; 0733 SND_DATA_CHARS, ! Total number of data characters sent ; 0734 RCV_DATA_CHARS, ! Total number of data characters received ; 0735 ! ; 0736 ! Misc constants. ; 0737 ! ; 0738 FILE_NAME : VECTOR [CH$ALLOCATION (MAX_FILE_NAME, CHR_SIZE)], ; 0739 FILE_SIZE, ; 0740 DELAY, ! Amount of time to delay ; 0741 PARITY_TYPE, ! Type of parity to use ; 0742 DEBUG_FLAG, ! Debugging mode on/off ; 0743 WARN_FLAG, ! File warning flag ; 0744 ECHO_FLAG, ! Local echo flag ; 0745 CONNECT_FLAG; ! Connected flag; True if ; 0746 ; 0747 ! terminal and SET LINE are ; 0748 ! the same ; 0749 %SBTTL 'Storage - Local' ; 0750 ! ; 0751 ! LOCAL OWN STORAGE: ; 0752 ! ; 0753 ; 0754 OWN ; 0755 STATE, ! Current state ; 0756 SIZE, ! Size of the current message ; 0757 OLD_RETRIES, ! Saved number of retries done. ; 0758 NUM_RETRIES, ! Number of retries ; 0759 MSG_NUMBER, ! Current message number ; 0760 REC_SEQ, ! Sequence number of msg in REC_MSG ; 0761 REC_LENGTH, ! Length of the message recv'd ; 0762 REC_TYPE, ! Type of the message received. ; 0763 REC_MSG : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ! Message received ; 0764 SND_MSG : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ! Message sent ; 0765 FILE_OPEN_FLAG; ! File is opened. ; 0766 ; 0767 %SBTTL 'External references' ; 0768 ! ; 0769 ! EXTERNAL REFERENCES: ; 0770 ! ; 0771 ! Packet I/O routines ; 0772 ; 0773 EXTERNAL ROUTINE ; 0774 SEND, ! Send a packet to the remote ; 0775 RECEIVE; ! Receive a packet from the remote ; 0776 ; 0777 ! ; 0778 ! Terminal I/O routines ; 0779 ! ; 0780 ; 0781 EXTERNAL ROUTINE ; 0782 TT_QCHAR : NOVALUE, ! Output a single quoted character ; 0783 TT_CHAR : NOVALUE, ! Output a single character ; 0784 TT_CRLF : NOVALUE, ! Output a CRLF ; 0785 TT_NUMBER : NOVALUE, ! Output a three digit number to the ; 0786 ! terminal ; 0787 TT_TEXT : NOVALUE; ! Output a string to the user's ; 0788 ; 0789 ! Operating system routines ; 0790 ; 0791 EXTERNAL ROUTINE ; 0792 KRM_ERROR : NOVALUE, ! Issue an error message ; 0793 SYS_LOGOUT : NOVALUE, ! Log the job off ; 0794 DISMISS : NOVALUE; ! Routine to dismiss for n seconds. ; 0795 ; 0796 ! ; 0797 ! External file processing routines ; 0798 ! ; 0799 ; 0800 EXTERNAL ROUTINE ; 0801 FILE_OPEN, ! Open a file for reading/writing ; 0802 FILE_CLOSE, ! Close an open file ; 0803 NEXT_FILE, ! Determine if there is a next file ; 0804 ! and open it for reading. ; 0805 GET_FILE, ! Get a byte from the file ; 0806 PUT_FILE, ! Put a byte in the file. ; 0807 FILE_DUMP; ! Dump the contents of the current ; 0808 ; 0809 ! record. Used for binary files ; 0810 ! if needed. ; 0811 %SBTTL 'MSG_INIT' ; 0812 ; 0813 GLOBAL ROUTINE MSG_INIT : NOVALUE = ; 0814 ; 0815 !++ ; 0816 ! FUNCTIONAL DESCRIPTION: ; 0817 ! ; 0818 ! This routine will initialize the message processing for ; 0819 ! KERMIT-32/36. ; 0820 ! ; 0821 ! CALLING SEQUENCE: ; 0822 ! ; 0823 ! MSG_INIT(); ; 0824 ! ; 0825 ! INPUT PARAMETERS: ; 0826 ! ; 0827 ! None. ; 0828 ! ; 0829 ! IMPLICIT INPUTS: ; 0830 ! ; 0831 ! None. ; 0832 ! ; 0833 ! OUTPUT PARAMETERS: ; 0834 ! ; 0835 ! None. ; 0836 ! ; 0837 ! IMPLICIT OUTPUTS: ; 0838 ! ; 0839 ! None. ; 0840 ! ; 0841 ! COMPLETION CODES: ; 0842 ! ; 0843 ! None. ; 0844 ! ; 0845 ! SIDE EFFECTS: ; 0846 ! ; 0847 ! None. ; 0848 ! ; 0849 !-- ; 0850 ; 0851 BEGIN ; 0852 ! ; 0853 ! Initialize some variables ; 0854 ! ; 0855 ! Receive parameters first ; 0856 ! ; 0857 RCV_PKT_SIZE = MY_PKT_SIZE; ; 0858 RCV_NPAD = MY_NPAD; ; 0859 RCV_PADCHAR = MY_PAD_CHAR; ; 0860 RCV_TIMEOUT = MY_TIME_OUT; ; 0861 RCV_EOL = MY_EOL_CHAR; ; 0862 RCV_QUOTE_CHR = MY_QUOTE_CHAR; ; 0863 RCV_8QUOTE_CHR = MY_8BIT_QUOTE; ; 0864 ! ; 0865 ! Send parameters. ; 0866 ! ; 0867 SND_PKT_SIZE = MY_PKT_SIZE; ; 0868 SND_NPAD = MY_NPAD; ; 0869 SND_PADCHAR = MY_PAD_CHAR; ; 0870 SND_TIMEOUT = MY_TIME_OUT; ; 0871 SND_EOL = MY_EOL_CHAR; ; 0872 SND_QUOTE_CHR = MY_QUOTE_CHAR; ; 0873 SND_8QUOTE_CHR = MY_8BIT_QUOTE; ; 0874 ! ; 0875 ! Other random parameters ; 0876 ! ; 0877 DELAY = INIT_DELAY; ; 0878 DEBUG_FLAG = FALSE; ; 0879 WARN_FLAG = FALSE; ; 0880 ECHO_FLAG = FALSE; ; 0881 FILE_OPEN_FLAG = FALSE; ; 0882 END; ! End of MSG_INIT .TITLE KERMSG .IDENT \1.0.001\ .PSECT $OWN$,NOEXE,2 ;STATE U.52: .BLKB 4 ;SIZE U.53: .BLKB 4 ;OLD_RETRIES U.54: .BLKB 4 ;NUM_RETRIES U.55: .BLKB 4 ;MSG_NUMBER U.56: .BLKB 4 ;REC_SEQ U.57: .BLKB 4 ;REC_LENGTH U.58: .BLKB 4 ;REC_TYPE U.59: .BLKB 4 ;REC_MSG U.60: .BLKB 96 ;SND_MSG U.61: .BLKB 96 ;FILE_OPEN_FLAG U.62: .BLKB 4 .PSECT $GLOBAL$,NOEXE,2 RCV_PKT_SIZE:: .BLKB 4 RCV_NPAD:: .BLKB 4 RCV_PADCHAR:: .BLKB 4 RCV_TIMEOUT:: .BLKB 4 RCV_EOL:: .BLKB 4 RCV_QUOTE_CHR:: .BLKB 4 RCV_8QUOTE_CHR:: .BLKB 4 SND_PKT_SIZE:: .BLKB 4 SND_NPAD:: .BLKB 4 SND_PADCHAR:: .BLKB 4 SND_TIMEOUT:: .BLKB 4 SND_EOL:: .BLKB 4 SND_QUOTE_CHR:: .BLKB 4 SND_8QUOTE_CHR:: .BLKB 4 SND_TOTAL_CHARS:: .BLKB 4 RCV_TOTAL_CHARS:: .BLKB 4 SND_DATA_CHARS:: .BLKB 4 RCV_DATA_CHARS:: .BLKB 4 FILE_NAME:: .BLKB 132 FILE_SIZE:: .BLKB 4 DELAY:: .BLKB 4 PARITY_TYPE:: .BLKB 4 DEBUG_FLAG:: .BLKB 4 WARN_FLAG:: .BLKB 4 ECHO_FLAG:: .BLKB 4 CONNECT_FLAG:: .BLKB 4 .EXTRN SEND, RECEIVE, TT_QCHAR, TT_CHAR, TT_CRLF, TT_NUMBER, TT_TEXT, KRM_ERROR, SYS_LOGOUT .EXTRN DISMISS, FILE_OPEN, FILE_CLOSE, NEXT_FILE, GET_FILE, PUT_FILE, FILE_DUMP .PSECT $CODE$,NOWRT,2 .ENTRY MSG_INIT, ^M ;MSG_INIT, Save R2 ; 0813 MOVAB W^RCV_PKT_SIZE, R2 ;RCV_PKT_SIZE, R2 ; MOVZBL #80, (R2) ;#80, RCV_PKT_SIZE ; 0857 CLRQ 4(R2) ;RCV_NPAD ; 0858 MOVL #15, 12(R2) ;#15, RCV_TIMEOUT ; 0860 MOVL #13, 16(R2) ;#13, RCV_EOL ; 0861 MOVL #35, 20(R2) ;#35, RCV_QUOTE_CHR ; 0862 MOVZBL #78, 24(R2) ;#78, RCV_8QUOTE_CHR ; 0863 MOVZBL #80, 28(R2) ;#80, SND_PKT_SIZE ; 0867 CLRQ 32(R2) ;SND_NPAD ; 0868 MOVL #15, 40(R2) ;#15, SND_TIMEOUT ; 0870 MOVL #13, 44(R2) ;#13, SND_EOL ; 0871 MOVL #35, 48(R2) ;#35, SND_QUOTE_CHR ; 0872 MOVZBL #78, 52(R2) ;#78, SND_8QUOTE_CHR ; 0873 MOVL #5, 208(R2) ;#5, DELAY ; 0877 CLRQ 216(R2) ;DEBUG_FLAG ; 0878 CLRL 224(R2) ;ECHO_FLAG ; 0880 CLRL W^U.62 ;U.62 ; 0881 RET ; ; 0813 ; Routine Size: 74 bytes, Routine Base: $CODE$ + 0000 ; 0883 ; 0884 %SBTTL 'SERVER - Server mode' ; 0885 ; 0886 GLOBAL ROUTINE SERVER = ; 0887 ; 0888 !++ ; 0889 ! FUNCTIONAL DESCRIPTION: ; 0890 ! ; 0891 ! This routine will handle the server function in the v2.0 protocol ; 0892 ! for KERMIT. This routine by it's nature will call various operating ; 0893 ! system routines to do things like logging off the system. ; 0894 ! ; 0895 ! CALLING SEQUENCE: ; 0896 ! ; 0897 ! EXIT_FLAG = SERVER(); ; 0898 ! ; 0899 ! INPUT PARAMETERS: ; 0900 ! ; 0901 ! None. ; 0902 ! ; 0903 ! IMPLICIT INPUTS: ; 0904 ! ; 0905 ! None. ; 0906 ! ; 0907 ! OUTPUT PARAMETERS: ; 0908 ! ; 0909 ! None. ; 0910 ! ; 0911 ! IMPLICIT OUTPUTS: ; 0912 ! ; 0913 ! None. ; 0914 ! ; 0915 ! COMPLETION CODES: ; 0916 ! ; 0917 ! None. ; 0918 ! ; 0919 ! SIDE EFFECTS: ; 0920 ! ; 0921 ! None. ; 0922 ! ; 0923 !-- ; 0924 ; 0925 BEGIN ; 0926 ; 0927 LOCAL ; 0928 STATUS; ! Low level status returned ; 0929 ; 0930 !++ ; 0931 ! ; 0932 ! This routine will determine if the type of message receive is valid for ; 0933 ! this routine. This is a co-routine for the REC_MESSAGE routine. This ; 0934 ! is called once we are sure that message parses correctly. ; 0935 ! ; 0936 !-- ; 0937 ; 0938 ROUTINE CHK_SERVER = ; 0939 BEGIN ; 0940 ; 0941 IF .REC_TYPE EQL MSG_SND_INIT OR .REC_TYPE EQL MSG_KERMIT OR .REC_TYPE EQL MSG_RCV_INIT ; 0942 THEN ; 0943 RETURN TRUE ; 0944 ELSE ; 0945 RETURN FALSE; ; 0946 ; 0947 END; ;CHK_SERVER U.65: .WORD ^M<> ;Save nothing ; 0938 MOVL W^U.59, R0 ;U.59, R0 ; 0941 CMPL R0, #83 ;R0, #83 ; BEQL 1$ ;1$ ; CMPL R0, #71 ;R0, #71 ; BEQL 1$ ;1$ ; CMPL R0, #82 ;R0, #82 ; BNEQ 2$ ;2$ ; 1$: MOVL #1, R0 ;#1, R0 ; 0939 RET ; ; 2$: CLRL R0 ;R0 ; RET ; ; 0938 ; Routine Size: 41 bytes, Routine Base: $CODE$ + 004A ; 0948 RETURN ; 0949 ; 0950 WHILE TRUE DO ; 0951 BEGIN ; 0952 STATUS = REC_MESSAGE (CHK_SERVER); ; 0953 ! ; 0954 ! Now determine what to do by the type of message we have receive. ; 0955 ! The type can only be one of the type checked by the CHK_SERVER routine ; 0956 ! ; 0957 ; 0958 SELECTONE .REC_TYPE OF ; 0959 SET ; 0960 ; 0961 [MSG_SND_INIT] : ; 0962 BEGIN ; 0963 MSG_NUMBER = (.REC_SEQ + 1) AND %O'77'; ; 0964 PRS_SEND_INIT(); ; 0965 SET_SEND_INIT(); ; 0966 IF SEND_PACKET (MSG_ACK, P_SI_LENGTH, .REC_SEQ) THEN ; 0967 BEGIN ; 0968 STATE = STATE_RF; ; 0969 REC_SWITCH_WORKER (); ; 0970 END; ; 0971 END; ; 0972 ; 0973 [MSG_RCV_INIT] : ; 0974 BEGIN ; 0975 MSG_NUMBER = .REC_SEQ; ; 0976 IF .REC_LENGTH GTR 0 ; 0977 THEN ; 0978 BEGIN ; 0979 CH$MOVE (.REC_LENGTH, CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE), ; 0980 CH$PTR(FILE_NAME, 0, CHR_SIZE)); ; 0981 FILE_SIZE = .REC_LENGTH; ; 0982 END; ; 0983 ; 0984 DELAY = 0; ; 0985 SEND_SWITCH (); ; 0986 END; ; 0987 ! ; 0988 ! Generic KERMIT commands ; 0989 ! ; 0990 ; 0991 [MSG_KERMIT] : ; 0992 BEGIN ; 0993 STATUS = SERVER_GENERIC (); ; 0994 ; 0995 IF .STATUS EQL KER_EXIT THEN EXITLOOP KER_EXIT; ; 0996 ; 0997 END; ; 0998 ! ; 0999 ! Unimplimented server routines ; 1000 ! ; 1001 ; 1002 [OTHERWISE] : ; 1003 KRM_ERROR (KER_UNISRV); ; 1004 TES; ; 1005 ; 1006 END; ; 1007 ; 1008 END; ! End of GLOBAL ROUTINE SERVER .ENTRY SERVER, ^M ;SERVER, Save R2,R3,R4,R5,R6,R7,R8 ; 0886 MOVAB W^U.57, R8 ;U.57, R8 ; 1$: PUSHAB B^U.65 ;U.65 ; 0952 CALLS #1, W^U.18 ;#1, U.18 ; MOVL R0, R7 ;R0, STATUS ; MOVL 8(R8), R0 ;REC_TYPE, R0 ; 0958 CMPL R0, #83 ;R0, #83 ; BNEQ 3$ ;3$ ; ADDL3 #1, (R8), R0 ;#1, REC_SEQ, R0 ; 0963 EXTZV #0, #6, R0, -4(R8) ;#0, #6, R0, MSG_NUMBER ; CALLS #0, W^U.16 ;#0, U.16 ; 0964 CALLS #0, W^U.15 ;#0, U.15 ; 0965 PUSHL (R8) ;REC_SEQ ; 0966 PUSHL #7 ;#7 ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; BLBC R0, 1$ ;R0, 1$ ; MOVL #7, -20(R8) ;#7, STATE ; 0968 CALLS #0, W^U.9 ;#0, U.9 ; 0969 2$: BRB 1$ ;1$ ; 0958 3$: CMPL R0, #82 ;R0, #82 ; BNEQ 5$ ;5$ ; MOVL (R8), -4(R8) ;REC_SEQ, MSG_NUMBER ; 0975 MOVL 4(R8), R6 ;REC_LENGTH, R6 ; 0976 BLEQ 4$ ;4$ ; MOVC3 R6, 16(R8), W^FILE_NAME ;R6, REC_MSG+4, FILE_NAME ; 0979 MOVL R6, W^FILE_SIZE ;R6, FILE_SIZE ; 0981 4$: CLRL W^DELAY ;DELAY ; 0984 CALLS #0, W^U.1 ;#0, U.1 ; 0985 BRB 1$ ;1$ ; 0958 5$: CMPL R0, #71 ;R0, #71 ; BNEQ 6$ ;6$ ; CALLS #0, W^U.13 ;#0, U.13 ; 0993 MOVL R0, R7 ;R0, STATUS ; CMPL R7, #134316179 ;STATUS, #134316179 ; 0995 BNEQ 2$ ;2$ ; MOVL #134316179, R0 ;#134316179, R0 ; RET ; ; 6$: PUSHL #134316194 ;#134316194 ; 1003 CALLS #1, W^KRM_ERROR ;#1, KRM_ERROR ; BRB 2$ ;2$ ; 0950 ; Routine Size: 167 bytes, Routine Base: $CODE$ + 0073 ; 1009 ; 1010 %SBTTL 'SERVER - Generic commands' ; 1011 ROUTINE SERVER_GENERIC = ; 1012 ; 1013 !++ ; 1014 ! FUNCTIONAL DESCRIPTION: ; 1015 ! ; 1016 ! This routine will handle the generic server messages. ; 1017 ! The generic server messages include FINISH, LOGOUT. ; 1018 ! ; 1019 ! CALLING SEQUENCE: ; 1020 ! ; 1021 ! SERVER_GENERIC(); ; 1022 ! ; 1023 ! INPUT PARAMETERS: ; 1024 ! ; 1025 ! None. ; 1026 ! ; 1027 ! IMPLICIT INPUTS: ; 1028 ! ; 1029 ! Generic message receive in REC_MSG. ; 1030 ! ; 1031 ! OUTPUT PARAMETERS: ; 1032 ! ; 1033 ! None. ; 1034 ! ; 1035 ! IMPLICIT OUTPUTS: ; 1036 ! ; 1037 ! None. ; 1038 ! ; 1039 ! COMPLETION CODES: ; 1040 ! ; 1041 ! None. ; 1042 ! ; 1043 ! SIDE EFFECTS: ; 1044 ! ; 1045 ! None. ; 1046 ! ; 1047 !-- ; 1048 ; 1049 BEGIN ; 1050 ; 1051 SELECTONE CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE)) OF ; 1052 SET ; 1053 ; 1054 [MSG_GEN_EXIT] : ; 1055 BEGIN ; 1056 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 1057 RETURN KER_EXIT; ; 1058 END; ; 1059 [MSG_GEN_LOGOUT] : ; 1060 BEGIN ; 1061 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 1062 SYS_LOGOUT (); ; 1063 RETURN KER_NORMAL; ; 1064 END; ; 1065 ! ; 1066 ! [MSG_GEN_DELETE] : ; 1067 ! BEGIN ; 1068 ! END; ; 1069 ! ; 1070 ! [MSG_GEN_PRINT] : ; 1071 ! BEGIN ; 1072 ! END; ; 1073 ; 1074 [OTHERWISE] : ; 1075 BEGIN ; 1076 KRM_ERROR (KER_UNIMPLGEN); ; 1077 RETURN KER_UNIMPLGEN; ; 1078 END; ; 1079 TES; ; 1080 ; 1081 END; ! End of SERVER_GENERIC ;SERVER_GENERIC U.13: .WORD ^M<> ;Save nothing ; 1011 MOVZBL W^U.60+4, R0 ;U.60+4, R0 ; 1051 CMPB R0, #70 ;R0, #70 ; BNEQ 1$ ;1$ ; PUSHL W^U.57 ;U.57 ; 1056 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; MOVL #134316179, R0 ;#134316179, R0 ; 1051 RET ; ; 1$: CMPB R0, #76 ;R0, #76 ; BNEQ 2$ ;2$ ; PUSHL W^U.57 ;U.57 ; 1061 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; CALLS #0, W^SYS_LOGOUT ;#0, SYS_LOGOUT ; 1062 MOVL #134316043, R0 ;#134316043, R0 ; 1051 RET ; ; 2$: PUSHL #134316186 ;#134316186 ; 1076 CALLS #1, W^KRM_ERROR ;#1, KRM_ERROR ; MOVL #134316186, R0 ;#134316186, R0 ; 1051 RET ; ; 1011 ; Routine Size: 89 bytes, Routine Base: $CODE$ + 011A ; 1082 %SBTTL 'SEND_SWITCH' ; 1083 ; 1084 GLOBAL ROUTINE SEND_SWITCH = ; 1085 ; 1086 !++ ; 1087 ! FUNCTIONAL DESCRIPTION: ; 1088 ! ; 1089 ! This routine is the state table switcher for sending files. It ; 1090 ! loops until either it is finished or an error is encountered. The ; 1091 ! routines called by SEND_SWITCH are responsible for changing the state. ; 1092 ! ; 1093 ! CALLING SEQUENCE: ; 1094 ! ; 1095 ! SEND_SWITCH(); ; 1096 ! ; 1097 ! INPUT PARAMETERS: ; 1098 ! ; 1099 ! None. ; 1100 ! ; 1101 ! IMPLICIT INPUTS: ; 1102 ! ; 1103 ! None. ; 1104 ! ; 1105 ! OUTPUT PARAMETERS: ; 1106 ! ; 1107 ! Returns: ; 1108 ! TRUE - File sent correctly. ; 1109 ! FALSE - Aborted sending the file. ; 1110 ! ; 1111 ! IMPLICIT OUTPUTS: ; 1112 ! ; 1113 ! None. ; 1114 ! ; 1115 ! COMPLETION CODES: ; 1116 ! ; 1117 ! None. ; 1118 ! ; 1119 ! SIDE EFFECTS: ; 1120 ! ; 1121 ! None. ; 1122 ! ; 1123 !-- ; 1124 ; 1125 BEGIN ; 1126 ; 1127 LOCAL ; 1128 VAL_RETURN, ; 1129 FINISHED; ; 1130 ; 1131 INIT_STATS (); ! Initialize stats ; 1132 STATE = STATE_S; ! Initial state is send ; 1133 NUM_RETRIES = 0; ! Initialize number of retries ; 1134 MSG_NUMBER = 0; ! Initial message number ; 1135 CLEAR (); ! Clear the message buffers ; 1136 DISMISS (.DELAY); ! Sleep if the user wanted us to ; 1137 FINISHED = FALSE; ; 1138 ; 1139 DO ; 1140 BEGIN ; 1141 ; 1142 CASE .STATE FROM STATE_MIN TO STATE_MAX OF ; 1143 SET ; 1144 ; 1145 [STATE_SD] : ; 1146 STATE = SEND_DATA (); ; 1147 ; 1148 [STATE_SF] : ; 1149 STATE = SEND_FILE (); ; 1150 ; 1151 [STATE_SZ] : ; 1152 STATE = SEND_EOF (); ; 1153 ; 1154 [STATE_S] : ; 1155 STATE = SEND_INIT (); ; 1156 ; 1157 [STATE_SB] : ; 1158 STATE = SEND_BREAK (); ; 1159 ; 1160 [STATE_C] : ; 1161 BEGIN ; 1162 FINISHED = TRUE; ; 1163 VAL_RETURN = TRUE; ; 1164 END; ; 1165 ; 1166 [STATE_A] : ; 1167 BEGIN ; 1168 ; 1169 IF .FILE_OPEN_FLAG ; 1170 THEN ; 1171 BEGIN ; 1172 FILE_CLOSE (); ; 1173 FILE_OPEN_FLAG = FALSE; ; 1174 END; ; 1175 ; 1176 FINISHED = TRUE; ; 1177 VAL_RETURN = FALSE; ; 1178 END; ; 1179 ; 1180 [INRANGE, OUTRANGE] : ; 1181 BEGIN ; 1182 FINISHED = TRUE; ; 1183 VAL_RETURN = FALSE; ; 1184 END; ; 1185 TES ; 1186 ; 1187 END ; 1188 UNTIL (.FINISHED EQL TRUE); ; 1189 ; 1190 RETURN .VAL_RETURN; ; 1191 END; U.1: .ENTRY SEND_SWITCH, ^M ;SEND_SWITCH, Save R2,R3,R4 ; 1084 MOVAB W^U.52, R4 ;U.52, R4 ; CALLS #0, W^U.14 ;#0, U.14 ; 1131 MOVL #1, (R4) ;#1, STATE ; 1132 CLRQ 12(R4) ;NUM_RETRIES ; 1133 CALLS #0, W^U.22 ;#0, U.22 ; 1135 PUSHL W^DELAY ;DELAY ; 1136 CALLS #1, W^DISMISS ;#1, DISMISS ; CLRL R2 ;FINISHED ; 1137 1$: CASEL (R4), #0, #10 ;STATE, #0, #10 ; 1140 2$: .WORD 11$-2$,- ;11$-2$,- ; 6$-2$,- ;6$-2$,- ; 4$-2$,- ;4$-2$,- ; 3$-2$,- ;3$-2$,- ; 5$-2$,- ;5$-2$,- ; 7$-2$,- ;7$-2$,- ; 11$-2$,- ;11$-2$,- ; 11$-2$,- ;11$-2$,- ; 11$-2$,- ;11$-2$,- ; 9$-2$,- ;9$-2$,- ; 10$-2$ ;10$-2$ ; BRB 11$ ;11$ ; 1182 3$: CALLS #0, W^U.2 ;#0, U.2 ; 1146 BRB 8$ ;8$ ; 4$: CALLS #0, W^U.3 ;#0, U.3 ; 1149 BRB 8$ ;8$ ; 5$: CALLS #0, W^U.4 ;#0, U.4 ; 1152 BRB 8$ ;8$ ; 6$: CALLS #0, W^U.5 ;#0, U.5 ; 1155 BRB 8$ ;8$ ; 7$: CALLS #0, W^U.6 ;#0, U.6 ; 1158 8$: MOVL R0, (R4) ;R0, STATE ; BRB 12$ ;12$ ; 1140 9$: MOVL #1, R2 ;#1, FINISHED ; 1162 MOVL #1, R3 ;#1, VAL_RETURN ; 1163 BRB 12$ ;12$ ; 1140 10$: BLBC 224(R4), 11$ ;FILE_OPEN_FLAG, 11$ ; 1169 CALLS #0, W^FILE_CLOSE ;#0, FILE_CLOSE ; 1172 CLRL 224(R4) ;FILE_OPEN_FLAG ; 1173 11$: MOVQ #1, R2 ;#1, FINISHED ; 1176 12$: CMPL R2, #1 ;FINISHED, #1 ; 1188 BNEQ 1$ ;1$ ; MOVL R3, R0 ;VAL_RETURN, R0 ; 1125 RET ; ; 1084 ; Routine Size: 134 bytes, Routine Base: $CODE$ + 0173 ; 1192 ; 1193 %SBTTL 'SEND_DATA' ; 1194 ROUTINE SEND_DATA = ; 1195 ; 1196 !++ ; 1197 ! FUNCTIONAL DESCRIPTION: ; 1198 ! ; 1199 ! This routine will send a data message to the remote KERMIT. ; 1200 ! ; 1201 ! CALLING SEQUENCE: ; 1202 ! ; 1203 ! STATE = SEND_DATA(); ; 1204 ! ; 1205 ! INPUT PARAMETERS: ; 1206 ! ; 1207 ! None. ; 1208 ! ; 1209 ! IMPLICIT INPUTS: ; 1210 ! ; 1211 ! None. ; 1212 ! ; 1213 ! OUTPUT PARAMETERS: ; 1214 ! ; 1215 ! New state to change the finite state machine to. ; 1216 ! ; 1217 ! IMPLICIT OUTPUTS: ; 1218 ! ; 1219 ! None. ; 1220 ! ; 1221 ! COMPLETION CODES: ; 1222 ! ; 1223 ! None. ; 1224 ! ; 1225 ! SIDE EFFECTS: ; 1226 ! ; 1227 ! None. ; 1228 ! ; 1229 !-- ; 1230 ; 1231 BEGIN ; 1232 ! ; 1233 ! Check to see if the number of retries have been exceeded. ; 1234 ! ; 1235 ; 1236 IF .NUM_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 1237 ; 1238 ! ; 1239 ! Not exceeded yet. Increment the number of retries we have attempted ; 1240 ! on this message. ; 1241 ! ; 1242 NUM_RETRIES = .NUM_RETRIES + 1; ; 1243 ! ; 1244 ! Attempt to send the packet and abort if the send fails. ; 1245 ! ; 1246 ; 1247 IF NOT SEND_PACKET (MSG_DATA, .SIZE, .MSG_NUMBER) THEN RETURN STATE_A; ; 1248 ; 1249 ! ; 1250 ! Attempt to receive a message from the remote KERMIT. ; 1251 ! ; 1252 ; 1253 IF NOT REC_PACKET () THEN RETURN STATE_A; ; 1254 ; 1255 ! ; 1256 ! Determine if the message is a NAK and the NAK is for the message number ; 1257 ! that we are current working on. If the NAK is for the next packet then ; 1258 ! ignore the NAK ; 1259 ! ; 1260 ; 1261 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1262 ; 1263 ! ; 1264 ! Make sure we have a NAK or ACK ; 1265 ! ; 1266 ; 1267 IF .REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK ; 1268 THEN ; 1269 BEGIN ; 1270 ! ; 1271 ! Is this for this message? ; 1272 ! ; 1273 ; 1274 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 1275 ; 1276 ! ; 1277 ! It was. Set up for sending the next data message to the remote KERMIT ; 1278 ! and return. ; 1279 ! ; 1280 NUM_RETRIES = 0; ; 1281 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1282 ; 1283 IF (BFR_FILL () EQL KER_NORMAL) ; 1284 THEN ; 1285 RETURN STATE_SD ; 1286 ELSE ; 1287 BEGIN ; 1288 FILE_CLOSE (); ; 1289 FILE_OPEN_FLAG = FALSE; ; 1290 RETURN STATE_SZ; ; 1291 END; ; 1292 ; 1293 END ; 1294 ELSE ; 1295 ! ; 1296 ! Not an ACK or NAK, abort. ; 1297 ! ; 1298 RETURN STATE_A; ; 1299 ; 1300 END; ;SEND_DATA U.2: .WORD ^M ;Save R2 ; 1194 MOVAB W^U.56, R2 ;U.56, R2 ; CMPL -4(R2), #30 ;NUM_RETRIES, #30 ; 1236 BGTR 6$ ;6$ ; INCL -4(R2) ;NUM_RETRIES ; 1242 PUSHL (R2) ;MSG_NUMBER ; 1247 PUSHL -12(R2) ;SIZE ; MOVZBL #68, -(SP) ;#68, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; BLBC R0, 6$ ;R0, 6$ ; CALLS #0, W^U.19 ;#0, U.19 ; 1253 BLBC R0, 6$ ;R0, 6$ ; CLRL R1 ;R1 ; 1261 CMPL 12(R2), #78 ;REC_TYPE, #78 ; BNEQ 1$ ;1$ ; INCL R1 ;R1 ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R2) ;#0, #6, R0, REC_SEQ ; BNEQ 3$ ;3$ ; 1$: CMPL 12(R2), #89 ;REC_TYPE, #89 ; 1267 BEQL 2$ ;2$ ; BLBC R1, 6$ ;R1, 6$ ; 2$: CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 1274 BEQL 4$ ;4$ ; 3$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 4$: CLRL -4(R2) ;NUM_RETRIES ; 1280 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 1281 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; CALLS #0, W^U.21 ;#0, U.21 ; 1283 CMPL R0, #134316043 ;R0, #134316043 ; BNEQ 5$ ;5$ ; MOVL #3, R0 ;#3, R0 ; 1269 RET ; ; 5$: CALLS #0, W^FILE_CLOSE ;#0, FILE_CLOSE ; 1288 CLRL 208(R2) ;FILE_OPEN_FLAG ; 1289 MOVL #4, R0 ;#4, R0 ; 1269 RET ; ; 1231 6$: MOVL #10, R0 ;#10, R0 ; RET ; ; 1194 ; Routine Size: 138 bytes, Routine Base: $CODE$ + 01F9 ; 1301 %SBTTL 'SEND_FILE' ; 1302 ROUTINE SEND_FILE = ; 1303 ; 1304 !++ ; 1305 ! FUNCTIONAL DESCRIPTION: ; 1306 ! ; 1307 ! This routine will send the file specification that is being ; 1308 ! transfered. ; 1309 ! ; 1310 ! CALLING SEQUENCE: ; 1311 ! ; 1312 ! STATE = SEND_FILE(); ; 1313 ! ; 1314 ! INPUT PARAMETERS: ; 1315 ! ; 1316 ! None. ; 1317 ! ; 1318 ! IMPLICIT INPUTS: ; 1319 ! ; 1320 ! None. ; 1321 ! ; 1322 ! OUTPUT PARAMETERS: ; 1323 ! ; 1324 ! New state to change the finite state machine to. ; 1325 ! ; 1326 ! IMPLICIT OUTPUTS: ; 1327 ! ; 1328 ! None. ; 1329 ! ; 1330 ! COMPLETION CODES: ; 1331 ! ; 1332 ! None. ; 1333 ! ; 1334 ! SIDE EFFECTS: ; 1335 ! ; 1336 ! None. ; 1337 ! ; 1338 !-- ; 1339 ; 1340 BEGIN ; 1341 ! ; 1342 ! First determine if we have exceed the number of retries that are ; 1343 ! allowed to attempt to send this message. ; 1344 ! ; 1345 ; 1346 IF .NUM_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 1347 ; 1348 ! ; 1349 ! The number of retries are not exceeded. Increment the number and then ; 1350 ! attempt to send the packet again. ; 1351 ! ; 1352 NUM_RETRIES = .NUM_RETRIES + 1; ; 1353 ; 1354 IF .FILE_SIZE NEQ 0 ; 1355 THEN ; 1356 CH$MOVE (.FILE_SIZE, CH$PTR (FILE_NAME, 0, CHR_SIZE), ; 1357 CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE)); ; 1358 ; 1359 IF NOT SEND_PACKET (MSG_FILE, .FILE_SIZE, .MSG_NUMBER) THEN RETURN STATE_A; ; 1360 ; 1361 ! ; 1362 ! Now get the responce from the remote KERMIT. ; 1363 ! ; 1364 ; 1365 IF NOT REC_PACKET () THEN RETURN STATE_A; ; 1366 ; 1367 ! ; 1368 ! Determine if the packet is good. ; 1369 ! ; 1370 ; 1371 IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A; ; 1372 ; 1373 ! ; 1374 ! If this is a NAK and the message number is not the one we just send ; 1375 ! treat this like an ACK, otherwise resend the last packet. ; 1376 ! ; 1377 ; 1378 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1379 ; 1380 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 1381 ; 1382 ! ; 1383 ! Here to send the file name to the other end. ; 1384 ! ; 1385 NUM_RETRIES = 0; ; 1386 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1387 ; 1388 IF BFR_FILL () THEN RETURN STATE_SD ELSE RETURN STATE_A; ; 1389 ; 1390 END; ! End of ;SEND_FILE U.3: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 ; 1302 MOVAB W^U.56, R7 ;U.56, R7 ; CMPL -4(R7), #30 ;NUM_RETRIES, #30 ; 1346 BGTR 6$ ;6$ ; INCL -4(R7) ;NUM_RETRIES ; 1352 MOVL W^FILE_SIZE, R6 ;FILE_SIZE, R6 ; 1354 BEQL 1$ ;1$ ; MOVC3 R6, W^FILE_NAME, 116(R7) ;R6, FILE_NAME, SND_MSG+4 ; 1356 1$: PUSHL (R7) ;MSG_NUMBER ; 1359 PUSHL R6 ;R6 ; MOVZBL #70, -(SP) ;#70, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; BLBC R0, 6$ ;R0, 6$ ; CALLS #0, W^U.19 ;#0, U.19 ; 1365 BLBC R0, 6$ ;R0, 6$ ; MOVL 12(R7), R0 ;REC_TYPE, R0 ; 1371 CMPL R0, #89 ;R0, #89 ; BEQL 2$ ;2$ ; CMPL R0, #78 ;R0, #78 ; BNEQ 6$ ;6$ ; 2$: CMPL R0, #78 ;R0, #78 ; 1378 BNEQ 3$ ;3$ ; ADDL3 #1, (R7), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R7) ;#0, #6, R0, REC_SEQ ; BNEQ 4$ ;4$ ; 3$: CMPL 4(R7), (R7) ;REC_SEQ, MSG_NUMBER ; 1380 BEQL 5$ ;5$ ; 4$: MOVL -16(R7), R0 ;STATE, R0 ; RET ; ; 5$: CLRL -4(R7) ;NUM_RETRIES ; 1385 ADDL3 #1, (R7), R0 ;#1, MSG_NUMBER, R0 ; 1386 EXTZV #0, #6, R0, (R7) ;#0, #6, R0, MSG_NUMBER ; CALLS #0, W^U.21 ;#0, U.21 ; 1388 BLBC R0, 6$ ;R0, 6$ ; MOVL #3, R0 ;#3, R0 ; 1340 RET ; ; 6$: MOVL #10, R0 ;#10, R0 ; RET ; ; 1302 ; Routine Size: 136 bytes, Routine Base: $CODE$ + 0283 ; 1391 %SBTTL 'SEND_EOF' ; 1392 ROUTINE SEND_EOF = ; 1393 ; 1394 !++ ; 1395 ! FUNCTIONAL DESCRIPTION: ; 1396 ! ; 1397 ! This routine will send the end of file message to the remote ; 1398 ! KERMIT. It will then determine if there are more files to ; 1399 ! send to the remote. ; 1400 ! ; 1401 ! CALLING SEQUENCE: ; 1402 ! ; 1403 ! STATE = SEND_EOF(); ; 1404 ! ; 1405 ! INPUT PARAMETERS: ; 1406 ! ; 1407 ! None. ; 1408 ! ; 1409 ! IMPLICIT INPUTS: ; 1410 ! ; 1411 ! None. ; 1412 ! ; 1413 ! OUTPUT PARAMETERS: ; 1414 ! ; 1415 ! New state to change the finite state machine to. ; 1416 ! ; 1417 ! IMPLICIT OUTPUTS: ; 1418 ! ; 1419 ! None. ; 1420 ! ; 1421 ! COMPLETION CODES: ; 1422 ! ; 1423 ! None. ; 1424 ! ; 1425 ! SIDE EFFECTS: ; 1426 ! ; 1427 ! Sets up for the next file to be processed if there is one. ; 1428 ! ; 1429 !-- ; 1430 ; 1431 BEGIN ; 1432 ; 1433 LOCAL ; 1434 STATUS; ! Local status of routine ; 1435 ; 1436 ! ; 1437 ! First determine if we have exceed the number of retries that are ; 1438 ! allowed to attempt to send this message. ; 1439 ! ; 1440 ; 1441 IF .NUM_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 1442 ; 1443 ! ; 1444 ! The number of retries are not exceeded. Increment the number and then ; 1445 ! attempt to send the packet again. ; 1446 ! ; 1447 NUM_RETRIES = .NUM_RETRIES + 1; ; 1448 ; 1449 IF NOT SEND_PACKET (MSG_EOF, 0, .MSG_NUMBER) THEN RETURN STATE_A; ; 1450 ; 1451 ! ; 1452 ! Now get the responce from the remote KERMIT. ; 1453 ! ; 1454 ; 1455 IF NOT REC_PACKET () THEN RETURN STATE_A; ; 1456 ; 1457 ! ; 1458 ! Determine if the packet is good. ; 1459 ! ; 1460 ; 1461 IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A; ; 1462 ; 1463 ! ; 1464 ! If this is a NAK and the message number is not the one we just send ; 1465 ! treat this like an ACK, otherwise resend the last packet. ; 1466 ! ; 1467 ; 1468 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1469 ; 1470 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 1471 ; 1472 ! ; 1473 ! Here to determine if there is another file to send. ; 1474 ! ; 1475 NUM_RETRIES = 0; ; 1476 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1477 STATUS = NEXT_FILE (); ; 1478 ; 1479 IF ( NOT .STATUS) OR (.STATUS EQL KER_NOMORFILES) THEN RETURN STATE_SB ELSE RETURN STATE_SF; ; 1480 ; 1481 END; ;SEND_EOF U.4: .WORD ^M ;Save R2 ; 1392 MOVAB W^U.56, R2 ;U.56, R2 ; CMPL -4(R2), #30 ;NUM_RETRIES, #30 ; 1441 BGTR 1$ ;1$ ; INCL -4(R2) ;NUM_RETRIES ; 1447 PUSHL (R2) ;MSG_NUMBER ; 1449 CLRL -(SP) ;-(SP) ; MOVZBL #90, -(SP) ;#90, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; BLBC R0, 1$ ;R0, 1$ ; CALLS #0, W^U.19 ;#0, U.19 ; 1455 BLBC R0, 1$ ;R0, 1$ ; MOVL 12(R2), R0 ;REC_TYPE, R0 ; 1461 CMPL R0, #89 ;R0, #89 ; BEQL 2$ ;2$ ; CMPL R0, #78 ;R0, #78 ; BEQL 2$ ;2$ ; 1$: MOVL #10, R0 ;#10, R0 ; RET ; ; 2$: CMPL R0, #78 ;R0, #78 ; 1468 BNEQ 3$ ;3$ ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R2) ;#0, #6, R0, REC_SEQ ; BNEQ 4$ ;4$ ; 3$: CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 1470 BEQL 5$ ;5$ ; 4$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 5$: CLRL -4(R2) ;NUM_RETRIES ; 1475 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 1476 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; CALLS #0, W^NEXT_FILE ;#0, NEXT_FILE ; 1477 BLBC R0, 6$ ;STATUS, 6$ ; 1479 CMPL R0, #134316123 ;STATUS, #134316123 ; BNEQ 7$ ;7$ ; 6$: MOVL #5, R0 ;#5, R0 ; 1431 RET ; ; 7$: MOVL #2, R0 ;#2, R0 ; RET ; ; 1392 ; Routine Size: 135 bytes, Routine Base: $CODE$ + 030B ; 1482 %SBTTL 'SEND_INIT' ; 1483 ROUTINE SEND_INIT = ; 1484 ; 1485 !++ ; 1486 ! FUNCTIONAL DESCRIPTION: ; 1487 ! ; 1488 ! This routine will send the initialization packet to the remote ; 1489 ! KERMIT. The message type sent is S. ; 1490 ! ; 1491 ! CALLING SEQUENCE: ; 1492 ! ; 1493 ! STATE = SEND_INIT(); ; 1494 ! ; 1495 ! INPUT PARAMETERS: ; 1496 ! ; 1497 ! None. ; 1498 ! ; 1499 ! IMPLICIT INPUTS: ; 1500 ! ; 1501 ! None. ; 1502 ! ; 1503 ! OUTPUT PARAMETERS: ; 1504 ! ; 1505 ! New state to change the finite state machine to. ; 1506 ! ; 1507 ! IMPLICIT OUTPUTS: ; 1508 ! ; 1509 ! None. ; 1510 ! ; 1511 ! COMPLETION CODES: ; 1512 ! ; 1513 ! None. ; 1514 ! ; 1515 ! SIDE EFFECTS: ; 1516 ! ; 1517 ! None. ; 1518 ! ; 1519 !-- ; 1520 ; 1521 BEGIN ; 1522 SET_SEND_INIT (); ; 1523 ; 1524 IF .NUM_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 1525 ; 1526 IF NOT SEND_PACKET (MSG_SND_INIT, P_SI_LENGTH, .MSG_NUMBER) THEN RETURN STATE_A; ; 1527 ; 1528 IF NOT REC_PACKET () THEN RETURN STATE_A; ; 1529 ; 1530 ! ; 1531 ! Determine if the packet is good. ; 1532 ! ; 1533 ; 1534 IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A; ; 1535 ; 1536 ! ; 1537 ! If this is a NAK and the message number is not the one we just send ; 1538 ! treat this like an ACK, otherwise resend the last packet. ; 1539 ! ; 1540 ; 1541 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1542 ; 1543 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 1544 ; 1545 ! ; 1546 ! Here if we have an ACK for the initialization message that was just sent ; 1547 ! to the remote KERMIT. ; 1548 ! ; 1549 ; 1550 PRS_SEND_INIT (); ; 1551 NUM_RETRIES = 0; ; 1552 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1553 ; 1554 IF NOT FILE_OPEN (FNC_READ) ; 1555 THEN ; 1556 RETURN STATE_A ; 1557 ELSE ; 1558 BEGIN ; 1559 FILE_OPEN_FLAG = TRUE; ; 1560 RETURN STATE_SF; ; 1561 END; ; 1562 ; 1563 END; ;SEND_INIT U.5: .WORD ^M ;Save R2 ; 1483 MOVAB W^U.56, R2 ;U.56, R2 ; CALLS #0, W^U.15 ;#0, U.15 ; 1522 CMPL -4(R2), #30 ;NUM_RETRIES, #30 ; 1524 BGTR 5$ ;5$ ; PUSHL (R2) ;MSG_NUMBER ; 1526 PUSHL #7 ;#7 ; MOVZBL #83, -(SP) ;#83, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; BLBC R0, 5$ ;R0, 5$ ; CALLS #0, W^U.19 ;#0, U.19 ; 1528 BLBC R0, 5$ ;R0, 5$ ; MOVL 12(R2), R0 ;REC_TYPE, R0 ; 1534 CMPL R0, #89 ;R0, #89 ; BEQL 1$ ;1$ ; CMPL R0, #78 ;R0, #78 ; BNEQ 5$ ;5$ ; 1$: CMPL R0, #78 ;R0, #78 ; 1541 BNEQ 2$ ;2$ ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R2) ;#0, #6, R0, REC_SEQ ; BNEQ 3$ ;3$ ; 2$: CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 1543 BEQL 4$ ;4$ ; 3$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 4$: CALLS #0, W^U.16 ;#0, U.16 ; 1550 CLRL -4(R2) ;NUM_RETRIES ; 1551 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 1552 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; CLRL -(SP) ;-(SP) ; 1554 CALLS #1, W^FILE_OPEN ;#1, FILE_OPEN ; BLBS R0, 6$ ;R0, 6$ ; 5$: MOVL #10, R0 ;#10, R0 ; 1521 RET ; ; 6$: MOVL #1, 208(R2) ;#1, FILE_OPEN_FLAG ; 1559 MOVL #2, R0 ;#2, R0 ; 1521 RET ; ; 1483 ; Routine Size: 136 bytes, Routine Base: $CODE$ + 0392 ; 1564 %SBTTL 'SEND_BREAK' ; 1565 ROUTINE SEND_BREAK = ; 1566 ; 1567 !++ ; 1568 ! FUNCTIONAL DESCRIPTION: ; 1569 ! ; 1570 ! This routine will send the break (end of transmission) message ; 1571 ! to the remote KERMIT. On an ACK the state becomes STATE_C. ; 1572 ! ; 1573 ! CALLING SEQUENCE: ; 1574 ! ; 1575 ! STATE = SEND_BREAK(); ; 1576 ! ; 1577 ! INPUT PARAMETERS: ; 1578 ! ; 1579 ! None. ; 1580 ! ; 1581 ! IMPLICIT INPUTS: ; 1582 ! ; 1583 ! None. ; 1584 ! ; 1585 ! OUTPUT PARAMETERS: ; 1586 ! ; 1587 ! New state for the finite state machine. ; 1588 ! ; 1589 ! IMPLICIT OUTPUTS: ; 1590 ! ; 1591 ! None. ; 1592 ! ; 1593 ! COMPLETION CODES: ; 1594 ! ; 1595 ! None. ; 1596 ! ; 1597 ! SIDE EFFECTS: ; 1598 ! ; 1599 ! None. ; 1600 ! ; 1601 !-- ; 1602 ; 1603 BEGIN ; 1604 ! ; 1605 ! First determine if we have exceed the number of retries that are ; 1606 ! allowed to attempt to send this message. ; 1607 ! ; 1608 ; 1609 IF .NUM_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 1610 ; 1611 ! ; 1612 ! The number of retries are not exceeded. Increment the number and then ; 1613 ! attempt to send the packet again. ; 1614 ! ; 1615 NUM_RETRIES = .NUM_RETRIES + 1; ; 1616 ; 1617 IF NOT SEND_PACKET (MSG_BREAK, 0, .MSG_NUMBER) THEN RETURN STATE_A; ; 1618 ; 1619 ! ; 1620 ! Now get the responce from the remote KERMIT. ; 1621 ! ; 1622 ; 1623 IF NOT REC_PACKET () THEN RETURN STATE_A; ; 1624 ; 1625 ! ; 1626 ! Determine if the packet is good. ; 1627 ! ; 1628 ; 1629 IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A; ; 1630 ; 1631 ! ; 1632 ! If this is a NAK and the message number is not the one we just send ; 1633 ! treat this like an ACK, otherwise resend the last packet. ; 1634 ! ; 1635 ; 1636 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1637 ; 1638 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 1639 ; 1640 ! ; 1641 ! Here to determine if there is another file to send. ; 1642 ! ; 1643 NUM_RETRIES = 0; ; 1644 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1645 RETURN STATE_C; ; 1646 END; ;SEND_BREAK U.6: .WORD ^M ;Save R2 ; 1565 MOVAB W^U.56, R2 ;U.56, R2 ; CMPL -4(R2), #30 ;NUM_RETRIES, #30 ; 1609 BGTR 1$ ;1$ ; INCL -4(R2) ;NUM_RETRIES ; 1615 PUSHL (R2) ;MSG_NUMBER ; 1617 CLRL -(SP) ;-(SP) ; MOVZBL #66, -(SP) ;#66, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; BLBC R0, 1$ ;R0, 1$ ; CALLS #0, W^U.19 ;#0, U.19 ; 1623 BLBC R0, 1$ ;R0, 1$ ; MOVL 12(R2), R0 ;REC_TYPE, R0 ; 1629 CMPL R0, #89 ;R0, #89 ; BEQL 2$ ;2$ ; CMPL R0, #78 ;R0, #78 ; BEQL 2$ ;2$ ; 1$: MOVL #10, R0 ;#10, R0 ; RET ; ; 2$: CMPL R0, #78 ;R0, #78 ; 1636 BNEQ 3$ ;3$ ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R2) ;#0, #6, R0, REC_SEQ ; BNEQ 4$ ;4$ ; 3$: CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 1638 BEQL 5$ ;5$ ; 4$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 5$: CLRL -4(R2) ;NUM_RETRIES ; 1643 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 1644 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; MOVL #9, R0 ;#9, R0 ; 1603 RET ; ; 1565 ; Routine Size: 114 bytes, Routine Base: $CODE$ + 041A ; 1647 %SBTTL 'SND_ERROR' ; 1648 ; 1649 GLOBAL ROUTINE SND_ERROR (COUNT, ADDRESS) : NOVALUE = ; 1650 ; 1651 !++ ; 1652 ! FUNCTIONAL DESCRIPTION: ; 1653 ! ; 1654 ! This routine will send an error packet to the remote KERMIT. It ; 1655 ! is called with the count of characters and the address of the text. ; 1656 ! ; 1657 ! CALLING SEQUENCE: ; 1658 ! ; 1659 ! SND_ERROR(COUNT, %ASCII 'Error text'); ; 1660 ! ; 1661 ! INPUT PARAMETERS: ; 1662 ! ; 1663 ! None. ; 1664 ! ; 1665 ! IMPLICIT INPUTS: ; 1666 ! ; 1667 ! None. ; 1668 ! ; 1669 ! OUTPUT PARAMETERS: ; 1670 ! ; 1671 ! None. ; 1672 ! ; 1673 ! IMPLICIT OUTPUTS: ; 1674 ! ; 1675 ! None. ; 1676 ! ; 1677 ! COMPLETION CODES: ; 1678 ! ; 1679 ! None. ; 1680 ! ; 1681 ! SIDE EFFECTS: ; 1682 ! ; 1683 ! ; 1684 !-- ; 1685 ; 1686 BEGIN ; 1687 ; 1688 LOCAL ; 1689 CHR, ! Character we are processing ; 1690 SIZE, ! Size of data area ; 1691 STO_PTR, ! Pointer used to store chars ; 1692 FET_PTR; ! Pointer used to fetch characters ; 1693 ; 1694 ! ; 1695 ! Initialize the various pointers and counter. ; 1696 ! ; 1697 FET_PTR = CH$PTR (.ADDRESS); ; 1698 STO_PTR = CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE); ; 1699 SIZE = (IF .COUNT GTR .SND_PKT_SIZE - PKT_TOT_OVR_HEAD THEN .SND_PKT_SIZE - PKT_TOT_OVR_HEAD ELSE .COUNT); ; 1700 ! ; 1701 ! Move the information from the source to the destination ; 1702 ! ; 1703 CH$MOVE (.SIZE, .FET_PTR, .STO_PTR); ; 1704 ; 1705 IF NOT SEND_PACKET (MSG_ERROR, .SIZE, .MSG_NUMBER) THEN RETURN STATE_A; ; 1706 ; 1707 END; ! End of SND_ERROR U.7: .ENTRY SND_ERROR, ^M ;SND_ERROR, Save R2,R3,R4,R5,R6 ; 1649 MOVL 8(AP), R1 ;ADDRESS, FET_PTR ; 1697 MOVAB W^U.61+4, R2 ;U.61+4, STO_PTR ; 1698 SUBL3 #6, W^SND_PKT_SIZE, R0 ;#6, SND_PKT_SIZE, R0 ; 1699 CMPL 4(AP), R0 ;COUNT, R0 ; BLEQ 1$ ;1$ ; MOVL R0, R6 ;R0, SIZE ; BRB 2$ ;2$ ; 1$: MOVL 4(AP), R6 ;COUNT, SIZE ; 2$: MOVC3 R6, (R1), (R2) ;SIZE, (FET_PTR), (STO_PTR) ; 1703 PUSHL W^U.56 ;U.56 ; 1705 PUSHL R6 ;SIZE ; MOVZBL #69, -(SP) ;#69, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; RET ; ; 1649 ; Routine Size: 52 bytes, Routine Base: $CODE$ + 048C ; 1708 ; 1709 %SBTTL 'REC_SWITCH' ; 1710 ; 1711 GLOBAL ROUTINE REC_SWITCH = ; 1712 ; 1713 !++ ; 1714 ! FUNCTIONAL DESCRIPTION: ; 1715 ! ; 1716 ! This routine will cause file(s) to be received by the remote ; 1717 ! KERMIT. This routine contains the main loop for the sending of the ; 1718 ! data. ; 1719 ! ; 1720 ! CALLING SEQUENCE: ; 1721 ! ; 1722 ! REC_SWITCH(); ; 1723 ! ; 1724 ! INPUT PARAMETERS: ; 1725 ! ; 1726 ! None. ; 1727 ! ; 1728 ! IMPLICIT INPUTS: ; 1729 ! ; 1730 ! FILE_DESC - Descriptor describing the file to be received by ; 1731 ! the remote KERMIT. ; 1732 ! ; 1733 ! OUTPUT PARAMETERS: ; 1734 ! ; 1735 ! None. ; 1736 ! ; 1737 ! IMPLICIT OUTPUTS: ; 1738 ! ; 1739 ! None. ; 1740 ! ; 1741 ! COMPLETION CODES: ; 1742 ! ; 1743 ! True - File received correctly. ; 1744 ! FALSE - File transfer aborted. ; 1745 ! ; 1746 ! SIDE EFFECTS: ; 1747 ! ; 1748 ! None. ; 1749 ! ; 1750 !-- ; 1751 ; 1752 BEGIN ; 1753 ; 1754 STATE = STATE_R; ! Initialize the state ; 1755 RETURN REC_SWITCH_WORKER(); ; 1756 END; ! End of REC_SWITCH U.8: .ENTRY REC_SWITCH, ^M<> ;REC_SWITCH, Save nothing ; 1711 MOVL #6, W^U.52 ;#6, U.52 ; 1754 CALLS #0, W^U.9 ;#0, U.9 ; 1755 RET ; ; 1711 ; Routine Size: 13 bytes, Routine Base: $CODE$ + 04C0 ; 1757 ; 1758 %SBTTL 'Receive - REC_SWITCH_WORKER' ; 1759 ; 1760 ROUTINE REC_SWITCH_WORKER = ; 1761 !++ ; 1762 ! FUNCTIONAL DESCRIPTION: ; 1763 ! ; 1764 ! This is the worker routine for either REC_SWITCH or SERVER. ; 1765 ! This routine will be called with the STATE variable set to the ; 1766 ! correct state for either the SERVER or the REC_SWITCH routine. ; 1767 ! ; 1768 ! CALLING SEQUENCE: ; 1769 ! ; 1770 ! Status = REC_SWITCH_WORKER(); ; 1771 ! ; 1772 ! INPUT PARAMETERS: ; 1773 ! ; 1774 ! None. ; 1775 ! ; 1776 ! IMPLICIT INPUTS: ; 1777 ! ; 1778 ! None. ; 1779 ! ; 1780 ! OUPTUT PARAMETERS: ; 1781 ! ; 1782 ! None. ; 1783 ! ; 1784 ! IMPLICIT OUTPUTS: ; 1785 ! ; 1786 ! None. ; 1787 ! ; 1788 ! COMPLETION CODES: ; 1789 ! ; 1790 ! None. ; 1791 ! ; 1792 ! SIDE EFFECTS: ; 1793 ! ; 1794 ! None. ; 1795 ! ; 1796 !-- ; 1797 ; 1798 BEGIN ; 1799 ; 1800 LOCAL ; 1801 RETURN_VALUE; ; 1802 ; 1803 INIT_STATS (); ! Initialize the stats ; 1804 NUM_RETRIES = 0; ! Initialize the number of retries ; 1805 ; 1806 WHILE TRUE DO ; 1807 ; 1808 CASE .STATE FROM STATE_MIN TO STATE_MAX OF ; 1809 SET ; 1810 ! ; 1811 ! Receiving of the data and the end of file message. ; 1812 ! ; 1813 ; 1814 [STATE_RD] : ; 1815 STATE = REC_DATA (); ; 1816 ! ; 1817 ! Receiving the FILE information of the break to end the transfer of ; 1818 ! one or more files ; 1819 ! ; 1820 ; 1821 [STATE_RF] : ; 1822 STATE = REC_FILE (); ; 1823 ! ; 1824 ! Initialization for the receiving of a file ; 1825 ! ; 1826 ; 1827 [STATE_R] : ; 1828 STATE = REC_INIT (); ; 1829 ! ; 1830 ! Here if we have completed the receiving of the file ; 1831 ! ; 1832 ; 1833 [STATE_C] : ; 1834 BEGIN ; 1835 RETURN_VALUE = TRUE; ; 1836 EXITLOOP; ; 1837 END; ; 1838 ! ; 1839 ! Here if we aborted the transfer or we have gotten into some random ; 1840 ! state (internal KERMSG problem). ; 1841 ! ; 1842 ; 1843 [STATE_A, INRANGE, OUTRANGE] : ; 1844 BEGIN ; 1845 RETURN_VALUE = FALSE; ; 1846 ! ; 1847 ! Determine if the file is still open and if so close it ; 1848 ! ; 1849 ; 1850 IF .FILE_OPEN_FLAG ; 1851 THEN ; 1852 BEGIN ; 1853 FILE_OPEN_FLAG = FALSE; ; 1854 FILE_CLOSE (); ; 1855 END; ; 1856 ; 1857 EXITLOOP; ; 1858 END; ; 1859 TES; ; 1860 ; 1861 RETURN .RETURN_VALUE; ; 1862 END; ! End of REC_SWITCH_WORKER ;REC_SWITCH_WORKER U.9: .WORD ^M ;Save R2 ; 1760 CALLS #0, W^U.14 ;#0, U.14 ; 1803 CLRL W^U.55 ;U.55 ; 1804 1$: CASEL W^U.52, #0, #10 ;U.52, #0, #10 ; 1808 2$: .WORD 3$-2$,- ;3$-2$,- ; 3$-2$,- ;3$-2$,- ; 3$-2$,- ;3$-2$,- ; 3$-2$,- ;3$-2$,- ; 3$-2$,- ;3$-2$,- ; 3$-2$,- ;3$-2$,- ; 6$-2$,- ;6$-2$,- ; 5$-2$,- ;5$-2$,- ; 4$-2$,- ;4$-2$,- ; 8$-2$,- ;8$-2$,- ; 3$-2$ ;3$-2$ ; 3$: CLRL R2 ;RETURN_VALUE ; 1845 BLBC W^U.62, 9$ ;U.62, 9$ ; 1850 CLRL W^U.62 ;U.62 ; 1853 CALLS #0, W^FILE_CLOSE ;#0, FILE_CLOSE ; 1854 BRB 9$ ;9$ ; 1844 4$: CALLS #0, W^U.12 ;#0, U.12 ; 1815 BRB 7$ ;7$ ; 5$: CALLS #0, W^U.11 ;#0, U.11 ; 1822 BRB 7$ ;7$ ; 6$: CALLS #0, W^U.10 ;#0, U.10 ; 1828 7$: MOVL R0, W^U.52 ;R0, U.52 ; BRB 1$ ;1$ ; 1808 8$: MOVL #1, R2 ;#1, RETURN_VALUE ; 1835 9$: MOVL R2, R0 ;RETURN_VALUE, R0 ; 1798 RET ; ; 1760 ; Routine Size: 90 bytes, Routine Base: $CODE$ + 04CD ; 1863 ; 1864 %SBTTL 'REC_INIT' ; 1865 ROUTINE REC_INIT = ; 1866 ; 1867 !++ ; 1868 ! FUNCTIONAL DESCRIPTION: ; 1869 ! ; 1870 ! This routine will process an initialization message received from ; 1871 ! the remote KERMIT. ; 1872 ! ; 1873 ! CALLING SEQUENCE: ; 1874 ! ; 1875 ! STATE = REC_INIT(); ; 1876 ! ; 1877 ! INPUT PARAMETERS: ; 1878 ! ; 1879 ! None. ; 1880 ! ; 1881 ! IMPLICIT INPUTS: ; 1882 ! ; 1883 ! None. ; 1884 ! ; 1885 ! OUTPUT PARAMETERS: ; 1886 ! ; 1887 ! New machine state. ; 1888 ! ; 1889 ! IMPLICIT OUTPUTS: ; 1890 ! ; 1891 ! None. ; 1892 ! ; 1893 ! COMPLETION CODES: ; 1894 ! ; 1895 ! None. ; 1896 ! ; 1897 ! SIDE EFFECTS: ; 1898 ! ; 1899 ! None. ; 1900 ! ; 1901 !-- ; 1902 ; 1903 BEGIN ; 1904 ROUTINE CHECK_INIT = ; 1905 BEGIN ; 1906 ; 1907 IF .REC_TYPE EQL MSG_SND_INIT THEN RETURN TRUE ELSE RETURN FALSE; ; 1908 ; 1909 END; ;CHECK_INIT U.66: .WORD ^M<> ;Save nothing ; 1904 CMPL W^U.59, #83 ;U.59, #83 ; 1907 BNEQ 1$ ;1$ ; MOVL #1, R0 ;#1, R0 ; 1905 RET ; ; 1$: CLRL R0 ;R0 ; RET ; ; 1904 ; Routine Size: 20 bytes, Routine Base: $CODE$ + 0527 ; 1910 ; 1911 IF NOT REC_MESSAGE (CHECK_INIT) THEN RETURN STATE_A; ; 1912 ; 1913 MSG_NUMBER = .REC_SEQ; ; 1914 PRS_SEND_INIT (); ; 1915 SET_SEND_INIT (); ; 1916 SEND_PACKET (MSG_ACK, P_SI_LENGTH, .MSG_NUMBER); ; 1917 OLD_RETRIES = .NUM_RETRIES; ; 1918 NUM_RETRIES = 0; ; 1919 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1920 RETURN STATE_RF; ; 1921 END; ! End of REC_INIT ;REC_INIT U.10: .WORD ^M ;Save R2 ; 1865 MOVAB W^U.56, R2 ;U.56, R2 ; PUSHAB B^U.66 ;U.66 ; 1911 CALLS #1, W^U.18 ;#1, U.18 ; BLBS R0, 1$ ;R0, 1$ ; MOVL #10, R0 ;#10, R0 ; RET ; ; 1$: MOVL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 1913 CALLS #0, W^U.16 ;#0, U.16 ; 1914 CALLS #0, W^U.15 ;#0, U.15 ; 1915 PUSHL (R2) ;MSG_NUMBER ; 1916 PUSHL #7 ;#7 ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; MOVL -4(R2), -8(R2) ;NUM_RETRIES, OLD_RETRIES ; 1917 CLRL -4(R2) ;NUM_RETRIES ; 1918 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 1919 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; MOVL #7, R0 ;#7, R0 ; 1903 RET ; ; 1865 ; Routine Size: 70 bytes, Routine Base: $CODE$ + 053B ; 1922 %SBTTL 'REC_FILE' ; 1923 ROUTINE REC_FILE = ; 1924 ; 1925 !++ ; 1926 ! FUNCTIONAL DESCRIPTION: ; 1927 ! ; 1928 ! This routine expects to receive an MSG_FILE packet from the remote ; 1929 ! KERMIT. If the message is correct this routine will change the state ; 1930 ! to STATE_RD. ; 1931 ! ; 1932 ! This routine also expects MSG_SND_INIT, MSG_EOF, or MSG_BREAK. ; 1933 ! ; 1934 ! CALLING SEQUENCE: ; 1935 ! ; 1936 ! STATE = REC_FILE(); ; 1937 ! ; 1938 ! INPUT PARAMETERS: ; 1939 ! ; 1940 ! None. ; 1941 ! ; 1942 ! IMPLICIT INPUTS: ; 1943 ! ; 1944 ! None. ; 1945 ! ; 1946 ! OUTPUT PARAMETERS: ; 1947 ! ; 1948 ! New state. ; 1949 ! ; 1950 ! IMPLICIT OUTPUTS: ; 1951 ! ; 1952 ! None. ; 1953 ! ; 1954 ! COMPLETION CODES: ; 1955 ! ; 1956 ! None. ; 1957 ! ; 1958 ! SIDE EFFECTS: ; 1959 ! ; 1960 ! None. ; 1961 ! ; 1962 !-- ; 1963 ; 1964 BEGIN ; 1965 ROUTINE CHECK_FILE = ; 1966 BEGIN ; 1967 ; 1968 IF (.REC_TYPE EQL MSG_SND_INIT) OR (.REC_TYPE EQL MSG_EOF) OR (.REC_TYPE EQL MSG_FILE) OR (.REC_TYPE ; 1969 EQL MSG_BREAK) ; 1970 THEN ; 1971 RETURN TRUE ; 1972 ELSE ; 1973 RETURN FALSE; ; 1974 ; 1975 END; ;CHECK_FILE U.67: .WORD ^M<> ;Save nothing ; 1965 MOVL W^U.59, R0 ;U.59, R0 ; 1968 CMPL R0, #83 ;R0, #83 ; BEQL 1$ ;1$ ; CMPL R0, #90 ;R0, #90 ; BEQL 1$ ;1$ ; CMPL R0, #70 ;R0, #70 ; BEQL 1$ ;1$ ; CMPL R0, #66 ;R0, #66 ; BNEQ 2$ ;2$ ; 1$: MOVL #1, R0 ;#1, R0 ; 1966 RET ; ; 2$: CLRL R0 ;R0 ; RET ; ; 1965 ; Routine Size: 50 bytes, Routine Base: $CODE$ + 0581 ; 1976 ; 1977 IF NOT REC_MESSAGE (CHECK_FILE) THEN RETURN STATE_A; ; 1978 ; 1979 SELECTONE .REC_TYPE OF ; 1980 SET ; 1981 ; 1982 [MSG_SND_INIT] : ; 1983 BEGIN ; 1984 ; 1985 IF .OLD_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 1986 ; 1987 OLD_RETRIES = .OLD_RETRIES + 1; ; 1988 ; 1989 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 1990 THEN ; 1991 BEGIN ; 1992 SET_SEND_INIT (); ; 1993 SEND_PACKET (MSG_ACK, P_SI_LENGTH, .MSG_NUMBER); ; 1994 NUM_RETRIES = 0; ; 1995 RETURN .STATE; ; 1996 END ; 1997 ELSE ; 1998 RETURN STATE_A; ; 1999 ; 2000 END; ; 2001 ; 2002 [MSG_EOF] : ; 2003 BEGIN ; 2004 ; 2005 IF .OLD_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 2006 ; 2007 OLD_RETRIES = .OLD_RETRIES + 1; ; 2008 ; 2009 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 2010 THEN ; 2011 BEGIN ; 2012 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2013 NUM_RETRIES = 0; ; 2014 RETURN .STATE; ; 2015 END ; 2016 ELSE ; 2017 RETURN STATE_A; ; 2018 ; 2019 END; ; 2020 ; 2021 [MSG_FILE] : ; 2022 BEGIN ; 2023 ; 2024 IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A; ; 2025 ; 2026 FILE_SIZE = .REC_LENGTH; ; 2027 ; 2028 IF .REC_LENGTH GTR 0 ; 2029 THEN ; 2030 CH$MOVE (.REC_LENGTH, CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE), ; 2031 CH$PTR (FILE_NAME, 0, CHR_SIZE)); ; 2032 ; 2033 IF NOT FILE_OPEN (FNC_WRITE) THEN RETURN STATE_A; ; 2034 ; 2035 FILE_OPEN_FLAG = TRUE; ; 2036 SEND_PACKET (MSG_ACK, 0, .MSG_NUMBER); ; 2037 OLD_RETRIES = .NUM_RETRIES; ; 2038 NUM_RETRIES = 0; ; 2039 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2040 RETURN STATE_RD; ; 2041 END; ; 2042 ; 2043 [MSG_BREAK] : ; 2044 BEGIN ; 2045 ; 2046 IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A; ; 2047 ; 2048 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2049 RETURN STATE_C; ; 2050 END; ; 2051 ; 2052 [OTHERWISE] : ; 2053 RETURN STATE_A; ; 2054 TES; ; 2055 ; 2056 END; ! End of REC_FILE ;REC_FILE U.11: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 ; 1923 MOVAB W^U.17, R7 ;U.17, R7 ; MOVAB W^U.56, R6 ;U.56, R6 ; PUSHAB B^U.67 ;U.67 ; 1977 CALLS #1, W^U.18 ;#1, U.18 ; BLBS R0, 2$ ;R0, 2$ ; 1$: BRW 8$ ;8$ ; 2$: MOVL 12(R6), R0 ;REC_TYPE, R0 ; 1979 CMPL R0, #83 ;R0, #83 ; BNEQ 3$ ;3$ ; CMPL -8(R6), #30 ;OLD_RETRIES, #30 ; 1985 BGTR 1$ ;1$ ; INCL -8(R6) ;OLD_RETRIES ; 1987 SUBL3 #1, (R6), R0 ;#1, MSG_NUMBER, R0 ; 1989 CMPL R0, 4(R6) ;R0, REC_SEQ ; BNEQ 1$ ;1$ ; CALLS #0, W^U.15 ;#0, U.15 ; 1992 PUSHL (R6) ;MSG_NUMBER ; 1993 PUSHL #7 ;#7 ; BRB 4$ ;4$ ; 3$: CMPL R0, #90 ;R0, #90 ; 1979 BNEQ 5$ ;5$ ; CMPL -8(R6), #30 ;OLD_RETRIES, #30 ; 2005 BGTR 1$ ;1$ ; INCL -8(R6) ;OLD_RETRIES ; 2007 SUBL3 #1, (R6), R0 ;#1, MSG_NUMBER, R0 ; 2009 CMPL R0, 4(R6) ;R0, REC_SEQ ; BNEQ 1$ ;1$ ; PUSHL 4(R6) ;REC_SEQ ; 2012 CLRL -(SP) ;-(SP) ; 4$: MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R7) ;#3, SEND_PACKET ; CLRL -4(R6) ;NUM_RETRIES ; 2013 MOVL -16(R6), R0 ;STATE, R0 ; 2003 RET ; ; 5$: CMPL R0, #70 ;R0, #70 ; 1979 BNEQ 7$ ;7$ ; CMPL (R6), 4(R6) ;MSG_NUMBER, REC_SEQ ; 2024 BNEQ 8$ ;8$ ; MOVL 8(R6), R0 ;REC_LENGTH, R0 ; 2026 MOVL R0, W^FILE_SIZE ;R0, FILE_SIZE ; BLEQ 6$ ;6$ ; 2028 MOVC3 R0, 20(R6), W^FILE_NAME ;R0, REC_MSG+4, FILE_NAME ; 2030 6$: PUSHL #1 ;#1 ; 2033 CALLS #1, W^FILE_OPEN ;#1, FILE_OPEN ; BLBC R0, 8$ ;R0, 8$ ; MOVL #1, 208(R6) ;#1, FILE_OPEN_FLAG ; 2035 PUSHL (R6) ;MSG_NUMBER ; 2036 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R7) ;#3, SEND_PACKET ; MOVL -4(R6), -8(R6) ;NUM_RETRIES, OLD_RETRIES ; 2037 CLRL -4(R6) ;NUM_RETRIES ; 2038 ADDL3 #1, (R6), R0 ;#1, MSG_NUMBER, R0 ; 2039 EXTZV #0, #6, R0, (R6) ;#0, #6, R0, MSG_NUMBER ; MOVL #8, R0 ;#8, R0 ; 1979 RET ; ; 7$: CMPL R0, #66 ;R0, #66 ; BNEQ 8$ ;8$ ; CMPL (R6), 4(R6) ;MSG_NUMBER, REC_SEQ ; 2046 BNEQ 8$ ;8$ ; PUSHL 4(R6) ;REC_SEQ ; 2048 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R7) ;#3, SEND_PACKET ; MOVL #9, R0 ;#9, R0 ; 1979 RET ; ; 8$: MOVL #10, R0 ;#10, R0 ; RET ; ; 1923 ; Routine Size: 232 bytes, Routine Base: $CODE$ + 05B3 ; 2057 %SBTTL 'REC_DATA' ; 2058 ROUTINE REC_DATA = ; 2059 ; 2060 !++ ; 2061 ! FUNCTIONAL DESCRIPTION: ; 2062 ! ; 2063 ! This routine will accept data messages and write them to disk. ; 2064 ! It will also accept MSG_FILE and MSG_EOF messages. ; 2065 ! ; 2066 ! CALLING SEQUENCE: ; 2067 ! ; 2068 ! STATE = REC_DATA(); ; 2069 ! ; 2070 ! INPUT PARAMETERS: ; 2071 ! ; 2072 ! None. ; 2073 ! ; 2074 ! IMPLICIT INPUTS: ; 2075 ! ; 2076 ! None. ; 2077 ! ; 2078 ! OUTPUT PARAMETERS: ; 2079 ! ; 2080 ! New state for the finite state machine. ; 2081 ! ; 2082 ! IMPLICIT OUTPUTS: ; 2083 ! ; 2084 ! None. ; 2085 ! ; 2086 ! COMPLETION CODES: ; 2087 ! ; 2088 ! None. ; 2089 ! ; 2090 ! SIDE EFFECTS: ; 2091 ! ; 2092 ! None. ; 2093 ! ; 2094 !-- ; 2095 ; 2096 BEGIN ; 2097 ROUTINE CHECK_DATA = ; 2098 BEGIN ; 2099 ; 2100 IF .REC_TYPE EQL MSG_DATA OR .REC_TYPE EQL MSG_FILE OR .REC_TYPE EQL MSG_EOF ; 2101 THEN ; 2102 RETURN TRUE ; 2103 ELSE ; 2104 RETURN FALSE; ; 2105 ; 2106 END; ;CHECK_DATA U.68: .WORD ^M<> ;Save nothing ; 2097 MOVL W^U.59, R0 ;U.59, R0 ; 2100 CMPL R0, #68 ;R0, #68 ; BEQL 1$ ;1$ ; CMPL R0, #70 ;R0, #70 ; BEQL 1$ ;1$ ; CMPL R0, #90 ;R0, #90 ; BNEQ 2$ ;2$ ; 1$: MOVL #1, R0 ;#1, R0 ; 2098 RET ; ; 2$: CLRL R0 ;R0 ; RET ; ; 2097 ; Routine Size: 41 bytes, Routine Base: $CODE$ + 069B ; 2107 ; 2108 IF NOT REC_MESSAGE (CHECK_DATA) THEN RETURN STATE_A; ; 2109 ; 2110 SELECTONE .REC_TYPE OF ; 2111 SET ; 2112 ; 2113 [MSG_DATA] : ; 2114 BEGIN ; 2115 ; 2116 IF .MSG_NUMBER NEQ .REC_SEQ ; 2117 THEN ; 2118 BEGIN ; 2119 ; 2120 IF .OLD_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 2121 ; 2122 OLD_RETRIES = .OLD_RETRIES + 1; ; 2123 ; 2124 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 2125 THEN ; 2126 BEGIN ; 2127 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2128 NUM_RETRIES = 0; ; 2129 RETURN .STATE; ; 2130 END ; 2131 ELSE ; 2132 RETURN STATE_A; ; 2133 ; 2134 END; ; 2135 ; 2136 ! ; 2137 ! Here if we have a message with a valid message number ; 2138 ! ; 2139 ; 2140 IF NOT BFR_EMPTY () THEN RETURN STATE_A; ; 2141 ; 2142 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2143 OLD_RETRIES = .NUM_RETRIES; ; 2144 NUM_RETRIES = 0; ; 2145 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2146 RETURN STATE_RD; ; 2147 END; ; 2148 ; 2149 [MSG_FILE] : ; 2150 BEGIN ; 2151 ; 2152 IF .OLD_RETRIES GTR MAX_RETRIES THEN RETURN STATE_A; ; 2153 ; 2154 OLD_RETRIES = .OLD_RETRIES + 1; ; 2155 ; 2156 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 2157 THEN ; 2158 BEGIN ; 2159 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2160 NUM_RETRIES = 0; ; 2161 RETURN .STATE; ; 2162 END ; 2163 ELSE ; 2164 RETURN STATE_A; ; 2165 ; 2166 END; ; 2167 ; 2168 [MSG_EOF] : ; 2169 BEGIN ; 2170 ; 2171 IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A; ; 2172 ; 2173 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2174 FILE_OPEN_FLAG = FALSE; ; 2175 ; 2176 IF NOT FILE_CLOSE () THEN RETURN STATE_A; ; 2177 ; 2178 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2179 RETURN STATE_RF; ; 2180 END; ; 2181 ; 2182 [OTHERWISE] : ; 2183 RETURN STATE_A; ; 2184 TES; ; 2185 ; 2186 END; ! End of REC_DATA ;REC_DATA U.12: .WORD ^M ;Save R2,R3 ; 2058 MOVAB W^U.17, R3 ;U.17, R3 ; MOVAB W^U.56, R2 ;U.56, R2 ; PUSHAB B^U.68 ;U.68 ; 2108 CALLS #1, W^U.18 ;#1, U.18 ; BLBC R0, 2$ ;R0, 2$ ; MOVL 12(R2), R0 ;REC_TYPE, R0 ; 2110 CMPL R0, #68 ;R0, #68 ; BNEQ 3$ ;3$ ; MOVL 4(R2), R1 ;REC_SEQ, R1 ; 2116 CMPL (R2), R1 ;MSG_NUMBER, R1 ; BEQL 1$ ;1$ ; CMPL -8(R2), #30 ;OLD_RETRIES, #30 ; 2120 BGTR 6$ ;6$ ; INCL -8(R2) ;OLD_RETRIES ; 2122 SUBL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2124 CMPL R0, R1 ;R0, R1 ; BNEQ 6$ ;6$ ; PUSHL R1 ;R1 ; 2127 BRB 4$ ;4$ ; 1$: CALLS #0, W^U.20 ;#0, U.20 ; 2140 2$: BLBC R0, 7$ ;R0, 7$ ; PUSHL 4(R2) ;REC_SEQ ; 2142 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R3) ;#3, SEND_PACKET ; MOVL -4(R2), -8(R2) ;NUM_RETRIES, OLD_RETRIES ; 2143 CLRL -4(R2) ;NUM_RETRIES ; 2144 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2145 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; MOVL #8, R0 ;#8, R0 ; 2110 RET ; ; 3$: CMPL R0, #70 ;R0, #70 ; BNEQ 5$ ;5$ ; CMPL -8(R2), #30 ;OLD_RETRIES, #30 ; 2152 BGTR 8$ ;8$ ; INCL -8(R2) ;OLD_RETRIES ; 2154 SUBL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2156 CMPL R0, 4(R2) ;R0, REC_SEQ ; BNEQ 8$ ;8$ ; PUSHL 4(R2) ;REC_SEQ ; 2159 4$: CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R3) ;#3, SEND_PACKET ; CLRL -4(R2) ;NUM_RETRIES ; 2160 MOVL -16(R2), R0 ;STATE, R0 ; 2150 RET ; ; 5$: CMPL R0, #90 ;R0, #90 ; 2110 BNEQ 8$ ;8$ ; CMPL (R2), 4(R2) ;MSG_NUMBER, REC_SEQ ; 2171 6$: BNEQ 8$ ;8$ ; PUSHL 4(R2) ;REC_SEQ ; 2173 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R3) ;#3, SEND_PACKET ; CLRL 208(R2) ;FILE_OPEN_FLAG ; 2174 CALLS #0, W^FILE_CLOSE ;#0, FILE_CLOSE ; 2176 7$: BLBC R0, 8$ ;R0, 8$ ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2178 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; MOVL #7, R0 ;#7, R0 ; 2110 RET ; ; 8$: MOVL #10, R0 ;#10, R0 ; RET ; ; 2058 ; Routine Size: 212 bytes, Routine Base: $CODE$ + 06C4 ; 2187 %SBTTL 'CLEAR' ; 2188 ROUTINE CLEAR : NOVALUE = ; 2189 ; 2190 !++ ; 2191 ! FUNCTIONAL DESCRIPTION: ; 2192 ! ; 2193 ! This routine will clear the message buffer. ; 2194 ! ; 2195 ! CALLING SEQUENCE: ; 2196 ! ; 2197 ! CLEAR(); ; 2198 ! ; 2199 ! INPUT PARAMETERS: ; 2200 ! ; 2201 ! None. ; 2202 ! ; 2203 ! IMPLICIT INPUTS: ; 2204 ! ; 2205 ! None. ; 2206 ! ; 2207 ! OUTPUT PARAMETERS: ; 2208 ! ; 2209 ! None. ; 2210 ! ; 2211 ! IMPLICIT OUTPUTS: ; 2212 ! ; 2213 ! None. ; 2214 ! ; 2215 ! COMPLETION CODES: ; 2216 ! ; 2217 ! None. ; 2218 ! ; 2219 ! SIDE EFFECTS: ; 2220 ! ; 2221 ! None. ; 2222 ! ; 2223 !-- ; 2224 ; 2225 BEGIN ; 2226 CH$FILL (0, MAX_MSG, CH$PTR (SND_MSG, 0, CHR_SIZE)); ; 2227 END; ;CLEAR U.22: .WORD ^M ;Save R2,R3,R4,R5 ; 2188 MOVC5 #0, (SP), #0, #96, W^U.61 ;#0, (SP), #0, #96, U.61 ; 2226 RET ; ; 2188 ; Routine Size: 13 bytes, Routine Base: $CODE$ + 0798 ; 2228 %SBTTL 'Message processing -- PRS_SEND_INIT - Parse send init params' ; 2229 ; 2230 ROUTINE PRS_SEND_INIT : NOVALUE = ; 2231 !++ ; 2232 ! FUNCTIONAL DESCRIPTION: ; 2233 ! ; 2234 ! This routine will parse the SEND_INIT parameters that were sent by ; 2235 ! the remote Kermit. The items will be stored into the low segment. ; 2236 ! ; 2237 ! CALLING SEQUENCE: ; 2238 ! ; 2239 ! PRS_SEND_INIT (); ; 2240 ! ; 2241 ! INPUT PARAMETERS: ; 2242 ! ; 2243 ! None. ; 2244 ! ; 2245 ! IMPLICIT INPUTS: ; 2246 ! ; 2247 ! Message stored in REC_MSG. ; 2248 ! ; 2249 ! OUPTUT PARAMETERS: ; 2250 ! ; 2251 ! None. ; 2252 ! ; 2253 ! IMPLICIT OUTPUTS: ; 2254 ! ; 2255 ! None. ; 2256 ! ; 2257 ! COMPLETION CODES: ; 2258 ! ; 2259 ! None. ; 2260 ! ; 2261 ! SIDE EFFECTS: ; 2262 ! ; 2263 ! None. ; 2264 ! ; 2265 !-- ; 2266 ; 2267 BEGIN ; 2268 ; 2269 LOCAL ; 2270 TEMP; ; 2271 ; 2272 IF .REC_LENGTH GEQ P_SI_BUFSIZ THEN ; 2273 SND_PKT_SIZE = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_BUFSIZ, CHR_SIZE))); ; 2274 IF .REC_LENGTH GEQ P_SI_TIMOUT THEN ; 2275 SND_TIMEOUT = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_TIMOUT, CHR_SIZE))); ; 2276 IF .REC_LENGTH GEQ P_SI_NPAD THEN ; 2277 SND_NPAD = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_NPAD, CHR_SIZE))); ; 2278 IF .REC_LENGTH GEQ P_SI_PAD THEN ; 2279 SND_PADCHAR = CTL (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_PAD, CHR_SIZE))); ; 2280 IF .REC_LENGTH GEQ P_SI_EOL THEN ; 2281 SND_EOL = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_EOL, CHR_SIZE))); ; 2282 IF .REC_LENGTH GEQ P_SI_QUOTE THEN ; 2283 SND_QUOTE_CHR = CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_QUOTE, CHR_SIZE)); ; 2284 ; 2285 IF .REC_LENGTH GEQ P_SI_8QUOTE ; 2286 THEN ; 2287 SND_8QUOTE_CHR = CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_8QUOTE, ; 2288 CHR_SIZE)); ; 2289 END; ! End of PRS_SEND_INIT ;PRS_SEND_INIT U.16: .WORD ^M ;Save R2,R3 ; 2230 MOVAB W^U.58, R3 ;U.58, R3 ; MOVAB W^SND_PKT_SIZE, R2 ;SND_PKT_SIZE, R2 ; MOVL (R3), R0 ;REC_LENGTH, R0 ; 2272 BLSS 1$ ;1$ ; MOVZBL 12(R3), (R2) ;REC_MSG+4, SND_PKT_SIZE ; 2273 SUBL2 #32, (R2) ;#32, SND_PKT_SIZE ; 1$: TSTL R0 ;R0 ; 2274 BLEQ 2$ ;2$ ; MOVZBL 13(R3), 12(R2) ;REC_MSG+5, SND_TIMEOUT ; 2275 SUBL2 #32, 12(R2) ;#32, SND_TIMEOUT ; 2$: CMPL R0, #2 ;R0, #2 ; 2276 BLSS 3$ ;3$ ; MOVZBL 14(R3), 4(R2) ;REC_MSG+6, SND_NPAD ; 2277 SUBL2 #32, 4(R2) ;#32, SND_NPAD ; 3$: CMPL R0, #3 ;R0, #3 ; 2278 BLSS 4$ ;4$ ; MOVZBL 15(R3), R1 ;REC_MSG+7, R1 ; 2279 XORL3 #64, R1, 8(R2) ;#64, R1, SND_PADCHAR ; 4$: CMPL R0, #4 ;R0, #4 ; 2280 BLSS 5$ ;5$ ; MOVZBL 16(R3), 16(R2) ;REC_MSG+8, SND_EOL ; 2281 SUBL2 #32, 16(R2) ;#32, SND_EOL ; 5$: CMPL R0, #5 ;R0, #5 ; 2282 BLSS 6$ ;6$ ; MOVZBL 17(R3), 20(R2) ;REC_MSG+9, SND_QUOTE_CHR ; 2283 6$: CMPL R0, #6 ;R0, #6 ; 2285 BLSS 7$ ;7$ ; MOVZBL 18(R3), 24(R2) ;REC_MSG+10, SND_8QUOTE_CHR ; 2287 7$: RET ; ; 2230 ; Routine Size: 104 bytes, Routine Base: $CODE$ + 07A5 ; 2290 %SBTTL 'SET_SEND_INIT' ; 2291 ROUTINE SET_SEND_INIT : NOVALUE = ; 2292 ; 2293 !++ ; 2294 ! FUNCTIONAL DESCRIPTION: ; 2295 ! ; 2296 ! This routine will initialize the various parameters for the ; 2297 ! MSG_SND_INIT message. ; 2298 ! ; 2299 ! CALLING SEQUENCE: ; 2300 ! ; 2301 ! SET_SEND_INIT(); ; 2302 ! ; 2303 ! INPUT PARAMETERS: ; 2304 ! ; 2305 ! None. ; 2306 ! ; 2307 ! IMPLICIT INPUTS: ; 2308 ! ; 2309 ! None. ; 2310 ! ; 2311 ! OUTPUT PARAMETERS: ; 2312 ! ; 2313 ! None. ; 2314 ! ; 2315 ! IMPLICIT OUTPUTS: ; 2316 ! ; 2317 ! SND_MSG parameters set up. ; 2318 ! ; 2319 ! COMPLETION CODES: ; 2320 ! ; 2321 ! None. ; 2322 ! ; 2323 ! SIDE EFFECTS: ; 2324 ! ; 2325 ! None. ; 2326 ! ; 2327 !-- ; 2328 ; 2329 BEGIN ; 2330 CH$WCHAR (CHAR (.RCV_PKT_SIZE), CH$PTR (SND_MSG, PKT_MSG + P_SI_BUFSIZ, CHR_SIZE)); ; 2331 CH$WCHAR (CHAR (.RCV_TIMEOUT), CH$PTR (SND_MSG, PKT_MSG + P_SI_TIMOUT, CHR_SIZE)); ; 2332 CH$WCHAR (CHAR (.RCV_NPAD), CH$PTR (SND_MSG, PKT_MSG + P_SI_NPAD, CHR_SIZE)); ; 2333 CH$WCHAR (CTL (.RCV_PADCHAR), CH$PTR (SND_MSG, PKT_MSG + P_SI_PAD, CHR_SIZE)); ; 2334 CH$WCHAR (CHAR (.RCV_EOL), CH$PTR (SND_MSG, PKT_MSG + P_SI_EOL, CHR_SIZE)); ; 2335 CH$WCHAR (.RCV_QUOTE_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_QUOTE, CHR_SIZE)); ; 2336 CH$WCHAR (.RCV_8QUOTE_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_8QUOTE, CHR_SIZE)); ; 2337 END; ! End of SET_SEND_INIT ;SET_SEND_INIT U.15: .WORD ^M ;Save R2,R3 ; 2291 MOVAB W^RCV_PKT_SIZE, R3 ;RCV_PKT_SIZE, R3 ; MOVAB W^U.61+4, R2 ;U.61+4, R2 ; ADDB3 #32, (R3), (R2) ;#32, RCV_PKT_SIZE, SND_MSG+4 ; 2330 ADDB3 #32, 12(R3), 1(R2) ;#32, RCV_TIMEOUT, SND_MSG+5 ; 2331 ADDB3 #32, 4(R3), 2(R2) ;#32, RCV_NPAD, SND_MSG+6 ; 2332 XORB3 #64, 8(R3), 3(R2) ;#64, RCV_PADCHAR, SND_MSG+7 ; 2333 ADDB3 #32, 16(R3), 4(R2) ;#32, RCV_EOL, SND_MSG+8 ; 2334 MOVB 20(R3), 5(R2) ;RCV_QUOTE_CHR, SND_MSG+9 ; 2335 MOVB 24(R3), 6(R2) ;RCV_8QUOTE_CHR, SND_MSG+10 ; 2336 RET ; ; 2291 ; Routine Size: 52 bytes, Routine Base: $CODE$ + 080D ; 2338 %SBTTL 'SEND_PACKET' ; 2339 ROUTINE SEND_PACKET (TYPE, LENGTH, MN) = ; 2340 ; 2341 !++ ; 2342 ! FUNCTIONAL DESCRIPTION: ; 2343 ! ; 2344 ! This routine will cause a packet to be sent over the line ; 2345 ! that has been opened by OPEN_TERMINAL. ; 2346 ! ; 2347 ! CALLING SEQUENCE: ; 2348 ! ; 2349 ! SEND_PACKET(Type, Length); ; 2350 ! ; 2351 ! INPUT PARAMETERS: ; 2352 ! ; 2353 ! TYPE - Type of packet to send. ; 2354 ! ; 2355 ! LENGTH - Length of the packet being sent. ; 2356 ! ; 2357 ! IMPLICIT INPUTS: ; 2358 ! ; 2359 ! None. ; 2360 ! ; 2361 ! OUTPUT PARAMETERS: ; 2362 ! ; 2363 ! None. ; 2364 ! ; 2365 ! IMPLICIT OUTPUTS: ; 2366 ! ; 2367 ! None. ; 2368 ! ; 2369 ! COMPLETION CODES: ; 2370 ! ; 2371 ! None. ; 2372 ! ; 2373 ! SIDE EFFECTS: ; 2374 ! ; 2375 ! None. ; 2376 ! ; 2377 !-- ; 2378 ; 2379 BEGIN ; 2380 ; 2381 LOCAL ; 2382 FILLER : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ; 2383 CHKSUM, ! Checksum for the message we calculate ; 2384 POINTER; ! Pointer to the information in the message ; 2385 ; 2386 ! ; 2387 ! Do any filler processing that the remote KERMIT requires. ; 2388 ! ; 2389 ; 2390 IF .SND_NPAD NEQ 0 ; 2391 THEN ; 2392 BEGIN ; 2393 CH$FILL (.SND_PADCHAR, MAX_MSG, CH$PTR (FILLER, 0, CHR_SIZE)); ; 2394 SEND (FILLER, .SND_NPAD); ; 2395 END; ; 2396 ; 2397 ! ; 2398 ! Store the header information into the message. ; 2399 ! ; 2400 CH$WCHAR (.TYPE, CH$PTR (SND_MSG, PKT_TYPE, CHR_SIZE)); ; 2401 CH$WCHAR (CHR_SOH, CH$PTR (SND_MSG, PKT_MARK, CHR_SIZE)); ; 2402 CH$WCHAR (CHAR (.LENGTH + PKT_OVR_HEAD), CH$PTR (SND_MSG, PKT_COUNT, CHR_SIZE)); ; 2403 CH$WCHAR (CHAR (.MN), CH$PTR (SND_MSG, PKT_SEQ, CHR_SIZE)); ; 2404 ! ; 2405 ! Do the initial checksum calculation and set up the pointer to read cahracters ; 2406 ! from the message dependent part of the message ; 2407 ! ; 2408 CHKSUM = CHAR (.LENGTH + PKT_OVR_HEAD) + CHAR (.MN) + .TYPE; ; 2409 POINTER = CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE); ; 2410 ! ; 2411 ! Loop through the message dependent information adding the characters to ; 2412 ! the total checksum ; 2413 ! ; 2414 ; 2415 IF .LENGTH NEQ 0 ; 2416 THEN ; 2417 ; 2418 INCR I FROM 1 TO .LENGTH DO ; 2419 CHKSUM = .CHKSUM + CH$RCHAR_A (POINTER); ; 2420 ; 2421 ! ; 2422 ! Do the final checksum calculation ; 2423 ! ; 2424 CHKSUM = (.CHKSUM + (.CHKSUM AND %O'300')/%O'100') AND %O'77'; ; 2425 ! ; 2426 ! Store the checksum into the message ; 2427 ! ; 2428 CH$WCHAR_A (CHAR (.CHKSUM), POINTER); ; 2429 ! ; 2430 ! Store in the end of line character ; 2431 ! ; 2432 CH$WCHAR_A (.SND_EOL, POINTER); ; 2433 ! ; 2434 ! If we are debugging then type out the message we are sending. ; 2435 ! ; 2436 DBG_SEND (SND_MSG, (.LENGTH + PKT_TOT_OVR_HEAD)); ; 2437 ! ; 2438 ! Now call the O/S routine to send the message out to the remote KERMIT ; 2439 ! ; 2440 RETURN SEND (SND_MSG, .LENGTH + PKT_TOT_OVR_HEAD); ; 2441 END; ! End of SEND_PACKET ;SEND_PACKET U.17: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 ; 2339 MOVAB W^U.61, R7 ;U.61, R7 ; MOVAB -96(SP), SP ;-96(SP), SP ; MOVL W^SND_NPAD, R6 ;SND_NPAD, R6 ; 2390 BEQL 1$ ;1$ ; MOVC5 #0, (SP), W^SND_PADCHAR, #96, (SP) ;#0, (SP), SND_PADCHAR, #96, FILLER ; 2393 PUSHL R6 ;R6 ; 2394 PUSHAB 4(SP) ;FILLER ; CALLS #2, W^SEND ;#2, SEND ; 1$: MOVB 4(AP), 3(R7) ;TYPE, SND_MSG+3 ; 2400 MOVB #1, (R7) ;#1, SND_MSG ; 2401 MOVL 8(AP), R2 ;LENGTH, R2 ; 2402 ADDB3 #35, R2, 1(R7) ;#35, R2, SND_MSG+1 ; ADDB3 #32, 12(AP), 2(R7) ;#32, MN, SND_MSG+2 ; 2403 ADDL3 12(AP), R2, R0 ;MN, R2, R0 ; 2379 ADDL2 4(AP), R0 ;TYPE, R0 ; MOVAB 67(R0), R1 ;67(R0), CHKSUM ; 2408 MOVAB 4(R7), R3 ;SND_MSG+4, POINTER ; 2409 TSTL R2 ;R2 ; 2415 BEQL 4$ ;4$ ; CLRL R0 ;I ; 2418 BRB 3$ ;3$ ; 2$: MOVZBL (R3)+, R4 ;(POINTER)+, R4 ; 2419 ADDL2 R4, R1 ;R4, CHKSUM ; 3$: AOBLEQ R2, R0, 2$ ;R2, I, 2$ ; 2418 4$: BICL3 #-193, R1, R0 ;#-193, CHKSUM, R0 ; 2424 DIVL2 #64, R0 ;#64, R0 ; ADDL2 R1, R0 ;CHKSUM, R0 ; EXTZV #0, #6, R0, R1 ;#0, #6, R0, CHKSUM ; ADDB3 #32, R1, (R3)+ ;#32, CHKSUM, (POINTER)+ ; 2428 MOVB W^SND_EOL, (R3)+ ;SND_EOL, (POINTER)+ ; 2432 PUSHAB 6(R2) ;6(R2) ; 2436 PUSHL R7 ;R7 ; CALLS #2, W^U.24 ;#2, U.24 ; PUSHAB 6(R2) ;6(R2) ; 2440 PUSHL R7 ;R7 ; CALLS #2, W^SEND ;#2, SEND ; RET ; ; 2339 ; Routine Size: 149 bytes, Routine Base: $CODE$ + 0841 ; 2442 %SBTTL 'REC_MESSAGE - Receive a message' ; 2443 ROUTINE REC_MESSAGE (CHK_ROUTINE) = ; 2444 ; 2445 !++ ; 2446 ! FUNCTIONAL DESCRIPTION: ; 2447 ! ; 2448 ! This routine will handle the retry processing for the various ; 2449 ! messages that can be received. ; 2450 ! ; 2451 ! CALLING SEQUENCE: ; 2452 ! ; 2453 ! INPUT PARAMETERS: ; 2454 ! ; 2455 ! None. ; 2456 ! ; 2457 ! IMPLICIT INPUTS: ; 2458 ! ; 2459 ! None. ; 2460 ! ; 2461 ! OUPTUT PARAMETERS: ; 2462 ! ; 2463 ! None. ; 2464 ! ; 2465 ! IMPLICIT OUTPUTS: ; 2466 ! ; 2467 ! None. ; 2468 ! ; 2469 ! COMPLETION CODES: ; 2470 ! ; 2471 ! KER_NORMAL - Normal return ; 2472 ! KER_RETRIES - Too many retries ; 2473 ! (What ever REC_PACKET returns). ; 2474 ! ; 2475 ! SIDE EFFECTS: ; 2476 ! ; 2477 ! None. ; 2478 ! ; 2479 !-- ; 2480 ; 2481 BEGIN ; 2482 ; 2483 LOCAL ; 2484 STATUS; ! Status returned by lower level routines ; 2485 ; 2486 RETURN ; 2487 ; 2488 WHILE TRUE DO ; 2489 BEGIN ; 2490 ; 2491 IF .NUM_RETRIES GTR MAX_RETRIES THEN RETURN KER_RETRIES; ; 2492 ; 2493 NUM_RETRIES = .NUM_RETRIES + 1; ; 2494 STATUS = REC_PACKET (); ; 2495 ; 2496 IF NOT .STATUS AND .STATUS NEQ KER_CHKSUMERR THEN EXITLOOP .STATUS; ; 2497 ; 2498 IF NOT .STATUS ; 2499 THEN ; 2500 SEND_PACKET (MSG_NAK, 0, .MSG_NUMBER - 1) ; 2501 ELSE ; 2502 BEGIN ; 2503 ; 2504 IF NOT (.CHK_ROUTINE) () THEN SEND_PACKET (MSG_NAK, 0, .REC_SEQ) ELSE EXITLOOP KER_NORMAL; ; 2505 ; 2506 END; ; 2507 ; 2508 END; ; 2509 ; 2510 END; ! End of REC_PARSE ;REC_MESSAGE U.18: .WORD ^M ;Save R2,R3 ; 2443 MOVAB W^U.55, R3 ;U.55, R3 ; 1$: CMPL (R3), #30 ;NUM_RETRIES, #30 ; 2491 BLEQ 2$ ;2$ ; MOVL #134316170, R0 ;#134316170, R0 ; RET ; ; 2$: INCL (R3) ;NUM_RETRIES ; 2493 CALLS #0, W^U.19 ;#0, U.19 ; 2494 MOVL R0, R2 ;R0, STATUS ; BLBS R2, 4$ ;STATUS, 4$ ; 2496 CMPL R2, #134316154 ;STATUS, #134316154 ; BEQL 3$ ;3$ ; MOVL R2, R0 ;STATUS, R0 ; RET ; ; 3$: BLBS R2, 4$ ;STATUS, 4$ ; 2498 SUBL3 #1, 4(R3), -(SP) ;#1, MSG_NUMBER, -(SP) ; 2500 BRB 5$ ;5$ ; 4$: CALLS #0, @4(AP) ;#0, @CHK_ROUTINE ; 2504 BLBS R0, 6$ ;R0, 6$ ; PUSHL 8(R3) ;REC_SEQ ; 5$: CLRL -(SP) ;-(SP) ; MOVZBL #78, -(SP) ;#78, -(SP) ; CALLS #3, W^U.17 ;#3, U.17 ; BRB 1$ ;1$ ; 6$: MOVL #134316043, R0 ;#134316043, R0 ; RET ; ; 2443 ; Routine Size: 87 bytes, Routine Base: $CODE$ + 08D6 ; 2511 %SBTTL 'REC_PACKET' ; 2512 ROUTINE REC_PACKET = ; 2513 ; 2514 !++ ; 2515 ! FUNCTIONAL DESCRIPTION: ; 2516 ! ; 2517 ! This routine will do the oppoiste of SEND_PACKET. It will wait ; 2518 ! for the message to be read from the remote and then it will ; 2519 ! check the message for validity. ; 2520 ! ; 2521 ! CALLING SEQUENCE: ; 2522 ! ; 2523 ! Flag = REC_PACKET(); ; 2524 ! ; 2525 ! INPUT PARAMETERS: ; 2526 ! ; 2527 ! None. ; 2528 ! ; 2529 ! IMPLICIT INPUTS: ; 2530 ! ; 2531 ! None. ; 2532 ! ; 2533 ! OUTPUT PARAMETERS: ; 2534 ! ; 2535 ! None. ; 2536 ! ; 2537 ! IMPLICIT OUTPUTS: ; 2538 ! ; 2539 ! REC_MSG - Contains the message received. ; 2540 ! ; 2541 ! COMPLETION CODES: ; 2542 ! ; 2543 ! True - Packet receive ok. ; 2544 ! False - Problem occured during the receiving of the packet. ; 2545 ! ; 2546 ! SIDE EFFECTS: ; 2547 ! ; 2548 ! None. ; 2549 ! ; 2550 !-- ; 2551 ; 2552 BEGIN ; 2553 ; 2554 BIND ; 2555 ATTEMPT_TEXT = UPLIT (%ASCIZ'Attempting to receive'); ; 2556 ; 2557 LOCAL ; 2558 BUFFER : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ; 2559 ERR_BUFFER : VECTOR [CH$ALLOCATION (MAX_MSG)], ; 2560 STATUS, ! Status returned by RECEIVE ; 2561 MSG_LENGTH, ; 2562 ERR_POINTER, ! Pointer to the error buffer ; 2563 POINTER, ; 2564 OLD_POINTER, ! Character pointer to the data section ; 2565 NEW_POINTER, ; 2566 CHKSUM; ! Checksum of the message ; 2567 ; 2568 ! ; 2569 ! Attempt to read the message from the remote. ; 2570 ! ; 2571 ; 2572 DO ; 2573 BEGIN ; 2574 ; 2575 IF .DEBUG_FLAG AND NOT .CONNECT_FLAG ; 2576 THEN ; 2577 BEGIN ; 2578 TT_TEXT (ATTEMPT_TEXT); ; 2579 TT_CRLF (); ; 2580 END; ; 2581 ; 2582 STATUS = RECEIVE (BUFFER, MSG_LENGTH); ; 2583 ; 2584 IF NOT .STATUS THEN RETURN .STATUS; ; 2585 ; 2586 IF .MSG_LENGTH EQL 0 THEN RETURN KER_PROTOERR; ; 2587 ; 2588 OLD_POINTER = CH$PTR (BUFFER, 0, CHR_SIZE); ; 2589 NEW_POINTER = CH$FIND_CH (.MSG_LENGTH, .OLD_POINTER, CHR_SOH); ; 2590 ; 2591 WHILE TRUE DO ; 2592 ; 2593 IF CH$FAIL (.NEW_POINTER) EQL 0 ; 2594 THEN ; 2595 BEGIN ; 2596 MSG_LENGTH = .MSG_LENGTH - CH$DIFF (.NEW_POINTER, .OLD_POINTER); ; 2597 ; 2598 IF .MSG_LENGTH EQL 0 THEN EXITLOOP; ; 2599 ; 2600 OLD_POINTER = .NEW_POINTER; ; 2601 NEW_POINTER = CH$FIND_CH (.MSG_LENGTH, CH$PLUS (.OLD_POINTER, 1), CHR_SOH); ; 2602 END ; 2603 ELSE ; 2604 EXITLOOP; ; 2605 ; 2606 END ; 2607 UNTIL .MSG_LENGTH NEQ 0; ; 2608 ; 2609 CH$MOVE (.MSG_LENGTH, .OLD_POINTER, CH$PTR (REC_MSG, 0, CHR_SIZE)); ; 2610 ! ; 2611 ! Initialize the checksum and others ; 2612 ! ; 2613 REC_TYPE = CH$RCHAR (CH$PTR (REC_MSG, PKT_TYPE, CHR_SIZE)); ; 2614 CHKSUM = CH$RCHAR (CH$PTR (REC_MSG, PKT_COUNT, CHR_SIZE)) + CH$RCHAR (CH$PTR (REC_MSG, PKT_SEQ, CHR_SIZE)) ; 2615 + .REC_TYPE; ; 2616 ! ; 2617 ! Now break the message apart byte by byte. ; 2618 ! ; 2619 REC_LENGTH = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_COUNT, CHR_SIZE))) - PKT_OVR_HEAD; ; 2620 REC_SEQ = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_SEQ, CHR_SIZE))); ; 2621 ! ; 2622 ! Now compute the final checksum and make sure that it is identical ; 2623 ! to what we received from the remote KERMIT ; 2624 ! ; 2625 POINTER = CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE); ; 2626 ; 2627 INCR I FROM 1 TO .REC_LENGTH DO ; 2628 CHKSUM = .CHKSUM + CH$RCHAR_A (POINTER); ; 2629 ; 2630 CHKSUM = (.CHKSUM + (.CHKSUM AND %O'300')/%O'100') AND %O'77'; ; 2631 ; 2632 IF .CHKSUM NEQ UNCHAR (CH$RCHAR_A (POINTER)) THEN RETURN KER_CHKSUMERR; ; 2633 ; 2634 ! ; 2635 ! Typed the packet if we are debugging ; 2636 ! ; 2637 DBG_RECEIVE (REC_MSG); ; 2638 ! ; 2639 ! Now check to see if we have an E type (Error) packet. ; 2640 ! ; 2641 ; 2642 IF .REC_TYPE NEQ MSG_ERROR THEN RETURN KER_NORMAL; ; 2643 ; 2644 ! ; 2645 ! Here to process an error packet. Call the user routine to output the ; 2646 ! error message to the terminal. ; 2647 ! ; 2648 ERR_POINTER = CH$PTR (ERR_BUFFER); ; 2649 POINTER = CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE); ; 2650 ; 2651 INCR I FROM 1 TO .REC_LENGTH DO ; 2652 CH$WCHAR_A (CH$RCHAR_A (POINTER), ERR_POINTER); ; 2653 ; 2654 CH$WCHAR (CHR_NUL, ERR_POINTER); ; 2655 TT_TEXT (ERR_BUFFER); ; 2656 RETURN KER_ERRMSG; ; 2657 END; ! End of REC_PACKET .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAA: .ASCII \Attempting to receive\<0><0><0> ; ; U.69= P.AAA .PSECT $CODE$,NOWRT,2 ;REC_PACKET U.19: .WORD ^M ;Save R2,R3,R4,R5,R6 ; 2512 MOVAB W^U.58, R6 ;U.58, R6 ; MOVAB -196(SP), SP ;-196(SP), SP ; 1$: BLBC W^DEBUG_FLAG, 2$ ;DEBUG_FLAG, 2$ ; 2575 BLBS W^CONNECT_FLAG, 2$ ;CONNECT_FLAG, 2$ ; PUSHAB W^U.69 ;U.69 ; 2578 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 2579 2$: PUSHL SP ;SP ; 2582 PUSHAB 104(SP) ;BUFFER ; CALLS #2, W^RECEIVE ;#2, RECEIVE ; MOVL R0, R4 ;R0, STATUS ; BLBS R4, 3$ ;STATUS, 3$ ; 2584 MOVL R4, R0 ;STATUS, R0 ; RET ; ; 3$: TSTL (SP) ;MSG_LENGTH ; 2586 BNEQ 4$ ;4$ ; MOVL #134316202, R0 ;#134316202, R0 ; RET ; ; 4$: MOVAB 100(SP), R2 ;BUFFER, OLD_POINTER ; 2588 LOCC #1, (SP), (R2) ;#1, MSG_LENGTH, (OLD_POINTER) ; 2589 BNEQ 6$ ;6$ ; 5$: CLRL R1 ;R1 ; 6$: MOVL R1, R3 ;R1, NEW_POINTER ; CLRL R0 ;R0 ; 2593 TSTL R3 ;NEW_POINTER ; BNEQ 7$ ;7$ ; INCL R0 ;R0 ; 7$: TSTL R0 ;R0 ; BNEQ 8$ ;8$ ; SUBL3 R3, R2, R0 ;NEW_POINTER, OLD_POINTER, R0 ; 2596 ADDL2 R0, (SP) ;R0, MSG_LENGTH ; BEQL 8$ ;8$ ; 2598 MOVL R3, R2 ;NEW_POINTER, OLD_POINTER ; 2600 LOCC #1, (SP), 1(R2) ;#1, MSG_LENGTH, 1(OLD_POINTER) ; 2601 BEQL 5$ ;5$ ; BRB 6$ ;6$ ; 8$: TSTL (SP) ;MSG_LENGTH ; 2607 BEQL 1$ ;1$ ; MOVC3 (SP), (R2), 8(R6) ;MSG_LENGTH, (OLD_POINTER), REC_MSG ; 2609 MOVZBL 11(R6), 4(R6) ;REC_MSG+3, REC_TYPE ; 2613 MOVZBL 9(R6), R0 ;REC_MSG+1, R0 ; 2614 MOVZBL 10(R6), R1 ;REC_MSG+2, R1 ; ADDL2 R1, R0 ;R1, R0 ; ADDL3 4(R6), R0, R1 ;REC_TYPE, R0, CHKSUM ; 2615 MOVZBL 9(R6), (R6) ;REC_MSG+1, REC_LENGTH ; 2619 SUBL2 #35, (R6) ;#35, REC_LENGTH ; MOVZBL 10(R6), -4(R6) ;REC_MSG+2, REC_SEQ ; 2620 SUBL2 #32, -4(R6) ;#32, REC_SEQ ; MOVAB 12(R6), R3 ;REC_MSG+4, POINTER ; 2625 CLRL R0 ;I ; 2627 BRB 10$ ;10$ ; 9$: MOVZBL (R3)+, R2 ;(POINTER)+, R2 ; 2628 ADDL2 R2, R1 ;R2, CHKSUM ; 10$: AOBLEQ (R6), R0, 9$ ;REC_LENGTH, I, 9$ ; 2627 BICL3 #-193, R1, R0 ;#-193, CHKSUM, R0 ; 2630 DIVL2 #64, R0 ;#64, R0 ; ADDL2 R1, R0 ;CHKSUM, R0 ; EXTZV #0, #6, R0, R1 ;#0, #6, R0, CHKSUM ; MOVZBL (R3)+, R0 ;(POINTER)+, R0 ; 2632 SUBL2 #32, R0 ;#32, R0 ; CMPL R1, R0 ;CHKSUM, R0 ; BEQL 11$ ;11$ ; MOVL #134316154, R0 ;#134316154, R0 ; RET ; ; 11$: PUSHAB 8(R6) ;REC_MSG ; 2637 CALLS #1, W^U.25 ;#1, U.25 ; CMPL 4(R6), #69 ;REC_TYPE, #69 ; 2642 BEQL 12$ ;12$ ; MOVL #134316043, R0 ;#134316043, R0 ; RET ; ; 12$: MOVAB 4(SP), R0 ;ERR_BUFFER, ERR_POINTER ; 2648 MOVAB 12(R6), R3 ;REC_MSG+4, POINTER ; 2649 CLRL R1 ;I ; 2651 BRB 14$ ;14$ ; 13$: MOVB (R3)+, (R0)+ ;(POINTER)+, (ERR_POINTER)+ ; 2652 14$: AOBLEQ (R6), R1, 13$ ;REC_LENGTH, I, 13$ ; 2651 CLRB R0 ;ERR_POINTER ; 2654 PUSHAB 4(SP) ;ERR_BUFFER ; 2655 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; MOVL #134316146, R0 ;#134316146, R0 ; 2552 RET ; ; 2512 ; Routine Size: 285 bytes, Routine Base: $CODE$ + 092D ; 2658 %SBTTL 'Buffer filling -- Main routine' ; 2659 ROUTINE BFR_FILL = ; 2660 ; 2661 !++ ; 2662 ! FUNCTIONAL DESCRIPTION: ; 2663 ! ; 2664 ! This routine will fill the buffer with data from the file. It ; 2665 ! will do all the quoting that is required. ; 2666 ! ; 2667 ! CALLING SEQUENCE: ; 2668 ! ; 2669 ! EOF_FLAG = BFR_FILL(); ; 2670 ! ; 2671 ! INPUT PARAMETERS: ; 2672 ! ; 2673 ! None. ; 2674 ! ; 2675 ! IMPLICIT INPUTS: ; 2676 ! ; 2677 ! None. ; 2678 ! ; 2679 ! OUTPUT PARAMETERS: ; 2680 ! ; 2681 ! True - Buffer filled may be at end of file. ; 2682 ! False - At end of file. ; 2683 ! ; 2684 ! IMPLICIT OUTPUTS: ; 2685 ! ; 2686 ! Number of characters stored in the buffer. ; 2687 ! ; 2688 ! COMPLETION CODES: ; 2689 ! ; 2690 ! None. ; 2691 ! ; 2692 ! SIDE EFFECTS: ; 2693 ! ; 2694 ! None. ; 2695 ! ; 2696 !-- ; 2697 ; 2698 BEGIN ; 2699 ; 2700 LOCAL ; 2701 STATUS, ! Status returned by GET_FILE ; 2702 CHARACTER, ! Character read from the file ; 2703 POINTER; ! Pointer into the message buffer ; 2704 ; 2705 ! ; 2706 ! Initialize the variables ; 2707 ! ; 2708 SIZE = 0; ; 2709 POINTER = CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE); ; 2710 ! ; 2711 ! Loop getting characters from the file ; 2712 ! ; 2713 ; 2714 WHILE (STATUS = GET_FILE (CHARACTER)) EQL KER_NORMAL DO ; 2715 BEGIN ; 2716 ; 2717 ! ; 2718 ! Determine if this is a character that must be quoted. ; 2719 ! ; 2720 ; 2721 IF ((.CHARACTER AND %O'177') LSS %C' ') ; 2722 OR ((.CHARACTER AND %O'177') EQL CHR_DEL) ; 2723 OR ((.CHARACTER AND %O'177') EQL .SND_QUOTE_CHR) ; 2724 THEN ; 2725 BEGIN ; 2726 SIZE = .SIZE + 1; ; 2727 CH$WCHAR_A (.SND_QUOTE_CHR, POINTER); ; 2728 ; 2729 IF ((.CHARACTER AND %O'177') NEQ .SND_QUOTE_CHR) THEN CHARACTER = CTL (.CHARACTER); ; 2730 ; 2731 END; ; 2732 ; 2733 ! ; 2734 ! Now write the character into the buffer. ; 2735 ! ; 2736 SIZE = .SIZE + 1; ; 2737 CH$WCHAR_A (.CHARACTER, POINTER); ; 2738 ; 2739 IF (.SIZE GEQ .SND_PKT_SIZE - PKT_TOT_OVR_HEAD - 2) THEN EXITLOOP; ; 2740 ; 2741 END; ; 2742 ; 2743 ! ; 2744 ! Determine if we really stored anything into the buffer. ; 2745 ! ; 2746 ; 2747 IF .SIZE NEQ 0 THEN RETURN KER_NORMAL ELSE RETURN .STATUS; ; 2748 ; 2749 END; ! End of BFR_FILL ;BFR_FILL U.21: .WORD ^M ;Save R2,R3,R4 ; 2659 MOVAB W^SND_QUOTE_CHR, R4 ;SND_QUOTE_CHR, R4 ; MOVAB W^U.53, R3 ;U.53, R3 ; SUBL2 #4, SP ;#4, SP ; CLRL (R3) ;SIZE ; 2708 MOVAB 128(R3), R2 ;SND_MSG+4, POINTER ; 2709 1$: PUSHL SP ;SP ; 2714 CALLS #1, W^GET_FILE ;#1, GET_FILE ; CMPL R0, #134316043 ;STATUS, #134316043 ; BNEQ 4$ ;4$ ; CMPZV #0, #7, (SP), #32 ;#0, #7, CHARACTER, #32 ; 2721 BLSS 2$ ;2$ ; CMPZV #0, #7, (SP), #127 ;#0, #7, CHARACTER, #127 ; 2722 BEQL 2$ ;2$ ; CMPZV #0, #7, (SP), (R4) ;#0, #7, CHARACTER, SND_QUOTE_CHR ; 2723 BNEQ 3$ ;3$ ; 2$: INCL (R3) ;SIZE ; 2726 MOVB (R4), (R2)+ ;SND_QUOTE_CHR, (POINTER)+ ; 2727 CMPZV #0, #7, (SP), (R4) ;#0, #7, CHARACTER, SND_QUOTE_CHR ; 2729 BEQL 3$ ;3$ ; XORB2 #64, (SP) ;#64, CHARACTER ; 3$: INCL (R3) ;SIZE ; 2736 MOVB (SP), (R2)+ ;CHARACTER, (POINTER)+ ; 2737 SUBL3 #8, -20(R4), R1 ;#8, SND_PKT_SIZE, R1 ; 2739 CMPL (R3), R1 ;SIZE, R1 ; BLSS 1$ ;1$ ; 4$: TSTL (R3) ;SIZE ; 2747 BEQL 5$ ;5$ ; MOVL #134316043, R0 ;#134316043, R0 ; 2698 5$: RET ; ; 2659 ; Routine Size: 106 bytes, Routine Base: $CODE$ + 0A4A ; 2750 %SBTTL 'Buffer filling -- Parity routine' ; 2751 ; 2752 ROUTINE PARITY (CHARACTER) = ; 2753 ; 2754 !++ ; 2755 ! FUNCTIONAL DESCRIPTION: ; 2756 ! ; 2757 ! This routine will add parity to the character that is supplied. ; 2758 ! ; 2759 ! CALLING SEQUENCE: ; 2760 ! ; 2761 ! CHARACTER = PARITY(CHARACTER) ; 2762 ! ; 2763 ! INPUT PARAMETERS: ; 2764 ! ; 2765 ! CHARACTER - Produce the parity for this character depending on the ; 2766 ! setting of the SET PARITY switch. ; 2767 ! ; 2768 ! IMPLICIT INPUTS: ; 2769 ! ; 2770 ! None. ; 2771 ! ; 2772 ! OUPTUT PARAMETERS: ; 2773 ! ; 2774 ! None. ; 2775 ! ; 2776 ! IMPLICIT OUTPUTS: ; 2777 ! ; 2778 ! None. ; 2779 ! ; 2780 ! COMPLETION CODES: ; 2781 ! ; 2782 ! None. ; 2783 ! ; 2784 ! SIDE EFFECTS: ; 2785 ! ; 2786 ! None. ; 2787 ! ; 2788 !-- ; 2789 ; 2790 BEGIN ; 2791 ; 2792 LOCAL ; 2793 TEMP_CHAR; ; 2794 ; 2795 CASE .PARITY_TYPE FROM PAR_MIN TO PAR_MAX OF ; 2796 SET ; 2797 [PAR_NONE] : ; 2798 RETURN .CHARACTER AND %O'177'; ; 2799 ; 2800 [PAR_MARK] : ; 2801 RETURN (.CHARACTER AND %O'177') OR %O'200'; ; 2802 ; 2803 [PAR_ODD] : ; 2804 BEGIN ; 2805 TEMP_CHAR = .CHARACTER AND %O'177' OR %O'200'; ; 2806 TEMP_CHAR = .TEMP_CHAR<0, 4> XOR .TEMP_CHAR <4, 4>; ; 2807 TEMP_CHAR = .TEMP_CHAR<0, 2> XOR .TEMP_CHAR <2, 2>; ; 2808 IF .TEMP_CHAR EQL %B'01' OR .TEMP_CHAR EQL %B'10' THEN ; 2809 RETURN .CHARACTER AND %O'177' OR %O'200' ; 2810 ELSE ; 2811 RETURN .CHARACTER AND %O'177'; ; 2812 END; ; 2813 ; 2814 [PAR_EVEN] : ; 2815 BEGIN ; 2816 TEMP_CHAR = .CHARACTER AND %O'177'; ; 2817 TEMP_CHAR = .TEMP_CHAR<0, 4> XOR .TEMP_CHAR <4, 4>; ; 2818 TEMP_CHAR = .TEMP_CHAR<0, 2> XOR .TEMP_CHAR <2, 2>; ; 2819 IF .TEMP_CHAR EQL %B'01' OR .TEMP_CHAR EQL %B'10' THEN ; 2820 RETURN .CHARACTER AND %O'177' OR %O'200' ; 2821 ELSE ; 2822 RETURN .CHARACTER AND %O'177'; ; 2823 END; ; 2824 TES; ; 2825 END; ! End of PARITY ;PARITY U.70: .WORD ^M ;Save R2,R3 ; 2752 MOVL 4(AP), R1 ;CHARACTER, R1 ; 2798 CASEL W^PARITY_TYPE, #0, #3 ;PARITY_TYPE, #0, #3 ; 2790 1$: .WORD 5$-1$,- ;5$-1$,- ; 4$-1$,- ;4$-1$,- ; 3$-1$,- ;3$-1$,- ; 2$-1$ ;2$-1$ ; BRB 5$ ;5$ ; 2$: EXTZV #0, #7, R1, R0 ;#0, #7, R1, R0 ; 2805 INSV #1, #7, #1, R0 ;#1, #7, #1, R0 ; MOVL R0, R2 ;R0, TEMP_CHAR ; EXTZV #0, #4, R2, R3 ;#0, #4, TEMP_CHAR, R3 ; 2806 EXTZV #4, #4, R2, R2 ;#4, #4, TEMP_CHAR, TEMP_CHAR ; XORL2 R3, R2 ;R3, TEMP_CHAR ; EXTZV #0, #2, R2, R3 ;#0, #2, TEMP_CHAR, R3 ; 2807 EXTZV #2, #2, R2, R2 ;#2, #2, TEMP_CHAR, TEMP_CHAR ; XORL2 R3, R2 ;R3, TEMP_CHAR ; CMPL R2, #1 ;TEMP_CHAR, #1 ; 2808 BEQL 6$ ;6$ ; CMPL R2, #2 ;TEMP_CHAR, #2 ; BNEQ 5$ ;5$ ; RET ; ; 2804 3$: EXTZV #0, #7, R1, R2 ;#0, #7, R1, TEMP_CHAR ; 2816 EXTZV #0, #4, R2, R0 ;#0, #4, TEMP_CHAR, R0 ; 2817 EXTZV #4, #4, R2, R2 ;#4, #4, TEMP_CHAR, TEMP_CHAR ; XORL2 R0, R2 ;R0, TEMP_CHAR ; EXTZV #0, #2, R2, R0 ;#0, #2, TEMP_CHAR, R0 ; 2818 EXTZV #2, #2, R2, R2 ;#2, #2, TEMP_CHAR, TEMP_CHAR ; XORL2 R0, R2 ;R0, TEMP_CHAR ; CMPL R2, #1 ;TEMP_CHAR, #1 ; 2819 BEQL 4$ ;4$ ; CMPL R2, #2 ;TEMP_CHAR, #2 ; BNEQ 5$ ;5$ ; 4$: EXTZV #0, #7, R1, R0 ;#0, #7, R1, R0 ; 2820 INSV #1, #7, #1, R0 ;#1, #7, #1, R0 ; RET ; ; 2815 5$: EXTZV #0, #7, R1, R0 ;#0, #7, R1, R0 ; 6$: RET ; ; 2752 ; Routine Size: 130 bytes, Routine Base: $CODE$ + 0AB4 ; 2826 %SBTTL 'BFR_EMPTY' ; 2827 ROUTINE BFR_EMPTY = ; 2828 ; 2829 !++ ; 2830 ! FUNCTIONAL DESCRIPTION: ; 2831 ! ; 2832 ! This routine will empty the data from the REC_MSG message buffer ; 2833 ! to the file. It will process quoting characters. ; 2834 ! ; 2835 ! CALLING SEQUENCE: ; 2836 ! ; 2837 ! Flag = BFR_EMPTY(); ; 2838 ! ; 2839 ! INPUT PARAMETERS: ; 2840 ! ; 2841 ! None. ; 2842 ! ; 2843 ! IMPLICIT INPUTS: ; 2844 ! ; 2845 ! None. ; 2846 ! ; 2847 ! OUTPUT PARAMETERS: ; 2848 ! ; 2849 ! True - No problems writing the file. ; 2850 ! False - I/O error writing the file. ; 2851 ! ; 2852 ! IMPLICIT OUTPUTS: ; 2853 ! ; 2854 ! None. ; 2855 ! ; 2856 ! COMPLETION CODES: ; 2857 ! ; 2858 ! None. ; 2859 ! ; 2860 ! SIDE EFFECTS: ; 2861 ! ; 2862 ! None. ; 2863 ! ; 2864 !-- ; 2865 ; 2866 BEGIN ; 2867 ; 2868 LOCAL ; 2869 STATUS, ! Status returned by PUT_FILE ; 2870 COUNTER, ! Count of the characters left ; 2871 CHARACTER, ! Character we are processing ; 2872 POINTER; ! Pointer to the data ; 2873 ; 2874 POINTER = CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE); ; 2875 COUNTER = 0; ; 2876 ; 2877 WHILE (.COUNTER LSS .REC_LENGTH) DO ; 2878 BEGIN ; 2879 CHARACTER = CH$RCHAR_A (POINTER); ; 2880 COUNTER = .COUNTER + 1; ; 2881 ; 2882 IF .CHARACTER EQL .RCV_QUOTE_CHR ; 2883 THEN ; 2884 BEGIN ; 2885 CHARACTER = CH$RCHAR_A (POINTER); ; 2886 COUNTER = .COUNTER + 1; ; 2887 ; 2888 IF (.CHARACTER AND %O'177') NEQ .RCV_QUOTE_CHR THEN CHARACTER = CTL (.CHARACTER); ; 2889 ; 2890 END; ; 2891 ; 2892 STATUS = PUT_FILE (.CHARACTER); ; 2893 ; 2894 IF NOT .STATUS THEN RETURN .STATUS; ; 2895 ; 2896 END; ; 2897 ; 2898 STATUS = FILE_DUMP (); ; 2899 ; 2900 IF NOT .STATUS THEN RETURN .STATUS; ; 2901 ; 2902 RETURN KER_NORMAL; ; 2903 END; ! End of BFR_EMPTY ;BFR_EMPTY U.20: .WORD ^M ;Save R2,R3,R4 ; 2827 MOVAB W^U.60+4, R4 ;U.60+4, POINTER ; 2874 CLRL R3 ;COUNTER ; 2875 1$: CMPL R3, W^U.58 ;COUNTER, U.58 ; 2877 BGEQ 3$ ;3$ ; MOVZBL (R4)+, R2 ;(POINTER)+, CHARACTER ; 2879 INCL R3 ;COUNTER ; 2880 CMPL R2, W^RCV_QUOTE_CHR ;CHARACTER, RCV_QUOTE_CHR ; 2882 BNEQ 2$ ;2$ ; MOVZBL (R4)+, R2 ;(POINTER)+, CHARACTER ; 2885 INCL R3 ;COUNTER ; 2886 CMPZV #0, #7, R2, W^RCV_QUOTE_CHR ;#0, #7, CHARACTER, RCV_QUOTE_CHR ; 2888 BEQL 2$ ;2$ ; XORB2 #64, R2 ;#64, CHARACTER ; 2$: PUSHL R2 ;CHARACTER ; 2892 CALLS #1, W^PUT_FILE ;#1, PUT_FILE ; BLBS R0, 1$ ;STATUS, 1$ ; 2894 RET ; ; 3$: CALLS #0, W^FILE_DUMP ;#0, FILE_DUMP ; 2898 BLBC R0, 4$ ;STATUS, 4$ ; 2900 MOVL #134316043, R0 ;#134316043, R0 ; 2866 4$: RET ; ; 2827 ; Routine Size: 73 bytes, Routine Base: $CODE$ + 0B36 ; 2904 %SBTTL 'Statistics -- Initialization' ; 2905 ROUTINE INIT_STATS : NOVALUE = ; 2906 ; 2907 !++ ; 2908 ! FUNCTIONAL DESCRIPTION: ; 2909 ! ; 2910 ! This routine will initialize the various locations that the ; 2911 ! send and receive statistics are kept. ; 2912 ! ; 2913 ! CALLING SEQUENCE: ; 2914 ! ; 2915 ! INIT_STATS(); ; 2916 ! ; 2917 ! INPUT PARAMETERS: ; 2918 ! ; 2919 ! None. ; 2920 ! ; 2921 ! IMPLICIT INPUTS: ; 2922 ! ; 2923 ! None. ; 2924 ! ; 2925 ! OUPTUT PARAMETERS: ; 2926 ! ; 2927 ! None. ; 2928 ! ; 2929 ! IMPLICIT OUTPUTS: ; 2930 ! ; 2931 ! None. ; 2932 ! ; 2933 ! COMPLETION CODES: ; 2934 ! ; 2935 ! None. ; 2936 ! ; 2937 ! SIDE EFFECTS: ; 2938 ! ; 2939 ! None. ; 2940 ! ; 2941 !-- ; 2942 ; 2943 BEGIN ; 2944 SND_TOTAL_CHARS = 0; ; 2945 RCV_TOTAL_CHARS = 0; ; 2946 SND_DATA_CHARS = 0; ; 2947 RCV_DATA_CHARS = 0; ; 2948 END; ! End of INIT_STATS ;INIT_STATS U.14: .WORD ^M<> ;Save nothing ; 2905 CLRQ W^SND_TOTAL_CHARS ;SND_TOTAL_CHARS ; 2944 CLRQ W^SND_DATA_CHARS ;SND_DATA_CHARS ; 2946 RET ; ; 2905 ; Routine Size: 11 bytes, Routine Base: $CODE$ + 0B7F ; 2949 %SBTTL 'Debugging -- DBG_SEND' ; 2950 ROUTINE DBG_SEND (ADDRESS, LENGTH) : NOVALUE = ; 2951 ; 2952 !++ ; 2953 ! FUNCTIONAL DESCRIPTION: ; 2954 ! ; 2955 ! This routine will output the message that is going to be sent ; 2956 ! as part of the debugging information that is turned on in the ; 2957 ! SET DEBUG command. ; 2958 ! ; 2959 ! CALLING SEQUENCE: ; 2960 ! ; 2961 ! DBG_SEND(MSG_ADDRESS, MSG_LENGTH); ; 2962 ! ; 2963 ! INPUT PARAMETERS: ; 2964 ! ; 2965 ! MSG_ADDRESS - Address of the message that is going to be sent ; 2966 ! to the remote KERMIT. The bytes are CHR_SIZE. ; 2967 ! MSG_LENGTH - Length of the message. ; 2968 ! ; 2969 ! IMPLICIT INPUTS: ; 2970 ! ; 2971 ! None. ; 2972 ! ; 2973 ! OUPTUT PARAMETERS: ; 2974 ! ; 2975 ! None. ; 2976 ! ; 2977 ! IMPLICIT OUTPUTS: ; 2978 ! ; 2979 ! None. ; 2980 ! ; 2981 ! COMPLETION CODES: ; 2982 ! ; 2983 ! None. ; 2984 ! ; 2985 ! SIDE EFFECTS: ; 2986 ! ; 2987 ! None. ; 2988 ! ; 2989 !-- ; 2990 ; 2991 BEGIN ; 2992 ; 2993 BIND ; 2994 SEND_TEXT = UPLIT (%ASCIZ'Sending...'); ; 2995 ; 2996 IF .DEBUG_FLAG AND NOT .CONNECT_FLAG ; 2997 THEN ; 2998 BEGIN ; 2999 TT_TEXT (SEND_TEXT); ; 3000 DBG_MESSAGE (.ADDRESS, .LENGTH); ; 3001 END; ; 3002 ; 3003 END; ! End of DBG_SEND .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAB: .ASCII \Sending...\<0><0> ; ; U.71= P.AAB .PSECT $CODE$,NOWRT,2 ;DBG_SEND U.24: .WORD ^M<> ;Save nothing ; 2950 BLBC W^DEBUG_FLAG, 1$ ;DEBUG_FLAG, 1$ ; 2996 BLBS W^CONNECT_FLAG, 1$ ;CONNECT_FLAG, 1$ ; PUSHAB W^U.71 ;U.71 ; 2999 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; MOVQ 4(AP), -(SP) ;ADDRESS, -(SP) ; 3000 CALLS #2, W^U.23 ;#2, U.23 ; 1$: RET ; ; 2950 ; Routine Size: 31 bytes, Routine Base: $CODE$ + 0B8A ; 3004 %SBTTL 'Debugging -- DBG_RECEIVE' ; 3005 ROUTINE DBG_RECEIVE (ADDRESS) : NOVALUE = ; 3006 ; 3007 !++ ; 3008 ! FUNCTIONAL DESCRIPTION: ; 3009 ! ; 3010 ! This routine will output the message that was received from ; 3011 ! the remote KERMIT. This routine is called only if the DEBUG_FLAG ; 3012 ! is true. ; 3013 ! ; 3014 ! CALLING SEQUENCE: ; 3015 ! ; 3016 ! DBG_RECEIVE(MSG_ADDRESS); ; 3017 ! ; 3018 ! INPUT PARAMETERS: ; 3019 ! ; 3020 ! MSG_ADDRESS - Address of the message received by the remote KERMIT. ; 3021 ! ; 3022 ! IMPLICIT INPUTS: ; 3023 ! ; 3024 ! None. ; 3025 ! ; 3026 ! OUPTUT PARAMETERS: ; 3027 ! ; 3028 ! None. ; 3029 ! ; 3030 ! IMPLICIT OUTPUTS: ; 3031 ! ; 3032 ! None. ; 3033 ! ; 3034 ! COMPLETION CODES: ; 3035 ! ; 3036 ! None. ; 3037 ! ; 3038 ! SIDE EFFECTS: ; 3039 ! ; 3040 ! None. ; 3041 ! ; 3042 !-- ; 3043 ; 3044 BEGIN ; 3045 ; 3046 BIND ; 3047 RECEIVE_TEXT = UPLIT (%ASCIZ'Received...'); ; 3048 ; 3049 IF .DEBUG_FLAG AND NOT .CONNECT_FLAG ; 3050 THEN ; 3051 BEGIN ; 3052 TT_TEXT (RECEIVE_TEXT); ; 3053 DBG_MESSAGE (.ADDRESS, .REC_LENGTH); ; 3054 END; ; 3055 ; 3056 END; ! End of DBG_RECEIVE .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAC: .ASCII \Received...\<0> ; ; U.72= P.AAC .PSECT $CODE$,NOWRT,2 ;DBG_RECEIVE U.25: .WORD ^M<> ;Save nothing ; 3005 BLBC W^DEBUG_FLAG, 1$ ;DEBUG_FLAG, 1$ ; 3049 BLBS W^CONNECT_FLAG, 1$ ;CONNECT_FLAG, 1$ ; PUSHAB W^U.72 ;U.72 ; 3052 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; PUSHL W^U.58 ;U.58 ; 3053 PUSHL 4(AP) ;ADDRESS ; CALLS #2, W^U.23 ;#2, U.23 ; 1$: RET ; ; 3005 ; Routine Size: 34 bytes, Routine Base: $CODE$ + 0BA9 ; 3057 %SBTTL 'Debugging -- DBG_MESSAGE' ; 3058 ; 3059 GLOBAL ROUTINE DBG_MESSAGE (MSG_ADDRESS, MSG_LENGTH) : NOVALUE = ; 3060 ; 3061 !++ ; 3062 ! FUNCTIONAL DESCRIPTION: ; 3063 ! ; 3064 ! This routine will display a message that is either being sent ; 3065 ! or received on the user's terminal. ; 3066 ! ; 3067 ! CALLING SEQUENCE: ; 3068 ! ; 3069 ! DBG_MESSAGE(MSG_ADDRESS, MSG_LENGTH); ; 3070 ! ; 3071 ! INPUT PARAMETERS: ; 3072 ! ; 3073 ! MSG_ADDRESS - Address of the message to be output ; 3074 ! MSG_LENGTH - Length of the message to be output. ; 3075 ! ; 3076 ! IMPLICIT INPUTS: ; 3077 ! ; 3078 ! None. ; 3079 ! ; 3080 ! OUPTUT PARAMETERS: ; 3081 ! ; 3082 ! None. ; 3083 ! ; 3084 ! IMPLICIT OUTPUTS: ; 3085 ! ; 3086 ! None. ; 3087 ! ; 3088 ! COMPLETION CODES: ; 3089 ! ; 3090 ! None. ; 3091 ! ; 3092 ! SIDE EFFECTS: ; 3093 ! ; 3094 ! None. ; 3095 ! ; 3096 !-- ; 3097 ; 3098 BEGIN ; 3099 ; 3100 MAP ; 3101 MSG_ADDRESS : REF VECTOR [CH$ALLOCATION (MAX_MSG)]; ! Point to the vector ; 3102 ; 3103 LOCAL ; 3104 TEMP_POINTER, ! Temporary character pointer ; 3105 MSG_LEN; ; 3106 ; 3107 ! ; 3108 ! Message type text ; 3109 ! ; 3110 ; 3111 BIND ; 3112 DATA_TEXT = UPLIT (%ASCIZ' (Data)'), ; 3113 ACK_TEXT = UPLIT (%ASCIZ' (ACK)'), ; 3114 NAK_TEXT = UPLIT (%ASCIZ' (NAK)'), ; 3115 SND_INIT_TEXT = UPLIT (%ASCIZ' (Send init)'), ; 3116 BREAK_TEXT = UPLIT (%ASCIZ' (Break)'), ; 3117 FILE_TEXT = UPLIT (%ASCIZ' (File)'), ; 3118 EOF_TEXT = UPLIT (%ASCIZ' (EOF)'), ; 3119 ERROR_TEXT = UPLIT (%ASCIZ' (Error)'), ; 3120 RCV_INIT_TEXT = UPLIT (%ASCIZ' (Receive initiate)'), ; 3121 COMMAND_TEXT = UPLIT (%ASCIZ' (Command)'), ; 3122 KERMIT_TEXT = UPLIT (%ASCIZ' (Generic KERMIT command)'); ; 3123 ; 3124 ! ; 3125 ! Header information ; 3126 ! ; 3127 ; 3128 BIND ; 3129 MN_TEXT = UPLIT (%ASCIZ'Message number: '), ; 3130 LENGTH_TEXT = UPLIT (%ASCIZ' Length: '), ; 3131 DEC_TEXT = UPLIT (%ASCIZ' (dec)'), ; 3132 MSG_TYP_TEXT = UPLIT (%ASCIZ'Message type: '), ; 3133 CHKSUM_TEXT = UPLIT (%ASCIZ'Checksum: '), ; 3134 OPT_DATA_TEXT = UPLIT (%ASCIZ'Optional data: '), ; 3135 PRE_CHAR_TEXT = UPLIT (%ASCIZ' "'); ; 3136 ; 3137 ! ; 3138 ! Preliminary calculations ; 3139 ! ; 3140 MSG_LEN = UNCHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_COUNT, CHR_SIZE))); ; 3141 ! ; 3142 ! First output some header information for the packet. ; 3143 ! ; 3144 TT_CRLF (); ; 3145 TT_TEXT (MN_TEXT); ; 3146 TT_NUMBER (UNCHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_SEQ, CHR_SIZE)))); ; 3147 TT_TEXT (DEC_TEXT); ; 3148 TT_TEXT (LENGTH_TEXT); ; 3149 TT_NUMBER (.MSG_LEN); ; 3150 TT_TEXT (DEC_TEXT); ; 3151 TT_CRLF (); ; 3152 ! ; 3153 ! Now output the message type and dependent information ; 3154 ! ; 3155 TT_TEXT (MSG_TYP_TEXT); ; 3156 TT_CHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_TYPE, CHR_SIZE))); ; 3157 ; 3158 SELECTONE CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_TYPE, CHR_SIZE)) OF ; 3159 SET ; 3160 ; 3161 [MSG_DATA] : ; 3162 TT_TEXT (DATA_TEXT); ; 3163 ; 3164 [MSG_ACK] : ; 3165 TT_TEXT (ACK_TEXT); ; 3166 ; 3167 [MSG_NAK] : ; 3168 TT_TEXT (NAK_TEXT); ; 3169 ; 3170 [MSG_SND_INIT] : ; 3171 TT_TEXT (SND_INIT_TEXT); ; 3172 ; 3173 [MSG_BREAK] : ; 3174 TT_TEXT (BREAK_TEXT); ; 3175 ; 3176 [MSG_FILE] : ; 3177 TT_TEXT (FILE_TEXT); ; 3178 ; 3179 [MSG_EOF] : ; 3180 TT_TEXT (EOF_TEXT); ; 3181 ; 3182 [MSG_ERROR] : ; 3183 TT_TEXT (ERROR_TEXT); ; 3184 TES; ; 3185 ; 3186 TT_CRLF (); ; 3187 ! ; 3188 ! Now output any of the optional data. ; 3189 ! ; 3190 ; 3191 IF .MSG_LEN - PKT_OVR_HEAD NEQ 0 ; 3192 THEN ; 3193 BEGIN ; 3194 TT_TEXT (OPT_DATA_TEXT); ; 3195 TT_CRLF (); ; 3196 TEMP_POINTER = CH$PTR (.MSG_ADDRESS, PKT_MSG, CHR_SIZE); ; 3197 ; 3198 INCR I FROM 1 TO .MSG_LEN - PKT_OVR_HEAD DO ; 3199 BEGIN ; 3200 ; 3201 IF (.I MOD 10) EQL 1 ; 3202 THEN ; 3203 BEGIN ; 3204 TT_CRLF (); ; 3205 TT_CHAR (CHR_TAB); ; 3206 END; ; 3207 ; 3208 TT_TEXT (PRE_CHAR_TEXT); ; 3209 TT_QCHAR (CH$RCHAR_A (TEMP_POINTER)); ; 3210 TT_CHAR (%C'"'); ; 3211 END; ; 3212 ; 3213 IF ((.MSG_LEN - PKT_OVR_HEAD) MOD 10) EQL 1 THEN TT_CRLF (); ; 3214 ; 3215 TT_CRLF (); ; 3216 END; ; 3217 ; 3218 ! ; 3219 ! Now output the checksum for the message that we received ; 3220 ! ; 3221 TT_TEXT (CHKSUM_TEXT); ; P 3222 TT_NUMBER (UNCHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_MSG + .MSG_LEN + PKT_CHKSUM - PKT_OVR_HEAD, ; 3223 CHR_SIZE)))); ; 3224 TT_TEXT (DEC_TEXT); ; 3225 TT_CRLF (); ; 3226 END; ! End of DBG_MESSAGE .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAD: .ASCII \ (Data)\<0> ; ; P.AAE: .ASCII \ (ACK)\<0><0> ; ; P.AAF: .ASCII \ (NAK)\<0><0> ; ; P.AAG: .ASCII \ (Send init)\<0><0><0><0> ; ; P.AAH: .ASCII \ (Break)\<0><0><0><0> ; ; P.AAI: .ASCII \ (File)\<0> ; ; P.AAJ: .ASCII \ (EOF)\<0><0> ; ; P.AAK: .ASCII \ (Error)\<0><0><0><0> ; ; P.AAL: .ASCII \ (Receive initiate)\<0> ; ; P.AAM: .ASCII \ (Command)\<0><0> ; ; P.AAN: .ASCII \ (Generic KERMIT command)\<0><0><0> ; ; P.AAO: .ASCII \Message number: \<0><0><0><0> ; ; P.AAP: .ASCII <9>\Length: \<0><0><0> ; ; P.AAQ: .ASCII \ (dec)\<0><0> ; ; P.AAR: .ASCII \Message type: \<0><0> ; ; P.AAS: .ASCII \Checksum: \<0><0> ; ; P.AAT: .ASCII \Optional data: \<0> ; ; P.AAU: .ASCII \ "\<0><0> ; ; U.74= P.AAD U.75= P.AAE U.76= P.AAF U.77= P.AAG U.78= P.AAH U.79= P.AAI U.80= P.AAJ U.81= P.AAK U.82= P.AAL U.83= P.AAM U.84= P.AAN U.85= P.AAO U.86= P.AAP U.87= P.AAQ U.88= P.AAR U.89= P.AAS U.90= P.AAT U.91= P.AAU U.23: .PSECT $CODE$,NOWRT,2 .ENTRY DBG_MESSAGE, ^M ; ; MOVAB W^TT_CHAR, R11 ;TT_CHAR, R11 ; MOVAB W^TT_NUMBER, R10 ;TT_NUMBER, R10 ; MOVAB W^TT_CRLF, R9 ;TT_CRLF, R9 ; MOVAB W^TT_TEXT, R8 ;TT_TEXT, R8 ; MOVAB W^U.87, R7 ;U.87, R7 ; MOVL 4(AP), R3 ;MSG_ADDRESS, R3 ; 3140 MOVZBL 1(R3), R5 ;1(R3), MSG_LEN ; SUBL2 #32, R5 ;#32, MSG_LEN ; CALLS #0, (R9) ;#0, TT_CRLF ; 3144 PUSHAB -32(R7) ;MN_TEXT ; 3145 CALLS #1, (R8) ;#1, TT_TEXT ; MOVZBL 2(R3), -(SP) ;2(R3), -(SP) ; 3146 SUBL2 #32, (SP) ;#32, (SP) ; CALLS #1, (R10) ;#1, TT_NUMBER ; PUSHL R7 ;R7 ; 3147 CALLS #1, (R8) ;#1, TT_TEXT ; PUSHAB -12(R7) ;LENGTH_TEXT ; 3148 CALLS #1, (R8) ;#1, TT_TEXT ; PUSHL R5 ;MSG_LEN ; 3149 CALLS #1, (R10) ;#1, TT_NUMBER ; PUSHL R7 ;R7 ; 3150 CALLS #1, (R8) ;#1, TT_TEXT ; CALLS #0, (R9) ;#0, TT_CRLF ; 3151 PUSHAB 8(R7) ;MSG_TYP_TEXT ; 3155 CALLS #1, (R8) ;#1, TT_TEXT ; MOVZBL 3(R3), R2 ;3(R3), R2 ; 3156 PUSHL R2 ;R2 ; CALLS #1, (R11) ;#1, TT_CHAR ; CMPB R2, #68 ;R2, #68 ; 3158 BNEQ 1$ ;1$ ; PUSHAB -172(R7) ;DATA_TEXT ; 3162 BRB 8$ ;8$ ; 1$: CMPB R2, #89 ;R2, #89 ; 3158 BNEQ 2$ ;2$ ; PUSHAB -164(R7) ;ACK_TEXT ; 3165 BRB 8$ ;8$ ; 2$: CMPB R2, #78 ;R2, #78 ; 3158 BNEQ 3$ ;3$ ; PUSHAB -156(R7) ;NAK_TEXT ; 3168 BRB 8$ ;8$ ; 3$: CMPB R2, #83 ;R2, #83 ; 3158 BNEQ 4$ ;4$ ; PUSHAB -148(R7) ;SND_INIT_TEXT ; 3171 BRB 8$ ;8$ ; 4$: CMPB R2, #66 ;R2, #66 ; 3158 BNEQ 5$ ;5$ ; PUSHAB -132(R7) ;BREAK_TEXT ; 3174 BRB 8$ ;8$ ; 5$: CMPB R2, #70 ;R2, #70 ; 3158 BNEQ 6$ ;6$ ; PUSHAB -120(R7) ;FILE_TEXT ; 3177 BRB 8$ ;8$ ; 6$: CMPB R2, #90 ;R2, #90 ; 3158 BNEQ 7$ ;7$ ; PUSHAB -112(R7) ;EOF_TEXT ; 3180 BRB 8$ ;8$ ; 7$: CMPB R2, #69 ;R2, #69 ; 3158 BNEQ 9$ ;9$ ; PUSHAB -104(R7) ;ERROR_TEXT ; 3183 8$: CALLS #1, (R8) ;#1, TT_TEXT ; 9$: CALLS #0, (R9) ;#0, TT_CRLF ; 3186 CMPL R5, #3 ;MSG_LEN, #3 ; 3191 BEQL 14$ ;14$ ; PUSHAB 36(R7) ;OPT_DATA_TEXT ; 3194 CALLS #1, (R8) ;#1, TT_TEXT ; CALLS #0, (R9) ;#0, TT_CRLF ; 3195 MOVAB 4(R3), R6 ;4(R3), TEMP_POINTER ; 3196 MOVAB -3(R5), R4 ;-3(R5), R4 ; 3198 CLRL R2 ;I ; BRB 12$ ;12$ ; 10$: EMUL #1, R2, #0, -(SP) ;#1, I, #0, -(SP) ; 3201 EDIV #10, (SP)+, R0, R0 ;#10, (SP)+, R0, R0 ; CMPL R0, #1 ;R0, #1 ; BNEQ 11$ ;11$ ; CALLS #0, (R9) ;#0, TT_CRLF ; 3204 PUSHL #9 ;#9 ; 3205 CALLS #1, (R11) ;#1, TT_CHAR ; 11$: PUSHAB 52(R7) ;PRE_CHAR_TEXT ; 3208 CALLS #1, (R8) ;#1, TT_TEXT ; MOVZBL (R6)+, -(SP) ;(TEMP_POINTER)+, -(SP) ; 3209 CALLS #1, W^TT_QCHAR ;#1, TT_QCHAR ; PUSHL #34 ;#34 ; 3210 CALLS #1, (R11) ;#1, TT_CHAR ; 12$: AOBLEQ R4, R2, 10$ ;R4, I, 10$ ; 3198 EMUL #1, R4, #0, -(SP) ;#1, R4, #0, -(SP) ; 3213 EDIV #10, (SP)+, R0, R0 ;#10, (SP)+, R0, R0 ; CMPL R0, #1 ;R0, #1 ; BNEQ 13$ ;13$ ; CALLS #0, (R9) ;#0, TT_CRLF ; 13$: CALLS #0, (R9) ;#0, TT_CRLF ; 3215 14$: PUSHAB 24(R7) ;CHKSUM_TEXT ; 3221 CALLS #1, (R8) ;#1, TT_TEXT ; MOVZBL 1(R5)[R3], -(SP) ;1(MSG_LEN)[R3], -(SP) ; 3223 SUBL2 #32, (SP) ;#32, (SP) ; CALLS #1, (R10) ;#1, TT_NUMBER ; 3222 PUSHL R7 ;R7 ; 3224 CALLS #1, (R8) ;#1, TT_TEXT ; CALLS #0, (R9) ;#0, TT_CRLF ; 3225 RET ; ; 3059 ; Routine Size: 312 bytes, Routine Base: $CODE$ + 0BCB ; 3227 ; 3228 %SBTTL 'End of KERMSG' ; 3229 END ; 3230 ; 3231 ELUDOM ; PSECT SUMMARY ; ; Name Bytes Attributes ; ; $GLOBAL$ 232 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $OWN$ 228 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $CODE$ 3331 NOVEC,NOWRT, RD , EXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $PLIT$ 276 NOVEC,NOWRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; LIBRARY STATISTICS ; ; -------- Symbols -------- Blocks ; File Total Loaded Percent Read ; ; SYS$SYSROOT:[SYSLIB]STARLET.L32;1 5809 4 0 208 ; COMMAND QUALIFIERS ; BLISS KERMSGNEW/LIST=KERMSGNEW.MAR/MACHINE_CODE=(ASSEM,NOBINARY,UNIQUE)/NOOBJECT/SOURCE=NOHEADER ; Compilation Complete .END