; 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) ; U 0397 %THEN ; U 0398 ; U 0399 LIBRARY 'SYS$LIBRARY:STARLET'; ; U 0400 ; 0401 %FI ; 0402 ; 0403 REQUIRE 'KERCOM'; ; 0573 ; 0574 REQUIRE 'KERERR'; ; 0597 ; 0598 %SBTTL 'Macro definitions' ; 0599 ! ; 0600 ! MACROS: ; 0601 ! ; 0602 ; 0603 MACRO ; M 0604 CTL (C) = ; 0605 ((C) XOR %O'100')%, ; M 0606 CHAR (C) = ; 0607 ((C) + %O'40')%, ; M 0608 UNCHAR (C) = ; 0609 ((C) - %O'40')%; ; 0610 ; 0611 %SBTTL 'KERMIT Protocol Definitions' ; 0612 ; 0613 !++ ; 0614 ! The following describes the various items that are found in the ; 0615 ! KERMIT messages. A complete and through desription of the protocol can be ; 0616 ! found in the KERMIT PROTOCOL MANUAL. ; 0617 ! ; 0618 ! ; 0619 ! All KERMIT messages have the following format: ; 0620 ! ; 0621 ! ; 0622 ! ; 0623 ! ; 0624 ! Normally SOH (Control-A, octal 001). ; 0625 ! ; 0626 ! ; 0627 ! Count of the number of characters following this position. ; 0628 ! Character counts of ONLY 0 to 94 are valid. ; 0629 ! ; 0630 ! ; 0631 ! Packet sequence number, modulo 100 (octal). ; 0632 ! ; 0633 ! ; 0634 ! This field contains the message dependent information. There can ; 0635 ! be multiple fields in this section. See the KERMIT Protocol document ; 0636 ! for a complete description of this. ; 0637 ! ; 0638 ! ; 0639 ! A block check on the characters in the packet between, but not ; 0640 ! including, the mark and the checksum itself. It may be one to three ; 0641 ! characters, depending upon the type agreed upon. ; 0642 ! ; 0643 ! 1. Single character arithmetic sum equal to: ; 0644 ! chksum = (s + ((s AND 300)/100)) AND 77 ; 0645 ! Character sent is CHAR(chksum). ; 0646 ! ; 0647 ! 2. Two character arithmetic sum. CHAR of bits 6-11 are the first ; 0648 ! character, CHAR of bits 0-5 are the second character. ; 0649 ! ; 0650 ! 3. Three character CRC-CCITT. First character is CHAR of bits 12-15, ; 0651 ! second is CHAR of bits 6-11, third is CHAR of bits 0-5. ; 0652 ! ; 0653 ! ; 0654 ! ; 0655 ! End of line. Any line terminator that may be required by the host. ; 0656 !-- ; 0657 ; 0658 %SBTTL 'KERMIT Protocol Definitions -- Packet offsets' ; 0659 ; 0660 !++ ; 0661 ! The following define the various offsets of the standard KERMIT ; 0662 ! packets. ; 0663 !-- ; 0664 ; 0665 LITERAL ; 0666 PKT%MARK = 0, ! ; 0667 PKT%COUNT = 1, ! ; 0668 PKT%SEQ = 2, ! ; 0669 PKT%TYPE = 3, ! ; 0670 PKT%MSG = 4, ! ; 0671 PKT%MAX%MSG = 94 - 5, ! Maximum size of the message dependent ; 0672 ! information ; 0673 PKT%CHKSUM = 0, ! offset from end of ; 0674 ! Message dependent information ; 0675 PKT%EOL = 1, ! offset from end of data ; 0676 PKT%OVR%HEAD%B = 2, ! Header overhead ; 0677 PKT%OVR%HEAD%E = 1, ! Overhead at the end ; 0678 PKT%OVR%HEAD = 3, ! Overhead added to data length ; 0679 PKT%TOT%OVR%HEAD = 6; ! Total overhead of the message ; 0680 ; 0681 %SBTTL 'KERMIT Protocol Definitions -- Message dependent field' ; 0682 ; 0683 !++ ; 0684 ! The MESSAGE-DEPENDENT information field of the message contains at ; 0685 ! least one part. That is the type of message. The remainder of the message ; 0686 ! MESSAGE-DEPENDENT field is different depending on the message. ; 0687 ! ; 0688 ! ; 0689 ! ; 0690 ! ; 0691 ! The type defines the type of message that is being processed. ; 0692 ! ; 0693 !-- ; 0694 ; 0695 ! Protocol version 1.0 message types ; 0696 ; 0697 LITERAL ; 0698 MSG%DATA = %C'D', ! Data packet ; 0699 MSG%ACK = %C'Y', ! Acknowledgement ; 0700 MSG%NAK = %C'N', ! Negative acknowledgement ; 0701 MSG%SND%INIT = %C'S', ! Send initiate ; 0702 MSG%BREAK = %C'B', ! Break transmission ; 0703 MSG%FILE = %C'F', ! File header ; 0704 MSG%EOF = %C'Z', ! End of file (EOF) ; 0705 MSG%ERROR = %C'E'; ! Error ; 0706 ; 0707 ! Protocol version 2.0 message types ; 0708 ; 0709 LITERAL ; 0710 MSG%RCV%INIT = %C'R', ! Receive initiate ; 0711 MSG%COMMAND = %C'C', ! Host command ; 0712 MSG%KERMIT = %C'G'; ! Generic KERMIT command. ; 0713 ; 0714 ! Protocol version 4.0 message types ; 0715 ; 0716 LITERAL ; 0717 MSG%SER%INIT = %C'I'; ! Server initialization ; 0718 ; 0719 !++ ; 0720 ! Generic KERMIT commands ; 0721 !-- ; 0722 ; 0723 LITERAL ; 0724 MSG%GEN%LOGIN = %C'I', ! Login ; 0725 MSG%GEN%EXIT = %C'F', ! Finish (exit to OS) ; 0726 MSG%GEN%CONNECT = %C'C', ! Connect to a directory ; 0727 MSG%GEN%LOGOUT = %C'L', ! Logout ; 0728 MSG%GEN%DIRECTORY = %C'D', ! Directory ; 0729 MSG%GEN%DISK%USAGE = %C'U', ! Disk usage ; 0730 MSG%GEN%DELETE = %C'E', ! Delete a file ; 0731 MSG%GEN%TYPE = %C'T', ! Type a file specification ; 0732 MSG%GEN%SUBMIT = %C'S', ! Submit ; 0733 MSG%GEN%PRINT = %C'P', ! Print ; 0734 MSG%GEN%WHO = %C'W', ! Who's logged in ; 0735 MSG%GEN%SEND = %C'M', ! Send a message to a user ; 0736 MSG%GEN%HELP = %C'H', ! Help ; 0737 MSG%GEN%QUERY = %C'Q'; ! Query status ; 0738 ; 0739 ! ; 0740 ! Acknowledgement modifiers (protocol 4.0?) ; 0741 ! ; 0742 ; 0743 LITERAL ; 0744 MSG%ACK%ABT%CUR = %C'X', ! Abort current file ; 0745 MSG%ACK%ABT%ALL = %C'Z'; ! Abort entire stream of files ; 0746 ; 0747 ! ; 0748 ! End of file packet modifier ; 0749 ! ; 0750 ; 0751 LITERAL ; 0752 MSG%EOF%DISCARD = %C'D'; ! Discard data from previous file ; 0753 ; 0754 %SBTTL 'KERMIT Protocol Definitions -- SEND initiate packet' ; 0755 ; 0756 !++ ; 0757 ! ; 0758 ! The following describes the send initiate packet. All fields in the message ; 0759 ! data area are optional. ; 0760 ! ; 0761 ! <"S"> ; 0762 ! <8-bit-quote> ; 0763 ! ; 0764 ! BUFSIZ ; 0765 ! Sending Kermit's maximum buffer size. ; 0766 ! ; 0767 ! Timeout ; 0768 ! Number of seconds after which the sending Kermit wishes to be timed out ; 0769 ! ; 0770 ! Npad ; 0771 ! Number of padding caracters the sending Kermit needs preceding each ; 0772 ! packet. ; 0773 ! ; 0774 ! PAD ; 0775 ! Padding character. ; 0776 ! ; 0777 ! EOL ; 0778 ! A line terminator required on all packets set by the receiving ; 0779 ! Kermit. ; 0780 ! ; 0781 ! Quote ; 0782 ! The printable ASCII characer the sending Kermit will use when quoting ; 0783 ! the control cahracters. Default is "#". ; 0784 ! ; 0785 ! 8-bit-quote ; 0786 ! Specify quoting mecanism for 8-bit quantities. A quoting mecanism is ; 0787 ! mecessary when sending to hosts which prevent the use of the 8th bit ; 0788 ! for data. When elected, the quoting mechanism will be used by both ; 0789 ! hosts, and the quote character must be in the range of 41-76 or 140-176 ; 0790 ! octal, but different from the control-quoting character. This field is ; 0791 ! interpreted as follows: ; 0792 ! ; 0793 ! "Y" - I agree to 8-bit quoting if you request it. ; 0794 ! "N" - I will not do 8-bit quoting. ; 0795 ! "&" - (or any other character in the range of 41-76 or 140-176) I want ; 0796 ! to do 8-bit quoting using this character (it will be done if the ; 0797 ! other Kermit puts a "Y" in this field. ; 0798 ! Anything else: Quoting will not be done. ; 0799 ! ; 0800 ! Check-type ; 0801 ! Type of block check. The only values presently allowed in this ; 0802 ! field are "1", "2" or "3". Future implementations may allow other ; 0803 ! values. Interpretation of the values is: ; 0804 ! ; 0805 ! "1" - Single character checksum. Default value if none specified. ; 0806 ! "2" - Double character checksum. ; 0807 ! "3" - Three character CRC. ; 0808 ! ; 0809 ! Repeat-count-processing ; 0810 ! The prefix character to be used to indicate a repeated character. ; 0811 ! This can be any printable cahracter other than blank (which denotes ; 0812 ! no repeat count). ; 0813 ! ; 0814 ! Fields 10 to 11 reserved. ; 0815 !-- ; 0816 ; 0817 LITERAL ; 0818 P%SI%BUFSIZ = 0, ! Buffersize ; 0819 MY%PKT%SIZE = 80, ! My packet size ; 0820 P%SI%TIMOUT = 1, ! Time out ; 0821 MY%TIME%OUT = 15, ! My time out ; 0822 P%SI%NPAD = 2, ! Number of padding characters ; 0823 MY%NPAD = 0, ! Amount of padding I require ; 0824 P%SI%PAD = 3, ! Padding character ; 0825 MY%PAD%CHAR = 0, ! My pad character ; 0826 P%SI%EOL = 4, ! End of line character ; 0827 MY%EOL%CHAR = %O'015', ! My EOL cahracter ; 0828 P%SI%QUOTE = 5, ! Quote character ; 0829 MY%QUOTE%CHAR = %C'#', ! My quoting character ; 0830 P%SI%8QUOTE = 6, ! 8-bit quote ; 0831 MY%8BIT%QUOTE = %C'&', ! Don't do it ; 0832 P%SI%CHKTYPE = 7, ! Checktype used ; 0833 MY%CHKTYPE = CHK%1CHAR, ! Use single character checksum ; 0834 P%SI%REPEAT = 8, ! Repeat character ; 0835 MY%REPEAT = %C'~', ! My repeat character ; 0836 P%SI%LENGTH = 9; ! Length of the message ; 0837 ; 0838 %SBTTL 'KERMIT Protocol States' ; 0839 ; 0840 !++ ; 0841 ! The following are the various states that KERMIT can be in. ; 0842 ! The state transitions are defined in the KERMIT Protocol manual. ; 0843 !-- ; 0844 ; 0845 LITERAL ; 0846 STATE%MIN = 0, ! Min state number ; 0847 STATE%START = 0, ! Start state ; 0848 STATE%S = 1, ! Send init state ; 0849 STATE%SF = 2, ! Send file header ; 0850 STATE%SD = 3, ! Send file data packet ; 0851 STATE%SZ = 4, ! Send EOF packet ; 0852 STATE%SB = 5, ! Send break ; 0853 STATE%R = 6, ! Receive state (wait for send-init) ; 0854 STATE%RF = 7, ! Receive file header packet ; 0855 STATE%RD = 8, ! Receive file data packet ; 0856 STATE%C = 9, ! Send complete ; 0857 STATE%A = 10, ! Abort ; 0858 STATE%MAX = 10; ! Max state number ; 0859 ; 0860 %SBTTL 'Internal constants' ; 0861 ; 0862 !++ ; 0863 ! The following represent various internal KERMSG constants. ; 0864 !-- ; 0865 ; 0866 LITERAL ; 0867 MAX%PKT%RETRIES = 16, ! Maximum packet retries ; 0868 MAX%SI%RETRIES = 5; ! Maximum send init retries ; 0869 ; 0870 %SBTTL 'Storage - Global' ; 0871 ! ; 0872 ! OWN STORAGE: ; 0873 ! ; 0874 ; 0875 GLOBAL ; 0876 ! ; 0877 ! Receive parameters ; 0878 ! ; 0879 RCV%PKT%SIZE, ! Receive packet size ; 0880 RCV%NPAD, ! Padding length ; 0881 RCV%PADCHAR, ! Padding character ; 0882 RCV%TIMEOUT, ! Time out ; 0883 RCV%EOL, ! EOL character ; 0884 RCV%QUOTE%CHR, ! Quote character ; 0885 RCV%SOH, ! Start of header character ; 0886 RCV%8QUOTE%CHR, ! 8-bit quoting character ; 0887 ! ; 0888 ! Miscellaneous parameters ; 0889 ! ; 0890 SET%REPT%CHR, ! Repeat character ; 0891 ! ; 0892 ! Send parameters ; 0893 ! ; 0894 SND%PKT%SIZE, ! Send packet size ; 0895 SND%NPAD, ! Padding length ; 0896 SND%PADCHAR, ! Padding character ; 0897 SND%TIMEOUT, ! Time out ; 0898 SND%EOL, ! EOL character ; 0899 SND%QUOTE%CHR, ! Quote character ; 0900 SND%SOH, ! Start of header character ; 0901 ! ; 0902 ! Statistics ; 0903 ! ; 0904 SND%TOTAL%CHARS, ! Total characters sent ; 0905 RCV%TOTAL%CHARS, ! Total characters received ; 0906 SND%DATA%CHARS, ! Total number of data characters sent ; 0907 RCV%DATA%CHARS, ! Total number of data characters received ; 0908 SND%NAKS, ! Total NAKs sent ; 0909 RCV%NAKS, ! Total NAKs received ; 0910 SND%COUNT, ! Total number of packets sent ; 0911 RCV%COUNT, ! Total number of packets received ; 0912 SMSG%TOTAL%CHARS, ! Total chars sent this file xfer ; 0913 RMSG%TOTAL%CHARS, ! Total chars rcvd this file xfer ; 0914 SMSG%DATA%CHARS, ! Total data chars this file xfer ; 0915 RMSG%DATA%CHARS, ! Total data chars this file xfer ; 0916 SMSG%NAKS, ! Total number of NAKs this file xfer ; 0917 RMSG%NAKS, ! Total number of NAKs received ; 0918 XFR%TIME, ! Amount of time last xfr took ; 0919 TOTAL%TIME, ! Total time of all xfrs ; 0920 ! this file xfer ; 0921 LAST%ERROR : VECTOR [CH$ALLOCATION (MAX%MSG + 1)], ! Last error message ; 0922 ! ; 0923 ! Misc constants. ; 0924 ! ; 0925 FILE%NAME : VECTOR [CH$ALLOCATION (MAX%FILE%NAME)], ; 0926 FILE%SIZE, ; 0927 SI%RETRIES, ! Send init retries to attempt ; 0928 PKT%RETRIES, ! Number of retries to try for a message ; 0929 DELAY, ! Amount of time to delay ; 0930 DUPLEX, ! Type of connection (half or full) ; 0931 PARITY%TYPE, ! Type of parity to use ; 0932 DEV%PARITY%FLAG, ! True if output device does ; 0933 ! parity, false if we do it ; 0934 CHKTYPE, ! Type of block check desired ; 0935 ABT%FLAG, ! True if aborted file should be discarded ; 0936 DEBUG%FLAG, ! Debugging mode on/off ; 0937 WARN%FLAG, ! File warning flag ; 0938 IBM%FLAG, ! Talking to an IBM system ; 0939 IBM%CHAR, ! Turnaround character for IBM mode ; 0940 ECHO%FLAG, ! Local echo flag ; 0941 CONNECT%FLAG, ! Connected flag; True if ; 0942 ! terminal and SET LINE are ; 0943 ! the same ; 0944 ABT%CUR%FILE, ! Abort current file ; 0945 ABT%ALL%FILE, ! Abort all files in stream ; 0946 TY%FIL, ! Type file specs ; 0947 TY%PKT; ! Type packet info ; 0948 ; 0949 %SBTTL 'Storage - Local' ; 0950 ! ; 0951 ! LOCAL OWN STORAGE: ; 0952 ! ; 0953 ; 0954 OWN ; 0955 ! ; 0956 ! Receive parameters ; 0957 ! ; 0958 RECV%8QUOTE%CHR, ! 8th-bit quoting character ; 0959 REPT%CHR, ! Repeat prefix character ; 0960 ! ; 0961 ! Send parameters ; 0962 ! ; 0963 SEND%PKT%SIZE, ! Send packet size ; 0964 SEND%NPAD, ! Padding length ; 0965 SEND%PADCHAR, ! Padding character ; 0966 SEND%TIMEOUT, ! Time out ; 0967 SEND%EOL, ! EOL character ; 0968 SEND%QUOTE%CHR, ! Quote character ; 0969 SEND%8QUOTE%CHR, ! 8-bit quoting character ; 0970 ! ; 0971 ! Misc parameters ; 0972 ! ; 0973 INI%CHK%TYPE, ! Type of block checking from init message ; 0974 BLK%CHK%TYPE, ! Type of block check to use ; 0975 FLAG%8QUOTE, ! Flag to determine if doing 8bit quoting ; 0976 FLAG%REPEAT, ! True if doing repeated character compression ; 0977 STATUS, ! Status returned by various routines ; 0978 STATE, ! Current state ; 0979 SIZE, ! Size of the current message ; 0980 OLD%RETRIES, ! Saved number of retries done. ; 0981 NUM%RETRIES, ! Number of retries ; 0982 MSG%NUMBER, ! Current message number ; 0983 REC%SEQ, ! Sequence number of msg in REC%MSG ; 0984 REC%LENGTH, ! Length of the message recv'd ; 0985 REC%TYPE, ! Type of the message received. ; 0986 REC%MSG : VECTOR [CH$ALLOCATION (MAX%MSG, CHR%SIZE)], ! Message received ; 0987 SND%MSG : VECTOR [CH$ALLOCATION (MAX%MSG, CHR%SIZE)], ! Message sent ; 0988 FILE%OPEN%FLAG; ! File is opened. ; 0989 ; 0990 %SBTTL 'External references' ; 0991 ! ; 0992 ! EXTERNAL REFERENCES: ; 0993 ! ; 0994 ! Packet I/O routines ; 0995 ; 0996 EXTERNAL ROUTINE ; 0997 SEND, ! Send a packet to the remote ; 0998 IBM%WAIT, ! Wait for IBM turnaround ; 0999 RECEIVE; ! Receive a packet from the remote ; 1000 ; 1001 ! ; 1002 ! Terminal I/O routines ; 1003 ! ; 1004 ; 1005 EXTERNAL ROUTINE ; 1006 TERM%DUMP : NOVALUE, ! Normal terminal output ; 1007 DBG%DUMP : NOVALUE, ! Debugging output ; 1008 TT%SET%OUTPUT, ! Set output routine ; 1009 TT%CHAR : NOVALUE, ! Output a single character ; 1010 TT%CRLF : NOVALUE, ! Output a CRLF ; 1011 TT%NUMBER : NOVALUE, ! Output a three digit number to the ; 1012 ! terminal ; 1013 TT%TEXT : NOVALUE, ! Output a string to the user's ; 1014 TT%OUTPUT : NOVALUE; ! Force buffered output to terminal ; 1015 ; 1016 ! Operating system routines and misc routines ; 1017 ; 1018 EXTERNAL ROUTINE ; 1019 CRCCLC, ! Calculate a CRC-CCITT ; 1020 XFR%STATUS : NOVALUE, ! Routine to tell the user the ; 1021 ! status of a transfer ; 1022 KRM%ERROR : NOVALUE, ! Issue an error message ; 1023 SY%LOGOUT : NOVALUE, ! Log the job off ; 1024 SY%TIME, ! Return elapsed time in milliseconds ; 1025 SY%DISMISS : NOVALUE; ! Routine to dismiss for n seconds. ; 1026 ; 1027 ! ; 1028 ! External file processing routines ; 1029 ! ; 1030 ; 1031 EXTERNAL ROUTINE ; 1032 FILE%OPEN, ! Open a file for reading/writing ; 1033 FILE%CLOSE, ! Close an open file ; 1034 NEXT%FILE, ! Determine if there is a next file ; 1035 ! and open it for reading. ; 1036 GET%FILE, ! Get a byte from the file ; 1037 PUT%FILE, ! Put a byte in the file. ; 1038 FILE%DUMP; ! Dump the contents of the current ; 1039 ; 1040 ! record. Used for binary files ; 1041 ! if needed. ; 1042 %SBTTL 'MSG%INIT' ; 1043 ; 1044 GLOBAL ROUTINE MSG%INIT : NOVALUE = ; 1045 ; 1046 !++ ; 1047 ! FUNCTIONAL DESCRIPTION: ; 1048 ! ; 1049 ! This routine will initialize the message processing for ; 1050 ! KERMIT-32/36. ; 1051 ! ; 1052 ! CALLING SEQUENCE: ; 1053 ! ; 1054 ! MSG%INIT(); ; 1055 ! ; 1056 ! INPUT PARAMETERS: ; 1057 ! ; 1058 ! None. ; 1059 ! ; 1060 ! IMPLICIT INPUTS: ; 1061 ! ; 1062 ! None. ; 1063 ! ; 1064 ! OUTPUT PARAMETERS: ; 1065 ! ; 1066 ! None. ; 1067 ! ; 1068 ! IMPLICIT OUTPUTS: ; 1069 ! ; 1070 ! None. ; 1071 ! ; 1072 ! COMPLETION CODES: ; 1073 ! ; 1074 ! None. ; 1075 ! ; 1076 ! SIDE EFFECTS: ; 1077 ! ; 1078 ! None. ; 1079 ! ; 1080 !-- ; 1081 ; 1082 BEGIN ; 1083 ! ; 1084 ! Initialize some variables ; 1085 ! ; 1086 ! Receive parameters first ; 1087 ! ; 1088 RCV%PKT%SIZE = MY%PKT%SIZE; ; 1089 RCV%NPAD = MY%NPAD; ; 1090 RCV%PADCHAR = MY%PAD%CHAR; ; 1091 RCV%TIMEOUT = MY%TIME%OUT; ; 1092 RCV%EOL = MY%EOL%CHAR; ; 1093 RCV%QUOTE%CHR = MY%QUOTE%CHAR; ; 1094 RCV%SOH = CHR%SOH; ; 1095 RCV%8QUOTE%CHR = MY%8BIT%QUOTE; ; 1096 SET%REPT%CHR = MY%REPEAT; ; 1097 ! ; 1098 ! Send parameters. ; 1099 ! ; 1100 SND%PKT%SIZE = -MY%PKT%SIZE; ; 1101 SND%NPAD = -MY%NPAD; ; 1102 SND%PADCHAR = -MY%PAD%CHAR; ; 1103 SND%TIMEOUT = -MY%TIME%OUT; ; 1104 SND%EOL = -MY%EOL%CHAR; ; 1105 SND%QUOTE%CHR = -MY%QUOTE%CHAR; ; 1106 SND%SOH = CHR%SOH; ; 1107 ! ; 1108 ! Other random parameters ; 1109 ! ; 1110 PKT%RETRIES = MAX%PKT%RETRIES; ! Number of retries per message ; 1111 SI%RETRIES = MAX%SI%RETRIES; ! Number of retries on send inits ; 1112 DELAY = INIT%DELAY; ; 1113 DUPLEX = DP%FULL; ! Use full duplex ; 1114 DEBUG%FLAG = FALSE; ; 1115 WARN%FLAG = FALSE; ; 1116 ECHO%FLAG = FALSE; ; 1117 BLK%CHK%TYPE = CHK%1CHAR; ! Start using single char checksum ; 1118 CHKTYPE = MY%CHKTYPE; ! Desired block check type ; 1119 INI%CHK%TYPE = .CHKTYPE; ! Same as default for now ; 1120 DEV%PARITY%FLAG = FALSE; ! We generate parity ; 1121 PARITY%TYPE = PR%NONE; ! No parity ; 1122 ABT%FLAG = TRUE; ! Discard incomplete files ; 1123 FILE%OPEN%FLAG = FALSE; ; 1124 IBM%FLAG = FALSE; ! Not talking to an IBM ; 1125 IBM%CHAR = CHR%DC1; ! XON is IBM turnaround character ; 1126 TY%FIL = TRUE; ! Default to typing files ; 1127 TY%PKT = FALSE; ! But not packet numbers ; 1128 END; ! End of MSG%INIT TITLE KERMSG TWOSEG .REQUEST DSKB:B361LB.REL[1,4] RELOC 0 RCV%PKT%SIZE:: BLOCK 1 RCV%NPAD:: BLOCK 1 RCV%PADCHAR:: BLOCK 1 RCV%TIMEOUT:: BLOCK 1 RCV%EOL:: BLOCK 1 RCV%QUOTE%CHR:: BLOCK 1 RCV%SOH:: BLOCK 1 RCV%8QUOTE%CHR:: BLOCK 1 SET%REPT%CHR:: BLOCK 1 SND%PKT%SIZE:: BLOCK 1 SND%NPAD:: BLOCK 1 SND%PADCHAR:: BLOCK 1 SND%TIMEOUT:: BLOCK 1 SND%EOL:: BLOCK 1 SND%QUOTE%CHR:: BLOCK 1 SND%SOH:: BLOCK 1 SND%TOTAL%CHARS:: BLOCK 1 RCV%TOTAL%CHARS:: BLOCK 1 SND%DATA%CHARS:: BLOCK 1 RCV%DATA%CHARS:: BLOCK 1 SND%NAKS:: BLOCK 1 RCV%NAKS:: BLOCK 1 SND%COUNT:: BLOCK 1 RCV%COUNT:: BLOCK 1 SMSG%TOTAL%CHARS:: BLOCK 1 RMSG%TOTAL%CHARS:: BLOCK 1 SMSG%DATA%CHARS:: BLOCK 1 RMSG%DATA%CHARS:: BLOCK 1 SMSG%NAKS:: BLOCK 1 RMSG%NAKS:: BLOCK 1 XFR%TIME:: BLOCK 1 TOTAL%TIME:: BLOCK 1 LAST%ERROR:: BLOCK 24 FILE%NAME:: BLOCK 33 FILE%SIZE:: BLOCK 1 SI%RETRIES:: BLOCK 1 PKT%RETRIES:: BLOCK 1 DELAY:: BLOCK 1 DUPLEX::BLOCK 1 PARITY%TYPE:: BLOCK 1 DEV%PARITY%FLAG:: BLOCK 1 CHKTYPE:: BLOCK 1 ABT%FLAG:: BLOCK 1 DEBUG%FLAG:: BLOCK 1 WARN%FLAG:: BLOCK 1 IBM%FLAG:: BLOCK 1 IBM%CHAR:: BLOCK 1 ECHO%FLAG:: BLOCK 1 CONNECT%FLAG:: BLOCK 1 ABT%CUR%FILE:: BLOCK 1 ABT%ALL%FILE:: BLOCK 1 TY%FIL::BLOCK 1 TY%PKT::BLOCK 1 ; RECV%8QUOTE%CHR U.84: BLOCK 1 ; REPT%CHR U.85: BLOCK 1 ; SEND%PKT%SIZE U.86: BLOCK 1 ; SEND%NPAD U.87: BLOCK 1 ; SEND%PADCHAR U.88: BLOCK 1 ; SEND%TIMEOUT U.89: BLOCK 1 ; SEND%EOL U.90: BLOCK 1 ; SEND%QUOTE%CHR U.91: BLOCK 1 ; SEND%8QUOTE%CHR U.92: BLOCK 1 ; INI%CHK%TYPE U.93: BLOCK 1 ; BLK%CHK%TYPE U.94: BLOCK 1 ; FLAG%8QUOTE U.95: BLOCK 1 ; FLAG%REPEAT U.96: BLOCK 1 ; STATUS U.97: BLOCK 1 ; STATE U.98: BLOCK 1 ; SIZE U.99: BLOCK 1 ; OLD%RETRIES U.100: BLOCK 1 ; NUM%RETRIES U.101: BLOCK 1 ; MSG%NUMBER U.102: BLOCK 1 ; REC%SEQ U.103: BLOCK 1 ; REC%LENGTH U.104: BLOCK 1 ; REC%TYPE U.105: BLOCK 1 ; REC%MSG U.106: BLOCK 30 ; SND%MSG U.107: BLOCK 30 ; FILE%OPEN%FLAG U.108: BLOCK 1 EXTERN SEND, IBM%WAIT, RECEIVE, TERM%DUMP, DBG%DUMP, TT%SET%OUTPUT, TT%CHAR, TT%CRLF, TT%NUMBER EXTERN TT%TEXT, TT%OUTPUT, CRCCLC, XFR%STATUS, KRM%ERROR, SY%LOGOUT, SY%TIME, SY%DISMISS EXTERN FILE%OPEN, FILE%CLOSE, NEXT%FILE, GET%FILE, PUT%FILE, FILE%DUMP 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==: 61 CHK%2CHAR==: 62 CHK%CRC==: 63 MAX%MSG==: 140 AC0= 0 AC1= 1 AC2= 2 AC3= 3 AC4= 4 AC5= 5 AC6= 6 AC7= 7 AC10= 10 AC11= 11 AC12= 12 AC13= 13 AC14= 14 FP= 15 AC16= 16 SP= 17 RELOC 400000 MSG%INIT:: MOVEI AC1,120 ; 1088 MOVEM AC1,RCV%PKT%SIZE SETZM RCV%NPAD ; 1089 SETZM RCV%PADCHAR ; 1090 MOVEI AC1,17 ; 1091 MOVEM AC1,RCV%TIMEOUT MOVEI AC1,15 ; 1092 MOVEM AC1,RCV%EOL MOVEI AC1,43 ; 1093 MOVEM AC1,RCV%QUOTE%CHR MOVEI AC1,1 ; 1094 MOVEM AC1,RCV%SOH MOVEI AC1,46 ; 1095 MOVEM AC1,RCV%8QUOTE%CHR MOVEI AC1,176 ; 1096 MOVEM AC1,SET%REPT%CHR HRROI AC1,-120 ; 1100 MOVEM AC1,SND%PKT%SIZE SETZM SND%NPAD ; 1101 SETZM SND%PADCHAR ; 1102 HRROI AC1,-17 ; 1103 MOVEM AC1,SND%TIMEOUT HRROI AC1,-15 ; 1104 MOVEM AC1,SND%EOL HRROI AC1,-43 ; 1105 MOVEM AC1,SND%QUOTE%CHR MOVEI AC1,1 ; 1106 MOVEM AC1,SND%SOH MOVEI AC1,20 ; 1110 MOVEM AC1,PKT%RETRIES MOVEI AC1,5 ; 1111 MOVEM AC1,SI%RETRIES MOVEI AC1,5 ; 1112 MOVEM AC1,DELAY SETZM DUPLEX ; 1113 SETZM DEBUG%FLAG ; 1114 SETZM WARN%FLAG ; 1115 SETZM ECHO%FLAG ; 1116 MOVEI AC1,61 ; 1117 MOVEM AC1,U.94 MOVEI AC1,61 ; 1118 MOVEM AC1,CHKTYPE MOVEM AC1,U.93 ; 1119 SETZM DEV%PARITY%FLAG ; 1120 SETZM PARITY%TYPE ; 1121 MOVEI AC1,1 ; 1122 MOVEM AC1,ABT%FLAG SETZM U.108 ; 1123 SETZM IBM%FLAG ; 1124 MOVEI AC1,21 ; 1125 MOVEM AC1,IBM%CHAR MOVEI AC1,1 ; 1126 MOVEM AC1,TY%FIL SETZM TY%PKT ; 1127 POPJ SP, ; 1044 ; Routine Size: 55 words ; 1129 ; 1130 %SBTTL 'SERVER - Server mode' ; 1131 ; 1132 GLOBAL ROUTINE SERVER = ; 1133 ; 1134 !++ ; 1135 ! FUNCTIONAL DESCRIPTION: ; 1136 ! ; 1137 ! This routine will handle the server function in the v2.0 protocol ; 1138 ! for KERMIT. This routine by it's nature will call various operating ; 1139 ! system routines to do things like logging off the system. ; 1140 ! ; 1141 ! CALLING SEQUENCE: ; 1142 ! ; 1143 ! EXIT%FLAG = SERVER(); ; 1144 ! ; 1145 ! INPUT PARAMETERS: ; 1146 ! ; 1147 ! None. ; 1148 ! ; 1149 ! IMPLICIT INPUTS: ; 1150 ! ; 1151 ! None. ; 1152 ! ; 1153 ! OUTPUT PARAMETERS: ; 1154 ! ; 1155 ! None. ; 1156 ! ; 1157 ! IMPLICIT OUTPUTS: ; 1158 ! ; 1159 ! None. ; 1160 ! ; 1161 ! COMPLETION CODES: ; 1162 ! ; 1163 ! None. ; 1164 ! ; 1165 ! SIDE EFFECTS: ; 1166 ! ; 1167 ! None. ; 1168 ! ; 1169 !-- ; 1170 ; 1171 BEGIN ; 1172 RETURN ; 1173 ; 1174 WHILE TRUE DO ; 1175 BEGIN ; 1176 INIT%XFR (); ! Set up so we can send a message ; 1177 STATUS = REC%PACKET (); ; 1178 ! ; 1179 ! Now determine what to do by the type of message we have receive. ; 1180 ! ; 1181 ; 1182 IF .STATUS EQL KER%ABORTED THEN EXITLOOP .STATUS; ; 1183 ; 1184 IF .STATUS ; 1185 THEN ; 1186 BEGIN ; 1187 ; 1188 SELECTONE .REC%TYPE OF ; 1189 SET ; 1190 ! ; 1191 ! Server initialization message received. ACK the ; 1192 ! message and continue. ; 1193 ! ; 1194 ! [MSG%SER%INIT] : ; 1195 ! BEGIN ; 1196 ! IF (STATUS = PRS%SEND%INIT ()) ; 1197 ! THEN ; 1198 ! BEGIN ; 1199 ! SET%SEND%INIT (); ; 1200 ! STATUS = SEND%PACKET (MSG%ACK, P%SI%LENGTH, .REC%SEQ); ; 1201 ! END; ; 1202 ! END; ; 1203 ! ; 1204 ! Send init message received. We must ACK the message and ; 1205 ! then attempt to receive a file from the remote. ; 1206 ! ; 1207 ; 1208 [MSG%SND%INIT] : ; 1209 BEGIN ; 1210 MSG%NUMBER = (.REC%SEQ + 1) AND %O'77'; ; 1211 ; 1212 IF (STATUS = PRS%SEND%INIT ()) ; 1213 THEN ; 1214 BEGIN ; 1215 SET%SEND%INIT (); ; 1216 ! ; 1217 ! ACK the message then receive everything. ; 1218 ! ; 1219 ; 1220 IF SEND%PACKET (MSG%ACK, P%SI%LENGTH, .REC%SEQ) ; 1221 THEN ; 1222 BEGIN ; 1223 STATE = STATE%RF; ; 1224 BLK%CHK%TYPE = .INI%CHK%TYPE; ; 1225 ! Switch to desired form of block check ; 1226 REC%SWITCH%WORKER (); ; 1227 END; ; 1228 ; 1229 END; ; 1230 ; 1231 END; ; 1232 ! ; 1233 ! Here if we receive a receive init message. ; 1234 ! We will be sending a file to the other end. ; 1235 ! ; 1236 ; 1237 [MSG%RCV%INIT] : ; 1238 BEGIN ; 1239 MSG%NUMBER = .REC%SEQ; ; 1240 ! ; 1241 ! Move the file specification if we received one ; 1242 ! ; 1243 ; 1244 IF .REC%LENGTH GTR 0 ; 1245 THEN ; 1246 BEGIN ; 1247 CH$COPY (.REC%LENGTH, CH$PTR (REC%MSG, PKT%MSG, CHR%SIZE), ; 1248 CHR%NUL, MAX%FILE%NAME, CH$PTR (FILE%NAME)); ; 1249 FILE%SIZE = .REC%LENGTH; ; 1250 SEND%SWITCH%WORKER (); ; 1251 END ; 1252 ELSE ; 1253 BEGIN ; 1254 KRM%ERROR (KER%PROTOERR); ; 1255 END; ; 1256 ; 1257 END; ; 1258 ! ; 1259 ! Generic KERMIT commands ; 1260 ! ; 1261 ; 1262 [MSG%KERMIT] : ; 1263 BEGIN ; 1264 STATUS = SERVER%GENERIC (); ; 1265 ; 1266 IF .STATUS EQL KER%EXIT THEN EXITLOOP KER%EXIT; ; 1267 ; 1268 END; ; 1269 ! ; 1270 ! Unimplimented server routines ; 1271 ! ; 1272 ; 1273 [OTHERWISE] : ; 1274 KRM%ERROR (KER%UNISRV); ; 1275 TES; ; 1276 ; 1277 END ; 1278 ELSE ; 1279 SEND%PACKET (MSG%NAK, 0, 0); ; 1280 ; 1281 END; ; 1282 ; 1283 END; ! End of GLOBAL ROUTINE SERVER SERVER:: L.1: PUSHJ SP,U.27 ; 1176 PUSHJ SP,U.23 ; 1177 MOVEM AC1,U.97 CAIN AC1,312 ; 1182 POPJ SP, TRNN AC1,1 ; 1184 JRST L.7 MOVE AC1,U.105 ; 1188 CAIE AC1,123 JRST L.2 MOVE AC1,U.103 ; 1210 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 PUSHJ SP,U.18 ; 1212 MOVEM AC1,U.97 TRNN AC1,1 JRST L.1 PUSHJ SP,U.17 ; 1215 PUSH SP,C.3 ; 1220 PUSH SP,C.4 PUSH SP,U.103 PUSHJ SP,U.21 ADJSP SP,-3 TRNN AC1,1 JRST L.1 MOVEI AC1,7 ; 1223 MOVEM AC1,U.98 MOVE AC1,U.93 ; 1224 MOVEM AC1,U.94 PUSHJ SP,U.10 ; 1226 JRST L.1 ; 1220 L.2: CAIE AC1,122 ; 1188 JRST L.4 MOVE AC2,U.103 ; 1239 MOVEM AC2,U.102 MOVE AC3,U.104 ; 1244 JUMPLE AC3,L.3 MOVE AC1,AC3 ; 1247 MOVE AC2,C.5 MOVEI AC4,204 MOVE AC5,C.6 EXTEND AC1,C.2 JFCL MOVEM AC3,FILE%SIZE ; 1249 PUSHJ SP,U.2 ; 1250 JRST L.1 ; 1244 L.3: PUSH SP,C.7 ; 1254 JRST L.6 L.4: CAIE AC1,107 ; 1188 JRST L.5 PUSHJ SP,U.14 ; 1264 MOVEM AC1,U.97 MOVEI AC1,223 ; 1266 CAME AC1,U.97 JRST L.1 MOVEI AC1,223 POPJ SP, L.5: PUSH SP,C.8 ; 1274 L.6: PUSHJ SP,KRM%ERROR ADJSP SP,-1 JRST L.1 ; 1184 L.7: PUSH SP,C.9 ; 1279 PUSH SP,C.10 PUSH SP,C.10 PUSHJ SP,U.21 ADJSP SP,-3 JRST L.1 ; 1174 C.1: POINT 6,AC1,35 C.2: MOVSLJ EXP 0 C.3: EXP 131 C.4: EXP 11 C.5: POINT 8,U.106,31 C.6: POINT 7,FILE%NAME-1,34 C.7: EXP 252 C.8: EXP 242 C.9: EXP 116 C.10: EXP 0 ; Routine Size: 79 words ; 1284 ; 1285 %SBTTL 'SERVER - Generic commands' ; 1286 ROUTINE SERVER%GENERIC = ; 1287 ; 1288 !++ ; 1289 ! FUNCTIONAL DESCRIPTION: ; 1290 ! ; 1291 ! This routine will handle the generic server messages. ; 1292 ! The generic server messages include FINISH, LOGOUT. ; 1293 ! ; 1294 ! CALLING SEQUENCE: ; 1295 ! ; 1296 ! SERVER%GENERIC(); ; 1297 ! ; 1298 ! INPUT PARAMETERS: ; 1299 ! ; 1300 ! None. ; 1301 ! ; 1302 ! IMPLICIT INPUTS: ; 1303 ! ; 1304 ! Generic message receive in REC%MSG. ; 1305 ! ; 1306 ! OUTPUT PARAMETERS: ; 1307 ! ; 1308 ! None. ; 1309 ! ; 1310 ! IMPLICIT OUTPUTS: ; 1311 ! ; 1312 ! None. ; 1313 ! ; 1314 ! COMPLETION CODES: ; 1315 ! ; 1316 ! None. ; 1317 ! ; 1318 ! SIDE EFFECTS: ; 1319 ! ; 1320 ! None. ; 1321 ! ; 1322 !-- ; 1323 ; 1324 BEGIN ; 1325 ; 1326 SELECTONE CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG, CHR%SIZE)) OF ; 1327 SET ; 1328 ! ; 1329 ! EXIT command, just return the status to the upper level ; 1330 ! ; 1331 ; 1332 [MSG%GEN%EXIT] : ; 1333 BEGIN ; 1334 SEND%PACKET (MSG%ACK, 0, .REC%SEQ); ; 1335 RETURN KER%EXIT; ; 1336 END; ; 1337 ! ; 1338 ! LOGOUT command, ACK the message then call the system routine to ; 1339 ! kill the process (log the job out, etc.) ; 1340 ! ; 1341 ; 1342 [MSG%GEN%LOGOUT] : ; 1343 BEGIN ; 1344 SEND%PACKET (MSG%ACK, 0, .REC%SEQ); ; 1345 SY%LOGOUT (); ; 1346 RETURN KER%NORMAL; ; 1347 END; ; 1348 ! ; 1349 ! This routine will cause files to be deleted from disk. ; 1350 ! ; 1351 ![MSG%GEN%DELETE] : ; 1352 ! BEGIN ; 1353 ! END; ; 1354 ! ; 1355 ! This routine will cause file(s) to be printed on the line printer. ; 1356 ! ; 1357 ![MSG%GEN%PRINT] : ; 1358 ! BEGIN ; 1359 ! END; ; 1360 ! ; 1361 ! Here if we have a function that is currently not implemented ; 1362 ! return a unimplmented server function error code. ; 1363 ! ; 1364 ; 1365 [OTHERWISE] : ; 1366 BEGIN ; 1367 KRM%ERROR (KER%UNIMPLGEN); ; 1368 RETURN KER%UNIMPLGEN; ; 1369 END; ; 1370 TES; ; 1371 ; 1372 END; ! End of SERVER%GENERIC ; SERVER%GENERIC U.14: MOVE AC1,C.5 ; 1326 ILDB AC1,AC1 CAIE AC1,106 JRST L.8 PUSH SP,C.3 ; 1334 PUSH SP,C.10 PUSH SP,U.103 PUSHJ SP,U.21 ADJSP SP,-2 ; 1333 MOVEI AC1,223 ; 1326 JRST L.10 L.8: CAIE AC1,114 JRST L.9 PUSH SP,C.3 ; 1344 PUSH SP,C.10 PUSH SP,U.103 PUSHJ SP,U.21 PUSHJ SP,SY%LOGOUT ; 1345 ADJSP SP,-2 ; 1343 MOVEI AC1,13 ; 1326 JRST L.10 L.9: PUSH SP,C.11 ; 1367 PUSHJ SP,KRM%ERROR MOVEI AC1,232 ; 1326 L.10: ADJSP SP,-1 ; 1286 POPJ SP, C.11: EXP 232 ; Routine Size: 27 words ; 1373 %SBTTL 'Server -- DO%GENERIC - Execute a generic command' ; 1374 ; 1375 GLOBAL ROUTINE DO%GENERIC (TYPE) = ; 1376 ; 1377 !++ ; 1378 ! FUNCTIONAL DESCRIPTION: ; 1379 ! ; 1380 ! This routine will send a generic command to the remote Kermit. ; 1381 ! it will do all the processing required for the generic command ; 1382 ! that was executed. It will return to the caller after the ; 1383 ! command has be executed. ; 1384 ! ; 1385 ! CALLING SEQUENCE: ; 1386 ! ; 1387 ! STATUS = DO%GENERIC (Command-type); ; 1388 ! ; 1389 ! INPUT PARAMETERS: ; 1390 ! ; 1391 ! Command-type -- Command type to be executed. ; 1392 ! ; 1393 ! IMPLICIT INPUTS: ; 1394 ! ; 1395 ! None. ; 1396 ! ; 1397 ! OUTPUT PARAMETERS: ; 1398 ! ; 1399 ! None. ; 1400 ! ; 1401 ! IMPLICIT OUTPUTS: ; 1402 ! ; 1403 ! None. ; 1404 ! ; 1405 ! COMPLETION CODES: ; 1406 ! ; 1407 ! None. ; 1408 ! ; 1409 ! SIDE EFFECTS: ; 1410 ! ; 1411 ! None. ; 1412 ! ; 1413 !-- ; 1414 ; 1415 BEGIN ; 1416 INIT%XFR (); ; 1417 ; 1418 CASE .TYPE FROM GC%MIN TO GC%MAX OF ; 1419 SET ; 1420 ! ; 1421 ! Here if the caller wants the remote server Kermit to exit ; 1422 ! to the operating system prompt level. We send the generic ; 1423 ! message and wait until it is ACK'd. ; 1424 ! Resend the message if we must. ; 1425 ! ; 1426 ; 1427 [GC%EXIT] : ; 1428 BEGIN ; 1429 CH$WCHAR (MSG%GEN%EXIT, CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE)); ; 1430 ; 1431 WHILE TRUE DO ; 1432 BEGIN ; 1433 ; 1434 IF NOT (STATUS = SEND%PACKET (MSG%KERMIT, 1, 0)) THEN RETURN .STATUS; ; 1435 ; 1436 IF NOT (STATUS = REC%PACKET ()) THEN RETURN .STATUS; ; 1437 ; 1438 IF .REC%TYPE EQL MSG%ACK AND .REC%SEQ EQL 0 THEN EXITLOOP; ; 1439 ; 1440 END; ; 1441 ; 1442 RETURN KER%NORMAL; ; 1443 END; ; 1444 ! ; 1445 ! Here if the caller wants the remote server to die off. ; 1446 ! Send the generic LOGOUT message and wait until it is ACK'd. ; 1447 ! Resend the message if we must. ; 1448 ! ; 1449 ; 1450 [GC%LOGOUT] : ; 1451 BEGIN ; 1452 CH$WCHAR (MSG%GEN%LOGOUT, CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE)); ; 1453 ; 1454 WHILE TRUE DO ; 1455 BEGIN ; 1456 ; 1457 IF NOT (STATUS = SEND%PACKET (MSG%KERMIT, 1, 0)) THEN RETURN .STATUS; ; 1458 ; 1459 IF NOT (STATUS = REC%PACKET ()) THEN RETURN .STATUS; ; 1460 ; 1461 IF .REC%TYPE EQL MSG%ACK AND .REC%SEQ EQL 0 THEN EXITLOOP; ; 1462 ; 1463 END; ; 1464 ; 1465 RETURN KER%NORMAL; ; 1466 END; ; 1467 ! ; 1468 ! Here if the caller wants us to send something that we currently ; 1469 ! don't support. We will return an unimplemented code to the caller. ; 1470 ! ; 1471 ; 1472 [INRANGE, OUTRANGE] : ; 1473 BEGIN ; 1474 KRM%ERROR (KER%UNIMPLGEN); ; 1475 RETURN KER%UNIMPLGEN; ; 1476 END; ; 1477 TES; ; 1478 ; 1479 END; ! End of DO%GENERIC DO%GENERIC:: PUSHJ SP,U.27 ; 1416 MOVE AC1,-1(SP) ; 1418 JUMPL AC1,L.12 ; 1415 CAIGE AC1,2 JRST L.11(AC1) JRST L.12 L.11: JRST L.15 JRST L.13 L.12: PUSH SP,C.11 ; 1474 PUSHJ SP,KRM%ERROR ADJSP SP,-1 ; 1473 MOVEI AC1,232 ; 1415 POPJ SP, L.13: MOVEI AC2,106 ; 1429 MOVE AC1,C.12 IDPB AC2,AC1 L.14: PUSH SP,C.13 ; 1434 PUSH SP,C.14 PUSH SP,C.10 PUSHJ SP,U.21 ADJSP SP,-3 MOVEM AC1,U.97 TRNN AC1,1 JRST L.17 PUSHJ SP,U.23 ; 1436 MOVEM AC1,U.97 TRNN AC1,1 JRST L.17 MOVEI AC1,131 ; 1438 CAMN AC1,U.105 SKIPE U.103 JRST L.14 JRST L.19 ; 1431 L.15: MOVEI AC2,114 ; 1452 MOVE AC1,C.12 IDPB AC2,AC1 L.16: PUSH SP,C.13 ; 1457 PUSH SP,C.14 PUSH SP,C.10 PUSHJ SP,U.21 ADJSP SP,-3 MOVEM AC1,U.97 TRNN AC1,1 JRST L.17 PUSHJ SP,U.23 ; 1459 MOVEM AC1,U.97 TRNE AC1,1 JRST L.18 L.17: MOVE AC1,U.97 POPJ SP, L.18: MOVEI AC1,131 ; 1461 CAMN AC1,U.105 SKIPE U.103 JRST L.16 L.19: MOVEI AC1,13 ; 1415 POPJ SP, ; 1375 C.12: POINT 8,U.107,31 C.13: EXP 107 C.14: EXP 1 ; Routine Size: 59 words ; 1480 ; 1481 %SBTTL 'SEND%SWITCH' ; 1482 ; 1483 GLOBAL ROUTINE SEND%SWITCH = ; 1484 ; 1485 !++ ; 1486 ! FUNCTIONAL DESCRIPTION: ; 1487 ! ; 1488 ! This routine is the state table switcher for sending files. It ; 1489 ! loops until either it is finished or an error is encountered. The ; 1490 ! routines called by SEND%SWITCH are responsible for changing the state. ; 1491 ! ; 1492 ! CALLING SEQUENCE: ; 1493 ! ; 1494 ! SEND%SWITCH(); ; 1495 ! ; 1496 ! INPUT PARAMETERS: ; 1497 ! ; 1498 ! None. ; 1499 ! ; 1500 ! IMPLICIT INPUTS: ; 1501 ! ; 1502 ! None. ; 1503 ! ; 1504 ! OUTPUT PARAMETERS: ; 1505 ! ; 1506 ! Returns: ; 1507 ! TRUE - File sent correctly. ; 1508 ! FALSE - Aborted sending the file. ; 1509 ! ; 1510 ! IMPLICIT OUTPUTS: ; 1511 ! ; 1512 ! None. ; 1513 ! ; 1514 ! COMPLETION CODES: ; 1515 ! ; 1516 ! None. ; 1517 ! ; 1518 ! SIDE EFFECTS: ; 1519 ! ; 1520 ! None. ; 1521 ! ; 1522 !-- ; 1523 ; 1524 BEGIN ; 1525 ; 1526 IF .CONNECT%FLAG THEN SY%DISMISS (.DELAY); ! Sleep if the user wanted us to ; 1527 ; 1528 RETURN SEND%SWITCH%WORKER (); ! Call routine to do real work ; 1529 END; U.1: SEND%SWITCH:: MOVEI AC1,1 ; 1526 TDNN AC1,CONNECT%FLAG JRST U.2 PUSH SP,DELAY PUSHJ SP,SY%DISMISS ADJSP SP,-1 JRST U.2 ; 1528 ; Routine Size: 7 words ; 1530 ; 1531 %SBTTL 'SEND%SWITCH%WORKER' ; 1532 ROUTINE SEND%SWITCH%WORKER = ; 1533 ; 1534 !++ ; 1535 ! FUNCTIONAL DESCRIPTION: ; 1536 ! ; 1537 ! This routine is the state table switcher for sending files. It ; 1538 ! loops until either it is finished or an error is encountered. The ; 1539 ! routines called by SEND%SWITCH%WORKER are responsible for changing ; 1540 ! the state. ; 1541 ! ; 1542 ! CALLING SEQUENCE: ; 1543 ! ; 1544 ! SEND%SWITCH%WORKER(); ; 1545 ! ; 1546 ! INPUT PARAMETERS: ; 1547 ! ; 1548 ! None. ; 1549 ! ; 1550 ! IMPLICIT INPUTS: ; 1551 ! ; 1552 ! None. ; 1553 ! ; 1554 ! OUTPUT PARAMETERS: ; 1555 ! ; 1556 ! Returns: ; 1557 ! TRUE - File sent correctly. ; 1558 ! FALSE - Aborted sending the file. ; 1559 ! ; 1560 ! IMPLICIT OUTPUTS: ; 1561 ! ; 1562 ! None. ; 1563 ! ; 1564 ! COMPLETION CODES: ; 1565 ! ; 1566 ! None. ; 1567 ! ; 1568 ! SIDE EFFECTS: ; 1569 ! ; 1570 ! None. ; 1571 ! ; 1572 !-- ; 1573 ; 1574 BEGIN ; 1575 ; 1576 LOCAL ; 1577 VAL%RETURN, ; 1578 FINISHED; ; 1579 ; 1580 INIT%XFR (); ! Initialize for this transfer ; 1581 STATE = STATE%S; ! Initial state is send ; 1582 NUM%RETRIES = 0; ! Initialize number of retries ; 1583 MSG%NUMBER = 0; ! Initial message number ; 1584 CLEAR (); ! Clear the message buffers ; 1585 FINISHED = FALSE; ; 1586 ; 1587 DO ; 1588 BEGIN ; 1589 ; 1590 CASE .STATE FROM STATE%MIN TO STATE%MAX OF ; 1591 SET ; 1592 ; 1593 [STATE%SD] : ; 1594 STATE = SEND%DATA (); ; 1595 ; 1596 [STATE%SF] : ; 1597 STATE = SEND%FILE (); ; 1598 ; 1599 [STATE%SZ] : ; 1600 STATE = SEND%EOF (); ; 1601 ; 1602 [STATE%S] : ; 1603 STATE = SEND%INIT (); ; 1604 ; 1605 [STATE%SB] : ; 1606 STATE = SEND%BREAK (); ; 1607 ; 1608 [STATE%C] : ; 1609 BEGIN ; 1610 FINISHED = TRUE; ; 1611 VAL%RETURN = TRUE; ; 1612 END; ; 1613 ; 1614 [STATE%A] : ; 1615 BEGIN ; 1616 ; 1617 IF .FILE%OPEN%FLAG ; 1618 THEN ; 1619 BEGIN ; 1620 ; 1621 IF ( NOT .CONNECT%FLAG) AND .TY%FIL ; 1622 THEN ; 1623 BEGIN ; 1624 TT%TEXT (UPLIT (%ASCIZ' [Aborted]')); ; 1625 TT%CRLF (); ! End the line ; 1626 END; ; 1627 ; 1628 FILE%CLOSE (FALSE); ; 1629 FILE%OPEN%FLAG = FALSE; ; 1630 END; ; 1631 ; 1632 FINISHED = TRUE; ; 1633 VAL%RETURN = FALSE; ; 1634 END; ; 1635 ; 1636 [INRANGE, OUTRANGE] : ; 1637 BEGIN ; 1638 FINISHED = TRUE; ; 1639 VAL%RETURN = FALSE; ; 1640 END; ; 1641 TES ; 1642 ; 1643 END ; 1644 UNTIL (.FINISHED EQL TRUE); ; 1645 ; 1646 ! ; 1647 ! Close off the stats and return ; 1648 ! ; 1649 END%STATS (); ; 1650 RETURN .VAL%RETURN; ; 1651 END; P.AAA: BYTE (7)" ","[","A","b","o" BYTE (7)"r","t","e","d","]" BYTE (7)000,000,000,000,000 ; SEND%SWITCH%WORKER U.2: PUSH SP,AC14 ; 1532 PUSH SP,AC16 PUSHJ SP,U.27 ; 1580 MOVEI AC1,1 ; 1581 MOVEM AC1,U.98 SETZM U.101 ; 1582 SETZM U.102 ; 1583 PUSHJ SP,U.26 ; 1584 SETZ AC16, ; 1585 L.20: MOVE AC1,U.98 ; 1590 JUMPL AC1,L.31 ; 1588 CAIGE AC1,13 JRST L.21(AC1) L.21: JRST L.31 JRST L.25 JRST L.23 JRST L.22 JRST L.24 JRST L.26 JRST L.31 JRST L.31 JRST L.31 JRST L.28 JRST L.29 L.22: PUSHJ SP,U.3 ; 1594 JRST L.27 L.23: PUSHJ SP,U.4 ; 1597 JRST L.27 L.24: PUSHJ SP,U.5 ; 1600 JRST L.27 L.25: PUSHJ SP,U.6 ; 1603 JRST L.27 L.26: PUSHJ SP,U.7 ; 1606 L.27: MOVEM AC1,U.98 JRST L.32 ; 1588 L.28: MOVEI AC16,1 ; 1610 MOVEI AC14,1 ; 1611 JRST L.32 ; 1588 L.29: MOVEI AC1,1 ; 1617 TDNN AC1,U.108 JRST L.31 MOVEI AC1,1 ; 1621 TDNE AC1,CONNECT%FLAG JRST L.30 MOVEI AC1,1 TDNN AC1,TY%FIL JRST L.30 PUSH SP,C.15 ; 1624 PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 1625 ADJSP SP,-1 ; 1623 L.30: PUSH SP,C.10 ; 1628 PUSHJ SP,FILE%CLOSE SETZM U.108 ; 1629 ADJSP SP,-1 ; 1619 L.31: MOVEI AC16,1 ; 1632 SETZ AC14, ; 1633 L.32: CAIE AC16,1 ; 1644 JRST L.20 ; 1587 PUSHJ SP,U.15 ; 1649 MOVE AC1,AC14 ; 1574 POP SP,AC16 ; 1532 POP SP,AC14 POPJ SP, C.15: XWD 0,P.AAA ; Routine Size: 65 words ; 1652 %SBTTL 'SEND%DATA' ; 1653 ROUTINE SEND%DATA = ; 1654 ; 1655 !++ ; 1656 ! FUNCTIONAL DESCRIPTION: ; 1657 ! ; 1658 ! This routine will send a data message to the remote KERMIT. ; 1659 ! ; 1660 ! CALLING SEQUENCE: ; 1661 ! ; 1662 ! STATE = SEND%DATA(); ; 1663 ! ; 1664 ! INPUT PARAMETERS: ; 1665 ! ; 1666 ! None. ; 1667 ! ; 1668 ! IMPLICIT INPUTS: ; 1669 ! ; 1670 ! None. ; 1671 ! ; 1672 ! OUTPUT PARAMETERS: ; 1673 ! ; 1674 ! New state to change the finite state machine to. ; 1675 ! ; 1676 ! IMPLICIT OUTPUTS: ; 1677 ! ; 1678 ! None. ; 1679 ! ; 1680 ! COMPLETION CODES: ; 1681 ! ; 1682 ! None. ; 1683 ! ; 1684 ! SIDE EFFECTS: ; 1685 ! ; 1686 ! None. ; 1687 ! ; 1688 !-- ; 1689 ; 1690 BEGIN ; 1691 ! ; 1692 ! Check to see if the number of retries have been exceeded. ; 1693 ! ; 1694 ; 1695 IF .NUM%RETRIES GTR .PKT%RETRIES THEN RETURN STATE%A; ; 1696 ; 1697 ! ; 1698 ! Not exceeded yet. Increment the number of retries we have attempted ; 1699 ! on this message. ; 1700 ! ; 1701 NUM%RETRIES = .NUM%RETRIES + 1; ; 1702 ! ; 1703 ! Attempt to send the packet and abort if the send fails. ; 1704 ! ; 1705 ; 1706 IF NOT SEND%PACKET (MSG%DATA, .SIZE, .MSG%NUMBER) THEN RETURN STATE%A; ; 1707 ; 1708 ! ; 1709 ! Attempt to receive a message from the remote KERMIT. ; 1710 ! ; 1711 STATUS = REC%PACKET (); ; 1712 ; 1713 IF NOT .STATUS ; 1714 THEN ; 1715 BEGIN ; 1716 ; 1717 IF (.STATUS EQL KER%ZEROLENMSG) OR (.STATUS EQL KER%TIMEOUT) OR (.STATUS EQL KER%CHKSUMERR) ; 1718 THEN ; 1719 RETURN .STATE ; 1720 ELSE ; 1721 RETURN STATE%A; ; 1722 ; 1723 END; ; 1724 ; 1725 ! ; 1726 ! Determine if the message is a NAK and the NAK is for the message number ; 1727 ! that we are current working on. If the NAK is for the next packet then ; 1728 ! ignore the NAK ; 1729 ! ; 1730 ; 1731 IF .REC%TYPE EQL MSG%NAK AND .REC%SEQ NEQ ((.MSG%NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1732 ; 1733 ! ; 1734 ! Make sure we have a NAK or ACK ; 1735 ! ; 1736 ; 1737 IF .REC%TYPE EQL MSG%ACK OR .REC%TYPE EQL MSG%NAK ; 1738 THEN ; 1739 BEGIN ; 1740 ! ; 1741 ! Is this for this message? ; 1742 ! ; 1743 ; 1744 IF .REC%SEQ NEQ .MSG%NUMBER THEN RETURN .STATE; ; 1745 ; 1746 ! ; 1747 ! It was. Set up for sending the next data message to the remote KERMIT ; 1748 ! and return. ; 1749 ! ; 1750 ! ; 1751 ! Check for data field in ACK indicating abort file or stream ; 1752 ! ; 1753 ! ; 1754 ; 1755 IF .REC%TYPE EQL MSG%ACK AND .REC%LENGTH EQL 1 ; 1756 THEN ; 1757 ; 1758 SELECTONE CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG, CHR%SIZE)) OF ; 1759 SET ; 1760 ; 1761 [MSG%ACK%ABT%CUR] : ; 1762 ABT%CUR%FILE = TRUE; ; 1763 ; 1764 [MSG%ACK%ABT%ALL] : ; 1765 ABT%ALL%FILE = TRUE; ; 1766 TES; ; 1767 ; 1768 NUM%RETRIES = 0; ; 1769 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 1770 ; 1771 IF (BFR%FILL (FALSE) EQL KER%NORMAL) AND NOT (.ABT%CUR%FILE OR .ABT%ALL%FILE) ; 1772 THEN ; 1773 RETURN STATE%SD ; 1774 ELSE ; 1775 BEGIN ; 1776 ; 1777 IF ( NOT .CONNECT%FLAG) AND .TY%FIL ; 1778 THEN ; 1779 BEGIN ; 1780 ; 1781 IF .ABT%ALL%FILE ; 1782 THEN ; 1783 TT%TEXT (UPLIT (%ASCIZ' [Group interrupted]')) ; 1784 ELSE ; 1785 ; 1786 IF .ABT%CUR%FILE ; 1787 THEN ; 1788 TT%TEXT (UPLIT (%ASCIZ' [Interrupted]')) ; 1789 ELSE ; 1790 TT%TEXT (UPLIT (%ASCIZ' [OK]')); ; 1791 ; 1792 TT%CRLF (); ; 1793 END; ; 1794 ; 1795 FILE%CLOSE (FALSE); ; 1796 FILE%OPEN%FLAG = FALSE; ; 1797 RETURN STATE%SZ; ; 1798 END; ; 1799 ; 1800 END ; 1801 ELSE ; 1802 ! ; 1803 ! Not an ACK or NAK, abort. ; 1804 ! ; 1805 RETURN STATE%A; ; 1806 ; 1807 END; P.AAB: BYTE (7)" ","[","G","r","o" BYTE (7)"u","p"," ","i","n" BYTE (7)"t","e","r","r","u" BYTE (7)"p","t","e","d","]" BYTE (7)000,000,000,000,000 P.AAC: BYTE (7)" ","[","I","n","t" BYTE (7)"e","r","r","u","p" BYTE (7)"t","e","d","]",000 P.AAD: BYTE (7)" ","[","O","K","]" BYTE (7)000,000,000,000,000 ; SEND%DATA U.3: MOVE AC1,U.101 ; 1695 CAMLE AC1,PKT%RETRIES JRST L.46 AOS U.101 ; 1701 PUSH SP,C.16 ; 1706 PUSH SP,U.99 PUSH SP,U.102 PUSHJ SP,U.21 ADJSP SP,-3 TRNN AC1,1 JRST L.46 PUSHJ SP,U.23 ; 1711 MOVEM AC1,U.97 TRNE AC1,1 ; 1713 JRST L.33 CAIE AC1,262 ; 1717 CAIN AC1,300 JRST L.37 CAIN AC1,172 JRST L.37 ; 1719 JRST L.46 ; 1721 L.33: MOVE AC2,U.105 ; 1731 SETZ AC3, CAIE AC2,116 JRST L.34 MOVEI AC3,1 MOVE AC1,U.102 ADDI AC1,1 LDB AC4,C.1 CAME AC4,U.103 JRST L.37 L.34: SETZ AC1, ; 1737 CAIE AC2,131 JRST L.35 MOVEI AC1,1 JRST L.36 L.35: TRNN AC3,1 JRST L.46 L.36: MOVE AC2,U.103 ; 1744 CAMN AC2,U.102 JRST L.38 L.37: MOVE AC1,U.98 POPJ SP, L.38: TRNN AC1,1 ; 1755 JRST L.40 MOVEI AC1,1 CAME AC1,U.104 JRST L.40 MOVE AC1,C.5 ; 1758 ILDB AC1,AC1 CAIE AC1,130 JRST L.39 MOVEI AC2,1 ; 1762 MOVEM AC2,ABT%CUR%FILE JRST L.40 ; 1758 L.39: CAIE AC1,132 JRST L.40 MOVEI AC1,1 ; 1765 MOVEM AC1,ABT%ALL%FILE L.40: SETZM U.101 ; 1768 MOVE AC1,U.102 ; 1769 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 PUSH SP,C.10 ; 1771 PUSHJ SP,U.25 ADJSP SP,-1 CAIE AC1,13 JRST L.41 MOVEI AC1,1 TDNE AC1,ABT%CUR%FILE JRST L.41 MOVEI AC1,1 TDNE AC1,ABT%ALL%FILE JRST L.41 MOVEI AC1,3 ; 1739 POPJ SP, L.41: MOVEI AC1,1 ; 1777 TDNE AC1,CONNECT%FLAG JRST L.45 MOVEI AC1,1 TDNN AC1,TY%FIL JRST L.45 MOVEI AC1,1 ; 1781 TDNN AC1,ABT%ALL%FILE JRST L.42 PUSH SP,C.17 ; 1783 JRST L.44 L.42: MOVEI AC1,1 ; 1786 TDNN AC1,ABT%CUR%FILE JRST L.43 PUSH SP,C.18 ; 1788 JRST L.44 L.43: PUSH SP,C.19 ; 1790 L.44: PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 1792 ADJSP SP,-1 ; 1779 L.45: PUSH SP,C.10 ; 1795 PUSHJ SP,FILE%CLOSE SETZM U.108 ; 1796 ADJSP SP,-1 ; 1775 MOVEI AC1,4 ; 1739 POPJ SP, ; 1690 L.46: MOVEI AC1,12 POPJ SP, ; 1653 C.16: EXP 104 C.17: XWD 0,P.AAB C.18: XWD 0,P.AAC C.19: XWD 0,P.AAD ; Routine Size: 109 words ; 1808 %SBTTL 'SEND%FILE' ; 1809 ROUTINE SEND%FILE = ; 1810 ; 1811 !++ ; 1812 ! FUNCTIONAL DESCRIPTION: ; 1813 ! ; 1814 ! This routine will send the file specification that is being ; 1815 ! transfered. ; 1816 ! ; 1817 ! CALLING SEQUENCE: ; 1818 ! ; 1819 ! STATE = SEND%FILE(); ; 1820 ! ; 1821 ! INPUT PARAMETERS: ; 1822 ! ; 1823 ! None. ; 1824 ! ; 1825 ! IMPLICIT INPUTS: ; 1826 ! ; 1827 ! None. ; 1828 ! ; 1829 ! OUTPUT PARAMETERS: ; 1830 ! ; 1831 ! New state to change the finite state machine to. ; 1832 ! ; 1833 ! IMPLICIT OUTPUTS: ; 1834 ! ; 1835 ! None. ; 1836 ! ; 1837 ! COMPLETION CODES: ; 1838 ! ; 1839 ! None. ; 1840 ! ; 1841 ! SIDE EFFECTS: ; 1842 ! ; 1843 ! None. ; 1844 ! ; 1845 !-- ; 1846 ; 1847 BEGIN ; 1848 ! ; 1849 ! Flag we don't want to abort yet ; 1850 ! ; 1851 ABT%CUR%FILE = FALSE; ; 1852 ABT%ALL%FILE = FALSE; ; 1853 ! ; 1854 ! First determine if we have exceed the number of retries that are ; 1855 ! allowed to attempt to send this message. ; 1856 ! ; 1857 ; 1858 IF .NUM%RETRIES GTR .PKT%RETRIES THEN RETURN STATE%A; ; 1859 ; 1860 ! ; 1861 ! The number of retries are not exceeded. Increment the number and then ; 1862 ! attempt to send the packet again. ; 1863 ! ; 1864 NUM%RETRIES = .NUM%RETRIES + 1; ; 1865 ; 1866 IF .FILE%SIZE NEQ 0 ; 1867 THEN ; 1868 CH$MOVE (.FILE%SIZE, CH$PTR (FILE%NAME), ; 1869 CH$PTR (SND%MSG, PKT%MSG, ; 1870 CHR%SIZE)); ; 1871 ; 1872 IF NOT SEND%PACKET (MSG%FILE, .FILE%SIZE, .MSG%NUMBER) THEN RETURN STATE%A; ; 1873 ; 1874 ! ; 1875 ! Now get the responce from the remote KERMIT. ; 1876 ! ; 1877 STATUS = REC%PACKET (); ; 1878 ; 1879 IF NOT .STATUS ; 1880 THEN ; 1881 BEGIN ; 1882 ; 1883 IF (.STATUS EQL KER%ZEROLENMSG) OR (.STATUS EQL KER%TIMEOUT) OR (.STATUS EQL KER%CHKSUMERR) ; 1884 THEN ; 1885 RETURN .STATE ; 1886 ELSE ; 1887 RETURN STATE%A; ; 1888 ; 1889 END; ; 1890 ; 1891 ! ; 1892 ! Determine if the packet is good. ; 1893 ! ; 1894 ; 1895 IF NOT (.REC%TYPE EQL MSG%ACK OR .REC%TYPE EQL MSG%NAK) THEN RETURN STATE%A; ; 1896 ; 1897 ! ; 1898 ! If this is a NAK and the message number is not the one we just send ; 1899 ! treat this like an ACK, otherwise resend the last packet. ; 1900 ! ; 1901 ; 1902 IF .REC%TYPE EQL MSG%NAK AND .REC%SEQ NEQ ((.MSG%NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 1903 ; 1904 IF .REC%SEQ NEQ .MSG%NUMBER THEN RETURN .STATE; ; 1905 ; 1906 ! ; 1907 ! If all is ok, bump the message number and fill first buffer ; 1908 ! ; 1909 NUM%RETRIES = 0; ; 1910 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 1911 ; 1912 IF BFR%FILL (TRUE) THEN RETURN STATE%SD ELSE RETURN STATE%A; ; 1913 ; 1914 END; ! End of SEND%FILE ; SEND%FILE U.4: SETZM ABT%CUR%FILE ; 1851 SETZM ABT%ALL%FILE ; 1852 MOVE AC1,U.101 ; 1858 CAMLE AC1,PKT%RETRIES JRST L.53 AOS U.101 ; 1864 MOVE AC3,FILE%SIZE ; 1866 JUMPE AC3,L.47 MOVE AC1,AC3 ; 1868 MOVE AC2,C.6 MOVE AC4,AC3 MOVE AC5,C.12 EXTEND AC1,C.20 JFCL L.47: PUSH SP,C.21 ; 1872 PUSH SP,AC3 PUSH SP,U.102 PUSHJ SP,U.21 ADJSP SP,-3 TRNN AC1,1 JRST L.53 PUSHJ SP,U.23 ; 1877 MOVEM AC1,U.97 TRNE AC1,1 ; 1879 JRST L.48 CAIE AC1,262 ; 1883 CAIN AC1,300 JRST L.51 CAIN AC1,172 JRST L.51 ; 1885 JRST L.53 ; 1887 L.48: MOVE AC1,U.105 ; 1895 CAIE AC1,131 CAIN AC1,116 JRST L.49 JRST L.53 L.49: CAIE AC1,116 ; 1902 JRST L.50 MOVE AC1,U.102 ADDI AC1,1 LDB AC2,C.1 CAME AC2,U.103 JRST L.51 L.50: MOVE AC1,U.103 ; 1904 CAMN AC1,U.102 JRST L.52 L.51: MOVE AC1,U.98 POPJ SP, L.52: SETZM U.101 ; 1909 MOVE AC1,U.102 ; 1910 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 PUSH SP,C.14 ; 1912 PUSHJ SP,U.25 ADJSP SP,-1 TRNN AC1,1 JRST L.53 MOVEI AC1,3 ; 1847 POPJ SP, L.53: MOVEI AC1,12 POPJ SP, ; 1809 C.20: MOVSLJ C.21: EXP 106 ; Routine Size: 64 words ; 1915 %SBTTL 'SEND%EOF' ; 1916 ROUTINE SEND%EOF = ; 1917 ; 1918 !++ ; 1919 ! FUNCTIONAL DESCRIPTION: ; 1920 ! ; 1921 ! This routine will send the end of file message to the remote ; 1922 ! KERMIT. It will then determine if there are more files to ; 1923 ! send to the remote. ; 1924 ! ; 1925 ! CALLING SEQUENCE: ; 1926 ! ; 1927 ! STATE = SEND%EOF(); ; 1928 ! ; 1929 ! INPUT PARAMETERS: ; 1930 ! ; 1931 ! None. ; 1932 ! ; 1933 ! IMPLICIT INPUTS: ; 1934 ! ; 1935 ! None. ; 1936 ! ; 1937 ! OUTPUT PARAMETERS: ; 1938 ! ; 1939 ! New state to change the finite state machine to. ; 1940 ! ; 1941 ! IMPLICIT OUTPUTS: ; 1942 ! ; 1943 ! None. ; 1944 ! ; 1945 ! COMPLETION CODES: ; 1946 ! ; 1947 ! None. ; 1948 ! ; 1949 ! SIDE EFFECTS: ; 1950 ! ; 1951 ! Sets up for the next file to be processed if there is one. ; 1952 ! ; 1953 !-- ; 1954 ; 1955 BEGIN ; 1956 ; 1957 LOCAL ; 1958 EOF%MSG%LEN; ! Length of EOF message to send ; 1959 ; 1960 ! ; 1961 ! First determine if we have exceed the number of retries that are ; 1962 ! allowed to attempt to send this message. ; 1963 ! ; 1964 ; 1965 IF .NUM%RETRIES GTR .PKT%RETRIES THEN RETURN STATE%A; ; 1966 ; 1967 ! ; 1968 ! The number of retries are not exceeded. Increment the number and then ; 1969 ! attempt to send the packet again. ; 1970 ! ; 1971 NUM%RETRIES = .NUM%RETRIES + 1; ; 1972 ! ; 1973 ! Store character in packet to indicate discard of file ; 1974 ! Character will only be sent if file should be discarded ; 1975 ! ; 1976 CH$WCHAR (MSG%EOF%DISCARD, CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE)); ; 1977 ; 1978 IF .ABT%CUR%FILE OR .ABT%ALL%FILE THEN EOF%MSG%LEN = 1 ELSE EOF%MSG%LEN = 0; ; 1979 ; 1980 IF NOT SEND%PACKET (MSG%EOF, .EOF%MSG%LEN, .MSG%NUMBER) THEN RETURN STATE%A; ; 1981 ; 1982 ! ; 1983 ! Now get the responce from the remote KERMIT. ; 1984 ! ; 1985 STATUS = REC%PACKET (); ; 1986 ; 1987 IF NOT .STATUS ; 1988 THEN ; 1989 BEGIN ; 1990 ; 1991 IF (.STATUS EQL KER%ZEROLENMSG) OR (.STATUS EQL KER%TIMEOUT) OR (.STATUS EQL KER%CHKSUMERR) ; 1992 THEN ; 1993 RETURN .STATE ; 1994 ELSE ; 1995 RETURN STATE%A; ; 1996 ; 1997 END; ; 1998 ; 1999 ! ; 2000 ! Determine if the packet is good. ; 2001 ! ; 2002 ; 2003 IF NOT (.REC%TYPE EQL MSG%ACK OR .REC%TYPE EQL MSG%NAK) THEN RETURN STATE%A; ; 2004 ; 2005 ! ; 2006 ! If this is a NAK and the message number is not the one we just send ; 2007 ! treat this like an ACK, otherwise resend the last packet. ; 2008 ! ; 2009 ; 2010 IF .REC%TYPE EQL MSG%NAK AND .REC%SEQ NEQ ((.MSG%NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 2011 ; 2012 IF .REC%SEQ NEQ .MSG%NUMBER THEN RETURN .STATE; ; 2013 ; 2014 ! ; 2015 ! Here to determine if there is another file to send. ; 2016 ! ; 2017 NUM%RETRIES = 0; ; 2018 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 2019 ; 2020 IF NOT .ABT%ALL%FILE THEN STATUS = NEXT%FILE () ELSE STATUS = KER%NOMORFILES; ; 2021 ; 2022 IF ( NOT .STATUS) OR (.STATUS EQL KER%NOMORFILES) THEN RETURN STATE%SB ELSE RETURN STATE%SF; ; 2023 ; 2024 END; ; SEND%EOF U.5: MOVE AC1,U.101 ; 1965 CAMLE AC1,PKT%RETRIES JRST L.58 AOS U.101 ; 1971 MOVEI AC2,104 ; 1976 MOVE AC1,C.12 IDPB AC2,AC1 MOVEI AC1,1 ; 1978 TDNE AC1,ABT%CUR%FILE JRST L.54 MOVEI AC1,1 TDNN AC1,ABT%ALL%FILE JRST L.55 L.54: MOVEI AC1,1 JRST L.56 L.55: SETZ AC1, L.56: PUSH SP,C.22 ; 1980 PUSH SP,AC1 PUSH SP,U.102 PUSHJ SP,U.21 ADJSP SP,-3 TRNN AC1,1 JRST L.58 PUSHJ SP,U.23 ; 1985 MOVEM AC1,U.97 TRNE AC1,1 ; 1987 JRST L.57 CAIE AC1,262 ; 1991 CAIN AC1,300 JRST L.61 CAIN AC1,172 JRST L.61 ; 1993 JRST L.58 ; 1995 L.57: MOVE AC1,U.105 ; 2003 CAIE AC1,131 CAIN AC1,116 JRST L.59 L.58: MOVEI AC1,12 POPJ SP, L.59: CAIE AC1,116 ; 2010 JRST L.60 MOVE AC1,U.102 ADDI AC1,1 LDB AC2,C.1 CAME AC2,U.103 JRST L.61 L.60: MOVE AC1,U.103 ; 2012 CAMN AC1,U.102 JRST L.62 L.61: MOVE AC1,U.98 POPJ SP, L.62: SETZM U.101 ; 2017 MOVE AC1,U.102 ; 2018 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 MOVEI AC1,1 ; 2020 TDNE AC1,ABT%ALL%FILE JRST L.63 PUSHJ SP,NEXT%FILE JRST L.64 L.63: MOVEI AC1,133 L.64: MOVEM AC1,U.97 TRNN AC1,1 ; 2022 JRST L.65 CAIE AC1,133 JRST L.66 L.65: MOVEI AC1,5 ; 1955 POPJ SP, L.66: MOVEI AC1,2 POPJ SP, ; 1916 C.22: EXP 132 ; Routine Size: 72 words ; 2025 %SBTTL 'SEND%INIT' ; 2026 ROUTINE SEND%INIT = ; 2027 ; 2028 !++ ; 2029 ! FUNCTIONAL DESCRIPTION: ; 2030 ! ; 2031 ! This routine will send the initialization packet to the remote ; 2032 ! KERMIT. The message type sent is S. ; 2033 ! ; 2034 ! CALLING SEQUENCE: ; 2035 ! ; 2036 ! STATE = SEND%INIT(); ; 2037 ! ; 2038 ! INPUT PARAMETERS: ; 2039 ! ; 2040 ! None. ; 2041 ! ; 2042 ! IMPLICIT INPUTS: ; 2043 ! ; 2044 ! None. ; 2045 ! ; 2046 ! OUTPUT PARAMETERS: ; 2047 ! ; 2048 ! New state to change the finite state machine to. ; 2049 ! ; 2050 ! IMPLICIT OUTPUTS: ; 2051 ! ; 2052 ! None. ; 2053 ! ; 2054 ! COMPLETION CODES: ; 2055 ! ; 2056 ! None. ; 2057 ! ; 2058 ! SIDE EFFECTS: ; 2059 ! ; 2060 ! None. ; 2061 ! ; 2062 !-- ; 2063 ; 2064 BEGIN ; 2065 SET%SEND%INIT (); ; 2066 ; 2067 IF .NUM%RETRIES GTR .SI%RETRIES THEN RETURN STATE%A; ; 2068 ; 2069 ! ; 2070 ! Count the number of times we try this ; 2071 ! ; 2072 NUM%RETRIES = .NUM%RETRIES + 1; ; 2073 ; 2074 IF NOT SEND%PACKET (MSG%SND%INIT, P%SI%LENGTH, .MSG%NUMBER) THEN RETURN STATE%A; ; 2075 ; 2076 ! ; 2077 ! Determine if we received a packet it good condition. If we timed out or ; 2078 ! got an illegal message, just try again. ; 2079 ! ; 2080 STATUS = REC%PACKET (); ; 2081 ; 2082 IF NOT .STATUS ; 2083 THEN ; 2084 BEGIN ; 2085 ; 2086 IF (.STATUS EQL KER%ZEROLENMSG) OR (.STATUS EQL KER%TIMEOUT) OR (.STATUS EQL KER%CHKSUMERR) ; 2087 THEN ; 2088 RETURN .STATE ; 2089 ELSE ; 2090 RETURN STATE%A; ; 2091 ; 2092 END; ; 2093 ; 2094 ! ; 2095 ! Determine if the packet is good. ; 2096 ! ; 2097 ; 2098 IF .REC%TYPE NEQ MSG%ACK THEN RETURN .STATE; ; 2099 ; 2100 IF .REC%SEQ NEQ .MSG%NUMBER THEN RETURN .STATE; ; 2101 ; 2102 ! ; 2103 ! Here if we have an ACK for the initialization message that was just sent ; 2104 ! to the remote KERMIT. ; 2105 ! ; 2106 ; 2107 IF NOT (STATUS = PRS%SEND%INIT ()) THEN RETURN STATE%A; ; 2108 ; 2109 BLK%CHK%TYPE = .INI%CHK%TYPE; ! We now use agreed upon block check type ; 2110 NUM%RETRIES = 0; ; 2111 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 2112 ; 2113 IF ( NOT .CONNECT%FLAG) AND .TY%FIL ; 2114 THEN ; 2115 BEGIN ; 2116 TT%TEXT (UPLIT (%ASCIZ'Sending: ')); ; 2117 TT%OUTPUT (); ; 2118 END; ; 2119 ; 2120 IF NOT FILE%OPEN (FNC%READ) ; 2121 THEN ; 2122 RETURN STATE%A ; 2123 ELSE ; 2124 BEGIN ; 2125 ; 2126 IF ( NOT .CONNECT%FLAG) AND .TY%FIL ; 2127 THEN ; 2128 BEGIN ; 2129 TT%TEXT (FILE%NAME); ; 2130 TT%OUTPUT (); ; 2131 END; ; 2132 ; 2133 FILE%OPEN%FLAG = TRUE; ; 2134 RETURN STATE%SF; ; 2135 END; ; 2136 ; 2137 END; P.AAE: BYTE (7)"S","e","n","d","i" BYTE (7)"n","g",":"," ",000 ; SEND%INIT U.6: PUSHJ SP,U.17 ; 2065 MOVE AC1,U.101 ; 2067 CAMLE AC1,SI%RETRIES JRST L.71 AOS U.101 ; 2072 PUSH SP,C.23 ; 2074 PUSH SP,C.4 PUSH SP,U.102 PUSHJ SP,U.21 ADJSP SP,-3 TRNN AC1,1 JRST L.71 PUSHJ SP,U.23 ; 2080 MOVEM AC1,U.97 TRNE AC1,1 ; 2082 JRST L.67 CAIE AC1,262 ; 2086 CAIN AC1,300 JRST L.68 CAIN AC1,172 JRST L.68 ; 2088 JRST L.71 ; 2090 L.67: MOVEI AC1,131 ; 2098 CAME AC1,U.105 JRST L.68 MOVE AC1,U.103 ; 2100 CAMN AC1,U.102 JRST L.69 L.68: MOVE AC1,U.98 POPJ SP, L.69: PUSHJ SP,U.18 ; 2107 MOVEM AC1,U.97 TRNN AC1,1 JRST L.71 MOVE AC1,U.93 ; 2109 MOVEM AC1,U.94 SETZM U.101 ; 2110 MOVE AC1,U.102 ; 2111 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 MOVEI AC1,1 ; 2113 TDNE AC1,CONNECT%FLAG JRST L.70 MOVEI AC1,1 TDNN AC1,TY%FIL JRST L.70 PUSH SP,C.24 ; 2116 PUSHJ SP,TT%TEXT PUSHJ SP,TT%OUTPUT ; 2117 ADJSP SP,-1 ; 2115 L.70: PUSH SP,C.10 ; 2120 PUSHJ SP,FILE%OPEN ADJSP SP,-1 TRNE AC1,1 JRST L.72 L.71: MOVEI AC1,12 ; 2064 POPJ SP, L.72: MOVEI AC1,1 ; 2126 TDNE AC1,CONNECT%FLAG JRST L.73 MOVEI AC1,1 TDNN AC1,TY%FIL JRST L.73 PUSH SP,C.25 ; 2129 PUSHJ SP,TT%TEXT PUSHJ SP,TT%OUTPUT ; 2130 ADJSP SP,-1 ; 2128 L.73: MOVEI AC1,1 ; 2133 MOVEM AC1,U.108 MOVEI AC1,2 ; 2064 POPJ SP, ; 2026 C.23: EXP 123 C.24: XWD 0,P.AAE C.25: XWD 0,FILE%NAME ; Routine Size: 75 words ; 2138 %SBTTL 'SEND%BREAK' ; 2139 ROUTINE SEND%BREAK = ; 2140 ; 2141 !++ ; 2142 ! FUNCTIONAL DESCRIPTION: ; 2143 ! ; 2144 ! This routine will send the break (end of transmission) message ; 2145 ! to the remote KERMIT. On an ACK the state becomes STATE%C. ; 2146 ! ; 2147 ! CALLING SEQUENCE: ; 2148 ! ; 2149 ! STATE = SEND%BREAK(); ; 2150 ! ; 2151 ! INPUT PARAMETERS: ; 2152 ! ; 2153 ! None. ; 2154 ! ; 2155 ! IMPLICIT INPUTS: ; 2156 ! ; 2157 ! None. ; 2158 ! ; 2159 ! OUTPUT PARAMETERS: ; 2160 ! ; 2161 ! New state for the finite state machine. ; 2162 ! ; 2163 ! IMPLICIT OUTPUTS: ; 2164 ! ; 2165 ! None. ; 2166 ! ; 2167 ! COMPLETION CODES: ; 2168 ! ; 2169 ! None. ; 2170 ! ; 2171 ! SIDE EFFECTS: ; 2172 ! ; 2173 ! None. ; 2174 ! ; 2175 !-- ; 2176 ; 2177 BEGIN ; 2178 ! ; 2179 ! First determine if we have exceed the number of retries that are ; 2180 ! allowed to attempt to send this message. ; 2181 ! ; 2182 ; 2183 IF .NUM%RETRIES GTR .PKT%RETRIES THEN RETURN STATE%A; ; 2184 ; 2185 ! ; 2186 ! The number of retries are not exceeded. Increment the number and then ; 2187 ! attempt to send the packet again. ; 2188 ! ; 2189 NUM%RETRIES = .NUM%RETRIES + 1; ; 2190 ; 2191 IF NOT SEND%PACKET (MSG%BREAK, 0, .MSG%NUMBER) THEN RETURN STATE%A; ; 2192 ; 2193 ! ; 2194 ! Now get the responce from the remote KERMIT. ; 2195 ! ; 2196 STATUS = REC%PACKET (); ; 2197 ; 2198 IF NOT .STATUS ; 2199 THEN ; 2200 BEGIN ; 2201 ; 2202 IF (.STATUS EQL KER%ZEROLENMSG) OR (.STATUS EQL KER%TIMEOUT) OR (.STATUS EQL KER%CHKSUMERR) ; 2203 THEN ; 2204 RETURN .STATE ; 2205 ELSE ; 2206 RETURN STATE%A; ; 2207 ; 2208 END; ; 2209 ; 2210 ! ; 2211 ! Determine if the packet is good. ; 2212 ! ; 2213 ; 2214 IF NOT (.REC%TYPE EQL MSG%ACK OR .REC%TYPE EQL MSG%NAK) THEN RETURN STATE%A; ; 2215 ; 2216 ! ; 2217 ! If this is a NAK and the message number is not the one we just send ; 2218 ! treat this like an ACK, otherwise resend the last packet. ; 2219 ! ; 2220 ; 2221 IF .REC%TYPE EQL MSG%NAK AND .REC%SEQ NEQ ((.MSG%NUMBER + 1) AND %O'77') THEN RETURN .STATE; ; 2222 ; 2223 IF .REC%SEQ NEQ .MSG%NUMBER THEN RETURN .STATE; ; 2224 ; 2225 ! ; 2226 ! Here to determine if there is another file to send. ; 2227 ! ; 2228 NUM%RETRIES = 0; ; 2229 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 2230 RETURN STATE%C; ; 2231 END; ; SEND%BREAK U.7: MOVE AC1,U.101 ; 2183 CAMLE AC1,PKT%RETRIES JRST L.75 AOS U.101 ; 2189 PUSH SP,C.26 ; 2191 PUSH SP,C.10 PUSH SP,U.102 PUSHJ SP,U.21 ADJSP SP,-3 TRNN AC1,1 JRST L.75 PUSHJ SP,U.23 ; 2196 MOVEM AC1,U.97 TRNE AC1,1 ; 2198 JRST L.74 CAIE AC1,262 ; 2202 CAIN AC1,300 JRST L.78 CAIN AC1,172 JRST L.78 ; 2204 JRST L.75 ; 2206 L.74: MOVE AC1,U.105 ; 2214 CAIE AC1,131 CAIN AC1,116 JRST L.76 L.75: MOVEI AC1,12 POPJ SP, L.76: CAIE AC1,116 ; 2221 JRST L.77 MOVE AC1,U.102 ADDI AC1,1 LDB AC2,C.1 CAME AC2,U.103 JRST L.78 L.77: MOVE AC1,U.103 ; 2223 CAMN AC1,U.102 JRST L.79 L.78: MOVE AC1,U.98 POPJ SP, L.79: SETZM U.101 ; 2228 MOVE AC1,U.102 ; 2229 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 MOVEI AC1,11 ; 2177 POPJ SP, ; 2139 C.26: EXP 102 ; Routine Size: 47 words ; 2232 %SBTTL 'SND%ERROR' ; 2233 ; 2234 GLOBAL ROUTINE SND%ERROR (COUNT, ADDRESS) : NOVALUE = ; 2235 ; 2236 !++ ; 2237 ! FUNCTIONAL DESCRIPTION: ; 2238 ! ; 2239 ! This routine will send an error packet to the remote KERMIT. It ; 2240 ! is called with the count of characters and the address of the text. ; 2241 ! ; 2242 ! CALLING SEQUENCE: ; 2243 ! ; 2244 ! SND%ERROR(COUNT, %ASCII 'Error text'); ; 2245 ! ; 2246 ! INPUT PARAMETERS: ; 2247 ! ; 2248 ! None. ; 2249 ! ; 2250 ! IMPLICIT INPUTS: ; 2251 ! ; 2252 ! None. ; 2253 ! ; 2254 ! OUTPUT PARAMETERS: ; 2255 ! ; 2256 ! None. ; 2257 ! ; 2258 ! IMPLICIT OUTPUTS: ; 2259 ! ; 2260 ! None. ; 2261 ! ; 2262 ! COMPLETION CODES: ; 2263 ! ; 2264 ! None. ; 2265 ! ; 2266 ! SIDE EFFECTS: ; 2267 ! ; 2268 ! ; 2269 !-- ; 2270 ; 2271 BEGIN ; 2272 ; 2273 LOCAL ; 2274 CHR, ! Character we are processing ; 2275 SIZE, ! Size of data area ; 2276 STO%PTR, ! Pointer used to store chars ; 2277 FET%PTR; ! Pointer used to fetch characters ; 2278 ; 2279 ! ; 2280 ! Initialize the various pointers and counter. ; 2281 ! ; 2282 FET%PTR = CH$PTR (.ADDRESS); ; 2283 STO%PTR = CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE); ; 2284 ! ; 2285 ! Determine the max size we can use ; 2286 ! ; 2287 SIZE = (IF .COUNT GTR .SEND%PKT%SIZE - PKT%TOT%OVR%HEAD THEN .SEND%PKT%SIZE - PKT%TOT%OVR%HEAD ; 2288 ELSE .COUNT); ; 2289 ! ; 2290 ! Move the information from the source to the destination ; 2291 ! ; 2292 CH$MOVE (.SIZE, .FET%PTR, .STO%PTR); ; 2293 CH$COPY (.SIZE, CH$PTR (.ADDRESS), 0, .SIZE + 1, CH$PTR (LAST%ERROR)); ; 2294 ; 2295 IF NOT SEND%PACKET (MSG%ERROR, .SIZE, .MSG%NUMBER) THEN RETURN STATE%A; ; 2296 ; 2297 END; ! End of SND%ERROR U.8: SND%ERROR:: PUSH SP,AC16 ; 2234 MOVE AC16,-2(SP) ; 2282 MOVE AC1,AC16 MOVEI AC2,-1(AC1) HRLI AC2,10700 MOVE AC5,C.12 ; 2283 MOVE AC1,U.86 ; 2287 SUBI AC1,6 CAMGE AC1,-3(SP) SKIPA AC3,AC1 MOVE AC3,-3(SP) MOVE AC1,AC3 ; 2292 MOVE AC4,AC3 EXTEND AC1,C.20 JFCL MOVE AC1,AC16 ; 2293 MOVEI AC2,-1(AC1) HRLI AC2,10700 MOVE AC4,AC3 ADDI AC4,1 MOVE AC1,AC3 MOVE AC5,C.27 EXTEND AC1,C.2 JFCL PUSH SP,C.28 ; 2295 PUSH SP,AC3 PUSH SP,U.102 PUSHJ SP,U.21 ADJSP SP,-3 POP SP,AC16 ; 2234 POPJ SP, C.27: POINT 7,LAST%ERROR-1,34 C.28: EXP 105 ; Routine Size: 33 words ; 2298 ; 2299 %SBTTL 'REC%SWITCH' ; 2300 ; 2301 GLOBAL ROUTINE REC%SWITCH = ; 2302 ; 2303 !++ ; 2304 ! FUNCTIONAL DESCRIPTION: ; 2305 ! ; 2306 ! This routine will cause file(s) to be received by the remote ; 2307 ! KERMIT. This routine contains the main loop for the sending of the ; 2308 ! data. ; 2309 ! ; 2310 ! CALLING SEQUENCE: ; 2311 ! ; 2312 ! REC%SWITCH(); ; 2313 ! ; 2314 ! INPUT PARAMETERS: ; 2315 ! ; 2316 ! None. ; 2317 ! ; 2318 ! IMPLICIT INPUTS: ; 2319 ! ; 2320 ! FILE%DESC - Descriptor describing the file to be received by ; 2321 ! the remote KERMIT. ; 2322 ! ; 2323 ! OUTPUT PARAMETERS: ; 2324 ! ; 2325 ! None. ; 2326 ! ; 2327 ! IMPLICIT OUTPUTS: ; 2328 ! ; 2329 ! None. ; 2330 ! ; 2331 ! COMPLETION CODES: ; 2332 ! ; 2333 ! True - File received correctly. ; 2334 ! FALSE - File transfer aborted. ; 2335 ! ; 2336 ! SIDE EFFECTS: ; 2337 ! ; 2338 ! None. ; 2339 ! ; 2340 !-- ; 2341 ; 2342 BEGIN ; 2343 STATE = STATE%R; ! Initialize the state ; 2344 MSG%NUMBER = 0; ; 2345 INIT%XFR (); ! Initialize the per transfer info ; 2346 ! ; 2347 ! Determine if they said REC ; 2348 ! Send MSG%RCV%INIT and then receive the file ; 2349 ! ; 2350 ; 2351 IF .FILE%SIZE GTR 0 ; 2352 THEN ; 2353 BEGIN ; 2354 CH$MOVE (.FILE%SIZE, CH$PTR (FILE%NAME), CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE)); ; 2355 ; 2356 IF NOT (STATUS = SEND%PACKET (MSG%RCV%INIT, .FILE%SIZE, .MSG%NUMBER)) THEN RETURN .STATUS; ; 2357 ; 2358 END; ; 2359 ; 2360 ! ; 2361 ! Now receive the file normally ; 2362 ! ; 2363 RETURN REC%SWITCH%WORKER (); ; 2364 END; ! End of REC%SWITCH U.9: REC%SWITCH:: MOVEI AC1,6 ; 2343 MOVEM AC1,U.98 SETZM U.102 ; 2344 PUSHJ SP,U.27 ; 2345 MOVE AC3,FILE%SIZE ; 2351 JUMPLE AC3,L.80 MOVE AC1,AC3 ; 2354 MOVE AC2,C.6 MOVE AC4,AC3 MOVE AC5,C.12 EXTEND AC1,C.20 JFCL PUSH SP,C.29 ; 2356 PUSH SP,AC3 PUSH SP,U.102 PUSHJ SP,U.21 ADJSP SP,-3 MOVEM AC1,U.97 TRNN AC1,1 SKIPA AC1,U.97 L.80: PUSHJ SP,U.10 ; 2363 POPJ SP, ; 2301 C.29: EXP 122 ; Routine Size: 23 words ; 2365 ; 2366 %SBTTL 'Receive - REC%SWITCH%WORKER' ; 2367 ROUTINE REC%SWITCH%WORKER = ; 2368 ; 2369 !++ ; 2370 ! FUNCTIONAL DESCRIPTION: ; 2371 ! ; 2372 ! This is the worker routine for either REC%SWITCH or SERVER. ; 2373 ! This routine will be called with the STATE variable set to the ; 2374 ! correct state for either the SERVER or the REC%SWITCH routine. ; 2375 ! ; 2376 ! CALLING SEQUENCE: ; 2377 ! ; 2378 ! Status = REC%SWITCH%WORKER(); ; 2379 ! ; 2380 ! INPUT PARAMETERS: ; 2381 ! ; 2382 ! None. ; 2383 ! ; 2384 ! IMPLICIT INPUTS: ; 2385 ! ; 2386 ! None. ; 2387 ! ; 2388 ! OUTPUT PARAMETERS: ; 2389 ! ; 2390 ! None. ; 2391 ! ; 2392 ! IMPLICIT OUTPUTS: ; 2393 ! ; 2394 ! None. ; 2395 ! ; 2396 ! COMPLETION CODES: ; 2397 ! ; 2398 ! None. ; 2399 ! ; 2400 ! SIDE EFFECTS: ; 2401 ! ; 2402 ! None. ; 2403 ! ; 2404 !-- ; 2405 ; 2406 BEGIN ; 2407 ; 2408 LOCAL ; 2409 RETURN%VALUE; ; 2410 ; 2411 NUM%RETRIES = 0; ! Initialize the number of retries ; 2412 ; 2413 WHILE TRUE DO ; 2414 ; 2415 CASE .STATE FROM STATE%MIN TO STATE%MAX OF ; 2416 SET ; 2417 ! ; 2418 ! Receiving of the data and the end of file message. ; 2419 ! ; 2420 ; 2421 [STATE%RD] : ; 2422 STATE = REC%DATA (); ; 2423 ! ; 2424 ! Receiving the FILE information of the break to end the transfer of ; 2425 ! one or more files ; 2426 ! ; 2427 ; 2428 [STATE%RF] : ; 2429 STATE = REC%FILE (); ; 2430 ! ; 2431 ! Initialization for the receiving of a file ; 2432 ! ; 2433 ; 2434 [STATE%R] : ; 2435 STATE = REC%INIT (); ; 2436 ! ; 2437 ! Here if we have completed the receiving of the file ; 2438 ! ; 2439 ; 2440 [STATE%C] : ; 2441 BEGIN ; 2442 RETURN%VALUE = TRUE; ; 2443 EXITLOOP; ; 2444 END; ; 2445 ! ; 2446 ! Here if we aborted the transfer or we have gotten into some random ; 2447 ! state (internal KERMSG problem). ; 2448 ! ; 2449 ; 2450 [STATE%A, INRANGE, OUTRANGE] : ; 2451 BEGIN ; 2452 RETURN%VALUE = FALSE; ; 2453 ! ; 2454 ! Determine if the file is still open and if so close it ; 2455 ! ; 2456 ; 2457 IF .FILE%OPEN%FLAG ; 2458 THEN ; 2459 BEGIN ; 2460 FILE%OPEN%FLAG = FALSE; ; 2461 ; 2462 IF ( NOT .CONNECT%FLAG) AND .TY%FIL ; 2463 THEN ; 2464 BEGIN ; 2465 TT%TEXT (UPLIT (%ASCIZ' [Aborted]')); ; 2466 TT%CRLF (); ; 2467 END; ; 2468 ; 2469 FILE%CLOSE (.ABT%FLAG AND (.STATE EQL STATE%A)); ; 2470 END; ; 2471 ; 2472 EXITLOOP; ; 2473 END; ; 2474 TES; ; 2475 ; 2476 ! ; 2477 ! End the stats and return to the caller ; 2478 ! ; 2479 END%STATS (); ; 2480 ! ; 2481 RETURN .RETURN%VALUE; ; 2482 END; ! End of REC%SWITCH%WORKER P.AAF: BYTE (7)" ","[","A","b","o" BYTE (7)"r","t","e","d","]" BYTE (7)000,000,000,000,000 ; REC%SWITCH%WORKER U.10: PUSH SP,AC16 ; 2367 SETZM U.101 ; 2411 L.81: MOVE AC1,U.98 ; 2415 JUMPL AC1,L.83 CAIGE AC1,13 JRST L.82(AC1) L.82: JRST L.83 JRST L.83 JRST L.83 JRST L.83 JRST L.83 JRST L.83 JRST L.87 JRST L.86 JRST L.85 JRST L.89 JRST L.83 L.83: SETZ AC16, ; 2452 MOVEI AC1,1 ; 2457 TDNN AC1,U.108 JRST L.90 SETZM U.108 ; 2460 MOVEI AC1,1 ; 2462 TDNE AC1,CONNECT%FLAG JRST L.84 MOVEI AC1,1 TDNN AC1,TY%FIL JRST L.84 PUSH SP,C.30 ; 2465 PUSHJ SP,TT%TEXT ADJSP SP,-1 PUSHJ SP,TT%CRLF ; 2466 L.84: SETZ AC1, ; 2469 MOVEI AC2,12 CAMN AC2,U.98 MOVEI AC1,1 AND AC1,ABT%FLAG PUSH SP,AC1 PUSHJ SP,FILE%CLOSE ADJSP SP,-1 JRST L.90 ; 2457 L.85: PUSHJ SP,U.13 ; 2422 JRST L.88 L.86: PUSHJ SP,U.12 ; 2429 JRST L.88 L.87: PUSHJ SP,U.11 ; 2435 L.88: MOVEM AC1,U.98 JRST L.81 ; 2415 L.89: MOVEI AC16,1 ; 2442 L.90: PUSHJ SP,U.15 ; 2479 MOVE AC1,AC16 ; 2406 POP SP,AC16 ; 2367 POPJ SP, C.30: XWD 0,P.AAF ; Routine Size: 54 words ; 2483 %SBTTL 'REC%INIT' ; 2484 ROUTINE REC%INIT = ; 2485 ; 2486 !++ ; 2487 ! FUNCTIONAL DESCRIPTION: ; 2488 ! ; 2489 ! This routine will process an initialization message received from ; 2490 ! the remote KERMIT. ; 2491 ! ; 2492 ! CALLING SEQUENCE: ; 2493 ! ; 2494 ! STATE = REC%INIT(); ; 2495 ! ; 2496 ! INPUT PARAMETERS: ; 2497 ! ; 2498 ! None. ; 2499 ! ; 2500 ! IMPLICIT INPUTS: ; 2501 ! ; 2502 ! None. ; 2503 ! ; 2504 ! OUTPUT PARAMETERS: ; 2505 ! ; 2506 ! New machine state. ; 2507 ! ; 2508 ! IMPLICIT OUTPUTS: ; 2509 ! ; 2510 ! None. ; 2511 ! ; 2512 ! COMPLETION CODES: ; 2513 ! ; 2514 ! None. ; 2515 ! ; 2516 ! SIDE EFFECTS: ; 2517 ! ; 2518 ! None. ; 2519 ! ; 2520 !-- ; 2521 ; 2522 BEGIN ; 2523 ROUTINE CHECK%INIT = ; 2524 BEGIN ; 2525 ; 2526 IF .REC%TYPE EQL MSG%SND%INIT THEN RETURN TRUE ELSE RETURN FALSE; ; 2527 ; 2528 END; ; CHECK%INIT U.112: MOVEI AC1,123 ; 2526 CAME AC1,U.105 JRST L.91 MOVEI AC1,1 ; 2524 POPJ SP, L.91: SETZ AC1, POPJ SP, ; 2523 ; Routine Size: 7 words ; 2529 ; 2530 IF NOT REC%MESSAGE (CHECK%INIT) THEN RETURN STATE%A; ; 2531 ; 2532 MSG%NUMBER = .REC%SEQ; ; 2533 ; 2534 IF NOT (STATUS = PRS%SEND%INIT ()) THEN RETURN STATE%A; ; 2535 ; 2536 SET%SEND%INIT (); ; 2537 SEND%PACKET (MSG%ACK, P%SI%LENGTH, .MSG%NUMBER); ; 2538 BLK%CHK%TYPE = .INI%CHK%TYPE; ! Can now use agreed upon type ; 2539 OLD%RETRIES = .NUM%RETRIES; ; 2540 NUM%RETRIES = 0; ; 2541 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 2542 RETURN STATE%RF; ; 2543 END; ! End of REC%INIT ; REC%INIT U.11: PUSH SP,C.31 ; 2530 PUSHJ SP,U.22 ADJSP SP,-1 TRNN AC1,1 JRST L.92 MOVE AC1,U.103 ; 2532 MOVEM AC1,U.102 PUSHJ SP,U.18 ; 2534 MOVEM AC1,U.97 TRNE AC1,1 JRST L.93 L.92: MOVEI AC1,12 POPJ SP, L.93: PUSHJ SP,U.17 ; 2536 PUSH SP,C.3 ; 2537 PUSH SP,C.4 PUSH SP,U.102 PUSHJ SP,U.21 MOVE AC1,U.93 ; 2538 MOVEM AC1,U.94 MOVE AC1,U.101 ; 2539 MOVEM AC1,U.100 SETZM U.101 ; 2540 MOVE AC1,U.102 ; 2541 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 ADJSP SP,-3 ; 2484 MOVEI AC1,7 ; 2522 POPJ SP, ; 2484 C.31: XWD 0,U.112 ; Routine Size: 31 words ; 2544 %SBTTL 'REC%FILE' ; 2545 ROUTINE REC%FILE = ; 2546 ; 2547 !++ ; 2548 ! FUNCTIONAL DESCRIPTION: ; 2549 ! ; 2550 ! This routine expects to receive an MSG%FILE packet from the remote ; 2551 ! KERMIT. If the message is correct this routine will change the state ; 2552 ! to STATE%RD. ; 2553 ! ; 2554 ! This routine also expects MSG%SND%INIT, MSG%EOF, or MSG%BREAK. ; 2555 ! ; 2556 ! CALLING SEQUENCE: ; 2557 ! ; 2558 ! STATE = REC%FILE(); ; 2559 ! ; 2560 ! INPUT PARAMETERS: ; 2561 ! ; 2562 ! None. ; 2563 ! ; 2564 ! IMPLICIT INPUTS: ; 2565 ! ; 2566 ! None. ; 2567 ! ; 2568 ! OUTPUT PARAMETERS: ; 2569 ! ; 2570 ! New state. ; 2571 ! ; 2572 ! IMPLICIT OUTPUTS: ; 2573 ! ; 2574 ! None. ; 2575 ! ; 2576 ! COMPLETION CODES: ; 2577 ! ; 2578 ! None. ; 2579 ! ; 2580 ! SIDE EFFECTS: ; 2581 ! ; 2582 ! None. ; 2583 ! ; 2584 !-- ; 2585 ; 2586 BEGIN ; 2587 ROUTINE CHECK%FILE = ; 2588 BEGIN ; 2589 ; 2590 IF (.REC%TYPE EQL MSG%SND%INIT) OR (.REC%TYPE EQL MSG%EOF) OR (.REC%TYPE EQL MSG%FILE) OR ( ; 2591 .REC%TYPE EQL MSG%BREAK) ; 2592 THEN ; 2593 RETURN TRUE ; 2594 ELSE ; 2595 RETURN FALSE; ; 2596 ; 2597 END; ; CHECK%FILE U.113: MOVE AC1,U.105 ; 2590 CAIE AC1,123 CAIN AC1,132 JRST L.94 CAIN AC1,106 JRST L.94 CAIE AC1,102 JRST L.95 L.94: MOVEI AC1,1 ; 2588 POPJ SP, L.95: SETZ AC1, POPJ SP, ; 2587 ; Routine Size: 12 words ; 2598 ! ; 2599 ! Initialize the abort flags ; 2600 ! ; 2601 ABT%CUR%FILE = FALSE; ; 2602 ABT%ALL%FILE = FALSE; ; 2603 ! ; 2604 ! Get a message ; 2605 ! ; 2606 ; 2607 IF NOT REC%MESSAGE (CHECK%FILE) THEN RETURN STATE%A; ; 2608 ; 2609 SELECTONE .REC%TYPE OF ; 2610 SET ; 2611 ; 2612 [MSG%SND%INIT] : ; 2613 BEGIN ; 2614 ; 2615 IF .OLD%RETRIES GTR .SI%RETRIES THEN RETURN STATE%A; ; 2616 ; 2617 OLD%RETRIES = .OLD%RETRIES + 1; ; 2618 ; 2619 IF .MSG%NUMBER - 1 EQL .REC%SEQ ; 2620 THEN ; 2621 BEGIN ; 2622 SET%SEND%INIT (); ; 2623 BLK%CHK%TYPE = CHK%1CHAR; ! Must use 1 character CHKSUM ; 2624 SEND%PACKET (MSG%ACK, P%SI%LENGTH, .REC%SEQ); ; 2625 BLK%CHK%TYPE = .INI%CHK%TYPE; ! Back to agreed upon type ; 2626 NUM%RETRIES = 0; ; 2627 RETURN .STATE; ; 2628 END ; 2629 ELSE ; 2630 RETURN STATE%A; ; 2631 ; 2632 END; ; 2633 ; 2634 [MSG%EOF] : ; 2635 BEGIN ; 2636 ; 2637 IF .OLD%RETRIES GTR .PKT%RETRIES THEN RETURN STATE%A; ; 2638 ; 2639 OLD%RETRIES = .OLD%RETRIES + 1; ; 2640 ; 2641 IF .MSG%NUMBER - 1 EQL .REC%SEQ ; 2642 THEN ; 2643 BEGIN ; 2644 SEND%PACKET (MSG%ACK, 0, .REC%SEQ); ; 2645 NUM%RETRIES = 0; ; 2646 RETURN .STATE; ; 2647 END ; 2648 ELSE ; 2649 RETURN STATE%A; ; 2650 ; 2651 END; ; 2652 ; 2653 [MSG%FILE] : ; 2654 BEGIN ; 2655 ; 2656 IF .MSG%NUMBER NEQ .REC%SEQ THEN RETURN STATE%A; ; 2657 ; 2658 IF .REC%LENGTH EQL 0 ; 2659 THEN ; 2660 BEGIN ; 2661 KRM%ERROR (KER%PROTOERR); ; 2662 RETURN STATE%A; ; 2663 END; ; 2664 ; 2665 FILE%SIZE = .REC%LENGTH; ; 2666 CH$COPY (.REC%LENGTH, CH$PTR (REC%MSG, PKT%MSG, CHR%SIZE), CHR%NUL, MAX%FILE%NAME, ; 2667 CH$PTR (FILE%NAME)); ; 2668 ; 2669 IF ( NOT .CONNECT%FLAG) AND .TY%FIL ; 2670 THEN ; 2671 BEGIN ; 2672 TT%TEXT (UPLIT (%ASCIZ'Receiving: ')); ; 2673 TT%TEXT (FILE%NAME); ; 2674 TT%OUTPUT (); ; 2675 END; ; 2676 ; 2677 IF NOT FILE%OPEN (FNC%WRITE) THEN RETURN STATE%A; ; 2678 ; 2679 FILE%OPEN%FLAG = TRUE; ; 2680 SEND%PACKET (MSG%ACK, 0, .MSG%NUMBER); ; 2681 OLD%RETRIES = .NUM%RETRIES; ; 2682 NUM%RETRIES = 0; ; 2683 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 2684 RETURN STATE%RD; ; 2685 END; ; 2686 ; 2687 [MSG%BREAK] : ; 2688 BEGIN ; 2689 ; 2690 IF .MSG%NUMBER NEQ .REC%SEQ THEN RETURN STATE%A; ; 2691 ; 2692 SEND%PACKET (MSG%ACK, 0, .REC%SEQ); ; 2693 RETURN STATE%C; ; 2694 END; ; 2695 ; 2696 [OTHERWISE] : ; 2697 RETURN STATE%A; ; 2698 TES; ; 2699 ; 2700 END; ! End of REC%FILE P.AAG: BYTE (7)"R","e","c","e","i" BYTE (7)"v","i","n","g",":" BYTE (7)" ",000,000,000,000 ; REC%FILE U.12: SETZM ABT%CUR%FILE ; 2601 SETZM ABT%ALL%FILE ; 2602 PUSH SP,C.32 ; 2607 PUSHJ SP,U.22 ADJSP SP,-1 TRNN AC1,1 JRST L.102 MOVE AC1,U.105 ; 2609 CAIE AC1,123 JRST L.96 MOVE AC2,U.100 ; 2615 CAMLE AC2,SI%RETRIES JRST L.102 AOS U.100 ; 2617 MOVE AC1,U.102 ; 2619 SUBI AC1,1 CAME AC1,U.103 JRST L.102 PUSHJ SP,U.17 ; 2622 MOVEI AC1,61 ; 2623 MOVEM AC1,U.94 PUSH SP,C.3 ; 2624 PUSH SP,C.4 PUSH SP,U.103 PUSHJ SP,U.21 MOVE AC1,U.93 ; 2625 MOVEM AC1,U.94 JRST L.97 L.96: CAIE AC1,132 ; 2609 JRST L.98 MOVE AC2,U.100 ; 2637 CAMLE AC2,PKT%RETRIES JRST L.102 AOS U.100 ; 2639 MOVE AC1,U.102 ; 2641 SUBI AC1,1 CAME AC1,U.103 JRST L.102 PUSH SP,C.3 ; 2644 PUSH SP,C.10 PUSH SP,U.103 PUSHJ SP,U.21 L.97: SETZM U.101 ; 2645 ADJSP SP,-3 ; 2643 MOVE AC1,U.98 ; 2635 POPJ SP, L.98: CAIE AC1,106 ; 2609 JRST L.101 MOVE AC1,U.102 ; 2656 CAME AC1,U.103 JRST L.102 SKIPE U.104 ; 2658 JRST L.99 PUSH SP,C.7 ; 2661 PUSHJ SP,KRM%ERROR ADJSP SP,-1 ; 2658 JRST L.102 L.99: MOVE AC1,U.104 ; 2665 MOVEM AC1,FILE%SIZE MOVE AC1,U.104 ; 2666 MOVE AC2,C.5 MOVEI AC4,204 MOVE AC5,C.6 EXTEND AC1,C.2 JFCL MOVEI AC1,1 ; 2669 TDNE AC1,CONNECT%FLAG JRST L.100 MOVEI AC1,1 TDNN AC1,TY%FIL JRST L.100 PUSH SP,C.33 ; 2672 PUSHJ SP,TT%TEXT PUSH SP,C.25 ; 2673 PUSHJ SP,TT%TEXT PUSHJ SP,TT%OUTPUT ; 2674 ADJSP SP,-2 ; 2671 L.100: PUSH SP,C.14 ; 2677 PUSHJ SP,FILE%OPEN ADJSP SP,-1 TRNN AC1,1 JRST L.102 MOVEI AC1,1 ; 2679 MOVEM AC1,U.108 PUSH SP,C.3 ; 2680 PUSH SP,C.10 PUSH SP,U.102 PUSHJ SP,U.21 MOVE AC1,U.101 ; 2681 MOVEM AC1,U.100 SETZM U.101 ; 2682 MOVE AC1,U.102 ; 2683 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 ADJSP SP,-3 ; 2654 MOVEI AC1,10 ; 2609 POPJ SP, L.101: CAIE AC1,102 JRST L.102 MOVE AC1,U.102 ; 2690 CAME AC1,U.103 JRST L.102 PUSH SP,C.3 ; 2692 PUSH SP,C.10 PUSH SP,U.103 PUSHJ SP,U.21 ADJSP SP,-3 ; 2688 MOVEI AC1,11 ; 2609 POPJ SP, L.102: MOVEI AC1,12 POPJ SP, ; 2545 C.32: XWD 0,U.113 C.33: XWD 0,P.AAG ; Routine Size: 114 words ; 2701 %SBTTL 'REC%DATA' ; 2702 ROUTINE REC%DATA = ; 2703 ; 2704 !++ ; 2705 ! FUNCTIONAL DESCRIPTION: ; 2706 ! ; 2707 ! This routine will accept data messages and write them to disk. ; 2708 ! It will also accept MSG%FILE and MSG%EOF messages. ; 2709 ! ; 2710 ! CALLING SEQUENCE: ; 2711 ! ; 2712 ! STATE = REC%DATA(); ; 2713 ! ; 2714 ! INPUT PARAMETERS: ; 2715 ! ; 2716 ! None. ; 2717 ! ; 2718 ! IMPLICIT INPUTS: ; 2719 ! ; 2720 ! None. ; 2721 ! ; 2722 ! OUTPUT PARAMETERS: ; 2723 ! ; 2724 ! New state for the finite state machine. ; 2725 ! ; 2726 ! IMPLICIT OUTPUTS: ; 2727 ! ; 2728 ! None. ; 2729 ! ; 2730 ! COMPLETION CODES: ; 2731 ! ; 2732 ! None. ; 2733 ! ; 2734 ! SIDE EFFECTS: ; 2735 ! ; 2736 ! None. ; 2737 ! ; 2738 !-- ; 2739 ; 2740 BEGIN ; 2741 ROUTINE CHECK%DATA = ; 2742 BEGIN ; 2743 ; 2744 IF .REC%TYPE EQL MSG%DATA OR .REC%TYPE EQL MSG%FILE OR .REC%TYPE EQL MSG%EOF ; 2745 THEN ; 2746 RETURN TRUE ; 2747 ELSE ; 2748 RETURN FALSE; ; 2749 ; 2750 END; ; CHECK%DATA U.114: MOVE AC1,U.105 ; 2744 CAIE AC1,104 CAIN AC1,106 JRST L.103 CAIE AC1,132 JRST L.104 L.103: MOVEI AC1,1 ; 2742 POPJ SP, L.104: SETZ AC1, POPJ SP, ; 2741 ; Routine Size: 10 words ; 2751 ; 2752 LOCAL ; 2753 DISCARD%FILE%FLAG, ! Sender requested discard ; 2754 ACK%MSG%LEN; ! Length of ACK to send ; 2755 ; 2756 ! ; 2757 ! First get a message ; 2758 ! ; 2759 ; 2760 IF NOT REC%MESSAGE (CHECK%DATA) THEN RETURN STATE%A; ; 2761 ; 2762 SELECTONE .REC%TYPE OF ; 2763 SET ; 2764 ; 2765 [MSG%DATA] : ; 2766 BEGIN ; 2767 ; 2768 IF .MSG%NUMBER NEQ .REC%SEQ ; 2769 THEN ; 2770 BEGIN ; 2771 ; 2772 IF .OLD%RETRIES GTR .PKT%RETRIES THEN RETURN STATE%A; ; 2773 ; 2774 OLD%RETRIES = .OLD%RETRIES + 1; ; 2775 ; 2776 IF .MSG%NUMBER - 1 EQL .REC%SEQ ; 2777 THEN ; 2778 BEGIN ; 2779 SEND%PACKET (MSG%ACK, 0, .REC%SEQ); ; 2780 NUM%RETRIES = 0; ; 2781 RETURN .STATE; ; 2782 END ; 2783 ELSE ; 2784 RETURN STATE%A; ; 2785 ; 2786 END; ; 2787 ; 2788 ! ; 2789 ! Here if we have a message with a valid message number ; 2790 ! ; 2791 ; 2792 IF NOT BFR%EMPTY () THEN RETURN STATE%A; ; 2793 ; 2794 ! ; 2795 ! Check if we wish to abort for some reason ; 2796 ! ; 2797 ; 2798 IF .ABT%CUR%FILE ; 2799 THEN ; 2800 BEGIN ; 2801 CH$WCHAR (MSG%ACK%ABT%CUR, CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE)); ; 2802 ACK%MSG%LEN = 1; ; 2803 END ; 2804 ELSE ; 2805 ; 2806 IF .ABT%ALL%FILE ; 2807 THEN ; 2808 BEGIN ; 2809 CH$WCHAR (MSG%ACK%ABT%ALL, CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE)); ; 2810 ACK%MSG%LEN = 1; ; 2811 END ; 2812 ELSE ; 2813 ACK%MSG%LEN = 0; ; 2814 ; 2815 ! ; 2816 ! Now send the ACK ; 2817 ! ; 2818 SEND%PACKET (MSG%ACK, .ACK%MSG%LEN, .REC%SEQ); ; 2819 OLD%RETRIES = .NUM%RETRIES; ; 2820 NUM%RETRIES = 0; ; 2821 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 2822 RETURN STATE%RD; ; 2823 END; ; 2824 ; 2825 [MSG%FILE] : ; 2826 BEGIN ; 2827 ; 2828 IF .OLD%RETRIES GTR .PKT%RETRIES THEN RETURN STATE%A; ; 2829 ; 2830 OLD%RETRIES = .OLD%RETRIES + 1; ; 2831 ; 2832 IF .MSG%NUMBER - 1 EQL .REC%SEQ ; 2833 THEN ; 2834 BEGIN ; 2835 SEND%PACKET (MSG%ACK, 0, .REC%SEQ); ; 2836 NUM%RETRIES = 0; ; 2837 RETURN .STATE; ; 2838 END ; 2839 ELSE ; 2840 RETURN STATE%A; ; 2841 ; 2842 END; ; 2843 ; 2844 [MSG%EOF] : ; 2845 BEGIN ; 2846 ; 2847 IF .MSG%NUMBER NEQ .REC%SEQ THEN RETURN STATE%A; ; 2848 ; 2849 SEND%PACKET (MSG%ACK, 0, .REC%SEQ); ; 2850 FILE%OPEN%FLAG = FALSE; ; 2851 DISCARD%FILE%FLAG = FALSE; ! Assume we want file ; 2852 ; 2853 IF .REC%LENGTH EQL 1 ; 2854 THEN ; 2855 ; 2856 IF CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG, CHR%SIZE)) EQL MSG%EOF%DISCARD ; 2857 THEN ; 2858 DISCARD%FILE%FLAG = .ABT%FLAG; ; 2859 ; 2860 IF ( NOT .CONNECT%FLAG) AND .TY%FIL ; 2861 THEN ; 2862 BEGIN ; 2863 ; 2864 IF .DISCARD%FILE%FLAG ; 2865 THEN ; 2866 ; 2867 IF .ABT%FLAG ; 2868 THEN ; 2869 TT%TEXT (UPLIT (%ASCIZ' [Interrupted]')) ; 2870 ELSE ; 2871 TT%TEXT (UPLIT (%ASCIZ' [Interrupted, partial file saved]')) ; 2872 ; 2873 ELSE ; 2874 TT%TEXT (UPLIT (%ASCIZ' [OK]')); ; 2875 ; 2876 TT%CRLF (); ; 2877 END; ; 2878 ; 2879 IF NOT FILE%CLOSE (.DISCARD%FILE%FLAG) THEN RETURN STATE%A; ; 2880 ; 2881 MSG%NUMBER = (.MSG%NUMBER + 1) AND %O'77'; ; 2882 RETURN STATE%RF; ; 2883 END; ; 2884 ; 2885 [OTHERWISE] : ; 2886 RETURN STATE%A; ; 2887 TES; ; 2888 ; 2889 END; ! End of REC%DATA P.AAH: BYTE (7)" ","[","I","n","t" BYTE (7)"e","r","r","u","p" BYTE (7)"t","e","d","]",000 P.AAI: BYTE (7)" ","[","I","n","t" BYTE (7)"e","r","r","u","p" BYTE (7)"t","e","d",","," " BYTE (7)"p","a","r","t","i" BYTE (7)"a","l"," ","f","i" BYTE (7)"l","e"," ","s","a" BYTE (7)"v","e","d","]",000 P.AAJ: BYTE (7)" ","[","O","K","]" BYTE (7)000,000,000,000,000 ; REC%DATA U.13: PUSH SP,AC16 ; 2702 PUSH SP,C.34 ; 2760 PUSHJ SP,U.22 ADJSP SP,-1 TRNN AC1,1 JRST L.119 MOVE AC1,U.105 ; 2762 CAIE AC1,104 JRST L.110 MOVE AC2,U.102 ; 2768 CAMN AC2,U.103 JRST L.105 MOVE AC1,U.100 ; 2772 CAMLE AC1,PKT%RETRIES JRST L.119 AOS U.100 ; 2774 MOVE AC1,U.102 ; 2776 SUBI AC1,1 CAMN AC1,U.103 JRST L.111 JRST L.119 ; 2784 L.105: PUSHJ SP,U.24 ; 2792 TRNN AC1,1 JRST L.119 MOVEI AC1,1 ; 2798 TDNN AC1,ABT%CUR%FILE JRST L.106 MOVEI AC2,130 ; 2801 JRST L.107 L.106: MOVEI AC1,1 ; 2806 TDNN AC1,ABT%ALL%FILE JRST L.108 MOVEI AC2,132 ; 2809 L.107: MOVE AC1,C.12 IDPB AC2,AC1 MOVEI AC3,1 ; 2810 JRST L.109 ; 2806 L.108: SETZ AC3, ; 2813 L.109: PUSH SP,C.3 ; 2818 PUSH SP,AC3 PUSH SP,U.103 PUSHJ SP,U.21 MOVE AC1,U.101 ; 2819 MOVEM AC1,U.100 SETZM U.101 ; 2820 MOVE AC1,U.102 ; 2821 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 ADJSP SP,-3 ; 2766 MOVEI AC1,10 ; 2762 JRST L.120 L.110: CAIE AC1,106 JRST L.112 MOVE AC1,U.100 ; 2828 CAMLE AC1,PKT%RETRIES JRST L.119 AOS U.100 ; 2830 MOVE AC1,U.102 ; 2832 SUBI AC1,1 CAME AC1,U.103 JRST L.119 L.111: PUSH SP,C.3 ; 2835 PUSH SP,C.10 PUSH SP,U.103 PUSHJ SP,U.21 SETZM U.101 ; 2836 ADJSP SP,-3 ; 2834 MOVE AC1,U.98 ; 2826 JRST L.120 L.112: CAIE AC1,132 ; 2762 JRST L.119 MOVE AC1,U.102 ; 2847 CAME AC1,U.103 JRST L.119 PUSH SP,C.3 ; 2849 PUSH SP,C.10 PUSH SP,U.103 PUSHJ SP,U.21 SETZB AC16,U.108 ; 2850 MOVEI AC1,1 ; 2853 CAME AC1,U.104 JRST L.113 MOVE AC1,C.5 ; 2856 ILDB AC1,AC1 CAIN AC1,104 MOVE AC16,ABT%FLAG ; 2858 L.113: MOVEI AC1,1 ; 2860 TDNE AC1,CONNECT%FLAG JRST L.117 MOVEI AC1,1 TDNN AC1,TY%FIL JRST L.117 TRNN AC16,1 ; 2864 JRST L.115 MOVEI AC1,1 ; 2867 TDNN AC1,ABT%FLAG JRST L.114 PUSH SP,C.35 ; 2869 JRST L.116 L.114: PUSH SP,C.36 ; 2871 JRST L.116 L.115: PUSH SP,C.37 ; 2874 L.116: PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 2876 ADJSP SP,-1 ; 2862 L.117: MOVEM AC16,0(SP) ; 2879 PUSHJ SP,FILE%CLOSE TRNE AC1,1 JRST L.118 ADJSP SP,-3 JRST L.119 L.118: MOVE AC1,U.102 ; 2881 ADDI AC1,1 LDB AC2,C.1 MOVEM AC2,U.102 ADJSP SP,-3 ; 2845 MOVEI AC1,7 ; 2762 JRST L.120 L.119: MOVEI AC1,12 L.120: POP SP,AC16 ; 2702 POPJ SP, C.34: XWD 0,U.114 C.35: XWD 0,P.AAH C.36: XWD 0,P.AAI C.37: XWD 0,P.AAJ ; Routine Size: 126 words ; 2890 %SBTTL 'CLEAR' ; 2891 ROUTINE CLEAR : NOVALUE = ; 2892 ; 2893 !++ ; 2894 ! FUNCTIONAL DESCRIPTION: ; 2895 ! ; 2896 ! This routine will clear the message buffer. ; 2897 ! ; 2898 ! CALLING SEQUENCE: ; 2899 ! ; 2900 ! CLEAR(); ; 2901 ! ; 2902 ! INPUT PARAMETERS: ; 2903 ! ; 2904 ! None. ; 2905 ! ; 2906 ! IMPLICIT INPUTS: ; 2907 ! ; 2908 ! None. ; 2909 ! ; 2910 ! OUTPUT PARAMETERS: ; 2911 ! ; 2912 ! None. ; 2913 ! ; 2914 ! IMPLICIT OUTPUTS: ; 2915 ! ; 2916 ! None. ; 2917 ! ; 2918 ! COMPLETION CODES: ; 2919 ! ; 2920 ! None. ; 2921 ! ; 2922 ! SIDE EFFECTS: ; 2923 ! ; 2924 ! None. ; 2925 ! ; 2926 !-- ; 2927 ; 2928 BEGIN ; 2929 CH$FILL (0, MAX%MSG, CH$PTR (SND%MSG, 0, CHR%SIZE)); ; 2930 END; ; CLEAR U.26: SETZ AC1, ; 2929 MOVEI AC4,140 MOVE AC5,C.38 EXTEND AC1,C.2 JFCL POPJ SP, ; 2891 C.38: POINT 8,U.107-1,31 ; Routine Size: 7 words ; 2931 %SBTTL 'Message processing -- PRS%SEND%INIT - Parse send init params' ; 2932 ROUTINE PRS%SEND%INIT = ; 2933 ; 2934 !++ ; 2935 ! FUNCTIONAL DESCRIPTION: ; 2936 ! ; 2937 ! This routine will parse the SEND%INIT parameters that were sent by ; 2938 ! the remote Kermit. The items will be stored into the low segment. ; 2939 ! ; 2940 ! CALLING SEQUENCE: ; 2941 ! ; 2942 ! PRS%SEND%INIT (); ; 2943 ! ; 2944 ! INPUT PARAMETERS: ; 2945 ! ; 2946 ! None. ; 2947 ! ; 2948 ! IMPLICIT INPUTS: ; 2949 ! ; 2950 ! Message stored in REC%MSG. ; 2951 ! ; 2952 ! OUTPUT PARAMETERS: ; 2953 ! ; 2954 ! None. ; 2955 ! ; 2956 ! IMPLICIT OUTPUTS: ; 2957 ! ; 2958 ! None. ; 2959 ! ; 2960 ! COMPLETION CODES: ; 2961 ! ; 2962 ! None. ; 2963 ! ; 2964 ! SIDE EFFECTS: ; 2965 ! ; 2966 ! None. ; 2967 ! ; 2968 !-- ; 2969 ; 2970 BEGIN ; 2971 ! The following section of code will parse the various send parameters ; 2972 ! that are found in the send-init message. The following code will store ; 2973 ! the following as the value. ; 2974 ! ; 2975 ! If the user specified a value then the user supplied value will be used else ; 2976 ! the value in the message and if none in the message then the default value. ; 2977 ! ; 2978 ! User supplied values are denoted as positive values in SND%xxxxxxx. ; 2979 ! ; 2980 ! Parse the packet size ; 2981 ! ; 2982 SEND%PKT%SIZE = (IF .SND%PKT%SIZE GEQ 0 THEN .SND%PKT%SIZE ELSE ; 2983 BEGIN ; 2984 ; 2985 IF .REC%LENGTH GTR P%SI%BUFSIZ ; 2986 THEN ; P 2987 UNCHAR (CH$RCHAR (CH$PTR (REC%MSG, ; 2988 PKT%MSG + P%SI%BUFSIZ, CHR%SIZE))) ; 2989 ELSE ; 2990 ABS (.SND%PKT%SIZE) ; 2991 ; 2992 END ; 2993 ); ; 2994 ! ; 2995 ! Parse the time out value ; 2996 ! ; 2997 SEND%TIMEOUT = (IF .SND%TIMEOUT GEQ 0 THEN .SND%TIMEOUT ELSE ; 2998 BEGIN ; 2999 ; 3000 IF .REC%LENGTH GTR P%SI%TIMOUT ; 3001 THEN ; P 3002 UNCHAR (CH$RCHAR (CH$PTR (REC%MSG, ; 3003 PKT%MSG + P%SI%TIMOUT, CHR%SIZE))) ; 3004 ELSE ; 3005 ABS (.SND%TIMEOUT) ; 3006 ; 3007 END ; 3008 ); ; 3009 ! ; 3010 ! Parse the number of padding characters supplied ; 3011 ! ; 3012 SEND%NPAD = (IF .SND%NPAD GEQ 0 THEN .SND%NPAD ELSE ; 3013 BEGIN ; 3014 ; 3015 IF .REC%LENGTH GTR P%SI%NPAD ; 3016 THEN ; P 3017 UNCHAR (CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG + P%SI%NPAD, ; 3018 CHR%SIZE))) ; 3019 ELSE ; 3020 ABS (.SND%NPAD) ; 3021 ; 3022 END ; 3023 ); ; 3024 ! ; 3025 ! Parse the padding character ; 3026 ! ; 3027 SEND%PADCHAR = (IF .SND%PADCHAR GEQ 0 THEN .SND%PADCHAR ELSE ; 3028 BEGIN ; 3029 ; 3030 IF .REC%LENGTH GTR P%SI%PAD ; 3031 THEN ; P 3032 CTL (CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG + P%SI%PAD, ; 3033 CHR%SIZE))) ; 3034 ELSE ; 3035 ABS (.SND%PADCHAR) ; 3036 ; 3037 END ; 3038 ); ; 3039 ! ; 3040 ! Parse the end of line character ; 3041 ! ; 3042 SEND%EOL = (IF .SND%EOL GEQ 0 THEN .SND%EOL ELSE ; 3043 BEGIN ; 3044 ; 3045 IF .REC%LENGTH GTR P%SI%EOL ; 3046 THEN ; P 3047 UNCHAR (CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG + P%SI%EOL, ; 3048 CHR%SIZE))) ; 3049 ELSE ; 3050 ABS (.SND%EOL) ; 3051 ; 3052 END ; 3053 ); ; 3054 ! ; 3055 ! Parse the quoting character ; 3056 ! ; 3057 SEND%QUOTE%CHR = (IF .SND%QUOTE%CHR GEQ 0 THEN .SND%QUOTE%CHR ELSE ; 3058 BEGIN ; 3059 ; 3060 IF .REC%LENGTH GTR P%SI%QUOTE ; 3061 THEN ; 3062 CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG + P%SI%QUOTE, ; 3063 CHR%SIZE)) ; 3064 ELSE ; 3065 ABS (.SND%QUOTE%CHR) ; 3066 ; 3067 END ; 3068 ); ; 3069 ! ; 3070 ! Parse the 8-bit quoting character ; 3071 ! ; 3072 ! If the character was not included in the packet, assume no eight-bit ; 3073 ! quoting allowed (we are probably talking to an old version of Kermit). ; 3074 ! ; 3075 SEND%8QUOTE%CHR = (IF .REC%LENGTH GTR P%SI%8QUOTE THEN CH$RCHAR (CH$PTR (REC%MSG, ; 3076 PKT%MSG + P%SI%8QUOTE, CHR%SIZE)) ELSE %C'N' ! Assume no 8-bit quoting allowed ; 3077 ); ; 3078 ! ; 3079 ! Parse the checksum type ; 3080 ! ; 3081 ; 3082 IF .REC%LENGTH GTR P%SI%CHKTYPE ; 3083 THEN ; 3084 BEGIN ; 3085 ; 3086 IF CH$RCHAR (CH$PTR (REC%MSG, PKT%MSG + P%SI%CHKTYPE, CHR%SIZE)) NEQ .CHKTYPE ; 3087 THEN ; 3088 INI%CHK%TYPE = CHK%1CHAR ; 3089 ; 3090 END ; 3091 ELSE ; 3092 INI%CHK%TYPE = CHK%1CHAR; ! Only single character checksum if not specified ; 3093 ; 3094 ! ; 3095 ! Parse the repeat character ; 3096 ! ; 3097 REPT%CHR = (IF .REC%LENGTH GTR P%SI%REPEAT THEN CH$RCHAR (CH$PTR (REC%MSG, ; 3098 PKT%MSG + P%SI%REPEAT, CHR%SIZE)) ELSE %C' '); ; 3099 ! ; 3100 ! Check for a valid quoting character. If it is not valid, then we have ; 3101 ! a protocol error ; 3102 ! ; 3103 ; 3104 IF NOT ((.SEND%QUOTE%CHR GEQ %O'41' AND .SEND%QUOTE%CHR LEQ %O'76') OR (.SEND%QUOTE%CHR GEQ %O ; 3105 '140' AND .SEND%QUOTE%CHR LEQ %O'176')) ; 3106 THEN ; 3107 BEGIN ; 3108 KRM%ERROR (KER%PROTOERR); ; 3109 RETURN KER%PROTOERR; ; 3110 END; ; 3111 ; 3112 ! ; 3113 ! Check for a valid 8 bit quoting and set the 8 bit quoting flag as needed ; 3114 ! ; 3115 ; 3116 IF ( NOT ((.SEND%8QUOTE%CHR GEQ %O'041' AND .SEND%8QUOTE%CHR LEQ %O'076') OR (.SEND%8QUOTE%CHR ; 3117 GEQ %O'140' AND .SEND%8QUOTE%CHR LEQ %O'176') OR (.SEND%8QUOTE%CHR EQL %C'N') OR ( ; 3118 .SEND%8QUOTE%CHR EQL %C'Y'))) OR .SEND%8QUOTE%CHR EQL .SEND%QUOTE%CHR ; 3119 THEN ; 3120 BEGIN ; 3121 KRM%ERROR (KER%PROTOERR); ; 3122 RETURN KER%PROTOERR; ; 3123 END; ; 3124 ; 3125 IF .SEND%8QUOTE%CHR EQL %C'Y' THEN SEND%8QUOTE%CHR = .RECV%8QUOTE%CHR; ; 3126 ; 3127 IF .SEND%8QUOTE%CHR NEQ %C'N' AND .SEND%8QUOTE%CHR NEQ %C'Y' ; 3128 THEN ; 3129 FLAG%8QUOTE = TRUE ; 3130 ELSE ; 3131 FLAG%8QUOTE = FALSE; ; 3132 ; 3133 ! ; 3134 ! Check the repeat character and set flags ; 3135 ! ; 3136 ; 3137 IF ( NOT ((.REPT%CHR GEQ %O'41' AND .REPT%CHR LEQ %O'76') OR (.REPT%CHR GEQ %O'140' AND ; 3138 .REPT%CHR LEQ %O'176')) OR .REPT%CHR EQL .SEND%QUOTE%CHR OR .REPT%CHR EQL .SEND%8QUOTE%CHR) ; 3139 AND .REPT%CHR NEQ %C' ' ; 3140 THEN ; 3141 BEGIN ; 3142 KRM%ERROR (KER%PROTOERR); ; 3143 RETURN KER%PROTOERR; ; 3144 END; ; 3145 ; 3146 IF .REPT%CHR NEQ %C' ' THEN FLAG%REPEAT = TRUE ELSE FLAG%REPEAT = FALSE; ; 3147 ; 3148 RETURN KER%NORMAL; ; 3149 END; ! End of PRS%SEND%INIT ; PRS%SEND%INIT U.18: MOVE AC1,SND%PKT%SIZE ; 2982 JUMPGE AC1,L.122 SKIPG U.104 ; 2985 JRST L.121 MOVE AC1,C.5 ; 2988 ILDB AC1,AC1 SUBI AC1,40 JRST L.122 ; 2983 L.121: MOVM AC1,AC1 ; 2990 L.122: MOVEM AC1,U.86 ; 2982 MOVE AC1,SND%TIMEOUT ; 2997 JUMPGE AC1,L.124 MOVEI AC2,1 ; 3000 CAML AC2,U.104 JRST L.123 MOVE AC1,C.39 ; 3003 ILDB AC1,AC1 SUBI AC1,40 JRST L.124 ; 2998 L.123: MOVM AC1,AC1 ; 3005 L.124: MOVEM AC1,U.89 ; 2997 MOVE AC1,SND%NPAD ; 3012 JUMPGE AC1,L.126 MOVEI AC2,2 ; 3015 CAML AC2,U.104 JRST L.125 MOVE AC1,C.40 ; 3018 ILDB AC1,AC1 SUBI AC1,40 JRST L.126 ; 3013 L.125: MOVM AC1,AC1 ; 3020 L.126: MOVEM AC1,U.87 ; 3012 MOVE AC1,SND%PADCHAR ; 3027 JUMPGE AC1,L.128 MOVEI AC2,3 ; 3030 CAML AC2,U.104 JRST L.127 MOVE AC1,C.41 ; 3033 ILDB AC1,AC1 TRCA AC1,100 L.127: MOVM AC1,AC1 ; 3035 L.128: MOVEM AC1,U.88 ; 3027 MOVE AC1,SND%EOL ; 3042 JUMPGE AC1,L.130 MOVEI AC2,4 ; 3045 CAML AC2,U.104 JRST L.129 MOVE AC1,C.42 ; 3048 ILDB AC1,AC1 SUBI AC1,40 JRST L.130 ; 3043 L.129: MOVM AC1,AC1 ; 3050 L.130: MOVEM AC1,U.90 ; 3042 MOVE AC1,SND%QUOTE%CHR ; 3057 JUMPGE AC1,L.132 MOVEI AC2,5 ; 3060 CAML AC2,U.104 JRST L.131 MOVE AC1,C.43 ; 3062 ILDB AC1,AC1 JRST L.132 ; 3058 L.131: MOVM AC1,AC1 ; 3065 L.132: MOVEM AC1,U.91 ; 3057 MOVE AC2,U.104 ; 3075 CAIG AC2,6 JRST L.133 MOVE AC1,C.44 ILDB AC1,AC1 JRST L.134 L.133: MOVEI AC1,116 L.134: MOVEM AC1,U.92 CAIG AC2,7 ; 3082 JRST L.135 MOVE AC1,C.45 ; 3086 ILDB AC1,AC1 CAMN AC1,CHKTYPE JRST L.136 L.135: MOVEI AC1,61 ; 3092 MOVEM AC1,U.93 L.136: CAIG AC2,10 ; 3097 JRST L.137 MOVE AC1,C.46 ILDB AC1,AC1 JRST L.138 L.137: MOVEI AC1,40 L.138: MOVEM AC1,U.85 MOVE AC1,U.91 ; 3104 CAIGE AC1,41 JRST L.139 CAIG AC1,76 JRST L.140 L.139: CAIL AC1,140 CAILE AC1,176 ; 3105 JRST L.150 ; 3107 L.140: MOVE AC1,U.92 ; 3116 CAIGE AC1,41 JRST L.141 CAIG AC1,76 JRST L.143 L.141: CAIGE AC1,140 ; 3117 JRST L.142 CAIG AC1,176 JRST L.143 L.142: CAIN AC1,116 JRST L.143 CAIE AC1,131 JRST L.150 L.143: CAMN AC1,U.91 ; 3118 JRST L.150 ; 3120 MOVEI AC1,131 ; 3125 CAME AC1,U.92 JRST L.144 MOVE AC1,U.84 MOVEM AC1,U.92 L.144: MOVE AC2,U.92 ; 3127 CAIE AC2,116 CAIN AC2,131 JRST L.145 MOVEI AC1,1 ; 3129 MOVEM AC1,U.95 JRST L.146 ; 3127 L.145: SETZM U.95 ; 3131 L.146: MOVE AC1,U.85 ; 3137 CAIGE AC1,41 JRST L.147 CAIG AC1,76 JRST L.148 L.147: CAIL AC1,140 CAILE AC1,176 ; 3138 JRST L.149 L.148: CAMN AC1,U.91 JRST L.149 CAME AC1,AC2 JRST L.151 L.149: CAIN AC1,40 ; 3139 JRST L.151 L.150: PUSH SP,C.7 ; 3142 PUSHJ SP,KRM%ERROR ADJSP SP,-1 ; 3137 MOVEI AC1,252 ; 3141 POPJ SP, L.151: MOVEI AC1,40 ; 3146 CAMN AC1,U.85 JRST L.152 MOVEI AC1,1 MOVEM AC1,U.96 JRST L.153 L.152: SETZM U.96 L.153: MOVEI AC1,13 ; 2970 POPJ SP, ; 2932 C.39: POINT 8,U.106+1,7 C.40: POINT 8,U.106+1,15 C.41: POINT 8,U.106+1,23 C.42: POINT 8,U.106+1,31 C.43: POINT 8,U.106+2,7 C.44: POINT 8,U.106+2,15 C.45: POINT 8,U.106+2,23 C.46: POINT 8,U.106+2,31 ; Routine Size: 158 words ; 3150 %SBTTL 'SET%SEND%INIT' ; 3151 ROUTINE SET%SEND%INIT : NOVALUE = ; 3152 ; 3153 !++ ; 3154 ! FUNCTIONAL DESCRIPTION: ; 3155 ! ; 3156 ! This routine will initialize the various parameters for the ; 3157 ! MSG%SND%INIT message. ; 3158 ! ; 3159 ! CALLING SEQUENCE: ; 3160 ! ; 3161 ! SET%SEND%INIT(); ; 3162 ! ; 3163 ! INPUT PARAMETERS: ; 3164 ! ; 3165 ! None. ; 3166 ! ; 3167 ! IMPLICIT INPUTS: ; 3168 ! ; 3169 ! None. ; 3170 ! ; 3171 ! OUTPUT PARAMETERS: ; 3172 ! ; 3173 ! None. ; 3174 ! ; 3175 ! IMPLICIT OUTPUTS: ; 3176 ! ; 3177 ! SND%MSG parameters set up. ; 3178 ! ; 3179 ! COMPLETION CODES: ; 3180 ! ; 3181 ! None. ; 3182 ! ; 3183 ! SIDE EFFECTS: ; 3184 ! ; 3185 ! None. ; 3186 ! ; 3187 !-- ; 3188 ; 3189 BEGIN ; 3190 CH$WCHAR (CHAR (.RCV%PKT%SIZE), CH$PTR (SND%MSG, PKT%MSG + P%SI%BUFSIZ, CHR%SIZE)); ; 3191 CH$WCHAR (CHAR (.RCV%TIMEOUT), CH$PTR (SND%MSG, PKT%MSG + P%SI%TIMOUT, CHR%SIZE)); ; 3192 CH$WCHAR (CHAR (.RCV%NPAD), CH$PTR (SND%MSG, PKT%MSG + P%SI%NPAD, CHR%SIZE)); ; 3193 CH$WCHAR (CTL (.RCV%PADCHAR), CH$PTR (SND%MSG, PKT%MSG + P%SI%PAD, CHR%SIZE)); ; 3194 CH$WCHAR (CHAR (.RCV%EOL), CH$PTR (SND%MSG, PKT%MSG + P%SI%EOL, CHR%SIZE)); ; 3195 CH$WCHAR (.RCV%QUOTE%CHR, CH$PTR (SND%MSG, PKT%MSG + P%SI%QUOTE, CHR%SIZE)); ; 3196 CH$WCHAR (.SEND%8QUOTE%CHR, CH$PTR (SND%MSG, PKT%MSG + P%SI%8QUOTE, CHR%SIZE)); ; 3197 CH$WCHAR (.INI%CHK%TYPE, CH$PTR (SND%MSG, PKT%MSG + P%SI%CHKTYPE, CHR%SIZE)); ; 3198 CH$WCHAR (.REPT%CHR, CH$PTR (SND%MSG, PKT%MSG + P%SI%REPEAT, CHR%SIZE)); ; 3199 END; ! End of SET%SEND%INIT ; SET%SEND%INIT U.17: MOVE AC2,RCV%PKT%SIZE ; 3190 ADDI AC2,40 MOVE AC1,C.12 IDPB AC2,AC1 MOVE AC2,RCV%TIMEOUT ; 3191 ADDI AC2,40 MOVE AC1,C.47 IDPB AC2,AC1 MOVE AC2,RCV%NPAD ; 3192 ADDI AC2,40 MOVE AC1,C.48 IDPB AC2,AC1 MOVE AC2,RCV%PADCHAR ; 3193 TRC AC2,100 MOVE AC1,C.49 IDPB AC2,AC1 MOVE AC2,RCV%EOL ; 3194 ADDI AC2,40 MOVE AC1,C.50 IDPB AC2,AC1 MOVE AC2,RCV%QUOTE%CHR ; 3195 MOVE AC1,C.51 IDPB AC2,AC1 MOVE AC2,U.92 ; 3196 MOVE AC1,C.52 IDPB AC2,AC1 MOVE AC2,U.93 ; 3197 MOVE AC1,C.53 IDPB AC2,AC1 MOVE AC2,U.85 ; 3198 MOVE AC1,C.54 IDPB AC2,AC1 POPJ SP, ; 3151 C.47: POINT 8,U.107+1,7 C.48: POINT 8,U.107+1,15 C.49: POINT 8,U.107+1,23 C.50: POINT 8,U.107+1,31 C.51: POINT 8,U.107+2,7 C.52: POINT 8,U.107+2,15 C.53: POINT 8,U.107+2,23 C.54: POINT 8,U.107+2,31 ; Routine Size: 41 words ; 3200 %SBTTL 'SEND%PACKET' ; 3201 ROUTINE SEND%PACKET (TYPE, LENGTH, MN) = ; 3202 ; 3203 !++ ; 3204 ! FUNCTIONAL DESCRIPTION: ; 3205 ! ; 3206 ! This routine will cause a packet to be sent over the line ; 3207 ! that has been opened by OPEN%TERMINAL. ; 3208 ! ; 3209 ! CALLING SEQUENCE: ; 3210 ! ; 3211 ! SEND%PACKET(Type, Length); ; 3212 ! ; 3213 ! INPUT PARAMETERS: ; 3214 ! ; 3215 ! TYPE - Type of packet to send. ; 3216 ! ; 3217 ! LENGTH - Length of the packet being sent. ; 3218 ! ; 3219 ! IMPLICIT INPUTS: ; 3220 ! ; 3221 ! None. ; 3222 ! ; 3223 ! OUTPUT PARAMETERS: ; 3224 ! ; 3225 ! None. ; 3226 ! ; 3227 ! IMPLICIT OUTPUTS: ; 3228 ! ; 3229 ! None. ; 3230 ! ; 3231 ! COMPLETION CODES: ; 3232 ! ; 3233 ! None. ; 3234 ! ; 3235 ! SIDE EFFECTS: ; 3236 ! ; 3237 ! None. ; 3238 ! ; 3239 !-- ; 3240 ; 3241 BEGIN ; 3242 ; 3243 LOCAL ; 3244 FILLER : VECTOR [CH$ALLOCATION (MAX%MSG, CHR%SIZE)], ; 3245 TOT%MSG%LEN, ! Length of message including all characters ; 3246 CHKSUM, ! Checksum for the message we calculate ; 3247 POINTER; ! Pointer to the information in the message ; 3248 ; 3249 ! ; 3250 ! Do any filler processing that the remote KERMIT requires. ; 3251 ! ; 3252 ; 3253 IF .SEND%NPAD NEQ 0 ; 3254 THEN ; 3255 BEGIN ; 3256 CH$FILL (.SEND%PADCHAR, MAX%MSG, CH$PTR (FILLER, 0, CHR%SIZE)); ; 3257 ! ; 3258 ! Update the send stats ; 3259 ! ; 3260 SMSG%TOTAL%CHARS = .SMSG%TOTAL%CHARS + .SEND%NPAD; ; 3261 ! ; 3262 ! Send the fill ; 3263 ! ; 3264 DO%PARITY (FILLER, .SEND%NPAD + PKT%TOT%OVR%HEAD); ; 3265 SEND (FILLER, .SEND%NPAD + PKT%TOT%OVR%HEAD); ; 3266 END; ; 3267 ; 3268 ! ; 3269 ! Store the header information into the message. ; 3270 ! ; 3271 CH$WCHAR (.TYPE, CH$PTR (SND%MSG, PKT%TYPE, CHR%SIZE)); ; 3272 CH$WCHAR (.SND%SOH, CH$PTR (SND%MSG, PKT%MARK, CHR%SIZE)); ; 3273 CH$WCHAR (CHAR (.LENGTH + PKT%OVR%HEAD + (.BLK%CHK%TYPE - CHK%1CHAR)), ; 3274 CH$PTR (SND%MSG, ; 3275 PKT%COUNT, CHR%SIZE)); ; 3276 CH$WCHAR (CHAR ((IF .MN LSS 0 THEN 0 ELSE .MN)), CH$PTR (SND%MSG, PKT%SEQ, CHR%SIZE)); ; 3277 ! ; 3278 ! Calculate the block check value ; 3279 ! ; 3280 POINTER = CH$PTR (SND%MSG, PKT%MARK + 1, CHR%SIZE); ; 3281 CHKSUM = CALC%BLOCK%CHECK (.POINTER, .LENGTH + PKT%OVR%HEAD); ; 3282 TOT%MSG%LEN = .LENGTH + PKT%TOT%OVR%HEAD; ; 3283 ! ; 3284 ! Store the checksum into the message ; 3285 ! ; 3286 POINTER = CH$PTR (SND%MSG, .LENGTH + PKT%OVR%HEAD + 1, CHR%SIZE); ; 3287 ; 3288 CASE .BLK%CHK%TYPE FROM CHK%1CHAR TO CHK%CRC OF ; 3289 SET ; 3290 ; 3291 [CHK%1CHAR] : ; 3292 CH$WCHAR%A (CHAR (.CHKSUM), POINTER); ; 3293 ; 3294 [CHK%2CHAR] : ; 3295 BEGIN ; 3296 CH$WCHAR%A (CHAR (.CHKSUM<6, 6>), POINTER); ; 3297 CH$WCHAR%A (CHAR (.CHKSUM<0, 6>), POINTER); ; 3298 TOT%MSG%LEN = .TOT%MSG%LEN + 1; ; 3299 END; ; 3300 ; 3301 [CHK%CRC] : ; 3302 BEGIN ; 3303 CH$WCHAR%A (CHAR (.CHKSUM<12, 4>), POINTER); ; 3304 CH$WCHAR%A (CHAR (.CHKSUM<6, 6>), POINTER); ; 3305 CH$WCHAR%A (CHAR (.CHKSUM<0, 6>), POINTER); ; 3306 TOT%MSG%LEN = .TOT%MSG%LEN + 2; ; 3307 END; ; 3308 TES; ; 3309 ; 3310 ! ; 3311 ! Store in the end of line character ; 3312 ! ; 3313 CH$WCHAR%A (.SEND%EOL, POINTER); ; 3314 ! ; 3315 ! If we are debugging then type out the message we are sending. ; 3316 ! ; 3317 DBG%SEND (SND%MSG, (.TOT%MSG%LEN)); ; 3318 ! ; 3319 ! Update the stats for total characters and the data characters ; 3320 ! ; 3321 SMSG%TOTAL%CHARS = .SMSG%TOTAL%CHARS + .TOT%MSG%LEN; ; 3322 SMSG%DATA%CHARS = .SMSG%DATA%CHARS + .LENGTH; ; 3323 ; 3324 IF .TYPE EQL MSG%NAK ; 3325 THEN ; 3326 BEGIN ; 3327 SMSG%NAKS = .SMSG%NAKS + 1; ; 3328 XFR%STATUS (%C'S', %C'N'); ; 3329 END ; 3330 ELSE ; 3331 BEGIN ; 3332 SND%COUNT = .SND%COUNT + 1; ; 3333 XFR%STATUS (%C'S', %C'P'); ; 3334 END; ; 3335 ; 3336 ! ; 3337 ! Check if we are in IBM mode and need to wait for an XON first ; 3338 ! We will not wait if this is a packet which might be going out ; 3339 ! without previous traffic (generic commands, init packets). ; 3340 ; 3341 IF .IBM%FLAG AND NOT (.TYPE EQL MSG%SND%INIT OR .TYPE EQL MSG%SER%INIT OR .TYPE EQL MSG%RCV%INIT ; 3342 OR .TYPE EQL MSG%COMMAND OR .TYPE EQL MSG%KERMIT) ; 3343 THEN ; 3344 ; 3345 IF NOT IBM%WAIT () THEN RETURN KER%ABORTED; ; 3346 ; 3347 ! ; 3348 ! Now call the O/S routine to send the message out to the remote KERMIT ; 3349 ! ; 3350 DO%PARITY (SND%MSG, .TOT%MSG%LEN); ; 3351 RETURN SEND (SND%MSG, .TOT%MSG%LEN); ; 3352 END; ! End of SEND%PACKET ; SEND%PACKET U.21: PUSH SP,AC13 ; 3201 PUSH SP,AC14 PUSH SP,AC16 ADJSP SP,32 MOVE AC3,U.87 ; 3253 JUMPE AC3,L.154 MOVEI AC5,-32(SP) ; 3256 HRLI AC5,41000 SETZ AC1, MOVEI AC4,140 MOVEI AC13,-2(SP) PUSH AC13,C.20 PUSH AC13,U.88 EXTEND AC1,-1(SP) JFCL ADDM AC3,SMSG%TOTAL%CHARS ; 3260 MOVEI AC1,-31(SP) ; 3264 PUSH SP,AC1 ADDI AC3,6 PUSH SP,AC3 PUSHJ SP,U.19 MOVEI AC1,-33(SP) ; 3265 PUSH SP,AC1 MOVE AC1,U.87 ADDI AC1,6 PUSH SP,AC1 PUSHJ SP,SEND ADJSP SP,-4 ; 3255 L.154: MOVE AC2,-40(SP) ; 3271 MOVE AC1,C.58 IDPB AC2,AC1 MOVE AC2,SND%SOH ; 3272 MOVE AC1,C.38 IDPB AC2,AC1 MOVE AC14,-37(SP) ; 3273 MOVE AC1,AC14 ADD AC1,U.94 SUBI AC1,16 MOVE AC2,C.59 ; 3274 IDPB AC1,AC2 ; 3273 SKIPGE AC1,-36(SP) ; 3276 SETZ AC1, ADDI AC1,40 MOVE AC2,C.60 IDPB AC1,AC2 MOVE AC16,C.59 ; 3280 PUSH SP,AC16 ; 3281 MOVE AC1,AC14 ADDI AC1,3 PUSH SP,AC1 PUSHJ SP,U.16 MOVE AC13,AC14 ; 3282 ADDI AC13,6 ADDI AC14,4 ; 3286 MOVE AC3,C.55 MOVE AC2,AC14 ADJBP AC2,AC3 MOVE AC16,AC2 MOVE AC2,U.94 ; 3288 SUBI AC2,61 JRST L.155(AC2) L.155: JRST L.156 JRST L.157 JRST L.158 L.156: MOVE AC2,AC1 ; 3292 ADDI AC2,40 IDPB AC2,AC16 JRST L.159 ; 3288 L.157: LDB AC2,C.56 ; 3296 ADDI AC2,40 IDPB AC2,AC16 LDB AC2,C.1 ; 3297 ADDI AC2,40 IDPB AC2,AC16 AOJA AC13,L.159 ; 3288 L.158: LDB AC2,C.57 ; 3303 ADDI AC2,40 IDPB AC2,AC16 LDB AC2,C.56 ; 3304 ADDI AC2,40 IDPB AC2,AC16 ANDI AC1,77 ; 3305 ADDI AC1,40 IDPB AC1,AC16 ADDI AC13,2 ; 3306 L.159: MOVE AC1,U.90 ; 3313 IDPB AC1,AC16 PUSH SP,C.61 ; 3317 PUSH SP,AC13 PUSHJ SP,U.29 ADDM AC13,SMSG%TOTAL%CHARS ; 3321 MOVE AC1,-43(SP) ; 3322 ADDM AC1,SMSG%DATA%CHARS MOVE AC14,-44(SP) ; 3324 CAIE AC14,116 JRST L.160 AOS SMSG%NAKS ; 3327 PUSH SP,C.23 ; 3328 PUSH SP,C.9 JRST L.161 L.160: AOS SND%COUNT ; 3332 PUSH SP,C.23 ; 3333 PUSH SP,C.62 L.161: PUSHJ SP,XFR%STATUS MOVEI AC1,1 ; 3341 TDNE AC1,IBM%FLAG CAIN AC14,123 JRST L.162 CAIE AC14,111 CAIN AC14,122 JRST L.162 CAIE AC14,103 ; 3342 CAIN AC14,107 JRST L.162 PUSHJ SP,IBM%WAIT ; 3345 TRNE AC1,1 JRST L.162 ADJSP SP,-6 MOVEI AC1,312 JRST L.163 L.162: PUSH SP,C.61 ; 3350 PUSH SP,AC13 PUSHJ SP,U.19 PUSH SP,C.61 ; 3351 PUSH SP,AC13 PUSHJ SP,SEND ADJSP SP,-12 ; 3201 L.163: ADJSP SP,-32 POP SP,AC16 POP SP,AC14 POP SP,AC13 POPJ SP, C.55: POINT 8,U.107,-1 C.56: POINT 6,AC1,29 C.57: POINT 4,AC1,23 C.58: POINT 8,U.107,23 C.59: POINT 8,U.107,7 C.60: POINT 8,U.107,15 C.61: XWD 0,U.107 C.62: EXP 120 ; Routine Size: 140 words ; 3353 %SBTTL 'REC%MESSAGE - Receive a message' ; 3354 ROUTINE REC%MESSAGE (CHK%ROUTINE) = ; 3355 ; 3356 !++ ; 3357 ! FUNCTIONAL DESCRIPTION: ; 3358 ! ; 3359 ! This routine will handle the retry processing for the various ; 3360 ! messages that can be received. ; 3361 ! ; 3362 ! CALLING SEQUENCE: ; 3363 ! ; 3364 ! INPUT PARAMETERS: ; 3365 ! ; 3366 ! None. ; 3367 ! ; 3368 ! IMPLICIT INPUTS: ; 3369 ! ; 3370 ! None. ; 3371 ! ; 3372 ! OUTPUT PARAMETERS: ; 3373 ! ; 3374 ! None. ; 3375 ! ; 3376 ! IMPLICIT OUTPUTS: ; 3377 ! ; 3378 ! None. ; 3379 ! ; 3380 ! COMPLETION CODES: ; 3381 ! ; 3382 ! KER%NORMAL - Normal return ; 3383 ! KER%RETRIES - Too many retries ; 3384 ! (What ever REC%PACKET returns). ; 3385 ! ; 3386 ! SIDE EFFECTS: ; 3387 ! ; 3388 ! None. ; 3389 ! ; 3390 !-- ; 3391 ; 3392 BEGIN ; 3393 RETURN ; 3394 ; 3395 WHILE TRUE DO ; 3396 BEGIN ; 3397 ! I don't think this check is needed. ; 3398 ! IF .NUM%RETRIES GTR .PKT%RETRIES THEN RETURN KER%RETRIES; ; 3399 NUM%RETRIES = .NUM%RETRIES + 1; ; 3400 STATUS = REC%PACKET (); ; 3401 ; 3402 IF NOT .STATUS AND .STATUS NEQ KER%CHKSUMERR THEN EXITLOOP .STATUS; ; 3403 ; 3404 IF NOT .STATUS ; 3405 THEN ; 3406 SEND%PACKET (MSG%NAK, 0, .MSG%NUMBER - 1) ; 3407 ELSE ; 3408 BEGIN ; 3409 ; 3410 IF NOT (.CHK%ROUTINE) () ; 3411 THEN ; 3412 SEND%PACKET (MSG%NAK, 0, .REC%SEQ) ; 3413 ELSE ; 3414 EXITLOOP KER%NORMAL; ; 3415 ; 3416 END; ; 3417 ; 3418 END; ; 3419 ; 3420 END; ! End of REC%PARSE ; REC%MESSAGE U.22: L.164: AOS U.101 ; 3399 PUSHJ SP,U.23 ; 3400 MOVEM AC1,U.97 TRNN AC1,1 ; 3402 CAIN AC1,172 JRST L.165 POPJ SP, L.165: TRNE AC1,1 ; 3404 JRST L.166 PUSH SP,C.9 ; 3406 PUSH SP,C.10 MOVE AC1,U.102 SUBI AC1,1 PUSH SP,AC1 JRST L.167 L.166: MOVE AC1,-1(SP) ; 3410 PUSHJ SP,0(AC1) TRNE AC1,1 JRST L.168 PUSH SP,C.9 ; 3412 PUSH SP,C.10 PUSH SP,U.103 L.167: PUSHJ SP,U.21 ADJSP SP,-3 JRST L.164 ; 3410 L.168: MOVEI AC1,13 ; 3414 POPJ SP, ; 3354 ; Routine Size: 27 words ; 3421 %SBTTL 'REC%PACKET' ; 3422 ROUTINE REC%PACKET = ; 3423 ; 3424 !++ ; 3425 ! FUNCTIONAL DESCRIPTION: ; 3426 ! ; 3427 ! This routine will do the oppoiste of SEND%PACKET. It will wait ; 3428 ! for the message to be read from the remote and then it will ; 3429 ! check the message for validity. ; 3430 ! ; 3431 ! CALLING SEQUENCE: ; 3432 ! ; 3433 ! Flag = REC%PACKET(); ; 3434 ! ; 3435 ! INPUT PARAMETERS: ; 3436 ! ; 3437 ! None. ; 3438 ! ; 3439 ! IMPLICIT INPUTS: ; 3440 ! ; 3441 ! None. ; 3442 ! ; 3443 ! OUTPUT PARAMETERS: ; 3444 ! ; 3445 ! None. ; 3446 ! ; 3447 ! IMPLICIT OUTPUTS: ; 3448 ! ; 3449 ! REC%MSG - Contains the message received. ; 3450 ! ; 3451 ! COMPLETION CODES: ; 3452 ! ; 3453 ! True - Packet receive ok. ; 3454 ! False - Problem occured during the receiving of the packet. ; 3455 ! ; 3456 ! SIDE EFFECTS: ; 3457 ! ; 3458 ! None. ; 3459 ! ; 3460 !-- ; 3461 ; 3462 BEGIN ; 3463 ; 3464 BIND ; 3465 ATTEMPT%TEXT = UPLIT (%ASCIZ'Attempting to receive'); ; 3466 ; 3467 LOCAL ; 3468 ! BUFFER : VECTOR [CH$ALLOCATION (MAX%MSG, CHR%SIZE)], ; 3469 MSG%LENGTH, ; 3470 ERR%POINTER, ! Pointer to the error buffer ; 3471 POINTER, ; 3472 ! OLD%POINTER, ! Character pointer to the data section ; 3473 ! NEW%POINTER, ; 3474 CHKSUM; ! Checksum of the message ; 3475 ; 3476 ! ; 3477 ! Attempt to read the message from the remote. ; 3478 ! ; 3479 ! DO ; 3480 ! BEGIN ; 3481 ; 3482 IF .DEBUG%FLAG ; 3483 THEN ; 3484 BEGIN ; 3485 ; 3486 LOCAL ; 3487 OLD%RTN; ; 3488 ; 3489 OLD%RTN = TT%SET%OUTPUT (DBG%DUMP); ; 3490 TT%TEXT (ATTEMPT%TEXT); ; 3491 TT%CRLF (); ; 3492 TT%SET%OUTPUT (.OLD%RTN); ; 3493 END; ; 3494 ; 3495 ! ; 3496 ! Receive the message from the remote Kermit ; 3497 ! ; 3498 STATUS = RECEIVE (REC%MSG, MSG%LENGTH); ; 3499 ! ; 3500 ! If it failed return the status to the upper level ; 3501 ! ; 3502 ; 3503 IF NOT .STATUS THEN RETURN .STATUS; ; 3504 ; 3505 ! ; 3506 ! Determine if we got a good message ; 3507 ! ; 3508 ; 3509 IF .MSG%LENGTH EQL 0 ; 3510 THEN ; 3511 BEGIN ; 3512 RETURN KER%ZEROLENMSG; ; 3513 END; ; 3514 ; 3515 ! ; 3516 ! Update the stats on the total number of characters received. ; 3517 ! ; 3518 RMSG%TOTAL%CHARS = .RMSG%TOTAL%CHARS + .MSG%LENGTH; ; 3519 ! ; 3520 ! Now find the message in the information we just received. ; 3521 ! (could have fillers supplied by remote Kermit or remote system. ; 3522 ! just discard them and look for the Ctl-A) ; 3523 ! ; 3524 ! OLD%POINTER = CH$PTR (BUFFER, 0, CHR%SIZE); ; 3525 ! NEW%POINTER = CH$FIND%CH (.MSG%LENGTH, .OLD%POINTER, .RCV%SOH); ; 3526 ! ; 3527 ! WHILE TRUE DO ; 3528 ! ; 3529 ! IF CH$FAIL (.NEW%POINTER) EQL 0 ; 3530 ! THEN ; 3531 ! BEGIN ; 3532 ! MSG%LENGTH = .MSG%LENGTH - CH$DIFF (.NEW%POINTER, .OLD%POINTER); ; 3533 ! ; 3534 ! IF .MSG%LENGTH EQL 0 THEN EXITLOOP; ; 3535 ! ; 3536 ! OLD%POINTER = .NEW%POINTER; ; 3537 ! NEW%POINTER = CH$FIND%CH (.MSG%LENGTH, CH$PLUS (.OLD%POINTER, 1), .RCV%SOH); ; 3538 ! END ; 3539 ! ELSE ; 3540 ! EXITLOOP; ; 3541 ! ; 3542 ! END ; 3543 ! UNTIL .MSG%LENGTH NEQ 0; ; 3544 ! ; 3545 ! IF .MSG%LENGTH EQL 0 THEN RETURN KER%ZEROLENMSG; ; 3546 ! ; 3547 ! CH$MOVE (.MSG%LENGTH, .OLD%POINTER, CH$PTR (REC%MSG, 0, CHR%SIZE)); ; 3548 ! ; 3549 ! Initialize the checksum and others ; 3550 ! ; 3551 REC%TYPE = CH$RCHAR (CH$PTR (REC%MSG, PKT%TYPE, CHR%SIZE)); ; 3552 CHKSUM = CH$RCHAR (CH$PTR (REC%MSG, PKT%COUNT, CHR%SIZE)) + CH$RCHAR (CH$PTR (REC%MSG, PKT%SEQ, ; 3553 CHR%SIZE)) + .REC%TYPE; ; 3554 ! ; 3555 ! Now break the message apart byte by byte. ; 3556 ! ; 3557 REC%LENGTH = UNCHAR (CH$RCHAR (CH$PTR (REC%MSG, PKT%COUNT, CHR%SIZE))) - PKT%OVR%HEAD - ( ; 3558 .BLK%CHK%TYPE - CHK%1CHAR); ; 3559 REC%SEQ = UNCHAR (CH$RCHAR (CH$PTR (REC%MSG, PKT%SEQ, CHR%SIZE))); ; 3560 ! ; 3561 ! Typed the packet if we are debugging ; 3562 ! ; 3563 DBG%RECEIVE (REC%MSG); ; 3564 ! ; 3565 ! Now compute the final checksum and make sure that it is identical ; 3566 ! to what we received from the remote KERMIT ; 3567 ! ; 3568 POINTER = CH$PTR (REC%MSG, PKT%MARK + 1, CHR%SIZE); ; 3569 CHKSUM = CALC%BLOCK%CHECK (.POINTER, .REC%LENGTH + PKT%OVR%HEAD); ; 3570 POINTER = CH$PTR (REC%MSG, .REC%LENGTH + PKT%OVR%HEAD + 1, CHR%SIZE); ; 3571 ; 3572 CASE .BLK%CHK%TYPE FROM CHK%1CHAR TO CHK%CRC OF ; 3573 SET ; 3574 ; 3575 [CHK%1CHAR] : ; 3576 ; 3577 IF .CHKSUM NEQ UNCHAR (CH$RCHAR%A (POINTER)) THEN RETURN KER%CHKSUMERR; ; 3578 ; 3579 [CHK%2CHAR] : ; 3580 ; P 3581 IF (.CHKSUM<6, 6> NEQ UNCHAR (CH$RCHAR%A (POINTER))) OR (.CHKSUM<0, 6> NEQ UNCHAR ( ; 3582 CH$RCHAR%A (POINTER))) ; 3583 THEN ; 3584 RETURN KER%CHKSUMERR; ; 3585 ; 3586 [CHK%CRC] : ; 3587 ; P 3588 IF (.CHKSUM<12, 4> NEQ UNCHAR (CH$RCHAR%A (POINTER))) OR (.CHKSUM<6, 6> NEQ UNCHAR ( ; 3589 CH$RCHAR%A (POINTER))) OR (.CHKSUM<0, 6> NEQ UNCHAR (CH$RCHAR%A (POINTER))) ; 3590 THEN ; 3591 RETURN KER%CHKSUMERR; ; 3592 ; 3593 TES; ; 3594 ; 3595 ! ; 3596 ! Update the stats ; 3597 ! ; 3598 RMSG%DATA%CHARS = .RMSG%DATA%CHARS + .REC%LENGTH; ; 3599 ; 3600 IF .REC%TYPE EQL MSG%NAK ; 3601 THEN ; 3602 BEGIN ; 3603 RMSG%NAKS = .RMSG%NAKS + 1; ; 3604 XFR%STATUS (%C'R', %C'N'); ; 3605 END ; 3606 ELSE ; 3607 BEGIN ; 3608 RCV%COUNT = .RCV%COUNT + 1; ; 3609 XFR%STATUS (%C'R', %C'P'); ; 3610 END; ; 3611 ; 3612 ! ; 3613 ! Now check to see if we have an E type (Error) packet. ; 3614 ! ; 3615 ; 3616 IF .REC%TYPE NEQ MSG%ERROR THEN RETURN KER%NORMAL; ; 3617 ; 3618 ! ; 3619 ! Here to process an error packet. Call the user routine to output the ; 3620 ! error message to the terminal. ; 3621 ! ; 3622 ERR%POINTER = CH$PTR (LAST%ERROR); ; 3623 POINTER = CH$PTR (REC%MSG, PKT%MSG, CHR%SIZE); ; 3624 ; 3625 INCR I FROM 1 TO .REC%LENGTH DO ; 3626 CH$WCHAR%A (CH$RCHAR%A (POINTER), ERR%POINTER); ; 3627 ; 3628 CH$WCHAR (CHR%NUL, ERR%POINTER); ; 3629 TT%TEXT (LAST%ERROR); ; 3630 TT%CRLF (); ; 3631 RETURN KER%ERRMSG; ; 3632 END; ! End of REC%PACKET P.AAK: BYTE (7)"A","t","t","e","m" BYTE (7)"p","t","i","n","g" BYTE (7)" ","t","o"," ","r" BYTE (7)"e","c","e","i","v" BYTE (7)"e",000,000,000,000 ; ATTEMPT%TEXT U.115= P.AAK ; REC%PACKET U.23: PUSH SP,AC14 ; 3422 PUSH SP,AC16 ADJSP SP,2 MOVEI AC1,1 ; 3482 TDNN AC1,DEBUG%FLAG JRST L.169 PUSH SP,C.67 ; 3489 PUSHJ SP,TT%SET%OUTPUT MOVE AC14,AC1 PUSH SP,C.68 ; 3490 PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 3491 MOVEM AC14,0(SP) ; 3492 PUSHJ SP,TT%SET%OUTPUT ADJSP SP,-2 ; 3484 L.169: PUSH SP,C.69 ; 3498 MOVEI AC1,-2(SP) PUSH SP,AC1 PUSHJ SP,RECEIVE MOVEM AC1,U.97 TRNE AC1,1 ; 3503 JRST L.170 ADJSP SP,-2 JRST L.183 L.170: MOVE AC1,-3(SP) ; 3509 JUMPN AC1,L.171 ADJSP SP,-2 MOVEI AC1,262 ; 3511 JRST L.183 L.171: ADDM AC1,RMSG%TOTAL%CHARS ; 3518 MOVE AC1,C.70 ; 3551 ILDB AC1,AC1 MOVEM AC1,U.105 MOVE AC1,C.71 ; 3552 ILDB AC2,AC1 MOVE AC1,C.72 ILDB AC1,AC1 ADD AC2,AC1 MOVE AC16,AC2 ; 3553 ADD AC16,U.105 MOVE AC1,C.71 ; 3557 ILDB AC1,AC1 SUB AC1,U.94 ADDI AC1,16 MOVEM AC1,U.104 MOVE AC1,C.72 ; 3559 ILDB AC1,AC1 SUBI AC1,40 MOVEM AC1,U.103 PUSH SP,C.69 ; 3563 PUSHJ SP,U.30 MOVE AC14,C.71 ; 3568 MOVEM AC14,0(SP) ; 3569 MOVE AC1,U.104 ADDI AC1,3 PUSH SP,AC1 PUSHJ SP,U.16 MOVE AC16,AC1 MOVE AC1,U.104 ; 3570 ADDI AC1,4 MOVE AC2,C.63 ADJBP AC1,AC2 MOVE AC14,AC1 MOVE AC1,U.94 ; 3572 SUBI AC1,61 JRST L.172(AC1) L.172: JRST L.173 JRST L.175 JRST L.174 L.173: ILDB AC1,AC14 ; 3577 SUBI AC1,40 CAMN AC16,AC1 JRST L.177 JRST L.176 L.174: ILDB AC1,AC14 ; 3588 SUBI AC1,40 LDB AC2,C.64 CAME AC2,AC1 JRST L.176 L.175: ILDB AC1,AC14 ; 3589 SUBI AC1,40 LDB AC2,C.65 ; 3588 CAME AC2,AC1 JRST L.176 ILDB AC1,AC14 ; 3589 SUBI AC1,40 LDB AC2,C.66 CAMN AC2,AC1 JRST L.177 L.176: ADJSP SP,-4 ; 3591 MOVEI AC1,172 JRST L.183 L.177: MOVE AC1,U.104 ; 3598 ADDM AC1,RMSG%DATA%CHARS MOVEI AC1,116 ; 3600 CAME AC1,U.105 JRST L.178 AOS RMSG%NAKS ; 3603 PUSH SP,C.29 ; 3604 PUSH SP,C.9 JRST L.179 L.178: AOS RCV%COUNT ; 3608 PUSH SP,C.29 ; 3609 PUSH SP,C.62 L.179: PUSHJ SP,XFR%STATUS MOVEI AC1,105 ; 3616 CAMN AC1,U.105 JRST L.180 ADJSP SP,-6 MOVEI AC1,13 JRST L.183 L.180: MOVE AC1,C.27 ; 3622 MOVEM AC1,-6(SP) MOVE AC14,C.5 ; 3623 MOVE AC3,U.104 ; 3625 SETZ AC1, JRST L.182 L.181: ILDB AC2,AC14 ; 3626 IDPB AC2,-6(SP) L.182: ADDI AC1,1 ; 3625 CAMG AC1,AC3 JRST L.181 SETZ AC2, ; 3628 MOVEI AC1,-6(SP) IDPB AC2,AC1 PUSH SP,C.73 ; 3629 PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 3630 ADJSP SP,-7 ; 3422 MOVEI AC1,162 ; 3462 L.183: ADJSP SP,-2 ; 3422 POP SP,AC16 POP SP,AC14 POPJ SP, C.63: POINT 8,U.106,-1 C.64: POINT 4,AC16,23 C.65: POINT 6,AC16,29 C.66: POINT 6,AC16,35 C.67: XWD 0,DBG%DUMP C.68: XWD 0,U.115 C.69: XWD 0,U.106 C.70: POINT 8,U.106,23 C.71: POINT 8,U.106,7 C.72: POINT 8,U.106,15 C.73: XWD 0,LAST%ERROR ; Routine Size: 145 words ; 3633 %SBTTL 'CALC%BLOCK%CHECK' ; 3634 ROUTINE CALC%BLOCK%CHECK (POINTER, LENGTH) = ; 3635 ; 3636 !++ ; 3637 ! FUNCTIONAL DESCRIPTION: ; 3638 ! ; 3639 ! This routine will calculate the proper value for the block check ; 3640 ! for a given message. The value it returns is dependant upon the ; 3641 ! type of block check requested in BLK%CHK%TYPE. ; 3642 ! ; 3643 ! CALLING SEQUENCE: ; 3644 ! ; 3645 ! CHKSUM = CALC%BLOCK%CHECK (.POINTER, .LENGTH); ; 3646 ! ; 3647 ! INPUT PARAMETERS: ; 3648 ! ; 3649 ! POINTER - A character pointer to the first character to be ; 3650 ! included in the block check. ; 3651 ! ; 3652 ! LENGTH - The number of characters to be included. ; 3653 ! ; 3654 ! IMPLICIT INPUTS: ; 3655 ! ; 3656 ! BLK%CHK%TYPE - The type of block check to generate. ; 3657 ! ; 3658 ! OUPTUT PARAMETERS: ; 3659 ! ; 3660 ! The value is the block check. ; 3661 ! ; 3662 ! IMPLICIT OUTPUTS: ; 3663 ! ; 3664 ! None. ; 3665 ! ; 3666 ! COMPLETION CODES: ; 3667 ! ; 3668 ! None. ; 3669 ! ; 3670 ! SIDE EFFECTS: ; 3671 ! ; 3672 ! None. ; 3673 ! ; 3674 !-- ; 3675 ; 3676 BEGIN ; 3677 ; 3678 LOCAL ; 3679 BLOCK%CHECK, ! To build initial block check value ; 3680 I; ! Loop counter ; 3681 ; 3682 BLOCK%CHECK = 0; ! Start out at 0 ; 3683 ; 3684 CASE .BLK%CHK%TYPE FROM CHK%1CHAR TO CHK%CRC OF ; 3685 SET ; 3686 ; 3687 [CHK%1CHAR, CHK%2CHAR] : ; 3688 ; 3689 INCR I FROM 1 TO .LENGTH DO ; 3690 BLOCK%CHECK = .BLOCK%CHECK + CH$RCHAR%A (POINTER); ; 3691 ; 3692 [CHK%CRC] : ; 3693 BLOCK%CHECK = CRCCLC (.POINTER, .LENGTH); ; 3694 TES; ; 3695 ; 3696 IF .BLK%CHK%TYPE EQL CHK%1CHAR ; 3697 THEN ; 3698 BLOCK%CHECK = (.BLOCK%CHECK + ((.BLOCK%CHECK AND %O'300')/%O'100')) AND %O'77'; ; 3699 ; 3700 RETURN .BLOCK%CHECK; ! Return the correct value ; 3701 END; ! End of CALC%BLOCK%CHK ; CALC%BLOCK%CHECK U.16: SETZ AC3, ; 3682 MOVE AC1,U.94 ; 3684 SUBI AC1,61 JRST L.184(AC1) L.184: JRST L.185 JRST L.185 JRST L.188 L.185: SETZ AC2, ; 3689 JRST L.187 L.186: ILDB AC1,-2(SP) ; 3690 ADD AC3,AC1 L.187: ADDI AC2,1 ; 3689 CAMG AC2,-1(SP) JRST L.186 JRST L.189 ; 3684 L.188: PUSH SP,-2(SP) ; 3693 PUSH SP,-2(SP) PUSHJ SP,CRCCLC MOVE AC3,AC1 ADJSP SP,-2 L.189: MOVEI AC1,61 ; 3696 CAME AC1,U.94 JRST L.190 MOVE AC1,AC3 ; 3698 ANDI AC1,300 IDIVI AC1,100 ADD AC1,AC3 LDB AC3,C.1 L.190: MOVE AC1,AC3 ; 3676 POPJ SP, ; 3634 ; Routine Size: 30 words ; 3702 %SBTTL 'Buffer filling -- Main routine' ; 3703 ROUTINE BFR%FILL (FIRST%FLAG) = ; 3704 ; 3705 !++ ; 3706 ! FUNCTIONAL DESCRIPTION: ; 3707 ! ; 3708 ! This routine will fill the buffer with data from the file. It ; 3709 ! will do all the quoting that is required. ; 3710 ! ; 3711 ! CALLING SEQUENCE: ; 3712 ! ; 3713 ! EOF%FLAG = BFR%FILL(.FIRST%FLAG); ; 3714 ! ; 3715 ! INPUT PARAMETERS: ; 3716 ! ; 3717 ! FIRST%FLAG - Flag whether first call for this file ; 3718 ! ; 3719 ! IMPLICIT INPUTS: ; 3720 ! ; 3721 ! None. ; 3722 ! ; 3723 ! OUTPUT PARAMETERS: ; 3724 ! ; 3725 ! True - Buffer filled may be at end of file. ; 3726 ! False - At end of file. ; 3727 ! ; 3728 ! IMPLICIT OUTPUTS: ; 3729 ! ; 3730 ! Number of characters stored in the buffer. ; 3731 ! ; 3732 ! COMPLETION CODES: ; 3733 ! ; 3734 ! None. ; 3735 ! ; 3736 ! SIDE EFFECTS: ; 3737 ! ; 3738 ! None. ; 3739 ! ; 3740 !-- ; 3741 ; 3742 BEGIN ; 3743 ; 3744 LOCAL ; 3745 I, ! Temp loop index ; 3746 MAX%SIZE, ! Maximum size of data ; 3747 POINTER; ! Pointer into the message buffer ; 3748 ; 3749 OWN ; 3750 NEXT%CHR, ! Saved character ; 3751 STATUS, ! Status value ; 3752 REPEAT%COUNT, ! Number of times character repeated ; 3753 CHAR%8%BIT, ! 8 bit character from file ; 3754 CHRS : VECTOR [5], ! String needed to represent character ; 3755 CHR%IDX, ! Index into CHRS ; 3756 OLD%CHAR%8%BIT, ! Previous 8-bit character ; 3757 OLD%CHRS : VECTOR [5], ! String for previous character ; 3758 OLD%CHR%IDX; ! Index for previous character ; 3759 ; 3760 ROUTINE GET%QUOTED%CHAR = ; 3761 ! ; 3762 ! This routine gets a character from the file and returns both ; 3763 ! the character and the string needed to represent the character ; 3764 ! if it needs quoting. ; 3765 ! ; 3766 BEGIN ; 3767 IF .NEXT%CHR GEQ 0 ; 3768 THEN ; 3769 BEGIN ; 3770 CHAR%8%BIT = .NEXT%CHR; ; 3771 NEXT%CHR = -1; ; 3772 STATUS = KER%NORMAL; ; 3773 END ; 3774 ELSE ; 3775 STATUS = GET%FILE (CHAR%8%BIT); ; 3776 IF .STATUS EQL KER%NORMAL ; 3777 THEN ; 3778 BEGIN ; 3779 ! ; 3780 ! Determine if we should just quote the character ; 3781 ! Either: ; 3782 ! Character is a delete (177 octal) ; 3783 ! or Character is a control character (less than 40 octal) ; 3784 ! or Character is a quote character ; 3785 ! or Character is the repeat character and doing repeat compression ; 3786 ! or Character is an eight bit quote character and doing eight bit ; 3787 ! quoting. ; 3788 ! ; 3789 ; 3790 IF ((.CHAR%8%BIT AND %O'177') LSS %C' ') OR ((.CHAR%8%BIT AND %O'177') EQL CHR%DEL) OR ( ; 3791 (.CHAR%8%BIT AND %O'177') EQL .SEND%QUOTE%CHR) OR (.FLAG%REPEAT AND ((.CHAR%8%BIT ; 3792 AND %O'177') EQL .REPT%CHR)) OR (.FLAG%8QUOTE AND ((.CHAR%8%BIT AND %O'177') EQL ; 3793 .SEND%8QUOTE%CHR)) ; 3794 THEN ; 3795 BEGIN ; 3796 ! ; 3797 ! If the character is a control character or delete we must do a CTL(Character) ; 3798 ! so it is something that we can be sure we can send. ; 3799 ! ; 3800 ; 3801 IF ((.CHAR%8%BIT AND %O'177') LSS %C' ') OR ((.CHAR%8%BIT AND %O'177') EQL CHR%DEL) ; 3802 THEN ; 3803 CHRS [0] = CTL (.CHAR%8%BIT) ; 3804 ELSE ; 3805 CHRS [0] = .CHAR%8%BIT; ; 3806 ; 3807 CHR%IDX = 1; ; 3808 CHRS [1] = .SEND%QUOTE%CHR; ; 3809 END ; 3810 ELSE ; 3811 BEGIN ; 3812 CHR%IDX = 0; ; 3813 CHRS [0] = .CHAR%8%BIT; ; 3814 END; ; 3815 ; 3816 END; ; 3817 ; 3818 RETURN .STATUS; ; 3819 END; RELOC 251 ; NEXT%CHR U.116: BLOCK 1 ; STATUS U.117: BLOCK 1 ; REPEAT%COUNT U.118: BLOCK 1 ; CHAR%8%BIT U.119: BLOCK 1 ; CHRS U.120: BLOCK 5 ; CHR%IDX U.121: BLOCK 1 ; OLD%CHAR%8%BIT U.122: BLOCK 1 ; OLD%CHRS U.123: BLOCK 5 ; OLD%CHR%IDX U.124: BLOCK 1 RELOC 403167 ; GET%QUOTED%CHAR U.125: MOVE AC1,U.116 ; 3767 JUMPL AC1,L.191 MOVEM AC1,U.119 ; 3770 SETOM U.116 ; 3771 MOVEI AC1,13 ; 3772 MOVEM AC1,U.117 JRST L.192 ; 3767 L.191: PUSH SP,C.75 ; 3775 PUSHJ SP,GET%FILE MOVEM AC1,U.117 ADJSP SP,-1 L.192: MOVE AC4,U.117 ; 3776 CAIE AC4,13 JRST L.197 MOVE AC2,U.119 ; 3790 LDB AC1,C.74 SETZ AC3, CAIL AC1,40 JRST L.193 MOVEI AC3,1 JRST L.195 L.193: CAIE AC1,177 CAMN AC1,U.91 JRST L.195 MOVEI AC5,1 ; 3791 TDNN AC5,U.96 JRST L.194 CAMN AC1,U.85 JRST L.195 L.194: MOVEI AC5,1 ; 3792 TDNE AC5,U.95 CAME AC1,U.92 JRST L.196 L.195: TRNN AC3,1 ; 3801 CAIN AC1,177 TRC AC2,100 ; 3803 MOVEM AC2,U.120 ; 3805 MOVEI AC1,1 ; 3807 MOVEM AC1,U.121 MOVE AC1,U.91 ; 3808 MOVEM AC1,U.120+1 JRST L.197 ; 3790 L.196: SETZM U.121 ; 3812 MOVEM AC2,U.120 ; 3813 L.197: MOVE AC1,AC4 ; 3766 POPJ SP, ; 3760 C.74: POINT 7,AC2,35 C.75: XWD 0,U.119 ; Routine Size: 48 words ; 3820 ROUTINE GET%8%QUOTED%CHAR = ; 3821 ! ; 3822 ! This routine will get the quoted representation of a character ; 3823 ! (by calling GET%QUOTED%CHAR), and return the 8th-bit quoted ; 3824 ! representation. ; 3825 ! ; 3826 BEGIN ; 3827 ; 3828 IF (STATUS = GET%QUOTED%CHAR ()) EQL KER%NORMAL ; 3829 THEN ; 3830 BEGIN ; 3831 ! ; 3832 ! Determine if we must quote the eighth bit (parity bit on) ; 3833 ! ; 3834 ; 3835 IF (((.CHRS [0] AND %O'177') NEQ .CHRS [0]) AND .FLAG%8QUOTE) ; 3836 THEN ; 3837 BEGIN ; 3838 CHRS [0] = .CHRS [0] AND %O'177'; ; 3839 CHR%IDX = .CHR%IDX + 1; ; 3840 CHRS [.CHR%IDX] = .SEND%8QUOTE%CHR; ; 3841 END; ; 3842 ; 3843 END; ; 3844 ; 3845 RETURN .STATUS; ; 3846 END; ; GET%8%QUOTED%CHAR U.126: PUSHJ SP,U.125 ; 3828 MOVEM AC1,U.117 CAIE AC1,13 JRST L.198 LDB AC1,C.76 ; 3835 CAMN AC1,U.120 JRST L.198 MOVEI AC1,1 TDNN AC1,U.95 JRST L.198 LDB AC1,C.76 ; 3838 MOVEM AC1,U.120 AOS AC1,U.121 ; 3840 MOVE AC2,U.92 MOVEM AC2,U.120(AC1) L.198: MOVE AC1,U.117 ; 3826 POPJ SP, ; 3820 C.76: POINT 7,U.120,35 ; Routine Size: 18 words ; 3847 ! ; 3848 ! Start of code for BFR%FILL ; 3849 ! ; 3850 ! Initialize pointer and count ; 3851 ! ; 3852 SIZE = 0; ; 3853 POINTER = CH$PTR (SND%MSG, PKT%MSG, CHR%SIZE); ; 3854 MAX%SIZE = .SEND%PKT%SIZE - PKT%OVR%HEAD - (.BLK%CHK%TYPE - CHK%1CHAR); ; 3855 ; 3856 ! ; 3857 ! If last call got an error or eof, return it now ; 3858 ! ; 3859 ; 3860 IF NOT .FIRST%FLAG AND (.STATUS NEQ KER%NORMAL) THEN RETURN .STATUS; ; 3861 ; 3862 ! ; 3863 ! If first time for a file prime the pump with the first character. ; 3864 ! ; 3865 ; 3866 IF .FIRST%FLAG ; 3867 THEN ; 3868 BEGIN ; 3869 FIRST%FLAG = FALSE; ; 3870 NEXT%CHR = -1; ! No backed up character ; 3871 ; 3872 IF .FLAG%8QUOTE THEN STATUS = GET%8%QUOTED%CHAR () ELSE STATUS = GET%QUOTED%CHAR (); ; 3873 ; 3874 OLD%CHAR%8%BIT = .CHAR%8%BIT; ; 3875 ; 3876 INCR OLD%CHR%IDX FROM 0 TO .CHR%IDX DO ; 3877 OLD%CHRS [.OLD%CHR%IDX] = .CHRS [.OLD%CHR%IDX]; ; 3878 ; 3879 OLD%CHR%IDX = .CHR%IDX; ; 3880 REPEAT%COUNT = 0; ! Character was not repeated yet ; 3881 ! Will always be incremented ; 3882 END; ; 3883 ; 3884 ! ; 3885 ! Otherwise, loop until we fill buffer ; 3886 ! ; 3887 ; 3888 WHILE .SIZE LSS .MAX%SIZE DO ! Normal exit is via an EXITLOOP ; 3889 BEGIN ; 3890 ! ; 3891 ! Check if we are doing run compression ; 3892 ! ; 3893 ; 3894 IF .FLAG%REPEAT ; 3895 THEN ; 3896 BEGIN ; 3897 ! ; 3898 ! Here with previous character in OLD%xxx. As long as we ; 3899 ! are getting the same character, just count the run. ; 3900 ! ; 3901 ; 3902 WHILE (.CHAR%8%BIT EQL .OLD%CHAR%8%BIT) AND (.REPEAT%COUNT LSS 94) DO ; 3903 BEGIN ; 3904 REPEAT%COUNT = .REPEAT%COUNT + 1; ; 3905 ; 3906 IF .FLAG%8QUOTE THEN STATUS = GET%8%QUOTED%CHAR () ELSE STATUS = GET%QUOTED%CHAR (); ; 3907 ; 3908 IF (.STATUS NEQ KER%NORMAL) THEN CHAR%8%BIT = -1; ; 3909 ; 3910 END; ; 3911 ; 3912 IF .OLD%CHR%IDX + 1 + 2 LSS ((.OLD%CHR%IDX + 1)*.REPEAT%COUNT) ; 3913 THEN ; 3914 BEGIN ; 3915 IF .SIZE + .OLD%CHR%IDX + 1 + 2 GTR .MAX%SIZE ; 3916 THEN ; 3917 BEGIN ; 3918 IF .CHAR%8%BIT EQL .OLD%CHAR%8%BIT ; 3919 THEN ; 3920 BEGIN ; 3921 NEXT%CHR = .CHAR%8%BIT; ; 3922 REPEAT%COUNT = .REPEAT%COUNT - 1; ; 3923 END; ; 3924 EXITLOOP; ; 3925 END; ; 3926 OLD%CHRS [.OLD%CHR%IDX + 1] = CHAR (.REPEAT%COUNT); ; 3927 OLD%CHRS [.OLD%CHR%IDX + 2] = .REPT%CHR; ; 3928 OLD%CHR%IDX = .OLD%CHR%IDX + 2; ; 3929 REPEAT%COUNT = 1; ! Only one time for this string ; 3930 END; ; 3931 ; 3932 ! ; 3933 ! If we don't have enough room for this character, wait till next ; 3934 ! time. ; 3935 ! ; 3936 ; 3937 IF .SIZE + (.OLD%CHR%IDX + 1)*.REPEAT%COUNT GTR .MAX%SIZE ; 3938 THEN ; 3939 BEGIN ; 3940 ! If the next character is the same, the count will get incremented ; 3941 ! next time we enter, so back it off now. ; 3942 ; 3943 IF .CHAR%8%BIT EQL .OLD%CHAR%8%BIT ; 3944 THEN ; 3945 BEGIN ; 3946 NEXT%CHR = .CHAR%8%BIT; ; 3947 REPEAT%COUNT = .REPEAT%COUNT - 1; ; 3948 END; ; 3949 EXITLOOP; ; 3950 END; ; 3951 ; 3952 DECR REPEAT%COUNT FROM .REPEAT%COUNT TO 1 DO ; 3953 ; 3954 DECR I FROM .OLD%CHR%IDX TO 0 DO ; 3955 BEGIN ; 3956 CH$WCHAR%A (.OLD%CHRS [.I], POINTER); ; 3957 SIZE = .SIZE + 1; ; 3958 END; ; 3959 ; 3960 ! ; 3961 ! If we got an error (or EOF) then exit ; 3962 ! ; 3963 ; 3964 IF (.STATUS NEQ KER%NORMAL) THEN EXITLOOP; ; 3965 ; 3966 ! ; 3967 ! Otherwise, copy the character which broke the run ; 3968 ! ; 3969 OLD%CHAR%8%BIT = .CHAR%8%BIT; ; 3970 ; 3971 INCR OLD%CHR%IDX FROM 0 TO .CHR%IDX DO ; 3972 OLD%CHRS [.OLD%CHR%IDX] = .CHRS [.OLD%CHR%IDX]; ; 3973 ; 3974 OLD%CHR%IDX = .CHR%IDX; ; 3975 REPEAT%COUNT = 0; ; 3976 END ; 3977 ELSE ; 3978 ! ; 3979 ! Here if we are not doing run compression. We can do things much ; 3980 ! easier. ; 3981 ! ; 3982 BEGIN ; 3983 ; 3984 IF (.SIZE + .CHR%IDX + 1) GTR .MAX%SIZE THEN EXITLOOP; ; 3985 ; 3986 DECR CHR%IDX FROM .CHR%IDX TO 0 DO ; 3987 BEGIN ; 3988 CH$WCHAR%A (.CHRS [.CHR%IDX], POINTER); ; 3989 SIZE = .SIZE + 1; ; 3990 END; ; 3991 ; 3992 IF .FLAG%8QUOTE THEN STATUS = GET%8%QUOTED%CHAR () ELSE STATUS = GET%QUOTED%CHAR (); ; 3993 ; 3994 IF (.STATUS NEQ KER%NORMAL) THEN EXITLOOP; ; 3995 ; 3996 END; ; 3997 ; 3998 END; ; 3999 ; 4000 ! ; 4001 ! Determine if we really stored anything into the buffer. ; 4002 ! ; 4003 ; 4004 IF .SIZE NEQ 0 THEN RETURN KER%NORMAL ELSE RETURN .STATUS; ; 4005 ; 4006 END; ! End of BFR%FILL ; BFR%FILL U.25: PUSH SP,AC14 ; 3703 PUSH SP,AC16 SETZM U.99 ; 3852 MOVE AC14,C.12 ; 3853 MOVE AC1,U.86 ; 3854 SUB AC1,U.94 MOVE AC16,AC1 ADDI AC16,56 MOVE AC1,-3(SP) ; 3860 TRNE AC1,1 JRST L.199 MOVEI AC2,13 CAME AC2,U.117 JRST L.226 L.199: TRNN AC1,1 ; 3866 JRST L.205 SETZM -3(SP) ; 3869 SETOM U.116 ; 3870 MOVEI AC1,1 ; 3872 TDNN AC1,U.95 JRST L.200 PUSHJ SP,U.126 JRST L.201 L.200: PUSHJ SP,U.125 L.201: MOVEM AC1,U.117 MOVE AC1,U.119 ; 3874 MOVEM AC1,U.122 SETO AC1, ; 3876 JRST L.203 L.202: MOVE AC2,U.120(AC1) ; 3877 MOVEM AC2,U.123(AC1) L.203: ADDI AC1,1 ; 3876 CAMG AC1,U.121 JRST L.202 L.204: MOVE AC1,U.121 ; 3879 MOVEM AC1,U.124 SETZM U.118 ; 3880 L.205: CAMG AC16,U.99 ; 3888 JRST L.225 MOVEI AC1,1 ; 3894 TDNN AC1,U.96 JRST L.220 L.206: MOVE AC1,U.119 ; 3902 CAME AC1,U.122 JRST L.209 MOVEI AC1,136 CAMG AC1,U.118 JRST L.209 AOS U.118 ; 3904 MOVEI AC1,1 ; 3906 TDNN AC1,U.95 JRST L.207 PUSHJ SP,U.126 JRST L.208 L.207: PUSHJ SP,U.125 L.208: MOVEM AC1,U.117 MOVEI AC1,13 ; 3908 CAME AC1,U.117 SETOM U.119 JRST L.206 L.209: MOVE AC2,U.124 ; 3912 MOVE AC4,AC2 ADDI AC4,3 MOVE AC1,AC2 AOS AC3,AC1 IMUL AC3,U.118 CAML AC4,AC3 JRST L.211 MOVE AC3,U.99 ; 3915 ADD AC3,AC2 ADDI AC3,3 CAMG AC3,AC16 JRST L.210 MOVE AC3,U.119 ; 3918 CAME AC3,U.122 JRST L.225 MOVE AC3,U.119 ; 3921 MOVEM AC3,U.116 JRST L.212 L.210: MOVE AC3,U.118 ; 3926 ADDI AC3,40 MOVEM AC3,U.123(AC1) MOVE AC1,U.85 ; 3927 MOVEM AC1,U.123+2(AC2) MOVEI AC1,2 ; 3928 ADDM AC1,U.124 MOVEI AC1,1 ; 3929 MOVEM AC1,U.118 L.211: MOVE AC1,U.124 ; 3937 ADDI AC1,1 IMUL AC1,U.118 ADD AC1,U.99 CAMG AC1,AC16 JRST L.213 MOVE AC1,U.119 ; 3943 CAME AC1,U.122 JRST L.225 MOVE AC1,U.119 ; 3946 MOVEM AC1,U.116 L.212: SOS U.118 ; 3947 JRST L.225 ; 3943 L.213: MOVE AC3,U.118 ; 3952 AOJA AC3,L.217 L.214: MOVE AC1,U.124 ; 3954 AOJA AC1,L.216 L.215: MOVE AC2,U.123(AC1) ; 3956 IDPB AC2,AC14 AOS U.99 ; 3957 L.216: SOJGE AC1,L.215 ; 3954 L.217: SOJG AC3,L.214 ; 3952 MOVEI AC1,13 ; 3964 CAME AC1,U.117 JRST L.225 MOVE AC1,U.119 ; 3969 MOVEM AC1,U.122 SETO AC1, ; 3971 JRST L.219 L.218: MOVE AC2,U.120(AC1) ; 3972 MOVEM AC2,U.123(AC1) L.219: ADDI AC1,1 ; 3971 CAMG AC1,U.121 JRST L.218 JRST L.204 L.220: MOVE AC1,U.99 ; 3984 ADD AC1,U.121 ADDI AC1,1 CAMLE AC1,AC16 JRST L.225 MOVE AC1,U.121 ; 3986 AOJA AC1,L.222 L.221: MOVE AC2,U.120(AC1) ; 3988 IDPB AC2,AC14 AOS U.99 ; 3989 L.222: SOJGE AC1,L.221 ; 3986 MOVEI AC1,1 ; 3992 TDNN AC1,U.95 JRST L.223 PUSHJ SP,U.126 JRST L.224 L.223: PUSHJ SP,U.125 L.224: MOVEM AC1,U.117 MOVEI AC1,13 ; 3994 CAMN AC1,U.117 JRST L.205 ; 3888 L.225: SKIPN U.99 ; 4004 JRST L.226 MOVEI AC1,13 ; 3742 JRST L.227 L.226: MOVE AC1,U.117 L.227: POP SP,AC16 ; 3703 POP SP,AC14 POPJ SP, ; Routine Size: 152 words ; 4007 %SBTTL 'Buffer filling -- Add parity routine' ; 4008 ROUTINE DO%PARITY (MESSAGE, LENGTH) : NOVALUE = ; 4009 ; 4010 !++ ; 4011 ! FUNCTIONAL DESCRIPTION: ; 4012 ! ; 4013 ! This routine will add parity for a complete message that is to be ; 4014 ! sent to the remote Kermit. ; 4015 ! ; 4016 ! CALLING SEQUENCE: ; 4017 ! ; 4018 ! DO%PARITY (Message%address, Message%length); ; 4019 ! ; 4020 ! INPUT PARAMETERS: ; 4021 ! ; 4022 ! Message%address - Address of the message to put parity on. ; 4023 ! Message%length - Lengtho of the message. ; 4024 ! ; 4025 ! IMPLICIT INPUTS: ; 4026 ! ; 4027 ! None. ; 4028 ! ; 4029 ! OUTPUT PARAMETERS: ; 4030 ! ; 4031 ! None. ; 4032 ! ; 4033 ! IMPLICIT OUTPUTS: ; 4034 ! ; 4035 ! None. ; 4036 ! ; 4037 ! COMPLETION CODES: ; 4038 ! ; 4039 ! None. ; 4040 ! ; 4041 ! SIDE EFFECTS: ; 4042 ! ; 4043 ! None. ; 4044 ! ; 4045 !-- ; 4046 ; 4047 BEGIN ; 4048 ; 4049 MAP ; 4050 MESSAGE : REF VECTOR [CH$ALLOCATION (MAX%MSG, CHR%SIZE)]; ; 4051 ; 4052 LOCAL ; 4053 POINTER; ! Point into the message ; 4054 ; 4055 IF NOT .DEV%PARITY%FLAG ; 4056 THEN ; 4057 BEGIN ; 4058 POINTER = CH$PTR (.MESSAGE,, CHR%SIZE); ; 4059 ; 4060 INCR I FROM 1 TO .LENGTH DO ; 4061 CH$WCHAR%A (GEN%PARITY (CH$RCHAR (.POINTER)), POINTER); ; 4062 ; 4063 END; ; 4064 ; 4065 END; ! End of DO%PARITY ; DO%PARITY U.19: PUSH SP,AC13 ; 4008 PUSH SP,AC14 PUSH SP,AC16 MOVEI AC1,1 ; 4055 TDNE AC1,DEV%PARITY%FLAG JRST L.230 MOVE AC1,-5(SP) ; 4058 MOVEI AC1,-1(AC1) HRLI AC1,41000 MOVE AC14,AC1 MOVE AC13,-4(SP) ; 4060 SETZ AC16, JRST L.229 L.228: MOVE AC1,AC14 ; 4061 ILDB AC1,AC1 PUSH SP,AC1 PUSHJ SP,U.20 IDPB AC1,AC14 ADJSP SP,-1 L.229: ADDI AC16,1 ; 4060 CAMG AC16,AC13 JRST L.228 L.230: POP SP,AC16 ; 4008 POP SP,AC14 POP SP,AC13 POPJ SP, ; Routine Size: 26 words ; 4066 %SBTTL 'Buffer filling -- Parity routine' ; 4067 ; 4068 GLOBAL ROUTINE GEN%PARITY (CHARACTER) = ; 4069 ; 4070 !++ ; 4071 ! FUNCTIONAL DESCRIPTION: ; 4072 ! ; 4073 ! This routine will add parity to the character that is supplied. ; 4074 ! ; 4075 ! CALLING SEQUENCE: ; 4076 ! ; 4077 ! CHARACTER = GEN%PARITY(CHARACTER) ; 4078 ! ; 4079 ! INPUT PARAMETERS: ; 4080 ! ; 4081 ! CHARACTER - Produce the parity for this character depending on the ; 4082 ! setting of the SET PARITY switch. ; 4083 ! ; 4084 ! IMPLICIT INPUTS: ; 4085 ! ; 4086 ! None. ; 4087 ! ; 4088 ! OUTPUT PARAMETERS: ; 4089 ! ; 4090 ! None. ; 4091 ! ; 4092 ! IMPLICIT OUTPUTS: ; 4093 ! ; 4094 ! None. ; 4095 ! ; 4096 ! COMPLETION CODES: ; 4097 ! ; 4098 ! None. ; 4099 ! ; 4100 ! SIDE EFFECTS: ; 4101 ! ; 4102 ! None. ; 4103 ! ; 4104 !-- ; 4105 ; 4106 BEGIN ; 4107 ; 4108 LOCAL ; 4109 TEMP%CHAR; ; 4110 ; 4111 IF .IBM%FLAG THEN RETURN .CHARACTER OR %O'200'; ; 4112 ; 4113 CASE .PARITY%TYPE FROM PR%MIN TO PR%MAX OF ; 4114 SET ; 4115 ; 4116 [PR%NONE] : ; 4117 RETURN .CHARACTER; ; 4118 ; 4119 [PR%SPACE] : ; 4120 RETURN .CHARACTER AND %O'177'; ; 4121 ; 4122 [PR%MARK] : ; 4123 RETURN .CHARACTER OR %O'200'; ; 4124 ; 4125 [PR%ODD] : ; 4126 BEGIN ; 4127 TEMP%CHAR = .CHARACTER AND %O'177' OR %O'200'; ; 4128 TEMP%CHAR = .TEMP%CHAR<0, 4> XOR .TEMP%CHAR<4, 4>; ; 4129 TEMP%CHAR = .TEMP%CHAR<0, 2> XOR .TEMP%CHAR<2, 2>; ; 4130 ; 4131 IF .TEMP%CHAR EQL %B'01' OR .TEMP%CHAR EQL %B'10' ; 4132 THEN ; 4133 RETURN .CHARACTER AND %O'177' OR %O'200' ; 4134 ELSE ; 4135 RETURN .CHARACTER AND %O'177'; ; 4136 ; 4137 END; ; 4138 ; 4139 [PR%EVEN] : ; 4140 BEGIN ; 4141 TEMP%CHAR = .CHARACTER AND %O'177'; ; 4142 TEMP%CHAR = .TEMP%CHAR<0, 4> XOR .TEMP%CHAR<4, 4>; ; 4143 TEMP%CHAR = .TEMP%CHAR<0, 2> XOR .TEMP%CHAR<2, 2>; ; 4144 ; 4145 IF .TEMP%CHAR EQL %B'01' OR .TEMP%CHAR EQL %B'10' ; 4146 THEN ; 4147 RETURN .CHARACTER AND %O'177' OR %O'200' ; 4148 ELSE ; 4149 RETURN .CHARACTER AND %O'177'; ; 4150 ; 4151 END; ; 4152 TES; ; 4153 ; 4154 END; ! End of GEN%PARITY U.20: GEN%PARITY:: MOVEI AC1,1 ; 4111 TDNN AC1,IBM%FLAG JRST L.231 MOVE AC1,-1(SP) JRST L.239 L.231: MOVE AC3,-1(SP) ; 4117 MOVE AC1,PARITY%TYPE ; 4113 JRST L.232(AC1) ; 4106 L.232: JRST L.233 JRST L.234 JRST L.237 JRST L.235 JRST L.240 L.233: MOVE AC1,AC3 POPJ SP, L.234: MOVE AC1,AC3 ; 4123 JRST L.239 L.235: LDB AC4,C.77 ; 4127 TRO AC4,200 MOVE AC1,AC4 LDB AC2,C.78 ; 4128 LDB AC5,C.79 XOR AC2,AC5 MOVE AC1,AC2 LDB AC2,C.80 ; 4129 LDB AC5,C.81 XOR AC2,AC5 MOVE AC1,AC2 CAIN AC1,1 ; 4131 JRST L.236 CAIE AC1,2 JRST L.240 L.236: MOVE AC1,AC4 ; 4126 POPJ SP, L.237: LDB AC1,C.77 ; 4141 LDB AC2,C.78 ; 4142 LDB AC4,C.79 XOR AC2,AC4 MOVE AC1,AC2 LDB AC2,C.80 ; 4143 LDB AC4,C.81 XOR AC2,AC4 MOVE AC1,AC2 CAIN AC1,1 ; 4145 JRST L.238 CAIE AC1,2 JRST L.240 L.238: LDB AC1,C.77 ; 4147 L.239: TROA AC1,200 L.240: LDB AC1,C.77 ; 4140 POPJ SP, ; 4068 C.77: POINT 7,AC3,35 C.78: POINT 4,AC1,35 C.79: POINT 4,AC1,31 C.80: POINT 2,AC1,35 C.81: POINT 2,AC1,33 ; Routine Size: 56 words ; 4155 ; 4156 %SBTTL 'BFR%EMPTY' ; 4157 ROUTINE BFR%EMPTY = ; 4158 ; 4159 !++ ; 4160 ! FUNCTIONAL DESCRIPTION: ; 4161 ! ; 4162 ! This routine will empty the data from the REC%MSG message buffer ; 4163 ! to the file. It will process quoting characters. ; 4164 ! ; 4165 ! CALLING SEQUENCE: ; 4166 ! ; 4167 ! Flag = BFR%EMPTY(); ; 4168 ! ; 4169 ! INPUT PARAMETERS: ; 4170 ! ; 4171 ! None. ; 4172 ! ; 4173 ! IMPLICIT INPUTS: ; 4174 ! ; 4175 ! None. ; 4176 ! ; 4177 ! OUTPUT PARAMETERS: ; 4178 ! ; 4179 ! True - No problems writing the file. ; 4180 ! False - I/O error writing the file. ; 4181 ! ; 4182 ! IMPLICIT OUTPUTS: ; 4183 ! ; 4184 ! None. ; 4185 ! ; 4186 ! COMPLETION CODES: ; 4187 ! ; 4188 ! None. ; 4189 ! ; 4190 ! SIDE EFFECTS: ; 4191 ! ; 4192 ! None. ; 4193 ! ; 4194 !-- ; 4195 ; 4196 BEGIN ; 4197 ; 4198 LOCAL ; 4199 REPEAT%COUNT, ! Count of times to repeat character ; 4200 TURN%BIT%8%ON, ! If eight bit quoting ; 4201 COUNTER, ! Count of the characters left ; 4202 CHARACTER, ! Character we are processing ; 4203 POINTER; ! Pointer to the data ; 4204 ; 4205 POINTER = CH$PTR (REC%MSG, PKT%MSG, CHR%SIZE); ; 4206 COUNTER = 0; ; 4207 ; 4208 WHILE (.COUNTER LSS .REC%LENGTH) DO ; 4209 BEGIN ; 4210 CHARACTER = CH$RCHAR%A (POINTER); ; 4211 COUNTER = .COUNTER + 1; ; 4212 ! ; 4213 ! If the character is the repeat character (and we are doing repeat ; 4214 ! compression), then get the count. ; 4215 ! ; 4216 ; 4217 IF ((.CHARACTER EQL .REPT%CHR) AND .FLAG%REPEAT) ; 4218 THEN ; 4219 BEGIN ; 4220 REPEAT%COUNT = UNCHAR (CH$RCHAR%A (POINTER) AND %O'177'); ; 4221 CHARACTER = CH$RCHAR%A (POINTER); ; 4222 COUNTER = .COUNTER + 2; ; 4223 END ; 4224 ELSE ; 4225 REPEAT%COUNT = 1; ; 4226 ; 4227 ! ; 4228 ! If the character is an eight bit quoting character and we are doing eight ; 4229 ! bit quoting then turn on the flag so we turn the eighth bit on when we ; 4230 ! get the real character. ; 4231 ! ; 4232 ; 4233 IF ((.CHARACTER EQL .SEND%8QUOTE%CHR) AND .FLAG%8QUOTE) ; 4234 THEN ; 4235 BEGIN ; 4236 TURN%BIT%8%ON = TRUE; ; 4237 COUNTER = .COUNTER + 1; ; 4238 CHARACTER = CH$RCHAR%A (POINTER); ; 4239 END ; 4240 ELSE ; 4241 TURN%BIT%8%ON = FALSE; ; 4242 ; 4243 ! ; 4244 ! Now determine if we are quoting the character. If so then we must eat ; 4245 ! the quoting character and get the real character. ; 4246 ! ; 4247 ; 4248 IF .CHARACTER EQL .RCV%QUOTE%CHR ; 4249 THEN ; 4250 BEGIN ; 4251 CHARACTER = CH$RCHAR%A (POINTER); ; 4252 COUNTER = .COUNTER + 1; ; 4253 ! ; 4254 ! Determine if we must undo what someone else has done to the character ; 4255 ! ; 4256 ; P 4257 IF ((.CHARACTER AND %O'177') GEQ CTL (CHR%DEL)) AND ((.CHARACTER AND %O'177') LEQ CTL ( ; 4258 CHR%DEL) + %O'40') ; 4259 THEN ; 4260 CHARACTER = CTL (.CHARACTER); ; 4261 ; 4262 END; ; 4263 ; 4264 ! ; 4265 ! Turn on the eight bit if needed and then write the character out ; 4266 ! ; 4267 ; 4268 IF .TURN%BIT%8%ON THEN CHARACTER = .CHARACTER OR %O'200'; ; 4269 ; 4270 WHILE (REPEAT%COUNT = .REPEAT%COUNT - 1) GEQ 0 DO ; 4271 BEGIN ; 4272 STATUS = PUT%FILE (.CHARACTER); ; 4273 ; 4274 IF NOT .STATUS THEN RETURN .STATUS; ; 4275 ; 4276 END; ; 4277 ; 4278 END; ; 4279 ; 4280 ! ; 4281 ! Dump the record if we have an RMS based system. Otherwise we will have ; 4282 ! problem with binary files. ; 4283 ! ; 4284 STATUS = FILE%DUMP (); ; 4285 ; 4286 IF NOT .STATUS THEN RETURN .STATUS; ; 4287 ; 4288 RETURN KER%NORMAL; ; 4289 END; ! End of BFR%EMPTY ; BFR%EMPTY U.24: PUSH SP,AC11 ; 4157 PUSH SP,AC12 PUSH SP,AC13 PUSH SP,AC14 PUSH SP,AC16 MOVE AC13,C.5 ; 4205 SETZ AC14, ; 4206 L.241: CAML AC14,U.104 ; 4208 JRST L.249 ILDB AC16,AC13 ; 4210 ADDI AC14,1 ; 4211 CAME AC16,U.85 ; 4217 JRST L.242 MOVEI AC1,1 TDNN AC1,U.96 JRST L.242 ILDB AC1,AC13 ; 4220 LDB AC12,C.82 SUBI AC12,40 ILDB AC16,AC13 ; 4221 ADDI AC14,2 ; 4222 JRST L.243 ; 4217 L.242: MOVEI AC12,1 ; 4225 L.243: CAME AC16,U.92 ; 4233 JRST L.244 MOVEI AC1,1 TDNN AC1,U.95 JRST L.244 MOVEI AC11,1 ; 4236 ADDI AC14,1 ; 4237 ILDB AC16,AC13 ; 4238 JRST L.245 ; 4233 L.244: SETZ AC11, ; 4241 L.245: CAME AC16,RCV%QUOTE%CHR ; 4248 JRST L.246 ILDB AC16,AC13 ; 4251 ADDI AC14,1 ; 4252 LDB AC1,C.83 ; 4257 CAIL AC1,77 CAILE AC1,137 JRST L.246 TRC AC16,100 ; 4260 L.246: TRNE AC11,1 ; 4268 TRO AC16,200 L.247: SOJL AC12,L.241 ; 4270 PUSH SP,AC16 ; 4272 PUSHJ SP,PUT%FILE MOVEM AC1,U.97 TRNE AC1,1 ; 4274 JRST L.248 ADJSP SP,-1 JRST L.250 L.248: ADJSP SP,-1 ; 4271 JRST L.247 ; 4270 L.249: PUSHJ SP,FILE%DUMP ; 4284 MOVEM AC1,U.97 TRNE AC1,1 ; 4286 MOVEI AC1,13 ; 4196 L.250: POP SP,AC16 ; 4157 POP SP,AC14 POP SP,AC13 POP SP,AC12 POP SP,AC11 POPJ SP, C.82: POINT 7,AC1,35 C.83: POINT 7,AC16,35 ; Routine Size: 66 words ; 4290 %SBTTL 'Per transfer -- Initialization' ; 4291 ROUTINE INIT%XFR : NOVALUE = ; 4292 ; 4293 !++ ; 4294 ! FUNCTIONAL DESCRIPTION: ; 4295 ! ; 4296 ! This routine will initialize the various locations that the ; 4297 ! send and receive statistics are kept. ; 4298 ! ; 4299 ! CALLING SEQUENCE: ; 4300 ! ; 4301 ! INIT%XFR(); ; 4302 ! ; 4303 ! INPUT PARAMETERS: ; 4304 ! ; 4305 ! None. ; 4306 ! ; 4307 ! IMPLICIT INPUTS: ; 4308 ! ; 4309 ! None. ; 4310 ! ; 4311 ! OUTPUT PARAMETERS: ; 4312 ! ; 4313 ! None. ; 4314 ! ; 4315 ! IMPLICIT OUTPUTS: ; 4316 ! ; 4317 ! None. ; 4318 ! ; 4319 ! COMPLETION CODES: ; 4320 ! ; 4321 ! None. ; 4322 ! ; 4323 ! SIDE EFFECTS: ; 4324 ! ; 4325 ! None. ; 4326 ! ; 4327 !-- ; 4328 ; 4329 BEGIN ; 4330 ! ; 4331 ! Determine if we should do 8 bit quoting ; 4332 ! ; 4333 ; 4334 IF .PARITY%TYPE NEQ PR%NONE ; 4335 THEN ; 4336 BEGIN ; 4337 RECV%8QUOTE%CHR = .RCV%8QUOTE%CHR; ; 4338 END ; 4339 ELSE ; 4340 BEGIN ; 4341 RECV%8QUOTE%CHR = %C'Y'; ; 4342 END; ; 4343 SEND%8QUOTE%CHR = .RECV%8QUOTE%CHR; ; 4344 ; 4345 ! ; 4346 ! Send parameters that may not get set before we need them for the first ; 4347 ! time. ; 4348 ! ; 4349 SEND%PKT%SIZE = ABS (.SND%PKT%SIZE); ; 4350 SEND%NPAD = ABS (.SND%NPAD); ; 4351 SEND%PADCHAR = ABS (.SND%PADCHAR); ; 4352 SEND%TIMEOUT = ABS (.SND%TIMEOUT); ; 4353 SEND%EOL = ABS (.SND%EOL); ; 4354 SEND%QUOTE%CHR = ABS (.SND%QUOTE%CHR); ; 4355 ! ; 4356 ! For initialization messages, we must use single character checksum ; 4357 ! When the send-init/ack sequence has been done, we will switch to the ; 4358 ! desired form ; 4359 ! ; 4360 BLK%CHK%TYPE = CHK%1CHAR; ; 4361 INI%CHK%TYPE = .CHKTYPE; ! Send desired type ; 4362 ! ; 4363 ! Set desired repeat character for use in we are doing send-init ; 4364 ! Will be overwritten by other ends desired character if it sends ; 4365 ! the send-init. ; 4366 ! ; 4367 REPT%CHR = .SET%REPT%CHR; ; 4368 ! ; 4369 ! Stats information ; 4370 ! ; 4371 SMSG%TOTAL%CHARS = 0; ; 4372 RMSG%TOTAL%CHARS = 0; ; 4373 SMSG%DATA%CHARS = 0; ; 4374 RMSG%DATA%CHARS = 0; ; 4375 RMSG%NAKS = 0; ; 4376 SMSG%NAKS = 0; ; 4377 XFR%TIME = SY%TIME (); ; 4378 END; ! End of INIT%XFR ; INIT%XFR U.27: SKIPE PARITY%TYPE ; 4334 SKIPA AC1,RCV%8QUOTE%CHR ; 4337 MOVEI AC1,131 ; 4341 MOVEM AC1,U.84 MOVEM AC1,U.92 ; 4343 MOVE AC1,SND%PKT%SIZE ; 4349 MOVMM AC1,U.86 MOVE AC1,SND%NPAD ; 4350 MOVMM AC1,U.87 MOVE AC1,SND%PADCHAR ; 4351 MOVMM AC1,U.88 MOVE AC1,SND%TIMEOUT ; 4352 MOVMM AC1,U.89 MOVE AC1,SND%EOL ; 4353 MOVMM AC1,U.90 MOVE AC1,SND%QUOTE%CHR ; 4354 MOVMM AC1,U.91 MOVEI AC1,61 ; 4360 MOVEM AC1,U.94 MOVE AC1,CHKTYPE ; 4361 MOVEM AC1,U.93 MOVE AC1,SET%REPT%CHR ; 4367 MOVEM AC1,U.85 SETZM SMSG%TOTAL%CHARS ; 4371 SETZM RMSG%TOTAL%CHARS ; 4372 SETZM SMSG%DATA%CHARS ; 4373 SETZM RMSG%DATA%CHARS ; 4374 SETZM RMSG%NAKS ; 4375 SETZM SMSG%NAKS ; 4376 PUSHJ SP,SY%TIME ; 4377 MOVEM AC1,XFR%TIME POPJ SP, ; 4291 ; Routine Size: 32 words ; 4379 %SBTTL 'Statistics -- Finish message transfer' ; 4380 ROUTINE END%STATS : NOVALUE = ; 4381 ; 4382 !++ ; 4383 ! FUNCTIONAL DESCRIPTION: ; 4384 ! ; 4385 ! This routine will end the collection of the statistices. It will ; 4386 ! update the various overall statistic parameters. ; 4387 ! ; 4388 ! CALLING SEQUENCE: ; 4389 ! ; 4390 ! END%STATS (); ; 4391 ! ; 4392 ! INPUT PARAMETERS: ; 4393 ! ; 4394 ! None. ; 4395 ! ; 4396 ! IMPLICIT INPUTS: ; 4397 ! ; 4398 ! None. ; 4399 ! ; 4400 ! OUTPUT PARAMETERS: ; 4401 ! ; 4402 ! None. ; 4403 ! ; 4404 ! IMPLICIT OUTPUTS: ; 4405 ! ; 4406 ! None. ; 4407 ! ; 4408 ! COMPLETION CODES: ; 4409 ! ; 4410 ! None. ; 4411 ! ; 4412 ! SIDE EFFECTS: ; 4413 ! ; 4414 ! None. ; 4415 ! ; 4416 !-- ; 4417 ; 4418 BEGIN ; 4419 SND%TOTAL%CHARS = .SND%TOTAL%CHARS + .SMSG%TOTAL%CHARS; ; 4420 SND%DATA%CHARS = .SND%DATA%CHARS + .SMSG%DATA%CHARS; ; 4421 RCV%TOTAL%CHARS = .RCV%TOTAL%CHARS + .RMSG%TOTAL%CHARS; ; 4422 RCV%DATA%CHARS = .RCV%DATA%CHARS + .RMSG%DATA%CHARS; ; 4423 SND%NAKS = .SND%NAKS + .SMSG%NAKS; ; 4424 RCV%NAKS = .RCV%NAKS + .RMSG%NAKS; ; 4425 XFR%TIME = SY%TIME () - .XFR%TIME; ; 4426 TOTAL%TIME = .TOTAL%TIME + .XFR%TIME; ; 4427 END; ! End of END%STATS ; END%STATS U.15: MOVE AC1,SMSG%TOTAL%CHARS ; 4419 ADDM AC1,SND%TOTAL%CHARS MOVE AC1,SMSG%DATA%CHARS ; 4420 ADDM AC1,SND%DATA%CHARS MOVE AC1,RMSG%TOTAL%CHARS ; 4421 ADDM AC1,RCV%TOTAL%CHARS MOVE AC1,RMSG%DATA%CHARS ; 4422 ADDM AC1,RCV%DATA%CHARS MOVE AC1,SMSG%NAKS ; 4423 ADDM AC1,SND%NAKS MOVE AC1,RMSG%NAKS ; 4424 ADDM AC1,RCV%NAKS PUSHJ SP,SY%TIME ; 4425 SUBB AC1,XFR%TIME ADDM AC1,TOTAL%TIME ; 4426 POPJ SP, ; 4380 ; Routine Size: 16 words ; 4428 %SBTTL 'Debugging -- DBG%SEND' ; 4429 ROUTINE DBG%SEND (ADDRESS, LENGTH) : NOVALUE = ; 4430 ; 4431 !++ ; 4432 ! FUNCTIONAL DESCRIPTION: ; 4433 ! ; 4434 ! This routine will output the message that is going to be sent ; 4435 ! as part of the debugging information that is turned on in the ; 4436 ! SET DEBUG command. ; 4437 ! ; 4438 ! CALLING SEQUENCE: ; 4439 ! ; 4440 ! DBG%SEND(MSG%ADDRESS, MSG%LENGTH); ; 4441 ! ; 4442 ! INPUT PARAMETERS: ; 4443 ! ; 4444 ! MSG%ADDRESS - Address of the message that is going to be sent ; 4445 ! to the remote KERMIT. The bytes are CHR%SIZE. ; 4446 ! MSG%LENGTH - Length of the message. ; 4447 ! ; 4448 ! IMPLICIT INPUTS: ; 4449 ! ; 4450 ! None. ; 4451 ! ; 4452 ! OUTPUT PARAMETERS: ; 4453 ! ; 4454 ! None. ; 4455 ! ; 4456 ! IMPLICIT OUTPUTS: ; 4457 ! ; 4458 ! None. ; 4459 ! ; 4460 ! COMPLETION CODES: ; 4461 ! ; 4462 ! None. ; 4463 ! ; 4464 ! SIDE EFFECTS: ; 4465 ! ; 4466 ! None. ; 4467 ! ; 4468 !-- ; 4469 ; 4470 BEGIN ; 4471 ; 4472 BIND ; 4473 SEND%TEXT = UPLIT (%ASCIZ'Sending...'); ; 4474 ; 4475 IF .DEBUG%FLAG ; 4476 THEN ; 4477 BEGIN ; 4478 ; 4479 LOCAL ; 4480 OLD%RTN; ; 4481 ; 4482 OLD%RTN = TT%SET%OUTPUT (DBG%DUMP); ; 4483 TT%TEXT (SEND%TEXT); ; 4484 DBG%MESSAGE (.ADDRESS, .LENGTH); ; 4485 TT%SET%OUTPUT (.OLD%RTN); ; 4486 END; ; 4487 ; 4488 END; ! End of DBG%SEND P.AAL: BYTE (7)"S","e","n","d","i" BYTE (7)"n","g",".",".","." BYTE (7)000,000,000,000,000 ; SEND%TEXT U.128= P.AAL ; DBG%SEND U.29: PUSH SP,AC16 ; 4429 MOVEI AC1,1 ; 4475 TDNN AC1,DEBUG%FLAG JRST L.251 PUSH SP,C.67 ; 4482 PUSHJ SP,TT%SET%OUTPUT MOVE AC16,AC1 PUSH SP,C.84 ; 4483 PUSHJ SP,TT%TEXT PUSH SP,-5(SP) ; 4484 PUSH SP,-5(SP) PUSHJ SP,U.28 MOVEM AC16,0(SP) ; 4485 PUSHJ SP,TT%SET%OUTPUT ADJSP SP,-4 ; 4477 L.251: POP SP,AC16 ; 4429 POPJ SP, C.84: XWD 0,U.128 ; Routine Size: 18 words ; 4489 %SBTTL 'Debugging -- DBG%RECEIVE' ; 4490 ROUTINE DBG%RECEIVE (ADDRESS) : NOVALUE = ; 4491 ; 4492 !++ ; 4493 ! FUNCTIONAL DESCRIPTION: ; 4494 ! ; 4495 ! This routine will output the message that was received from ; 4496 ! the remote KERMIT. This routine is called only if the DEBUG%FLAG ; 4497 ! is true. ; 4498 ! ; 4499 ! CALLING SEQUENCE: ; 4500 ! ; 4501 ! DBG%RECEIVE(MSG%ADDRESS); ; 4502 ! ; 4503 ! INPUT PARAMETERS: ; 4504 ! ; 4505 ! MSG%ADDRESS - Address of the message received by the remote KERMIT. ; 4506 ! ; 4507 ! IMPLICIT INPUTS: ; 4508 ! ; 4509 ! None. ; 4510 ! ; 4511 ! OUTPUT PARAMETERS: ; 4512 ! ; 4513 ! None. ; 4514 ! ; 4515 ! IMPLICIT OUTPUTS: ; 4516 ! ; 4517 ! None. ; 4518 ! ; 4519 ! COMPLETION CODES: ; 4520 ! ; 4521 ! None. ; 4522 ! ; 4523 ! SIDE EFFECTS: ; 4524 ! ; 4525 ! None. ; 4526 ! ; 4527 !-- ; 4528 ; 4529 BEGIN ; 4530 ; 4531 BIND ; 4532 RECEIVE%TEXT = UPLIT (%ASCIZ'Received...'); ; 4533 ; 4534 IF .DEBUG%FLAG ; 4535 THEN ; 4536 BEGIN ; 4537 ; 4538 LOCAL ; 4539 OLD%RTN; ; 4540 ; 4541 OLD%RTN = TT%SET%OUTPUT (DBG%DUMP); ; 4542 TT%TEXT (RECEIVE%TEXT); ; 4543 DBG%MESSAGE (.ADDRESS, .REC%LENGTH); ; 4544 TT%SET%OUTPUT (.OLD%RTN); ; 4545 END; ; 4546 ; 4547 END; ! End of DBG%RECEIVE P.AAM: BYTE (7)"R","e","c","e","i" BYTE (7)"v","e","d",".","." BYTE (7)".",000,000,000,000 ; RECEIVE%TEXT U.129= P.AAM ; DBG%RECEIVE U.30: PUSH SP,AC16 ; 4490 MOVEI AC1,1 ; 4534 TDNN AC1,DEBUG%FLAG JRST L.252 PUSH SP,C.67 ; 4541 PUSHJ SP,TT%SET%OUTPUT MOVE AC16,AC1 PUSH SP,C.85 ; 4542 PUSHJ SP,TT%TEXT PUSH SP,-4(SP) ; 4543 PUSH SP,U.104 PUSHJ SP,U.28 MOVEM AC16,0(SP) ; 4544 PUSHJ SP,TT%SET%OUTPUT ADJSP SP,-4 ; 4536 L.252: POP SP,AC16 ; 4490 POPJ SP, C.85: XWD 0,U.129 ; Routine Size: 18 words ; 4548 %SBTTL 'Debugging -- DBG%MESSAGE' ; 4549 ; 4550 GLOBAL ROUTINE DBG%MESSAGE (MSG%ADDRESS, MSG%LENGTH) : NOVALUE = ; 4551 ; 4552 !++ ; 4553 ! FUNCTIONAL DESCRIPTION: ; 4554 ! ; 4555 ! This routine will display a message that is either being sent ; 4556 ! or received on the user's terminal. ; 4557 ! ; 4558 ! CALLING SEQUENCE: ; 4559 ! ; 4560 ! DBG%MESSAGE(MSG%ADDRESS, MSG%LENGTH); ; 4561 ! ; 4562 ! INPUT PARAMETERS: ; 4563 ! ; 4564 ! MSG%ADDRESS - Address of the message to be output ; 4565 ! MSG%LENGTH - Length of the message to be output. ; 4566 ! ; 4567 ! IMPLICIT INPUTS: ; 4568 ! ; 4569 ! None. ; 4570 ! ; 4571 ! OUTPUT PARAMETERS: ; 4572 ! ; 4573 ! None. ; 4574 ! ; 4575 ! IMPLICIT OUTPUTS: ; 4576 ! ; 4577 ! None. ; 4578 ! ; 4579 ! COMPLETION CODES: ; 4580 ! ; 4581 ! None. ; 4582 ! ; 4583 ! SIDE EFFECTS: ; 4584 ! ; 4585 ! None. ; 4586 ! ; 4587 !-- ; 4588 ; 4589 BEGIN ; 4590 ; 4591 MAP ; 4592 MSG%ADDRESS : REF VECTOR [CH$ALLOCATION (MAX%MSG, CHR%SIZE)]; ! Point to the vector ; 4593 ; 4594 LOCAL ; 4595 OLD%RTN, ! Old type out routine ; 4596 CHKSUM, ! Numeric value of block check ; 4597 TEMP%POINTER, ! Temporary character pointer ; 4598 MSG%LEN; ; 4599 ; 4600 ! ; 4601 ! Message type text ; 4602 ! ; 4603 ; 4604 BIND ; 4605 DATA%TEXT = UPLIT (%ASCIZ' (Data)'), ; 4606 ACK%TEXT = UPLIT (%ASCIZ' (ACK)'), ; 4607 NAK%TEXT = UPLIT (%ASCIZ' (NAK)'), ; 4608 SND%INIT%TEXT = UPLIT (%ASCIZ' (Send init)'), ; 4609 BREAK%TEXT = UPLIT (%ASCIZ' (Break)'), ; 4610 FILE%TEXT = UPLIT (%ASCIZ' (File)'), ; 4611 EOF%TEXT = UPLIT (%ASCIZ' (EOF)'), ; 4612 ERROR%TEXT = UPLIT (%ASCIZ' (Error)'), ; 4613 RCV%INIT%TEXT = UPLIT (%ASCIZ' (Receive initiate)'), ; 4614 COMMAND%TEXT = UPLIT (%ASCIZ' (Command)'), ; 4615 KERMIT%TEXT = UPLIT (%ASCIZ' (Generic KERMIT command)'); ; 4616 ; 4617 ! ; 4618 ! Header information ; 4619 ! ; 4620 ; 4621 BIND ; 4622 MN%TEXT = UPLIT (%ASCIZ'Message number: '), ; 4623 LENGTH%TEXT = UPLIT (%ASCIZ' Length: '), ; 4624 DEC%TEXT = UPLIT (%ASCIZ' (dec)'), ; 4625 MSG%TYP%TEXT = UPLIT (%ASCIZ'Message type: '), ; 4626 CHKSUM%TEXT = UPLIT (%ASCIZ'Checksum: '), ; 4627 CHKSUM%NUM%TEXT = UPLIT (%ASCIZ' = '), ; 4628 OPT%DATA%TEXT = UPLIT (%ASCIZ'Optional data: '), ; 4629 PRE%CHAR%TEXT = UPLIT (%ASCIZ' "'); ; 4630 ; 4631 ! ; 4632 ! Ensure that the type out will go to the debugging location ; 4633 ! ; 4634 OLD%RTN = TT%SET%OUTPUT (DBG%DUMP); ; 4635 ! ; 4636 ! Preliminary calculations ; 4637 ! ; 4638 MSG%LEN = UNCHAR (CH$RCHAR (CH$PTR (.MSG%ADDRESS, PKT%COUNT, CHR%SIZE))); ; 4639 ! ; 4640 ! First output some header information for the packet. ; 4641 ! ; 4642 TT%CRLF (); ; 4643 TT%TEXT (MN%TEXT); ; 4644 TT%NUMBER (UNCHAR (CH$RCHAR (CH$PTR (.MSG%ADDRESS, PKT%SEQ, CHR%SIZE)))); ; 4645 TT%TEXT (DEC%TEXT); ; 4646 TT%TEXT (LENGTH%TEXT); ; 4647 TT%NUMBER (.MSG%LEN); ; 4648 TT%TEXT (DEC%TEXT); ; 4649 TT%CRLF (); ; 4650 ! ; 4651 ! Now output the message type and dependent information ; 4652 ! ; 4653 TT%TEXT (MSG%TYP%TEXT); ; 4654 TT%CHAR (CH$RCHAR (CH$PTR (.MSG%ADDRESS, PKT%TYPE, CHR%SIZE))); ; 4655 ; 4656 SELECTONE CH$RCHAR (CH$PTR (.MSG%ADDRESS, PKT%TYPE, CHR%SIZE)) OF ; 4657 SET ; 4658 ; 4659 [MSG%DATA] : ; 4660 TT%TEXT (DATA%TEXT); ; 4661 ; 4662 [MSG%ACK] : ; 4663 TT%TEXT (ACK%TEXT); ; 4664 ; 4665 [MSG%NAK] : ; 4666 TT%TEXT (NAK%TEXT); ; 4667 ; 4668 [MSG%SND%INIT] : ; 4669 TT%TEXT (SND%INIT%TEXT); ; 4670 ; 4671 [MSG%BREAK] : ; 4672 TT%TEXT (BREAK%TEXT); ; 4673 ; 4674 [MSG%FILE] : ; 4675 TT%TEXT (FILE%TEXT); ; 4676 ; 4677 [MSG%EOF] : ; 4678 TT%TEXT (EOF%TEXT); ; 4679 ; 4680 [MSG%ERROR] : ; 4681 TT%TEXT (ERROR%TEXT); ; 4682 TES; ; 4683 ; 4684 TT%CRLF (); ; 4685 ! ; 4686 ! Now output any of the optional data. ; 4687 ! ; 4688 ; 4689 IF .MSG%LEN - PKT%OVR%HEAD - (.BLK%CHK%TYPE - CHK%1CHAR) NEQ 0 ; 4690 THEN ; 4691 BEGIN ; 4692 TT%TEXT (OPT%DATA%TEXT); ; 4693 TT%CRLF (); ; 4694 TEMP%POINTER = CH$PTR (.MSG%ADDRESS, PKT%MSG, CHR%SIZE); ; 4695 ; 4696 INCR I FROM 1 TO .MSG%LEN - PKT%OVR%HEAD - (.BLK%CHK%TYPE - CHK%1CHAR) DO ; 4697 BEGIN ; 4698 ; 4699 IF (.I MOD 10) EQL 1 ; 4700 THEN ; 4701 BEGIN ; 4702 TT%CRLF (); ; 4703 TT%CHAR (CHR%TAB); ; 4704 END; ; 4705 ; 4706 TT%TEXT (PRE%CHAR%TEXT); ; 4707 TT%CHAR (CH$RCHAR%A (TEMP%POINTER)); ; 4708 TT%CHAR (%C'"'); ; 4709 END; ; 4710 ; 4711 IF ((.MSG%LEN - PKT%OVR%HEAD - (.BLK%CHK%TYPE - CHK%1CHAR)) MOD 10) EQL 1 THEN TT%CRLF (); ; 4712 ; 4713 TT%CRLF (); ; 4714 END; ; 4715 ; 4716 ! ; 4717 ! Now output the checksum for the message that we received ; 4718 ! ; 4719 ! This could be either 1 two or three characters. ; 4720 TT%TEXT (CHKSUM%TEXT); ; 4721 TEMP%POINTER = CH$PTR (.MSG%ADDRESS, ; 4722 PKT%MSG + .MSG%LEN + PKT%CHKSUM - PKT%OVR%HEAD - (.BLK%CHK%TYPE - CHK%1CHAR), CHR%SIZE); ; 4723 ; 4724 CASE .BLK%CHK%TYPE FROM CHK%1CHAR TO CHK%CRC OF ; 4725 SET ; 4726 ; 4727 [CHK%1CHAR] : ; 4728 BEGIN ; 4729 TT%TEXT (PRE%CHAR%TEXT); ; 4730 TT%CHAR (CH$RCHAR (.TEMP%POINTER)); ; 4731 TT%CHAR (%C'"'); ; 4732 CHKSUM = UNCHAR (CH$RCHAR (.TEMP%POINTER)); ; 4733 END; ; 4734 ; 4735 [CHK%2CHAR] : ; 4736 BEGIN ; 4737 CHKSUM = 0; ; 4738 TT%TEXT (PRE%CHAR%TEXT); ; 4739 TT%CHAR (CH$RCHAR (.TEMP%POINTER)); ; 4740 TT%CHAR (%C'"'); ; 4741 CHKSUM<6, 6> = UNCHAR (CH$RCHAR%A (TEMP%POINTER)); ; 4742 TT%TEXT (PRE%CHAR%TEXT); ; 4743 TT%CHAR (CH$RCHAR (.TEMP%POINTER)); ; 4744 TT%CHAR (%C'"'); ; 4745 CHKSUM<0, 6> = UNCHAR (CH$RCHAR (.TEMP%POINTER)); ; 4746 END; ; 4747 ; 4748 [CHK%CRC] : ; 4749 BEGIN ; 4750 CHKSUM = 0; ; 4751 TT%TEXT (PRE%CHAR%TEXT); ; 4752 TT%CHAR (CH$RCHAR (.TEMP%POINTER)); ; 4753 TT%CHAR (%C'"'); ; 4754 CHKSUM<12, 4> = UNCHAR (CH$RCHAR%A (TEMP%POINTER)); ; 4755 TT%TEXT (PRE%CHAR%TEXT); ; 4756 TT%CHAR (CH$RCHAR (.TEMP%POINTER)); ; 4757 TT%CHAR (%C'"'); ; 4758 CHKSUM<6, 6> = UNCHAR (CH$RCHAR%A (TEMP%POINTER)); ; 4759 TT%TEXT (PRE%CHAR%TEXT); ; 4760 TT%CHAR (CH$RCHAR (.TEMP%POINTER)); ; 4761 TT%CHAR (%C'"'); ; 4762 CHKSUM<0, 6> = UNCHAR (CH$RCHAR (.TEMP%POINTER)); ; 4763 END; ; 4764 TES; ; 4765 ; 4766 TT%TEXT (CHKSUM%NUM%TEXT); ; 4767 TT%NUMBER (.CHKSUM); ; 4768 TT%TEXT (DEC%TEXT); ; 4769 TT%CRLF (); ; 4770 TT%SET%OUTPUT (.OLD%RTN); ! Reset output destination ; 4771 END; ! End of DBG%MESSAGE P.AAN: BYTE (7)" ","(","D","a","t" BYTE (7)"a",")",000,000,000 P.AAO: BYTE (7)" ","(","A","C","K" BYTE (7)")",000,000,000,000 P.AAP: BYTE (7)" ","(","N","A","K" BYTE (7)")",000,000,000,000 P.AAQ: BYTE (7)" ","(","S","e","n" BYTE (7)"d"," ","i","n","i" BYTE (7)"t",")",000,000,000 P.AAR: BYTE (7)" ","(","B","r","e" BYTE (7)"a","k",")",000,000 P.AAS: BYTE (7)" ","(","F","i","l" BYTE (7)"e",")",000,000,000 P.AAT: BYTE (7)" ","(","E","O","F" BYTE (7)")",000,000,000,000 P.AAU: BYTE (7)" ","(","E","r","r" BYTE (7)"o","r",")",000,000 P.AAV: BYTE (7)" ","(","R","e","c" BYTE (7)"e","i","v","e"," " BYTE (7)"i","n","i","t","i" BYTE (7)"a","t","e",")",000 P.AAW: BYTE (7)" ","(","C","o","m" BYTE (7)"m","a","n","d",")" BYTE (7)000,000,000,000,000 P.AAX: BYTE (7)" ","(","G","e","n" BYTE (7)"e","r","i","c"," " BYTE (7)"K","E","R","M","I" BYTE (7)"T"," ","c","o","m" BYTE (7)"m","a","n","d",")" BYTE (7)000,000,000,000,000 P.AAY: BYTE (7)"M","e","s","s","a" BYTE (7)"g","e"," ","n","u" BYTE (7)"m","b","e","r",":" BYTE (7)" ",000,000,000,000 P.AAZ: BYTE (7)011,"L","e","n","g" BYTE (7)"t","h",":"," ",000 P.ABA: BYTE (7)" ","(","d","e","c" BYTE (7)")",000,000,000,000 P.ABB: BYTE (7)"M","e","s","s","a" BYTE (7)"g","e"," ","t","y" BYTE (7)"p","e",":"," ",000 P.ABC: BYTE (7)"C","h","e","c","k" BYTE (7)"s","u","m",":"," " BYTE (7)000,000,000,000,000 P.ABD: BYTE (7)" ","="," ",000,000 P.ABE: BYTE (7)"O","p","t","i","o" BYTE (7)"n","a","l"," ","d" BYTE (7)"a","t","a",":"," " BYTE (7)000,000,000,000,000 P.ABF: BYTE (7)" ",042,000,000,000 ; DATA%TEXT U.131= P.AAN ; ACK%TEXT U.132= P.AAO ; NAK%TEXT U.133= P.AAP ; SND%INIT%TEXT U.134= P.AAQ ; BREAK%TEXT U.135= P.AAR ; FILE%TEXT U.136= P.AAS ; EOF%TEXT U.137= P.AAT ; ERROR%TEXT U.138= P.AAU ; RCV%INIT%TEXT U.139= P.AAV ; COMMAND%TEXT U.140= P.AAW ; KERMIT%TEXT U.141= P.AAX ; MN%TEXT U.142= P.AAY ; LENGTH%TEXT U.143= P.AAZ ; DEC%TEXT U.144= P.ABA ; MSG%TYP%TEXT U.145= P.ABB ; CHKSUM%TEXT U.146= P.ABC ; CHKSUM%NUM%TEXT U.147= P.ABD ; OPT%DATA%TEXT U.148= P.ABE ; PRE%CHAR%TEXT U.149= P.ABF U.28: DBG%MESSAGE:: PUSH SP,AC0 ; 4550 PUSH SP,AC10 PUSH SP,AC11 PUSH SP,AC12 PUSH SP,AC13 PUSH SP,AC14 PUSH SP,AC16 PUSH SP,C.67 ; 4634 PUSHJ SP,TT%SET%OUTPUT MOVE AC0,AC1 MOVE AC13,-12(SP) ; 4638 MOVEI AC1,0(AC13) HRLI AC1,341000 ILDB AC2,AC1 MOVE AC11,AC2 SUBI AC11,40 PUSHJ SP,TT%CRLF ; 4642 PUSH SP,C.89 ; 4643 PUSHJ SP,TT%TEXT MOVEI AC1,0(AC13) ; 4644 HRLI AC1,241000 ILDB AC1,AC1 SUBI AC1,40 PUSH SP,AC1 PUSHJ SP,TT%NUMBER PUSH SP,C.90 ; 4645 PUSHJ SP,TT%TEXT PUSH SP,C.91 ; 4646 PUSHJ SP,TT%TEXT MOVEM AC11,0(SP) ; 4647 PUSHJ SP,TT%NUMBER PUSH SP,C.90 ; 4648 PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 4649 PUSH SP,C.92 ; 4653 PUSHJ SP,TT%TEXT MOVEI AC1,0(AC13) ; 4654 HRLI AC1,141000 ILDB AC1,AC1 PUSH SP,AC1 PUSHJ SP,TT%CHAR MOVEI AC1,0(AC13) ; 4656 HRLI AC1,141000 ILDB AC16,AC1 CAIE AC16,104 JRST L.253 PUSH SP,C.93 ; 4660 JRST L.260 L.253: CAIE AC16,131 ; 4656 JRST L.254 PUSH SP,C.94 ; 4663 JRST L.260 L.254: CAIE AC16,116 ; 4656 JRST L.255 PUSH SP,C.95 ; 4666 JRST L.260 L.255: CAIE AC16,123 ; 4656 JRST L.256 PUSH SP,C.96 ; 4669 JRST L.260 L.256: CAIE AC16,102 ; 4656 JRST L.257 PUSH SP,C.97 ; 4672 JRST L.260 L.257: CAIE AC16,106 ; 4656 JRST L.258 PUSH SP,C.98 ; 4675 JRST L.260 L.258: CAIE AC16,132 ; 4656 JRST L.259 PUSH SP,C.99 ; 4678 JRST L.260 L.259: CAIE AC16,105 ; 4656 JRST L.261 PUSH SP,C.100 ; 4681 L.260: PUSHJ SP,TT%TEXT ADJSP SP,-1 L.261: PUSHJ SP,TT%CRLF ; 4684 MOVE AC12,AC11 ; 4689 SUBI AC12,3 MOVE AC1,U.94 SUBI AC1,61 CAMN AC12,AC1 JRST L.265 PUSH SP,C.101 ; 4692 PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 4693 MOVEI AC16,0(AC13) ; 4694 HRLI AC16,41000 MOVE AC2,AC12 ; 4696 SUB AC2,U.94 MOVE AC10,AC2 ADDI AC10,61 SETZ AC14, JRST L.264 L.262: MOVE AC1,AC14 ; 4699 IDIVI AC1,12 CAIE AC2,1 JRST L.263 PUSHJ SP,TT%CRLF ; 4702 PUSH SP,C.4 ; 4703 PUSHJ SP,TT%CHAR ADJSP SP,-1 ; 4701 L.263: PUSH SP,C.102 ; 4706 PUSHJ SP,TT%TEXT ILDB AC1,AC16 ; 4707 PUSH SP,AC1 PUSHJ SP,TT%CHAR PUSH SP,C.103 ; 4708 PUSHJ SP,TT%CHAR ADJSP SP,-3 ; 4697 L.264: ADDI AC14,1 ; 4696 CAMG AC14,AC10 JRST L.262 MOVE AC2,AC12 ; 4711 SUB AC2,U.94 ADDI AC2,61 MOVE AC1,AC2 IDIVI AC1,12 CAIN AC2,1 PUSHJ SP,TT%CRLF PUSHJ SP,TT%CRLF ; 4713 ADJSP SP,-1 ; 4691 L.265: PUSH SP,C.104 ; 4720 PUSHJ SP,TT%TEXT MOVE AC1,U.94 ; 4722 MOVE AC2,AC11 SUB AC2,AC1 ADDI AC2,62 MOVEI AC3,0(AC13) ; 4721 HRLI AC3,-337000 ADJBP AC2,AC3 MOVE AC16,AC2 SUBI AC1,61 ; 4724 JRST L.266(AC1) L.266: JRST L.267 JRST L.268 JRST L.269 L.267: PUSH SP,C.102 ; 4729 PUSHJ SP,TT%TEXT MOVE AC2,AC16 ; 4730 ILDB AC1,AC2 PUSH SP,AC1 PUSHJ SP,TT%CHAR PUSH SP,C.103 ; 4731 PUSHJ SP,TT%CHAR MOVE AC2,AC16 ; 4732 ILDB AC14,AC2 SUBI AC14,40 JRST L.270 ; 4724 L.268: SETZ AC14, ; 4737 PUSH SP,C.102 ; 4738 PUSHJ SP,TT%TEXT MOVE AC2,AC16 ; 4739 ILDB AC1,AC2 PUSH SP,AC1 PUSHJ SP,TT%CHAR PUSH SP,C.103 ; 4740 PUSHJ SP,TT%CHAR ILDB AC1,AC16 ; 4741 SUBI AC1,40 DPB AC1,C.86 PUSH SP,C.102 ; 4742 PUSHJ SP,TT%TEXT MOVE AC2,AC16 ; 4743 ILDB AC1,AC2 PUSH SP,AC1 PUSHJ SP,TT%CHAR PUSH SP,C.103 ; 4744 PUSHJ SP,TT%CHAR MOVE AC2,AC16 ; 4745 ILDB AC1,AC2 SUBI AC1,40 DPB AC1,C.87 ADJSP SP,-3 ; 4736 JRST L.270 ; 4724 L.269: SETZ AC14, ; 4750 PUSH SP,C.102 ; 4751 PUSHJ SP,TT%TEXT MOVE AC2,AC16 ; 4752 ILDB AC1,AC2 PUSH SP,AC1 PUSHJ SP,TT%CHAR PUSH SP,C.103 ; 4753 PUSHJ SP,TT%CHAR ILDB AC1,AC16 ; 4754 SUBI AC1,40 DPB AC1,C.88 PUSH SP,C.102 ; 4755 PUSHJ SP,TT%TEXT MOVE AC2,AC16 ; 4756 ILDB AC1,AC2 PUSH SP,AC1 PUSHJ SP,TT%CHAR PUSH SP,C.103 ; 4757 PUSHJ SP,TT%CHAR ILDB AC1,AC16 ; 4758 SUBI AC1,40 DPB AC1,C.86 PUSH SP,C.102 ; 4759 PUSHJ SP,TT%TEXT MOVE AC2,AC16 ; 4760 ILDB AC1,AC2 PUSH SP,AC1 PUSHJ SP,TT%CHAR PUSH SP,C.103 ; 4761 PUSHJ SP,TT%CHAR ILDB AC1,AC16 ; 4762 SUBI AC1,40 DPB AC1,C.87 ADJSP SP,-6 ; 4749 L.270: PUSH SP,C.105 ; 4766 PUSHJ SP,TT%TEXT MOVEM AC14,0(SP) ; 4767 PUSHJ SP,TT%NUMBER PUSH SP,C.90 ; 4768 PUSHJ SP,TT%TEXT PUSHJ SP,TT%CRLF ; 4769 MOVEM AC0,0(SP) ; 4770 PUSHJ SP,TT%SET%OUTPUT ADJSP SP,-16 ; 4589 POP SP,AC16 ; 4550 POP SP,AC14 POP SP,AC13 POP SP,AC12 POP SP,AC11 POP SP,AC10 POP SP,AC0 POPJ SP, C.86: POINT 6,AC14,29 C.87: POINT 6,AC14,35 C.88: POINT 4,AC14,23 C.89: XWD 0,U.142 C.90: XWD 0,U.144 C.91: XWD 0,U.143 C.92: XWD 0,U.145 C.93: XWD 0,U.131 C.94: XWD 0,U.132 C.95: XWD 0,U.133 C.96: XWD 0,U.134 C.97: XWD 0,U.135 C.98: XWD 0,U.136 C.99: XWD 0,U.137 C.100: XWD 0,U.138 C.101: XWD 0,U.148 C.102: XWD 0,U.149 C.103: EXP 42 C.104: XWD 0,U.146 C.105: XWD 0,U.147 ; Routine Size: 249 words ; 4772 ; 4773 %SBTTL 'End of KERMSG' ; 4774 END ; 4775 ; 4776 ELUDOM END ; Low segment length: 186 words ; High segment length: 2410 words ; Compilation Complete END