home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / alphamicro / am68k.m68 < prev    next >
Text File  |  2020-01-01  |  108KB  |  3,548 lines
  1. ; Kermit.m68 - a telecommunications & error free file transfer program
  2. ; Version 2.0 - supports wildcarding, 3 byte CRC
  3. ; Author:    Robert P. Rubendunst, Soft Machines,
  4. ;        P.O. box 3701, Champaign, IL 61821
  5.  
  6. ; Copyright 1984, 1991  Robert P. Rubendunst. All rights reserved. In
  7. ; addition, anthology copyrights prohibited without written permission from
  8. ; the author.
  9.  
  10. ; N O T E  - requires 1.3D AMOS/L//1.0D AMOS/32 or later to assemble.
  11. ; To assemble, M68 KERMIT.m68 produces KERMIT.LIT
  12.  
  13. ; Edit History:
  14. ;[024] 16 March 1994 13:45    Edited by Bob Rubendunst
  15. ;    Added test & message when re-entering user tries to 
  16. ;    re-specify port name.
  17. ;[023] 31 January 1992 10:49    Edited by Bob Rubendunst
  18. ;    Corrected problems in RPAR which caused file transfers to fail.
  19. ;[022] 10 January 1992 09:37    Edited by Bob Rubendunst
  20. ;    Added logic to strip CONNECT to 7 bits if PARITY is not NONE.
  21. ;[021] 09 January 1992 09:37    Edited by Bob Rubendunst
  22. ;    Documentation changes in CONNECT message
  23. ;    Added TIMEOUT and ENDLINE parametes to SET parameters list in SHOW
  24. ;    Changed SHOCHR to always display 3 characters, show ^ as dim if ctl
  25. ;    fixed problem with outputting zero byte files
  26. ;    improved SPAR & RPAR logic to handle 7 bit cases better.
  27. ;[020] 31 December 1991 11:06    Edited by Bob Rubendunst
  28. ;    Added code to make CONNECT mode compatible with 8 bit terminals.
  29. ;    (Exit character must match all 8 bits if TDV presents TD$EXT)
  30. ;    Deleted BPT legerdemain and just used SUPVR instead in SETSTS!
  31. ;[019] 31 December 1991 10:41    Edited by Bob Rubendunst
  32. ;    AUTORECEIVE feature completed
  33. ;[018] 06 December 1991 13:08    Edited by Bob Rubendunst
  34. ;    Added random file bypass for batch SENDing.
  35. ;    Added code to eliminate possible bogus packet timeout at midnight.
  36. ;    Added command line help.
  37. ;    Added SET PARITY input checking
  38. ;[017] 02 December 1991 11:48    Edited by Bob Rubendunst
  39. ;    Added SET PACKETSTART option
  40. ;    Deleted code to save & restore jcb jobtyp word (not used)
  41. ;[016] 22 November 1991 13:27    Edited by Bob Rubendunst
  42. ;    Added AUTORECEIVE command
  43. ;    Changed SEND logic to send a Break packet if no files sent.
  44. ;    Corrected some help text with Karen Bojda's help.
  45. ;    Streamlined INUSE subroutine
  46. ;    Added code to revive job when attaching JCB & TCB
  47. ;    Completed graceful abort code for SENDing
  48. ;    Corrected tests for maximum retries - some were BNE instead of BLOS
  49. ;[015] 31 October 1991 16:49    Edited by Bob Rubendunst
  50. ;    Added wildcarding via CMDLIN.SYS. Kudos to Tom Niccum of KW fame.
  51. ;    Added totals statistics.
  52. ;    Added code to make SEND automatically send KERMIT and REC commands
  53. ;    to remote Kermit. Can be de-activated with SET AUTOSEND OFF.
  54. ;    Changed filenames to lower case for Unix compatibility.
  55. ;    Added 3 byte CRC check type. Should eliminate problems with
  56. ;    PC Kermits that do 2 byte CRCs wrong (Select either 1 or 3 byte option
  57. ;    in Procomm Plus - vers 2.0 STILL does 2 byte checksums wrong.)
  58. ;    Added SY$M40 symbol for possible AM4000 machine.
  59. ;    Added code to avoid T.SEM problems with smart I/O cards
  60. ;    Enhanced file size calcs to work under extended directories
  61. ;    Added file closes to make compatible with AMOS 2.x
  62. ;    Kermit only delays five seconds before SENDING in REMOTE mode instead
  63. ;    of fifteen.
  64. ;    Changed VMAJOR to 2.
  65. ;[014] 28 March 1991 12:38    Edited by Bob Rubendunst
  66. ;    Added routine to adjust sleep value for faster baud rates.
  67. ;    Note that this does improve performance at higher baud rates,
  68. ;    especially for file transfers. Due to limitations in TTYIN monitor
  69. ;    call, Kermit can still lose characters at higher baud rates.
  70. ;    Fixed bug in effective baud rate calculation when calculating
  71. ;    date rollover at midnight.
  72. ;[013] 28 March 1991 12:08    Edited by Bob Rubendunst
  73. ;    Corrected problems with received filenames being expanded to 6 & 3
  74. ;    even if they were shorter.
  75. ;    Fixed problem in edit 12 with max packetsize not being defaulted
  76. ;    at startup.
  77. ;[012] 06 February 1990 09:23    Edited by Bob Rubendunst
  78. ;    Corrected a few bugs in checking for previous or next packet
  79. ;    needing to be ACKed. Also fixed parameter display to display
  80. ;    active END-OF-LINE caharcter, rather than default end-of-line.
  81. ;[011] 02 Dec 1988
  82. ;    made compare for ESCAPE character 7 bits instead of 8 bits
  83. ;     added BLOCKSIZE to SET command
  84. ;[010] 11 Sept 1988
  85. ;    Changed handling of port busy bit so that REMOTE users do not monitor
  86. ;    or  change the terminal busy bit. Defines new SY$ symbols for 68020 & 
  87. ;    68030 if not already defined.
  88. ;[009] 29 Jun 1988
  89. ;    Completed basic compatibility with AM3000 systems
  90. ;[008] May 1988
  91. ;    Started compatibility with AM3000 systems.
  92. ;[007] 24 Oct 1986
  93. ;    Changed CONNEC routine to properly set T.DAT bit and T.XLT bits so 
  94. ;    nulls can be sent from keyboard.
  95. ;[006] 29 Jul 1986
  96. ;    Tidied up SHOW command, added dot for every packet of data sent or
  97. ;    rec'd, SET ? now shows SET list.
  98. ;[005] ??
  99. ;    Change Kermit to accept running under AMOS/32. rpr
  100. ;[004] 12 May 1986
  101. ;       straightened out 8-bit quoting problem in RPAR
  102. ;    updated INUSE bit to use new bit under 1.3B
  103. ;    transformed SET BINQUOTE feature into SET PARITY feature
  104. ;    (does not set parity, but info is used to determine 7 or 8 bit modes.)
  105. ;    corrected checkbyte size detection problem when used with unix c
  106. ;    where ACK to F contained new filename under c. Alpha-Kermit thought
  107. ;    this was an ACK to an I packet and used the wrong checkbyte type.
  108. ;    Fixed 255 to 255. in max retries entry code 6/27/85 rpr
  109. ;    Fix requires keeping track of the ACKing of the I packet via RIACK(A0)
  110. ;    Fixed QBIN not defined on short received SINIT packet 4/24/85 rpr
  111. ;    AMUS release (clean-up same TCB use) 12/3/84 rpr
  112. ;     Added 7 bit mode to allow use with ELS... 10/23/84 rpr
  113. ;    First non-alpha transfers 10/5/84 with ibm pc
  114. ;[000]    07 Sept 1984 project begun
  115.  
  116. ; Permission is granted to any individual or institution to copy or use this
  117. ; software and the routines described in it, except for explicitly commercial
  118. ; purposes. This software must not be sold to any person or institution.
  119.  
  120. ;;;;;;;;;;;;;;;;;;;;;;;;;;;; D I S C L A I M E R ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  121. ;; No warranty of the software or of the accuracy of the documentation     ;;
  122. ;; surrounding it is expressed or implied, and neither the authors,        ;;
  123. ;; Columbia University, Soft Machines, or AMUS acknowledge any liability   ;;
  124. ;; resulting from program or documentation errors.                         ;;
  125. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  126.  
  127. ; usage format:
  128. ;    KERMIT <terminal-name> <escape character>
  129. ; then enter ? or HELP for use hints.
  130.  
  131.     SEARCH    SYS
  132.     SEARCH    SYSSYM
  133.     SEARCH    TRM
  134.     COPY    CMDSYM
  135.  
  136. IF    NDF,SY$M20, SY$M20 = ^O20000    ; supply missing symbols [010]
  137. IF    NDF,SY$M30, SY$M30 = ^O100000    ; supply missing symbols [010]
  138. IF    NDF,SY$M40, SY$M40 = ^O2000000000 ; support possible 68040 [015]
  139. IF    NDF,SY$EXT, SY$EXT = ^O10000000 ; support 8 bit terminals [021]
  140. IF    NDF,TD$EXT, TD$EXT = ^O1000000000 ; support 8 bit terminals [021]
  141. IF    NDF,T$EXT, T$EXT = ^O20000 ; support 8 bit terminals [021]
  142.  
  143. ; supplementary symbols for finding file type & size
  144. D.LEN=D.WRK
  145. D.ACT=D.LEN+4
  146. D.1ST=D.ACT+10
  147.  
  148. ; symbols to define byte-word-lword relationships
  149. ; The Alpha Micro uses byte-swap logic to switch the sense of UDS & LDS
  150. ; in hardware, so that BYTE ACCESS of data is the opposite of normal 68000s.
  151. ; (This was done because the WD-16 processor used Intel style byte access,
  152. ; were the MSB of a word is stored at higher addresses. Motorola CPUs
  153. ; store words MSB at lower addresses.)
  154. ; (WORD & LWORD ACCESS is not affected, only BYTE ACCESS.)
  155. ; (change these definitions for non-AM style hardware!!)
  156.     .B0W7    =    0    ; access LS byte of a 16 bit word
  157.     .B8W15    =    1    ; access MS byte of a 16 bit word
  158.     .B0L7    =    2    ; access bits 00-07 of a 32 bit word    
  159.     .B8L15    =    3    ; access bits 08-15 of a long word
  160.     .B16L23    =    0    ; access bits 16-23 of a long word
  161.     .B24L31    =    1    ; access bits 24-31 of a long word
  162.     .W0L15    =    2    ; access LS word of long word
  163.     .W16L31    =    0    ; access MS word of long word
  164.  
  165. ; symbol definitions
  166. TRUE    =    -1
  167. FALSE    =    1
  168.  
  169.  
  170. PAKSIZ    =    94.        ; max packet size
  171. SOH    =    1.        ; default MARK character
  172. CR    =    13.        ; ASCII carriage return
  173. SPACE    =    32.        ; ASCII SP
  174. DEL    =    127.        ; ASCII DEL
  175. ESCCHR    =    '^        ; default escape character
  176. A.BEL    =    7.        ; ASCII bell [24]
  177.  
  178. TRIES    =    10.        ; number of packet tries
  179. MYQUOT    =    '#        ; control-quoting
  180. MYPAD    =    0        ; number of pad chars
  181. MYPCHR    =    0        ; the pad character I need
  182. MYEOL    =    0        ; my end of line character
  183. MYTIME    =    08.        ; seconds before timeout
  184. MYBIN    =    'Y        ; binary qoute mode
  185. MYCHK    =    '3        ; try to use 3 byte check bytes
  186. MAXCHK    =    3        ; maximum check type supported
  187. MAXTIM    =    60.        ; maximum timeout
  188. MINTIM    =    2        ; minimum timeout period
  189.  
  190. ; This macro is used to read a packet
  191. DEFINE    RPACK    LEN,SEQ,PACKET,TYPE
  192.     LEA    A3,PACKET
  193.     CALL    RECPAK
  194.     SSTS    D7
  195.     MARG    MOVB,    D2,LEN
  196.     MARG    MOVB,    D3,SEQ
  197.     MARG    MOVB,    D4,TYPE
  198.     LCC    D7
  199.     ENDM
  200.  
  201. ; This macro sends a packet to the REMOTE
  202. DEFINE    SPACK    TYPE,SEQ,SIZE,PACKET
  203.     LEA    A3,PACKET
  204.     CCLR    SIZE,D2
  205.     CCLR    SEQ,D3
  206.     CCLR    TYPE,D4
  207.     MARG    MOVB,    SIZE,D2
  208.     MARG    MOVB,    SEQ,D3
  209.     MARG    MOVB,    TYPE,D4
  210.     CALL    SNDPAK
  211.     ENDM
  212.  
  213. ; This macro assembles argument linkage opcodes only where the default
  214. ; argument is not used. This provides more readable code without adding
  215. ; unnecessary instructions.
  216. ; For example, if D2 is the standard data link register, the macro
  217. ;    MARG    MOVW    D2,D2
  218. ; will not produce an assembly line, but
  219. ;    MARG    MOVW    D2,D3
  220. ; will assemble the line MOVW D2,D3    
  221. DEFINE    MARG    OPCODE, SRC, DST
  222.     NTYPE    ...X,SRC
  223.     NTYPE    ...Y,DST
  224.     IF    NE,...X-...Y,OPCODE    SRC,DST
  225.     ENDM
  226.     ASECT
  227.  
  228.  
  229. ; This macro is used to pre-clear result variables before a packet call
  230. ; IF they are not registers.
  231. DEFINE    CCLR    ARG,REG
  232.     NTYPE    ...D,ARG
  233.     NTYPE    ...E,REG
  234.     IF    NE,...D-...E,CLR REG
  235.     ENDM
  236.  
  237.     .=0
  238. ; define the impure area for KERMIT.
  239.     NOSYM
  240. ; CONNECT command variables and general REMOTE/LOCAL channel variable
  241. TNAME:    BLKW    2            ; terminal name packed RAD50
  242. SAVTDV:    BLKL    1            ; address of saved TDV
  243. PSEUDO:    BLKL    1            ; address of PSEUDO driver
  244. SAVSTS:    BLKW    1            ; saved TCB status
  245. SAVJCB:    BLKL    1            ; saved attached JCB index
  246. REMOTE:    BLKL    1            ; index to remote TCB
  247. LOCAL:    BLKL    1            ; index to local TCB
  248. STIME:    BLKL    1            ; start time of event
  249. FSIZE:    BLKL    1            ; size of file in bytes
  250. KMETA:    BLKB    1            ; escape character
  251. DONE:    BLKB    1            ; done with kermit flag
  252. NOTALK:    BLKB    1            ; flag that remote TCB is job's.
  253. ECHO:    BLKB    1            ; duplex flag 0 for full, 377 for half
  254. CCOUNT:    BLKB    1            ; control-c count
  255. AUTOS:    BLKB    1            ; autosend option for SEND
  256. AUTOR:    BLKB    1            ; AUTORECEIVE option for REC
  257. COMSER:    BLKB    1            ; flag -1 if COMSER routines O.K.
  258. EXTEND:    BLKB    1            ; extended device support flag
  259. ABORTB:    BLKB    1            ; -1 if send batch to be aborted
  260. ABORTF:    BLKB    1            ; -1 if send file to be aborted
  261. WILDOK:    BLKB    1            ; -1 if wildcarding O.K.
  262. CMASK:    BLKB    1            ; bit mask for 7 or 8 bit characters
  263. CFLAG:    BLKB    1            ; flag we have breifed user on CONNECT
  264. ATERM:    BLKB    7            ; terminal name in ASCII & null
  265.     EVEN
  266. FIO:    BLKB    D.DDB            ; file I/O ddb area
  267. SIO:    BLKB    D.DDB            ; ddb just for file spec & cmdlin
  268. ; KERMIT packet receiver variables
  269. ASSUM:    BLKW    1        ; checksum storage
  270. FRMSUM:    BLKW    1        ; CRC storage
  271. RTOUT:    BLKL    1        ; time's up in seconds from midnight.
  272. FUDGE:    BLKL    1        ; fudge factor for midnight wrap-around
  273. TIMINT:    BLKL    1        ; # of seconds for timeout on sends
  274. DF.TIM:    BLKL    1        ; default timeout
  275. ; Global variables for file section
  276. LOGIC:    BLKB    1        ;  1=false, -1=true
  277. LDATA:    BLKB    1        ; size of present data
  278. SPSIZ:    BLKB    1        ; max send packet size
  279. PAD:    BLKB    1        ; # of padding chars to send
  280. PADCHR:    BLKB    1        ; pad character
  281. EOL:    BLKB    1        ; EOL character to send
  282. N:    BLKB    1        ; packet number
  283. MAXTRY:    BLKB    1        ; max # of tries
  284. NUMTRY:    BLKB    1        ; times this packet retried
  285. OLDTRY:    BLKB    1        ; times previous packet retried
  286. BUFCNT:    BLKB    1        ; # of data bytes for packet
  287. DEBUGO:    BLKB    1        ; level of debug output (0=none)
  288. DING:    BLKB    1        ; ding after each command flag (#0=yes)
  289. DF.EOL:    BLKB    1        ; default EOL character
  290. DF.CHK:    BLKB    1        ; default check type character
  291. PARITY:    BLKB    1        ; parity mode (None, Odd, Even, Space.)
  292. STATE:    BLKB    1        ; present state of file transfer automaton
  293. QUOTE:    BLKB    1        ; incoming quote char
  294. QBIN:    BLKB    1        ; storage & flag controlling 8 bit quoting:
  295.                 ; 0  indicates 8 bit path, no quoting
  296.                 ; -1 indicates 7 bit path, no quoting
  297.                 ; all other values 33.-62. 96.-126. are valid
  298.                 ; 8 bit quote characters (usually &)
  299. CHKT:    BLKB    1        ; checkbyte method as ascii character
  300. CHKNOW:    BLKB    1        ; checkbyte in use for this packet
  301. REPT:    BLKB    1        ; repeat byte (not implemented yet)
  302. FLLEN:    BLKB    1        ; filename length
  303. RMARK:    BLKB    1        ; the MARK character
  304. RIACK:    BLKB    1        ; flag we got an ACK to an I packet
  305. MXPKSZ:    BLKB    1        ; maximum packet size allowed
  306. STLCHR:    BLKB    1        ; stall character time in 100ths of a second
  307. RECPKT:    BLKB    PAKSIZ        ; buffer for receiving packets
  308. PACKET:    BLKB    PAKSIZ        ;  another one
  309. NFILNM:    BLKB    4        ; room for MARK,LEN,SEQ,TYPE
  310. FILNAM:    BLKB    60.        ; current filename
  311.     BLKB    20.
  312. COPY:    BLKB    60.        ;    ; copied filename
  313.     BLKB    PAKSIZ-80.
  314.     EVEN
  315. SLPVAL:    BLKL    1        ; sleep value in ticks for GETREM routine
  316. TFILES:    BLKL    1        ; total files sent or received
  317. TBYTES:    BLKL    1        ; total bytes in files sent or received
  318. TTIME:    BLKL    1        ; total elapsed times
  319. CLDDB:    BLKB    D.DDB        ; CMDLIN.SYS ddb area
  320. CMDERR:    BLKL    1        ; CMDLIN.SYS .CMINI error cod
  321. CMDPTR:    BLKL    1        ; ptr to CMDLIN.SYS module
  322. SAVSPC:    BLKL    1        ; ptr to user's command line
  323. CMNEXT:    BLKL    1        ; saved flags from CM.NXT in CMDLIN routines
  324. NXTCNT:    BLKB    1        ; count of times NXTSPC called w/o wildcard
  325. CMDFLG:    BLKB    1        ; flag we have CMDLIN.SYS
  326.     EVEN
  327. CMDIMP:    BLKB    IMP.SZ+100.    ; room for CMDLIN.SYS
  328.     EVEN
  329. KSIZE=.
  330.     .=0
  331. ; definition of KERMIT packet offsets
  332. MARK:    BLKB    1        ; the MARK character
  333. LEN:    BLKB    1        ; received LEN
  334. SEQ:    BLKB    1        ; received sequence
  335. TYPE:    BLKB    1        ; received type
  336. DATA:    BLKB    1        ; beginning of DATA
  337. ; 1, 2, or 3 byte check bytes follow the data and end the packet
  338.     .=0
  339.     SYM
  340.  
  341.  
  342. REMMOD = T$IMI!T$ECS!T$DAT    ; IMAGE, NOECHO mode bits
  343.  
  344.  
  345. ; The following macros define character tranlation functions needed to
  346. ; implement the KERMIT protocol.
  347. ; MACROs to perform CHAR, UNCHAR & CTL functions via register argument.
  348.  
  349.  
  350. ; C H A R  - change control character to printable character
  351. DEFINE    CHAR    DST
  352.     ADDB    #SPACE,DST
  353.     ENDM
  354.  
  355. ; U N C H A R  -change CHARed control character back into a control character
  356. DEFINE    UNCHAR    DST
  357.     SUBB    #SPACE,DST
  358.     ENDM
  359.  
  360. ; CTL - UNCONTROLIFY a CHARACTER. CTL(CTL(CHAR)) leaves CHAR unchanged.
  361. DEFINE    CTL    DST
  362.     XORB    #64.,DST
  363.     ENDM
  364.  
  365.  
  366.     PSECT
  367.  
  368.  
  369. ;  K E R M I T
  370. ; Main Kermit routine. The first time executed, KERMIT builds its impure area,
  371. ; KERMIT.IMP. Then the main routine accepts and performs user commands.
  372. ; 
  373.     VMAJOR =2
  374.     VMINOR =0
  375.     VSUB = 0
  376.     VEDIT = 024.
  377.     VWHO =0
  378.  
  379.     RADIX    8.        ; default numbers in octal
  380.  
  381. KERMIT:    PHDR    -1,PV$RSM!PV$WSM!PV$RPD!PV$WPD,PH$REE!PH$REU
  382.     CMPB    @A2,#'/            ; flag?
  383.     BNE    2$
  384.     INC    A2
  385.     CMPB    @A2,#'?            ; help?
  386.     BEQ    1$
  387.     TTYI
  388.     ASCII    "undefined switch - assuming /? switch"
  389.     BYTE    CR,A.BEL,0
  390.     EVEN
  391. 1$:    TTYL    USAGE
  392.     EXIT
  393.  
  394. ; make sure we are running under an OS that supports TTYOUT.
  395. 2$:    CALL    KERTTL            ; show title and version
  396.     MOV    SYSTEM,D5        ; get system word
  397.     AND    #SY$M20!SY$M30!SY$M40,D5 ; mask to just AMOS/32
  398.     BNE    10$            ;  we are on AMOS/32, has TTYOUT
  399.     CMPB    PH.VER+.B8W15,#1.    ; MAJOR higher than 1?
  400.     BHI    10$            ;  yes-use new value
  401.     MOVB    PH.VER+.B16L23,D5    ;  no- get sub release
  402.     ANDB    #^O17,D5        ; strip out VWHO in top 4 bits
  403.     CMPB    D5,#2.            ; is this 1.2 or later?
  404.     BHIS    10$            ;  yes- we can execute
  405.                     ;  no- time to update the system!
  406.     TTYI
  407.     ASCII    "%This software requires AMOS/L 1.2 or later O/S."
  408.     BYTE    CR,0
  409.     EVEN
  410.     EXIT
  411.  
  412. 10$:    CALL    INIMEM            ; initial memory area
  413.      BNE    EXEUNT            ;  need more memory-abort
  414.      BMI    20$            ; TCB already assigned
  415. ; first time entry. Check for CONNECT terminal name
  416.     BYP                ; scan past blanks
  417.     CALL    FNDASN            ; find and assign user supplied terminal-name
  418.      BNE    EXEUNT            ;  no match
  419.     ORW    #FIL!LOK,-10(A0)    ; set file and locked in memo flags
  420. 20$:    JOBIDX                ; index A6 to JCB
  421.     ANDW    #^C<J.CCC>,@A6        ; clear control-c
  422.     CALL    CHOICE            ; get user's command choice
  423.     BNE    20$            ;  no such command!
  424.     CALL    PROCES            ; perform user's command
  425.     TSTB    DONE(A0)        ; done ?
  426.      BEQ    20$            ;  no, accept another command.
  427.  
  428. 40$:    CLRB    DONE(A0)
  429.  
  430. ; E X E U N T  - exit back to AMOS
  431. EXEUNT:    EXIT
  432.  
  433. ; I N I M E M 
  434. ; This routine builds, clears and initializes the user's impure area.
  435. INIMEM:    LEA    A6,IMPNAM        ; index impure module name
  436.     SRCH    @A6,A0,F.USR        ; search user area for kermit
  437.     BEQ    10$            ; already present-done
  438.     GETIMP    KSIZE,A0,100$        ; allocate impure area
  439.     CLEAR    @A0,KSIZE        ; clear it (redundant now, so what!)
  440.     LEA    A6,IMPNAM
  441.     MOV    (A6)+,-6(A0)        ; set module name to program name
  442.     MOVW    @A6,-2(A0)        ;  set module extension to .IMP
  443. ; do first time-only inits
  444.     CALL    INI2            ; get JCB & attached TCB addresses
  445.     CALL    INIXFR            ; init xfer section once.
  446.     CALL    OSVER            ; determine O/S version
  447.     CALL    TRMVER            ; determine terminal driver version
  448.     MOVB    #ESCCHR,KMETA(A0)    ; set CONNECT ESCAPE character
  449.     MOVB    #PAKSIZ,MXPKSZ(A0)    ; set maximum packet size allowed [13]
  450.     MOV    #100.,SLPVAL(A0)    ; set sleep ticks for GETREM [14]
  451.     MOVB    #-1,AUTOS(A0)        ; invoke auto-send [15]
  452.     MOVB    #-1,AUTOR(A0)        ; invoke auto-receive [16]
  453.     LCC    #PS.Z
  454.     RTN
  455.  
  456. ; finish re-entry inits
  457. 10$:    CALL    INI2            ; get JCB & attached TCB AGAIN
  458.     BYP                ; [024]
  459.     LIN                ; [024] port named?
  460.     BEQ    20$            ; [024]   no
  461.     TTYL    RENTER            ; [024]   yes, been there, done that!
  462. 20$:    LCC    #PS.N!PS.Z        ; set N and Z if impure already there
  463.     RTN
  464.  
  465. ; not enough memory, so depart
  466. 100$:    TYPECR    <?Insufficient memory for KERMIT.>
  467.     LCC    #0            ; flag no memory
  468.     RTN
  469.  
  470. ; OSVER plays twenty questions games to find out what resources are
  471. ; available in current operating system.
  472. OSVER:    MOV    SYSTEM,D7
  473.     AND    #SY$EXD,D7        ; system supports extended disks?
  474.     SETNE    EXTEND(A0)        ; set flag -1 if extended disk O.K.
  475.     CLRB    COMSER(A0)        ; assume we don't have new comm stuff
  476.     MOV    SYSTEM,D7        ; get system word
  477.     AND    #SY$M20!SY$M30!SY$M40,D7 ; mask to just AMOS/32
  478.     BNE    10$            ; all AMOS/32 has COMSER, CMDLIN
  479.     CMPB    PH.VER+.B8W15,#1.    ; MAJOR higher than 1?
  480.     BHI    10$            ;  yes-use new value
  481.     MOVB    PH.VER+.B16L23,D7    ;  no- get sub release
  482.     ANDB    #^O17,D7        ; strip out VWHO in top 4 bits
  483.     CMPB    D7,#3.            ; is this 1.3?
  484.     BLO    30$            ;  no-1.2 or older, no COMSER
  485.     BHI    10$            ;  no-1.4 or higher COMSER fur sure!
  486.     SETB    WILDOK(A0)        ; wildcarding started in 1.3
  487.     MOVB    PH.VER+.B8L15,D7    ;  exactly 1.3 - check for B
  488.     LSRB    D7,#4.            ; bring it to ground zero.
  489.     CMPB    D7,#'I-'@        ; is it B or higher?
  490.     BEQ    30$            ; 1.3I comes before 1.3B (go figure)
  491.     CMPB    D7,#'B-'@        ; is it B or higher?
  492.     BLO    30$            ;  yes-use new value
  493. 10$:    SETB    WILDOK(A0)        ; O.K. to user CMDLIN.SYS
  494. 20$:    SETB    COMSER(A0)        ; O/S has COMSER routines
  495. 30$:    RTN                ; O/S has got not a lot...
  496.  
  497. ; determine terminal driver resources (7 or 8 bit system & terminal driver)
  498. TRMVER:    MOVB    #^B01111111,CMASK(A0)    ; preset mask for 7 bit terminal
  499.     MOV    SYSTEM,D7        ; get system type
  500.     AND    #SY$EXT,D7        ; does system support 8 bit terms?
  501.     BEQ    10$            ;  no
  502.     MOV    LOCAL(A0),A5        ; A5 indexs local TCB
  503.     MOV    T.TDV(A5),A6        ; index terminal driver
  504.     MOVW    TD.TYP(A6),D7        ; get type word
  505.     ANDW    #TD$NEW,D7        ; is it a "new" TDV
  506.     BEQ    10$            ;  no, use 7 bit mask
  507.     MOV    TD.FLG(A6),D7        ;  yes, get tdv's flag bits
  508.     AND    #TD$EXT,D7        ;  mask
  509.     BEQ    10$            ; tdv is recent, but only 7 bit!
  510.     MOVB    #-1,CMASK(A0)        ;  TDV supports 8 bit terminals
  511. 10$:    RTN
  512.  
  513.  
  514. ; These values are inited every time KERMIT is executed.
  515. INI2:    JOBIDX    A6            ; index A6 to JCB
  516.     MOV    JOBTRM(A6),LOCAL(A0)    ; save address of local TCB
  517.     RTN
  518.  
  519. ; I N I X F R
  520. ; Initialize the the file transfer area
  521. INIXFR:    MOVB    #MYEOL,DF.EOL(A0)    ; set default EOL [17]
  522.     MOVB    #MYCHK,DF.CHK(A0)    ; set default check type
  523.     MOVB    #'N,PARITY(A0)        ; set parity to NONE.
  524.     MOVB    #PAKSIZ,SPSIZ(A0)    ; set max send size
  525. ;
  526.     MOVB    #SOH,RMARK(A0)        ; define start of packet byte
  527.     MOVB    #MYQUOT,QUOTE(A0)    ; set quote char
  528.     MOV    LOCAL(A0),A5        ; set index
  529.     MOVB    #MYPAD,PAD(A0)        ; pad count
  530.     MOVB    #MYPCHR,PADCHR(A0)    ; & character
  531.     MOVB    #TRIES,MAXTRY(A0)    ; set max tries
  532.     MOVB    #'1,CHKT(A0)        ; checkbyte type
  533.     MOV    #08.,TIMINT(A0)        ; set timeout period
  534.     MOV    #08.,DF.TIM(A0)        ; set default timeout period
  535.     RTN    
  536.  
  537. ;  F N D A S N
  538. ; FNDASN finds the user specified TCB, and marks it as busy if found.
  539. ; The "busy" bit in the TCB depends on the O/S version.
  540. ; If the O/S version is before 1.3B AMOS/L, the busy bit is bit 11. of T.STS
  541. ; If the O/S is AMOS/32, or AMOS/L 1.3B or later, the busy is bit 9. of T.STS
  542. FNDASN:    JOBIDX    A6            ; index A6 to JCB
  543.     MOV    JOBTRM(A6),A5        ; index our own TCB as default
  544.     LIN                ; user provide terminal name
  545.     BEQ    25$            ;  no-use our own terminal
  546.     LEA    A1,TNAME(A0)        ; index terminal name storage
  547.     PUSH    A1            ; save for unpack
  548.     PACK
  549.     PACK                ; pack the terminal name RAD50
  550.     POP    A1
  551.     LEA    A2,ATERM(A0)        ; then unpack it for later
  552.     UNPACK
  553.     UNPACK
  554.     CLRB    @A2            ; save ASCII version for SHOW.
  555.     MOV    TNAME(A0),D6        ; D6 gets whole RAD50 terminal name
  556.     LEA    A3,TRMDFC        ; index the head of the TCB chain
  557. 10$:    MOV    @A3,D7            ; get link to next entry
  558.     JEQ    100$            ;  no matching TCB name          [010]
  559.     MOV    D7,A3            ; A3 indexs next element
  560. 20$:    CMPL    D6,4(A3)        ; compare to this entry
  561.     BNE    10$            ;  try next one if no match
  562. ; TCB with matching name is found. Check for prior use
  563.     LEA    A6,10(A3)        ; index A6 to remote TCB         [010]
  564.     CMP    A5,A6            ; using specified own terminal?  [010]
  565.     BNE    22$            ;  no
  566.     CLRB    ATERM(A0)        ;  yes-clear name of terminal to [010]
  567.                     ;  to flag comm port & user's    [010]
  568.                     ;  port are the same.            [010]
  569. 22$:    MOV    A6,A5            ; index A5 to comm port          [010]
  570. 25$:    MOVW    @A5,SAVSTS(A0)        ; save the TCB status      
  571.     CALL    INUSE            ; get proper in-use bits
  572.     TSTB    ATERM(A0)        ; user & comm port the same?     [010]
  573.     BEQ    250$            ;  yes-leave busy bit as is      [010]
  574.     BSET    D6,1(A5)        ; set "assigned" bit
  575.     BNE    110$            ;  already set by prior use-.
  576. 250$:    MOV    A5,REMOTE(A0)        ; save pointer to remote TCB     [010]
  577.     MOV    T.TDV(A5),SAVTDV(A0)    ; save old TDV address
  578. ; find address of PSEUDO TCB in memory for data transfer use.
  579.     MOV    SAVTDV(A0),PSEUDO(A0)    ; preset any TDV in case PSEUDO is gone!
  580.     MOV    TRMTDC,A6        ; get base of tdv chain
  581.     MOV    #[PSE]_16.+[UDO],D7    ; D7 gets PSEUDO in RAD50 notation
  582. 30$:    CMP    D7,4(A6)        ; match ?
  583.     BEQ    40$            ;  yes
  584.     MOV    @A6,A6            ;  no-get next link
  585.     MOV    A6,D6            ; set flags
  586.     BNE    30$            ;  keep trying
  587.     BR    50$             ; give up
  588. 40$:    ADD    #^O10,A6        ; add offset size of link word and name
  589.     MOV    A6,PSEUDO(A0)        ; save address of PSEUDO driver
  590. 50$:    CMP    A5,LOCAL(A0)        ; TCB same as job's terminal's?
  591.     SETEQ    NOTALK(A0)        ;  yes-flag KERMIT owns the data TCB
  592.     BEQ    60$            ;   and bypass TDV swap.
  593. ; swap in PSEUDO terminal driver instead of normal TDV because some TDVs will
  594. ; use multi-byte capture sequences or other translate routines, which will
  595. ; mess up incoming or outgoing data.
  596. ; (There is a cleaner way to do this in newer O/Ss, but it isn't
  597. ; backwards compatible, so we won't bother - rpr 12/31/91)
  598.     MOV    PSEUDO(A0),T.TDV(A5)    ; substitute PSEUDO driver on remote
  599. ; unless TCB is owned by KERMIT job, detach all TCB <=> JCB links
  600. 60$:    MOV    T.JLK(A5),A6        ; get JCB link
  601.     MOV    A6,SAVJCB(A0)        ; save the JCB address for EXIT
  602.     BEQ    70$            ;  TCB already detached-done
  603.     TSTB    NOTALK(A0)        ; TCB owned by KERMIT job?
  604.     BNE    70$            ;  yes-leave it attached
  605.     CLR    JOBTRM(A6)        ;   else detach TCB from job
  606.     CLR    T.JLK(A5)        ;    and job from TCB
  607. 70$:    LCC    #PS.Z
  608.     RTN
  609.  
  610. 100$:    TTYL    NMTN
  611.     LCC    #0
  612.     RTN
  613. 110$:    TYPECR    <?terminal is being used by another job.>
  614.     LCC    #0
  615.     RTN
  616.  
  617. ; INUSE - routine to determine the proper INUSE bit values for this OS.
  618. ; The "busy" bit in the TCB depends on the O/S version.
  619. ; If the O/S version is before 1.3B AMOS/L, the busy bit is bit 11. of T.STS
  620. ; If the O/S is AMOS/32, or AMOS/L 1.3B or later, the busy is bit 9. of T.STS
  621. ; delivers status bit value for BTST to D6
  622. INUSE:
  623.     MOV    #1+8.,D6        ; D6 gets new INUSE bit value
  624.     TSTB    COMSER(A0)        ; do we have COMSER?
  625.     BNE    20$            ;  yes
  626.     MOV    #3.+8.,D6        ; set old INUSE bit
  627. 20$:    RTN
  628.  
  629.  
  630. ; R A W T R M  - set datacomm TCB to pass all data intact, character mode.
  631. RAWTRM:    MOV    REMOTE(A0),A5        ; get index to the TCB
  632.     MOVW    #REMMOD,D1        ; remote mode bits
  633.     CALL    SETSTS            ; set the status
  634.     RTN
  635.  
  636. ; L I N T R M  -  set datacomm TCB for normal AMOSL line mode.
  637. ; except echo is supressed if same TCB for comm & commands
  638. LINTRM:    TSTB    NOTALK(A0)        ; same TCB for comm and job?
  639.     BEQ    10$            ;  no-just return
  640. ; enable line input mode so user can enter commands
  641.     MOV    REMOTE(A0),A5        ;  yes-get index to the TCB
  642.     MOVW    #^C<REMMOD>,D1        ; clear remote mode bits
  643.     CALL    SETSTS            ; clear the status
  644. 10$:    RTN
  645.  
  646. ; P S E T D V  - assign PSEUDO driver if data TCB is owned by KERMIT job.
  647. PSETDV:    TSTB    NOTALK(A0)        ; TCB owned by KERMIT job?
  648.     BEQ    10$            ;  no-no need to swap
  649.     MOV    PSEUDO(A0),T.TDV(A5)    ; swap in PSEUDO driver
  650. 10$:    RTN
  651.  
  652. ; O R G T D V  - set normal terminal driver if data TCB is owned by KERMIT job.
  653. ORGTDV:    TSTB    NOTALK(A0)        ; TCB owned by KERMIT job?
  654.     BEQ    10$            ;  no-no need to swap
  655.     MOV    SAVTDV(A0),T.TDV(A5)    ; swap back real terminal driver
  656. 10$:    RTN
  657.  
  658. ; S E T S L P  - set SLEEP delay time based on serial baud rate
  659. ; added in edit [14]
  660. SETSLP:    MOV    #100.,D6        ; set default value
  661.     CLR    D7
  662.     MOVW    T.BAU(A5),D7        ; get baud rate code
  663.     CMPW    D7,#^O23        ; is it defined in our table?
  664.     BHI    10$            ;  no, use default
  665.     LSLW    D7            ; double index value
  666.     MOVW    SLPTBL[D7],D7        ; get table value in D7
  667.     BEQ    10$    
  668.     MOV    D7,D6
  669. 10$:    MOV    D6,SLPVAL(A0)    ; set sleep value
  670.     RTN
  671.  
  672. ; sleep time in ticks for one character at all defined alpha baud rates
  673. SLPTBL:    WORD    100000./50.
  674.     WORD    100000./75.
  675.     WORD    100000./110.
  676.     WORD    100000./134.
  677.     WORD    100000./150.
  678.     WORD    100000./200.
  679.     WORD    100000./300.
  680.     WORD    100000./600.
  681.     WORD    100000./1200.
  682.     WORD    100000./1800.
  683.     WORD    100000./2000.
  684.     WORD    100000./2400.
  685.     WORD    100000./3600.
  686.     WORD    100000./4800.
  687.     WORD    100000./7200.
  688.     WORD    100000./9600.
  689.     WORD    100000./19200.
  690.     WORD    100000./38400.
  691.     WORD    100000./57600.
  692.     WORD    100000./76800.
  693. ; end [14] additions for SETSLP
  694.  
  695. ; S N O O Z E - delay if data TCB owned by KERMIT job. This gives user
  696. ; time to escape back to the other KERMIT and enter REC.
  697. SNOOZE:    TSTB    NOTALK(A0)        ; data TCB same as KERMITs?
  698.     BEQ    10$            ;  no - do not wait.
  699.     SLEEP    #5.*10000.        ;  yes - wait 5 seconds
  700. 10$:    RTN
  701.  
  702. ;  E V L C H R
  703. ; EVLCHR evaluates the next non-blank character indexed by A2 and
  704. ; returns its value in D1.
  705. ; At exit, A2 is updated, and D1 contains the new character or 0.
  706. ; The Z flag is set if a character was encountered, else Z is clear.
  707. EVLCHR:    CLR    D1            ; pre-clear
  708.     BYP
  709.     LIN                ; end of line?
  710.     BEQ    100$            ;  yes-no characters to process
  711.     NUM                ;  else check for numeric
  712.     BNE    10$            ;   not numeric
  713.     GTDEC                ;   get the value
  714.     BR    40$            ;    and use it
  715.  
  716. ; process non-numeric
  717. 10$:    MOVB    (A2)+,D1
  718.     CMPB    D1,#'^            ; control character prefix ?
  719.     BNE    20$            ;  no-use straight ASCII.
  720.     LIN                ;  yes-check again for end of line
  721.     BEQ    40$            ;   treat as the ^ character [21]
  722.     MOVB    (A2)+,D1        ;   else get next character
  723.     AND     #^O37,D1        ;   mask to control character
  724.     BR    40$            ;   and exit
  725.  
  726. 20$:    CMPB    D1,#SPACE        ; compare to ASCII space
  727.     BLO    100$            ;  invalid argument
  728.     LIN
  729.     BNE    100$            ; bad input, too many chars
  730.     
  731. 40$:    LCC    #PS.Z            ;  arg ok, value in D1
  732.     RTN
  733.  
  734. 100$:    LCC    #0            ; arg is bad.
  735.     RTN
  736.  
  737. ; P R O M P T  displays the KERMIT command prompt.
  738. PROMPT:
  739.     MOV    #CR,D1
  740.     TTY
  741.     TSTB    ATERM(A0)        ; is this kermit the REMOTE?
  742.     BNE    10$            ;  no
  743.     TYPE    <REMOTE >        ;  yes-give user different prompts
  744. 10$:    TTYI                ;  for local & remote kermies.
  745.     ASCII    /Alpha-Kermit >/
  746.     BYTE    0
  747.     EVEN
  748.     RTN
  749.  
  750. ; C H O I C E - prompts the user for command & gets the command.
  751. CHOICE:    CALL    PROMPT            ; prompt the user
  752.     KBD    25$            ; get a command line in line mode
  753.     BYP                ; scan past blanks
  754.     LIN                ; end of line?
  755.     BEQ    CHOICE            ;  ignore blank lines
  756.     LEA    A1,KERCOM        ; index argument list
  757.     CALL    COMAND            ; match the command
  758.     BEQ    30$            ;  command matched
  759. ;  no match - show user bad news.
  760.     TYPE<? >            
  761. 10$:    LIN
  762.     BEQ    20$            ; end of line.
  763.     MOVB    (A2)+,D1        ;  else
  764.     TTY                ;  type the
  765.     BR    10$            ; character and loop
  766. 20$:    TYPECR    <? - undefined command.>; end error display
  767. 25$:    LCC    #0            ; flag no command
  768.     RTN                ; return
  769. 30$:    LCC    #PS.Z            ; flag valid command
  770.     RTN                ; return
  771.  
  772. ; C O M A N D - This subroutine compares the user's command string 
  773. ; to the command list indexed by A1 (e.g. KERCOM).
  774. ; If a match is found, A1 will index the command offset for a tabled call.
  775. ; At entry, A1 indexs the command/subcommand list. A2 indexs user's string.
  776. ; At exit, Z is set to indicate the command was valid.
  777. ; If Z is set, A1 indexs the command offset word.
  778. ;
  779. ; This routine will match the entire command, or to a valid and unique subset
  780. ; of the command name as defined in the table structure.
  781. ; e.g. The string CON will match the command name CONNECT.
  782.  
  783. COMAND:    SUB    #2,A1            ; adjustment for first entry
  784.     BYP                ; scan past seperators
  785.     PUSH    A2            ; save string address for compares
  786.       LIN                ; end of line?
  787.       BEQ    CHO.5            ;  no command-exit.
  788. ; calculate address of next entry and place in A1.
  789. CHO.1:      MOV    @SP,A2            ; restore string pointer
  790.       LEA    A3,2(A1)        ; A3 indexs next entry
  791.       TSTW    @A3            ;  end of table ?
  792.       BEQ    CHO.5            ;   yes-no match.
  793.       MOV    A3,A1            ;   no-get address of command size word
  794.       ADDW    (A3)+,A1        ;  and index to next command.
  795.       CLR    D5
  796.       MOVB    (A3)+,D5        ; D5 gets qualifier size in bytes
  797.  
  798. CHO.2:      TRM                ; check for end of word
  799.       BEQ    CHO.4            ;  yes-check match count
  800.       TSTB    @A3            ;  check for end of table entry
  801.       BEQ    CHO.1            ;  must be wrong if so.
  802. CHO.3:      MOVB    @A2,D1
  803.       UCS                ; convert to upper case
  804.       CMPB    D1,(A3)+        ; compare strings
  805.       BNE    CHO.4            ;  until no match
  806.       ADD    #1,A2            ; advance A2
  807.       TST    D5            ; check for minimum match length
  808.       BEQ    CHO.2            ;  made it-stop counting
  809.       SUB    #1,D5            ; decrement byte count
  810.       BR    CHO.2            ;  keep testing till line is terminated
  811.  
  812. CHO.4:      TST    D5            ; good match has zero count
  813.       BNE    CHO.1            ;  no good-try next
  814.       TRM                ; good match has no more data
  815.       BNE    CHO.1
  816.     POP                ; toss old A2
  817.     LCC    #PS.Z            ; flag command match found
  818.     RTN
  819.  
  820. ; undefined command - Clear Z flag
  821. CHO.5:    POP    A2            ; update A2 to index args
  822.     LCC    #0
  823.     RTN
  824.  
  825. ; P R O C E S
  826. ; Process performs the process defined by the user command.
  827. ; At Entry, A1 indexs the word offset (from A1) of the command address
  828. PROCES:    ADDW    @A1,A1            ; do a tabled called by adding
  829.     CALL    @A1            ; offset @A1 to A1 and executing at
  830.     RTN                ; that new address.
  831.  
  832. ; S E N D sends a file to the remote KERMIT using the KERMIT protocol.
  833. SEND:    TSTB    NOTALK(A0)
  834.     BNE    4$            ; AUTOsend doesn't make sense in REMOTE
  835.     TSTB    AUTOS(A0)        ; automatically sending KERMIT & RECEIVE?
  836.     BEQ    4$            ;  no
  837.     TYPECR    <Sending KERMIT and RECEIVE commands to remote Kermit>
  838.     LEA    A1,PRESND        ; index commands for remote kermit
  839.     CALL    SREMOT            ; send to remote
  840. 4$:    CALL    PREBAT            ; init wildcarding, if present
  841.     BYP
  842. 5$:    CALL    GETNXT            ; get next filename
  843. ; delay inspection of no files error until we are ready to send F packet,
  844. ; then, just send a B packet.
  845.     TSTB    FIO+D.ERR(A0)        ; file error?
  846.     BEQ    6$            ;  no
  847.     CALL    LFERR            ;  yes, display it
  848.     BR    5$            ;  and try for another spec
  849. 6$:    CALL    GTSIZE            ; save file size in bytes
  850.     CALL    STARTT            ; set start time
  851.     CALL    RAWTRM            ; put remote in data mode
  852.     CALL    SNOOZE            ; delay if TCB owned by KERMIT
  853.     CALL    PSETDV            ; swap in PSEUDO driver if needed
  854.     CALL    SETSLP            ; set sleep parameter
  855.     CALL    SENDSW            ; else send the file
  856.     CALL    LINTRM            ; put remote in line mode
  857.     CALL    ORGTDV            ; put back real TDV if PSEUDO used
  858.     TSTB    LOGIC(A0)        ; did it work?
  859.     BMI    10$            ;  yes
  860.     TYPECR    <?SEND failed>        ;  no
  861. 10$:    CALL    STATS
  862. 20$:    RTN
  863.     
  864. 100$:    CALL    LFERR
  865.     RTN
  866.  
  867. ; L F E R R
  868. ; LFERR displays local file errors on the user's CRT
  869. LFERR:    TSTB    NOTALK(A0)        ; do we have a user terminal?
  870.     BNE    10$            ;  no-do not print message.
  871.     TYPE    <Local file error, >
  872.     PFILE    FIO(A0)            ; show filename
  873.     ERRMSG    FIO+D.ERR(A0), OT$TRM!OT$LSP    ; and error message
  874.     CRLF
  875. 10$:    RTN
  876.  
  877. ; R E C E I V - receive a file from remote KERMIT using the KERMIT protocol.
  878. RECEIV:
  879.     MOV    A2,SAVSPC(A0)        ; save user's string ptr
  880.     MOVB    #1,NXTCNT(A0)        ; set count for output spec
  881.     CALL    SCNSTR            ; scan string for AUTO-receive
  882.     CLR    TFILES(A0)
  883.     CLR    TBYTES(A0)
  884.     CLR    TTIME(A0)        ; clear total stat amounts
  885.     MOV    #60.,TIMINT(A0)        ; 60 second timeout
  886.     CALL    SETSLP            ; set sleep parameter
  887.     CALL    PSETDV            ; swap in PSEUDO terminal driver
  888.     CALL    RAWTRM            ; remote TCB to character mode
  889.     CALL    RECSW            ; call receive state manager/switcher
  890.     CALL    LINTRM            ; remote TCB to line mode
  891.     CALL    ORGTDV            ; return to real TDV if PSEUDO used
  892.     TSTB    LOGIC(A0)        ;  test for sucess
  893.     BMI    10$            ;   it worked
  894.     TYPECR    <?RECEIVE failed.>    ;   it didn't work
  895. 10$:    CALL    STATS            ; show elapsed time & speed
  896.     RTN
  897.  
  898. ; scan user spec for = and spec following it. If found, send remote Kermit
  899. ; the commands KERMIT^M, and SEND followed by the user's filespec.
  900. SCNSTR:    
  901.     SAVE    A2
  902.     TSTB    NOTALK(A0)
  903.     BNE    100$            ; AUTOREC doesn't make sense in REMOTE
  904.     TSTB    AUTOR(A0)        ; automatically sending KERMIT & SEND?
  905.     BEQ    100$            ;  no
  906.     BYP
  907.     LIN                ; any parms?
  908.     BEQ    100$            ;  no
  909.     CMPB    @A2,#'=            ; do we have an equal sign?
  910.     BEQ    20$            ;  yes
  911.     FSPEC    FIO(A0),LST        ;  no, use FSPEC to skip past outspec
  912.     BYP
  913. 20$:    CMPB    (A2)+,#'=        ; do we have AUTO spec?
  914.     BNE    100$            ;  no
  915.                     ;  yes
  916.     TYPECR    <Sending KERMIT and SEND commands to remote Kermit>
  917.     LEA    A1,PREREC        ; index commands for remote kermit
  918.     CALL    SREMOT            ; send to remote
  919.     MOV    A2,A1
  920.     CALL    SREMOT            ; send user string ( even CR & LF)
  921. 100$:    REST    A2
  922.     RTN
  923.  
  924. ; G F I L N M
  925. ; This routine gets a filename and places it in FILNAM(A0)
  926. ; At entry, the filename has been loaded in ddb FIO(A0)
  927. ; On exit, FLLEN(A0) contains the length in bytes.
  928. ; Z is set if the filename was valid.
  929. GFILNM:
  930. ; now convert the name to KERMIT standard form which is NAME.EXT.        
  931. ; We must delete all spaces from the filespec.
  932.     LEA    A2,FILNAM(A0)        ; index the target area
  933.     PUSH    A2            ;  and save the index
  934.     LEA    A1,FIO+D.FIL(A0)    ; index the filname in the ddb
  935.     UNPACK
  936.     UNPACK                ; put the ASCII filename @A1
  937.     MOVB    #'.,(A2)+        ; add the comma
  938.     UNPACK
  939.     CLRB    @A2            ; terminate it
  940. ; clean up the filespec by deleting space & other illegal characters.
  941.     POP    A2            ; restore pointer to filnam
  942.     MOV    A2,A1            ; A1 will be write pointer
  943.     CLR    D0            ; D0 counts valid chars we found
  944. 10$:    MOVB    @A2,D1            ; get current char in D7
  945.     BEQ    20$            ;  end of line
  946.     LCS                ; convert to lower case [15]
  947.     CMPB    D1,#'.            ; current char a dot?
  948.     BEQ    20$            ;  yes -it is ok
  949.     ALF                ; is it alpha ?
  950.     BEQ    20$            ;  yes-use it.
  951.     NUM                ; or numeric ?
  952.     BNE    25$            ;  yes-use it
  953.  
  954. 20$:    MOVB    D1,(A1)+
  955.     BEQ    30$            ; end of string
  956.     ADD    #1,D0            ; count how many we found
  957. 25$:    ADD    #1,A2            ; bump pointer
  958.     BR    10$            ; continue scan
  959.  
  960. 30$:    CMP    D0,#3            ; got at least x.x?
  961.     BLO    100$            ; no-invalid filename
  962.     MOVB    D0,FLLEN(A0)        ; save the length
  963.     LCC    #PS.Z            ; valid filename received
  964.     RTN
  965.  
  966. 100$:    LCC    #0            ; bad filename given.
  967.     RTN
  968.     
  969. ; R F I L N M
  970. ; This routine gets the remote filename from NFILNM(A0) 
  971. ; and places it in the FIO(A0) DDB.
  972. ; It then opens the file for input and returns the OPEN condition codes
  973. ; to the caller. Z is set if the open was succesful.
  974. ; [13] revised to not extend filenames or extensions rpr
  975. RFILNM:
  976.     LEA    A2,FILNAM(A0)        ; index the filname
  977.     LEA    A1,COPY(A0)        ; index copy buffer
  978.     CLR    D2
  979.     MOVB    LDATA(A0),D2        ; d2 gets total length of filename
  980.                     ; from remote kermit
  981.     CMP    D2,#30.-1        ; compare to max allowed by definition
  982.     BLOS    10$
  983.     MOV    #30.-1,D2        ; set max
  984. ; terminate filename part to 6 characters
  985. 10$:    MOV    #6.,D0            ; set limit for filename
  986. 20$:    ALF
  987.     BEQ    30$            ; letters ok
  988.     NUM
  989.     BEQ    30$            ; numbers ok, too.
  990.     CMPB    @A2,#'.            ; period?
  991.     BEQ    60$            ;  yes-end of filename!
  992.     BNE    40$            ;  no-toss bad char & continue
  993.  
  994. 30$:    MOVB    @A2,(A1)+        ; save good character
  995. 40$:    ADD    #1,A2            ; advance pointer
  996.     SUB    #1,D2            ; count down total filename size
  997.     BEQ    100$            ;  end of filename (use .KMT extension)
  998.     SUB    #1,D0            ; adjust allowed filename chars
  999.     BNE    20$            ;  more allowed
  1000.                     ;  else wait for a period.
  1001. ; truncate file names longer than 6 characters by waiting for a period
  1002. ; wait for a period
  1003. 50$:    CMPB    @A2,#'.            ; period
  1004.     BEQ    60$            ;  yes-ok.
  1005.     ADD    #1,A2            ;  no-advance ptr
  1006.     SUB    #1,D2            ; count down total filename size
  1007.     BNE    50$            ;  until period or end of file
  1008.     BR    100$            ;  no period found
  1009. ; we found the period (and truncated a long filename)
  1010. 60$:    ADD    #1,A2            ;  no-advance
  1011.     SUB    #1,D2            ; count down original filename size
  1012.     BEQ    100$            ;  no more filename, use default ext!
  1013.     MOVB    #'.,(A1)+        ; buffer a period
  1014.     MOV    #3.,D0            ; max size of extension.
  1015. 70$:    ALF
  1016.     BEQ    80$            ; ok
  1017.     NUM
  1018.     BNE    90$            ; not ok
  1019. 80$:    MOVB    @A2,(A1)+        ; buffer o.k. character
  1020. 90$:    ADD    #1,A2            ; advance pointer
  1021.     SUB    #1,D2            ; count down original filename size
  1022.     BEQ    100$            ; until a period
  1023.     SUB    #1,D0            ; count down
  1024.     BNE    70$            ;  yes
  1025. 100$:    CLRB    (A1)+            ;  no- end with a null
  1026. ; add code to override the name of first file received, if user gave a name
  1027.     TSTB    NXTCNT(A0)        ; been here before?
  1028.     BEQ    106$            ;  yes, not first time
  1029.     MOV    SAVSPC(A0),A2        ;  no, get user spec
  1030.     BYP
  1031.     LIN                ; do we have text?
  1032.     BEQ    106$            ;  no, user name from F packet
  1033.     CMPB    @A2,#'=            ;  yes, is text a filename?
  1034.     BNE    107$            ;   yes, override filename!
  1035.     INC    A2            ; else use name from F packet
  1036.     BYP
  1037. 106$:    CLRB    NXTCNT(A0)
  1038.     LEA    A2,COPY(A0)        ; index the new filename
  1039. 107$:    INIT    FIO(A0)            ; init the ddb
  1040.     FSPEC    FIO(A0),KMT        ; load the ddb with filespec
  1041.     LOOKUP    FIO(A0)            ; does file already exist?
  1042.     BNE    110$            ;  no
  1043.     DSKDEL    FIO(A0)            ;  yes-erase the old one
  1044. 110$:    OPENO    FIO(A0)            ; open it sequentially
  1045.     BNE    120$
  1046.     CALL    STARTT            ; start counting
  1047.     CLR    D7            ; clear Z flag
  1048. 120$:    RTN                ; Z is set if file found
  1049.  
  1050. ; C O N N E C
  1051. ; CONNEC is the local terminal <--> remote terminal conversational routine.
  1052. ; User keypresses are sent (except the ESCAPE or KMETA character) to the
  1053. ; remote computer & incoming characters form the remote are displayed on 
  1054. ; the user's CRT screen.
  1055. CONNEC:    TSTB    NOTALK(A0)        ; using same TCB for in & out?
  1056.     BEQ    4$            ;  no-ok.
  1057.     TTYL    NONONO            ;  tell user it is a no-no
  1058.     RTN
  1059.  
  1060. 4$:    TAS    CFLAG(A0)        ; have we been here before?
  1061.     BNE    5$            ;  yes
  1062.     TTYL    CUSAGE            ;  no, explain CONNECT to user
  1063. 5$:    CALL    RAWTRM            ; set remote in "raw" mode.
  1064.     CALL    SETSLP            ; set sleep parameter
  1065.     CALL    SHOESC            ; show the escape character in effect.
  1066.     MOV    LOCAL(A0),A5        ; A5 indexs local TCB
  1067.     MOVW    #REMMOD,D1        ; allow function key xlation
  1068.     TSTB    CMASK(A0)
  1069.     BPL    6$            ;  7 bit terminal
  1070.     ORW    #T$EXT,D1        ;  8 bit terminal
  1071. 6$:    CALL    SETSTS            ; set them via breakpoint
  1072.     MOV    A5,A4            ; A4 will be the local TCB pointer
  1073.     MOV    REMOTE(A0),A5        ; now A5 indexs REMOTE 
  1074. 10$:    CTRLC    15$            ;  user entered control-c?
  1075.     TST    T.ICC(A4)        ; LOCAL chars present ?
  1076.     BNE    20$            ;  something to do
  1077.     TST    T.ICC(A5)        ; REMOTE chars present ?
  1078.     BNE    20$            ;  something to do
  1079.     SLEEP    SLPVAL(A0)        ; take a one character nap. [14]
  1080.     BR    10$            ; see if the store needs minding now.
  1081.  
  1082. ; handle control-c's by trapping them, unflagging them and sending them out.
  1083. 15$:    JOBIDX                ; index A6 to JCB
  1084.     ANDW    #^C<J.CCC>,@A6        ; clear control-c flag
  1085.     MOV    #3,D1            ; get ASCII equivalent
  1086.     BR    37$            ; send it out
  1087.  
  1088. ; enter here when we have some communications data to move
  1089. 20$:    TST    T.ICC(A5)        ; have remote input ?
  1090.     BEQ    30$            ;  no
  1091.     TTYIN                ;  yes-grab a character
  1092.     CMPB    PARITY(A0),#'N
  1093.     BEQ    25$
  1094.     ANDB    #^B01111111,D1        ; strip to seven if PARITY is on [22]
  1095. 25$:    TTY                ; print it
  1096. 30$:    TCKI                ; have LOCAL input ?
  1097.     BNE    40$            ;  no local input
  1098.     KBD                ;  yes-get local input via KBD
  1099. 35$:    MOVB    D1,D7
  1100.     ANDB    CMASK(A0),D7        ; mask character to 7 or 8 bits
  1101.     CMPB    D7,KMETA(A0)        ; escape character ?
  1102.     BEQ    100$            ;  yes-leave
  1103. ; check for half duplex echoing
  1104.     TSTB    ECHO(A0)        ; got echoing?
  1105.     BEQ    37$            ;  no-full duplex
  1106.     CMPB    D7,#SPACE        ; printable?
  1107.     BHIS    36$            ; yes-echo it
  1108.     CMPB    D7,#CR            ; CR?
  1109.     BEQ    36$             ; yes-echo
  1110.     CMPB    D7,#08.            ; backspace?
  1111.     BEQ    36$             ; yes-echo
  1112.     CMPB    D7,#12            ; line feed ?
  1113.     BNE    37$            ;   ignore other ctl chars
  1114. 36$:    TTY                ;  yes-half duplex,
  1115.                     ;     so echo the character
  1116. ; transmit a character to the remote site.
  1117. 37$:    TTYOUT                ; send byte to REMOTE
  1118. 40$:    BR    10$            ; loop    
  1119.  
  1120. ; exit back to main routine, since user entered ESCAPE character.
  1121. 100$:    MOV    LOCAL(A0),A5        ; index user's TCB
  1122.     MOVW    #REMMOD,D1        ; get char mode bits
  1123.     TSTB    CMASK(A0)
  1124.     BPL    110$            ;  7 bit terminal
  1125.     ORW    #T$EXT,D1        ;  8 bit terminal
  1126. 110$:    COMW    D1            ; flip the bits to clear
  1127.     CALL    SETSTS            ; clear them via breakpoint
  1128. ;;    CALL    LINTRM            ; reset remote TCB to line mode.
  1129.     CRLF
  1130.     RTN
  1131.  
  1132. ; H E L P - inform user as to how KERMIT works.
  1133. HELP:    TTYL    HLP1
  1134.     LEA    A1,KERCOM        ; index argument list
  1135.     CALL    COMAND            ; see if we have an argument
  1136.     BNE    100$            ;  no-show the whole list.
  1137. ; show the selected help line by backing up to the start of it
  1138. 4$:    TSTB    -(A1)            ; backup to non-null
  1139.     BEQ    4$
  1140. 10$:    MOVB    -(A1),D1        ; look for null byte between command
  1141.     BNE    10$            ;  and help strings.
  1142.     CRLF
  1143.     TTYL    1(A1)            ; show the help message
  1144.     CRLF
  1145.     RTN
  1146.  
  1147. ; Show help lines for all commands
  1148. 100$:    LEA    A2,KERCOM        ; index table
  1149. 110$:    MOV    A2,A1
  1150.     CLR    D7
  1151.     MOVW    @A1,D7            ; get offset to end
  1152.     BEQ    140$            ; null is end of table
  1153.     MOV    A1,A2            
  1154.     ADDW    (A1)+,A2        ; A2 indexs the address field
  1155.     ADD    #2,A2            ; A2 now indexs the next entry
  1156.     ADD    #1,A1            ; ignore size byte
  1157.     CLR    D0
  1158.     CALL    PTRTYP            ; type command name
  1159.     TSTB    @A1
  1160.     BNE    120$
  1161.     ADD    #1,A1
  1162. 120$:    CMPB    D0,#09.            ; nine characters?
  1163.     BHI    130$            ;  yes, done spacing
  1164.     INC    D0            ;  no,
  1165.     TYPESP                ;   so space
  1166.     BR    120$            ;         out
  1167. 130$:    CALL    PTRTYP            ; type the help text
  1168.     CRLF
  1169.     BR    110$
  1170.  
  1171. 140$:    CRLF
  1172.     CRLF
  1173.     RTN
  1174.  
  1175. ; S H O W  - Show user the current optional settings & some packet info.
  1176. SHOW:    CALL    KERVER            ; show kermit version
  1177.     TTYL    SH1.0            ; type modem port:
  1178.     LEA    A1,ATERM(A0)        ; index TCB name    
  1179.     TSTB    @A1            ; do we have remote? [1]
  1180.     BNE    10$            ;  yes
  1181.     LEA    A1,SH.DAS        ;  else index dashes
  1182. 10$:    TTYL    @A1            ; show name or dashes
  1183. ; [016] display auto-receive
  1184.     TTYL    SH2.0
  1185.     LEA    A6,SH.ON        
  1186.     TSTB    AUTOR(A0)
  1187.     BNE    20$
  1188.     LEA    A6,SH.OFF
  1189. 20$:    TTYL
  1190. ; [015] display auto-send
  1191.     TTYL    SH2.1
  1192.     LEA    A6,SH.ON        
  1193.     TSTB    AUTOS(A0)
  1194.     BNE    30$
  1195.     LEA    A6,SH.OFF
  1196. 30$:    TTYL
  1197. ; display bell
  1198.     TTYL    SH2.2            ; do end of line 1 & BELL label
  1199.     LEA    A6,SH.OFF
  1200.     TSTB    DING(A0)
  1201.     BEQ    40$
  1202.     LEA    A6,SH.ON
  1203. 40$:    TTYL                ; show on or off
  1204. ; display blockcheck
  1205.     TTYL    SH2.3            ; blockcheck selected label
  1206.     MOVB    DF.CHK(A0),D1
  1207.     TTY
  1208. ; display debug
  1209.     TTYL    SH2.4            ; show DEBUG label
  1210.     LEA    A6,SH.OFF
  1211.     TSTB    DEBUGO(A0)
  1212.     BEQ    50$
  1213.     LEA    A6,SH.ON
  1214. 50$:    TTYL
  1215. ; show duplex
  1216.     TTYL    SH2.5            ; then type duplex label
  1217.     LEA    A6,SH.FUL        ; assume FULL
  1218.     TSTB    ECHO(A0)        ; check duplex 0=full, -1=half
  1219.     BEQ    60$
  1220.     LEA    A6,SH.HAL        ; o.k., then, HALF.
  1221. 60$:    TTYL                ; type string @A6
  1222. ; display user's endline
  1223.     TTYL    SH3.2            ; end of line 3, ENDLINE label
  1224. ;[012] display end-of-line character in use, rather than default
  1225.     MOVB    DF.EOL(A0),D1        ; set end of line char
  1226.     BNE    65$
  1227.     TTYL    SH.ZIP
  1228.     BR    67$            ; [015]
  1229. 65$:    TYPE    < >
  1230.     CALL    SHOCHR
  1231. 67$:
  1232. ; display ESCAPE
  1233.     TTYL    SH2.6            ; show ESCAPE label
  1234.     CLR    D1            ; preclear D1
  1235.     MOVB    KMETA(A0),D1
  1236.     CALL    SHOCHR            ; show escape character
  1237. ; display PACKETSIZE
  1238.     TTYL    SH2.7
  1239.     CLR    D1
  1240.     MOVB    MXPKSZ(A0),D1        ; set max value
  1241.     DCVT    4,OT$TRM!OT$ZER
  1242. ; display PACKETSTART
  1243.     TTYL    SH2.7A
  1244.     MOVB    RMARK(A0),D1
  1245.     CALL    SHOCHR
  1246. ; display PARITY
  1247.     TTYL    SH2.8            ; type parity label
  1248.     MOVB    PARITY(A0),D1
  1249.     CALL    SHOCHR
  1250. ; display default retries
  1251.     TTYL    SH2.8A
  1252.     MOVB    MAXTRY(A0),D1
  1253.     DCVT    4,OT$TRM!OT$ZER
  1254. ; display stall time in hundredths of seconds
  1255.     TTYL    SH2.9
  1256.     CLR    D1
  1257.     MOVB    STLCHR(A0),D1
  1258.     DCVT    4,OT$TRM!OT$ZER
  1259. ; display default TIMOUT
  1260.     TTYL    SH2.9A            ; show timeout label
  1261.     MOV    DF.TIM(A0),D1        ;  
  1262.     DCVT    4,OT$TRM!OT$ZER
  1263.     CRLF
  1264. ; display packet parameters
  1265. ; display blockchek
  1266.     TTYL    SH3.0
  1267.     MOVB    CHKT(A0),D1        ; get check type
  1268.     TTY
  1269. ; display eight bit quote
  1270.     TTYL    SH3.1
  1271.     MOVB    QBIN(A0),D1
  1272.     BMI    70$            ; 7 bit path
  1273.     BNE    80$            ; we have a real 8B quote, show it
  1274.     TTYL    SH.ZIP            ; we don't need 8B quote so far
  1275.     BR    90$
  1276. 70$:    MOVB    #'&,D1            ; show default 8 bit quote
  1277. 80$:    TYPE    < >
  1278.     CALL    SHOCHR
  1279. 90$:    
  1280. ; display endline
  1281.     TTYL    SH3.2            ; end of line 3, ENDLINE label
  1282. ;[012] display end-of-line character in use, rather than default
  1283.     MOVB    DF.EOL(A0),D1        ; set end of line char
  1284.     BNE    100$
  1285.     TTYL    SH.ZIP
  1286.     BR    110$            ; [015]
  1287. 100$:    TYPE    < >
  1288.     CALL    SHOCHR
  1289. ; display max packet size
  1290. 110$:    TTYL    SH3.3            ; do end of line 2, packet parms.
  1291.     CLR    D1
  1292.     MOVB    SPSIZ(A0),D1        ; get packet size
  1293.     DCVT    4,OT$TRM!OT$ZER
  1294. ; display packet end
  1295.     TTYL    SH3.4            ; show number of pads            
  1296.     MOVB    PAD(A0),D1        ; 
  1297.     DCVT    2,OT$TRM!OT$ZER
  1298.     TTYL    SH3.5            ; show pad character value
  1299.     MOVB    PADCHR(A0),D1        ; 
  1300.     CALL    SHOCHR
  1301.     TTYL    SH3.6            ; show timout label
  1302.     MOV    TIMINT(A0),D1        ;  
  1303.     DCVT    4,OT$TRM!OT$ZER
  1304.     TTYL    SH3.8
  1305.     RTN
  1306.  
  1307. ; S E T  - allow user to change some parameters.
  1308. ; SET command accepts a sub-command (or argument) to define the action.
  1309. ; If no sub-command is given, a short expansion of the subcommands is given.
  1310. SET:    BYP
  1311.     LIN                ; end of line?
  1312.     BEQ    100$            ;  yes-show user what can be set.
  1313.     CMPB    @A2,#'?            ; user wants some help?
  1314.     BEQ    100$            ;  yes-show user what he can set.
  1315.     LEA    A1,SETCOM        ; index set command list
  1316.     CALL    COMAND            ; see if we have an argument
  1317.     BNE    10$            ;  no-show user no can do.
  1318. ; perform the desired function. Each function does its own error-checking.
  1319.     CALL    PROCES            ; do the set
  1320.     RTN
  1321.  
  1322. 10$:    TYPE<? >            ;  no match - show user bad news.
  1323. 15$:    LIN                ; end of line?
  1324.     BEQ    20$            ;  yes-done typing user's entry
  1325.     MOVB    (A2)+,D1
  1326.     TTY                ; type a character
  1327.     BR    15$            ; until the end of line
  1328. 20$:    TYPECR    <? - undefined command.>
  1329. 25$:    RTN
  1330.  
  1331. ; Show explanation for all set commands
  1332. 100$:    TTYL    SET1
  1333.     LEA    A2,SETCOM        ; index table
  1334. 110$:    MOV    A2,A1
  1335.     CLR    D7
  1336.     MOVW    @A1,D7            ; get offset to end
  1337.     BEQ    140$            ; null is end of table
  1338.     MOV    A1,A2            
  1339.     ADDW    (A1)+,A2        ; A2 indexs the address field
  1340.     ADD    #2,A2            ; A2 now indexs the next entry
  1341.     ADD    #1,A1            ; ignore size byte
  1342.     CLR    D0            ; [015] count characters
  1343.     CALL    PTRTYP            ; type command name
  1344.     TSTB    @A1
  1345.     BNE    120$
  1346.     ADD    #1,A1
  1347. 120$:    CMPB    D0,#11.            ; eleven characters?
  1348.     BHI    130$            ;  yes, done spacing
  1349.     INC    D0            ;  no,
  1350.     TYPESP                ;   so space
  1351.     BR    120$            ;         out
  1352. 130$:    CALL    PTRTYP            ; type the help text
  1353.     CRLF
  1354.     BR    110$
  1355.  
  1356. 140$:    CRLF
  1357.     CRLF
  1358.     RTN
  1359.  
  1360. ;;        S E T   S U B C O M M A N D S
  1361.  
  1362. ; B E L L - set bell after each command completeion flag.
  1363. BELL:    LEA    A1,ONOFF        ; index option list
  1364.     CALL    GETOPT            ; process option
  1365.     BNE    10$            ;  no good
  1366.     MOVB    D1,DING(A0)        ; set bell option
  1367. 10$:    RTN
  1368.  
  1369. ; D U P L E X - set half or full duplex.
  1370. DUPLEX:    LEA    A1,EPLEX        ; index echoplex options
  1371.     CALL    GETOPT            ; process option
  1372.     BNE    10$            ;  no good
  1373.     MOVB    D1,ECHO(A0)        ; set duplex option
  1374. 10$:    RTN
  1375.  
  1376.  
  1377. ; B L O C K - set default check type. 1, 2 or 3 byte check types
  1378. BLOCK:    LEA    A1,ONE23        ; index check-type options
  1379.     CALL    GETOPT
  1380.     BNE    10$            ; no good
  1381.     MOVB    D1,DF.CHK(A0)        ; set default check type
  1382. 10$:    RTN
  1383.  
  1384. ; D E B U G - Set debug message print flag.
  1385. DEBUG:    LEA    A1,ONOFF        ; allow YES or NO.
  1386.     CALL    GETOPT
  1387.     BNE    10$
  1388.     MOVB    D1,DEBUGO(A0)        ; set debug option
  1389. 10$:    RTN
  1390.  
  1391. ; A U T S N D - Set AUTOSEND option flag.
  1392. AUTSND:    LEA    A1,ONOFF        ; allow YES or NO.
  1393.     CALL    GETOPT
  1394.     BNE    10$
  1395.     MOVB    D1,AUTOS(A0)        ; set autosend option
  1396. 10$:    RTN
  1397.  
  1398. ; A U T R E C - Set AUTORECEIVE option flag.
  1399. AUTREC:    LEA    A1,ONOFF        ; allow YES or NO.
  1400.     CALL    GETOPT
  1401.     BNE    10$
  1402.     MOVB    D1,AUTOR(A0)        ; set autosend option
  1403. 10$:    RTN
  1404.  
  1405. ; E N D L I N - set optional end of packet character. (normally CR.)
  1406. ENDLIN:    CALL    EVLCHR            ; get the character
  1407.     BNE    10$        
  1408.     MOVB    D1,DF.EOL(A0)        ; set default EOL
  1409. 10$:    RTN
  1410.  
  1411. ; P A K M R K - set optional start of packet character. (normally CR.)
  1412. PAKMRK:    CALL    EVLCHR            ; get the character
  1413.     BNE    10$        
  1414.     MOVB    D1,RMARK(A0)        ; set default MARK character
  1415. 10$:    RTN
  1416.  
  1417.  
  1418. ; E S C A P E - set the escape from CONNECT mode character.
  1419. ESCAPE:    CALL    EVLCHR
  1420.     BNE    10$            ; no good
  1421.     ANDB    CMASK(A0),D1        ; limit to valid character set range
  1422.     MOVB    D1,KMETA(A0)        ; set escape character
  1423. 10$:    RTN
  1424.  
  1425. ; T I M E R - set the timeout period used in packet transmission.
  1426. TIMER:    BYP
  1427.     GTDEC                ; get decimal number
  1428.     CMP    D1,#MINTIM        ; compare to minimum time
  1429.     BHIS    10$            ; allow 2 or more
  1430.     MOV    #MINTIM,D1        ;  force minimum
  1431.     TYPECR    <Setting timeout to 2 second minimum.>
  1432. 10$:    MOV    D1,DF.TIM(A0)        ; set default and
  1433.     MOV    D1,TIMINT(A0)        ; current timer value
  1434.     RTN
  1435.  
  1436. ; N E W T R Y   - sets the maximum # of tries for a packet.
  1437. NEWTRY:    BYP
  1438.     GTDEC
  1439.     TST    D1            ; test new value
  1440.     BEQ    20$            ; zero is too few!
  1441.     CMP    D1,#255.        ; this is max was ^O255
  1442.     BHI    20$            ;  too high-leave as is
  1443.     MOVB    D1,MAXTRY(A0)        ; set max value
  1444.     RTN
  1445. 20$:    TTYI
  1446.     ASCII    /?value out of range?/
  1447.     BYTE    A.BEL,CR,0
  1448.     EVEN
  1449.     RTN
  1450.  
  1451. ; P A K M A X - set maximum packet size supported
  1452. PAKMAX:    BYP
  1453.     GTDEC
  1454.     CMP    D1,#10.            ; compare to minimum
  1455.     BLO    20$            ;  too small [16]
  1456.     CMP    D1,#PAKSIZ        ; compare to max size allowed
  1457.     BHI    20$            ;  too high-leave as is
  1458.     MOVB    D1,MXPKSZ(A0)        ; set max value
  1459.     MOVB    D1,SPSIZ(A0)        ; set max send size, too!
  1460.     RTN
  1461.  
  1462. 20$:    TTYI
  1463.     ASCII    /?select a packet size from 10 to 94 bytes./
  1464.     BYTE    A.BEL,CR,0
  1465.     EVEN
  1466.     RTN
  1467.  
  1468. ; S E T P A R - set the parity type (already in use) by the remote
  1469. ; This allows Alpha-Kermit to know whether 8bit quoting is needed, or not.
  1470. SETPAR:    LEA    A1,PARLST        ; allow YES or NO.
  1471.     CALL    GETOPT
  1472.     BNE    10$
  1473.     MOVB    D1,PARITY(A0)        ; set parity
  1474.     CMPB    D1,#'N            ; no parity?
  1475.     SETNE    QBIN(A0)
  1476.     TTYL    NOSET            ; tell user limitations
  1477. 10$:    RTN
  1478.  
  1479. ; S T L V A L  - set # of 100ths of seconds to stall between output
  1480. ; characters for file transfers.
  1481. STLVAL:    BYP
  1482.     GTDEC
  1483.     TST    D1            ; test new value
  1484.     BEQ    20$            ; zero is too few!
  1485.     CMP    D1,#255.        ; this is max was ^O255
  1486.     BHI    20$            ;  too high-leave as is
  1487.     MOVB    D1,STLCHR(A0)        ; set max value
  1488.     RTN
  1489. 20$:    TTYI
  1490.     ASCII    /?STALL range is 0 to 255 hundredths of seconds./
  1491.     BYTE    A.BEL,CR,0
  1492.     EVEN
  1493.     RTN
  1494.  
  1495.  
  1496. ; G E T O P T  - compares the input option @A2 to the option list @A1.
  1497. ; If there is a match, the match number is returned in D1 and Z is set.
  1498. ; No match returns Z clear and displays the error message at  the end of the
  1499. ; option list.
  1500. GETOPT:    SUB    #2,A1            ; adjustment for first entry
  1501.     BYP                ; scan past seperators
  1502.     PUSH    A2            ; save string address for compares
  1503. ; calculate address of next entry and place in A1.
  1504. OPT.1:    MOV    @SP,A2            ; restore string pointer
  1505.     LEA    A3,2(A1)        ; A3 indexs next entry
  1506.     TSTW    @A3            ;  end of table ?
  1507.     BEQ    OPT.5            ;   yes-no match.
  1508.     MOV    A3,A1            ;   no-get address of command size word
  1509.     ADDW    (A3)+,A1        ;  and index to next command.
  1510.     CLR    D5
  1511.     MOVB    (A3)+,D5        ; D5 gets qualifier size in bytes
  1512.  
  1513. OPT.2:    TRM                ; check for end of word
  1514.     BEQ    OPT.4            ;  yes-check match count
  1515.     TSTB    @A3            ;  check for end of table entry
  1516.     BEQ    OPT.1            ;  must be wrong if so.
  1517. OPT.3:    MOVB    @A2,D1
  1518.     UCS                ; convert to upper case
  1519.     CMPB    D1,(A3)+        ; compare strings
  1520.     BNE    OPT.4            ;  until no match
  1521.     ADD    #1,A2            ; advance A2
  1522.     TST    D5            ; check for minimum match length
  1523.     BEQ    OPT.2            ;  made it-stop counting
  1524.     SUB    #1,D5            ; decrement byte count
  1525.     BR    OPT.2            ;  keep testing till line is terminated
  1526.  
  1527. OPT.4:    TST    D5            ; good match has zero count
  1528.     BNE    OPT.1            ;  no good-try next
  1529.     TRM                ; good match has no more data
  1530.     BNE    OPT.1
  1531.     POP                ; toss old A2
  1532.     CLR    D1
  1533.     MOVB    @A1,D1            ; D1 gets argument value
  1534.     LCC    #PS.Z            ; flag command match found
  1535.     RTN
  1536.  
  1537. ; undefined command - Clear Z flag
  1538. OPT.5:    POP    A2
  1539.     TTYL    2(A3)            ; display error message at end of list
  1540.     CRLF                ; [15]
  1541.     LCC    #0
  1542.     RTN                ; return with Z clear
  1543.  
  1544. ; P T R T Y P  - print the string indexed by A1 until a null is found.
  1545. PTRTYP:    MOVB    (A1)+,D1
  1546.     BEQ    10$
  1547.     INC    D0            ; count characters
  1548.     TTY
  1549.     BR    PTRTYP
  1550. 10$:    RTN
  1551.  
  1552. ; G O O D B Y  - exit from KERMIT to AMOS for good.
  1553. ; re-attach comm TCB to its former JCB, if any.
  1554. GOODBY:    ANDW    #^C<FIL!LOK>,-10(A0)    ; clear file and locked in mem flags
  1555.     MOV    REMOTE(A0),A5
  1556.     MOV    #^C<REMMOD>,D1        ; clear bits we set (except OIP)
  1557.     CALL    INUSE            ; get in-use bit
  1558.     TSTB    ATERM(A0)        ; user & comm port the same?     [010]
  1559.     BEQ    4$            ;  yes-leave busy bit as is      [010]
  1560.     BCLR    D6,D1            ; clear it for bit clear mask
  1561. 4$:    CALL    SETSTS            ; clear all those bits
  1562.     CLR    D1
  1563.     MOVW    SAVSTS(A0),D1        ; get saved status
  1564.     AND    #^CT$OIP,D1        ;  less OIP bit which hangs output!
  1565.     CALL    SETSTS            ; set the saved bits
  1566.     MOV    SAVJCB(A0),A6
  1567.     MOV    A6,T.JLK(A5)        ; restore any attached job
  1568.     BEQ    10$
  1569.     MOV    A5,JOBTRM(A6)        ; and JCB, if there was one
  1570. 10$:    MOV    SAVTDV(A0),T.TDV(A5)    ; restore TDV
  1571.     SAVE    A0            ; [16] JRUN the newly reattached job,
  1572.                     ; if it is waiting for OIP
  1573.     MOV    SAVJCB(A0),D7        ; get saved job
  1574.     BEQ    20$            ;  no saved job
  1575.     MOV    D7,A0
  1576.     MOVW    JOBSTS(A6),D7        ; get job status
  1577.     ANDW    #J.TOW,D7        ; was job waiting for output?
  1578.     BEQ    20$            ;  no
  1579.     JRUN    J.TOW            ;  yes
  1580. 20$:    REST    A0
  1581.     SETB    DONE(A0)        ; set the we are done flag
  1582.     RTN
  1583.  
  1584. ; A M O S - move to AMOS level temporarily.
  1585. AMOS:    SETB    DONE(A0)        ; set the we are done flag    
  1586.     RTN
  1587.  
  1588. ; S E T S T S
  1589. ; This routine sets or clears status bits in D1.
  1590. ; If D1 is minus, the bits are cleared. If they are +, the bits are set
  1591.  
  1592. ; This routine is used to set and reset TRMSER status word bits without
  1593. ; getting T$OIP fouled up and hanging the job's output.
  1594. SETSTS:    SUPVR
  1595. ; This routine runs in SUPVR mode
  1596. ; Used to change TRMSER status bits.
  1597. ; Made compatible with smart I/O cards by using new monitor calls if
  1598. ; O/S is new enough for it.
  1599.     SVLOK                ; prevent interrupts
  1600.     TSTB    COMSER(A0)        ; do we have COMSER? [015]
  1601.     BEQ    8$            ;  no, do it old way
  1602.     TSTW    D1            ; clear or set bits?
  1603.     BMI    4$            ; clear bits
  1604. ; new way to change T.STS word without violating T.SEM rules.
  1605.     PUSHW    D1
  1606.     TRMRST    D1,@A5            ; read status
  1607.     ORW    (SP)+,D1        ; stir in the new bits
  1608.     TRMWST    D1,@A5            ; write status
  1609.     BR    20$
  1610. 4$:    PUSHW    D1
  1611.     TRMRST    D1,@A5            ; read status
  1612.     ANDW    (SP)+,D1        ; pick out the icky bits
  1613.     TRMWST    D1,@A5            ; write status
  1614.     BR    20$
  1615.  
  1616. ; old way to change T.STS word
  1617. 8$:    TSTW    D1            ; set or clear bits?
  1618.     BMI    10$            ;  clear is negative
  1619.     ORW    D1,@A5            ; set bits if + or 0.
  1620.     BR    20$            ; done setting...
  1621. 10$:    ANDW    D1,@A5            ; clear those bits
  1622. 20$:    LSTS    #0            ; unlock CPU & return to user mode
  1623.     RTN
  1624. ;;;         F I L E   T R A N S F E R   R O U T I N E S
  1625.  
  1626. ; S E N D S W
  1627. ; SENDSW is the state table switch for file transfers. It loops either
  1628. ; until it finishes, or an error is encountered. The routines called
  1629. ; by SENDSW change the automaton state.
  1630. SENDSW:
  1631.     MOVB    #'S,STATE(A0)        ; start with SEND INIT
  1632.     CLRB    N(A0)            ; clear the seq number
  1633.     CLRB    NUMTRY(A0)        ;  and the retry count
  1634.     CLRB    LOGIC(A0)        ; CLEAR LOGIC
  1635.     CLRB    RIACK(A0)        ; clear the I is ACKed flag
  1636. 10$:    TSTB    LOGIC(A0)        ; test logic flag
  1637.     BNE    100$            ;  we are done
  1638.     CTRLC    ABORT            ; exit on control-C
  1639.     TSTB    DEBUGO(A0)        ; debug on ?
  1640.     BEQ    20$            ;   no
  1641.     TYPE    <SENDSW state >
  1642.     MOVB    STATE(A0),D1
  1643.     TTY
  1644.     CRLF
  1645.     CRLF
  1646. 20$:    LEA    A6,SWSTAT-4        ; index the state table
  1647.     MOVB    STATE(A0),D7        ; D7 gets the current state
  1648. 30$:    ADD    #4.,A6            ; pre-advance
  1649.     MOVB    @A6,D6
  1650.     BEQ    100$            ; undefined state - so exit
  1651.     CMPB    D6,D7            ;  matching state ?
  1652.     BNE    30$            ;   no
  1653.     ADD    #2.,A6            ; yes - advance to offset
  1654.     ADDW    @A6,A6            ; calc address of new routine
  1655.     CALL    @A6            ; execute it
  1656.     BR    10$            ; loop till we exit
  1657. 100$:    RTN
  1658.  
  1659. ABORT:    MOVB    #'A,STATE(A0)        ; flag it as bad.
  1660.     MOVB    #FALSE,LOGIC(A0)
  1661.     CALL    CLOSER
  1662.     RTN
  1663.  
  1664. COMPLT:    MOVB    #TRUE,LOGIC(A0)        ; flag complete o.k.
  1665.     RTN
  1666.  
  1667.  
  1668. ; S I N I T
  1669. ; Send (I) Initiate Packet & receive REMOTEs reply
  1670.  
  1671. SINIT:    ADDB    #1,NUMTRY(A0)        ; bump # of tries
  1672.     CMMB    NUMTRY(A0),MAXTRY(A0)    ; beyond the max?
  1673.     BLOS    20$
  1674.     MOVB    #'A,STATE(A0)
  1675. 10$:    RTN
  1676.  
  1677. 20$:    LEA    A3,PACKET(A0)        ; index the packet area
  1678.     CALL    SPAR            ; load default data for S packet
  1679.     CALL    FLUSH            ; flush pending input
  1680.     MOVB    DF.EOL(A0),EOL(A0)    ; use default EOL
  1681.     SPACK    #'S,N(A0),#PARSIZ,PACKET(A0)    ; send an S packet
  1682. ; just in case host requires an EOL character, send the default EOL value.
  1683.     MOVB    #CR,D1            ; send universal EOL value
  1684.     CALL    OUTBYT            ; output the EOL to get remote going
  1685. ;    RPACK    LEN,SEQ,PACKET,TYPE
  1686.     RPACK    D2,D3,RECPKT(A0),D4    ; receive a packet
  1687.     BNE    1000$            ; no packet received ; timeout
  1688.                     ;  or damaged packet
  1689.     CMPB    D4,#'N            ; NAK, try again
  1690.     JEQ    1000$            ;  just return, leave state as is.
  1691.     CMPB    D4,#'Y            ; ACK ?
  1692.     BNE    30$            ;  no ACK
  1693.     CMPB    D3,N(A0)        ;  yes-same # as I sent?
  1694.     BNE    1000$            ;   no-return, same state
  1695. ; get other side's init info.
  1696.     SETB    RIACK(A0)        ; flag we got ACK to I packet
  1697.     LEA    A3,RECPKT(A0)        ; index work area
  1698.     CALL    RPAR            ; load parameters from work area
  1699.     CMPB    QUOTE(A0),#SPACE    ; check for space or null
  1700.     BHI    32$
  1701.     MOVB    #MYQUOT,QUOTE(A0)    ; reset to #
  1702. 32$:    CLRB    NUMTRY(A0)        ; clear retries
  1703.     CALL    BUMPP            ; bump N mod 64.
  1704.     MOVB    #'F,STATE(A0)        ; move to state F
  1705.     JMP    1000$            ; done
  1706. 30$:    CMPB    D4,#'E            ; error packet received ?
  1707.     BNE    40$            ;  no
  1708.     CALL    PRTERR            ; show error
  1709. ; move to abort state on any undefined TYPEs
  1710. 40$:    MOVB    #'A,STATE(A0)        ; move to abort state.
  1711. 1000$:    RTN
  1712.  
  1713. ; S F I L E sends the file header.
  1714. SFILE:    TSTB    FIO+D.ERR(A0)        ; error on input file?
  1715.     BNE    2$            ;  yes, move to break state
  1716.     MOV    CMNEXT(A0),D7
  1717.     AND    #NX$END,D7        ; end of specs?
  1718.     BEQ    4$            ;  no
  1719. 2$:    MOVB    #'B,STATE(A0)        ;  yes, send a break
  1720.     RTN
  1721.  
  1722. 4$:    INCB    NUMTRY(A0)        ; bump the count
  1723.     CMMB    NUMTRY(A0),MAXTRY(A0)    ; beyond the max?
  1724.     BLOS    10$            ;  no
  1725.     MOVB    #'A,STATE(A0)        ; set state to abort
  1726.     RTN
  1727.  
  1728. 10$:    CLR    D2
  1729.     MOVB    FLLEN(A0),D2
  1730. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  1731.     SPACK    #'F,N(A0),D2,NFILNM(A0)    ; send the F packet
  1732.  
  1733. ;     RPACK    LEN,SEQ,PACKET,TYPE
  1734.     RPACK    D2,D3,RECPKT(A0),D4        ; wait for reply
  1735.     BNE    1000$                ; no reply
  1736. ; compare received sequence # to expected #
  1737.     CMPB    D4,#'N            ; NAK ?
  1738.     BNE    30$            ;  no NAK here
  1739. ; check to see if NAK is for next block, which we will
  1740. ; interpret as being an ACK for this block.
  1741.     CALL    NEXTN            ; D1 gets NEXT packet #
  1742.     CMPB    D1,D3            ; NAK for next block ?
  1743.     BNE    1000$            ;  no-return with state unchanged
  1744.     BR    35$            ;  yes-treat as ACK for this block
  1745.  
  1746. 30$:    CMPB    D4,#'Y            ; ACK ?
  1747.     BNE    40$            ;  no
  1748.     MOVB    N(A0),D1        ; D1 gets current SEQ #
  1749.     CMPB    D3,D1            ;  yes-is it expected SEQ?
  1750.     BNE    1000$            ;   no-return state unchanged
  1751. 35$:    CLRB    NUMTRY(A0)        ;   yes-clear retries count
  1752.     CALL    BUMPP
  1753.     LEA    A3,PACKET(A0)
  1754.     CALL    BUFFIL            ; fill a buffer @A3
  1755.     MOVB    #'D,STATE(A0)        ; goto Data state
  1756.     JMP    1000$
  1757.  
  1758. 40$:    CMPB    D4,#'E            ; Error packet received
  1759.     BNE    50$
  1760.     CALL    PRTERR            ; show the error
  1761. ; if any other case, move to abort case
  1762. 50$:    MOVB    #'A,STATE(A0)        ; move to abort state
  1763. 1000$:    RTN
  1764.  
  1765. ; S D A T A  - sends a portion of file contents
  1766. SDATA:    INCB    NUMTRY(A0)        ; bump try count
  1767.     CMMB    NUMTRY(A0),MAXTRY(A0)    ; maxxed out ?
  1768.     BLOS    10$            ;  no    
  1769.     MOVB    #'A,STATE(A0)        ;  yes-move to abort state
  1770.     RTN
  1771.  
  1772. 10$:    
  1773. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  1774.     SPACK    #'D,N(A0),BUFCNT(A0),PACKET(A0)    ; send data packet
  1775. ;    RPACK    LEN,SEQ,PACKET,TYPE
  1776.     RPACK    D2,D3,RECPKT(A0),D4    ; receive a packet
  1777.     JNE    1000$            ;  no data received
  1778.     CMPB    D4,#'N            ; NAK ?
  1779.     BNE    15$            ;  no
  1780.     CALL    NEXTN            ; D1 gets N
  1781.     CMPB    D1,D3            ; NAK for N+1?
  1782.     BEQ    40$            ;  yes-treat as lost ACK for N
  1783.     JMP    1000$            ; else exit state unchanged
  1784.  
  1785. 15$:    CMPB    D4,#'Y            ; ACK ?
  1786.     BNE    70$            ; no
  1787.     CMPB    D3,N(A0)        ; right SEQ of ACK?
  1788.     BNE    1000$            ;  no-state unchanged
  1789.     TSTB    LDATA(A0)        ; is data length zero?
  1790.     BEQ    30$            ;  yes
  1791. ;test for graceful abort request from RECeiving Kermit.
  1792.     MOVB    RECPKT+DATA(A0),D7    ;  no-get the byte
  1793.     ANDB    #^O177,D7        ; strip to ACSII
  1794.     CMPB    D7,#'Z            ; is it abort batch?
  1795.     BNE    20$            ;  no
  1796.     SETB    ABORTB(A0)        ;  yes, set abort batch flag
  1797.     BR    30$            ; 
  1798. 20$:    CMPB    D7,#'X            ; is it abort file?
  1799.     BNE    30$            ;  yes
  1800.     SETB    ABORTF(A0)
  1801. 30$:    CALL    SHODOT            ; tell user we moved some data
  1802. 40$:    CALL    BUMPP            ; bump packet count
  1803.     TSTB    ABORTF(A0)        ; abort file?
  1804.     BNE    50$            ;  yes
  1805.     CLRB    NUMTRY(A0)        ; clear the try count
  1806.     LEA    A3,PACKET(A0)        ; index the Packet
  1807.     CALL    BUFFIL            ; get a buffer
  1808.     TSTB    BUFCNT(A0)        ; any data to send ?
  1809.     BNE    60$    
  1810. 50$:    CALL    CLOSER            ; close file
  1811.     MOVB    #'Z,STATE(A0)        ; move to Z state (end of file)
  1812.     JMP    1000$
  1813. 60$:    MOVB    #'D,STATE(A0)        ; stay in D state
  1814.     JMP    1000$
  1815. 70$:    CMPB    D4,#'E            ; Error packet ?
  1816.     BNE    1000$
  1817.     CALL    PRTERR
  1818.     MOVB    #'A,STATE(A0)        ; move to A state.
  1819. 1000$:    RTN
  1820.     
  1821. ; S E O F  - send the end of file packet.
  1822. SEOF:    INCB    NUMTRY(A0)
  1823.     CMMB    NUMTRY(A0),MAXTRY(A0)
  1824.     BLOS    10$
  1825.     MOVB    #'A,STATE(A0)
  1826.     RTN
  1827.  
  1828. 10$:    CLR    D2            ; D2 is packet size
  1829.     TSTB    ABORTF(A0)        ; aborting this file ( or batch)?
  1830.     BEQ    20$            ;  no
  1831.     MOV    #1,D2            ;  yes, set size to 1 byte
  1832.     MOVB    #'D,PACKET+DATA(A0)    ; flag "DISCARD" to remote
  1833. 20$:
  1834. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  1835.     SPACK    #'Z,N(A0),D2,PACKET(A0)    ; send a Z packet
  1836. ;    RPACK    LEN,SEQ,PACKET,TYPE
  1837.     RPACK    D2,D3,RECPKT(A0),D4    ; get a reply
  1838.     BNE    1000$            ; 
  1839.     CMPB    D4,#'N            ; NAK ?
  1840.     BNE    30$
  1841.     CALL    NEXTN            ; D1 gets next N mod 64.
  1842.     CMPB    D1,D3            ; NAK for SEQ+1?
  1843.     BEQ    40$            ; yes-treat as ACK.
  1844.     JMP    1000$            ; return as is
  1845.  
  1846. 30$:    CMPB    D4,#'Y            ; ACK ?
  1847.     BNE    60$            ;  no
  1848.     CMPB    D3,N(A0)        ; matching SEQ #?
  1849.     BNE    1000$            ;  no-return as is
  1850. 40$:    CALL    BUMPP            ; bump the N value
  1851.     CALL    ENDTM            ; display speed stats
  1852.     CALL    DINGEM            ; [015]
  1853.     TSTB    ABORTB(A0)        ; abort batch? [015]
  1854.     BNE    50$            ;  yes [015]
  1855.     CALL    GETNXT            ; any more files?
  1856.     BVS    50$            ;  no
  1857.     TSTB    FIO+D.ERR(A0)        ;  file error?
  1858.     BNE    50$            ;  yes, end transfer
  1859.     CALL    GTSIZE            ; calc file size
  1860.     CALL    STARTT            ; set start time
  1861.     MOVB    #'F,STATE(A0)        ; reset state for more files
  1862. ;    CLRB    N(A0)            ; clear the seq number
  1863.     CLRB    NUMTRY(A0)        ;  and the retry count
  1864.     JMP    1000$
  1865.  
  1866. ; we found the "free time" for multiple files in 1991!
  1867. 50$:    MOVB    #'B,STATE(A0)        ; goto Break state
  1868.     JMP    1000$
  1869.  
  1870. 60$:    CMPB    D4,#'E            ; error packet ?
  1871.     BNE    70$            ;  no
  1872.     CALL    PRTERR            ;  yes-print erorrrr.
  1873.     JMP    1000$
  1874. 70$:    MOVB    #'A,STATE(A0)        ; abort on undefined types
  1875. 1000$:    RTN
  1876.  
  1877. ;  S B R E A K -  sends a break frame (no more files to send).
  1878. SBREAK:    INCB    NUMTRY(A0)        ; bump the try count
  1879.     CMMB    NUMTRY(A0),MAXTRY(A0)    ; maxxed out?
  1880.     BLOS    10$            ;  no
  1881.     MOVB    #'A,STATE(A0)        ;  yes-abort state
  1882.     RTN
  1883.  
  1884. 10$:    
  1885. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  1886.     SPACK    #'B,N(A0),#0,PACKET(A0)    ; send a B packet
  1887. ;    RPACK    LEN,SEQ,PACKET,TYPE
  1888.     RPACK    D2,D3,RECPKT(A0),D4    ; get a reply
  1889.     BNE    1000$            ; no reply
  1890.     CMPB    D4,#'N            ; NAK ?
  1891.     BNE    20$
  1892.     CALL    NEXTN            ; D1 gets next N mod 64.
  1893.     CMPB    D1,D3            ; NAK for SEQ+1?
  1894.     BEQ    30$            ; yes-treat as ACK.
  1895.     JMP    1000$            ; return as is
  1896.  
  1897. 20$:    CMPB    D4,#'Y            ; ACK ?
  1898.     BNE    40$            ;  no
  1899.     CMPB    D3,N(A0)        ; matching SEQ #?
  1900.     BNE    1000$            ;  no-return as is
  1901. 30$:    CALL    BUMPP            ; bump the N value
  1902.     MOVB    #'C,STATE(A0)        ; goto Complete state
  1903.     JMP    1000$
  1904.  
  1905. 40$:    CMPB    D4,#'E            ; error packet ?
  1906.     BNE    50$            ;  no
  1907.     CALL    PRTERR            ;  yes-print erorrrr.
  1908.     JMP    1000$
  1909.  
  1910. 50$:    MOVB    #'A,STATE(A0)        ; abort on undefined types
  1911. 1000$:    RTN
  1912.  
  1913. ; R E C S W  - is the state table switch for receiving files.
  1914. RECSW:    MOVB    #'R,STATE(A0)        ; start with RECV INIT state
  1915.     CLRB    N(A0)            ; clear the seq number
  1916.     CLRB    NUMTRY(A0)        ;  and the retry count
  1917.     CLRB    LOGIC(A0)        ; clear logic
  1918.     CLRB    RIACK(A0)        ; clear the I is ACKed flag
  1919. 10$:    TSTB    LOGIC(A0)        ; test logic flag
  1920.     BNE    100$            ;  we are done
  1921.     CTRLC    RABOR            ;  or user wants out
  1922.     TSTB    DEBUGO(A0)        ; debug on ?
  1923.     BEQ    20$            ;   no
  1924.     TYPE    <RECSW state >
  1925.     MOVB    STATE(A0),D1
  1926.     TTY
  1927.     CRLF
  1928. 20$:    LEA    A6,RCSTAT-4        ; index the state table
  1929.     MOVB    STATE(A0),D7        ; D7 gets the current state
  1930. 30$:    ADD    #4.,A6            ; pre-advance
  1931.     MOVB    @A6,D6
  1932.     BEQ    100$            ; undefined state - so exit
  1933.     CMPB    D6,D7            ;  matching state ?
  1934.     BNE    30$            ;   no
  1935.     ADD    #2.,A6            ; yes - advance to offset
  1936.     ADDW    @A6,A6            ; calc address of new routine
  1937.     CALL    @A6            ; execute it
  1938.     BR    10$            ; loop till we exit
  1939. 100$:    RTN
  1940.  
  1941. RABOR:    MOVB    #'A,STATE(A0)        ; flag transfer as bad
  1942.     MOVB    #FALSE,LOGIC(A0)
  1943.     RTN
  1944.  
  1945. RCOMP:    MOVB    #TRUE,LOGIC(A0)        ; flag complete o.k.
  1946.     RTN
  1947.  
  1948. ; R I N I T - is the receive init routine
  1949. ; Wait for the send-init packet from sending Kermit.
  1950. RINIT:    ADDB    #1,NUMTRY(A0)        ; count the tries
  1951.     CMMB    NUMTRY(A0),MAXTRY(A0)    ; beyond the max?
  1952.     BLOS    20$
  1953.     MOVB    #'A,STATE(A0)
  1954.     RTN
  1955.  
  1956. 20$:    
  1957. ;    RPACK    LEN,SEQ,PACKET,TYPE
  1958.     RPACK    D2,D3,PACKET(A0),D4    ; receive a packet
  1959.     BNE    50$            ;  no packet received ; timeout
  1960.     CMPB    D4,#'S            ;  got an S packet ?
  1961.     BNE    30$            ;   no S packet
  1962. ; get other side's init data
  1963.     LEA    A3,PACKET(A0)        ; index data packet address
  1964.     CALL    RPAR            ; get parameters
  1965.     LEA    A3,PACKET(A0)        ; index data packet address
  1966.     CALL    SPAR            ;  send our parameters
  1967. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  1968.     SPACK    #'Y,N(A0),#PARSIZ,PACKET(A0); send ACK with reply
  1969.     SETB    RIACK(A0)        ; flag ACK to I has been sent
  1970.     MOVB    NUMTRY(A0),OLDTRY(A0)    ; save try count
  1971.     CLRB    NUMTRY(A0)        ; clear count
  1972.     CALL    BUMPP            ; bump packet #
  1973.     MOVB    #'F,STATE(A0)        ; bump state
  1974.     JMP    1000$            ; end
  1975.  
  1976. 30$:    CMPB    D4,#'E            ; error received ?
  1977.     BNE    40$
  1978.     CALL    PRTERR            ; display the error.
  1979.     MOVB    #'A,STATE(A0)
  1980.     JMP    1000$            ; done
  1981. ; all others default to A state
  1982. 40$:    MOVB    #'A,STATE(A0)        ; received junk-abort
  1983.     JMP    1000$
  1984. ; no packet received - send a NAK
  1985. 50$:    SPACK    #'N,N(A0),#0,NFILNM(A0)    ; send a NAK packet
  1986.                     ; return without state change
  1987. 1000$:    RTN
  1988.  
  1989. ; R F I L E  - receive a file header frame with the filename.
  1990. RFILE:    ADDB    #1,NUMTRY(A0)        ; count the tries
  1991.     CMMB    NUMTRY(A0),MAXTRY(A0)    ; beyond the max?
  1992.     BLOS    20$
  1993.     MOVB    #'A,STATE(A0)
  1994.     RTN
  1995.  
  1996. 20$:    
  1997.  
  1998. ;    RPACK    LEN,SEQ,PACKET,TYPE
  1999.     RPACK    D2,D3,NFILNM(A0),D4    ; receive a packet (expecting filename)
  2000.     JNE    500$            ;  no packet received ; timeout
  2001.     CMPB    D4,#'S            ;  got an S packet ?
  2002.     BNE    50$            ;   no
  2003. ; SEND-INIT received, maybe ACK was lost.
  2004.     CALL    NEXTO            ; D1 gets next OLDTRY value
  2005.     CMPB    D1,MAXTRY(A0)        ;  time to give up?
  2006.     BLOS    30$            ;   no
  2007.     MOVB    #'A,STATE(A0)
  2008.     JMP    1000$            ; yes-goto abort state.
  2009.  
  2010. 30$:    MOVB    N(A0),D1        ; D1 gets current packet #
  2011.     CALL    PREVP            ; get previous packet #
  2012.     CMPB    D1,D3            ; previous packet ?
  2013.     BNE    40$            ;  no
  2014. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2015.     SPACK    #'Y,D3,#PARSIZ,PACKET(A0)    ;   yes-ack again with SEND-INIT
  2016.     CLRB    NUMTRY(A0)        ; clear retry count
  2017.     JMP    1000$            ;  stay in state.
  2018.  
  2019. 40$:    MOVB    #'A,STATE(A0)        ; goto abort
  2020.     JMP    1000$            ;  done
  2021.  
  2022. 50$:    CMPB    D4,#'Z            ; end of file?
  2023.     BNE    80$            ;  no
  2024.     CALL    NEXTO            ; D1 gets next oldtry
  2025.     CMPB    D1,MAXTRY(A0)        ;  time to give up?
  2026.     BLOS    60$            ;   no
  2027.     MOVB    #'A,STATE(A0)        ;   yes-abort
  2028.     JMP    1000$            ; done
  2029.  
  2030. 60$:    MOVB    N(A0),D1        ; get N
  2031.     CALL    PREVP            ; calc previous packet # to D1
  2032.     CMPB    D1,D3            ;  same ?
  2033.     BNE    70$            ;  no
  2034. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2035.     SPACK    #'Y,D3,#0,PACKET(A0)    ;   yes-ack Z from file before!
  2036.     CLRB    NUMTRY(A0)        ; reset tries
  2037.     JMP    1000$            ;  done
  2038.  
  2039. 70$:    MOVB    #'A,STATE(A0)        ; goto ABORT otherwise.
  2040.     JMP    1000$
  2041.  
  2042. 80$:    CMPB    D4,#'F            ; is it the blessed file header yet?
  2043.     JNE    200$            ;  no    
  2044.     CMPB    D3,N(A0)        ;  yes-is the packet # correct?
  2045.     BNE    70$            ;   no-move to abort state.
  2046.     CALL    RFILNM            ; process the filename & open.
  2047.     BEQ    90$            ; it opened ok
  2048.     CALL    LFERR            ; show local file error
  2049.     MOVB    #'A,STATE(A0)        ; move to abort state
  2050.     JMP    1000$            ; done
  2051. 90$:    TSTB    NOTALK(A0)        ; do we have a user terminal?
  2052.     BNE    120$            ;  no-bypass message
  2053.     CRLF
  2054.     TYPE    <Receiving >
  2055.     CLR    D0
  2056.     MOVB    LDATA(A0),D0
  2057.     LEA    A1,FILNAM(A0)
  2058.     BR    110$
  2059. 100$:    MOVB    (A1)+,D1
  2060.     TTY
  2061. 110$:    DBF    D0,100$
  2062.     TYPE    < as >
  2063.     PFILE    FIO(A0)
  2064.     CRLF
  2065. 120$:
  2066. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2067.     SPACK    #'Y,N(A0),#0,PACKET(A0)    ;   send ACK for the F packet
  2068.     MOVB    NUMTRY(A0),OLDTRY(A0)    ; reset try counters
  2069.     CLRB    NUMTRY(A0)
  2070.     CALL    BUMPP            ; get next packet #
  2071.     MOVB    #'D,STATE(A0)        ; move to data state
  2072.     JMP    1000$
  2073.  
  2074. 200$:    CMPB    D4,#'B            ; break ?
  2075.     BNE    300$            ;  no
  2076.     CMPB    D3,N(A0)        ;  yes-is packet # correct?
  2077.     BNE    310$    
  2078. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2079.     SPACK    #'Y,N(A0),#0,PACKET(A0)    ;   send ACK for the B packet
  2080.     MOVB    #'C,STATE(A0)        ; and move to Complete state
  2081.     JMP    1000$            ; end
  2082.  
  2083. 300$:    CMPB    D4,#'E            ; error frame ?
  2084.     BNE    400$            ;  no
  2085.     CALL    PRTERR            ;  show it
  2086. 310$:    MOVB    #'A,STATE(A0)        ; move to abort
  2087.     JMP    1000$
  2088. 400$:    MOVB    #'A,STATE(A0)        ; goto abort state
  2089.     JMP    1000$
  2090.  
  2091. ; didnt get a packet
  2092. 500$:
  2093. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2094.     SPACK    #'N,N(A0),#0,PACKET(A0)    ;   send NAK 
  2095. 1000$:    RTN
  2096.  
  2097. ; R D A T A -  receives the data packets that make up the file.
  2098. RDATA:    ADDB    #1,NUMTRY(A0)        ; count the tries
  2099.     CMMB    NUMTRY(A0),MAXTRY(A0)    ; beyond the max?
  2100.     BLOS    20$
  2101.     MOVB    #'A,STATE(A0)
  2102.     RTN
  2103.  
  2104. 20$:    
  2105. ;    RPACK    LEN,SEQ,PACKET,TYPE
  2106.     RPACK    D2,D3,PACKET(A0),D4    ; receive a packet (expecting filename)
  2107.     JNE    500$            ;  no packet received ; timeout
  2108.     CMPB    D4,#'D            ; got a Data packet ?
  2109.     JNE    60$            ;  no
  2110.     CMPB    D3,N(A0)        ;  yes-is it right packet # ?
  2111.     BEQ    50$            ;   YES
  2112.     CALL    NEXTO            ;   NO-get next OLDTRY value in D1
  2113.     CMPB    D1,MAXTRY(A0)        ;  
  2114.     BLOS    25$
  2115.     MOVB    #'A,STATE(A0)        ; abort -retries exceeded
  2116.     JMP    1000$            ;  done
  2117.  
  2118. 25$:    MOVB    N(A0),D1        ; D1 gets current packet #
  2119.     CALL    PREVP            ; get previous packet #
  2120.     CMPB    D1,D3            ; previous packet ?
  2121.     BNE    40$            ;  no
  2122. ;    SPACK    TYPE,SEQ,SIZE,PACKET    
  2123.     SPACK    #'Y,D3,#6,PACKET(A0)    ;   yes-re-ack.
  2124.     CLRB    NUMTRY(A0)        ; clear retry count
  2125.     JMP    1000$            ;  stay in state.
  2126.  
  2127. 40$:    MOVB    #'A,STATE(A0)        ; goto abort
  2128.     JMP    1000$            ;  done
  2129.  
  2130. ; received valid data frame - output it
  2131. 50$:    CALL    BUFEMP            ; empty the buffer to disk
  2132. ;    SPACK    TYPE,SEQ,SIZE,PACKET    
  2133.     SPACK    #'Y,N(A0),#0,PACKET(A0)    ;   ack the data
  2134.     MOVB    NUMTRY(A0),OLDTRY(A0)    ; reset the try counters
  2135.     CLRB    NUMTRY(A0)        ; clear retry count
  2136.     CALL    BUMPP            ; bump the packet #
  2137.     MOVB    #'D,STATE(A0)        ; stick in D state.
  2138.     CALL    SHODOT            ; tell user we moved some data
  2139.     JMP    1000$            ;  stay in state.
  2140.  
  2141. 60$:    CMPB    D4,#'F            ; file header?
  2142.     BNE    80$            ;  no
  2143.     CALL    NEXTO            ; D1 gets next oldtry
  2144.     CMPB    D1,MAXTRY(A0)        ;  time to give up?
  2145.     BLOS    70$            ;   no
  2146. 65$:    MOVB    #'A,STATE(A0)        ;   yes-abort
  2147.     JMP    1000$            ; done
  2148. 70$:    MOVB    N(A0),D1        ; get N
  2149.     CALL    PREVP            ; calc previous packet # to D1
  2150.     CMPB    D1,D3            ;  same ?
  2151.     BNE    65$            ;  no
  2152. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2153.     SPACK    #'Y,D3,#0,PACKET(A0)    ;   yes-ack again
  2154.     CLRB    NUMTRY(A0)        ; reset tries
  2155.     JMP    1000$            ;  done
  2156.  
  2157. 80$:    CMPB    D4,#'Z            ; end of file?
  2158.     BNE    200$            ;  no    
  2159.     CMPB    D3,N(A0)        ;  yes-is the packet # correct?
  2160.     BNE    65$            ;   no-move to abort state.
  2161. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2162.     SPACK    #'Y,D3,#0,PACKET(A0)    ;   ack the Z
  2163.     CALL    CLOSER
  2164.     LOOKUP    FIO(A0)            ; do file lookup
  2165.     CALL    GTSIZE            ; to get file size
  2166.     CALL    ENDTM            ; show elapsed time & speed
  2167.     CALL    DINGEM            ; [015] alert user
  2168.     CALL    BUMPP            ; bumpthepacket#
  2169.     MOVB    #'F,STATE(A0)        ; return the F state
  2170.     BR    1000$
  2171.  
  2172. 200$:    CALL    CLOSER            ; close file if open
  2173.     CMPB    D4,#'E            ; error frame ?
  2174.     BNE    400$            ;  no
  2175.     CALL    PRTERR            ;  show it
  2176.     MOVB    #'A,STATE(A0)        ; move to abort
  2177.     JMP    1000$
  2178.  
  2179. 400$:    MOVB    #'A,STATE(A0)        ; goto abort state
  2180.     JMP    1000$
  2181. ; didnt get a packet
  2182. 500$:
  2183. ;    SPACK    TYPE,SEQ,SIZE,PACKET
  2184.     SPACK    #'N,N(A0),#0,PACKET(A0)    ;   send NAK 
  2185. 1000$:    RTN
  2186.  
  2187. ;;;               P A C K E T   U T I L I T I E S
  2188.  
  2189. ; B U M P P - bumps the current packet mod 64. The new N is returned in D1,
  2190. ; and is also updated in N(A0).
  2191. BUMPP:    BCALL    NEXTN
  2192.     MOVB    D1,N(A0)
  2193.     RTN
  2194.  
  2195. ; N E X T N - returns the next N(A0) value in D1. It does NOT update N(A0).
  2196. NEXTN:    CLR    D1
  2197.     MOVB    N(A0),D1
  2198.     ADD    #1,D1
  2199.     ANDB    #63.,D1
  2200.     RTN
  2201.  
  2202. ; N E X T O - returns the next OLDTRY(A0) value in D1. 
  2203. ; It does not update OLDTRY(A0).
  2204. NEXTO:    CLR    D1
  2205.     MOVB    OLDTRY(A0),D1
  2206.     ADD    #1,D1
  2207.     ANDB    #63.,D1
  2208.     RTN
  2209.  
  2210. ; P R E V P - returns the prior packet to D1 in D1. ( D1-1 mod 64. )
  2211. PREVP:    SUB    #1,D1
  2212.     AND    #63.,D1
  2213.     RTN
  2214.  
  2215. ; P R T E R R - prints the error message contained in the Error packet
  2216. PRTERR:    CLR    D0            ; 
  2217.     MOVB    LDATA(A0),D0        ; get length of data field
  2218.     LEA    A1,DATA(A3)
  2219.     TTYL    ABTTTL
  2220.     BR    30$
  2221. 20$:    MOVB    (A1)+,D1
  2222.     TTY
  2223. 30$:    DBF    D0,20$
  2224.     CRLF
  2225.     RTN
  2226.  
  2227. ; R P A R  -  get the REMOTE's send-init parameters.
  2228. ; At entry, A3 indexs the packet area
  2229. ; revised [21]
  2230. RPAR:    MOVB    #'1,CHKT(A0)        ; default to 1 char checksum
  2231.     MOVB    #SPACE,REPT(A0)        ; and no repeat
  2232.     CLRB    QBIN(A0)        ; default to no quoting, 7 bit path
  2233. 10$:    LEA    A1,DATA(A3)        ; index the payload area
  2234.     CLR    D1
  2235.     MOVB    (A1)+,D1        ; get MAXL byte
  2236.     AND    #177,D1            ; strip to ASCII in case of parity
  2237.     UNCHAR    D1
  2238.     CMPB    D1,#PAKSIZ        ; bigger than protocol max?
  2239.     BHI    19$            ;  yes, use default
  2240. 15$:    CMPB    D1,MXPKSZ(A0)        ; compare to user's max
  2241.     BLO    18$            ;  but no higher
  2242.     MOVB    MXPKSZ(A0),D1        ; use our local max
  2243. 18$:    CMPB    D1,#10.            ; MAXL should be at least 10.
  2244.     BHIS    30$
  2245. 19$:    MOV    #80.,D1            ; yes, use default MAXL of 80.
  2246. 30$:    MOVB    D1,SPSIZ(A0)        ; set send packet size
  2247.     MOVB    (A1)+,D1         ; get TIME byte
  2248.     UNCHAR    D1
  2249.     MOV    D1,TIMINT(A0)        ; set when I should time out
  2250.     MOVB    (A1)+,D1        ; get NPAD byte
  2251.     UNCHAR    D1
  2252.     MOVB    D1,PAD(A0)        ; set pad count.
  2253.     MOVB    (A1)+,D1        ; get PADC byte
  2254.     CTL    D1
  2255.     MOVB    D1,PADCHR(A0)        ; set pad character
  2256.     MOVB    (A1)+,D1        ; get EOL byte
  2257.     UNCHAR    D1
  2258.     MOVB    D1,EOL(A0)        ; set end of line char
  2259.     MOVB    (A1)+,D1        ; get QCTL byte
  2260.     CMPB    D1,#SPACE
  2261.     BHI    40$
  2262.     MOV    #MYQUOT,D1        ; default it
  2263. 40$:    MOVB    D1,QUOTE(A0)        ; set control-quote.
  2264.     CLR    D2
  2265.     MOVB    LDATA(A0),D2        ; get size of data area
  2266.     SUB    #6,D2            ; have more than basic 6 bytes?
  2267.     JLOS    140$            ; no more data
  2268. ; get QBIN
  2269.     MOVB    (A1)+,D1        ; get QBIN byte
  2270.     AND    #177,D1            ; strip to ASCII
  2271.     CMPB    D1,#'Y            ; will quote if we request?
  2272.     BNE    50$            ;  no
  2273.     MOV    #1,D0            ;  yes
  2274.     BR    80$
  2275. ; allowable ranges are decimal 33-62 & 96-126. Reject all others.
  2276. 50$:    CMPB    D1,#SPACE        ; was it a space through null?
  2277.     BLOS    70$            ;  not legal 8b quote value
  2278.     CMPB    D1,#62.            ; ASCII 33-62?
  2279.     BLOS    60$            ;  yes-use it
  2280.     CMPB    D1,#127.        ; check high boundary of 2nd range
  2281.     BHIS    70$            ;  not legal 8b quote value
  2282.     CMPB    D1,#96.            ; check lower bound of 2nd range
  2283.     BHIS    60$            ;  legal
  2284.     BR    70$            ;  not legal
  2285. 60$:    MOV    #2,D0            ; set case 2 - we have valid 8b q
  2286.     BR    80$
  2287. 70$:    MOV    #0,D0            ; case 0 - we have no 8b q info
  2288. ; D0 is 0, 1 or 2
  2289. 80$:    DEC    D0            ; was it 0?
  2290.     BCC    90$            ;  no
  2291.     CMPB    PARITY(A0),#'N        ; do we have NO parity?
  2292.     SETNE    QBIN(A0)        ;  P=None, allow full 8 bits
  2293.                     ;  P=other, mask to 7 bits
  2294.     BR    110$
  2295. 90$:    DEC    D0            ; was it 1? (quote if needed only)
  2296.     BCC    100$            ;  no
  2297.     CMPB    PARITY(A0),#'N        ; do we have NO parity?
  2298.     BEQ    95$            ;  yes-flag 8 bits, no quoting
  2299.     MOVB    #'&,QBIN(A0)        ; else 7 bits, default quote
  2300.     BR    110$
  2301. 95$:    CLRB    QBIN(A0)        
  2302.     BR    110$
  2303. 100$:    MOVB    D1,QBIN(A0)        ; got QBIN - 7 bits w/quoting
  2304. 110$:    SUB    #1,D2
  2305.     BEQ    140$            ; no more
  2306. ; get CHKT
  2307.     MOVB    (A1)+,D1        ; get CHKT byte
  2308. ;;[023]    CMPB    D1,#'2            ; higher than 2?
  2309.     CMPB    D1,DF.CHK(A0)        ; higher than max user value? [023]
  2310.     BHI    120$            ;  yes-force to one
  2311.     BEQ    130$            ;  no-allow it
  2312.     CMPB    D1,#1            ; do not allow zero
  2313.     BEQ    130$
  2314. 120$:    MOV    #'1,D1            ; force to 1 if BOTH SIDES don't agree
  2315. 130$:    MOVB    D1,CHKT(A0)        ; set checksum method
  2316.     SUB    #1,D2
  2317.     BEQ    140$
  2318. ; get REPT
  2319.     MOVB    (A1)+,D1        ; get REPT byte
  2320.     UNCHAR    D1
  2321.     MOVB    D1,REPT(A0)        ; set repeat prefix
  2322. 140$:    CMPB    QUOTE(A0),#SPACE    ; quote undefined ?
  2323.     BNE    150$            ;  no-defined
  2324.     MOVB    #'#,QUOTE(A0)        ;  yes-use default
  2325. 150$:    RTN
  2326.  
  2327.  
  2328. ; S P A R  - fill data area with send-init parameters
  2329. SPAR:    LEA    A1,DATA(A3)    ; index payload area
  2330.     CLR    D1
  2331.     MOVB    MXPKSZ(A0),D1        ; get max packet size
  2332.     CHAR    D1
  2333.     MOVB    D1,(A1)+        ; 1 max packet size
  2334.     MOV     DF.TIM(A0),D1        ; get our default value
  2335.     CHAR    D1
  2336.     MOVB    D1,(A1)+        ; 2 # of seconds to my timeout
  2337.     MOV    #MYPAD,D1
  2338.     CHAR    D1
  2339.     MOVB    D1,(A1)+        ; 3 # of padding characters
  2340.     MOV    #MYPCHR,D1
  2341.     CTL    D1            ; the pad character translated
  2342.     MOVB    D1,(A1)+        ; 4
  2343.     MOV    #0,D1            ; we do not need an EOL this end.
  2344.     CHAR    D1
  2345.     MOVB    D1,(A1)+        ; 5 end of line character
  2346.     MOV    #MYQUOT,D1
  2347.     MOVB    D1,(A1)+        ; 6 control quoting character
  2348. ; handle QBIN
  2349.     MOVB    QBIN(A0),D1        ; get QBIN
  2350.     BEQ    40$            ;  only quote on request
  2351.     CMPB    D1,#^O377        ; is QBIN already defined?
  2352.     BNE    60$            ;  yes, else
  2353. 40$:    MOVB    #'Y,D1            ; default to quoting on request
  2354. 60$:    MOVB    D1,(A1)+        ; 7 the optional binary quoter
  2355.     MOVB    DF.CHK(A0),(A1)+    ; 8 the optional checkbyte type
  2356.     PARSIZ    =8.
  2357.     RTN
  2358.  
  2359.  
  2360. ; FLUSH deletes all pending input from the input buffer
  2361. FLUSH:    MOV    REMOTE(A0),A5
  2362. 10$:    TST    T.ICC(A5)        ; more data?
  2363.     BEQ    20$            ;  no, done
  2364.     TTYIN                ; dump a byte
  2365.     BR    10$
  2366. 20$:    RTN
  2367.  
  2368. ; B U F F I L  -  fills a packet @A3 with data.
  2369. ; we will limit data size to 3 less than actual size to allow the last
  2370. ; character to be control and 8bit quoted, without look-ahead schemes.
  2371. ; the worst cases are '# = &## and '& = &#&.
  2372. ; data count goes to BUFCNT(A0).
  2373. ; At entry,     A3 must index the data packet area to be filled,
  2374. ;        CHKNOW(A0) must contain the binary checkbyte size
  2375. BUFFIL:    CLR    D0
  2376.     MOVB    SPSIZ(A0),D0        ; D0 gets max msg size to remote
  2377.     SUBB    CHKNOW(A0),D0        ; less size of checkbyte
  2378.     SUB    #<3.>,D0        ;  less overhead bytes    
  2379.     LEA    A1,DATA(A3)        ; index the data area
  2380. 10$:    CALL    INBYTE            ; get a data byte
  2381.     TST    FIO+D.SIZ(A0)        ; end of file ?
  2382.     BEQ    100$            ;  yes
  2383. ; test for high bit
  2384.     BTST    #7.,D1            ;  no-test for eighth bit set.
  2385.     BEQ    30$            ;   bit 7 is clear
  2386. ; handle high bit prefixing, if any
  2387.     MOVB    QBIN(A0),D7        ; get 8bit quote character.
  2388.     BMI    20$            ;  no high bit can be used
  2389.     BEQ    30$            ;  no 8 bit quoting needed!
  2390.     MOVB    D7,(A1)+        ; buffer the 8bit quote
  2391.     SUB    #1,D0            ; decrement the count
  2392. 20$:    AND    #^O177,D1        ; strip to ascii
  2393. 30$:    MOVB    D1,D2        
  2394.     ANDB    #^O177,D2        ; D2 gets stripped version
  2395.     CMPB    D2,#DEL            ; is it a DEL
  2396.     BEQ    35$            ;   this is non-printable.
  2397. ; also prefix the prefix, and the high bit prefix with the prefix!
  2398.     CMPB    D2,QUOTE(A0)        ; is this character the prefix?
  2399.     BNE    32$            ;   no
  2400.     MOVB    D2,(A1)+        ;   yes-prefix it with itself
  2401.     SUB    #1,D0
  2402. 32$:    TSTB    QBIN(A0)        ; check 8 bit quoting
  2403.     BLE    34$            ;  none
  2404.     CMPB    D2,QBIN(A0)        ; matching?
  2405.     BNE    34$            ;  no-      [10/23/84 rpr]
  2406.     MOVB    QUOTE(A0),(A1)+        ;  yes-quote it first
  2407.     SUB    #1,D0            ; less one for quote
  2408. 34$:    CMPB    D2,#SPACE        ; is it control ?
  2409.     BHIS    50$            ;  no-prinatble
  2410. ; unctrol-ify the character, while preserving possible bit7.
  2411. 35$:    CTL    D1            ; uncontrol-ify
  2412. 40$:    MOVB    QUOTE(A0),(A1)+
  2413.     SUB    #1,D0
  2414. 50$:    MOVB    D1,(A1)+
  2415.     SUB    #1,D0
  2416.     BGT    10$            ; loop till filled up
  2417. 100$:    LEA    A6,DATA(A3)        ; ptr to start of data
  2418.     MOV    A1,D1            ; get ending ptr
  2419.     SUB    A6,D1            ; D1 gets outgoing data size
  2420.     MOVB    D1,BUFCNT(A0)        ; set data count
  2421.     RTN
  2422.  
  2423. ; INBYTE gets a byte from a disk file. 
  2424. INBYTE:    TST    FIO+D.SIZ(A0)        ; EOF already?
  2425.     BEQ    10$            ;  yes, done
  2426.     FILINB    FIO(A0)            ; get a byte from file
  2427. 10$:    RTN
  2428.  
  2429. ; close file if it is open.
  2430. CLOSER:    TSTB    FIO+D.OPN(A0)        ; is file open?
  2431.     BEQ    10$            ;  no
  2432.     CLOSE    FIO(A0)            ;   yes-close the file
  2433.     CLRB    FIO+D.OPN(A0)        ; and clear open code!
  2434. 10$:    RTN
  2435.  
  2436.  
  2437. ; B U F E M P  -  empties the incoming data contents of the packet @A3 to
  2438. ; the FIO(A0) file.
  2439. BUFEMP:    LEA    A1,DATA(A3)        ; index the data area
  2440.     CLR    D0
  2441.     MOVB    LDATA(A0),D0        ; D0 gets the count
  2442.     BR    600$            ; check for 0 bytes in packet [21]
  2443. 10$:    CALL    GETBYT            ; get an input byte [10/23/84]
  2444. ; doing 8bit quoting?
  2445.     MOVB    QBIN(A0),D2        ; get 8bit quote character
  2446.     BLE    100$            ;  no binary quoting
  2447.     CMPB    D2,D1            ; is it binary quote ?
  2448.     BNE    100$            ;  no
  2449. ; 8bit quote received. Evaluate following characters.
  2450.     MOV    #^O200,D3        ; set high bit flag
  2451.     CALL    GETBYT            ; get next byte
  2452.     CALL    EVALQ            ; evaluate this & next chars
  2453.     ORB    D3,D1            ; combine evaluated char & top bit
  2454.     BR    500$
  2455.  
  2456. 100$:    CLR    D3            ; clear high bit flag
  2457.     CALL    EVALQ            ; evaluate
  2458. 500$:    FILOTB    FIO(A0)            ; output the data byte
  2459. 600$:    TST    D0
  2460.     BGT    10$            ; output all bytes
  2461.     RTN
  2462.  
  2463. ; E V A L Q  - evaluates the byte in D1. Expands quoted control characters,
  2464. ; quoted quotes, and eighth bit quotes and quoted eighth bit quotes.
  2465. EVALQ:    CMPB    D1,QUOTE(A0)        ; is it a quote ?
  2466.     BNE    100$            ;  no-just return with value
  2467.     CALL    GETBYT            ;  yes - get next byte
  2468.     MOVB    D1,D7
  2469.     AND    #^O177,D7        ; get stripped version of character
  2470.     CMPB    D7,QUOTE(A0)        ; is it double qoute ?
  2471.     BEQ    100$            ; yes-pass it literally
  2472.     TSTB    QBIN(A0)        ; test for 8 bit quote active
  2473.     BLE    10$            ;  no-sending binaries
  2474.     CMPB    D1,QBIN(A0)        ; 8bit quote prefixed by ctl quote?
  2475.     BEQ    100$            ;  yes-use literally.
  2476. 10$:    CTL    D1            ; turn it to control
  2477. 100$:    RTN        
  2478.  
  2479. ; G E T B Y T - gets the next data byte for BUFEMP.
  2480. GETBYT:    MOVB    (A1)+,D1        ; get a byte    
  2481.     TSTB    QBIN(A0)        ; allowing binaries?
  2482.     BEQ    10$            ;  yes
  2483.     AND    #^O177,D1        ;  no-strip to seven    
  2484. 10$:    SUB    #1,D0            ;  adjust count
  2485.     RTN
  2486.  
  2487. ; R E C P A K  -  receives a data packet from the remote computer.
  2488. ; This routine simply inputs a single packet, without performing
  2489. ; packet checking or other details.
  2490. ; On Entry,    A3 indexs the packet destination
  2491.  
  2492. ; On exit,    D0 is the received checkbyte
  2493. ;        D1 is the calculated checkbyte
  2494. ;        D2 is the LEN
  2495. ;        D3 is the SEQ
  2496. ;        D4 is the TYPE
  2497. ;        Z is set if a packet is received
  2498. ;         CHKNOW(A0) contains binary 1,2, or 3 for checkbyte size
  2499. RECPAK:    
  2500. ; initialize packet receiver
  2501.     CALL    SETEND            ; set timer ending time
  2502.     MOV    REMOTE(A0),A5        ; index the remote TCB
  2503. 10$:    CALL    GETREM            ; get remote character
  2504.     JNE    100$            ;  timeout, no data
  2505. ; syncronize the packet to the mark byte (usually ^A)
  2506.     AND    #^O177,D1        ; strip parity here, always
  2507.     CMPB    D1,RMARK(A0)        ; start of packet ?
  2508.     BNE    10$            ;  no-keep looking
  2509. 20$:    MOV    A3,A1            ; use A1 as work register.
  2510.     MOVB    D1,(A1)+        ;  yes-store it
  2511. ; get the length from the next byte
  2512.     CALL    GETREM            ;   get LEN
  2513.     JNE    100$            ; timeout, no data
  2514.     CMPB    D1,RMARK(A0)        ; start of packet ?
  2515.     BEQ    20$            ;  yes-resync.
  2516.     MOVB    D1,(A1)+        ;  else save the LEN
  2517.     CALL    CLRSUM            ; clear checkbytes
  2518.     CALL    ACCUM
  2519.     UNCHAR    D1            ; convert to binary
  2520.     MOV    D1,D2            ; save the LEN
  2521. ; receive the SEQ byte
  2522. 30$:    CALL    GETREM            ;   get SEQ
  2523.     JNE    100$            ; timeout, no data
  2524.     CMPB    D1,RMARK(A0)        ; start of packet ?
  2525.     BEQ    20$            ;  yes-resync.
  2526.     MOVB    D1,(A1)+        ;  else save the SEQ
  2527.     CALL    ACCUM
  2528.     MOV    D1,D3
  2529.     UNCHAR    D3            ; D3 is sequence #
  2530. ; receive the TYPE byte
  2531.     CALL    GETREM            ;   get TYPE
  2532.     JNE    100$            ; timeout, no data
  2533.     CMPB    D1,RMARK(A0)        ; start of packet ?
  2534.     BEQ    20$            ;  yes-resync.
  2535.     MOVB    D1,(A1)+        ;  else save the TYPE
  2536.     CALL    ACCUM            ; update checkbyte
  2537.     MOV    D1,D4            ; D4 gets the type
  2538. ; calc the data area size.
  2539.     MOV    D2,D1            ; D1 gets the binary length
  2540.     CALL    CALCHK            ; calculate checkbyte size
  2541.     CLR    D0
  2542.     MOVB    CHKNOW(A0),D0        ; get checkbyte size
  2543.     ADD    #2.,D0            ; D0 gets size of SEQ,TYPE
  2544.     SUB    D0,D1            ;  D1 gets size of data area
  2545.     MOVB    D1,LDATA(A0)        ; save length of data
  2546.     MOV    D1,D0            ; D0 gets length
  2547.     CMPB    D0,#95.-3.        ; is it legal ?
  2548.     JHI    10$            ;   no-toss it & try again
  2549.     BR    45$            ; use DBF to control buffering of
  2550.                     ; 0 or more characters.
  2551. ; buffer the data bytes
  2552. 40$:    CALL    GETREM            ; get a byte
  2553.     JNE    100$            ;  timeout
  2554.     CMPB    D1,RMARK(A0)        ; start of packet ?
  2555.     BEQ    20$            ;  yes-resync.
  2556.     MOVB    D1,(A1)+        ; store data
  2557.     CALL    ACCUM            ; update checkbyte
  2558. 45$:    DBF    D0,40$            ;  gather packet.
  2559. ; now get the checkbyte(s)
  2560.     CALL    GETREM            ;   get CHECK
  2561.     JNE    100$            ; timeout, no data
  2562.     CMPB    D1,RMARK(A0)        ; start of packet ?
  2563.     JEQ    20$            ;  yes-resync.
  2564.     UNCHAR    D1            ; convert CHECK
  2565.     CLR    D0
  2566.     MOVB    D1,D0            ; D0 gets checkbyte byte #1
  2567.     CMPB    CHKNOW(A0),#3.        ; three character checkbyte?
  2568.     BNE    50$            ;  no-leave CHECK type as normal
  2569. ; handle 3 byte 16 bit CCITT reverse CRC here
  2570.     ANDB    #^B1111,D0        ;  yes, mask 1st byte to 4 bits
  2571.     RORW    D0,#4.            ; move 1st byte bits to B15-B12
  2572.     CALL    GETREM            ;  and get second byte
  2573.     JNE    100$            ;  receive data fault
  2574.     UNCHAR    D1            ; convert it
  2575.     LSLW    D1,#6.            ; shift 2nd byte to bits 11-6
  2576.     ORW    D1,D0            ; D0 gets bits 11-0
  2577.     CALL    GETREM            ;  yes- get 3rd byte
  2578.     JNE    100$            ;  receive data fault
  2579.     UNCHAR    D1            ; convert it
  2580.     ORW    D1,D0            ; D0 gets complete checkbytes
  2581.     MOVW    FRMSUM(A0),D1        ; D1 gets calculated CRC-ITT
  2582.     BR    90$
  2583. ; handle 2 byte 12 bit checksum here
  2584. 50$:    CMPB    CHKNOW(A0),#2.        ; two character checkbytes?
  2585.     BNE    60$            ;  no-leave CHECK type as normal
  2586.     CALL    GETREM            ;  yes- get second byte
  2587.     JNE    100$            ;  receive data fault
  2588.     UNCHAR    D1            ; convert it
  2589.     LSL    D0,#6.            ; shift 1st byte to bits 11-6
  2590.     ORW    D1,D0            ; D0 gets bits 11-0
  2591.     MOVW    ASSUM(A0),D1        ; D1 gets calculated ASSUM
  2592.     ANDW    #^B0000111111111111,D1    ; mask it to 12 bits only
  2593.     BR    90$
  2594. ; handle one byte 6 bit checksum here
  2595. 60$:    CLR    D1
  2596.     MOVB    ASSUM+.B0W7(A0),D1    ; {ok} get calculated sum
  2597.     MOV    D1,D7            ;  twice
  2598.     LSRW    D7,#6.            ; move bits 7-6 to 1-0
  2599.     ANDW    #3,D7            ; toss all other bits
  2600.     ADDW    D7,D1            ; add to sum
  2601.     ANDW    #^O77,D1        ; strip to 6 bits.
  2602. 90$:    TSTB    DEBUGO(A0)        ; debug mode ?
  2603.     JEQ    95$            ;  no
  2604.     PUSH    D1
  2605.     CLR    D1
  2606.     TYPE    <==Received Packet # >
  2607.     MOV    D3,D1                
  2608.     DCVT    2,OT$TRM!OT$TSP        ; output as 2 characters
  2609.     TYPE    <, Type >    
  2610.     MOV    D4,D1
  2611.     TTY
  2612.     TYPE    < Length: >
  2613.     MOV    D2,D1
  2614.     DCVT    2,OT$TRM
  2615.     CRLF
  2616.     TYPE    <Checkbytes >    
  2617.     MOV    @SP,D1            ; get calced sum
  2618.     CMPW    D0,D1            ; do they match ?
  2619.     BNE    93$            ;  no
  2620.     TYPE    <match (>
  2621.     DCVT    0,OT$TRM
  2622.     TYPE    <)>
  2623.     BR    94$
  2624.  
  2625. 93$:    TYPE    <calculated = >
  2626.     DCVT    0,OT$TRM
  2627.     TYPE    <, received = >
  2628.     MOV    D0,D1
  2629.     DCVT    0,OT$TRM
  2630. 94$:    CRLF
  2631.     CRLF
  2632.     POP    D1
  2633. 95$:    TSTB    NOTALK(A0)        ; are we showing crc errors?
  2634.     BNE    98$            ;  no
  2635.     CMPW    D0,D1            ; compare checkbytes
  2636.     BEQ    96$            ;  no error
  2637.     TYPE    c
  2638.     BR    98$
  2639. ; come here if packet is O.K. Check for NAK. If NAK, put n on screen
  2640. 96$:    CMPB    D4,#'N            ; was it a NAK?
  2641.     BNE    98$
  2642.     TYPE    n
  2643. 98$:    CMPW    D0,D1            ; compare checkbytes
  2644.     RTN
  2645.  
  2646. ; come here on timeout while waiting for packets.
  2647. ; show timeouts as t's if there is a user watching.
  2648. 100$:    TSTB    NOTALK(A0)        ; TCB owned by KERMIT job?
  2649.     BNE    110$            ;  yes - do not type anything
  2650.     TYPE    <t>            ;  no-go ahead & show user kermit
  2651. 110$:    LCC    #0            ; flag timeout
  2652.     RTN                ;  
  2653.  
  2654.  
  2655.  
  2656. ; S N D P A K  -  sends a packet.
  2657. ; On Entry,    A3 indexs the packet destination
  2658. ;        D2 is the LEN
  2659. ;        D3 is the SEQ
  2660. ;        D4 is the TYPE
  2661. ; At exit,    CHKNOW(A0) contains the checkbyte size used.
  2662. SNDPAK:    TSTB    DEBUGO(A0)
  2663.     BEQ    30$
  2664.     TYPE    <Sending ">
  2665.     MOVB    D4,D1
  2666.     TTY
  2667.     TYPE    <" packet # >
  2668.     CLR    D1    
  2669.     MOVB    D3,D1
  2670.     DCVT    0,OT$TRM
  2671.     TYPE    < of length >
  2672.     MOVB    D2,D1
  2673.     DCVT    0,OT$TRM
  2674.     CRLF
  2675.     TYPE    <Data =">
  2676.     SAVE    A2,D0
  2677.     LEA    A2,DATA(A3)
  2678.     MOV    D2,D0
  2679.     SUB    #1,D0
  2680.     BMI    20$
  2681. 10$:    MOVB    (A2)+,D1
  2682.     TTY
  2683.     DBF    D0,10$
  2684. 20$:    REST    A2,D0
  2685.     TYPECR    <">
  2686.     CRLF
  2687. ; send a packet to the remote KERMIT
  2688. 30$:    MOV    REMOTE(A0),A5        ; index remote TCB
  2689.     CLR    D0
  2690.     MOVB    PAD(A0),D0        ; get pad count
  2691.     MOVB    PADCHR(A0),D1        ; and pad character
  2692.     BR    50$
  2693. 40$:    TTYOUT                ; send the pad character
  2694.     CALL    STALL            ; stall, if needed
  2695. 50$:    DBF    D0,40$            ; output pad chars while D0#0
  2696.     MOV    A3,A1            ; A1 is work pointer
  2697.     MOVB    RMARK(A0),(A1)+        ; buffer MARK character
  2698.     MOV    D2,D1            ; D1 gets LEN
  2699.     CALL    CALCHK            ; calculate checkbyte size
  2700.     ADDB    CHKNOW(A0),D1        ; add size of checkbyte
  2701.     ADD    #2.,D1            ; plus SEQ & TYPE
  2702.     CHAR    D1            ; make it printable
  2703.     MOVB    D1,(A1)+        ; store LEN    
  2704.     CALL    CLRSUM
  2705.     CALL    ACCUM            ; update checkbyte & CRC
  2706.     MOV    D3,D1
  2707.     CHAR    D1
  2708.     MOVB    D1,(A1)+        ; store SEQ
  2709.     CALL    ACCUM            ; update checkbyte & CRC
  2710.     MOVB    D4,(A1)+        ; store TYPE    
  2711.     MOVB    D4,D1
  2712.     CALL    ACCUM            ; update checkbyte & CRC
  2713. ; data (if any) is already in buffer. Add it to checkbyte
  2714.     CLR    D1
  2715.     BR    70$            
  2716. 60$:    MOVB    (A1)+,D1        ; get a byte
  2717.     CALL    ACCUM
  2718. 70$:    DBF    D2,60$            ; loop till all data checked
  2719. ; handle checkbyte(s) translation
  2720. ; [015] add code for three character CRC
  2721. 75$:    CMPB    CHKNOW(A0),#3.        ; three character checkbyte ?
  2722.     BNE    80$            ;  no - try for two!
  2723. ; three character checkbyte
  2724.     CLR    D1
  2725.     MOVW    FRMSUM(A0),D1        ; get all bits
  2726.     CLR    D7
  2727.     MOVW    D1,D7            ;  in two regs
  2728.     ROLW    D7,#4.            ; position bits D15-D12
  2729.     ANDW    #^B1111,D7        ; strip to 4 bits
  2730.     CHAR    D7            ; make it printable
  2731.     MOVB    D7,(A1)+        ; store D15-D12
  2732.     MOVW    D1,D7            ;  in two regs
  2733.     LSRW    D7,#6.            ; get bits D11-D6 in low 6
  2734.     ANDW    #^B111111,D7        ; strip to 6 bits
  2735.     CHAR    D7            ; make it printable
  2736.     MOVB    D7,(A1)+        ; store D11-D6
  2737.     ANDW    #^B111111,D1        ; strip to 6 bits
  2738.     CHAR    D1            ; make it printable
  2739.     MOVB    D1,(A1)+        ; store checkbyte bits D5-D0
  2740.     BR    100$
  2741.  
  2742. 80$:    CMPB    CHKNOW(A0),#2.        ; two character checkbyte ?
  2743.     BNE    90$            ;  no - must be one character
  2744. ; two character checkbyte
  2745.     MOVW    ASSUM(A0),D1        ; get all bits
  2746.     MOV    D1,D7            ;  in two regs
  2747.     LSR    D7,#6.            ; position bits D11-D6
  2748.     AND    #^O77,D7        ; strip to 6 bits
  2749.     CHAR    D7            ; make it printable
  2750.     MOVB    D7,(A1)+        ; store D11-D6
  2751.     AND    #^O77,D1        ; strip to 6 bits
  2752.     CHAR    D1            ; make it printable
  2753.     MOVB    D1,(A1)+        ; store checkbyte bits D5-D0
  2754.     BR    100$
  2755.  
  2756. 90$:    MOVB    ASSUM+.B0W7(A0),D1    ; {ok} D1 gets low eight of sum
  2757.     MOV    D1,D7            ; D7 gets same
  2758.     AND    #^O300,D7        ; take just bits 7-6.
  2759.     LSR    D7,#6.            ; shift to bits 1-0
  2760.     ADD    D7,D1            ; D1 gets sum
  2761.     AND    #63.,D1            ; make it six bits again.
  2762.     CHAR    D1            ; make it prinatble
  2763.     MOVB    D1,(A1)+        ; store checkbyte
  2764. ; check for EOL character
  2765. 100$:    MOVB    EOL(A0),D7        ; remote need any EOL ?
  2766.     BEQ    110$            ;  no
  2767.     MOVB    D7,(A1)+        ;  yes-store it
  2768. ; calculate size of buffered packet from pointer displacement
  2769. 110$:    MOV    A1,D0            ; current position
  2770.     SUB    A3,D0            ;  less start is length
  2771.     SUB    #1,D0
  2772. 120$:    MOVB    (A3)+,D1        ; get a byte
  2773.     TTYOUT                ; output it to REMOTE
  2774.     CALL    STALL            ; stall ,if needed
  2775.     DBF    D0,120$            ;  till packet is sent
  2776.     RTN
  2777.  
  2778. ; O U T B Y T   - This routine outputs the byte in D1 to the remote.
  2779. OUTBYT:    MOV    REMOTE(A0),A5        ; get TCB pointer for remote
  2780.     TTYOUT                ; send the byte out
  2781.     RTN
  2782.  
  2783. ; S T A L L - stalls a certain amount of time after output in progress
  2784. ; is lowered. At entry, A5 must index the output TCB.
  2785. STALL:    TSTB    STLCHR(A0)        ; do we need to stall?
  2786.     BEQ    20$            ;  no
  2787. 10$:    CTRLC    20$            ; abort - CTS must be low
  2788.     TSTB    @A5
  2789.     BMI    10$            ; wait for OIP to drop
  2790.     CLR    D7
  2791.     MOVB    STLCHR(A0),D7
  2792.     MUL    D7,#10000./100.        ; transform to ticks
  2793.     SLEEP    D7
  2794. 20$:    RTN
  2795.  
  2796. ; SREMOT - send the A1 string to the remote
  2797. SREMOT:    MOV    REMOTE(A0),A5        ;  index to remote TCB
  2798. 10$:    MOVB    (A1)+,D1
  2799.     BEQ    100$
  2800.     CMPB    D1,#-1            ; is it wait byte?
  2801.     BNE    20$            ;  no
  2802.     SLEEP    #10000./2.        ; yes, wait .5 seconds
  2803.     BR    10$        
  2804. 20$:    TTYOUT
  2805.     BR    10$
  2806. 100$:    RTN
  2807.  
  2808. ; C A L C H K  -  determines the current checkbyte size.
  2809. ; This routine unifies the logic needed to force 1 byte checkbytes on SEND-INIT
  2810. ; fields and their ACKS.
  2811. ; At entry,
  2812. ;    D2 contains the LEN in binary
  2813. ;    D4 contains the packet type
  2814. ; At exit, CHKNOW(A0) contains the binary value of the current checkbyte size.
  2815. CALCHK:    CLR    D7
  2816.     MOVB    CHKT(A0),D7        ; get checkbyte type
  2817.     SUBB    #'0,D7            ;  less ASCII bias
  2818. ; if NAK, we can deduce packet size from LEN
  2819. ; this is useful if the 1st packet after changing checkbyte types is damaged.
  2820. ; The other side will NAK, and we can recover the right length from the LEN
  2821. ; of the NAK packet. (ACK packets may have filenames or discard info appended
  2822. ; their size is not predictable.)
  2823.     CMPB    D4,#'N            ; is it a NAK?
  2824.     BNE    10$            ;  no- use selected type
  2825.     MOVB    D2,D6            ;  yes-get LEN
  2826.     SUBB    #2.,D6            ; less 2 gives checkbyte size
  2827.     CMPB    D6,#MAXCHK        ; compare to largest supported type    
  2828.     BHI    30$            ;  out of range - ignore bad advice    
  2829.     MOVB    D6,D7            ; well
  2830.     ADDB    #'0,D6            ; D6 gets character
  2831.     MOVB    D6,CHKT(A0)        ; force proper check type
  2832.     BR    30$            ; and set binary type as well
  2833. ; handle all but NAKs here
  2834. 10$:    TSTB    RIACK(A0)        ; have we recv'd "S" packet? 
  2835.     BNE    30$            ;  yes, use 
  2836.     MOV    #1,D7            ;   no-force checkbyte type 1
  2837. 30$:    MOVB    D7,CHKNOW(A0)        ; save current checkbyte choice
  2838.     RTN
  2839.  
  2840. ; G E T R E M  -  gets a single character from the remote computer. 
  2841. ; At entry, A5 must index the REMOTE TCB
  2842. ; At exit, D1 will contain the character, or a -1 for no character.
  2843. ; Z will be set if a character was available for input.
  2844. GETREM:    MOV    #-1,D1            ; preset for no data
  2845.     BR    20$
  2846. 10$:    SLEEP    SLPVAL(A0)        ; wait for more data [14]
  2847. ; wait 1 character time for more date for higher throughput [14]
  2848.     CTRLC    100$
  2849.     GTIMEI    D7
  2850.     SUB    FUDGE(A0),D7        ; less the fudge factor for wraparound
  2851.     CMP    D7,RTOUT(A0)        ; EXPIRED?
  2852.     BGT    200$            ;  YES
  2853. 20$:    TST    T.ICC(A5)        ; any data to input ?
  2854.     BEQ    10$            ;  no input
  2855.     CLR    D1            ; pre-clear D1
  2856.     TTYIN                ; get a character
  2857.     TSTB    QBIN(A0)        ; are we allowing 8 data bits?
  2858.     BEQ    30$            ;  yes
  2859.     AND    #^O177,D1        ;  no-strip parity bit
  2860. 30$:    CMPB    D1,#3.            ; control-c?
  2861.     BNE    40$            ; no
  2862.     COMB    CCOUNT(A0)        ; yes-toggle /2 counter
  2863.     BNE    50$            ; only one detected
  2864.     JOBIDX
  2865.     ORW    #J.CCC,@A6        ; two detected - set control-c flag
  2866. 40$:    CLRB    CCOUNT(A0)        ; clear control-c count
  2867. 50$:    LCC    #PS.Z
  2868.     RTN
  2869. 100$:    LCC    #0
  2870.     RTN
  2871. 200$:    LCC    #PS.V            ; flag overflow for timeout
  2872.     RTN
  2873.  
  2874. ; S E T E N D  -  calculates and stores the value of the timeout point 
  2875. ; in internal format.
  2876. SETEND:    CLR    FUDGE(A0)        ; clear wrap-around value
  2877.     GTIMEI    D7            ; D6 gets internal format time.
  2878.     ADD    TIMINT(A0),D7
  2879.     MOV    #24.*60.*60.,D6        ; D6 gets highest internal time+1
  2880.     CMP    D7,D6
  2881.     BLO    10$             ; o.k. - no wraparound
  2882.     SUB    D6,D7            ; handle wrap-around
  2883.     MOV    D6,FUDGE(A0)        ; set fudge factor to indicate
  2884.                     ; time wraparound
  2885. 10$:    MOV    D7,RTOUT(A0)        ; SET TIME-OUT TIME
  2886.     RTN
  2887.  
  2888.  
  2889. ; G T S I Z E  -  gets file size in bytes. Destroys D6,D7. Assumes file 
  2890. ; has been looked up on FIO(A0). FSIZE(A0) contains the size on exit.
  2891. GTSIZE:    MOV    FIO+D.SIZ(A0),D7    ; D7 gets record size
  2892.     MOV    FIO+D.LEN(A0),D6    ; D6 gets # of blocks
  2893.     TSTW    FIO+D.ACT+.W0L15(A0)    ; random file ?
  2894.     BMI    10$            ;  yep-straight multiply
  2895.     SUB    #2.,D7            ;  no-subtract pointer bytes.
  2896.     TSTB    EXTEND(A0)        ;  O/S support extended disks?
  2897.     BEQ    8$            ;   no
  2898.     SUBW    FIO+D.FMT(A0),D7    ;   yes, get extra link bytes (if any)
  2899. 8$:    SUB    #1,D6            ;  and less last block
  2900. 10$:    MUL    D7,D6            ; block payload size * blocks
  2901.     TSTW    FIO+D.ACT+.W0l15(A0)    ; random file ?
  2902.     BMI    20$            ;  yep.
  2903.     ADD    FIO+D.ACT(A0),D7    ;  sequential-add last block's count
  2904.     SUB    #2.,D7            ; less link word in last block
  2905.     TSTB    EXTEND(A0)        ;  O/S support extended disks?
  2906.     BEQ    20$            ;  no
  2907.     SUBW    FIO+D.FMT(A0),D7    ;  yes, get extra link bytes (if any)
  2908. 20$:    MOV    D7,FSIZE(A0)        ; size of the file
  2909.     RTN
  2910.  
  2911. ; send the user terminal a BELL if SET ALARM ON.
  2912. DINGEM:    TSTB    DING(A0)        ; wake the user up?
  2913.     BEQ    20$            ;  no
  2914.     TTYI                ;  yes
  2915.     BYTE    A.BEL,0
  2916.     EVEN
  2917. 20$:    RTN
  2918.  
  2919.  
  2920. ; S T A R T T  - gets the current time and saves it in STIME(A0).
  2921. ; Used to determine the elapsed time in file transfers.
  2922. STARTT:    GTIMEI    STIME(A0)        ; save the start time
  2923.     RTN
  2924.  
  2925. ; E N D T M  - calculate and display the elapsed time & effective baud rate
  2926. ; for a file transfer.
  2927. ; At entry, FSIZE must contain the file size in bytes.
  2928. ENDTM:    TSTB    NOTALK(A0)        ; do we have a user terminal?
  2929.     BNE    30$
  2930.     TSTB    ABORTF(A0)        ; file aborted?
  2931.     BNE    40$
  2932.     GTIMEI    D2            ; get current time
  2933.     SUB    STIME(A0),D2        ; less start time
  2934.     BCC    10$            ;  no midnight wraparound
  2935.     ADD    #24.*60.*60.,D2        ;  else add 24 hours of seconds [14]
  2936. 10$:    ADD    D2,TTIME(A0)        ; add to total time
  2937.     MOV    FSIZE(A0),D7
  2938.     ADD    D7,TBYTES(A0)        ; accum total bytes
  2939.     INC    TFILES(A0)        ; accum total files
  2940.     MOV    D2,D4            ; save for effective baud rate
  2941.     MOV    FSIZE(A0),D3        ; get characters
  2942.     CRLF
  2943.     CALL    ELAPSE
  2944. 30$:    RTN
  2945. 40$:    CRLF
  2946.     TYPECR    <File transfer interrupted.>
  2947.     RTN
  2948.  
  2949. STATS:    TSTB    NOTALK(A0)
  2950.     BNE    100$            ; no user to talk to
  2951.     TYPE    <A total of>
  2952.     MOV    TBYTES(A0),D1
  2953.     DCVT    0,OT$TRM!OT$TSP!OT$LSP
  2954.     TYPE    <byte>
  2955.     CALL    PLURAL
  2956.     TYPE    < in>
  2957.     MOV    TFILES(A0),D1
  2958.     DCVT    0,OT$TRM!OT$TSP!OT$LSP
  2959.     TYPE    <file>
  2960.     CALL    PLURAL
  2961. 20$:    TYPECR    < transferred.>
  2962.     CMP    D1,#1
  2963.     BLOS    100$            ; show cumulative effect for <1 file
  2964.     MOV    TBYTES(A0),D3        ; get characters
  2965.     MOV    TTIME(A0),D2        ; get seconds
  2966.     TYPE    <Total >
  2967.     CALL    ELAPSE
  2968. 100$:    RTN
  2969.  
  2970. ; PLURAL - print an "s" if D1 is not 1.
  2971. PLURAL:    CMP    D1,#1    ; is it singular?
  2972.     BEQ    20$    ;  yes
  2973.     TYPE    <s>    ; no, plural
  2974. 20$:    RTN
  2975.  
  2976.     
  2977. ; ELAPSE displays the elapsed time & baud rate
  2978. ; At entry, D2 contains the time, and D3 contains the number of bytes xferred
  2979. ; trashes D4,D1,D6,D7,A6
  2980. ELAPSE:    TYPE    <elapsed time was >
  2981.     CLR    D1
  2982.     MOV    D2,D4
  2983.     DIV    D4,#60.*60.        ; convert to hours
  2984.     MOVW    D4,D1
  2985.     DCVT    2,OT$TRM!OT$ZER        ; display hours
  2986.     TYPE    :
  2987.     CLRW    D4
  2988.     SWAP    D4            ; remainder to lower 16 bits
  2989.     DIV    D4,#60.            ; make it minutes
  2990.     MOVW    D4,D1
  2991.     DCVT    2,OT$TRM        ; display minutes
  2992.     TYPE    :
  2993.     CLRW    D4
  2994.     SWAP    D4            ; seconds remiander to low 16
  2995.     MOV    D4,D1
  2996.     DCVT    2,OT$TRM        ; display seconds
  2997.     TST    D2            ; were seconds 0?
  2998.     BEQ    20$            ;  baud rate is infinite!
  2999.     TYPE    <, effective baud rate was >
  3000.     MOV    D3,D1
  3001. ; multiply by 10 by adding 2*D1 and 8*D1
  3002.     MOV    D1,D7            ; duplicate
  3003.     ADD    D1,D1            ;  double
  3004.     LSL    D7,#3.            ;   shift to make 8* old D1
  3005.     ADD    D7,D1            ;    add to make 10 * old D1
  3006.     DIV    D1,D2            ;  divided by seconds
  3007.     AND    #^O177777,D1        ; strip off remainder
  3008.     DCVT    0,OT$TRM        ; display it
  3009. 20$:    TYPECR    <.>            ; new line
  3010. 30$:    RTN
  3011.  
  3012.  
  3013. ; S H O E S C  displays the current escape from connect mode character.
  3014. SHOESC:    TYPE    <Escape character is >
  3015.     MOVB    KMETA(A0),D1
  3016.     CALL    SHOCHR
  3017.     CRLF
  3018.     RTN
  3019.  
  3020. ; S H O C H R  -  displays in printable form the character in D1.
  3021. SHOCHR:    PUSH    D1
  3022.     TSTB    CMASK(A0)        ; 7 or 8 bit terminal?
  3023.     BMI    10$            ;  terminal is 8 bits!
  3024.     BTST    #7.,D1
  3025.     BEQ    10$
  3026.     TYPE    <%>
  3027.     BR    15$
  3028. 10$:    TYPE    < >
  3029. 15$:    ANDB    CMASK(A0),D1
  3030.     CMPB    D1,#DEL
  3031.     BNE    18$
  3032.     TYPE    DEL
  3033.     BR    50$
  3034. 18$:    CMPB    D1,#SPACE
  3035.     BHIS    20$
  3036.     PUSH    D1
  3037.     MOVW    #177400!11.,D1
  3038.     TCRT
  3039.     TYPE    ^
  3040.     MOVW    #177400!12.,D1
  3041.     TCRT
  3042.     POP    D1
  3043.     CTL    D1            ; un-controlify it
  3044.     BR    30$
  3045. 20$:    TYPE    < >
  3046. 30$:    TTY    
  3047. 50$:    POP    D1
  3048.     RTN
  3049.  
  3050. ; show the notice & title & version
  3051. KERTTL:    TTYL    TITLE        ; show the title
  3052. ; show the program name & version
  3053. KERVER:    TTYL    TITL2
  3054.     VCVT    KERMIT+PH.VER,OT$TRM    ; show the version #
  3055.     CRLF
  3056.     RTN
  3057.  
  3058. ; S H O D O T  - print a dot on user's terminal whenever a packet has been
  3059. ; sent or recvd. (But don't do it when using user's terminal for I/O.)
  3060. SHODOT:    TSTB    NOTALK(A0)        ; TCB owned by KERMIT job?
  3061.     BNE    10$            ;  yes - do not type dot!
  3062.     TYPE    <.>            ;  no-go ahead & show user kermit
  3063. 10$:    RTN                ;  is working
  3064.  
  3065. ; initialize wildcarder
  3066. PREBAT:
  3067.     ORB    #D$BYP!D$ERC,FIO+D.FLG(A0) ; bypass error messages
  3068.     CLRB    ABORTB(A0)        ; clear batch abort flag
  3069.     CLR    TFILES(A0)
  3070.     CLR    TBYTES(A0)
  3071.     CLR    TTIME(A0)        ; clear total stat amounts
  3072.     MOV    A2,SAVSPC(A0)        ; save user's file spec
  3073.     CLR    CMDPTR(A0)        ; clear ptr to CMDLIN.SYS
  3074.     CLR    CMDERR(A0)        ; clear CMDLIN error value
  3075.     CLRB    NXTCNT(A0)        ; pre-clear # of times GETNXT called
  3076.     TSTB    WILDOK(A0)        ; O.K. to use wildcarding?
  3077.     JEQ    100$            ;  no, don't even try!
  3078.     LEA    A2,CMDLNS
  3079.     FSPEC    CLDDB(A0)        ; load the DDB
  3080. ; fetch or find CMDLIN.SYS module - often in system memory
  3081.     FETCH    CLDDB(A0),A6        ; find or fetch it
  3082.     BNE    100$            ;  not found
  3083.     MOV    A6,CMDPTR(A0)
  3084.     SAVE    A0,A5
  3085.      LEA    A5,CMDIMP(A0)
  3086.      MOV    CMDPTR(A0),A6    
  3087.      MOV    A6,D7
  3088.      ADD    #PH.SIZ,A6
  3089. ; set up CMDLIN's internal ptrs in our impure area
  3090.      MOV    (A6)+,CMINI$(A5)    ; CMINI offset
  3091.      MOV    (A6)+,CMNXT$(A5)    ; CMNXT offset
  3092.      MOV    (A6)+,CMQRY$(A5)    ; CMQRY offset
  3093.      MOV    (A6)+,CMCMP$(A5)    ; CMCMP offset
  3094.      MOV    (A6)+,CMSKP$(A5)    ; CMSKP offset
  3095.      MOV    (A6)+,CMFSP$(A5)    ; CMFSP offset
  3096.      ADD    D7,CMINI$(A5)        ; CMINI address
  3097.      ADD    D7,CMNXT$(A5)        ; CMNXT address
  3098.      ADD    D7,CMQRY$(A5)        ; CMQRY address
  3099.      ADD    D7,CMCMP$(A5)        ; CMCMP address
  3100.      ADD    D7,CMSKP$(A5)        ; CMSKP address
  3101.      ADD    D7,CMFSP$(A5)        ; CMFSP address
  3102. ; now init CMDLIN    
  3103.      MOV    SAVSPC(A0),A2        ; user's spec
  3104.      LEA    A0,DFAULT        ; default spec
  3105.      CLR    D7            ; operation flags
  3106.      .CMINI
  3107.     REST    A0,A5            ; restore regs CMDLIN uses
  3108.     MOV    D6,CMDERR(A0)        ; save CMDLIN error, if any
  3109.     SETB    CMDFLG(A0)        ; flag we have CMDLIN.SYS
  3110. 100$:    MOV    SAVSPC(A0),A2
  3111.     RTN
  3112.  
  3113.  
  3114. ; wildcard next spec routine
  3115. ; handles a single spec if CMDLIN.SYS is not available.
  3116. ;     V set if end of spec 
  3117. GETNXT:
  3118.     PUSHB    FIO+D.FLG(A0)        ; save flags
  3119.      PUSH    FIO+D.BUF(A0)        ; save buffer address (if any)
  3120.       CLEAR    FIO(A0),D.DDB        ; clean the ddb for re-use
  3121.      POP    FIO+D.BUF(A0)        ; 
  3122.     POPB    FIO+D.FLG(A0)        ; restore buffer address & flags
  3123.     CLRB    ABORTF(A0)        ; clear abort file flag
  3124.     TSTB    CMDFLG(A0)        ; do we have CMDLIN?
  3125.     BNE    10$            ;  yes
  3126.     TSTB    NXTCNT(A0)        ;  no, bump count
  3127.     JNE    60$            ;  done    
  3128.     INCB    NXTCNT(A0)
  3129.     MOV    SAVSPC(A0),A2
  3130.     ORB    #D$BYP!D$ERC,SIO+D.FLG(A0) ; bypass error messages
  3131.     FSPEC    SIO(A0),LST
  3132.     BR    20$            ; transfer
  3133.  
  3134. ; handle file request via system wildcarder.
  3135. 10$:    MOV    SAVSPC(A0),A2        ; index the spec
  3136.     PUSH    A5
  3137.      LEA    A5,CMDIMP(A0)        ; index CMDLIN impure ptr
  3138.     .CMNXT    SIO(A0)            
  3139.      MOV    D7,CMNEXT(A0)
  3140.     POP    A5
  3141.     MOV    A2,SAVSPC(A0)        ; save the spec
  3142.     MOV    CMNEXT(A0),D7        ; get the flags
  3143.     AND    #NX$END,D7        ; end of specs?
  3144.     JNE    60$            ;  yes-end
  3145. ; handle /Q logic if not invoking send remotely
  3146.     TSTB    NOTALK(A0)        ; invoked remotely?
  3147.     BNE    20$            ;  yes, no user to query
  3148.     PFILE    SIO(A0)
  3149.     SAVE    A5
  3150.      LEA    A5,CMDIMP(A0)        ; index CMDLIN impure ptr
  3151.     .CMQRY                ; ask user
  3152.     REST    A5
  3153.     BEQ    10$            ;  user didn't want to send that file
  3154. 20$:
  3155. ; copy filespec to working ddb
  3156.     MOVW    SIO+D.DEV(A0),FIO+D.DEV(A0)
  3157.     MOVW    SIO+D.DRV(A0),FIO+D.DRV(A0)
  3158.     MOV    SIO+D.FIL(A0),FIO+D.FIL(A0)
  3159.     MOVW    SIO+D.EXT(A0),FIO+D.EXT(A0)
  3160.     MOVW    SIO+D.PPN(A0),FIO+D.PPN(A0)
  3161.     MOV    SIO+D.CPU(A0),FIO+D.CPU(A0)
  3162.     CALL    GFILNM            ; process the filename
  3163.     INIT    FIO(A0)
  3164.     LOOKUP    FIO(A0)            ; does the file exist?    
  3165.     BEQ    30$            ;  yes-ok, proceed
  3166.     NEGB    FIO+D.ERR(A0)        ; normalize error code
  3167.     BR    50$            ; and exit
  3168. 30$:    TSTW    FIO+D.ACT+.W0L15(A0)    ; random file ?
  3169.     BPL    40$            ;  no
  3170.     TSTB    NOTALK(A0)        ;   yes-we dont do these!
  3171.     BNE    34$            ;    no user to show!
  3172.     TYPE    <%Bypassing random file >
  3173.     PFILE    FIO(A0)
  3174.     CRLF
  3175. 34$:    JMP    10$            ; skip the random file
  3176.  
  3177. 40$:    OPENI    FIO(A0)            ; open for input
  3178. 50$:    MOV    #1,D7            ; cheap LCC #0
  3179.     BR    70$
  3180. 60$:    LCC    #PS.V            ; end of spec
  3181. 70$:    RTN
  3182.  
  3183. ; clear the checkbytes
  3184. CLRSUM:    CLRW    ASSUM(A0)        ; clear checksum
  3185.     CLRW    FRMSUM(A0)        ; and clear CRC
  3186.     RTN
  3187.  
  3188. ; accumulate the checksum & CRC
  3189. ACCUM:    PUSH    D1
  3190.     AND    #^H0FF,D1
  3191.     ADDW    D1,ASSUM(A0)        ; handle 1 & 2 byte sums
  3192.     CALL    CCITT            ; handle 3 byte CRC
  3193.     POP    D1
  3194.     RTN
  3195.  
  3196. ;    x^16+x^12+x^5+1 REVERSE!!!!!
  3197. ; Routine to calculate CCITT CRC for byte in D1.
  3198. ; this routine breaks down the task into two nibble operations.
  3199. ; based on C routine by andy lowry of columbia university. 
  3200. ; See page 257 of Da Cruz book.
  3201. CCITT:    SAVE    D2,D4,D7
  3202.     MOVW    FRMSUM(A0),D4        ; get remainder bits
  3203.     ANDW    #^H0FF,D1        ; mask to 8 bits
  3204.     XORB    D4,D1            ; combine
  3205.     MOVW    D1,D2            ; copy
  3206.     RORW    D2,#4.            ; move bits 7-4 to 3-0
  3207.     ANDW    #^B1111,D2        ; strip to a nibble
  3208.     ANDW    #^B1111,D1        ; strip to a nibble
  3209.     LSLW    D2,#1
  3210.     LSLW    D1,#1            ; make them word offsets
  3211. ; NOTE THAT [~Dx] IS OK SINCE D1 & D2 ARE STRIPPED TO A NIBBLE!
  3212. ; (got to watch sign extend on word ops!)
  3213.     MOVW    CRCTB2[~D1],D1
  3214.     MOVW    CRCTAB[~D2],D7
  3215.     XORW    D7,D1
  3216.     RORW    D4,#8.            ; get old B15-B8 in lo 8
  3217.     ANDW    #^O377,D4
  3218.     XORW    D1,D4            ; xor in new bits
  3219.     MOVW    D4,FRMSUM(A0)        ; store CRC
  3220.     REST    D2,D4,D7
  3221.     RTN
  3222.  
  3223. ; Data tables for CRC-CCITT generation
  3224. CRCTAB:    word    0
  3225.     word    10201
  3226.     word    20402
  3227.     word    30603
  3228.     word    41004
  3229.     word    51205
  3230.     word    61406
  3231.     word    71607
  3232.     word    102010
  3233.     word    112211
  3234.     word    122412
  3235.     word    132613
  3236.     word    143014
  3237.     word    153215
  3238.     word    163416
  3239.     word    173617
  3240.  
  3241. CRCTB2:    word    0
  3242.     word    10611
  3243.     word    21422
  3244.     word    31233
  3245.     word    43044
  3246.     word    53655
  3247.     word    62466
  3248.     word    72277
  3249.     word    106110
  3250.     word    116701
  3251.     word    127532
  3252.     word    137323
  3253.     word    145154
  3254.     word    155745
  3255.     word    164576
  3256.     word    174367
  3257.  
  3258.  
  3259.  
  3260.  
  3261. IMPNAM:    RAD50    /KERMITIMP/        ; name of user's variables module.
  3262.  
  3263. ; This table defines the KERMIT commands and the subroutine address
  3264. DEFINE    KCOM    NAME, KSIZE, ADDR, HELP
  3265.     WORD    10$$-.
  3266.     BYTE    KSIZE
  3267.     ASCII    /NAME/
  3268.     BYTE    0
  3269.     EVEN
  3270.     ASCII    /HELP/
  3271.     BYTE    0
  3272.     EVEN
  3273. 10$$:    WORD    ADDR-.
  3274.     ENDM
  3275.  
  3276. ; K E R C O M   is the main commands table for KERMIT.
  3277. KERCOM:    
  3278. KCOM    AMOS,1,AMOS,<Execute an AMOS command.>
  3279. KCOM    CONNECT,1,CONNEC,<Connects your terminal to the remote KERMIT site.>
  3280. KCOM    EXIT,1,GOODBY,<Exit from KERMIT to AMOS.>
  3281. KCOM    HELP,1,HELP,<Types a summary of KERMIT commands and what they do.>
  3282. KCOM    RECEIVE,1,RECEIV,<RECEIVE {filespec} receives one or more files from the remote KERMIT.>
  3283. KCOM    SEND,1,SEND,<SEND {filespec} sends one or more files to remote KERMIT.>
  3284. KCOM    SET,3,SET,<Set controls options: enter SET ? for more help.>
  3285. KCOM    SHOW,2,SHOW,<Show displays the current SET options.>
  3286. KCOM    ?,1,HELP,<The shorthand version of HELP.>
  3287.     WORD    0
  3288.  
  3289. ; S E T C O M  is the SET subcommands table for SET.
  3290. SETCOM:    
  3291. KCOM    AUTORECEIVE,5,AUTREC,<RECEIVE command automatically sends KERMIT & SEND to remote Kermit.>
  3292. KCOM    AUTOSEND,5,AUTSND,<SEND command automatically sends KERMIT & RECEIVE to remote Kermit.>
  3293. KCOM    BELL,2,BELL,<Beep after each file transfer.>
  3294. KCOM    BLOCKCHECK,2,BLOCK,<Block-check type: 1, 2, or 3 check bytes.>    
  3295. KCOM    DEBUG,2,DEBUG,<Debug option ON or OFF.>
  3296. KCOM    DUPLEX,2,DUPLEX,<Set FULL or HALF duplex.>
  3297. KCOM    ENDLINE,2, ENDLIN,<Packet terminator character.>
  3298. KCOM    ESCAPE,2,ESCAPE,<Escape character for CONNECT.>
  3299. KCOM    PACKETSIZE,8.,PAKMAX,<Maximum packet size.>
  3300. KCOM    PACKETSTART,8.,PAKMRK,<Packet starting character.>
  3301. KCOM    PARITY,2,SETPAR,<Denote parity type for NON-alpha remotes.>
  3302. KCOM    RETRIES,1,NEWTRY,<Number of failed packet attempts that cause abort.>
  3303. KCOM    STALL,1,STLVAL,<Number of hundreths of seconds to pause between characters.>
  3304. KCOM    TIMEOUT,1,TIMER,<Packet time-out value in seconds.>
  3305.     WORD    0
  3306.  
  3307. ; This table defines the GETOPT list for options arguments.
  3308. DEFINE    OPT    NAME, KSIZE, VALUE
  3309.     WORD    10$$-.    ; offset to next entry
  3310.     BYTE    KSIZE    ; # of unique bytes in entry
  3311.     ASCII    /NAME/    ; entry text
  3312.     BYTE    0    ; terminator
  3313.     EVEN        ; word oriented table
  3314. 10$$:    WORD    VALUE    ; associated value
  3315.     ENDM
  3316.  
  3317. ; This defines the format of the end of the options list.
  3318. DEFINE    OMSG    STRING
  3319.     WORD    0
  3320.     ASCII    /STRING/
  3321.     BYTE    0
  3322.     ENDM
  3323.  
  3324. ; options list for logical options (YES, NO, 1,0, TRUE, FALSE are valid)
  3325. ONOFF:
  3326. YESNO:    OPT    YES,1,377
  3327.     OPT    NO,1,0
  3328.     OPT    ON,2,377
  3329.     OPT    OFF,2,0
  3330.     OPT    TRUE,1,377
  3331.     OPT    FALSE,1,0
  3332.     OPT    1,1,377
  3333.     OPT    0,1,0
  3334.     OMSG    <%Use YES or NO, ON or OFF, TRUE or FALSE, 1 or 0.>
  3335.     EVEN    
  3336.  
  3337. ; options list for block check size
  3338. ONE23:    OPT    1,1,'1
  3339.     OPT    2,1,'2
  3340.     OPT    3,1,'3
  3341.     OPT    ONE,1,'1
  3342.     OPT    TWO,2,'2
  3343.     OPT    THREE,2,'3
  3344.     OPT    III,3,'3
  3345.     OPT    II,2,'2
  3346.     OPT    I,1,'1
  3347.     OMSG    <%Use 1, 2, 3, ONE ,TWO, THREE, I, II, III to set check value size.>
  3348.     EVEN
  3349.  
  3350. ; list of valid parity settings, so you can't set parity George, but you
  3351. ; can set parity Mark.
  3352. PARLST:    OPT    NONE,1,'N
  3353.     OPT    EVEN,1,'E
  3354.     OPT    ODD,1,'O
  3355.     OPT    MARK,1,'M
  3356.     OPT    SPACE,1,'S
  3357.     OPT    YES,1,'Y
  3358.     OMSG    <%Use None, Even, Odd, Mark, or Space.>
  3359.     EVEN
  3360.  
  3361. ; options for echoplex (see DUPLEX:)
  3362. EPLEX:    OPT    FULL,1,0
  3363.     OPT    HALF,1,377
  3364.     OMSG    <%Use FULL or HALF to set duplex options.>
  3365.     EVEN
  3366.  
  3367.  
  3368. ; S W C A S E - macro to define the switcher state table
  3369. DEFINE    SWCASE    STATE, ROUTE
  3370.     BYTE    STATE
  3371.     EVEN
  3372.     OFFSET    ROUTE
  3373.     ENDM
  3374.  
  3375. ; S W S T A T  is the table of valid SEND FILE states for KERMIT,
  3376. ; and the offsets to the corresponding next routines.
  3377. SWSTAT:    SWCASE    'S,SINIT
  3378.     SWCASE    'F,SFILE
  3379.     SWCASE    'D,SDATA
  3380.     SWCASE    'Z,SEOF
  3381.     SWCASE    'B,SBREAK
  3382.     SWCASE    'C,COMPLT
  3383.     SWCASE    'A,ABORT
  3384.     BYTE    0
  3385.  
  3386.     EVEN
  3387.  
  3388. ; R C S T A T  is the table of valid RECEIVE FILE states for KERMIT,
  3389. ; and the offsets to the corresponding next routines.
  3390. RCSTAT:    SWCASE    'R,RINIT            ; receive init
  3391.     SWCASE    'F,RFILE            ; receive file
  3392.     SWCASE    'D,RDATA            ; receive data
  3393.     SWCASE    'C,RCOMP            ; receive complete
  3394.     SWCASE    'A,RABOR            ; receieve abort
  3395.     BYTE    0
  3396.  
  3397.  
  3398.  
  3399. HLP1:    ASCII    /          ========== Alpha-Kermit help ==========/
  3400.     BYTE    CR,CR,0    
  3401.  
  3402. ABTTTL:    ASCII    /KERMIT aborting with the following error from REMOTE host:/
  3403.     BYTE    CR,0
  3404.  
  3405. ; tables for GETOPT subroutine
  3406.  
  3407. DEFINE    OPT    CHAR,CODE = BYTE    CHAR,CODE
  3408.  
  3409.  
  3410. SET1:    ASCII    / SET allows you to change the following parameters./
  3411.     BYTE    CR,CR,0
  3412.  
  3413. NONONO:    ASCII    /%You cannot CONNECT to your own terminal!/
  3414.     BYTE    CR
  3415.     ASCII    /You must specify the communications port name when KERMIT is invoked:/
  3416.     BYTE    CR
  3417.     ASCII    /     e.g.  KERMIT MODEM uses the MODEM communications port./
  3418.     BYTE    CR,0
  3419.  
  3420. TITLE:
  3421.     ASCII    'Copyright 1984, 1994 Robert P. Rubendunst.'
  3422.     BYTE    CR    
  3423.     ASCII    'Alpha-Kermit by Soft Machines.'
  3424.     BYTE    CR
  3425.     ASCII    'Permission is granted to use this software at no charge'
  3426.     BYTE    CR
  3427.     ASCII    'provided that this message is not changed or deleted from'
  3428.     BYTE    CR
  3429.     ASCII    'any copy of this software.'
  3430.     BYTE    CR,0
  3431.  
  3432.  
  3433.     DEFINE    TEXT    ARG
  3434.     ASCII    ~ARG~
  3435.     BYTE    CR
  3436.     ENDM
  3437. USAGE:
  3438.     BYTE    CR,CR
  3439.     TEXT    <Usage: KERMIT  {communications-port}>
  3440.     BYTE    CR
  3441.     TEXT    <   NOTE: KERMIT has two modes of operation - Local and Remote!>
  3442.     BYTE    CR
  3443.     TEXT    <   LOCAL mode supports serial communications and file transfers through>
  3444.     TEXT    <   a separate communications port, e.g. MODEM1.>
  3445.     TEXT    <   For LOCAL mode, enter KERMIT and the name of the communications port,>
  3446.     TEXT    <   and then a carriage return, e.g. KERMIT MODEM1.>
  3447.     BYTE    CR
  3448.     TEXT    <   REMOTE mode is used to support only file transfers for REMOTE users,>
  3449.     TEXT    <   e.g. PC users signed on to the Alpha Micro.>
  3450.     TEXT    <   REMOTE mode uses the same port for commands and file transfers.>
  3451.     TEXT    <   For REMOTE mode, just enter KERMIT and return.>
  3452.     BYTE    CR,CR
  3453.     TEXT    <KERMIT will display the prompt Alpha-Kermit> if you have selected LOCAL mode,>
  3454.     TEXT    <or REMOTE Alpha-Kermit if you have selected REMOTE mode.>
  3455.     BYTE    0
  3456.  
  3457. CUSAGE:
  3458.     BYTE    CR
  3459.     TEXT    <You are now communicating with whatever device is connected>
  3460.     TEXT    <to the serial port (e.g. your modem, or another system.)>
  3461.     TEXT    <Data received by the serial port will be displayed on this screen.>
  3462.     TEXT    <Until you press the special escape character, all of your keypresses>
  3463.     TEXT    <will be sent out of the serial port.>
  3464.     TEXT    <Pressing the escape character returns you to Alpha-Kermit's command mode.>
  3465.     BYTE    CR
  3466.     TEXT    <If you are using a modem, your terminal is now "connected">
  3467.     TEXT    <to the modem. Consult your modem manual for instructions on>
  3468.     TEXT    <dialing, hanging up, changing modem settings, etc.>
  3469.     BYTE    CR
  3470.     TEXT    <Special tips for most modem users:>
  3471.     TEXT    <  Before dialing, enter the characters ATE1Q0 and a return,>
  3472.     TEXT    <  even though your keypresses may not be echoed on the screen.>
  3473.     TEXT    <  Before exiting CONNECT, enter ATE0Q1 and a return!>
  3474.     BYTE    CR
  3475.     TEXT    <Have fun!>
  3476.     BYTE    CR,CR,0
  3477.  
  3478. ; string that SEND command sends to remote Kermit to automatically get it
  3479. ; ready to receive data.
  3480. PRESND:    ASCII    "KERMIT"
  3481.     BYTE    CR,-1
  3482.     ASCII    "RECEIVE"
  3483.     BYTE    CR,0
  3484. ; string that RECEIVE command sends to remote Kermit to automatically get it
  3485. ; ready to send data.
  3486. PREREC:    ASCII    "KERMIT"
  3487.     BYTE    CR,-1
  3488.     ASCII    "SEND "    ; note no CR - RECEIVE will send the filespec later!
  3489.     BYTE    0
  3490. ; show command strings
  3491. SH1.0:    ASCIZ    "Modem Port: "
  3492. SH2.0:    BYTE    CR
  3493.     TEXT    <             SET Options>
  3494.     ASCIZ    " Autoreceive:  "
  3495. SH2.1:    ASCIZ    "      Autosend:  "
  3496. SH2.2:    BYTE    CR
  3497.     ASCIZ    "        Bell:  "
  3498. SH2.3:    ASCIZ    "    Blockcheck:    "
  3499. SH2.4:    BYTE    CR
  3500.     ASCIZ    "       Debug:  "
  3501. SH2.5:    ASCIZ    "        Duplex: "
  3502. SH2.6:    ASCIZ    "        Escape:  "
  3503. SH2.7:    BYTE    CR
  3504.     ASCIZ    " Packet Size: "
  3505. SH2.7A:
  3506.     ASCIZ    "  Packet Start:  "
  3507. SH2.8:    BYTE    CR
  3508.     ASCIZ    "      Parity:  "
  3509. SH2.8A:    ASCIZ    "       Retries: "
  3510. SH2.9:    BYTE    CR
  3511.     ASCIZ    "       Stall: "
  3512. SH2.9A:    ASCIZ    "/100   Timeout: "
  3513. SH3.0:    BYTE    CR
  3514.     TEXT    <Received or Default Packet Parameters>
  3515.     ASCIZ    "  Blockcheck:    "
  3516. SH3.1:    ASCIZ    "    8Bit Quote: "
  3517. SH3.2:    BYTE    CR
  3518.     ASCIZ    "     Endline: "
  3519. SH3.3:    ASCIZ    "  Maximum Size: "
  3520. SH3.4:    BYTE    CR
  3521.     ASCIZ    "   Pad Count:   "
  3522. SH3.5:    ASCIZ    "     Pad Value:  "
  3523. SH3.6:    BYTE    CR
  3524.     ASCIZ    "     Timeout: "
  3525. SH3.8:    BYTE    CR,CR,0
  3526.     
  3527. SH.DAS:    ASCIZ    "------"
  3528. SH.OFF:    ASCIZ    "OFF"
  3529. SH.ON:    ASCIZ    " ON"
  3530. SH.FUL:    ASCIZ    "FULL"
  3531. SH.HAL:    ASCIZ    "HALF"
  3532. SH.ZIP:    ASCIZ    "NONE"
  3533. NOSET:    BYTE    CR
  3534.     ASCII    /%Kermit cannot change the communications port parity, but setting is noted./
  3535.     BYTE    CR,0
  3536. TITL2:    BYTE    CR
  3537.     ASCII    'Alpha-Kermit version '
  3538.     BYTE    0
  3539. CMDLNS:    ASCIZ    "DSK0:CMDLIN.SYS[1,4]"
  3540. DFAULT:    ASCIZ    "*.*"
  3541. NMTN:    ASCII    "?No matching terminal name"
  3542.     BYTE    CR,0
  3543. RENTER:    ASCII    "Note: Kermit session already in progress - new port name ignored."
  3544.     BYTE    CR,A.BEL,0
  3545.     EVEN
  3546.  
  3547.     END END END
  3548.