home *** CD-ROM | disk | FTP | other *** search
/ kermit.columbia.edu / kermit.columbia.edu.tar / kermit.columbia.edu / archives / decpro300.zip / promsg.mac < prev    next >
Text File  |  1988-08-16  |  293KB  |  10,939 lines

  1.     .NLIST
  2.     .ENABL    LC
  3.     .NLIST    BIN,LOC
  4.     .LIST
  5. ;      0001    %TITLE 'KERMSG - Kermit message processing'
  6. ;      0002    MODULE KERMSG (IDENT = '2.0.035'
  7. ;      0003            ) =
  8. ;      0004    BEGIN
  9. ;      0005    
  10. ;      0006    SWITCHES LANGUAGE (COMMON);
  11. ;      0007    
  12. ;      0008    !<BLF/WIDTH:100>
  13. ;      0009    
  14. ;      0010    !++
  15. ;      0011    ! FACILITY:
  16. ;      0012    !   Kermit-10, VMS Kermit, Pro/Kermit
  17. ;      0013    !
  18. ;      0014    ! ABSTRACT:
  19. ;      0015    !    KERMSG is the message processing routines for Kermit-10, VMS Kermit,
  20. ;      0016    !    and PRO/Kermit.
  21. ;      0017    !    This module is written in common BLISS, so that it can be
  22. ;      0018    !    transported for the DECsystem-10 and VAX/VMS systems.
  23. ;      0019    !
  24. ;      0020    ! ENVIRONMENT:
  25. ;      0021    !   User mode
  26. ;      0022    !
  27. ;      0023    ! AUTHOR: Robert C. McQueen, CREATION DATE: 24-January-1983
  28. ;      0024    !
  29. ;      0025    ! MODIFIED BY:
  30. ;      0026    !
  31. ;      0027    !--
  32. ;      0028    
  33. ;      0029    %SBTTL    'Table of Contents'
  34. ;      0030    
  35. ;      0031    !+
  36. ;      0032    !.pag.lit
  37. ;      0033    
  38. ;      0034    !        Table of Contents for KERMSG
  39. ;      0035    !
  40. ;      0036    !
  41. ;      0037    !               Section                  Page
  42. ;      0038    !   1. Revision History . . . . . . . . . . . . . . . . . . .    3
  43. ;      0039    !   2. Interface requirements . . . . . . . . . . . . . . . .    4
  44. ;      0040    !   3. Declarations
  45. ;      0041    !        3.1.   Forward definitions . . . . . . . . . . . . .    5
  46. ;      0042    !   4. Require files. . . . . . . . . . . . . . . . . . . . .   28
  47. ;      0043    !   5. Macro definitions. . . . . . . . . . . . . . . . . . .   29
  48. ;      0044    !   6. KERMIT Protocol Definitions. . . . . . . . . . . . . .   30
  49. ;      0045    !        6.1.   Packet offsets. . . . . . . . . . . . . . . .   31
  50. ;      0046    !        6.2.   Message dependent field . . . . . . . . . . .   32
  51. ;      0047    !        6.3.   SEND initiate packet. . . . . . . . . . . . .   33
  52. ;      0048    !   7. KERMIT Protocol States . . . . . . . . . . . . . . . .   34
  53. ;      0049    !   8. Internal constants . . . . . . . . . . . . . . . . . .   35
  54. ;      0050    !   9. Storage - External . . . . . . . . . . . . . . . . . .   36
  55. ;      0051    !  10. Storage - Local. . . . . . . . . . . . . . . . . . . .   37
  56. ;      0052    !  11. External references. . . . . . . . . . . . . . . . . .   38
  57. ;      0053    !  12. MSG_INIT . . . . . . . . . . . . . . . . . . . . . . .   39
  58. ;      0054    !  13. SND_ERROR. . . . . . . . . . . . . . . . . . . . . . .   40
  59. ;      0055    !  14. SERVER - Server mode . . . . . . . . . . . . . . . . .   41
  60. ;      0056    !  15. SEND_SWITCH. . . . . . . . . . . . . . . . . . . . . .   42
  61. ;      0057    !  16. REC_SWITCH . . . . . . . . . . . . . . . . . . . . . .   43
  62. ;      0058    !  17. Server
  63. ;      0059    !       17.1.   DO_GENERIC - Execute a generic command. . . .   44
  64. ;      0060    !  18. DO_TRANSACTION - Main loop for FSM . . . . . . . . . .   45
  65. ;      0061    !  19. REC_SERVER_IDLE - Idle server state. . . . . . . . . .   46
  66. ;      0062    !  20. SEND_SERVER_INIT . . . . . . . . . . . . . . . . . . .   47
  67. ;      0063    !  21. SEND_DATA. . . . . . . . . . . . . . . . . . . . . . .   48
  68. ;      0064    !  22. SEND_FILE. . . . . . . . . . . . . . . . . . . . . . .   49
  69. ;      0065    !  23. SEND_EOF . . . . . . . . . . . . . . . . . . . . . . .   50
  70. ;      0066    !  24. SEND_INIT. . . . . . . . . . . . . . . . . . . . . . .   51
  71. ;      0067    !  25. SEND_OPEN_FILE - Open file for sending . . . . . . . .   52
  72. ;      0068    !  26. SEND_GENCMD. . . . . . . . . . . . . . . . . . . . . .   53
  73. ;      0069    !  27. SEND_BREAK . . . . . . . . . . . . . . . . . . . . . .   54
  74. ;      0070    !  28. REC_INIT . . . . . . . . . . . . . . . . . . . . . . .   55
  75. ;      0071    !  29. REC_FILE . . . . . . . . . . . . . . . . . . . . . . .   56
  76. ;      0072    !  30. REC_DATA . . . . . . . . . . . . . . . . . . . . . . .   57
  77. ;      0073    !  31. SERVER - Generic commands. . . . . . . . . . . . . . .   58
  78. ;      0074    !  32. HOST_COMMAND - perform a host command. . . . . . . . .   59
  79. ;      0075    !  33. CALL_SY_RTN - handle operating system dependent functions  60
  80. ;      0076    !  34. Message processing
  81. ;      0077    !       34.1.   PRS_SEND_INIT - Parse send init params. . . .   61
  82. ;      0078    !  35. SET_SEND_INIT. . . . . . . . . . . . . . . . . . . . .   62
  83. ;      0079    !  36. SEND_PACKET. . . . . . . . . . . . . . . . . . . . . .   63
  84. ;      0080    !  37. REC_MESSAGE - Receive a message. . . . . . . . . . . .   64
  85. ;      0081    !  38. REC_PACKET . . . . . . . . . . . . . . . . . . . . . .   65
  86. ;      0082    !  39. CALC_BLOCK_CHECK . . . . . . . . . . . . . . . . . . .   66
  87. ;      0083    !  40. NORMALIZE_FILE - Put file name into normal form. . . .   67
  88. ;      0084    !  41. Buffer filling
  89. ;      0085    !       41.1.   Main routine. . . . . . . . . . . . . . . . .   68
  90. ;      0086    !  42. BFR_EMPTY. . . . . . . . . . . . . . . . . . . . . . .   69
  91. ;      0087    !  43. Buffer filling and emptying subroutines. . . . . . . .   70
  92. ;      0088    !  44. Add parity routine . . . . . . . . . . . . . . . . . .   71
  93. ;      0089    !  45. Parity routine . . . . . . . . . . . . . . . . . . . .   72
  94. ;      0090    !  46. Per transfer
  95. ;      0091    !       46.1.   Initialization. . . . . . . . . . . . . . . .   73
  96. ;      0092    !  47. Statistics
  97. ;      0093    !       47.1.   Finish message transfer . . . . . . . . . . .   74
  98. ;      0094    !  48. Status type out
  99. ;      0095    !       48.1.   STS_OUTPUT. . . . . . . . . . . . . . . . . .   75
  100. ;      0096    !  49. TYPE_CHAR - Type out a character . . . . . . . . . . .   76
  101. ;      0097    !  50. Debugging
  102. ;      0098    !       50.1.   DBG_SEND. . . . . . . . . . . . . . . . . . .   77
  103. ;      0099    !       50.2.   DBG_RECEIVE . . . . . . . . . . . . . . . . .   78
  104. ;      0100    !       50.3.   DBG_MESSAGE . . . . . . . . . . . . . . . . .   79
  105. ;      0101    !  51. End of KERMSG. . . . . . . . . . . . . . . . . . . . .   80
  106. ;      0102    
  107. ;      0103    !.end lit.pag
  108. ;      0104    !-
  109. ;      0105    %SBTTL 'Revision History'
  110. ;      0106    
  111. ;      0107    !++
  112. ;      0108    ! Start of version 1.
  113. ;      0109    !
  114. ;      0110    ! 1.0.000    By: Robert C. McQueen        On: 4-Jan-1983
  115. ;      0111    !        Create this program.
  116. ;      0112    !
  117. ;      0113    ! 1.0.001    By: Robert C. McQueen        On: 30-Apr-1983
  118. ;      0114    !        Change PAR_xxx to be PR_xxx, so that they can be used for
  119. ;      0115    !        KERMIT-10.
  120. ;      0116    !
  121. ;      0117    ! 1.0.002    By: Robert C. McQueen        On: 1-May-1983
  122. ;      0118    !        Add DO_GENERIC routine to cause a generic Kermit command to
  123. ;      0119    !        be executed on the remote Kermit.
  124. ;      0120    !
  125. ;      0121    ! 1.0.003    By: Robert C. McQueen        On: 3-May-1983
  126. ;      0122    !        Fix message number incrementing.
  127. ;      0123    !
  128. ;      0124    ! 1.0.004    By: Robert C. McQueen        On: 4-May-1983
  129. ;      0125    !        Allow RECEIVE file-specification to work correctly.
  130. ;      0126    !
  131. ;      0127    ! 1.0.005    By: Robert C. McQueen        On: 6-May-1983
  132. ;      0128    !        Add more stats support.
  133. ;      0129    !
  134. ;      0130    ! 1.0.006    By: Nick Bush            On: 13-June-1983
  135. ;      0131    !        Fix SEND_PACKET to copy correct characters when fixing
  136. ;      0132    !        parity bits.
  137. ;      0133    !
  138. ;      0134    ! 1.1.007    By: Nick Bush            On: 15-July-1983
  139. ;      0135    !        Correct SEND-INIT message handling to do the right things
  140. ;      0136    !        with the protocol version 3 items.
  141. ;      0137    !
  142. ;      0138    ! 1.1.010    By: Robert C. McQueen        On: 20-July-1983
  143. ;      0139    !        Make PARITY a global routine, so that it can be called by
  144. ;      0140    !        CONNECT processing.  Change the name from PARITY to GEN_PARITY
  145. ;      0141    !        add a new routine to generate the parity, since it is not
  146. ;      0142    !        part of the checksum.
  147. ;      0143    !
  148. ;      0144    ! 1.1.011    By: Robert C. McQueen        On: 28-July-1983
  149. ;      0145    !        KER_TIMEOUT errors in the SERVER loop would cause
  150. ;      0146    !        KER_UNISRV error messages to be returned to the remote.
  151. ;      0147    !        Check for receive failures and send NAKs instead.
  152. ;      0148    !
  153. ;      0149    ! 1.2.012    By: Robert C. McQueen        On: 23-August-1983
  154. ;      0150    !        Don't abort if we get a message that is just an end of line
  155. ;      0151    !        character.  It could be noise on the line.
  156. ;      0152    !
  157. ;      0153    ! 1.2.013    By: Nick Bush            On: 7-September-1983
  158. ;      0154    !        Fix several problems with the SEND_xxx parameters
  159. ;      0155    !
  160. ;      0156    ! 1.2.014    By: Robert C. McQueen        On: 15-September-1983
  161. ;      0157    !        Add routine calls to XFR_STATUS to tell the user on the
  162. ;      0158    !        number of packets have changed.
  163. ;      0159    !
  164. ;      0160    ! 1.2.015    By: Nick Bush            On: 5-October-1983
  165. ;      0161    !        Add 2 and 3 character checksum (block check) support.
  166. ;      0162    !        Add support for data within acknowledgement packets
  167. ;      0163    !        and withing end-of-file packets to allow for file
  168. ;      0164    !        transmission to be aborted.  Also add support for
  169. ;      0165    !        "I" packet to allow server parameters to be initialized.
  170. ;      0166    !
  171. ;      0167    ! 1.2.016    By: Nick Bush            On: 19-October-1983
  172. ;      0168    !        Add repeat character support.
  173. ;      0169    !
  174. ;      0170    ! 2.0.017    Release TOPS-10 Kermit-10 version 2.0
  175. ;      0171    !        Release VAX/VMS Kermit-32 version 2.0
  176. ;      0172    !
  177. ;      0173    ! 2.0.018    By: Robert C. McQueen        On: 16-November-1983
  178. ;      0174    !        Fix four checks on the message number that were not
  179. ;      0175    !        mod 64.
  180. ;      0176    !
  181. ;      0177    ! 2.0.019    By: Robert C. McQueen        On: 16-November-1983
  182. ;      0178    !        Remove the CLEAR routine.  It is not really needed.
  183. ;      0179    !
  184. ;      0180    ! 2.0.020    By: Nick Bush            On: 12-Dec-1983
  185. ;      0181    !        Fix SEND_DATA and BFR_FILL to handle empty files and
  186. ;      0182    !        files which happen to end just on a message boundary.
  187. ;      0183    !        This would sometimes produce extra nulls.
  188. ;      0184    !
  189. ;      0185    ! 2.0.021    By: Nick Bush            On: 15-Dec-1983
  190. ;      0186    !        Fix some problems with REC_MESSAGE which would cause
  191. ;      0187    !        aborts when a message timed out.
  192. ;      0188    !
  193. ;      0189    ! 2.0.022    By: Robert C. McQueen        19-Dec-1983
  194. ;      0190    !        Make STATUS a local for most routines and remove FILE_DUMP
  195. ;      0191    !        as it is nolonger needed.
  196. ;      0192    !
  197. ;      0193    ! 2.0.023    By: Nick Bush            On: 3-Jan-1984
  198. ;      0194    !        Change FIL_NORMAL_FORM to contain not just a flag, but
  199. ;      0195    !        a file name type instead.
  200. ;      0196    !
  201. ;      0197    ! 2.0.024    By: Nick Bush            On: 11-Jan-1984
  202. ;      0198    !        Fix REC_MESSAGE to send NAK for packet we expect, not
  203. ;      0199    !        previous packet.
  204. ;      0200    !
  205. ;      0201    ! 2.0.025    By: Nick Bush            On: 23-Jan-1984
  206. ;      0202    !        Re-enable server-init packet and complete code so that
  207. ;      0203    !        parameters set by it will remain set.
  208. ;      0204    !        Fix file name copying to use BFR_FILL or BFR_EMPTY
  209. ;      0205    !        so that all quoting/compression is done properly.
  210. ;      0206    !
  211. ;      0207    ! 2.0.026    By: Nick Bush            On: 15-Feb-1984
  212. ;      0208    !        Add code for generic command support (both directions).
  213. ;      0209    !        There is now only one state dispatch loop, entered
  214. ;      0210    !        in various states for different functions.
  215. ;      0211    !
  216. ;      0212    ! 2.0.027    By: Robert C. McQueen        On: 16-Feb-1984
  217. ;      0213    !        At some point SEND_TIMEOUT became global, but it was not moved
  218. ;      0214    !        to KERGLB.  This edit moves it to KERGLB.BLI.
  219. ;      0215    !
  220. ;      0216    ! 2.0.030    By: Nick Bush            On: 2-March-1984
  221. ;      0217    !        Fix BFR_FILL to handle case of last repeated character
  222. ;      0218    !        not fitting within a packet.  It was forgetting to
  223. ;      0219    !        send the characters at all.
  224. ;      0220    !
  225. ;      0221    ! 2.0.031    By: Nick Bush            On: 6-March-1984
  226. ;      0222    !        Make sure FILE_OPEN_FLAG is set properly when advancing
  227. ;      0223    !        to next file of a wild-card send.  The file was not
  228. ;      0224    !        being set true, leading to problems after a couple files.
  229. ;      0225    !
  230. ;      0226    ! 2.0.032    By: Nick Bush            On: 9-March-1984
  231. ;      0227    !        Fix UNPACK_DATA in SERVER_GENERIC to properly store
  232. ;      0228    !        new string pointer.
  233. ;      0229    !
  234. ;      0230    ! 2.0.033    By: Robert C. McQueen        On: 12-March-1984
  235. ;      0231    !        If NEXT_FILE fails with anything other than a NOMORFILES
  236. ;      0232    !        it should change state to STATE_A not STATE_SB.  This
  237. ;      0233    !        fixes a problem caused by Pro/Kermit and KERFIL (VMS).
  238. ;      0234    !
  239. ;      0235    ! 2.0.034    By: Nick Bush            On: 15-March-1984
  240. ;      0236    !        Put file spec into X packet as well as F packet. This
  241. ;      0237    !        makes wild card TYPE's work nicer.
  242. ;      0238    !
  243. ;      0239    ! 2.0.035    By: Nick Bush            On: 20-March-1984
  244. ;      0240    !        Fix send/receive quoting to conform to the way the
  245. ;      0241    !        protocol manual says it should be done, rather
  246. ;      0242    !        than the way we (and Kermit-20) have always done it.
  247. ;      0243    !--
  248. ;      0244    
  249. ;      0245    %SBTTL 'Interface requirements'
  250. ;      0246    
  251. ;      0247    !++
  252. ;      0248    !        Interface requirements
  253. ;      0249    !
  254. ;      0250    ! The following routines and data locations are rquired for a correct
  255. ;      0251    ! implementation of KERMIT.
  256. ;      0252    !
  257. ;      0253    ! File routines:
  258. ;      0254    !
  259. ;      0255    !    FILE_OPEN (Function)
  260. ;      0256    !        This routine will open a file for reading or writting.  It
  261. ;      0257    !        will assume that FILE_SIZE contains the number of bytes
  262. ;      0258    !        and FILE_NAME contains the file name of length FILE_SIZE.
  263. ;      0259    !        The function that is passed is either FNC_READ or FNC_WRITE.
  264. ;      0260    !
  265. ;      0261    !    FILE_CLOSE ()
  266. ;      0262    !        This routine will close the currently open file.  This
  267. ;      0263    !        routine will return the status of the operation.
  268. ;      0264    !
  269. ;      0265    !    GET_FILE (Character)
  270. ;      0266    !        This routine will get a character from the currently open file
  271. ;      0267    !        and store it in the location specified by "Character".  There
  272. ;      0268    !        will be a true/false value returned by the routine to determine
  273. ;      0269    !        if there was an error.
  274. ;      0270    !
  275. ;      0271    !    PUT_FILE (Character)
  276. ;      0272    !        This routine will output a character to the currently open
  277. ;      0273    !        file.  It will return a true/false value to determine if the
  278. ;      0274    !        routine was successful.
  279. ;      0275    !
  280. ;      0276    !    NEXT_FILE ()
  281. ;      0277    !        This routine will advance to the next file.  This routine
  282. ;      0278    !        will return false if there are no more files to process.
  283. ;      0279    !
  284. ;      0280    ! Communications line routines:
  285. ;      0281    !
  286. ;      0282    !    RECEIVE (Buffer address, Address of var to store length into)
  287. ;      0283    !        This routine will receive a message from the remote Kermit.
  288. ;      0284    !
  289. ;      0285    !    SEND (Buffer address, Length in characters)
  290. ;      0286    !        This routine will send a message to the remote Kermit.
  291. ;      0287    !
  292. ;      0288    !    GEN_CRC (Buffer address, length in characters)
  293. ;      0289    !        This routine will calculate the CRC-CCITT for the characters
  294. ;      0290    !        in the buffer.
  295. ;      0291    !
  296. ;      0292    ! Operating system routines:
  297. ;      0293    !
  298. ;      0294    !    SY_DISMISS (Seconds)
  299. ;      0295    !        This routine will cause Kermit to sleep for the specified
  300. ;      0296    !        number of seconds.  It is used to handle the DELAY parameter.
  301. ;      0297    !
  302. ;      0298    !    SY_LOGOUT ()
  303. ;      0299    !        Log the job off of the system. (Kill the process).
  304. ;      0300    !
  305. ;      0301    !    SY_TIME ()
  306. ;      0302    !        This routine will return the starting time milliseconds.
  307. ;      0303    !        It can be the start of Kermit, the system, etc, so long
  308. ;      0304    !        as it always is incrementing.
  309. ;      0305    !
  310. ;      0306    ! Status routines:
  311. ;      0307    !
  312. ;      0308    !    XFR_STATUS (Type, Subtype);
  313. ;      0309    !        This routine is called to indicate the occurance of
  314. ;      0310    !        a significant event that the user interface may wish
  315. ;      0311    !        to inform the user about.  The arguments indicate the
  316. ;      0312    !        type of event.
  317. ;      0313    !        Type: "S" - Send, "R" - Receive
  318. ;      0314    !            Subtype: "P" - Packet
  319. ;      0315    !                 "N" - NAK
  320. ;      0316    !                 "T" - timeout
  321. ;      0317    !        For type = "I" (initiate), "T" (terminate):
  322. ;      0318    !            Subtype: "S" - a file send
  323. ;      0319    !                 "R" - a file receive
  324. ;      0320    !                 "G" - a generic command
  325. ;      0321    !                 "I" - for "T" only, returning to server idle
  326. ;      0322    !        For type = "F" (file operation):
  327. ;      0323    !            Subtype: "S" - open for sending
  328. ;      0324    !                 "R" - open for receiving
  329. ;      0325    !                 "C" - closing file OK
  330. ;      0326    !                 "X" - aborting file by user request
  331. ;      0327    !                 "Z" - aborting group by user request
  332. ;      0328    !                 "D" - aborting file, but saving due to disposition
  333. ;      0329    !                 "A" - aborting file due to protocol error
  334. ;      0330    !
  335. ;      0331    ! Error processing:
  336. ;      0332    !
  337. ;      0333    !    KRM_ERROR (Error parameter)
  338. ;      0334    !        This routine will cause an error message to be issued.
  339. ;      0335    !        The error parameter is defined by KERERR.  This may cause
  340. ;      0336    !        SND_ERROR to be called to send an "E" message to the remote.
  341. ;      0337    !
  342. ;      0338    ! Terminal I/O routines:
  343. ;      0339    !
  344. ;      0340    !    TERM_DUMP (Buffer, Count)
  345. ;      0341    !    DBG_DUMP (Buffer, Count)
  346. ;      0342    !        This routine will dump the buffer onto the user's terminal.
  347. ;      0343    !        The routine is supplied with the count of the characters
  348. ;      0344    !        and the address of the buffer.
  349. ;      0345    !        These may be the same routine or different.  DBG_DUMP
  350. ;      0346    !        is only called for debugging output.
  351. ;      0347    !
  352. ;      0348    !
  353. ;      0349    !            ENTRY POINTS
  354. ;      0350    !
  355. ;      0351    ! KERMSG contains the following entry points for the KERMIT.
  356. ;      0352    !
  357. ;      0353    !    SERVER ()
  358. ;      0354    !        This routine will cause KERMIT go enter server mode.
  359. ;      0355    !
  360. ;      0356    !    SEND_SWITCH ()
  361. ;      0357    !        This routine will send a file.  It expects that the user
  362. ;      0358    !        has stored the text of the file name into FILE_NAME and
  363. ;      0359    !        the length of the text into FILE_SIZE.
  364. ;      0360    !
  365. ;      0361    !    REC_SWITCH ()
  366. ;      0362    !        This routine will receive a file.  It expects that the default
  367. ;      0363    !        file name is set up in FILE_NAME and the length is in
  368. ;      0364    !        FILE_SIZE.
  369. ;      0365    !
  370. ;      0366    !    GEN_PARITY (Character)
  371. ;      0367    !        This routine will return the character with the proper parity
  372. ;      0368    !        on the character.
  373. ;      0369    !
  374. ;      0370    !    SND_ERROR (COUNT, ADDRESS)
  375. ;      0371    !        This routine will send the text of an error to the remote
  376. ;      0372    !        Kermit.
  377. ;      0373    !
  378. ;      0374    !    DO_GENERIC (TYPE)
  379. ;      0375    !        This routine will cause a generic function to be sent to
  380. ;      0376    !        the remote Kermit.  This routine will then do all of the
  381. ;      0377    !        necessary hand shaking to handle the local end of the generic
  382. ;      0378    !        Kermit command.
  383. ;      0379    !
  384. ;      0380    !
  385. ;      0381    !        GLOBAL Storage
  386. ;      0382    !
  387. ;      0383    ! The following are the global storage locations that are used to interface
  388. ;      0384    ! to KERMSG.  These locations contains the various send and receive parameters.
  389. ;      0385    !
  390. ;      0386    ! Receive parameters:
  391. ;      0387    !
  392. ;      0388    !    RCV_PKT_SIZE
  393. ;      0389    !        Receive packet size.
  394. ;      0390    !    RCV_NPAD
  395. ;      0391    !        Padding length
  396. ;      0392    !    RCV_PADCHAR
  397. ;      0393    !        Padding character
  398. ;      0394    !    RCV_TIMEOUT
  399. ;      0395    !        Time out
  400. ;      0396    !    RCV_EOL
  401. ;      0397    !        End of line character
  402. ;      0398    !    RCV_QUOTE_CHR
  403. ;      0399    !        Quote character
  404. ;      0400    !    RCV_8QUOTE_CHR
  405. ;      0401    !        8-bit quoting character
  406. ;      0402    !    RCV_SOH
  407. ;      0403    !        Start of header character
  408. ;      0404    !
  409. ;      0405    ! Send parameters (Negative values denote the default, positive user supplied):
  410. ;      0406    !
  411. ;      0407    !    SND_PKT_SIZE
  412. ;      0408    !        Send packet size
  413. ;      0409    !    SND_NPAD
  414. ;      0410    !        Padding length
  415. ;      0411    !    SND_PADCHAR
  416. ;      0412    !        Padding character
  417. ;      0413    !    SND_TIMEOUT
  418. ;      0414    !        Time out
  419. ;      0415    !    SND_EOL
  420. ;      0416    !        End of line character
  421. ;      0417    !    SND_QUOTE_CHR
  422. ;      0418    !        Quote character
  423. ;      0419    !    SND_SOH
  424. ;      0420    !        Start of header character (normally 001)
  425. ;      0421    !
  426. ;      0422    ! Statistics:
  427. ;      0423    !
  428. ;      0424    !    SND_TOTAL_CHARS
  429. ;      0425    !        Total characters sent for this Kermit session
  430. ;      0426    !    RCV_TOTAL_CHARS
  431. ;      0427    !        Total characters received for this Kermit session
  432. ;      0428    !    SND_DATA_CHARS
  433. ;      0429    !        Total number of data characters sent for this Kermit session
  434. ;      0430    !    RCV_DATA_CHARS
  435. ;      0431    !        Total number of data characters received for this Kermit session
  436. ;      0432    !    SND_COUNT
  437. ;      0433    !        Total number of packets that have been sent
  438. ;      0434    !    RCV_COUNT
  439. ;      0435    !        Total number of packets that have been received.
  440. ;      0436    !    SMSG_TOTAL_CHARS
  441. ;      0437    !        Total characters sent for this file transfer
  442. ;      0438    !    RMSG_TOTAL_CHARS
  443. ;      0439    !        Total characters received for this file transfer
  444. ;      0440    !    SMSG_DATA_CHARS
  445. ;      0441    !        Total data characters sent for this file transfer
  446. ;      0442    !    RMSG_DATA_CHARS
  447. ;      0443    !        Total data characters received for this file transfer
  448. ;      0444    !    SMSG_NAKS
  449. ;      0445    !        Total number of NAKs sent for this file transfer
  450. ;      0446    !    RMSG_NAKS
  451. ;      0447    !        Total number of NAKs received for this file transfer
  452. ;      0448    !    XFR_TIME
  453. ;      0449    !        Amount of time the last transfer took in milliseconds.
  454. ;      0450    !    TOTAL_TIME
  455. ;      0451    !        Total amount of time spend transfering data.
  456. ;      0452    !
  457. ;      0453    ! Misc constants:
  458. ;      0454    !
  459. ;      0455    !    LAST_ERROR
  460. ;      0456    !        ASCIZ of the last error message issued.
  461. ;      0457    !    FILE_NAME
  462. ;      0458    !        Vector containing the ASCII characters of the file name.
  463. ;      0459    !    FILE_SIZE
  464. ;      0460    !        Number of characters in the FILE_NAME vector.
  465. ;      0461    !    DELAY
  466. ;      0462    !        Amount of time to delay
  467. ;      0463    !    DUPLEX
  468. ;      0464    !        DP_HALF or DP_FULL to denote either half duplex or full duplex.
  469. ;      0465    !        [Currently only DP_FULL is supported]
  470. ;      0466    !    PKT_RETRIES
  471. ;      0467    !        Number of retries to attempt to read a message.
  472. ;      0468    !    SI_RETRIES
  473. ;      0469    !        Number of retries to attempt on send inits
  474. ;      0470    !    DEBUG_FLAG
  475. ;      0471    !        Debugging mode on/off
  476. ;      0472    !    WARN_FLAG
  477. ;      0473    !        File warning flag
  478. ;      0474    !    IBM_FLAG
  479. ;      0475    !        True if talking to an IBM system, else false.
  480. ;      0476    !    ECHO_FLAG
  481. ;      0477    !        Local echo flag
  482. ;      0478    !    CONNECT_FLAG
  483. ;      0479    !        Connected flag; True if terminal and SET LINE are the same
  484. ;      0480    !    PARITY_TYPE
  485. ;      0481    !        Type of parity to use on sends.
  486. ;      0482    !    DEV_PARITY_FLAG
  487. ;      0483    !        Device will add parity to message.  True if device adds
  488. ;      0484    !        parity and false if we must do it.
  489. ;      0485    !
  490. ;      0486    !--
  491. ;      0487    
  492. ;      0488    %SBTTL 'Declarations -- Forward definitions'
  493. ;      0489    !<BLF/NOFORMAT>
  494. ;      0490    !
  495. ;      0491    ! Forward definitions
  496. ;      0492    !
  497. ;      0493    
  498. ;      0494    FORWARD ROUTINE
  499. ;      0495    
  500. ;      0496    ! Main loop for a complete transaction
  501. ;      0497        DO_TRANSACTION,        ! Perform a complete transaction
  502. ;      0498    
  503. ;      0499    ! Send processing routines
  504. ;      0500    
  505. ;      0501        SEND_SERVER_INIT,        ![026] Send a server init packet
  506. ;      0502        SEND_DATA,            ! Send data to the micro
  507. ;      0503        SEND_FILE,            ! Send file name
  508. ;      0504        SEND_OPEN_FILE,            ! Open file for sending
  509. ;      0505        SEND_GENCMD,        ! Send generic command
  510. ;      0506        SEND_EOF,            ! Send EOF
  511. ;      0507        SEND_INIT,            ! Send initialization msg
  512. ;      0508        SEND_BREAK,            ! Send break end of transmission
  513. ;      0509    
  514. ;      0510    ! Receive processing routines
  515. ;      0511    
  516. ;      0512        REC_SERVER_IDLE,        ! Wait for message while server is idle
  517. ;      0513        REC_INIT,            ! Receive initialization
  518. ;      0514        REC_FILE,            ! Receive file information
  519. ;      0515        REC_DATA,            ! Receive data
  520. ;      0516    !
  521. ;      0517    ! Server processing routines
  522. ;      0518    !
  523. ;      0519        SERVER_GENERIC,        ! Process generic KERMIT commands
  524. ;      0520        HOST_COMMAND,        ! Process host command
  525. ;      0521        CALL_SY_RTN,        ! Handle calling system routine and returning result
  526. ;      0522    !
  527. ;      0523    ! Statistic gathering routines
  528. ;      0524    !
  529. ;      0525        END_STATS    : NOVALUE,    ! End of a message processing stats routine
  530. ;      0526    
  531. ;      0527    ! Low level send/receive routines
  532. ;      0528    
  533. ;      0529        CALC_BLOCK_CHECK,        ! Routine to calculate the block check value
  534. ;      0530        SET_SEND_INIT : NOVALUE,    ! Set up the MSG_SND_INIT parameters.
  535. ;      0531        PRS_SEND_INIT,        ! Parse MSG_SND_INIT parameters.
  536. ;      0532        DO_PARITY : NOVALUE,    ! Routine to generate parity for a message
  537. ;      0533        GEN_PARITY,            ! Routine to add parity to a character
  538. ;      0534        SEND_PACKET,        ! Send a packet to the remote
  539. ;      0535        REC_MESSAGE,        ! Receive a message with retry processing
  540. ;      0536        REC_PACKET,            ! Receive a packet from the remote
  541. ;      0537    
  542. ;      0538    ! Utility routines
  543. ;      0539    
  544. ;      0540        NORMALIZE_FILE : NOVALUE,    ! Force file name into normal form
  545. ;      0541        BFR_EMPTY,            ! Empty the data buffer
  546. ;      0542        BFR_FILL,            ! Fill the data buffer from a file
  547. ;      0543        SET_STRING,            ![025] Routine to set alternate get/put routines
  548. ;      0544                        ! for use with in memory strings
  549. ;      0545        TYPE_CHAR,            ! Type a character from a packet
  550. ;      0546        INIT_XFR    : NOVALUE,    ! Initialize the per transfer processing
  551. ;      0547        STS_OUTPUT    : NOVALUE,    ! Output current transfer status
  552. ;      0548    !
  553. ;      0549    ! Debugging routines
  554. ;      0550    !
  555. ;      0551        DBG_MESSAGE    : NOVALUE,    ! Type out a formatted message
  556. ;      0552        DBG_SEND    : NOVALUE,    ! Send message debugging routine
  557. ;      0553        DBG_RECEIVE    : NOVALUE;    ! Receive message debugging routine
  558. ;      0554        %SBTTL    'Require files'
  559. ;      0555    
  560. ;      0556    !
  561. ;      0557    !<BLF/FORMAT>
  562. ;      0558    !
  563. ;      0559    ! REQUIRE FILES:
  564. ;      0560    !
  565. ;      0561    
  566. ;    L 0562    %IF %BLISS (BLISS32)
  567. ;    U 0563    %THEN
  568. ;    U 0564    
  569. ;    U 0565    LIBRARY 'SYS$LIBRARY:STARLET';
  570. ;    U 0566    
  571. ;      0567    %FI
  572. ;      0568    
  573. ;      0569    REQUIRE 'KERCOM';
  574. ;      0769    
  575. ;      0770    REQUIRE 'KERERR';
  576. ;      0799    
  577. ;      0800    %SBTTL 'Macro definitions'
  578. ;      0801    !
  579. ;      0802    ! MACROS:
  580. ;      0803    !
  581. ;      0804    
  582. ;      0805    MACRO
  583. ;    M 0806        CTL (C) =
  584. ;      0807     ((C) XOR %O'100')%,
  585. ;    M 0808        CHAR (C) =
  586. ;      0809     ((C) + %O'40')%,
  587. ;    M 0810        UNCHAR (C) =
  588. ;      0811     ((C) - %O'40')%;
  589. ;      0812    
  590. ;      0813    %SBTTL 'KERMIT Protocol Definitions'
  591. ;      0814    
  592. ;      0815    !++
  593. ;      0816    ! The following describes the various items that are found in the
  594. ;      0817    ! KERMIT messages.  A complete and through desription of the protocol can be
  595. ;      0818    ! found in the KERMIT PROTOCOL MANUAL.
  596. ;      0819    !
  597. ;      0820    !
  598. ;      0821    ! All KERMIT messages have the following format:
  599. ;      0822    !
  600. ;      0823    ! <Mark><CHAR(Count)><CHAR(Seq)><Message-dependent information><Check><EOL>
  601. ;      0824    !
  602. ;      0825    ! <MARK>
  603. ;      0826    !    Normally SOH (Control-A, octal 001).
  604. ;      0827    !
  605. ;      0828    ! <CHAR(Count)>
  606. ;      0829    !    Count of the number of characters following this position.
  607. ;      0830    !    Character counts of ONLY 0 to 94 are valid.
  608. ;      0831    !
  609. ;      0832    ! <CHAR(Seq)>
  610. ;      0833    !    Packet sequence number, modulo 100 (octal).
  611. ;      0834    !
  612. ;      0835    ! <MESSAGE-DEPENDENT INFORMATION>
  613. ;      0836    !    This field contains the message dependent information.  There can
  614. ;      0837    !    be multiple fields in this section.  See the KERMIT Protocol document
  615. ;      0838    !    for a complete description of this.
  616. ;      0839    !
  617. ;      0840    ! <Check>
  618. ;      0841    !    A block check on the characters in the packet between, but not
  619. ;      0842    !    including, the mark and the checksum itself.  It may be one to three
  620. ;      0843    !    characters, depending upon the type agreed upon.
  621. ;      0844    !
  622. ;      0845    !    1. Single character arithmetic sum equal to:
  623. ;      0846    !        chksum = (s + ((s AND 300)/100)) AND 77
  624. ;      0847    !        Character sent is CHAR(chksum).
  625. ;      0848    !
  626. ;      0849    !    2. Two character arithmetic sum.  CHAR of bits 6-11 are the first
  627. ;      0850    !       character, CHAR of bits 0-5 are the second character.
  628. ;      0851    !
  629. ;      0852    !    3. Three character CRC-CCITT.  First character is CHAR of bits 12-15,
  630. ;      0853    !       second is CHAR of bits 6-11, third is CHAR of bits 0-5.
  631. ;      0854    !
  632. ;      0855    !
  633. ;      0856    ! <EOL>
  634. ;      0857    !    End of line.  Any line terminator that may be required by the host.
  635. ;      0858    !--
  636. ;      0859    
  637. ;      0860    %SBTTL 'KERMIT Protocol Definitions -- Packet offsets'
  638. ;      0861    
  639. ;      0862    !++
  640. ;      0863    ! The following define the various offsets of the standard KERMIT
  641. ;      0864    ! packets.
  642. ;      0865    !--
  643. ;      0866    
  644. ;      0867    LITERAL
  645. ;      0868        PKT_MARK = 0,                ! <MARK>
  646. ;      0869        PKT_COUNT = 1,                ! <CHAR(Count)>
  647. ;      0870        PKT_SEQ = 2,                ! <CHAR(Seq)>
  648. ;      0871        PKT_TYPE = 3,                ! <Message type>
  649. ;      0872        PKT_MSG = 4,                ! <MESSAGE-DEPENDENT INFORMATION>
  650. ;      0873        PKT_MAX_MSG = 94 - 5,            ! Maximum size of the message dependent
  651. ;      0874                                !  information
  652. ;      0875        PKT_CHKSUM = 0,                ! <CHAR(Chksum)> offset from end of
  653. ;      0876                                !    Message dependent information
  654. ;      0877        PKT_EOL = 1,                ! <Eol> offset from end of data
  655. ;      0878        PKT_OVR_HEAD_B = 2,                ! Header overhead
  656. ;      0879        PKT_OVR_HEAD_E = 1,                ! Overhead at the end
  657. ;      0880        PKT_OVR_HEAD = 3,                ! Overhead added to data length
  658. ;      0881        PKT_TOT_OVR_HEAD = 6;            ! Total overhead of the message
  659. ;      0882    
  660. ;      0883    %SBTTL 'KERMIT Protocol Definitions -- Message dependent field'
  661. ;      0884    
  662. ;      0885    !++
  663. ;      0886    ! The MESSAGE-DEPENDENT information field of the message contains at
  664. ;      0887    ! least one part.  That is the type of message.  The remainder of the message
  665. ;      0888    ! MESSAGE-DEPENDENT field is different depending on the message.
  666. ;      0889    !
  667. ;      0890    ! <TYPE><TYPE-DEPENDENT-INFORMATION>
  668. ;      0891    !
  669. ;      0892    ! <TYPE>
  670. ;      0893    !    The type defines the type of message that is being processed.
  671. ;      0894    !
  672. ;      0895    !--
  673. ;      0896    
  674. ;      0897    ! Protocol version 1.0 message types
  675. ;      0898    
  676. ;      0899    LITERAL
  677. ;      0900        MSG_DATA = %C'D',                ! Data packet
  678. ;      0901        MSG_ACK = %C'Y',                ! Acknowledgement
  679. ;      0902        MSG_NAK = %C'N',                ! Negative acknowledgement
  680. ;      0903        MSG_SND_INIT = %C'S',            ! Send initiate
  681. ;      0904        MSG_BREAK = %C'B',                ! Break transmission
  682. ;      0905        MSG_FILE = %C'F',                ! File header
  683. ;      0906        MSG_EOF = %C'Z',                ! End of file (EOF)
  684. ;      0907        MSG_ERROR = %C'E';                ! Error
  685. ;      0908    
  686. ;      0909    ! Protocol version 2.0 message types
  687. ;      0910    
  688. ;      0911    LITERAL
  689. ;      0912        MSG_RCV_INIT = %C'R',            ! Receive initiate
  690. ;      0913        MSG_COMMAND = %C'C',            ! Host command
  691. ;      0914        MSG_KERMIT = %C'G';                ! Generic KERMIT command.
  692. ;      0915    
  693. ;      0916    ! Protocol version 4.0 message types
  694. ;      0917    
  695. ;      0918    LITERAL
  696. ;      0919        MSG_SER_INIT = %C'I',            ! Server initialization
  697. ;      0920        MSG_TEXT = %C'X';                ! Text header message
  698. ;      0921    
  699. ;      0922    !++
  700. ;      0923    ! Generic KERMIT commands
  701. ;      0924    !--
  702. ;      0925    
  703. ;      0926    LITERAL
  704. ;      0927        MSG_GEN_LOGIN = %C'I',            ! Login
  705. ;      0928        MSG_GEN_EXIT = %C'F',            ! Finish (exit to OS)
  706. ;      0929        MSG_GEN_CONNECT = %C'C',            ! Connect to a directory
  707. ;      0930        MSG_GEN_LOGOUT = %C'L',            ! Logout
  708. ;      0931        MSG_GEN_DIRECTORY = %C'D',            ! Directory
  709. ;      0932        MSG_GEN_DISK_USAGE = %C'U',            ! Disk usage
  710. ;      0933        MSG_GEN_DELETE = %C'E',            ! Delete a file
  711. ;      0934        MSG_GEN_TYPE = %C'T',            ! Type a file specification
  712. ;      0935    !    MSG_GEN_SUBMIT = %C'S',            ! Submit
  713. ;      0936    !    MSG_GEN_PRINT = %C'P',            ! Print
  714. ;      0937        MSG_GEN_WHO = %C'W',            ! Who's logged in
  715. ;      0938        MSG_GEN_SEND = %C'M',            ! Send a message to a user
  716. ;      0939        MSG_GEN_HELP = %C'H',            ! Help
  717. ;      0940        MSG_GEN_QUERY = %C'Q',            ! Query status
  718. ;      0941        MSG_GEN_RENAME = %C'R',            ! Rename file
  719. ;      0942        MSG_GEN_COPY = %C'K';            ! Copy file
  720. ;      0943    
  721. ;      0944    !
  722. ;      0945    ! Acknowledgement modifiers (protocol 4.0)
  723. ;      0946    !
  724. ;      0947    
  725. ;      0948    LITERAL
  726. ;      0949        MSG_ACK_ABT_CUR = %C'X',            ! Abort current file
  727. ;      0950        MSG_ACK_ABT_ALL = %C'Z';            ! Abort entire stream of files
  728. ;      0951    
  729. ;      0952    !
  730. ;      0953    ! End of file packet modifier
  731. ;      0954    !
  732. ;      0955    
  733. ;      0956    LITERAL
  734. ;      0957        MSG_EOF_DISCARD = %C'D';            ! Discard data from previous file
  735. ;      0958    
  736. ;      0959    %SBTTL 'KERMIT Protocol Definitions -- SEND initiate packet'
  737. ;      0960    
  738. ;      0961    !++
  739. ;      0962    !
  740. ;      0963    ! The following describes the send initiate packet.  All fields in the message
  741. ;      0964    ! data area are optional.
  742. ;      0965    !
  743. ;      0966    ! <"S"><CHAR(Bufsiz)><CHAR(Timeout)><CHAR(npad)><CTL(pad)><CHAR(Eol)><Quote>
  744. ;      0967    !    <8-bit-quote><Check-type><Repeat-count-processing><Reserved><Reserved>
  745. ;      0968    !
  746. ;      0969    ! BUFSIZ
  747. ;      0970    !    Sending Kermit's maximum buffer size.
  748. ;      0971    !
  749. ;      0972    ! Timeout
  750. ;      0973    !    Number of seconds after which the sending Kermit wishes to be timed out
  751. ;      0974    !
  752. ;      0975    ! Npad
  753. ;      0976    !    Number of padding caracters the sending Kermit needs preceding each
  754. ;      0977    !    packet.
  755. ;      0978    !
  756. ;      0979    ! PAD
  757. ;      0980    !    Padding character.
  758. ;      0981    !
  759. ;      0982    ! EOL
  760. ;      0983    !    A line terminator required on all packets set by the receiving
  761. ;      0984    !    Kermit.
  762. ;      0985    !
  763. ;      0986    ! Quote
  764. ;      0987    !    The printable ASCII characer the sending Kermit will use when quoting
  765. ;      0988    !    the control cahracters.  Default is "#".
  766. ;      0989    !
  767. ;      0990    ! 8-bit-quote
  768. ;      0991    !    Specify quoting mecanism for 8-bit quantities.  A quoting mecanism is
  769. ;      0992    !    mecessary when sending to hosts which prevent the use of the 8th bit
  770. ;      0993    !    for data.  When elected, the quoting mechanism will be used by both
  771. ;      0994    !    hosts, and the quote character must be in the range of 41-76 or 140-176
  772. ;      0995    !    octal, but different from the control-quoting character.  This field is
  773. ;      0996    !    interpreted as follows:
  774. ;      0997    !
  775. ;      0998    !    "Y" - I agree to 8-bit quoting if you request it.
  776. ;      0999    !    "N" - I will not do 8-bit quoting.
  777. ;      1000    !    "&" - (or any other character in the range of 41-76 or 140-176) I want
  778. ;      1001    !          to do 8-bit quoting using this character (it will be done if the
  779. ;      1002    !          other Kermit puts a "Y" in this field.
  780. ;      1003    !    Anything else: Quoting will not be done.
  781. ;      1004    !
  782. ;      1005    ! Check-type
  783. ;      1006    !    Type of block check.  The only values presently allowed in this
  784. ;      1007    !    field are "1", "2" or "3".  Future implementations may allow other
  785. ;      1008    !    values.  Interpretation of the values is:
  786. ;      1009    !
  787. ;      1010    !    "1" - Single character checksum.  Default value if none specified.
  788. ;      1011    !    "2" - Double character checksum.
  789. ;      1012    !    "3" - Three character CRC.
  790. ;      1013    !
  791. ;      1014    ! Repeat-count-processing
  792. ;      1015    !    The prefix character to be used to indicate a repeated character.
  793. ;      1016    !    This can be any printable cahracter other than blank (which denotes
  794. ;      1017    !    no repeat count).
  795. ;      1018    !
  796. ;      1019    ! Fields 10 to 11 reserved.
  797. ;      1020    !--
  798. ;      1021    
  799. ;      1022    LITERAL
  800. ;      1023        P_SI_BUFSIZ = 0,                ! Buffersize
  801. ;      1024        MY_PKT_SIZE = 80,                ! My packet size
  802. ;      1025        P_SI_TIMOUT = 1,                ! Time out
  803. ;      1026        MY_TIME_OUT = 15,                ! My time out
  804. ;      1027        P_SI_NPAD = 2,                ! Number of padding characters
  805. ;      1028        MY_NPAD = 0,                ! Amount of padding I require
  806. ;      1029        P_SI_PAD = 3,                ! Padding character
  807. ;      1030        MY_PAD_CHAR = 0,                ! My pad character
  808. ;      1031        P_SI_EOL = 4,                ! End of line character
  809. ;      1032        MY_EOL_CHAR = %O'015',            ! My EOL cahracter
  810. ;      1033        P_SI_QUOTE = 5,                ! Quote character
  811. ;      1034        MY_QUOTE_CHAR = %C'#',            ! My quoting character
  812. ;      1035        P_SI_8QUOTE = 6,                ! 8-bit quote
  813. ;      1036        MY_8BIT_QUOTE = %C'&',            ! Don't do it
  814. ;      1037        P_SI_CHKTYPE = 7,                ! Checktype used
  815. ;      1038        MY_CHKTYPE = CHK_1CHAR,            ! Use single character checksum
  816. ;      1039        P_SI_REPEAT = 8,                ! Repeat character
  817. ;      1040        MY_REPEAT = %C'~',                ! My repeat character
  818. ;      1041        P_SI_LENGTH = 9;                ! Length of the message
  819. ;      1042    
  820. ;      1043    %SBTTL 'KERMIT Protocol States'
  821. ;      1044    
  822. ;      1045    !++
  823. ;      1046    ! The following are the various states that KERMIT can be in.
  824. ;      1047    ! The state transitions are defined in the KERMIT Protocol manual.
  825. ;      1048    !--
  826. ;      1049    
  827. ;      1050    LITERAL
  828. ;      1051        STATE_MIN = 1,                ! Min state number
  829. ;      1052        STATE_S = 1,                ! Send init state
  830. ;      1053        STATE_SF = 2,                ! Send file header
  831. ;      1054        STATE_SD = 3,                ! Send file data packet
  832. ;      1055        STATE_SZ = 4,                ! Send EOF packet
  833. ;      1056        STATE_SB = 5,                ! Send break
  834. ;      1057        STATE_R = 6,                ! Receive state (wait for send-init)
  835. ;      1058        STATE_RF = 7,                ! Receive file header packet
  836. ;      1059        STATE_RD = 8,                ! Receive file data packet
  837. ;      1060        STATE_C = 9,                ! Send complete
  838. ;      1061        STATE_A = 10,                ! Abort
  839. ;      1062        STATE_SX = 11,                ! Send text header
  840. ;      1063        STATE_SG = 12,                ! Send generic command
  841. ;      1064        STATE_SI = 13,                ! Send server init
  842. ;      1065        STATE_ID = 14,                ! Server idle loop
  843. ;      1066        STATE_II = 15,                ! Server idle after server init
  844. ;      1067        STATE_FI = 16,                ! Server should exit
  845. ;      1068        STATE_LG = 17,                ! Server should logout
  846. ;      1069        STATE_OF = 18,                ! Send - open first input file
  847. ;      1070        STATE_EX = 19,                ! Exit back to command parser
  848. ;      1071        STATE_MAX = 19;                ! Max state number
  849. ;      1072    
  850. ;      1073    %SBTTL 'Internal constants'
  851. ;      1074    
  852. ;      1075    !++
  853. ;      1076    ! The following represent various internal KERMSG constants.
  854. ;      1077    !--
  855. ;      1078    
  856. ;      1079    LITERAL
  857. ;      1080        MAX_PKT_RETRIES = 16,            ! Maximum packet retries
  858. ;      1081        MAX_SI_RETRIES = 5;                ! Maximum send init retries
  859. ;      1082    
  860. ;      1083    %SBTTL 'Storage - External'
  861. ;      1084    !
  862. ;      1085    ! OWN STORAGE:
  863. ;      1086    !
  864. ;      1087    
  865. ;      1088    EXTERNAL
  866. ;      1089    !
  867. ;      1090    ! Receive parameters
  868. ;      1091    !
  869. ;      1092        RCV_PKT_SIZE,                ! Receive packet size
  870. ;      1093        RCV_NPAD,                    ! Padding length
  871. ;      1094        RCV_PADCHAR,                ! Padding character
  872. ;      1095        RCV_TIMEOUT,                ! Time out
  873. ;      1096        RCV_EOL,                    ! EOL character
  874. ;      1097        RCV_QUOTE_CHR,                ! Quote character
  875. ;      1098        RCV_SOH,                    ! Start of header character
  876. ;      1099        RCV_8QUOTE_CHR,                ! 8-bit quoting character
  877. ;      1100    !
  878. ;      1101    ! Miscellaneous parameters
  879. ;      1102    !
  880. ;      1103        SET_REPT_CHR,                ! Repeat character
  881. ;      1104    !
  882. ;      1105    ! Send parameters
  883. ;      1106    !
  884. ;      1107        SND_PKT_SIZE,                ! Send packet size
  885. ;      1108        SND_NPAD,                    ! Padding length
  886. ;      1109        SND_PADCHAR,                ! Padding character
  887. ;      1110        SND_TIMEOUT,                ! Time out
  888. ;      1111        SND_EOL,                    ! EOL character
  889. ;      1112        SND_QUOTE_CHR,                ! Quote character
  890. ;      1113        SND_SOH,                    ! Start of header character
  891. ;      1114        SEND_TIMEOUT,                ! Time to wait for receiving message
  892. ;      1115    !
  893. ;      1116    ! Statistics
  894. ;      1117    !
  895. ;      1118        SND_TOTAL_CHARS,                ! Total characters sent
  896. ;      1119        RCV_TOTAL_CHARS,                ! Total characters received
  897. ;      1120        SND_DATA_CHARS,                ! Total number of data characters sent
  898. ;      1121        RCV_DATA_CHARS,                ! Total number of data characters received
  899. ;      1122        SND_NAKS,                    ! Total NAKs sent
  900. ;      1123        RCV_NAKS,                    ! Total NAKs received
  901. ;      1124        SND_COUNT,                    ! Count of total number of packets
  902. ;      1125        RCV_COUNT,                    ! Count of total number packets received
  903. ;      1126        SMSG_COUNT,                    ! Total number of packets sent
  904. ;      1127        RMSG_COUNT,                    ! Total number of packets received
  905. ;      1128        SMSG_TOTAL_CHARS,                ! Total chars sent this file xfer
  906. ;      1129        RMSG_TOTAL_CHARS,                ! Total chars rcvd this file xfer
  907. ;      1130        SMSG_DATA_CHARS,                ! Total data chars this file xfer
  908. ;      1131        RMSG_DATA_CHARS,                ! Total data chars this file xfer
  909. ;      1132        SMSG_NAKS,                    ! Total number of NAKs this file xfer
  910. ;      1133        RMSG_NAKS,                    ! Total number of NAKs received
  911. ;      1134        XFR_TIME,                    ! Amount of time last xfr took
  912. ;      1135        TOTAL_TIME,                    ! Total time of all xfrs
  913. ;      1136                                !  this file xfer
  914. ;      1137        LAST_ERROR : VECTOR [CH$ALLOCATION (MAX_MSG + 1)],    ! Last error message
  915. ;      1138    !
  916. ;      1139    ! Misc constants.
  917. ;      1140    !
  918. ;      1141        FILE_NAME : VECTOR [CH$ALLOCATION (MAX_FILE_NAME)],
  919. ;      1142        FILE_SIZE,
  920. ;      1143        SI_RETRIES,                    ! Send init retries to attempt
  921. ;      1144        PKT_RETRIES,                ! Number of retries to try for a message
  922. ;      1145        DELAY,                    ! Amount of time to delay
  923. ;      1146        DUPLEX,                    ! Type of connection (half or full)
  924. ;      1147        PARITY_TYPE,                ! Type of parity to use
  925. ;      1148        DEV_PARITY_FLAG,                ! True if output device does
  926. ;      1149                                !  parity, false if we do it
  927. ;      1150        CHKTYPE,                    ! Type of block check desired
  928. ;      1151        ABT_FLAG,                    ! True if aborted file should be discarded
  929. ;      1152        DEBUG_FLAG,                    ! Debugging mode on/off
  930. ;      1153        WARN_FLAG,                    ! File warning flag
  931. ;      1154        IBM_FLAG,                    ! Talking to an IBM system
  932. ;      1155        IBM_CHAR,                    ! Turnaround character for IBM mode
  933. ;      1156        ECHO_FLAG,                    ! Local echo flag
  934. ;      1157        CONNECT_FLAG,                ! Connected flag; True if
  935. ;      1158                                !  terminal and SET LINE are
  936. ;      1159                                !  the same
  937. ;      1160        ABT_CUR_FILE,                ! Abort current file
  938. ;      1161        ABT_ALL_FILE,                ! Abort all files in stream
  939. ;      1162        TYP_STS_FLAG,                ! Type status next message
  940. ;      1163        TY_FIL,                    ! Type file specs
  941. ;      1164        TY_PKT,                    ! Type packet info
  942. ;      1165        FIL_NORMAL_FORM,                ! If true, file names should be normalized
  943. ;      1166        GEN_1DATA : VECTOR [CH$ALLOCATION (MAX_MSG)],    ! Data for generic command
  944. ;      1167        GEN_1SIZE,                    ! Size of data in GEN_1DATA
  945. ;      1168        GEN_2DATA : VECTOR [CH$ALLOCATION (MAX_MSG)],    ! Second argument for generic command
  946. ;      1169        GEN_2SIZE,                    ! Size of data in GEN_2DATA
  947. ;      1170        GEN_3DATA : VECTOR [CH$ALLOCATION (MAX_MSG)],    ! Third arg for generic command
  948. ;      1171        GEN_3SIZE;                    ! Size of data in GEN_3DATA
  949. ;      1172    
  950. ;      1173    %SBTTL 'Storage - Local'
  951. ;      1174    !
  952. ;      1175    ! LOCAL OWN STORAGE:
  953. ;      1176    !
  954. ;      1177    
  955. ;      1178    OWN
  956. ;      1179    !
  957. ;      1180    ! Receive parameters
  958. ;      1181    !
  959. ;      1182        RECV_8QUOTE_CHR,                ! 8th-bit quoting character
  960. ;      1183        REPT_CHR,                    ! Repeat prefix character
  961. ;      1184    !
  962. ;      1185    ! Send parameters
  963. ;      1186    !
  964. ;      1187        SEND_PKT_SIZE,                ! Send packet size
  965. ;      1188        SEND_NPAD,                    ! Padding length
  966. ;      1189        SEND_PADCHAR,                ! Padding character
  967. ;      1190        SEND_EOL,                    ! EOL character
  968. ;      1191        SEND_QUOTE_CHR,                ! Quote character
  969. ;      1192        SEND_8QUOTE_CHR,                ! 8-bit quoting character
  970. ;      1193    !
  971. ;      1194    ! Misc parameters
  972. ;      1195    !
  973. ;      1196        INI_CHK_TYPE,                ! Type of block checking from init message
  974. ;      1197        BLK_CHK_TYPE,                ! Type of block check to use
  975. ;      1198        FLAG_8QUOTE,                ! Flag to determine if doing 8bit quoting
  976. ;      1199        FLAG_REPEAT,                ! True if doing repeated character compression
  977. ;      1200        STATE,                    ! Current state
  978. ;      1201        SIZE,                    ! Size of the current message
  979. ;      1202        OLD_RETRIES,                ! Saved number of retries done.
  980. ;      1203        NUM_RETRIES,                ! Number of retries
  981. ;      1204        MSG_NUMBER,                    ! Current message number
  982. ;      1205        REC_SEQ,                    ! Sequence number of msg in REC_MSG
  983. ;      1206        REC_LENGTH,                    ! Length of the message recv'd
  984. ;      1207        REC_TYPE,                    ! Type of the message received.
  985. ;      1208        REC_MSG : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)],    ! Message received
  986. ;      1209        SND_MSG : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)],    ! Message sent
  987. ;      1210        FILE_OPEN_FLAG,                ! File is opened.
  988. ;      1211        FILE_CHARS,                    ! Number of characters sent or received
  989. ;      1212        TEXT_HEAD_FLAG,                ! Text header received, not file header
  990. ;      1213        NO_FILE_NEEDED,                ! Don't open a file
  991. ;      1214        INIT_PKT_SENT,                ! Server-init sent and ACKed
  992. ;      1215        GEN_TYPE,                    ! Command message type
  993. ;      1216        GEN_SUBTYPE,                ! Generic command subtype
  994. ;      1217        GET_CHR_ROUTINE,            ![025] Address of routine to get a character for BFR_FILL
  995. ;      1218        PUT_CHR_ROUTINE;            ![025] Address of routine to put a character for BFR_EMPTY
  996. ;      1219    
  997. ;      1220    %SBTTL 'External references'
  998. ;      1221    !
  999. ;      1222    ! EXTERNAL REFERENCES:
  1000. ;      1223    !
  1001. ;      1224    ! Packet I/O routines
  1002. ;      1225    
  1003. ;      1226    EXTERNAL ROUTINE
  1004. ;      1227        SEND,                    ! Send a packet to the remote
  1005. ;      1228        IBM_WAIT,                    ! Wait for IBM turnaround
  1006. ;      1229        RECEIVE;                    ! Receive a packet from the remote
  1007. ;      1230    
  1008. ;      1231    !
  1009. ;      1232    ! Terminal I/O routines
  1010. ;      1233    !
  1011. ;      1234    
  1012. ;      1235    EXTERNAL ROUTINE
  1013. ;      1236        TERM_DUMP : NOVALUE,            ! Normal terminal output
  1014. ;      1237        DBG_DUMP : NOVALUE,                ! Debugging output
  1015. ;      1238        TT_SET_OUTPUT,                ! Set output routine
  1016. ;      1239        TT_CHAR : NOVALUE,                ! Output a single character
  1017. ;      1240        TT_CRLF : NOVALUE,                ! Output a CRLF
  1018. ;      1241        TT_NUMBER : NOVALUE,            ! Output a three digit number to the
  1019. ;      1242                                !  terminal
  1020. ;      1243        TT_TEXT : NOVALUE,                ! Output a string to the user's
  1021. ;      1244        TT_OUTPUT : NOVALUE;            ! Force buffered output to terminal
  1022. ;      1245    
  1023. ;      1246    ! Operating system routines and misc routines
  1024. ;      1247    
  1025. ;      1248    EXTERNAL ROUTINE
  1026. ;      1249        CRCCLC,                    ! Calculate a CRC-CCITT
  1027. ;      1250        XFR_STATUS : NOVALUE,            ! Routine to tell the user the
  1028. ;      1251                                !  status of a transfer
  1029. ;      1252        KRM_ERROR : NOVALUE,            ! Issue an error message
  1030. ;      1253        SY_LOGOUT : NOVALUE,            ! Log the job off
  1031. ;      1254        SY_GENERIC,                    ! Perform a generic command
  1032. ;      1255        SY_TIME,                    ! Return elapsed time in milliseconds
  1033. ;      1256        SY_DISMISS : NOVALUE;            ! Routine to dismiss for n seconds.
  1034. ;      1257    
  1035. ;      1258    !
  1036. ;      1259    ! External file processing routines
  1037. ;      1260    !
  1038. ;      1261    
  1039. ;      1262    EXTERNAL ROUTINE
  1040. ;      1263        FILE_OPEN,                    ! Open a file for reading/writing
  1041. ;      1264        FILE_CLOSE,                    ! Close an open file
  1042. ;      1265        NEXT_FILE,                    ! Determine if there is a next file
  1043. ;      1266                                !  and open it for reading.
  1044. ;      1267        GET_FILE,                    ! Get a byte from the file
  1045. ;      1268        PUT_FILE;                    ! Put a byte in the file.
  1046. ;      1269    
  1047. ;      1270    %SBTTL 'MSG_INIT'
  1048. ;      1271    
  1049. ;      1272    GLOBAL ROUTINE MSG_INIT : NOVALUE =
  1050. ;      1273    
  1051. ;      1274    !++
  1052. ;      1275    ! FUNCTIONAL DESCRIPTION:
  1053. ;      1276    !
  1054. ;      1277    !    This routine will initialize the message processing for
  1055. ;      1278    !    KERMIT-32/36.
  1056. ;      1279    !
  1057. ;      1280    ! CALLING SEQUENCE:
  1058. ;      1281    !
  1059. ;      1282    !    MSG_INIT();
  1060. ;      1283    !
  1061. ;      1284    ! INPUT PARAMETERS:
  1062. ;      1285    !
  1063. ;      1286    !    None.
  1064. ;      1287    !
  1065. ;      1288    ! IMPLICIT INPUTS:
  1066. ;      1289    !
  1067. ;      1290    !    None.
  1068. ;      1291    !
  1069. ;      1292    ! OUTPUT PARAMETERS:
  1070. ;      1293    !
  1071. ;      1294    !    None.
  1072. ;      1295    !
  1073. ;      1296    ! IMPLICIT OUTPUTS:
  1074. ;      1297    !
  1075. ;      1298    !    None.
  1076. ;      1299    !
  1077. ;      1300    ! COMPLETION CODES:
  1078. ;      1301    !
  1079. ;      1302    !    None.
  1080. ;      1303    !
  1081. ;      1304    ! SIDE EFFECTS:
  1082. ;      1305    !
  1083. ;      1306    !    None.
  1084. ;      1307    !
  1085. ;      1308    !--
  1086. ;      1309    
  1087. ;      1310        BEGIN
  1088. ;      1311    !
  1089. ;      1312    ! Initialize some variables
  1090. ;      1313    !
  1091. ;      1314    ! Receive parameters first
  1092. ;      1315    !
  1093. ;      1316        RCV_PKT_SIZE = MY_PKT_SIZE;
  1094. ;      1317        RCV_NPAD = MY_NPAD;
  1095. ;      1318        RCV_PADCHAR = MY_PAD_CHAR;
  1096. ;      1319        RCV_TIMEOUT = MY_TIME_OUT;
  1097. ;      1320        RCV_EOL = MY_EOL_CHAR;
  1098. ;      1321        RCV_QUOTE_CHR = MY_QUOTE_CHAR;
  1099. ;      1322        RCV_SOH = CHR_SOH;
  1100. ;      1323        RCV_8QUOTE_CHR = MY_8BIT_QUOTE;
  1101. ;      1324        SET_REPT_CHR = MY_REPEAT;
  1102. ;      1325    !
  1103. ;      1326    ! Send parameters.
  1104. ;      1327    !
  1105. ;      1328        SND_PKT_SIZE = -MY_PKT_SIZE;
  1106. ;      1329        SND_NPAD = -MY_NPAD;
  1107. ;      1330        SND_PADCHAR = -MY_PAD_CHAR;
  1108. ;      1331        SND_TIMEOUT = -MY_TIME_OUT;
  1109. ;      1332        SND_EOL = -MY_EOL_CHAR;
  1110. ;      1333        SND_QUOTE_CHR = -MY_QUOTE_CHAR;
  1111. ;      1334        SND_SOH = CHR_SOH;
  1112. ;      1335    !
  1113. ;      1336    ! Other random parameters
  1114. ;      1337    !
  1115. ;      1338        PKT_RETRIES = MAX_PKT_RETRIES;        ! Number of retries per message
  1116. ;      1339        SI_RETRIES = MAX_SI_RETRIES;        ! Number of retries on send inits
  1117. ;      1340        DELAY = INIT_DELAY;
  1118. ;      1341        DUPLEX = DP_FULL;                ! Use full duplex
  1119. ;      1342        DEBUG_FLAG = FALSE;
  1120. ;      1343        WARN_FLAG = FALSE;
  1121. ;      1344        ECHO_FLAG = FALSE;
  1122. ;      1345        BLK_CHK_TYPE = CHK_1CHAR;            ! Start using single char checksum
  1123. ;      1346        CHKTYPE = MY_CHKTYPE;            ! Desired block check type
  1124. ;      1347        INI_CHK_TYPE = .CHKTYPE;            ! Same as default for now
  1125. ;      1348        DEV_PARITY_FLAG = FALSE;            ! We generate parity
  1126. ;      1349        PARITY_TYPE = PR_NONE;            ! No parity
  1127. ;      1350        ABT_FLAG = TRUE;                ! Discard incomplete files
  1128. ;      1351        FILE_OPEN_FLAG = FALSE;
  1129. ;      1352        IBM_FLAG = FALSE;                ! Not talking to an IBM
  1130. ;      1353        IBM_CHAR = CHR_DC1;                ! XON is IBM turnaround character
  1131. ;      1354        TY_FIL = TRUE;                ! Default to typing files
  1132. ;      1355        TY_PKT = FALSE;                ! But not packet numbers
  1133. ;      1356        FIL_NORMAL_FORM = FNM_NORMAL;        ! Default to normal form names
  1134. ;      1357        GET_CHR_ROUTINE = GET_FILE;            ![025] Initialize the get-a-char routine
  1135. ;      1358        PUT_CHR_ROUTINE = PUT_FILE;            ![025] And the put-a-char
  1136. ;      1359        END;                    ! End of MSG_INIT
  1137.     .NLIST
  1138.     .LIST    BIN,LOC
  1139.     .LIST
  1140.  
  1141.     .TITLE    KERMSG KERMSG - Kermit message processing
  1142.     .IDENT    /2.0.03/
  1143.  
  1144.  
  1145.     .PSECT    $OWN$,  D  
  1146. ; RECV.8QUOTE.CHR
  1147. U.62:    .BLKW    1
  1148. ; REPT.CHR
  1149. U.63:    .BLKW    1
  1150. ; SEND.PKT.SIZE
  1151. U.64:    .BLKW    1
  1152. ; SEND.NPAD
  1153. U.65:    .BLKW    1
  1154. ; SEND.PADCHAR
  1155. U.66:    .BLKW    1
  1156. ; SEND.EOL
  1157. U.67:    .BLKW    1
  1158. ; SEND.QUOTE.CHR
  1159. U.68:    .BLKW    1
  1160. ; SEND.8QUOTE.CHR
  1161. U.69:    .BLKW    1
  1162. ; INI.CHK.TYPE
  1163. U.70:    .BLKW    1
  1164. ; BLK.CHK.TYPE
  1165. U.71:    .BLKW    1
  1166. ; FLAG.8QUOTE
  1167. U.72:    .BLKW    1
  1168. ; FLAG.REPEAT
  1169. U.73:    .BLKW    1
  1170. ; STATE
  1171. U.74:    .BLKW    1
  1172. ; SIZE
  1173. U.75:    .BLKW    1
  1174. ; OLD.RETRIES
  1175. U.76:    .BLKW    1
  1176. ; NUM.RETRIES
  1177. U.77:    .BLKW    1
  1178. ; MSG.NUMBER
  1179. U.78:    .BLKW    1
  1180. ; REC.SEQ
  1181. U.79:    .BLKW    1
  1182. ; REC.LENGTH
  1183. U.80:    .BLKW    1
  1184. ; REC.TYPE
  1185. U.81:    .BLKW    1
  1186. ; REC.MSG
  1187. U.82:    .BLKW    60
  1188. ; SND.MSG
  1189. U.83:    .BLKW    60
  1190. ; FILE.OPEN.FLAG
  1191. U.84:    .BLKW    1
  1192. ; FILE.CHARS
  1193. U.85:    .BLKW    1
  1194. ; TEXT.HEAD.FLAG
  1195. U.86:    .BLKW    1
  1196. ; NO.FILE.NEEDED
  1197. U.87:    .BLKW    1
  1198. ; INIT.PKT.SENT
  1199. U.88:    .BLKW    1
  1200. ; GEN.TYPE
  1201. U.89:    .BLKW    1
  1202. ; GEN.SUBTYPE
  1203. U.90:    .BLKW    1
  1204. ; GET.CHR.ROUTINE
  1205. U.91:    .BLKW    1
  1206. ; PUT.CHR.ROUTINE
  1207. U.92:    .BLKW    1
  1208.  
  1209.  
  1210.     .GLOBL    RCV.PKT.SIZE, RCV.NPAD, RCV.PADCHAR
  1211.     .GLOBL    RCV.TIMEOUT, RCV.EOL, RCV.QUOTE.CHR
  1212.     .GLOBL    RCV.SOH, RCV.8QUOTE.CHR, SET.REPT.CHR
  1213.     .GLOBL    SND.PKT.SIZE, SND.NPAD, SND.PADCHAR
  1214.     .GLOBL    SND.TIMEOUT, SND.EOL, SND.QUOTE.CHR
  1215.     .GLOBL    SND.SOH, SEND.TIMEOUT, SND.TOTAL.CHARS
  1216.     .GLOBL    RCV.TOTAL.CHARS, SND.DATA.CHARS
  1217.     .GLOBL    RCV.DATA.CHARS, SND.NAKS, RCV.NAKS
  1218.     .GLOBL    SND.COUNT, RCV.COUNT, SMSG.COUNT
  1219.     .GLOBL    RMSG.COUNT, SMSG.TOTAL.CHARS, RMSG.TOTAL.CHARS
  1220.     .GLOBL    SMSG.DATA.CHARS, RMSG.DATA.CHARS
  1221.     .GLOBL    SMSG.NAKS, RMSG.NAKS, XFR.TIME
  1222.     .GLOBL    TOTAL.TIME, LAST.ERROR, FILE.NAME
  1223.     .GLOBL    FILE.SIZE, SI.RETRIES, PKT.RETRIES
  1224.     .GLOBL    DELAY, DUPLEX, PARITY.TYPE, DEV.PARITY.FLAG
  1225.     .GLOBL    CHKTYPE, ABT.FLAG, DEBUG.FLAG
  1226.     .GLOBL    WARN.FLAG, IBM.FLAG, IBM.CHAR
  1227.     .GLOBL    ECHO.FLAG, CONNECT.FLAG, ABT.CUR.FILE
  1228.     .GLOBL    ABT.ALL.FILE, TYP.STS.FLAG, TY.FIL
  1229.     .GLOBL    TY.PKT, FIL.NORMAL.FORM, GEN.1DATA
  1230.     .GLOBL    GEN.1SIZE, GEN.2DATA, GEN.2SIZE
  1231.     .GLOBL    GEN.3DATA, GEN.3SIZE, SEND, IBM.WAIT
  1232.     .GLOBL    RECEIVE, TERM.DUMP, DBG.DUMP, TT.SET.OUTPUT
  1233.     .GLOBL    TT.CHAR, TT.CRLF, TT.NUMBER, TT.TEXT
  1234.     .GLOBL    TT.OUTPUT, CRCCLC, XFR.STATUS
  1235.     .GLOBL    KRM.ERROR, SY.LOGOUT, SY.GENERIC
  1236.     .GLOBL    SY.TIME, SY.DISMISS, FILE.OPEN
  1237.     .GLOBL    FILE.CLOSE, NEXT.FILE, GET.FILE
  1238.     .GLOBL    PUT.FILE
  1239.  
  1240.  
  1241. FNM.NORMAL==        1
  1242. FNM.FULL==        2
  1243. FNM.UNTRAN==        4
  1244. PR.MIN==        0
  1245. PR.NONE==        0
  1246. PR.MARK==        1
  1247. PR.EVEN==        2
  1248. PR.ODD==        3
  1249. PR.SPACE==        4
  1250. PR.MAX==        4
  1251. GC.MIN==        1
  1252. GC.EXIT==        1
  1253. GC.DIRECTORY==        2
  1254. GC.DISK.USAGE==     3
  1255. GC.DELETE==        4
  1256. GC.TYPE==        5
  1257. GC.HELP==        6
  1258. GC.LOGOUT==        7
  1259. GC.LGN==        10
  1260. GC.CONNECT==        11
  1261. GC.RENAME==        12
  1262. GC.COPY==        13
  1263. GC.WHO==        14
  1264. GC.SEND.MSG==        15
  1265. GC.STATUS==        16
  1266. GC.COMMAND==        17
  1267. GC.MAX==        17
  1268. DP.FULL==        0
  1269. DP.HALF==        1
  1270. CHK.1CHAR==        61
  1271. CHK.2CHAR==        62
  1272. CHK.CRC==        63
  1273. MAX.MSG==        140
  1274. ; KER.NORMAL
  1275. U.36=            1
  1276. ; KER.INTERNALERR
  1277. U.37=            12
  1278. ; KER.CMDERR
  1279. U.38=            22
  1280. ; KER.ILLEOL
  1281. U.39=            32
  1282. ; KER.ILLPKTLEN
  1283. U.40=            42
  1284. ; KER.ILLPADCHR
  1285. U.41=            52
  1286. ; KER.ILLNPAD
  1287. U.42=            62
  1288. ; KER.LINTOOLNG
  1289. U.43=            72
  1290. ; KER.EOF
  1291. U.44=            101
  1292. ; KER.RMS32
  1293. U.45=            112
  1294. ; KER.NOMORFILES
  1295. U.46=            121
  1296. ; KER.ILLFILTYP
  1297. U.47=            132
  1298. ; KER.REC.TOO.BIG
  1299. U.48=            142
  1300. ; KER.ERRMSG
  1301. U.49=            152
  1302. ; KER.CHKSUMERR
  1303. U.50=            162
  1304. ; KER.SNDERR
  1305. U.51=            172
  1306. ; KER.RETRIES
  1307. U.52=            202
  1308. ; KER.EXIT
  1309. U.53=            211
  1310. ; KER.UNIMPLGEN
  1311. U.54=            222
  1312. ; KER.UNISRV
  1313. U.55=            232
  1314. ; KER.PROTOERR
  1315. U.56=            242
  1316. ; KER.LINTERM
  1317. U.57=            252
  1318. ; KER.TIMEOUT
  1319. U.58=            264
  1320. ; KER.ABORTED
  1321. U.59=            272
  1322. ; KER.RECERR
  1323. U.60=            302
  1324. ; KER.ZEROLENMSG
  1325. U.61=            312
  1326.  
  1327.  
  1328.     .SBTTL    MSG.INIT MSG_INIT
  1329.     .PSECT    $CODE$,  RO 
  1330.  
  1331.     .NLIST
  1332.     .ENABL    LSB
  1333.     .LIST
  1334. MSG.INIT::
  1335.     MOV    #120,RCV.PKT.SIZE        ;                    1316
  1336.     CLR    RCV.NPAD            ;                    1317
  1337.     CLR    RCV.PADCHAR            ;                    1318
  1338.     MOV    #17,RCV.TIMEOUT            ;                    1319
  1339.     MOV    #15,RCV.EOL            ;                    1320
  1340.     MOV    #43,RCV.QUOTE.CHR        ;                    1321
  1341.     MOV    #1,RCV.SOH            ;                    1322
  1342.     MOV    #46,RCV.8QUOTE.CHR        ;                    1323
  1343.     MOV    #176,SET.REPT.CHR        ;                    1324
  1344.     MOV    #-120,SND.PKT.SIZE        ;                    1328
  1345.     CLR    SND.NPAD            ;                    1329
  1346.     CLR    SND.PADCHAR            ;                    1330
  1347.     MOV    #-17,SND.TIMEOUT        ;                    1331
  1348.     MOV    #-15,SND.EOL            ;                    1332
  1349.     MOV    #-43,SND.QUOTE.CHR        ;                    1333
  1350.     MOV    #1,SND.SOH            ;                    1334
  1351.     MOV    #20,PKT.RETRIES            ;                    1338
  1352.     MOV    #5,SI.RETRIES            ;                    1339
  1353.     MOV    #5,DELAY            ;                    1340
  1354.     CLR    DUPLEX                ;                    1341
  1355.     CLR    DEBUG.FLAG            ;                    1342
  1356.     CLR    WARN.FLAG            ;                    1343
  1357.     CLR    ECHO.FLAG            ;                    1344
  1358.     MOV    #61,U.71            ;                    1345
  1359.     MOV    #61,CHKTYPE            ;                    1346
  1360.     MOV    #61,U.70            ;                    1347
  1361.     CLR    DEV.PARITY.FLAG            ;                    1348
  1362.     CLR    PARITY.TYPE            ;                    1349
  1363.     MOV    #1,ABT.FLAG            ;                    1350
  1364.     CLR    U.84                ;                    1351
  1365.     CLR    IBM.FLAG            ;                    1352
  1366.     MOV    #21,IBM.CHAR            ;                    1353
  1367.     MOV    #1,TY.FIL            ;                    1354
  1368.     CLR    TY.PKT                ;                    1355
  1369.     MOV    #1,FIL.NORMAL.FORM        ;                    1356
  1370.     MOV    #GET.FILE,U.91            ;                    1357
  1371.     MOV    #PUT.FILE,U.92            ;                    1358
  1372.     RTS    PC                ;                    1272
  1373. ; Routine Size:  99 words,    Routine Base:  $CODE$ + 0000
  1374. ; Maximum stack depth per invocation:  0 words
  1375.     .NLIST
  1376.     .DSABL    LSB
  1377.     .NLIST    BIN,LOC
  1378.     .LIST
  1379.  
  1380.  
  1381. ;      1360    
  1382. ;      1361    %SBTTL 'SND_ERROR'
  1383. ;      1362    
  1384. ;      1363    GLOBAL ROUTINE SND_ERROR (COUNT, ADDRESS) : NOVALUE =
  1385. ;      1364    
  1386. ;      1365    !++
  1387. ;      1366    ! FUNCTIONAL DESCRIPTION:
  1388. ;      1367    !
  1389. ;      1368    !    This routine will send an error packet to the remote KERMIT.  It
  1390. ;      1369    !    is called with the count of characters and the address of the text.
  1391. ;      1370    !
  1392. ;      1371    ! CALLING SEQUENCE:
  1393. ;      1372    !
  1394. ;      1373    !    SND_ERROR(COUNT, %ASCII 'Error text');
  1395. ;      1374    !
  1396. ;      1375    ! INPUT PARAMETERS:
  1397. ;      1376    !
  1398. ;      1377    !    None.
  1399. ;      1378    !
  1400. ;      1379    ! IMPLICIT INPUTS:
  1401. ;      1380    !
  1402. ;      1381    !    None.
  1403. ;      1382    !
  1404. ;      1383    ! OUTPUT PARAMETERS:
  1405. ;      1384    !
  1406. ;      1385    !    None.
  1407. ;      1386    !
  1408. ;      1387    ! IMPLICIT OUTPUTS:
  1409. ;      1388    !
  1410. ;      1389    !    None.
  1411. ;      1390    !
  1412. ;      1391    ! COMPLETION CODES:
  1413. ;      1392    !
  1414. ;      1393    !    None.
  1415. ;      1394    !
  1416. ;      1395    ! SIDE EFFECTS:
  1417. ;      1396    !
  1418. ;      1397    !
  1419. ;      1398    !--
  1420. ;      1399    
  1421. ;      1400        BEGIN
  1422. ;      1401    !
  1423. ;      1402    ! Pack the message into the buffer
  1424. ;      1403    !
  1425. ;      1404        SET_STRING (CH$PTR (.ADDRESS), .COUNT, TRUE);
  1426. ;      1405        BFR_FILL (TRUE);
  1427. ;      1406        SET_STRING (0, 0, FALSE);
  1428. ;      1407    !
  1429. ;      1408    ! Save the last error message also
  1430. ;      1409    !
  1431. ;      1410    
  1432. ;      1411        IF .COUNT GTR MAX_MSG THEN COUNT = MAX_MSG;
  1433. ;      1412    
  1434. ;      1413        CH$COPY (.COUNT, CH$PTR (.ADDRESS), 0, MAX_MSG + 1, CH$PTR (LAST_ERROR));
  1435. ;      1414    
  1436. ;      1415        IF NOT SEND_PACKET (MSG_ERROR, .SIZE, .MSG_NUMBER) THEN RETURN KER_ABORTED;
  1437. ;      1416    
  1438. ;      1417        END;                    ! End of SND_ERROR
  1439.     .NLIST
  1440.     .LIST    BIN,LOC
  1441.     .LIST
  1442.  
  1443.     .SBTTL    SND.ERROR SND_ERROR
  1444.     .NLIST
  1445.     .ENABL    LSB
  1446.     .LIST
  1447. SND.ERROR::
  1448.     MOV    2(SP),-(SP)            ; ADDRESS,*                1404
  1449.     MOV    6(SP),-(SP)            ; COUNT,*
  1450.     MOV    #1,-(SP)
  1451.     JSR    PC,U.29
  1452.     MOV    #1,(SP)                ;                    1405
  1453.     JSR    PC,U.28
  1454.     CLR    (SP)                ;                    1406
  1455.     CLR    -(SP)
  1456.     CLR    -(SP)
  1457.     JSR    PC,U.29
  1458.     CMP    16(SP),#140            ; COUNT,*                1411
  1459.     BLE    1$
  1460.     MOV    #140,16(SP)            ; *,COUNT
  1461. 1$:    MOV    16(SP),(SP)            ; COUNT,*                1413
  1462.     MOV    14(SP),-(SP)            ; ADDRESS,*
  1463.     CLR    -(SP)
  1464.     MOV    #141,-(SP)
  1465.     MOV    #LAST.ERROR,-(SP)
  1466.     MOV    #-5,-(SP)
  1467.     JSR    PC,BL$CPY
  1468.     MOV    #105,(SP)            ;                    1415
  1469.     MOV    U.75,-(SP)
  1470.     MOV    U.78,-(SP)
  1471.     JSR    PC,U.23
  1472.     ROR    R0
  1473.     ADD    #30,SP                ;                    1400
  1474.     RTS    PC                ;                    1363
  1475. ; Routine Size:  49 words,    Routine Base:  $CODE$ + 0306
  1476. ; Maximum stack depth per invocation:  13 words
  1477.     .NLIST
  1478.     .DSABL    LSB
  1479.     .NLIST    BIN,LOC
  1480.     .LIST
  1481.  
  1482.  
  1483. ;      1418    
  1484. ;      1419    %SBTTL 'SERVER - Server mode'
  1485. ;      1420    
  1486. ;      1421    GLOBAL ROUTINE SERVER =
  1487. ;      1422    
  1488. ;      1423    !++
  1489. ;      1424    ! FUNCTIONAL DESCRIPTION:
  1490. ;      1425    !
  1491. ;      1426    !    This routine will handle the server function in the v2.0 protocol
  1492. ;      1427    !    for KERMIT.  This routine by it's nature will call various operating
  1493. ;      1428    !    system routines to do things like logging off the system.
  1494. ;      1429    !
  1495. ;      1430    ! CALLING SEQUENCE:
  1496. ;      1431    !
  1497. ;      1432    !    EXIT_FLAG = SERVER();
  1498. ;      1433    !
  1499. ;      1434    ! INPUT PARAMETERS:
  1500. ;      1435    !
  1501. ;      1436    !    None.
  1502. ;      1437    !
  1503. ;      1438    ! IMPLICIT INPUTS:
  1504. ;      1439    !
  1505. ;      1440    !    None.
  1506. ;      1441    !
  1507. ;      1442    ! OUTPUT PARAMETERS:
  1508. ;      1443    !
  1509. ;      1444    !    None.
  1510. ;      1445    !
  1511. ;      1446    ! IMPLICIT OUTPUTS:
  1512. ;      1447    !
  1513. ;      1448    !    None.
  1514. ;      1449    !
  1515. ;      1450    ! COMPLETION CODES:
  1516. ;      1451    !
  1517. ;      1452    !    None.
  1518. ;      1453    !
  1519. ;      1454    ! SIDE EFFECTS:
  1520. ;      1455    !
  1521. ;      1456    !    None.
  1522. ;      1457    !
  1523. ;      1458    !--
  1524. ;      1459    
  1525. ;      1460        BEGIN
  1526. ;      1461    
  1527. ;      1462        LOCAL
  1528. ;      1463        STATUS;                    ! Status returned by various routines
  1529. ;      1464    
  1530. ;      1465        DO
  1531. ;      1466        BEGIN
  1532. ;      1467        INIT_XFR ();
  1533. ;      1468        XFR_STATUS (%C'T', %C'I');        ! Now idle
  1534. ;      1469        STATUS = DO_TRANSACTION (STATE_ID);
  1535. ;      1470        END
  1536. ;      1471        UNTIL .STATUS EQL KER_EXIT OR .STATUS EQL KER_ABORTED;
  1537. ;      1472    
  1538. ;      1473        RETURN .STATUS;
  1539. ;      1474        END;                    ! End of GLOBAL ROUTINE SERVER
  1540.     .NLIST
  1541.     .LIST    BIN,LOC
  1542.     .LIST
  1543.  
  1544.     .SBTTL    SERVER SERVER - Server mode
  1545.     .NLIST
  1546.     .ENABL    LSB
  1547.     .LIST
  1548. SERVER::MOV    R1,-(SP)            ;                    1421
  1549. 1$:    JSR    PC,U.31                ;                    1467
  1550.     MOV    #124,-(SP)            ;                    1468
  1551.     MOV    #111,-(SP)
  1552.     JSR    PC,XFR.STATUS
  1553.     MOV    #16,(SP)            ;                    1469
  1554.     JSR    PC,U.1
  1555.     MOV    R0,R1                ; *,STATUS
  1556.     CMP    (SP)+,(SP)+            ;                    1466
  1557.     CMP    R1,#211                ; STATUS,*                1471
  1558.     BEQ    2$
  1559.     CMP    R1,#272                ; STATUS,*
  1560.     BNE    1$
  1561. 2$:    MOV    R1,R0                ; STATUS,*                1460
  1562.     MOV    (SP)+,R1            ;                    1421
  1563.     RTS    PC
  1564. ; Routine Size:  24 words,    Routine Base:  $CODE$ + 0450
  1565. ; Maximum stack depth per invocation:  4 words
  1566.     .NLIST
  1567.     .DSABL    LSB
  1568.     .NLIST    BIN,LOC
  1569.     .LIST
  1570.  
  1571.  
  1572. ;      1475    
  1573. ;      1476    %SBTTL 'SEND_SWITCH'
  1574. ;      1477    
  1575. ;      1478    GLOBAL ROUTINE SEND_SWITCH =
  1576. ;      1479    
  1577. ;      1480    !++
  1578. ;      1481    ! FUNCTIONAL DESCRIPTION:
  1579. ;      1482    !
  1580. ;      1483    !    This routine is the state table switcher for sending files.  It
  1581. ;      1484    !    loops until either it is finished or an error is encountered.  The
  1582. ;      1485    !    routines called by SEND_SWITCH are responsible for changing the state.
  1583. ;      1486    !
  1584. ;      1487    ! CALLING SEQUENCE:
  1585. ;      1488    !
  1586. ;      1489    !    SEND_SWITCH();
  1587. ;      1490    !
  1588. ;      1491    ! INPUT PARAMETERS:
  1589. ;      1492    !
  1590. ;      1493    !    None.
  1591. ;      1494    !
  1592. ;      1495    ! IMPLICIT INPUTS:
  1593. ;      1496    !
  1594. ;      1497    !    None.
  1595. ;      1498    !
  1596. ;      1499    ! OUTPUT PARAMETERS:
  1597. ;      1500    !
  1598. ;      1501    !    Returns:
  1599. ;      1502    !        TRUE - File sent correctly.
  1600. ;      1503    !        FALSE - Aborted sending the file.
  1601. ;      1504    !
  1602. ;      1505    ! IMPLICIT OUTPUTS:
  1603. ;      1506    !
  1604. ;      1507    !    None.
  1605. ;      1508    !
  1606. ;      1509    ! COMPLETION CODES:
  1607. ;      1510    !
  1608. ;      1511    !    None.
  1609. ;      1512    !
  1610. ;      1513    ! SIDE EFFECTS:
  1611. ;      1514    !
  1612. ;      1515    !    None.
  1613. ;      1516    !
  1614. ;      1517    !--
  1615. ;      1518    
  1616. ;      1519        BEGIN
  1617. ;      1520    
  1618. ;      1521        LOCAL
  1619. ;      1522        STATUS;                    ! Status result
  1620. ;      1523    
  1621. ;      1524        IF .CONNECT_FLAG THEN SY_DISMISS (.DELAY);    ! Sleep if the user wanted us to
  1622. ;      1525    
  1623. ;      1526        INIT_XFR ();                ! Initialize for this transfer
  1624. ;      1527        TEXT_HEAD_FLAG = FALSE;            ! Set text flag correctly
  1625. ;      1528        XFR_STATUS (%C'I', %C'S');            ! Start of file send
  1626. ;      1529        STATUS = DO_TRANSACTION (STATE_S);        ! Call routine to do real work
  1627. ;      1530        XFR_STATUS (%C'T', %C'S');            ! Done with send
  1628. ;      1531        RETURN .STATUS;                ! Return the result
  1629. ;      1532        END;
  1630.     .NLIST
  1631.     .LIST    BIN,LOC
  1632.     .LIST
  1633.  
  1634.     .SBTTL    SEND.SWITCH SEND_SWITCH
  1635.     .NLIST
  1636.     .ENABL    LSB
  1637.     .LIST
  1638. SEND.SWITCH::
  1639.     MOV    R1,-(SP)            ;                    1478
  1640.     BIT    #1,CONNECT.FLAG            ;                    1524
  1641.     BEQ    1$
  1642.     MOV    DELAY,-(SP)
  1643.     JSR    PC,SY.DISMISS
  1644.     TST    (SP)+
  1645. 1$:    JSR    PC,U.31                ;                    1526
  1646.     CLR    U.86                ;                    1527
  1647.     MOV    #111,-(SP)            ;                    1528
  1648.     MOV    #123,-(SP)
  1649.     JSR    PC,XFR.STATUS
  1650.     MOV    #1,(SP)                ;                    1529
  1651.     JSR    PC,U.1
  1652.     MOV    R0,R1                ; *,STATUS
  1653.     MOV    #124,(SP)            ;                    1530
  1654.     MOV    #123,-(SP)
  1655.     JSR    PC,XFR.STATUS
  1656.     ADD    #6,SP                ;                    1478
  1657.     MOV    R1,R0                ; STATUS,*                1519
  1658.     MOV    (SP)+,R1            ;                    1478
  1659.     RTS    PC
  1660. ; Routine Size:  36 words,    Routine Base:  $CODE$ + 0530
  1661. ; Maximum stack depth per invocation:  5 words
  1662.     .NLIST
  1663.     .DSABL    LSB
  1664.     .NLIST    BIN,LOC
  1665.     .LIST
  1666.  
  1667.  
  1668. ;      1533    
  1669. ;      1534    %SBTTL 'REC_SWITCH'
  1670. ;      1535    
  1671. ;      1536    GLOBAL ROUTINE REC_SWITCH =
  1672. ;      1537    
  1673. ;      1538    !++
  1674. ;      1539    ! FUNCTIONAL DESCRIPTION:
  1675. ;      1540    !
  1676. ;      1541    !    This routine will cause file(s) to be received by the remote
  1677. ;      1542    !    KERMIT.  This routine contains the main loop for the sending of the
  1678. ;      1543    !    data.
  1679. ;      1544    !
  1680. ;      1545    ! CALLING SEQUENCE:
  1681. ;      1546    !
  1682. ;      1547    !    REC_SWITCH();
  1683. ;      1548    !
  1684. ;      1549    ! INPUT PARAMETERS:
  1685. ;      1550    !
  1686. ;      1551    !    None.
  1687. ;      1552    !
  1688. ;      1553    ! IMPLICIT INPUTS:
  1689. ;      1554    !
  1690. ;      1555    !    FILE_DESC - Descriptor describing the file to be received by
  1691. ;      1556    !        the remote KERMIT.
  1692. ;      1557    !
  1693. ;      1558    ! OUTPUT PARAMETERS:
  1694. ;      1559    !
  1695. ;      1560    !    None.
  1696. ;      1561    !
  1697. ;      1562    ! IMPLICIT OUTPUTS:
  1698. ;      1563    !
  1699. ;      1564    !    None.
  1700. ;      1565    !
  1701. ;      1566    ! COMPLETION CODES:
  1702. ;      1567    !
  1703. ;      1568    !    True - File received correctly.
  1704. ;      1569    !    FALSE - File transfer aborted.
  1705. ;      1570    !
  1706. ;      1571    ! SIDE EFFECTS:
  1707. ;      1572    !
  1708. ;      1573    !    None.
  1709. ;      1574    !
  1710. ;      1575    !--
  1711. ;      1576    
  1712. ;      1577        BEGIN
  1713. ;      1578    
  1714. ;      1579        LOCAL
  1715. ;      1580        INIT_STATE,                ! State to start up DO_TRANSACTION in
  1716. ;      1581        STATUS;                    ! Status returned by various routines
  1717. ;      1582    
  1718. ;      1583        INIT_STATE = STATE_R;            ! Initialize the state
  1719. ;      1584        MSG_NUMBER = 0;
  1720. ;      1585        INIT_XFR ();                ! Initialize the per transfer info
  1721. ;      1586    !
  1722. ;      1587    ! Determine if they said REC <file-spec>
  1723. ;      1588    !    Send MSG_RCV_INIT and then receive the file
  1724. ;      1589    !
  1725. ;      1590    
  1726. ;      1591        IF .FILE_SIZE GTR 0
  1727. ;      1592        THEN
  1728. ;      1593        BEGIN
  1729. ;      1594        GEN_TYPE = MSG_RCV_INIT;        ! Use receive-init message
  1730. ;      1595        CH$MOVE (.FILE_SIZE, CH$PTR (FILE_NAME), CH$PTR (GEN_1DATA));
  1731. ;      1596        GEN_1SIZE = .FILE_SIZE;            ! Save the length
  1732. ;      1597        INIT_STATE = STATE_SI;            ! Start out with server init
  1733. ;      1598        END;
  1734. ;      1599    
  1735. ;      1600    !
  1736. ;      1601    ! Now receive the file normally
  1737. ;      1602    !
  1738. ;      1603        XFR_STATUS (%C'I', %C'R');            ! Start of a file receive
  1739. ;      1604        STATUS = DO_TRANSACTION (.INIT_STATE);
  1740. ;      1605        XFR_STATUS (%C'T', %C'R');            ! End of file receive
  1741. ;      1606        RETURN .STATUS;                ! Return the result
  1742. ;      1607        END;                    ! End of REC_SWITCH
  1743.     .NLIST
  1744.     .LIST    BIN,LOC
  1745.     .LIST
  1746.  
  1747.     .SBTTL    REC.SWITCH REC_SWITCH
  1748.     .NLIST
  1749.     .ENABL    LSB
  1750.     .LIST
  1751. REC.SWITCH::
  1752.     MOV    R1,-(SP)            ;                    1536
  1753.     MOV    #6,R1                ; *,INIT.STATE                1583
  1754.     CLR    U.78                ;                    1584
  1755.     JSR    PC,U.31                ;                    1585
  1756.     MOV    FILE.SIZE,R0            ;                    1591
  1757.     BLE    1$
  1758.     MOV    #122,U.89            ;                    1594
  1759.     MOV    R0,-(SP)            ;                    1595
  1760.     MOV    #FILE.NAME,-(SP)
  1761.     MOV    #GEN.1DATA,-(SP)
  1762.     JSR    PC,BL$MOV
  1763.     MOV    FILE.SIZE,GEN.1SIZE        ;                    1596
  1764.     MOV    #15,R1                ; *,INIT.STATE                1597
  1765.     ADD    #6,SP                ;                    1593
  1766. 1$:    MOV    #111,-(SP)            ;                    1603
  1767.     MOV    #122,-(SP)
  1768.     JSR    PC,XFR.STATUS
  1769.     MOV    R1,(SP)                ; INIT.STATE,*                1604
  1770.     JSR    PC,U.1
  1771.     MOV    R0,R1                ; *,STATUS
  1772.     MOV    #124,(SP)            ;                    1605
  1773.     MOV    #122,-(SP)
  1774.     JSR    PC,XFR.STATUS
  1775.     ADD    #6,SP                ;                    1536
  1776.     MOV    R1,R0                ; STATUS,*                1577
  1777.     MOV    (SP)+,R1            ;                    1536
  1778.     RTS    PC
  1779. ; Routine Size:  48 words,    Routine Base:  $CODE$ + 0640
  1780. ; Maximum stack depth per invocation:  5 words
  1781.     .NLIST
  1782.     .DSABL    LSB
  1783.     .NLIST    BIN,LOC
  1784.     .LIST
  1785.  
  1786.  
  1787. ;      1608    
  1788. ;      1609    %SBTTL 'Server -- DO_GENERIC - Execute a generic command'
  1789. ;      1610    
  1790. ;      1611    GLOBAL ROUTINE DO_GENERIC (TYPE) =
  1791. ;      1612    
  1792. ;      1613    !++
  1793. ;      1614    ! FUNCTIONAL DESCRIPTION:
  1794. ;      1615    !
  1795. ;      1616    !    This routine will send a generic command to the remote Kermit.
  1796. ;      1617    !    it will do all the processing required for the generic command
  1797. ;      1618    !    that was executed.  It will return to the caller after the
  1798. ;      1619    !    command has be executed.
  1799. ;      1620    !
  1800. ;      1621    ! CALLING SEQUENCE:
  1801. ;      1622    !
  1802. ;      1623    !    STATUS = DO_GENERIC (Command-type);
  1803. ;      1624    !
  1804. ;      1625    ! INPUT PARAMETERS:
  1805. ;      1626    !
  1806. ;      1627    !    Command-type -- Command type to be executed.
  1807. ;      1628    !
  1808. ;      1629    ! IMPLICIT INPUTS:
  1809. ;      1630    !
  1810. ;      1631    !    None.
  1811. ;      1632    !
  1812. ;      1633    ! OUTPUT PARAMETERS:
  1813. ;      1634    !
  1814. ;      1635    !    None.
  1815. ;      1636    !
  1816. ;      1637    ! IMPLICIT OUTPUTS:
  1817. ;      1638    !
  1818. ;      1639    !    None.
  1819. ;      1640    !
  1820. ;      1641    ! COMPLETION CODES:
  1821. ;      1642    !
  1822. ;      1643    !    None.
  1823. ;      1644    !
  1824. ;      1645    ! SIDE EFFECTS:
  1825. ;      1646    !
  1826. ;      1647    !    None.
  1827. ;      1648    !
  1828. ;      1649    !--
  1829. ;      1650    
  1830. ;      1651        BEGIN
  1831. ;      1652    
  1832. ;      1653        LOCAL
  1833. ;      1654        INIT_STATE;                ! Initial state for FSM
  1834. ;      1655    
  1835. ;      1656    !
  1836. ;      1657    ! Set up the per transfer items
  1837. ;      1658    !
  1838. ;      1659        INIT_XFR ();
  1839. ;      1660        NUM_RETRIES = 0;
  1840. ;      1661        MSG_NUMBER = 0;
  1841. ;      1662    !
  1842. ;      1663    ! These are all generic commands
  1843. ;      1664    !
  1844. ;      1665        GEN_TYPE = MSG_KERMIT;
  1845. ;      1666    !
  1846. ;      1667    ! Assume we will not need server init
  1847. ;      1668    !
  1848. ;      1669        INIT_STATE = STATE_SG;
  1849. ;      1670    
  1850. ;      1671        CASE .TYPE FROM GC_MIN TO GC_MAX OF
  1851. ;      1672        SET
  1852. ;      1673    
  1853. ;      1674        [GC_EXIT] :
  1854. ;      1675            GEN_SUBTYPE = MSG_GEN_EXIT;
  1855. ;      1676    
  1856. ;      1677        [GC_LOGOUT] :
  1857. ;      1678            GEN_SUBTYPE = MSG_GEN_LOGOUT;
  1858. ;      1679    
  1859. ;      1680        [GC_DIRECTORY] :
  1860. ;      1681            BEGIN
  1861. ;      1682            INIT_STATE = STATE_SI;        ! We will need server-init
  1862. ;      1683            GEN_SUBTYPE = MSG_GEN_DIRECTORY;
  1863. ;      1684            END;
  1864. ;      1685    
  1865. ;      1686        [GC_DISK_USAGE] :
  1866. ;      1687            BEGIN
  1867. ;      1688            INIT_STATE = STATE_SI;        ! We will need server-init
  1868. ;      1689            GEN_SUBTYPE = MSG_GEN_DISK_USAGE;
  1869. ;      1690            END;
  1870. ;      1691    
  1871. ;      1692        [GC_DELETE] :
  1872. ;      1693            GEN_SUBTYPE = MSG_GEN_DELETE;
  1873. ;      1694    
  1874. ;      1695        [GC_TYPE] :
  1875. ;      1696            BEGIN
  1876. ;      1697            INIT_STATE = STATE_SI;        ! We will need server-init
  1877. ;      1698            GEN_SUBTYPE = MSG_GEN_TYPE;
  1878. ;      1699            END;
  1879. ;      1700    
  1880. ;      1701        [GC_HELP] :
  1881. ;      1702            BEGIN
  1882. ;      1703            INIT_STATE = STATE_SI;        ! We will need server-init
  1883. ;      1704            GEN_SUBTYPE = MSG_GEN_HELP;
  1884. ;      1705            END;
  1885. ;      1706    
  1886. ;      1707        [GC_LGN] :
  1887. ;      1708            GEN_SUBTYPE = MSG_GEN_LOGIN;    ! Login just gets ACK
  1888. ;      1709    
  1889. ;      1710        [GC_CONNECT] :
  1890. ;      1711            GEN_SUBTYPE = MSG_GEN_CONNECT;    ! CWD just gets ACK
  1891. ;      1712    
  1892. ;      1713        [GC_RENAME] :
  1893. ;      1714            GEN_SUBTYPE = MSG_GEN_RENAME;    ! Rename file just needs ACK
  1894. ;      1715    
  1895. ;      1716        [GC_COPY] :
  1896. ;      1717            GEN_SUBTYPE = MSG_GEN_COPY;        ! Copy file just needs ACK
  1897. ;      1718    
  1898. ;      1719        [GC_WHO] :
  1899. ;      1720            BEGIN
  1900. ;      1721            INIT_STATE = STATE_SI;        ! May get large response
  1901. ;      1722            GEN_SUBTYPE = MSG_GEN_WHO;
  1902. ;      1723            END;
  1903. ;      1724    
  1904. ;      1725        [GC_SEND_MSG] :
  1905. ;      1726            GEN_SUBTYPE = MSG_GEN_SEND;        ! Just need an ACK
  1906. ;      1727    
  1907. ;      1728        [GC_STATUS] :
  1908. ;      1729            BEGIN
  1909. ;      1730            INIT_STATE = STATE_SI;        ! May get large response
  1910. ;      1731            GEN_SUBTYPE = MSG_GEN_QUERY;
  1911. ;      1732            END;
  1912. ;      1733    
  1913. ;      1734        [GC_COMMAND] :
  1914. ;      1735            BEGIN
  1915. ;      1736            INIT_STATE = STATE_SI;        ! Large response likely
  1916. ;      1737            GEN_TYPE = MSG_COMMAND;        ! This is host command
  1917. ;      1738            END;
  1918. ;      1739    
  1919. ;      1740        [INRANGE, OUTRANGE] :
  1920. ;      1741            BEGIN
  1921. ;      1742            KRM_ERROR (KER_UNIMPLGEN);
  1922. ;      1743            RETURN STATE_A;
  1923. ;      1744            END;
  1924. ;      1745        TES;
  1925. ;      1746    
  1926. ;      1747        RETURN DO_TRANSACTION (.INIT_STATE);    ! Go do the command
  1927. ;      1748        END;                    ! End of DO_GENERIC
  1928.     .NLIST
  1929.     .LIST    BIN,LOC
  1930.     .LIST
  1931.  
  1932.     .SBTTL    DO.GENERIC Server -- DO_GENERIC - Execute a generic comman
  1933.     .NLIST
  1934.     .ENABL    LSB
  1935.     .LIST
  1936. DO.GENERIC::
  1937.     MOV    R1,-(SP)            ;                    1611
  1938.     JSR    PC,U.31                ;                    1659
  1939.     CLR    U.77                ;                    1660
  1940.     CLR    U.78                ;                    1661
  1941.     MOV    #107,U.89            ;                    1665
  1942.     MOV    #14,R1                ; *,INIT.STATE                1669
  1943.     MOV    4(SP),R0            ; TYPE,*                1671
  1944.     DEC    R0
  1945.     CMP    R0,#16
  1946.     BHI    2$
  1947.     ASL    R0
  1948.     ADD    P.AAA(R0),PC            ; Case dispatch
  1949. 2$:    MOV    #222,-(SP)            ;                    1742
  1950.     JSR    PC,KRM.ERROR
  1951.     TST    (SP)+                ;                    1671
  1952.     MOV    #12,R0                ;                    1741
  1953.     BR    19$
  1954. 3$:    MOV    #106,U.90            ;                    1675
  1955.     BR    18$                ;                    1671
  1956. 4$:    MOV    #114,U.90            ;                    1678
  1957.     BR    18$                ;                    1671
  1958. 5$:    MOV    #15,R1                ; *,INIT.STATE                1682
  1959.     MOV    #104,U.90            ;                    1683
  1960.     BR    18$                ;                    1671
  1961. 6$:    MOV    #15,R1                ; *,INIT.STATE                1688
  1962.     MOV    #125,U.90            ;                    1689
  1963.     BR    18$                ;                    1671
  1964. 7$:    MOV    #105,U.90            ;                    1693
  1965.     BR    18$                ;                    1671
  1966. 8$:    MOV    #15,R1                ; *,INIT.STATE                1697
  1967.     MOV    #124,U.90            ;                    1698
  1968.     BR    18$                ;                    1671
  1969. 9$:    MOV    #15,R1                ; *,INIT.STATE                1703
  1970.     MOV    #110,U.90            ;                    1704
  1971.     BR    18$                ;                    1671
  1972. 10$:    MOV    #111,U.90            ;                    1708
  1973.     BR    18$                ;                    1671
  1974. 11$:    MOV    #103,U.90            ;                    1711
  1975.     BR    18$                ;                    1671
  1976. 12$:    MOV    #122,U.90            ;                    1714
  1977.     BR    18$                ;                    1671
  1978. 13$:    MOV    #113,U.90            ;                    1717
  1979.     BR    18$                ;                    1671
  1980. 14$:    MOV    #15,R1                ; *,INIT.STATE                1721
  1981.     MOV    #127,U.90            ;                    1722
  1982.     BR    18$                ;                    1671
  1983. 15$:    MOV    #115,U.90            ;                    1726
  1984.     BR    18$                ;                    1671
  1985. 16$:    MOV    #15,R1                ; *,INIT.STATE                1730
  1986.     MOV    #121,U.90            ;                    1731
  1987.     BR    18$                ;                    1671
  1988. 17$:    MOV    #15,R1                ; *,INIT.STATE                1736
  1989.     MOV    #103,U.89            ;                    1737
  1990. 18$:    MOV    R1,-(SP)            ; INIT.STATE,*                1747
  1991.     JSR    PC,U.1
  1992.     TST    (SP)+                ;                    1611
  1993. 19$:    MOV    (SP)+,R1
  1994.     RTS    PC
  1995. ; Routine Size:  108 words,    Routine Base:  $CODE$ + 1000
  1996. ; Maximum stack depth per invocation:  3 words
  1997.  
  1998.  
  1999.     .PSECT    $PLIT$,  RO ,  D  
  2000.  
  2001. P.AAA:                        ; CASE Table for DO.GENERIC+0046    1671
  2002. 1$:    .WORD    20                ; [3$]
  2003.     .WORD    40                ; [5$]
  2004.     .WORD    54                ; [6$]
  2005.     .WORD    70                ; [7$]
  2006.     .WORD    100                ; [8$]
  2007.     .WORD    114                ; [9$]
  2008.     .WORD    30                ; [4$]
  2009.     .WORD    130                ; [10$]
  2010.     .WORD    140                ; [11$]
  2011.     .WORD    150                ; [12$]
  2012.     .WORD    160                ; [13$]
  2013.     .WORD    170                ; [14$]
  2014.     .WORD    204                ; [15$]
  2015.     .WORD    214                ; [16$]
  2016.     .WORD    230                ; [17$]
  2017.  
  2018.     .NLIST
  2019.     .DSABL    LSB
  2020.     .NLIST    BIN,LOC
  2021.     .LIST
  2022.  
  2023.  
  2024. ;      1749    
  2025. ;      1750    %SBTTL 'DO_TRANSACTION - Main loop for FSM'
  2026. ;      1751    ROUTINE DO_TRANSACTION (INIT_STATE) =
  2027. ;      1752    
  2028. ;      1753    !++
  2029. ;      1754    ! FUNCTIONAL DESCRIPTION:
  2030. ;      1755    !
  2031. ;      1756    !    This is the main routine for performing a Kermit transaction.
  2032. ;      1757    !    It is structured as a finite state machine with each state
  2033. ;      1758    !    determining the next based upon the packet which is received.
  2034. ;      1759    !    It is supplied with the initial state by the caller.
  2035. ;      1760    !
  2036. ;      1761    ! CALLING SEQUENCE:
  2037. ;      1762    !
  2038. ;      1763    !    Status = DO_TRANSACTION(.INIT_STATE);
  2039. ;      1764    !
  2040. ;      1765    ! INPUT PARAMETERS:
  2041. ;      1766    !
  2042. ;      1767    !    INIT_STATE - Initial state.
  2043. ;      1768    !
  2044. ;      1769    ! IMPLICIT INPUTS:
  2045. ;      1770    !
  2046. ;      1771    !    None.
  2047. ;      1772    !
  2048. ;      1773    ! OUTPUT PARAMETERS:
  2049. ;      1774    !
  2050. ;      1775    !    None.
  2051. ;      1776    !
  2052. ;      1777    ! IMPLICIT OUTPUTS:
  2053. ;      1778    !
  2054. ;      1779    !    None.
  2055. ;      1780    !
  2056. ;      1781    ! COMPLETION CODES:
  2057. ;      1782    !
  2058. ;      1783    !    None.
  2059. ;      1784    !
  2060. ;      1785    ! SIDE EFFECTS:
  2061. ;      1786    !
  2062. ;      1787    !    None.
  2063. ;      1788    !
  2064. ;      1789    !--
  2065. ;      1790    
  2066. ;      1791        BEGIN
  2067. ;      1792    
  2068. ;      1793        LOCAL
  2069. ;      1794        RETURN_VALUE;
  2070. ;      1795    
  2071. ;      1796        NUM_RETRIES = 0;                ! Initialize the number of retries
  2072. ;      1797        STATE = .INIT_STATE;            ! Initialize the state
  2073. ;      1798    
  2074. ;      1799        WHILE TRUE DO
  2075. ;      1800    
  2076. ;      1801        CASE .STATE FROM STATE_MIN TO STATE_MAX OF
  2077. ;      1802            SET
  2078. ;      1803    !
  2079. ;      1804    ! Send states
  2080. ;      1805    !
  2081. ;      1806    
  2082. ;      1807            [STATE_ID] :
  2083. ;      1808    !
  2084. ;      1809    ! Server while idle.  Set the timeout to twice the normal wait
  2085. ;      1810    ! and wait for something to show up
  2086. ;      1811    !
  2087. ;      1812            BEGIN
  2088. ;      1813    
  2089. ;      1814            LOCAL
  2090. ;      1815                SAVED_TIMEOUT;
  2091. ;      1816    
  2092. ;      1817            SAVED_TIMEOUT = .SEND_TIMEOUT;
  2093. ;      1818            SEND_TIMEOUT = .SEND_TIMEOUT*2;
  2094. ;      1819            STATE = REC_SERVER_IDLE ();
  2095. ;      1820            SEND_TIMEOUT = .SAVED_TIMEOUT;
  2096. ;      1821            END;
  2097. ;      1822    
  2098. ;      1823            [STATE_II] :
  2099. ;      1824    !
  2100. ;      1825    ! Here while server idle after having received a server-init packet
  2101. ;      1826    !
  2102. ;      1827            STATE = REC_SERVER_IDLE ();
  2103. ;      1828    
  2104. ;      1829            [STATE_FI, STATE_LG] :
  2105. ;      1830    !
  2106. ;      1831    ! Here when we are supposed to exit
  2107. ;      1832    !
  2108. ;      1833            RETURN KER_EXIT;
  2109. ;      1834    
  2110. ;      1835            [STATE_SD] :
  2111. ;      1836            STATE = SEND_DATA ();
  2112. ;      1837    
  2113. ;      1838            [STATE_SF] :
  2114. ;      1839            STATE = SEND_FILE ();
  2115. ;      1840    
  2116. ;      1841            [STATE_SZ] :
  2117. ;      1842            STATE = SEND_EOF ();
  2118. ;      1843    
  2119. ;      1844            [STATE_S] :
  2120. ;      1845            STATE = SEND_INIT ();
  2121. ;      1846    
  2122. ;      1847            [STATE_OF] :
  2123. ;      1848            STATE = SEND_OPEN_FILE ();
  2124. ;      1849    
  2125. ;      1850            [STATE_SI] :
  2126. ;      1851            STATE = SEND_SERVER_INIT ();
  2127. ;      1852    
  2128. ;      1853            [STATE_SG] :
  2129. ;      1854            STATE = SEND_GENCMD ();
  2130. ;      1855    
  2131. ;      1856            [STATE_SB] :
  2132. ;      1857            STATE = SEND_BREAK ();
  2133. ;      1858    !
  2134. ;      1859    ! Receiving of the data and the end of file message.
  2135. ;      1860    !
  2136. ;      1861    
  2137. ;      1862            [STATE_RD] :
  2138. ;      1863            STATE = REC_DATA ();
  2139. ;      1864    !
  2140. ;      1865    ! Receiving the FILE information of the break to end the transfer of
  2141. ;      1866    ! one or more files
  2142. ;      1867    !
  2143. ;      1868    
  2144. ;      1869            [STATE_RF] :
  2145. ;      1870            STATE = REC_FILE ();
  2146. ;      1871    !
  2147. ;      1872    ! Initialization for the receiving of a file
  2148. ;      1873    !
  2149. ;      1874    
  2150. ;      1875            [STATE_R] :
  2151. ;      1876            STATE = REC_INIT ();
  2152. ;      1877    !
  2153. ;      1878    ! Here if we have completed the receiving of the file
  2154. ;      1879    !
  2155. ;      1880    
  2156. ;      1881            [STATE_C] :
  2157. ;      1882            BEGIN
  2158. ;      1883            RETURN_VALUE = TRUE;
  2159. ;      1884            EXITLOOP;
  2160. ;      1885            END;
  2161. ;      1886    !
  2162. ;      1887    ! Here if we aborted the transfer or we have gotten into some random
  2163. ;      1888    ! state (internal KERMSG problem).
  2164. ;      1889    !
  2165. ;      1890    
  2166. ;      1891            [STATE_A, STATE_EX, INRANGE, OUTRANGE] :
  2167. ;      1892            BEGIN
  2168. ;      1893            RETURN_VALUE = FALSE;
  2169. ;      1894    
  2170. ;      1895            IF .STATE EQL STATE_EX THEN RETURN_VALUE = KER_ABORTED;
  2171. ;      1896    
  2172. ;      1897            !
  2173. ;      1898            ! Determine if the file is still open and if so close it
  2174. ;      1899            !
  2175. ;      1900    
  2176. ;      1901            IF .FILE_OPEN_FLAG
  2177. ;      1902            THEN
  2178. ;      1903                BEGIN
  2179. ;      1904                FILE_OPEN_FLAG = FALSE;
  2180. ;      1905    
  2181. ;      1906                IF ( NOT .CONNECT_FLAG) AND .TY_FIL
  2182. ;      1907                THEN
  2183. ;      1908                BEGIN
  2184. ;      1909                TT_TEXT (UPLIT (%ASCIZ' [Aborted]'));
  2185. ;      1910                TT_CRLF ();
  2186. ;      1911                END;
  2187. ;      1912    
  2188. ;      1913                FILE_CLOSE (.ABT_FLAG AND (.STATE EQL STATE_A OR .STATE EQL STATE_EX));
  2189. ;      1914                XFR_STATUS (%C'F', %C'A');
  2190. ;      1915                END;
  2191. ;      1916    
  2192. ;      1917            EXITLOOP;
  2193. ;      1918            END;
  2194. ;      1919            TES;
  2195. ;      1920    
  2196. ;      1921    !
  2197. ;      1922    ! End the stats and return to the caller
  2198. ;      1923    !
  2199. ;      1924        END_STATS ();
  2200. ;      1925    !
  2201. ;      1926        RETURN .RETURN_VALUE;
  2202. ;      1927        END;                    ! End of DO_TRANSACTION
  2203.     .NLIST
  2204.     .LIST    BIN,LOC
  2205.     .LIST
  2206.  
  2207. P.AAC:    .ASCII    / [A/
  2208.     .ASCII    /bor/
  2209.     .ASCII    /ted/
  2210.     .ASCII    /]/<00><00>
  2211.  
  2212.  
  2213.     .SBTTL    DO.TRANSACTION DO_TRANSACTION - Main loop for FSM
  2214.     .PSECT    $CODE$,  RO 
  2215.  
  2216.     .NLIST
  2217.     .ENABL    LSB
  2218.     .LIST
  2219. ; DO.TRANSACTION
  2220. U.1:    JSR    R1,$SAVE2            ;                    1751
  2221.     CLR    U.77                ;                    1796
  2222.     MOV    10(SP),U.74            ; INIT.STATE,*                1797
  2223. 1$:    MOV    U.74,R0                ;                    1801
  2224.     DEC    R0
  2225.     CMP    R0,#22
  2226.     BHI    3$
  2227.     ASL    R0
  2228.     ADD    P.AAB(R0),PC            ; Case dispatch
  2229. 3$:    CLR    R2                ; RETURN.VALUE                1893
  2230.     CMP    U.74,#23            ;                    1895
  2231.     BNE    4$
  2232.     MOV    #272,R2                ; *,RETURN.VALUE
  2233. 4$:    BIT    #1,U.84                ;                    1901
  2234.     BEQ    24$
  2235.     CLR    U.84                ;                    1904
  2236.     BIT    #1,CONNECT.FLAG            ;                    1906
  2237.     BNE    5$
  2238.     BIT    #1,TY.FIL
  2239.     BEQ    5$
  2240.     MOV    #P.AAC,-(SP)            ;                    1909
  2241.     JSR    PC,TT.TEXT
  2242.     TST    (SP)+
  2243.     JSR    PC,TT.CRLF            ;                    1910
  2244. 5$:    CLR    R1                ;                    1913
  2245.     CMP    U.74,#12
  2246.     BNE    6$
  2247.     INC    R1
  2248. 6$:    CLR    R0
  2249.     CMP    U.74,#23
  2250.     BNE    7$
  2251.     INC    R0
  2252. 7$:    BIS    R1,R0
  2253.     MOV    ABT.FLAG,-(SP)
  2254.     COM    R0
  2255.     BIC    R0,(SP)
  2256.     JSR    PC,FILE.CLOSE
  2257.     MOV    #106,(SP)            ;                    1914
  2258.     MOV    #101,-(SP)
  2259.     JSR    PC,XFR.STATUS
  2260.     CMP    (SP)+,(SP)+
  2261.     BR    24$                ;                    1892
  2262. 8$:    MOV    SEND.TIMEOUT,R1            ; *,SAVED.TIMEOUT            1817
  2263.     ASL    SEND.TIMEOUT            ;                    1818
  2264.     JSR    PC,U.10                ;                    1819
  2265.     MOV    R0,U.74
  2266.     MOV    R1,SEND.TIMEOUT            ; SAVED.TIMEOUT,*            1820
  2267.     BR    1$                ;                    1801
  2268. 9$:    JSR    PC,U.10                ;                    1827
  2269.     BR    22$
  2270. 10$:    MOV    #211,R0                ;                    1833
  2271.     RTS    PC
  2272. 11$:    JSR    PC,U.3                ;                    1836
  2273.     BR    22$
  2274. 12$:    JSR    PC,U.4                ;                    1839
  2275.     BR    22$
  2276. 13$:    JSR    PC,U.7                ;                    1842
  2277.     BR    22$
  2278. 14$:    JSR    PC,U.8                ;                    1845
  2279.     BR    22$
  2280. 15$:    JSR    PC,U.5                ;                    1848
  2281.     BR    22$
  2282. 16$:    JSR    PC,U.2                ;                    1851
  2283.     BR    22$
  2284. 17$:    JSR    PC,U.6                ;                    1854
  2285.     BR    22$
  2286. 18$:    JSR    PC,U.9                ;                    1857
  2287.     BR    22$
  2288. 19$:    JSR    PC,U.13                ;                    1863
  2289.     BR    22$
  2290. 20$:    JSR    PC,U.12                ;                    1870
  2291.     BR    22$
  2292. 21$:    JSR    PC,U.11                ;                    1876
  2293. 22$:    MOV    R0,U.74
  2294.     BR    1$                ;                    1801
  2295. 23$:    MOV    #1,R2                ; *,RETURN.VALUE            1883
  2296. 24$:    JSR    PC,U.17                ;                    1924
  2297.     MOV    R2,R0                ; RETURN.VALUE,*            1791
  2298.     RTS    PC                ;                    1751
  2299. ; Routine Size:  129 words,    Routine Base:  $CODE$ + 1330
  2300. ; Maximum stack depth per invocation:  6 words
  2301.  
  2302.  
  2303.     .PSECT    $PLIT$,  RO ,  D  
  2304.  
  2305. P.AAB:                        ; CASE Table for DO.TRANSACTION+0034    1801
  2306. 2$:    .WORD    242                ; [14$]
  2307.     .WORD    226                ; [12$]
  2308.     .WORD    220                ; [11$]
  2309.     .WORD    234                ; [13$]
  2310.     .WORD    272                ; [18$]
  2311.     .WORD    314                ; [21$]
  2312.     .WORD    306                ; [20$]
  2313.     .WORD    300                ; [19$]
  2314.     .WORD    326                ; [23$]
  2315.     .WORD    0                ; [3$]
  2316.     .WORD    0                ; [3$]
  2317.     .WORD    264                ; [17$]
  2318.     .WORD    256                ; [16$]
  2319.     .WORD    156                ; [8$]
  2320.     .WORD    204                ; [9$]
  2321.     .WORD    212                ; [10$]
  2322.     .WORD    212                ; [10$]
  2323.     .WORD    250                ; [15$]
  2324.     .WORD    0                ; [3$]
  2325.  
  2326.     .NLIST
  2327.     .DSABL    LSB
  2328.     .NLIST    BIN,LOC
  2329.     .LIST
  2330.  
  2331.  
  2332. ;      1928    %SBTTL 'REC_SERVER_IDLE - Idle server state'
  2333. ;      1929    ROUTINE REC_SERVER_IDLE =
  2334. ;      1930    
  2335. ;      1931    !++
  2336. ;      1932    ! FUNCTIONAL DESCRIPTION:
  2337. ;      1933    !
  2338. ;      1934    ! This routine is called from DO_TRANSACTION when is the server idle
  2339. ;      1935    ! state.  It will receive a message and properly dispatch to the new
  2340. ;      1936    ! state.
  2341. ;      1937    !
  2342. ;      1938    ! CALLING SEQUENCE:
  2343. ;      1939    !
  2344. ;      1940    !    STATE = REC_SERVER_IDLE ();
  2345. ;      1941    !
  2346. ;      1942    ! INPUT PARAMETERS:
  2347. ;      1943    !
  2348. ;      1944    !    None.
  2349. ;      1945    !
  2350. ;      1946    ! IMPLICIT INPUTS:
  2351. ;      1947    !
  2352. ;      1948    !    Almost everything.
  2353. ;      1949    !
  2354. ;      1950    ! OUPTUT PARAMETERS:
  2355. ;      1951    !
  2356. ;      1952    !    Routine value is new state for FSM
  2357. ;      1953    !
  2358. ;      1954    ! IMPLICIT OUTPUTS:
  2359. ;      1955    !
  2360. ;      1956    !    None.
  2361. ;      1957    !
  2362. ;      1958    ! COMPLETION CODES:
  2363. ;      1959    !
  2364. ;      1960    !    None.
  2365. ;      1961    !
  2366. ;      1962    ! SIDE EFFECTS:
  2367. ;      1963    !
  2368. ;      1964    !    None.
  2369. ;      1965    !
  2370. ;      1966    !--
  2371. ;      1967    
  2372. ;      1968        BEGIN
  2373. ;      1969    
  2374. ;      1970        LOCAL
  2375. ;      1971        STATUS;
  2376. ;      1972    
  2377. ;      1973        STATUS = REC_PACKET ();
  2378. ;      1974    !
  2379. ;      1975    ! Now determine what to do by the type of message we have receive.
  2380. ;      1976    !
  2381. ;      1977    
  2382. ;      1978        IF .STATUS EQL KER_ABORTED THEN RETURN STATE_EX;
  2383. ;      1979    
  2384. ;      1980        IF .STATUS
  2385. ;      1981        THEN
  2386. ;      1982        BEGIN
  2387. ;      1983    
  2388. ;      1984        SELECTONE .REC_TYPE OF
  2389. ;      1985            SET
  2390. ;      1986            !
  2391. ;      1987            ! Server initialization message received. ACK the
  2392. ;      1988            ! message and continue.
  2393. ;      1989            !
  2394. ;      1990    
  2395. ;      1991            [MSG_SER_INIT] :
  2396. ;      1992            BEGIN
  2397. ;      1993    
  2398. ;      1994            IF (STATUS = PRS_SEND_INIT ())
  2399. ;      1995            THEN
  2400. ;      1996                BEGIN
  2401. ;      1997                SET_SEND_INIT ();
  2402. ;      1998    
  2403. ;      1999                IF (STATUS = SEND_PACKET (MSG_ACK, P_SI_LENGTH, .REC_SEQ))
  2404. ;      2000                THEN
  2405. ;      2001                BEGIN
  2406. ;      2002                SND_PKT_SIZE = -.SEND_PKT_SIZE;
  2407. ;      2003                SND_TIMEOUT = -.SEND_TIMEOUT;
  2408. ;      2004                SND_NPAD = -.SEND_NPAD;
  2409. ;      2005                SND_PADCHAR = -.SEND_PADCHAR;
  2410. ;      2006                SND_EOL = -.SEND_EOL;
  2411. ;      2007                SND_QUOTE_CHR = -.SEND_QUOTE_CHR;
  2412. ;      2008                RCV_8QUOTE_CHR = .SEND_8QUOTE_CHR;
  2413. ;      2009                CHKTYPE = .INI_CHK_TYPE;
  2414. ;      2010                SET_REPT_CHR = .REPT_CHR;
  2415. ;      2011                RETURN STATE_II;    ! Now idle after INIT
  2416. ;      2012                END;
  2417. ;      2013    
  2418. ;      2014                END;
  2419. ;      2015    
  2420. ;      2016            KRM_ERROR (KER_PROTOERR);
  2421. ;      2017            RETURN STATE_A;
  2422. ;      2018            END;
  2423. ;      2019            !
  2424. ;      2020            ! Send init message received.  We must ACK the message and
  2425. ;      2021            ! then attempt to receive a file from the remote.
  2426. ;      2022            !
  2427. ;      2023    
  2428. ;      2024            [MSG_SND_INIT] :
  2429. ;      2025            BEGIN
  2430. ;      2026            MSG_NUMBER = (.REC_SEQ + 1) AND %O'77';
  2431. ;      2027    
  2432. ;      2028            IF (STATUS = PRS_SEND_INIT ())
  2433. ;      2029            THEN
  2434. ;      2030                BEGIN
  2435. ;      2031                SET_SEND_INIT ();
  2436. ;      2032                !
  2437. ;      2033                ! ACK the message then receive everything.
  2438. ;      2034                !
  2439. ;      2035    
  2440. ;      2036                IF SEND_PACKET (MSG_ACK, P_SI_LENGTH, .REC_SEQ)
  2441. ;      2037                THEN
  2442. ;      2038                BEGIN
  2443. ;      2039                BLK_CHK_TYPE = .INI_CHK_TYPE;    ! Switch to desired form of block check
  2444. ;      2040                XFR_STATUS (%C'I', %C'R');    ! Start of file receive
  2445. ;      2041                RETURN STATE_RF;
  2446. ;      2042                END;
  2447. ;      2043    
  2448. ;      2044                END;
  2449. ;      2045    
  2450. ;      2046            KRM_ERROR (KER_PROTOERR);
  2451. ;      2047            RETURN STATE_A;
  2452. ;      2048            END;
  2453. ;      2049            !
  2454. ;      2050            ! Here if we receive a receive init message.
  2455. ;      2051            ! We will be sending a file to the other end.
  2456. ;      2052            !
  2457. ;      2053    
  2458. ;      2054            [MSG_RCV_INIT] :
  2459. ;      2055            BEGIN
  2460. ;      2056            !
  2461. ;      2057            ! Move the file specification if we received one
  2462. ;      2058            !
  2463. ;      2059            SET_STRING (CH$PTR (FILE_NAME), MAX_FILE_NAME, TRUE);
  2464. ;      2060            BFR_EMPTY ();
  2465. ;      2061            FILE_SIZE = SET_STRING (0, 0, FALSE);
  2466. ;      2062            CH$WCHAR (CHR_NUL, CH$PTR (FILE_NAME, .FILE_SIZE));
  2467. ;      2063    
  2468. ;      2064            IF .FILE_SIZE GTR 0
  2469. ;      2065            THEN
  2470. ;      2066                BEGIN
  2471. ;      2067                XFR_STATUS (%C'I', %C'S');    ! Start of a file send
  2472. ;      2068                RETURN STATE_S;
  2473. ;      2069                END;
  2474. ;      2070    
  2475. ;      2071            KRM_ERROR (KER_PROTOERR);
  2476. ;      2072            RETURN STATE_A;
  2477. ;      2073            END;
  2478. ;      2074    !
  2479. ;      2075    ! Generic KERMIT commands
  2480. ;      2076    !
  2481. ;      2077    
  2482. ;      2078            [MSG_KERMIT] :
  2483. ;      2079            RETURN SERVER_GENERIC ();
  2484. ;      2080    !
  2485. ;      2081    ! Host command
  2486. ;      2082    !
  2487. ;      2083    
  2488. ;      2084            [MSG_COMMAND] :
  2489. ;      2085            RETURN HOST_COMMAND ();
  2490. ;      2086    !
  2491. ;      2087    ! Unimplimented server routines
  2492. ;      2088    !
  2493. ;      2089    
  2494. ;      2090            [OTHERWISE] :
  2495. ;      2091            BEGIN
  2496. ;      2092            KRM_ERROR (KER_UNISRV);
  2497. ;      2093            RETURN STATE_A;
  2498. ;      2094            END;
  2499. ;      2095            TES;
  2500. ;      2096    
  2501. ;      2097        END;
  2502. ;      2098    
  2503. ;      2099    !
  2504. ;      2100    ! If we get here, we must have gotten something random.  Therefore,
  2505. ;      2101    ! just send a NAK and remain in the current state (unless we have done this
  2506. ;      2102    ! too many times).
  2507. ;      2103    !
  2508. ;      2104        NUM_RETRIES = .NUM_RETRIES + 1;
  2509. ;      2105    
  2510. ;      2106        IF .NUM_RETRIES GTR .SI_RETRIES THEN RETURN STATE_A;
  2511. ;      2107    
  2512. ;      2108        IF SEND_PACKET (MSG_NAK, 0, 0) THEN RETURN .STATE ELSE RETURN STATE_EX;
  2513. ;      2109    
  2514. ;      2110        END;                    ! End of REC_SERVER_IDLE
  2515.     .NLIST
  2516.     .LIST    BIN,LOC
  2517.     .LIST
  2518.  
  2519.     .SBTTL    REC.SERVER.IDLE REC_SERVER_IDLE - Idle server state
  2520.     .PSECT    $CODE$,  RO 
  2521.  
  2522.     .NLIST
  2523.     .ENABL    LSB
  2524.     .LIST
  2525. ; REC.SERVER.IDLE
  2526. U.10:    JSR    R1,$SAVE2            ;                    1929
  2527.     JSR    PC,U.25                ;                    1973
  2528.     MOV    R0,R2                ; *,STATUS
  2529.     CMP    R2,#272                ; STATUS,*                1978
  2530.     BNE    1$
  2531.     JMP    14$
  2532. 1$:    BIT    #1,R2                ; *,STATUS                1980
  2533.     BNE    2$
  2534.     JMP    11$
  2535. 2$:    MOV    U.81,R1                ;                    1984
  2536.     CMP    R1,#111
  2537.     BNE    4$
  2538.     JSR    PC,U.20                ;                    1994
  2539.     MOV    R0,R2                ; *,STATUS
  2540.     BIT    #1,R2                ; *,STATUS
  2541.     BEQ    3$
  2542.     JSR    PC,U.19                ;                    1997
  2543.     MOV    #131,-(SP)            ;                    1999
  2544.     MOV    #11,-(SP)
  2545.     MOV    U.79,-(SP)
  2546.     JSR    PC,U.23
  2547.     MOV    R0,R2                ; *,STATUS
  2548.     ADD    #6,SP
  2549.     BIT    #1,R2                ; *,STATUS
  2550.     BEQ    3$
  2551.     MOV    U.64,SND.PKT.SIZE        ;                    2002
  2552.     NEG    SND.PKT.SIZE
  2553.     MOV    SEND.TIMEOUT,SND.TIMEOUT    ;                    2003
  2554.     NEG    SND.TIMEOUT
  2555.     MOV    U.65,SND.NPAD            ;                    2004
  2556.     NEG    SND.NPAD
  2557.     MOV    U.66,SND.PADCHAR        ;                    2005
  2558.     NEG    SND.PADCHAR
  2559.     MOV    U.67,SND.EOL            ;                    2006
  2560.     NEG    SND.EOL
  2561.     MOV    U.68,SND.QUOTE.CHR        ;                    2007
  2562.     NEG    SND.QUOTE.CHR
  2563.     MOV    U.69,RCV.8QUOTE.CHR        ;                    2008
  2564.     MOV    U.70,CHKTYPE            ;                    2009
  2565.     MOV    U.63,SET.REPT.CHR        ;                    2010
  2566.     MOV    #17,R0                ;                    2001
  2567.     RTS    PC
  2568. 3$:    MOV    #242,-(SP)            ;                    2016
  2569.     BR    10$
  2570. 4$:    CMP    R1,#123                ;                    1984
  2571.     BNE    5$
  2572.     MOV    U.79,R0                ;                    2026
  2573.     INC    R0
  2574.     MOV    R0,U.78
  2575.     BIC    #177700,U.78
  2576.     JSR    PC,U.20                ;                    2028
  2577.     MOV    R0,R2                ; *,STATUS
  2578.     ROR    R2                ; STATUS
  2579.     BCC    3$
  2580.     JSR    PC,U.19                ;                    2031
  2581.     MOV    #131,-(SP)            ;                    2036
  2582.     MOV    #11,-(SP)
  2583.     MOV    U.79,-(SP)
  2584.     JSR    PC,U.23
  2585.     ADD    #6,SP
  2586.     ROR    R0
  2587.     BCC    3$
  2588.     MOV    U.70,U.71            ;                    2039
  2589.     MOV    #111,-(SP)            ;                    2040
  2590.     MOV    #122,-(SP)
  2591.     JSR    PC,XFR.STATUS
  2592.     CMP    (SP)+,(SP)+            ;                    2036
  2593.     MOV    #7,R0                ;                    2038
  2594.     RTS    PC
  2595. 5$:    CMP    R1,#122                ;                    1984
  2596.     BNE    7$
  2597.     MOV    #FILE.NAME,-(SP)        ;                    2059
  2598.     MOV    #204,-(SP)
  2599.     MOV    #1,-(SP)
  2600.     JSR    PC,U.29
  2601.     JSR    PC,U.27                ;                    2060
  2602.     CLR    (SP)                ;                    2061
  2603.     CLR    -(SP)
  2604.     CLR    -(SP)
  2605.     JSR    PC,U.29
  2606.     MOV    R0,FILE.SIZE
  2607.     CLRB    FILE.NAME(R0)            ;                    2062
  2608.     TST    R0                ;                    2064
  2609.     BLE    6$
  2610.     MOV    #111,(SP)            ;                    2067
  2611.     MOV    #123,-(SP)
  2612.     JSR    PC,XFR.STATUS
  2613.     ADD    #14,SP                ;                    2064
  2614.     MOV    #1,R0                ;                    2066
  2615.     RTS    PC
  2616. 6$:    MOV    #242,(SP)            ;                    2071
  2617.     JSR    PC,KRM.ERROR
  2618.     ADD    #12,SP                ;                    2055
  2619.     BR    12$                ;                    1984
  2620. 7$:    CMP    R1,#107
  2621.     BNE    8$
  2622.     JSR    PC,U.14                ;                    2079
  2623.     RTS    PC                ;                    1984
  2624. 8$:    CMP    R1,#103
  2625.     BNE    9$
  2626.     JSR    PC,U.15                ;                    2085
  2627.     RTS    PC                ;                    1984
  2628. 9$:    MOV    #232,-(SP)            ;                    2092
  2629. 10$:    JSR    PC,KRM.ERROR
  2630.     TST    (SP)+                ;                    2091
  2631.     BR    12$                ;                    1984
  2632. 11$:    INC    U.77                ;                    2104
  2633.     CMP    U.77,SI.RETRIES            ;                    2106
  2634.     BLE    13$
  2635. 12$:    MOV    #12,R0
  2636.     RTS    PC
  2637. 13$:    MOV    #116,-(SP)            ;                    2108
  2638.     CLR    -(SP)
  2639.     CLR    -(SP)
  2640.     JSR    PC,U.23
  2641.     ADD    #6,SP
  2642.     ROR    R0
  2643.     BCC    14$
  2644.     MOV    U.74,R0                ;                    1968
  2645.     RTS    PC
  2646. 14$:    MOV    #23,R0
  2647.     RTS    PC                ;                    1929
  2648. ; Routine Size:  215 words,    Routine Base:  $CODE$ + 1732
  2649. ; Maximum stack depth per invocation:  10 words
  2650.     .NLIST
  2651.     .DSABL    LSB
  2652.     .NLIST    BIN,LOC
  2653.     .LIST
  2654.  
  2655.  
  2656. ;      2111    %SBTTL 'SEND_SERVER_INIT'
  2657. ;      2112    ROUTINE SEND_SERVER_INIT =
  2658. ;      2113    
  2659. ;      2114    !++
  2660. ;      2115    ! FUNCTIONAL DESCRIPTION:
  2661. ;      2116    !
  2662. ;      2117    !    This routine will send a server initialization message to the
  2663. ;      2118    !    remote KERMIT.
  2664. ;      2119    !
  2665. ;      2120    ! CALLING SEQUENCE:
  2666. ;      2121    !
  2667. ;      2122    !    STATE = SEND_SERVER_INIT();
  2668. ;      2123    !
  2669. ;      2124    ! INPUT PARAMETERS:
  2670. ;      2125    !
  2671. ;      2126    !    None.
  2672. ;      2127    !
  2673. ;      2128    ! IMPLICIT INPUTS:
  2674. ;      2129    !
  2675. ;      2130    !    RECV_xxx - desired receive parameters
  2676. ;      2131    !
  2677. ;      2132    ! OUTPUT PARAMETERS:
  2678. ;      2133    !
  2679. ;      2134    !    New state to change the finite state machine to.
  2680. ;      2135    !
  2681. ;      2136    ! IMPLICIT OUTPUTS:
  2682. ;      2137    !
  2683. ;      2138    !    SEND_xxx - Other Kermit's desired parameters
  2684. ;      2139    !
  2685. ;      2140    ! COMPLETION CODES:
  2686. ;      2141    !
  2687. ;      2142    !    None.
  2688. ;      2143    !
  2689. ;      2144    ! SIDE EFFECTS:
  2690. ;      2145    !
  2691. ;      2146    !    None.
  2692. ;      2147    !
  2693. ;      2148    !--
  2694. ;      2149    
  2695. ;      2150        BEGIN
  2696. ;      2151    
  2697. ;      2152        LOCAL
  2698. ;      2153        OLD_OUTPUT,                ! Saved terminal output routine
  2699. ;      2154        STATUS;                    ! Status returned by various routines
  2700. ;      2155    
  2701. ;      2156    ![026] Local routine to ignore error message output
  2702. ;      2157        ROUTINE IGNORE_ERROR (ADDRESS, LENGTH) =
  2703. ;      2158        BEGIN
  2704. ;      2159        RETURN TRUE;
  2705. ;      2160        END;
  2706.     .NLIST
  2707.     .LIST    BIN,LOC
  2708.     .LIST
  2709.  
  2710.     .SBTTL    IGNORE.ERROR SEND_SERVER_INIT
  2711.     .NLIST
  2712.     .ENABL    LSB
  2713.     .LIST
  2714. ; IGNORE.ERROR
  2715. U.99:    MOV    #1,R0                ;                    2158
  2716.     RTS    PC                ;                    2157
  2717. ; Routine Size:  3 words,    Routine Base:  $CODE$ + 2610
  2718. ; Maximum stack depth per invocation:  0 words
  2719.     .NLIST
  2720.     .DSABL    LSB
  2721.     .NLIST    BIN,LOC
  2722.     .LIST
  2723.  
  2724.  
  2725. ;      2161        SET_SEND_INIT ();
  2726. ;      2162    ![026] If too many tries, just give up.  Maybe the other Kermit doesn't
  2727. ;      2163    ![026] know what to do with this packet.
  2728. ;      2164    
  2729. ;      2165        IF .NUM_RETRIES GTR .SI_RETRIES THEN RETURN STATE_A;
  2730. ;      2166    
  2731. ;      2167    ![026]
  2732. ;      2168    ![026] Count the number of times we try this
  2733. ;      2169    ![026]
  2734. ;      2170        NUM_RETRIES = .NUM_RETRIES + 1;
  2735. ;      2171    
  2736. ;      2172        IF NOT SEND_PACKET (MSG_SER_INIT, P_SI_LENGTH, .MSG_NUMBER) THEN RETURN STATE_A;
  2737. ;      2173    
  2738. ;      2174    ![026]
  2739. ;      2175    ![026] Determine if we received a packet it good condition.  If we timed out
  2740. ;      2176    ![026] just try again.  If we get an error packet back, ignore it and
  2741. ;      2177    ![026] just continue.  The other Kermit must not support this packet.
  2742. ;      2178    ![026]
  2743. ;      2179        OLD_OUTPUT = TT_SET_OUTPUT (IGNORE_ERROR);
  2744. ;      2180        STATUS = REC_PACKET ();
  2745. ;      2181        TT_OUTPUT ();
  2746. ;      2182        TT_SET_OUTPUT (.OLD_OUTPUT);
  2747. ;      2183    
  2748. ;      2184        IF .STATUS EQL KER_ERRMSG THEN RETURN STATE_SG;
  2749. ;      2185    
  2750. ;      2186        IF NOT .STATUS
  2751. ;      2187        THEN
  2752. ;      2188    
  2753. ;      2189        IF NOT ((.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL
  2754. ;      2190            KER_CHKSUMERR))
  2755. ;      2191        THEN
  2756. ;      2192            RETURN STATE_EX
  2757. ;      2193        ELSE
  2758. ;      2194            RETURN .STATE;
  2759. ;      2195    
  2760. ;      2196    !
  2761. ;      2197    ! Determine if the packet is good.
  2762. ;      2198    !
  2763. ;      2199    
  2764. ;      2200        IF .REC_TYPE EQL MSG_ACK AND .REC_SEQ EQL .MSG_NUMBER
  2765. ;      2201        THEN
  2766. ;      2202        BEGIN
  2767. ;      2203    !
  2768. ;      2204    ! Here if we have an ACK for the initialization message that was just sent
  2769. ;      2205    ! to the remote KERMIT.
  2770. ;      2206    !
  2771. ;      2207    
  2772. ;      2208        IF NOT (STATUS = PRS_SEND_INIT ()) THEN RETURN STATE_A;
  2773. ;      2209    
  2774. ;      2210        NUM_RETRIES = 0;
  2775. ;      2211        INIT_PKT_SENT = TRUE;            ! We have exchanged init's
  2776. ;      2212        RETURN STATE_SG;
  2777. ;      2213        END;
  2778. ;      2214    
  2779. ;      2215    !
  2780. ;      2216    ! If we haven't returned yet, we must have gotten an invalid response.
  2781. ;      2217    ! Just stay in the same state so we try again
  2782. ;      2218    !
  2783. ;      2219        RETURN .STATE;
  2784. ;      2220        END;
  2785.     .NLIST
  2786.     .LIST    BIN,LOC
  2787.     .LIST
  2788.  
  2789.     .SBTTL    SEND.SERVER.INIT SEND_SERVER_INIT
  2790.     .NLIST
  2791.     .ENABL    LSB
  2792.     .LIST
  2793. ; SEND.SERVER.INIT
  2794. U.2:    JSR    R1,$SAVE2            ;                    2112
  2795.     JSR    PC,U.19                ;                    2161
  2796.     CMP    U.77,SI.RETRIES            ;                    2165
  2797.     BGT    4$
  2798.     INC    U.77                ;                    2170
  2799.     MOV    #111,-(SP)            ;                    2172
  2800.     MOV    #11,-(SP)
  2801.     MOV    U.78,-(SP)
  2802.     JSR    PC,U.23
  2803.     ADD    #6,SP
  2804.     ROR    R0
  2805.     BHIS    4$
  2806.     MOV    #U.99,-(SP)            ;                    2179
  2807.     JSR    PC,TT.SET.OUTPUT
  2808.     MOV    R0,R2                ; *,OLD.OUTPUT
  2809.     JSR    PC,U.25                ;                    2180
  2810.     MOV    R0,R1                ; *,STATUS
  2811.     JSR    PC,TT.OUTPUT            ;                    2181
  2812.     MOV    R2,(SP)                ; OLD.OUTPUT,*                2182
  2813.     JSR    PC,TT.SET.OUTPUT
  2814.     CMP    R1,#152                ; STATUS,*                2184
  2815.     BEQ    6$
  2816.     BIT    #1,R1                ; *,STATUS                2186
  2817.     BNE    3$
  2818.     CMP    R1,#312                ; STATUS,*                2189
  2819.     BEQ    1$
  2820.     CMP    R1,#264                ; STATUS,*
  2821.     BEQ    1$
  2822.     CMP    R1,#162                ; STATUS,*
  2823.     BEQ    1$
  2824.     MOV    #23,R0                ;                    2186
  2825.     BR    2$
  2826. 1$:    MOV    U.74,R0
  2827. 2$:    TST    (SP)+
  2828.     RTS    PC                ;                    2189
  2829. 3$:    CMP    U.81,#131            ;                    2200
  2830.     BNE    7$
  2831.     CMP    U.79,U.78
  2832.     BNE    7$
  2833.     JSR    PC,U.20                ;                    2208
  2834.     MOV    R0,R1                ; *,STATUS
  2835.     ROR    R1                ; STATUS
  2836.     BLO    5$
  2837.     TST    (SP)+
  2838. 4$:    MOV    #12,R0
  2839.     RTS    PC
  2840. 5$:    CLR    U.77                ;                    2210
  2841.     MOV    #1,U.88                ;                    2211
  2842. 6$:    TST    (SP)+                ;                    2200
  2843.     MOV    #14,R0                ;                    2202
  2844.     RTS    PC
  2845. 7$:    TST    (SP)+                ;                    2112
  2846.     MOV    U.74,R0                ;                    2150
  2847.     RTS    PC                ;                    2112
  2848. ; Routine Size:  87 words,    Routine Base:  $CODE$ + 2616
  2849. ; Maximum stack depth per invocation:  7 words
  2850.     .NLIST
  2851.     .DSABL    LSB
  2852.     .NLIST    BIN,LOC
  2853.     .LIST
  2854.  
  2855.  
  2856. ;      2221    %SBTTL 'SEND_DATA'
  2857. ;      2222    ROUTINE SEND_DATA =
  2858. ;      2223    
  2859. ;      2224    !++
  2860. ;      2225    ! FUNCTIONAL DESCRIPTION:
  2861. ;      2226    !
  2862. ;      2227    !    This routine will send a data message to the remote KERMIT.
  2863. ;      2228    !
  2864. ;      2229    ! CALLING SEQUENCE:
  2865. ;      2230    !
  2866. ;      2231    !    STATE = SEND_DATA();
  2867. ;      2232    !
  2868. ;      2233    ! INPUT PARAMETERS:
  2869. ;      2234    !
  2870. ;      2235    !    None.
  2871. ;      2236    !
  2872. ;      2237    ! IMPLICIT INPUTS:
  2873. ;      2238    !
  2874. ;      2239    !    None.
  2875. ;      2240    !
  2876. ;      2241    ! OUTPUT PARAMETERS:
  2877. ;      2242    !
  2878. ;      2243    !    New state to change the finite state machine to.
  2879. ;      2244    !
  2880. ;      2245    ! IMPLICIT OUTPUTS:
  2881. ;      2246    !
  2882. ;      2247    !    None.
  2883. ;      2248    !
  2884. ;      2249    ! COMPLETION CODES:
  2885. ;      2250    !
  2886. ;      2251    !    None.
  2887. ;      2252    !
  2888. ;      2253    ! SIDE EFFECTS:
  2889. ;      2254    !
  2890. ;      2255    !    None.
  2891. ;      2256    !
  2892. ;      2257    !--
  2893. ;      2258    
  2894. ;      2259        BEGIN
  2895. ;      2260    
  2896. ;      2261        LOCAL
  2897. ;      2262        SUB_TYPE,                ! Subtype for XFR_STATUS call
  2898. ;      2263        STATUS;                    ! Status returned by various routines
  2899. ;      2264    
  2900. ;      2265    !
  2901. ;      2266    ! If there is nothing in the data packet, we should not bother to send it.
  2902. ;      2267    ! Instead, we will just call BFR_FILL again to get some more data
  2903. ;      2268    !
  2904. ;      2269    
  2905. ;      2270        IF .SIZE GTR 0
  2906. ;      2271        THEN
  2907. ;      2272        BEGIN
  2908. ;      2273    !
  2909. ;      2274    ! Check to see if the number of retries have been exceeded.
  2910. ;      2275    !
  2911. ;      2276    
  2912. ;      2277        IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  2913. ;      2278    
  2914. ;      2279    !
  2915. ;      2280    ! Not exceeded yet.  Increment the number of retries we have attempted
  2916. ;      2281    ! on this message.
  2917. ;      2282    !
  2918. ;      2283        NUM_RETRIES = .NUM_RETRIES + 1;
  2919. ;      2284    !
  2920. ;      2285    ! Attempt to send the packet and abort if the send fails.
  2921. ;      2286    !
  2922. ;      2287    
  2923. ;      2288        IF NOT SEND_PACKET (MSG_DATA, .SIZE, .MSG_NUMBER) THEN RETURN STATE_EX;
  2924. ;      2289    
  2925. ;      2290    !
  2926. ;      2291    ! Attempt to receive a message from the remote KERMIT.
  2927. ;      2292    !
  2928. ;      2293        STATUS = REC_PACKET ();
  2929. ;      2294    
  2930. ;      2295        IF NOT .STATUS
  2931. ;      2296        THEN
  2932. ;      2297            BEGIN
  2933. ;      2298    
  2934. ;      2299            IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL
  2935. ;      2300            KER_CHKSUMERR)
  2936. ;      2301            THEN
  2937. ;      2302            RETURN .STATE
  2938. ;      2303            ELSE
  2939. ;      2304            RETURN STATE_EX;
  2940. ;      2305    
  2941. ;      2306            END;
  2942. ;      2307    
  2943. ;      2308    !
  2944. ;      2309    ! Determine if the message is a NAK and the NAK is for the message number
  2945. ;      2310    ! that we are current working on.  If the NAK is for the next packet then
  2946. ;      2311    ! treat it like an ACK for this packet
  2947. ;      2312    !
  2948. ;      2313    
  2949. ;      2314        IF .REC_TYPE EQL MSG_NAK AND (.REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77'))
  2950. ;      2315        THEN
  2951. ;      2316            RETURN .STATE;
  2952. ;      2317    
  2953. ;      2318    !
  2954. ;      2319    ! Make sure we have a NAK or ACK
  2955. ;      2320    !
  2956. ;      2321    
  2957. ;      2322        IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK)
  2958. ;      2323        THEN
  2959. ;      2324    !
  2960. ;      2325    ! Not an ACK or NAK, abort.
  2961. ;      2326    !
  2962. ;      2327            RETURN STATE_A;
  2963. ;      2328    
  2964. ;      2329    !
  2965. ;      2330    ! Is this for this message?
  2966. ;      2331    !
  2967. ;      2332    
  2968. ;      2333        IF .REC_TYPE EQL MSG_ACK AND .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE;
  2969. ;      2334    
  2970. ;      2335    !
  2971. ;      2336    ! It was.  Set up for sending the next data message to the remote KERMIT
  2972. ;      2337    ! and return.
  2973. ;      2338    !
  2974. ;      2339    !
  2975. ;      2340    ! Check for data field in ACK indicating abort file or stream
  2976. ;      2341    !
  2977. ;      2342    !
  2978. ;      2343    
  2979. ;      2344        IF .REC_TYPE EQL MSG_ACK AND .REC_LENGTH EQL 1
  2980. ;      2345        THEN
  2981. ;      2346    
  2982. ;      2347            SELECTONE CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE)) OF
  2983. ;      2348            SET
  2984. ;      2349    
  2985. ;      2350            [MSG_ACK_ABT_CUR] :
  2986. ;      2351                ABT_CUR_FILE = TRUE;
  2987. ;      2352    
  2988. ;      2353            [MSG_ACK_ABT_ALL] :
  2989. ;      2354                ABT_ALL_FILE = TRUE;
  2990. ;      2355            TES;
  2991. ;      2356    
  2992. ;      2357        NUM_RETRIES = 0;
  2993. ;      2358        MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  2994. ;      2359        END;                    ! End of IF .SIZE GTR 0
  2995. ;      2360    
  2996. ;      2361        IF (BFR_FILL (FALSE) EQL KER_NORMAL) AND NOT (.ABT_CUR_FILE OR .ABT_ALL_FILE)
  2997. ;      2362        THEN
  2998. ;      2363        RETURN STATE_SD
  2999. ;      2364        ELSE
  3000. ;      2365        BEGIN
  3001. ;      2366    
  3002. ;      2367        IF ( NOT .CONNECT_FLAG) AND .TY_FIL
  3003. ;      2368        THEN
  3004. ;      2369            BEGIN
  3005. ;      2370    
  3006. ;      2371            IF .ABT_ALL_FILE
  3007. ;      2372            THEN
  3008. ;      2373            TT_TEXT (UPLIT (%ASCIZ' [Group interrupted]'))
  3009. ;      2374            ELSE
  3010. ;      2375    
  3011. ;      2376            IF .ABT_CUR_FILE
  3012. ;      2377            THEN
  3013. ;      2378                TT_TEXT (UPLIT (%ASCIZ' [Interrupted]'))
  3014. ;      2379            ELSE
  3015. ;      2380                TT_TEXT (UPLIT (%ASCIZ' [OK]'));
  3016. ;      2381    
  3017. ;      2382            TT_CRLF ();
  3018. ;      2383            END;
  3019. ;      2384    
  3020. ;      2385        IF .FILE_OPEN_FLAG THEN FILE_CLOSE (FALSE);
  3021. ;      2386    
  3022. ;      2387        SUB_TYPE = %C'C';            ! Assume ok
  3023. ;      2388    
  3024. ;      2389        IF .ABT_ALL_FILE
  3025. ;      2390        THEN
  3026. ;      2391            SUB_TYPE = %C'Z'
  3027. ;      2392        ELSE
  3028. ;      2393    
  3029. ;      2394            IF .ABT_CUR_FILE THEN SUB_TYPE = %C'X';
  3030. ;      2395    
  3031. ;      2396        XFR_STATUS (%C'F', .SUB_TYPE);
  3032. ;      2397        FILE_OPEN_FLAG = FALSE;
  3033. ;      2398        RETURN STATE_SZ;
  3034. ;      2399        END;
  3035. ;      2400    
  3036. ;      2401        END;
  3037.     .NLIST
  3038.     .LIST    BIN,LOC
  3039.     .LIST
  3040.  
  3041.  
  3042.     .PSECT    $PLIT$,  RO ,  D  
  3043. P.AAD:    .ASCII    / [G/
  3044.     .ASCII    /rou/
  3045.     .ASCII    /p i/
  3046.     .ASCII    /nte/
  3047.     .ASCII    /rru/
  3048.     .ASCII    /pte/
  3049.     .ASCII    /d]/<00>
  3050.     .ASCII    <00>
  3051. P.AAE:    .ASCII    / [I/
  3052.     .ASCII    /nte/
  3053.     .ASCII    /rru/
  3054.     .ASCII    /pte/
  3055.     .ASCII    /d]/<00>
  3056.     .ASCII    <00>
  3057. P.AAF:    .ASCII    / [O/
  3058.     .ASCII    /K]/<00>
  3059.  
  3060.  
  3061.     .SBTTL    SEND.DATA SEND_DATA
  3062.     .PSECT    $CODE$,  RO 
  3063.  
  3064.     .NLIST
  3065.     .ENABL    LSB
  3066.     .LIST
  3067. ; SEND.DATA
  3068. U.3:    JSR    R1,$SAVE3            ;                    2222
  3069.     MOV    U.75,R0                ;                    2270
  3070.     BLE    11$
  3071.     CMP    U.77,PKT.RETRIES        ;                    2277
  3072.     BGT    5$
  3073.     INC    U.77                ;                    2283
  3074.     MOV    #104,-(SP)            ;                    2288
  3075.     MOV    R0,-(SP)
  3076.     MOV    U.78,-(SP)
  3077.     JSR    PC,U.23
  3078.     ADD    #6,SP
  3079.     ROR    R0
  3080.     BHIS    1$
  3081.     JSR    PC,U.25                ;                    2293
  3082.     BIT    #1,R0                ; *,STATUS                2295
  3083.     BNE    2$
  3084.     CMP    R0,#312                ; STATUS,*                2299
  3085.     BEQ    7$
  3086.     CMP    R0,#264                ; STATUS,*
  3087.     BEQ    7$
  3088.     CMP    R0,#162                ; STATUS,*
  3089.     BEQ    7$                ;                    2297
  3090. 1$:    MOV    #23,R0
  3091.     RTS    PC
  3092. 2$:    CLR    R1                ;                    2314
  3093.     CMP    U.81,#116
  3094.     BNE    3$
  3095.     INC    R1
  3096.     MOV    U.78,R0
  3097.     INC    R0
  3098.     MOV    R0,R3
  3099.     BIC    #177700,R3
  3100.     MOV    U.79,R2
  3101.     CMP    R2,R3
  3102.     BNE    7$                ;                    2316
  3103. 3$:    CLR    R0                ;                    2322
  3104.     CMP    U.81,#131
  3105.     BNE    4$
  3106.     INC    R0
  3107.     BR    6$
  3108. 4$:    ROR    R1
  3109.     BLO    6$
  3110. 5$:    MOV    #12,R0                ;                    2327
  3111.     RTS    PC
  3112. 6$:    BIT    #1,R0                ;                    2333
  3113.     BEQ    8$
  3114.     CMP    U.79,U.78
  3115.     BEQ    8$
  3116. 7$:    MOV    U.74,R0
  3117.     RTS    PC
  3118. 8$:    ROR    R0                ;                    2344
  3119.     BCC    10$
  3120.     CMP    U.80,#1
  3121.     BNE    10$
  3122.     CLR    R0                ;                    2347
  3123.     BISB    U.82+4,R0
  3124.     CMP    R0,#130
  3125.     BNE    9$
  3126.     MOV    #1,ABT.CUR.FILE            ;                    2351
  3127.     BR    10$                ;                    2347
  3128. 9$:    CMP    R0,#132
  3129.     BNE    10$
  3130.     MOV    #1,ABT.ALL.FILE            ;                    2354
  3131. 10$:    CLR    U.77                ;                    2357
  3132.     MOV    U.78,R0                ;                    2358
  3133.     INC    R0
  3134.     MOV    R0,U.78
  3135.     BIC    #177700,U.78
  3136. 11$:    CLR    -(SP)                ;                    2361
  3137.     JSR    PC,U.28
  3138.     TST    (SP)+
  3139.     CMP    R0,#1
  3140.     BNE    12$
  3141.     BIT    #1,ABT.CUR.FILE
  3142.     BNE    12$
  3143.     BIT    #1,ABT.ALL.FILE
  3144.     BNE    12$
  3145.     MOV    #3,R0                ;                    2259
  3146.     RTS    PC
  3147. 12$:    BIT    #1,CONNECT.FLAG            ;                    2367
  3148.     BNE    16$
  3149.     BIT    #1,TY.FIL
  3150.     BEQ    16$
  3151.     BIT    #1,ABT.ALL.FILE            ;                    2371
  3152.     BEQ    13$
  3153.     MOV    #P.AAD,-(SP)            ;                    2373
  3154.     BR    15$
  3155. 13$:    BIT    #1,ABT.CUR.FILE            ;                    2376
  3156.     BEQ    14$
  3157.     MOV    #P.AAE,-(SP)            ;                    2378
  3158.     BR    15$
  3159. 14$:    MOV    #P.AAF,-(SP)            ;                    2380
  3160. 15$:    JSR    PC,TT.TEXT
  3161.     JSR    PC,TT.CRLF            ;                    2382
  3162.     TST    (SP)+                ;                    2369
  3163. 16$:    BIT    #1,U.84                ;                    2385
  3164.     BEQ    17$
  3165.     CLR    -(SP)
  3166.     JSR    PC,FILE.CLOSE
  3167.     TST    (SP)+
  3168. 17$:    MOV    #103,R0                ; *,SUB.TYPE                2387
  3169.     BIT    #1,ABT.ALL.FILE            ;                    2389
  3170.     BEQ    18$
  3171.     MOV    #132,R0                ; *,SUB.TYPE                2391
  3172.     BR    19$                ;                    2389
  3173. 18$:    BIT    #1,ABT.CUR.FILE            ;                    2394
  3174.     BEQ    19$
  3175.     MOV    #130,R0                ; *,SUB.TYPE
  3176. 19$:    MOV    #106,-(SP)            ;                    2396
  3177.     MOV    R0,-(SP)            ; SUB.TYPE,*
  3178.     JSR    PC,XFR.STATUS
  3179.     CLR    U.84                ;                    2397
  3180.     CMP    (SP)+,(SP)+            ;                    2365
  3181.     MOV    #4,R0                ;                    2259
  3182.     RTS    PC                ;                    2222
  3183. ; Routine Size:  190 words,    Routine Base:  $CODE$ + 3074
  3184. ; Maximum stack depth per invocation:  8 words
  3185.     .NLIST
  3186.     .DSABL    LSB
  3187.     .NLIST    BIN,LOC
  3188.     .LIST
  3189.  
  3190.  
  3191. ;      2402    %SBTTL 'SEND_FILE'
  3192. ;      2403    ROUTINE SEND_FILE =
  3193. ;      2404    
  3194. ;      2405    !++
  3195. ;      2406    ! FUNCTIONAL DESCRIPTION:
  3196. ;      2407    !
  3197. ;      2408    !    This routine will send the file specification that is being
  3198. ;      2409    !    transfered, or it will send a text header message.
  3199. ;      2410    !
  3200. ;      2411    ! CALLING SEQUENCE:
  3201. ;      2412    !
  3202. ;      2413    !    STATE = SEND_FILE();
  3203. ;      2414    !
  3204. ;      2415    ! INPUT PARAMETERS:
  3205. ;      2416    !
  3206. ;      2417    !    None.
  3207. ;      2418    !
  3208. ;      2419    ! IMPLICIT INPUTS:
  3209. ;      2420    !
  3210. ;      2421    !    TEXT_HEAD_FLAG - If true, send text header instead of file header
  3211. ;      2422    !
  3212. ;      2423    ! OUTPUT PARAMETERS:
  3213. ;      2424    !
  3214. ;      2425    !    New state to change the finite state machine to.
  3215. ;      2426    !
  3216. ;      2427    ! IMPLICIT OUTPUTS:
  3217. ;      2428    !
  3218. ;      2429    !    None.
  3219. ;      2430    !
  3220. ;      2431    ! COMPLETION CODES:
  3221. ;      2432    !
  3222. ;      2433    !    None.
  3223. ;      2434    !
  3224. ;      2435    ! SIDE EFFECTS:
  3225. ;      2436    !
  3226. ;      2437    !    None.
  3227. ;      2438    !
  3228. ;      2439    !--
  3229. ;      2440    
  3230. ;      2441        BEGIN
  3231. ;      2442    
  3232. ;      2443        LOCAL
  3233. ;      2444        M_TYPE,                    ! Message type to send
  3234. ;      2445        STATUS;                    ! Status returned by various routines
  3235. ;      2446    
  3236. ;      2447    !
  3237. ;      2448    ! Flag we don't want to abort yet
  3238. ;      2449    !
  3239. ;      2450        ABT_CUR_FILE = FALSE;
  3240. ;      2451        ABT_ALL_FILE = FALSE;
  3241. ;      2452    !
  3242. ;      2453    ! First determine if we have exceed the number of retries that are
  3243. ;      2454    ! allowed to attempt to send this message.
  3244. ;      2455    !
  3245. ;      2456    
  3246. ;      2457        IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  3247. ;      2458    
  3248. ;      2459    !
  3249. ;      2460    ! The number of retries are not exceeded.  Increment the number and then
  3250. ;      2461    ! attempt to send the packet again.
  3251. ;      2462    !
  3252. ;      2463        NUM_RETRIES = .NUM_RETRIES + 1;
  3253. ;      2464        SIZE = 0;                    ! Assume no name
  3254. ;      2465    
  3255. ;      2466        IF .TEXT_HEAD_FLAG THEN M_TYPE = MSG_TEXT ELSE M_TYPE = MSG_FILE;
  3256. ;      2467    
  3257. ;      2468        IF .FILE_SIZE NEQ 0 AND NOT .NO_FILE_NEEDED
  3258. ;      2469        THEN
  3259. ;      2470        BEGIN
  3260. ;      2471    ![025]    CH$MOVE (.FILE_SIZE, CH$PTR (FILE_NAME),
  3261. ;      2472    ![025]        CH$PTR (SND_MSG, PKT_MSG,
  3262. ;      2473    ![025]        CHR_SIZE));
  3263. ;      2474    ![025]
  3264. ;      2475    ![025] Fill packet with file name
  3265. ;      2476    ![025]
  3266. ;      2477        SET_STRING (CH$PTR (FILE_NAME), .FILE_SIZE, TRUE);
  3267. ;      2478        BFR_FILL (TRUE);
  3268. ;      2479        SET_STRING (0, 0, FALSE);
  3269. ;      2480        END;
  3270. ;      2481    
  3271. ;      2482        IF NOT SEND_PACKET (.M_TYPE, .SIZE, .MSG_NUMBER) THEN RETURN STATE_EX;
  3272. ;      2483    
  3273. ;      2484    !
  3274. ;      2485    ! Now get the responce from the remote KERMIT.
  3275. ;      2486    !
  3276. ;      2487        STATUS = REC_PACKET ();
  3277. ;      2488    
  3278. ;      2489        IF NOT .STATUS
  3279. ;      2490        THEN
  3280. ;      2491        BEGIN
  3281. ;      2492    
  3282. ;      2493        IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR)
  3283. ;      2494        THEN
  3284. ;      2495            RETURN .STATE
  3285. ;      2496        ELSE
  3286. ;      2497            RETURN STATE_EX;
  3287. ;      2498    
  3288. ;      2499        END;
  3289. ;      2500    
  3290. ;      2501    !
  3291. ;      2502    ! Determine if the packet is good.
  3292. ;      2503    !
  3293. ;      2504    
  3294. ;      2505        IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A;
  3295. ;      2506    
  3296. ;      2507    !
  3297. ;      2508    ! If this is a NAK and the message number is not the one we just send
  3298. ;      2509    ! treat this like an ACK, otherwise resend the last packet.
  3299. ;      2510    !
  3300. ;      2511    
  3301. ;      2512        IF .REC_TYPE EQL MSG_NAK AND (.REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77')) THEN RETURN .STATE;
  3302. ;      2513    
  3303. ;      2514        IF .REC_TYPE EQL MSG_ACK AND .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE;
  3304. ;      2515    
  3305. ;      2516    !
  3306. ;      2517    ! If all is ok, bump the message number and fill first buffer
  3307. ;      2518    !
  3308. ;      2519        NUM_RETRIES = 0;
  3309. ;      2520        MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  3310. ;      2521    
  3311. ;      2522        IF BFR_FILL (TRUE) THEN RETURN STATE_SD ELSE RETURN STATE_A;
  3312. ;      2523    
  3313. ;      2524        END;                    ! End of SEND_FILE
  3314.     .NLIST
  3315.     .LIST    BIN,LOC
  3316.     .LIST
  3317.  
  3318.     .SBTTL    SEND.FILE SEND_FILE
  3319.     .NLIST
  3320.     .ENABL    LSB
  3321.     .LIST
  3322. ; SEND.FILE
  3323. U.4:    JSR    R1,$SAVE3            ;                    2403
  3324.     CLR    ABT.CUR.FILE            ;                    2450
  3325.     CLR    ABT.ALL.FILE            ;                    2451
  3326.     CMP    U.77,PKT.RETRIES        ;                    2457
  3327.     BGT    11$
  3328.     INC    U.77                ;                    2463
  3329.     CLR    U.75                ;                    2464
  3330.     BIT    #1,U.86                ;                    2466
  3331.     BEQ    1$
  3332.     MOV    #130,R1                ; *,M.TYPE
  3333.     BR    2$
  3334. 1$:    MOV    #106,R1                ; *,M.TYPE
  3335. 2$:    MOV    FILE.SIZE,R0            ;                    2468
  3336.     BEQ    3$
  3337.     BIT    #1,U.87
  3338.     BNE    3$
  3339.     MOV    #FILE.NAME,-(SP)        ;                    2477
  3340.     MOV    R0,-(SP)
  3341.     MOV    #1,-(SP)
  3342.     JSR    PC,U.29
  3343.     MOV    #1,(SP)                ;                    2478
  3344.     JSR    PC,U.28
  3345.     CLR    (SP)                ;                    2479
  3346.     CLR    -(SP)
  3347.     CLR    -(SP)
  3348.     JSR    PC,U.29
  3349.     ADD    #12,SP                ;                    2470
  3350. 3$:    MOV    R1,-(SP)            ; M.TYPE,*                2482
  3351.     MOV    U.75,-(SP)
  3352.     MOV    U.78,-(SP)
  3353.     JSR    PC,U.23
  3354.     ADD    #6,SP
  3355.     ROR    R0
  3356.     BHIS    4$
  3357.     JSR    PC,U.25                ;                    2487
  3358.     BIT    #1,R0                ; *,STATUS                2489
  3359.     BNE    5$
  3360.     CMP    R0,#312                ; STATUS,*                2493
  3361.     BEQ    9$
  3362.     CMP    R0,#264                ; STATUS,*
  3363.     BEQ    9$
  3364.     CMP    R0,#162                ; STATUS,*
  3365.     BEQ    9$                ;                    2491
  3366. 4$:    MOV    #23,R0
  3367.     RTS    PC
  3368. 5$:    MOV    U.81,R0                ;                    2505
  3369.     CLR    R1
  3370.     CMP    R0,#131
  3371.     BNE    6$
  3372.     INC    R1
  3373.     BR    7$
  3374. 6$:    CMP    R0,#116
  3375.     BNE    11$
  3376. 7$:    CMP    R0,#116                ;                    2512
  3377.     BNE    8$
  3378.     MOV    U.78,R0
  3379.     INC    R0
  3380.     MOV    R0,R3
  3381.     BIC    #177700,R3
  3382.     MOV    U.79,R2
  3383.     CMP    R2,R3
  3384.     BNE    9$
  3385. 8$:    ROR    R1                ;                    2514
  3386.     BCC    10$
  3387.     CMP    U.79,U.78
  3388.     BEQ    10$
  3389. 9$:    MOV    U.74,R0
  3390.     RTS    PC
  3391. 10$:    CLR    U.77                ;                    2519
  3392.     MOV    U.78,R0                ;                    2520
  3393.     INC    R0
  3394.     MOV    R0,U.78
  3395.     BIC    #177700,U.78
  3396.     MOV    #1,-(SP)            ;                    2522
  3397.     JSR    PC,U.28
  3398.     TST    (SP)+
  3399.     ROR    R0
  3400.     BCC    11$
  3401.     MOV    #3,R0                ;                    2441
  3402.     RTS    PC
  3403. 11$:    MOV    #12,R0
  3404.     RTS    PC                ;                    2403
  3405. ; Routine Size:  132 words,    Routine Base:  $CODE$ + 3670
  3406. ; Maximum stack depth per invocation:  10 words
  3407.     .NLIST
  3408.     .DSABL    LSB
  3409.     .NLIST    BIN,LOC
  3410.     .LIST
  3411.  
  3412.  
  3413. ;      2525    %SBTTL 'SEND_EOF'
  3414. ;      2526    ROUTINE SEND_EOF =
  3415. ;      2527    
  3416. ;      2528    !++
  3417. ;      2529    ! FUNCTIONAL DESCRIPTION:
  3418. ;      2530    !
  3419. ;      2531    !    This routine will send the end of file message to the remote
  3420. ;      2532    !    KERMIT.  It will then determine if there are more files to
  3421. ;      2533    !    send to the remote.
  3422. ;      2534    !
  3423. ;      2535    ! CALLING SEQUENCE:
  3424. ;      2536    !
  3425. ;      2537    !    STATE = SEND_EOF();
  3426. ;      2538    !
  3427. ;      2539    ! INPUT PARAMETERS:
  3428. ;      2540    !
  3429. ;      2541    !    None.
  3430. ;      2542    !
  3431. ;      2543    ! IMPLICIT INPUTS:
  3432. ;      2544    !
  3433. ;      2545    !    None.
  3434. ;      2546    !
  3435. ;      2547    ! OUTPUT PARAMETERS:
  3436. ;      2548    !
  3437. ;      2549    !    New state to change the finite state machine to.
  3438. ;      2550    !
  3439. ;      2551    ! IMPLICIT OUTPUTS:
  3440. ;      2552    !
  3441. ;      2553    !    None.
  3442. ;      2554    !
  3443. ;      2555    ! COMPLETION CODES:
  3444. ;      2556    !
  3445. ;      2557    !    None.
  3446. ;      2558    !
  3447. ;      2559    ! SIDE EFFECTS:
  3448. ;      2560    !
  3449. ;      2561    !    Sets up for the next file to be processed if there is one.
  3450. ;      2562    !
  3451. ;      2563    !--
  3452. ;      2564    
  3453. ;      2565        BEGIN
  3454. ;      2566    
  3455. ;      2567        LOCAL
  3456. ;      2568        STATUS,                    ! Status returned by various routines
  3457. ;      2569        EOF_MSG_LEN;                ! Length of EOF message to send
  3458. ;      2570    
  3459. ;      2571    !
  3460. ;      2572    ! First determine if we have exceed the number of retries that are
  3461. ;      2573    ! allowed to attempt to send this message.
  3462. ;      2574    !
  3463. ;      2575    
  3464. ;      2576        IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  3465. ;      2577    
  3466. ;      2578    !
  3467. ;      2579    ! The number of retries are not exceeded.  Increment the number and then
  3468. ;      2580    ! attempt to send the packet again.
  3469. ;      2581    !
  3470. ;      2582        NUM_RETRIES = .NUM_RETRIES + 1;
  3471. ;      2583    !
  3472. ;      2584    ! Store character in packet to indicate discard of file
  3473. ;      2585    ! Character will only be sent if file should be discarded
  3474. ;      2586    !
  3475. ;      2587        CH$WCHAR (MSG_EOF_DISCARD, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE));
  3476. ;      2588    
  3477. ;      2589        IF .ABT_CUR_FILE OR .ABT_ALL_FILE THEN EOF_MSG_LEN = 1 ELSE EOF_MSG_LEN = 0;
  3478. ;      2590    
  3479. ;      2591        IF NOT SEND_PACKET (MSG_EOF, .EOF_MSG_LEN, .MSG_NUMBER) THEN RETURN STATE_EX;
  3480. ;      2592    
  3481. ;      2593    !
  3482. ;      2594    ! Now get the responce from the remote KERMIT.
  3483. ;      2595    !
  3484. ;      2596        STATUS = REC_PACKET ();
  3485. ;      2597    
  3486. ;      2598        IF NOT .STATUS
  3487. ;      2599        THEN
  3488. ;      2600        BEGIN
  3489. ;      2601    
  3490. ;      2602        IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR)
  3491. ;      2603        THEN
  3492. ;      2604            RETURN .STATE
  3493. ;      2605        ELSE
  3494. ;      2606            RETURN STATE_EX;
  3495. ;      2607    
  3496. ;      2608        END;
  3497. ;      2609    
  3498. ;      2610    !
  3499. ;      2611    ! Determine if the packet is good.
  3500. ;      2612    !
  3501. ;      2613    
  3502. ;      2614        IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A;
  3503. ;      2615    
  3504. ;      2616    !
  3505. ;      2617    ! If this is a NAK and the message number is not the one we just send
  3506. ;      2618    ! treat this like an ACK, otherwise resend the last packet.
  3507. ;      2619    !
  3508. ;      2620    
  3509. ;      2621        IF .REC_TYPE EQL MSG_NAK AND (.REC_SEQ NEQ ((.MSG_NUMBER + 1) AND %O'77')) THEN RETURN .STATE;
  3510. ;      2622    
  3511. ;      2623        IF .REC_TYPE EQL MSG_ACK AND .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE;
  3512. ;      2624    
  3513. ;      2625    !
  3514. ;      2626    ! Here to determine if there is another file to send.
  3515. ;      2627    !
  3516. ;      2628        NUM_RETRIES = 0;
  3517. ;      2629        MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  3518. ;      2630    
  3519. ;      2631        IF NOT .ABT_ALL_FILE THEN STATUS = NEXT_FILE () ELSE STATUS = KER_NOMORFILES;
  3520. ;      2632    
  3521. ;      2633        IF ( NOT .STATUS) OR (.STATUS EQL KER_NOMORFILES)
  3522. ;      2634        THEN
  3523. ;      2635        BEGIN
  3524. ;      2636        IF (.STATUS NEQ KER_NOMORFILES) THEN
  3525. ;      2637            RETURN STATE_A
  3526. ;      2638        ELSE
  3527. ;      2639            RETURN STATE_SB;
  3528. ;      2640        END
  3529. ;      2641        ELSE
  3530. ;      2642        BEGIN
  3531. ;      2643        FILE_OPEN_FLAG = TRUE;            ! Have a file open again
  3532. ;      2644        IF .FIL_NORMAL_FORM THEN NORMALIZE_FILE (FILE_NAME, FILE_SIZE, -1, -1);
  3533. ;      2645    
  3534. ;      2646        XFR_STATUS (%C'F', %C'S');        ! Inform display routine
  3535. ;      2647    
  3536. ;      2648        IF ( NOT .CONNECT_FLAG) AND .TY_FIL
  3537. ;      2649        THEN
  3538. ;      2650            BEGIN
  3539. ;      2651            TT_TEXT (UPLIT (%ASCIZ'Sending: '));
  3540. ;      2652            TT_TEXT (FILE_NAME);
  3541. ;      2653            TT_OUTPUT ();
  3542. ;      2654            END;
  3543. ;      2655    
  3544. ;      2656        FILE_CHARS = 0;                ! No characters sent yet
  3545. ;      2657        RETURN STATE_SF;
  3546. ;      2658        END;
  3547. ;      2659    
  3548. ;      2660        END;                    ! End of SEND_EOF
  3549.     .NLIST
  3550.     .LIST    BIN,LOC
  3551.     .LIST
  3552.  
  3553.  
  3554.     .PSECT    $PLIT$,  RO ,  D  
  3555. P.AAG:    .ASCII    /Sen/
  3556.     .ASCII    /din/
  3557.     .ASCII    /g: /
  3558.     .ASCII    <00>
  3559.  
  3560.  
  3561.     .SBTTL    SEND.EOF SEND_EOF
  3562.     .PSECT    $CODE$,  RO 
  3563.  
  3564.     .NLIST
  3565.     .ENABL    LSB
  3566.     .LIST
  3567. ; SEND.EOF
  3568. U.7:    JSR    R1,$SAVE4            ;                    2526
  3569.     CMP    U.77,PKT.RETRIES        ;                    2576
  3570.     BGT    17$
  3571.     INC    U.77                ;                    2582
  3572.     MOVB    #104,U.83+4            ;                    2587
  3573.     BIT    #1,ABT.CUR.FILE            ;                    2589
  3574.     BNE    1$
  3575.     BIT    #1,ABT.ALL.FILE
  3576.     BEQ    2$
  3577. 1$:    MOV    #1,R0                ; *,EOF.MSG.LEN
  3578.     BR    3$
  3579. 2$:    CLR    R0                ; EOF.MSG.LEN
  3580. 3$:    MOV    #132,-(SP)            ;                    2591
  3581.     MOV    R0,-(SP)            ; EOF.MSG.LEN,*
  3582.     MOV    U.78,-(SP)
  3583.     JSR    PC,U.23
  3584.     ADD    #6,SP
  3585.     ROR    R0
  3586.     BLO    4$
  3587.     MOV    #23,R0
  3588.     RTS    PC
  3589. 4$:    JSR    PC,U.25                ;                    2596
  3590.     BIT    #1,R0                ; *,STATUS                2598
  3591.     BNE    8$
  3592.     CMP    R0,#312                ; STATUS,*                2602
  3593.     BEQ    5$
  3594.     CMP    R0,#264                ; STATUS,*
  3595.     BEQ    5$
  3596.     CMP    R0,#162                ; STATUS,*
  3597.     BNE    6$
  3598. 5$:    MOV    U.74,R1                ;                    2600
  3599.     BR    7$
  3600. 6$:    MOV    #23,R1
  3601. 7$:    MOV    R1,R0
  3602.     RTS    PC
  3603. 8$:    MOV    U.81,R1                ;                    2614
  3604.     CLR    R2
  3605.     CMP    R1,#131
  3606.     BNE    9$
  3607.     INC    R2
  3608.     BR    10$
  3609. 9$:    CMP    R1,#116
  3610.     BNE    17$
  3611. 10$:    CMP    R1,#116                ;                    2621
  3612.     BNE    11$
  3613.     MOV    U.78,R1
  3614.     INC    R1
  3615.     MOV    R1,R4
  3616.     BIC    #177700,R4
  3617.     MOV    U.79,R3
  3618.     CMP    R3,R4
  3619.     BNE    12$
  3620. 11$:    ROR    R2                ;                    2623
  3621.     BCC    13$
  3622.     CMP    U.79,U.78
  3623.     BEQ    13$
  3624. 12$:    MOV    U.74,R0
  3625.     RTS    PC
  3626. 13$:    CLR    U.77                ;                    2628
  3627.     MOV    U.78,R1                ;                    2629
  3628.     INC    R1
  3629.     MOV    R1,U.78
  3630.     BIC    #177700,U.78
  3631.     BIT    #1,ABT.ALL.FILE            ;                    2631
  3632.     BNE    14$
  3633.     JSR    PC,NEXT.FILE
  3634.     BR    15$
  3635. 14$:    MOV    #121,R0                ; *,STATUS
  3636. 15$:    BIT    #1,R0                ; *,STATUS                2633
  3637.     BEQ    16$
  3638.     CMP    R0,#121                ; STATUS,*
  3639.     BNE    19$
  3640. 16$:    CMP    R0,#121                ; STATUS,*                2636
  3641.     BEQ    18$
  3642. 17$:    MOV    #12,R0                ;                    2635
  3643.     RTS    PC
  3644. 18$:    MOV    #5,R0
  3645.     RTS    PC                ;                    2565
  3646. 19$:    MOV    #1,U.84                ;                    2643
  3647.     BIT    #1,FIL.NORMAL.FORM        ;                    2644
  3648.     BEQ    20$
  3649.     MOV    #FILE.NAME,-(SP)
  3650.     MOV    #FILE.SIZE,-(SP)
  3651.     MOV    #-1,-(SP)
  3652.     MOV    (SP),-(SP)
  3653.     JSR    PC,U.26
  3654.     ADD    #10,SP
  3655. 20$:    MOV    #106,-(SP)            ;                    2646
  3656.     MOV    #123,-(SP)
  3657.     JSR    PC,XFR.STATUS
  3658.     BIT    #1,CONNECT.FLAG            ;                    2648
  3659.     BNE    21$
  3660.     BIT    #1,TY.FIL
  3661.     BEQ    21$
  3662.     MOV    #P.AAG,(SP)            ;                    2651
  3663.     JSR    PC,TT.TEXT
  3664.     MOV    #FILE.NAME,(SP)            ;                    2652
  3665.     JSR    PC,TT.TEXT
  3666.     JSR    PC,TT.OUTPUT            ;                    2653
  3667. 21$:    CLR    U.85                ;                    2656
  3668.     CMP    (SP)+,(SP)+            ;                    2642
  3669.     MOV    #2,R0                ;                    2565
  3670.     RTS    PC                ;                    2526
  3671. ; Routine Size:  173 words,    Routine Base:  $CODE$ + 4300
  3672. ; Maximum stack depth per invocation:  10 words
  3673.     .NLIST
  3674.     .DSABL    LSB
  3675.     .NLIST    BIN,LOC
  3676.     .LIST
  3677.  
  3678.  
  3679. ;      2661    %SBTTL 'SEND_INIT'
  3680. ;      2662    ROUTINE SEND_INIT =
  3681. ;      2663    
  3682. ;      2664    !++
  3683. ;      2665    ! FUNCTIONAL DESCRIPTION:
  3684. ;      2666    !
  3685. ;      2667    !    This routine will send the initialization packet to the remote
  3686. ;      2668    !    KERMIT.  The message type sent is S.
  3687. ;      2669    !
  3688. ;      2670    ! CALLING SEQUENCE:
  3689. ;      2671    !
  3690. ;      2672    !    STATE = SEND_INIT();
  3691. ;      2673    !
  3692. ;      2674    ! INPUT PARAMETERS:
  3693. ;      2675    !
  3694. ;      2676    !    None.
  3695. ;      2677    !
  3696. ;      2678    ! IMPLICIT INPUTS:
  3697. ;      2679    !
  3698. ;      2680    !    None.
  3699. ;      2681    !
  3700. ;      2682    ! OUTPUT PARAMETERS:
  3701. ;      2683    !
  3702. ;      2684    !    New state to change the finite state machine to.
  3703. ;      2685    !
  3704. ;      2686    ! IMPLICIT OUTPUTS:
  3705. ;      2687    !
  3706. ;      2688    !    None.
  3707. ;      2689    !
  3708. ;      2690    ! COMPLETION CODES:
  3709. ;      2691    !
  3710. ;      2692    !    None.
  3711. ;      2693    !
  3712. ;      2694    ! SIDE EFFECTS:
  3713. ;      2695    !
  3714. ;      2696    !    None.
  3715. ;      2697    !
  3716. ;      2698    !--
  3717. ;      2699    
  3718. ;      2700        BEGIN
  3719. ;      2701    
  3720. ;      2702        LOCAL
  3721. ;      2703        STATUS;                    ! Status returned by various routines
  3722. ;      2704    
  3723. ;      2705        SET_SEND_INIT ();
  3724. ;      2706    
  3725. ;      2707        IF .NUM_RETRIES GTR .SI_RETRIES THEN RETURN STATE_A;
  3726. ;      2708    
  3727. ;      2709    !
  3728. ;      2710    ! Count the number of times we try this
  3729. ;      2711    !
  3730. ;      2712        NUM_RETRIES = .NUM_RETRIES + 1;
  3731. ;      2713    
  3732. ;      2714        IF NOT SEND_PACKET (MSG_SND_INIT, P_SI_LENGTH, .MSG_NUMBER) THEN RETURN STATE_EX;
  3733. ;      2715    
  3734. ;      2716    !
  3735. ;      2717    ! Determine if we received a packet it good condition.  If we timed out or
  3736. ;      2718    ! got an illegal message, just try again.
  3737. ;      2719    !
  3738. ;      2720        STATUS = REC_PACKET ();
  3739. ;      2721    
  3740. ;      2722        IF NOT .STATUS
  3741. ;      2723        THEN
  3742. ;      2724        BEGIN
  3743. ;      2725    
  3744. ;      2726        IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR)
  3745. ;      2727        THEN
  3746. ;      2728            RETURN .STATE
  3747. ;      2729        ELSE
  3748. ;      2730            RETURN STATE_EX;
  3749. ;      2731    
  3750. ;      2732        END;
  3751. ;      2733    
  3752. ;      2734    !
  3753. ;      2735    ! Determine if the packet is good.
  3754. ;      2736    !
  3755. ;      2737    
  3756. ;      2738        IF .REC_TYPE NEQ MSG_ACK THEN RETURN .STATE;
  3757. ;      2739    
  3758. ;      2740        IF .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE;
  3759. ;      2741    
  3760. ;      2742    !
  3761. ;      2743    ! Here if we have an ACK for the initialization message that was just sent
  3762. ;      2744    ! to the remote KERMIT.
  3763. ;      2745    !
  3764. ;      2746    
  3765. ;      2747        IF NOT (STATUS = PRS_SEND_INIT ()) THEN RETURN STATE_A;
  3766. ;      2748    
  3767. ;      2749        BLK_CHK_TYPE = .INI_CHK_TYPE;        ! We now use agreed upon block check type
  3768. ;      2750        NUM_RETRIES = 0;
  3769. ;      2751        MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  3770. ;      2752        RETURN STATE_OF;                ! Now need to open the file
  3771. ;      2753        END;
  3772.     .NLIST
  3773.     .LIST    BIN,LOC
  3774.     .LIST
  3775.  
  3776.     .SBTTL    SEND.INIT SEND_INIT
  3777.     .NLIST
  3778.     .ENABL    LSB
  3779.     .LIST
  3780. ; SEND.INIT
  3781. U.8:    MOV    R1,-(SP)            ;                    2662
  3782.     JSR    PC,U.19                ;                    2705
  3783.     CMP    U.77,SI.RETRIES            ;                    2707
  3784.     BGT    8$
  3785.     INC    U.77                ;                    2712
  3786.     MOV    #123,-(SP)            ;                    2714
  3787.     MOV    #11,-(SP)
  3788.     MOV    U.78,-(SP)
  3789.     JSR    PC,U.23
  3790.     ADD    #6,SP
  3791.     ROR    R0
  3792.     BLO    1$
  3793.     MOV    #23,R0
  3794.     BR    10$
  3795. 1$:    JSR    PC,U.25                ;                    2720
  3796.     BIT    #1,R0                ; *,STATUS                2722
  3797.     BNE    5$
  3798.     CMP    R0,#312                ; STATUS,*                2726
  3799.     BEQ    2$
  3800.     CMP    R0,#264                ; STATUS,*
  3801.     BEQ    2$
  3802.     CMP    R0,#162                ; STATUS,*
  3803.     BNE    3$
  3804. 2$:    MOV    U.74,R1                ;                    2724
  3805.     BR    4$
  3806. 3$:    MOV    #23,R1
  3807. 4$:    MOV    R1,R0
  3808.     BR    10$
  3809. 5$:    CMP    U.81,#131            ;                    2738
  3810.     BNE    6$
  3811.     CMP    U.79,U.78            ;                    2740
  3812.     BEQ    7$
  3813. 6$:    MOV    U.74,R0
  3814.     BR    10$
  3815. 7$:    JSR    PC,U.20                ;                    2747
  3816.     ROR    R0                ; STATUS
  3817.     BLO    9$
  3818. 8$:    MOV    #12,R0
  3819.     BR    10$
  3820. 9$:    MOV    U.70,U.71            ;                    2749
  3821.     CLR    U.77                ;                    2750
  3822.     MOV    U.78,R0                ;                    2751
  3823.     INC    R0
  3824.     MOV    R0,U.78
  3825.     BIC    #177700,U.78
  3826.     MOV    #22,R0                ;                    2700
  3827. 10$:    MOV    (SP)+,R1            ;                    2662
  3828.     RTS    PC
  3829. ; Routine Size:  80 words,    Routine Base:  $CODE$ + 5032
  3830. ; Maximum stack depth per invocation:  5 words
  3831.     .NLIST
  3832.     .DSABL    LSB
  3833.     .NLIST    BIN,LOC
  3834.     .LIST
  3835. ;      2754    %SBTTL 'SEND_OPEN_FILE - Open file for sending'
  3836. ;      2755    ROUTINE SEND_OPEN_FILE =
  3837. ;      2756    
  3838. ;      2757    !++
  3839. ;      2758    ! FUNCTIONAL DESCRIPTION:
  3840. ;      2759    !
  3841. ;      2760    ! This routine is called from DO_TRANSACTION when the first input file
  3842. ;      2761    ! needs to be opened.
  3843. ;      2762    !
  3844. ;      2763    ! CALLING SEQUENCE:
  3845. ;      2764    !
  3846. ;      2765    !    STATE = SEND_OPEN_FILE ();
  3847. ;      2766    !
  3848. ;      2767    ! INPUT PARAMETERS:
  3849. ;      2768    !
  3850. ;      2769    !    None.
  3851. ;      2770    !
  3852. ;      2771    ! IMPLICIT INPUTS:
  3853. ;      2772    !
  3854. ;      2773    !    FILE_NAME, FILE_SIZE, etc.
  3855. ;      2774    !
  3856. ;      2775    ! OUPTUT PARAMETERS:
  3857. ;      2776    !
  3858. ;      2777    !    New state for FSM.
  3859. ;      2778    !
  3860. ;      2779    ! IMPLICIT OUTPUTS:
  3861. ;      2780    !
  3862. ;      2781    !    None.
  3863. ;      2782    !
  3864. ;      2783    ! COMPLETION CODES:
  3865. ;      2784    !
  3866. ;      2785    !    None.
  3867. ;      2786    !
  3868. ;      2787    ! SIDE EFFECTS:
  3869. ;      2788    !
  3870. ;      2789    !    None.
  3871. ;      2790    !
  3872. ;      2791    !--
  3873. ;      2792    
  3874. ;      2793        BEGIN
  3875. ;      2794    
  3876. ;      2795        IF ( NOT .CONNECT_FLAG) AND .TY_FIL
  3877. ;      2796        THEN
  3878. ;      2797        BEGIN
  3879. ;      2798        TT_TEXT (UPLIT (%ASCIZ'Sending: '));
  3880. ;      2799        TT_OUTPUT ();
  3881. ;      2800        END;
  3882. ;      2801    
  3883. ;      2802        FILE_CHARS = 0;                ! No characters sent yet
  3884. ;      2803    
  3885. ;      2804        IF NOT .NO_FILE_NEEDED
  3886. ;      2805        THEN
  3887. ;      2806    
  3888. ;      2807        IF NOT FILE_OPEN (FNC_READ) THEN RETURN STATE_A ELSE FILE_OPEN_FLAG = TRUE;
  3889. ;      2808    
  3890. ;      2809    ![023]
  3891. ;      2810    ![023] If we want normalized file names, beat up the name now
  3892. ;      2811    ![023]
  3893. ;      2812    
  3894. ;      2813        IF .FIL_NORMAL_FORM THEN NORMALIZE_FILE (FILE_NAME, FILE_SIZE, -1, -1);
  3895. ;      2814    
  3896. ;      2815        XFR_STATUS (%C'F', %C'S');            ! Inform display routine
  3897. ;      2816    
  3898. ;      2817        IF ( NOT .CONNECT_FLAG) AND .TY_FIL
  3899. ;      2818        THEN
  3900. ;      2819        BEGIN
  3901. ;      2820        TT_TEXT (FILE_NAME);
  3902. ;      2821        TT_OUTPUT ();
  3903. ;      2822        END;
  3904. ;      2823    
  3905. ;      2824        RETURN STATE_SF;
  3906. ;      2825        END;                    ! End of FSM_OPEN_FILE
  3907.     .NLIST
  3908.     .LIST    BIN,LOC
  3909.     .LIST
  3910.  
  3911.  
  3912.     .PSECT    $PLIT$,  RO ,  D  
  3913. P.AAH:    .ASCII    /Sen/
  3914.     .ASCII    /din/
  3915.     .ASCII    /g: /
  3916.     .ASCII    <00>
  3917.  
  3918.  
  3919.     .SBTTL    SEND.OPEN.FILE SEND_OPEN_FILE - Open file for sending
  3920.     .PSECT    $CODE$,  RO 
  3921.  
  3922.     .NLIST
  3923.     .ENABL    LSB
  3924.     .LIST
  3925. ; SEND.OPEN.FILE
  3926. U.5:    BIT    #1,CONNECT.FLAG            ;                    2795
  3927.     BNE    1$
  3928.     BIT    #1,TY.FIL
  3929.     BEQ    1$
  3930.     MOV    #P.AAH,-(SP)            ;                    2798
  3931.     JSR    PC,TT.TEXT
  3932.     JSR    PC,TT.OUTPUT            ;                    2799
  3933.     TST    (SP)+                ;                    2797
  3934. 1$:    CLR    U.85                ;                    2802
  3935.     BIT    #1,U.87                ;                    2804
  3936.     BNE    3$
  3937.     CLR    -(SP)                ;                    2807
  3938.     JSR    PC,FILE.OPEN
  3939.     TST    (SP)+
  3940.     ROR    R0
  3941.     BLO    2$
  3942.     MOV    #12,R0
  3943.     RTS    PC
  3944. 2$:    MOV    #1,U.84
  3945. 3$:    BIT    #1,FIL.NORMAL.FORM        ;                    2813
  3946.     BEQ    4$
  3947.     MOV    #FILE.NAME,-(SP)
  3948.     MOV    #FILE.SIZE,-(SP)
  3949.     MOV    #-1,-(SP)
  3950.     MOV    (SP),-(SP)
  3951.     JSR    PC,U.26
  3952.     ADD    #10,SP
  3953. 4$:    MOV    #106,-(SP)            ;                    2815
  3954.     MOV    #123,-(SP)
  3955.     JSR    PC,XFR.STATUS
  3956.     BIT    #1,CONNECT.FLAG            ;                    2817
  3957.     BNE    5$
  3958.     BIT    #1,TY.FIL
  3959.     BEQ    5$
  3960.     MOV    #FILE.NAME,(SP)            ;                    2820
  3961.     JSR    PC,TT.TEXT
  3962.     JSR    PC,TT.OUTPUT            ;                    2821
  3963. 5$:    CMP    (SP)+,(SP)+            ;                    2755
  3964.     MOV    #2,R0                ;                    2793
  3965.     RTS    PC                ;                    2755
  3966. ; Routine Size:  72 words,    Routine Base:  $CODE$ + 5272
  3967. ; Maximum stack depth per invocation:  5 words
  3968.     .NLIST
  3969.     .DSABL    LSB
  3970.     .NLIST    BIN,LOC
  3971.     .LIST
  3972.  
  3973.  
  3974. ;      2826    %SBTTL 'SEND_GENCMD'
  3975. ;      2827    ROUTINE SEND_GENCMD =
  3976. ;      2828    
  3977. ;      2829    !++
  3978. ;      2830    ! FUNCTIONAL DESCRIPTION:
  3979. ;      2831    !
  3980. ;      2832    !    This routine will send a command packet to the server Kermit.
  3981. ;      2833    !    The new state will depend upon the response.  If a send-init
  3982. ;      2834    !    is received, it will process it and switch to STATE_RF.
  3983. ;      2835    !    If a text-header is received it will switch to STATE_RD.
  3984. ;      2836    !    If an ACK is received, it will type the data portion and
  3985. ;      2837    !    switch to STATE_C.
  3986. ;      2838    !
  3987. ;      2839    ! CALLING SEQUENCE:
  3988. ;      2840    !
  3989. ;      2841    !    STATE = SEND_GENCMD();
  3990. ;      2842    !
  3991. ;      2843    ! INPUT PARAMETERS:
  3992. ;      2844    !
  3993. ;      2845    !    None.
  3994. ;      2846    !
  3995. ;      2847    ! IMPLICIT INPUTS:
  3996. ;      2848    !
  3997. ;      2849    !    GEN_TYPE - Message type to send (normally MSG_KERMIT)
  3998. ;      2850    !    GEN_SUBTYPE - Message subtype (only if MSG_KERMIT)
  3999. ;      2851    !    GEN_1DATA - First argument string
  4000. ;      2852    !    GEN_1SIZE - Size of first argument
  4001. ;      2853    !    GEN_2DATA - Second argument string
  4002. ;      2854    !    GEN_2SIZE - Size of second argument
  4003. ;      2855    !    GEN_3DATA - Third argument string
  4004. ;      2856    !    GEN_3SIZE - Size of third argument
  4005. ;      2857    !
  4006. ;      2858    ! OUTPUT PARAMETERS:
  4007. ;      2859    !
  4008. ;      2860    !    New state for the finite state machine.
  4009. ;      2861    !
  4010. ;      2862    ! IMPLICIT OUTPUTS:
  4011. ;      2863    !
  4012. ;      2864    !    None.
  4013. ;      2865    !
  4014. ;      2866    ! COMPLETION CODES:
  4015. ;      2867    !
  4016. ;      2868    !    None.
  4017. ;      2869    !
  4018. ;      2870    ! SIDE EFFECTS:
  4019. ;      2871    !
  4020. ;      2872    !    None.
  4021. ;      2873    !
  4022. ;      2874    !--
  4023. ;      2875    
  4024. ;      2876        BEGIN
  4025. ;      2877    
  4026. ;      2878        LOCAL
  4027. ;      2879        POINTER,                ! Pointer at DATA_TEXT
  4028. ;      2880        DATA_TEXT : VECTOR [CH$ALLOCATION (MAX_MSG)],    ! Data buffer
  4029. ;      2881        DATA_SIZE,                ! Length of data buffer used
  4030. ;      2882        STATUS;                    ! Status returned by various routines
  4031. ;      2883    
  4032. ;      2884        ROUTINE PACK_DATA (POINTER, LENGTH, SRC_ADDR, SRC_LEN) =
  4033. ;      2885    !
  4034. ;      2886    ! Routine to pack an argument into the buffer.
  4035. ;      2887    !
  4036. ;      2888        BEGIN
  4037. ;      2889    
  4038. ;      2890        IF .SRC_LEN GTR MAX_MSG - .LENGTH - 1 THEN SRC_LEN = MAX_MSG - .LENGTH - 1;
  4039. ;      2891    
  4040. ;      2892        LENGTH = .LENGTH + .SRC_LEN + 1;
  4041. ;      2893        CH$WCHAR_A (CHAR (.SRC_LEN), .POINTER);
  4042. ;      2894        .POINTER = CH$MOVE (.SRC_LEN, CH$PTR (.SRC_ADDR), ..POINTER);
  4043. ;      2895        RETURN .LENGTH;
  4044. ;      2896        END;
  4045.     .NLIST
  4046.     .LIST    BIN,LOC
  4047.     .LIST
  4048.  
  4049.     .SBTTL    PACK.DATA SEND_GENCMD
  4050.     .NLIST
  4051.     .ENABL    LSB
  4052.     .LIST
  4053. ; PACK.DATA
  4054. U.100:    JSR    R1,$SAVE2            ;                    2884
  4055.     MOV    14(SP),R0            ; LENGTH,*                2890
  4056.     SUB    #137,R0
  4057.     MOV    R0,R1
  4058.     NEG    R1
  4059.     CMP    10(SP),R1            ; SRC.LEN,*
  4060.     BLE    1$
  4061.     NEG    R0
  4062.     MOV    R0,10(SP)            ; *,SRC.LEN
  4063. 1$:    MOV    10(SP),R1            ; SRC.LEN,*                2892
  4064.     MOV    R1,R0
  4065.     ADD    14(SP),R0            ; LENGTH,*
  4066.     MOV    R0,14(SP)            ; *,LENGTH
  4067.     INC    14(SP)                ; LENGTH
  4068.     MOV    @16(SP),R0            ; POINTER,*                2893
  4069.     MOV    R1,R2
  4070.     ADD    #40,R2
  4071.     MOVB    R2,(R0)
  4072.     INC    @16(SP)                ; POINTER
  4073.     MOV    R1,-(SP)            ;                    2894
  4074.     MOV    14(SP),-(SP)            ; SRC.ADDR,*
  4075.     MOV    @22(SP),-(SP)            ; POINTER,*
  4076.     JSR    PC,BL$MOV
  4077.     MOV    R0,@24(SP)            ; *,POINTER
  4078.     ADD    #6,SP                ;                    2884
  4079.     MOV    14(SP),R0            ; LENGTH,*                2888
  4080.     RTS    PC                ;                    2884
  4081. ; Routine Size:  45 words,    Routine Base:  $CODE$ + 5512
  4082. ; Maximum stack depth per invocation:  7 words
  4083.     .NLIST
  4084.     .DSABL    LSB
  4085.     .NLIST    BIN,LOC
  4086.     .LIST
  4087.  
  4088.  
  4089. ;      2897    !
  4090. ;      2898    ! First determine if we have exceed the number of retries that are
  4091. ;      2899    ! allowed to attempt to send this message.
  4092. ;      2900    !
  4093. ;      2901    
  4094. ;      2902        IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  4095. ;      2903    
  4096. ;      2904    !
  4097. ;      2905    ! The number of retries are not exceeded.  Increment the number and then
  4098. ;      2906    ! attempt to send the packet again.
  4099. ;      2907    !
  4100. ;      2908        NUM_RETRIES = .NUM_RETRIES + 1;
  4101. ;      2909    !
  4102. ;      2910    ! Build the packet data field
  4103. ;      2911    !
  4104. ;      2912        POINTER = CH$PTR (DATA_TEXT);
  4105. ;      2913        DATA_SIZE = 0;
  4106. ;      2914    
  4107. ;      2915        IF .GEN_TYPE EQL MSG_KERMIT
  4108. ;      2916        THEN
  4109. ;      2917        BEGIN
  4110. ;      2918        CH$WCHAR_A (.GEN_SUBTYPE, POINTER);
  4111. ;      2919        DATA_SIZE = 1;
  4112. ;      2920    
  4113. ;      2921        IF .GEN_1SIZE GTR 0 OR .GEN_2SIZE GTR 0 OR .GEN_3SIZE GTR 0
  4114. ;      2922        THEN
  4115. ;      2923            BEGIN
  4116. ;      2924            DATA_SIZE = PACK_DATA (POINTER, .DATA_SIZE, GEN_1DATA, .GEN_1SIZE);
  4117. ;      2925    
  4118. ;      2926            IF .GEN_2SIZE GTR 0 OR .GEN_3SIZE GTR 0
  4119. ;      2927            THEN
  4120. ;      2928            BEGIN
  4121. ;      2929            DATA_SIZE = PACK_DATA (POINTER, .DATA_SIZE, GEN_2DATA, .GEN_2SIZE);
  4122. ;      2930    
  4123. ;      2931            IF .GEN_3SIZE GTR 0
  4124. ;      2932            THEN
  4125. ;      2933                BEGIN
  4126. ;      2934                DATA_SIZE = PACK_DATA (POINTER, .DATA_SIZE, GEN_3DATA, .GEN_3SIZE);
  4127. ;      2935                END;
  4128. ;      2936    
  4129. ;      2937            END;
  4130. ;      2938    
  4131. ;      2939            END;
  4132. ;      2940    
  4133. ;      2941        END
  4134. ;      2942        ELSE
  4135. ;      2943        BEGIN
  4136. ;      2944    
  4137. ;      2945        IF .GEN_1SIZE GTR MAX_MSG THEN GEN_1SIZE = MAX_MSG;
  4138. ;      2946    
  4139. ;      2947        DATA_SIZE = .GEN_1SIZE;
  4140. ;      2948        CH$MOVE (.GEN_1SIZE, CH$PTR (GEN_1DATA), .POINTER);
  4141. ;      2949        END;
  4142. ;      2950    
  4143. ;      2951        SET_STRING (CH$PTR (DATA_TEXT), .DATA_SIZE, TRUE);
  4144. ;      2952        BFR_FILL (TRUE);
  4145. ;      2953        SET_STRING (0, 0, FALSE);
  4146. ;      2954    !
  4147. ;      2955    ! Send the packet
  4148. ;      2956    !
  4149. ;      2957    
  4150. ;      2958        IF NOT SEND_PACKET (.GEN_TYPE, .SIZE, .MSG_NUMBER) THEN RETURN STATE_EX;
  4151. ;      2959    
  4152. ;      2960    !
  4153. ;      2961    ! Now get the responce from the remote KERMIT.
  4154. ;      2962    !
  4155. ;      2963        STATUS = REC_PACKET ();
  4156. ;      2964    
  4157. ;      2965        IF NOT .STATUS
  4158. ;      2966        THEN
  4159. ;      2967        BEGIN
  4160. ;      2968    
  4161. ;      2969        IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR)
  4162. ;      2970        THEN
  4163. ;      2971            RETURN .STATE
  4164. ;      2972        ELSE
  4165. ;      2973            RETURN STATE_EX;
  4166. ;      2974    
  4167. ;      2975        END;
  4168. ;      2976    
  4169. ;      2977    ! Did we get a send-init?
  4170. ;      2978    
  4171. ;      2979        SELECTONE .REC_TYPE OF
  4172. ;      2980        SET
  4173. ;      2981    
  4174. ;      2982        [MSG_SND_INIT] :
  4175. ;      2983            BEGIN
  4176. ;      2984            MSG_NUMBER = .REC_SEQ;        ! Initialize sequence numbers
  4177. ;      2985    ! Determine if the parameters are ok.  If not, give up
  4178. ;      2986    
  4179. ;      2987            IF NOT (STATUS = PRS_SEND_INIT ()) THEN RETURN .STATUS;
  4180. ;      2988    
  4181. ;      2989            SET_SEND_INIT ();            ! Set up our acknowledgement to the send-init
  4182. ;      2990            SEND_PACKET (MSG_ACK, P_SI_LENGTH, .MSG_NUMBER);    ! Send it
  4183. ;      2991            BLK_CHK_TYPE = .INI_CHK_TYPE;    ! Can now use agreed upon type
  4184. ;      2992            OLD_RETRIES = .NUM_RETRIES;
  4185. ;      2993            NUM_RETRIES = 0;
  4186. ;      2994            MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  4187. ;      2995            RETURN STATE_RF;            ! Now expect file header
  4188. ;      2996            END;
  4189. ;      2997    
  4190. ;      2998        [MSG_TEXT] :
  4191. ;      2999    !
  4192. ;      3000    ! If we just got a text header, set up for typing on the terminal and
  4193. ;      3001    ! shift to receiving data
  4194. ;      3002    !
  4195. ;      3003            BEGIN
  4196. ;      3004            TEXT_HEAD_FLAG = TRUE;        ! We want terminal output
  4197. ;      3005            PUT_CHR_ROUTINE = TYPE_CHAR;    ! Set up the put a character routine
  4198. ;      3006            BFR_EMPTY ();            ! Dump the packet data to the terminal
  4199. ;      3007            TT_CRLF ();                ! And a CRLF
  4200. ;      3008            TT_OUTPUT ();            ! Dump the output
  4201. ;      3009            SEND_PACKET (MSG_ACK, 0, .MSG_NUMBER);    ! Send an ACK
  4202. ;      3010            OLD_RETRIES = .NUM_RETRIES;
  4203. ;      3011            NUM_RETRIES = 0;
  4204. ;      3012            MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  4205. ;      3013            RETURN STATE_RD;            ! We now want data
  4206. ;      3014            END;
  4207. ;      3015    
  4208. ;      3016        [MSG_ACK] :
  4209. ;      3017    !
  4210. ;      3018    ! If we get an ACK, just type the data on the terminal and complete the
  4211. ;      3019    ! transaction.
  4212. ;      3020    !
  4213. ;      3021            BEGIN
  4214. ;      3022            PUT_CHR_ROUTINE = TYPE_CHAR;    ! Dump to terminal
  4215. ;      3023            BFR_EMPTY ();            ! Do it
  4216. ;      3024    
  4217. ;      3025            IF .REC_LENGTH GTR 0 THEN TT_CRLF ();
  4218. ;      3026    
  4219. ;      3027            RETURN STATE_C;            ! And go idle
  4220. ;      3028            END;
  4221. ;      3029    
  4222. ;      3030        [MSG_NAK] :
  4223. ;      3031    !
  4224. ;      3032    ! If we get a NAK, stay in the same state.  We will re-transmit the
  4225. ;      3033    ! packet again.
  4226. ;      3034    !
  4227. ;      3035            RETURN .STATE;
  4228. ;      3036        TES;
  4229. ;      3037    
  4230. ;      3038    !
  4231. ;      3039    ! If we get here, we didn't get anything resembling an acceptable
  4232. ;      3040    ! packet, so we will abort.
  4233. ;      3041    !
  4234. ;      3042        RETURN STATE_A;
  4235. ;      3043        END;
  4236.     .NLIST
  4237.     .LIST    BIN,LOC
  4238.     .LIST
  4239.  
  4240.     .SBTTL    SEND.GENCMD SEND_GENCMD
  4241.     .NLIST
  4242.     .ENABL    LSB
  4243.     .LIST
  4244. ; SEND.GENCMD
  4245. U.6:    MOV    R1,-(SP)            ;                    2827
  4246.     SUB    #142,SP
  4247.     CMP    U.77,PKT.RETRIES        ;                    2902
  4248.     BLE    1$
  4249.     JMP    21$
  4250. 1$:    INC    U.77                ;                    2908
  4251.     MOV    #2,(SP)                ; *,POINTER                2912
  4252.     ADD    SP,(SP)                ; DATA.TEXT,POINTER
  4253.     CLR    R1                ; DATA.SIZE                2913
  4254.     MOV    GEN.1SIZE,R0            ;                    2921
  4255.     CMP    U.89,#107            ;                    2915
  4256.     BNE    6$
  4257.     MOVB    U.90,@0(SP)            ; *,POINTER                2918
  4258.     INC    (SP)                ; POINTER
  4259.     MOV    #1,R1                ; *,DATA.SIZE                2919
  4260.     TST    R0                ;                    2921
  4261.     BGT    2$
  4262.     TST    GEN.2SIZE
  4263.     BGT    2$
  4264.     TST    GEN.3SIZE
  4265.     BLE    8$
  4266. 2$:    MOV    #2,-(SP)            ;                    2924
  4267.     ADD    SP,(SP)                ; POINTER,*
  4268.     MOV    R1,-(SP)            ; DATA.SIZE,*
  4269.     MOV    #GEN.1DATA,-(SP)
  4270.     MOV    R0,-(SP)
  4271.     JSR    PC,U.100
  4272.     MOV    R0,R1                ; *,DATA.SIZE
  4273.     MOV    GEN.2SIZE,R0            ;                    2926
  4274.     BGT    3$
  4275.     TST    GEN.3SIZE
  4276.     BLE    5$
  4277. 3$:    MOV    #10,(SP)            ;                    2929
  4278.     ADD    SP,(SP)                ; POINTER,*
  4279.     MOV    R1,-(SP)            ; DATA.SIZE,*
  4280.     MOV    #GEN.2DATA,-(SP)
  4281.     MOV    R0,-(SP)
  4282.     JSR    PC,U.100
  4283.     MOV    R0,R1                ; *,DATA.SIZE
  4284.     MOV    GEN.3SIZE,R0            ;                    2931
  4285.     BLE    4$
  4286.     MOV    #16,(SP)            ;                    2934
  4287.     ADD    SP,(SP)                ; POINTER,*
  4288.     MOV    R1,-(SP)            ; DATA.SIZE,*
  4289.     MOV    #GEN.3DATA,-(SP)
  4290.     MOV    R0,-(SP)
  4291.     JSR    PC,U.100
  4292.     MOV    R0,R1                ; *,DATA.SIZE
  4293.     ADD    #6,SP                ;                    2933
  4294. 4$:    ADD    #6,SP                ;                    2928
  4295. 5$:    ADD    #10,SP                ;                    2923
  4296.     BR    8$                ;                    2915
  4297. 6$:    CMP    R0,#140                ;                    2945
  4298.     BLE    7$
  4299.     MOV    #140,GEN.1SIZE
  4300. 7$:    MOV    GEN.1SIZE,R1            ; *,DATA.SIZE                2947
  4301.     MOV    R1,-(SP)            ; GEN.1SIZE,*                2948
  4302.     MOV    #GEN.1DATA,-(SP)
  4303.     MOV    4(SP),-(SP)            ; POINTER,*
  4304.     JSR    PC,BL$MOV
  4305.     ADD    #6,SP                ;                    2943
  4306. 8$:    MOV    #4,-(SP)            ;                    2951
  4307.     ADD    SP,(SP)                ; DATA.TEXT,*
  4308.     MOV    R1,-(SP)            ; DATA.SIZE,*
  4309.     MOV    #1,-(SP)
  4310.     JSR    PC,U.29
  4311.     MOV    #1,(SP)                ;                    2952
  4312.     JSR    PC,U.28
  4313.     CLR    (SP)                ;                    2953
  4314.     CLR    -(SP)
  4315.     CLR    -(SP)
  4316.     JSR    PC,U.29
  4317.     MOV    U.89,(SP)            ;                    2958
  4318.     MOV    U.75,-(SP)
  4319.     MOV    U.78,-(SP)
  4320.     JSR    PC,U.23
  4321.     CMP    (SP)+,(SP)+
  4322.     ROR    R0
  4323.     BLO    9$
  4324.     ADD    #12,SP
  4325.     MOV    #23,R0
  4326.     BR    18$
  4327. 9$:    JSR    PC,U.25                ;                    2963
  4328.     BIT    #1,R0                ; *,STATUS                2965
  4329.     BNE    13$
  4330.     CMP    R0,#312                ; STATUS,*                2969
  4331.     BEQ    10$
  4332.     CMP    R0,#264                ; STATUS,*
  4333.     BEQ    10$
  4334.     CMP    R0,#162                ; STATUS,*
  4335.     BNE    11$
  4336. 10$:    MOV    U.74,R1                ;                    2967
  4337.     BR    12$
  4338. 11$:    MOV    #23,R1
  4339. 12$:    ADD    #12,SP                ;                    2965
  4340.     MOV    R1,R0                ;                    2967
  4341.     BR    22$
  4342. 13$:    MOV    U.81,R1                ;                    2979
  4343.     CMP    R1,#123
  4344.     BNE    15$
  4345.     MOV    U.79,U.78            ;                    2984
  4346.     JSR    PC,U.20                ;                    2987
  4347.     BIT    #1,R0                ; *,STATUS
  4348.     BNE    14$
  4349.     ADD    #12,SP
  4350.     BR    22$
  4351. 14$:    JSR    PC,U.19                ;                    2989
  4352.     MOV    #131,(SP)            ;                    2990
  4353.     MOV    #11,-(SP)
  4354.     MOV    U.78,-(SP)
  4355.     JSR    PC,U.23
  4356.     MOV    U.70,U.71            ;                    2991
  4357.     MOV    U.77,U.76            ;                    2992
  4358.     CLR    U.77                ;                    2993
  4359.     MOV    U.78,R0                ;                    2994
  4360.     INC    R0
  4361.     MOV    R0,U.78
  4362.     BIC    #177700,U.78
  4363.     ADD    #16,SP                ;                    2979
  4364.     MOV    #7,R0                ;                    2983
  4365.     BR    22$
  4366. 15$:    CMP    R1,#130                ;                    2979
  4367.     BNE    16$
  4368.     MOV    #1,U.86                ;                    3004
  4369.     MOV    #U.30,U.92            ;                    3005
  4370.     JSR    PC,U.27                ;                    3006
  4371.     JSR    PC,TT.CRLF            ;                    3007
  4372.     JSR    PC,TT.OUTPUT            ;                    3008
  4373.     MOV    #131,(SP)            ;                    3009
  4374.     CLR    -(SP)
  4375.     MOV    U.78,-(SP)
  4376.     JSR    PC,U.23
  4377.     MOV    U.77,U.76            ;                    3010
  4378.     CLR    U.77                ;                    3011
  4379.     MOV    U.78,R0                ;                    3012
  4380.     INC    R0
  4381.     MOV    R0,U.78
  4382.     BIC    #177700,U.78
  4383.     ADD    #16,SP                ;                    2979
  4384.     MOV    #10,R0                ;                    3003
  4385.     BR    22$
  4386. 16$:    CMP    R1,#131                ;                    2979
  4387.     BNE    19$
  4388.     MOV    #U.30,U.92            ;                    3022
  4389.     JSR    PC,U.27                ;                    3023
  4390.     TST    U.80                ;                    3025
  4391.     BLE    17$
  4392.     JSR    PC,TT.CRLF
  4393. 17$:    ADD    #12,SP                ;                    2979
  4394.     MOV    #11,R0                ;                    3021
  4395. 18$:    BR    22$
  4396. 19$:    CMP    R1,#116                ;                    2979
  4397.     BNE    20$
  4398.     ADD    #12,SP                ;                    3035
  4399.     MOV    U.74,R0
  4400.     BR    22$
  4401. 20$:    ADD    #12,SP                ;                    2827
  4402. 21$:    MOV    #12,R0                ;                    2876
  4403. 22$:    ADD    #142,SP                ;                    2827
  4404.     MOV    (SP)+,R1
  4405.     RTS    PC
  4406. ; Routine Size:  275 words,    Routine Base:  $CODE$ + 5644
  4407. ; Maximum stack depth per invocation:  61 words
  4408.     .NLIST
  4409.     .DSABL    LSB
  4410.     .NLIST    BIN,LOC
  4411.     .LIST
  4412.  
  4413.  
  4414. ;      3044    %SBTTL 'SEND_BREAK'
  4415. ;      3045    ROUTINE SEND_BREAK =
  4416. ;      3046    
  4417. ;      3047    !++
  4418. ;      3048    ! FUNCTIONAL DESCRIPTION:
  4419. ;      3049    !
  4420. ;      3050    !    This routine will send the break (end of transmission) message
  4421. ;      3051    !    to the remote KERMIT.  On an ACK the state becomes STATE_C.
  4422. ;      3052    !
  4423. ;      3053    ! CALLING SEQUENCE:
  4424. ;      3054    !
  4425. ;      3055    !    STATE = SEND_BREAK();
  4426. ;      3056    !
  4427. ;      3057    ! INPUT PARAMETERS:
  4428. ;      3058    !
  4429. ;      3059    !    None.
  4430. ;      3060    !
  4431. ;      3061    ! IMPLICIT INPUTS:
  4432. ;      3062    !
  4433. ;      3063    !    None.
  4434. ;      3064    !
  4435. ;      3065    ! OUTPUT PARAMETERS:
  4436. ;      3066    !
  4437. ;      3067    !    New state for the finite state machine.
  4438. ;      3068    !
  4439. ;      3069    ! IMPLICIT OUTPUTS:
  4440. ;      3070    !
  4441. ;      3071    !    None.
  4442. ;      3072    !
  4443. ;      3073    ! COMPLETION CODES:
  4444. ;      3074    !
  4445. ;      3075    !    None.
  4446. ;      3076    !
  4447. ;      3077    ! SIDE EFFECTS:
  4448. ;      3078    !
  4449. ;      3079    !    None.
  4450. ;      3080    !
  4451. ;      3081    !--
  4452. ;      3082    
  4453. ;      3083        BEGIN
  4454. ;      3084    
  4455. ;      3085        LOCAL
  4456. ;      3086        STATUS;                    ! Status returned by various routines
  4457. ;      3087    
  4458. ;      3088    !
  4459. ;      3089    ! First determine if we have exceed the number of retries that are
  4460. ;      3090    ! allowed to attempt to send this message.
  4461. ;      3091    !
  4462. ;      3092    
  4463. ;      3093        IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  4464. ;      3094    
  4465. ;      3095    !
  4466. ;      3096    ! The number of retries are not exceeded.  Increment the number and then
  4467. ;      3097    ! attempt to send the packet again.
  4468. ;      3098    !
  4469. ;      3099        NUM_RETRIES = .NUM_RETRIES + 1;
  4470. ;      3100    
  4471. ;      3101        IF NOT SEND_PACKET (MSG_BREAK, 0, .MSG_NUMBER) THEN RETURN STATE_EX;
  4472. ;      3102    
  4473. ;      3103    !
  4474. ;      3104    ! Now get the responce from the remote KERMIT.
  4475. ;      3105    !
  4476. ;      3106        STATUS = REC_PACKET ();
  4477. ;      3107    
  4478. ;      3108        IF NOT .STATUS
  4479. ;      3109        THEN
  4480. ;      3110        BEGIN
  4481. ;      3111    
  4482. ;      3112        IF (.STATUS EQL KER_ZEROLENMSG) OR (.STATUS EQL KER_TIMEOUT) OR (.STATUS EQL KER_CHKSUMERR)
  4483. ;      3113        THEN
  4484. ;      3114            RETURN .STATE
  4485. ;      3115        ELSE
  4486. ;      3116            RETURN STATE_EX;
  4487. ;      3117    
  4488. ;      3118        END;
  4489. ;      3119    
  4490. ;      3120    !
  4491. ;      3121    ! Determine if the packet is good.
  4492. ;      3122    !
  4493. ;      3123    
  4494. ;      3124        IF NOT (.REC_TYPE EQL MSG_ACK OR .REC_TYPE EQL MSG_NAK) THEN RETURN STATE_A;
  4495. ;      3125    
  4496. ;      3126    !
  4497. ;      3127    ! If this is a NAK and the message number is not the one we just send
  4498. ;      3128    ! treat this like an ACK, otherwise resend the last packet.
  4499. ;      3129    !
  4500. ;      3130    
  4501. ;      3131        IF .REC_TYPE EQL MSG_NAK AND .REC_SEQ NEQ 0 THEN RETURN .STATE;
  4502. ;      3132    
  4503. ;      3133        IF .REC_TYPE EQL MSG_ACK AND .REC_SEQ NEQ .MSG_NUMBER THEN RETURN .STATE;
  4504. ;      3134    
  4505. ;      3135    !
  4506. ;      3136    ! Here to determine if there is another file to send.
  4507. ;      3137    !
  4508. ;      3138        NUM_RETRIES = 0;
  4509. ;      3139        MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  4510. ;      3140        RETURN STATE_C;
  4511. ;      3141        END;
  4512.     .NLIST
  4513.     .LIST    BIN,LOC
  4514.     .LIST
  4515.  
  4516.     .SBTTL    SEND.BREAK SEND_BREAK
  4517.     .NLIST
  4518.     .ENABL    LSB
  4519.     .LIST
  4520. ; SEND.BREAK
  4521. U.9:    MOV    R1,-(SP)            ;                    3045
  4522.     CMP    U.77,PKT.RETRIES        ;                    3093
  4523.     BGT    4$
  4524.     INC    U.77                ;                    3099
  4525.     MOV    #102,-(SP)            ;                    3101
  4526.     CLR    -(SP)
  4527.     MOV    U.78,-(SP)
  4528.     JSR    PC,U.23
  4529.     ADD    #6,SP
  4530.     ROR    R0
  4531.     BHIS    1$
  4532.     JSR    PC,U.25                ;                    3106
  4533.     BIT    #1,R0                ; *,STATUS                3108
  4534.     BNE    2$
  4535.     CMP    R0,#312                ; STATUS,*                3112
  4536.     BEQ    8$
  4537.     CMP    R0,#264                ; STATUS,*
  4538.     BEQ    8$
  4539.     CMP    R0,#162                ; STATUS,*
  4540.     BEQ    8$                ;                    3110
  4541. 1$:    MOV    #23,R0
  4542.     BR    10$
  4543. 2$:    MOV    U.81,R0                ;                    3124
  4544.     CLR    R1
  4545.     CMP    R0,#131
  4546.     BNE    3$
  4547.     INC    R1
  4548.     BR    5$
  4549. 3$:    CMP    R0,#116
  4550.     BEQ    6$
  4551. 4$:    MOV    #12,R0
  4552.     BR    10$
  4553. 5$:    CMP    R0,#116                ;                    3131
  4554.     BNE    7$
  4555. 6$:    TST    U.79
  4556.     BNE    8$
  4557. 7$:    ROR    R1                ;                    3133
  4558.     BCC    9$
  4559.     CMP    U.79,U.78
  4560.     BEQ    9$
  4561. 8$:    MOV    U.74,R0
  4562.     BR    10$
  4563. 9$:    CLR    U.77                ;                    3138
  4564.     MOV    U.78,R0                ;                    3139
  4565.     INC    R0
  4566.     MOV    R0,U.78
  4567.     BIC    #177700,U.78
  4568.     MOV    #11,R0                ;                    3083
  4569. 10$:    MOV    (SP)+,R1            ;                    3045
  4570.     RTS    PC
  4571. ; Routine Size:  78 words,    Routine Base:  $CODE$ + 6712
  4572. ; Maximum stack depth per invocation:  5 words
  4573.     .NLIST
  4574.     .DSABL    LSB
  4575.     .NLIST    BIN,LOC
  4576.     .LIST
  4577.  
  4578.  
  4579. ;      3142    %SBTTL 'REC_INIT'
  4580. ;      3143    ROUTINE REC_INIT =
  4581. ;      3144    
  4582. ;      3145    !++
  4583. ;      3146    ! FUNCTIONAL DESCRIPTION:
  4584. ;      3147    !
  4585. ;      3148    !    This routine will process an initialization message received from
  4586. ;      3149    !    the remote KERMIT.
  4587. ;      3150    !
  4588. ;      3151    ! CALLING SEQUENCE:
  4589. ;      3152    !
  4590. ;      3153    !    STATE = REC_INIT();
  4591. ;      3154    !
  4592. ;      3155    ! INPUT PARAMETERS:
  4593. ;      3156    !
  4594. ;      3157    !    None.
  4595. ;      3158    !
  4596. ;      3159    ! IMPLICIT INPUTS:
  4597. ;      3160    !
  4598. ;      3161    !    None.
  4599. ;      3162    !
  4600. ;      3163    ! OUTPUT PARAMETERS:
  4601. ;      3164    !
  4602. ;      3165    !    New machine state.
  4603. ;      3166    !
  4604. ;      3167    ! IMPLICIT OUTPUTS:
  4605. ;      3168    !
  4606. ;      3169    !    None.
  4607. ;      3170    !
  4608. ;      3171    ! COMPLETION CODES:
  4609. ;      3172    !
  4610. ;      3173    !    None.
  4611. ;      3174    !
  4612. ;      3175    ! SIDE EFFECTS:
  4613. ;      3176    !
  4614. ;      3177    !    None.
  4615. ;      3178    !
  4616. ;      3179    !--
  4617. ;      3180    
  4618. ;      3181        BEGIN
  4619. ;      3182    
  4620. ;      3183        LOCAL
  4621. ;      3184        STATUS;                    ! Status returned by various routines
  4622. ;      3185    
  4623. ;      3186        ROUTINE CHECK_INIT =
  4624. ;      3187        BEGIN
  4625. ;      3188    
  4626. ;      3189        IF .REC_TYPE EQL MSG_SND_INIT THEN RETURN TRUE ELSE RETURN FALSE;
  4627. ;      3190    
  4628. ;      3191        END;
  4629.     .NLIST
  4630.     .LIST    BIN,LOC
  4631.     .LIST
  4632.  
  4633.     .SBTTL    CHECK.INIT REC_INIT
  4634.     .NLIST
  4635.     .ENABL    LSB
  4636.     .LIST
  4637. ; CHECK.INIT
  4638. U.101:    CMP    U.81,#123            ;                    3189
  4639.     BNE    1$
  4640.     MOV    #1,R0                ;                    3187
  4641.     RTS    PC
  4642. 1$:    CLR    R0
  4643.     RTS    PC                ;                    3186
  4644. ; Routine Size:  9 words,    Routine Base:  $CODE$ + 7146
  4645. ; Maximum stack depth per invocation:  0 words
  4646.     .NLIST
  4647.     .DSABL    LSB
  4648.     .NLIST    BIN,LOC
  4649.     .LIST
  4650.  
  4651.  
  4652. ;      3192    
  4653. ;      3193        IF NOT (STATUS = REC_MESSAGE (CHECK_INIT))
  4654. ;      3194        THEN
  4655. ;      3195    
  4656. ;      3196        IF .STATUS NEQ KER_ABORTED THEN RETURN STATE_A ELSE RETURN STATE_EX;
  4657. ;      3197    
  4658. ;      3198        MSG_NUMBER = .REC_SEQ;
  4659. ;      3199    
  4660. ;      3200        IF NOT (STATUS = PRS_SEND_INIT ()) THEN RETURN STATE_A;
  4661. ;      3201    
  4662. ;      3202        SET_SEND_INIT ();
  4663. ;      3203        SEND_PACKET (MSG_ACK, P_SI_LENGTH, .MSG_NUMBER);
  4664. ;      3204        BLK_CHK_TYPE = .INI_CHK_TYPE;        ! Can now use agreed upon type
  4665. ;      3205        OLD_RETRIES = .NUM_RETRIES;
  4666. ;      3206        NUM_RETRIES = 0;
  4667. ;      3207        MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  4668. ;      3208        RETURN STATE_RF;
  4669. ;      3209        END;                    ! End of REC_INIT
  4670.     .NLIST
  4671.     .LIST    BIN,LOC
  4672.     .LIST
  4673.  
  4674.     .SBTTL    REC.INIT REC_INIT
  4675.     .NLIST
  4676.     .ENABL    LSB
  4677.     .LIST
  4678. ; REC.INIT
  4679. U.11:    MOV    R1,-(SP)            ;                    3143
  4680.     MOV    #U.101,-(SP)            ;                    3193
  4681.     JSR    PC,U.24
  4682.     TST    (SP)+
  4683.     BIT    #1,R0                ; *,STATUS
  4684.     BNE    3$
  4685.     CMP    R0,#272                ; STATUS,*                3196
  4686.     BEQ    1$
  4687.     MOV    #12,R1                ;                    3193
  4688.     BR    2$
  4689. 1$:    MOV    #23,R1
  4690. 2$:    MOV    R1,R0                ;                    3196
  4691.     BR    5$
  4692. 3$:    MOV    U.79,U.78            ;                    3198
  4693.     JSR    PC,U.20                ;                    3200
  4694.     ROR    R0                ; STATUS
  4695.     BLO    4$
  4696.     MOV    #12,R0
  4697.     BR    5$
  4698. 4$:    JSR    PC,U.19                ;                    3202
  4699.     MOV    #131,-(SP)            ;                    3203
  4700.     MOV    #11,-(SP)
  4701.     MOV    U.78,-(SP)
  4702.     JSR    PC,U.23
  4703.     MOV    U.70,U.71            ;                    3204
  4704.     MOV    U.77,U.76            ;                    3205
  4705.     CLR    U.77                ;                    3206
  4706.     MOV    U.78,R0                ;                    3207
  4707.     INC    R0
  4708.     MOV    R0,U.78
  4709.     BIC    #177700,U.78
  4710.     ADD    #6,SP                ;                    3143
  4711.     MOV    #7,R0                ;                    3181
  4712. 5$:    MOV    (SP)+,R1            ;                    3143
  4713.     RTS    PC
  4714. ; Routine Size:  61 words,    Routine Base:  $CODE$ + 7170
  4715. ; Maximum stack depth per invocation:  5 words
  4716.     .NLIST
  4717.     .DSABL    LSB
  4718.     .NLIST    BIN,LOC
  4719.     .LIST
  4720.  
  4721.  
  4722. ;      3210    %SBTTL 'REC_FILE'
  4723. ;      3211    ROUTINE REC_FILE =
  4724. ;      3212    
  4725. ;      3213    !++
  4726. ;      3214    ! FUNCTIONAL DESCRIPTION:
  4727. ;      3215    !
  4728. ;      3216    !    This routine expects to receive an MSG_FILE packet from the remote
  4729. ;      3217    !    KERMIT.  If the message is correct this routine will change the state
  4730. ;      3218    !    to STATE_RD.
  4731. ;      3219    !
  4732. ;      3220    !    This routine also expects MSG_SND_INIT, MSG_EOF, or MSG_BREAK.
  4733. ;      3221    !
  4734. ;      3222    ! CALLING SEQUENCE:
  4735. ;      3223    !
  4736. ;      3224    !    STATE = REC_FILE();
  4737. ;      3225    !
  4738. ;      3226    ! INPUT PARAMETERS:
  4739. ;      3227    !
  4740. ;      3228    !    None.
  4741. ;      3229    !
  4742. ;      3230    ! IMPLICIT INPUTS:
  4743. ;      3231    !
  4744. ;      3232    !    None.
  4745. ;      3233    !
  4746. ;      3234    ! OUTPUT PARAMETERS:
  4747. ;      3235    !
  4748. ;      3236    !    New state.
  4749. ;      3237    !
  4750. ;      3238    ! IMPLICIT OUTPUTS:
  4751. ;      3239    !
  4752. ;      3240    !    None.
  4753. ;      3241    !
  4754. ;      3242    ! COMPLETION CODES:
  4755. ;      3243    !
  4756. ;      3244    !    None.
  4757. ;      3245    !
  4758. ;      3246    ! SIDE EFFECTS:
  4759. ;      3247    !
  4760. ;      3248    !    None.
  4761. ;      3249    !
  4762. ;      3250    !--
  4763. ;      3251    
  4764. ;      3252        BEGIN
  4765. ;      3253    
  4766. ;      3254        LOCAL
  4767. ;      3255        STATUS;
  4768. ;      3256    
  4769. ;      3257        ROUTINE CHECK_FILE =
  4770. ;      3258        BEGIN
  4771. ;      3259    
  4772. ;      3260        IF (.REC_TYPE EQL MSG_SND_INIT) OR (.REC_TYPE EQL MSG_EOF) OR (.REC_TYPE EQL MSG_FILE) OR (
  4773. ;      3261            .REC_TYPE EQL MSG_BREAK) OR (.REC_TYPE EQL MSG_TEXT)
  4774. ;      3262        THEN
  4775. ;      3263            RETURN TRUE
  4776. ;      3264        ELSE
  4777. ;      3265            RETURN FALSE;
  4778. ;      3266    
  4779. ;      3267        END;
  4780.     .NLIST
  4781.     .LIST    BIN,LOC
  4782.     .LIST
  4783.  
  4784.     .SBTTL    CHECK.FILE REC_FILE
  4785.     .NLIST
  4786.     .ENABL    LSB
  4787.     .LIST
  4788. ; CHECK.FILE
  4789. U.102:    MOV    U.81,R0                ;                    3260
  4790.     CMP    R0,#123
  4791.     BEQ    1$
  4792.     CMP    R0,#132
  4793.     BEQ    1$
  4794.     CMP    R0,#106
  4795.     BEQ    1$
  4796.     CMP    R0,#102
  4797.     BEQ    1$
  4798.     CMP    R0,#130                ;                    3261
  4799.     BNE    2$
  4800. 1$:    MOV    #1,R0                ;                    3258
  4801.     RTS    PC
  4802. 2$:    CLR    R0
  4803.     RTS    PC                ;                    3257
  4804. ; Routine Size:  22 words,    Routine Base:  $CODE$ + 7362
  4805. ; Maximum stack depth per invocation:  0 words
  4806.     .NLIST
  4807.     .DSABL    LSB
  4808.     .NLIST    BIN,LOC
  4809.     .LIST
  4810.  
  4811.  
  4812. ;      3268    !
  4813. ;      3269    ! Initialize the abort flags
  4814. ;      3270    !
  4815. ;      3271        ABT_CUR_FILE = FALSE;
  4816. ;      3272        ABT_ALL_FILE = FALSE;
  4817. ;      3273    !
  4818. ;      3274    ! Get a message
  4819. ;      3275    !
  4820. ;      3276    
  4821. ;      3277        IF NOT (STATUS = REC_MESSAGE (CHECK_FILE))
  4822. ;      3278        THEN
  4823. ;      3279    
  4824. ;      3280        IF .STATUS NEQ KER_ABORTED THEN RETURN STATE_A ELSE RETURN STATE_EX;
  4825. ;      3281    
  4826. ;      3282        SELECTONE .REC_TYPE OF
  4827. ;      3283        SET
  4828. ;      3284    
  4829. ;      3285        [MSG_SND_INIT] :
  4830. ;      3286            BEGIN
  4831. ;      3287    
  4832. ;      3288            IF .OLD_RETRIES GTR .SI_RETRIES THEN RETURN STATE_A;
  4833. ;      3289    
  4834. ;      3290            OLD_RETRIES = .OLD_RETRIES + 1;
  4835. ;      3291    
  4836. ;      3292            IF ((.MSG_NUMBER - 1) AND %O'77') EQL .REC_SEQ
  4837. ;      3293            THEN
  4838. ;      3294            BEGIN
  4839. ;      3295            SET_SEND_INIT ();
  4840. ;      3296            BLK_CHK_TYPE = CHK_1CHAR;    ! Must use 1 character CHKSUM
  4841. ;      3297            SEND_PACKET (MSG_ACK, P_SI_LENGTH, .REC_SEQ);
  4842. ;      3298            BLK_CHK_TYPE = .INI_CHK_TYPE;    ! Back to agreed upon type
  4843. ;      3299            NUM_RETRIES = 0;
  4844. ;      3300            RETURN .STATE;
  4845. ;      3301            END
  4846. ;      3302            ELSE
  4847. ;      3303            RETURN STATE_A;
  4848. ;      3304    
  4849. ;      3305            END;
  4850. ;      3306    
  4851. ;      3307        [MSG_EOF] :
  4852. ;      3308            BEGIN
  4853. ;      3309    
  4854. ;      3310            IF .OLD_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  4855. ;      3311    
  4856. ;      3312            OLD_RETRIES = .OLD_RETRIES + 1;
  4857. ;      3313    
  4858. ;      3314            IF ((.MSG_NUMBER - 1) AND %O'77') EQL .REC_SEQ
  4859. ;      3315            THEN
  4860. ;      3316            BEGIN
  4861. ;      3317            SEND_PACKET (MSG_ACK, 0, .REC_SEQ);
  4862. ;      3318            NUM_RETRIES = 0;
  4863. ;      3319            RETURN .STATE;
  4864. ;      3320            END
  4865. ;      3321            ELSE
  4866. ;      3322            RETURN STATE_A;
  4867. ;      3323    
  4868. ;      3324            END;
  4869. ;      3325    
  4870. ;      3326        [MSG_FILE] :
  4871. ;      3327            BEGIN
  4872. ;      3328    
  4873. ;      3329            IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A;
  4874. ;      3330    
  4875. ;      3331            IF .REC_LENGTH EQL 0
  4876. ;      3332            THEN
  4877. ;      3333            BEGIN
  4878. ;      3334            KRM_ERROR (KER_PROTOERR);
  4879. ;      3335            RETURN STATE_A;
  4880. ;      3336            END;
  4881. ;      3337    
  4882. ;      3338    ![025]
  4883. ;      3339    ![025] Get file name from packet with all quoting undone
  4884. ;      3340    ![025]
  4885. ;      3341            SET_STRING (CH$PTR (FILE_NAME), MAX_FILE_NAME, TRUE);
  4886. ;      3342            BFR_EMPTY ();
  4887. ;      3343            FILE_SIZE = SET_STRING (0, 0, FALSE);
  4888. ;      3344            CH$WCHAR (CHR_NUL, CH$PTR (FILE_NAME, .FILE_SIZE));
  4889. ;      3345    ![025]        FILE_SIZE = .REC_LENGTH;
  4890. ;      3346    ![025]        CH$COPY (.REC_LENGTH, CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE), CHR_NUL, MAX_FILE_NAME,
  4891. ;      3347    ![025]        CH$PTR (FILE_NAME));
  4892. ;      3348    
  4893. ;      3349            IF ( NOT .CONNECT_FLAG) AND .TY_FIL
  4894. ;      3350            THEN
  4895. ;      3351            BEGIN
  4896. ;      3352            TT_TEXT (UPLIT (%ASCIZ'Receiving: '));
  4897. ;      3353            TT_TEXT (FILE_NAME);
  4898. ;      3354            TT_OUTPUT ();
  4899. ;      3355            END;
  4900. ;      3356    
  4901. ;      3357    ![023]
  4902. ;      3358    ![023] Force file name into normal form if desired
  4903. ;      3359    ![023]
  4904. ;      3360    
  4905. ;      3361            IF .FIL_NORMAL_FORM THEN NORMALIZE_FILE (FILE_NAME, FILE_SIZE, 9, 3);
  4906. ;      3362    
  4907. ;      3363            FILE_CHARS = 0;            ! No characters received yet
  4908. ;      3364    
  4909. ;      3365            IF NOT FILE_OPEN (FNC_WRITE) THEN RETURN STATE_A;
  4910. ;      3366    
  4911. ;      3367            XFR_STATUS (%C'F', %C'R');        ! Tell display routine
  4912. ;      3368            TEXT_HEAD_FLAG = FALSE;        ! Got an F, not an X
  4913. ;      3369            FILE_OPEN_FLAG = TRUE;
  4914. ;      3370            SEND_PACKET (MSG_ACK, 0, .MSG_NUMBER);
  4915. ;      3371            OLD_RETRIES = .NUM_RETRIES;
  4916. ;      3372            NUM_RETRIES = 0;
  4917. ;      3373            MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  4918. ;      3374            RETURN STATE_RD;
  4919. ;      3375            END;
  4920. ;      3376    
  4921. ;      3377        [MSG_TEXT] :
  4922. ;      3378    !
  4923. ;      3379    ! If we get a text header, we will want to type the data on
  4924. ;      3380    ! the terminal.  Set up the put a character routine correctly.
  4925. ;      3381    !
  4926. ;      3382            BEGIN
  4927. ;      3383    
  4928. ;      3384            IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A;
  4929. ;      3385    
  4930. ;      3386            TEXT_HEAD_FLAG = TRUE;        ! Got an X, not an F
  4931. ;      3387            PUT_CHR_ROUTINE = TYPE_CHAR;    ! Empty buffer on terminal
  4932. ;      3388            BFR_EMPTY ();            ! Do the header data
  4933. ;      3389            TT_CRLF ();                ! And a crlf
  4934. ;      3390            SEND_PACKET (MSG_ACK, 0, .MSG_NUMBER);
  4935. ;      3391            OLD_RETRIES = .NUM_RETRIES;
  4936. ;      3392            NUM_RETRIES = 0;
  4937. ;      3393            MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  4938. ;      3394            RETURN STATE_RD;
  4939. ;      3395            END;
  4940. ;      3396    
  4941. ;      3397        [MSG_BREAK] :
  4942. ;      3398            BEGIN
  4943. ;      3399    
  4944. ;      3400            IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A;
  4945. ;      3401    
  4946. ;      3402            SEND_PACKET (MSG_ACK, 0, .REC_SEQ);
  4947. ;      3403            RETURN STATE_C;
  4948. ;      3404            END;
  4949. ;      3405    
  4950. ;      3406        [OTHERWISE] :
  4951. ;      3407            RETURN STATE_A;
  4952. ;      3408        TES;
  4953. ;      3409    
  4954. ;      3410        END;                    ! End of REC_FILE
  4955.     .NLIST
  4956.     .LIST    BIN,LOC
  4957.     .LIST
  4958.  
  4959.  
  4960.     .PSECT    $PLIT$,  RO ,  D  
  4961. P.AAI:    .ASCII    /Rec/
  4962.     .ASCII    /eiv/
  4963.     .ASCII    /ing/
  4964.     .ASCII    /: /<00>
  4965.  
  4966.  
  4967.     .SBTTL    REC.FILE REC_FILE
  4968.     .PSECT    $CODE$,  RO 
  4969.  
  4970.     .NLIST
  4971.     .ENABL    LSB
  4972.     .LIST
  4973. ; REC.FILE
  4974. U.12:    JSR    R1,$SAVE2            ;                    3211
  4975.     CLR    ABT.CUR.FILE            ;                    3271
  4976.     CLR    ABT.ALL.FILE            ;                    3272
  4977.     MOV    #U.102,-(SP)            ;                    3277
  4978.     JSR    PC,U.24
  4979.     TST    (SP)+
  4980.     BIT    #1,R0                ; *,STATUS
  4981.     BNE    1$
  4982.     CMP    R0,#272                ; STATUS,*                3280
  4983.     BNE    5$                ;                    3277
  4984.     MOV    #23,R0
  4985.     RTS    PC                ;                    3280
  4986. 1$:    MOV    U.81,R0                ;                    3282
  4987.     CMP    R0,#123
  4988.     BNE    2$
  4989.     CMP    U.76,SI.RETRIES            ;                    3288
  4990.     BGT    5$
  4991.     INC    U.76                ;                    3290
  4992.     MOV    U.78,R0                ;                    3292
  4993.     DEC    R0
  4994.     MOV    U.79,R2
  4995.     MOV    R0,R1
  4996.     BIC    #177700,R1
  4997.     CMP    R1,R2
  4998.     BNE    5$
  4999.     JSR    PC,U.19                ;                    3295
  5000.     MOV    #61,U.71            ;                    3296
  5001.     MOV    #131,-(SP)            ;                    3297
  5002.     MOV    #11,-(SP)
  5003.     MOV    U.79,-(SP)
  5004.     JSR    PC,U.23
  5005.     MOV    U.70,U.71            ;                    3298
  5006.     BR    3$                ;                    3299
  5007. 2$:    CMP    R0,#132                ;                    3282
  5008.     BNE    4$
  5009.     CMP    U.76,PKT.RETRIES        ;                    3310
  5010.     BGT    9$
  5011.     INC    U.76                ;                    3312
  5012.     MOV    U.78,R0                ;                    3314
  5013.     DEC    R0
  5014.     MOV    U.79,R2
  5015.     MOV    R0,R1
  5016.     BIC    #177700,R1
  5017.     CMP    R1,R2
  5018.     BNE    9$
  5019.     MOV    #131,-(SP)            ;                    3317
  5020.     CLR    -(SP)
  5021.     MOV    R2,-(SP)            ; REC.SEQ,*
  5022.     JSR    PC,U.23
  5023. 3$:    CLR    U.77                ;                    3318
  5024.     ADD    #6,SP                ;                    3316
  5025.     MOV    U.74,R0                ;                    3308
  5026.     RTS    PC
  5027. 4$:    CMP    R0,#106                ;                    3282
  5028.     BNE    11$
  5029.     CMP    U.78,U.79            ;                    3329
  5030.     BNE    12$
  5031.     TST    U.80                ;                    3331
  5032.     BNE    6$
  5033.     MOV    #242,-(SP)            ;                    3334
  5034.     JSR    PC,KRM.ERROR
  5035.     TST    (SP)+                ;                    3331
  5036. 5$:    BR    9$                ;                    3333
  5037. 6$:    MOV    #FILE.NAME,-(SP)        ;                    3341
  5038.     MOV    #204,-(SP)
  5039.     MOV    #1,-(SP)
  5040.     JSR    PC,U.29
  5041.     JSR    PC,U.27                ;                    3342
  5042.     CLR    (SP)                ;                    3343
  5043.     CLR    -(SP)
  5044.     CLR    -(SP)
  5045.     JSR    PC,U.29
  5046.     MOV    R0,FILE.SIZE
  5047.     CLRB    FILE.NAME(R0)            ;                    3344
  5048.     BIT    #1,CONNECT.FLAG            ;                    3349
  5049.     BNE    7$
  5050.     BIT    #1,TY.FIL
  5051.     BEQ    7$
  5052.     MOV    #P.AAI,(SP)            ;                    3352
  5053.     JSR    PC,TT.TEXT
  5054.     MOV    #FILE.NAME,(SP)            ;                    3353
  5055.     JSR    PC,TT.TEXT
  5056.     JSR    PC,TT.OUTPUT            ;                    3354
  5057. 7$:    BIT    #1,FIL.NORMAL.FORM        ;                    3361
  5058.     BEQ    8$
  5059.     MOV    #FILE.NAME,(SP)
  5060.     MOV    #FILE.SIZE,-(SP)
  5061.     MOV    #11,-(SP)
  5062.     MOV    #3,-(SP)
  5063.     JSR    PC,U.26
  5064.     ADD    #6,SP
  5065. 8$:    CLR    U.85                ;                    3363
  5066.     MOV    #1,(SP)                ;                    3365
  5067.     JSR    PC,FILE.OPEN
  5068.     ROR    R0
  5069.     BLO    10$
  5070.     ADD    #12,SP
  5071. 9$:    BR    15$
  5072. 10$:    MOV    #106,(SP)            ;                    3367
  5073.     MOV    #122,-(SP)
  5074.     JSR    PC,XFR.STATUS
  5075.     CLR    U.86                ;                    3368
  5076.     MOV    #1,U.84                ;                    3369
  5077.     MOV    #131,(SP)            ;                    3370
  5078.     CLR    -(SP)
  5079.     MOV    U.78,-(SP)
  5080.     JSR    PC,U.23
  5081.     MOV    U.77,U.76            ;                    3371
  5082.     CLR    U.77                ;                    3372
  5083.     MOV    U.78,R0                ;                    3373
  5084.     INC    R0
  5085.     MOV    R0,U.78
  5086.     BIC    #177700,U.78
  5087.     ADD    #20,SP                ;                    3327
  5088.     BR    13$                ;                    3282
  5089. 11$:    CMP    R0,#130
  5090.     BNE    14$
  5091.     CMP    U.78,U.79            ;                    3384
  5092. 12$:    BNE    15$
  5093.     MOV    #1,U.86                ;                    3386
  5094.     MOV    #U.30,U.92            ;                    3387
  5095.     JSR    PC,U.27                ;                    3388
  5096.     JSR    PC,TT.CRLF            ;                    3389
  5097.     MOV    #131,-(SP)            ;                    3390
  5098.     CLR    -(SP)
  5099.     MOV    U.78,-(SP)
  5100.     JSR    PC,U.23
  5101.     MOV    U.77,U.76            ;                    3391
  5102.     CLR    U.77                ;                    3392
  5103.     MOV    U.78,R0                ;                    3393
  5104.     INC    R0
  5105.     MOV    R0,U.78
  5106.     BIC    #177700,U.78
  5107.     ADD    #6,SP                ;                    3382
  5108. 13$:    MOV    #10,R0                ;                    3282
  5109.     RTS    PC
  5110. 14$:    CMP    R0,#102
  5111.     BNE    15$
  5112.     CMP    U.78,U.79            ;                    3400
  5113.     BNE    15$
  5114.     MOV    #131,-(SP)            ;                    3402
  5115.     CLR    -(SP)
  5116.     MOV    U.79,-(SP)
  5117.     JSR    PC,U.23
  5118.     ADD    #6,SP                ;                    3398
  5119.     MOV    #11,R0                ;                    3282
  5120.     RTS    PC
  5121. 15$:    MOV    #12,R0
  5122.     RTS    PC                ;                    3211
  5123. ; Routine Size:  268 words,    Routine Base:  $CODE$ + 7436
  5124. ; Maximum stack depth per invocation:  12 words
  5125.     .NLIST
  5126.     .DSABL    LSB
  5127.     .NLIST    BIN,LOC
  5128.     .LIST
  5129.  
  5130.  
  5131. ;      3411    %SBTTL 'REC_DATA'
  5132. ;      3412    ROUTINE REC_DATA =
  5133. ;      3413    
  5134. ;      3414    !++
  5135. ;      3415    ! FUNCTIONAL DESCRIPTION:
  5136. ;      3416    !
  5137. ;      3417    ! This routine will accept data messages and write them to disk.
  5138. ;      3418    ! It will also accept MSG_FILE, MSG_TEXT and MSG_EOF messages.
  5139. ;      3419    !
  5140. ;      3420    ! CALLING SEQUENCE:
  5141. ;      3421    !
  5142. ;      3422    !    STATE = REC_DATA();
  5143. ;      3423    !
  5144. ;      3424    ! INPUT PARAMETERS:
  5145. ;      3425    !
  5146. ;      3426    !    None.
  5147. ;      3427    !
  5148. ;      3428    ! IMPLICIT INPUTS:
  5149. ;      3429    !
  5150. ;      3430    !    None.
  5151. ;      3431    !
  5152. ;      3432    ! OUTPUT PARAMETERS:
  5153. ;      3433    !
  5154. ;      3434    !    New state for the finite state machine.
  5155. ;      3435    !
  5156. ;      3436    ! IMPLICIT OUTPUTS:
  5157. ;      3437    !
  5158. ;      3438    !    None.
  5159. ;      3439    !
  5160. ;      3440    ! COMPLETION CODES:
  5161. ;      3441    !
  5162. ;      3442    !    None.
  5163. ;      3443    !
  5164. ;      3444    ! SIDE EFFECTS:
  5165. ;      3445    !
  5166. ;      3446    !    None.
  5167. ;      3447    !
  5168. ;      3448    !--
  5169. ;      3449    
  5170. ;      3450        BEGIN
  5171. ;      3451    
  5172. ;      3452        LOCAL
  5173. ;      3453        STATUS;
  5174. ;      3454    
  5175. ;      3455        ROUTINE CHECK_DATA =
  5176. ;      3456        BEGIN
  5177. ;      3457    
  5178. ;      3458        IF .REC_TYPE EQL MSG_DATA OR (.REC_TYPE EQL MSG_FILE AND NOT .TEXT_HEAD_FLAG) OR .REC_TYPE
  5179. ;      3459            EQL MSG_EOF OR (.REC_TYPE EQL MSG_TEXT AND .TEXT_HEAD_FLAG)
  5180. ;      3460        THEN
  5181. ;      3461            RETURN TRUE
  5182. ;      3462        ELSE
  5183. ;      3463            RETURN FALSE;
  5184. ;      3464    
  5185. ;      3465        END;
  5186.     .NLIST
  5187.     .LIST    BIN,LOC
  5188.     .LIST
  5189.  
  5190.     .SBTTL    CHECK.DATA REC_DATA
  5191.     .NLIST
  5192.     .ENABL    LSB
  5193.     .LIST
  5194. ; CHECK.DATA
  5195. U.103:    MOV    U.81,R0                ;                    3458
  5196.     CMP    R0,#104
  5197.     BEQ    2$
  5198.     CMP    R0,#106
  5199.     BNE    1$
  5200.     BIT    #1,U.86
  5201.     BEQ    2$
  5202. 1$:    CMP    R0,#132                ;                    3459
  5203.     BEQ    2$
  5204.     CMP    R0,#130
  5205.     BNE    3$
  5206.     BIT    #1,U.86
  5207.     BEQ    3$
  5208. 2$:    MOV    #1,R0                ;                    3456
  5209.     RTS    PC
  5210. 3$:    CLR    R0
  5211.     RTS    PC                ;                    3455
  5212. ; Routine Size:  27 words,    Routine Base:  $CODE$ + 10466
  5213. ; Maximum stack depth per invocation:  0 words
  5214.     .NLIST
  5215.     .DSABL    LSB
  5216.     .NLIST    BIN,LOC
  5217.     .LIST
  5218.  
  5219.  
  5220. ;      3466    
  5221. ;      3467        LOCAL
  5222. ;      3468        SUB_TYPE,                ! Subtype for XFR_STATUS
  5223. ;      3469        DISCARD_FILE_FLAG,            ! Sender requested discard
  5224. ;      3470        ACK_MSG_LEN;                ! Length of ACK to send
  5225. ;      3471    
  5226. ;      3472    !
  5227. ;      3473    ! First get a message
  5228. ;      3474    !
  5229. ;      3475    
  5230. ;      3476        IF NOT (STATUS = REC_MESSAGE (CHECK_DATA))
  5231. ;      3477        THEN
  5232. ;      3478    
  5233. ;      3479        IF .STATUS NEQ KER_ABORTED THEN RETURN STATE_A ELSE RETURN STATE_EX;
  5234. ;      3480    
  5235. ;      3481        SELECTONE .REC_TYPE OF
  5236. ;      3482        SET
  5237. ;      3483    
  5238. ;      3484        [MSG_DATA] :
  5239. ;      3485            BEGIN
  5240. ;      3486    
  5241. ;      3487            IF .MSG_NUMBER NEQ .REC_SEQ
  5242. ;      3488            THEN
  5243. ;      3489            BEGIN
  5244. ;      3490    
  5245. ;      3491            IF .OLD_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  5246. ;      3492    
  5247. ;      3493            OLD_RETRIES = .OLD_RETRIES + 1;
  5248. ;      3494    
  5249. ;      3495            IF ((.MSG_NUMBER - 1) AND %O'77') EQL .REC_SEQ
  5250. ;      3496            THEN
  5251. ;      3497                BEGIN
  5252. ;      3498                SEND_PACKET (MSG_ACK, 0, .REC_SEQ);
  5253. ;      3499                NUM_RETRIES = 0;
  5254. ;      3500                RETURN .STATE;
  5255. ;      3501                END
  5256. ;      3502            ELSE
  5257. ;      3503                RETURN STATE_A;
  5258. ;      3504    
  5259. ;      3505            END;
  5260. ;      3506    
  5261. ;      3507    !
  5262. ;      3508    ! Here if we have a message with a valid message number
  5263. ;      3509    !
  5264. ;      3510    
  5265. ;      3511            IF NOT BFR_EMPTY () THEN RETURN STATE_A;
  5266. ;      3512    
  5267. ;      3513    !
  5268. ;      3514    ! Check if we wish to abort for some reason
  5269. ;      3515    !
  5270. ;      3516    
  5271. ;      3517            IF .ABT_CUR_FILE
  5272. ;      3518            THEN
  5273. ;      3519            BEGIN
  5274. ;      3520            CH$WCHAR (MSG_ACK_ABT_CUR, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE));
  5275. ;      3521            ACK_MSG_LEN = 1;
  5276. ;      3522            END
  5277. ;      3523            ELSE
  5278. ;      3524    
  5279. ;      3525            IF .ABT_ALL_FILE
  5280. ;      3526            THEN
  5281. ;      3527                BEGIN
  5282. ;      3528                CH$WCHAR (MSG_ACK_ABT_ALL, CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE));
  5283. ;      3529                ACK_MSG_LEN = 1;
  5284. ;      3530                END
  5285. ;      3531            ELSE
  5286. ;      3532                ACK_MSG_LEN = 0;
  5287. ;      3533    
  5288. ;      3534    !
  5289. ;      3535    ! Now send the ACK
  5290. ;      3536    !
  5291. ;      3537            SEND_PACKET (MSG_ACK, .ACK_MSG_LEN, .REC_SEQ);
  5292. ;      3538            OLD_RETRIES = .NUM_RETRIES;
  5293. ;      3539            NUM_RETRIES = 0;
  5294. ;      3540            MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  5295. ;      3541            RETURN STATE_RD;
  5296. ;      3542            END;
  5297. ;      3543    
  5298. ;      3544        [MSG_FILE, MSG_TEXT] :
  5299. ;      3545            BEGIN
  5300. ;      3546    
  5301. ;      3547            IF .OLD_RETRIES GTR .PKT_RETRIES THEN RETURN STATE_A;
  5302. ;      3548    
  5303. ;      3549            OLD_RETRIES = .OLD_RETRIES + 1;
  5304. ;      3550    
  5305. ;      3551            IF ((.MSG_NUMBER - 1) AND %O'77') EQL .REC_SEQ
  5306. ;      3552            THEN
  5307. ;      3553            BEGIN
  5308. ;      3554            SEND_PACKET (MSG_ACK, 0, .REC_SEQ);
  5309. ;      3555            NUM_RETRIES = 0;
  5310. ;      3556            RETURN .STATE;
  5311. ;      3557            END
  5312. ;      3558            ELSE
  5313. ;      3559            RETURN STATE_A;
  5314. ;      3560    
  5315. ;      3561            END;
  5316. ;      3562    
  5317. ;      3563        [MSG_EOF] :
  5318. ;      3564            BEGIN
  5319. ;      3565    
  5320. ;      3566            IF .MSG_NUMBER NEQ .REC_SEQ THEN RETURN STATE_A;
  5321. ;      3567    
  5322. ;      3568            SEND_PACKET (MSG_ACK, 0, .REC_SEQ);
  5323. ;      3569    
  5324. ;      3570            IF NOT .TEXT_HEAD_FLAG
  5325. ;      3571            THEN
  5326. ;      3572            BEGIN
  5327. ;      3573            FILE_OPEN_FLAG = FALSE;
  5328. ;      3574            DISCARD_FILE_FLAG = FALSE;    ! Assume we want file
  5329. ;      3575    
  5330. ;      3576            IF .REC_LENGTH EQL 1
  5331. ;      3577            THEN
  5332. ;      3578    
  5333. ;      3579                IF CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE)) EQL MSG_EOF_DISCARD
  5334. ;      3580                THEN
  5335. ;      3581                DISCARD_FILE_FLAG = TRUE;
  5336. ;      3582    
  5337. ;      3583            IF ( NOT .CONNECT_FLAG) AND .TY_FIL
  5338. ;      3584            THEN
  5339. ;      3585                BEGIN
  5340. ;      3586    
  5341. ;      3587                IF .DISCARD_FILE_FLAG
  5342. ;      3588                THEN
  5343. ;      3589    
  5344. ;      3590                IF .ABT_FLAG
  5345. ;      3591                THEN
  5346. ;      3592                    TT_TEXT (UPLIT (%ASCIZ' [Interrupted]'))
  5347. ;      3593                ELSE
  5348. ;      3594                    TT_TEXT (UPLIT (%ASCIZ' [Interrupted, partial file saved]'))
  5349. ;      3595    
  5350. ;      3596                ELSE
  5351. ;      3597                TT_TEXT (UPLIT (%ASCIZ' [OK]'));
  5352. ;      3598    
  5353. ;      3599                TT_CRLF ();
  5354. ;      3600                END;
  5355. ;      3601    
  5356. ;      3602            IF NOT FILE_CLOSE (.DISCARD_FILE_FLAG AND .ABT_FLAG) THEN RETURN STATE_A;
  5357. ;      3603    
  5358. ;      3604            IF .DISCARD_FILE_FLAG
  5359. ;      3605            THEN
  5360. ;      3606    
  5361. ;      3607                IF .ABT_FLAG THEN SUB_TYPE = %C'X' ELSE SUB_TYPE = %C'D'
  5362. ;      3608    
  5363. ;      3609            ELSE
  5364. ;      3610                SUB_TYPE = %C'C';
  5365. ;      3611    
  5366. ;      3612            END
  5367. ;      3613            ELSE
  5368. ;      3614            BEGIN
  5369. ;      3615            TT_CRLF ();            ! Make sure we have a CRLF
  5370. ;      3616            TT_OUTPUT ();            ! And make sure all output is sent
  5371. ;      3617            END;
  5372. ;      3618    
  5373. ;      3619            XFR_STATUS (%C'F', .SUB_TYPE);
  5374. ;      3620            MSG_NUMBER = (.MSG_NUMBER + 1) AND %O'77';
  5375. ;      3621            RETURN STATE_RF;
  5376. ;      3622            END;
  5377. ;      3623    
  5378. ;      3624        [OTHERWISE] :
  5379. ;      3625            RETURN STATE_A;
  5380. ;      3626        TES;
  5381. ;      3627    
  5382. ;      3628        END;                    ! End of REC_DATA
  5383.     .NLIST
  5384.     .LIST    BIN,LOC
  5385.     .LIST
  5386.  
  5387.  
  5388.     .PSECT    $PLIT$,  RO ,  D  
  5389. P.AAJ:    .ASCII    / [I/
  5390.     .ASCII    /nte/
  5391.     .ASCII    /rru/
  5392.     .ASCII    /pte/
  5393.     .ASCII    /d]/<00>
  5394.     .ASCII    <00>
  5395. P.AAK:    .ASCII    / [I/
  5396.     .ASCII    /nte/
  5397.     .ASCII    /rru/
  5398.     .ASCII    /pte/
  5399.     .ASCII    /d, /
  5400.     .ASCII    /par/
  5401.     .ASCII    /tia/
  5402.     .ASCII    /l f/
  5403.     .ASCII    /ile/
  5404.     .ASCII    / sa/
  5405.     .ASCII    /ved/
  5406.     .ASCII    /]/<00><00>
  5407. P.AAL:    .ASCII    / [O/
  5408.     .ASCII    /K]/<00>
  5409.  
  5410.  
  5411.     .SBTTL    REC.DATA REC_DATA
  5412.     .PSECT    $CODE$,  RO 
  5413.  
  5414.     .NLIST
  5415.     .ENABL    LSB
  5416.     .LIST
  5417. ; REC.DATA
  5418. U.13:    JSR    R1,$SAVE3            ;                    3412
  5419.     MOV    #U.103,-(SP)            ;                    3476
  5420.     JSR    PC,U.24
  5421.     TST    (SP)+
  5422.     BIT    #1,R0                ; *,STATUS
  5423.     BNE    1$
  5424.     CMP    R0,#272                ; STATUS,*                3479
  5425.     BNE    3$                ;                    3476
  5426.     MOV    #23,R0
  5427.     RTS    PC                ;                    3479
  5428. 1$:    MOV    U.81,R0                ;                    3481
  5429.     CMP    R0,#104
  5430.     BNE    9$
  5431.     MOV    U.79,R1                ;                    3487
  5432.     CMP    U.78,R1
  5433.     BEQ    2$
  5434.     CMP    U.76,PKT.RETRIES        ;                    3491
  5435.     BGT    3$
  5436.     INC    U.76                ;                    3493
  5437.     MOV    U.78,R0                ;                    3495
  5438.     DEC    R0
  5439.     MOV    R1,R3
  5440.     MOV    R0,R2
  5441.     BIC    #177700,R2
  5442.     CMP    R2,R3
  5443.     BNE    3$
  5444.     MOV    #131,-(SP)            ;                    3498
  5445.     CLR    -(SP)
  5446.     MOV    R1,-(SP)
  5447.     BR    11$
  5448. 2$:    JSR    PC,U.27                ;                    3511
  5449.     ROR    R0
  5450.     BLO    4$
  5451. 3$:    JMP    23$
  5452. 4$:    BIT    #1,ABT.CUR.FILE            ;                    3517
  5453.     BEQ    5$
  5454.     MOVB    #130,U.83+4            ;                    3520
  5455.     BR    6$                ;                    3521
  5456. 5$:    BIT    #1,ABT.ALL.FILE            ;                    3525
  5457.     BEQ    7$
  5458.     MOVB    #132,U.83+4            ;                    3528
  5459. 6$:    MOV    #1,R0                ; *,ACK.MSG.LEN                3529
  5460.     BR    8$                ;                    3525
  5461. 7$:    CLR    R0                ; ACK.MSG.LEN                3532
  5462. 8$:    MOV    #131,-(SP)            ;                    3537
  5463.     MOV    R0,-(SP)            ; ACK.MSG.LEN,*
  5464.     MOV    U.79,-(SP)
  5465.     JSR    PC,U.23
  5466.     MOV    U.77,U.76            ;                    3538
  5467.     CLR    U.77                ;                    3539
  5468.     MOV    U.78,R0                ;                    3540
  5469.     INC    R0
  5470.     MOV    R0,U.78
  5471.     BIC    #177700,U.78
  5472.     ADD    #6,SP                ;                    3485
  5473.     MOV    #10,R0                ;                    3481
  5474.     RTS    PC
  5475. 9$:    CMP    R0,#106
  5476.     BEQ    10$
  5477.     CMP    R0,#130
  5478.     BNE    12$
  5479. 10$:    CMP    U.76,PKT.RETRIES        ;                    3547
  5480.     BGT    3$
  5481.     INC    U.76                ;                    3549
  5482.     MOV    U.78,R0                ;                    3551
  5483.     DEC    R0
  5484.     MOV    U.79,R2
  5485.     MOV    R0,R1
  5486.     BIC    #177700,R1
  5487.     CMP    R1,R2
  5488.     BNE    23$
  5489.     MOV    #131,-(SP)            ;                    3554
  5490.     CLR    -(SP)
  5491.     MOV    R2,-(SP)            ; REC.SEQ,*
  5492. 11$:    JSR    PC,U.23
  5493.     CLR    U.77                ;                    3555
  5494.     ADD    #6,SP                ;                    3553
  5495.     MOV    U.74,R0                ;                    3545
  5496.     RTS    PC
  5497. 12$:    CMP    R0,#132                ;                    3481
  5498.     BNE    23$
  5499.     CMP    U.78,U.79            ;                    3566
  5500.     BNE    23$
  5501.     MOV    #131,-(SP)            ;                    3568
  5502.     CLR    -(SP)
  5503.     MOV    U.79,-(SP)
  5504.     JSR    PC,U.23
  5505.     BIT    #1,U.86                ;                    3570
  5506.     BNE    21$
  5507.     CLR    U.84                ;                    3573
  5508.     CLR    R1                ; DISCARD.FILE.FL            3574
  5509.     CMP    U.80,#1                ;                    3576
  5510.     BNE    13$
  5511.     CMPB    U.82+4,#104            ;                    3579
  5512.     BNE    13$
  5513.     MOV    #1,R1                ; *,DISCARD.FILE.FL            3581
  5514. 13$:    BIT    #1,CONNECT.FLAG            ;                    3583
  5515.     BNE    17$
  5516.     BIT    #1,TY.FIL
  5517.     BEQ    17$
  5518.     BIT    #1,R1                ; *,DISCARD.FILE.FL            3587
  5519.     BEQ    15$
  5520.     BIT    #1,ABT.FLAG            ;                    3590
  5521.     BEQ    14$
  5522.     MOV    #P.AAJ,(SP)            ;                    3592
  5523.     BR    16$
  5524. 14$:    MOV    #P.AAK,(SP)            ;                    3594
  5525.     BR    16$
  5526. 15$:    MOV    #P.AAL,(SP)            ;                    3597
  5527. 16$:    JSR    PC,TT.TEXT
  5528.     JSR    PC,TT.CRLF            ;                    3599
  5529. 17$:    MOV    R1,R0                ; DISCARD.FILE.FL,*            3602
  5530.     MOV    ABT.FLAG,(SP)
  5531.     COM    R0
  5532.     BIC    R0,(SP)
  5533.     JSR    PC,FILE.CLOSE
  5534.     ROR    R0
  5535.     BLO    18$
  5536.     ADD    #6,SP
  5537.     BR    23$
  5538. 18$:    ROR    R1                ; DISCARD.FILE.FL            3604
  5539.     BCC    20$
  5540.     BIT    #1,ABT.FLAG            ;                    3607
  5541.     BEQ    19$
  5542.     MOV    #130,R0                ; *,SUB.TYPE
  5543.     BR    22$
  5544. 19$:    MOV    #104,R0                ; *,SUB.TYPE
  5545.     BR    22$                ;                    3604
  5546. 20$:    MOV    #103,R0                ; *,SUB.TYPE                3610
  5547.     BR    22$                ;                    3570
  5548. 21$:    JSR    PC,TT.CRLF            ;                    3615
  5549.     JSR    PC,TT.OUTPUT            ;                    3616
  5550. 22$:    MOV    #106,(SP)            ;                    3619
  5551.     MOV    R0,-(SP)            ; SUB.TYPE,*
  5552.     JSR    PC,XFR.STATUS
  5553.     MOV    U.78,R0                ;                    3620
  5554.     INC    R0
  5555.     MOV    R0,U.78
  5556.     BIC    #177700,U.78
  5557.     ADD    #10,SP                ;                    3564
  5558.     MOV    #7,R0                ;                    3481
  5559.     RTS    PC
  5560. 23$:    MOV    #12,R0
  5561.     RTS    PC                ;                    3412
  5562. ; Routine Size:  241 words,    Routine Base:  $CODE$ + 10554
  5563. ; Maximum stack depth per invocation:  9 words
  5564.     .NLIST
  5565.     .DSABL    LSB
  5566.     .NLIST    BIN,LOC
  5567.     .LIST
  5568.  
  5569.  
  5570. ;      3629    %SBTTL 'SERVER - Generic commands'
  5571. ;      3630    ROUTINE SERVER_GENERIC =
  5572. ;      3631    
  5573. ;      3632    !++
  5574. ;      3633    ! FUNCTIONAL DESCRIPTION:
  5575. ;      3634    !
  5576. ;      3635    !    This routine will handle the generic server messages.
  5577. ;      3636    !    The generic server messages include FINISH, LOGOUT.
  5578. ;      3637    !
  5579. ;      3638    ! CALLING SEQUENCE:
  5580. ;      3639    !
  5581. ;      3640    !    STATE = SERVER_GENERIC();
  5582. ;      3641    !
  5583. ;      3642    ! INPUT PARAMETERS:
  5584. ;      3643    !
  5585. ;      3644    !    None.
  5586. ;      3645    !
  5587. ;      3646    ! IMPLICIT INPUTS:
  5588. ;      3647    !
  5589. ;      3648    !    Generic message receive in REC_MSG.
  5590. ;      3649    !
  5591. ;      3650    ! OUTPUT PARAMETERS:
  5592. ;      3651    !
  5593. ;      3652    !    Returns new state for FSM
  5594. ;      3653    !
  5595. ;      3654    ! IMPLICIT OUTPUTS:
  5596. ;      3655    !
  5597. ;      3656    !    None.
  5598. ;      3657    !
  5599. ;      3658    ! COMPLETION CODES:
  5600. ;      3659    !
  5601. ;      3660    !    None.
  5602. ;      3661    !
  5603. ;      3662    ! SIDE EFFECTS:
  5604. ;      3663    !
  5605. ;      3664    !    None.
  5606. ;      3665    !
  5607. ;      3666    !--
  5608. ;      3667    
  5609. ;      3668        BEGIN
  5610. ;      3669    
  5611. ;      3670        LOCAL
  5612. ;      3671        STATUS,                    ! Returned status
  5613. ;      3672        G_FUNC,                    ! Generic command function
  5614. ;      3673        POINTER,                ! Character pointer
  5615. ;      3674        DATA_TEXT : VECTOR [CH$ALLOCATION (MAX_MSG)],    ! Unpacked message
  5616. ;      3675        DATA_SIZE;                ! Actual size of data
  5617. ;      3676    
  5618. ;      3677        ROUTINE UNPACK_DATA (POINTER, SIZE, DST_ADDR, DST_LEN) =
  5619. ;      3678    !
  5620. ;      3679    ! Routine to unpack an argument.
  5621. ;      3680    ! This will copy the argument data to the desired buffer.
  5622. ;      3681    !
  5623. ;      3682        BEGIN
  5624. ;      3683    
  5625. ;      3684        IF .SIZE GTR 0                ! If we have something to unpack
  5626. ;      3685        THEN
  5627. ;      3686            BEGIN
  5628. ;      3687            .DST_LEN = UNCHAR (CH$RCHAR_A (.POINTER));
  5629. ;      3688    
  5630. ;      3689            IF ..DST_LEN GTR .SIZE - 1 THEN .DST_LEN = .SIZE - 1;
  5631. ;      3690    
  5632. ;      3691            CH$COPY (..DST_LEN, ..POINTER, CHR_NUL, MAX_MSG, CH$PTR (.DST_ADDR));
  5633. ;      3692            .POINTER = CH$PLUS (..POINTER, ..DST_LEN);
  5634. ;      3693            RETURN .SIZE - ..DST_LEN - 1;
  5635. ;      3694            END
  5636. ;      3695        ELSE
  5637. ;      3696    !
  5638. ;      3697    ! If nothing left in buffer, return the current size (0)
  5639. ;      3698    !
  5640. ;      3699            RETURN .SIZE;
  5641. ;      3700    
  5642. ;      3701        END;
  5643.     .NLIST
  5644.     .LIST    BIN,LOC
  5645.     .LIST
  5646.  
  5647.     .SBTTL    UNPACK.DATA SERVER - Generic commands
  5648.     .NLIST
  5649.     .ENABL    LSB
  5650.     .LIST
  5651. ; UNPACK.DATA
  5652. U.104:    JSR    R1,$SAVE3            ;                    3677
  5653.     MOV    16(SP),R3            ; SIZE,*                3684
  5654.     BLE    2$
  5655.     MOV    12(SP),R2            ; DST.LEN,*                3687
  5656.     MOV    20(SP),R1            ; POINTER,*
  5657.     INC    (R1)
  5658.     MOV    (R1),R0
  5659.     MOVB    -1(R0),(R2)
  5660.     CLRB    1(R2)
  5661.     SUB    #40,(R2)
  5662.     MOV    R3,R0                ;                    3689
  5663.     DEC    R0
  5664.     CMP    (R2),R0
  5665.     BLE    1$
  5666.     MOV    R0,(R2)
  5667. 1$:    MOV    (R2),-(SP)            ;                    3691
  5668.     MOV    (R1),-(SP)
  5669.     CLR    -(SP)
  5670.     MOV    #140,-(SP)
  5671.     MOV    24(SP),-(SP)            ; DST.ADDR,*
  5672.     MOV    #-5,-(SP)
  5673.     JSR    PC,BL$CPY
  5674.     ADD    (R2),(R1)            ;                    3692
  5675.     MOV    R3,R0                ;                    3693
  5676.     SUB    (R2),R0
  5677.     DEC    R0
  5678.     ADD    #14,SP                ;                    3686
  5679.     RTS    PC                ;                    3682
  5680. 2$:    MOV    R3,R0
  5681.     RTS    PC                ;                    3677
  5682. ; Routine Size:  42 words,    Routine Base:  $CODE$ + 11516
  5683. ; Maximum stack depth per invocation:  11 words
  5684.     .NLIST
  5685.     .DSABL    LSB
  5686.     .NLIST    BIN,LOC
  5687.     .LIST
  5688.  
  5689.  
  5690. ;      3702    !
  5691. ;      3703    ! First unpack the message data into its various pieces
  5692. ;      3704    !
  5693. ;      3705        SET_STRING (CH$PTR (DATA_TEXT), MAX_MSG, TRUE);    ! Initialize for unpacking
  5694. ;      3706        BFR_EMPTY ();                ! Unpack the data
  5695. ;      3707        DATA_SIZE = SET_STRING (0, 0, FALSE);    ! All done, get size
  5696. ;      3708    
  5697. ;      3709        IF .DATA_SIZE LEQ 0
  5698. ;      3710        THEN
  5699. ;      3711        BEGIN
  5700. ;      3712        KRM_ERROR (KER_PROTOERR);        ! Someone screwed up
  5701. ;      3713        RETURN STATE_A;                ! Since no subtype
  5702. ;      3714        END;
  5703. ;      3715    
  5704. ;      3716    !
  5705. ;      3717    ! Get the arguments from the unpacked data (if any)
  5706. ;      3718    !
  5707. ;      3719        GEN_1SIZE = 0;                ! Assume no args
  5708. ;      3720        GEN_2SIZE = 0;                ! none at all
  5709. ;      3721        GEN_3SIZE = 0;
  5710. ;      3722        CH$WCHAR (CHR_NUL, CH$PTR (GEN_1DATA));    ! Ensure all are null terminated
  5711. ;      3723        CH$WCHAR (CHR_NUL, CH$PTR (GEN_2DATA));
  5712. ;      3724        CH$WCHAR (CHR_NUL, CH$PTR (GEN_3DATA));
  5713. ;      3725        POINTER = CH$PTR (DATA_TEXT, 1);        ! Point at second character
  5714. ;      3726        DATA_SIZE = .DATA_SIZE - 1;            ! Account for subtype
  5715. ;      3727    
  5716. ;      3728        IF .DATA_SIZE GTR 0                ! Room for first arg?
  5717. ;      3729        THEN
  5718. ;      3730        BEGIN
  5719. ;      3731        DATA_SIZE = UNPACK_DATA (POINTER, .DATA_SIZE, GEN_1DATA, GEN_1SIZE);
  5720. ;      3732    
  5721. ;      3733        IF .DATA_SIZE GTR 0            ! Second argument present?
  5722. ;      3734        THEN
  5723. ;      3735            BEGIN
  5724. ;      3736            DATA_SIZE = UNPACK_DATA (POINTER, .DATA_SIZE, GEN_2DATA, GEN_2SIZE);
  5725. ;      3737    
  5726. ;      3738            IF .DATA_SIZE GTR 0            ! Third argument here?
  5727. ;      3739            THEN
  5728. ;      3740            DATA_SIZE = UNPACK_DATA (POINTER, .DATA_SIZE, GEN_3DATA, GEN_3SIZE);
  5729. ;      3741    
  5730. ;      3742            END;
  5731. ;      3743    
  5732. ;      3744        END;
  5733. ;      3745    
  5734. ;      3746        SELECTONE CH$RCHAR (CH$PTR (DATA_TEXT)) OF
  5735. ;      3747        SET
  5736. ;      3748        !
  5737. ;      3749        ! EXIT command, just return the status to the upper level
  5738. ;      3750        !
  5739. ;      3751    
  5740. ;      3752        [MSG_GEN_EXIT] :
  5741. ;      3753            BEGIN
  5742. ;      3754            SEND_PACKET (MSG_ACK, 0, .REC_SEQ);
  5743. ;      3755            RETURN STATE_FI;
  5744. ;      3756            END;
  5745. ;      3757        !
  5746. ;      3758        ! LOGOUT command, ACK the message then call the system routine to
  5747. ;      3759        ! kill the process (log the job out, etc.)
  5748. ;      3760        !
  5749. ;      3761    
  5750. ;      3762        [MSG_GEN_LOGOUT] :
  5751. ;      3763            BEGIN
  5752. ;      3764            SEND_PACKET (MSG_ACK, 0, .REC_SEQ);
  5753. ;      3765            SY_LOGOUT ();
  5754. ;      3766            RETURN STATE_LG;
  5755. ;      3767            END;
  5756. ;      3768    !
  5757. ;      3769    ! For a type command, just set up a transfer flagging we want a text header
  5758. ;      3770    ! instead of a file header.
  5759. ;      3771    !
  5760. ;      3772    
  5761. ;      3773        [MSG_GEN_TYPE] :
  5762. ;      3774            BEGIN
  5763. ;      3775            CH$COPY (.GEN_1SIZE, CH$PTR (GEN_1DATA), CHR_NUL, MAX_FILE_NAME, CH$PTR (FILE_NAME));
  5764. ;      3776            FILE_SIZE = .GEN_1SIZE;
  5765. ;      3777            TEXT_HEAD_FLAG = TRUE;        ! Now want text header
  5766. ;      3778            XFR_STATUS (%C'I', %C'G');        ! Tell display routine we are doing a command
  5767. ;      3779    
  5768. ;      3780            IF .STATE EQL STATE_II AND .BLK_CHK_TYPE EQL .INI_CHK_TYPE
  5769. ;      3781            THEN
  5770. ;      3782            RETURN STATE_OF            ! Must open the file
  5771. ;      3783            ELSE
  5772. ;      3784            RETURN STATE_S;            ! Start the transaction with a send
  5773. ;      3785    
  5774. ;      3786            END;
  5775. ;      3787    
  5776. ;      3788        [MSG_GEN_DIRECTORY] :
  5777. ;      3789            G_FUNC = GC_DIRECTORY;
  5778. ;      3790    
  5779. ;      3791        [MSG_GEN_DISK_USAGE] :
  5780. ;      3792            G_FUNC = GC_DISK_USAGE;
  5781. ;      3793    
  5782. ;      3794        [MSG_GEN_DELETE] :
  5783. ;      3795            G_FUNC = GC_DELETE;
  5784. ;      3796    
  5785. ;      3797        [MSG_GEN_HELP] :
  5786. ;      3798            G_FUNC = GC_HELP;
  5787. ;      3799    
  5788. ;      3800        [MSG_GEN_LOGIN] :
  5789. ;      3801            G_FUNC = GC_LGN;
  5790. ;      3802    
  5791. ;      3803        [MSG_GEN_CONNECT] :
  5792. ;      3804            G_FUNC = GC_CONNECT;
  5793. ;      3805    
  5794. ;      3806        [MSG_GEN_RENAME] :
  5795. ;      3807            G_FUNC = GC_RENAME;
  5796. ;      3808    
  5797. ;      3809        [MSG_GEN_COPY] :
  5798. ;      3810            G_FUNC = GC_COPY;
  5799. ;      3811    
  5800. ;      3812        [MSG_GEN_WHO] :
  5801. ;      3813            G_FUNC = GC_WHO;
  5802. ;      3814    
  5803. ;      3815        [MSG_GEN_SEND] :
  5804. ;      3816            G_FUNC = GC_SEND_MSG;
  5805. ;      3817    
  5806. ;      3818        [MSG_GEN_QUERY] :
  5807. ;      3819            G_FUNC = GC_STATUS;
  5808. ;      3820    !
  5809. ;      3821    ! Here if we have a function that is not implemented in KERMSG.
  5810. ;      3822    !
  5811. ;      3823    
  5812. ;      3824        [OTHERWISE] :
  5813. ;      3825            BEGIN
  5814. ;      3826            KRM_ERROR (KER_UNIMPLGEN);
  5815. ;      3827            RETURN STATE_A;
  5816. ;      3828            END;
  5817. ;      3829        TES;
  5818. ;      3830    
  5819. ;      3831    !
  5820. ;      3832    ! If we get here, we have gotten a known type of generic message that
  5821. ;      3833    ! we need to have our operating system dependent routine handle.
  5822. ;      3834    !
  5823. ;      3835        RETURN CALL_SY_RTN (.G_FUNC);
  5824. ;      3836        END;                    ! End of SERVER_GENERIC
  5825.     .NLIST
  5826.     .LIST    BIN,LOC
  5827.     .LIST
  5828.  
  5829.     .SBTTL    SERVER.GENERIC SERVER - Generic commands
  5830.     .NLIST
  5831.     .ENABL    LSB
  5832.     .LIST
  5833. ; SERVER.GENERIC
  5834. U.14:    JSR    R1,$SAVE2            ;                    3630
  5835.     SUB    #142,SP
  5836.     MOV    #4,-(SP)            ;                    3705
  5837.     ADD    SP,(SP)                ; DATA.TEXT,*
  5838.     MOV    #140,-(SP)
  5839.     MOV    #1,-(SP)
  5840.     JSR    PC,U.29
  5841.     JSR    PC,U.27                ;                    3706
  5842.     CLR    (SP)                ;                    3707
  5843.     CLR    -(SP)
  5844.     CLR    -(SP)
  5845.     JSR    PC,U.29
  5846.     MOV    R0,R1                ; *,DATA.SIZE
  5847.     BGT    1$                ;                    3709
  5848.     MOV    #242,(SP)            ;                    3712
  5849.     JMP    22$
  5850. 1$:    CLR    GEN.1SIZE            ;                    3719
  5851.     CLR    GEN.2SIZE            ;                    3720
  5852.     CLR    GEN.3SIZE            ;                    3721
  5853.     CLRB    GEN.1DATA            ;                    3722
  5854.     CLRB    GEN.2DATA            ;                    3723
  5855.     CLRB    GEN.3DATA            ;                    3724
  5856.     MOV    #15,12(SP)            ; *,POINTER                3725
  5857.     ADD    SP,12(SP)            ; DATA.TEXT+1,POINTER
  5858.     DEC    R1                ; DATA.SIZE                3726
  5859.     .WORD CLV!CLC
  5860.                         ;                    3728
  5861.     BLE    4$
  5862.     MOV    #12,(SP)            ;                    3731
  5863.     ADD    SP,(SP)                ; POINTER,*
  5864.     MOV    R1,-(SP)            ; DATA.SIZE,*
  5865.     MOV    #GEN.1DATA,-(SP)
  5866.     MOV    #GEN.1SIZE,-(SP)
  5867.     JSR    PC,U.104
  5868.     MOV    R0,R1                ; *,DATA.SIZE
  5869.     BLE    3$                ;                    3733
  5870.     MOV    #20,(SP)            ;                    3736
  5871.     ADD    SP,(SP)                ; POINTER,*
  5872.     MOV    R1,-(SP)            ; DATA.SIZE,*
  5873.     MOV    #GEN.2DATA,-(SP)
  5874.     MOV    #GEN.2SIZE,-(SP)
  5875.     JSR    PC,U.104
  5876.     MOV    R0,R1                ; *,DATA.SIZE
  5877.     BLE    2$                ;                    3738
  5878.     MOV    #26,(SP)            ;                    3740
  5879.     ADD    SP,(SP)                ; POINTER,*
  5880.     MOV    R1,-(SP)            ; DATA.SIZE,*
  5881.     MOV    #GEN.3DATA,-(SP)
  5882.     MOV    #GEN.3SIZE,-(SP)
  5883.     JSR    PC,U.104
  5884.     ADD    #6,SP
  5885. 2$:    ADD    #6,SP                ;                    3735
  5886. 3$:    ADD    #6,SP                ;                    3730
  5887. 4$:    CLR    R1                ;                    3746
  5888.     BISB    14(SP),R1            ; DATA.TEXT,*
  5889.     CMP    R1,#106
  5890.     BNE    5$
  5891.     MOV    #131,(SP)            ;                    3754
  5892.     CLR    -(SP)
  5893.     MOV    U.79,-(SP)
  5894.     JSR    PC,U.23
  5895.     ADD    #16,SP                ;                    3746
  5896.     MOV    #20,R0                ;                    3753
  5897.     BR    9$
  5898. 5$:    CMP    R1,#114                ;                    3746
  5899.     BNE    6$
  5900.     MOV    #131,(SP)            ;                    3764
  5901.     CLR    -(SP)
  5902.     MOV    U.79,-(SP)
  5903.     JSR    PC,U.23
  5904.     JSR    PC,SY.LOGOUT            ;                    3765
  5905.     ADD    #16,SP                ;                    3746
  5906.     MOV    #21,R0                ;                    3763
  5907.     BR    24$
  5908. 6$:    CMP    R1,#124                ;                    3746
  5909.     BNE    10$
  5910.     MOV    GEN.1SIZE,(SP)            ;                    3775
  5911.     MOV    #GEN.1DATA,-(SP)
  5912.     CLR    -(SP)
  5913.     MOV    #204,-(SP)
  5914.     MOV    #FILE.NAME,-(SP)
  5915.     MOV    #-5,-(SP)
  5916.     JSR    PC,BL$CPY
  5917.     MOV    GEN.1SIZE,FILE.SIZE        ;                    3776
  5918.     MOV    #1,U.86                ;                    3777
  5919.     MOV    #111,(SP)            ;                    3778
  5920.     MOV    #107,-(SP)
  5921.     JSR    PC,XFR.STATUS
  5922.     CMP    U.74,#17            ;                    3780
  5923.     BNE    7$
  5924.     CMP    U.71,U.70
  5925.     BNE    7$
  5926.     MOV    #22,R0                ;                    3774
  5927.     BR    8$
  5928. 7$:    MOV    #1,R0
  5929. 8$:    ADD    #26,SP                ;                    3746
  5930. 9$:    BR    24$                ;                    3774
  5931. 10$:    CMP    R1,#104                ;                    3746
  5932.     BNE    11$
  5933.     MOV    #2,R2                ; *,G.FUNC                3789
  5934.     BR    23$                ;                    3746
  5935. 11$:    CMP    R1,#125
  5936.     BNE    12$
  5937.     MOV    #3,R2                ; *,G.FUNC                3792
  5938.     BR    23$                ;                    3746
  5939. 12$:    CMP    R1,#105
  5940.     BNE    13$
  5941.     MOV    #4,R2                ; *,G.FUNC                3795
  5942.     BR    23$                ;                    3746
  5943. 13$:    CMP    R1,#110
  5944.     BNE    14$
  5945.     MOV    #6,R2                ; *,G.FUNC                3798
  5946.     BR    23$                ;                    3746
  5947. 14$:    CMP    R1,#111
  5948.     BNE    15$
  5949.     MOV    #10,R2                ; *,G.FUNC                3801
  5950.     BR    23$                ;                    3746
  5951. 15$:    CMP    R1,#103
  5952.     BNE    16$
  5953.     MOV    #11,R2                ; *,G.FUNC                3804
  5954.     BR    23$                ;                    3746
  5955. 16$:    CMP    R1,#122
  5956.     BNE    17$
  5957.     MOV    #12,R2                ; *,G.FUNC                3807
  5958.     BR    23$                ;                    3746
  5959. 17$:    CMP    R1,#113
  5960.     BNE    18$
  5961.     MOV    #13,R2                ; *,G.FUNC                3810
  5962.     BR    23$                ;                    3746
  5963. 18$:    CMP    R1,#127
  5964.     BNE    19$
  5965.     MOV    #14,R2                ; *,G.FUNC                3813
  5966.     BR    23$                ;                    3746
  5967. 19$:    CMP    R1,#115
  5968.     BNE    20$
  5969.     MOV    #15,R2                ; *,G.FUNC                3816
  5970.     BR    23$                ;                    3746
  5971. 20$:    CMP    R1,#121
  5972.     BNE    21$
  5973.     MOV    #16,R2                ; *,G.FUNC                3819
  5974.     BR    23$                ;                    3746
  5975. 21$:    MOV    #222,(SP)            ;                    3826
  5976. 22$:    JSR    PC,KRM.ERROR
  5977.     ADD    #12,SP                ;                    3746
  5978.     MOV    #12,R0                ;                    3825
  5979.     BR    24$
  5980. 23$:    MOV    R2,(SP)                ; G.FUNC,*                3835
  5981.     JSR    PC,U.16
  5982.     ADD    #12,SP                ;                    3630
  5983. 24$:    ADD    #142,SP
  5984.     RTS    PC
  5985. ; Routine Size:  248 words,    Routine Base:  $CODE$ + 11642
  5986. ; Maximum stack depth per invocation:  67 words
  5987.     .NLIST
  5988.     .DSABL    LSB
  5989.     .NLIST    BIN,LOC
  5990.     .LIST
  5991.  
  5992.  
  5993. ;      3837    %SBTTL 'HOST_COMMAND - perform a host command'
  5994. ;      3838    ROUTINE HOST_COMMAND =
  5995. ;      3839    
  5996. ;      3840    !++
  5997. ;      3841    ! FUNCTIONAL DESCRIPTION:
  5998. ;      3842    !
  5999. ;      3843    ! This routine will handle the host command packet.
  6000. ;      3844    ! It will set up the data for the call to the system routine.
  6001. ;      3845    !
  6002. ;      3846    ! CALLING SEQUENCE:
  6003. ;      3847    !
  6004. ;      3848    !    STATE = HOST_COMMAND();
  6005. ;      3849    !
  6006. ;      3850    ! INPUT PARAMETERS:
  6007. ;      3851    !
  6008. ;      3852    !    None.
  6009. ;      3853    !
  6010. ;      3854    ! IMPLICIT INPUTS:
  6011. ;      3855    !
  6012. ;      3856    !    Generic message receive in REC_MSG.
  6013. ;      3857    !
  6014. ;      3858    ! OUTPUT PARAMETERS:
  6015. ;      3859    !
  6016. ;      3860    !    Returns new state for FSM
  6017. ;      3861    !
  6018. ;      3862    ! IMPLICIT OUTPUTS:
  6019. ;      3863    !
  6020. ;      3864    !    None.
  6021. ;      3865    !
  6022. ;      3866    ! COMPLETION CODES:
  6023. ;      3867    !
  6024. ;      3868    !    None.
  6025. ;      3869    !
  6026. ;      3870    ! SIDE EFFECTS:
  6027. ;      3871    !
  6028. ;      3872    !    None.
  6029. ;      3873    !
  6030. ;      3874    !--
  6031. ;      3875    
  6032. ;      3876        BEGIN
  6033. ;      3877        GEN_1SIZE = 0;
  6034. ;      3878        GEN_2SIZE = 0;
  6035. ;      3879        GEN_3SIZE = 0;
  6036. ;      3880    
  6037. ;      3881        IF .REC_LENGTH LEQ 0
  6038. ;      3882        THEN
  6039. ;      3883        BEGIN
  6040. ;      3884        KRM_ERROR (KER_PROTOERR);        ! Return an error
  6041. ;      3885        RETURN STATE_A;                ! Just abort
  6042. ;      3886        END;
  6043. ;      3887    
  6044. ;      3888        SET_STRING (CH$PTR (GEN_1DATA), MAX_MSG, TRUE);    ! Start writing to buffer
  6045. ;      3889        BFR_EMPTY ();                ! Dump the text
  6046. ;      3890        GEN_1SIZE = SET_STRING (0, 0, FALSE);    ! Get the result
  6047. ;      3891        RETURN CALL_SY_RTN (GC_COMMAND);
  6048. ;      3892        END;                    ! End of HOST_COMMAND
  6049.     .NLIST
  6050.     .LIST    BIN,LOC
  6051.     .LIST
  6052.  
  6053.     .SBTTL    HOST.COMMAND HOST_COMMAND - perform a host command
  6054.     .NLIST
  6055.     .ENABL    LSB
  6056.     .LIST
  6057. ; HOST.COMMAND
  6058. U.15:    CLR    GEN.1SIZE            ;                    3877
  6059.     CLR    GEN.2SIZE            ;                    3878
  6060.     CLR    GEN.3SIZE            ;                    3879
  6061.     TST    U.80                ;                    3881
  6062.     BGT    1$
  6063.     MOV    #242,-(SP)            ;                    3884
  6064.     JSR    PC,KRM.ERROR
  6065.     TST    (SP)+                ;                    3881
  6066.     MOV    #12,R0                ;                    3883
  6067.     RTS    PC
  6068. 1$:    MOV    #GEN.1DATA,-(SP)        ;                    3888
  6069.     MOV    #140,-(SP)
  6070.     MOV    #1,-(SP)
  6071.     JSR    PC,U.29
  6072.     JSR    PC,U.27                ;                    3889
  6073.     CLR    (SP)                ;                    3890
  6074.     CLR    -(SP)
  6075.     CLR    -(SP)
  6076.     JSR    PC,U.29
  6077.     MOV    R0,GEN.1SIZE
  6078.     MOV    #17,(SP)            ;                    3891
  6079.     JSR    PC,U.16
  6080.     ADD    #12,SP                ;                    3838
  6081.     RTS    PC
  6082. ; Routine Size:  41 words,    Routine Base:  $CODE$ + 12622
  6083. ; Maximum stack depth per invocation:  6 words
  6084.     .NLIST
  6085.     .DSABL    LSB
  6086.     .NLIST    BIN,LOC
  6087.     .LIST
  6088.  
  6089.  
  6090. ;      3893    %SBTTL 'CALL_SY_RTN - handle operating system dependent functions'
  6091. ;      3894    ROUTINE CALL_SY_RTN (G_FUNC) =
  6092. ;      3895    
  6093. ;      3896    !++
  6094. ;      3897    ! FUNCTIONAL DESCRIPTION:
  6095. ;      3898    !
  6096. ;      3899    ! This routine will handle calling the operating system dependent routine
  6097. ;      3900    ! for a server function and returning the response.
  6098. ;      3901    !
  6099. ;      3902    ! CALLING SEQUENCE:
  6100. ;      3903    !
  6101. ;      3904    !    STATE = CALL_SY_RTN(.G_FUNC);
  6102. ;      3905    !
  6103. ;      3906    ! INPUT PARAMETERS:
  6104. ;      3907    !
  6105. ;      3908    !    G_FUNC - Generic function code
  6106. ;      3909    !
  6107. ;      3910    ! IMPLICIT INPUTS:
  6108. ;      3911    !
  6109. ;      3912    !    Generic message data in GEN_1DATA
  6110. ;      3913    !
  6111. ;      3914    ! OUTPUT PARAMETERS:
  6112. ;      3915    !
  6113. ;      3916    !    Returns new state for FSM
  6114. ;      3917    !
  6115. ;      3918    ! IMPLICIT OUTPUTS:
  6116. ;      3919    !
  6117. ;      3920    !    None.
  6118. ;      3921    !
  6119. ;      3922    ! COMPLETION CODES:
  6120. ;      3923    !
  6121. ;      3924    !    None.
  6122. ;      3925    !
  6123. ;      3926    ! SIDE EFFECTS:
  6124. ;      3927    !
  6125. ;      3928    !    None.
  6126. ;      3929    !
  6127. ;      3930    !--
  6128. ;      3931    
  6129. ;      3932        BEGIN
  6130. ;      3933    
  6131. ;      3934        LOCAL
  6132. ;      3935        STRING_ADDRESS,                ! Address of string result
  6133. ;      3936        STRING_LENGTH,                ! Length of string result
  6134. ;      3937        GET_CHR_SUBROUTINE,            ! Routine to get a response character
  6135. ;      3938        STATUS;                    ! Status value
  6136. ;      3939    
  6137. ;      3940    !
  6138. ;      3941    ! Call the routine with the desired type of command.
  6139. ;      3942    !
  6140. ;      3943        STRING_LENGTH = 0;                ! Initialize for no string
  6141. ;      3944        GET_CHR_SUBROUTINE = 0;            ! And no subroutine
  6142. ;      3945        IF NOT SY_GENERIC (.G_FUNC, STRING_ADDRESS, STRING_LENGTH, GET_CHR_SUBROUTINE)
  6143. ;      3946        THEN
  6144. ;      3947        RETURN STATE_A;                ! And abort
  6145. ;      3948    
  6146. ;      3949    
  6147. ;      3950        IF .STRING_LENGTH GTR 0
  6148. ;      3951        THEN
  6149. ;      3952        BEGIN
  6150. ;      3953        SET_STRING (CH$PTR (.STRING_ADDRESS), .STRING_LENGTH, TRUE);
  6151. ;      3954    
  6152. ;      3955        IF .STRING_LENGTH LSS .SEND_PKT_SIZE - PKT_OVR_HEAD
  6153. ;      3956        THEN
  6154. ;      3957            BEGIN
  6155. ;      3958            BFR_FILL (TRUE);            ! If it should fit, pack it in
  6156. ;      3959    
  6157. ;      3960            IF SET_STRING (0, 0, FALSE) GEQ .STRING_LENGTH
  6158. ;      3961            THEN                 ! It fit, so just send the ACK
  6159. ;      3962    
  6160. ;      3963            IF SEND_PACKET (MSG_ACK, .SIZE, .REC_SEQ) THEN RETURN STATE_C ELSE RETURN STATE_EX;
  6161. ;      3964    
  6162. ;      3965    !
  6163. ;      3966    ! It didn't fit, reset the pointers to the beginning
  6164. ;      3967    !
  6165. ;      3968            SET_STRING (CH$PTR (.STRING_ADDRESS), .STRING_LENGTH, TRUE);
  6166. ;      3969            END;
  6167. ;      3970    
  6168. ;      3971        NO_FILE_NEEDED = TRUE;            ! Don't need a file
  6169. ;      3972        END
  6170. ;      3973        ELSE
  6171. ;      3974    
  6172. ;      3975        IF .GET_CHR_SUBROUTINE NEQ 0        ! If we got a subroutine back
  6173. ;      3976        THEN
  6174. ;      3977            BEGIN
  6175. ;      3978            GET_CHR_ROUTINE = .GET_CHR_SUBROUTINE;
  6176. ;      3979            NO_FILE_NEEDED = TRUE;
  6177. ;      3980            END;
  6178. ;      3981    
  6179. ;      3982        TEXT_HEAD_FLAG = TRUE;            ! Send to be typed
  6180. ;      3983        XFR_STATUS (%C'I', %C'G');            ! Doing a generic command
  6181. ;      3984    
  6182. ;      3985        IF .STATE EQL STATE_II AND .BLK_CHK_TYPE EQL .INI_CHK_TYPE
  6183. ;      3986        THEN
  6184. ;      3987        RETURN STATE_OF
  6185. ;      3988        ELSE
  6186. ;      3989        RETURN STATE_S;                ! Send the response
  6187. ;      3990    
  6188. ;      3991        END;                    ! End of CALL_SY_RTN
  6189.     .NLIST
  6190.     .LIST    BIN,LOC
  6191.     .LIST
  6192.  
  6193.     .SBTTL    CALL.SY.RTN CALL_SY_RTN - handle operating system dependent
  6194.     .NLIST
  6195.     .ENABL    LSB
  6196.     .LIST
  6197. ; CALL.SY.RTN
  6198. U.16:    MOV    R1,-(SP)            ;                    3894
  6199.     TST    -(SP)
  6200.     CLR    -(SP)                ; STRING.LENGTH                3943
  6201.     CLR    -(SP)                ; GET.CHR.SUBROUT            3944
  6202.     MOV    12(SP),-(SP)            ; G.FUNC,*                3945
  6203.     MOV    #10,-(SP)
  6204.     ADD    SP,(SP)                ; STRING.ADDRESS,*
  6205.     MOV    #10,-(SP)
  6206.     ADD    SP,(SP)                ; STRING.LENGTH,*
  6207.     MOV    #10,-(SP)
  6208.     ADD    SP,(SP)                ; GET.CHR.SUBROUT,*
  6209.     JSR    PC,SY.GENERIC
  6210.     ADD    #10,SP
  6211.     ROR    R0
  6212.     BLO    1$
  6213.     MOV    #12,R0                ;                    3947
  6214.     BR    10$
  6215. 1$:    MOV    2(SP),R1            ; STRING.LENGTH,*            3950
  6216.     BLE    6$
  6217.     MOV    4(SP),-(SP)            ; STRING.ADDRESS,*            3953
  6218.     MOV    R1,-(SP)
  6219.     MOV    #1,-(SP)
  6220.     JSR    PC,U.29
  6221.     MOV    U.64,R0                ;                    3955
  6222.     SUB    #3,R0
  6223.     CMP    R1,R0
  6224.     BGE    5$
  6225.     MOV    #1,(SP)                ;                    3958
  6226.     JSR    PC,U.28
  6227.     CLR    (SP)                ;                    3960
  6228.     CLR    -(SP)
  6229.     CLR    -(SP)
  6230.     JSR    PC,U.29
  6231.     CMP    (SP)+,(SP)+
  6232.     CMP    R0,R1
  6233.     BLT    4$
  6234.     MOV    #131,(SP)            ;                    3963
  6235.     MOV    U.75,-(SP)
  6236.     MOV    U.79,-(SP)
  6237.     JSR    PC,U.23
  6238.     CMP    (SP)+,(SP)+
  6239.     ROR    R0
  6240.     BCC    2$
  6241.     MOV    #11,R0                ;                    3960
  6242.     BR    3$
  6243. 2$:    MOV    #23,R0
  6244. 3$:    ADD    #6,SP
  6245.     BR    10$                ;                    3963
  6246. 4$:    MOV    12(SP),(SP)            ; STRING.ADDRESS,*            3968
  6247.     MOV    R1,-(SP)
  6248.     MOV    #1,-(SP)
  6249.     JSR    PC,U.29
  6250.     CMP    (SP)+,(SP)+            ;                    3957
  6251. 5$:    MOV    #1,U.87                ;                    3971
  6252.     ADD    #6,SP                ;                    3952
  6253.     BR    7$                ;                    3950
  6254. 6$:    MOV    (SP),R0                ; GET.CHR.SUBROUT,*            3975
  6255.     BEQ    7$
  6256.     MOV    R0,U.91                ;                    3978
  6257.     MOV    #1,U.87                ;                    3979
  6258. 7$:    MOV    #1,U.86                ;                    3982
  6259.     MOV    #111,-(SP)            ;                    3983
  6260.     MOV    #107,-(SP)
  6261.     JSR    PC,XFR.STATUS
  6262.     CMP    U.74,#17            ;                    3985
  6263.     BNE    8$
  6264.     CMP    U.71,U.70
  6265.     BNE    8$
  6266.     MOV    #22,R0                ;                    3932
  6267.     BR    9$
  6268. 8$:    MOV    #1,R0
  6269. 9$:    CMP    (SP)+,(SP)+            ;                    3894
  6270. 10$:    ADD    #6,SP
  6271.     MOV    (SP)+,R1
  6272.     RTS    PC
  6273. ; Routine Size:  119 words,    Routine Base:  $CODE$ + 12744
  6274. ; Maximum stack depth per invocation:  10 words
  6275.     .NLIST
  6276.     .DSABL    LSB
  6277.     .NLIST    BIN,LOC
  6278.     .LIST
  6279.  
  6280.  
  6281. ;      3992    %SBTTL 'Message processing -- PRS_SEND_INIT - Parse send init params'
  6282. ;      3993    ROUTINE PRS_SEND_INIT =
  6283. ;      3994    
  6284. ;      3995    !++
  6285. ;      3996    ! FUNCTIONAL DESCRIPTION:
  6286. ;      3997    !
  6287. ;      3998    !    This routine will parse the SEND_INIT parameters that were sent by
  6288. ;      3999    !    the remote Kermit.  The items will be stored into the low segment.
  6289. ;      4000    !
  6290. ;      4001    ! CALLING SEQUENCE:
  6291. ;      4002    !
  6292. ;      4003    !    PRS_SEND_INIT ();
  6293. ;      4004    !
  6294. ;      4005    ! INPUT PARAMETERS:
  6295. ;      4006    !
  6296. ;      4007    !    None.
  6297. ;      4008    !
  6298. ;      4009    ! IMPLICIT INPUTS:
  6299. ;      4010    !
  6300. ;      4011    !    Message stored in REC_MSG.
  6301. ;      4012    !
  6302. ;      4013    ! OUTPUT PARAMETERS:
  6303. ;      4014    !
  6304. ;      4015    !    None.
  6305. ;      4016    !
  6306. ;      4017    ! IMPLICIT OUTPUTS:
  6307. ;      4018    !
  6308. ;      4019    !    None.
  6309. ;      4020    !
  6310. ;      4021    ! COMPLETION CODES:
  6311. ;      4022    !
  6312. ;      4023    !    None.
  6313. ;      4024    !
  6314. ;      4025    ! SIDE EFFECTS:
  6315. ;      4026    !
  6316. ;      4027    !    None.
  6317. ;      4028    !
  6318. ;      4029    !--
  6319. ;      4030    
  6320. ;      4031        BEGIN
  6321. ;      4032    ! The following section of code will parse the various send parameters
  6322. ;      4033    ! that are found in the send-init message.  The following code will store
  6323. ;      4034    ! the following as the value.
  6324. ;      4035    !
  6325. ;      4036    ! If the user specified a value then the user supplied value will be used else
  6326. ;      4037    ! the value in the message and if none in the message then the default value.
  6327. ;      4038    !
  6328. ;      4039    ! User supplied values are denoted as positive values in SND_xxxxxxx.
  6329. ;      4040    !
  6330. ;      4041    ! Parse the packet size
  6331. ;      4042    !
  6332. ;      4043        SEND_PKT_SIZE = (IF .SND_PKT_SIZE GEQ 0 THEN .SND_PKT_SIZE ELSE
  6333. ;      4044        BEGIN
  6334. ;      4045    
  6335. ;      4046        IF .REC_LENGTH GTR P_SI_BUFSIZ
  6336. ;      4047        THEN
  6337. ;    P 4048            UNCHAR (CH$RCHAR (CH$PTR (REC_MSG,
  6338. ;      4049                PKT_MSG + P_SI_BUFSIZ, CHR_SIZE)))
  6339. ;      4050        ELSE
  6340. ;      4051            ABS (.SND_PKT_SIZE)
  6341. ;      4052    
  6342. ;      4053        END
  6343. ;      4054        );
  6344. ;      4055    !
  6345. ;      4056    ! Parse the time out value
  6346. ;      4057    !
  6347. ;      4058        SEND_TIMEOUT = (IF .SND_TIMEOUT GEQ 0 THEN .SND_TIMEOUT ELSE
  6348. ;      4059        BEGIN
  6349. ;      4060    
  6350. ;      4061        IF .REC_LENGTH GTR P_SI_TIMOUT
  6351. ;      4062        THEN
  6352. ;    P 4063            UNCHAR (CH$RCHAR (CH$PTR (REC_MSG,
  6353. ;      4064                PKT_MSG + P_SI_TIMOUT, CHR_SIZE)))
  6354. ;      4065        ELSE
  6355. ;      4066            ABS (.SND_TIMEOUT)
  6356. ;      4067    
  6357. ;      4068        END
  6358. ;      4069        );
  6359. ;      4070    !
  6360. ;      4071    ! Parse the number of padding characters supplied
  6361. ;      4072    !
  6362. ;      4073        SEND_NPAD = (IF .SND_NPAD GEQ 0 THEN .SND_NPAD ELSE
  6363. ;      4074        BEGIN
  6364. ;      4075    
  6365. ;      4076        IF .REC_LENGTH GTR P_SI_NPAD
  6366. ;      4077        THEN
  6367. ;    P 4078            UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_NPAD,
  6368. ;      4079                CHR_SIZE)))
  6369. ;      4080        ELSE
  6370. ;      4081            ABS (.SND_NPAD)
  6371. ;      4082    
  6372. ;      4083        END
  6373. ;      4084        );
  6374. ;      4085    !
  6375. ;      4086    ! Parse the padding character
  6376. ;      4087    !
  6377. ;      4088        SEND_PADCHAR = (IF .SND_PADCHAR GEQ 0 THEN .SND_PADCHAR ELSE
  6378. ;      4089        BEGIN
  6379. ;      4090    
  6380. ;      4091        IF .REC_LENGTH GTR P_SI_PAD
  6381. ;      4092        THEN
  6382. ;    P 4093            CTL (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_PAD,
  6383. ;      4094                CHR_SIZE)))
  6384. ;      4095        ELSE
  6385. ;      4096            ABS (.SND_PADCHAR)
  6386. ;      4097    
  6387. ;      4098        END
  6388. ;      4099        );
  6389. ;      4100    !
  6390. ;      4101    ! Parse the end of line character
  6391. ;      4102    !
  6392. ;      4103        SEND_EOL = (IF .SND_EOL GEQ 0 THEN .SND_EOL ELSE
  6393. ;      4104        BEGIN
  6394. ;      4105    
  6395. ;      4106        IF .REC_LENGTH GTR P_SI_EOL
  6396. ;      4107        THEN
  6397. ;    P 4108            UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_EOL,
  6398. ;      4109                CHR_SIZE)))
  6399. ;      4110        ELSE
  6400. ;      4111            ABS (.SND_EOL)
  6401. ;      4112    
  6402. ;      4113        END
  6403. ;      4114        );
  6404. ;      4115    !
  6405. ;      4116    ! Parse the quoting character
  6406. ;      4117    !
  6407. ;      4118        SEND_QUOTE_CHR = (IF .SND_QUOTE_CHR GEQ 0 THEN .SND_QUOTE_CHR ELSE
  6408. ;      4119        BEGIN
  6409. ;      4120    
  6410. ;      4121        IF .REC_LENGTH GTR P_SI_QUOTE
  6411. ;      4122        THEN
  6412. ;      4123            CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_QUOTE,
  6413. ;      4124                CHR_SIZE))
  6414. ;      4125        ELSE
  6415. ;      4126            ABS (.SND_QUOTE_CHR)
  6416. ;      4127    
  6417. ;      4128        END
  6418. ;      4129        );
  6419. ;      4130    !
  6420. ;      4131    ! Parse the 8-bit quoting character
  6421. ;      4132    !
  6422. ;      4133    ! If the character was not included in the packet, assume no eight-bit
  6423. ;      4134    ! quoting allowed (we are probably talking to an old version of Kermit).
  6424. ;      4135    !
  6425. ;      4136        SEND_8QUOTE_CHR = (IF .REC_LENGTH GTR P_SI_8QUOTE THEN CH$RCHAR (CH$PTR (REC_MSG,
  6426. ;      4137            PKT_MSG + P_SI_8QUOTE, CHR_SIZE)) ELSE %C'N'    ! Assume no 8-bit quoting allowed
  6427. ;      4138        );
  6428. ;      4139    !
  6429. ;      4140    ! Parse the checksum type
  6430. ;      4141    !
  6431. ;      4142    
  6432. ;      4143        IF .REC_LENGTH GTR P_SI_CHKTYPE
  6433. ;      4144        THEN
  6434. ;      4145        BEGIN
  6435. ;      4146    
  6436. ;      4147        LOCAL
  6437. ;      4148            REQ_CHK_TYPE;
  6438. ;      4149    
  6439. ;      4150        REQ_CHK_TYPE = CH$RCHAR (CH$PTR (REC_MSG, PKT_MSG + P_SI_CHKTYPE, CHR_SIZE));
  6440. ;      4151    
  6441. ;      4152        IF .REC_TYPE NEQ MSG_ACK
  6442. ;      4153        THEN
  6443. ;      4154    
  6444. ;      4155            IF .REQ_CHK_TYPE GEQ CHK_1CHAR AND .REQ_CHK_TYPE LEQ CHK_CRC
  6445. ;      4156            THEN
  6446. ;      4157            INI_CHK_TYPE = .REQ_CHK_TYPE
  6447. ;      4158            ELSE
  6448. ;      4159            INI_CHK_TYPE = CHK_1CHAR
  6449. ;      4160    
  6450. ;      4161        ELSE
  6451. ;      4162    
  6452. ;      4163            IF .REQ_CHK_TYPE NEQ .CHKTYPE
  6453. ;      4164            THEN
  6454. ;      4165            INI_CHK_TYPE = CHK_1CHAR
  6455. ;      4166            ELSE
  6456. ;      4167            INI_CHK_TYPE = .REQ_CHK_TYPE
  6457. ;      4168    
  6458. ;      4169        END
  6459. ;      4170        ELSE
  6460. ;      4171        INI_CHK_TYPE = CHK_1CHAR;        ! Only single character checksum if not specified
  6461. ;      4172    
  6462. ;      4173    !
  6463. ;      4174    ! Parse the repeat character
  6464. ;      4175    !
  6465. ;      4176        REPT_CHR = (IF .REC_LENGTH GTR P_SI_REPEAT THEN CH$RCHAR (CH$PTR (REC_MSG,
  6466. ;      4177            PKT_MSG + P_SI_REPEAT, CHR_SIZE)) ELSE %C' ');
  6467. ;      4178    !
  6468. ;      4179    ! Check for a valid quoting character.  If it is not valid, then we have
  6469. ;      4180    ! a protocol error
  6470. ;      4181    !
  6471. ;      4182    
  6472. ;      4183        IF NOT ((.SEND_QUOTE_CHR GEQ %O'41' AND .SEND_QUOTE_CHR LEQ %O'76') OR (.SEND_QUOTE_CHR GEQ %O
  6473. ;      4184        '140' AND .SEND_QUOTE_CHR LEQ %O'176'))
  6474. ;      4185        THEN
  6475. ;      4186        BEGIN
  6476. ;      4187        KRM_ERROR (KER_PROTOERR);
  6477. ;      4188        RETURN KER_PROTOERR;
  6478. ;      4189        END;
  6479. ;      4190    
  6480. ;      4191    !
  6481. ;      4192    ! Check for a valid 8 bit quoting and set the 8 bit quoting flag as needed
  6482. ;      4193    !
  6483. ;      4194    
  6484. ;      4195        IF ( NOT ((.SEND_8QUOTE_CHR GEQ %O'041' AND .SEND_8QUOTE_CHR LEQ %O'076') OR (.SEND_8QUOTE_CHR
  6485. ;      4196        GEQ %O'140' AND .SEND_8QUOTE_CHR LEQ %O'176') OR (.SEND_8QUOTE_CHR EQL %C'N') OR (
  6486. ;      4197        .SEND_8QUOTE_CHR EQL %C'Y'))) OR .SEND_8QUOTE_CHR EQL .SEND_QUOTE_CHR
  6487. ;      4198        OR .SEND_8QUOTE_CHR EQL .RCV_QUOTE_CHR
  6488. ;      4199        THEN
  6489. ;      4200        BEGIN
  6490. ;      4201        KRM_ERROR (KER_PROTOERR);
  6491. ;      4202        RETURN KER_PROTOERR;
  6492. ;      4203        END;
  6493. ;      4204    
  6494. ;      4205        IF .SEND_8QUOTE_CHR EQL %C'Y' THEN SEND_8QUOTE_CHR = .RECV_8QUOTE_CHR;
  6495. ;      4206    
  6496. ;      4207        IF .SEND_8QUOTE_CHR NEQ %C'N' AND .SEND_8QUOTE_CHR NEQ %C'Y'
  6497. ;      4208        THEN
  6498. ;      4209        FLAG_8QUOTE = TRUE
  6499. ;      4210        ELSE
  6500. ;      4211        FLAG_8QUOTE = FALSE;
  6501. ;      4212    
  6502. ;      4213    !
  6503. ;      4214    ! Check the repeat character and set flags
  6504. ;      4215    !
  6505. ;      4216    
  6506. ;      4217        IF ( NOT ((.REPT_CHR GEQ %O'41' AND .REPT_CHR LEQ %O'76') OR (.REPT_CHR GEQ %O'140' AND
  6507. ;      4218        .REPT_CHR LEQ %O'176')) OR .REPT_CHR EQL .SEND_QUOTE_CHR OR .REPT_CHR EQL .SEND_8QUOTE_CHR OR .REPT_CHR EQL .RCV_Q
  6508. ;      4219        AND .REPT_CHR NEQ %C' '
  6509. ;      4220        THEN
  6510. ;      4221        BEGIN
  6511. ;      4222        KRM_ERROR (KER_PROTOERR);
  6512. ;      4223        RETURN KER_PROTOERR;
  6513. ;      4224        END;
  6514. ;      4225    
  6515. ;      4226        IF .REPT_CHR NEQ %C' ' THEN FLAG_REPEAT = TRUE ELSE FLAG_REPEAT = FALSE;
  6516. ;      4227    
  6517. ;      4228        RETURN KER_NORMAL;
  6518. ;      4229        END;                    ! End of PRS_SEND_INIT
  6519.     .NLIST
  6520.     .LIST    BIN,LOC
  6521.     .LIST
  6522.  
  6523.     .SBTTL    PRS.SEND.INIT Message processing -- PRS_SEND_INIT - Parse sen
  6524.     .NLIST
  6525.     .ENABL    LSB
  6526.     .LIST
  6527. ; PRS.SEND.INIT
  6528. U.20:    MOV    R1,-(SP)            ;                    3993
  6529.     MOV    SND.PKT.SIZE,R0            ;                    4043
  6530.     BGE    2$
  6531.     TST    U.80                ;                    4046
  6532.     BLE    1$
  6533.     CLR    R0                ;                    4049
  6534.     BISB    U.82+4,R0
  6535.     SUB    #40,R0
  6536.     BR    2$                ;                    4044
  6537. 1$:    MOV    R0,-(SP)            ;                    4051
  6538.     JSR    PC,BL$ABS
  6539.     TST    (SP)+
  6540. 2$:    MOV    R0,U.64                ;                    4043
  6541.     MOV    SND.TIMEOUT,R0            ;                    4058
  6542.     BGE    4$
  6543.     CMP    U.80,#1                ;                    4061
  6544.     BLE    3$
  6545.     CLR    R0                ;                    4064
  6546.     BISB    U.82+5,R0
  6547.     SUB    #40,R0
  6548.     BR    4$                ;                    4059
  6549. 3$:    MOV    R0,-(SP)            ;                    4066
  6550.     JSR    PC,BL$ABS
  6551.     TST    (SP)+
  6552. 4$:    MOV    R0,SEND.TIMEOUT            ;                    4058
  6553.     MOV    SND.NPAD,R0            ;                    4073
  6554.     BGE    6$
  6555.     CMP    U.80,#2                ;                    4076
  6556.     BLE    5$
  6557.     CLR    R0                ;                    4079
  6558.     BISB    U.82+6,R0
  6559.     SUB    #40,R0
  6560.     BR    6$                ;                    4074
  6561. 5$:    MOV    R0,-(SP)            ;                    4081
  6562.     JSR    PC,BL$ABS
  6563.     TST    (SP)+
  6564. 6$:    MOV    R0,U.65                ;                    4073
  6565.     MOV    SND.PADCHAR,R0            ;                    4088
  6566.     BGE    8$
  6567.     CMP    U.80,#3                ;                    4091
  6568.     BLE    7$
  6569.     MOV    #100,R1                ;                    4094
  6570.     CLR    R0
  6571.     BISB    U.82+7,R0
  6572.     XOR    R0,R1
  6573.     MOV    R1,R0                ;                    4089
  6574.     BR    8$
  6575. 7$:    MOV    R0,-(SP)            ;                    4096
  6576.     JSR    PC,BL$ABS
  6577.     TST    (SP)+
  6578. 8$:    MOV    R0,U.66                ;                    4088
  6579.     MOV    SND.EOL,R0            ;                    4103
  6580.     BGE    10$
  6581.     CMP    U.80,#4                ;                    4106
  6582.     BLE    9$
  6583.     CLR    R0                ;                    4109
  6584.     BISB    U.82+10,R0
  6585.     SUB    #40,R0
  6586.     BR    10$                ;                    4104
  6587. 9$:    MOV    R0,-(SP)            ;                    4111
  6588.     JSR    PC,BL$ABS
  6589.     TST    (SP)+
  6590. 10$:    MOV    R0,U.67                ;                    4103
  6591.     MOV    SND.QUOTE.CHR,R0        ;                    4118
  6592.     BGE    12$
  6593.     CMP    U.80,#5                ;                    4121
  6594.     BLE    11$
  6595.     CLR    R0                ;                    4119
  6596.     BISB    U.82+11,R0
  6597.     BR    12$
  6598. 11$:    MOV    R0,-(SP)            ;                    4126
  6599.     JSR    PC,BL$ABS
  6600.     TST    (SP)+
  6601. 12$:    MOV    R0,U.68                ;                    4118
  6602.     MOV    U.80,R1                ;                    4136
  6603.     CMP    R1,#6
  6604.     BLE    13$
  6605.     CLR    R0
  6606.     BISB    U.82+12,R0
  6607.     BR    14$
  6608. 13$:    MOV    #116,R0
  6609. 14$:    MOV    R0,U.69
  6610.     CMP    R1,#7                ;                    4143
  6611.     BLE    17$
  6612.     CLR    R0                ; REQ.CHK.TYPE                4150
  6613.     BISB    U.82+13,R0            ; *,REQ.CHK.TYPE
  6614.     CMP    U.81,#131            ;                    4152
  6615.     BEQ    15$
  6616.     CMP    R0,#61                ; REQ.CHK.TYPE,*            4155
  6617.     BLT    17$
  6618.     CMP    R0,#63                ; REQ.CHK.TYPE,*
  6619.     BGT    17$
  6620.     BR    16$                ;                    4157
  6621. 15$:    CMP    R0,CHKTYPE            ; REQ.CHK.TYPE,*            4163
  6622.     BNE    17$                ;                    4165
  6623. 16$:    MOV    R0,U.70                ; REQ.CHK.TYPE,*            4167
  6624.     BR    18$                ;                    4143
  6625. 17$:    MOV    #61,U.70            ;                    4171
  6626. 18$:    CMP    R1,#10                ;                    4176
  6627.     BLE    19$
  6628.     CLR    R0
  6629.     BISB    U.82+14,R0
  6630.     BR    20$
  6631. 19$:    MOV    #40,R0
  6632. 20$:    MOV    R0,U.63
  6633.     MOV    U.68,R0                ;                    4183
  6634.     CMP    R0,#41
  6635.     BLT    21$
  6636.     CMP    R0,#76
  6637.     BLE    22$
  6638. 21$:    CMP    R0,#140
  6639.     BLT    32$
  6640.     CMP    R0,#176                ;                    4184
  6641.     BGT    32$                ;                    4187
  6642. 22$:    MOV    U.69,R0                ;                    4195
  6643.     CMP    R0,#41
  6644.     BLT    23$
  6645.     CMP    R0,#76
  6646.     BLE    25$
  6647. 23$:    CMP    R0,#140                ;                    4196
  6648.     BLT    24$
  6649.     CMP    R0,#176
  6650.     BLE    25$
  6651. 24$:    CMP    R0,#116
  6652.     BEQ    25$
  6653.     CMP    R0,#131
  6654.     BNE    32$
  6655. 25$:    CMP    R0,U.68                ;                    4197
  6656.     BEQ    32$
  6657.     CMP    R0,RCV.QUOTE.CHR        ;                    4198
  6658.     BEQ    32$                ;                    4201
  6659.     CMP    U.69,#131            ;                    4205
  6660.     BNE    26$
  6661.     MOV    U.62,U.69
  6662. 26$:    MOV    U.69,R1                ;                    4207
  6663.     CMP    R1,#116
  6664.     BEQ    27$
  6665.     CMP    R1,#131
  6666.     BEQ    27$
  6667.     MOV    #1,U.72                ;                    4209
  6668.     BR    28$                ;                    4207
  6669. 27$:    CLR    U.72                ;                    4211
  6670. 28$:    MOV    U.63,R0                ;                    4217
  6671.     CMP    R0,#41
  6672.     BLT    29$
  6673.     CMP    R0,#76
  6674.     BLE    30$
  6675. 29$:    CMP    R0,#140
  6676.     BLT    31$
  6677.     CMP    R0,#176                ;                    4218
  6678.     BGT    31$
  6679. 30$:    CMP    R0,U.68
  6680.     BEQ    31$
  6681.     CMP    R0,R1
  6682.     BEQ    31$
  6683.     CMP    R0,RCV.QUOTE.CHR
  6684.     BNE    33$
  6685. 31$:    CMP    R0,#40                ;                    4219
  6686.     BEQ    33$
  6687. 32$:    MOV    #242,-(SP)            ;                    4222
  6688.     JSR    PC,KRM.ERROR
  6689.     TST    (SP)+                ;                    4217
  6690.     MOV    #242,R0                ;                    4221
  6691.     BR    36$
  6692. 33$:    CMP    U.63,#40            ;                    4226
  6693.     BEQ    34$
  6694.     MOV    #1,U.73
  6695.     BR    35$
  6696. 34$:    CLR    U.73
  6697. 35$:    MOV    #1,R0                ;                    4031
  6698. 36$:    MOV    (SP)+,R1            ;                    3993
  6699.     RTS    PC
  6700. ; Routine Size:  272 words,    Routine Base:  $CODE$ + 13322
  6701. ; Maximum stack depth per invocation:  3 words
  6702.     .NLIST
  6703.     .DSABL    LSB
  6704.     .NLIST    BIN,LOC
  6705.     .LIST
  6706.  
  6707.  
  6708. ;      4230    %SBTTL 'SET_SEND_INIT'
  6709. ;      4231    ROUTINE SET_SEND_INIT : NOVALUE =
  6710. ;      4232    
  6711. ;      4233    !++
  6712. ;      4234    ! FUNCTIONAL DESCRIPTION:
  6713. ;      4235    !
  6714. ;      4236    !    This routine will initialize the various parameters for the
  6715. ;      4237    !    MSG_SND_INIT message.
  6716. ;      4238    !
  6717. ;      4239    ! CALLING SEQUENCE:
  6718. ;      4240    !
  6719. ;      4241    !    SET_SEND_INIT();
  6720. ;      4242    !
  6721. ;      4243    ! INPUT PARAMETERS:
  6722. ;      4244    !
  6723. ;      4245    !    None.
  6724. ;      4246    !
  6725. ;      4247    ! IMPLICIT INPUTS:
  6726. ;      4248    !
  6727. ;      4249    !    None.
  6728. ;      4250    !
  6729. ;      4251    ! OUTPUT PARAMETERS:
  6730. ;      4252    !
  6731. ;      4253    !    None.
  6732. ;      4254    !
  6733. ;      4255    ! IMPLICIT OUTPUTS:
  6734. ;      4256    !
  6735. ;      4257    !    SND_MSG parameters set up.
  6736. ;      4258    !
  6737. ;      4259    ! COMPLETION CODES:
  6738. ;      4260    !
  6739. ;      4261    !    None.
  6740. ;      4262    !
  6741. ;      4263    ! SIDE EFFECTS:
  6742. ;      4264    !
  6743. ;      4265    !    None.
  6744. ;      4266    !
  6745. ;      4267    !--
  6746. ;      4268    
  6747. ;      4269        BEGIN
  6748. ;      4270        CH$WCHAR (CHAR (.RCV_PKT_SIZE), CH$PTR (SND_MSG, PKT_MSG + P_SI_BUFSIZ, CHR_SIZE));
  6749. ;      4271        CH$WCHAR (CHAR (.RCV_TIMEOUT), CH$PTR (SND_MSG, PKT_MSG + P_SI_TIMOUT, CHR_SIZE));
  6750. ;      4272        CH$WCHAR (CHAR (.RCV_NPAD), CH$PTR (SND_MSG, PKT_MSG + P_SI_NPAD, CHR_SIZE));
  6751. ;      4273        CH$WCHAR (CTL (.RCV_PADCHAR), CH$PTR (SND_MSG, PKT_MSG + P_SI_PAD, CHR_SIZE));
  6752. ;      4274        CH$WCHAR (CHAR (.RCV_EOL), CH$PTR (SND_MSG, PKT_MSG + P_SI_EOL, CHR_SIZE));
  6753. ;      4275        CH$WCHAR (.RCV_QUOTE_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_QUOTE, CHR_SIZE));
  6754. ;      4276        CH$WCHAR (.SEND_8QUOTE_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_8QUOTE, CHR_SIZE));
  6755. ;      4277        CH$WCHAR (.INI_CHK_TYPE, CH$PTR (SND_MSG, PKT_MSG + P_SI_CHKTYPE, CHR_SIZE));
  6756. ;      4278        CH$WCHAR (.REPT_CHR, CH$PTR (SND_MSG, PKT_MSG + P_SI_REPEAT, CHR_SIZE));
  6757. ;      4279        END;                    ! End of SET_SEND_INIT
  6758.     .NLIST
  6759.     .LIST    BIN,LOC
  6760.     .LIST
  6761.  
  6762.     .SBTTL    SET.SEND.INIT SET_SEND_INIT
  6763.     .NLIST
  6764.     .ENABL    LSB
  6765.     .LIST
  6766. ; SET.SEND.INIT
  6767. U.19:    MOV    R1,-(SP)            ;                    4231
  6768.     MOV    RCV.PKT.SIZE,R0            ;                    4270
  6769.     ADD    #40,R0
  6770.     MOVB    R0,U.83+4
  6771.     MOV    RCV.TIMEOUT,R0            ;                    4271
  6772.     ADD    #40,R0
  6773.     MOVB    R0,U.83+5
  6774.     MOV    RCV.NPAD,R0            ;                    4272
  6775.     ADD    #40,R0
  6776.     MOVB    R0,U.83+6
  6777.     MOV    RCV.PADCHAR,R1            ;                    4273
  6778.     MOV    #100,R0
  6779.     XOR    R0,R1
  6780.     MOVB    R1,U.83+7
  6781.     MOV    RCV.EOL,R0            ;                    4274
  6782.     ADD    #40,R0
  6783.     MOVB    R0,U.83+10
  6784.     MOVB    RCV.QUOTE.CHR,U.83+11        ;                    4275
  6785.     MOVB    U.69,U.83+12            ;                    4276
  6786.     MOVB    U.70,U.83+13            ;                    4277
  6787.     MOVB    U.63,U.83+14            ;                    4278
  6788.     MOV    (SP)+,R1            ;                    4231
  6789.     RTS    PC
  6790. ; Routine Size:  46 words,    Routine Base:  $CODE$ + 14362
  6791. ; Maximum stack depth per invocation:  2 words
  6792.     .NLIST
  6793.     .DSABL    LSB
  6794.     .NLIST    BIN,LOC
  6795.     .LIST
  6796.  
  6797.  
  6798. ;      4280    %SBTTL 'SEND_PACKET'
  6799. ;      4281    ROUTINE SEND_PACKET (TYPE, LENGTH, MN) =
  6800. ;      4282    
  6801. ;      4283    !++
  6802. ;      4284    ! FUNCTIONAL DESCRIPTION:
  6803. ;      4285    !
  6804. ;      4286    !    This routine will cause a packet to be sent over the line
  6805. ;      4287    !    that has been opened by OPEN_TERMINAL.
  6806. ;      4288    !
  6807. ;      4289    ! CALLING SEQUENCE:
  6808. ;      4290    !
  6809. ;      4291    !    SEND_PACKET(Type, Length);
  6810. ;      4292    !
  6811. ;      4293    ! INPUT PARAMETERS:
  6812. ;      4294    !
  6813. ;      4295    !    TYPE - Type of packet to send.
  6814. ;      4296    !
  6815. ;      4297    !    LENGTH - Length of the packet being sent.
  6816. ;      4298    !
  6817. ;      4299    ! IMPLICIT INPUTS:
  6818. ;      4300    !
  6819. ;      4301    !    None.
  6820. ;      4302    !
  6821. ;      4303    ! OUTPUT PARAMETERS:
  6822. ;      4304    !
  6823. ;      4305    !    None.
  6824. ;      4306    !
  6825. ;      4307    ! IMPLICIT OUTPUTS:
  6826. ;      4308    !
  6827. ;      4309    !    None.
  6828. ;      4310    !
  6829. ;      4311    ! COMPLETION CODES:
  6830. ;      4312    !
  6831. ;      4313    !    None.
  6832. ;      4314    !
  6833. ;      4315    ! SIDE EFFECTS:
  6834. ;      4316    !
  6835. ;      4317    !    None.
  6836. ;      4318    !
  6837. ;      4319    !--
  6838. ;      4320    
  6839. ;      4321        BEGIN
  6840. ;      4322    
  6841. ;      4323        LOCAL
  6842. ;      4324        FILLER : VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)],
  6843. ;      4325        TOT_MSG_LEN,                ! Length of message including all characters
  6844. ;      4326        CHKSUM,                    ! Checksum for the message we calculate
  6845. ;      4327        POINTER;                ! Pointer to the information in the message
  6846. ;      4328    
  6847. ;      4329    !
  6848. ;      4330    ! Do any filler processing that the remote KERMIT requires.
  6849. ;      4331    !
  6850. ;      4332    
  6851. ;      4333        IF .SEND_NPAD NEQ 0
  6852. ;      4334        THEN
  6853. ;      4335        BEGIN
  6854. ;      4336        CH$FILL (.SEND_PADCHAR, MAX_MSG, CH$PTR (FILLER, 0, CHR_SIZE));
  6855. ;      4337    !
  6856. ;      4338    ! Update the send stats
  6857. ;      4339    !
  6858. ;      4340        SMSG_TOTAL_CHARS = .SMSG_TOTAL_CHARS + .SEND_NPAD;
  6859. ;      4341    !
  6860. ;      4342    ! Send the fill
  6861. ;      4343    !
  6862. ;      4344        DO_PARITY (FILLER, .SEND_NPAD + PKT_TOT_OVR_HEAD);
  6863. ;      4345        SEND (FILLER, .SEND_NPAD + PKT_TOT_OVR_HEAD);
  6864. ;      4346        END;
  6865. ;      4347    
  6866. ;      4348    !
  6867. ;      4349    ! Store the header information into the message.
  6868. ;      4350    !
  6869. ;      4351        CH$WCHAR (.TYPE, CH$PTR (SND_MSG, PKT_TYPE, CHR_SIZE));
  6870. ;      4352        CH$WCHAR (.SND_SOH, CH$PTR (SND_MSG, PKT_MARK, CHR_SIZE));
  6871. ;      4353        CH$WCHAR (CHAR (.LENGTH + PKT_OVR_HEAD + (.BLK_CHK_TYPE - CHK_1CHAR)),
  6872. ;      4354        CH$PTR (SND_MSG,
  6873. ;      4355            PKT_COUNT, CHR_SIZE));
  6874. ;      4356        CH$WCHAR (CHAR ((IF .MN LSS 0 THEN 0 ELSE .MN)), CH$PTR (SND_MSG, PKT_SEQ, CHR_SIZE));
  6875. ;      4357    !
  6876. ;      4358    ! Calculate the block check value
  6877. ;      4359    !
  6878. ;      4360        POINTER = CH$PTR (SND_MSG, PKT_MARK + 1, CHR_SIZE);
  6879. ;      4361        CHKSUM = CALC_BLOCK_CHECK (.POINTER, .LENGTH + PKT_OVR_HEAD);
  6880. ;      4362        TOT_MSG_LEN = .LENGTH + PKT_TOT_OVR_HEAD;
  6881. ;      4363    !
  6882. ;      4364    ! Store the checksum into the message
  6883. ;      4365    !
  6884. ;      4366        POINTER = CH$PTR (SND_MSG, .LENGTH + PKT_OVR_HEAD + 1, CHR_SIZE);
  6885. ;      4367    
  6886. ;      4368        CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF
  6887. ;      4369        SET
  6888. ;      4370    
  6889. ;      4371        [CHK_1CHAR] :
  6890. ;      4372            CH$WCHAR_A (CHAR (.CHKSUM), POINTER);
  6891. ;      4373    
  6892. ;      4374        [CHK_2CHAR] :
  6893. ;      4375            BEGIN
  6894. ;      4376            CH$WCHAR_A (CHAR (.CHKSUM<6, 6>), POINTER);
  6895. ;      4377            CH$WCHAR_A (CHAR (.CHKSUM<0, 6>), POINTER);
  6896. ;      4378            TOT_MSG_LEN = .TOT_MSG_LEN + 1;
  6897. ;      4379            END;
  6898. ;      4380    
  6899. ;      4381        [CHK_CRC] :
  6900. ;      4382            BEGIN
  6901. ;      4383            CH$WCHAR_A (CHAR (.CHKSUM<12, 4>), POINTER);
  6902. ;      4384            CH$WCHAR_A (CHAR (.CHKSUM<6, 6>), POINTER);
  6903. ;      4385            CH$WCHAR_A (CHAR (.CHKSUM<0, 6>), POINTER);
  6904. ;      4386            TOT_MSG_LEN = .TOT_MSG_LEN + 2;
  6905. ;      4387            END;
  6906. ;      4388        TES;
  6907. ;      4389    
  6908. ;      4390    !
  6909. ;      4391    ! Store in the end of line character
  6910. ;      4392    !
  6911. ;      4393        CH$WCHAR_A (.SEND_EOL, POINTER);
  6912. ;      4394    !
  6913. ;      4395    ! If we are debugging then type out the message we are sending.
  6914. ;      4396    !
  6915. ;      4397        DBG_SEND (SND_MSG, (.TOT_MSG_LEN));
  6916. ;      4398    !
  6917. ;      4399    ! Update the stats for total characters and the data characters
  6918. ;      4400    !
  6919. ;      4401        SMSG_TOTAL_CHARS = .SMSG_TOTAL_CHARS + .TOT_MSG_LEN;
  6920. ;      4402    ! Make data characters really be that, not just characters in data field
  6921. ;      4403    !    SMSG_DATA_CHARS = .SMSG_DATA_CHARS + .LENGTH;
  6922. ;      4404    
  6923. ;      4405        IF .TYPE EQL MSG_NAK
  6924. ;      4406        THEN
  6925. ;      4407        BEGIN
  6926. ;      4408        SMSG_NAKS = .SMSG_NAKS + 1;
  6927. ;      4409        XFR_STATUS (%C'S', %C'N');
  6928. ;      4410        END
  6929. ;      4411        ELSE
  6930. ;      4412        BEGIN
  6931. ;      4413        SMSG_COUNT = .SMSG_COUNT + 1;
  6932. ;      4414        XFR_STATUS (%C'S', %C'P');
  6933. ;      4415        END;
  6934. ;      4416    
  6935. ;      4417    !
  6936. ;      4418    ! Check if we are in IBM mode and need to wait for an XON first
  6937. ;      4419    ! We will not wait if this is a packet which might be going out
  6938. ;      4420    ! without previous traffic (generic commands, init packets).
  6939. ;      4421    
  6940. ;      4422        IF .IBM_FLAG AND NOT (.TYPE EQL MSG_SND_INIT OR .TYPE EQL MSG_SER_INIT OR .TYPE EQL MSG_RCV_INIT
  6941. ;      4423        OR .TYPE EQL MSG_COMMAND OR .TYPE EQL MSG_KERMIT)
  6942. ;      4424        THEN
  6943. ;      4425    
  6944. ;      4426        IF NOT IBM_WAIT () THEN RETURN KER_ABORTED;
  6945. ;      4427    
  6946. ;      4428    !
  6947. ;      4429    ! Now call the O/S routine to send the message out to the remote KERMIT
  6948. ;      4430    !
  6949. ;      4431        DO_PARITY (SND_MSG, .TOT_MSG_LEN);
  6950. ;      4432        RETURN SEND (SND_MSG, .TOT_MSG_LEN);
  6951. ;      4433        END;                    ! End of SEND_PACKET
  6952.     .NLIST
  6953.     .LIST    BIN,LOC
  6954.     .LIST
  6955.  
  6956.     .SBTTL    SEND.PACKET SEND_PACKET
  6957.     .NLIST
  6958.     .ENABL    LSB
  6959.     .LIST
  6960. ; SEND.PACKET
  6961. U.23:    JSR    R1,$SAVE4            ;                    4281
  6962.     SUB    #140,SP
  6963.     TST    U.65                ;                    4333
  6964.     BEQ    1$
  6965.     MOV    U.66,-(SP)            ;                    4336
  6966.     MOV    #140,-(SP)
  6967.     MOV    #6,-(SP)
  6968.     ADD    SP,(SP)                ; FILLER,*
  6969.     JSR    PC,BL$FIL
  6970.     ADD    U.65,SMSG.TOTAL.CHARS        ;                    4340
  6971.     MOV    #6,(SP)                ;                    4344
  6972.     ADD    SP,(SP)                ; FILLER,*
  6973.     MOV    U.65,-(SP)
  6974.     ADD    #6,(SP)
  6975.     JSR    PC,U.21
  6976.     MOV    #10,(SP)            ;                    4345
  6977.     ADD    SP,(SP)                ; FILLER,*
  6978.     MOV    U.65,-(SP)
  6979.     ADD    #6,(SP)
  6980.     JSR    PC,SEND
  6981.     ADD    #12,SP                ;                    4335
  6982. 1$:    MOV    160(SP),R2            ; TYPE,*                4351
  6983.     MOVB    R2,U.83+3
  6984.     MOVB    SND.SOH,U.83            ;                    4352
  6985.     MOV    156(SP),R1            ; LENGTH,*                4353
  6986.     MOV    R1,R0
  6987.     ADD    U.71,R0
  6988.     MOV    R0,R3
  6989.     SUB    #16,R3
  6990.     MOVB    R3,U.83+1
  6991.     MOV    154(SP),R0            ; MN,*                    4356
  6992.     BGE    2$
  6993.     CLR    R0
  6994. 2$:    MOV    R0,R3
  6995.     ADD    #40,R3
  6996.     MOVB    R3,U.83+2
  6997.     MOV    #U.83+1,R4            ; *,POINTER                4360
  6998.     MOV    R4,-(SP)            ; POINTER,*                4361
  6999.     MOV    R1,-(SP)
  7000.     ADD    #3,(SP)
  7001.     JSR    PC,U.18
  7002.     MOV    R1,R3                ; *,TOT.MSG.LEN                4362
  7003.     ADD    #6,R3                ; *,TOT.MSG.LEN
  7004.     ADD    #U.83,R1            ;                    4366
  7005.     MOV    R1,R4                ; *,POINTER
  7006.     ADD    #4,R4                ; *,POINTER
  7007.     MOV    U.71,R1                ;                    4368
  7008.     SUB    #61,R1
  7009.     ASL    R1
  7010.     ADD    P.AAM(R1),PC            ; Case dispatch
  7011. 4$:    MOV    R0,R1                ; CHKSUM,*                4372
  7012.     ADD    #40,R1
  7013.     MOVB    R1,(R4)                ; *,POINTER
  7014.     BR    7$                ;                    4368
  7015. 5$:    MOV    R0,R1                ; CHKSUM,*                4376
  7016.     ASH    #-6,R1
  7017.     BIC    #177700,R1
  7018.     ADD    #40,R1
  7019.     MOVB    R1,(R4)+            ; *,POINTER
  7020.     MOV    R0,R1                ; CHKSUM,*                4377
  7021.     BIC    #177700,R1
  7022.     ADD    #40,R1
  7023.     MOVB    R1,(R4)                ; *,POINTER
  7024.     INC    R3                ; TOT.MSG.LEN                4378
  7025.     BR    7$                ;                    4368
  7026. 6$:    MOV    R0,R1                ; CHKSUM,*                4383
  7027.     ASH    #-14,R1
  7028.     BIC    #177760,R1
  7029.     ADD    #40,R1
  7030.     MOVB    R1,(R4)+            ; *,POINTER
  7031.     MOV    R0,R1                ; CHKSUM,*                4384
  7032.     ASH    #-6,R1
  7033.     BIC    #177700,R1
  7034.     ADD    #40,R1
  7035.     MOVB    R1,(R4)+            ; *,POINTER
  7036.     MOV    R0,R1                ; CHKSUM,*                4385
  7037.     BIC    #177700,R1
  7038.     ADD    #40,R1
  7039.     MOVB    R1,(R4)                ; *,POINTER
  7040.     ADD    #2,R3                ; *,TOT.MSG.LEN                4386
  7041. 7$:    INC    R4                ; POINTER                4372
  7042.     MOVB    U.67,(R4)+            ; *,POINTER                4393
  7043.     MOV    #U.83,(SP)            ;                    4397
  7044.     MOV    R3,-(SP)            ; TOT.MSG.LEN,*
  7045.     JSR    PC,U.34
  7046.     ADD    R3,SMSG.TOTAL.CHARS        ; TOT.MSG.LEN,*                4401
  7047.     CMP    R2,#116                ;                    4405
  7048.     BNE    8$
  7049.     INC    SMSG.NAKS            ;                    4408
  7050.     MOV    #123,(SP)            ;                    4409
  7051.     MOV    #116,-(SP)
  7052.     BR    9$
  7053. 8$:    INC    SMSG.COUNT            ;                    4413
  7054.     MOV    #123,(SP)            ;                    4414
  7055.     MOV    #120,-(SP)
  7056. 9$:    JSR    PC,XFR.STATUS
  7057.     BIT    #1,IBM.FLAG            ;                    4422
  7058.     BEQ    10$
  7059.     CMP    R2,#123
  7060.     BEQ    10$
  7061.     CMP    R2,#111
  7062.     BEQ    10$
  7063.     CMP    R2,#122
  7064.     BEQ    10$
  7065.     CMP    R2,#103                ;                    4423
  7066.     BEQ    10$
  7067.     CMP    R2,#107
  7068.     BEQ    10$
  7069.     JSR    PC,IBM.WAIT            ;                    4426
  7070.     ROR    R0
  7071.     BLO    10$
  7072.     ADD    #10,SP
  7073.     MOV    #272,R0
  7074.     BR    11$
  7075. 10$:    MOV    #U.83,(SP)            ;                    4431
  7076.     MOV    R3,-(SP)            ; TOT.MSG.LEN,*
  7077.     JSR    PC,U.21
  7078.     MOV    #U.83,(SP)            ;                    4432
  7079.     MOV    R3,-(SP)            ; TOT.MSG.LEN,*
  7080.     JSR    PC,SEND
  7081.     ADD    #14,SP                ;                    4281
  7082. 11$:    ADD    #140,SP
  7083.     RTS    PC
  7084. ; Routine Size:  204 words,    Routine Base:  $CODE$ + 14516
  7085. ; Maximum stack depth per invocation:  60 words
  7086.  
  7087.  
  7088.     .PSECT    $PLIT$,  RO ,  D  
  7089.  
  7090. P.AAM:                        ; CASE Table for SEND.PACKET+0254    4368
  7091. 3$:    .WORD    0                ; [4$]
  7092.     .WORD    12                ; [5$]
  7093.     .WORD    52                ; [6$]
  7094.  
  7095.     .NLIST
  7096.     .DSABL    LSB
  7097.     .NLIST    BIN,LOC
  7098.     .LIST
  7099.  
  7100.  
  7101. ;      4434    %SBTTL 'REC_MESSAGE - Receive a message'
  7102. ;      4435    ROUTINE REC_MESSAGE (CHK_ROUTINE) =
  7103. ;      4436    
  7104. ;      4437    !++
  7105. ;      4438    ! FUNCTIONAL DESCRIPTION:
  7106. ;      4439    !
  7107. ;      4440    !    This routine will handle the retry processing for the various
  7108. ;      4441    !    messages that can be received.
  7109. ;      4442    !
  7110. ;      4443    ! CALLING SEQUENCE:
  7111. ;      4444    !
  7112. ;      4445    ! INPUT PARAMETERS:
  7113. ;      4446    !
  7114. ;      4447    !    None.
  7115. ;      4448    !
  7116. ;      4449    ! IMPLICIT INPUTS:
  7117. ;      4450    !
  7118. ;      4451    !    None.
  7119. ;      4452    !
  7120. ;      4453    ! OUTPUT PARAMETERS:
  7121. ;      4454    !
  7122. ;      4455    !    None.
  7123. ;      4456    !
  7124. ;      4457    ! IMPLICIT OUTPUTS:
  7125. ;      4458    !
  7126. ;      4459    !    None.
  7127. ;      4460    !
  7128. ;      4461    ! COMPLETION CODES:
  7129. ;      4462    !
  7130. ;      4463    !    KER_NORMAL - Normal return
  7131. ;      4464    !    KER_RETRIES - Too many retries
  7132. ;      4465    !    (What ever REC_PACKET returns).
  7133. ;      4466    !
  7134. ;      4467    ! SIDE EFFECTS:
  7135. ;      4468    !
  7136. ;      4469    !    None.
  7137. ;      4470    !
  7138. ;      4471    !--
  7139. ;      4472    
  7140. ;      4473        BEGIN
  7141. ;      4474    
  7142. ;      4475        LOCAL
  7143. ;      4476        STATUS;                    ! Status returned by various routines
  7144. ;      4477    
  7145. ;      4478        RETURN
  7146. ;      4479    
  7147. ;      4480        WHILE TRUE DO
  7148. ;      4481            BEGIN
  7149. ;      4482    
  7150. ;      4483            IF .NUM_RETRIES GTR .PKT_RETRIES THEN RETURN KER_RETRIES;
  7151. ;      4484    
  7152. ;      4485            NUM_RETRIES = .NUM_RETRIES + 1;
  7153. ;      4486            STATUS = REC_PACKET ();
  7154. ;      4487    
  7155. ;      4488            IF NOT .STATUS AND .STATUS NEQ KER_CHKSUMERR AND .STATUS NEQ KER_TIMEOUT
  7156. ;      4489            THEN
  7157. ;      4490            EXITLOOP .STATUS;
  7158. ;      4491    
  7159. ;      4492            IF NOT .STATUS
  7160. ;      4493            THEN
  7161. ;      4494            SEND_PACKET (MSG_NAK, 0, .MSG_NUMBER)    ![024]
  7162. ;      4495            ELSE
  7163. ;      4496            BEGIN
  7164. ;      4497    ![021]
  7165. ;      4498    ![021] If the packet type is not acceptable by our caller, nak it so the
  7166. ;      4499    ![021] other end tries again, and abort the current operation.  This is so
  7167. ;      4500    ![021] we will return to server mode (if we are running that way) quickly
  7168. ;      4501    ![021] when the other Kermit has been aborted and then restarted, and should
  7169. ;      4502    ![021] also make restarting quick, since we will not need to wait for the
  7170. ;      4503    ![021] other Kermit to time this message out before retransmitting.
  7171. ;      4504    ![021]
  7172. ;      4505    
  7173. ;      4506            IF NOT (.CHK_ROUTINE) ()
  7174. ;      4507            THEN
  7175. ;      4508                BEGIN
  7176. ;      4509                SEND_PACKET (MSG_NAK, 0, .REC_SEQ);
  7177. ;      4510                RETURN KER_RETRIES;
  7178. ;      4511                END
  7179. ;      4512            ELSE
  7180. ;      4513                EXITLOOP KER_NORMAL;
  7181. ;      4514    
  7182. ;      4515            END;
  7183. ;      4516    
  7184. ;      4517            END;
  7185. ;      4518    
  7186. ;      4519        END;                    ! End of REC_PARSE
  7187.     .NLIST
  7188.     .LIST    BIN,LOC
  7189.     .LIST
  7190.  
  7191.     .SBTTL    REC.MESSAGE REC_MESSAGE - Receive a message
  7192.     .PSECT    $CODE$,  RO 
  7193.  
  7194.     .NLIST
  7195.     .ENABL    LSB
  7196.     .LIST
  7197. ; REC.MESSAGE
  7198. U.24:    MOV    R1,-(SP)            ;                    4435
  7199. 1$:    CMP    U.77,PKT.RETRIES        ;                    4483
  7200.     BGT    4$
  7201.     INC    U.77                ;                    4485
  7202.     JSR    PC,U.25                ;                    4486
  7203.     MOV    R0,R1                ; *,STATUS
  7204.     BIT    #1,R1                ; *,STATUS                4488
  7205.     BNE    3$
  7206.     CMP    R1,#162                ; STATUS,*
  7207.     BEQ    2$
  7208.     CMP    R1,#264                ; STATUS,*
  7209.     BNE    6$                ;                    4490
  7210. 2$:    BIT    #1,R1                ; *,STATUS                4492
  7211.     BNE    3$
  7212.     MOV    #116,-(SP)            ;                    4494
  7213.     CLR    -(SP)
  7214.     MOV    U.78,-(SP)
  7215.     JSR    PC,U.23
  7216.     ADD    #6,SP
  7217.     BR    1$                ;                    4492
  7218. 3$:    JSR    PC,@4(SP)            ; *,CHK.ROUTINE                4506
  7219.     ROR    R0
  7220.     BLO    5$
  7221.     MOV    #116,-(SP)            ;                    4509
  7222.     CLR    -(SP)
  7223.     MOV    U.79,-(SP)
  7224.     JSR    PC,U.23
  7225.     ADD    #6,SP                ;                    4506
  7226. 4$:    MOV    #202,R0                ;                    4508
  7227.     BR    6$
  7228. 5$:    MOV    #1,R0                ;                    4513
  7229. 6$:    MOV    (SP)+,R1            ;                    4435
  7230.     RTS    PC
  7231. ; Routine Size:  52 words,    Routine Base:  $CODE$ + 15346
  7232. ; Maximum stack depth per invocation:  5 words
  7233.     .NLIST
  7234.     .DSABL    LSB
  7235.     .NLIST    BIN,LOC
  7236.     .LIST
  7237.  
  7238.  
  7239. ;      4520    %SBTTL 'REC_PACKET'
  7240. ;      4521    ROUTINE REC_PACKET =
  7241. ;      4522    
  7242. ;      4523    !++
  7243. ;      4524    ! FUNCTIONAL DESCRIPTION:
  7244. ;      4525    !
  7245. ;      4526    !    This routine will do the oppoiste of SEND_PACKET.  It will wait
  7246. ;      4527    !    for the message to be read from the remote and then it will
  7247. ;      4528    !    check the message for validity.
  7248. ;      4529    !
  7249. ;      4530    ! CALLING SEQUENCE:
  7250. ;      4531    !
  7251. ;      4532    !    Flag = REC_PACKET();
  7252. ;      4533    !
  7253. ;      4534    ! INPUT PARAMETERS:
  7254. ;      4535    !
  7255. ;      4536    !    None.
  7256. ;      4537    !
  7257. ;      4538    ! IMPLICIT INPUTS:
  7258. ;      4539    !
  7259. ;      4540    !    None.
  7260. ;      4541    !
  7261. ;      4542    ! OUTPUT PARAMETERS:
  7262. ;      4543    !
  7263. ;      4544    !    None.
  7264. ;      4545    !
  7265. ;      4546    ! IMPLICIT OUTPUTS:
  7266. ;      4547    !
  7267. ;      4548    !    REC_MSG - Contains the message received.
  7268. ;      4549    !
  7269. ;      4550    ! COMPLETION CODES:
  7270. ;      4551    !
  7271. ;      4552    !    True - Packet receive ok.
  7272. ;      4553    !    False - Problem occured during the receiving of the packet.
  7273. ;      4554    !
  7274. ;      4555    ! SIDE EFFECTS:
  7275. ;      4556    !
  7276. ;      4557    !    None.
  7277. ;      4558    !
  7278. ;      4559    !--
  7279. ;      4560    
  7280. ;      4561        BEGIN
  7281. ;      4562    
  7282. ;      4563        BIND
  7283. ;      4564        ATTEMPT_TEXT = UPLIT (%ASCIZ'Attempting to receive');
  7284. ;      4565    
  7285. ;      4566        LOCAL
  7286. ;      4567        STATUS,                    ! Status returned by various routines
  7287. ;      4568        MSG_LENGTH,
  7288. ;      4569        ERR_POINTER,                ! Pointer to the error buffer
  7289. ;      4570        POINTER,
  7290. ;      4571        CHKSUM;                    ! Checksum of the message
  7291. ;      4572    
  7292. ;      4573    !
  7293. ;      4574    ! Attempt to read the message from the remote.
  7294. ;      4575    !
  7295. ;      4576    !    DO
  7296. ;      4577    !    BEGIN
  7297. ;      4578    
  7298. ;      4579        IF .DEBUG_FLAG
  7299. ;      4580        THEN
  7300. ;      4581        BEGIN
  7301. ;      4582    
  7302. ;      4583        LOCAL
  7303. ;      4584            OLD_RTN;
  7304. ;      4585    
  7305. ;      4586        OLD_RTN = TT_SET_OUTPUT (DBG_DUMP);
  7306. ;      4587        TT_TEXT (ATTEMPT_TEXT);
  7307. ;      4588        TT_CRLF ();
  7308. ;      4589        TT_SET_OUTPUT (.OLD_RTN);
  7309. ;      4590        END;
  7310. ;      4591    
  7311. ;      4592    !
  7312. ;      4593    ! If status type out requested, do it once
  7313. ;      4594    !
  7314. ;      4595    
  7315. ;      4596        IF .TYP_STS_FLAG
  7316. ;      4597        THEN
  7317. ;      4598        BEGIN
  7318. ;      4599        STS_OUTPUT ();
  7319. ;      4600        TYP_STS_FLAG = FALSE;
  7320. ;      4601        END;
  7321. ;      4602    
  7322. ;      4603    !
  7323. ;      4604    ! Receive the message from the remote Kermit
  7324. ;      4605    !
  7325. ;      4606        STATUS = RECEIVE (REC_MSG, MSG_LENGTH);
  7326. ;      4607    !
  7327. ;      4608    ! Check for timeouts
  7328. ;      4609    !
  7329. ;      4610    
  7330. ;      4611        IF .STATUS EQL KER_TIMEOUT THEN XFR_STATUS (%C'R', %C'T');
  7331. ;      4612    
  7332. ;      4613    !
  7333. ;      4614    ! If it failed return the status to the upper level
  7334. ;      4615    !
  7335. ;      4616    
  7336. ;      4617        IF NOT .STATUS THEN RETURN .STATUS;
  7337. ;      4618    
  7338. ;      4619    !
  7339. ;      4620    ! Determine if we got a good message
  7340. ;      4621    !
  7341. ;      4622    
  7342. ;      4623        IF .MSG_LENGTH EQL 0
  7343. ;      4624        THEN
  7344. ;      4625        BEGIN
  7345. ;      4626        RETURN KER_ZEROLENMSG;
  7346. ;      4627        END;
  7347. ;      4628    
  7348. ;      4629    !
  7349. ;      4630    ! Update the stats on the total number of characters received.
  7350. ;      4631    !
  7351. ;      4632        RMSG_TOTAL_CHARS = .RMSG_TOTAL_CHARS + .MSG_LENGTH;
  7352. ;      4633    !
  7353. ;      4634    ! Initialize the checksum and others
  7354. ;      4635    !
  7355. ;      4636        REC_TYPE = CH$RCHAR (CH$PTR (REC_MSG, PKT_TYPE, CHR_SIZE));
  7356. ;      4637    !
  7357. ;      4638    ! Now break the message apart byte by byte.
  7358. ;      4639    !
  7359. ;      4640        REC_LENGTH = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_COUNT, CHR_SIZE))) - PKT_OVR_HEAD - (
  7360. ;      4641        .BLK_CHK_TYPE - CHK_1CHAR);
  7361. ;      4642        REC_SEQ = UNCHAR (CH$RCHAR (CH$PTR (REC_MSG, PKT_SEQ, CHR_SIZE)));
  7362. ;      4643    !
  7363. ;      4644    ! In order to detect a remote server Kermit aborting back to the idle
  7364. ;      4645    ! state without giving us any indication, we will accept a NAK which
  7365. ;      4646    ! has a single character checksum so long as it also is message sequence
  7366. ;      4647    ! number zero.  Note that we will reset the block check type if this
  7367. ;      4648    ! is the case.
  7368. ;      4649    !
  7369. ;      4650    
  7370. ;      4651        IF .BLK_CHK_TYPE NEQ CHK_1CHAR AND .REC_SEQ EQL 0 AND .REC_LENGTH LSS 1 - (.BLK_CHK_TYPE -
  7371. ;      4652        CHK_1CHAR) AND .REC_TYPE EQL MSG_NAK
  7372. ;      4653        THEN
  7373. ;      4654        BLK_CHK_TYPE = CHK_1CHAR;
  7374. ;      4655    
  7375. ;      4656    !
  7376. ;      4657    ! Typed the packet if we are debugging
  7377. ;      4658    !
  7378. ;      4659        DBG_RECEIVE (REC_MSG);
  7379. ;      4660    !
  7380. ;      4661    ! Now compute the final checksum and make sure that it is identical
  7381. ;      4662    ! to what we received from the remote KERMIT
  7382. ;      4663    !
  7383. ;      4664        POINTER = CH$PTR (REC_MSG, PKT_MARK + 1, CHR_SIZE);
  7384. ;      4665        CHKSUM = CALC_BLOCK_CHECK (.POINTER, .REC_LENGTH + PKT_OVR_HEAD);
  7385. ;      4666        POINTER = CH$PTR (REC_MSG, .REC_LENGTH + PKT_OVR_HEAD + 1, CHR_SIZE);
  7386. ;      4667    
  7387. ;      4668        CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF
  7388. ;      4669        SET
  7389. ;      4670    
  7390. ;      4671        [CHK_1CHAR] :
  7391. ;      4672    
  7392. ;      4673            IF .CHKSUM NEQ UNCHAR (CH$RCHAR_A (POINTER)) THEN RETURN KER_CHKSUMERR;
  7393. ;      4674    
  7394. ;      4675        [CHK_2CHAR] :
  7395. ;      4676    
  7396. ;    P 4677            IF (.CHKSUM<6, 6> NEQ UNCHAR (CH$RCHAR_A (POINTER))) OR (.CHKSUM<0, 6> NEQ UNCHAR (
  7397. ;      4678                CH$RCHAR_A (POINTER)))
  7398. ;      4679            THEN
  7399. ;      4680            RETURN KER_CHKSUMERR;
  7400. ;      4681    
  7401. ;      4682        [CHK_CRC] :
  7402. ;      4683    
  7403. ;    P 4684            IF (.CHKSUM<12, 4> NEQ UNCHAR (CH$RCHAR_A (POINTER))) OR (.CHKSUM<6, 6> NEQ UNCHAR (
  7404. ;      4685                CH$RCHAR_A (POINTER))) OR (.CHKSUM<0, 6> NEQ UNCHAR (CH$RCHAR_A (POINTER)))
  7405. ;      4686            THEN
  7406. ;      4687            RETURN KER_CHKSUMERR;
  7407. ;      4688    
  7408. ;      4689        TES;
  7409. ;      4690    
  7410. ;      4691    !
  7411. ;      4692    ! Update the stats
  7412. ;      4693    !
  7413. ;      4694    !    RMSG_DATA_CHARS = .RMSG_DATA_CHARS + .REC_LENGTH;
  7414. ;      4695    
  7415. ;      4696        IF .REC_TYPE EQL MSG_NAK
  7416. ;      4697        THEN
  7417. ;      4698        BEGIN
  7418. ;      4699        RMSG_NAKS = .RMSG_NAKS + 1;
  7419. ;      4700        XFR_STATUS (%C'R', %C'N');
  7420. ;      4701        END
  7421. ;      4702        ELSE
  7422. ;      4703        BEGIN
  7423. ;      4704        RMSG_COUNT = .RMSG_COUNT + 1;
  7424. ;      4705        XFR_STATUS (%C'R', %C'P');
  7425. ;      4706        END;
  7426. ;      4707    
  7427. ;      4708    !
  7428. ;      4709    ! Now check to see if we have an E type (Error) packet.
  7429. ;      4710    !
  7430. ;      4711    
  7431. ;      4712        IF .REC_TYPE NEQ MSG_ERROR THEN RETURN KER_NORMAL;
  7432. ;      4713    
  7433. ;      4714    !
  7434. ;      4715    ! Here to process an error packet.  Call the user routine to output the
  7435. ;      4716    ! error message to the terminal.
  7436. ;      4717    !
  7437. ;      4718    !
  7438. ;      4719    ![026] Use decoding routine to fetch the error text
  7439. ;      4720    !
  7440. ;      4721        CH$FILL (CHR_NUL, MAX_MSG + 1, CH$PTR (LAST_ERROR));
  7441. ;      4722        SET_STRING (CH$PTR (LAST_ERROR), MAX_MSG, TRUE);
  7442. ;      4723        BFR_EMPTY ();
  7443. ;      4724        SET_STRING (0, 0, FALSE);
  7444. ;      4725    ![026]    ERR_POINTER = CH$PTR (LAST_ERROR);
  7445. ;      4726    ![026]    POINTER = CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE);
  7446. ;      4727    ![026]
  7447. ;      4728    ![026]    INCR I FROM 1 TO .REC_LENGTH DO
  7448. ;      4729    ![026]    CH$WCHAR_A (CH$RCHAR_A (POINTER), ERR_POINTER);
  7449. ;      4730    ![026]
  7450. ;      4731    ![026]    CH$WCHAR (CHR_NUL, ERR_POINTER);
  7451. ;      4732        TT_TEXT (LAST_ERROR);
  7452. ;      4733        TT_CRLF ();
  7453. ;      4734        RETURN KER_ERRMSG;
  7454. ;      4735        END;                    ! End of REC_PACKET
  7455.     .NLIST
  7456.     .LIST    BIN,LOC
  7457.     .LIST
  7458.  
  7459.  
  7460.     .PSECT    $PLIT$,  RO ,  D  
  7461. P.AAN:    .ASCII    /Att/
  7462.     .ASCII    /emp/
  7463.     .ASCII    /tin/
  7464.     .ASCII    /g t/
  7465.     .ASCII    /o r/
  7466.     .ASCII    /ece/
  7467.     .ASCII    /ive/
  7468.     .ASCII    <00>
  7469.  
  7470.  
  7471. ; ATTEMPT.TEXT
  7472. U.105=            P.AAN
  7473.  
  7474.  
  7475.     .SBTTL    REC.PACKET REC_PACKET
  7476.     .PSECT    $CODE$,  RO 
  7477.  
  7478.     .NLIST
  7479.     .ENABL    LSB
  7480.     .LIST
  7481. ; REC.PACKET
  7482. U.25:    JSR    R1,$SAVE4            ;                    4521
  7483.     TST    -(SP)
  7484.     BIT    #1,DEBUG.FLAG            ;                    4579
  7485.     BEQ    1$
  7486.     MOV    #DBG.DUMP,-(SP)            ;                    4586
  7487.     JSR    PC,TT.SET.OUTPUT
  7488.     MOV    R0,R1                ; *,OLD.RTN
  7489.     MOV    #U.105,(SP)            ;                    4587
  7490.     JSR    PC,TT.TEXT
  7491.     JSR    PC,TT.CRLF            ;                    4588
  7492.     MOV    R1,(SP)                ; OLD.RTN,*                4589
  7493.     JSR    PC,TT.SET.OUTPUT
  7494.     TST    (SP)+                ;                    4581
  7495. 1$:    BIT    #1,TYP.STS.FLAG            ;                    4596
  7496.     BEQ    2$
  7497.     JSR    PC,U.32                ;                    4599
  7498.     CLR    TYP.STS.FLAG            ;                    4600
  7499. 2$:    MOV    #U.82,-(SP)            ;                    4606
  7500.     MOV    #4,-(SP)
  7501.     ADD    SP,(SP)                ; MSG.LENGTH,*
  7502.     JSR    PC,RECEIVE
  7503.     MOV    R0,R1                ; *,STATUS
  7504.     CMP    R1,#264                ; STATUS,*                4611
  7505.     BNE    3$
  7506.     MOV    #122,(SP)
  7507.     MOV    #124,-(SP)
  7508.     JSR    PC,XFR.STATUS
  7509.     TST    (SP)+
  7510. 3$:    BIT    #1,R1                ; *,STATUS                4617
  7511.     BNE    4$
  7512.     CMP    (SP)+,(SP)+
  7513.     MOV    R1,R0                ; STATUS,*
  7514.     BR    5$
  7515. 4$:    MOV    4(SP),R0            ; MSG.LENGTH,*                4623
  7516.     BNE    6$
  7517.     CMP    (SP)+,(SP)+
  7518.     MOV    #312,R0                ;                    4625
  7519. 5$:    JMP    18$
  7520. 6$:    ADD    R0,RMSG.TOTAL.CHARS        ;                    4632
  7521.     CLR    U.81                ;                    4636
  7522.     MOVB    U.82+3,U.81
  7523.     CLR    R0                ;                    4640
  7524.     BISB    U.82+1,R0
  7525.     SUB    U.71,R0
  7526.     MOV    R0,U.80
  7527.     ADD    #16,U.80
  7528.     CLR    U.79                ;                    4642
  7529.     MOVB    U.82+2,U.79
  7530.     SUB    #40,U.79
  7531.     CMP    U.71,#61            ;                    4651
  7532.     BEQ    7$
  7533.     TST    U.79
  7534.     BNE    7$
  7535.     MOV    U.71,R0
  7536.     SUB    #62,R0
  7537.     NEG    R0
  7538.     CMP    U.80,R0
  7539.     BGE    7$
  7540.     CMP    U.81,#116            ;                    4652
  7541.     BNE    7$
  7542.     MOV    #61,U.71            ;                    4654
  7543. 7$:    MOV    #U.82,(SP)            ;                    4659
  7544.     JSR    PC,U.35
  7545.     MOV    #U.82+1,R2            ; *,POINTER                4664
  7546.     MOV    R2,(SP)                ; POINTER,*                4665
  7547.     MOV    U.80,-(SP)
  7548.     ADD    #3,(SP)
  7549.     JSR    PC,U.18
  7550.     MOV    U.80,R1                ;                    4666
  7551.     ADD    #U.82,R1
  7552.     MOV    R1,R2                ; *,POINTER
  7553.     ADD    #4,R2                ; *,POINTER
  7554.     MOV    U.71,R1                ;                    4668
  7555.     SUB    #61,R1
  7556.     ASL    R1
  7557.     ADD    P.AAO(R1),PC            ; Case dispatch
  7558. 9$:    CLR    R1                ;                    4673
  7559.     BISB    (R2)+,R1            ; POINTER,*
  7560.     SUB    #40,R1
  7561.     CMP    R0,R1                ; CHKSUM,*
  7562.     BR    12$
  7563. 10$:    CLR    R1                ;                    4677
  7564.     BISB    (R2)+,R1            ; POINTER,*
  7565.     SUB    #40,R1
  7566.     MOV    R1,R4
  7567.     MOV    R0,R3                ; CHKSUM,*
  7568.     ASH    #-6,R3
  7569.     BIC    #177700,R3
  7570.     CMP    R3,R4
  7571.     BNE    13$
  7572.     CLR    R1                ;                    4678
  7573.     BISB    (R2)+,R1            ; POINTER,*
  7574.     SUB    #40,R1
  7575.     MOV    R1,R4                ;                    4677
  7576.     MOV    R0,R3                ; CHKSUM,*
  7577.     BIC    #177700,R3
  7578.     CMP    R3,R4
  7579.     BR    12$
  7580. 11$:    CLR    R1                ;                    4684
  7581.     BISB    (R2)+,R1            ; POINTER,*
  7582.     SUB    #40,R1
  7583.     MOV    R1,R4
  7584.     MOV    R0,R3                ; CHKSUM,*
  7585.     ASH    #-14,R3
  7586.     BIC    #177760,R3
  7587.     CMP    R3,R4
  7588.     BNE    13$
  7589.     CLR    R1                ;                    4685
  7590.     BISB    (R2)+,R1            ; POINTER,*
  7591.     SUB    #40,R1
  7592.     MOV    R1,R4                ;                    4684
  7593.     MOV    R0,R3                ; CHKSUM,*
  7594.     ASH    #-6,R3
  7595.     BIC    #177700,R3
  7596.     CMP    R3,R4
  7597.     BNE    13$
  7598.     CLR    R1                ;                    4685
  7599.     BISB    (R2)+,R1            ; POINTER,*
  7600.     SUB    #40,R1
  7601.     MOV    R1,R3
  7602.     MOV    R0,R2                ; CHKSUM,*
  7603.     BIC    #177700,R2
  7604.     CMP    R2,R3
  7605. 12$:    BEQ    14$
  7606. 13$:    ADD    #6,SP                ;                    4687
  7607.     MOV    #162,R0
  7608.     BR    18$
  7609. 14$:    CMP    U.81,#116            ;                    4696
  7610.     BNE    15$
  7611.     INC    RMSG.NAKS            ;                    4699
  7612.     MOV    #122,(SP)            ;                    4700
  7613.     MOV    #116,-(SP)
  7614.     BR    16$
  7615. 15$:    INC    RMSG.COUNT            ;                    4704
  7616.     MOV    #122,(SP)            ;                    4705
  7617.     MOV    #120,-(SP)
  7618. 16$:    JSR    PC,XFR.STATUS
  7619.     CMP    U.81,#105            ;                    4712
  7620.     BEQ    17$
  7621.     ADD    #10,SP
  7622.     MOV    #1,R0
  7623.     BR    18$
  7624. 17$:    CLR    (SP)                ;                    4721
  7625.     MOV    #141,-(SP)
  7626.     MOV    #LAST.ERROR,-(SP)
  7627.     JSR    PC,BL$FIL
  7628.     MOV    #LAST.ERROR,(SP)        ;                    4722
  7629.     MOV    #140,-(SP)
  7630.     MOV    #1,-(SP)
  7631.     JSR    PC,U.29
  7632.     JSR    PC,U.27                ;                    4723
  7633.     CLR    (SP)                ;                    4724
  7634.     CLR    -(SP)
  7635.     CLR    -(SP)
  7636.     JSR    PC,U.29
  7637.     MOV    #LAST.ERROR,(SP)        ;                    4732
  7638.     JSR    PC,TT.TEXT
  7639.     JSR    PC,TT.CRLF            ;                    4733
  7640.     ADD    #24,SP                ;                    4521
  7641.     MOV    #152,R0                ;                    4561
  7642. 18$:    TST    (SP)+                ;                    4521
  7643.     RTS    PC
  7644. ; Routine Size:  265 words,    Routine Base:  $CODE$ + 15516
  7645. ; Maximum stack depth per invocation:  17 words
  7646.  
  7647.  
  7648.     .PSECT    $PLIT$,  RO ,  D  
  7649.  
  7650. P.AAO:                        ; CASE Table for REC.PACKET+0414    4668
  7651. 8$:    .WORD    0                ; [9$]
  7652.     .WORD    14                ; [10$]
  7653.     .WORD    70                ; [11$]
  7654.  
  7655.     .NLIST
  7656.     .DSABL    LSB
  7657.     .NLIST    BIN,LOC
  7658.     .LIST
  7659.  
  7660.  
  7661. ;      4736    %SBTTL 'CALC_BLOCK_CHECK'
  7662. ;      4737    ROUTINE CALC_BLOCK_CHECK (POINTER, LENGTH) =
  7663. ;      4738    
  7664. ;      4739    !++
  7665. ;      4740    ! FUNCTIONAL DESCRIPTION:
  7666. ;      4741    !
  7667. ;      4742    !    This routine will calculate the proper value for the block check
  7668. ;      4743    !    for a given message.  The value it returns is dependant upon the
  7669. ;      4744    !    type of block check requested in BLK_CHK_TYPE.
  7670. ;      4745    !
  7671. ;      4746    ! CALLING SEQUENCE:
  7672. ;      4747    !
  7673. ;      4748    !    CHKSUM = CALC_BLOCK_CHECK (.POINTER, .LENGTH);
  7674. ;      4749    !
  7675. ;      4750    ! INPUT PARAMETERS:
  7676. ;      4751    !
  7677. ;      4752    !    POINTER - A character pointer to the first character to be
  7678. ;      4753    !        included in the block check.
  7679. ;      4754    !
  7680. ;      4755    !    LENGTH - The number of characters to be included.
  7681. ;      4756    !
  7682. ;      4757    ! IMPLICIT INPUTS:
  7683. ;      4758    !
  7684. ;      4759    !    BLK_CHK_TYPE - The type of block check to generate.
  7685. ;      4760    !
  7686. ;      4761    ! OUPTUT PARAMETERS:
  7687. ;      4762    !
  7688. ;      4763    !    The value is the block check.
  7689. ;      4764    !
  7690. ;      4765    ! IMPLICIT OUTPUTS:
  7691. ;      4766    !
  7692. ;      4767    !    None.
  7693. ;      4768    !
  7694. ;      4769    ! COMPLETION CODES:
  7695. ;      4770    !
  7696. ;      4771    !    None.
  7697. ;      4772    !
  7698. ;      4773    ! SIDE EFFECTS:
  7699. ;      4774    !
  7700. ;      4775    !    None.
  7701. ;      4776    !
  7702. ;      4777    !--
  7703. ;      4778    
  7704. ;      4779        BEGIN
  7705. ;      4780    
  7706. ;      4781        LOCAL
  7707. ;      4782        BLOCK_CHECK,                ! To build initial block check value
  7708. ;      4783        I;                    ! Loop counter
  7709. ;      4784    
  7710. ;      4785        BLOCK_CHECK = 0;                ! Start out at 0
  7711. ;      4786    
  7712. ;      4787        CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF
  7713. ;      4788        SET
  7714. ;      4789    
  7715. ;      4790        [CHK_1CHAR, CHK_2CHAR] :
  7716. ;      4791    
  7717. ;      4792            INCR I FROM 1 TO .LENGTH DO
  7718. ;      4793            BLOCK_CHECK = .BLOCK_CHECK + CH$RCHAR_A (POINTER);
  7719. ;      4794    
  7720. ;      4795        [CHK_CRC] :
  7721. ;      4796            BLOCK_CHECK = CRCCLC (.POINTER, .LENGTH);
  7722. ;      4797        TES;
  7723. ;      4798    
  7724. ;      4799        IF .BLK_CHK_TYPE EQL CHK_1CHAR
  7725. ;      4800        THEN
  7726. ;      4801        BLOCK_CHECK = (.BLOCK_CHECK + ((.BLOCK_CHECK AND %O'300')/%O'100')) AND %O'77';
  7727. ;      4802    
  7728. ;      4803        RETURN .BLOCK_CHECK;            ! Return the correct value
  7729. ;      4804        END;                    ! End of CALC_BLOCK_CHK
  7730.     .NLIST
  7731.     .LIST    BIN,LOC
  7732.     .LIST
  7733.  
  7734.     .SBTTL    CALC.BLOCK.CHECK CALC_BLOCK_CHECK
  7735.     .PSECT    $CODE$,  RO 
  7736.  
  7737.     .NLIST
  7738.     .ENABL    LSB
  7739.     .LIST
  7740. ; CALC.BLOCK.CHECK
  7741. U.18:    JSR    R1,$SAVE3            ;                    4737
  7742.     CLR    R2                ; BLOCK.CHECK                4785
  7743.     MOV    U.71,R0                ;                    4787
  7744.     SUB    #61,R0
  7745.     ASL    R0
  7746.     ADD    P.AAP(R0),PC            ; Case dispatch
  7747. 2$:    CLR    R1                ; I                    4792
  7748.     BR    4$
  7749. 3$:    INC    14(SP)                ; POINTER                4793
  7750.     MOV    14(SP),R0            ; POINTER,*
  7751.     CLR    R3
  7752.     BISB    -1(R0),R3
  7753.     ADD    R3,R2                ; *,BLOCK.CHECK
  7754. 4$:    INC    R1                ; I                    4792
  7755.     CMP    R1,12(SP)            ; I,LENGTH
  7756.     BLE    3$
  7757.     BR    6$                ;                    4787
  7758. 5$:    MOV    14(SP),-(SP)            ; POINTER,*                4796
  7759.     MOV    14(SP),-(SP)            ; LENGTH,*
  7760.     JSR    PC,CRCCLC
  7761.     MOV    R0,R2                ; *,BLOCK.CHECK
  7762.     CMP    (SP)+,(SP)+
  7763. 6$:    CMP    U.71,#61            ;                    4799
  7764.     BNE    7$
  7765.     MOV    R2,R0                ; BLOCK.CHECK,*                4801
  7766.     BIC    #177477,R0
  7767.     MOV    R0,R1
  7768.     SXT    R0
  7769.     DIV    #100,R0
  7770.     ADD    R2,R0                ; BLOCK.CHECK,*
  7771.     MOV    R0,R2                ; *,BLOCK.CHECK
  7772.     BIC    #177700,R2            ; *,BLOCK.CHECK
  7773. 7$:    MOV    R2,R0                ; BLOCK.CHECK,*                4779
  7774.     RTS    PC                ;                    4737
  7775. ; Routine Size:  50 words,    Routine Base:  $CODE$ + 16540
  7776. ; Maximum stack depth per invocation:  7 words
  7777.  
  7778.  
  7779.     .PSECT    $PLIT$,  RO ,  D  
  7780.  
  7781. P.AAP:                        ; CASE Table for CALC.BLOCK.CHEC+0020    4787
  7782. 1$:    .WORD    0                ; [2$]
  7783.     .WORD    0                ; [2$]
  7784.     .WORD    36                ; [5$]
  7785.  
  7786.     .NLIST
  7787.     .DSABL    LSB
  7788.     .NLIST    BIN,LOC
  7789.     .LIST
  7790.  
  7791.  
  7792. ;      4805    %SBTTL 'NORMALIZE_FILE - Put file name into normal form'
  7793. ;      4806    ROUTINE NORMALIZE_FILE (FILE_ADDRESS, FILE_LENGTH, NAME_LENGTH, TYPE_LENGTH) : NOVALUE =
  7794. ;      4807    
  7795. ;      4808    !++
  7796. ;      4809    ! FUNCTIONAL DESCRIPTION:
  7797. ;      4810    !
  7798. ;      4811    !    This routine will ensure that a file specification is in normal
  7799. ;      4812    !    form.  It does this by replacing all non-alphanumeric characters
  7800. ;      4813    !    (except the first period) with "X".  It will also ensure that
  7801. ;      4814    !    the resulting specification (of form name.type) has only
  7802. ;      4815    !    a specified number of characters in the name portion and type portion.
  7803. ;      4816    !
  7804. ;      4817    ! CALLING SEQUENCE:
  7805. ;      4818    !
  7806. ;      4819    !    NORMALIZE_FILE (FILE_ADDRESS, FILE_LENGTH, NAME_LENGTH, TYPE_LENGTH);
  7807. ;      4820    !
  7808. ;      4821    ! INPUT PARAMETERS:
  7809. ;      4822    !
  7810. ;      4823    !    FILE_ADDRESS - Address of file specification string to be normalized
  7811. ;      4824    !
  7812. ;      4825    !    FILE_LENGTH - Length of file specification
  7813. ;      4826    !
  7814. ;      4827    !    NAME_LENGTH - Maximum length desired for "name" portion.
  7815. ;      4828    !
  7816. ;      4829    !    TYPE_LENGTH - Maximum length desired for "type" portion.
  7817. ;      4830    !
  7818. ;      4831    !    With both NAME_LENGTH and TYPE_LENGTH, a negative value indicates
  7819. ;      4832    !    unlimited lenght.
  7820. ;      4833    !
  7821. ;      4834    ! IMPLICIT INPUTS:
  7822. ;      4835    !
  7823. ;      4836    !    None.
  7824. ;      4837    !
  7825. ;      4838    ! OUPTUT PARAMETERS:
  7826. ;      4839    !
  7827. ;      4840    !    FILE_LENGTH - The length of the resulting file spec
  7828. ;      4841    !
  7829. ;      4842    !    NAME_LENGTH - The actual length of the resulting file name
  7830. ;      4843    !
  7831. ;      4844    !    TYPE_LENGTH - The actual length of the resulting file type
  7832. ;      4845    !
  7833. ;      4846    ! IMPLICIT OUTPUTS:
  7834. ;      4847    !
  7835. ;      4848    !    None.
  7836. ;      4849    !
  7837. ;      4850    ! COMPLETION CODES:
  7838. ;      4851    !
  7839. ;      4852    !    None.
  7840. ;      4853    !
  7841. ;      4854    ! SIDE EFFECTS:
  7842. ;      4855    !
  7843. ;      4856    !    None.
  7844. ;      4857    !
  7845. ;      4858    !--
  7846. ;      4859    
  7847. ;      4860        BEGIN
  7848. ;      4861    
  7849. ;      4862        LOCAL
  7850. ;      4863        CH,                    ! Character being processed
  7851. ;      4864        POINTER,                ! Pointer to file spec
  7852. ;      4865        WRT_POINTER,                ! Pointer to write file spec
  7853. ;      4866        WRT_SIZE,
  7854. ;      4867        FIRST_PERIOD,                ! Flag we have seen a period
  7855. ;      4868        IGNORE_BAD,                ! Flag we should ignore bad characters
  7856. ;      4869        BAD_CHAR,                ! Flag this character was bad
  7857. ;      4870        FILE_CTR,                ! Counter for overall length
  7858. ;      4871        NAME_CTR,                ! Counter for name characters
  7859. ;      4872        TYPE_CTR;                ! Counter for type characters
  7860. ;      4873    
  7861. ;      4874        FILE_CTR = 0;
  7862. ;      4875        NAME_CTR = 0;
  7863. ;      4876        TYPE_CTR = 0;
  7864. ;      4877        WRT_SIZE = 0;
  7865. ;      4878        FIRST_PERIOD = FALSE;            ! No periods yet
  7866. ;      4879        POINTER = CH$PTR (.FILE_ADDRESS);        ! Set up pointer to file name
  7867. ;      4880        WRT_POINTER = .POINTER;
  7868. ;      4881    
  7869. ;      4882        IF .NAME_LENGTH EQL 0 THEN FIRST_PERIOD = TRUE;    ! Pretend we did name already
  7870. ;      4883    
  7871. ;      4884        IGNORE_BAD = FALSE;
  7872. ;      4885    
  7873. ;      4886        IF .NAME_LENGTH GTR 0
  7874. ;      4887        THEN
  7875. ;      4888        BEGIN
  7876. ;      4889    
  7877. ;      4890        DECR I FROM ..FILE_LENGTH TO 0 DO
  7878. ;      4891    
  7879. ;      4892            IF CH$RCHAR_A (POINTER) EQL %C'.'
  7880. ;      4893            THEN
  7881. ;      4894            BEGIN
  7882. ;      4895            IGNORE_BAD = TRUE;
  7883. ;      4896            EXITLOOP;
  7884. ;      4897            END;
  7885. ;      4898    
  7886. ;      4899        END;
  7887. ;      4900    
  7888. ;      4901        POINTER = .WRT_POINTER;
  7889. ;      4902    
  7890. ;      4903        WHILE .FILE_CTR LSS ..FILE_LENGTH DO
  7891. ;      4904        BEGIN
  7892. ;      4905        CH = CH$RCHAR_A (POINTER);        ! Get a character
  7893. ;      4906        FILE_CTR = .FILE_CTR + 1;
  7894. ;      4907    
  7895. ;      4908        IF (.CH LSS %C'0' AND (.CH NEQ %C'.' OR .FIRST_PERIOD)) OR .CH GTR %C'z' OR (.CH GTR %C'9'
  7896. ;      4909            AND .CH LSS %C'A') OR (.CH GTR %C'Z' AND .CH LSS %C'a')
  7897. ;      4910        THEN
  7898. ;      4911            BEGIN
  7899. ;      4912            BAD_CHAR = TRUE;
  7900. ;      4913            CH = %C'X';
  7901. ;      4914            END
  7902. ;      4915        ELSE
  7903. ;      4916            BEGIN
  7904. ;      4917            BAD_CHAR = FALSE;
  7905. ;      4918    
  7906. ;      4919            IF .CH GEQ %C'a' THEN CH = .CH - (%C'a' - %C'A');
  7907. ;      4920    
  7908. ;      4921            END;
  7909. ;      4922    
  7910. ;      4923        IF .CH EQL %C'.'
  7911. ;      4924        THEN
  7912. ;      4925            BEGIN
  7913. ;      4926            FIRST_PERIOD = TRUE;
  7914. ;      4927            CH$WCHAR_A (.CH, WRT_POINTER);
  7915. ;      4928            WRT_SIZE = .WRT_SIZE + 1;
  7916. ;      4929            END
  7917. ;      4930        ELSE
  7918. ;      4931    
  7919. ;      4932            IF NOT .BAD_CHAR OR NOT .IGNORE_BAD
  7920. ;      4933            THEN
  7921. ;      4934    
  7922. ;      4935            IF NOT .FIRST_PERIOD
  7923. ;      4936            THEN
  7924. ;      4937                BEGIN
  7925. ;      4938    
  7926. ;      4939                IF .NAME_LENGTH LSS 0 OR .NAME_CTR LSS .NAME_LENGTH
  7927. ;      4940                THEN
  7928. ;      4941                BEGIN
  7929. ;      4942                NAME_CTR = .NAME_CTR + 1;
  7930. ;      4943                WRT_SIZE = .WRT_SIZE + 1;
  7931. ;      4944                CH$WCHAR_A (.CH, WRT_POINTER);
  7932. ;      4945                END;
  7933. ;      4946    
  7934. ;      4947                END
  7935. ;      4948            ELSE
  7936. ;      4949    
  7937. ;      4950                IF .TYPE_LENGTH LSS 0 OR .TYPE_CTR LSS .TYPE_LENGTH
  7938. ;      4951                THEN
  7939. ;      4952                BEGIN
  7940. ;      4953                TYPE_CTR = .TYPE_CTR + 1;
  7941. ;      4954                WRT_SIZE = .WRT_SIZE + 1;
  7942. ;      4955                CH$WCHAR_A (.CH, WRT_POINTER);
  7943. ;      4956                END;
  7944. ;      4957    
  7945. ;      4958        END;
  7946. ;      4959    
  7947. ;      4960        .FILE_LENGTH = .WRT_SIZE;
  7948. ;      4961        CH$WCHAR_A (CHR_NUL, WRT_POINTER);
  7949. ;      4962        END;                    ! End of NORMALIZE_FILE
  7950.     .NLIST
  7951.     .LIST    BIN,LOC
  7952.     .LIST
  7953.  
  7954.     .SBTTL    NORMALIZE.FILE NORMALIZE_FILE - Put file name into normal form
  7955.     .PSECT    $CODE$,  RO 
  7956.  
  7957.     .NLIST
  7958.     .ENABL    LSB
  7959.     .LIST
  7960. ; NORMALIZE.FILE
  7961. U.26:    JSR    R1,$SAVE5            ;                    4806
  7962.     CMP    -(SP),-(SP)
  7963.     CLR    -(SP)                ; FILE.CTR                4874
  7964.     CLR    -(SP)                ; NAME.CTR                4875
  7965.     CLR    -(SP)                ; TYPE.CTR                4876
  7966.     CLR    R3                ; WRT.SIZE                4877
  7967.     CLR    R4                ; FIRST.PERIOD                4878
  7968.     MOV    36(SP),R2            ; FILE.ADDRESS,POINTER            4879
  7969.     MOV    R2,-(SP)            ; POINTER,WRT.POINTER            4880
  7970.     MOV    34(SP),R5            ; NAME.LENGTH,*                4882
  7971.     BNE    1$
  7972.     MOV    #1,R4                ; *,FIRST.PERIOD
  7973. 1$:    CLR    10(SP)                ; IGNORE.BAD                4884
  7974.     TST    R5                ;                    4886
  7975.     BLE    4$
  7976.     MOV    @36(SP),R0            ; FILE.LENGTH,I                4890
  7977.     BLT    4$
  7978. 2$:    CMPB    (R2)+,#56            ; POINTER,*                4892
  7979.     BNE    3$
  7980.     MOV    #1,10(SP)            ; *,IGNORE.BAD                4895
  7981.     BR    4$                ;                    4894
  7982. 3$:    DEC    R0                ; I                    4890
  7983.     BGE    2$
  7984. 4$:    MOV    (SP),R2                ; WRT.POINTER,POINTER            4901
  7985. 5$:    CMP    6(SP),@36(SP)            ; FILE.CTR,FILE.LENGTH            4903
  7986.     BGE    17$
  7987.     CLR    R1                ; CH                    4905
  7988.     BISB    (R2)+,R1            ; POINTER,CH
  7989.     INC    6(SP)                ; FILE.CTR                4906
  7990.     CMP    R1,#60                ; CH,*                    4908
  7991.     BGE    6$
  7992.     CMP    R1,#56                ; CH,*
  7993.     BNE    8$
  7994.     BIT    #1,R4                ; *,FIRST.PERIOD
  7995.     BNE    8$
  7996. 6$:    CMP    R1,#172                ; CH,*
  7997.     BGT    8$
  7998.     CMP    R1,#71                ; CH,*
  7999.     BLE    7$
  8000.     CMP    R1,#101                ; CH,*                    4909
  8001.     BLT    8$
  8002. 7$:    CMP    R1,#132                ; CH,*
  8003.     BLE    9$
  8004.     CMP    R1,#141                ; CH,*
  8005.     BGE    9$
  8006. 8$:    MOV    #1,12(SP)            ; *,BAD.CHAR                4912
  8007.     MOV    #130,R1                ; *,CH                    4913
  8008.     BR    10$                ;                    4908
  8009. 9$:    CLR    12(SP)                ; BAD.CHAR                4917
  8010.     CMP    R1,#141                ; CH,*                    4919
  8011.     BLT    10$
  8012.     SUB    #40,R1                ; *,CH
  8013. 10$:    CMP    R1,#56                ; CH,*                    4923
  8014.     BNE    11$
  8015.     MOV    #1,R4                ; *,FIRST.PERIOD            4926
  8016.     MOVB    R1,@0(SP)            ; CH,WRT.POINTER            4927
  8017.     ADD    R4,(SP)                ; *,WRT.POINTER
  8018.     ADD    R4,R3                ; *,WRT.SIZE                4928
  8019.     BR    5$                ;                    4923
  8020. 11$:    BIT    #1,12(SP)            ; *,BAD.CHAR                4932
  8021.     BEQ    12$
  8022.     BIT    #1,10(SP)            ; *,IGNORE.BAD
  8023.     BNE    5$
  8024. 12$:    BIT    #1,R4                ; *,FIRST.PERIOD            4935
  8025.     BNE    14$
  8026.     TST    R5                ;                    4939
  8027.     BLT    13$
  8028.     CMP    4(SP),R5            ; NAME.CTR,*
  8029.     BGE    5$
  8030. 13$:    INC    4(SP)                ; NAME.CTR                4942
  8031.     BR    16$                ;                    4943
  8032. 14$:    MOV    32(SP),R0            ; TYPE.LENGTH,*                4950
  8033.     BLT    15$
  8034.     CMP    2(SP),R0            ; TYPE.CTR,*
  8035.     BGE    5$
  8036. 15$:    INC    2(SP)                ; TYPE.CTR                4953
  8037. 16$:    INC    R3                ; WRT.SIZE                4954
  8038.     MOVB    R1,@0(SP)            ; CH,WRT.POINTER            4955
  8039.     INC    (SP)                ; WRT.POINTER
  8040.     BR    5$                ;                    4932
  8041. 17$:    MOV    R3,@36(SP)            ; WRT.SIZE,FILE.LENGTH            4960
  8042.     CLRB    @0(SP)                ; WRT.POINTER                4961
  8043.     INC    (SP)+                ; WRT.POINTER
  8044.     ADD    #12,SP                ;                    4806
  8045.     RTS    PC
  8046. ; Routine Size:  128 words,    Routine Base:  $CODE$ + 16704
  8047. ; Maximum stack depth per invocation:  13 words
  8048.     .NLIST
  8049.     .DSABL    LSB
  8050.     .NLIST    BIN,LOC
  8051.     .LIST
  8052. ;      4963    %SBTTL 'Buffer filling -- Main routine'
  8053. ;      4964    ROUTINE BFR_FILL (FIRST_FLAG) =
  8054. ;      4965    
  8055. ;      4966    !++
  8056. ;      4967    ! FUNCTIONAL DESCRIPTION:
  8057. ;      4968    !
  8058. ;      4969    !    This routine will fill the buffer with data from the file.  It
  8059. ;      4970    !    will do all the quoting that is required.
  8060. ;      4971    !
  8061. ;      4972    ! CALLING SEQUENCE:
  8062. ;      4973    !
  8063. ;      4974    !    EOF_FLAG = BFR_FILL(.FIRST_FLAG);
  8064. ;      4975    !
  8065. ;      4976    ! INPUT PARAMETERS:
  8066. ;      4977    !
  8067. ;      4978    !    FIRST_FLAG - Flag whether first call for this file
  8068. ;      4979    !
  8069. ;      4980    ! IMPLICIT INPUTS:
  8070. ;      4981    !
  8071. ;      4982    !    None.
  8072. ;      4983    !
  8073. ;      4984    ! OUTPUT PARAMETERS:
  8074. ;      4985    !
  8075. ;      4986    !    True - Buffer filled may be at end of file.
  8076. ;      4987    !    False - At end of file.
  8077. ;      4988    !
  8078. ;      4989    ! IMPLICIT OUTPUTS:
  8079. ;      4990    !
  8080. ;      4991    !    Number of characters stored in the buffer.
  8081. ;      4992    !
  8082. ;      4993    ! COMPLETION CODES:
  8083. ;      4994    !
  8084. ;      4995    !    None.
  8085. ;      4996    !
  8086. ;      4997    ! SIDE EFFECTS:
  8087. ;      4998    !
  8088. ;      4999    !    None.
  8089. ;      5000    !
  8090. ;      5001    !--
  8091. ;      5002    
  8092. ;      5003        BEGIN
  8093. ;      5004    
  8094. ;      5005        LITERAL
  8095. ;      5006        NO_CHAR = -1,                ! No character next
  8096. ;      5007        EOF_CHAR = -2;                ! EOF seen
  8097. ;      5008    
  8098. ;      5009        LOCAL
  8099. ;      5010        I,                    ! Temp loop index
  8100. ;      5011        MAX_SIZE,                ! Maximum size of data
  8101. ;      5012        POINTER;                ! Pointer into the message buffer
  8102. ;      5013    
  8103. ;      5014        OWN
  8104. ;      5015        NEXT_CHR,                ! Saved character
  8105. ;      5016        STATUS,                    ! Status value
  8106. ;      5017        REPEAT_COUNT,                ! Number of times character repeated
  8107. ;      5018        CHAR_8_BIT,                ! 8 bit character from file
  8108. ;      5019        CHRS : VECTOR [5],            ! String needed to represent character
  8109. ;      5020        CHR_IDX,                ! Index into CHRS
  8110. ;      5021        OLD_CHAR_8_BIT,                ! Previous 8-bit character
  8111. ;      5022        OLD_CHRS : VECTOR [5],            ! String for previous character
  8112. ;      5023        OLD_CHR_IDX;                ! Index for previous character
  8113. ;      5024    
  8114. ;      5025        ROUTINE GET_QUOTED_CHAR =
  8115. ;      5026    !
  8116. ;      5027    ! This routine gets a character from the file and returns both
  8117. ;      5028    ! the character and the string needed to represent the character
  8118. ;      5029    ! if it needs quoting.
  8119. ;      5030    !
  8120. ;      5031        BEGIN
  8121. ;      5032    
  8122. ;      5033        IF .NEXT_CHR GEQ 0
  8123. ;      5034        THEN
  8124. ;      5035            BEGIN
  8125. ;      5036            CHAR_8_BIT = .NEXT_CHR;
  8126. ;      5037            NEXT_CHR = NO_CHAR;
  8127. ;      5038            STATUS = KER_NORMAL;
  8128. ;      5039            END
  8129. ;      5040        ELSE
  8130. ;      5041    
  8131. ;      5042            IF .NEXT_CHR EQL NO_CHAR
  8132. ;      5043            THEN
  8133. ;      5044            STATUS = (.GET_CHR_ROUTINE) (CHAR_8_BIT)
  8134. ;      5045            ELSE
  8135. ;      5046            STATUS = KER_EOF;
  8136. ;      5047    
  8137. ;      5048        IF .STATUS EQL KER_NORMAL
  8138. ;      5049        THEN
  8139. ;      5050            BEGIN
  8140. ;      5051    !
  8141. ;      5052    ! Determine if we should just quote the character
  8142. ;      5053    !    Either:
  8143. ;      5054    !        Character is a delete (177 octal)
  8144. ;      5055    !    or    Character is a control character (less than 40 octal)
  8145. ;      5056    !    or    Character is a quote character
  8146. ;      5057    !    or    Character is the repeat character and doing repeat compression
  8147. ;      5058    !    or    Character is an eight bit quote character and doing eight bit
  8148. ;      5059    !          quoting.
  8149. ;      5060    !
  8150. ;      5061    
  8151. ;      5062            IF ((.CHAR_8_BIT AND %O'177') LSS %C' ') OR ((.CHAR_8_BIT AND %O'177') EQL CHR_DEL) OR (
  8152. ;      5063            (.CHAR_8_BIT AND %O'177') EQL .RCV_QUOTE_CHR) OR (.FLAG_REPEAT AND ((.CHAR_8_BIT
  8153. ;      5064            AND %O'177') EQL .REPT_CHR)) OR (.FLAG_8QUOTE AND ((.CHAR_8_BIT AND %O'177') EQL
  8154. ;      5065            .SEND_8QUOTE_CHR))
  8155. ;      5066            THEN
  8156. ;      5067            BEGIN
  8157. ;      5068    !
  8158. ;      5069    ! If the character is a control character or delete we must do a CTL(Character)
  8159. ;      5070    ! so it is something that we can be sure we can send.
  8160. ;      5071    !
  8161. ;      5072    
  8162. ;      5073            IF ((.CHAR_8_BIT AND %O'177') LSS %C' ') OR ((.CHAR_8_BIT AND %O'177') EQL CHR_DEL)
  8163. ;      5074            THEN
  8164. ;      5075                CHRS [0] = CTL (.CHAR_8_BIT)
  8165. ;      5076            ELSE
  8166. ;      5077                CHRS [0] = .CHAR_8_BIT;
  8167. ;      5078    
  8168. ;      5079            CHR_IDX = 1;
  8169. ;      5080            CHRS [1] = .RCV_QUOTE_CHR;    ![035] Use character we said we would send
  8170. ;      5081            END
  8171. ;      5082            ELSE
  8172. ;      5083            BEGIN
  8173. ;      5084            CHR_IDX = 0;
  8174. ;      5085            CHRS [0] = .CHAR_8_BIT;
  8175. ;      5086            END;
  8176. ;      5087    
  8177. ;      5088            END;
  8178. ;      5089    
  8179. ;      5090        RETURN .STATUS;
  8180. ;      5091        END;
  8181.     .NLIST
  8182.     .LIST    BIN,LOC
  8183.     .LIST
  8184.  
  8185.  
  8186.     .PSECT    $OWN$,  D  
  8187. ; NEXT.CHR
  8188. U.106:    .BLKW    1
  8189. ; STATUS
  8190. U.107:    .BLKW    1
  8191. ; REPEAT.COUNT
  8192. U.108:    .BLKW    1
  8193. ; CHAR.8.BIT
  8194. U.109:    .BLKW    1
  8195. ; CHRS
  8196. U.110:    .BLKW    5
  8197. ; CHR.IDX
  8198. U.111:    .BLKW    1
  8199. ; OLD.CHAR.8.BIT
  8200. U.112:    .BLKW    1
  8201. ; OLD.CHRS
  8202. U.113:    .BLKW    5
  8203. ; OLD.CHR.IDX
  8204. U.114:    .BLKW    1
  8205.  
  8206.  
  8207.     .SBTTL    GET.QUOTED.CHAR Buffer filling -- Main routine
  8208.     .PSECT    $CODE$,  RO 
  8209.  
  8210.     .NLIST
  8211.     .ENABL    LSB
  8212.     .LIST
  8213. ; GET.QUOTED.CHAR
  8214. U.115:    JSR    R1,$SAVE3            ;                    5025
  8215.     MOV    U.106,R0            ;                    5033
  8216.     BLT    1$
  8217.     MOV    R0,U.109            ;                    5036
  8218.     MOV    #-1,U.106            ;                    5037
  8219.     MOV    #1,U.107            ;                    5038
  8220.     BR    3$                ;                    5033
  8221. 1$:    INC    R0                ;                    5042
  8222.     BNE    2$
  8223.     MOV    #U.109,-(SP)            ;                    5044
  8224.     JSR    PC,@U.91
  8225.     MOV    R0,U.107
  8226.     TST    (SP)+
  8227.     BR    3$                ;                    5042
  8228. 2$:    MOV    #101,U.107            ;                    5046
  8229. 3$:    CMP    U.107,#1            ;                    5048
  8230.     BNE    11$
  8231.     MOV    U.109,R0            ;                    5062
  8232.     CLR    R1
  8233.     MOV    R0,R2
  8234.     BIC    #177600,R2
  8235.     CMP    R2,#40
  8236.     BHIS    4$
  8237.     INC    R1
  8238.     BR    6$
  8239. 4$:    MOV    #177,R2
  8240.     BIC    R0,R2
  8241.     BEQ    6$
  8242.     MOV    RCV.QUOTE.CHR,R3
  8243.     MOV    R0,R2
  8244.     BIC    #177600,R2
  8245.     CMP    R2,R3
  8246.     BEQ    6$
  8247.     BIT    #1,U.73                ;                    5063
  8248.     BEQ    5$
  8249.     MOV    U.63,R3
  8250.     MOV    R0,R2
  8251.     BIC    #177600,R2
  8252.     CMP    R2,R3
  8253.     BEQ    6$
  8254. 5$:    BIT    #1,U.72                ;                    5064
  8255.     BEQ    10$
  8256.     MOV    U.69,R3
  8257.     MOV    R0,R2
  8258.     BIC    #177600,R2
  8259.     CMP    R2,R3
  8260.     BNE    10$
  8261. 6$:    ROR    R1                ;                    5073
  8262.     BLO    7$
  8263.     MOV    #177,R1
  8264.     BIC    R0,R1
  8265.     BNE    8$
  8266. 7$:    MOV    #100,U.110            ;                    5075
  8267.     XOR    R0,U.110
  8268.     BR    9$                ;                    5073
  8269. 8$:    MOV    R0,U.110            ;                    5077
  8270. 9$:    MOV    #1,U.111            ;                    5079
  8271.     MOV    RCV.QUOTE.CHR,U.110+2        ;                    5080
  8272.     BR    11$                ;                    5062
  8273. 10$:    CLR    U.111                ;                    5084
  8274.     MOV    R0,U.110            ;                    5085
  8275. 11$:    MOV    U.107,R0            ;                    5031
  8276.     RTS    PC                ;                    5025
  8277. ; Routine Size:  103 words,    Routine Base:  $CODE$ + 17304
  8278. ; Maximum stack depth per invocation:  6 words
  8279.     .NLIST
  8280.     .DSABL    LSB
  8281.     .NLIST    BIN,LOC
  8282.     .LIST
  8283.  
  8284.  
  8285. ;      5092        ROUTINE GET_8_QUOTED_CHAR =
  8286. ;      5093    !
  8287. ;      5094    ! This routine will get the quoted representation of a character
  8288. ;      5095    ! (by calling GET_QUOTED_CHAR), and return the 8th-bit quoted
  8289. ;      5096    ! representation.
  8290. ;      5097    !
  8291. ;      5098        BEGIN
  8292. ;      5099    
  8293. ;      5100        IF (STATUS = GET_QUOTED_CHAR ()) EQL KER_NORMAL
  8294. ;      5101        THEN
  8295. ;      5102            BEGIN
  8296. ;      5103    !
  8297. ;      5104    ! Determine if we must quote the eighth bit (parity bit on)
  8298. ;      5105    !
  8299. ;      5106    
  8300. ;      5107            IF (((.CHRS [0] AND %O'177') NEQ .CHRS [0]) AND .FLAG_8QUOTE)
  8301. ;      5108            THEN
  8302. ;      5109            BEGIN
  8303. ;      5110            CHRS [0] = .CHRS [0] AND %O'177';
  8304. ;      5111            CHR_IDX = .CHR_IDX + 1;
  8305. ;      5112            CHRS [.CHR_IDX] = .SEND_8QUOTE_CHR;
  8306. ;      5113            END;
  8307. ;      5114    
  8308. ;      5115            END;
  8309. ;      5116    
  8310. ;      5117        RETURN .STATUS;
  8311. ;      5118        END;
  8312.     .NLIST
  8313.     .LIST    BIN,LOC
  8314.     .LIST
  8315.  
  8316.     .SBTTL    GET.8.QUOTED.CHAR Buffer filling -- Main routine
  8317.     .NLIST
  8318.     .ENABL    LSB
  8319.     .LIST
  8320. ; GET.8.QUOTED.CHAR
  8321. U.116:    MOV    R1,-(SP)            ;                    5092
  8322.     JSR    PC,U.115            ;                    5100
  8323.     MOV    R0,U.107
  8324.     CMP    R0,#1
  8325.     BNE    1$
  8326.     MOV    U.110,R1            ;                    5107
  8327.     MOV    R1,R0                ; CHRS,*
  8328.     BIC    #177600,R0
  8329.     CMP    R0,R1
  8330.     BEQ    1$
  8331.     BIT    #1,U.72
  8332.     BEQ    1$
  8333.     BIC    #177600,U.110            ;                    5110
  8334.     INC    U.111                ;                    5111
  8335.     MOV    U.111,R0            ;                    5112
  8336.     ASL    R0
  8337.     MOV    U.69,U.110(R0)
  8338. 1$:    MOV    U.107,R0            ;                    5098
  8339.     MOV    (SP)+,R1            ;                    5092
  8340.     RTS    PC
  8341. ; Routine Size:  34 words,    Routine Base:  $CODE$ + 17622
  8342. ; Maximum stack depth per invocation:  2 words
  8343.     .NLIST
  8344.     .DSABL    LSB
  8345.     .NLIST    BIN,LOC
  8346.     .LIST
  8347.  
  8348.  
  8349. ;      5119    !
  8350. ;      5120    ! Start of code for BFR_FILL
  8351. ;      5121    !
  8352. ;      5122    ! Initialize pointer and count
  8353. ;      5123    !
  8354. ;      5124        SIZE = 0;
  8355. ;      5125        POINTER = CH$PTR (SND_MSG, PKT_MSG, CHR_SIZE);
  8356. ;      5126        MAX_SIZE = .SEND_PKT_SIZE - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR);
  8357. ;      5127    !
  8358. ;      5128    ! If last call got an error or eof, return it now
  8359. ;      5129    !
  8360. ;      5130    
  8361. ;      5131        IF NOT .FIRST_FLAG AND (.STATUS NEQ KER_NORMAL) THEN RETURN .STATUS;
  8362. ;      5132    
  8363. ;      5133    !
  8364. ;      5134    ! If first time for a file prime the pump with the first character.
  8365. ;      5135    !
  8366. ;      5136    
  8367. ;      5137        IF .FIRST_FLAG
  8368. ;      5138        THEN
  8369. ;      5139        BEGIN
  8370. ;      5140        FIRST_FLAG = FALSE;
  8371. ;      5141        NEXT_CHR = -1;                ! No backed up character
  8372. ;      5142    
  8373. ;      5143        IF .FLAG_8QUOTE THEN STATUS = GET_8_QUOTED_CHAR () ELSE STATUS = GET_QUOTED_CHAR ();
  8374. ;      5144    
  8375. ;      5145        IF .STATUS NEQ KER_NORMAL THEN RETURN .STATUS;
  8376. ;      5146    
  8377. ;      5147        OLD_CHAR_8_BIT = .CHAR_8_BIT;
  8378. ;      5148    
  8379. ;      5149        INCR OLD_CHR_IDX FROM 0 TO .CHR_IDX DO
  8380. ;      5150            OLD_CHRS [.OLD_CHR_IDX] = .CHRS [.OLD_CHR_IDX];
  8381. ;      5151    
  8382. ;      5152        OLD_CHR_IDX = .CHR_IDX;
  8383. ;      5153        REPEAT_COUNT = 0;            ! Character was not repeated yet
  8384. ;      5154                            ! Will always be incremented
  8385. ;      5155        END;
  8386. ;      5156    
  8387. ;      5157    !
  8388. ;      5158    ! Otherwise, loop until we fill buffer
  8389. ;      5159    !
  8390. ;      5160    
  8391. ;      5161        WHILE .SIZE LSS .MAX_SIZE DO         ! Normal exit is via an EXITLOOP
  8392. ;      5162        BEGIN
  8393. ;      5163    !
  8394. ;      5164    ! Check if we are doing run compression
  8395. ;      5165    !
  8396. ;      5166    
  8397. ;      5167        IF .FLAG_REPEAT
  8398. ;      5168        THEN
  8399. ;      5169            BEGIN
  8400. ;      5170    !
  8401. ;      5171    ! Here with previous character in OLD_xxx.  As long as we
  8402. ;      5172    ! are getting the same character, just count the run.
  8403. ;      5173    !
  8404. ;      5174    
  8405. ;      5175            WHILE (.CHAR_8_BIT EQL .OLD_CHAR_8_BIT) AND (.REPEAT_COUNT LSS 94) DO
  8406. ;      5176            BEGIN
  8407. ;      5177            REPEAT_COUNT = .REPEAT_COUNT + 1;
  8408. ;      5178    
  8409. ;      5179            IF .FLAG_8QUOTE THEN STATUS = GET_8_QUOTED_CHAR () ELSE STATUS = GET_QUOTED_CHAR ();
  8410. ;      5180    
  8411. ;      5181            IF .STATUS NEQ KER_NORMAL
  8412. ;      5182            THEN
  8413. ;      5183    
  8414. ;      5184                IF .STATUS NEQ KER_EOF
  8415. ;      5185                THEN
  8416. ;      5186                CHAR_8_BIT = NO_CHAR
  8417. ;      5187                ELSE
  8418. ;      5188                BEGIN
  8419. ;      5189                CHAR_8_BIT = EOF_CHAR;
  8420. ;      5190                CHR_IDX = -1;
  8421. ;      5191                END;
  8422. ;      5192    
  8423. ;      5193            END;
  8424. ;      5194    
  8425. ;      5195            IF .OLD_CHR_IDX + 1 + 2 LSS ((.OLD_CHR_IDX + 1)*.REPEAT_COUNT)
  8426. ;      5196            THEN
  8427. ;      5197            BEGIN
  8428. ;      5198    
  8429. ;      5199            IF .SIZE + .OLD_CHR_IDX + 1 + 2 GTR .MAX_SIZE
  8430. ;      5200            THEN
  8431. ;      5201                BEGIN
  8432. ;      5202    
  8433. ;      5203                IF .CHAR_8_BIT EQL .OLD_CHAR_8_BIT
  8434. ;      5204                THEN
  8435. ;      5205                BEGIN
  8436. ;      5206                NEXT_CHR = .CHAR_8_BIT;
  8437. ;      5207                REPEAT_COUNT = .REPEAT_COUNT - 1;
  8438. ;      5208                END;
  8439. ;      5209    
  8440. ;      5210                IF .CHAR_8_BIT EQL EOF_CHAR
  8441. ;      5211                THEN
  8442. ;      5212                BEGIN
  8443. ;      5213                NEXT_CHR = EOF_CHAR;    ! Remember EOF for next time
  8444. ;      5214                STATUS = KER_NORMAL;    ! And give good return now
  8445. ;      5215                END;
  8446. ;      5216    
  8447. ;      5217                EXITLOOP;
  8448. ;      5218                END;
  8449. ;      5219    
  8450. ;      5220            OLD_CHRS [.OLD_CHR_IDX + 1] = CHAR (.REPEAT_COUNT);
  8451. ;      5221            OLD_CHRS [.OLD_CHR_IDX + 2] = .REPT_CHR;
  8452. ;      5222            OLD_CHR_IDX = .OLD_CHR_IDX + 2;
  8453. ;      5223    !
  8454. ;      5224    ! Count the number of file characters this represents
  8455. ;      5225    !
  8456. ;      5226            SMSG_DATA_CHARS = .SMSG_DATA_CHARS + .REPEAT_COUNT - 1;
  8457. ;      5227            FILE_CHARS = .FILE_CHARS + .REPEAT_COUNT - 1;
  8458. ;      5228            REPEAT_COUNT = 1;        ! Only one time for this string
  8459. ;      5229            END;
  8460. ;      5230    
  8461. ;      5231    !
  8462. ;      5232    ! If we don't have enough room for this character, wait till next
  8463. ;      5233    ! time.
  8464. ;      5234    !
  8465. ;      5235    
  8466. ;      5236            IF .SIZE + (.OLD_CHR_IDX + 1)*.REPEAT_COUNT GTR .MAX_SIZE
  8467. ;      5237            THEN
  8468. ;      5238            BEGIN
  8469. ;      5239    ! If the next character is the same, the count will get incremented
  8470. ;      5240    ! next time we enter, so back it off now.
  8471. ;      5241    
  8472. ;      5242            IF .CHAR_8_BIT EQL .OLD_CHAR_8_BIT
  8473. ;      5243            THEN
  8474. ;      5244                BEGIN
  8475. ;      5245                NEXT_CHR = .CHAR_8_BIT;
  8476. ;      5246                REPEAT_COUNT = .REPEAT_COUNT - 1;
  8477. ;      5247                END;
  8478. ;      5248    
  8479. ;      5249            EXITLOOP;
  8480. ;      5250            END;
  8481. ;      5251    
  8482. ;      5252            SMSG_DATA_CHARS = .SMSG_DATA_CHARS + .REPEAT_COUNT;
  8483. ;      5253            FILE_CHARS = .FILE_CHARS + .REPEAT_COUNT;
  8484. ;      5254    
  8485. ;      5255            DECR REPEAT_COUNT FROM .REPEAT_COUNT TO 1 DO
  8486. ;      5256    
  8487. ;      5257            DECR I FROM .OLD_CHR_IDX TO 0 DO
  8488. ;      5258                BEGIN
  8489. ;      5259                CH$WCHAR_A (.OLD_CHRS [.I], POINTER);
  8490. ;      5260                SIZE = .SIZE + 1;
  8491. ;      5261                END;
  8492. ;      5262    
  8493. ;      5263    !
  8494. ;      5264    ! If we got an error (or EOF) then exit
  8495. ;      5265    !
  8496. ;      5266    
  8497. ;      5267            IF (.STATUS NEQ KER_NORMAL) THEN EXITLOOP;
  8498. ;      5268    
  8499. ;      5269    !
  8500. ;      5270    ! Otherwise, copy the character which broke the run
  8501. ;      5271    !
  8502. ;      5272            OLD_CHAR_8_BIT = .CHAR_8_BIT;
  8503. ;      5273    
  8504. ;      5274            INCR OLD_CHR_IDX FROM 0 TO .CHR_IDX DO
  8505. ;      5275            OLD_CHRS [.OLD_CHR_IDX] = .CHRS [.OLD_CHR_IDX];
  8506. ;      5276    
  8507. ;      5277            OLD_CHR_IDX = .CHR_IDX;
  8508. ;      5278            REPEAT_COUNT = 0;
  8509. ;      5279            END
  8510. ;      5280        ELSE
  8511. ;      5281    !
  8512. ;      5282    ! Here if we are not doing run compression.  We can do things much
  8513. ;      5283    ! easier.
  8514. ;      5284    !
  8515. ;      5285            BEGIN
  8516. ;      5286    
  8517. ;      5287            IF (.SIZE + .CHR_IDX + 1) GTR .MAX_SIZE THEN EXITLOOP;
  8518. ;      5288    
  8519. ;      5289            SMSG_DATA_CHARS = .SMSG_DATA_CHARS + 1;
  8520. ;      5290            FILE_CHARS = .FILE_CHARS + 1;
  8521. ;      5291    
  8522. ;      5292            DECR CHR_IDX FROM .CHR_IDX TO 0 DO
  8523. ;      5293            BEGIN
  8524. ;      5294            CH$WCHAR_A (.CHRS [.CHR_IDX], POINTER);
  8525. ;      5295            SIZE = .SIZE + 1;
  8526. ;      5296            END;
  8527. ;      5297    
  8528. ;      5298            IF .FLAG_8QUOTE THEN STATUS = GET_8_QUOTED_CHAR () ELSE STATUS = GET_QUOTED_CHAR ();
  8529. ;      5299    
  8530. ;      5300            IF (.STATUS NEQ KER_NORMAL) THEN EXITLOOP;
  8531. ;      5301    
  8532. ;      5302            END;
  8533. ;      5303    
  8534. ;      5304        END;
  8535. ;      5305    
  8536. ;      5306    !
  8537. ;      5307    ! Determine if we really stored anything into the buffer.
  8538. ;      5308    !
  8539. ;      5309    
  8540. ;      5310        IF .SIZE NEQ 0 THEN RETURN KER_NORMAL ELSE RETURN .STATUS;
  8541. ;      5311    
  8542. ;      5312        END;                    ! End of BFR_FILL
  8543.     .NLIST
  8544.     .LIST    BIN,LOC
  8545.     .LIST
  8546.  
  8547.     .SBTTL    BFR.FILL Buffer filling -- Main routine
  8548.     .NLIST
  8549.     .ENABL    LSB
  8550.     .LIST
  8551. ; BFR.FILL
  8552. U.28:    JSR    R1,$SAVE5            ;                    4964
  8553.     CLR    U.75                ;                    5124
  8554.     MOV    #U.83+4,R5            ; *,POINTER                5125
  8555.     MOV    U.64,R0                ;                    5126
  8556.     SUB    U.71,R0
  8557.     MOV    R0,R4                ; *,MAX.SIZE
  8558.     ADD    #56,R4                ; *,MAX.SIZE
  8559.     BIT    #1,16(SP)            ; *,FIRST.FLAG                5131
  8560.     BNE    1$
  8561.     CMP    U.107,#1
  8562.     BNE    4$
  8563.     BIT    #1,16(SP)            ; *,FIRST.FLAG                5137
  8564.     BEQ    9$
  8565. 1$:    CLR    16(SP)                ; FIRST.FLAG                5140
  8566.     MOV    #-1,U.106            ;                    5141
  8567.     BIT    #1,U.72                ;                    5143
  8568.     BEQ    2$
  8569.     JSR    PC,U.116
  8570.     BR    3$
  8571. 2$:    JSR    PC,U.115
  8572. 3$:    MOV    R0,U.107
  8573.     CMP    R0,#1                ; STATUS,*                5145
  8574. 4$:    BEQ    5$
  8575.     JMP    34$
  8576. 5$:    MOV    U.109,U.112            ;                    5147
  8577.     CLR    R1                ; OLD.CHR.IDX                5149
  8578.     BR    7$
  8579. 6$:    MOV    R1,R0                ; OLD.CHR.IDX,*                5150
  8580.     ASL    R0
  8581.     MOV    U.110(R0),U.113(R0)
  8582.     INC    R1                ; OLD.CHR.IDX                5149
  8583. 7$:    CMP    R1,U.111            ; OLD.CHR.IDX,*
  8584.     BLE    6$
  8585. 8$:    MOV    U.111,U.114            ;                    5152
  8586.     CLR    U.108                ;                    5153
  8587. 9$:    CMP    U.75,R4                ; *,MAX.SIZE                5161
  8588.     BGE    16$
  8589.     BIT    #1,U.73                ;                    5167
  8590.     BNE    10$
  8591.     JMP    28$
  8592. 10$:    CMP    U.109,U.112            ;                    5175
  8593.     BNE    14$
  8594.     CMP    U.108,#136
  8595.     BGE    14$
  8596.     INC    U.108                ;                    5177
  8597.     BIT    #1,U.72                ;                    5179
  8598.     BEQ    11$
  8599.     JSR    PC,U.116
  8600.     BR    12$
  8601. 11$:    JSR    PC,U.115
  8602. 12$:    MOV    R0,U.107
  8603.     CMP    R0,#1                ; STATUS,*                5181
  8604.     BEQ    10$
  8605.     CMP    R0,#101                ; STATUS,*                5184
  8606.     BEQ    13$
  8607.     MOV    #-1,U.109            ;                    5186
  8608.     BR    10$                ;                    5184
  8609. 13$:    MOV    #-2,U.109            ;                    5189
  8610.     MOV    #-1,U.111            ;                    5190
  8611.     BR    10$                ;                    5181
  8612. 14$:    MOV    U.114,R2            ;                    5195
  8613.     MOV    R2,R0
  8614.     ADD    #3,R0
  8615.     MOV    R2,R3
  8616.     INC    R3
  8617.     MOV    R3,R1
  8618.     MUL    U.108,R1
  8619.     CMP    R0,R1
  8620.     BGE    18$
  8621.     MOV    R2,R0                ;                    5199
  8622.     ADD    U.75,R0
  8623.     ADD    #3,R0
  8624.     CMP    R0,R4                ; *,MAX.SIZE
  8625.     BLE    17$
  8626.     MOV    U.109,R0            ;                    5203
  8627.     CMP    R0,U.112
  8628.     BNE    15$
  8629.     MOV    R0,U.106            ;                    5206
  8630.     DEC    U.108                ;                    5207
  8631. 15$:    CMP    R0,#-2                ;                    5210
  8632.     BNE    25$
  8633.     MOV    #-2,U.106            ;                    5213
  8634.     MOV    #1,U.107            ;                    5214
  8635. 16$:    BR    19$                ;                    5201
  8636. 17$:    MOV    R3,R1                ;                    5220
  8637.     ASL    R1
  8638.     MOV    U.108,R0
  8639.     MOV    R0,U.113(R1)
  8640.     ADD    #40,U.113(R1)
  8641.     MOV    R2,R1                ;                    5221
  8642.     ASL    R1
  8643.     MOV    U.63,U.113+4(R1)
  8644.     ADD    #2,U.114            ;                    5222
  8645.     MOV    R0,R1                ;                    5226
  8646.     ADD    SMSG.DATA.CHARS,R1
  8647.     MOV    R1,SMSG.DATA.CHARS
  8648.     DEC    SMSG.DATA.CHARS
  8649.     MOV    R0,R1                ;                    5227
  8650.     ADD    U.85,R1
  8651.     MOV    R1,U.85
  8652.     DEC    U.85
  8653.     MOV    #1,U.108            ;                    5228
  8654. 18$:    MOV    U.114,R1            ;                    5236
  8655.     INC    R1
  8656.     MUL    U.108,R1
  8657.     ADD    U.75,R1
  8658.     CMP    R1,R4                ; *,MAX.SIZE
  8659.     BLE    20$
  8660.     CMP    U.109,U.112            ;                    5242
  8661.     BNE    33$
  8662.     MOV    U.109,U.106            ;                    5245
  8663.     DEC    U.108                ;                    5246
  8664. 19$:    BR    33$                ;                    5238
  8665. 20$:    MOV    U.108,R0            ;                    5252
  8666.     ADD    R0,SMSG.DATA.CHARS
  8667.     ADD    R0,U.85                ;                    5253
  8668.     TST    R0                ; REPEAT.COUNT                5255
  8669.     BLE    24$
  8670. 21$:    MOV    U.114,R1            ; *,I                    5257
  8671.     BLT    23$
  8672. 22$:    MOV    R1,R2                ; I,*                    5259
  8673.     ASL    R2
  8674.     MOVB    U.113(R2),(R5)+            ; *,POINTER
  8675.     INC    U.75                ;                    5260
  8676.     DEC    R1                ; I                    5257
  8677.     BGE    22$
  8678. 23$:    SOB    R0,21$                ; REPEAT.COUNT,*            5255
  8679. 24$:    CMP    U.107,#1            ;                    5267
  8680. 25$:    BNE    33$
  8681.     MOV    U.109,U.112            ;                    5272
  8682.     CLR    R1                ; OLD.CHR.IDX                5274
  8683.     BR    27$
  8684. 26$:    MOV    R1,R0                ; OLD.CHR.IDX,*                5275
  8685.     ASL    R0
  8686.     MOV    U.110(R0),U.113(R0)
  8687.     INC    R1                ; OLD.CHR.IDX                5274
  8688. 27$:    CMP    R1,U.111            ; OLD.CHR.IDX,*
  8689.     BLE    26$
  8690.     JMP    8$                ;                    5277
  8691. 28$:    MOV    U.75,R0                ;                    5287
  8692.     ADD    U.111,R0
  8693.     INC    R0
  8694.     CMP    R0,R4                ; *,MAX.SIZE
  8695.     BGT    33$
  8696.     INC    SMSG.DATA.CHARS            ;                    5289
  8697.     INC    U.85                ;                    5290
  8698.     MOV    U.111,R1            ; *,CHR.IDX                5292
  8699.     BLT    30$
  8700. 29$:    MOV    R1,R0                ; CHR.IDX,*                5294
  8701.     ASL    R0
  8702.     MOVB    U.110(R0),(R5)+            ; *,POINTER
  8703.     INC    U.75                ;                    5295
  8704.     DEC    R1                ; CHR.IDX                5292
  8705.     BGE    29$
  8706. 30$:    BIT    #1,U.72                ;                    5298
  8707.     BEQ    31$
  8708.     JSR    PC,U.116
  8709.     BR    32$
  8710. 31$:    JSR    PC,U.115
  8711. 32$:    MOV    R0,U.107
  8712.     CMP    R0,#1                ; STATUS,*                5300
  8713.     BNE    33$
  8714.     JMP    9$
  8715. 33$:    TST    U.75                ;                    5310
  8716.     BEQ    34$
  8717.     MOV    #1,R0                ;                    5003
  8718.     RTS    PC
  8719. 34$:    MOV    U.107,R0
  8720.     RTS    PC                ;                    4964
  8721. ; Routine Size:  290 words,    Routine Base:  $CODE$ + 17726
  8722. ; Maximum stack depth per invocation:  7 words
  8723.     .NLIST
  8724.     .DSABL    LSB
  8725.     .NLIST    BIN,LOC
  8726.     .LIST
  8727. ;      5313    %SBTTL 'BFR_EMPTY'
  8728. ;      5314    ROUTINE BFR_EMPTY =
  8729. ;      5315    
  8730. ;      5316    !++
  8731. ;      5317    ! FUNCTIONAL DESCRIPTION:
  8732. ;      5318    !
  8733. ;      5319    !    This routine will empty the data from the REC_MSG message buffer
  8734. ;      5320    !    to the file.  It will process quoting characters.
  8735. ;      5321    !
  8736. ;      5322    ! CALLING SEQUENCE:
  8737. ;      5323    !
  8738. ;      5324    !    Flag = BFR_EMPTY();
  8739. ;      5325    !
  8740. ;      5326    ! INPUT PARAMETERS:
  8741. ;      5327    !
  8742. ;      5328    !    None.
  8743. ;      5329    !
  8744. ;      5330    ! IMPLICIT INPUTS:
  8745. ;      5331    !
  8746. ;      5332    !    None.
  8747. ;      5333    !
  8748. ;      5334    ! OUTPUT PARAMETERS:
  8749. ;      5335    !
  8750. ;      5336    !    True - No problems writing the file.
  8751. ;      5337    !    False - I/O error writing the file.
  8752. ;      5338    !
  8753. ;      5339    ! IMPLICIT OUTPUTS:
  8754. ;      5340    !
  8755. ;      5341    !    None.
  8756. ;      5342    !
  8757. ;      5343    ! COMPLETION CODES:
  8758. ;      5344    !
  8759. ;      5345    !    None.
  8760. ;      5346    !
  8761. ;      5347    ! SIDE EFFECTS:
  8762. ;      5348    !
  8763. ;      5349    !    None.
  8764. ;      5350    !
  8765. ;      5351    !--
  8766. ;      5352    
  8767. ;      5353        BEGIN
  8768. ;      5354    
  8769. ;      5355        LOCAL
  8770. ;      5356        STATUS,                    ! Status returned by various routines
  8771. ;      5357        REPEAT_COUNT,                ! Count of times to repeat character
  8772. ;      5358        TURN_BIT_8_ON,                ! If eight bit quoting
  8773. ;      5359        COUNTER,                ! Count of the characters left
  8774. ;      5360        CHARACTER,                ! Character we are processing
  8775. ;      5361        POINTER;                ! Pointer to the data
  8776. ;      5362    
  8777. ;      5363        POINTER = CH$PTR (REC_MSG, PKT_MSG, CHR_SIZE);
  8778. ;      5364        COUNTER = 0;
  8779. ;      5365    
  8780. ;      5366        WHILE (.COUNTER LSS .REC_LENGTH) DO
  8781. ;      5367        BEGIN
  8782. ;      5368        CHARACTER = CH$RCHAR_A (POINTER);
  8783. ;      5369        COUNTER = .COUNTER + 1;
  8784. ;      5370    !
  8785. ;      5371    ! If the character is the repeat character (and we are doing repeat
  8786. ;      5372    ! compression), then get the count.
  8787. ;      5373    !
  8788. ;      5374    
  8789. ;      5375        IF ((.CHARACTER EQL .REPT_CHR) AND .FLAG_REPEAT)
  8790. ;      5376        THEN
  8791. ;      5377            BEGIN
  8792. ;      5378            REPEAT_COUNT = UNCHAR (CH$RCHAR_A (POINTER) AND %O'177');
  8793. ;      5379            CHARACTER = CH$RCHAR_A (POINTER);
  8794. ;      5380            COUNTER = .COUNTER + 2;
  8795. ;      5381            END
  8796. ;      5382        ELSE
  8797. ;      5383            REPEAT_COUNT = 1;
  8798. ;      5384    
  8799. ;      5385    !
  8800. ;      5386    ! If the character is an eight bit quoting character and we are doing eight
  8801. ;      5387    ! bit quoting then turn on the flag so we turn the eighth bit on when we
  8802. ;      5388    ! get the real character.
  8803. ;      5389    !
  8804. ;      5390    
  8805. ;      5391        IF ((.CHARACTER EQL .SEND_8QUOTE_CHR) AND .FLAG_8QUOTE)
  8806. ;      5392        THEN
  8807. ;      5393            BEGIN
  8808. ;      5394            TURN_BIT_8_ON = TRUE;
  8809. ;      5395            COUNTER = .COUNTER + 1;
  8810. ;      5396            CHARACTER = CH$RCHAR_A (POINTER);
  8811. ;      5397            END
  8812. ;      5398        ELSE
  8813. ;      5399            TURN_BIT_8_ON = FALSE;
  8814. ;      5400    
  8815. ;      5401    !
  8816. ;      5402    ! Now determine if we are quoting the character.  If so then we must eat
  8817. ;      5403    ! the quoting character and get the real character.
  8818. ;      5404    !
  8819. ;      5405    
  8820. ;      5406        IF .CHARACTER EQL .SEND_QUOTE_CHR    ![035] Is this character other Kermit sends as quote?
  8821. ;      5407        THEN
  8822. ;      5408            BEGIN
  8823. ;      5409            CHARACTER = CH$RCHAR_A (POINTER);
  8824. ;      5410            COUNTER = .COUNTER + 1;
  8825. ;      5411    !
  8826. ;      5412    ! Determine if we must undo what someone else has done to the character
  8827. ;      5413    !
  8828. ;      5414    
  8829. ;    P 5415            IF ((.CHARACTER AND %O'177') GEQ CTL (CHR_DEL)) AND ((.CHARACTER AND %O'177') LEQ CTL (
  8830. ;      5416                CHR_DEL) + %O'40')
  8831. ;      5417            THEN
  8832. ;      5418            CHARACTER = CTL (.CHARACTER);
  8833. ;      5419    
  8834. ;      5420            END;
  8835. ;      5421    
  8836. ;      5422    !
  8837. ;      5423    ! Turn on the eight bit if needed and then write the character out
  8838. ;      5424    !
  8839. ;      5425    
  8840. ;      5426        IF .TURN_BIT_8_ON THEN CHARACTER = .CHARACTER OR %O'200';
  8841. ;      5427    
  8842. ;      5428        RMSG_DATA_CHARS = .RMSG_DATA_CHARS + .REPEAT_COUNT;
  8843. ;      5429        FILE_CHARS = .FILE_CHARS + .REPEAT_COUNT;
  8844. ;      5430    
  8845. ;      5431        DECR REPEAT_COUNT FROM .REPEAT_COUNT TO 1 DO
  8846. ;      5432            BEGIN
  8847. ;      5433            STATUS = (.PUT_CHR_ROUTINE) (.CHARACTER);
  8848. ;      5434    
  8849. ;      5435            IF NOT .STATUS THEN RETURN .STATUS;
  8850. ;      5436    
  8851. ;      5437            END;
  8852. ;      5438    
  8853. ;      5439        END;
  8854. ;      5440    
  8855. ;      5441        RETURN KER_NORMAL;
  8856. ;      5442        END;                    ! End of BFR_EMPTY
  8857.     .NLIST
  8858.     .LIST    BIN,LOC
  8859.     .LIST
  8860.  
  8861.     .SBTTL    BFR.EMPTY BFR_EMPTY
  8862.     .NLIST
  8863.     .ENABL    LSB
  8864.     .LIST
  8865. ; BFR.EMPTY
  8866. U.27:    JSR    R1,$SAVE5            ;                    5314
  8867.     TST    -(SP)
  8868.     MOV    #U.82+4,R4            ; *,POINTER                5363
  8869.     CLR    R3                ; COUNTER                5364
  8870. 1$:    CMP    R3,U.80                ; COUNTER,*                5366
  8871.     BGE    10$
  8872.     CLR    R2                ; CHARACTER                5368
  8873.     BISB    (R4)+,R2            ; POINTER,CHARACTER
  8874.     INC    R3                ; COUNTER                5369
  8875.     CMP    R2,U.63                ; CHARACTER,*                5375
  8876.     BNE    2$
  8877.     BIT    #1,U.73
  8878.     BEQ    2$
  8879.     MOVB    (R4)+,R5            ; POINTER,REPEAT.COUNT            5378
  8880.     BIC    #177600,R5            ; *,REPEAT.COUNT
  8881.     SUB    #40,R5                ; *,REPEAT.COUNT
  8882.     CLR    R2                ; CHARACTER                5379
  8883.     BISB    (R4)+,R2            ; POINTER,CHARACTER
  8884.     ADD    #2,R3                ; *,COUNTER                5380
  8885.     BR    3$                ;                    5375
  8886. 2$:    MOV    #1,R5                ; *,REPEAT.COUNT            5383
  8887. 3$:    CMP    R2,U.69                ; CHARACTER,*                5391
  8888.     BNE    4$
  8889.     BIT    #1,U.72
  8890.     BEQ    4$
  8891.     MOV    #1,(SP)                ; *,TURN.BIT.8.ON            5394
  8892.     ADD    (SP),R3                ; *,COUNTER                5395
  8893.     ADD    (SP),R4                ; *,POINTER                5396
  8894.     CLR    R2                ; CHARACTER
  8895.     BISB    -1(R4),R2            ; *(POINTER),CHARACTER
  8896.     BR    5$                ;                    5391
  8897. 4$:    CLR    (SP)                ; TURN.BIT.8.ON                5399
  8898. 5$:    CMP    R2,U.68                ; CHARACTER,*                5406
  8899.     BNE    6$
  8900.     CLR    R2                ; CHARACTER                5409
  8901.     BISB    (R4)+,R2            ; POINTER,CHARACTER
  8902.     INC    R3                ; COUNTER                5410
  8903.     MOV    R2,R1                ; CHARACTER,*                5415
  8904.     BIC    #177600,R1
  8905.     CMP    R1,#77
  8906.     BLO    6$
  8907.     MOV    R2,R1                ; CHARACTER,*
  8908.     BIC    #177600,R1
  8909.     CMP    R1,#137
  8910.     BHI    6$
  8911.     MOV    #100,R1                ;                    5418
  8912.     XOR    R1,R2                ; *,CHARACTER
  8913. 6$:    BIT    #1,(SP)                ; *,TURN.BIT.8.ON            5426
  8914.     BEQ    7$
  8915.     BIS    #200,R2                ; *,CHARACTER
  8916. 7$:    ADD    R5,RMSG.DATA.CHARS        ; REPEAT.COUNT,*            5428
  8917.     ADD    R5,U.85                ; REPEAT.COUNT,*            5429
  8918.     MOV    R5,R1                ; REPEAT.COUNT,REPEAT.COUNT        5431
  8919.     BLE    1$
  8920. 8$:    MOV    R2,-(SP)            ; CHARACTER,*                5433
  8921.     JSR    PC,@U.92
  8922.     BIT    #1,R0                ; *,STATUS                5435
  8923.     BNE    9$
  8924.     TST    (SP)+
  8925.     BR    11$
  8926. 9$:    TST    (SP)+                ;                    5432
  8927.     SOB    R1,8$                ; REPEAT.COUNT,*            5431
  8928.     BR    1$                ;                    5366
  8929. 10$:    MOV    #1,R0                ;                    5353
  8930. 11$:    TST    (SP)+                ;                    5314
  8931.     RTS    PC
  8932. ; Routine Size:  94 words,    Routine Base:  $CODE$ + 21032
  8933. ; Maximum stack depth per invocation:  9 words
  8934.     .NLIST
  8935.     .DSABL    LSB
  8936.     .NLIST    BIN,LOC
  8937.     .LIST
  8938.  
  8939.  
  8940. ;      5443    %SBTTL 'Buffer filling and emptying subroutines'
  8941. ;      5444    ROUTINE SET_STRING (POINTER, LENGTH, START) =
  8942. ;      5445    
  8943. ;      5446    !++
  8944. ;      5447    ! FUNCTIONAL DESCRIPTION:
  8945. ;      5448    !
  8946. ;      5449    !    This routine is used to set up the buffer filling and emptying
  8947. ;      5450    !    routines to use a string for input (or output) rather than
  8948. ;      5451    !    the file I/O routines.
  8949. ;      5452    !
  8950. ;      5453    ! CALLING SEQUENCE:
  8951. ;      5454    !
  8952. ;      5455    !    SET_STRING (.POINTER, .LENGTH, .START)
  8953. ;      5456    !
  8954. ;      5457    ! INPUT PARAMETERS:
  8955. ;      5458    !
  8956. ;      5459    !    POINTER - Character pointer to string
  8957. ;      5460    !
  8958. ;      5461    !    LENGTH - Number of characters in string
  8959. ;      5462    !
  8960. ;      5463    !    START - True to start string, false to end it
  8961. ;      5464    !
  8962. ;      5465    ! IMPLICIT INPUTS:
  8963. ;      5466    !
  8964. ;      5467    !    None.
  8965. ;      5468    !
  8966. ;      5469    ! OUPTUT PARAMETERS:
  8967. ;      5470    !
  8968. ;      5471    !    Returns 0 if START = TRUE, actual number of characters used
  8969. ;      5472    !    by last string if START = FALSE.
  8970. ;      5473    !
  8971. ;      5474    ! IMPLICIT OUTPUTS:
  8972. ;      5475    !
  8973. ;      5476    !    GET_CHR_ROUTINE and PUT_CHR_ROUTINE modifed so that string
  8974. ;      5477    !    routines are called instead of file I/O.
  8975. ;      5478    !
  8976. ;      5479    ! COMPLETION CODES:
  8977. ;      5480    !
  8978. ;      5481    !    None.
  8979. ;      5482    !
  8980. ;      5483    ! SIDE EFFECTS:
  8981. ;      5484    !
  8982. ;      5485    !    None.
  8983. ;      5486    !
  8984. ;      5487    !--
  8985. ;      5488    
  8986. ;      5489        BEGIN
  8987. ;      5490    
  8988. ;      5491        OWN
  8989. ;      5492        STR_POINTER,                ! Pointer to string
  8990. ;      5493        STR_LENGTH,                ! Length of string
  8991. ;      5494        STR_ORG_LENGTH,                ! Original length of string
  8992. ;      5495        OLD_GET_CHR,                ! Old get-char routine
  8993. ;      5496        OLD_PUT_CHR;                ! Old put-char routine
  8994. ;      5497    
  8995. ;      5498    !
  8996. ;      5499    ! Routine to get a character from the string
  8997. ;      5500    !
  8998. ;      5501        ROUTINE GET_STRING (CHAR_ADDRESS) =
  8999. ;      5502        BEGIN
  9000. ;      5503    !
  9001. ;      5504    ! If some characters are left, count down the length and get next character
  9002. ;      5505    ! Otherwise return and end of file indication.
  9003. ;      5506    !
  9004. ;      5507    
  9005. ;      5508        IF .STR_LENGTH GTR 0
  9006. ;      5509        THEN
  9007. ;      5510            BEGIN
  9008. ;      5511            STR_LENGTH = .STR_LENGTH - 1;
  9009. ;      5512            .CHAR_ADDRESS = CH$RCHAR_A (STR_POINTER);
  9010. ;      5513            RETURN KER_NORMAL;
  9011. ;      5514            END
  9012. ;      5515        ELSE
  9013. ;      5516            RETURN KER_EOF;
  9014. ;      5517    
  9015. ;      5518        END;                    ! End of GET_STRING
  9016.     .NLIST
  9017.     .LIST    BIN,LOC
  9018.     .LIST
  9019.  
  9020.  
  9021.     .PSECT    $OWN$,  D  
  9022. ; STR.POINTER
  9023. U.117:    .BLKW    1
  9024. ; STR.LENGTH
  9025. U.118:    .BLKW    1
  9026. ; STR.ORG.LENGTH
  9027. U.119:    .BLKW    1
  9028. ; OLD.GET.CHR
  9029. U.120:    .BLKW    1
  9030. ; OLD.PUT.CHR
  9031. U.121:    .BLKW    1
  9032.  
  9033.  
  9034.     .SBTTL    GET.STRING Buffer filling and emptying subroutines
  9035.     .PSECT    $CODE$,  RO 
  9036.  
  9037.     .NLIST
  9038.     .ENABL    LSB
  9039.     .LIST
  9040. ; GET.STRING
  9041. U.122:    TST    U.118                ;                    5508
  9042.     BLE    1$
  9043.     DEC    U.118                ;                    5511
  9044.     INC    U.117                ;                    5512
  9045.     MOV    U.117,R0
  9046.     MOVB    -1(R0),@2(SP)            ; *,CHAR.ADDRESS
  9047.     BIC    #177400,@2(SP)            ; *,CHAR.ADDRESS
  9048.     MOV    #1,R0                ;                    5502
  9049.     RTS    PC
  9050. 1$:    MOV    #101,R0
  9051.     RTS    PC                ;                    5501
  9052. ; Routine Size:  21 words,    Routine Base:  $CODE$ + 21326
  9053. ; Maximum stack depth per invocation:  0 words
  9054.     .NLIST
  9055.     .DSABL    LSB
  9056.     .NLIST    BIN,LOC
  9057.     .LIST
  9058.  
  9059.  
  9060. ;      5519        ROUTINE PUT_STRING (CHAR_VALUE) =
  9061. ;      5520        BEGIN
  9062. ;      5521    !
  9063. ;      5522    ! If there is enough room to store another character, store the character
  9064. ;      5523    ! and count it.  Otherwise return a line too long indication.
  9065. ;      5524    !
  9066. ;      5525    
  9067. ;      5526        IF .STR_LENGTH GTR 0
  9068. ;      5527        THEN
  9069. ;      5528            BEGIN
  9070. ;      5529            STR_LENGTH = .STR_LENGTH - 1;
  9071. ;      5530            CH$WCHAR_A (.CHAR_VALUE, STR_POINTER);
  9072. ;      5531            RETURN KER_NORMAL;
  9073. ;      5532            END
  9074. ;      5533        ELSE
  9075. ;      5534            RETURN KER_LINTOOLNG;
  9076. ;      5535    
  9077. ;      5536        END;                    ! End of PUT_STRING
  9078.     .NLIST
  9079.     .LIST    BIN,LOC
  9080.     .LIST
  9081.  
  9082.     .SBTTL    PUT.STRING Buffer filling and emptying subroutines
  9083.     .NLIST
  9084.     .ENABL    LSB
  9085.     .LIST
  9086. ; PUT.STRING
  9087. U.123:    TST    U.118                ;                    5526
  9088.     BLE    1$
  9089.     DEC    U.118                ;                    5529
  9090.     MOVB    2(SP),@U.117            ; CHAR.VALUE,*                5530
  9091.     INC    U.117
  9092.     MOV    #1,R0                ;                    5520
  9093.     RTS    PC
  9094. 1$:    MOV    #72,R0
  9095.     RTS    PC                ;                    5519
  9096. ; Routine Size:  16 words,    Routine Base:  $CODE$ + 21400
  9097. ; Maximum stack depth per invocation:  0 words
  9098.     .NLIST
  9099.     .DSABL    LSB
  9100.     .NLIST    BIN,LOC
  9101.     .LIST
  9102.  
  9103.  
  9104. ;      5537    !
  9105. ;      5538    ! If we have a request to start a string (input or output), save the old
  9106. ;      5539    ! routines and set up ours.  Also save the string pointer and length for
  9107. ;      5540    ! use by our get/put routines.
  9108. ;      5541    ! Otherwise this is a request to stop using the string routines, so reset
  9109. ;      5542    ! the old routines and return the actual number of characters read or
  9110. ;      5543    ! written
  9111. ;      5544    !
  9112. ;      5545    
  9113. ;      5546        IF .START
  9114. ;      5547        THEN
  9115. ;      5548        BEGIN
  9116. ;      5549        STR_POINTER = .POINTER;
  9117. ;      5550        STR_ORG_LENGTH = .LENGTH;
  9118. ;      5551        STR_LENGTH = .LENGTH;
  9119. ;      5552        OLD_GET_CHR = .GET_CHR_ROUTINE;
  9120. ;      5553        OLD_PUT_CHR = .PUT_CHR_ROUTINE;
  9121. ;      5554        GET_CHR_ROUTINE = GET_STRING;
  9122. ;      5555        PUT_CHR_ROUTINE = PUT_STRING;
  9123. ;      5556        RETURN 0;
  9124. ;      5557        END
  9125. ;      5558        ELSE
  9126. ;      5559        BEGIN
  9127. ;      5560        GET_CHR_ROUTINE = .OLD_GET_CHR;
  9128. ;      5561        PUT_CHR_ROUTINE = .OLD_PUT_CHR;
  9129. ;      5562        RETURN .STR_ORG_LENGTH - .STR_LENGTH;
  9130. ;      5563        END;
  9131. ;      5564    
  9132. ;      5565        END;                    ! End of SET_STRING
  9133.     .NLIST
  9134.     .LIST    BIN,LOC
  9135.     .LIST
  9136.  
  9137.     .SBTTL    SET.STRING Buffer filling and emptying subroutines
  9138.     .NLIST
  9139.     .ENABL    LSB
  9140.     .LIST
  9141. ; SET.STRING
  9142. U.29:    BIT    #1,2(SP)            ; *,START                5546
  9143.     BEQ    1$
  9144.     MOV    6(SP),U.117            ; POINTER,*                5549
  9145.     MOV    4(SP),U.119            ; LENGTH,*                5550
  9146.     MOV    4(SP),U.118            ; STR.ORG.LENGTH,*            5551
  9147.     MOV    U.91,U.120            ;                    5552
  9148.     MOV    U.92,U.121            ;                    5553
  9149.     MOV    #U.122,U.91            ;                    5554
  9150.     MOV    #U.123,U.92            ;                    5555
  9151.     CLR    R0                ;                    5489
  9152.     RTS    PC
  9153. 1$:    MOV    U.120,U.91            ;                    5560
  9154.     MOV    U.121,U.92            ;                    5561
  9155.     MOV    U.119,R0            ;                    5562
  9156.     SUB    U.118,R0
  9157.     RTS    PC                ;                    5444
  9158. ; Routine Size:  38 words,    Routine Base:  $CODE$ + 21440
  9159. ; Maximum stack depth per invocation:  0 words
  9160.     .NLIST
  9161.     .DSABL    LSB
  9162.     .NLIST    BIN,LOC
  9163.     .LIST
  9164.  
  9165.  
  9166. ;      5566    %SBTTL 'Add parity routine'
  9167. ;      5567    ROUTINE DO_PARITY (MESSAGE, LENGTH) : NOVALUE =
  9168. ;      5568    
  9169. ;      5569    !++
  9170. ;      5570    ! FUNCTIONAL DESCRIPTION:
  9171. ;      5571    !
  9172. ;      5572    !    This routine will add parity for a complete message that is to be
  9173. ;      5573    !    sent to the remote Kermit.
  9174. ;      5574    !
  9175. ;      5575    ! CALLING SEQUENCE:
  9176. ;      5576    !
  9177. ;      5577    !    DO_PARITY (Message_address, Message_length);
  9178. ;      5578    !
  9179. ;      5579    ! INPUT PARAMETERS:
  9180. ;      5580    !
  9181. ;      5581    !    Message_address - Address of the message to put parity on.
  9182. ;      5582    !    Message_length  - Lengtho of the message.
  9183. ;      5583    !
  9184. ;      5584    ! IMPLICIT INPUTS:
  9185. ;      5585    !
  9186. ;      5586    !    None.
  9187. ;      5587    !
  9188. ;      5588    ! OUTPUT PARAMETERS:
  9189. ;      5589    !
  9190. ;      5590    !    None.
  9191. ;      5591    !
  9192. ;      5592    ! IMPLICIT OUTPUTS:
  9193. ;      5593    !
  9194. ;      5594    !    None.
  9195. ;      5595    !
  9196. ;      5596    ! COMPLETION CODES:
  9197. ;      5597    !
  9198. ;      5598    !    None.
  9199. ;      5599    !
  9200. ;      5600    ! SIDE EFFECTS:
  9201. ;      5601    !
  9202. ;      5602    !    None.
  9203. ;      5603    !
  9204. ;      5604    !--
  9205. ;      5605    
  9206. ;      5606        BEGIN
  9207. ;      5607    
  9208. ;      5608        MAP
  9209. ;      5609        MESSAGE : REF VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)];
  9210. ;      5610    
  9211. ;      5611        LOCAL
  9212. ;      5612        POINTER;                ! Point into the message
  9213. ;      5613    
  9214. ;      5614        IF NOT .DEV_PARITY_FLAG
  9215. ;      5615        THEN
  9216. ;      5616        BEGIN
  9217. ;      5617        POINTER = CH$PTR (.MESSAGE,, CHR_SIZE);
  9218. ;      5618    
  9219. ;      5619        INCR I FROM 1 TO .LENGTH DO
  9220. ;      5620            CH$WCHAR_A (GEN_PARITY (CH$RCHAR (.POINTER)), POINTER);
  9221. ;      5621    
  9222. ;      5622        END;
  9223. ;      5623    
  9224. ;      5624        END;                    ! End of DO_PARITY
  9225.     .NLIST
  9226.     .LIST    BIN,LOC
  9227.     .LIST
  9228.  
  9229.     .SBTTL    DO.PARITY Add parity routine
  9230.     .NLIST
  9231.     .ENABL    LSB
  9232.     .LIST
  9233. ; DO.PARITY
  9234. U.21:    JSR    R1,$SAVE2            ;                    5567
  9235.     BIT    #1,DEV.PARITY.FLAG        ;                    5614
  9236.     BNE    3$
  9237.     MOV    12(SP),R2            ; MESSAGE,POINTER            5617
  9238.     CLR    R1                ; I                    5619
  9239.     BR    2$
  9240. 1$:    CLR    -(SP)                ;                    5620
  9241.     MOVB    (R2),(SP)            ; POINTER,*
  9242.     JSR    PC,U.22
  9243.     MOVB    R0,(R2)+            ; *,POINTER
  9244.     TST    (SP)+
  9245. 2$:    INC    R1                ; I                    5619
  9246.     CMP    R1,10(SP)            ; I,LENGTH
  9247.     BLE    1$
  9248. 3$:    RTS    PC                ;                    5567
  9249. ; Routine Size:  21 words,    Routine Base:  $CODE$ + 21554
  9250. ; Maximum stack depth per invocation:  5 words
  9251.     .NLIST
  9252.     .DSABL    LSB
  9253.     .NLIST    BIN,LOC
  9254.     .LIST
  9255.  
  9256.  
  9257. ;      5625    %SBTTL 'Parity routine'
  9258. ;      5626    
  9259. ;      5627    GLOBAL ROUTINE GEN_PARITY (CHARACTER) =
  9260. ;      5628    
  9261. ;      5629    !++
  9262. ;      5630    ! FUNCTIONAL DESCRIPTION:
  9263. ;      5631    !
  9264. ;      5632    !    This routine will add parity to the character that is supplied.
  9265. ;      5633    !
  9266. ;      5634    ! CALLING SEQUENCE:
  9267. ;      5635    !
  9268. ;      5636    !    CHARACTER = GEN_PARITY(CHARACTER)
  9269. ;      5637    !
  9270. ;      5638    ! INPUT PARAMETERS:
  9271. ;      5639    !
  9272. ;      5640    !    CHARACTER - Produce the parity for this character depending on the
  9273. ;      5641    !        setting of the SET PARITY switch.
  9274. ;      5642    !
  9275. ;      5643    ! IMPLICIT INPUTS:
  9276. ;      5644    !
  9277. ;      5645    !    None.
  9278. ;      5646    !
  9279. ;      5647    ! OUTPUT PARAMETERS:
  9280. ;      5648    !
  9281. ;      5649    !    None.
  9282. ;      5650    !
  9283. ;      5651    ! IMPLICIT OUTPUTS:
  9284. ;      5652    !
  9285. ;      5653    !    None.
  9286. ;      5654    !
  9287. ;      5655    ! COMPLETION CODES:
  9288. ;      5656    !
  9289. ;      5657    !    None.
  9290. ;      5658    !
  9291. ;      5659    ! SIDE EFFECTS:
  9292. ;      5660    !
  9293. ;      5661    !    None.
  9294. ;      5662    !
  9295. ;      5663    !--
  9296. ;      5664    
  9297. ;      5665        BEGIN
  9298. ;      5666    
  9299. ;      5667        LOCAL
  9300. ;      5668        TEMP_CHAR;
  9301. ;      5669    
  9302. ;      5670        IF .IBM_FLAG THEN RETURN .CHARACTER OR %O'200';
  9303. ;      5671    
  9304. ;      5672        CASE .PARITY_TYPE FROM PR_MIN TO PR_MAX OF
  9305. ;      5673        SET
  9306. ;      5674    
  9307. ;      5675        [PR_NONE] :
  9308. ;      5676            RETURN .CHARACTER;
  9309. ;      5677    
  9310. ;      5678        [PR_SPACE] :
  9311. ;      5679            RETURN .CHARACTER AND %O'177';
  9312. ;      5680    
  9313. ;      5681        [PR_MARK] :
  9314. ;      5682            RETURN .CHARACTER OR %O'200';
  9315. ;      5683    
  9316. ;      5684        [PR_ODD] :
  9317. ;      5685            TEMP_CHAR = .CHARACTER AND %O'177' OR %O'200';
  9318. ;      5686    
  9319. ;      5687        [PR_EVEN] :
  9320. ;      5688            TEMP_CHAR = .CHARACTER AND %O'177';
  9321. ;      5689        TES;
  9322. ;      5690    
  9323. ;      5691        TEMP_CHAR = .TEMP_CHAR XOR (.TEMP_CHAR^-4);
  9324. ;      5692        TEMP_CHAR = .TEMP_CHAR XOR (.TEMP_CHAR^-2);
  9325. ;      5693    
  9326. ;      5694        IF .TEMP_CHAR<0, 2> EQL %B'01' OR .TEMP_CHAR<0, 2> EQL %B'10'
  9327. ;      5695        THEN
  9328. ;      5696        RETURN .CHARACTER AND %O'177' OR %O'200'
  9329. ;      5697        ELSE
  9330. ;      5698        RETURN .CHARACTER AND %O'177';
  9331. ;      5699    
  9332. ;      5700        END;                    ! End of GEN_PARITY
  9333.     .NLIST
  9334.     .LIST    BIN,LOC
  9335.     .LIST
  9336.  
  9337.     .SBTTL    GEN.PARITY Parity routine
  9338.     .NLIST
  9339.     .ENABL    LSB
  9340.     .LIST
  9341. GEN.PARITY::
  9342. U.22:    JSR    R1,$SAVE2            ;                    5627
  9343.     BIT    #1,IBM.FLAG            ;                    5670
  9344.     BEQ    1$
  9345.     MOV    10(SP),R0            ; CHARACTER,*
  9346.     BR    9$
  9347. 1$:    MOV    10(SP),R2            ; CHARACTER,*                5676
  9348.     MOV    PARITY.TYPE,R0            ;                    5672
  9349.     ASL    R0
  9350.     ADD    P.AAQ(R0),PC            ; Case dispatch
  9351. 3$:    MOV    R2,R0                ;                    5676
  9352.     RTS    PC
  9353. 4$:    MOV    R2,R0                ;                    5682
  9354.     BR    9$
  9355. 5$:    MOV    R2,R1                ; *,TEMP.CHAR                5685
  9356.     BIC    #177600,R1            ; *,TEMP.CHAR
  9357.     BIS    #200,R1                ; *,TEMP.CHAR
  9358.     BR    7$                ;                    5672
  9359. 6$:    MOV    R2,R1                ; *,TEMP.CHAR                5688
  9360.     BIC    #177600,R1            ; *,TEMP.CHAR
  9361. 7$:    MOV    R1,R0                ; TEMP.CHAR,*                5691
  9362.     ASH    #-4,R0
  9363.     XOR    R0,R1                ; *,TEMP.CHAR
  9364.     MOV    R1,R0                ; TEMP.CHAR,*                5692
  9365.     ASR    R0
  9366.     ASR    R0
  9367.     XOR    R0,R1                ; *,TEMP.CHAR
  9368.     MOV    R1,R0                ; TEMP.CHAR,*                5694
  9369.     BIC    #177774,R0
  9370.     CMP    R0,#1
  9371.     BEQ    8$
  9372.     BIC    #177774,R1
  9373.     CMP    R1,#2
  9374.     BNE    10$
  9375. 8$:    MOV    R2,R0                ;                    5696
  9376.     BIC    #177600,R0
  9377. 9$:    BIS    #200,R0
  9378.     RTS    PC                ;                    5665
  9379. 10$:    MOV    R2,R0
  9380.     BIC    #177600,R0
  9381.     RTS    PC                ;                    5627
  9382. ; Routine Size:  58 words,    Routine Base:  $CODE$ + 21626
  9383. ; Maximum stack depth per invocation:  4 words
  9384.  
  9385.  
  9386.     .PSECT    $PLIT$,  RO ,  D  
  9387.  
  9388. P.AAQ:                        ; CASE Table for GEN.PARITY+0034    5672
  9389. 2$:    .WORD    0                ; [3$]
  9390.     .WORD    4                ; [4$]
  9391.     .WORD    24                ; [6$]
  9392.     .WORD    10                ; [5$]
  9393.     .WORD    114                ; [10$]
  9394.  
  9395.     .NLIST
  9396.     .DSABL    LSB
  9397.     .NLIST    BIN,LOC
  9398.     .LIST
  9399.  
  9400.  
  9401. ;      5701    
  9402. ;      5702    %SBTTL 'Per transfer -- Initialization'
  9403. ;      5703    ROUTINE INIT_XFR : NOVALUE =
  9404. ;      5704    
  9405. ;      5705    !++
  9406. ;      5706    ! FUNCTIONAL DESCRIPTION:
  9407. ;      5707    !
  9408. ;      5708    !    This routine will initialize the various locations that the
  9409. ;      5709    !    send and receive statistics are kept.
  9410. ;      5710    !
  9411. ;      5711    ! CALLING SEQUENCE:
  9412. ;      5712    !
  9413. ;      5713    !    INIT_XFR();
  9414. ;      5714    !
  9415. ;      5715    ! INPUT PARAMETERS:
  9416. ;      5716    !
  9417. ;      5717    !    None.
  9418. ;      5718    !
  9419. ;      5719    ! IMPLICIT INPUTS:
  9420. ;      5720    !
  9421. ;      5721    !    None.
  9422. ;      5722    !
  9423. ;      5723    ! OUTPUT PARAMETERS:
  9424. ;      5724    !
  9425. ;      5725    !    None.
  9426. ;      5726    !
  9427. ;      5727    ! IMPLICIT OUTPUTS:
  9428. ;      5728    !
  9429. ;      5729    !    None.
  9430. ;      5730    !
  9431. ;      5731    ! COMPLETION CODES:
  9432. ;      5732    !
  9433. ;      5733    !    None.
  9434. ;      5734    !
  9435. ;      5735    ! SIDE EFFECTS:
  9436. ;      5736    !
  9437. ;      5737    !    None.
  9438. ;      5738    !
  9439. ;      5739    !--
  9440. ;      5740    
  9441. ;      5741        BEGIN
  9442. ;      5742    !
  9443. ;      5743    ! Determine if we should do 8 bit quoting
  9444. ;      5744    !
  9445. ;      5745    
  9446. ;      5746        IF .PARITY_TYPE NEQ PR_NONE
  9447. ;      5747        THEN
  9448. ;      5748        BEGIN
  9449. ;      5749        RECV_8QUOTE_CHR = .RCV_8QUOTE_CHR;
  9450. ;      5750        END
  9451. ;      5751        ELSE
  9452. ;      5752        BEGIN
  9453. ;      5753        RECV_8QUOTE_CHR = %C'Y';
  9454. ;      5754        END;
  9455. ;      5755    
  9456. ;      5756        NUM_RETRIES = 0;
  9457. ;      5757        SEND_8QUOTE_CHR = .RECV_8QUOTE_CHR;
  9458. ;      5758    !
  9459. ;      5759    ! Send parameters that may not get set before we need them for the first
  9460. ;      5760    ! time.
  9461. ;      5761    !
  9462. ;      5762        SEND_PKT_SIZE = ABS (.SND_PKT_SIZE);
  9463. ;      5763        SEND_NPAD = ABS (.SND_NPAD);
  9464. ;      5764        SEND_PADCHAR = ABS (.SND_PADCHAR);
  9465. ;      5765        SEND_TIMEOUT = ABS (.SND_TIMEOUT);
  9466. ;      5766        SEND_EOL = ABS (.SND_EOL);
  9467. ;      5767        SEND_QUOTE_CHR = ABS (.SND_QUOTE_CHR);
  9468. ;      5768    !
  9469. ;      5769    ! For initialization messages, we must use single character checksum
  9470. ;      5770    ! When the send-init/ack sequence has been done, we will switch to the
  9471. ;      5771    ! desired form
  9472. ;      5772    !
  9473. ;      5773        BLK_CHK_TYPE = CHK_1CHAR;
  9474. ;      5774        INI_CHK_TYPE = .CHKTYPE;            ! Send desired type
  9475. ;      5775    !
  9476. ;      5776    ! Set desired repeat character for use in we are doing send-init
  9477. ;      5777    ! Will be overwritten by other ends desired character if it sends
  9478. ;      5778    ! the send-init.
  9479. ;      5779    !
  9480. ;      5780        REPT_CHR = .SET_REPT_CHR;
  9481. ;      5781    !
  9482. ;      5782    ! Assume packet assembly/disassembly uses characters from a file
  9483. ;      5783    !
  9484. ;      5784        GET_CHR_ROUTINE = GET_FILE;            ! Initialize the get-a-char routine
  9485. ;      5785        PUT_CHR_ROUTINE = PUT_FILE;            ! And the put-a-char
  9486. ;      5786        TEXT_HEAD_FLAG = FALSE;            ! And assume we will get an File header
  9487. ;      5787        NO_FILE_NEEDED = FALSE;            ! Assume will do file ops
  9488. ;      5788        INIT_PKT_SENT = FALSE;            ! And no server-init sent
  9489. ;      5789    !
  9490. ;      5790    ! Always start with packet number 0
  9491. ;      5791    !
  9492. ;      5792        MSG_NUMBER = 0;                ! Initial message number
  9493. ;      5793    !
  9494. ;      5794    ! Stats information
  9495. ;      5795    !
  9496. ;      5796        SMSG_TOTAL_CHARS = 0;
  9497. ;      5797        RMSG_TOTAL_CHARS = 0;
  9498. ;      5798        SMSG_DATA_CHARS = 0;
  9499. ;      5799        RMSG_DATA_CHARS = 0;
  9500. ;      5800        SMSG_COUNT = 0;
  9501. ;      5801        RMSG_COUNT = 0;
  9502. ;      5802        RMSG_NAKS = 0;
  9503. ;      5803        SMSG_NAKS = 0;
  9504. ;      5804        XFR_TIME = SY_TIME ();
  9505. ;      5805        END;                    ! End of INIT_XFR
  9506.     .NLIST
  9507.     .LIST    BIN,LOC
  9508.     .LIST
  9509.  
  9510.     .SBTTL    INIT.XFR Per transfer -- Initialization
  9511.     .PSECT    $CODE$,  RO 
  9512.  
  9513.     .NLIST
  9514.     .ENABL    LSB
  9515.     .LIST
  9516. ; INIT.XFR
  9517. U.31:    TST    PARITY.TYPE            ;                    5746
  9518.     BEQ    1$
  9519.     MOV    RCV.8QUOTE.CHR,U.62        ;                    5749
  9520.     BR    2$                ;                    5746
  9521. 1$:    MOV    #131,U.62            ;                    5753
  9522. 2$:    CLR    U.77                ;                    5756
  9523.     MOV    U.62,U.69            ;                    5757
  9524.     MOV    SND.PKT.SIZE,-(SP)        ;                    5762
  9525.     JSR    PC,BL$ABS
  9526.     MOV    R0,U.64
  9527.     MOV    SND.NPAD,(SP)            ;                    5763
  9528.     JSR    PC,BL$ABS
  9529.     MOV    R0,U.65
  9530.     MOV    SND.PADCHAR,(SP)        ;                    5764
  9531.     JSR    PC,BL$ABS
  9532.     MOV    R0,U.66
  9533.     MOV    SND.TIMEOUT,(SP)        ;                    5765
  9534.     JSR    PC,BL$ABS
  9535.     MOV    R0,SEND.TIMEOUT
  9536.     MOV    SND.EOL,(SP)            ;                    5766
  9537.     JSR    PC,BL$ABS
  9538.     MOV    R0,U.67
  9539.     MOV    SND.QUOTE.CHR,(SP)        ;                    5767
  9540.     JSR    PC,BL$ABS
  9541.     MOV    R0,U.68
  9542.     MOV    #61,U.71            ;                    5773
  9543.     MOV    CHKTYPE,U.70            ;                    5774
  9544.     MOV    SET.REPT.CHR,U.63        ;                    5780
  9545.     MOV    #GET.FILE,U.91            ;                    5784
  9546.     MOV    #PUT.FILE,U.92            ;                    5785
  9547.     CLR    U.86                ;                    5786
  9548.     CLR    U.87                ;                    5787
  9549.     CLR    U.88                ;                    5788
  9550.     CLR    U.78                ;                    5792
  9551.     CLR    SMSG.TOTAL.CHARS        ;                    5796
  9552.     CLR    RMSG.TOTAL.CHARS        ;                    5797
  9553.     CLR    SMSG.DATA.CHARS            ;                    5798
  9554.     CLR    RMSG.DATA.CHARS            ;                    5799
  9555.     CLR    SMSG.COUNT            ;                    5800
  9556.     CLR    RMSG.COUNT            ;                    5801
  9557.     CLR    RMSG.NAKS            ;                    5802
  9558.     CLR    SMSG.NAKS            ;                    5803
  9559.     JSR    PC,SY.TIME            ;                    5804
  9560.     MOV    R0,XFR.TIME
  9561.     TST    (SP)+                ;                    5741
  9562.     RTS    PC                ;                    5703
  9563. ; Routine Size:  96 words,    Routine Base:  $CODE$ + 22012
  9564. ; Maximum stack depth per invocation:  2 words
  9565.     .NLIST
  9566.     .DSABL    LSB
  9567.     .NLIST    BIN,LOC
  9568.     .LIST
  9569.  
  9570.  
  9571. ;      5806    %SBTTL 'Statistics -- Finish message transfer'
  9572. ;      5807    ROUTINE END_STATS : NOVALUE =
  9573. ;      5808    
  9574. ;      5809    !++
  9575. ;      5810    ! FUNCTIONAL DESCRIPTION:
  9576. ;      5811    !
  9577. ;      5812    !    This routine will end the collection of the statistices.  It will
  9578. ;      5813    !    update the various overall statistic parameters.
  9579. ;      5814    !
  9580. ;      5815    ! CALLING SEQUENCE:
  9581. ;      5816    !
  9582. ;      5817    !    END_STATS ();
  9583. ;      5818    !
  9584. ;      5819    ! INPUT PARAMETERS:
  9585. ;      5820    !
  9586. ;      5821    !    None.
  9587. ;      5822    !
  9588. ;      5823    ! IMPLICIT INPUTS:
  9589. ;      5824    !
  9590. ;      5825    !    None.
  9591. ;      5826    !
  9592. ;      5827    ! OUTPUT PARAMETERS:
  9593. ;      5828    !
  9594. ;      5829    !    None.
  9595. ;      5830    !
  9596. ;      5831    ! IMPLICIT OUTPUTS:
  9597. ;      5832    !
  9598. ;      5833    !    None.
  9599. ;      5834    !
  9600. ;      5835    ! COMPLETION CODES:
  9601. ;      5836    !
  9602. ;      5837    !    None.
  9603. ;      5838    !
  9604. ;      5839    ! SIDE EFFECTS:
  9605. ;      5840    !
  9606. ;      5841    !    None.
  9607. ;      5842    !
  9608. ;      5843    !--
  9609. ;      5844    
  9610. ;      5845        BEGIN
  9611. ;      5846        SND_COUNT = .SND_COUNT + .SMSG_COUNT;
  9612. ;      5847        RCV_COUNT = .RCV_COUNT + .RMSG_COUNT;
  9613. ;      5848        SND_TOTAL_CHARS = .SND_TOTAL_CHARS + .SMSG_TOTAL_CHARS;
  9614. ;      5849        SND_DATA_CHARS = .SND_DATA_CHARS + .SMSG_DATA_CHARS;
  9615. ;      5850        RCV_TOTAL_CHARS = .RCV_TOTAL_CHARS + .RMSG_TOTAL_CHARS;
  9616. ;      5851        RCV_DATA_CHARS = .RCV_DATA_CHARS + .RMSG_DATA_CHARS;
  9617. ;      5852        SND_NAKS = .SND_NAKS + .SMSG_NAKS;
  9618. ;      5853        RCV_NAKS = .RCV_NAKS + .RMSG_NAKS;
  9619. ;      5854        XFR_TIME = SY_TIME () - .XFR_TIME;
  9620. ;      5855        TOTAL_TIME = .TOTAL_TIME + .XFR_TIME;
  9621. ;      5856        END;                    ! End of END_STATS
  9622.     .NLIST
  9623.     .LIST    BIN,LOC
  9624.     .LIST
  9625.  
  9626.     .SBTTL    END.STATS Statistics -- Finish message transfer
  9627.     .NLIST
  9628.     .ENABL    LSB
  9629.     .LIST
  9630. ; END.STATS
  9631. U.17:    ADD    SMSG.COUNT,SND.COUNT        ;                    5846
  9632.     ADD    RMSG.COUNT,RCV.COUNT        ;                    5847
  9633.     ADD    SMSG.TOTAL.CHARS,SND.TOTAL.CHARS;                    5848
  9634.     ADD    SMSG.DATA.CHARS,SND.DATA.CHARS    ;                    5849
  9635.     ADD    RMSG.TOTAL.CHARS,RCV.TOTAL.CHARS;                    5850
  9636.     ADD    RMSG.DATA.CHARS,RCV.DATA.CHARS    ;                    5851
  9637.     ADD    SMSG.NAKS,SND.NAKS        ;                    5852
  9638.     ADD    RMSG.NAKS,RCV.NAKS        ;                    5853
  9639.     JSR    PC,SY.TIME            ;                    5854
  9640.     SUB    XFR.TIME,R0
  9641.     MOV    R0,XFR.TIME
  9642.     ADD    R0,TOTAL.TIME            ; XFR.TIME,*                5855
  9643.     RTS    PC                ;                    5807
  9644. ; Routine Size:  33 words,    Routine Base:  $CODE$ + 22312
  9645. ; Maximum stack depth per invocation:  1 word
  9646.     .NLIST
  9647.     .DSABL    LSB
  9648.     .NLIST    BIN,LOC
  9649.     .LIST
  9650.  
  9651.  
  9652. ;      5857    %SBTTL 'Status type out -- STS_OUTPUT'
  9653. ;      5858    ROUTINE STS_OUTPUT : NOVALUE =
  9654. ;      5859    
  9655. ;      5860    !++
  9656. ;      5861    ! FUNCTIONAL DESCRIPTION:
  9657. ;      5862    !
  9658. ;      5863    !    This routine will output the current status of a transfer.
  9659. ;      5864    !    This is used when the user types a ^A during a transfer.
  9660. ;      5865    !
  9661. ;      5866    ! CALLING SEQUENCE:
  9662. ;      5867    !
  9663. ;      5868    !    STS_OUTPUT ()
  9664. ;      5869    !
  9665. ;      5870    ! INPUT PARAMETERS:
  9666. ;      5871    !
  9667. ;      5872    !    None.
  9668. ;      5873    !
  9669. ;      5874    ! IMPLICIT INPUTS:
  9670. ;      5875    !
  9671. ;      5876    !    Statistics blocks, file names, etc.
  9672. ;      5877    !
  9673. ;      5878    ! OUPTUT PARAMETERS:
  9674. ;      5879    !
  9675. ;      5880    !    None.
  9676. ;      5881    !
  9677. ;      5882    ! IMPLICIT OUTPUTS:
  9678. ;      5883    !
  9679. ;      5884    !    None.
  9680. ;      5885    !
  9681. ;      5886    ! COMPLETION CODES:
  9682. ;      5887    !
  9683. ;      5888    !    None.
  9684. ;      5889    !
  9685. ;      5890    ! SIDE EFFECTS:
  9686. ;      5891    !
  9687. ;      5892    !    None.
  9688. ;      5893    !
  9689. ;      5894    !--
  9690. ;      5895    
  9691. ;      5896        BEGIN
  9692. ;      5897        TT_CHAR (%C'[');                ! Start the message
  9693. ;      5898    
  9694. ;      5899        CASE .STATE FROM STATE_MIN TO STATE_MAX OF
  9695. ;      5900        SET
  9696. ;      5901    
  9697. ;      5902        [STATE_ID, STATE_II] :
  9698. ;      5903            TT_TEXT (UPLIT (%ASCIZ'Idle in server mode'));
  9699. ;      5904    
  9700. ;      5905        [STATE_S, STATE_SF] :
  9701. ;      5906            BEGIN
  9702. ;      5907            TT_TEXT (UPLIT (%ASCIZ'Initializing for sending file '));
  9703. ;      5908            TT_TEXT (FILE_NAME);
  9704. ;      5909            END;
  9705. ;      5910    
  9706. ;      5911        [STATE_SI] :
  9707. ;      5912            TT_TEXT (UPLIT (%ASCIZ'Initializing for remote command'));
  9708. ;      5913    
  9709. ;      5914        [STATE_SG] :
  9710. ;      5915            TT_TEXT (UPLIT (%ASCIZ'Waiting for response to remote command'));
  9711. ;      5916    
  9712. ;      5917        [STATE_SD] :
  9713. ;      5918            BEGIN
  9714. ;      5919            TT_NUMBER (.FILE_CHARS);
  9715. ;      5920            TT_TEXT (UPLIT (%ASCIZ' characters sent for file '));
  9716. ;      5921            TT_TEXT (FILE_NAME);
  9717. ;      5922            END;
  9718. ;      5923    
  9719. ;      5924        [STATE_SZ] :
  9720. ;      5925            BEGIN
  9721. ;      5926            TT_TEXT (UPLIT (%ASCIZ'At end of file '));
  9722. ;      5927            TT_TEXT (FILE_NAME);
  9723. ;      5928            END;
  9724. ;      5929    
  9725. ;      5930        [STATE_SB] :
  9726. ;      5931            TT_TEXT (UPLIT (%ASCIZ'Finishing transfer session'));
  9727. ;      5932    
  9728. ;      5933        [STATE_R] :
  9729. ;      5934            TT_TEXT (UPLIT (%ASCIZ'Waiting for initialization'));
  9730. ;      5935    
  9731. ;      5936        [STATE_RF] :
  9732. ;      5937            TT_TEXT (UPLIT (%ASCIZ'Waiting for next file or end of session'));
  9733. ;      5938    
  9734. ;      5939        [STATE_RD] :
  9735. ;      5940            BEGIN
  9736. ;      5941            TT_NUMBER (.FILE_CHARS);
  9737. ;      5942            TT_TEXT (UPLIT (%ASCIZ' characters received for file '));
  9738. ;      5943            TT_TEXT (FILE_NAME);
  9739. ;      5944            END;
  9740. ;      5945    
  9741. ;      5946        [STATE_C] :
  9742. ;      5947            TT_TEXT (UPLIT (%ASCIZ' Session complete'));
  9743. ;      5948    
  9744. ;      5949        [STATE_A] :
  9745. ;      5950            TT_TEXT (UPLIT (%ASCIZ' Session aborted'));
  9746. ;      5951    
  9747. ;      5952        [INRANGE, OUTRANGE] :
  9748. ;      5953            TT_TEXT (UPLIT (%ASCIZ' Unknown state'));
  9749. ;      5954        TES;
  9750. ;      5955    
  9751. ;      5956        SELECTONE .STATE OF
  9752. ;      5957        SET
  9753. ;      5958    
  9754. ;      5959        [STATE_S, STATE_SF, STATE_SD, STATE_SZ, STATE_SB] :
  9755. ;      5960            BEGIN
  9756. ;      5961    
  9757. ;      5962            IF .RMSG_NAKS GTR 0
  9758. ;      5963            THEN
  9759. ;      5964            BEGIN
  9760. ;      5965            TT_TEXT (UPLIT (%ASCIZ', '));
  9761. ;      5966            TT_NUMBER (.RMSG_NAKS);
  9762. ;      5967            TT_TEXT (UPLIT (%ASCIZ' NAKs received'));
  9763. ;      5968            END;
  9764. ;      5969    
  9765. ;      5970            END;
  9766. ;      5971    
  9767. ;      5972        [STATE_R, STATE_RF, STATE_RD] :
  9768. ;      5973            BEGIN
  9769. ;      5974    
  9770. ;      5975            IF .SMSG_NAKS GTR 0
  9771. ;      5976            THEN
  9772. ;      5977            BEGIN
  9773. ;      5978            TT_TEXT (UPLIT (%ASCIZ', '));
  9774. ;      5979            TT_NUMBER (.SMSG_NAKS);
  9775. ;      5980            TT_TEXT (UPLIT (%ASCIZ' NAKs sent'));
  9776. ;      5981            END;
  9777. ;      5982    
  9778. ;      5983            END;
  9779. ;      5984        TES;
  9780. ;      5985    
  9781. ;      5986        TT_CHAR (%C']');                ! End the line
  9782. ;      5987        TT_CRLF ();                    ! with a CRLF
  9783. ;      5988        END;                    ! End of STS_OUTPUT
  9784.     .NLIST
  9785.     .LIST    BIN,LOC
  9786.     .LIST
  9787.  
  9788.  
  9789.     .PSECT    $PLIT$,  RO ,  D  
  9790. P.AAS:    .ASCII    /Idl/
  9791.     .ASCII    /e i/
  9792.     .ASCII    /n s/
  9793.     .ASCII    /erv/
  9794.     .ASCII    /er /
  9795.     .ASCII    /mod/
  9796.     .ASCII    /e/<00>
  9797. P.AAT:    .ASCII    /Ini/
  9798.     .ASCII    /tia/
  9799.     .ASCII    /liz/
  9800.     .ASCII    /ing/
  9801.     .ASCII    / fo/
  9802.     .ASCII    /r s/
  9803.     .ASCII    /end/
  9804.     .ASCII    /ing/
  9805.     .ASCII    / fi/
  9806.     .ASCII    /le /
  9807.     .ASCII    <00><00>
  9808. P.AAU:    .ASCII    /Ini/
  9809.     .ASCII    /tia/
  9810.     .ASCII    /liz/
  9811.     .ASCII    /ing/
  9812.     .ASCII    / fo/
  9813.     .ASCII    /r r/
  9814.     .ASCII    /emo/
  9815.     .ASCII    /te /
  9816.     .ASCII    /com/
  9817.     .ASCII    /man/
  9818.     .ASCII    /d/<00>
  9819. P.AAV:    .ASCII    /Wai/
  9820.     .ASCII    /tin/
  9821.     .ASCII    /g f/
  9822.     .ASCII    /or /
  9823.     .ASCII    /res/
  9824.     .ASCII    /pon/
  9825.     .ASCII    /se /
  9826.     .ASCII    /to /
  9827.     .ASCII    /rem/
  9828.     .ASCII    /ote/
  9829.     .ASCII    / co/
  9830.     .ASCII    /mma/
  9831.     .ASCII    /nd/<00>
  9832.     .ASCII    <00>
  9833. P.AAW:    .ASCII    / ch/
  9834.     .ASCII    /ara/
  9835.     .ASCII    /cte/
  9836.     .ASCII    /rs /
  9837.     .ASCII    /sen/
  9838.     .ASCII    /t f/
  9839.     .ASCII    /or /
  9840.     .ASCII    /fil/
  9841.     .ASCII    /e /<00>
  9842.     .ASCII    <00>
  9843. P.AAX:    .ASCII    /At /
  9844.     .ASCII    /end/
  9845.     .ASCII    / of/
  9846.     .ASCII    / fi/
  9847.     .ASCII    /le /
  9848.     .ASCII    <00>
  9849. P.AAY:    .ASCII    /Fin/
  9850.     .ASCII    /ish/
  9851.     .ASCII    /ing/
  9852.     .ASCII    / tr/
  9853.     .ASCII    /ans/
  9854.     .ASCII    /fer/
  9855.     .ASCII    / se/
  9856.     .ASCII    /ssi/
  9857.     .ASCII    /on/<00>
  9858.     .ASCII    <00>
  9859. P.AAZ:    .ASCII    /Wai/
  9860.     .ASCII    /tin/
  9861.     .ASCII    /g f/
  9862.     .ASCII    /or /
  9863.     .ASCII    /ini/
  9864.     .ASCII    /tia/
  9865.     .ASCII    /liz/
  9866.     .ASCII    /ati/
  9867.     .ASCII    /on/<00>
  9868.     .ASCII    <00>
  9869. P.ABA:    .ASCII    /Wai/
  9870.     .ASCII    /tin/
  9871.     .ASCII    /g f/
  9872.     .ASCII    /or /
  9873.     .ASCII    /nex/
  9874.     .ASCII    /t f/
  9875.     .ASCII    /ile/
  9876.     .ASCII    / or/
  9877.     .ASCII    / en/
  9878.     .ASCII    /d o/
  9879.     .ASCII    /f s/
  9880.     .ASCII    /ess/
  9881.     .ASCII    /ion/
  9882.     .ASCII    <00>
  9883. P.ABB:    .ASCII    / ch/
  9884.     .ASCII    /ara/
  9885.     .ASCII    /cte/
  9886.     .ASCII    /rs /
  9887.     .ASCII    /rec/
  9888.     .ASCII    /eiv/
  9889.     .ASCII    /ed /
  9890.     .ASCII    /for/
  9891.     .ASCII    / fi/
  9892.     .ASCII    /le /
  9893.     .ASCII    <00><00>
  9894. P.ABC:    .ASCII    / Se/
  9895.     .ASCII    /ssi/
  9896.     .ASCII    /on /
  9897.     .ASCII    /com/
  9898.     .ASCII    /ple/
  9899.     .ASCII    /te/<00>
  9900. P.ABD:    .ASCII    / Se/
  9901.     .ASCII    /ssi/
  9902.     .ASCII    /on /
  9903.     .ASCII    /abo/
  9904.     .ASCII    /rte/
  9905.     .ASCII    /d/<00><00>
  9906. P.ABE:    .ASCII    / Un/
  9907.     .ASCII    /kno/
  9908.     .ASCII    /wn /
  9909.     .ASCII    /sta/
  9910.     .ASCII    /te/<00>
  9911.     .ASCII    <00>
  9912. P.ABF:    .ASCII    /, /<00>
  9913.     .ASCII    <00>
  9914. P.ABG:    .ASCII    / NA/
  9915.     .ASCII    /Ks /
  9916.     .ASCII    /rec/
  9917.     .ASCII    /eiv/
  9918.     .ASCII    /ed/<00>
  9919.     .ASCII    <00>
  9920. P.ABH:    .ASCII    /, /<00>
  9921.     .ASCII    <00>
  9922. P.ABI:    .ASCII    / NA/
  9923.     .ASCII    /Ks /
  9924.     .ASCII    /sen/
  9925.     .ASCII    /t/<00><00>
  9926.  
  9927.  
  9928.     .SBTTL    STS.OUTPUT Status type out -- STS_OUTPUT
  9929.     .PSECT    $CODE$,  RO 
  9930.  
  9931.     .NLIST
  9932.     .ENABL    LSB
  9933.     .LIST
  9934. ; STS.OUTPUT
  9935. U.32:    MOV    #133,-(SP)            ;                    5897
  9936.     JSR    PC,TT.CHAR
  9937.     MOV    U.74,R0                ;                    5899
  9938.     DEC    R0
  9939.     CMP    R0,#22
  9940.     BHI    2$
  9941.     ASL    R0
  9942.     ADD    P.AAR(R0),PC            ; Case dispatch
  9943. 2$:    MOV    #P.ABE,(SP)            ;                    5953
  9944.     BR    16$
  9945. 3$:    MOV    #P.AAS,(SP)            ;                    5903
  9946.     BR    16$
  9947. 4$:    MOV    #P.AAT,(SP)            ;                    5907
  9948. 5$:    JSR    PC,TT.TEXT
  9949.     MOV    #FILE.NAME,(SP)            ;                    5908
  9950.     BR    16$
  9951. 6$:    MOV    #P.AAU,(SP)            ;                    5912
  9952.     BR    16$
  9953. 7$:    MOV    #P.AAV,(SP)            ;                    5915
  9954.     BR    16$
  9955. 8$:    MOV    U.85,(SP)            ;                    5919
  9956.     JSR    PC,TT.NUMBER
  9957.     MOV    #P.AAW,(SP)            ;                    5920
  9958.     BR    5$
  9959. 9$:    MOV    #P.AAX,(SP)            ;                    5926
  9960.     BR    5$
  9961. 10$:    MOV    #P.AAY,(SP)            ;                    5931
  9962.     BR    16$
  9963. 11$:    MOV    #P.AAZ,(SP)            ;                    5934
  9964.     BR    16$
  9965. 12$:    MOV    #P.ABA,(SP)            ;                    5937
  9966.     BR    16$
  9967. 13$:    MOV    U.85,(SP)            ;                    5941
  9968.     JSR    PC,TT.NUMBER
  9969.     MOV    #P.ABB,(SP)            ;                    5942
  9970.     BR    5$
  9971. 14$:    MOV    #P.ABC,(SP)            ;                    5947
  9972.     BR    16$
  9973. 15$:    MOV    #P.ABD,(SP)            ;                    5950
  9974. 16$:    JSR    PC,TT.TEXT
  9975.     MOV    U.74,R0                ;                    5956
  9976.     BLE    17$
  9977.     CMP    R0,#5
  9978.     BGT    17$
  9979.     TST    RMSG.NAKS            ;                    5962
  9980.     BLE    19$
  9981.     MOV    #P.ABF,(SP)            ;                    5965
  9982.     JSR    PC,TT.TEXT
  9983.     MOV    RMSG.NAKS,(SP)            ;                    5966
  9984.     JSR    PC,TT.NUMBER
  9985.     MOV    #P.ABG,(SP)            ;                    5967
  9986.     BR    18$
  9987. 17$:    CMP    R0,#6                ;                    5956
  9988.     BLT    19$
  9989.     CMP    R0,#10
  9990.     BGT    19$
  9991.     TST    SMSG.NAKS            ;                    5975
  9992.     BLE    19$
  9993.     MOV    #P.ABH,(SP)            ;                    5978
  9994.     JSR    PC,TT.TEXT
  9995.     MOV    SMSG.NAKS,(SP)            ;                    5979
  9996.     JSR    PC,TT.NUMBER
  9997.     MOV    #P.ABI,(SP)            ;                    5980
  9998. 18$:    JSR    PC,TT.TEXT
  9999. 19$:    MOV    #135,(SP)            ;                    5986
  10000.     JSR    PC,TT.CHAR
  10001.     JSR    PC,TT.CRLF            ;                    5987
  10002.     TST    (SP)+                ;                    5896
  10003.     RTS    PC                ;                    5858
  10004. ; Routine Size:  114 words,    Routine Base:  $CODE$ + 22414
  10005. ; Maximum stack depth per invocation:  2 words
  10006.  
  10007.  
  10008.     .PSECT    $PLIT$,  RO ,  D  
  10009.  
  10010. P.AAR:                        ; CASE Table for STS.OUTPUT+0026    5899
  10011. 1$:    .WORD    14                ; [4$]
  10012.     .WORD    14                ; [4$]
  10013.     .WORD    46                ; [8$]
  10014.     .WORD    64                ; [9$]
  10015.     .WORD    72                ; [10$]
  10016.     .WORD    100                ; [11$]
  10017.     .WORD    106                ; [12$]
  10018.     .WORD    114                ; [13$]
  10019.     .WORD    132                ; [14$]
  10020.     .WORD    140                ; [15$]
  10021.     .WORD    0                ; [2$]
  10022.     .WORD    40                ; [7$]
  10023.     .WORD    32                ; [6$]
  10024.     .WORD    6                ; [3$]
  10025.     .WORD    6                ; [3$]
  10026.     .WORD    0                ; [2$]
  10027.     .WORD    0                ; [2$]
  10028.     .WORD    0                ; [2$]
  10029.     .WORD    0                ; [2$]
  10030.  
  10031.     .NLIST
  10032.     .DSABL    LSB
  10033.     .NLIST    BIN,LOC
  10034.     .LIST
  10035.  
  10036.  
  10037. ;      5989    %SBTTL 'TYPE_CHAR - Type out a character'
  10038. ;      5990    ROUTINE TYPE_CHAR (CHARACTER) =
  10039. ;      5991    
  10040. ;      5992    !++
  10041. ;      5993    ! FUNCTIONAL DESCRIPTION:
  10042. ;      5994    !
  10043. ;      5995    ! This routine is used as an alternate output routine for BFR_EMPTY.
  10044. ;      5996    ! It will type the character on the terminal, and always return a
  10045. ;      5997    ! true status.
  10046. ;      5998    !
  10047. ;      5999    ! CALLING SEQUENCE:
  10048. ;      6000    !
  10049. ;      6001    !    STATUS = TYPE_CHAR (.CHARACTER);
  10050. ;      6002    !
  10051. ;      6003    ! INPUT PARAMETERS:
  10052. ;      6004    !
  10053. ;      6005    !    CHARACTER - The character to type
  10054. ;      6006    !
  10055. ;      6007    ! IMPLICIT INPUTS:
  10056. ;      6008    !
  10057. ;      6009    !    None.
  10058. ;      6010    !
  10059. ;      6011    ! OUPTUT PARAMETERS:
  10060. ;      6012    !
  10061. ;      6013    !    None.
  10062. ;      6014    !
  10063. ;      6015    ! IMPLICIT OUTPUTS:
  10064. ;      6016    !
  10065. ;      6017    !    None.
  10066. ;      6018    !
  10067. ;      6019    ! COMPLETION CODES:
  10068. ;      6020    !
  10069. ;      6021    !    None.
  10070. ;      6022    !
  10071. ;      6023    ! SIDE EFFECTS:
  10072. ;      6024    !
  10073. ;      6025    !    None.
  10074. ;      6026    !
  10075. ;      6027    !--
  10076. ;      6028    
  10077. ;      6029        BEGIN
  10078. ;      6030        TT_CHAR (.CHARACTER);            ! Type the character
  10079. ;      6031        RETURN KER_NORMAL;                ! And return OK
  10080. ;      6032        END;                    ! End of TYPE_CHAR
  10081.     .NLIST
  10082.     .LIST    BIN,LOC
  10083.     .LIST
  10084.  
  10085.     .SBTTL    TYPE.CHAR TYPE_CHAR - Type out a character
  10086.     .PSECT    $CODE$,  RO 
  10087.  
  10088.     .NLIST
  10089.     .ENABL    LSB
  10090.     .LIST
  10091. ; TYPE.CHAR
  10092. U.30:    MOV    2(SP),-(SP)            ; CHARACTER,*                6030
  10093.     JSR    PC,TT.CHAR
  10094.     TST    (SP)+                ;                    5990
  10095.     MOV    #1,R0                ;                    6029
  10096.     RTS    PC                ;                    5990
  10097. ; Routine Size:  8 words,    Routine Base:  $CODE$ + 22760
  10098. ; Maximum stack depth per invocation:  2 words
  10099.     .NLIST
  10100.     .DSABL    LSB
  10101.     .NLIST    BIN,LOC
  10102.     .LIST
  10103.  
  10104.  
  10105. ;      6033    %SBTTL 'Debugging -- DBG_SEND'
  10106. ;      6034    ROUTINE DBG_SEND (ADDRESS, LENGTH) : NOVALUE =
  10107. ;      6035    
  10108. ;      6036    !++
  10109. ;      6037    ! FUNCTIONAL DESCRIPTION:
  10110. ;      6038    !
  10111. ;      6039    !    This routine will output the message that is going to be sent
  10112. ;      6040    !    as part of the debugging information that is turned on in the
  10113. ;      6041    !    SET DEBUG command.
  10114. ;      6042    !
  10115. ;      6043    ! CALLING SEQUENCE:
  10116. ;      6044    !
  10117. ;      6045    !    DBG_SEND(MSG_ADDRESS, MSG_LENGTH);
  10118. ;      6046    !
  10119. ;      6047    ! INPUT PARAMETERS:
  10120. ;      6048    !
  10121. ;      6049    !    MSG_ADDRESS - Address of the message that is going to be sent
  10122. ;      6050    !        to the remote KERMIT.  The bytes are CHR_SIZE.
  10123. ;      6051    !    MSG_LENGTH - Length of the message.
  10124. ;      6052    !
  10125. ;      6053    ! IMPLICIT INPUTS:
  10126. ;      6054    !
  10127. ;      6055    !    None.
  10128. ;      6056    !
  10129. ;      6057    ! OUTPUT PARAMETERS:
  10130. ;      6058    !
  10131. ;      6059    !    None.
  10132. ;      6060    !
  10133. ;      6061    ! IMPLICIT OUTPUTS:
  10134. ;      6062    !
  10135. ;      6063    !    None.
  10136. ;      6064    !
  10137. ;      6065    ! COMPLETION CODES:
  10138. ;      6066    !
  10139. ;      6067    !    None.
  10140. ;      6068    !
  10141. ;      6069    ! SIDE EFFECTS:
  10142. ;      6070    !
  10143. ;      6071    !    None.
  10144. ;      6072    !
  10145. ;      6073    !--
  10146. ;      6074    
  10147. ;      6075        BEGIN
  10148. ;      6076    
  10149. ;      6077        BIND
  10150. ;      6078        SEND_TEXT = UPLIT (%ASCIZ'Sending...');
  10151. ;      6079    
  10152. ;      6080        IF .DEBUG_FLAG
  10153. ;      6081        THEN
  10154. ;      6082        BEGIN
  10155. ;      6083    
  10156. ;      6084        LOCAL
  10157. ;      6085            OLD_RTN;
  10158. ;      6086    
  10159. ;      6087        OLD_RTN = TT_SET_OUTPUT (DBG_DUMP);
  10160. ;      6088        TT_TEXT (SEND_TEXT);
  10161. ;      6089        DBG_MESSAGE (.ADDRESS, .LENGTH);
  10162. ;      6090        TT_SET_OUTPUT (.OLD_RTN);
  10163. ;      6091        END;
  10164. ;      6092    
  10165. ;      6093        END;                    ! End of DBG_SEND
  10166.     .NLIST
  10167.     .LIST    BIN,LOC
  10168.     .LIST
  10169.  
  10170.  
  10171.     .PSECT    $PLIT$,  RO ,  D  
  10172. P.ABJ:    .ASCII    /Sen/
  10173.     .ASCII    /din/
  10174.     .ASCII    /g../
  10175.     .ASCII    /./<00><00>
  10176.  
  10177.  
  10178. ; SEND.TEXT
  10179. U.125=            P.ABJ
  10180.  
  10181.  
  10182.     .SBTTL    DBG.SEND Debugging -- DBG_SEND
  10183.     .PSECT    $CODE$,  RO 
  10184.  
  10185.     .NLIST
  10186.     .ENABL    LSB
  10187.     .LIST
  10188. ; DBG.SEND
  10189. U.34:    MOV    R1,-(SP)            ;                    6034
  10190.     BIT    #1,DEBUG.FLAG            ;                    6080
  10191.     BEQ    1$
  10192.     MOV    #DBG.DUMP,-(SP)            ;                    6087
  10193.     JSR    PC,TT.SET.OUTPUT
  10194.     MOV    R0,R1                ; *,OLD.RTN
  10195.     MOV    #U.125,(SP)            ;                    6088
  10196.     JSR    PC,TT.TEXT
  10197.     MOV    10(SP),(SP)            ; ADDRESS,*                6089
  10198.     MOV    6(SP),-(SP)            ; LENGTH,*
  10199.     JSR    PC,U.33
  10200.     MOV    R1,(SP)                ; OLD.RTN,*                6090
  10201.     JSR    PC,TT.SET.OUTPUT
  10202.     CMP    (SP)+,(SP)+            ;                    6082
  10203. 1$:    MOV    (SP)+,R1            ;                    6034
  10204.     RTS    PC
  10205. ; Routine Size:  26 words,    Routine Base:  $CODE$ + 23000
  10206. ; Maximum stack depth per invocation:  4 words
  10207.     .NLIST
  10208.     .DSABL    LSB
  10209.     .NLIST    BIN,LOC
  10210.     .LIST
  10211.  
  10212.  
  10213. ;      6094    %SBTTL 'Debugging -- DBG_RECEIVE'
  10214. ;      6095    ROUTINE DBG_RECEIVE (ADDRESS) : NOVALUE =
  10215. ;      6096    
  10216. ;      6097    !++
  10217. ;      6098    ! FUNCTIONAL DESCRIPTION:
  10218. ;      6099    !
  10219. ;      6100    !    This routine will output the message that was received from
  10220. ;      6101    !    the remote KERMIT.  This routine is called only if the DEBUG_FLAG
  10221. ;      6102    !    is true.
  10222. ;      6103    !
  10223. ;      6104    ! CALLING SEQUENCE:
  10224. ;      6105    !
  10225. ;      6106    !    DBG_RECEIVE(MSG_ADDRESS);
  10226. ;      6107    !
  10227. ;      6108    ! INPUT PARAMETERS:
  10228. ;      6109    !
  10229. ;      6110    !    MSG_ADDRESS - Address of the message received by the remote KERMIT.
  10230. ;      6111    !
  10231. ;      6112    ! IMPLICIT INPUTS:
  10232. ;      6113    !
  10233. ;      6114    !    None.
  10234. ;      6115    !
  10235. ;      6116    ! OUTPUT PARAMETERS:
  10236. ;      6117    !
  10237. ;      6118    !    None.
  10238. ;      6119    !
  10239. ;      6120    ! IMPLICIT OUTPUTS:
  10240. ;      6121    !
  10241. ;      6122    !    None.
  10242. ;      6123    !
  10243. ;      6124    ! COMPLETION CODES:
  10244. ;      6125    !
  10245. ;      6126    !    None.
  10246. ;      6127    !
  10247. ;      6128    ! SIDE EFFECTS:
  10248. ;      6129    !
  10249. ;      6130    !    None.
  10250. ;      6131    !
  10251. ;      6132    !--
  10252. ;      6133    
  10253. ;      6134        BEGIN
  10254. ;      6135    
  10255. ;      6136        BIND
  10256. ;      6137        RECEIVE_TEXT = UPLIT (%ASCIZ'Received...');
  10257. ;      6138    
  10258. ;      6139        IF .DEBUG_FLAG
  10259. ;      6140        THEN
  10260. ;      6141        BEGIN
  10261. ;      6142    
  10262. ;      6143        LOCAL
  10263. ;      6144            OLD_RTN;
  10264. ;      6145    
  10265. ;      6146        OLD_RTN = TT_SET_OUTPUT (DBG_DUMP);
  10266. ;      6147        TT_TEXT (RECEIVE_TEXT);
  10267. ;      6148        DBG_MESSAGE (.ADDRESS, .REC_LENGTH);
  10268. ;      6149        TT_SET_OUTPUT (.OLD_RTN);
  10269. ;      6150        END;
  10270. ;      6151    
  10271. ;      6152        END;                    ! End of DBG_RECEIVE
  10272.     .NLIST
  10273.     .LIST    BIN,LOC
  10274.     .LIST
  10275.  
  10276.  
  10277.     .PSECT    $PLIT$,  RO ,  D  
  10278. P.ABK:    .ASCII    /Rec/
  10279.     .ASCII    /eiv/
  10280.     .ASCII    /ed./
  10281.     .ASCII    /../<00>
  10282.  
  10283.  
  10284. ; RECEIVE.TEXT
  10285. U.126=            P.ABK
  10286.  
  10287.  
  10288.     .SBTTL    DBG.RECEIVE Debugging -- DBG_RECEIVE
  10289.     .PSECT    $CODE$,  RO 
  10290.  
  10291.     .NLIST
  10292.     .ENABL    LSB
  10293.     .LIST
  10294. ; DBG.RECEIVE
  10295. U.35:    MOV    R1,-(SP)            ;                    6095
  10296.     BIT    #1,DEBUG.FLAG            ;                    6139
  10297.     BEQ    1$
  10298.     MOV    #DBG.DUMP,-(SP)            ;                    6146
  10299.     JSR    PC,TT.SET.OUTPUT
  10300.     MOV    R0,R1                ; *,OLD.RTN
  10301.     MOV    #U.126,(SP)            ;                    6147
  10302.     JSR    PC,TT.TEXT
  10303.     MOV    6(SP),(SP)            ; ADDRESS,*                6148
  10304.     MOV    U.80,-(SP)
  10305.     JSR    PC,U.33
  10306.     MOV    R1,(SP)                ; OLD.RTN,*                6149
  10307.     JSR    PC,TT.SET.OUTPUT
  10308.     CMP    (SP)+,(SP)+            ;                    6141
  10309. 1$:    MOV    (SP)+,R1            ;                    6095
  10310.     RTS    PC
  10311. ; Routine Size:  26 words,    Routine Base:  $CODE$ + 23064
  10312. ; Maximum stack depth per invocation:  4 words
  10313.     .NLIST
  10314.     .DSABL    LSB
  10315.     .NLIST    BIN,LOC
  10316.     .LIST
  10317. ;      6153    %SBTTL 'Debugging -- DBG_MESSAGE'
  10318. ;      6154    ROUTINE DBG_MESSAGE (MSG_ADDRESS, MSG_LENGTH) : NOVALUE =
  10319. ;      6155    
  10320. ;      6156    !++
  10321. ;      6157    ! FUNCTIONAL DESCRIPTION:
  10322. ;      6158    !
  10323. ;      6159    !    This routine will display a message that is either being sent
  10324. ;      6160    !    or received on the user's terminal.
  10325. ;      6161    !
  10326. ;      6162    ! CALLING SEQUENCE:
  10327. ;      6163    !
  10328. ;      6164    !    DBG_MESSAGE(MSG_ADDRESS, MSG_LENGTH);
  10329. ;      6165    !
  10330. ;      6166    ! INPUT PARAMETERS:
  10331. ;      6167    !
  10332. ;      6168    !    MSG_ADDRESS - Address of the message to be output
  10333. ;      6169    !    MSG_LENGTH - Length of the message to be output.
  10334. ;      6170    !
  10335. ;      6171    ! IMPLICIT INPUTS:
  10336. ;      6172    !
  10337. ;      6173    !    None.
  10338. ;      6174    !
  10339. ;      6175    ! OUTPUT PARAMETERS:
  10340. ;      6176    !
  10341. ;      6177    !    None.
  10342. ;      6178    !
  10343. ;      6179    ! IMPLICIT OUTPUTS:
  10344. ;      6180    !
  10345. ;      6181    !    None.
  10346. ;      6182    !
  10347. ;      6183    ! COMPLETION CODES:
  10348. ;      6184    !
  10349. ;      6185    !    None.
  10350. ;      6186    !
  10351. ;      6187    ! SIDE EFFECTS:
  10352. ;      6188    !
  10353. ;      6189    !    None.
  10354. ;      6190    !
  10355. ;      6191    !--
  10356. ;      6192    
  10357. ;      6193        BEGIN
  10358. ;      6194    
  10359. ;      6195        MAP
  10360. ;      6196        MSG_ADDRESS : REF VECTOR [CH$ALLOCATION (MAX_MSG, CHR_SIZE)];    ! Point to the vector
  10361. ;      6197    
  10362. ;      6198        LOCAL
  10363. ;      6199        OLD_RTN,                ! Old type out routine
  10364. ;      6200        CHKSUM,                    ! Numeric value of block check
  10365. ;      6201        TEMP_POINTER,                ! Temporary character pointer
  10366. ;      6202        MSG_LEN;
  10367. ;      6203    
  10368. ;      6204    !
  10369. ;      6205    ! Message type text
  10370. ;      6206    !
  10371. ;      6207    
  10372. ;      6208        BIND
  10373. ;      6209        DATA_TEXT = UPLIT (%ASCIZ' (Data)'),
  10374. ;      6210        ACK_TEXT = UPLIT (%ASCIZ' (ACK)'),
  10375. ;      6211        NAK_TEXT = UPLIT (%ASCIZ' (NAK)'),
  10376. ;      6212        SND_INIT_TEXT = UPLIT (%ASCIZ' (Send init)'),
  10377. ;      6213        BREAK_TEXT = UPLIT (%ASCIZ' (Break)'),
  10378. ;      6214        TEXT_TEXT = UPLIT (%ASCIZ' (Text header)'),
  10379. ;      6215        FILE_TEXT = UPLIT (%ASCIZ' (File header)'),
  10380. ;      6216        EOF_TEXT = UPLIT (%ASCIZ' (EOF)'),
  10381. ;      6217        ERROR_TEXT = UPLIT (%ASCIZ' (Error)'),
  10382. ;      6218        RCV_INIT_TEXT = UPLIT (%ASCIZ' (Receive initiate)'),
  10383. ;      6219        COMMAND_TEXT = UPLIT (%ASCIZ' (Command)'),
  10384. ;      6220        KERMIT_TEXT = UPLIT (%ASCIZ' (Generic KERMIT command)');
  10385. ;      6221    
  10386. ;      6222    !
  10387. ;      6223    ! Header information
  10388. ;      6224    !
  10389. ;      6225    
  10390. ;      6226        BIND
  10391. ;      6227        MN_TEXT = UPLIT (%ASCIZ'Message number: '),
  10392. ;      6228        LENGTH_TEXT = UPLIT (%ASCIZ'    Length: '),
  10393. ;      6229        DEC_TEXT = UPLIT (%ASCIZ' (dec)'),
  10394. ;      6230        MSG_TYP_TEXT = UPLIT (%ASCIZ'Message type: '),
  10395. ;      6231        CHKSUM_TEXT = UPLIT (%ASCIZ'Checksum: '),
  10396. ;      6232        CHKSUM_NUM_TEXT = UPLIT (%ASCIZ' = '),
  10397. ;      6233        OPT_DATA_TEXT = UPLIT (%ASCIZ'Optional data: '),
  10398. ;      6234        PRE_CHAR_TEXT = UPLIT (%ASCIZ' "');
  10399. ;      6235    
  10400. ;      6236    !
  10401. ;      6237    ! Ensure that the type out will go to the debugging location
  10402. ;      6238    !
  10403. ;      6239        OLD_RTN = TT_SET_OUTPUT (DBG_DUMP);
  10404. ;      6240    !
  10405. ;      6241    ! Preliminary calculations
  10406. ;      6242    !
  10407. ;      6243        MSG_LEN = UNCHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_COUNT, CHR_SIZE)));
  10408. ;      6244    !
  10409. ;      6245    ! First output some header information for the packet.
  10410. ;      6246    !
  10411. ;      6247        TT_CRLF ();
  10412. ;      6248        TT_TEXT (MN_TEXT);
  10413. ;      6249        TT_NUMBER (UNCHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_SEQ, CHR_SIZE))));
  10414. ;      6250        TT_TEXT (DEC_TEXT);
  10415. ;      6251        TT_TEXT (LENGTH_TEXT);
  10416. ;      6252        TT_NUMBER (.MSG_LEN);
  10417. ;      6253        TT_TEXT (DEC_TEXT);
  10418. ;      6254        TT_CRLF ();
  10419. ;      6255    !
  10420. ;      6256    ! Now output the message type and dependent information
  10421. ;      6257    !
  10422. ;      6258        TT_TEXT (MSG_TYP_TEXT);
  10423. ;      6259        TT_CHAR (CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_TYPE, CHR_SIZE)));
  10424. ;      6260    
  10425. ;      6261        SELECTONE CH$RCHAR (CH$PTR (.MSG_ADDRESS, PKT_TYPE, CHR_SIZE)) OF
  10426. ;      6262        SET
  10427. ;      6263    
  10428. ;      6264        [MSG_DATA] :
  10429. ;      6265            TT_TEXT (DATA_TEXT);
  10430. ;      6266    
  10431. ;      6267        [MSG_ACK] :
  10432. ;      6268            TT_TEXT (ACK_TEXT);
  10433. ;      6269    
  10434. ;      6270        [MSG_NAK] :
  10435. ;      6271            TT_TEXT (NAK_TEXT);
  10436. ;      6272    
  10437. ;      6273        [MSG_SND_INIT] :
  10438. ;      6274            TT_TEXT (SND_INIT_TEXT);
  10439. ;      6275    
  10440. ;      6276        [MSG_BREAK] :
  10441. ;      6277            TT_TEXT (BREAK_TEXT);
  10442. ;      6278    
  10443. ;      6279        [MSG_FILE] :
  10444. ;      6280            TT_TEXT (FILE_TEXT);
  10445. ;      6281    
  10446. ;      6282        [MSG_TEXT] :
  10447. ;      6283            TT_TEXT (TEXT_TEXT);
  10448. ;      6284    
  10449. ;      6285        [MSG_EOF] :
  10450. ;      6286            TT_TEXT (EOF_TEXT);
  10451. ;      6287    
  10452. ;      6288        [MSG_ERROR] :
  10453. ;      6289            TT_TEXT (ERROR_TEXT);
  10454. ;      6290    
  10455. ;      6291        [MSG_KERMIT] :
  10456. ;      6292            TT_TEXT (KERMIT_TEXT);
  10457. ;      6293    
  10458. ;      6294        [MSG_COMMAND] :
  10459. ;      6295            TT_TEXT (COMMAND_TEXT);
  10460. ;      6296        TES;
  10461. ;      6297    
  10462. ;      6298        TT_CRLF ();
  10463. ;      6299    !
  10464. ;      6300    ! Now output any of the optional data.
  10465. ;      6301    !
  10466. ;      6302    
  10467. ;      6303        IF .MSG_LEN - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR) NEQ 0
  10468. ;      6304        THEN
  10469. ;      6305        BEGIN
  10470. ;      6306        TT_TEXT (OPT_DATA_TEXT);
  10471. ;      6307        TT_CRLF ();
  10472. ;      6308        TEMP_POINTER = CH$PTR (.MSG_ADDRESS, PKT_MSG, CHR_SIZE);
  10473. ;      6309    
  10474. ;      6310        INCR I FROM 1 TO .MSG_LEN - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR) DO
  10475. ;      6311            BEGIN
  10476. ;      6312    
  10477. ;      6313            IF (.I MOD 10) EQL 1
  10478. ;      6314            THEN
  10479. ;      6315            BEGIN
  10480. ;      6316            TT_CRLF ();
  10481. ;      6317            TT_CHAR (CHR_TAB);
  10482. ;      6318            END;
  10483. ;      6319    
  10484. ;      6320            TT_TEXT (PRE_CHAR_TEXT);
  10485. ;      6321            TT_CHAR (CH$RCHAR_A (TEMP_POINTER));
  10486. ;      6322            TT_CHAR (%C'"');
  10487. ;      6323            END;
  10488. ;      6324    
  10489. ;      6325        IF ((.MSG_LEN - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR)) MOD 10) EQL 1 THEN TT_CRLF ();
  10490. ;      6326    
  10491. ;      6327        TT_CRLF ();
  10492. ;      6328        END;
  10493. ;      6329    
  10494. ;      6330    !
  10495. ;      6331    ! Now output the checksum for the message that we received
  10496. ;      6332    !
  10497. ;      6333    ! This could be either 1 two or three characters.
  10498. ;      6334        TT_TEXT (CHKSUM_TEXT);
  10499. ;      6335        TEMP_POINTER = CH$PTR (.MSG_ADDRESS,
  10500. ;      6336        PKT_MSG + .MSG_LEN + PKT_CHKSUM - PKT_OVR_HEAD - (.BLK_CHK_TYPE - CHK_1CHAR), CHR_SIZE);
  10501. ;      6337    
  10502. ;      6338        CASE .BLK_CHK_TYPE FROM CHK_1CHAR TO CHK_CRC OF
  10503. ;      6339        SET
  10504. ;      6340    
  10505. ;      6341        [CHK_1CHAR] :
  10506. ;      6342            BEGIN
  10507. ;      6343            TT_TEXT (PRE_CHAR_TEXT);
  10508. ;      6344            TT_CHAR (CH$RCHAR (.TEMP_POINTER));
  10509. ;      6345            TT_CHAR (%C'"');
  10510. ;      6346            CHKSUM = UNCHAR (CH$RCHAR (.TEMP_POINTER));
  10511. ;      6347            END;
  10512. ;      6348    
  10513. ;      6349        [CHK_2CHAR] :
  10514. ;      6350            BEGIN
  10515. ;      6351            CHKSUM = 0;
  10516. ;      6352            TT_TEXT (PRE_CHAR_TEXT);
  10517. ;      6353            TT_CHAR (CH$RCHAR (.TEMP_POINTER));
  10518. ;      6354            TT_CHAR (%C'"');
  10519. ;      6355            CHKSUM<6, 6> = UNCHAR (CH$RCHAR_A (TEMP_POINTER));
  10520. ;      6356            TT_TEXT (PRE_CHAR_TEXT);
  10521. ;      6357            TT_CHAR (CH$RCHAR (.TEMP_POINTER));
  10522. ;      6358            TT_CHAR (%C'"');
  10523. ;      6359            CHKSUM<0, 6> = UNCHAR (CH$RCHAR (.TEMP_POINTER));
  10524. ;      6360            END;
  10525. ;      6361    
  10526. ;      6362        [CHK_CRC] :
  10527. ;      6363            BEGIN
  10528. ;      6364            CHKSUM = 0;
  10529. ;      6365            TT_TEXT (PRE_CHAR_TEXT);
  10530. ;      6366            TT_CHAR (CH$RCHAR (.TEMP_POINTER));
  10531. ;      6367            TT_CHAR (%C'"');
  10532. ;      6368            CHKSUM<12, 4> = UNCHAR (CH$RCHAR_A (TEMP_POINTER));
  10533. ;      6369            TT_TEXT (PRE_CHAR_TEXT);
  10534. ;      6370            TT_CHAR (CH$RCHAR (.TEMP_POINTER));
  10535. ;      6371            TT_CHAR (%C'"');
  10536. ;      6372            CHKSUM<6, 6> = UNCHAR (CH$RCHAR_A (TEMP_POINTER));
  10537. ;      6373            TT_TEXT (PRE_CHAR_TEXT);
  10538. ;      6374            TT_CHAR (CH$RCHAR (.TEMP_POINTER));
  10539. ;      6375            TT_CHAR (%C'"');
  10540. ;      6376            CHKSUM<0, 6> = UNCHAR (CH$RCHAR (.TEMP_POINTER));
  10541. ;      6377            END;
  10542. ;      6378        TES;
  10543. ;      6379    
  10544. ;      6380        TT_TEXT (CHKSUM_NUM_TEXT);
  10545. ;      6381        TT_NUMBER (.CHKSUM);
  10546. ;      6382        TT_TEXT (DEC_TEXT);
  10547. ;      6383        TT_CRLF ();
  10548. ;      6384        TT_SET_OUTPUT (.OLD_RTN);            ! Reset output destination
  10549. ;      6385        END;                    ! End of DBG_MESSAGE
  10550.     .NLIST
  10551.     .LIST    BIN,LOC
  10552.     .LIST
  10553.  
  10554.  
  10555.     .PSECT    $PLIT$,  RO ,  D  
  10556. P.ABL:    .ASCII    / (D/
  10557.     .ASCII    /ata/
  10558.     .ASCII    /)/<00>
  10559. P.ABM:    .ASCII    / (A/
  10560.     .ASCII    /CK)/
  10561.     .ASCII    <00><00>
  10562. P.ABN:    .ASCII    / (N/
  10563.     .ASCII    /AK)/
  10564.     .ASCII    <00><00>
  10565. P.ABO:    .ASCII    / (S/
  10566.     .ASCII    /end/
  10567.     .ASCII    / in/
  10568.     .ASCII    /it)/
  10569.     .ASCII    <00><00>
  10570. P.ABP:    .ASCII    / (B/
  10571.     .ASCII    /rea/
  10572.     .ASCII    /k)/<00>
  10573.     .ASCII    <00>
  10574. P.ABQ:    .ASCII    / (T/
  10575.     .ASCII    /ext/
  10576.     .ASCII    / he/
  10577.     .ASCII    /ade/
  10578.     .ASCII    /r)/<00>
  10579.     .ASCII    <00>
  10580. P.ABR:    .ASCII    / (F/
  10581.     .ASCII    /ile/
  10582.     .ASCII    / he/
  10583.     .ASCII    /ade/
  10584.     .ASCII    /r)/<00>
  10585.     .ASCII    <00>
  10586. P.ABS:    .ASCII    / (E/
  10587.     .ASCII    /OF)/
  10588.     .ASCII    <00><00>
  10589. P.ABT:    .ASCII    / (E/
  10590.     .ASCII    /rro/
  10591.     .ASCII    /r)/<00>
  10592.     .ASCII    <00>
  10593. P.ABU:    .ASCII    / (R/
  10594.     .ASCII    /ece/
  10595.     .ASCII    /ive/
  10596.     .ASCII    / in/
  10597.     .ASCII    /iti/
  10598.     .ASCII    /ate/
  10599.     .ASCII    /)/<00>
  10600. P.ABV:    .ASCII    / (C/
  10601.     .ASCII    /omm/
  10602.     .ASCII    /and/
  10603.     .ASCII    /)/<00><00>
  10604. P.ABW:    .ASCII    / (G/
  10605.     .ASCII    /ene/
  10606.     .ASCII    /ric/
  10607.     .ASCII    / KE/
  10608.     .ASCII    /RMI/
  10609.     .ASCII    /T c/
  10610.     .ASCII    /omm/
  10611.     .ASCII    /and/
  10612.     .ASCII    /)/<00>
  10613. P.ABX:    .ASCII    /Mes/
  10614.     .ASCII    /sag/
  10615.     .ASCII    /e n/
  10616.     .ASCII    /umb/
  10617.     .ASCII    /er:/
  10618.     .ASCII    / /<00><00>
  10619. P.ABY:    .ASCII    <11>/Le/
  10620.     .ASCII    /ngt/
  10621.     .ASCII    /h: /
  10622.     .ASCII    <00>
  10623. P.ABZ:    .ASCII    / (d/
  10624.     .ASCII    /ec)/
  10625.     .ASCII    <00><00>
  10626. P.ACA:    .ASCII    /Mes/
  10627.     .ASCII    /sag/
  10628.     .ASCII    /e t/
  10629.     .ASCII    /ype/
  10630.     .ASCII    /: /<00>
  10631.     .ASCII    <00>
  10632. P.ACB:    .ASCII    /Che/
  10633.     .ASCII    /cks/
  10634.     .ASCII    /um:/
  10635.     .ASCII    / /<00><00>
  10636. P.ACC:    .ASCII    / = /
  10637.     .ASCII    <00>
  10638. P.ACD:    .ASCII    /Opt/
  10639.     .ASCII    /ion/
  10640.     .ASCII    /al /
  10641.     .ASCII    /dat/
  10642.     .ASCII    /a: /
  10643.     .ASCII    <00>
  10644. P.ACE:    .ASCII    / "/<00>
  10645.     .ASCII    <00>
  10646.  
  10647.  
  10648. ; DATA.TEXT
  10649. U.128=            P.ABL
  10650. ; ACK.TEXT
  10651. U.129=            P.ABM
  10652. ; NAK.TEXT
  10653. U.130=            P.ABN
  10654. ; SND.INIT.TEXT
  10655. U.131=            P.ABO
  10656. ; BREAK.TEXT
  10657. U.132=            P.ABP
  10658. ; TEXT.TEXT
  10659. U.133=            P.ABQ
  10660. ; FILE.TEXT
  10661. U.134=            P.ABR
  10662. ; EOF.TEXT
  10663. U.135=            P.ABS
  10664. ; ERROR.TEXT
  10665. U.136=            P.ABT
  10666. ; RCV.INIT.TEXT
  10667. U.137=            P.ABU
  10668. ; COMMAND.TEXT
  10669. U.138=            P.ABV
  10670. ; KERMIT.TEXT
  10671. U.139=            P.ABW
  10672. ; MN.TEXT
  10673. U.140=            P.ABX
  10674. ; LENGTH.TEXT
  10675. U.141=            P.ABY
  10676. ; DEC.TEXT
  10677. U.142=            P.ABZ
  10678. ; MSG.TYP.TEXT
  10679. U.143=            P.ACA
  10680. ; CHKSUM.TEXT
  10681. U.144=            P.ACB
  10682. ; CHKSUM.NUM.TEXT
  10683. U.145=            P.ACC
  10684. ; OPT.DATA.TEXT
  10685. U.146=            P.ACD
  10686. ; PRE.CHAR.TEXT
  10687. U.147=            P.ACE
  10688.  
  10689.  
  10690.     .SBTTL    DBG.MESSAGE Debugging -- DBG_MESSAGE
  10691.     .PSECT    $CODE$,  RO 
  10692.  
  10693.     .NLIST
  10694.     .ENABL    LSB
  10695.     .LIST
  10696. ; DBG.MESSAGE
  10697. U.33:    JSR    R1,$SAVE5            ;                    6154
  10698.     SUB    #6,SP
  10699.     MOV    #DBG.DUMP,-(SP)            ;                    6239
  10700.     JSR    PC,TT.SET.OUTPUT
  10701.     MOV    R0,4(SP)            ; *,OLD.RTN
  10702.     MOV    30(SP),R2            ; MSG.ADDRESS,*                6243
  10703.     MOVB    1(R2),2(SP)            ; *,MSG.LEN
  10704.     CLRB    3(SP)                ; MSG.LEN
  10705.     SUB    #40,2(SP)            ; *,MSG.LEN
  10706.     JSR    PC,TT.CRLF            ;                    6247
  10707.     MOV    #U.140,(SP)            ;                    6248
  10708.     JSR    PC,TT.TEXT
  10709.     CLR    (SP)                ;                    6249
  10710.     MOVB    2(R2),(SP)
  10711.     SUB    #40,(SP)
  10712.     JSR    PC,TT.NUMBER
  10713.     MOV    #U.142,(SP)            ;                    6250
  10714.     JSR    PC,TT.TEXT
  10715.     MOV    #U.141,(SP)            ;                    6251
  10716.     JSR    PC,TT.TEXT
  10717.     MOV    2(SP),(SP)            ; MSG.LEN,*                6252
  10718.     JSR    PC,TT.NUMBER
  10719.     MOV    #U.142,(SP)            ;                    6253
  10720.     JSR    PC,TT.TEXT
  10721.     JSR    PC,TT.CRLF            ;                    6254
  10722.     MOV    #U.143,(SP)            ;                    6258
  10723.     JSR    PC,TT.TEXT
  10724.     CLR    R1                ;                    6259
  10725.     BISB    3(R2),R1
  10726.     MOV    R1,(SP)
  10727.     JSR    PC,TT.CHAR
  10728.     CMP    R1,#104                ;                    6261
  10729.     BNE    1$
  10730.     MOV    #U.128,(SP)            ;                    6265
  10731.     BR    11$
  10732. 1$:    CMP    R1,#131                ;                    6261
  10733.     BNE    2$
  10734.     MOV    #U.129,(SP)            ;                    6268
  10735.     BR    11$
  10736. 2$:    CMP    R1,#116                ;                    6261
  10737.     BNE    3$
  10738.     MOV    #U.130,(SP)            ;                    6271
  10739.     BR    11$
  10740. 3$:    CMP    R1,#123                ;                    6261
  10741.     BNE    4$
  10742.     MOV    #U.131,(SP)            ;                    6274
  10743.     BR    11$
  10744. 4$:    CMP    R1,#102                ;                    6261
  10745.     BNE    5$
  10746.     MOV    #U.132,(SP)            ;                    6277
  10747.     BR    11$
  10748. 5$:    CMP    R1,#106                ;                    6261
  10749.     BNE    6$
  10750.     MOV    #U.134,(SP)            ;                    6280
  10751.     BR    11$
  10752. 6$:    CMP    R1,#130                ;                    6261
  10753.     BNE    7$
  10754.     MOV    #U.133,(SP)            ;                    6283
  10755.     BR    11$
  10756. 7$:    CMP    R1,#132                ;                    6261
  10757.     BNE    8$
  10758.     MOV    #U.135,(SP)            ;                    6286
  10759.     BR    11$
  10760. 8$:    CMP    R1,#105                ;                    6261
  10761.     BNE    9$
  10762.     MOV    #U.136,(SP)            ;                    6289
  10763.     BR    11$
  10764. 9$:    CMP    R1,#107                ;                    6261
  10765.     BNE    10$
  10766.     MOV    #U.139,(SP)            ;                    6292
  10767.     BR    11$
  10768. 10$:    CMP    R1,#103                ;                    6261
  10769.     BNE    12$
  10770.     MOV    #U.138,(SP)            ;                    6295
  10771. 11$:    JSR    PC,TT.TEXT
  10772. 12$:    JSR    PC,TT.CRLF            ;                    6298
  10773.     MOV    2(SP),R4            ; MSG.LEN,*                6303
  10774.     SUB    #3,R4
  10775.     MOV    U.71,R0
  10776.     SUB    #61,R0
  10777.     CMP    R4,R0
  10778.     BEQ    17$
  10779.     MOV    #U.146,(SP)            ;                    6306
  10780.     JSR    PC,TT.TEXT
  10781.     JSR    PC,TT.CRLF            ;                    6307
  10782.     MOV    #4,R5                ; *,TEMP.POINTER            6308
  10783.     ADD    R2,R5                ; *,TEMP.POINTER
  10784.     MOV    R4,R1                ;                    6310
  10785.     SUB    U.71,R1
  10786.     MOV    R1,6(SP)
  10787.     ADD    #61,6(SP)
  10788.     CLR    R3                ; I
  10789.     BR    15$
  10790. 13$:    MOV    R3,R1                ; I,*                    6313
  10791.     SXT    R0
  10792.     DIV    #12,R0
  10793.     CMP    R1,#1
  10794.     BNE    14$
  10795.     JSR    PC,TT.CRLF            ;                    6316
  10796.     MOV    #11,(SP)            ;                    6317
  10797.     JSR    PC,TT.CHAR
  10798. 14$:    MOV    #U.147,(SP)            ;                    6320
  10799.     JSR    PC,TT.TEXT
  10800.     CLR    (SP)                ;                    6321
  10801.     MOVB    (R5)+,(SP)            ; TEMP.POINTER,*
  10802.     JSR    PC,TT.CHAR
  10803.     MOV    #42,(SP)            ;                    6322
  10804.     JSR    PC,TT.CHAR
  10805. 15$:    INC    R3                ; I                    6310
  10806.     CMP    R3,6(SP)            ; I,*
  10807.     BLE    13$
  10808.     MOV    R4,R1                ;                    6325
  10809.     SUB    U.71,R1
  10810.     ADD    #61,R1
  10811.     SXT    R0
  10812.     DIV    #12,R0
  10813.     CMP    R1,#1
  10814.     BNE    16$
  10815.     JSR    PC,TT.CRLF
  10816. 16$:    JSR    PC,TT.CRLF            ;                    6327
  10817. 17$:    MOV    #U.144,(SP)            ;                    6334
  10818.     JSR    PC,TT.TEXT
  10819.     MOV    2(SP),R1            ; MSG.LEN,*                6336
  10820.     SUB    U.71,R1
  10821.     ADD    R2,R1
  10822.     MOV    R1,R5                ; *,TEMP.POINTER
  10823.     ADD    #62,R5                ; *,TEMP.POINTER
  10824.     MOV    U.71,R0                ;                    6338
  10825.     SUB    #61,R0
  10826.     ASL    R0
  10827.     ADD    P.ACF(R0),PC            ; Case dispatch
  10828. 19$:    MOV    #U.147,(SP)            ;                    6343
  10829.     JSR    PC,TT.TEXT
  10830.     CLR    (SP)                ;                    6344
  10831.     MOVB    (R5),(SP)            ; TEMP.POINTER,*
  10832.     JSR    PC,TT.CHAR
  10833.     MOV    #42,(SP)            ;                    6345
  10834.     JSR    PC,TT.CHAR
  10835.     CLR    R1                ; CHKSUM                6346
  10836.     BISB    (R5),R1                ; TEMP.POINTER,CHKSUM
  10837.     SUB    #40,R1                ; *,CHKSUM
  10838.     BR    23$                ;                    6338
  10839. 20$:    CLR    R1                ; CHKSUM                6351
  10840.     BR    22$                ;                    6352
  10841. 21$:    CLR    R1                ; CHKSUM                6364
  10842.     MOV    #U.147,(SP)            ;                    6365
  10843.     JSR    PC,TT.TEXT
  10844.     CLR    (SP)                ;                    6366
  10845.     MOVB    (R5),(SP)            ; TEMP.POINTER,*
  10846.     JSR    PC,TT.CHAR
  10847.     MOV    #42,(SP)            ;                    6367
  10848.     JSR    PC,TT.CHAR
  10849.     CLR    R0                ;                    6368
  10850.     BISB    (R5)+,R0            ; TEMP.POINTER,*
  10851.     SUB    #40,R0
  10852.     ASH    #14,R0
  10853.     BIC    #170000,R1            ; *,CHKSUM
  10854.     BIS    R0,R1                ; *,CHKSUM
  10855. 22$:    MOV    #U.147,(SP)            ;                    6369
  10856.     JSR    PC,TT.TEXT
  10857.     CLR    (SP)                ;                    6370
  10858.     MOVB    (R5),(SP)            ; TEMP.POINTER,*
  10859.     JSR    PC,TT.CHAR
  10860.     MOV    #42,(SP)            ;                    6371
  10861.     JSR    PC,TT.CHAR
  10862.     CLR    R0                ;                    6372
  10863.     BISB    (R5)+,R0            ; TEMP.POINTER,*
  10864.     SUB    #40,R0
  10865.     ASH    #6,R0
  10866.     BIC    #170077,R0
  10867.     BIC    #7700,R1            ; *,CHKSUM
  10868.     BIS    R0,R1                ; *,CHKSUM
  10869.     MOV    #U.147,(SP)            ;                    6373
  10870.     JSR    PC,TT.TEXT
  10871.     CLR    (SP)                ;                    6374
  10872.     MOVB    (R5),(SP)            ; TEMP.POINTER,*
  10873.     JSR    PC,TT.CHAR
  10874.     MOV    #42,(SP)            ;                    6375
  10875.     JSR    PC,TT.CHAR
  10876.     CLR    R0                ;                    6376
  10877.     BISB    (R5),R0                ; TEMP.POINTER,*
  10878.     SUB    #40,R0
  10879.     BIC    #177700,R0
  10880.     BICB    #77,R1                ; *,CHKSUM
  10881.     BIS    R0,R1                ; *,CHKSUM
  10882. 23$:    MOV    #U.145,(SP)            ;                    6380
  10883.     JSR    PC,TT.TEXT
  10884.     MOV    R1,(SP)                ; CHKSUM,*                6381
  10885.     JSR    PC,TT.NUMBER
  10886.     MOV    #U.142,(SP)            ;                    6382
  10887.     JSR    PC,TT.TEXT
  10888.     JSR    PC,TT.CRLF            ;                    6383
  10889.     MOV    4(SP),(SP)            ; OLD.RTN,*                6384
  10890.     JSR    PC,TT.SET.OUTPUT
  10891.     ADD    #10,SP                ;                    6154
  10892.     RTS    PC
  10893. ; Routine Size:  327 words,    Routine Base:  $CODE$ + 23150
  10894. ; Maximum stack depth per invocation:  11 words
  10895.  
  10896.  
  10897.     .PSECT    $PLIT$,  RO ,  D  
  10898.  
  10899. P.ACF:                        ; CASE Table for DBG.MESSAGE+0670    6338
  10900. 18$:    .WORD    0                ; [19$]
  10901.     .WORD    42                ; [20$]
  10902.     .WORD    46                ; [21$]
  10903.  
  10904.     .NLIST
  10905.     .DSABL    LSB
  10906.     .NLIST    BIN,LOC
  10907.     .LIST
  10908.  
  10909.  
  10910. ;      6386    %SBTTL 'End of KERMSG'
  10911. ;      6387    END
  10912. ;      6388    
  10913. ;      6389    ELUDOM
  10914.     .NLIST
  10915.     .LIST    BIN,LOC
  10916.     .LIST
  10917.  
  10918.  
  10919. ; OTS external references
  10920.     .GLOBL    $SAVE5, $SAVE4, $SAVE3, $SAVE2
  10921.     .GLOBL    BL$ABS, BL$FIL, BL$CPY, BL$MOV
  10922.  
  10923.  
  10924. ;                    PSECT SUMMARY
  10925. ;
  10926. ;    Psect Name            Words    ; Attributes
  10927. ;     $OWN$                  147    ;   RW ,  D  ,  LCL,  REL,  CON
  10928. ;     $CODE$                 5243    ;   RO ,  I  ,  LCL,  REL,  CON
  10929. ;     $PLIT$                  480    ;   RO ,  D  ,  LCL,  REL,  CON
  10930.  
  10931.  
  10932.  
  10933.  
  10934.  
  10935. ; Compilation Complete
  10936.  
  10937.     .END
  10938.  
  10939.