; 0001 MODULE KERMSG (IDENT = '2.0.017' ; 0002 ) = ; 0003 BEGIN ; 0004 ; 0005 SWITCHES LANGUAGE (COMMON); ; 0006 ; 0007 ! ; 0008 ; 0009 !++ ; 0010 ! FACILITY: ; 0011 ! KERMIT-32/36 ; 0012 ! ; 0013 ! ABSTRACT: ; 0014 ! KERMSG is the message processing routines for KERMIT-32/36. ; 0015 ! This module is written in common BLISS, so that it can be ; 0016 ! transported for the DECsystem-10 and VAX/VMS systems. ; 0017 ! ; 0018 ! ENVIRONMENT: ; 0019 ! User mode ; 0020 ! ; 0021 ! AUTHOR: Robert C. McQueen, CREATION DATE: 24-January-1983 ; 0022 ! ; 0023 ! MODIFIED BY: ; 0024 ! ; 0025 !-- ; 0026 ; 0027 %SBTTL 'Table of Contents' ; 0028 %SBTTL 'Revision History' ; 0029 ; 0030 !++ ; 0031 ! Start of version 1. ; 0032 ! ; 0033 ! 1.0.000 By: Robert C. McQueen On: 4-Jan-1983 ; 0034 ! Create this program. ; 0035 ! ; 0036 ! 1.0.001 By: Robert C. McQueen On: 30-Apr-1983 ; 0037 ! Change PAR_xxx to be PR_xxx, so that they can be used for ; 0038 ! KERMIT-10. ; 0039 ! ; 0040 ! 1.0.002 By: Robert C. McQueen On: 1-May-1983 ; 0041 ! Add DO_GENERIC routine to cause a generic Kermit command to ; 0042 ! be executed on the remote Kermit. ; 0043 ! ; 0044 ! 1.0.003 By: Robert C. McQueen On: 3-May-1983 ; 0045 ! Fix message number incrementing. ; 0046 ! ; 0047 ! 1.0.004 By: Robert C. McQueen On: 4-May-1983 ; 0048 ! Allow RECEIVE file-specification to work correctly. ; 0049 ! ; 0050 ! 1.0.005 By: Robert C. McQueen On: 6-May-1983 ; 0051 ! Add more stats support. ; 0052 ! ; 0053 ! 1.0.006 By: Nick Bush On: 13-June-1983 ; 0054 ! Fix SEND_PACKET to copy correct characters when fixing ; 0055 ! parity bits. ; 0056 ! ; 0057 ! 1.1.007 By: Nick Bush On: 15-July-1983 ; 0058 ! Correct SEND-INIT message handling to do the right things ; 0059 ! with the protocol version 3 items. ; 0060 ! ; 0061 ! 1.1.010 By: Robert C. McQueen On: 20-July-1983 ; 0062 ! Make PARITY a global routine, so that it can be called by ; 0063 ! CONNECT processing. Change the name from PARITY to GEN_PARITY ; 0064 ! add a new routine to generate the parity, since it is not ; 0065 ! part of the checksum. ; 0066 ! ; 0067 ! 1.1.011 By: Robert C. McQueen On: 28-July-1983 ; 0068 ! KER_TIMEOUT errors in the SERVER loop would cause ; 0069 ! KER_UNISRV error messages to be returned to the remote. ; 0070 ! Check for receive failures and send NAKs instead. ; 0071 ! ; 0072 ! 1.2.012 By: Robert C. McQueen On: 23-August-1983 ; 0073 ! Don't abort if we get a message that is just an end of line ; 0074 ! character. It could be noise on the line. ; 0075 ! ; 0076 ! 1.2.013 By: Nick Bush On: 7-September-1983 ; 0077 ! Fix several problems with the SEND_xxx parameters ; 0078 ! ; 0079 ! 1.2.014 By: Robert C. McQueen On: 15-September-1983 ; 0080 ! Add routine calls to XFR_STATUS to tell the user on the ; 0081 ! number of packets have changed. ; 0082 ! ; 0083 ! 1.2.015 By: Nick Bush On: 5-October-1983 ; 0084 ! Add 2 and 3 character checksum (block check) support. ; 0085 ! Add support for data within acknowledgement packets ; 0086 ! and withing end-of-file packets to allow for file ; 0087 ! transmission to be aborted. Also add support for ; 0088 ! "I" packet to allow server parameters to be initialized. ; 0089 ! ; 0090 ! 1.2.016 By: Nick Bush On: 19-October-1983 ; 0091 ! Add repeat character support. ; 0092 ! ; 0093 ! 2.0.017 Release TOPS-10 Kermit-10 version 2.0 ; 0094 ! Release VAX/VMS Kermit-32 version 2.0 ; 0095 !-- ; 0096 ; 0097 %SBTTL 'Interface requirements' ; 0098 ; 0099 !++ ; 0100 ! Interface requirements ; 0101 ! ; 0102 ! The following routines and data locations are rquired for a correct ; 0103 ! implementation of KERMIT. ; 0104 ! ; 0105 ! File routines: ; 0106 ! ; 0107 ! FILE_OPEN (Function) ; 0108 ! This routine will open a file for reading or writting. It ; 0109 ! will assume that FILE_SIZE contains the number of bytes ; 0110 ! and FILE_NAME contains the file name of length FILE_SIZE. ; 0111 ! The function that is passed is either FNC_READ or FNC_WRITE. ; 0112 ! ; 0113 ! FILE_CLOSE () ; 0114 ! This routine will close the currently open file. This ; 0115 ! routine will return the status of the operation. ; 0116 ! ; 0117 ! FILE_DUMP () ; 0118 ! This routine will cause the current record to be written to ; 0119 ! the file, this routine will only handle binary files if the ; 0120 ! low level I/O routines are record oriented. Otherwise it is ; 0121 ! not needed. ; 0122 ! ; 0123 ! GET_FILE (Character) ; 0124 ! This routine will get a character from the currently open file ; 0125 ! and store it in the location specified by "Character". There ; 0126 ! will be a true/false value returned by the routine to determine ; 0127 ! if there was an error. ; 0128 ! ; 0129 ! PUT_FILE (Character) ; 0130 ! This routine will output a character to the currently open ; 0131 ! file. It will return a true/false value to determine if the ; 0132 ! routine was successful. ; 0133 ! ; 0134 ! NEXT_FILE () ; 0135 ! This routine will advance to the next file. This routine ; 0136 ! will return false if there are no more files to process. ; 0137 ! ; 0138 ! Communications line routines: ; 0139 ! ; 0140 ! RECEIVE (Buffer address, Address of var to store length into) ; 0141 ! This routine will receive a message from the remote Kermit. ; 0142 ! ; 0143 ! SEND (Buffer address, Length in characters) ; 0144 ! This routine will send a message to the remote Kermit. ; 0145 ! ; 0146 ! GEN_CRC (Buffer address, length in characters) ; 0147 ! This routine will calculate the CRC-CCITT for the characters ; 0148 ! in the buffer. ; 0149 ! ; 0150 ! Operating system routines: ; 0151 ! ; 0152 ! SY_DISMISS (Seconds) ; 0153 ! This routine will cause Kermit to sleep for the specified ; 0154 ! number of seconds. It is used to handle the DELAY parameter. ; 0155 ! ; 0156 ! SY_LOGOUT () ; 0157 ! Log the job off of the system. (Kill the process). ; 0158 ! ; 0159 ! SY_TIME () ; 0160 ! This routine will return the starting time milliseconds. ; 0161 ! It can be the start of Kermit, the system, etc, so long ; 0162 ! as it always is incrementing. ; 0163 ! ; 0164 ! Status routines: ; 0165 ! ; 0166 ! XFR_STATUS (Type, Subtype); ; 0167 ! This routine will call the O/S routine to tell it that ; 0168 ! either the packet count as bee incremented or the ; 0169 ! retry count has been incremented. ; 0170 ! Type: "S" - Send, "R" - Receive ; 0171 ! Subtype: "P" - Packet, "N" - NAK ; 0172 ! ; 0173 ! Error processing: ; 0174 ! ; 0175 ! KRM_ERROR (Error parameter) ; 0176 ! This routine will cause an error message to be issued. ; 0177 ! The error parameter is defined by KERERR. This may cause ; 0178 ! SND_ERROR to be called to send an "E" message to the remote. ; 0179 ! ; 0180 ! Terminal I/O routines: ; 0181 ! ; 0182 ! TERM_DUMP (Buffer, Count) ; 0183 ! DBG_DUMP (Buffer, Count) ; 0184 ! This routine will dump the buffer onto the user's terminal. ; 0185 ! The routine is supplied with the count of the characters ; 0186 ! and the address of the buffer. ; 0187 ! These may be the same routine or different. DBG_DUMP ; 0188 ! is only called for debugging output. ; 0189 ! ; 0190 ! ; 0191 ! ENTRY POINTS ; 0192 ! ; 0193 ! KERMSG contains the following entry points for the KERMIT. ; 0194 ! ; 0195 ! SERVER () ; 0196 ! This routine will cause KERMIT go enter server mode. ; 0197 ! ; 0198 ! SEND_SWITCH () ; 0199 ! This routine will send a file. It expects that the user ; 0200 ! has stored the text of the file name into FILE_NAME and ; 0201 ! the length of the text into FILE_SIZE. ; 0202 ! ; 0203 ! REC_SWITCH () ; 0204 ! This routine will receive a file. It expects that the default ; 0205 ! file name is set up in FILE_NAME and the length is in ; 0206 ! FILE_SIZE. ; 0207 ! ; 0208 ! GEN_PARITY (Character) ; 0209 ! This routine will return the character with the proper parity ; 0210 ! on the character. ; 0211 ! ; 0212 ! SND_ERROR (COUNT, ADDRESS) ; 0213 ! This routine will send the text of an error to the remote ; 0214 ! Kermit. ; 0215 ! ; 0216 ! DO_GENERIC (TYPE) ; 0217 ! This routine will cause a generic function to be sent to ; 0218 ! the remote Kermit. This routine will then do all of the ; 0219 ! necessary hand shaking to handle the local end of the generic ; 0220 ! Kermit command. ; 0221 ! ; 0222 ! ; 0223 ! GLOBAL Storage ; 0224 ! ; 0225 ! The following are the global storage locations that are used to interface ; 0226 ! to KERMSG. These locations contains the various send and receive parameters. ; 0227 ! ; 0228 ! Receive parameters: ; 0229 ! ; 0230 ! RCV_PKT_SIZE ; 0231 ! Receive packet size. ; 0232 ! RCV_NPAD ; 0233 ! Padding length ; 0234 ! RCV_PADCHAR ; 0235 ! Padding character ; 0236 ! RCV_TIMEOUT ; 0237 ! Time out ; 0238 ! RCV_EOL ; 0239 ! End of line character ; 0240 ! RCV_QUOTE_CHR ; 0241 ! Quote character ; 0242 ! RCV_8QUOTE_CHR ; 0243 ! 8-bit quoting character ; 0244 ! RCV_SOH ; 0245 ! Start of header character ; 0246 ! ; 0247 ! Send parameters (Negative values denote the default, positive user supplied): ; 0248 ! ; 0249 ! SND_PKT_SIZE ; 0250 ! Send packet size ; 0251 ! SND_NPAD ; 0252 ! Padding length ; 0253 ! SND_PADCHAR ; 0254 ! Padding character ; 0255 ! SND_TIMEOUT ; 0256 ! Time out ; 0257 ! SND_EOL ; 0258 ! End of line character ; 0259 ! SND_QUOTE_CHR ; 0260 ! Quote character ; 0261 ! SND_SOH ; 0262 ! Start of header character (normally 001) ; 0263 ! ; 0264 ! Statistics: ; 0265 ! ; 0266 ! SND_TOTAL_CHARS ; 0267 ! Total characters sent for this Kermit session ; 0268 ! RCV_TOTAL_CHARS ; 0269 ! Total characters received for this Kermit session ; 0270 ! SND_DATA_CHARS ; 0271 ! Total number of data characters sent for this Kermit session ; 0272 ! RCV_DATA_CHARS ; 0273 ! Total number of data characters received for this Kermit session ; 0274 ! SND_COUNT ; 0275 ! Total number of packets that have been sent ; 0276 ! RCV_COUNT ; 0277 ! Total number of packets that have been received. ; 0278 ! SMSG_TOTAL_CHARS ; 0279 ! Total characters sent for this file transfer ; 0280 ! RMSG_TOTAL_CHARS ; 0281 ! Total characters received for this file transfer ; 0282 ! SMSG_DATA_CHARS ; 0283 ! Total data characters sent for this file transfer ; 0284 ! RMSG_DATA_CHARS ; 0285 ! Total data characters received for this file transfer ; 0286 ! SMSG_NAKS ; 0287 ! Total number of NAKs sent for this file transfer ; 0288 ! RMSG_NAKS ; 0289 ! Total number of NAKs received for this file transfer ; 0290 ! XFR_TIME ; 0291 ! Amount of time the last transfer took in milliseconds. ; 0292 ! TOTAL_TIME ; 0293 ! Total amount of time spend transfering data. ; 0294 ! ; 0295 ! Misc constants: ; 0296 ! ; 0297 ! LAST_ERROR ; 0298 ! ASCIZ of the last error message issued. ; 0299 ! FILE_NAME ; 0300 ! Vector containing the ASCII characters of the file name. ; 0301 ! FILE_SIZE ; 0302 ! Number of characters in the FILE_NAME vector. ; 0303 ! DELAY ; 0304 ! Amount of time to delay ; 0305 ! DUPLEX ; 0306 ! DP_HALF or DP_FULL to denote either half duplex or full duplex. ; 0307 ! [Currently only DP_FULL is supported] ; 0308 ! PKT_RETRIES ; 0309 ! Number of retries to attempt to read a message. ; 0310 ! SI_RETRIES ; 0311 ! Number of retries to attempt on send inits ; 0312 ! DEBUG_FLAG ; 0313 ! Debugging mode on/off ; 0314 ! WARN_FLAG ; 0315 ! File warning flag ; 0316 ! IBM_FLAG ; 0317 ! True if talking to an IBM system, else false. ; 0318 ! ECHO_FLAG ; 0319 ! Local echo flag ; 0320 ! CONNECT_FLAG ; 0321 ! Connected flag; True if terminal and SET LINE are the same ; 0322 ! PARITY_TYPE ; 0323 ! Type of parity to use on sends. ; 0324 ! DEV_PARITY_FLAG ; 0325 ! Device will add parity to message. True if device adds ; 0326 ! parity and false if we must do it. ; 0327 ! ; 0328 !-- ; 0329 ; 0330 %SBTTL 'Declarations -- Forward definitions' ; 0331 ! ; 0332 ! ; 0333 ! Forward definitions ; 0334 ! ; 0335 ; 0336 FORWARD ROUTINE ; 0337 ; 0338 ! Send processing routines ; 0339 ; 0340 SEND_SWITCH, ! Major send routine ; 0341 SEND_SWITCH_WORKER, ! Real portion of send routine ; 0342 SEND_DATA, ! Send data to the micro ; 0343 SEND_FILE, ! Send file name ; 0344 SEND_EOF, ! Send EOF ; 0345 SEND_INIT, ! Send initialization msg ; 0346 SEND_BREAK, ! Send break end of transmission ; 0347 SND_ERROR : NOVALUE, ! Send an error to the remote ; 0348 ; 0349 ! Receive processing routines ; 0350 ; 0351 REC_SWITCH, ! Receive main loop ; 0352 REC_SWITCH_WORKER, ! Worker routine for REC_SWITCH and SERVER ; 0353 REC_INIT, ! Receive initialization ; 0354 REC_FILE, ! Receive file information ; 0355 REC_DATA, ! Receive data ; 0356 ! ; 0357 ! Server processing routines ; 0358 ! ; 0359 SERVER_GENERIC, ! Process generic KERMIT commands ; 0360 ! ; 0361 ! Statistic gathering routines ; 0362 ! ; 0363 END_STATS : NOVALUE, ! End of a message processing stats routine ; 0364 ; 0365 ! Low level send/receive routines ; 0366 ; 0367 CALC_BLOCK_CHECK, ! Routine to calculate the block check value ; 0368 SET_SEND_INIT : NOVALUE, ! Set up the MSG_SND_INIT parameters. ; 0369 PRS_SEND_INIT, ! Parse MSG_SND_INIT parameters. ; 0370 DO_PARITY : NOVALUE, ! Routine to generate parity for a message ; 0371 GEN_PARITY, ! Routine to add parity to a character ; 0372 SEND_PACKET, ! Send a packet to the remote ; 0373 REC_MESSAGE, ! Receive a message with retry processing ; 0374 REC_PACKET, ! Receive a packet from the remote ; 0375 ; 0376 ! Utility routines ; 0377 ; 0378 BFR_EMPTY, ! Empty the data buffer ; 0379 BFR_FILL, ! Fill the data buffer from a file ; 0380 CLEAR : NOVALUE, ! Clear the message buffer. ; 0381 INIT_XFR : NOVALUE, ! Initialize the per transfer processing ; 0382 ! ; 0383 ! Debugging routines ; 0384 ! ; 0385 DBG_MESSAGE : NOVALUE, ! Type out a formatted message ; 0386 DBG_SEND : NOVALUE, ! Send message debugging routine ; 0387 DBG_RECEIVE : NOVALUE; ! Receive message debugging routine ; 0388 %SBTTL 'Require files' ; 0389 ; 0390 ! ; 0391 ! ; 0392 ! ; 0393 ! REQUIRE FILES: ; 0394 ! ; 0395 ; L 0396 %IF %BLISS (BLISS32) ; 0397 %THEN ; 0398 ; 0399 LIBRARY 'SYS$LIBRARY:STARLET'; ; 0400 ; 0401 %FI ; 0402 ; 0403 REQUIRE 'KERCOM'; ; 0573 ; 0574 REQUIRE 'KERERR'; ; 0626 ; 0627 %SBTTL 'Macro definitions' ; 0628 ! ; 0629 ! MACROS: ; 0630 ! ; 0631 ; 0632 MACRO ; M 0633 CTL (C) = ; 0634 ((C) XOR %O'100')%, ; M 0635 CHAR (C) = ; 0636 ((C) + %O'40')%, ; M 0637 UNCHAR (C) = ; 0638 ((C) - %O'40')%; ; 0639 ; 0640 %SBTTL 'KERMIT Protocol Definitions' ; 0641 ; 0642 !++ ; 0643 ! The following describes the various items that are found in the ; 0644 ! KERMIT messages. A complete and through desription of the protocol can be ; 0645 ! found in the KERMIT PROTOCOL MANUAL. ; 0646 ! ; 0647 ! ; 0648 ! All KERMIT messages have the following format: ; 0649 ! ; 0650 ! ; 0651 ! ; 0652 ! ; 0653 ! Normally SOH (Control-A, octal 001). ; 0654 ! ; 0655 ! ; 0656 ! Count of the number of characters following this position. ; 0657 ! Character counts of ONLY 0 to 94 are valid. ; 0658 ! ; 0659 ! ; 0660 ! Packet sequence number, modulo 100 (octal). ; 0661 ! ; 0662 ! ; 0663 ! This field contains the message dependent information. There can ; 0664 ! be multiple fields in this section. See the KERMIT Protocol document ; 0665 ! for a complete description of this. ; 0666 ! ; 0667 ! ; 0668 ! A block check on the characters in the packet between, but not ; 0669 ! including, the mark and the checksum itself. It may be one to three ; 0670 ! characters, depending upon the type agreed upon. ; 0671 ! ; 0672 ! 1. Single character arithmetic sum equal to: ; 0673 ! chksum = (s + ((s AND 300)/100)) AND 77 ; 0674 ! Character sent is CHAR(chksum). ; 0675 ! ; 0676 ! 2. Two character arithmetic sum. CHAR of bits 6-11 are the first ; 0677 ! character, CHAR of bits 0-5 are the second character. ; 0678 ! ; 0679 ! 3. Three character CRC-CCITT. First character is CHAR of bits 12-15, ; 0680 ! second is CHAR of bits 6-11, third is CHAR of bits 0-5. ; 0681 ! ; 0682 ! ; 0683 ! ; 0684 ! End of line. Any line terminator that may be required by the host. ; 0685 !-- ; 0686 ; 0687 %SBTTL 'KERMIT Protocol Definitions -- Packet offsets' ; 0688 ; 0689 !++ ; 0690 ! The following define the various offsets of the standard KERMIT ; 0691 ! packets. ; 0692 !-- ; 0693 ; 0694 LITERAL ; 0695 PKT_MARK = 0, ! ; 0696 PKT_COUNT = 1, ! ; 0697 PKT_SEQ = 2, ! ; 0698 PKT_TYPE = 3, ! ; 0699 PKT_MSG = 4, ! ; 0700 PKT_MAX_MSG = 94 - 5, ! Maximum size of the message dependent ; 0701 ! information ; 0702 PKT_CHKSUM = 0, ! offset from end of ; 0703 ! Message dependent information ; 0704 PKT_EOL = 1, ! offset from end of data ; 0705 PKT_OVR_HEAD_B = 2, ! Header overhead ; 0706 PKT_OVR_HEAD_E = 1, ! Overhead at the end ; 0707 PKT_OVR_HEAD = 3, ! Overhead added to data length ; 0708 PKT_TOT_OVR_HEAD = 6; ! Total overhead of the message ; 0709 ; 0710 %SBTTL 'KERMIT Protocol Definitions -- Message dependent field' ; 0711 ; 0712 !++ ; 0713 ! The MESSAGE-DEPENDENT information field of the message contains at ; 0714 ! least one part. That is the type of message. The remainder of the message ; 0715 ! MESSAGE-DEPENDENT field is different depending on the message. ; 0716 ! ; 0717 ! ; 0718 ! ; 0719 ! ; 0720 ! The type defines the type of message that is being processed. ; 0721 ! ; 0722 !-- ; 0723 ; 0724 ! Protocol version 1.0 message types ; 0725 ; 0726 LITERAL ; 0727 MSG_DATA = %C'D', ! Data packet ; 0728 MSG_ACK = %C'Y', ! Acknowledgement ; 0729 MSG_NAK = %C'N', ! Negative acknowledgement ; 0730 MSG_SND_INIT = %C'S', ! Send initiate ; 0731 MSG_BREAK = %C'B', ! Break transmission ; 0732 MSG_FILE = %C'F', ! File header ; 0733 MSG_EOF = %C'Z', ! End of file (EOF) ; 0734 MSG_ERROR = %C'E'; ! Error ; 0735 ; 0736 ! Protocol version 2.0 message types ; 0737 ; 0738 LITERAL ; 0739 MSG_RCV_INIT = %C'R', ! Receive initiate ; 0740 MSG_COMMAND = %C'C', ! Host command ; 0741 MSG_KERMIT = %C'G'; ! Generic KERMIT command. ; 0742 ; 0743 ! Protocol version 4.0 message types ; 0744 ; 0745 LITERAL ; 0746 MSG_SER_INIT = %C'I'; ! Server initialization ; 0747 ; 0748 !++ ; 0749 ! Generic KERMIT commands ; 0750 !-- ; 0751 ; 0752 LITERAL ; 0753 MSG_GEN_LOGIN = %C'I', ! Login ; 0754 MSG_GEN_EXIT = %C'F', ! Finish (exit to OS) ; 0755 MSG_GEN_CONNECT = %C'C', ! Connect to a directory ; 0756 MSG_GEN_LOGOUT = %C'L', ! Logout ; 0757 MSG_GEN_DIRECTORY = %C'D', ! Directory ; 0758 MSG_GEN_DISK_USAGE = %C'U', ! Disk usage ; 0759 MSG_GEN_DELETE = %C'E', ! Delete a file ; 0760 MSG_GEN_TYPE = %C'T', ! Type a file specification ; 0761 MSG_GEN_SUBMIT = %C'S', ! Submit ; 0762 MSG_GEN_PRINT = %C'P', ! Print ; 0763 MSG_GEN_WHO = %C'W', ! Who's logged in ; 0764 MSG_GEN_SEND = %C'M', ! Send a message to a user ; 0765 MSG_GEN_HELP = %C'H', ! Help ; 0766 MSG_GEN_QUERY = %C'Q'; ! Query status ; 0767 ; 0768 ! ; 0769 ! Acknowledgement modifiers (protocol 4.0?) ; 0770 ! ; 0771 ; 0772 LITERAL ; 0773 MSG_ACK_ABT_CUR = %C'X', ! Abort current file ; 0774 MSG_ACK_ABT_ALL = %C'Z'; ! Abort entire stream of files ; 0775 ; 0776 ! ; 0777 ! End of file packet modifier ; 0778 ! ; 0779 ; 0780 LITERAL ; 0781 MSG_EOF_DISCARD = %C'D'; ! Discard data from previous file ; 0782 ; 0783 %SBTTL 'KERMIT Protocol Definitions -- SEND initiate packet' ; 0784 ; 0785 !++ ; 0786 ! ; 0787 ! The following describes the send initiate packet. All fields in the message ; 0788 ! data area are optional. ; 0789 ! ; 0790 ! <"S"> ; 0791 ! <8-bit-quote> ; 0792 ! ; 0793 ! BUFSIZ ; 0794 ! Sending Kermit's maximum buffer size. ; 0795 ! ; 0796 ! Timeout ; 0797 ! Number of seconds after which the sending Kermit wishes to be timed out ; 0798 ! ; 0799 ! Npad ; 0800 ! Number of padding caracters the sending Kermit needs preceding each ; 0801 ! packet. ; 0802 ! ; 0803 ! PAD ; 0804 ! Padding character. ; 0805 ! ; 0806 ! EOL ; 0807 ! A line terminator required on all packets set by the receiving ; 0808 ! Kermit. ; 0809 ! ; 0810 ! Quote ; 0811 ! The printable ASCII characer the sending Kermit will use when quoting ; 0812 ! the control cahracters. Default is "#". ; 0813 ! ; 0814 ! 8-bit-quote ; 0815 ! Specify quoting mecanism for 8-bit quantities. A quoting mecanism is ; 0816 ! mecessary when sending to hosts which prevent the use of the 8th bit ; 0817 ! for data. When elected, the quoting mechanism will be used by both ; 0818 ! hosts, and the quote character must be in the range of 41-76 or 140-176 ; 0819 ! octal, but different from the control-quoting character. This field is ; 0820 ! interpreted as follows: ; 0821 ! ; 0822 ! "Y" - I agree to 8-bit quoting if you request it. ; 0823 ! "N" - I will not do 8-bit quoting. ; 0824 ! "&" - (or any other character in the range of 41-76 or 140-176) I want ; 0825 ! to do 8-bit quoting using this character (it will be done if the ; 0826 ! other Kermit puts a "Y" in this field. ; 0827 ! Anything else: Quoting will not be done. ; 0828 ! ; 0829 ! Check-type ; 0830 ! Type of block check. The only values presently allowed in this ; 0831 ! field are "1", "2" or "3". Future implementations may allow other ; 0832 ! values. Interpretation of the values is: ; 0833 ! ; 0834 ! "1" - Single character checksum. Default value if none specified. ; 0835 ! "2" - Double character checksum. ; 0836 ! "3" - Three character CRC. ; 0837 ! ; 0838 ! Repeat-count-processing ; 0839 ! The prefix character to be used to indicate a repeated character. ; 0840 ! This can be any printable cahracter other than blank (which denotes ; 0841 ! no repeat count). ; 0842 ! ; 0843 ! Fields 10 to 11 reserved. ; 0844 !-- ; 0845 ; 0846 LITERAL ; 0847 P_SI_BUFSIZ = 0, ! Buffersize ; 0848 MY_PKT_SIZE = 80, ! My packet size ; 0849 P_SI_TIMOUT = 1, ! Time out ; 0850 MY_TIME_OUT = 15, ! My time out ; 0851 P_SI_NPAD = 2, ! Number of padding characters ; 0852 MY_NPAD = 0, ! Amount of padding I require ; 0853 P_SI_PAD = 3, ! Padding character ; 0854 MY_PAD_CHAR = 0, ! My pad character ; 0855 P_SI_EOL = 4, ! End of line character ; 0856 MY_EOL_CHAR = %O'015', ! My EOL cahracter ; 0857 P_SI_QUOTE = 5, ! Quote character ; 0858 MY_QUOTE_CHAR = %C'#', ! My quoting character ; 0859 P_SI_8QUOTE = 6, ! 8-bit quote ; 0860 MY_8BIT_QUOTE = %C'&', ! Don't do it ; 0861 P_SI_CHKTYPE = 7, ! Checktype used ; 0862 MY_CHKTYPE = CHK_1CHAR, ! Use single character checksum ; 0863 P_SI_REPEAT = 8, ! Repeat character ; 0864 MY_REPEAT = %C'~', ! My repeat character ; 0865 P_SI_LENGTH = 9; ! Length of the message ; 0866 ; 0867 %SBTTL 'KERMIT Protocol States' ; 0868 ; 0869 !++ ; 0870 ! The following are the various states that KERMIT can be in. ; 0871 ! The state transitions are defined in the KERMIT Protocol manual. ; 0872 !-- ; 0873 ; 0874 LITERAL ; 0875 STATE_MIN = 0, ! Min state number ; 0876 STATE_START = 0, ! Start state ; 0877 STATE_S = 1, ! Send init state ; 0878 STATE_SF = 2, ! Send file header ; 0879 STATE_SD = 3, ! Send file data packet ; 0880 STATE_SZ = 4, ! Send EOF packet ; 0881 STATE_SB = 5, ! Send break ; 0882 STATE_R = 6, ! Receive state (wait for send-init) ; 0883 STATE_RF = 7, ! Receive file header packet ; 0884 STATE_RD = 8, ! Receive file data packet ; 0885 STATE_C = 9, ! Send complete ; 0886 STATE_A = 10, ! Abort ; 0887 STATE_MAX = 10; ! Max state number ; 0888 ; 0889 %SBTTL 'Internal constants' ; 0890 ; 0891 !++ ; 0892 ! The following represent various internal KERMSG constants. ; 0893 !-- ; 0894 ; 0895 LITERAL ; 0896 MAX_PKT_RETRIES = 16, ! Maximum packet retries ; 0897 MAX_SI_RETRIES = 5; ! Maximum send init retries ; 0898 ; 0899 %SBTTL 'Storage - Global' ; 0900 ! ; 0901 ! OWN STORAGE: ; 0902 ! ; 0903 ; 0904 GLOBAL ; 0905 ! ; 0906 ! Receive parameters ; 0907 ! ; 0908 RCV_PKT_SIZE, ! Receive packet size ; 0909 RCV_NPAD, ! Padding length ; 0910 RCV_PADCHAR, ! Padding character ; 0911 RCV_TIMEOUT, ! Time out ; 0912 RCV_EOL, ! EOL character ; 0913 RCV_QUOTE_CHR, ! Quote character ; 0914 RCV_SOH, ! Start of header character ; 0915 RCV_8QUOTE_CHR, ! 8-bit quoting character ; 0916 ! ; 0917 ! Miscellaneous parameters ; 0918 ! ; 0919 SET_REPT_CHR, ! Repeat character ; 0920 ! ; 0921 ! Send parameters ; 0922 ! ; 0923 SND_PKT_SIZE, ! Send packet size ; 0924 SND_NPAD, ! Padding length ; 0925 SND_PADCHAR, ! Padding character ; 0926 SND_TIMEOUT, ! Time out ; 0927 SND_EOL, ! EOL character ; 0928 SND_QUOTE_CHR, ! Quote character ; 0929 SND_SOH, ! Start of header character ; 0930 ! ; 0931 ! Statistics ; 0932 ! ; 0933 SND_TOTAL_CHARS, ! Total characters sent ; 0934 RCV_TOTAL_CHARS, ! Total characters received ; 0935 SND_DATA_CHARS, ! Total number of data characters sent ; 0936 RCV_DATA_CHARS, ! Total number of data characters received ; 0937 SND_NAKS, ! Total NAKs sent ; 0938 RCV_NAKS, ! Total NAKs received ; 0939 SND_COUNT, ! Total number of packets sent ; 0940 RCV_COUNT, ! Total number of packets received ; 0941 SMSG_TOTAL_CHARS, ! Total chars sent this file xfer ; 0942 RMSG_TOTAL_CHARS, ! Total chars rcvd this file xfer ; 0943 SMSG_DATA_CHARS, ! Total data chars this file xfer ; 0944 RMSG_DATA_CHARS, ! Total data chars this file xfer ; 0945 SMSG_NAKS, ! Total number of NAKs this file xfer ; 0946 RMSG_NAKS, ! Total number of NAKs received ; 0947 XFR_TIME, ! Amount of time last xfr took ; 0948 TOTAL_TIME, ! Total time of all xfrs ; 0949 ! this file xfer ; 0950 LAST_ERROR : VECTOR [CH$ALLOCATION (MAX_MSG + 1)], ! Last error message ; 0951 ! ; 0952 ! Misc constants. ; 0953 ! ; 0954 FILE_NAME : VECTOR [CH$ALLOCATION (MAX_FILE_NAME)], ; 0955 FILE_SIZE, ; 0956 SI_RETRIES, ! Send init retries to attempt ; 0957 PKT_RETRIES, ! Number of retries to try for a message ; 0958 DELAY, ! Amount of time to delay ; 0959 DUPLEX, ! Type of connection (half or full) ; 0960 PARITY_TYPE, ! Type of parity to use ; 0961 DEV_PARITY_FLAG, ! True if output device does ; 0962 ! parity, false if we do it ; 0963 CHKTYPE, ! Type of block check desired ; 0964 ABT_FLAG, ! True if aborted file should be discarded ; 0965 DEBUG_FLAG, ! Debugging mode on/off ; 0966 WARN_FLAG, ! File warning flag ; 0967 IBM_FLAG, ! Talking to an IBM system ; 0968 IBM_CHAR, ! Turnaround character for IBM mode ; 0969 ECHO_FLAG, ! Local echo flag ; 0970 CONNECT_FLAG, ! Connected flag; True if ; 0971 ! terminal and SET LINE are ; 0972 ! the same ; 0973 ABT_CUR_FILE, ! Abort current file ; 0974 ABT_ALL_FILE, ! Abort all files in stream ; 0975 TY_FIL, ! Type file specs ; 0976 TY_PKT; ! Type packet info ; 0977 ; 0978 %SBTTL 'Storage - Local' ; 0979 ! ; 0980 ! LOCAL OWN STORAGE: ; 0981 ! ; 0982 ; 0983 OWN ; 0984 ! ; 0985 ! Receive parameters ; 0986 ! ; 0987 RECV_8QUOTE_CHR, ! 8th-bit quoting character ; 0988 REPT_CHR, ! Repeat prefix character ; 0989 ! ; 0990 ! Send parameters ; 0991 ! ; 0992 SEND_PKT_SIZE, ! Send packet size ; 0993 SEND_NPAD, ! Padding length ; 0994 SEND_PADCHAR, ! Padding character ; 0995 SEND_TIMEOUT, ! Time out ; 0996 SEND_EOL, ! EOL character ; 0997 SEND_QUOTE_CHR, ! Quote character ; 0998 SEND_8QUOTE_CHR, ! 8-bit quoting character ; 0999 ! ; 1000 ! Misc parameters ; 1001 ! ; 1002 INI_CHK_TYPE, ! Type of block checking from init message ; 1003 BLK_CHK_TYPE, ! Type of block check to use ; 1004 FLAG_8QUOTE, ! Flag to determine if doing 8bit quoting ; 1005 FLAG_REPEAT, ! True if doing repeated character compression ; 1006 STATUS, ! Status returned by various routines ; 1007 STATE, ! Current state ; 1008 SIZE, ! Size of the current message ; 1009 OLD_RETRIES, ! Saved number of retries done. ; 1010 NUM_RETRIES, ! Number of retries ; 1011 MSG_NUMBER, ! Current message number ; 1012 REC_SEQ, ! Sequence number of msg in REC_MSG ; 1013 REC_LENGTH, ! Length of the message recv'd ; 1014 REC_TYPE, ! Type of the message received. ; 1015 REC_MSG : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ! Message received ; 1016 SND_MSG : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ! Message sent ; 1017 FILE_OPEN_FLAG; ! File is opened. ; 1018 ; 1019 %SBTTL 'External references' ; 1020 ! ; 1021 ! EXTERNAL REFERENCES: ; 1022 ! ; 1023 ! Packet I/O routines ; 1024 ; 1025 EXTERNAL ROUTINE ; 1026 SEND, ! Send a packet to the remote ; 1027 IBM_WAIT, ! Wait for IBM turnaround ; 1028 RECEIVE; ! Receive a packet from the remote ; 1029 ; 1030 ! ; 1031 ! Terminal I/O routines ; 1032 ! ; 1033 ; 1034 EXTERNAL ROUTINE ; 1035 TERM_DUMP : NOVALUE, ! Normal terminal output ; 1036 DBG_DUMP : NOVALUE, ! Debugging output ; 1037 TT_SET_OUTPUT, ! Set output routine ; 1038 TT_CHAR : NOVALUE, ! Output a single character ; 1039 TT_CRLF : NOVALUE, ! Output a CRLF ; 1040 TT_NUMBER : NOVALUE, ! Output a three digit number to the ; 1041 ! terminal ; 1042 TT_TEXT : NOVALUE, ! Output a string to the user's ; 1043 TT_OUTPUT : NOVALUE; ! Force buffered output to terminal ; 1044 ; 1045 ! Operating system routines and misc routines ; 1046 ; 1047 EXTERNAL ROUTINE ; 1048 CRCCLC, ! Calculate a CRC-CCITT ; 1049 XFR_STATUS : NOVALUE, ! Routine to tell the user the ; 1050 ! status of a transfer ; 1051 KRM_ERROR : NOVALUE, ! Issue an error message ; 1052 SY_LOGOUT : NOVALUE, ! Log the job off ; 1053 SY_TIME, ! Return elapsed time in milliseconds ; 1054 SY_DISMISS : NOVALUE; ! Routine to dismiss for n seconds. ; 1055 ; 1056 ! ; 1057 ! External file processing routines ; 1058 ! ; 1059 ; 1060 EXTERNAL ROUTINE ; 1061 FILE_OPEN, ! Open a file for reading/writing ; 1062 FILE_CLOSE, ! Close an open file ; 1063 NEXT_FILE, ! Determine if there is a next file ; 1064 ! and open it for reading. ; 1065 GET_FILE, ! Get a byte from the file ; 1066 PUT_FILE, ! Put a byte in the file. ; 1067 FILE_DUMP; ! Dump the contents of the current ; 1068 ; 1069 ! record. Used for binary files ; 1070 ! if needed. ; 1071 %SBTTL 'MSG_INIT' ; 1072 ; 1073 GLOBAL ROUTINE MSG_INIT : NOVALUE = ; 1074 ; 1075 !++ ; 1076 ! FUNCTIONAL DESCRIPTION: ; 1077 ! ; 1078 ! This routine will initialize the message processing for ; 1079 ! KERMIT-32/36. ; 1080 ! ; 1081 ! CALLING SEQUENCE: ; 1082 ! ; 1083 ! MSG_INIT(); ; 1084 ! ; 1085 ! INPUT PARAMETERS: ; 1086 ! ; 1087 ! None. ; 1088 ! ; 1089 ! IMPLICIT INPUTS: ; 1090 ! ; 1091 ! None. ; 1092 ! ; 1093 ! OUTPUT PARAMETERS: ; 1094 ! ; 1095 ! None. ; 1096 ! ; 1097 ! IMPLICIT OUTPUTS: ; 1098 ! ; 1099 ! None. ; 1100 ! ; 1101 ! COMPLETION CODES: ; 1102 ! ; 1103 ! None. ; 1104 ! ; 1105 ! SIDE EFFECTS: ; 1106 ! ; 1107 ! None. ; 1108 ! ; 1109 !-- ; 1110 ; 1111 BEGIN ; 1112 ! ; 1113 ! Initialize some variables ; 1114 ! ; 1115 ! Receive parameters first ; 1116 ! ; 1117 RCV_PKT_SIZE = MY_PKT_SIZE; ; 1118 RCV_NPAD = MY_NPAD; ; 1119 RCV_PADCHAR = MY_PAD_CHAR; ; 1120 RCV_TIMEOUT = MY_TIME_OUT; ; 1121 RCV_EOL = MY_EOL_CHAR; ; 1122 RCV_QUOTE_CHR = MY_QUOTE_CHAR; ; 1123 RCV_SOH = CHR_SOH; ; 1124 RCV_8QUOTE_CHR = MY_8BIT_QUOTE; ; 1125 SET_REPT_CHR = MY_REPEAT; ; 1126 ! ; 1127 ! Send parameters. ; 1128 ! ; 1129 SND_PKT_SIZE = -MY_PKT_SIZE; ; 1130 SND_NPAD = -MY_NPAD; ; 1131 SND_PADCHAR = -MY_PAD_CHAR; ; 1132 SND_TIMEOUT = -MY_TIME_OUT; ; 1133 SND_EOL = -MY_EOL_CHAR; ; 1134 SND_QUOTE_CHR = -MY_QUOTE_CHAR; ; 1135 SND_SOH = CHR_SOH; ; 1136 ! ; 1137 ! Other random parameters ; 1138 ! ; 1139 PKT_RETRIES = MAX_PKT_RETRIES; ! Number of retries per message ; 1140 SI_RETRIES = MAX_SI_RETRIES; ! Number of retries on send inits ; 1141 DELAY = INIT_DELAY; ; 1142 DUPLEX = DP_FULL; ! Use full duplex ; 1143 DEBUG_FLAG = FALSE; ; 1144 WARN_FLAG = FALSE; ; 1145 ECHO_FLAG = FALSE; ; 1146 BLK_CHK_TYPE = CHK_1CHAR; ! Start using single char checksum ; 1147 CHKTYPE = MY_CHKTYPE; ! Desired block check type ; 1148 INI_CHK_TYPE = .CHKTYPE; ! Same as default for now ; 1149 DEV_PARITY_FLAG = FALSE; ! We generate parity ; 1150 PARITY_TYPE = PR_NONE; ! No parity ; 1151 ABT_FLAG = TRUE; ! Discard incomplete files ; 1152 FILE_OPEN_FLAG = FALSE; ; 1153 IBM_FLAG = FALSE; ! Not talking to an IBM ; 1154 IBM_CHAR = CHR_DC1; ! XON is IBM turnaround character ; 1155 TY_FIL = TRUE; ! Default to typing files ; 1156 TY_PKT = FALSE; ! But not packet numbers ; 1157 END; ! End of MSG_INIT .TITLE KERMSG .IDENT \2.0.017\ .PSECT $OWN$,NOEXE,2 ;RECV_8QUOTE_CHR U.84: .BLKB 4 ;REPT_CHR U.85: .BLKB 4 ;SEND_PKT_SIZE U.86: .BLKB 4 ;SEND_NPAD U.87: .BLKB 4 ;SEND_PADCHAR U.88: .BLKB 4 ;SEND_TIMEOUT U.89: .BLKB 4 ;SEND_EOL U.90: .BLKB 4 ;SEND_QUOTE_CHR U.91: .BLKB 4 ;SEND_8QUOTE_CHR U.92: .BLKB 4 ;INI_CHK_TYPE U.93: .BLKB 4 ;BLK_CHK_TYPE U.94: .BLKB 4 ;FLAG_8QUOTE U.95: .BLKB 4 ;FLAG_REPEAT U.96: .BLKB 4 ;STATUS U.97: .BLKB 4 ;STATE U.98: .BLKB 4 ;SIZE U.99: .BLKB 4 ;OLD_RETRIES U.100: .BLKB 4 ;NUM_RETRIES U.101: .BLKB 4 ;MSG_NUMBER U.102: .BLKB 4 ;REC_SEQ U.103: .BLKB 4 ;REC_LENGTH U.104: .BLKB 4 ;REC_TYPE U.105: .BLKB 4 ;REC_MSG U.106: .BLKB 96 ;SND_MSG U.107: .BLKB 96 ;FILE_OPEN_FLAG U.108: .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_SOH:: .BLKB 4 RCV_8QUOTE_CHR:: .BLKB 4 SET_REPT_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_SOH:: .BLKB 4 SND_TOTAL_CHARS:: .BLKB 4 RCV_TOTAL_CHARS:: .BLKB 4 SND_DATA_CHARS:: .BLKB 4 RCV_DATA_CHARS:: .BLKB 4 SND_NAKS:: .BLKB 4 RCV_NAKS:: .BLKB 4 SND_COUNT:: .BLKB 4 RCV_COUNT:: .BLKB 4 SMSG_TOTAL_CHARS:: .BLKB 4 RMSG_TOTAL_CHARS:: .BLKB 4 SMSG_DATA_CHARS:: .BLKB 4 RMSG_DATA_CHARS:: .BLKB 4 SMSG_NAKS:: .BLKB 4 RMSG_NAKS:: .BLKB 4 XFR_TIME:: .BLKB 4 TOTAL_TIME:: .BLKB 4 LAST_ERROR:: .BLKB 100 FILE_NAME:: .BLKB 132 FILE_SIZE:: .BLKB 4 SI_RETRIES:: .BLKB 4 PKT_RETRIES:: .BLKB 4 DELAY:: .BLKB 4 DUPLEX::.BLKB 4 PARITY_TYPE:: .BLKB 4 DEV_PARITY_FLAG:: .BLKB 4 CHKTYPE:: .BLKB 4 ABT_FLAG:: .BLKB 4 DEBUG_FLAG:: .BLKB 4 WARN_FLAG:: .BLKB 4 IBM_FLAG:: .BLKB 4 IBM_CHAR:: .BLKB 4 ECHO_FLAG:: .BLKB 4 CONNECT_FLAG:: .BLKB 4 ABT_CUR_FILE:: .BLKB 4 ABT_ALL_FILE:: .BLKB 4 TY_FIL::.BLKB 4 TY_PKT::.BLKB 4 PR_MIN== 0 PR_NONE== 0 PR_MARK== 1 PR_EVEN== 2 PR_ODD== 3 PR_SPACE== 4 PR_MAX== 4 GC_MIN== 0 GC_LOGOUT== 0 GC_EXIT== 1 GC_MAX== 1 DP_FULL== 0 DP_HALF== 1 CHK_1CHAR== 49 CHK_2CHAR== 50 CHK_CRC== 51 MAX_MSG== 96 .EXTRN SEND, IBM_WAIT, RECEIVE, TERM_DUMP, DBG_DUMP, TT_SET_OUTPUT, TT_CHAR, TT_CRLF, TT_NUMBER .EXTRN TT_TEXT, TT_OUTPUT, CRCCLC, XFR_STATUS, KRM_ERROR, SY_LOGOUT, SY_TIME, SY_DISMISS .EXTRN FILE_OPEN, FILE_CLOSE, NEXT_FILE, GET_FILE, PUT_FILE, FILE_DUMP .PSECT $CODE$,NOWRT,2 .ENTRY MSG_INIT, ^M ;MSG_INIT, Save R2 ; 1073 MOVAB W^CHKTYPE, R2 ;CHKTYPE, R2 ; MOVZBL #80, -388(R2) ;#80, RCV_PKT_SIZE ; 1117 CLRQ -384(R2) ;RCV_NPAD ; 1118 MOVL #15, -376(R2) ;#15, RCV_TIMEOUT ; 1120 MOVL #13, -372(R2) ;#13, RCV_EOL ; 1121 MOVL #35, -368(R2) ;#35, RCV_QUOTE_CHR ; 1122 MOVL #1, -364(R2) ;#1, RCV_SOH ; 1123 MOVL #38, -360(R2) ;#38, RCV_8QUOTE_CHR ; 1124 MOVZBL #126, -356(R2) ;#126, SET_REPT_CHR ; 1125 CVTBL #-80, -352(R2) ;#-80, SND_PKT_SIZE ; 1129 CLRQ -348(R2) ;SND_NPAD ; 1130 MNEGL #15, -340(R2) ;#15, SND_TIMEOUT ; 1132 MNEGL #13, -336(R2) ;#13, SND_EOL ; 1133 MNEGL #35, -332(R2) ;#35, SND_QUOTE_CHR ; 1134 MOVL #1, -328(R2) ;#1, SND_SOH ; 1135 MOVL #16, -20(R2) ;#16, PKT_RETRIES ; 1139 MOVL #5, -24(R2) ;#5, SI_RETRIES ; 1140 MOVQ #5, -16(R2) ;#5, DELAY ; 1141 CLRQ 8(R2) ;DEBUG_FLAG ; 1143 MOVL #49, W^U.94 ;#49, U.94 ; 1146 MOVL #49, (R2) ;#49, CHKTYPE ; 1147 MOVL (R2), W^U.93 ;CHKTYPE, U.93 ; 1148 CLRQ -8(R2) ;PARITY_TYPE ; 1150 MOVL #1, 4(R2) ;#1, ABT_FLAG ; 1151 CLRL W^U.108 ;U.108 ; 1152 CLRL 16(R2) ;IBM_FLAG ; 1153 MOVQ #17, 20(R2) ;#17, IBM_CHAR ; 1154 MOVQ #1, 40(R2) ;#1, TY_FIL ; 1155 RET ; ; 1073 ; Routine Size: 129 bytes, Routine Base: $CODE$ + 0000 ; 1158 ; 1159 %SBTTL 'SERVER - Server mode' ; 1160 ; 1161 GLOBAL ROUTINE SERVER = ; 1162 ; 1163 !++ ; 1164 ! FUNCTIONAL DESCRIPTION: ; 1165 ! ; 1166 ! This routine will handle the server function in the v2.0 protocol ; 1167 ! for KERMIT. This routine by it's nature will call various operating ; 1168 ! system routines to do things like logging off the system. ; 1169 ! ; 1170 ! CALLING SEQUENCE: ; 1171 ! ; 1172 ! EXIT_FLAG = SERVER(); ; 1173 ! ; 1174 ! INPUT PARAMETERS: ; 1175 ! ; 1176 ! None. ; 1177 ! ; 1178 ! IMPLICIT INPUTS: ; 1179 ! ; 1180 ! None. ; 1181 ! ; 1182 ! OUTPUT PARAMETERS: ; 1183 ! ; 1184 ! None. ; 1185 ! ; 1186 ! IMPLICIT OUTPUTS: ; 1187 ! ; 1188 ! None. ; 1189 ! ; 1190 ! COMPLETION CODES: ; 1191 ! ; 1192 ! None. ; 1193 ! ; 1194 ! SIDE EFFECTS: ; 1195 ! ; 1196 ! None. ; 1197 ! ; 1198 !-- ; 1199 ; 1200 BEGIN ; 1201 RETURN ; 1202 ; 1203 WHILE TRUE DO ; 1204 BEGIN ; 1205 INIT_XFR (); ! Set up so we can send a message ; 1206 STATUS = REC_PACKET (); ; 1207 ! ; 1208 ! Now determine what to do by the type of message we have receive. ; 1209 ! ; 1210 ; 1211 IF .STATUS EQL KER_ABORTED THEN EXITLOOP .STATUS; ; 1212 ; 1213 IF .STATUS ; 1214 THEN ; 1215 BEGIN ; 1216 ; 1217 SELECTONE .REC_TYPE OF ; 1218 SET ; 1219 ! ; 1220 ! Server initialization message received. ACK the ; 1221 ! message and continue. ; 1222 ! ; 1223 ! [MSG_SER_INIT] : ; 1224 ! BEGIN ; 1225 ! IF (STATUS = PRS_SEND_INIT ()) ; 1226 ! THEN ; 1227 ! BEGIN ; 1228 ! SET_SEND_INIT (); ; 1229 ! STATUS = SEND_PACKET (MSG_ACK, P_SI_LENGTH, .REC_SEQ); ; 1230 ! END; ; 1231 ! END; ; 1232 ! ; 1233 ! Send init message received. We must ACK the message and ; 1234 ! then attempt to receive a file from the remote. ; 1235 ! ; 1236 ; 1237 [MSG_SND_INIT] : ; 1238 BEGIN ; 1239 MSG_NUMBER = (.REC_SEQ + 1) AND %O'77'; ; 1240 ; 1241 IF (STATUS = PRS_SEND_INIT ()) ; 1242 THEN ; 1243 BEGIN ; 1244 SET_SEND_INIT (); ; 1245 ! ; 1246 ! ACK the message then receive everything. ; 1247 ! ; 1248 ; 1249 IF SEND_PACKET (MSG_ACK, P_SI_LENGTH, .REC_SEQ) ; 1250 THEN ; 1251 BEGIN ; 1252 STATE = STATE_RF; ; 1253 BLK_CHK_TYPE = .INI_CHK_TYPE; ; 1254 ! Switch to desired form of block check ; 1255 REC_SWITCH_WORKER (); ; 1256 END; ; 1257 ; 1258 END; ; 1259 ; 1260 END; ; 1261 ! ; 1262 ! Here if we receive a receive init message. ; 1263 ! We will be sending a file to the other end. ; 1264 ! ; 1265 ; 1266 [MSG_RCV_INIT] : ; 1267 BEGIN ; 1268 MSG_NUMBER = .REC_SEQ; ; 1269 ! ; 1270 ! Move the file specification if we received one ; 1271 ! ; 1272 ; 1273 IF .REC_LENGTH GTR 0 ; 1274 THEN ; 1275 BEGIN ; 1276 CH$COPY (.REC_LENGTH, CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE), ; 1277 CHR_NUL, MAX_FILE_NAME, CH$PTR (FILE_NAME)); ; 1278 FILE_SIZE = .REC_LENGTH; ; 1279 SEND_SWITCH_WORKER (); ; 1280 END ; 1281 ELSE ; 1282 BEGIN ; 1283 KRM_ERROR (KER_PROTOERR); ; 1284 END; ; 1285 ; 1286 END; ; 1287 ! ; 1288 ! Generic KERMIT commands ; 1289 ! ; 1290 ; 1291 [MSG_KERMIT] : ; 1292 BEGIN ; 1293 STATUS = SERVER_GENERIC (); ; 1294 ; 1295 IF .STATUS EQL KER_EXIT THEN EXITLOOP KER_EXIT; ; 1296 ; 1297 END; ; 1298 ! ; 1299 ! Unimplimented server routines ; 1300 ! ; 1301 ; 1302 [OTHERWISE] : ; 1303 KRM_ERROR (KER_UNISRV); ; 1304 TES; ; 1305 ; 1306 END ; 1307 ELSE ; 1308 SEND_PACKET (MSG_NAK, 0, 0); ; 1309 ; 1310 END; ; 1311 ; 1312 END; ! End of GLOBAL ROUTINE SERVER .ENTRY SERVER, ^M ;SERVER, Save R2,R3,R4,R5,R6,R7 ; 1161 MOVAB W^U.97, R7 ;U.97, R7 ; 1$: CALLS #0, W^U.27 ;#0, U.27 ; 1205 CALLS #0, W^U.23 ;#0, U.23 ; 1206 MOVL R0, (R7) ;R0, STATUS ; CMPL R0, #134316242 ;R0, #134316242 ; 1211 BNEQ 2$ ;2$ ; RET ; ; 2$: BLBS R0, 3$ ;R0, 3$ ; 1213 BRW 10$ ;10$ ; 3$: MOVL 32(R7), R0 ;REC_TYPE, R0 ; 1217 CMPL R0, #83 ;R0, #83 ; BNEQ 5$ ;5$ ; ADDL3 #1, 24(R7), R0 ;#1, REC_SEQ, R0 ; 1239 EXTZV #0, #6, R0, 20(R7) ;#0, #6, R0, MSG_NUMBER ; CALLS #0, W^U.18 ;#0, U.18 ; 1241 MOVL R0, (R7) ;R0, STATUS ; BLBC R0, 1$ ;R0, 1$ ; CALLS #0, W^U.17 ;#0, U.17 ; 1244 PUSHL 24(R7) ;REC_SEQ ; 1249 PUSHL #9 ;#9 ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; BLBC R0, 1$ ;R0, 1$ ; MOVL #7, 4(R7) ;#7, STATE ; 1252 MOVL -16(R7), -12(R7) ;INI_CHK_TYPE, BLK_CHK_TYPE ; 1253 CALLS #0, W^U.10 ;#0, U.10 ; 1255 4$: BRB 1$ ;1$ ; 1217 5$: CMPL R0, #82 ;R0, #82 ; BNEQ 7$ ;7$ ; MOVL 24(R7), 20(R7) ;REC_SEQ, MSG_NUMBER ; 1268 MOVL 28(R7), R6 ;REC_LENGTH, R6 ; 1273 BLEQ 6$ ;6$ ; MOVC5 R6, 40(R7), #0, #132, W^FILE_NAME ;R6, REC_MSG+4, #0, #132, FILE_NAME ; 1276 MOVL R6, W^FILE_SIZE ;R6, FILE_SIZE ; 1278 CALLS #0, W^U.2 ;#0, U.2 ; 1279 BRB 11$ ;11$ ; 1273 6$: PUSHL #134316210 ;#134316210 ; 1283 BRB 9$ ;9$ ; 7$: CMPL R0, #71 ;R0, #71 ; 1217 BNEQ 8$ ;8$ ; CALLS #0, W^U.14 ;#0, U.14 ; 1293 MOVL R0, (R7) ;R0, STATUS ; CMPL (R7), #134316187 ;STATUS, #134316187 ; 1295 BNEQ 4$ ;4$ ; MOVL #134316187, R0 ;#134316187, R0 ; RET ; ; 8$: PUSHL #134316202 ;#134316202 ; 1303 9$: CALLS #1, W^KRM_ERROR ;#1, KRM_ERROR ; BRB 4$ ;4$ ; 1213 10$: CLRQ -(SP) ;-(SP) ; 1308 MOVZBL #78, -(SP) ;#78, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; 11$: BRB 4$ ;4$ ; 1203 RET ; ; 1161 ; Routine Size: 221 bytes, Routine Base: $CODE$ + 0081 ; 1313 ; 1314 %SBTTL 'SERVER - Generic commands' ; 1315 ROUTINE SERVER_GENERIC = ; 1316 ; 1317 !++ ; 1318 ! FUNCTIONAL DESCRIPTION: ; 1319 ! ; 1320 ! This routine will handle the generic server messages. ; 1321 ! The generic server messages include FINISH, LOGOUT. ; 1322 ! ; 1323 ! CALLING SEQUENCE: ; 1324 ! ; 1325 ! SERVER_GENERIC(); ; 1326 ! ; 1327 ! INPUT PARAMETERS: ; 1328 ! ; 1329 ! None. ; 1330 ! ; 1331 ! IMPLICIT INPUTS: ; 1332 ! ; 1333 ! Generic message receive in REC_MSG. ; 1334 ! ; 1335 ! OUTPUT PARAMETERS: ; 1336 ! ; 1337 ! None. ; 1338 ! ; 1339 ! IMPLICIT OUTPUTS: ; 1340 ! ; 1341 ! None. ; 1342 ! ; 1343 ! COMPLETION CODES: ; 1344 ! ; 1345 ! None. ; 1346 ! ; 1347 ! SIDE EFFECTS: ; 1348 ! ; 1349 ! None. ; 1350 ! ; 1351 !-- ; 1352 ; 1353 BEGIN ; 1354 ; 1355 SELECTONE CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE)) OF ; 1356 SET ; 1357 ! ; 1358 ! EXIT command, just return the status to the upper level ; 1359 ! ; 1360 ; 1361 [MSG_GEN_EXIT] : ; 1362 BEGIN ; 1363 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 1364 RETURN KER_EXIT; ; 1365 END; ; 1366 ! ; 1367 ! LOGOUT command, ACK the message then call the system routine to ; 1368 ! kill the process (log the job out, etc.) ; 1369 ! ; 1370 ; 1371 [MSG_GEN_LOGOUT] : ; 1372 BEGIN ; 1373 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 1374 SY_LOGOUT (); ; 1375 RETURN KER_NORMAL; ; 1376 END; ; 1377 ! ; 1378 ! This routine will cause files to be deleted from disk. ; 1379 ! ; 1380 ![MSG_GEN_DELETE] : ; 1381 ! BEGIN ; 1382 ! END; ; 1383 ! ; 1384 ! This routine will cause file(s) to be printed on the line printer. ; 1385 ! ; 1386 ![MSG_GEN_PRINT] : ; 1387 ! BEGIN ; 1388 ! END; ; 1389 ! ; 1390 ! Here if we have a function that is currently not implemented ; 1391 ! return a unimplmented server function error code. ; 1392 ! ; 1393 ; 1394 [OTHERWISE] : ; 1395 BEGIN ; 1396 KRM_ERROR (KER_UNIMPLGEN); ; 1397 RETURN KER_UNIMPLGEN; ; 1398 END; ; 1399 TES; ; 1400 ; 1401 END; ! End of SERVER_GENERIC ;SERVER_GENERIC U.14: .WORD ^M<> ;Save nothing ; 1315 MOVZBL W^U.106+4, R0 ;U.106+4, R0 ; 1355 CMPB R0, #70 ;R0, #70 ; BNEQ 1$ ;1$ ; PUSHL W^U.103 ;U.103 ; 1363 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; MOVL #134316187, R0 ;#134316187, R0 ; 1355 RET ; ; 1$: CMPB R0, #76 ;R0, #76 ; BNEQ 2$ ;2$ ; PUSHL W^U.103 ;U.103 ; 1373 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; CALLS #0, W^SY_LOGOUT ;#0, SY_LOGOUT ; 1374 MOVL #134316043, R0 ;#134316043, R0 ; 1355 RET ; ; 2$: PUSHL #134316194 ;#134316194 ; 1396 CALLS #1, W^KRM_ERROR ;#1, KRM_ERROR ; MOVL #134316194, R0 ;#134316194, R0 ; 1355 RET ; ; 1315 ; Routine Size: 89 bytes, Routine Base: $CODE$ + 015E ; 1402 %SBTTL 'Server -- DO_GENERIC - Execute a generic command' ; 1403 ; 1404 GLOBAL ROUTINE DO_GENERIC (TYPE) = ; 1405 ; 1406 !++ ; 1407 ! FUNCTIONAL DESCRIPTION: ; 1408 ! ; 1409 ! This routine will send a generic command to the remote Kermit. ; 1410 ! it will do all the processing required for the generic command ; 1411 ! that was executed. It will return to the caller after the ; 1412 ! command has be executed. ; 1413 ! ; 1414 ! CALLING SEQUENCE: ; 1415 ! ; 1416 ! STATUS = DO_GENERIC (Command-type); ; 1417 ! ; 1418 ! INPUT PARAMETERS: ; 1419 ! ; 1420 ! Command-type -- Command type to be executed. ; 1421 ! ; 1422 ! IMPLICIT INPUTS: ; 1423 ! ; 1424 ! None. ; 1425 ! ; 1426 ! OUTPUT PARAMETERS: ; 1427 ! ; 1428 ! None. ; 1429 ! ; 1430 ! IMPLICIT OUTPUTS: ; 1431 ! ; 1432 ! None. ; 1433 ! ; 1434 ! COMPLETION CODES: ; 1435 ! ; 1436 ! None. ; 1437 ! ; 1438 ! SIDE EFFECTS: ; 1439 ! ; 1440 ! None. ; 1441 ! ; 1442 !-- ; 1443 ; 1444 BEGIN ; 1445 INIT_XFR (); ; 1446 ; 1447 CASE .TYPE FROM GC_MIN TO GC_MAX OF ; 1448 SET ; 1449 ! ; 1450 ! Here if the caller wants the remote server Kermit to exit ; 1451 ! to the operating system prompt level. We send the generic ; 1452 ! message and wait until it is ACK'd. ; 1453 ! Resend the message if we must. ; 1454 ! ; 1455 ; 1456 [GC_EXIT] : ; 1457 BEGIN ; 1458 CH$WCHAR (MSG_GEN_EXIT, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE)); ; 1459 ; 1460 WHILE TRUE DO ; 1461 BEGIN ; 1462 ; 1463 IF NOT (STATUS = SEND_PACKET (MSG_KERMIT, 1, 0)) THEN RETURN .STATUS; ; 1464 ; 1465 IF NOT (STATUS = REC_PACKET ()) THEN RETURN .STATUS; ; 1466 ; 1467 IF .REC_TYPE EQL MSG_ACK AND .REC_SEQ EQL 0 THEN EXITLOOP; ; 1468 ; 1469 END; ; 1470 ; 1471 RETURN KER_NORMAL; ; 1472 END; ; 1473 ! ; 1474 ! Here if the caller wants the remote server to die off. ; 1475 ! Send the generic LOGOUT message and wait until it is ACK'd. ; 1476 ! Resend the message if we must. ; 1477 ! ; 1478 ; 1479 [GC_LOGOUT] : ; 1480 BEGIN ; 1481 CH$WCHAR (MSG_GEN_LOGOUT, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE)); ; 1482 ; 1483 WHILE TRUE DO ; 1484 BEGIN ; 1485 ; 1486 IF NOT (STATUS = SEND_PACKET (MSG_KERMIT, 1, 0)) THEN RETURN .STATUS; ; 1487 ; 1488 IF NOT (STATUS = REC_PACKET ()) THEN RETURN .STATUS; ; 1489 ; 1490 IF .REC_TYPE EQL MSG_ACK AND .REC_SEQ EQL 0 THEN EXITLOOP; ; 1491 ; 1492 END; ; 1493 ; 1494 RETURN KER_NORMAL; ; 1495 END; ; 1496 ! ; 1497 ! Here if the caller wants us to send something that we currently ; 1498 ! don't support. We will return an unimplemented code to the caller. ; 1499 ! ; 1500 ; 1501 [INRANGE, OUTRANGE] : ; 1502 BEGIN ; 1503 KRM_ERROR (KER_UNIMPLGEN); ; 1504 RETURN KER_UNIMPLGEN; ; 1505 END; ; 1506 TES; ; 1507 ; 1508 END; ! End of DO_GENERIC .ENTRY DO_GENERIC, ^M ;DO_GENERIC, Save R2 ; 1404 MOVAB W^U.97, R2 ;U.97, R2 ; CALLS #0, W^U.27 ;#0, U.27 ; 1445 CASEL 4(AP), #0, #1 ;TYPE, #0, #1 ; 1444 1$: .WORD 4$-1$,- ;4$-1$,- ; 2$-1$ ;2$-1$ ; PUSHL #134316194 ;#134316194 ; 1503 CALLS #1, W^KRM_ERROR ;#1, KRM_ERROR ; MOVL #134316194, R0 ;#134316194, R0 ; 1444 RET ; ; 2$: MOVB #70, 136(R2) ;#70, SND_MSG+4 ; 1458 3$: MOVQ #1, -(SP) ;#1, -(SP) ; 1463 MOVZBL #71, -(SP) ;#71, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; MOVL R0, (R2) ;R0, STATUS ; BLBC R0, 6$ ;R0, 6$ ; CALLS #0, W^U.23 ;#0, U.23 ; 1465 MOVL R0, (R2) ;R0, STATUS ; BLBC R0, 6$ ;R0, 6$ ; CMPL 32(R2), #89 ;REC_TYPE, #89 ; 1467 BNEQ 3$ ;3$ ; TSTL 24(R2) ;REC_SEQ ; BNEQ 3$ ;3$ ; BRB 8$ ;8$ ; 1444 4$: MOVB #76, 136(R2) ;#76, SND_MSG+4 ; 1481 5$: MOVQ #1, -(SP) ;#1, -(SP) ; 1486 MOVZBL #71, -(SP) ;#71, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; MOVL R0, (R2) ;R0, STATUS ; BLBC R0, 6$ ;R0, 6$ ; CALLS #0, W^U.23 ;#0, U.23 ; 1488 MOVL R0, (R2) ;R0, STATUS ; BLBS R0, 7$ ;R0, 7$ ; 6$: MOVL (R2), R0 ;STATUS, R0 ; RET ; ; 7$: CMPL 32(R2), #89 ;REC_TYPE, #89 ; 1490 BNEQ 5$ ;5$ ; TSTL 24(R2) ;REC_SEQ ; BNEQ 5$ ;5$ ; 8$: MOVL #134316043, R0 ;#134316043, R0 ; 1444 RET ; ; 1404 ; Routine Size: 154 bytes, Routine Base: $CODE$ + 01B7 ; 1509 ; 1510 %SBTTL 'SEND_SWITCH' ; 1511 ; 1512 GLOBAL ROUTINE SEND_SWITCH = ; 1513 ; 1514 !++ ; 1515 ! FUNCTIONAL DESCRIPTION: ; 1516 ! ; 1517 ! This routine is the state table switcher for sending files. It ; 1518 ! loops until either it is finished or an error is encountered. The ; 1519 ! routines called by SEND_SWITCH are responsible for changing the state. ; 1520 ! ; 1521 ! CALLING SEQUENCE: ; 1522 ! ; 1523 ! SEND_SWITCH(); ; 1524 ! ; 1525 ! INPUT PARAMETERS: ; 1526 ! ; 1527 ! None. ; 1528 ! ; 1529 ! IMPLICIT INPUTS: ; 1530 ! ; 1531 ! None. ; 1532 ! ; 1533 ! OUTPUT PARAMETERS: ; 1534 ! ; 1535 ! Returns: ; 1536 ! TRUE - File sent correctly. ; 1537 ! FALSE - Aborted sending the file. ; 1538 ! ; 1539 ! IMPLICIT OUTPUTS: ; 1540 ! ; 1541 ! None. ; 1542 ! ; 1543 ! COMPLETION CODES: ; 1544 ! ; 1545 ! None. ; 1546 ! ; 1547 ! SIDE EFFECTS: ; 1548 ! ; 1549 ! None. ; 1550 ! ; 1551 !-- ; 1552 ; 1553 BEGIN ; 1554 ; 1555 IF .CONNECT_FLAG THEN SY_DISMISS (.DELAY); ! Sleep if the user wanted us to ; 1556 ; 1557 RETURN SEND_SWITCH_WORKER (); ! Call routine to do real work ; 1558 END; U.1: .ENTRY SEND_SWITCH, ^M<> ;SEND_SWITCH, Save nothing ; 1512 BLBC W^CONNECT_FLAG, 1$ ;CONNECT_FLAG, 1$ ; 1555 PUSHL W^DELAY ;DELAY ; CALLS #1, W^SY_DISMISS ;#1, SY_DISMISS ; 1$: CALLS #0, W^U.2 ;#0, U.2 ; 1557 RET ; ; 1512 ; Routine Size: 22 bytes, Routine Base: $CODE$ + 0251 ; 1559 ; 1560 %SBTTL 'SEND_SWITCH_WORKER' ; 1561 ROUTINE SEND_SWITCH_WORKER = ; 1562 ; 1563 !++ ; 1564 ! FUNCTIONAL DESCRIPTION: ; 1565 ! ; 1566 ! This routine is the state table switcher for sending files. It ; 1567 ! loops until either it is finished or an error is encountered. The ; 1568 ! routines called by SEND_SWITCH_WORKER are responsible for changing ; 1569 ! the state. ; 1570 ! ; 1571 ! CALLING SEQUENCE: ; 1572 ! ; 1573 ! SEND_SWITCH_WORKER(); ; 1574 ! ; 1575 ! INPUT PARAMETERS: ; 1576 ! ; 1577 ! None. ; 1578 ! ; 1579 ! IMPLICIT INPUTS: ; 1580 ! ; 1581 ! None. ; 1582 ! ; 1583 ! OUTPUT PARAMETERS: ; 1584 ! ; 1585 ! Returns: ; 1586 ! TRUE - File sent correctly. ; 1587 ! FALSE - Aborted sending the file. ; 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 LOCAL ; 1606 VAL_RETURN, ; 1607 FINISHED; ; 1608 ; 1609 INIT_XFR (); ! Initialize for this transfer ; 1610 STATE = STATE_S; ! Initial state is send ; 1611 NUM_RETRIES = 0; ! Initialize number of retries ; 1612 MSG_NUMBER = 0; ! Initial message number ; 1613 CLEAR (); ! Clear the message buffers ; 1614 FINISHED = FALSE; ; 1615 ; 1616 DO ; 1617 BEGIN ; 1618 ; 1619 CASE .STATE FROM STATE_MIN TO STATE_MAX OF ; 1620 SET ; 1621 ; 1622 [STATE_SD] : ; 1623 STATE = SEND_DATA (); ; 1624 ; 1625 [STATE_SF] : ; 1626 STATE = SEND_FILE (); ; 1627 ; 1628 [STATE_SZ] : ; 1629 STATE = SEND_EOF (); ; 1630 ; 1631 [STATE_S] : ; 1632 STATE = SEND_INIT (); ; 1633 ; 1634 [STATE_SB] : ; 1635 STATE = SEND_BREAK (); ; 1636 ; 1637 [STATE_C] : ; 1638 BEGIN ; 1639 FINISHED = TRUE; ; 1640 VAL_RETURN = TRUE; ; 1641 END; ; 1642 ; 1643 [STATE_A] : ; 1644 BEGIN ; 1645 ; 1646 IF .FILE_OPEN_FLAG ; 1647 THEN ; 1648 BEGIN ; 1649 ; 1650 IF ( NOT .CONNECT_FLAG) AND .TY_FIL ; 1651 THEN ; 1652 BEGIN ; 1653 TT_TEXT (UPLIT (%ASCIZ' [Aborted]')); ; 1654 TT_CRLF (); ! End the line ; 1655 END; ; 1656 ; 1657 FILE_CLOSE (FALSE); ; 1658 FILE_OPEN_FLAG = FALSE; ; 1659 END; ; 1660 ; 1661 FINISHED = TRUE; ; 1662 VAL_RETURN = FALSE; ; 1663 END; ; 1664 ; 1665 [INRANGE, OUTRANGE] : ; 1666 BEGIN ; 1667 FINISHED = TRUE; ; 1668 VAL_RETURN = FALSE; ; 1669 END; ; 1670 TES ; 1671 ; 1672 END ; 1673 UNTIL (.FINISHED EQL TRUE); ; 1674 ; 1675 ! ; 1676 ! Close off the stats and return ; 1677 ! ; 1678 END_STATS (); ; 1679 RETURN .VAL_RETURN; ; 1680 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAA: .ASCII \ [Aborted]\<0><0> ; ; .PSECT $CODE$,NOWRT,2 ;SEND_SWITCH_WORKER U.2: .WORD ^M ;Save R2,R3,R4 ; 1561 MOVAB W^U.98, R4 ;U.98, R4 ; CALLS #0, W^U.27 ;#0, U.27 ; 1609 MOVL #1, (R4) ;#1, STATE ; 1610 CLRQ 12(R4) ;NUM_RETRIES ; 1611 CALLS #0, W^U.26 ;#0, U.26 ; 1613 CLRL R2 ;FINISHED ; 1614 1$: CASEL (R4), #0, #10 ;STATE, #0, #10 ; 1617 2$: .WORD 12$-2$,- ;12$-2$,- ; 6$-2$,- ;6$-2$,- ; 4$-2$,- ;4$-2$,- ; 3$-2$,- ;3$-2$,- ; 5$-2$,- ;5$-2$,- ; 7$-2$,- ;7$-2$,- ; 12$-2$,- ;12$-2$,- ; 12$-2$,- ;12$-2$,- ; 12$-2$,- ;12$-2$,- ; 9$-2$,- ;9$-2$,- ; 10$-2$ ;10$-2$ ; BRB 12$ ;12$ ; 1667 3$: CALLS #0, W^U.3 ;#0, U.3 ; 1623 BRB 8$ ;8$ ; 4$: CALLS #0, W^U.4 ;#0, U.4 ; 1626 BRB 8$ ;8$ ; 5$: CALLS #0, W^U.5 ;#0, U.5 ; 1629 BRB 8$ ;8$ ; 6$: CALLS #0, W^U.6 ;#0, U.6 ; 1632 BRB 8$ ;8$ ; 7$: CALLS #0, W^U.7 ;#0, U.7 ; 1635 8$: MOVL R0, (R4) ;R0, STATE ; BRB 13$ ;13$ ; 1617 9$: MOVL #1, R2 ;#1, FINISHED ; 1639 MOVL #1, R3 ;#1, VAL_RETURN ; 1640 BRB 13$ ;13$ ; 1617 10$: BLBC 224(R4), 12$ ;FILE_OPEN_FLAG, 12$ ; 1646 BLBS W^CONNECT_FLAG, 11$ ;CONNECT_FLAG, 11$ ; 1650 BLBC W^TY_FIL, 11$ ;TY_FIL, 11$ ; PUSHAB W^P.AAA ;P.AAA ; 1653 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 1654 11$: CLRL -(SP) ;-(SP) ; 1657 CALLS #1, W^FILE_CLOSE ;#1, FILE_CLOSE ; CLRL 224(R4) ;FILE_OPEN_FLAG ; 1658 12$: MOVQ #1, R2 ;#1, FINISHED ; 1661 13$: CMPL R2, #1 ;FINISHED, #1 ; 1673 BNEQ 1$ ;1$ ; CALLS #0, W^U.15 ;#0, U.15 ; 1678 MOVL R3, R0 ;VAL_RETURN, R0 ; 1603 RET ; ; 1561 ; Routine Size: 156 bytes, Routine Base: $CODE$ + 0267 ; 1681 %SBTTL 'SEND_DATA' ; 1682 ROUTINE SEND_DATA = ; 1683 ; 1684 !++ ; 1685 ! FUNCTIONAL DESCRIPTION: ; 1686 ! ; 1687 ! This routine will send a data message to the remote KERMIT. ; 1688 ! ; 1689 ! CALLING SEQUENCE: ; 1690 ! ; 1691 ! STATE = SEND_DATA(); ; 1692 ! ; 1693 ! INPUT PARAMETERS: ; 1694 ! ; 1695 ! None. ; 1696 ! ; 1697 ! IMPLICIT INPUTS: ; 1698 ! ; 1699 ! None. ; 1700 ! ; 1701 ! OUTPUT PARAMETERS: ; 1702 ! ; 1703 ! New state to change the finite state machine to. ; 1704 ! ; 1705 ! IMPLICIT OUTPUTS: ; 1706 ! ; 1707 ! None. ; 1708 ! ; 1709 ! COMPLETION CODES: ; 1710 ! ; 1711 ! None. ; 1712 ! ; 1713 ! SIDE EFFECTS: ; 1714 ! ; 1715 ! None. ; 1716 ! ; 1717 !-- ; 1718 ; 1719 BEGIN ; 1720 ! ; 1721 ! Check to see if the number of retries have been exceeded. ; 1722 ! ; 1723 ; 1724 IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A; ; 1725 ; 1726 ! ; 1727 ! Not exceeded yet. Increment the number of retries we have attempted ; 1728 ! on this message. ; 1729 ! ; 1730 NUM_RETRIES = .NUM_RETRIES + 1; ; 1731 ! ; 1732 ! Attempt to send the packet and abort if the send fails. ; 1733 ! ; 1734 ; 1735 IF NOT SEND_PACKET (MSG_DATA, .SIZE, .MSG_NUMBER) THEN RETURN STATE_A; ; 1736 ; 1737 ! ; 1738 ! Attempt to receive a message from the remote KERMIT. ; 1739 ! ; 1740 STATUS = REC_PACKET (); ; 1741 ; 1742 IF NOT .STATUS ; 1743 THEN ; 1744 BEGIN ; 1745 ; 1746 IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR) ; 1747 THEN ; 1748 RETURN .STATE ; 1749 ELSE ; 1750 RETURN STATE_A; ; 1751 ; 1752 END; ; 1753 ; 1754 ! ; 1755 ! Determine if the message is a NAK and the NAK is for the message number ; 1756 ! that we are current working on. If the NAK is for the next packet then ; 1757 ! ignore the NAK ; 1758 ! ; 1759 ; 1760 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1761 ; 1762 ! ; 1763 ! Make sure we have a NAK or ACK ; 1764 ! ; 1765 ; 1766 IF .REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK ; 1767 THEN ; 1768 BEGIN ; 1769 ! ; 1770 ! Is this for this message? ; 1771 ! ; 1772 ; 1773 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 1774 ; 1775 ! ; 1776 ! It was. Set up for sending the next data message to the remote KERMIT ; 1777 ! and return. ; 1778 ! ; 1779 ! ; 1780 ! Check for data field in ACK indicating abort file or stream ; 1781 ! ; 1782 ! ; 1783 ; 1784 IF .REC_TYPE EQL MSG_ACK AND .REC_LENGTH EQL 1 ; 1785 THEN ; 1786 ; 1787 SELECTONE CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE)) OF ; 1788 SET ; 1789 ; 1790 [MSG_ACK_ABT_CUR] : ; 1791 ABT_CUR_FILE = TRUE; ; 1792 ; 1793 [MSG_ACK_ABT_ALL] : ; 1794 ABT_ALL_FILE = TRUE; ; 1795 TES; ; 1796 ; 1797 NUM_RETRIES = 0; ; 1798 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1799 ; 1800 IF (BFR_FILL (FALSE) EQL KER_NORMAL) AND NOT (.ABT_CUR_FILE OR .ABT_ALL_FILE) ; 1801 THEN ; 1802 RETURN STATE_SD ; 1803 ELSE ; 1804 BEGIN ; 1805 ; 1806 IF ( NOT .CONNECT_FLAG) AND .TY_FIL ; 1807 THEN ; 1808 BEGIN ; 1809 ; 1810 IF .ABT_ALL_FILE ; 1811 THEN ; 1812 TT_TEXT (UPLIT (%ASCIZ' [Group interrupted]')) ; 1813 ELSE ; 1814 ; 1815 IF .ABT_CUR_FILE ; 1816 THEN ; 1817 TT_TEXT (UPLIT (%ASCIZ' [Interrupted]')) ; 1818 ELSE ; 1819 TT_TEXT (UPLIT (%ASCIZ' [OK]')); ; 1820 ; 1821 TT_CRLF (); ; 1822 END; ; 1823 ; 1824 FILE_CLOSE (FALSE); ; 1825 FILE_OPEN_FLAG = FALSE; ; 1826 RETURN STATE_SZ; ; 1827 END; ; 1828 ; 1829 END ; 1830 ELSE ; 1831 ! ; 1832 ! Not an ACK or NAK, abort. ; 1833 ! ; 1834 RETURN STATE_A; ; 1835 ; 1836 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAB: .ASCII \ [Group interrupted]\<0><0><0><0> ; ; P.AAC: .ASCII \ [Interrupted]\<0><0> ; ; P.AAD: .ASCII \ [OK]\<0><0><0> ; ; .PSECT $CODE$,NOWRT,2 ;SEND_DATA U.3: .WORD ^M ;Save R2,R3 ; 1682 MOVAB W^ABT_CUR_FILE, R3 ;ABT_CUR_FILE, R3 ; MOVAB W^U.102, R2 ;U.102, R2 ; CMPL -4(R2), -52(R3) ;NUM_RETRIES, PKT_RETRIES ; 1724 BGTR 1$ ;1$ ; INCL -4(R2) ;NUM_RETRIES ; 1730 PUSHL (R2) ;MSG_NUMBER ; 1735 PUSHL -12(R2) ;SIZE ; MOVZBL #68, -(SP) ;#68, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; BLBC R0, 1$ ;R0, 1$ ; CALLS #0, W^U.23 ;#0, U.23 ; 1740 MOVL R0, -20(R2) ;R0, STATUS ; BLBS R0, 2$ ;R0, 2$ ; 1742 CMPL R0, #134316218 ;R0, #134316218 ; 1746 BEQL 6$ ;6$ ; CMPL R0, #134316232 ;R0, #134316232 ; BEQL 6$ ;6$ ; CMPL R0, #134316162 ;R0, #134316162 ; BEQL 6$ ;6$ ; 1$: BRW 15$ ;15$ ; 1744 2$: CLRL R1 ;R1 ; 1760 CMPL 12(R2), #78 ;REC_TYPE, #78 ; BNEQ 3$ ;3$ ; INCL R1 ;R1 ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R2) ;#0, #6, R0, REC_SEQ ; BNEQ 6$ ;6$ ; 3$: CLRL R0 ;R0 ; 1766 CMPL 12(R2), #89 ;REC_TYPE, #89 ; BNEQ 4$ ;4$ ; INCL R0 ;R0 ; BRB 5$ ;5$ ; 4$: BLBC R1, 1$ ;R1, 1$ ; 5$: CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 1773 BEQL 7$ ;7$ ; 6$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 7$: BLBC R0, 9$ ;R0, 9$ ; 1784 CMPL 8(R2), #1 ;REC_LENGTH, #1 ; BNEQ 9$ ;9$ ; MOVZBL 20(R2), R0 ;REC_MSG+4, R0 ; 1787 CMPB R0, #88 ;R0, #88 ; BNEQ 8$ ;8$ ; MOVL #1, (R3) ;#1, ABT_CUR_FILE ; 1791 BRB 9$ ;9$ ; 1787 8$: CMPB R0, #90 ;R0, #90 ; BNEQ 9$ ;9$ ; MOVL #1, 4(R3) ;#1, ABT_ALL_FILE ; 1794 9$: CLRL -4(R2) ;NUM_RETRIES ; 1797 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 1798 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; CLRL -(SP) ;-(SP) ; 1800 CALLS #1, W^U.25 ;#1, U.25 ; CMPL R0, #134316043 ;R0, #134316043 ; BNEQ 10$ ;10$ ; BLBS (R3), 10$ ;ABT_CUR_FILE, 10$ ; BLBS 4(R3), 10$ ;ABT_ALL_FILE, 10$ ; MOVL #3, R0 ;#3, R0 ; 1768 RET ; ; 10$: BLBS -4(R3), 14$ ;CONNECT_FLAG, 14$ ; 1806 BLBC 8(R3), 14$ ;TY_FIL, 14$ ; BLBC 4(R3), 11$ ;ABT_ALL_FILE, 11$ ; 1810 PUSHAB W^P.AAB ;P.AAB ; 1812 BRB 13$ ;13$ ; 11$: BLBC (R3), 12$ ;ABT_CUR_FILE, 12$ ; 1815 PUSHAB W^P.AAC ;P.AAC ; 1817 BRB 13$ ;13$ ; 12$: PUSHAB W^P.AAD ;P.AAD ; 1819 13$: CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 1821 14$: CLRL -(SP) ;-(SP) ; 1824 CALLS #1, W^FILE_CLOSE ;#1, FILE_CLOSE ; CLRL 208(R2) ;FILE_OPEN_FLAG ; 1825 MOVL #4, R0 ;#4, R0 ; 1768 RET ; ; 1719 15$: MOVL #10, R0 ;#10, R0 ; RET ; ; 1682 ; Routine Size: 270 bytes, Routine Base: $CODE$ + 0303 ; 1837 %SBTTL 'SEND_FILE' ; 1838 ROUTINE SEND_FILE = ; 1839 ; 1840 !++ ; 1841 ! FUNCTIONAL DESCRIPTION: ; 1842 ! ; 1843 ! This routine will send the file specification that is being ; 1844 ! transfered. ; 1845 ! ; 1846 ! CALLING SEQUENCE: ; 1847 ! ; 1848 ! STATE = SEND_FILE(); ; 1849 ! ; 1850 ! INPUT PARAMETERS: ; 1851 ! ; 1852 ! None. ; 1853 ! ; 1854 ! IMPLICIT INPUTS: ; 1855 ! ; 1856 ! None. ; 1857 ! ; 1858 ! OUTPUT PARAMETERS: ; 1859 ! ; 1860 ! New state to change the finite state machine to. ; 1861 ! ; 1862 ! IMPLICIT OUTPUTS: ; 1863 ! ; 1864 ! None. ; 1865 ! ; 1866 ! COMPLETION CODES: ; 1867 ! ; 1868 ! None. ; 1869 ! ; 1870 ! SIDE EFFECTS: ; 1871 ! ; 1872 ! None. ; 1873 ! ; 1874 !-- ; 1875 ; 1876 BEGIN ; 1877 ! ; 1878 ! Flag we don't want to abort yet ; 1879 ! ; 1880 ABT_CUR_FILE = FALSE; ; 1881 ABT_ALL_FILE = FALSE; ; 1882 ! ; 1883 ! First determine if we have exceed the number of retries that are ; 1884 ! allowed to attempt to send this message. ; 1885 ! ; 1886 ; 1887 IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A; ; 1888 ; 1889 ! ; 1890 ! The number of retries are not exceeded. Increment the number and then ; 1891 ! attempt to send the packet again. ; 1892 ! ; 1893 NUM_RETRIES = .NUM_RETRIES + 1; ; 1894 ; 1895 IF .FILE_SIZE NEQ 0 ; 1896 THEN ; 1897 CH$MOVE (.FILE_SIZE, CH$PTR (FILE_NAME), ; 1898 CH$PTR (SND_MSG, PKT_MSG, ; 1899 CHR_SIZE)); ; 1900 ; 1901 IF NOT SEND_PACKET (MSG_FILE, .FILE_SIZE, .MSG_NUMBER) THEN RETURN STATE_A; ; 1902 ; 1903 ! ; 1904 ! Now get the responce from the remote KERMIT. ; 1905 ! ; 1906 STATUS = REC_PACKET (); ; 1907 ; 1908 IF NOT .STATUS ; 1909 THEN ; 1910 BEGIN ; 1911 ; 1912 IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR) ; 1913 THEN ; 1914 RETURN .STATE ; 1915 ELSE ; 1916 RETURN STATE_A; ; 1917 ; 1918 END; ; 1919 ; 1920 ! ; 1921 ! Determine if the packet is good. ; 1922 ! ; 1923 ; 1924 IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A; ; 1925 ; 1926 ! ; 1927 ! If this is a NAK and the message number is not the one we just send ; 1928 ! treat this like an ACK, otherwise resend the last packet. ; 1929 ! ; 1930 ; 1931 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1932 ; 1933 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 1934 ; 1935 ! ; 1936 ! If all is ok, bump the message number and fill first buffer ; 1937 ! ; 1938 NUM_RETRIES = 0; ; 1939 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 1940 ; 1941 IF BFR_FILL (TRUE) THEN RETURN STATE_SD ELSE RETURN STATE_A; ; 1942 ; 1943 END; ! End of SEND_FILE ;SEND_FILE U.4: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 ; 1838 MOVAB W^U.102, R7 ;U.102, R7 ; CLRQ W^ABT_CUR_FILE ;ABT_CUR_FILE ; 1880 CMPL -4(R7), W^PKT_RETRIES ;NUM_RETRIES, PKT_RETRIES ; 1887 BGTR 3$ ;3$ ; INCL -4(R7) ;NUM_RETRIES ; 1893 MOVL W^FILE_SIZE, R6 ;FILE_SIZE, R6 ; 1895 BEQL 1$ ;1$ ; MOVC3 R6, W^FILE_NAME, 116(R7) ;R6, FILE_NAME, SND_MSG+4 ; 1897 1$: PUSHL (R7) ;MSG_NUMBER ; 1901 PUSHL R6 ;R6 ; MOVZBL #70, -(SP) ;#70, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; BLBC R0, 8$ ;R0, 8$ ; CALLS #0, W^U.23 ;#0, U.23 ; 1906 MOVL R0, -20(R7) ;R0, STATUS ; BLBS R0, 2$ ;R0, 2$ ; 1908 CMPL R0, #134316218 ;R0, #134316218 ; 1912 BEQL 6$ ;6$ ; CMPL R0, #134316232 ;R0, #134316232 ; BEQL 6$ ;6$ ; CMPL R0, #134316162 ;R0, #134316162 ; BNEQ 8$ ;8$ ; BRB 6$ ;6$ ; 1910 2$: MOVL 12(R7), R0 ;REC_TYPE, R0 ; 1924 CMPL R0, #89 ;R0, #89 ; BEQL 4$ ;4$ ; CMPL R0, #78 ;R0, #78 ; 3$: BNEQ 8$ ;8$ ; 4$: CMPL R0, #78 ;R0, #78 ; 1931 BNEQ 5$ ;5$ ; ADDL3 #1, (R7), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R7) ;#0, #6, R0, REC_SEQ ; BNEQ 6$ ;6$ ; 5$: CMPL 4(R7), (R7) ;REC_SEQ, MSG_NUMBER ; 1933 BEQL 7$ ;7$ ; 6$: MOVL -16(R7), R0 ;STATE, R0 ; RET ; ; 7$: CLRL -4(R7) ;NUM_RETRIES ; 1938 ADDL3 #1, (R7), R0 ;#1, MSG_NUMBER, R0 ; 1939 EXTZV #0, #6, R0, (R7) ;#0, #6, R0, MSG_NUMBER ; PUSHL #1 ;#1 ; 1941 CALLS #1, W^U.25 ;#1, U.25 ; BLBC R0, 8$ ;R0, 8$ ; MOVL #3, R0 ;#3, R0 ; 1876 RET ; ; 8$: MOVL #10, R0 ;#10, R0 ; RET ; ; 1838 ; Routine Size: 177 bytes, Routine Base: $CODE$ + 0411 ; 1944 %SBTTL 'SEND_EOF' ; 1945 ROUTINE SEND_EOF = ; 1946 ; 1947 !++ ; 1948 ! FUNCTIONAL DESCRIPTION: ; 1949 ! ; 1950 ! This routine will send the end of file message to the remote ; 1951 ! KERMIT. It will then determine if there are more files to ; 1952 ! send to the remote. ; 1953 ! ; 1954 ! CALLING SEQUENCE: ; 1955 ! ; 1956 ! STATE = SEND_EOF(); ; 1957 ! ; 1958 ! INPUT PARAMETERS: ; 1959 ! ; 1960 ! None. ; 1961 ! ; 1962 ! IMPLICIT INPUTS: ; 1963 ! ; 1964 ! None. ; 1965 ! ; 1966 ! OUTPUT PARAMETERS: ; 1967 ! ; 1968 ! New state to change the finite state machine to. ; 1969 ! ; 1970 ! IMPLICIT OUTPUTS: ; 1971 ! ; 1972 ! None. ; 1973 ! ; 1974 ! COMPLETION CODES: ; 1975 ! ; 1976 ! None. ; 1977 ! ; 1978 ! SIDE EFFECTS: ; 1979 ! ; 1980 ! Sets up for the next file to be processed if there is one. ; 1981 ! ; 1982 !-- ; 1983 ; 1984 BEGIN ; 1985 ; 1986 LOCAL ; 1987 EOF_MSG_LEN; ! Length of EOF message to send ; 1988 ; 1989 ! ; 1990 ! First determine if we have exceed the number of retries that are ; 1991 ! allowed to attempt to send this message. ; 1992 ! ; 1993 ; 1994 IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A; ; 1995 ; 1996 ! ; 1997 ! The number of retries are not exceeded. Increment the number and then ; 1998 ! attempt to send the packet again. ; 1999 ! ; 2000 NUM_RETRIES = .NUM_RETRIES + 1; ; 2001 ! ; 2002 ! Store character in packet to indicate discard of file ; 2003 ! Character will only be sent if file should be discarded ; 2004 ! ; 2005 CH$WCHAR (MSG_EOF_DISCARD, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE)); ; 2006 ; 2007 IF .ABT_CUR_FILE OR .ABT_ALL_FILE THEN EOF_MSG_LEN = 1 ELSE EOF_MSG_LEN = 0; ; 2008 ; 2009 IF NOT SEND_PACKET (MSG_EOF, .EOF_MSG_LEN, .MSG_NUMBER) THEN RETURN STATE_A; ; 2010 ; 2011 ! ; 2012 ! Now get the responce from the remote KERMIT. ; 2013 ! ; 2014 STATUS = REC_PACKET (); ; 2015 ; 2016 IF NOT .STATUS ; 2017 THEN ; 2018 BEGIN ; 2019 ; 2020 IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR) ; 2021 THEN ; 2022 RETURN .STATE ; 2023 ELSE ; 2024 RETURN STATE_A; ; 2025 ; 2026 END; ; 2027 ; 2028 ! ; 2029 ! Determine if the packet is good. ; 2030 ! ; 2031 ; 2032 IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A; ; 2033 ; 2034 ! ; 2035 ! If this is a NAK and the message number is not the one we just send ; 2036 ! treat this like an ACK, otherwise resend the last packet. ; 2037 ! ; 2038 ; 2039 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 2040 ; 2041 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 2042 ; 2043 ! ; 2044 ! Here to determine if there is another file to send. ; 2045 ! ; 2046 NUM_RETRIES = 0; ; 2047 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2048 ; 2049 IF NOT .ABT_ALL_FILE THEN STATUS = NEXT_FILE () ELSE STATUS = KER_NOMORFILES; ; 2050 ; 2051 IF ( NOT .STATUS) OR (.STATUS EQL KER_NOMORFILES) THEN RETURN STATE_SB ELSE RETURN STATE_SF; ; 2052 ; 2053 END; ;SEND_EOF U.5: .WORD ^M ;Save R2,R3 ; 1945 MOVAB W^ABT_ALL_FILE, R3 ;ABT_ALL_FILE, R3 ; MOVAB W^U.102, R2 ;U.102, R2 ; CMPL -4(R2), -56(R3) ;NUM_RETRIES, PKT_RETRIES ; 1994 BGTR 5$ ;5$ ; INCL -4(R2) ;NUM_RETRIES ; 2000 MOVB #68, 116(R2) ;#68, SND_MSG+4 ; 2005 BLBS -4(R3), 1$ ;ABT_CUR_FILE, 1$ ; 2007 BLBC (R3), 2$ ;ABT_ALL_FILE, 2$ ; 1$: MOVL #1, R0 ;#1, EOF_MSG_LEN ; BRB 3$ ;3$ ; 2$: CLRL R0 ;EOF_MSG_LEN ; 3$: PUSHL (R2) ;MSG_NUMBER ; 2009 PUSHL R0 ;EOF_MSG_LEN ; MOVZBL #90, -(SP) ;#90, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; BLBC R0, 5$ ;R0, 5$ ; CALLS #0, W^U.23 ;#0, U.23 ; 2014 MOVL R0, -20(R2) ;R0, STATUS ; BLBS R0, 4$ ;R0, 4$ ; 2016 CMPL R0, #134316218 ;R0, #134316218 ; 2020 BEQL 8$ ;8$ ; CMPL R0, #134316232 ;R0, #134316232 ; BEQL 8$ ;8$ ; CMPL R0, #134316162 ;R0, #134316162 ; BNEQ 5$ ;5$ ; BRB 8$ ;8$ ; 2018 4$: MOVL 12(R2), R0 ;REC_TYPE, R0 ; 2032 CMPL R0, #89 ;R0, #89 ; BEQL 6$ ;6$ ; CMPL R0, #78 ;R0, #78 ; BEQL 6$ ;6$ ; 5$: MOVL #10, R0 ;#10, R0 ; RET ; ; 6$: CMPL R0, #78 ;R0, #78 ; 2039 BNEQ 7$ ;7$ ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R2) ;#0, #6, R0, REC_SEQ ; BNEQ 8$ ;8$ ; 7$: CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 2041 BEQL 9$ ;9$ ; 8$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 9$: CLRL -4(R2) ;NUM_RETRIES ; 2046 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2047 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; BLBS (R3), 10$ ;ABT_ALL_FILE, 10$ ; 2049 CALLS #0, W^NEXT_FILE ;#0, NEXT_FILE ; MOVL R0, -20(R2) ;R0, STATUS ; BRB 11$ ;11$ ; 10$: MOVL #134316131, -20(R2) ;#134316131, STATUS ; 11$: BLBC -20(R2), 12$ ;STATUS, 12$ ; 2051 CMPL -20(R2), #134316131 ;STATUS, #134316131 ; BNEQ 13$ ;13$ ; 12$: MOVL #5, R0 ;#5, R0 ; 1984 RET ; ; 13$: MOVL #2, R0 ;#2, R0 ; RET ; ; 1945 ; Routine Size: 212 bytes, Routine Base: $CODE$ + 04C2 ; 2054 %SBTTL 'SEND_INIT' ; 2055 ROUTINE SEND_INIT = ; 2056 ; 2057 !++ ; 2058 ! FUNCTIONAL DESCRIPTION: ; 2059 ! ; 2060 ! This routine will send the initialization packet to the remote ; 2061 ! KERMIT. The message type sent is S. ; 2062 ! ; 2063 ! CALLING SEQUENCE: ; 2064 ! ; 2065 ! STATE = SEND_INIT(); ; 2066 ! ; 2067 ! INPUT PARAMETERS: ; 2068 ! ; 2069 ! None. ; 2070 ! ; 2071 ! IMPLICIT INPUTS: ; 2072 ! ; 2073 ! None. ; 2074 ! ; 2075 ! OUTPUT PARAMETERS: ; 2076 ! ; 2077 ! New state to change the finite state machine to. ; 2078 ! ; 2079 ! IMPLICIT OUTPUTS: ; 2080 ! ; 2081 ! None. ; 2082 ! ; 2083 ! COMPLETION CODES: ; 2084 ! ; 2085 ! None. ; 2086 ! ; 2087 ! SIDE EFFECTS: ; 2088 ! ; 2089 ! None. ; 2090 ! ; 2091 !-- ; 2092 ; 2093 BEGIN ; 2094 SET_SEND_INIT (); ; 2095 ; 2096 IF .NUM_RETRIES GTR .SI_RETRIES THEN RETURN STATE_A; ; 2097 ; 2098 ! ; 2099 ! Count the number of times we try this ; 2100 ! ; 2101 NUM_RETRIES = .NUM_RETRIES + 1; ; 2102 ; 2103 IF NOT SEND_PACKET (MSG_SND_INIT, P_SI_LENGTH, .MSG_NUMBER) THEN RETURN STATE_A; ; 2104 ; 2105 ! ; 2106 ! Determine if we received a packet it good condition. If we timed out or ; 2107 ! got an illegal message, just try again. ; 2108 ! ; 2109 STATUS = REC_PACKET (); ; 2110 ; 2111 IF NOT .STATUS ; 2112 THEN ; 2113 BEGIN ; 2114 ; 2115 IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR) ; 2116 THEN ; 2117 RETURN .STATE ; 2118 ELSE ; 2119 RETURN STATE_A; ; 2120 ; 2121 END; ; 2122 ; 2123 ! ; 2124 ! Determine if the packet is good. ; 2125 ! ; 2126 ; 2127 IF .REC_TYPE NEQ MSG_ACK THEN RETURN .STATE; ; 2128 ; 2129 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 2130 ; 2131 ! ; 2132 ! Here if we have an ACK for the initialization message that was just sent ; 2133 ! to the remote KERMIT. ; 2134 ! ; 2135 ; 2136 IF NOT (STATUS = PRS_SEND_INIT ()) THEN RETURN STATE_A; ; 2137 ; 2138 BLK_CHK_TYPE = .INI_CHK_TYPE; ! We now use agreed upon block check type ; 2139 NUM_RETRIES = 0; ; 2140 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2141 ; 2142 IF ( NOT .CONNECT_FLAG) AND .TY_FIL ; 2143 THEN ; 2144 BEGIN ; 2145 TT_TEXT (UPLIT (%ASCIZ'Sending: ')); ; 2146 TT_OUTPUT (); ; 2147 END; ; 2148 ; 2149 IF NOT FILE_OPEN (FNC_READ) ; 2150 THEN ; 2151 RETURN STATE_A ; 2152 ELSE ; 2153 BEGIN ; 2154 ; 2155 IF ( NOT .CONNECT_FLAG) AND .TY_FIL ; 2156 THEN ; 2157 BEGIN ; 2158 TT_TEXT (FILE_NAME); ; 2159 TT_OUTPUT (); ; 2160 END; ; 2161 ; 2162 FILE_OPEN_FLAG = TRUE; ; 2163 RETURN STATE_SF; ; 2164 END; ; 2165 ; 2166 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAE: .ASCII \Sending: \<0><0><0> ; ; .PSECT $CODE$,NOWRT,2 ;SEND_INIT U.6: .WORD ^M ;Save R2,R3 ; 2055 MOVAB W^CONNECT_FLAG, R3 ;CONNECT_FLAG, R3 ; MOVAB W^U.102, R2 ;U.102, R2 ; CALLS #0, W^U.17 ;#0, U.17 ; 2094 CMPL -4(R2), -52(R3) ;NUM_RETRIES, SI_RETRIES ; 2096 BGTR 1$ ;1$ ; INCL -4(R2) ;NUM_RETRIES ; 2101 PUSHL (R2) ;MSG_NUMBER ; 2103 PUSHL #9 ;#9 ; MOVZBL #83, -(SP) ;#83, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; BLBC R0, 6$ ;R0, 6$ ; CALLS #0, W^U.23 ;#0, U.23 ; 2109 MOVL R0, -20(R2) ;R0, STATUS ; BLBS R0, 2$ ;R0, 2$ ; 2111 CMPL R0, #134316218 ;R0, #134316218 ; 2115 BEQL 3$ ;3$ ; CMPL R0, #134316232 ;R0, #134316232 ; BEQL 3$ ;3$ ; CMPL R0, #134316162 ;R0, #134316162 ; 1$: BNEQ 6$ ;6$ ; BRB 3$ ;3$ ; 2113 2$: CMPL 12(R2), #89 ;REC_TYPE, #89 ; 2127 BNEQ 3$ ;3$ ; CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 2129 BEQL 4$ ;4$ ; 3$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 4$: CALLS #0, W^U.18 ;#0, U.18 ; 2136 MOVL R0, -20(R2) ;R0, STATUS ; BLBC R0, 6$ ;R0, 6$ ; MOVL -36(R2), -32(R2) ;INI_CHK_TYPE, BLK_CHK_TYPE ; 2138 CLRL -4(R2) ;NUM_RETRIES ; 2139 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2140 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; BLBS (R3), 5$ ;CONNECT_FLAG, 5$ ; 2142 BLBC 12(R3), 5$ ;TY_FIL, 5$ ; PUSHAB W^P.AAE ;P.AAE ; 2145 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_OUTPUT ;#0, TT_OUTPUT ; 2146 5$: CLRL -(SP) ;-(SP) ; 2149 CALLS #1, W^FILE_OPEN ;#1, FILE_OPEN ; BLBS R0, 7$ ;R0, 7$ ; 6$: MOVL #10, R0 ;#10, R0 ; 2093 RET ; ; 7$: BLBS (R3), 8$ ;CONNECT_FLAG, 8$ ; 2155 BLBC 12(R3), 8$ ;TY_FIL, 8$ ; PUSHAB -188(R3) ;FILE_NAME ; 2158 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_OUTPUT ;#0, TT_OUTPUT ; 2159 8$: MOVL #1, 208(R2) ;#1, FILE_OPEN_FLAG ; 2162 MOVL #2, R0 ;#2, R0 ; 2093 RET ; ; 2055 ; Routine Size: 199 bytes, Routine Base: $CODE$ + 0596 ; 2167 %SBTTL 'SEND_BREAK' ; 2168 ROUTINE SEND_BREAK = ; 2169 ; 2170 !++ ; 2171 ! FUNCTIONAL DESCRIPTION: ; 2172 ! ; 2173 ! This routine will send the break (end of transmission) message ; 2174 ! to the remote KERMIT. On an ACK the state becomes STATE_C. ; 2175 ! ; 2176 ! CALLING SEQUENCE: ; 2177 ! ; 2178 ! STATE = SEND_BREAK(); ; 2179 ! ; 2180 ! INPUT PARAMETERS: ; 2181 ! ; 2182 ! None. ; 2183 ! ; 2184 ! IMPLICIT INPUTS: ; 2185 ! ; 2186 ! None. ; 2187 ! ; 2188 ! OUTPUT PARAMETERS: ; 2189 ! ; 2190 ! New state for the finite state machine. ; 2191 ! ; 2192 ! IMPLICIT OUTPUTS: ; 2193 ! ; 2194 ! None. ; 2195 ! ; 2196 ! COMPLETION CODES: ; 2197 ! ; 2198 ! None. ; 2199 ! ; 2200 ! SIDE EFFECTS: ; 2201 ! ; 2202 ! None. ; 2203 ! ; 2204 !-- ; 2205 ; 2206 BEGIN ; 2207 ! ; 2208 ! First determine if we have exceed the number of retries that are ; 2209 ! allowed to attempt to send this message. ; 2210 ! ; 2211 ; 2212 IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A; ; 2213 ; 2214 ! ; 2215 ! The number of retries are not exceeded. Increment the number and then ; 2216 ! attempt to send the packet again. ; 2217 ! ; 2218 NUM_RETRIES = .NUM_RETRIES + 1; ; 2219 ; 2220 IF NOT SEND_PACKET (MSG_BREAK, 0, .MSG_NUMBER) THEN RETURN STATE_A; ; 2221 ; 2222 ! ; 2223 ! Now get the responce from the remote KERMIT. ; 2224 ! ; 2225 STATUS = REC_PACKET (); ; 2226 ; 2227 IF NOT .STATUS ; 2228 THEN ; 2229 BEGIN ; 2230 ; 2231 IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR) ; 2232 THEN ; 2233 RETURN .STATE ; 2234 ELSE ; 2235 RETURN STATE_A; ; 2236 ; 2237 END; ; 2238 ; 2239 ! ; 2240 ! Determine if the packet is good. ; 2241 ! ; 2242 ; 2243 IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A; ; 2244 ; 2245 ! ; 2246 ! If this is a NAK and the message number is not the one we just send ; 2247 ! treat this like an ACK, otherwise resend the last packet. ; 2248 ! ; 2249 ; 2250 IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 2251 ; 2252 IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE; ; 2253 ; 2254 ! ; 2255 ! Here to determine if there is another file to send. ; 2256 ! ; 2257 NUM_RETRIES = 0; ; 2258 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2259 RETURN STATE_C; ; 2260 END; ;SEND_BREAK U.7: .WORD ^M ;Save R2 ; 2168 MOVAB W^U.102, R2 ;U.102, R2 ; CMPL -4(R2), W^PKT_RETRIES ;NUM_RETRIES, PKT_RETRIES ; 2212 BGTR 2$ ;2$ ; INCL -4(R2) ;NUM_RETRIES ; 2218 PUSHL (R2) ;MSG_NUMBER ; 2220 CLRL -(SP) ;-(SP) ; MOVZBL #66, -(SP) ;#66, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; BLBC R0, 2$ ;R0, 2$ ; CALLS #0, W^U.23 ;#0, U.23 ; 2225 MOVL R0, -20(R2) ;R0, STATUS ; BLBS R0, 1$ ;R0, 1$ ; 2227 CMPL R0, #134316218 ;R0, #134316218 ; 2231 BEQL 5$ ;5$ ; CMPL R0, #134316232 ;R0, #134316232 ; BEQL 5$ ;5$ ; CMPL R0, #134316162 ;R0, #134316162 ; BNEQ 2$ ;2$ ; BRB 5$ ;5$ ; 2229 1$: MOVL 12(R2), R0 ;REC_TYPE, R0 ; 2243 CMPL R0, #89 ;R0, #89 ; BEQL 3$ ;3$ ; CMPL R0, #78 ;R0, #78 ; BEQL 3$ ;3$ ; 2$: MOVL #10, R0 ;#10, R0 ; RET ; ; 3$: CMPL R0, #78 ;R0, #78 ; 2250 BNEQ 4$ ;4$ ; ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; CMPZV #0, #6, R0, 4(R2) ;#0, #6, R0, REC_SEQ ; BNEQ 5$ ;5$ ; 4$: CMPL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 2252 BEQL 6$ ;6$ ; 5$: MOVL -16(R2), R0 ;STATE, R0 ; RET ; ; 6$: CLRL -4(R2) ;NUM_RETRIES ; 2257 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2258 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; MOVL #9, R0 ;#9, R0 ; 2206 RET ; ; 2168 ; Routine Size: 149 bytes, Routine Base: $CODE$ + 065D ; 2261 %SBTTL 'SND_ERROR' ; 2262 ; 2263 GLOBAL ROUTINE SND_ERROR (COUNT, ADDRESS) : NOVALUE = ; 2264 ; 2265 !++ ; 2266 ! FUNCTIONAL DESCRIPTION: ; 2267 ! ; 2268 ! This routine will send an error packet to the remote KERMIT. It ; 2269 ! is called with the count of characters and the address of the text. ; 2270 ! ; 2271 ! CALLING SEQUENCE: ; 2272 ! ; 2273 ! SND_ERROR(COUNT, %ASCII 'Error text'); ; 2274 ! ; 2275 ! INPUT PARAMETERS: ; 2276 ! ; 2277 ! None. ; 2278 ! ; 2279 ! IMPLICIT INPUTS: ; 2280 ! ; 2281 ! None. ; 2282 ! ; 2283 ! OUTPUT PARAMETERS: ; 2284 ! ; 2285 ! None. ; 2286 ! ; 2287 ! IMPLICIT OUTPUTS: ; 2288 ! ; 2289 ! None. ; 2290 ! ; 2291 ! COMPLETION CODES: ; 2292 ! ; 2293 ! None. ; 2294 ! ; 2295 ! SIDE EFFECTS: ; 2296 ! ; 2297 ! ; 2298 !-- ; 2299 ; 2300 BEGIN ; 2301 ; 2302 LOCAL ; 2303 CHR, ! Character we are processing ; 2304 SIZE, ! Size of data area ; 2305 STO_PTR, ! Pointer used to store chars ; 2306 FET_PTR; ! Pointer used to fetch characters ; 2307 ; 2308 ! ; 2309 ! Initialize the various pointers and counter. ; 2310 ! ; 2311 FET_PTR = CH$PTR (.ADDRESS); ; 2312 STO_PTR = CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE); ; 2313 ! ; 2314 ! Determine the max size we can use ; 2315 ! ; 2316 SIZE = (IF .COUNT GTR .SEND_PKT_SIZE - PKT_TOT_OVR_HEAD THEN .SEND_PKT_SIZE - PKT_TOT_OVR_HEAD ; 2317 ELSE .COUNT); ; 2318 ! ; 2319 ! Move the information from the source to the destination ; 2320 ! ; 2321 CH$MOVE (.SIZE, .FET_PTR, .STO_PTR); ; 2322 CH$COPY (.SIZE, CH$PTR (.ADDRESS), 0, .SIZE + 1, CH$PTR (LAST_ERROR)); ; 2323 ; 2324 IF NOT SEND_PACKET (MSG_ERROR, .SIZE, .MSG_NUMBER) THEN RETURN STATE_A; ; 2325 ; 2326 END; ! End of SND_ERROR U.8: .ENTRY SND_ERROR, ^M ;SND_ERROR, Save R2,R3,R4,R5,R6 ; 2263 MOVL 8(AP), R1 ;ADDRESS, FET_PTR ; 2311 MOVAB W^U.107+4, R2 ;U.107+4, STO_PTR ; 2312 SUBL3 #6, W^U.86, R0 ;#6, U.86, R0 ; 2316 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) ; 2321 MOVAB 1(R6), R0 ;1(R6), R0 ; 2322 MOVC5 R6, @8(AP), #0, R0, W^LAST_ERROR ;SIZE, @ADDRESS, #0, R0, LAST_ERROR ; PUSHL W^U.102 ;U.102 ; 2324 PUSHL R6 ;SIZE ; MOVZBL #69, -(SP) ;#69, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; RET ; ; 2263 ; Routine Size: 65 bytes, Routine Base: $CODE$ + 06F2 ; 2327 ; 2328 %SBTTL 'REC_SWITCH' ; 2329 ; 2330 GLOBAL ROUTINE REC_SWITCH = ; 2331 ; 2332 !++ ; 2333 ! FUNCTIONAL DESCRIPTION: ; 2334 ! ; 2335 ! This routine will cause file(s) to be received by the remote ; 2336 ! KERMIT. This routine contains the main loop for the sending of the ; 2337 ! data. ; 2338 ! ; 2339 ! CALLING SEQUENCE: ; 2340 ! ; 2341 ! REC_SWITCH(); ; 2342 ! ; 2343 ! INPUT PARAMETERS: ; 2344 ! ; 2345 ! None. ; 2346 ! ; 2347 ! IMPLICIT INPUTS: ; 2348 ! ; 2349 ! FILE_DESC - Descriptor describing the file to be received by ; 2350 ! the remote KERMIT. ; 2351 ! ; 2352 ! OUTPUT PARAMETERS: ; 2353 ! ; 2354 ! None. ; 2355 ! ; 2356 ! IMPLICIT OUTPUTS: ; 2357 ! ; 2358 ! None. ; 2359 ! ; 2360 ! COMPLETION CODES: ; 2361 ! ; 2362 ! True - File received correctly. ; 2363 ! FALSE - File transfer aborted. ; 2364 ! ; 2365 ! SIDE EFFECTS: ; 2366 ! ; 2367 ! None. ; 2368 ! ; 2369 !-- ; 2370 ; 2371 BEGIN ; 2372 STATE = STATE_R; ! Initialize the state ; 2373 MSG_NUMBER = 0; ; 2374 INIT_XFR (); ! Initialize the per transfer info ; 2375 ! ; 2376 ! Determine if they said REC ; 2377 ! Send MSG_RCV_INIT and then receive the file ; 2378 ! ; 2379 ; 2380 IF .FILE_SIZE GTR 0 ; 2381 THEN ; 2382 BEGIN ; 2383 CH$MOVE (.FILE_SIZE, CH$PTR (FILE_NAME), CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE)); ; 2384 ; 2385 IF NOT (STATUS = SEND_PACKET (MSG_RCV_INIT, .FILE_SIZE, .MSG_NUMBER)) THEN RETURN .STATUS; ; 2386 ; 2387 END; ; 2388 ; 2389 ! ; 2390 ! Now receive the file normally ; 2391 ! ; 2392 RETURN REC_SWITCH_WORKER (); ; 2393 END; ! End of REC_SWITCH U.9: .ENTRY REC_SWITCH, ^M ;REC_SWITCH, Save R2,R3,R4,R5,R6,R7 ; 2330 MOVAB W^U.102, R7 ;U.102, R7 ; MOVL #6, -16(R7) ;#6, STATE ; 2372 CLRL (R7) ;MSG_NUMBER ; 2373 CALLS #0, W^U.27 ;#0, U.27 ; 2374 MOVL W^FILE_SIZE, R6 ;FILE_SIZE, R6 ; 2380 BLEQ 1$ ;1$ ; MOVC3 R6, W^FILE_NAME, 116(R7) ;R6, FILE_NAME, SND_MSG+4 ; 2383 PUSHL (R7) ;MSG_NUMBER ; 2385 PUSHL R6 ;R6 ; MOVZBL #82, -(SP) ;#82, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; MOVL R0, -20(R7) ;R0, STATUS ; BLBS R0, 1$ ;R0, 1$ ; MOVL -20(R7), R0 ;STATUS, R0 ; RET ; ; 1$: CALLS #0, W^U.10 ;#0, U.10 ; 2392 RET ; ; 2330 ; Routine Size: 63 bytes, Routine Base: $CODE$ + 0733 ; 2394 ; 2395 %SBTTL 'Receive - REC_SWITCH_WORKER' ; 2396 ROUTINE REC_SWITCH_WORKER = ; 2397 ; 2398 !++ ; 2399 ! FUNCTIONAL DESCRIPTION: ; 2400 ! ; 2401 ! This is the worker routine for either REC_SWITCH or SERVER. ; 2402 ! This routine will be called with the STATE variable set to the ; 2403 ! correct state for either the SERVER or the REC_SWITCH routine. ; 2404 ! ; 2405 ! CALLING SEQUENCE: ; 2406 ! ; 2407 ! Status = REC_SWITCH_WORKER(); ; 2408 ! ; 2409 ! INPUT PARAMETERS: ; 2410 ! ; 2411 ! None. ; 2412 ! ; 2413 ! IMPLICIT INPUTS: ; 2414 ! ; 2415 ! None. ; 2416 ! ; 2417 ! OUTPUT PARAMETERS: ; 2418 ! ; 2419 ! None. ; 2420 ! ; 2421 ! IMPLICIT OUTPUTS: ; 2422 ! ; 2423 ! None. ; 2424 ! ; 2425 ! COMPLETION CODES: ; 2426 ! ; 2427 ! None. ; 2428 ! ; 2429 ! SIDE EFFECTS: ; 2430 ! ; 2431 ! None. ; 2432 ! ; 2433 !-- ; 2434 ; 2435 BEGIN ; 2436 ; 2437 LOCAL ; 2438 RETURN_VALUE; ; 2439 ; 2440 NUM_RETRIES = 0; ! Initialize the number of retries ; 2441 ; 2442 WHILE TRUE DO ; 2443 ; 2444 CASE .STATE FROM STATE_MIN TO STATE_MAX OF ; 2445 SET ; 2446 ! ; 2447 ! Receiving of the data and the end of file message. ; 2448 ! ; 2449 ; 2450 [STATE_RD] : ; 2451 STATE = REC_DATA (); ; 2452 ! ; 2453 ! Receiving the FILE information of the break to end the transfer of ; 2454 ! one or more files ; 2455 ! ; 2456 ; 2457 [STATE_RF] : ; 2458 STATE = REC_FILE (); ; 2459 ! ; 2460 ! Initialization for the receiving of a file ; 2461 ! ; 2462 ; 2463 [STATE_R] : ; 2464 STATE = REC_INIT (); ; 2465 ! ; 2466 ! Here if we have completed the receiving of the file ; 2467 ! ; 2468 ; 2469 [STATE_C] : ; 2470 BEGIN ; 2471 RETURN_VALUE = TRUE; ; 2472 EXITLOOP; ; 2473 END; ; 2474 ! ; 2475 ! Here if we aborted the transfer or we have gotten into some random ; 2476 ! state (internal KERMSG problem). ; 2477 ! ; 2478 ; 2479 [STATE_A, INRANGE, OUTRANGE] : ; 2480 BEGIN ; 2481 RETURN_VALUE = FALSE; ; 2482 ! ; 2483 ! Determine if the file is still open and if so close it ; 2484 ! ; 2485 ; 2486 IF .FILE_OPEN_FLAG ; 2487 THEN ; 2488 BEGIN ; 2489 FILE_OPEN_FLAG = FALSE; ; 2490 ; 2491 IF ( NOT .CONNECT_FLAG) AND .TY_FIL ; 2492 THEN ; 2493 BEGIN ; 2494 TT_TEXT (UPLIT (%ASCIZ' [Aborted]')); ; 2495 TT_CRLF (); ; 2496 END; ; 2497 ; 2498 FILE_CLOSE (.ABT_FLAG AND (.STATE EQL STATE_A)); ; 2499 END; ; 2500 ; 2501 EXITLOOP; ; 2502 END; ; 2503 TES; ; 2504 ; 2505 ! ; 2506 ! End the stats and return to the caller ; 2507 ! ; 2508 END_STATS (); ; 2509 ! ; 2510 RETURN .RETURN_VALUE; ; 2511 END; ! End of REC_SWITCH_WORKER .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAF: .ASCII \ [Aborted]\<0><0> ; ; .PSECT $CODE$,NOWRT,2 ;REC_SWITCH_WORKER U.10: .WORD ^M ;Save R2,R3 ; 2396 MOVAB W^U.98, R3 ;U.98, R3 ; CLRL 12(R3) ;NUM_RETRIES ; 2440 1$: CASEL (R3), #0, #10 ;STATE, #0, #10 ; 2444 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$,- ; 8$-2$,- ;8$-2$,- ; 7$-2$,- ;7$-2$,- ; 6$-2$,- ;6$-2$,- ; 10$-2$,- ;10$-2$,- ; 3$-2$ ;3$-2$ ; 3$: CLRL R2 ;RETURN_VALUE ; 2481 BLBC 224(R3), 11$ ;FILE_OPEN_FLAG, 11$ ; 2486 CLRL 224(R3) ;FILE_OPEN_FLAG ; 2489 BLBS W^CONNECT_FLAG, 4$ ;CONNECT_FLAG, 4$ ; 2491 BLBC W^TY_FIL, 4$ ;TY_FIL, 4$ ; PUSHAB W^P.AAF ;P.AAF ; 2494 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 2495 4$: CLRL R0 ;R0 ; 2498 CMPL (R3), #10 ;STATE, #10 ; BNEQ 5$ ;5$ ; INCL R0 ;R0 ; 5$: MCOML W^ABT_FLAG, R1 ;ABT_FLAG, R1 ; BICL3 R1, R0, -(SP) ;R1, R0, -(SP) ; CALLS #1, W^FILE_CLOSE ;#1, FILE_CLOSE ; BRB 11$ ;11$ ; 2480 6$: CALLS #0, W^U.13 ;#0, U.13 ; 2451 BRB 9$ ;9$ ; 7$: CALLS #0, W^U.12 ;#0, U.12 ; 2458 BRB 9$ ;9$ ; 8$: CALLS #0, W^U.11 ;#0, U.11 ; 2464 9$: MOVL R0, (R3) ;R0, STATE ; BRB 1$ ;1$ ; 2444 10$: MOVL #1, R2 ;#1, RETURN_VALUE ; 2471 11$: CALLS #0, W^U.15 ;#0, U.15 ; 2508 MOVL R2, R0 ;RETURN_VALUE, R0 ; 2435 RET ; ; 2396 ; Routine Size: 132 bytes, Routine Base: $CODE$ + 0772 ; 2512 %SBTTL 'REC_INIT' ; 2513 ROUTINE REC_INIT = ; 2514 ; 2515 !++ ; 2516 ! FUNCTIONAL DESCRIPTION: ; 2517 ! ; 2518 ! This routine will process an initialization message received from ; 2519 ! the remote KERMIT. ; 2520 ! ; 2521 ! CALLING SEQUENCE: ; 2522 ! ; 2523 ! STATE = REC_INIT(); ; 2524 ! ; 2525 ! INPUT PARAMETERS: ; 2526 ! ; 2527 ! None. ; 2528 ! ; 2529 ! IMPLICIT INPUTS: ; 2530 ! ; 2531 ! None. ; 2532 ! ; 2533 ! OUTPUT PARAMETERS: ; 2534 ! ; 2535 ! New machine state. ; 2536 ! ; 2537 ! IMPLICIT OUTPUTS: ; 2538 ! ; 2539 ! None. ; 2540 ! ; 2541 ! COMPLETION CODES: ; 2542 ! ; 2543 ! None. ; 2544 ! ; 2545 ! SIDE EFFECTS: ; 2546 ! ; 2547 ! None. ; 2548 ! ; 2549 !-- ; 2550 ; 2551 BEGIN ; 2552 ROUTINE CHECK_INIT = ; 2553 BEGIN ; 2554 ; 2555 IF .REC_TYPE EQL MSG_SND_INIT THEN RETURN TRUE ELSE RETURN FALSE; ; 2556 ; 2557 END; ;CHECK_INIT U.112: .WORD ^M<> ;Save nothing ; 2552 CMPL W^U.105, #83 ;U.105, #83 ; 2555 BNEQ 1$ ;1$ ; MOVL #1, R0 ;#1, R0 ; 2553 RET ; ; 1$: CLRL R0 ;R0 ; RET ; ; 2552 ; Routine Size: 20 bytes, Routine Base: $CODE$ + 07F6 ; 2558 ; 2559 IF NOT REC_MESSAGE (CHECK_INIT) THEN RETURN STATE_A; ; 2560 ; 2561 MSG_NUMBER = .REC_SEQ; ; 2562 ; 2563 IF NOT (STATUS = PRS_SEND_INIT ()) THEN RETURN STATE_A; ; 2564 ; 2565 SET_SEND_INIT (); ; 2566 SEND_PACKET (MSG_ACK, P_SI_LENGTH, .MSG_NUMBER); ; 2567 BLK_CHK_TYPE = .INI_CHK_TYPE; ! Can now use agreed upon type ; 2568 OLD_RETRIES = .NUM_RETRIES; ; 2569 NUM_RETRIES = 0; ; 2570 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2571 RETURN STATE_RF; ; 2572 END; ! End of REC_INIT ;REC_INIT U.11: .WORD ^M ;Save R2 ; 2513 MOVAB W^U.102, R2 ;U.102, R2 ; PUSHAB B^U.112 ;U.112 ; 2559 CALLS #1, W^U.22 ;#1, U.22 ; BLBC R0, 1$ ;R0, 1$ ; MOVL 4(R2), (R2) ;REC_SEQ, MSG_NUMBER ; 2561 CALLS #0, W^U.18 ;#0, U.18 ; 2563 MOVL R0, -20(R2) ;R0, STATUS ; BLBS R0, 2$ ;R0, 2$ ; 1$: MOVL #10, R0 ;#10, R0 ; RET ; ; 2$: CALLS #0, W^U.17 ;#0, U.17 ; 2565 PUSHL (R2) ;MSG_NUMBER ; 2566 PUSHL #9 ;#9 ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; MOVL -36(R2), -32(R2) ;INI_CHK_TYPE, BLK_CHK_TYPE ; 2567 MOVL -4(R2), -8(R2) ;NUM_RETRIES, OLD_RETRIES ; 2568 CLRL -4(R2) ;NUM_RETRIES ; 2569 ADDL3 #1, (R2), R0 ;#1, MSG_NUMBER, R0 ; 2570 EXTZV #0, #6, R0, (R2) ;#0, #6, R0, MSG_NUMBER ; MOVL #7, R0 ;#7, R0 ; 2551 RET ; ; 2513 ; Routine Size: 82 bytes, Routine Base: $CODE$ + 080A ; 2573 %SBTTL 'REC_FILE' ; 2574 ROUTINE REC_FILE = ; 2575 ; 2576 !++ ; 2577 ! FUNCTIONAL DESCRIPTION: ; 2578 ! ; 2579 ! This routine expects to receive an MSG_FILE packet from the remote ; 2580 ! KERMIT. If the message is correct this routine will change the state ; 2581 ! to STATE_RD. ; 2582 ! ; 2583 ! This routine also expects MSG_SND_INIT, MSG_EOF, or MSG_BREAK. ; 2584 ! ; 2585 ! CALLING SEQUENCE: ; 2586 ! ; 2587 ! STATE = REC_FILE(); ; 2588 ! ; 2589 ! INPUT PARAMETERS: ; 2590 ! ; 2591 ! None. ; 2592 ! ; 2593 ! IMPLICIT INPUTS: ; 2594 ! ; 2595 ! None. ; 2596 ! ; 2597 ! OUTPUT PARAMETERS: ; 2598 ! ; 2599 ! New state. ; 2600 ! ; 2601 ! IMPLICIT OUTPUTS: ; 2602 ! ; 2603 ! None. ; 2604 ! ; 2605 ! COMPLETION CODES: ; 2606 ! ; 2607 ! None. ; 2608 ! ; 2609 ! SIDE EFFECTS: ; 2610 ! ; 2611 ! None. ; 2612 ! ; 2613 !-- ; 2614 ; 2615 BEGIN ; 2616 ROUTINE CHECK_FILE = ; 2617 BEGIN ; 2618 ; 2619 IF (.REC_TYPE EQL MSG_SND_INIT) OR (.REC_TYPE EQL MSG_EOF) OR (.REC_TYPE EQL MSG_FILE) OR ( ; 2620 .REC_TYPE EQL MSG_BREAK) ; 2621 THEN ; 2622 RETURN TRUE ; 2623 ELSE ; 2624 RETURN FALSE; ; 2625 ; 2626 END; ;CHECK_FILE U.113: .WORD ^M<> ;Save nothing ; 2616 MOVL W^U.105, R0 ;U.105, R0 ; 2619 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 ; 2617 RET ; ; 2$: CLRL R0 ;R0 ; RET ; ; 2616 ; Routine Size: 50 bytes, Routine Base: $CODE$ + 085C ; 2627 ! ; 2628 ! Initialize the abort flags ; 2629 ! ; 2630 ABT_CUR_FILE = FALSE; ; 2631 ABT_ALL_FILE = FALSE; ; 2632 ! ; 2633 ! Get a message ; 2634 ! ; 2635 ; 2636 IF NOT REC_MESSAGE (CHECK_FILE) THEN RETURN STATE_A; ; 2637 ; 2638 SELECTONE .REC_TYPE OF ; 2639 SET ; 2640 ; 2641 [MSG_SND_INIT] : ; 2642 BEGIN ; 2643 ; 2644 IF .OLD_RETRIES GTR .SI_RETRIES THEN RETURN STATE_A; ; 2645 ; 2646 OLD_RETRIES = .OLD_RETRIES + 1; ; 2647 ; 2648 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 2649 THEN ; 2650 BEGIN ; 2651 SET_SEND_INIT (); ; 2652 BLK_CHK_TYPE = CHK_1CHAR; ! Must use 1 character CHKSUM ; 2653 SEND_PACKET (MSG_ACK, P_SI_LENGTH, .REC_SEQ); ; 2654 BLK_CHK_TYPE = .INI_CHK_TYPE; ! Back to agreed upon type ; 2655 NUM_RETRIES = 0; ; 2656 RETURN .STATE; ; 2657 END ; 2658 ELSE ; 2659 RETURN STATE_A; ; 2660 ; 2661 END; ; 2662 ; 2663 [MSG_EOF] : ; 2664 BEGIN ; 2665 ; 2666 IF .OLD_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A; ; 2667 ; 2668 OLD_RETRIES = .OLD_RETRIES + 1; ; 2669 ; 2670 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 2671 THEN ; 2672 BEGIN ; 2673 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2674 NUM_RETRIES = 0; ; 2675 RETURN .STATE; ; 2676 END ; 2677 ELSE ; 2678 RETURN STATE_A; ; 2679 ; 2680 END; ; 2681 ; 2682 [MSG_FILE] : ; 2683 BEGIN ; 2684 ; 2685 IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A; ; 2686 ; 2687 IF .REC_LENGTH EQL 0 ; 2688 THEN ; 2689 BEGIN ; 2690 KRM_ERROR (KER_PROTOERR); ; 2691 RETURN STATE_A; ; 2692 END; ; 2693 ; 2694 FILE_SIZE = .REC_LENGTH; ; 2695 CH$COPY (.REC_LENGTH, CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE), CHR_NUL, MAX_FILE_NAME, ; 2696 CH$PTR (FILE_NAME)); ; 2697 ; 2698 IF ( NOT .CONNECT_FLAG) AND .TY_FIL ; 2699 THEN ; 2700 BEGIN ; 2701 TT_TEXT (UPLIT (%ASCIZ'Receiving: ')); ; 2702 TT_TEXT (FILE_NAME); ; 2703 TT_OUTPUT (); ; 2704 END; ; 2705 ; 2706 IF NOT FILE_OPEN (FNC_WRITE) THEN RETURN STATE_A; ; 2707 ; 2708 FILE_OPEN_FLAG = TRUE; ; 2709 SEND_PACKET (MSG_ACK, 0, .MSG_NUMBER); ; 2710 OLD_RETRIES = .NUM_RETRIES; ; 2711 NUM_RETRIES = 0; ; 2712 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2713 RETURN STATE_RD; ; 2714 END; ; 2715 ; 2716 [MSG_BREAK] : ; 2717 BEGIN ; 2718 ; 2719 IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A; ; 2720 ; 2721 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2722 RETURN STATE_C; ; 2723 END; ; 2724 ; 2725 [OTHERWISE] : ; 2726 RETURN STATE_A; ; 2727 TES; ; 2728 ; 2729 END; ! End of REC_FILE .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAG: .ASCII \Receiving: \<0> ; ; .PSECT $CODE$,NOWRT,2 ;REC_FILE U.12: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 ; 2574 MOVAB W^U.21, R7 ;U.21, R7 ; MOVAB W^U.102, R6 ;U.102, R6 ; CLRQ W^ABT_CUR_FILE ;ABT_CUR_FILE ; 2630 PUSHAB B^U.113 ;U.113 ; 2636 CALLS #1, W^U.22 ;#1, U.22 ; BLBS R0, 1$ ;R0, 1$ ; BRW 9$ ;9$ ; 1$: MOVL 12(R6), R0 ;REC_TYPE, R0 ; 2638 CMPL R0, #83 ;R0, #83 ; BNEQ 2$ ;2$ ; CMPL -8(R6), W^SI_RETRIES ;OLD_RETRIES, SI_RETRIES ; 2644 BGTR 5$ ;5$ ; INCL -8(R6) ;OLD_RETRIES ; 2646 SUBL3 #1, (R6), R0 ;#1, MSG_NUMBER, R0 ; 2648 CMPL R0, 4(R6) ;R0, REC_SEQ ; BNEQ 5$ ;5$ ; CALLS #0, W^U.17 ;#0, U.17 ; 2651 MOVL #49, -32(R6) ;#49, BLK_CHK_TYPE ; 2652 PUSHL 4(R6) ;REC_SEQ ; 2653 PUSHL #9 ;#9 ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R7) ;#3, SEND_PACKET ; MOVL -36(R6), -32(R6) ;INI_CHK_TYPE, BLK_CHK_TYPE ; 2654 BRB 3$ ;3$ ; 2655 2$: CMPL R0, #90 ;R0, #90 ; 2638 BNEQ 4$ ;4$ ; CMPL -8(R6), W^PKT_RETRIES ;OLD_RETRIES, PKT_RETRIES ; 2666 BGTR 5$ ;5$ ; INCL -8(R6) ;OLD_RETRIES ; 2668 SUBL3 #1, (R6), R0 ;#1, MSG_NUMBER, R0 ; 2670 CMPL R0, 4(R6) ;R0, REC_SEQ ; BNEQ 5$ ;5$ ; PUSHL 4(R6) ;REC_SEQ ; 2673 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R7) ;#3, SEND_PACKET ; 3$: CLRL -4(R6) ;NUM_RETRIES ; 2674 MOVL -16(R6), R0 ;STATE, R0 ; 2664 RET ; ; 4$: CMPL R0, #70 ;R0, #70 ; 2638 BNEQ 8$ ;8$ ; CMPL (R6), 4(R6) ;MSG_NUMBER, REC_SEQ ; 2685 BNEQ 5$ ;5$ ; TSTL 8(R6) ;REC_LENGTH ; 2687 BNEQ 6$ ;6$ ; PUSHL #134316210 ;#134316210 ; 2690 CALLS #1, W^KRM_ERROR ;#1, KRM_ERROR ; 5$: BRW 9$ ;9$ ; 2689 6$: MOVL 8(R6), W^FILE_SIZE ;REC_LENGTH, FILE_SIZE ; 2694 MOVC5 8(R6), 20(R6), #0, #132, W^FILE_NAME ;REC_LENGTH, REC_MSG+4, #0, #132, FILE_NAME ; 2695 BLBS W^CONNECT_FLAG, 7$ ;CONNECT_FLAG, 7$ ; 2698 BLBC W^TY_FIL, 7$ ;TY_FIL, 7$ ; PUSHAB W^P.AAG ;P.AAG ; 2701 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; PUSHAB W^FILE_NAME ;FILE_NAME ; 2702 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_OUTPUT ;#0, TT_OUTPUT ; 2703 7$: PUSHL #1 ;#1 ; 2706 CALLS #1, W^FILE_OPEN ;#1, FILE_OPEN ; BLBC R0, 9$ ;R0, 9$ ; MOVL #1, 208(R6) ;#1, FILE_OPEN_FLAG ; 2708 PUSHL (R6) ;MSG_NUMBER ; 2709 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R7) ;#3, SEND_PACKET ; MOVL -4(R6), -8(R6) ;NUM_RETRIES, OLD_RETRIES ; 2710 CLRL -4(R6) ;NUM_RETRIES ; 2711 ADDL3 #1, (R6), R0 ;#1, MSG_NUMBER, R0 ; 2712 EXTZV #0, #6, R0, (R6) ;#0, #6, R0, MSG_NUMBER ; MOVL #8, R0 ;#8, R0 ; 2638 RET ; ; 8$: CMPL R0, #66 ;R0, #66 ; BNEQ 9$ ;9$ ; CMPL (R6), 4(R6) ;MSG_NUMBER, REC_SEQ ; 2719 BNEQ 9$ ;9$ ; PUSHL 4(R6) ;REC_SEQ ; 2721 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R7) ;#3, SEND_PACKET ; MOVL #9, R0 ;#9, R0 ; 2638 RET ; ; 9$: MOVL #10, R0 ;#10, R0 ; RET ; ; 2574 ; Routine Size: 309 bytes, Routine Base: $CODE$ + 088E ; 2730 %SBTTL 'REC_DATA' ; 2731 ROUTINE REC_DATA = ; 2732 ; 2733 !++ ; 2734 ! FUNCTIONAL DESCRIPTION: ; 2735 ! ; 2736 ! This routine will accept data messages and write them to disk. ; 2737 ! It will also accept MSG_FILE and MSG_EOF messages. ; 2738 ! ; 2739 ! CALLING SEQUENCE: ; 2740 ! ; 2741 ! STATE = REC_DATA(); ; 2742 ! ; 2743 ! INPUT PARAMETERS: ; 2744 ! ; 2745 ! None. ; 2746 ! ; 2747 ! IMPLICIT INPUTS: ; 2748 ! ; 2749 ! None. ; 2750 ! ; 2751 ! OUTPUT PARAMETERS: ; 2752 ! ; 2753 ! New state for the finite state machine. ; 2754 ! ; 2755 ! IMPLICIT OUTPUTS: ; 2756 ! ; 2757 ! None. ; 2758 ! ; 2759 ! COMPLETION CODES: ; 2760 ! ; 2761 ! None. ; 2762 ! ; 2763 ! SIDE EFFECTS: ; 2764 ! ; 2765 ! None. ; 2766 ! ; 2767 !-- ; 2768 ; 2769 BEGIN ; 2770 ROUTINE CHECK_DATA = ; 2771 BEGIN ; 2772 ; 2773 IF .REC_TYPE EQL MSG_DATA OR .REC_TYPE EQL MSG_FILE OR .REC_TYPE EQL MSG_EOF ; 2774 THEN ; 2775 RETURN TRUE ; 2776 ELSE ; 2777 RETURN FALSE; ; 2778 ; 2779 END; ;CHECK_DATA U.114: .WORD ^M<> ;Save nothing ; 2770 MOVL W^U.105, R0 ;U.105, R0 ; 2773 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 ; 2771 RET ; ; 2$: CLRL R0 ;R0 ; RET ; ; 2770 ; Routine Size: 41 bytes, Routine Base: $CODE$ + 09C3 ; 2780 ; 2781 LOCAL ; 2782 DISCARD_FILE_FLAG, ! Sender requested discard ; 2783 ACK_MSG_LEN; ! Length of ACK to send ; 2784 ; 2785 ! ; 2786 ! First get a message ; 2787 ! ; 2788 ; 2789 IF NOT REC_MESSAGE (CHECK_DATA) THEN RETURN STATE_A; ; 2790 ; 2791 SELECTONE .REC_TYPE OF ; 2792 SET ; 2793 ; 2794 [MSG_DATA] : ; 2795 BEGIN ; 2796 ; 2797 IF .MSG_NUMBER NEQ .REC_SEQ ; 2798 THEN ; 2799 BEGIN ; 2800 ; 2801 IF .OLD_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A; ; 2802 ; 2803 OLD_RETRIES = .OLD_RETRIES + 1; ; 2804 ; 2805 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 2806 THEN ; 2807 BEGIN ; 2808 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2809 NUM_RETRIES = 0; ; 2810 RETURN .STATE; ; 2811 END ; 2812 ELSE ; 2813 RETURN STATE_A; ; 2814 ; 2815 END; ; 2816 ; 2817 ! ; 2818 ! Here if we have a message with a valid message number ; 2819 ! ; 2820 ; 2821 IF NOT BFR_EMPTY () THEN RETURN STATE_A; ; 2822 ; 2823 ! ; 2824 ! Check if we wish to abort for some reason ; 2825 ! ; 2826 ; 2827 IF .ABT_CUR_FILE ; 2828 THEN ; 2829 BEGIN ; 2830 CH$WCHAR (MSG_ACK_ABT_CUR, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE)); ; 2831 ACK_MSG_LEN = 1; ; 2832 END ; 2833 ELSE ; 2834 ; 2835 IF .ABT_ALL_FILE ; 2836 THEN ; 2837 BEGIN ; 2838 CH$WCHAR (MSG_ACK_ABT_ALL, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE)); ; 2839 ACK_MSG_LEN = 1; ; 2840 END ; 2841 ELSE ; 2842 ACK_MSG_LEN = 0; ; 2843 ; 2844 ! ; 2845 ! Now send the ACK ; 2846 ! ; 2847 SEND_PACKET (MSG_ACK, .ACK_MSG_LEN, .REC_SEQ); ; 2848 OLD_RETRIES = .NUM_RETRIES; ; 2849 NUM_RETRIES = 0; ; 2850 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2851 RETURN STATE_RD; ; 2852 END; ; 2853 ; 2854 [MSG_FILE] : ; 2855 BEGIN ; 2856 ; 2857 IF .OLD_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A; ; 2858 ; 2859 OLD_RETRIES = .OLD_RETRIES + 1; ; 2860 ; 2861 IF .MSG_NUMBER - 1 EQL .REC_SEQ ; 2862 THEN ; 2863 BEGIN ; 2864 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2865 NUM_RETRIES = 0; ; 2866 RETURN .STATE; ; 2867 END ; 2868 ELSE ; 2869 RETURN STATE_A; ; 2870 ; 2871 END; ; 2872 ; 2873 [MSG_EOF] : ; 2874 BEGIN ; 2875 ; 2876 IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A; ; 2877 ; 2878 SEND_PACKET (MSG_ACK, 0, .REC_SEQ); ; 2879 FILE_OPEN_FLAG = FALSE; ; 2880 DISCARD_FILE_FLAG = FALSE; ! Assume we want file ; 2881 ; 2882 IF .REC_LENGTH EQL 1 ; 2883 THEN ; 2884 ; 2885 IF CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE)) EQL MSG_EOF_DISCARD ; 2886 THEN ; 2887 DISCARD_FILE_FLAG = .ABT_FLAG; ; 2888 ; 2889 IF ( NOT .CONNECT_FLAG) AND .TY_FIL ; 2890 THEN ; 2891 BEGIN ; 2892 ; 2893 IF .DISCARD_FILE_FLAG ; 2894 THEN ; 2895 ; 2896 IF .ABT_FLAG ; 2897 THEN ; 2898 TT_TEXT (UPLIT (%ASCIZ' [Interrupted]')) ; 2899 ELSE ; 2900 TT_TEXT (UPLIT (%ASCIZ' [Interrupted, partial file saved]')) ; 2901 ; 2902 ELSE ; 2903 TT_TEXT (UPLIT (%ASCIZ' [OK]')); ; 2904 ; 2905 TT_CRLF (); ; 2906 END; ; 2907 ; 2908 IF NOT FILE_CLOSE (.DISCARD_FILE_FLAG) THEN RETURN STATE_A; ; 2909 ; 2910 MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77'; ; 2911 RETURN STATE_RF; ; 2912 END; ; 2913 ; 2914 [OTHERWISE] : ; 2915 RETURN STATE_A; ; 2916 TES; ; 2917 ; 2918 END; ! End of REC_DATA .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAH: .ASCII \ [Interrupted]\<0><0> ; ; P.AAI: .ASCII \ [Interrupted, partial file saved]\<0><0> ; ; P.AAJ: .ASCII \ [OK]\<0><0><0> ; ; .PSECT $CODE$,NOWRT,2 ;REC_DATA U.13: .WORD ^M ;Save R2,R3,R4,R5 ; 2731 MOVAB W^U.21, R5 ;U.21, R5 ; MOVAB W^PKT_RETRIES, R4 ;PKT_RETRIES, R4 ; MOVAB W^U.102, R3 ;U.102, R3 ; PUSHAB B^U.114 ;U.114 ; 2789 CALLS #1, W^U.22 ;#1, U.22 ; BLBC R0, 3$ ;R0, 3$ ; MOVL 12(R3), R0 ;REC_TYPE, R0 ; 2791 CMPL R0, #68 ;R0, #68 ; BNEQ 10$ ;10$ ; MOVL 4(R3), R1 ;REC_SEQ, R1 ; 2797 CMPL (R3), R1 ;MSG_NUMBER, R1 ; BEQL 2$ ;2$ ; CMPL -8(R3), (R4) ;OLD_RETRIES, PKT_RETRIES ; 2801 BGTR 11$ ;11$ ; INCL -8(R3) ;OLD_RETRIES ; 2803 SUBL3 #1, (R3), R0 ;#1, MSG_NUMBER, R0 ; 2805 CMPL R0, R1 ;R0, R1 ; BEQL 1$ ;1$ ; BRW 14$ ;14$ ; 1$: PUSHL R1 ;R1 ; 2808 BRB 12$ ;12$ ; 2$: CALLS #0, W^U.24 ;#0, U.24 ; 2821 3$: BLBS R0, 5$ ;R0, 5$ ; 4$: BRW 20$ ;20$ ; 5$: BLBC 52(R4), 6$ ;ABT_CUR_FILE, 6$ ; 2827 MOVB #88, 116(R3) ;#88, SND_MSG+4 ; 2830 BRB 7$ ;7$ ; 2831 6$: BLBC 56(R4), 8$ ;ABT_ALL_FILE, 8$ ; 2835 MOVB #90, 116(R3) ;#90, SND_MSG+4 ; 2838 7$: MOVL #1, R0 ;#1, ACK_MSG_LEN ; 2839 BRB 9$ ;9$ ; 2835 8$: CLRL R0 ;ACK_MSG_LEN ; 2842 9$: PUSHL 4(R3) ;REC_SEQ ; 2847 PUSHL R0 ;ACK_MSG_LEN ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R5) ;#3, SEND_PACKET ; MOVL -4(R3), -8(R3) ;NUM_RETRIES, OLD_RETRIES ; 2848 CLRL -4(R3) ;NUM_RETRIES ; 2849 ADDL3 #1, (R3), R0 ;#1, MSG_NUMBER, R0 ; 2850 EXTZV #0, #6, R0, (R3) ;#0, #6, R0, MSG_NUMBER ; MOVL #8, R0 ;#8, R0 ; 2791 RET ; ; 10$: CMPL R0, #70 ;R0, #70 ; BNEQ 13$ ;13$ ; CMPL -8(R3), (R4) ;OLD_RETRIES, PKT_RETRIES ; 2857 BGTR 4$ ;4$ ; INCL -8(R3) ;OLD_RETRIES ; 2859 SUBL3 #1, (R3), R0 ;#1, MSG_NUMBER, R0 ; 2861 CMPL R0, 4(R3) ;R0, REC_SEQ ; 11$: BNEQ 4$ ;4$ ; PUSHL 4(R3) ;REC_SEQ ; 2864 12$: CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R5) ;#3, SEND_PACKET ; CLRL -4(R3) ;NUM_RETRIES ; 2865 MOVL -16(R3), R0 ;STATE, R0 ; 2855 RET ; ; 13$: CMPL R0, #90 ;R0, #90 ; 2791 14$: BNEQ 20$ ;20$ ; CMPL (R3), 4(R3) ;MSG_NUMBER, REC_SEQ ; 2876 BNEQ 20$ ;20$ ; PUSHL 4(R3) ;REC_SEQ ; 2878 CLRL -(SP) ;-(SP) ; MOVZBL #89, -(SP) ;#89, -(SP) ; CALLS #3, (R5) ;#3, SEND_PACKET ; CLRL 208(R3) ;FILE_OPEN_FLAG ; 2879 CLRL R2 ;DISCARD_FILE_FLAG ; 2880 CMPL 8(R3), #1 ;REC_LENGTH, #1 ; 2882 BNEQ 15$ ;15$ ; CMPB 20(R3), #68 ;REC_MSG+4, #68 ; 2885 BNEQ 15$ ;15$ ; MOVL 24(R4), R2 ;ABT_FLAG, DISCARD_FILE_FLAG ; 2887 15$: BLBS 48(R4), 19$ ;CONNECT_FLAG, 19$ ; 2889 BLBC 60(R4), 19$ ;TY_FIL, 19$ ; BLBC R2, 17$ ;DISCARD_FILE_FLAG, 17$ ; 2893 BLBC 24(R4), 16$ ;ABT_FLAG, 16$ ; 2896 PUSHAB W^P.AAH ;P.AAH ; 2898 BRB 18$ ;18$ ; 16$: PUSHAB W^P.AAI ;P.AAI ; 2900 BRB 18$ ;18$ ; 17$: PUSHAB W^P.AAJ ;P.AAJ ; 2903 18$: CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 2905 19$: PUSHL R2 ;DISCARD_FILE_FLAG ; 2908 CALLS #1, W^FILE_CLOSE ;#1, FILE_CLOSE ; BLBC R0, 20$ ;R0, 20$ ; ADDL3 #1, (R3), R0 ;#1, MSG_NUMBER, R0 ; 2910 EXTZV #0, #6, R0, (R3) ;#0, #6, R0, MSG_NUMBER ; MOVL #7, R0 ;#7, R0 ; 2791 RET ; ; 20$: MOVL #10, R0 ;#10, R0 ; RET ; ; 2731 ; Routine Size: 312 bytes, Routine Base: $CODE$ + 09EC ; 2919 %SBTTL 'CLEAR' ; 2920 ROUTINE CLEAR : NOVALUE = ; 2921 ; 2922 !++ ; 2923 ! FUNCTIONAL DESCRIPTION: ; 2924 ! ; 2925 ! This routine will clear the message buffer. ; 2926 ! ; 2927 ! CALLING SEQUENCE: ; 2928 ! ; 2929 ! CLEAR(); ; 2930 ! ; 2931 ! INPUT PARAMETERS: ; 2932 ! ; 2933 ! None. ; 2934 ! ; 2935 ! IMPLICIT INPUTS: ; 2936 ! ; 2937 ! None. ; 2938 ! ; 2939 ! OUTPUT PARAMETERS: ; 2940 ! ; 2941 ! None. ; 2942 ! ; 2943 ! IMPLICIT OUTPUTS: ; 2944 ! ; 2945 ! None. ; 2946 ! ; 2947 ! COMPLETION CODES: ; 2948 ! ; 2949 ! None. ; 2950 ! ; 2951 ! SIDE EFFECTS: ; 2952 ! ; 2953 ! None. ; 2954 ! ; 2955 !-- ; 2956 ; 2957 BEGIN ; 2958 CH$FILL (0, MAX_MSG, CH$PTR (SND_MSG, 0, CHR_SIZE)); ; 2959 END; ;CLEAR U.26: .WORD ^M ;Save R2,R3,R4,R5 ; 2920 MOVC5 #0, (SP), #0, #96, W^U.107 ;#0, (SP), #0, #96, U.107 ; 2958 RET ; ; 2920 ; Routine Size: 13 bytes, Routine Base: $CODE$ + 0B24 ; 2960 %SBTTL 'Message processing -- PRS_SEND_INIT - Parse send init params' ; 2961 ROUTINE PRS_SEND_INIT = ; 2962 ; 2963 !++ ; 2964 ! FUNCTIONAL DESCRIPTION: ; 2965 ! ; 2966 ! This routine will parse the SEND_INIT parameters that were sent by ; 2967 ! the remote Kermit. The items will be stored into the low segment. ; 2968 ! ; 2969 ! CALLING SEQUENCE: ; 2970 ! ; 2971 ! PRS_SEND_INIT (); ; 2972 ! ; 2973 ! INPUT PARAMETERS: ; 2974 ! ; 2975 ! None. ; 2976 ! ; 2977 ! IMPLICIT INPUTS: ; 2978 ! ; 2979 ! Message stored in REC_MSG. ; 2980 ! ; 2981 ! OUTPUT PARAMETERS: ; 2982 ! ; 2983 ! None. ; 2984 ! ; 2985 ! IMPLICIT OUTPUTS: ; 2986 ! ; 2987 ! None. ; 2988 ! ; 2989 ! COMPLETION CODES: ; 2990 ! ; 2991 ! None. ; 2992 ! ; 2993 ! SIDE EFFECTS: ; 2994 ! ; 2995 ! None. ; 2996 ! ; 2997 !-- ; 2998 ; 2999 BEGIN ; 3000 ! The following section of code will parse the various send parameters ; 3001 ! that are found in the send-init message. The following code will store ; 3002 ! the following as the value. ; 3003 ! ; 3004 ! If the user specified a value then the user supplied value will be used else ; 3005 ! the value in the message and if none in the message then the default value. ; 3006 ! ; 3007 ! User supplied values are denoted as positive values in SND_xxxxxxx. ; 3008 ! ; 3009 ! Parse the packet size ; 3010 ! ; 3011 SEND_PKT_SIZE = (IF .SND_PKT_SIZE GEQ 0 THEN .SND_PKT_SIZE ELSE ; 3012 BEGIN ; 3013 ; 3014 IF .REC_LENGTH GTR P_SI_BUFSIZ ; 3015 THEN ; P 3016 UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, ; 3017 PKT_MSG + P_SI_BUFSIZ, CHR_SIZE))) ; 3018 ELSE ; 3019 ABS (.SND_PKT_SIZE) ; 3020 ; 3021 END ; 3022 ); ; 3023 ! ; 3024 ! Parse the time out value ; 3025 ! ; 3026 SEND_TIMEOUT = (IF .SND_TIMEOUT GEQ 0 THEN .SND_TIMEOUT ELSE ; 3027 BEGIN ; 3028 ; 3029 IF .REC_LENGTH GTR P_SI_TIMOUT ; 3030 THEN ; P 3031 UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, ; 3032 PKT_MSG + P_SI_TIMOUT, CHR_SIZE))) ; 3033 ELSE ; 3034 ABS (.SND_TIMEOUT) ; 3035 ; 3036 END ; 3037 ); ; 3038 ! ; 3039 ! Parse the number of padding characters supplied ; 3040 ! ; 3041 SEND_NPAD = (IF .SND_NPAD GEQ 0 THEN .SND_NPAD ELSE ; 3042 BEGIN ; 3043 ; 3044 IF .REC_LENGTH GTR P_SI_NPAD ; 3045 THEN ; P 3046 UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_NPAD, ; 3047 CHR_SIZE))) ; 3048 ELSE ; 3049 ABS (.SND_NPAD) ; 3050 ; 3051 END ; 3052 ); ; 3053 ! ; 3054 ! Parse the padding character ; 3055 ! ; 3056 SEND_PADCHAR = (IF .SND_PADCHAR GEQ 0 THEN .SND_PADCHAR ELSE ; 3057 BEGIN ; 3058 ; 3059 IF .REC_LENGTH GTR P_SI_PAD ; 3060 THEN ; P 3061 CTL (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_PAD, ; 3062 CHR_SIZE))) ; 3063 ELSE ; 3064 ABS (.SND_PADCHAR) ; 3065 ; 3066 END ; 3067 ); ; 3068 ! ; 3069 ! Parse the end of line character ; 3070 ! ; 3071 SEND_EOL = (IF .SND_EOL GEQ 0 THEN .SND_EOL ELSE ; 3072 BEGIN ; 3073 ; 3074 IF .REC_LENGTH GTR P_SI_EOL ; 3075 THEN ; P 3076 UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_EOL, ; 3077 CHR_SIZE))) ; 3078 ELSE ; 3079 ABS (.SND_EOL) ; 3080 ; 3081 END ; 3082 ); ; 3083 ! ; 3084 ! Parse the quoting character ; 3085 ! ; 3086 SEND_QUOTE_CHR = (IF .SND_QUOTE_CHR GEQ 0 THEN .SND_QUOTE_CHR ELSE ; 3087 BEGIN ; 3088 ; 3089 IF .REC_LENGTH GTR P_SI_QUOTE ; 3090 THEN ; 3091 CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_QUOTE, ; 3092 CHR_SIZE)) ; 3093 ELSE ; 3094 ABS (.SND_QUOTE_CHR) ; 3095 ; 3096 END ; 3097 ); ; 3098 ! ; 3099 ! Parse the 8-bit quoting character ; 3100 ! ; 3101 ! If the character was not included in the packet, assume no eight-bit ; 3102 ! quoting allowed (we are probably talking to an old version of Kermit). ; 3103 ! ; 3104 SEND_8QUOTE_CHR = (IF .REC_LENGTH GTR P_SI_8QUOTE THEN CH$RCHAR (CH$PTR (REC_MSG, ; 3105 PKT_MSG + P_SI_8QUOTE, CHR_SIZE)) ELSE %C'N' ! Assume no 8-bit quoting allowed ; 3106 ); ; 3107 ! ; 3108 ! Parse the checksum type ; 3109 ! ; 3110 ; 3111 IF .REC_LENGTH GTR P_SI_CHKTYPE ; 3112 THEN ; 3113 BEGIN ; 3114 ; 3115 IF CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_CHKTYPE, CHR_SIZE)) NEQ .CHKTYPE ; 3116 THEN ; 3117 INI_CHK_TYPE = CHK_1CHAR ; 3118 ; 3119 END ; 3120 ELSE ; 3121 INI_CHK_TYPE = CHK_1CHAR; ! Only single character checksum if not specified ; 3122 ; 3123 ! ; 3124 ! Parse the repeat character ; 3125 ! ; 3126 REPT_CHR = (IF .REC_LENGTH GTR P_SI_REPEAT THEN CH$RCHAR (CH$PTR (REC_MSG, ; 3127 PKT_MSG + P_SI_REPEAT, CHR_SIZE)) ELSE %C' '); ; 3128 ! ; 3129 ! Check for a valid quoting character. If it is not valid, then we have ; 3130 ! a protocol error ; 3131 ! ; 3132 ; 3133 IF NOT ((.SEND_QUOTE_CHR GEQ %O'41' AND .SEND_QUOTE_CHR LEQ %O'76') OR (.SEND_QUOTE_CHR GEQ %O ; 3134 '140' AND .SEND_QUOTE_CHR LEQ %O'176')) ; 3135 THEN ; 3136 BEGIN ; 3137 KRM_ERROR (KER_PROTOERR); ; 3138 RETURN KER_PROTOERR; ; 3139 END; ; 3140 ; 3141 ! ; 3142 ! Check for a valid 8 bit quoting and set the 8 bit quoting flag as needed ; 3143 ! ; 3144 ; 3145 IF ( NOT ((.SEND_8QUOTE_CHR GEQ %O'041' AND .SEND_8QUOTE_CHR LEQ %O'076') OR (.SEND_8QUOTE_CHR ; 3146 GEQ %O'140' AND .SEND_8QUOTE_CHR LEQ %O'176') OR (.SEND_8QUOTE_CHR EQL %C'N') OR ( ; 3147 .SEND_8QUOTE_CHR EQL %C'Y'))) OR .SEND_8QUOTE_CHR EQL .SEND_QUOTE_CHR ; 3148 THEN ; 3149 BEGIN ; 3150 KRM_ERROR (KER_PROTOERR); ; 3151 RETURN KER_PROTOERR; ; 3152 END; ; 3153 ; 3154 IF .SEND_8QUOTE_CHR EQL %C'Y' THEN SEND_8QUOTE_CHR = .RECV_8QUOTE_CHR; ; 3155 ; 3156 IF .SEND_8QUOTE_CHR NEQ %C'N' AND .SEND_8QUOTE_CHR NEQ %C'Y' ; 3157 THEN ; 3158 FLAG_8QUOTE = TRUE ; 3159 ELSE ; 3160 FLAG_8QUOTE = FALSE; ; 3161 ; 3162 ! ; 3163 ! Check the repeat character and set flags ; 3164 ! ; 3165 ; 3166 IF ( NOT ((.REPT_CHR GEQ %O'41' AND .REPT_CHR LEQ %O'76') OR (.REPT_CHR GEQ %O'140' AND ; 3167 .REPT_CHR LEQ %O'176')) OR .REPT_CHR EQL .SEND_QUOTE_CHR OR .REPT_CHR EQL .SEND_8QUOTE_CHR) ; 3168 AND .REPT_CHR NEQ %C' ' ; 3169 THEN ; 3170 BEGIN ; 3171 KRM_ERROR (KER_PROTOERR); ; 3172 RETURN KER_PROTOERR; ; 3173 END; ; 3174 ; 3175 IF .REPT_CHR NEQ %C' ' THEN FLAG_REPEAT = TRUE ELSE FLAG_REPEAT = FALSE; ; 3176 ; 3177 RETURN KER_NORMAL; ; 3178 END; ! End of PRS_SEND_INIT ;PRS_SEND_INIT U.18: .WORD ^M ;Save R2,R3 ; 2961 MOVAB W^SND_PKT_SIZE, R3 ;SND_PKT_SIZE, R3 ; MOVAB W^U.104, R2 ;U.104, R2 ; MOVL (R3), R0 ;SND_PKT_SIZE, R0 ; 3011 BGEQ 2$ ;2$ ; TSTL (R2) ;REC_LENGTH ; 3014 BLEQ 1$ ;1$ ; MOVZBL 12(R2), R0 ;REC_MSG+4, R0 ; 3017 SUBL2 #32, R0 ;#32, R0 ; BRB 2$ ;2$ ; 3012 1$: TSTL R0 ;R0 ; 3019 BGEQ 2$ ;2$ ; MNEGL R0, R0 ;R0, R0 ; 2$: MOVL R0, -72(R2) ;R0, SEND_PKT_SIZE ; 3011 MOVL 12(R3), R0 ;SND_TIMEOUT, R0 ; 3026 BGEQ 4$ ;4$ ; CMPL (R2), #1 ;REC_LENGTH, #1 ; 3029 BLEQ 3$ ;3$ ; MOVZBL 13(R2), R0 ;REC_MSG+5, R0 ; 3032 SUBL2 #32, R0 ;#32, R0 ; BRB 4$ ;4$ ; 3027 3$: TSTL R0 ;R0 ; 3034 BGEQ 4$ ;4$ ; MNEGL R0, R0 ;R0, R0 ; 4$: MOVL R0, -60(R2) ;R0, SEND_TIMEOUT ; 3026 MOVL 4(R3), R0 ;SND_NPAD, R0 ; 3041 BGEQ 6$ ;6$ ; CMPL (R2), #2 ;REC_LENGTH, #2 ; 3044 BLEQ 5$ ;5$ ; MOVZBL 14(R2), R0 ;REC_MSG+6, R0 ; 3047 SUBL2 #32, R0 ;#32, R0 ; BRB 6$ ;6$ ; 3042 5$: TSTL R0 ;R0 ; 3049 BGEQ 6$ ;6$ ; MNEGL R0, R0 ;R0, R0 ; 6$: MOVL R0, -68(R2) ;R0, SEND_NPAD ; 3041 MOVL 8(R3), R0 ;SND_PADCHAR, R0 ; 3056 BGEQ 8$ ;8$ ; CMPL (R2), #3 ;REC_LENGTH, #3 ; 3059 BLEQ 7$ ;7$ ; MOVZBL 15(R2), R0 ;REC_MSG+7, R0 ; 3062 XORL2 #64, R0 ;#64, R0 ; BRB 8$ ;8$ ; 3057 7$: TSTL R0 ;R0 ; 3064 BGEQ 8$ ;8$ ; MNEGL R0, R0 ;R0, R0 ; 8$: MOVL R0, -64(R2) ;R0, SEND_PADCHAR ; 3056 MOVL 16(R3), R0 ;SND_EOL, R0 ; 3071 BGEQ 10$ ;10$ ; CMPL (R2), #4 ;REC_LENGTH, #4 ; 3074 BLEQ 9$ ;9$ ; MOVZBL 16(R2), R0 ;REC_MSG+8, R0 ; 3077 SUBL2 #32, R0 ;#32, R0 ; BRB 10$ ;10$ ; 3072 9$: TSTL R0 ;R0 ; 3079 BGEQ 10$ ;10$ ; MNEGL R0, R0 ;R0, R0 ; 10$: MOVL R0, -56(R2) ;R0, SEND_EOL ; 3071 MOVL 20(R3), R0 ;SND_QUOTE_CHR, R0 ; 3086 BGEQ 12$ ;12$ ; CMPL (R2), #5 ;REC_LENGTH, #5 ; 3089 BLEQ 11$ ;11$ ; MOVZBL 17(R2), R0 ;REC_MSG+9, R0 ; 3087 BRB 12$ ;12$ ; 11$: TSTL R0 ;R0 ; 3094 BGEQ 12$ ;12$ ; MNEGL R0, R0 ;R0, R0 ; 12$: MOVL R0, -52(R2) ;R0, SEND_QUOTE_CHR ; 3086 MOVL (R2), R1 ;REC_LENGTH, R1 ; 3104 CMPL R1, #6 ;R1, #6 ; BLEQ 13$ ;13$ ; MOVZBL 18(R2), R0 ;REC_MSG+10, R0 ; BRB 14$ ;14$ ; 13$: MOVZBL #78, R0 ;#78, R0 ; 14$: MOVL R0, -48(R2) ;R0, SEND_8QUOTE_CHR ; CMPL R1, #7 ;R1, #7 ; 3111 BLEQ 15$ ;15$ ; CMPZV #0, #8, 19(R2), 352(R3) ;#0, #8, REC_MSG+11, CHKTYPE ; 3115 BEQL 16$ ;16$ ; 15$: MOVL #49, -44(R2) ;#49, INI_CHK_TYPE ; 3121 16$: CMPL R1, #8 ;R1, #8 ; 3126 BLEQ 17$ ;17$ ; MOVZBL 20(R2), R0 ;REC_MSG+12, R0 ; BRB 18$ ;18$ ; 17$: MOVL #32, R0 ;#32, R0 ; 18$: MOVL R0, -76(R2) ;R0, REPT_CHR ; MOVL -52(R2), R0 ;SEND_QUOTE_CHR, R0 ; 3133 CMPL R0, #33 ;R0, #33 ; BLSS 19$ ;19$ ; CMPL R0, #62 ;R0, #62 ; BLEQ 22$ ;22$ ; 19$: CMPL R0, #96 ;R0, #96 ; BGEQ 21$ ;21$ ; 20$: BRW 32$ ;32$ ; 21$: CMPL R0, #126 ;R0, #126 ; 3134 BGTR 20$ ;20$ ; 22$: MOVL -48(R2), R0 ;SEND_8QUOTE_CHR, R0 ; 3145 CMPL R0, #33 ;R0, #33 ; BLSS 23$ ;23$ ; CMPL R0, #62 ;R0, #62 ; BLEQ 25$ ;25$ ; 23$: CMPL R0, #96 ;R0, #96 ; 3146 BLSS 24$ ;24$ ; CMPL R0, #126 ;R0, #126 ; BLEQ 25$ ;25$ ; 24$: CMPL R0, #78 ;R0, #78 ; BEQL 25$ ;25$ ; CMPL R0, #89 ;R0, #89 ; BNEQ 32$ ;32$ ; 25$: CMPL R0, -52(R2) ;R0, SEND_QUOTE_CHR ; 3147 BEQL 32$ ;32$ ; CMPL -48(R2), #89 ;SEND_8QUOTE_CHR, #89 ; 3154 BNEQ 26$ ;26$ ; MOVL -80(R2), -48(R2) ;RECV_8QUOTE_CHR, SEND_8QUOTE_CHR ; 26$: MOVL -48(R2), R1 ;SEND_8QUOTE_CHR, R1 ; 3156 CMPL R1, #78 ;R1, #78 ; BEQL 27$ ;27$ ; CMPL R1, #89 ;R1, #89 ; BEQL 27$ ;27$ ; MOVL #1, -36(R2) ;#1, FLAG_8QUOTE ; 3158 BRB 28$ ;28$ ; 3156 27$: CLRL -36(R2) ;FLAG_8QUOTE ; 3160 28$: MOVL -76(R2), R0 ;REPT_CHR, R0 ; 3166 CMPL R0, #33 ;R0, #33 ; BLSS 29$ ;29$ ; CMPL R0, #62 ;R0, #62 ; BLEQ 30$ ;30$ ; 29$: CMPL R0, #96 ;R0, #96 ; BLSS 31$ ;31$ ; CMPL R0, #126 ;R0, #126 ; 3167 BGTR 31$ ;31$ ; 30$: CMPL R0, -52(R2) ;R0, SEND_QUOTE_CHR ; BEQL 31$ ;31$ ; CMPL R0, R1 ;R0, R1 ; BNEQ 33$ ;33$ ; 31$: CMPL R0, #32 ;R0, #32 ; 3168 BEQL 33$ ;33$ ; 32$: PUSHL #134316210 ;#134316210 ; 3171 CALLS #1, W^KRM_ERROR ;#1, KRM_ERROR ; MOVL #134316210, R0 ;#134316210, R0 ; 3170 RET ; ; 33$: CMPL -76(R2), #32 ;REPT_CHR, #32 ; 3175 BEQL 34$ ;34$ ; MOVL #1, -32(R2) ;#1, FLAG_REPEAT ; BRB 35$ ;35$ ; 34$: CLRL -32(R2) ;FLAG_REPEAT ; 35$: MOVL #134316043, R0 ;#134316043, R0 ; 2999 RET ; ; 2961 ; Routine Size: 483 bytes, Routine Base: $CODE$ + 0B31 ; 3179 %SBTTL 'SET_SEND_INIT' ; 3180 ROUTINE SET_SEND_INIT : NOVALUE = ; 3181 ; 3182 !++ ; 3183 ! FUNCTIONAL DESCRIPTION: ; 3184 ! ; 3185 ! This routine will initialize the various parameters for the ; 3186 ! MSG_SND_INIT message. ; 3187 ! ; 3188 ! CALLING SEQUENCE: ; 3189 ! ; 3190 ! SET_SEND_INIT(); ; 3191 ! ; 3192 ! INPUT PARAMETERS: ; 3193 ! ; 3194 ! None. ; 3195 ! ; 3196 ! IMPLICIT INPUTS: ; 3197 ! ; 3198 ! None. ; 3199 ! ; 3200 ! OUTPUT PARAMETERS: ; 3201 ! ; 3202 ! None. ; 3203 ! ; 3204 ! IMPLICIT OUTPUTS: ; 3205 ! ; 3206 ! SND_MSG parameters set up. ; 3207 ! ; 3208 ! COMPLETION CODES: ; 3209 ! ; 3210 ! None. ; 3211 ! ; 3212 ! SIDE EFFECTS: ; 3213 ! ; 3214 ! None. ; 3215 ! ; 3216 !-- ; 3217 ; 3218 BEGIN ; 3219 CH$WCHAR (CHAR (.RCV_PKT_SIZE), CH$PTR (SND_MSG, PKT_MSG + P_SI_BUFSIZ, CHR_SIZE)); ; 3220 CH$WCHAR (CHAR (.RCV_TIMEOUT), CH$PTR (SND_MSG, PKT_MSG + P_SI_TIMOUT, CHR_SIZE)); ; 3221 CH$WCHAR (CHAR (.RCV_NPAD), CH$PTR (SND_MSG, PKT_MSG + P_SI_NPAD, CHR_SIZE)); ; 3222 CH$WCHAR (CTL (.RCV_PADCHAR), CH$PTR (SND_MSG, PKT_MSG + P_SI_PAD, CHR_SIZE)); ; 3223 CH$WCHAR (CHAR (.RCV_EOL), CH$PTR (SND_MSG, PKT_MSG + P_SI_EOL, CHR_SIZE)); ; 3224 CH$WCHAR (.RCV_QUOTE_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_QUOTE, CHR_SIZE)); ; 3225 CH$WCHAR (.SEND_8QUOTE_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_8QUOTE, CHR_SIZE)); ; 3226 CH$WCHAR (.INI_CHK_TYPE, CH$PTR (SND_MSG, PKT_MSG + P_SI_CHKTYPE, CHR_SIZE)); ; 3227 CH$WCHAR (.REPT_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_REPEAT, CHR_SIZE)); ; 3228 END; ! End of SET_SEND_INIT ;SET_SEND_INIT U.17: .WORD ^M ;Save R2,R3 ; 3180 MOVAB W^RCV_PKT_SIZE, R3 ;RCV_PKT_SIZE, R3 ; MOVAB W^U.107+4, R2 ;U.107+4, R2 ; ADDB3 #32, (R3), (R2) ;#32, RCV_PKT_SIZE, SND_MSG+4 ; 3219 ADDB3 #32, 12(R3), 1(R2) ;#32, RCV_TIMEOUT, SND_MSG+5 ; 3220 ADDB3 #32, 4(R3), 2(R2) ;#32, RCV_NPAD, SND_MSG+6 ; 3221 XORB3 #64, 8(R3), 3(R2) ;#64, RCV_PADCHAR, SND_MSG+7 ; 3222 ADDB3 #32, 16(R3), 4(R2) ;#32, RCV_EOL, SND_MSG+8 ; 3223 MOVB 20(R3), 5(R2) ;RCV_QUOTE_CHR, SND_MSG+9 ; 3224 MOVB -156(R2), 6(R2) ;SEND_8QUOTE_CHR, SND_MSG+10 ; 3225 MOVB -152(R2), 7(R2) ;INI_CHK_TYPE, SND_MSG+11 ; 3226 MOVB -184(R2), 8(R2) ;REPT_CHR, SND_MSG+12 ; 3227 RET ; ; 3180 ; Routine Size: 65 bytes, Routine Base: $CODE$ + 0D14 ; 3229 %SBTTL 'SEND_PACKET' ; 3230 ROUTINE SEND_PACKET (TYPE, LENGTH, MN) = ; 3231 ; 3232 !++ ; 3233 ! FUNCTIONAL DESCRIPTION: ; 3234 ! ; 3235 ! This routine will cause a packet to be sent over the line ; 3236 ! that has been opened by OPEN_TERMINAL. ; 3237 ! ; 3238 ! CALLING SEQUENCE: ; 3239 ! ; 3240 ! SEND_PACKET(Type, Length); ; 3241 ! ; 3242 ! INPUT PARAMETERS: ; 3243 ! ; 3244 ! TYPE - Type of packet to send. ; 3245 ! ; 3246 ! LENGTH - Length of the packet being sent. ; 3247 ! ; 3248 ! IMPLICIT INPUTS: ; 3249 ! ; 3250 ! None. ; 3251 ! ; 3252 ! OUTPUT PARAMETERS: ; 3253 ! ; 3254 ! None. ; 3255 ! ; 3256 ! IMPLICIT OUTPUTS: ; 3257 ! ; 3258 ! None. ; 3259 ! ; 3260 ! COMPLETION CODES: ; 3261 ! ; 3262 ! None. ; 3263 ! ; 3264 ! SIDE EFFECTS: ; 3265 ! ; 3266 ! None. ; 3267 ! ; 3268 !-- ; 3269 ; 3270 BEGIN ; 3271 ; 3272 LOCAL ; 3273 FILLER : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ; 3274 TOT_MSG_LEN, ! Length of message including all characters ; 3275 CHKSUM, ! Checksum for the message we calculate ; 3276 POINTER; ! Pointer to the information in the message ; 3277 ; 3278 ! ; 3279 ! Do any filler processing that the remote KERMIT requires. ; 3280 ! ; 3281 ; 3282 IF .SEND_NPAD NEQ 0 ; 3283 THEN ; 3284 BEGIN ; 3285 CH$FILL (.SEND_PADCHAR, MAX_MSG, CH$PTR (FILLER, 0, CHR_SIZE)); ; 3286 ! ; 3287 ! Update the send stats ; 3288 ! ; 3289 SMSG_TOTAL_CHARS = .SMSG_TOTAL_CHARS + .SEND_NPAD; ; 3290 ! ; 3291 ! Send the fill ; 3292 ! ; 3293 DO_PARITY (FILLER, .SEND_NPAD + PKT_TOT_OVR_HEAD); ; 3294 SEND (FILLER, .SEND_NPAD + PKT_TOT_OVR_HEAD); ; 3295 END; ; 3296 ; 3297 ! ; 3298 ! Store the header information into the message. ; 3299 ! ; 3300 CH$WCHAR (.TYPE, CH$PTR (SND_MSG, PKT_TYPE, CHR_SIZE)); ; 3301 CH$WCHAR (.SND_SOH, CH$PTR (SND_MSG, PKT_MARK, CHR_SIZE)); ; 3302 CH$WCHAR (CHAR (.LENGTH + PKT_OVR_HEAD + (.BLK_CHK_TYPE - CHK_1CHAR)), ; 3303 CH$PTR (SND_MSG, ; 3304 PKT_COUNT, CHR_SIZE)); ; 3305 CH$WCHAR (CHAR ((IF .MN LSS 0 THEN 0 ELSE .MN)), CH$PTR (SND_MSG, PKT_SEQ, CHR_SIZE)); ; 3306 ! ; 3307 ! Calculate the block check value ; 3308 ! ; 3309 POINTER = CH$PTR (SND_MSG, PKT_MARK + 1, CHR_SIZE); ; 3310 CHKSUM = CALC_BLOCK_CHECK (.POINTER, .LENGTH + PKT_OVR_HEAD); ; 3311 TOT_MSG_LEN = .LENGTH + PKT_TOT_OVR_HEAD; ; 3312 ! ; 3313 ! Store the checksum into the message ; 3314 ! ; 3315 POINTER = CH$PTR (SND_MSG, .LENGTH + PKT_OVR_HEAD + 1, CHR_SIZE); ; 3316 ; 3317 CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF ; 3318 SET ; 3319 ; 3320 [CHK_1CHAR] : ; 3321 CH$WCHAR_A (CHAR (.CHKSUM), POINTER); ; 3322 ; 3323 [CHK_2CHAR] : ; 3324 BEGIN ; 3325 CH$WCHAR_A (CHAR (.CHKSUM<6, 6>), POINTER); ; 3326 CH$WCHAR_A (CHAR (.CHKSUM<0, 6>), POINTER); ; 3327 TOT_MSG_LEN = .TOT_MSG_LEN + 1; ; 3328 END; ; 3329 ; 3330 [CHK_CRC] : ; 3331 BEGIN ; 3332 CH$WCHAR_A (CHAR (.CHKSUM<12, 4>), POINTER); ; 3333 CH$WCHAR_A (CHAR (.CHKSUM<6, 6>), POINTER); ; 3334 CH$WCHAR_A (CHAR (.CHKSUM<0, 6>), POINTER); ; 3335 TOT_MSG_LEN = .TOT_MSG_LEN + 2; ; 3336 END; ; 3337 TES; ; 3338 ; 3339 ! ; 3340 ! Store in the end of line character ; 3341 ! ; 3342 CH$WCHAR_A (.SEND_EOL, POINTER); ; 3343 ! ; 3344 ! If we are debugging then type out the message we are sending. ; 3345 ! ; 3346 DBG_SEND (SND_MSG, (.TOT_MSG_LEN)); ; 3347 ! ; 3348 ! Update the stats for total characters and the data characters ; 3349 ! ; 3350 SMSG_TOTAL_CHARS = .SMSG_TOTAL_CHARS + .TOT_MSG_LEN; ; 3351 SMSG_DATA_CHARS = .SMSG_DATA_CHARS + .LENGTH; ; 3352 ; 3353 IF .TYPE EQL MSG_NAK ; 3354 THEN ; 3355 BEGIN ; 3356 SMSG_NAKS = .SMSG_NAKS + 1; ; 3357 XFR_STATUS (%C'S', %C'N'); ; 3358 END ; 3359 ELSE ; 3360 BEGIN ; 3361 SND_COUNT = .SND_COUNT + 1; ; 3362 XFR_STATUS (%C'S', %C'P'); ; 3363 END; ; 3364 ; 3365 ! ; 3366 ! Check if we are in IBM mode and need to wait for an XON first ; 3367 ! We will not wait if this is a packet which might be going out ; 3368 ! without previous traffic (generic commands, init packets). ; 3369 ; 3370 IF .IBM_FLAG AND NOT (.TYPE EQL MSG_SND_INIT OR .TYPE EQL MSG_SER_INIT OR .TYPE EQL MSG_RCV_INIT ; 3371 OR .TYPE EQL MSG_COMMAND OR .TYPE EQL MSG_KERMIT) ; 3372 THEN ; 3373 ; 3374 IF NOT IBM_WAIT () THEN RETURN KER_ABORTED; ; 3375 ; 3376 ! ; 3377 ! Now call the O/S routine to send the message out to the remote KERMIT ; 3378 ! ; 3379 DO_PARITY (SND_MSG, .TOT_MSG_LEN); ; 3380 RETURN SEND (SND_MSG, .TOT_MSG_LEN); ; 3381 END; ! End of SEND_PACKET ;SEND_PACKET U.21: .WORD ^M ;Save R2,R3,R4,R5,R6,R7,R8 ; 3230 MOVAB W^SMSG_TOTAL_CHARS, R8 ;SMSG_TOTAL_CHARS, R8 ; MOVAB W^U.107, R7 ;U.107, R7 ; MOVAB -96(SP), SP ;-96(SP), SP ; MOVL -172(R7), R6 ;SEND_NPAD, R6 ; 3282 BEQL 1$ ;1$ ; MOVC5 #0, (SP), -168(R7), #96, (SP) ;#0, (SP), SEND_PADCHAR, #96, FILLER ; 3285 ADDL2 R6, (R8) ;R6, SMSG_TOTAL_CHARS ; 3289 PUSHAB 6(R6) ;6(R6) ; 3293 PUSHAB 4(SP) ;FILLER ; CALLS #2, W^U.19 ;#2, U.19 ; ADDL3 #6, -172(R7), -(SP) ;#6, SEND_NPAD, -(SP) ; 3294 PUSHAB 4(SP) ;FILLER ; CALLS #2, W^SEND ;#2, SEND ; 1$: MOVL 4(AP), R4 ;TYPE, R4 ; 3300 MOVB R4, 3(R7) ;R4, SND_MSG+3 ; MOVB -36(R8), (R7) ;SND_SOH, SND_MSG ; 3301 MOVL 8(AP), R3 ;LENGTH, R3 ; 3302 ADDL3 -144(R7), R3, R0 ;BLK_CHK_TYPE, R3, R0 ; SUBB3 #14, R0, 1(R7) ;#14, R0, SND_MSG+1 ; TSTL 12(AP) ;MN ; 3305 BGEQ 2$ ;2$ ; CLRL R0 ;R0 ; BRB 3$ ;3$ ; 2$: MOVL 12(AP), R0 ;MN, R0 ; 3$: ADDB3 #32, R0, 2(R7) ;#32, R0, SND_MSG+2 ; MOVAB 1(R7), R2 ;SND_MSG+1, POINTER ; 3309 PUSHAB 3(R3) ;3(R3) ; 3310 PUSHL R2 ;POINTER ; CALLS #2, W^U.16 ;#2, U.16 ; MOVAB 6(R3), R5 ;6(R3), TOT_MSG_LEN ; 3311 MOVAB 4(R7)[R3], R2 ;SND_MSG+4[R3], POINTER ; 3315 CASEL -144(R7), #49, #2 ;BLK_CHK_TYPE, #49, #2 ; 3317 4$: .WORD 5$-4$,- ;5$-4$,- ; 6$-4$,- ;6$-4$,- ; 7$-4$ ;7$-4$ ; 5$: ADDB3 #32, R0, (R2) ;#32, CHKSUM, (POINTER) ; 3321 BRB 8$ ;8$ ; 3317 6$: EXTZV #6, #6, R0, R1 ;#6, #6, CHKSUM, R1 ; 3325 ADDB3 #32, R1, (R2)+ ;#32, R1, (POINTER)+ ; EXTZV #0, #6, R0, R1 ;#0, #6, CHKSUM, R1 ; 3326 ADDB3 #32, R1, (R2) ;#32, R1, (POINTER) ; INCL R5 ;TOT_MSG_LEN ; 3327 BRB 8$ ;8$ ; 3317 7$: EXTZV #12, #4, R0, R1 ;#12, #4, CHKSUM, R1 ; 3332 ADDB3 #32, R1, (R2)+ ;#32, R1, (POINTER)+ ; EXTZV #6, #6, R0, R1 ;#6, #6, CHKSUM, R1 ; 3333 ADDB3 #32, R1, (R2)+ ;#32, R1, (POINTER)+ ; EXTZV #0, #6, R0, R1 ;#0, #6, CHKSUM, R1 ; 3334 ADDB3 #32, R1, (R2) ;#32, R1, (POINTER) ; ADDL2 #2, R5 ;#2, TOT_MSG_LEN ; 3335 8$: INCL R2 ;POINTER ; 3321 MOVB -160(R7), (R2)+ ;SEND_EOL, (POINTER)+ ; 3342 PUSHL R5 ;TOT_MSG_LEN ; 3346 PUSHL R7 ;R7 ; CALLS #2, W^U.29 ;#2, U.29 ; ADDL2 R5, (R8) ;TOT_MSG_LEN, SMSG_TOTAL_CHARS ; 3350 ADDL2 R3, 8(R8) ;R3, SMSG_DATA_CHARS ; 3351 CMPL R4, #78 ;R4, #78 ; 3353 BNEQ 9$ ;9$ ; INCL 16(R8) ;SMSG_NAKS ; 3356 MOVZBL #78, -(SP) ;#78, -(SP) ; 3357 BRB 10$ ;10$ ; 9$: INCL -8(R8) ;SND_COUNT ; 3361 MOVZBL #80, -(SP) ;#80, -(SP) ; 3362 10$: MOVZBL #83, -(SP) ;#83, -(SP) ; CALLS #2, W^XFR_STATUS ;#2, XFR_STATUS ; BLBC 308(R8), 11$ ;IBM_FLAG, 11$ ; 3370 CMPL R4, #83 ;R4, #83 ; BEQL 11$ ;11$ ; CMPL R4, #73 ;R4, #73 ; BEQL 11$ ;11$ ; CMPL R4, #82 ;R4, #82 ; BEQL 11$ ;11$ ; CMPL R4, #67 ;R4, #67 ; 3371 BEQL 11$ ;11$ ; CMPL R4, #71 ;R4, #71 ; BEQL 11$ ;11$ ; CALLS #0, W^IBM_WAIT ;#0, IBM_WAIT ; 3374 BLBS R0, 11$ ;R0, 11$ ; MOVL #134316242, R0 ;#134316242, R0 ; RET ; ; 11$: PUSHL R5 ;TOT_MSG_LEN ; 3379 PUSHL R7 ;R7 ; CALLS #2, W^U.19 ;#2, U.19 ; PUSHL R5 ;TOT_MSG_LEN ; 3380 PUSHL R7 ;R7 ; CALLS #2, W^SEND ;#2, SEND ; RET ; ; 3230 ; Routine Size: 341 bytes, Routine Base: $CODE$ + 0D55 ; 3382 %SBTTL 'REC_MESSAGE - Receive a message' ; 3383 ROUTINE REC_MESSAGE (CHK_ROUTINE) = ; 3384 ; 3385 !++ ; 3386 ! FUNCTIONAL DESCRIPTION: ; 3387 ! ; 3388 ! This routine will handle the retry processing for the various ; 3389 ! messages that can be received. ; 3390 ! ; 3391 ! CALLING SEQUENCE: ; 3392 ! ; 3393 ! INPUT PARAMETERS: ; 3394 ! ; 3395 ! None. ; 3396 ! ; 3397 ! IMPLICIT INPUTS: ; 3398 ! ; 3399 ! None. ; 3400 ! ; 3401 ! OUTPUT PARAMETERS: ; 3402 ! ; 3403 ! None. ; 3404 ! ; 3405 ! IMPLICIT OUTPUTS: ; 3406 ! ; 3407 ! None. ; 3408 ! ; 3409 ! COMPLETION CODES: ; 3410 ! ; 3411 ! KER_NORMAL - Normal return ; 3412 ! KER_RETRIES - Too many retries ; 3413 ! (What ever REC_PACKET returns). ; 3414 ! ; 3415 ! SIDE EFFECTS: ; 3416 ! ; 3417 ! None. ; 3418 ! ; 3419 !-- ; 3420 ; 3421 BEGIN ; 3422 RETURN ; 3423 ; 3424 WHILE TRUE DO ; 3425 BEGIN ; 3426 ! I don't think this check is needed. ; 3427 ! IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN KER_RETRIES; ; 3428 NUM_RETRIES = .NUM_RETRIES + 1; ; 3429 STATUS = REC_PACKET (); ; 3430 ; 3431 IF NOT .STATUS AND .STATUS NEQ KER_CHKSUMERR THEN EXITLOOP .STATUS; ; 3432 ; 3433 IF NOT .STATUS ; 3434 THEN ; 3435 SEND_PACKET (MSG_NAK, 0, .MSG_NUMBER - 1) ; 3436 ELSE ; 3437 BEGIN ; 3438 ; 3439 IF NOT (.CHK_ROUTINE) () ; 3440 THEN ; 3441 SEND_PACKET (MSG_NAK, 0, .REC_SEQ) ; 3442 ELSE ; 3443 EXITLOOP KER_NORMAL; ; 3444 ; 3445 END; ; 3446 ; 3447 END; ; 3448 ; 3449 END; ! End of REC_PARSE ;REC_MESSAGE U.22: .WORD ^M<> ;Save nothing ; 3383 1$: INCL W^U.101 ;U.101 ; 3428 CALLS #0, W^U.23 ;#0, U.23 ; 3429 MOVL R0, W^U.97 ;R0, U.97 ; BLBS R0, 2$ ;R0, 2$ ; 3431 CMPL R0, #134316162 ;R0, #134316162 ; BNEQ 5$ ;5$ ; BLBS R0, 2$ ;R0, 2$ ; 3433 SUBL3 #1, W^U.102, -(SP) ;#1, U.102, -(SP) ; 3435 BRB 3$ ;3$ ; 2$: CALLS #0, @4(AP) ;#0, @CHK_ROUTINE ; 3439 BLBS R0, 4$ ;R0, 4$ ; PUSHL W^U.103 ;U.103 ; 3441 3$: CLRL -(SP) ;-(SP) ; MOVZBL #78, -(SP) ;#78, -(SP) ; CALLS #3, W^U.21 ;#3, U.21 ; BRB 1$ ;1$ ; 3439 4$: MOVL #134316043, R0 ;#134316043, R0 ; 3443 5$: RET ; ; 3383 ; Routine Size: 71 bytes, Routine Base: $CODE$ + 0EAA ; 3450 %SBTTL 'REC_PACKET' ; 3451 ROUTINE REC_PACKET = ; 3452 ; 3453 !++ ; 3454 ! FUNCTIONAL DESCRIPTION: ; 3455 ! ; 3456 ! This routine will do the oppoiste of SEND_PACKET. It will wait ; 3457 ! for the message to be read from the remote and then it will ; 3458 ! check the message for validity. ; 3459 ! ; 3460 ! CALLING SEQUENCE: ; 3461 ! ; 3462 ! Flag = REC_PACKET(); ; 3463 ! ; 3464 ! INPUT PARAMETERS: ; 3465 ! ; 3466 ! None. ; 3467 ! ; 3468 ! IMPLICIT INPUTS: ; 3469 ! ; 3470 ! None. ; 3471 ! ; 3472 ! OUTPUT PARAMETERS: ; 3473 ! ; 3474 ! None. ; 3475 ! ; 3476 ! IMPLICIT OUTPUTS: ; 3477 ! ; 3478 ! REC_MSG - Contains the message received. ; 3479 ! ; 3480 ! COMPLETION CODES: ; 3481 ! ; 3482 ! True - Packet receive ok. ; 3483 ! False - Problem occured during the receiving of the packet. ; 3484 ! ; 3485 ! SIDE EFFECTS: ; 3486 ! ; 3487 ! None. ; 3488 ! ; 3489 !-- ; 3490 ; 3491 BEGIN ; 3492 ; 3493 BIND ; 3494 ATTEMPT_TEXT = UPLIT (%ASCIZ'Attempting to receive'); ; 3495 ; 3496 LOCAL ; 3497 ! BUFFER : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)], ; 3498 MSG_LENGTH, ; 3499 ERR_POINTER, ! Pointer to the error buffer ; 3500 POINTER, ; 3501 ! OLD_POINTER, ! Character pointer to the data section ; 3502 ! NEW_POINTER, ; 3503 CHKSUM; ! Checksum of the message ; 3504 ; 3505 ! ; 3506 ! Attempt to read the message from the remote. ; 3507 ! ; 3508 ! DO ; 3509 ! BEGIN ; 3510 ; 3511 IF .DEBUG_FLAG ; 3512 THEN ; 3513 BEGIN ; 3514 ; 3515 LOCAL ; 3516 OLD_RTN; ; 3517 ; 3518 OLD_RTN = TT_SET_OUTPUT (DBG_DUMP); ; 3519 TT_TEXT (ATTEMPT_TEXT); ; 3520 TT_CRLF (); ; 3521 TT_SET_OUTPUT (.OLD_RTN); ; 3522 END; ; 3523 ; 3524 ! ; 3525 ! Receive the message from the remote Kermit ; 3526 ! ; 3527 STATUS = RECEIVE (REC_MSG, MSG_LENGTH); ; 3528 ! ; 3529 ! If it failed return the status to the upper level ; 3530 ! ; 3531 ; 3532 IF NOT .STATUS THEN RETURN .STATUS; ; 3533 ; 3534 ! ; 3535 ! Determine if we got a good message ; 3536 ! ; 3537 ; 3538 IF .MSG_LENGTH EQL 0 ; 3539 THEN ; 3540 BEGIN ; 3541 RETURN KER_ZEROLENMSG; ; 3542 END; ; 3543 ; 3544 ! ; 3545 ! Update the stats on the total number of characters received. ; 3546 ! ; 3547 RMSG_TOTAL_CHARS = .RMSG_TOTAL_CHARS + .MSG_LENGTH; ; 3548 ! ; 3549 ! Now find the message in the information we just received. ; 3550 ! (could have fillers supplied by remote Kermit or remote system. ; 3551 ! just discard them and look for the Ctl-A) ; 3552 ! ; 3553 ! OLD_POINTER = CH$PTR (BUFFER, 0, CHR_SIZE); ; 3554 ! NEW_POINTER = CH$FIND_CH (.MSG_LENGTH, .OLD_POINTER, .RCV_SOH); ; 3555 ! ; 3556 ! WHILE TRUE DO ; 3557 ! ; 3558 ! IF CH$FAIL (.NEW_POINTER) EQL 0 ; 3559 ! THEN ; 3560 ! BEGIN ; 3561 ! MSG_LENGTH = .MSG_LENGTH - CH$DIFF (.NEW_POINTER, .OLD_POINTER); ; 3562 ! ; 3563 ! IF .MSG_LENGTH EQL 0 THEN EXITLOOP; ; 3564 ! ; 3565 ! OLD_POINTER = .NEW_POINTER; ; 3566 ! NEW_POINTER = CH$FIND_CH (.MSG_LENGTH, CH$PLUS (.OLD_POINTER, 1), .RCV_SOH); ; 3567 ! END ; 3568 ! ELSE ; 3569 ! EXITLOOP; ; 3570 ! ; 3571 ! END ; 3572 ! UNTIL .MSG_LENGTH NEQ 0; ; 3573 ! ; 3574 ! IF .MSG_LENGTH EQL 0 THEN RETURN KER_ZEROLENMSG; ; 3575 ! ; 3576 ! CH$MOVE (.MSG_LENGTH, .OLD_POINTER, CH$PTR (REC_MSG, 0, CHR_SIZE)); ; 3577 ! ; 3578 ! Initialize the checksum and others ; 3579 ! ; 3580 REC_TYPE = CH$RCHAR (CH$PTR (REC_MSG, PKT_TYPE, CHR_SIZE)); ; 3581 CHKSUM = CH$RCHAR (CH$PTR (REC_MSG, PKT_COUNT, CHR_SIZE)) + CH$RCHAR (CH$PTR (REC_MSG, PKT_SEQ, ; 3582 CHR_SIZE)) + .REC_TYPE; ; 3583 ! ; 3584 ! Now break the message apart byte by byte. ; 3585 ! ; 3586 REC_LENGTH = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_COUNT, CHR_SIZE))) - PKT_OVR_HEAD - ( ; 3587 .BLK_CHK_TYPE - CHK_1CHAR); ; 3588 REC_SEQ = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_SEQ, CHR_SIZE))); ; 3589 ! ; 3590 ! Typed the packet if we are debugging ; 3591 ! ; 3592 DBG_RECEIVE (REC_MSG); ; 3593 ! ; 3594 ! Now compute the final checksum and make sure that it is identical ; 3595 ! to what we received from the remote KERMIT ; 3596 ! ; 3597 POINTER = CH$PTR (REC_MSG, PKT_MARK + 1, CHR_SIZE); ; 3598 CHKSUM = CALC_BLOCK_CHECK (.POINTER, .REC_LENGTH + PKT_OVR_HEAD); ; 3599 POINTER = CH$PTR (REC_MSG, .REC_LENGTH + PKT_OVR_HEAD + 1, CHR_SIZE); ; 3600 ; 3601 CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF ; 3602 SET ; 3603 ; 3604 [CHK_1CHAR] : ; 3605 ; 3606 IF .CHKSUM NEQ UNCHAR (CH$RCHAR_A (POINTER)) THEN RETURN KER_CHKSUMERR; ; 3607 ; 3608 [CHK_2CHAR] : ; 3609 ; P 3610 IF (.CHKSUM<6, 6> NEQ UNCHAR (CH$RCHAR_A (POINTER))) OR (.CHKSUM<0, 6> NEQ UNCHAR ( ; 3611 CH$RCHAR_A (POINTER))) ; 3612 THEN ; 3613 RETURN KER_CHKSUMERR; ; 3614 ; 3615 [CHK_CRC] : ; 3616 ; P 3617 IF (.CHKSUM<12, 4> NEQ UNCHAR (CH$RCHAR_A (POINTER))) OR (.CHKSUM<6, 6> NEQ UNCHAR ( ; 3618 CH$RCHAR_A (POINTER))) OR (.CHKSUM<0, 6> NEQ UNCHAR (CH$RCHAR_A (POINTER))) ; 3619 THEN ; 3620 RETURN KER_CHKSUMERR; ; 3621 ; 3622 TES; ; 3623 ; 3624 ! ; 3625 ! Update the stats ; 3626 ! ; 3627 RMSG_DATA_CHARS = .RMSG_DATA_CHARS + .REC_LENGTH; ; 3628 ; 3629 IF .REC_TYPE EQL MSG_NAK ; 3630 THEN ; 3631 BEGIN ; 3632 RMSG_NAKS = .RMSG_NAKS + 1; ; 3633 XFR_STATUS (%C'R', %C'N'); ; 3634 END ; 3635 ELSE ; 3636 BEGIN ; 3637 RCV_COUNT = .RCV_COUNT + 1; ; 3638 XFR_STATUS (%C'R', %C'P'); ; 3639 END; ; 3640 ; 3641 ! ; 3642 ! Now check to see if we have an E type (Error) packet. ; 3643 ! ; 3644 ; 3645 IF .REC_TYPE NEQ MSG_ERROR THEN RETURN KER_NORMAL; ; 3646 ; 3647 ! ; 3648 ! Here to process an error packet. Call the user routine to output the ; 3649 ! error message to the terminal. ; 3650 ! ; 3651 ERR_POINTER = CH$PTR (LAST_ERROR); ; 3652 POINTER = CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE); ; 3653 ; 3654 INCR I FROM 1 TO .REC_LENGTH DO ; 3655 CH$WCHAR_A (CH$RCHAR_A (POINTER), ERR_POINTER); ; 3656 ; 3657 CH$WCHAR (CHR_NUL, ERR_POINTER); ; 3658 TT_TEXT (LAST_ERROR); ; 3659 TT_CRLF (); ; 3660 RETURN KER_ERRMSG; ; 3661 END; ! End of REC_PACKET .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAK: .ASCII \Attempting to receive\<0><0><0> ; ; U.115= P.AAK .PSECT $CODE$,NOWRT,2 ;REC_PACKET U.23: .WORD ^M ;Save R2,R3,R4,R5 ; 3451 MOVAB W^LAST_ERROR, R5 ;LAST_ERROR, R5 ; MOVAB W^U.104, R4 ;U.104, R4 ; SUBL2 #4, SP ;#4, SP ; BLBC 268(R5), 1$ ;DEBUG_FLAG, 1$ ; 3511 PUSHAB W^DBG_DUMP ;DBG_DUMP ; 3518 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; MOVL R0, R2 ;R0, OLD_RTN ; PUSHAB W^U.115 ;U.115 ; 3519 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 3520 PUSHL R2 ;OLD_RTN ; 3521 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; 1$: PUSHL SP ;SP ; 3527 PUSHAB 8(R4) ;REC_MSG ; CALLS #2, W^RECEIVE ;#2, RECEIVE ; MOVL R0, -28(R4) ;R0, STATUS ; BLBS -28(R4), 2$ ;STATUS, 2$ ; 3532 MOVL -28(R4), R0 ;STATUS, R0 ; RET ; ; 2$: TSTL (SP) ;MSG_LENGTH ; 3538 BNEQ 3$ ;3$ ; MOVL #134316218, R0 ;#134316218, R0 ; 3540 RET ; ; 3$: ADDL2 (SP), -28(R5) ;MSG_LENGTH, RMSG_TOTAL_CHARS ; 3547 MOVZBL 11(R4), 4(R4) ;REC_MSG+3, REC_TYPE ; 3580 MOVZBL 9(R4), R0 ;REC_MSG+1, R0 ; 3581 MOVZBL 10(R4), R1 ;REC_MSG+2, R1 ; ADDL2 R1, R0 ;R1, R0 ; ADDL3 4(R4), R0, R2 ;REC_TYPE, R0, CHKSUM ; 3582 MOVZBL 9(R4), R0 ;REC_MSG+1, R0 ; 3586 SUBL2 -40(R4), R0 ;BLK_CHK_TYPE, R0 ; MOVAB 14(R0), (R4) ;14(R0), REC_LENGTH ; MOVZBL 10(R4), -4(R4) ;REC_MSG+2, REC_SEQ ; 3588 SUBL2 #32, -4(R4) ;#32, REC_SEQ ; PUSHAB 8(R4) ;REC_MSG ; 3592 CALLS #1, W^U.30 ;#1, U.30 ; MOVAB 9(R4), R3 ;REC_MSG+1, POINTER ; 3597 ADDL3 #3, (R4), -(SP) ;#3, REC_LENGTH, -(SP) ; 3598 PUSHL R3 ;POINTER ; CALLS #2, W^U.16 ;#2, U.16 ; MOVL R0, R2 ;R0, CHKSUM ; MOVAB 8(R4), R0 ;REC_MSG, R0 ; 3599 ADDL2 (R4), R0 ;REC_LENGTH, R0 ; MOVAB 4(R0), R3 ;4(R0), POINTER ; CASEL -40(R4), #49, #2 ;BLK_CHK_TYPE, #49, #2 ; 3601 4$: .WORD 5$-4$,- ;5$-4$,- ; 7$-4$,- ;7$-4$,- ; 6$-4$ ;6$-4$ ; 5$: MOVZBL (R3)+, R0 ;(POINTER)+, R0 ; 3606 SUBL2 #32, R0 ;#32, R0 ; CMPL R2, R0 ;CHKSUM, R0 ; BRB 8$ ;8$ ; 6$: MOVZBL (R3)+, R0 ;(POINTER)+, R0 ; 3617 SUBL2 #32, R0 ;#32, R0 ; CMPZV #12, #4, R2, R0 ;#12, #4, CHKSUM, R0 ; BNEQ 9$ ;9$ ; 7$: MOVZBL (R3)+, R0 ;(POINTER)+, R0 ; 3618 SUBL2 #32, R0 ;#32, R0 ; CMPZV #6, #6, R2, R0 ;#6, #6, CHKSUM, R0 ; 3617 BNEQ 9$ ;9$ ; MOVZBL (R3)+, R0 ;(POINTER)+, R0 ; 3618 SUBL2 #32, R0 ;#32, R0 ; CMPZV #0, #6, R2, R0 ;#0, #6, CHKSUM, R0 ; 8$: BEQL 10$ ;10$ ; 9$: MOVL #134316162, R0 ;#134316162, R0 ; 3620 RET ; ; 10$: ADDL2 (R4), -20(R5) ;REC_LENGTH, RMSG_DATA_CHARS ; 3627 CMPL 4(R4), #78 ;REC_TYPE, #78 ; 3629 BNEQ 11$ ;11$ ; INCL -12(R5) ;RMSG_NAKS ; 3632 MOVZBL #78, -(SP) ;#78, -(SP) ; 3633 BRB 12$ ;12$ ; 11$: INCL -36(R5) ;RCV_COUNT ; 3637 MOVZBL #80, -(SP) ;#80, -(SP) ; 3638 12$: MOVZBL #82, -(SP) ;#82, -(SP) ; CALLS #2, W^XFR_STATUS ;#2, XFR_STATUS ; CMPL 4(R4), #69 ;REC_TYPE, #69 ; 3645 BEQL 13$ ;13$ ; MOVL #134316043, R0 ;#134316043, R0 ; RET ; ; 13$: MOVAB (R5), R0 ;LAST_ERROR, ERR_POINTER ; 3651 MOVAB 12(R4), R3 ;REC_MSG+4, POINTER ; 3652 CLRL R1 ;I ; 3654 BRB 15$ ;15$ ; 14$: MOVB (R3)+, (R0)+ ;(POINTER)+, (ERR_POINTER)+ ; 3655 15$: AOBLEQ (R4), R1, 14$ ;REC_LENGTH, I, 14$ ; 3654 CLRB R0 ;ERR_POINTER ; 3657 PUSHL R5 ;R5 ; 3658 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 3659 MOVL #134316154, R0 ;#134316154, R0 ; 3491 RET ; ; 3451 ; Routine Size: 337 bytes, Routine Base: $CODE$ + 0EF1 ; 3662 %SBTTL 'CALC_BLOCK_CHECK' ; 3663 ROUTINE CALC_BLOCK_CHECK (POINTER, LENGTH) = ; 3664 ; 3665 !++ ; 3666 ! FUNCTIONAL DESCRIPTION: ; 3667 ! ; 3668 ! This routine will calculate the proper value for the block check ; 3669 ! for a given message. The value it returns is dependant upon the ; 3670 ! type of block check requested in BLK_CHK_TYPE. ; 3671 ! ; 3672 ! CALLING SEQUENCE: ; 3673 ! ; 3674 ! CHKSUM = CALC_BLOCK_CHECK (.POINTER, .LENGTH); ; 3675 ! ; 3676 ! INPUT PARAMETERS: ; 3677 ! ; 3678 ! POINTER - A character pointer to the first character to be ; 3679 ! included in the block check. ; 3680 ! ; 3681 ! LENGTH - The number of characters to be included. ; 3682 ! ; 3683 ! IMPLICIT INPUTS: ; 3684 ! ; 3685 ! BLK_CHK_TYPE - The type of block check to generate. ; 3686 ! ; 3687 ! OUPTUT PARAMETERS: ; 3688 ! ; 3689 ! The value is the block check. ; 3690 ! ; 3691 ! IMPLICIT OUTPUTS: ; 3692 ! ; 3693 ! None. ; 3694 ! ; 3695 ! COMPLETION CODES: ; 3696 ! ; 3697 ! None. ; 3698 ! ; 3699 ! SIDE EFFECTS: ; 3700 ! ; 3701 ! None. ; 3702 ! ; 3703 !-- ; 3704 ; 3705 BEGIN ; 3706 ; 3707 LOCAL ; 3708 BLOCK_CHECK, ! To build initial block check value ; 3709 I; ! Loop counter ; 3710 ; 3711 BLOCK_CHECK = 0; ! Start out at 0 ; 3712 ; 3713 CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF ; 3714 SET ; 3715 ; 3716 [CHK_1CHAR, CHK_2CHAR] : ; 3717 ; 3718 INCR I FROM 1 TO .LENGTH DO ; 3719 BLOCK_CHECK = .BLOCK_CHECK + CH$RCHAR_A (POINTER); ; 3720 ; 3721 [CHK_CRC] : ; 3722 BLOCK_CHECK = CRCCLC (.POINTER, .LENGTH); ; 3723 TES; ; 3724 ; 3725 IF .BLK_CHK_TYPE EQL CHK_1CHAR ; 3726 THEN ; 3727 BLOCK_CHECK = (.BLOCK_CHECK + ((.BLOCK_CHECK AND %O'300')/%O'100')) AND %O'77'; ; 3728 ; 3729 RETURN .BLOCK_CHECK; ! Return the correct value ; 3730 END; ! End of CALC_BLOCK_CHK ;CALC_BLOCK_CHECK U.16: .WORD ^M ;Save R2 ; 3663 CLRL R1 ;BLOCK_CHECK ; 3711 CASEL W^U.94, #49, #2 ;U.94, #49, #2 ; 3713 1$: .WORD 2$-1$,- ;2$-1$,- ; 2$-1$,- ;2$-1$,- ; 5$-1$ ;5$-1$ ; 2$: CLRL R0 ;I ; 3718 BRB 4$ ;4$ ; 3$: MOVZBL @4(AP), R2 ;@POINTER, R2 ; 3719 INCL 4(AP) ;POINTER ; ADDL2 R2, R1 ;R2, BLOCK_CHECK ; 4$: AOBLEQ 8(AP), R0, 3$ ;LENGTH, I, 3$ ; 3718 BRB 6$ ;6$ ; 3713 5$: MOVQ 4(AP), -(SP) ;POINTER, -(SP) ; 3722 CALLS #2, W^CRCCLC ;#2, CRCCLC ; MOVL R0, R1 ;R0, BLOCK_CHECK ; 6$: CMPL W^U.94, #49 ;U.94, #49 ; 3725 BNEQ 7$ ;7$ ; BICL3 #-193, R1, R0 ;#-193, BLOCK_CHECK, R0 ; 3727 DIVL2 #64, R0 ;#64, R0 ; ADDL2 R1, R0 ;BLOCK_CHECK, R0 ; EXTZV #0, #6, R0, R1 ;#0, #6, R0, BLOCK_CHECK ; 7$: MOVL R1, R0 ;BLOCK_CHECK, R0 ; 3705 RET ; ; 3663 ; Routine Size: 83 bytes, Routine Base: $CODE$ + 1042 ; 3731 %SBTTL 'Buffer filling -- Main routine' ; 3732 ROUTINE BFR_FILL (FIRST_FLAG) = ; 3733 ; 3734 !++ ; 3735 ! FUNCTIONAL DESCRIPTION: ; 3736 ! ; 3737 ! This routine will fill the buffer with data from the file. It ; 3738 ! will do all the quoting that is required. ; 3739 ! ; 3740 ! CALLING SEQUENCE: ; 3741 ! ; 3742 ! EOF_FLAG = BFR_FILL(.FIRST_FLAG); ; 3743 ! ; 3744 ! INPUT PARAMETERS: ; 3745 ! ; 3746 ! FIRST_FLAG - Flag whether first call for this file ; 3747 ! ; 3748 ! IMPLICIT INPUTS: ; 3749 ! ; 3750 ! None. ; 3751 ! ; 3752 ! OUTPUT PARAMETERS: ; 3753 ! ; 3754 ! True - Buffer filled may be at end of file. ; 3755 ! False - At end of file. ; 3756 ! ; 3757 ! IMPLICIT OUTPUTS: ; 3758 ! ; 3759 ! Number of characters stored in the buffer. ; 3760 ! ; 3761 ! COMPLETION CODES: ; 3762 ! ; 3763 ! None. ; 3764 ! ; 3765 ! SIDE EFFECTS: ; 3766 ! ; 3767 ! None. ; 3768 ! ; 3769 !-- ; 3770 ; 3771 BEGIN ; 3772 ; 3773 LOCAL ; 3774 I, ! Temp loop index ; 3775 MAX_SIZE, ! Maximum size of data ; 3776 POINTER; ! Pointer into the message buffer ; 3777 ; 3778 OWN ; 3779 NEXT_CHR, ! Saved character ; 3780 STATUS, ! Status value ; 3781 REPEAT_COUNT, ! Number of times character repeated ; 3782 CHAR_8_BIT, ! 8 bit character from file ; 3783 CHRS : VECTOR [5], ! String needed to represent character ; 3784 CHR_IDX, ! Index into CHRS ; 3785 OLD_CHAR_8_BIT, ! Previous 8-bit character ; 3786 OLD_CHRS : VECTOR [5], ! String for previous character ; 3787 OLD_CHR_IDX; ! Index for previous character ; 3788 ; 3789 ROUTINE GET_QUOTED_CHAR = ; 3790 ! ; 3791 ! This routine gets a character from the file and returns both ; 3792 ! the character and the string needed to represent the character ; 3793 ! if it needs quoting. ; 3794 ! ; 3795 BEGIN ; 3796 IF .NEXT_CHR GEQ 0 ; 3797 THEN ; 3798 BEGIN ; 3799 CHAR_8_BIT = .NEXT_CHR; ; 3800 NEXT_CHR = -1; ; 3801 STATUS = KER_NORMAL; ; 3802 END ; 3803 ELSE ; 3804 STATUS = GET_FILE (CHAR_8_BIT); ; 3805 IF .STATUS EQL KER_NORMAL ; 3806 THEN ; 3807 BEGIN ; 3808 ! ; 3809 ! Determine if we should just quote the character ; 3810 ! Either: ; 3811 ! Character is a delete (177 octal) ; 3812 ! or Character is a control character (less than 40 octal) ; 3813 ! or Character is a quote character ; 3814 ! or Character is the repeat character and doing repeat compression ; 3815 ! or Character is an eight bit quote character and doing eight bit ; 3816 ! quoting. ; 3817 ! ; 3818 ; 3819 IF ((.CHAR_8_BIT AND %O'177') LSS %C' ') OR ((.CHAR_8_BIT AND %O'177') EQL CHR_DEL) OR ( ; 3820 (.CHAR_8_BIT AND %O'177') EQL .SEND_QUOTE_CHR) OR (.FLAG_REPEAT AND ((.CHAR_8_BIT ; 3821 AND %O'177') EQL .REPT_CHR)) OR (.FLAG_8QUOTE AND ((.CHAR_8_BIT AND %O'177') EQL ; 3822 .SEND_8QUOTE_CHR)) ; 3823 THEN ; 3824 BEGIN ; 3825 ! ; 3826 ! If the character is a control character or delete we must do a CTL(Character) ; 3827 ! so it is something that we can be sure we can send. ; 3828 ! ; 3829 ; 3830 IF ((.CHAR_8_BIT AND %O'177') LSS %C' ') OR ((.CHAR_8_BIT AND %O'177') EQL CHR_DEL) ; 3831 THEN ; 3832 CHRS [0] = CTL (.CHAR_8_BIT) ; 3833 ELSE ; 3834 CHRS [0] = .CHAR_8_BIT; ; 3835 ; 3836 CHR_IDX = 1; ; 3837 CHRS [1] = .SEND_QUOTE_CHR; ; 3838 END ; 3839 ELSE ; 3840 BEGIN ; 3841 CHR_IDX = 0; ; 3842 CHRS [0] = .CHAR_8_BIT; ; 3843 END; ; 3844 ; 3845 END; ; 3846 ; 3847 RETURN .STATUS; ; 3848 END; .PSECT $OWN$,NOEXE,2 ;NEXT_CHR U.116: .BLKB 4 ;STATUS U.117: .BLKB 4 ;REPEAT_COUNT U.118: .BLKB 4 ;CHAR_8_BIT U.119: .BLKB 4 ;CHRS U.120: .BLKB 20 ;CHR_IDX U.121: .BLKB 4 ;OLD_CHAR_8_BIT U.122: .BLKB 4 ;OLD_CHRS U.123: .BLKB 20 ;OLD_CHR_IDX U.124: .BLKB 4 .PSECT $CODE$,NOWRT,2 ;GET_QUOTED_CHAR U.125: .WORD ^M ;Save R2 ; 3789 MOVAB W^U.117, R2 ;U.117, R2 ; MOVL -4(R2), R0 ;NEXT_CHR, R0 ; 3796 BLSS 1$ ;1$ ; MOVL R0, 8(R2) ;R0, CHAR_8_BIT ; 3799 MNEGL #1, -4(R2) ;#1, NEXT_CHR ; 3800 MOVL #134316043, (R2) ;#134316043, STATUS ; 3801 BRB 2$ ;2$ ; 3796 1$: PUSHAB 8(R2) ;CHAR_8_BIT ; 3804 CALLS #1, W^GET_FILE ;#1, GET_FILE ; MOVL R0, (R2) ;R0, STATUS ; 2$: CMPL (R2), #134316043 ;STATUS, #134316043 ; 3805 BNEQ 10$ ;10$ ; MOVL 8(R2), R0 ;CHAR_8_BIT, R0 ; 3819 CLRL R1 ;R1 ; CMPZV #0, #7, R0, #32 ;#0, #7, R0, #32 ; BGEQ 3$ ;3$ ; INCL R1 ;R1 ; BRB 5$ ;5$ ; 3$: CMPZV #0, #7, R0, #127 ;#0, #7, R0, #127 ; BEQL 5$ ;5$ ; CMPZV #0, #7, R0, -260(R2) ;#0, #7, R0, SEND_QUOTE_CHR ; BEQL 5$ ;5$ ; BLBC -240(R2), 4$ ;FLAG_REPEAT, 4$ ; 3820 CMPZV #0, #7, R0, -284(R2) ;#0, #7, R0, REPT_CHR ; BEQL 5$ ;5$ ; 4$: BLBC -244(R2), 9$ ;FLAG_8QUOTE, 9$ ; 3821 CMPZV #0, #7, R0, -256(R2) ;#0, #7, R0, SEND_8QUOTE_CHR ; BNEQ 9$ ;9$ ; 5$: BLBS R1, 6$ ;R1, 6$ ; 3830 CMPZV #0, #7, R0, #127 ;#0, #7, R0, #127 ; BNEQ 7$ ;7$ ; 6$: XORL3 #64, R0, 12(R2) ;#64, R0, CHRS ; 3832 BRB 8$ ;8$ ; 3830 7$: MOVL R0, 12(R2) ;R0, CHRS ; 3834 8$: MOVL #1, 32(R2) ;#1, CHR_IDX ; 3836 MOVL -260(R2), 16(R2) ;SEND_QUOTE_CHR, CHRS+4 ; 3837 BRB 10$ ;10$ ; 3819 9$: CLRL 32(R2) ;CHR_IDX ; 3841 MOVL R0, 12(R2) ;R0, CHRS ; 3842 10$: MOVL (R2), R0 ;STATUS, R0 ; 3795 RET ; ; 3789 ; Routine Size: 167 bytes, Routine Base: $CODE$ + 1095 ; 3849 ROUTINE GET_8_QUOTED_CHAR = ; 3850 ! ; 3851 ! This routine will get the quoted representation of a character ; 3852 ! (by calling GET_QUOTED_CHAR), and return the 8th-bit quoted ; 3853 ! representation. ; 3854 ! ; 3855 BEGIN ; 3856 ; 3857 IF (STATUS = GET_QUOTED_CHAR ()) EQL KER_NORMAL ; 3858 THEN ; 3859 BEGIN ; 3860 ! ; 3861 ! Determine if we must quote the eighth bit (parity bit on) ; 3862 ! ; 3863 ; 3864 IF (((.CHRS [0] AND %O'177') NEQ .CHRS [0]) AND .FLAG_8QUOTE) ; 3865 THEN ; 3866 BEGIN ; 3867 CHRS [0] = .CHRS [0] AND %O'177'; ; 3868 CHR_IDX = .CHR_IDX + 1; ; 3869 CHRS [.CHR_IDX] = .SEND_8QUOTE_CHR; ; 3870 END; ; 3871 ; 3872 END; ; 3873 ; 3874 RETURN .STATUS; ; 3875 END; ;GET_8_QUOTED_CHAR U.126: .WORD ^M ;Save R2 ; 3849 MOVAB W^U.120, R2 ;U.120, R2 ; CALLS #0, W^U.125 ;#0, U.125 ; 3857 MOVL R0, -12(R2) ;R0, STATUS ; CMPL R0, #134316043 ;R0, #134316043 ; BNEQ 1$ ;1$ ; CMPZV #0, #7, (R2), (R2) ;#0, #7, CHRS, CHRS ; 3864 BEQL 1$ ;1$ ; BLBC -256(R2), 1$ ;FLAG_8QUOTE, 1$ ; EXTZV #0, #7, (R2), (R2) ;#0, #7, CHRS, CHRS ; 3867 INCL 20(R2) ;CHR_IDX ; 3868 MOVL 20(R2), R0 ;CHR_IDX, R0 ; 3869 MOVL -268(R2), (R2)[R0] ;SEND_8QUOTE_CHR, CHRS[R0] ; 1$: MOVL -12(R2), R0 ;STATUS, R0 ; 3855 RET ; ; 3849 ; Routine Size: 60 bytes, Routine Base: $CODE$ + 113C ; 3876 ! ; 3877 ! Start of code for BFR_FILL ; 3878 ! ; 3879 ! Initialize pointer and count ; 3880 ! ; 3881 SIZE = 0; ; 3882 POINTER = CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE); ; 3883 MAX_SIZE = .SEND_PKT_SIZE - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR); ; 3884 ; 3885 ! ; 3886 ! If last call got an error or eof, return it now ; 3887 ! ; 3888 ; 3889 IF NOT .FIRST_FLAG AND (.STATUS NEQ KER_NORMAL) THEN RETURN .STATUS; ; 3890 ; 3891 ! ; 3892 ! If first time for a file prime the pump with the first character. ; 3893 ! ; 3894 ; 3895 IF .FIRST_FLAG ; 3896 THEN ; 3897 BEGIN ; 3898 FIRST_FLAG = FALSE; ; 3899 NEXT_CHR = -1; ! No backed up character ; 3900 ; 3901 IF .FLAG_8QUOTE THEN STATUS = GET_8_QUOTED_CHAR () ELSE STATUS = GET_QUOTED_CHAR (); ; 3902 ; 3903 OLD_CHAR_8_BIT = .CHAR_8_BIT; ; 3904 ; 3905 INCR OLD_CHR_IDX FROM 0 TO .CHR_IDX DO ; 3906 OLD_CHRS [.OLD_CHR_IDX] = .CHRS [.OLD_CHR_IDX]; ; 3907 ; 3908 OLD_CHR_IDX = .CHR_IDX; ; 3909 REPEAT_COUNT = 0; ! Character was not repeated yet ; 3910 ! Will always be incremented ; 3911 END; ; 3912 ; 3913 ! ; 3914 ! Otherwise, loop until we fill buffer ; 3915 ! ; 3916 ; 3917 WHILE .SIZE LSS .MAX_SIZE DO ! Normal exit is via an EXITLOOP ; 3918 BEGIN ; 3919 ! ; 3920 ! Check if we are doing run compression ; 3921 ! ; 3922 ; 3923 IF .FLAG_REPEAT ; 3924 THEN ; 3925 BEGIN ; 3926 ! ; 3927 ! Here with previous character in OLD_xxx. As long as we ; 3928 ! are getting the same character, just count the run. ; 3929 ! ; 3930 ; 3931 WHILE (.CHAR_8_BIT EQL .OLD_CHAR_8_BIT) AND (.REPEAT_COUNT LSS 94) DO ; 3932 BEGIN ; 3933 REPEAT_COUNT = .REPEAT_COUNT + 1; ; 3934 ; 3935 IF .FLAG_8QUOTE THEN STATUS = GET_8_QUOTED_CHAR () ELSE STATUS = GET_QUOTED_CHAR (); ; 3936 ; 3937 IF (.STATUS NEQ KER_NORMAL) THEN CHAR_8_BIT = -1; ; 3938 ; 3939 END; ; 3940 ; 3941 IF .OLD_CHR_IDX + 1 + 2 LSS ((.OLD_CHR_IDX + 1)*.REPEAT_COUNT) ; 3942 THEN ; 3943 BEGIN ; 3944 IF .SIZE + .OLD_CHR_IDX + 1 + 2 GTR .MAX_SIZE ; 3945 THEN ; 3946 BEGIN ; 3947 IF .CHAR_8_BIT EQL .OLD_CHAR_8_BIT ; 3948 THEN ; 3949 BEGIN ; 3950 NEXT_CHR = .CHAR_8_BIT; ; 3951 REPEAT_COUNT = .REPEAT_COUNT - 1; ; 3952 END; ; 3953 EXITLOOP; ; 3954 END; ; 3955 OLD_CHRS [.OLD_CHR_IDX + 1] = CHAR (.REPEAT_COUNT); ; 3956 OLD_CHRS [.OLD_CHR_IDX + 2] = .REPT_CHR; ; 3957 OLD_CHR_IDX = .OLD_CHR_IDX + 2; ; 3958 REPEAT_COUNT = 1; ! Only one time for this string ; 3959 END; ; 3960 ; 3961 ! ; 3962 ! If we don't have enough room for this character, wait till next ; 3963 ! time. ; 3964 ! ; 3965 ; 3966 IF .SIZE + (.OLD_CHR_IDX + 1)*.REPEAT_COUNT GTR .MAX_SIZE ; 3967 THEN ; 3968 BEGIN ; 3969 ! If the next character is the same, the count will get incremented ; 3970 ! next time we enter, so back it off now. ; 3971 ; 3972 IF .CHAR_8_BIT EQL .OLD_CHAR_8_BIT ; 3973 THEN ; 3974 BEGIN ; 3975 NEXT_CHR = .CHAR_8_BIT; ; 3976 REPEAT_COUNT = .REPEAT_COUNT - 1; ; 3977 END; ; 3978 EXITLOOP; ; 3979 END; ; 3980 ; 3981 DECR REPEAT_COUNT FROM .REPEAT_COUNT TO 1 DO ; 3982 ; 3983 DECR I FROM .OLD_CHR_IDX TO 0 DO ; 3984 BEGIN ; 3985 CH$WCHAR_A (.OLD_CHRS [.I], POINTER); ; 3986 SIZE = .SIZE + 1; ; 3987 END; ; 3988 ; 3989 ! ; 3990 ! If we got an error (or EOF) then exit ; 3991 ! ; 3992 ; 3993 IF (.STATUS NEQ KER_NORMAL) THEN EXITLOOP; ; 3994 ; 3995 ! ; 3996 ! Otherwise, copy the character which broke the run ; 3997 ! ; 3998 OLD_CHAR_8_BIT = .CHAR_8_BIT; ; 3999 ; 4000 INCR OLD_CHR_IDX FROM 0 TO .CHR_IDX DO ; 4001 OLD_CHRS [.OLD_CHR_IDX] = .CHRS [.OLD_CHR_IDX]; ; 4002 ; 4003 OLD_CHR_IDX = .CHR_IDX; ; 4004 REPEAT_COUNT = 0; ; 4005 END ; 4006 ELSE ; 4007 ! ; 4008 ! Here if we are not doing run compression. We can do things much ; 4009 ! easier. ; 4010 ! ; 4011 BEGIN ; 4012 ; 4013 IF (.SIZE + .CHR_IDX + 1) GTR .MAX_SIZE THEN EXITLOOP; ; 4014 ; 4015 DECR CHR_IDX FROM .CHR_IDX TO 0 DO ; 4016 BEGIN ; 4017 CH$WCHAR_A (.CHRS [.CHR_IDX], POINTER); ; 4018 SIZE = .SIZE + 1; ; 4019 END; ; 4020 ; 4021 IF .FLAG_8QUOTE THEN STATUS = GET_8_QUOTED_CHAR () ELSE STATUS = GET_QUOTED_CHAR (); ; 4022 ; 4023 IF (.STATUS NEQ KER_NORMAL) THEN EXITLOOP; ; 4024 ; 4025 END; ; 4026 ; 4027 END; ; 4028 ; 4029 ! ; 4030 ! Determine if we really stored anything into the buffer. ; 4031 ! ; 4032 ; 4033 IF .SIZE NEQ 0 THEN RETURN KER_NORMAL ELSE RETURN .STATUS; ; 4034 ; 4035 END; ! End of BFR_FILL ;BFR_FILL U.25: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 ; 3732 MOVAB B^U.126, R7 ;U.126, R7 ; MOVAB W^U.118, R6 ;U.118, R6 ; CLRL -232(R6) ;SIZE ; 3881 MOVAB -104(R6), R4 ;SND_MSG+4, POINTER ; 3882 SUBL3 -252(R6), -284(R6), R0 ;BLK_CHK_TYPE, SEND_PKT_SIZE, R0 ; 3883 MOVAB 46(R0), R5 ;46(R0), MAX_SIZE ; BLBS 4(AP), 2$ ;FIRST_FLAG, 2$ ; 3889 CMPL -4(R6), #134316043 ;STATUS, #134316043 ; BEQL 1$ ;1$ ; BRW 30$ ;30$ ; 1$: BLBC 4(AP), 8$ ;FIRST_FLAG, 8$ ; 3895 2$: CLRL 4(AP) ;FIRST_FLAG ; 3898 MNEGL #1, -8(R6) ;#1, NEXT_CHR ; 3899 BLBC -248(R6), 3$ ;FLAG_8QUOTE, 3$ ; 3901 CALLS #0, (R7) ;#0, GET_8_QUOTED_CHAR ; BRB 4$ ;4$ ; 3$: CALLS #0, -167(R7) ;#0, GET_QUOTED_CHAR ; 4$: MOVL R0, -4(R6) ;R0, STATUS ; MOVL 4(R6), 32(R6) ;CHAR_8_BIT, OLD_CHAR_8_BIT ; 3903 MNEGL #1, R0 ;#1, OLD_CHR_IDX ; 3905 BRB 6$ ;6$ ; 5$: MOVL 8(R6)[R0], 36(R6)[R0] ;CHRS[OLD_CHR_IDX], OLD_CHRS[OLD_CHR_IDX] ; 3906 6$: AOBLEQ 28(R6), R0, 5$ ;CHR_IDX, OLD_CHR_IDX, 5$ ; 3905 7$: MOVL 28(R6), 56(R6) ;CHR_IDX, OLD_CHR_IDX ; 3908 CLRL (R6) ;REPEAT_COUNT ; 3909 8$: CMPL -232(R6), R5 ;SIZE, MAX_SIZE ; 3917 BLSS 9$ ;9$ ; BRW 29$ ;29$ ; 9$: BLBS -244(R6), 10$ ;FLAG_REPEAT, 10$ ; 3923 BRW 24$ ;24$ ; 10$: CMPL 4(R6), 32(R6) ;CHAR_8_BIT, OLD_CHAR_8_BIT ; 3931 BNEQ 13$ ;13$ ; CMPL (R6), #94 ;REPEAT_COUNT, #94 ; BGEQ 13$ ;13$ ; INCL (R6) ;REPEAT_COUNT ; 3933 BLBC -248(R6), 11$ ;FLAG_8QUOTE, 11$ ; 3935 CALLS #0, (R7) ;#0, GET_8_QUOTED_CHAR ; BRB 12$ ;12$ ; 11$: CALLS #0, -167(R7) ;#0, GET_QUOTED_CHAR ; 12$: MOVL R0, -4(R6) ;R0, STATUS ; CMPL -4(R6), #134316043 ;STATUS, #134316043 ; 3937 BEQL 10$ ;10$ ; MNEGL #1, 4(R6) ;#1, CHAR_8_BIT ; BRB 10$ ;10$ ; 3931 13$: MOVL 56(R6), R1 ;OLD_CHR_IDX, R1 ; 3941 MOVAB 3(R1), R3 ;3(R1), R3 ; MOVAB 1(R1), R0 ;1(R1), R0 ; MULL3 (R6), R0, R2 ;REPEAT_COUNT, R0, R2 ; CMPL R3, R2 ;R3, R2 ; BGEQ 14$ ;14$ ; ADDL3 -232(R6), R1, R2 ;SIZE, R1, R2 ; 3944 ADDL2 #3, R2 ;#3, R2 ; CMPL R2, R5 ;R2, MAX_SIZE ; BGTR 15$ ;15$ ; ADDL3 #32, (R6), 36(R6)[R0] ;#32, REPEAT_COUNT, OLD_CHRS[R0] ; 3955 MOVL -288(R6), 44(R6)[R1] ;REPT_CHR, OLD_CHRS+8[R1] ; 3956 ADDL2 #2, 56(R6) ;#2, OLD_CHR_IDX ; 3957 MOVL #1, (R6) ;#1, REPEAT_COUNT ; 3958 14$: ADDL3 #1, 56(R6), R0 ;#1, OLD_CHR_IDX, R0 ; 3966 MULL2 (R6), R0 ;REPEAT_COUNT, R0 ; ADDL2 -232(R6), R0 ;SIZE, R0 ; CMPL R0, R5 ;R0, MAX_SIZE ; BLEQ 17$ ;17$ ; 15$: CMPL 4(R6), 32(R6) ;CHAR_8_BIT, OLD_CHAR_8_BIT ; 3972 BNEQ 16$ ;16$ ; MOVL 4(R6), -8(R6) ;CHAR_8_BIT, NEXT_CHR ; 3975 DECL (R6) ;REPEAT_COUNT ; 3976 16$: BRW 29$ ;29$ ; 3968 17$: ADDL3 #1, (R6), R1 ;#1, REPEAT_COUNT, REPEAT_COUNT ; 3981 BRB 21$ ;21$ ; 18$: ADDL3 #1, 56(R6), R0 ;#1, OLD_CHR_IDX, I ; 3983 BRB 20$ ;20$ ; 19$: CVTLB 36(R6)[R0], (R4)+ ;OLD_CHRS[I], (POINTER)+ ; 3985 INCL -232(R6) ;SIZE ; 3986 20$: SOBGEQ R0, 19$ ;I, 19$ ; 3983 21$: SOBGTR R1, 18$ ;REPEAT_COUNT, 18$ ; 3981 CMPL -4(R6), #134316043 ;STATUS, #134316043 ; 3993 BNEQ 29$ ;29$ ; MOVL 4(R6), 32(R6) ;CHAR_8_BIT, OLD_CHAR_8_BIT ; 3998 MNEGL #1, R0 ;#1, OLD_CHR_IDX ; 4000 BRB 23$ ;23$ ; 22$: MOVL 8(R6)[R0], 36(R6)[R0] ;CHRS[OLD_CHR_IDX], OLD_CHRS[OLD_CHR_IDX] ; 4001 23$: AOBLEQ 28(R6), R0, 22$ ;CHR_IDX, OLD_CHR_IDX, 22$ ; 4000 BRW 7$ ;7$ ; 4003 24$: ADDL3 28(R6), -232(R6), R0 ;CHR_IDX, SIZE, R0 ; 4013 INCL R0 ;R0 ; CMPL R0, R5 ;R0, MAX_SIZE ; BGTR 29$ ;29$ ; ADDL3 #1, 28(R6), R0 ;#1, CHR_IDX, CHR_IDX ; 4015 BRB 26$ ;26$ ; 25$: CVTLB 8(R6)[R0], (R4)+ ;CHRS[CHR_IDX], (POINTER)+ ; 4017 INCL -232(R6) ;SIZE ; 4018 26$: SOBGEQ R0, 25$ ;CHR_IDX, 25$ ; 4015 BLBC -248(R6), 27$ ;FLAG_8QUOTE, 27$ ; 4021 CALLS #0, (R7) ;#0, GET_8_QUOTED_CHAR ; BRB 28$ ;28$ ; 27$: CALLS #0, -167(R7) ;#0, GET_QUOTED_CHAR ; 28$: MOVL R0, -4(R6) ;R0, STATUS ; CMPL -4(R6), #134316043 ;STATUS, #134316043 ; 4023 BNEQ 29$ ;29$ ; BRW 8$ ;8$ ; 29$: TSTL -232(R6) ;SIZE ; 4033 BEQL 30$ ;30$ ; MOVL #134316043, R0 ;#134316043, R0 ; 3771 RET ; ; 30$: MOVL -4(R6), R0 ;STATUS, R0 ; RET ; ; 3732 ; Routine Size: 415 bytes, Routine Base: $CODE$ + 1178 ; 4036 %SBTTL 'Buffer filling -- Add parity routine' ; 4037 ROUTINE DO_PARITY (MESSAGE, LENGTH) : NOVALUE = ; 4038 ; 4039 !++ ; 4040 ! FUNCTIONAL DESCRIPTION: ; 4041 ! ; 4042 ! This routine will add parity for a complete message that is to be ; 4043 ! sent to the remote Kermit. ; 4044 ! ; 4045 ! CALLING SEQUENCE: ; 4046 ! ; 4047 ! DO_PARITY (Message_address, Message_length); ; 4048 ! ; 4049 ! INPUT PARAMETERS: ; 4050 ! ; 4051 ! Message_address - Address of the message to put parity on. ; 4052 ! Message_length - Lengtho of the message. ; 4053 ! ; 4054 ! IMPLICIT INPUTS: ; 4055 ! ; 4056 ! None. ; 4057 ! ; 4058 ! OUTPUT PARAMETERS: ; 4059 ! ; 4060 ! None. ; 4061 ! ; 4062 ! IMPLICIT OUTPUTS: ; 4063 ! ; 4064 ! None. ; 4065 ! ; 4066 ! COMPLETION CODES: ; 4067 ! ; 4068 ! None. ; 4069 ! ; 4070 ! SIDE EFFECTS: ; 4071 ! ; 4072 ! None. ; 4073 ! ; 4074 !-- ; 4075 ; 4076 BEGIN ; 4077 ; 4078 MAP ; 4079 MESSAGE : REF VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)]; ; 4080 ; 4081 LOCAL ; 4082 POINTER; ! Point into the message ; 4083 ; 4084 IF NOT .DEV_PARITY_FLAG ; 4085 THEN ; 4086 BEGIN ; 4087 POINTER = CH$PTR (.MESSAGE,, CHR_SIZE); ; 4088 ; 4089 INCR I FROM 1 TO .LENGTH DO ; 4090 CH$WCHAR_A (GEN_PARITY (CH$RCHAR (.POINTER)), POINTER); ; 4091 ; 4092 END; ; 4093 ; 4094 END; ! End of DO_PARITY ;DO_PARITY U.19: .WORD ^M ;Save R2,R3 ; 4037 BLBS W^DEV_PARITY_FLAG, 3$ ;DEV_PARITY_FLAG, 3$ ; 4084 MOVL 4(AP), R3 ;MESSAGE, POINTER ; 4087 CLRL R2 ;I ; 4089 BRB 2$ ;2$ ; 1$: MOVZBL (R3), -(SP) ;(POINTER), -(SP) ; 4090 CALLS #1, W^U.20 ;#1, U.20 ; MOVB R0, (R3)+ ;R0, (POINTER)+ ; 2$: AOBLEQ 8(AP), R2, 1$ ;LENGTH, I, 1$ ; 4089 3$: RET ; ; 4037 ; Routine Size: 32 bytes, Routine Base: $CODE$ + 1317 ; 4095 %SBTTL 'Buffer filling -- Parity routine' ; 4096 ; 4097 GLOBAL ROUTINE GEN_PARITY (CHARACTER) = ; 4098 ; 4099 !++ ; 4100 ! FUNCTIONAL DESCRIPTION: ; 4101 ! ; 4102 ! This routine will add parity to the character that is supplied. ; 4103 ! ; 4104 ! CALLING SEQUENCE: ; 4105 ! ; 4106 ! CHARACTER = GEN_PARITY(CHARACTER) ; 4107 ! ; 4108 ! INPUT PARAMETERS: ; 4109 ! ; 4110 ! CHARACTER - Produce the parity for this character depending on the ; 4111 ! setting of the SET PARITY switch. ; 4112 ! ; 4113 ! IMPLICIT INPUTS: ; 4114 ! ; 4115 ! None. ; 4116 ! ; 4117 ! OUTPUT PARAMETERS: ; 4118 ! ; 4119 ! None. ; 4120 ! ; 4121 ! IMPLICIT OUTPUTS: ; 4122 ! ; 4123 ! None. ; 4124 ! ; 4125 ! COMPLETION CODES: ; 4126 ! ; 4127 ! None. ; 4128 ! ; 4129 ! SIDE EFFECTS: ; 4130 ! ; 4131 ! None. ; 4132 ! ; 4133 !-- ; 4134 ; 4135 BEGIN ; 4136 ; 4137 LOCAL ; 4138 TEMP_CHAR; ; 4139 ; 4140 IF .IBM_FLAG THEN RETURN .CHARACTER OR %O'200'; ; 4141 ; 4142 CASE .PARITY_TYPE FROM PR_MIN TO PR_MAX OF ; 4143 SET ; 4144 ; 4145 [PR_NONE] : ; 4146 RETURN .CHARACTER; ; 4147 ; 4148 [PR_SPACE] : ; 4149 RETURN .CHARACTER AND %O'177'; ; 4150 ; 4151 [PR_MARK] : ; 4152 RETURN .CHARACTER OR %O'200'; ; 4153 ; 4154 [PR_ODD] : ; 4155 BEGIN ; 4156 TEMP_CHAR = .CHARACTER AND %O'177' OR %O'200'; ; 4157 TEMP_CHAR = .TEMP_CHAR<0, 4> XOR .TEMP_CHAR<4, 4>; ; 4158 TEMP_CHAR = .TEMP_CHAR<0, 2> XOR .TEMP_CHAR<2, 2>; ; 4159 ; 4160 IF .TEMP_CHAR EQL %B'01' OR .TEMP_CHAR EQL %B'10' ; 4161 THEN ; 4162 RETURN .CHARACTER AND %O'177' OR %O'200' ; 4163 ELSE ; 4164 RETURN .CHARACTER AND %O'177'; ; 4165 ; 4166 END; ; 4167 ; 4168 [PR_EVEN] : ; 4169 BEGIN ; 4170 TEMP_CHAR = .CHARACTER AND %O'177'; ; 4171 TEMP_CHAR = .TEMP_CHAR<0, 4> XOR .TEMP_CHAR<4, 4>; ; 4172 TEMP_CHAR = .TEMP_CHAR<0, 2> XOR .TEMP_CHAR<2, 2>; ; 4173 ; 4174 IF .TEMP_CHAR EQL %B'01' OR .TEMP_CHAR EQL %B'10' ; 4175 THEN ; 4176 RETURN .CHARACTER AND %O'177' OR %O'200' ; 4177 ELSE ; 4178 RETURN .CHARACTER AND %O'177'; ; 4179 ; 4180 END; ; 4181 TES; ; 4182 ; 4183 END; ! End of GEN_PARITY U.20: .ENTRY GEN_PARITY, ^M ;GEN_PARITY, Save R2,R3 ; 4097 BLBC W^IBM_FLAG, 1$ ;IBM_FLAG, 1$ ; 4140 BISL3 #128, 4(AP), R0 ;#128, CHARACTER, R0 ; RET ; ; 1$: MOVL 4(AP), R1 ;CHARACTER, R1 ; 4146 CASEL W^PARITY_TYPE, #0, #4 ;PARITY_TYPE, #0, #4 ; 4135 2$: .WORD 3$-2$,- ;3$-2$,- ; 4$-2$,- ;4$-2$,- ; 7$-2$,- ;7$-2$,- ; 5$-2$,- ;5$-2$,- ; 9$-2$ ;9$-2$ ; 3$: MOVL R1, R0 ;R1, R0 ; RET ; ; 4$: BISL3 #128, R1, R0 ;#128, R1, R0 ; 4152 RET ; ; 4135 5$: EXTZV #0, #7, R1, R2 ;#0, #7, R1, R2 ; 4156 INSV #1, #7, #1, R2 ;#1, #7, #1, R2 ; MOVL R2, R0 ;R2, TEMP_CHAR ; EXTZV #0, #4, R0, R3 ;#0, #4, TEMP_CHAR, R3 ; 4157 EXTZV #4, #4, R0, R0 ;#4, #4, TEMP_CHAR, TEMP_CHAR ; XORL2 R3, R0 ;R3, TEMP_CHAR ; EXTZV #0, #2, R0, R3 ;#0, #2, TEMP_CHAR, R3 ; 4158 EXTZV #2, #2, R0, R0 ;#2, #2, TEMP_CHAR, TEMP_CHAR ; XORL2 R3, R0 ;R3, TEMP_CHAR ; CMPL R0, #1 ;TEMP_CHAR, #1 ; 4160 BEQL 6$ ;6$ ; CMPL R0, #2 ;TEMP_CHAR, #2 ; BNEQ 9$ ;9$ ; 6$: MOVL R2, R0 ;R2, R0 ; 4155 RET ; ; 7$: EXTZV #0, #7, R1, R0 ;#0, #7, R1, TEMP_CHAR ; 4170 EXTZV #0, #4, R0, R2 ;#0, #4, TEMP_CHAR, R2 ; 4171 EXTZV #4, #4, R0, R0 ;#4, #4, TEMP_CHAR, TEMP_CHAR ; XORL2 R2, R0 ;R2, TEMP_CHAR ; EXTZV #0, #2, R0, R2 ;#0, #2, TEMP_CHAR, R2 ; 4172 EXTZV #2, #2, R0, R0 ;#2, #2, TEMP_CHAR, TEMP_CHAR ; XORL2 R2, R0 ;R2, TEMP_CHAR ; CMPL R0, #1 ;TEMP_CHAR, #1 ; 4174 BEQL 8$ ;8$ ; CMPL R0, #2 ;TEMP_CHAR, #2 ; BNEQ 9$ ;9$ ; 8$: EXTZV #0, #7, R1, R0 ;#0, #7, R1, R0 ; 4176 INSV #1, #7, #1, R0 ;#1, #7, #1, R0 ; RET ; ; 4169 9$: EXTZV #0, #7, R1, R0 ;#0, #7, R1, R0 ; RET ; ; 4097 ; Routine Size: 161 bytes, Routine Base: $CODE$ + 1337 ; 4184 ; 4185 %SBTTL 'BFR_EMPTY' ; 4186 ROUTINE BFR_EMPTY = ; 4187 ; 4188 !++ ; 4189 ! FUNCTIONAL DESCRIPTION: ; 4190 ! ; 4191 ! This routine will empty the data from the REC_MSG message buffer ; 4192 ! to the file. It will process quoting characters. ; 4193 ! ; 4194 ! CALLING SEQUENCE: ; 4195 ! ; 4196 ! Flag = BFR_EMPTY(); ; 4197 ! ; 4198 ! INPUT PARAMETERS: ; 4199 ! ; 4200 ! None. ; 4201 ! ; 4202 ! IMPLICIT INPUTS: ; 4203 ! ; 4204 ! None. ; 4205 ! ; 4206 ! OUTPUT PARAMETERS: ; 4207 ! ; 4208 ! True - No problems writing the file. ; 4209 ! False - I/O error writing the file. ; 4210 ! ; 4211 ! IMPLICIT OUTPUTS: ; 4212 ! ; 4213 ! None. ; 4214 ! ; 4215 ! COMPLETION CODES: ; 4216 ! ; 4217 ! None. ; 4218 ! ; 4219 ! SIDE EFFECTS: ; 4220 ! ; 4221 ! None. ; 4222 ! ; 4223 !-- ; 4224 ; 4225 BEGIN ; 4226 ; 4227 LOCAL ; 4228 REPEAT_COUNT, ! Count of times to repeat character ; 4229 TURN_BIT_8_ON, ! If eight bit quoting ; 4230 COUNTER, ! Count of the characters left ; 4231 CHARACTER, ! Character we are processing ; 4232 POINTER; ! Pointer to the data ; 4233 ; 4234 POINTER = CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE); ; 4235 COUNTER = 0; ; 4236 ; 4237 WHILE (.COUNTER LSS .REC_LENGTH) DO ; 4238 BEGIN ; 4239 CHARACTER = CH$RCHAR_A (POINTER); ; 4240 COUNTER = .COUNTER + 1; ; 4241 ! ; 4242 ! If the character is the repeat character (and we are doing repeat ; 4243 ! compression), then get the count. ; 4244 ! ; 4245 ; 4246 IF ((.CHARACTER EQL .REPT_CHR) AND .FLAG_REPEAT) ; 4247 THEN ; 4248 BEGIN ; 4249 REPEAT_COUNT = UNCHAR (CH$RCHAR_A (POINTER) AND %O'177'); ; 4250 CHARACTER = CH$RCHAR_A (POINTER); ; 4251 COUNTER = .COUNTER + 2; ; 4252 END ; 4253 ELSE ; 4254 REPEAT_COUNT = 1; ; 4255 ; 4256 ! ; 4257 ! If the character is an eight bit quoting character and we are doing eight ; 4258 ! bit quoting then turn on the flag so we turn the eighth bit on when we ; 4259 ! get the real character. ; 4260 ! ; 4261 ; 4262 IF ((.CHARACTER EQL .SEND_8QUOTE_CHR) AND .FLAG_8QUOTE) ; 4263 THEN ; 4264 BEGIN ; 4265 TURN_BIT_8_ON = TRUE; ; 4266 COUNTER = .COUNTER + 1; ; 4267 CHARACTER = CH$RCHAR_A (POINTER); ; 4268 END ; 4269 ELSE ; 4270 TURN_BIT_8_ON = FALSE; ; 4271 ; 4272 ! ; 4273 ! Now determine if we are quoting the character. If so then we must eat ; 4274 ! the quoting character and get the real character. ; 4275 ! ; 4276 ; 4277 IF .CHARACTER EQL .RCV_QUOTE_CHR ; 4278 THEN ; 4279 BEGIN ; 4280 CHARACTER = CH$RCHAR_A (POINTER); ; 4281 COUNTER = .COUNTER + 1; ; 4282 ! ; 4283 ! Determine if we must undo what someone else has done to the character ; 4284 ! ; 4285 ; P 4286 IF ((.CHARACTER AND %O'177') GEQ CTL (CHR_DEL)) AND ((.CHARACTER AND %O'177') LEQ CTL ( ; 4287 CHR_DEL) + %O'40') ; 4288 THEN ; 4289 CHARACTER = CTL (.CHARACTER); ; 4290 ; 4291 END; ; 4292 ; 4293 ! ; 4294 ! Turn on the eight bit if needed and then write the character out ; 4295 ! ; 4296 ; 4297 IF .TURN_BIT_8_ON THEN CHARACTER = .CHARACTER OR %O'200'; ; 4298 ; 4299 WHILE (REPEAT_COUNT = .REPEAT_COUNT - 1) GEQ 0 DO ; 4300 BEGIN ; 4301 STATUS = PUT_FILE (.CHARACTER); ; 4302 ; 4303 IF NOT .STATUS THEN RETURN .STATUS; ; 4304 ; 4305 END; ; 4306 ; 4307 END; ; 4308 ; 4309 ! ; 4310 ! Dump the record if we have an RMS based system. Otherwise we will have ; 4311 ! problem with binary files. ; 4312 ! ; 4313 STATUS = FILE_DUMP (); ; 4314 ; 4315 IF NOT .STATUS THEN RETURN .STATUS; ; 4316 ; 4317 RETURN KER_NORMAL; ; 4318 END; ! End of BFR_EMPTY ;BFR_EMPTY U.24: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 ; 4186 MOVAB W^U.97, R7 ;U.97, R7 ; MOVAB 40(R7), R3 ;REC_MSG+4, POINTER ; 4234 CLRL R4 ;COUNTER ; 4235 1$: CMPL R4, 28(R7) ;COUNTER, REC_LENGTH ; 4237 BGEQ 8$ ;8$ ; MOVZBL (R3)+, R2 ;(POINTER)+, CHARACTER ; 4239 INCL R4 ;COUNTER ; 4240 CMPL R2, -48(R7) ;CHARACTER, REPT_CHR ; 4246 BNEQ 2$ ;2$ ; BLBC -4(R7), 2$ ;FLAG_REPEAT, 2$ ; MOVZBL (R3)+, R0 ;(POINTER)+, R0 ; 4249 EXTZV #0, #7, R0, R5 ;#0, #7, R0, REPEAT_COUNT ; SUBL2 #32, R5 ;#32, REPEAT_COUNT ; MOVZBL (R3)+, R2 ;(POINTER)+, CHARACTER ; 4250 ADDL2 #2, R4 ;#2, COUNTER ; 4251 BRB 3$ ;3$ ; 4246 2$: MOVL #1, R5 ;#1, REPEAT_COUNT ; 4254 3$: CMPL R2, -20(R7) ;CHARACTER, SEND_8QUOTE_CHR ; 4262 BNEQ 4$ ;4$ ; BLBC -8(R7), 4$ ;FLAG_8QUOTE, 4$ ; MOVL #1, R6 ;#1, TURN_BIT_8_ON ; 4265 INCL R4 ;COUNTER ; 4266 MOVZBL (R3)+, R2 ;(POINTER)+, CHARACTER ; 4267 BRB 5$ ;5$ ; 4262 4$: CLRL R6 ;TURN_BIT_8_ON ; 4270 5$: CMPL R2, W^RCV_QUOTE_CHR ;CHARACTER, RCV_QUOTE_CHR ; 4277 BNEQ 6$ ;6$ ; MOVZBL (R3)+, R2 ;(POINTER)+, CHARACTER ; 4280 INCL R4 ;COUNTER ; 4281 CMPZV #0, #7, R2, #63 ;#0, #7, CHARACTER, #63 ; 4286 BLSS 6$ ;6$ ; CMPZV #0, #7, R2, #95 ;#0, #7, CHARACTER, #95 ; BGTR 6$ ;6$ ; XORB2 #64, R2 ;#64, CHARACTER ; 4289 6$: BLBC R6, 7$ ;TURN_BIT_8_ON, 7$ ; 4297 BISB2 #128, R2 ;#128, CHARACTER ; 7$: DECL R5 ;REPEAT_COUNT ; 4299 BLSS 1$ ;1$ ; PUSHL R2 ;CHARACTER ; 4301 CALLS #1, W^PUT_FILE ;#1, PUT_FILE ; MOVL R0, (R7) ;R0, STATUS ; BLBS (R7), 7$ ;STATUS, 7$ ; 4303 BRB 9$ ;9$ ; 8$: CALLS #0, W^FILE_DUMP ;#0, FILE_DUMP ; 4313 MOVL R0, (R7) ;R0, STATUS ; BLBS (R7), 10$ ;STATUS, 10$ ; 4315 9$: MOVL (R7), R0 ;STATUS, R0 ; RET ; ; 10$: MOVL #134316043, R0 ;#134316043, R0 ; 4225 RET ; ; 4186 ; Routine Size: 161 bytes, Routine Base: $CODE$ + 13D8 ; 4319 %SBTTL 'Per transfer -- Initialization' ; 4320 ROUTINE INIT_XFR : NOVALUE = ; 4321 ; 4322 !++ ; 4323 ! FUNCTIONAL DESCRIPTION: ; 4324 ! ; 4325 ! This routine will initialize the various locations that the ; 4326 ! send and receive statistics are kept. ; 4327 ! ; 4328 ! CALLING SEQUENCE: ; 4329 ! ; 4330 ! INIT_XFR(); ; 4331 ! ; 4332 ! INPUT PARAMETERS: ; 4333 ! ; 4334 ! None. ; 4335 ! ; 4336 ! IMPLICIT INPUTS: ; 4337 ! ; 4338 ! None. ; 4339 ! ; 4340 ! OUTPUT PARAMETERS: ; 4341 ! ; 4342 ! None. ; 4343 ! ; 4344 ! IMPLICIT OUTPUTS: ; 4345 ! ; 4346 ! None. ; 4347 ! ; 4348 ! COMPLETION CODES: ; 4349 ! ; 4350 ! None. ; 4351 ! ; 4352 ! SIDE EFFECTS: ; 4353 ! ; 4354 ! None. ; 4355 ! ; 4356 !-- ; 4357 ; 4358 BEGIN ; 4359 ! ; 4360 ! Determine if we should do 8 bit quoting ; 4361 ! ; 4362 ; 4363 IF .PARITY_TYPE NEQ PR_NONE ; 4364 THEN ; 4365 BEGIN ; 4366 RECV_8QUOTE_CHR = .RCV_8QUOTE_CHR; ; 4367 END ; 4368 ELSE ; 4369 BEGIN ; 4370 RECV_8QUOTE_CHR = %C'Y'; ; 4371 END; ; 4372 SEND_8QUOTE_CHR = .RECV_8QUOTE_CHR; ; 4373 ; 4374 ! ; 4375 ! Send parameters that may not get set before we need them for the first ; 4376 ! time. ; 4377 ! ; 4378 SEND_PKT_SIZE = ABS (.SND_PKT_SIZE); ; 4379 SEND_NPAD = ABS (.SND_NPAD); ; 4380 SEND_PADCHAR = ABS (.SND_PADCHAR); ; 4381 SEND_TIMEOUT = ABS (.SND_TIMEOUT); ; 4382 SEND_EOL = ABS (.SND_EOL); ; 4383 SEND_QUOTE_CHR = ABS (.SND_QUOTE_CHR); ; 4384 ! ; 4385 ! For initialization messages, we must use single character checksum ; 4386 ! When the send-init/ack sequence has been done, we will switch to the ; 4387 ! desired form ; 4388 ! ; 4389 BLK_CHK_TYPE = CHK_1CHAR; ; 4390 INI_CHK_TYPE = .CHKTYPE; ! Send desired type ; 4391 ! ; 4392 ! Set desired repeat character for use in we are doing send-init ; 4393 ! Will be overwritten by other ends desired character if it sends ; 4394 ! the send-init. ; 4395 ! ; 4396 REPT_CHR = .SET_REPT_CHR; ; 4397 ! ; 4398 ! Stats information ; 4399 ! ; 4400 SMSG_TOTAL_CHARS = 0; ; 4401 RMSG_TOTAL_CHARS = 0; ; 4402 SMSG_DATA_CHARS = 0; ; 4403 RMSG_DATA_CHARS = 0; ; 4404 RMSG_NAKS = 0; ; 4405 SMSG_NAKS = 0; ; 4406 XFR_TIME = SY_TIME (); ; 4407 END; ! End of INIT_XFR ;INIT_XFR U.27: .WORD ^M ;Save R2 ; 4320 MOVAB W^U.84, R2 ;U.84, R2 ; TSTL W^PARITY_TYPE ;PARITY_TYPE ; 4363 BEQL 1$ ;1$ ; MOVL W^RCV_8QUOTE_CHR, (R2) ;RCV_8QUOTE_CHR, RECV_8QUOTE_CHR ; 4366 BRB 2$ ;2$ ; 4363 1$: MOVZBL #89, (R2) ;#89, RECV_8QUOTE_CHR ; 4370 2$: MOVL (R2), 32(R2) ;RECV_8QUOTE_CHR, SEND_8QUOTE_CHR ; 4372 MOVL W^SND_PKT_SIZE, R0 ;SND_PKT_SIZE, R0 ; 4378 BGEQ 3$ ;3$ ; MNEGL R0, R0 ;R0, R0 ; 3$: MOVL R0, 8(R2) ;R0, SEND_PKT_SIZE ; MOVL W^SND_NPAD, R0 ;SND_NPAD, R0 ; 4379 BGEQ 4$ ;4$ ; MNEGL R0, R0 ;R0, R0 ; 4$: MOVL R0, 12(R2) ;R0, SEND_NPAD ; MOVL W^SND_PADCHAR, R0 ;SND_PADCHAR, R0 ; 4380 BGEQ 5$ ;5$ ; MNEGL R0, R0 ;R0, R0 ; 5$: MOVL R0, 16(R2) ;R0, SEND_PADCHAR ; MOVL W^SND_TIMEOUT, R0 ;SND_TIMEOUT, R0 ; 4381 BGEQ 6$ ;6$ ; MNEGL R0, R0 ;R0, R0 ; 6$: MOVL R0, 20(R2) ;R0, SEND_TIMEOUT ; MOVL W^SND_EOL, R0 ;SND_EOL, R0 ; 4382 BGEQ 7$ ;7$ ; MNEGL R0, R0 ;R0, R0 ; 7$: MOVL R0, 24(R2) ;R0, SEND_EOL ; MOVL W^SND_QUOTE_CHR, R0 ;SND_QUOTE_CHR, R0 ; 4383 BGEQ 8$ ;8$ ; MNEGL R0, R0 ;R0, R0 ; 8$: MOVL R0, 28(R2) ;R0, SEND_QUOTE_CHR ; MOVL #49, 40(R2) ;#49, BLK_CHK_TYPE ; 4389 MOVL W^CHKTYPE, 36(R2) ;CHKTYPE, INI_CHK_TYPE ; 4390 MOVL W^SET_REPT_CHR, 4(R2) ;SET_REPT_CHR, REPT_CHR ; 4396 CLRQ W^SMSG_TOTAL_CHARS ;SMSG_TOTAL_CHARS ; 4400 CLRQ W^SMSG_DATA_CHARS ;SMSG_DATA_CHARS ; 4402 CLRQ W^SMSG_NAKS ;SMSG_NAKS ; 4405 CALLS #0, W^SY_TIME ;#0, SY_TIME ; 4406 MOVL R0, W^XFR_TIME ;R0, XFR_TIME ; RET ; ; 4320 ; Routine Size: 151 bytes, Routine Base: $CODE$ + 1479 ; 4408 %SBTTL 'Statistics -- Finish message transfer' ; 4409 ROUTINE END_STATS : NOVALUE = ; 4410 ; 4411 !++ ; 4412 ! FUNCTIONAL DESCRIPTION: ; 4413 ! ; 4414 ! This routine will end the collection of the statistices. It will ; 4415 ! update the various overall statistic parameters. ; 4416 ! ; 4417 ! CALLING SEQUENCE: ; 4418 ! ; 4419 ! END_STATS (); ; 4420 ! ; 4421 ! INPUT PARAMETERS: ; 4422 ! ; 4423 ! None. ; 4424 ! ; 4425 ! IMPLICIT INPUTS: ; 4426 ! ; 4427 ! None. ; 4428 ! ; 4429 ! OUTPUT PARAMETERS: ; 4430 ! ; 4431 ! None. ; 4432 ! ; 4433 ! IMPLICIT OUTPUTS: ; 4434 ! ; 4435 ! None. ; 4436 ! ; 4437 ! COMPLETION CODES: ; 4438 ! ; 4439 ! None. ; 4440 ! ; 4441 ! SIDE EFFECTS: ; 4442 ! ; 4443 ! None. ; 4444 ! ; 4445 !-- ; 4446 ; 4447 BEGIN ; 4448 SND_TOTAL_CHARS = .SND_TOTAL_CHARS + .SMSG_TOTAL_CHARS; ; 4449 SND_DATA_CHARS = .SND_DATA_CHARS + .SMSG_DATA_CHARS; ; 4450 RCV_TOTAL_CHARS = .RCV_TOTAL_CHARS + .RMSG_TOTAL_CHARS; ; 4451 RCV_DATA_CHARS = .RCV_DATA_CHARS + .RMSG_DATA_CHARS; ; 4452 SND_NAKS = .SND_NAKS + .SMSG_NAKS; ; 4453 RCV_NAKS = .RCV_NAKS + .RMSG_NAKS; ; 4454 XFR_TIME = SY_TIME () - .XFR_TIME; ; 4455 TOTAL_TIME = .TOTAL_TIME + .XFR_TIME; ; 4456 END; ! End of END_STATS ;END_STATS U.15: .WORD ^M ;Save R2 ; 4409 MOVAB W^XFR_TIME, R2 ;XFR_TIME, R2 ; ADDL2 -24(R2), -56(R2) ;SMSG_TOTAL_CHARS, SND_TOTAL_CHARS ; 4448 ADDL2 -16(R2), -48(R2) ;SMSG_DATA_CHARS, SND_DATA_CHARS ; 4449 ADDL2 -20(R2), -52(R2) ;RMSG_TOTAL_CHARS, RCV_TOTAL_CHARS ; 4450 ADDL2 -12(R2), -44(R2) ;RMSG_DATA_CHARS, RCV_DATA_CHARS ; 4451 ADDL2 -8(R2), -40(R2) ;SMSG_NAKS, SND_NAKS ; 4452 ADDL2 -4(R2), -36(R2) ;RMSG_NAKS, RCV_NAKS ; 4453 CALLS #0, W^SY_TIME ;#0, SY_TIME ; 4454 SUBL3 (R2), R0, (R2) ;XFR_TIME, R0, XFR_TIME ; ADDL2 (R2), 4(R2) ;XFR_TIME, TOTAL_TIME ; 4455 RET ; ; 4409 ; Routine Size: 51 bytes, Routine Base: $CODE$ + 1510 ; 4457 %SBTTL 'Debugging -- DBG_SEND' ; 4458 ROUTINE DBG_SEND (ADDRESS, LENGTH) : NOVALUE = ; 4459 ; 4460 !++ ; 4461 ! FUNCTIONAL DESCRIPTION: ; 4462 ! ; 4463 ! This routine will output the message that is going to be sent ; 4464 ! as part of the debugging information that is turned on in the ; 4465 ! SET DEBUG command. ; 4466 ! ; 4467 ! CALLING SEQUENCE: ; 4468 ! ; 4469 ! DBG_SEND(MSG_ADDRESS, MSG_LENGTH); ; 4470 ! ; 4471 ! INPUT PARAMETERS: ; 4472 ! ; 4473 ! MSG_ADDRESS - Address of the message that is going to be sent ; 4474 ! to the remote KERMIT. The bytes are CHR_SIZE. ; 4475 ! MSG_LENGTH - Length of the message. ; 4476 ! ; 4477 ! IMPLICIT INPUTS: ; 4478 ! ; 4479 ! None. ; 4480 ! ; 4481 ! OUTPUT PARAMETERS: ; 4482 ! ; 4483 ! None. ; 4484 ! ; 4485 ! IMPLICIT OUTPUTS: ; 4486 ! ; 4487 ! None. ; 4488 ! ; 4489 ! COMPLETION CODES: ; 4490 ! ; 4491 ! None. ; 4492 ! ; 4493 ! SIDE EFFECTS: ; 4494 ! ; 4495 ! None. ; 4496 ! ; 4497 !-- ; 4498 ; 4499 BEGIN ; 4500 ; 4501 BIND ; 4502 SEND_TEXT = UPLIT (%ASCIZ'Sending...'); ; 4503 ; 4504 IF .DEBUG_FLAG ; 4505 THEN ; 4506 BEGIN ; 4507 ; 4508 LOCAL ; 4509 OLD_RTN; ; 4510 ; 4511 OLD_RTN = TT_SET_OUTPUT (DBG_DUMP); ; 4512 TT_TEXT (SEND_TEXT); ; 4513 DBG_MESSAGE (.ADDRESS, .LENGTH); ; 4514 TT_SET_OUTPUT (.OLD_RTN); ; 4515 END; ; 4516 ; 4517 END; ! End of DBG_SEND .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAL: .ASCII \Sending...\<0><0> ; ; U.128= P.AAL .PSECT $CODE$,NOWRT,2 ;DBG_SEND U.29: .WORD ^M ;Save R2 ; 4458 BLBC W^DEBUG_FLAG, 1$ ;DEBUG_FLAG, 1$ ; 4504 PUSHAB W^DBG_DUMP ;DBG_DUMP ; 4511 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; MOVL R0, R2 ;R0, OLD_RTN ; PUSHAB W^U.128 ;U.128 ; 4512 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; MOVQ 4(AP), -(SP) ;ADDRESS, -(SP) ; 4513 CALLS #2, W^U.28 ;#2, U.28 ; PUSHL R2 ;OLD_RTN ; 4514 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; 1$: RET ; ; 4458 ; Routine Size: 45 bytes, Routine Base: $CODE$ + 1543 ; 4518 %SBTTL 'Debugging -- DBG_RECEIVE' ; 4519 ROUTINE DBG_RECEIVE (ADDRESS) : NOVALUE = ; 4520 ; 4521 !++ ; 4522 ! FUNCTIONAL DESCRIPTION: ; 4523 ! ; 4524 ! This routine will output the message that was received from ; 4525 ! the remote KERMIT. This routine is called only if the DEBUG_FLAG ; 4526 ! is true. ; 4527 ! ; 4528 ! CALLING SEQUENCE: ; 4529 ! ; 4530 ! DBG_RECEIVE(MSG_ADDRESS); ; 4531 ! ; 4532 ! INPUT PARAMETERS: ; 4533 ! ; 4534 ! MSG_ADDRESS - Address of the message received by the remote KERMIT. ; 4535 ! ; 4536 ! IMPLICIT INPUTS: ; 4537 ! ; 4538 ! None. ; 4539 ! ; 4540 ! OUTPUT PARAMETERS: ; 4541 ! ; 4542 ! None. ; 4543 ! ; 4544 ! IMPLICIT OUTPUTS: ; 4545 ! ; 4546 ! None. ; 4547 ! ; 4548 ! COMPLETION CODES: ; 4549 ! ; 4550 ! None. ; 4551 ! ; 4552 ! SIDE EFFECTS: ; 4553 ! ; 4554 ! None. ; 4555 ! ; 4556 !-- ; 4557 ; 4558 BEGIN ; 4559 ; 4560 BIND ; 4561 RECEIVE_TEXT = UPLIT (%ASCIZ'Received...'); ; 4562 ; 4563 IF .DEBUG_FLAG ; 4564 THEN ; 4565 BEGIN ; 4566 ; 4567 LOCAL ; 4568 OLD_RTN; ; 4569 ; 4570 OLD_RTN = TT_SET_OUTPUT (DBG_DUMP); ; 4571 TT_TEXT (RECEIVE_TEXT); ; 4572 DBG_MESSAGE (.ADDRESS, .REC_LENGTH); ; 4573 TT_SET_OUTPUT (.OLD_RTN); ; 4574 END; ; 4575 ; 4576 END; ! End of DBG_RECEIVE .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAM: .ASCII \Received...\<0> ; ; U.129= P.AAM .PSECT $CODE$,NOWRT,2 ;DBG_RECEIVE U.30: .WORD ^M ;Save R2 ; 4519 BLBC W^DEBUG_FLAG, 1$ ;DEBUG_FLAG, 1$ ; 4563 PUSHAB W^DBG_DUMP ;DBG_DUMP ; 4570 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; MOVL R0, R2 ;R0, OLD_RTN ; PUSHAB W^U.129 ;U.129 ; 4571 CALLS #1, W^TT_TEXT ;#1, TT_TEXT ; PUSHL W^U.104 ;U.104 ; 4572 PUSHL 4(AP) ;ADDRESS ; CALLS #2, W^U.28 ;#2, U.28 ; PUSHL R2 ;OLD_RTN ; 4573 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; 1$: RET ; ; 4519 ; Routine Size: 48 bytes, Routine Base: $CODE$ + 1570 ; 4577 %SBTTL 'Debugging -- DBG_MESSAGE' ; 4578 ; 4579 GLOBAL ROUTINE DBG_MESSAGE (MSG_ADDRESS, MSG_LENGTH) : NOVALUE = ; 4580 ; 4581 !++ ; 4582 ! FUNCTIONAL DESCRIPTION: ; 4583 ! ; 4584 ! This routine will display a message that is either being sent ; 4585 ! or received on the user's terminal. ; 4586 ! ; 4587 ! CALLING SEQUENCE: ; 4588 ! ; 4589 ! DBG_MESSAGE(MSG_ADDRESS, MSG_LENGTH); ; 4590 ! ; 4591 ! INPUT PARAMETERS: ; 4592 ! ; 4593 ! MSG_ADDRESS - Address of the message to be output ; 4594 ! MSG_LENGTH - Length of the message to be output. ; 4595 ! ; 4596 ! IMPLICIT INPUTS: ; 4597 ! ; 4598 ! None. ; 4599 ! ; 4600 ! OUTPUT PARAMETERS: ; 4601 ! ; 4602 ! None. ; 4603 ! ; 4604 ! IMPLICIT OUTPUTS: ; 4605 ! ; 4606 ! None. ; 4607 ! ; 4608 ! COMPLETION CODES: ; 4609 ! ; 4610 ! None. ; 4611 ! ; 4612 ! SIDE EFFECTS: ; 4613 ! ; 4614 ! None. ; 4615 ! ; 4616 !-- ; 4617 ; 4618 BEGIN ; 4619 ; 4620 MAP ; 4621 MSG_ADDRESS : REF VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)]; ! Point to the vector ; 4622 ; 4623 LOCAL ; 4624 OLD_RTN, ! Old type out routine ; 4625 CHKSUM, ! Numeric value of block check ; 4626 TEMP_POINTER, ! Temporary character pointer ; 4627 MSG_LEN; ; 4628 ; 4629 ! ; 4630 ! Message type text ; 4631 ! ; 4632 ; 4633 BIND ; 4634 DATA_TEXT = UPLIT (%ASCIZ' (Data)'), ; 4635 ACK_TEXT = UPLIT (%ASCIZ' (ACK)'), ; 4636 NAK_TEXT = UPLIT (%ASCIZ' (NAK)'), ; 4637 SND_INIT_TEXT = UPLIT (%ASCIZ' (Send init)'), ; 4638 BREAK_TEXT = UPLIT (%ASCIZ' (Break)'), ; 4639 FILE_TEXT = UPLIT (%ASCIZ' (File)'), ; 4640 EOF_TEXT = UPLIT (%ASCIZ' (EOF)'), ; 4641 ERROR_TEXT = UPLIT (%ASCIZ' (Error)'), ; 4642 RCV_INIT_TEXT = UPLIT (%ASCIZ' (Receive initiate)'), ; 4643 COMMAND_TEXT = UPLIT (%ASCIZ' (Command)'), ; 4644 KERMIT_TEXT = UPLIT (%ASCIZ' (Generic KERMIT command)'); ; 4645 ; 4646 ! ; 4647 ! Header information ; 4648 ! ; 4649 ; 4650 BIND ; 4651 MN_TEXT = UPLIT (%ASCIZ'Message number: '), ; 4652 LENGTH_TEXT = UPLIT (%ASCIZ' Length: '), ; 4653 DEC_TEXT = UPLIT (%ASCIZ' (dec)'), ; 4654 MSG_TYP_TEXT = UPLIT (%ASCIZ'Message type: '), ; 4655 CHKSUM_TEXT = UPLIT (%ASCIZ'Checksum: '), ; 4656 CHKSUM_NUM_TEXT = UPLIT (%ASCIZ' = '), ; 4657 OPT_DATA_TEXT = UPLIT (%ASCIZ'Optional data: '), ; 4658 PRE_CHAR_TEXT = UPLIT (%ASCIZ' "'); ; 4659 ; 4660 ! ; 4661 ! Ensure that the type out will go to the debugging location ; 4662 ! ; 4663 OLD_RTN = TT_SET_OUTPUT (DBG_DUMP); ; 4664 ! ; 4665 ! Preliminary calculations ; 4666 ! ; 4667 MSG_LEN = UNCHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_COUNT, CHR_SIZE))); ; 4668 ! ; 4669 ! First output some header information for the packet. ; 4670 ! ; 4671 TT_CRLF (); ; 4672 TT_TEXT (MN_TEXT); ; 4673 TT_NUMBER (UNCHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_SEQ, CHR_SIZE)))); ; 4674 TT_TEXT (DEC_TEXT); ; 4675 TT_TEXT (LENGTH_TEXT); ; 4676 TT_NUMBER (.MSG_LEN); ; 4677 TT_TEXT (DEC_TEXT); ; 4678 TT_CRLF (); ; 4679 ! ; 4680 ! Now output the message type and dependent information ; 4681 ! ; 4682 TT_TEXT (MSG_TYP_TEXT); ; 4683 TT_CHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_TYPE, CHR_SIZE))); ; 4684 ; 4685 SELECTONE CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_TYPE, CHR_SIZE)) OF ; 4686 SET ; 4687 ; 4688 [MSG_DATA] : ; 4689 TT_TEXT (DATA_TEXT); ; 4690 ; 4691 [MSG_ACK] : ; 4692 TT_TEXT (ACK_TEXT); ; 4693 ; 4694 [MSG_NAK] : ; 4695 TT_TEXT (NAK_TEXT); ; 4696 ; 4697 [MSG_SND_INIT] : ; 4698 TT_TEXT (SND_INIT_TEXT); ; 4699 ; 4700 [MSG_BREAK] : ; 4701 TT_TEXT (BREAK_TEXT); ; 4702 ; 4703 [MSG_FILE] : ; 4704 TT_TEXT (FILE_TEXT); ; 4705 ; 4706 [MSG_EOF] : ; 4707 TT_TEXT (EOF_TEXT); ; 4708 ; 4709 [MSG_ERROR] : ; 4710 TT_TEXT (ERROR_TEXT); ; 4711 TES; ; 4712 ; 4713 TT_CRLF (); ; 4714 ! ; 4715 ! Now output any of the optional data. ; 4716 ! ; 4717 ; 4718 IF .MSG_LEN - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR) NEQ 0 ; 4719 THEN ; 4720 BEGIN ; 4721 TT_TEXT (OPT_DATA_TEXT); ; 4722 TT_CRLF (); ; 4723 TEMP_POINTER = CH$PTR (.MSG_ADDRESS, PKT_MSG, CHR_SIZE); ; 4724 ; 4725 INCR I FROM 1 TO .MSG_LEN - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR) DO ; 4726 BEGIN ; 4727 ; 4728 IF (.I MOD 10) EQL 1 ; 4729 THEN ; 4730 BEGIN ; 4731 TT_CRLF (); ; 4732 TT_CHAR (CHR_TAB); ; 4733 END; ; 4734 ; 4735 TT_TEXT (PRE_CHAR_TEXT); ; 4736 TT_CHAR (CH$RCHAR_A (TEMP_POINTER)); ; 4737 TT_CHAR (%C'"'); ; 4738 END; ; 4739 ; 4740 IF ((.MSG_LEN - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR)) MOD 10) EQL 1 THEN TT_CRLF (); ; 4741 ; 4742 TT_CRLF (); ; 4743 END; ; 4744 ; 4745 ! ; 4746 ! Now output the checksum for the message that we received ; 4747 ! ; 4748 ! This could be either 1 two or three characters. ; 4749 TT_TEXT (CHKSUM_TEXT); ; 4750 TEMP_POINTER = CH$PTR (.MSG_ADDRESS, ; 4751 PKT_MSG + .MSG_LEN + PKT_CHKSUM - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR), CHR_SIZE); ; 4752 ; 4753 CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF ; 4754 SET ; 4755 ; 4756 [CHK_1CHAR] : ; 4757 BEGIN ; 4758 TT_TEXT (PRE_CHAR_TEXT); ; 4759 TT_CHAR (CH$RCHAR (.TEMP_POINTER)); ; 4760 TT_CHAR (%C'"'); ; 4761 CHKSUM = UNCHAR (CH$RCHAR (.TEMP_POINTER)); ; 4762 END; ; 4763 ; 4764 [CHK_2CHAR] : ; 4765 BEGIN ; 4766 CHKSUM = 0; ; 4767 TT_TEXT (PRE_CHAR_TEXT); ; 4768 TT_CHAR (CH$RCHAR (.TEMP_POINTER)); ; 4769 TT_CHAR (%C'"'); ; 4770 CHKSUM<6, 6> = UNCHAR (CH$RCHAR_A (TEMP_POINTER)); ; 4771 TT_TEXT (PRE_CHAR_TEXT); ; 4772 TT_CHAR (CH$RCHAR (.TEMP_POINTER)); ; 4773 TT_CHAR (%C'"'); ; 4774 CHKSUM<0, 6> = UNCHAR (CH$RCHAR (.TEMP_POINTER)); ; 4775 END; ; 4776 ; 4777 [CHK_CRC] : ; 4778 BEGIN ; 4779 CHKSUM = 0; ; 4780 TT_TEXT (PRE_CHAR_TEXT); ; 4781 TT_CHAR (CH$RCHAR (.TEMP_POINTER)); ; 4782 TT_CHAR (%C'"'); ; 4783 CHKSUM<12, 4> = UNCHAR (CH$RCHAR_A (TEMP_POINTER)); ; 4784 TT_TEXT (PRE_CHAR_TEXT); ; 4785 TT_CHAR (CH$RCHAR (.TEMP_POINTER)); ; 4786 TT_CHAR (%C'"'); ; 4787 CHKSUM<6, 6> = UNCHAR (CH$RCHAR_A (TEMP_POINTER)); ; 4788 TT_TEXT (PRE_CHAR_TEXT); ; 4789 TT_CHAR (CH$RCHAR (.TEMP_POINTER)); ; 4790 TT_CHAR (%C'"'); ; 4791 CHKSUM<0, 6> = UNCHAR (CH$RCHAR (.TEMP_POINTER)); ; 4792 END; ; 4793 TES; ; 4794 ; 4795 TT_TEXT (CHKSUM_NUM_TEXT); ; 4796 TT_NUMBER (.CHKSUM); ; 4797 TT_TEXT (DEC_TEXT); ; 4798 TT_CRLF (); ; 4799 TT_SET_OUTPUT (.OLD_RTN); ! Reset output destination ; 4800 END; ! End of DBG_MESSAGE .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAN: .ASCII \ (Data)\<0> ; ; P.AAO: .ASCII \ (ACK)\<0><0> ; ; P.AAP: .ASCII \ (NAK)\<0><0> ; ; P.AAQ: .ASCII \ (Send init)\<0><0><0><0> ; ; P.AAR: .ASCII \ (Break)\<0><0><0><0> ; ; P.AAS: .ASCII \ (File)\<0> ; ; P.AAT: .ASCII \ (EOF)\<0><0> ; ; P.AAU: .ASCII \ (Error)\<0><0><0><0> ; ; P.AAV: .ASCII \ (Receive initiate)\<0> ; ; P.AAW: .ASCII \ (Command)\<0><0> ; ; P.AAX: .ASCII \ (Generic KERMIT command)\<0><0><0> ; ; P.AAY: .ASCII \Message number: \<0><0><0><0> ; ; P.AAZ: .ASCII <9>\Length: \<0><0><0> ; ; P.ABA: .ASCII \ (dec)\<0><0> ; ; P.ABB: .ASCII \Message type: \<0><0> ; ; P.ABC: .ASCII \Checksum: \<0><0> ; ; P.ABD: .ASCII \ = \<0> ; ; P.ABE: .ASCII \Optional data: \<0> ; ; P.ABF: .ASCII \ "\<0><0> ; ; U.131= P.AAN U.132= P.AAO U.133= P.AAP U.134= P.AAQ U.135= P.AAR U.136= P.AAS U.137= P.AAT U.138= P.AAU U.139= P.AAV U.140= P.AAW U.141= P.AAX U.142= P.AAY U.143= P.AAZ U.144= P.ABA U.145= P.ABB U.146= P.ABC U.147= P.ABD U.148= P.ABE U.149= P.ABF U.28: .PSECT $CODE$,NOWRT,2 .ENTRY DBG_MESSAGE, ^M ; ; MOVAB W^TT_CHAR, R11 ;TT_CHAR, R11 ; MOVAB W^TT_TEXT, R10 ;TT_TEXT, R10 ; MOVAB W^U.149, R9 ;U.149, R9 ; PUSHAB W^DBG_DUMP ;DBG_DUMP ; 4663 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; MOVL R0, R8 ;R0, OLD_RTN ; MOVL 4(AP), R3 ;MSG_ADDRESS, R3 ; 4667 MOVZBL 1(R3), R7 ;1(R3), MSG_LEN ; SUBL2 #32, R7 ;#32, MSG_LEN ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 4671 PUSHAB -88(R9) ;MN_TEXT ; 4672 CALLS #1, (R10) ;#1, TT_TEXT ; MOVZBL 2(R3), -(SP) ;2(R3), -(SP) ; 4673 SUBL2 #32, (SP) ;#32, (SP) ; CALLS #1, W^TT_NUMBER ;#1, TT_NUMBER ; PUSHAB -56(R9) ;DEC_TEXT ; 4674 CALLS #1, (R10) ;#1, TT_TEXT ; PUSHAB -68(R9) ;LENGTH_TEXT ; 4675 CALLS #1, (R10) ;#1, TT_TEXT ; PUSHL R7 ;MSG_LEN ; 4676 CALLS #1, W^TT_NUMBER ;#1, TT_NUMBER ; PUSHAB -56(R9) ;DEC_TEXT ; 4677 CALLS #1, (R10) ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 4678 PUSHAB -48(R9) ;MSG_TYP_TEXT ; 4682 CALLS #1, (R10) ;#1, TT_TEXT ; MOVZBL 3(R3), R2 ;3(R3), R2 ; 4683 PUSHL R2 ;R2 ; CALLS #1, (R11) ;#1, TT_CHAR ; CMPB R2, #68 ;R2, #68 ; 4685 BNEQ 1$ ;1$ ; PUSHAB -228(R9) ;DATA_TEXT ; 4689 BRB 8$ ;8$ ; 1$: CMPB R2, #89 ;R2, #89 ; 4685 BNEQ 2$ ;2$ ; PUSHAB -220(R9) ;ACK_TEXT ; 4692 BRB 8$ ;8$ ; 2$: CMPB R2, #78 ;R2, #78 ; 4685 BNEQ 3$ ;3$ ; PUSHAB -212(R9) ;NAK_TEXT ; 4695 BRB 8$ ;8$ ; 3$: CMPB R2, #83 ;R2, #83 ; 4685 BNEQ 4$ ;4$ ; PUSHAB -204(R9) ;SND_INIT_TEXT ; 4698 BRB 8$ ;8$ ; 4$: CMPB R2, #66 ;R2, #66 ; 4685 BNEQ 5$ ;5$ ; PUSHAB -188(R9) ;BREAK_TEXT ; 4701 BRB 8$ ;8$ ; 5$: CMPB R2, #70 ;R2, #70 ; 4685 BNEQ 6$ ;6$ ; PUSHAB -176(R9) ;FILE_TEXT ; 4704 BRB 8$ ;8$ ; 6$: CMPB R2, #90 ;R2, #90 ; 4685 BNEQ 7$ ;7$ ; PUSHAB -168(R9) ;EOF_TEXT ; 4707 BRB 8$ ;8$ ; 7$: CMPB R2, #69 ;R2, #69 ; 4685 BNEQ 9$ ;9$ ; PUSHAB -160(R9) ;ERROR_TEXT ; 4710 8$: CALLS #1, (R10) ;#1, TT_TEXT ; 9$: CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 4713 MOVAB -3(R7), R5 ;-3(R7), R5 ; 4718 SUBL3 #49, W^U.94, R0 ;#49, U.94, R0 ; CMPL R5, R0 ;R5, R0 ; BEQL 14$ ;14$ ; PUSHAB -16(R9) ;OPT_DATA_TEXT ; 4721 CALLS #1, (R10) ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 4722 MOVAB 4(R3), R2 ;4(R3), TEMP_POINTER ; 4723 SUBL3 W^U.94, R5, R0 ;U.94, R5, R0 ; 4725 MOVAB 49(R0), R6 ;49(R0), R6 ; CLRL R4 ;I ; BRB 12$ ;12$ ; 10$: EMUL #1, R4, #0, -(SP) ;#1, I, #0, -(SP) ; 4728 EDIV #10, (SP)+, R0, R0 ;#10, (SP)+, R0, R0 ; CMPL R0, #1 ;R0, #1 ; BNEQ 11$ ;11$ ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 4731 PUSHL #9 ;#9 ; 4732 CALLS #1, (R11) ;#1, TT_CHAR ; 11$: PUSHL R9 ;R9 ; 4735 CALLS #1, (R10) ;#1, TT_TEXT ; MOVZBL (R2)+, -(SP) ;(TEMP_POINTER)+, -(SP) ; 4736 CALLS #1, (R11) ;#1, TT_CHAR ; PUSHL #34 ;#34 ; 4737 CALLS #1, (R11) ;#1, TT_CHAR ; 12$: AOBLEQ R6, R4, 10$ ;R6, I, 10$ ; 4725 SUBL3 W^U.94, R5, R0 ;U.94, R5, R0 ; 4740 EMUL #1, R0, #49, -(SP) ;#1, R0, #49, -(SP) ; EDIV #10, (SP)+, R0, R0 ;#10, (SP)+, R0, R0 ; CMPL R0, #1 ;R0, #1 ; BNEQ 13$ ;13$ ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 13$: CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 4742 14$: PUSHAB -32(R9) ;CHKSUM_TEXT ; 4749 CALLS #1, (R10) ;#1, TT_TEXT ; SUBL3 W^U.94, R7, R0 ;U.94, MSG_LEN, R0 ; 4751 MOVAB 50(R0)[R3], R2 ;50(R0)[R3], TEMP_POINTER ; CASEL W^U.94, #49, #2 ;U.94, #49, #2 ; 4753 15$: .WORD 16$-15$,- ;16$-15$,- ; 17$-15$,- ;17$-15$,- ; 18$-15$ ;18$-15$ ; 16$: PUSHL R9 ;R9 ; 4758 CALLS #1, (R10) ;#1, TT_TEXT ; MOVZBL (R2), -(SP) ;(TEMP_POINTER), -(SP) ; 4759 CALLS #1, (R11) ;#1, TT_CHAR ; PUSHL #34 ;#34 ; 4760 CALLS #1, (R11) ;#1, TT_CHAR ; MOVZBL (R2), R4 ;(TEMP_POINTER), CHKSUM ; 4761 SUBL2 #32, R4 ;#32, CHKSUM ; BRB 20$ ;20$ ; 4753 17$: CLRL R4 ;CHKSUM ; 4766 BRB 19$ ;19$ ; 4767 18$: CLRL R4 ;CHKSUM ; 4779 PUSHL R9 ;R9 ; 4780 CALLS #1, (R10) ;#1, TT_TEXT ; MOVZBL (R2), -(SP) ;(TEMP_POINTER), -(SP) ; 4781 CALLS #1, (R11) ;#1, TT_CHAR ; PUSHL #34 ;#34 ; 4782 CALLS #1, (R11) ;#1, TT_CHAR ; MOVZBL (R2)+, R0 ;(TEMP_POINTER)+, R0 ; 4783 MOVAB -32(R0), R1 ;-32(R0), R1 ; INSV R1, #12, #4, R4 ;R1, #12, #4, CHKSUM ; 19$: PUSHL R9 ;R9 ; 4784 CALLS #1, (R10) ;#1, TT_TEXT ; MOVZBL (R2), -(SP) ;(TEMP_POINTER), -(SP) ; 4785 CALLS #1, (R11) ;#1, TT_CHAR ; PUSHL #34 ;#34 ; 4786 CALLS #1, (R11) ;#1, TT_CHAR ; MOVZBL (R2)+, R0 ;(TEMP_POINTER)+, R0 ; 4787 MOVAB -32(R0), R1 ;-32(R0), R1 ; INSV R1, #6, #6, R4 ;R1, #6, #6, CHKSUM ; PUSHL R9 ;R9 ; 4788 CALLS #1, (R10) ;#1, TT_TEXT ; MOVZBL (R2), -(SP) ;(TEMP_POINTER), -(SP) ; 4789 CALLS #1, (R11) ;#1, TT_CHAR ; PUSHL #34 ;#34 ; 4790 CALLS #1, (R11) ;#1, TT_CHAR ; MOVZBL (R2), R0 ;(TEMP_POINTER), R0 ; 4791 SUBL2 #32, R0 ;#32, R0 ; INSV R0, #0, #6, R4 ;R0, #0, #6, CHKSUM ; 20$: PUSHAB -20(R9) ;CHKSUM_NUM_TEXT ; 4795 CALLS #1, (R10) ;#1, TT_TEXT ; PUSHL R4 ;CHKSUM ; 4796 CALLS #1, W^TT_NUMBER ;#1, TT_NUMBER ; PUSHAB -56(R9) ;DEC_TEXT ; 4797 CALLS #1, (R10) ;#1, TT_TEXT ; CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 4798 PUSHL R8 ;OLD_RTN ; 4799 CALLS #1, W^TT_SET_OUTPUT ;#1, TT_SET_OUTPUT ; RET ; ; 4579 ; Routine Size: 504 bytes, Routine Base: $CODE$ + 15A0 ; 4801 ; 4802 %SBTTL 'End of KERMSG' ; 4803 END ; 4804 ; 4805 ELUDOM ; PSECT SUMMARY ; ; Name Bytes Attributes ; ; $GLOBAL$ 436 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $OWN$ 352 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $CODE$ 6040 NOVEC,NOWRT, RD , EXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; . ABS . 0 NOVEC,NOWRT,NORD ,NOEXE,NOSHR, LCL, ABS, CON,NOPIC,ALIGN(0) ; $PLIT$ 436 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 KERMSG/LIST=KERMSG.MAR/MACHINE_CODE=(ASSEM,NOBINARY,UNIQUE)/NOOBJECT/SOURCE=NOHEADER ; Compilation Complete .END