home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / msk316src.zip / MSNTNI.ASM < prev    next >
Assembly Source File  |  1999-04-24  |  26KB  |  942 lines
  1.     NAME    msntni
  2. ; File MSNTNI.ASM
  3. ; Telnet interface to MS-DOS Kermit
  4. ;
  5. ;    Copyright (C) 1982, 1999, Trustees of Columbia University in the 
  6. ;    City of New York.  The MS-DOS Kermit software may not be, in whole 
  7. ;    or in part, licensed or sold for profit as a software product itself,
  8. ;    nor may it be included in or distributed with commercial products
  9. ;    or otherwise distributed by commercial concerns to their clients 
  10. ;    or customers without written permission of the Office of Kermit 
  11. ;    Development and Distribution, Columbia University.  This copyright 
  12. ;    notice must not be removed, altered, or obscured.
  13. ;
  14. ; Written by Joe R. Doupnik, Utah State University, 
  15. ;  jrd@cc.usu.edu, jrd@usu.Bitnet.
  16. ;
  17. ; Edit history
  18. ; 12 Jan 1995 version 3.14
  19. ; Last edit
  20. ; 12 Jan 1995
  21. ;
  22. ; Some rules of the road.
  23. ; Starting a session: call ktpcopen. This will ensure the interrupts are
  24. ; hooked and will start a new session. Ktcpopen will return the ident of
  25. ; the new session, or -1 upon failure.
  26. ; Stopping a session: this must be done from outside Telnet. Call ktcpclose
  27. ; with a particular session ident (0.. MAXSESSIONS-1) to close that session
  28. ; or call it with an ident of -1 to close all and shutdown TCP. Ktcpclose
  29. ; will return with the ident of the next (cyclic) active session, or -1 if
  30. ; none remain active. Register AX holds incoming indent, outgoing status.
  31. ; When TCP/IP shuts down it releases all interrupts and disengages from the
  32. ; Packet Driver. This will occur upon closing the last active connection.
  33. ;
  34. ; Swapping active sessions: call ktcpswap with a new session ident to change
  35. ; to that new one. This will return with the new ident if successful, or -1.
  36. ; We have to guess session idents so an outside manager can pick and choose.
  37. ; Use ktcpswap to resume a session because ktcpstart always tries to start a
  38. ; new one.
  39.  
  40.     include    mssdef.h
  41.  
  42. bapicon    equ    0a0h        ; 3Com BAPI, connect to port
  43. bapidisc equ    0a1h        ; 3Com BAPI, disconnect
  44. bapiwrit equ    0a4h        ; 3Com BAPI, write block
  45. bapiread equ    0a5h        ; 3Com BAPI, read block
  46. bapibrk    equ    0a6h        ; 3Com BAPI, send short break
  47. bapistat equ    0a7h        ; 3Com BAPI, read status (# chars to be read)
  48. bapihere equ    0afh        ; 3Com BAPI, presence check
  49. bapieecm equ    0b0h        ; 3Com BAPI, enable/disable ECM char
  50. bapiecm    equ    0b1h        ; 3Com BAPI, trap Enter Command Mode char
  51.  
  52. data    segment public 'kdata'
  53.     extrn    tcptos:word        ; top of stack for TCP code
  54.     extrn    flags:byte, yflags:byte, portval:word, ttyact:byte
  55.     extrn    crt_lins:byte, crt_cols:byte
  56.     extrn    tcp_status:word
  57.     extrn    tcpaddress:byte, tcpsubnet:byte, tcpdomain:byte
  58.     extrn    tcpgateway:byte, tcpprimens:byte, tcpsecondns:byte
  59.     extrn    tcphost:byte, tcpbcast:byte, tcpbtpserver:byte
  60.     extrn    tcpport:word, tcppdint:word, tcpttbuf:byte, tcpnewline:byte
  61.     extrn    tcpdebug:byte, tcpmode:byte, tcpmss:word, tcpbtpkind:byte
  62.     extrn    tloghnd:word, tcp_rto:word
  63. ifndef    no_terminal
  64.     extrn    ftogmod:dword
  65. endif    ; no_terminal
  66. data    ends
  67.  
  68. _TEXT    SEGMENT  WORD PUBLIC 'CODE'
  69. _TEXT    ENDS
  70. _DATA    SEGMENT  WORD PUBLIC 'DATA'
  71. _DATA    ENDS
  72. CONST    SEGMENT  WORD PUBLIC 'CONST'
  73. CONST    ENDS
  74. _BSS    SEGMENT  WORD PUBLIC 'BSS'
  75. _BSS    ENDS
  76. DGROUP    GROUP    CONST, _BSS, _DATA
  77.     ASSUME  CS: _TEXT, DS: DGROUP, SS: DGROUP
  78.  
  79. _DATA      SEGMENT
  80.     public    _kmyip, _knetmask, _kdomain, _kgateway, _kns1, _kns2, _khost
  81.     public    _kbcast, _bapiadr, _bapireq, _bapiret
  82.     public    _display_mode, _kport, _kpdint, _kserver, _kdebug, _kterm
  83.     public    _ktttype, _kterm_lines, _kterm_cols, _kbtpserver, _tcp_status
  84.     public    _tcpflag, _ktnmode, _ktcpmss, int8cnt
  85.     extrn    _msgcnt:word, _msgbuf:byte, _echo:byte, _bootmethod:byte
  86.  
  87.         db 10 dup (0)        ; guard
  88.         db 'DUMMY',0           ; null pointer guard
  89. _kmyip        db 17 dup (0)        ; our IP number
  90. _knetmask    db 17 dup (0)        ; our netmask
  91. _kdomain    db 33 dup (0)        ; our domain
  92. _kgateway     db 33 dup (0)        ; our gateway
  93. _kns1        db 17 dup (0)        ; our nameserver #1
  94. _kns2        db 17 dup (0)        ; our nameserver #2
  95. _khost        db 61 dup (0)        ; remote host name/IP #
  96. _kbcast        db 17 dup (0)        ; broadcast IP
  97. _ktttype    db 33 dup (0)        ; terminal-type override string
  98. _kbtpserver    db 17 dup (0)        ; Bootp server which responded
  99. _kserver    dw    0        ; non-zero for Kermit server
  100. _kport        dw    23        ; TCP port (Telnet = 23)
  101. _kpdint        dw    0        ; Packet Driver Int, 0 = search
  102. _kdebug        db    0        ; if SET DEBUG ON is effective
  103. _ktnmode    db    0        ; Telnet mode (0=NVT-ASCII,1=BINARY)
  104. _kterm        dw    0        ; terminal type index, see mssdef.h
  105. _kterm_lines    db    0        ; terminal screen height (24)
  106. _kterm_cols    db    0        ; terminal screen width (80)
  107. _ktcpmss    dw    0        ; MSS override
  108. oldint8    dd    0            ; original Int 8 owner
  109. tcpstack dd    0            ; TCP code stack
  110. stack8    dd    0            ; stack at Int 8 invokation
  111. kstack    dw    0            ; Kermit mainline stack pointer
  112. tempax    dw    0            ; a temp
  113. _tcpflag db    0        ; who is running TCP code: 1=Kermit, 2=Int 8
  114. int8cnt    db    0            ; Int 8 times called counter
  115. hooked    db    0            ; Int 8 hooked status (0 = unhooked)
  116. _display_mode db 0            ; msg, none if == 0
  117. _bapireq dw    0            ; BAPI count of chars requested
  118. _bapiret dw    0            ; BAPI count of chars processed
  119. _bapiadr dd    0
  120. _tcp_status dw    0            ; tcp/ip status from msntnd.c
  121. _DATA      ENDS
  122.  
  123. _TEXT    segment
  124.     ASSUME  CS: _TEXT, DS: DGROUP, SS: DGROUP, es:nothing
  125.     extrn    _serial_handler:near, _tnmain:near, _tnexit:near 
  126.     extrn    _pkt_release:near, _tcp_tick:near
  127.     extrn    _strlen:near, _strcpy:near, _session_close:near
  128.     extrn    _session_change:near
  129.  
  130.     public    cpatch
  131. cpatch    equ    this byte
  132.     db    (100-($-cpatch)) dup (0)    ; _TEXT segment patch buffer
  133.  
  134. public    _enable
  135. enable    proc    near
  136. _enable    equ    this byte
  137.     sti
  138.     ret
  139. enable    endp
  140.  
  141. public    _disable
  142. disable    proc    near
  143. _disable equ    this byte
  144.     cli
  145.     ret
  146. disable    endp
  147.  
  148. ; Hook Interrupt 8h. Return AX = 1 if successful else 0.
  149. ; For use only by Telnet code as an internal procedure.
  150.     public    _hookvect
  151. hookvect proc    near
  152. _hookvect equ    this byte
  153.     cmp    hooked,0        ; hooked already?
  154.     je    hook0            ; e = no
  155.     mov    ax,1            ; say success
  156.     ret
  157. hook0:    push    bp
  158.     mov    bp,sp
  159.     mov    ax,bp
  160.     add    ax,2+2            ; C sp just before this call
  161.     cmp    word ptr tcpstack+2,0    ; have setup stack?
  162.     jne    hook1            ; ne = yes
  163.     mov    word ptr tcpstack,ax    ; save as main prog stack level
  164. hook1:    push    es
  165.     mov    ah,getintv        ; get interrupt vector
  166.     mov    al,8            ; vector number
  167.     int    dos
  168.     mov    ax,es
  169.     mov    cx,cs
  170.     cmp    ax,cx            ; points to us now?
  171.     je    hook2            ; e = yes, do not touch
  172.     mov    word ptr DGROUP:oldint8+2,ax    ; save segment
  173.     mov    word ptr DGROUP:oldint8,bx    ; save offset
  174.     mov    dx,offset ourtimer     ; new handler
  175.     push    ds
  176.     mov    ax,cs            ; segment
  177.     mov    ds,ax
  178.     mov    al,8            ; for Int 8
  179.     mov    ah,setintv        ; set interrupt address from ds:dx
  180.     int    dos
  181.     pop    ds
  182.     mov    hooked,1        ; say have hooked vector
  183. hook2:    mov    _tcpflag,1     ; say Kermit but not Int 8 is running TCP
  184.     mov    ax,1            ; return 1 for success
  185.     pop    es
  186.     pop    bp
  187.     ret
  188. hook3:    call    unhookvect        ; put any back
  189.     xor    ax,ax            ; return 0 for failure
  190.     pop    es
  191.     pop    bp
  192.     ret
  193. hookvect endp
  194.  
  195. ; For use only by Telnet code as an internal procedure.
  196.     public    _unhookvect
  197. unhookvect proc    near
  198. _unhookvect equ    this byte
  199.     cmp    hooked,0        ; hooked the vector?
  200.     jne    unhook1            ; ne = yes
  201.     mov    ax,1            ; say success
  202.     ret
  203. unhook1:push    bp
  204.     mov    bp,sp
  205.     push    es
  206.     push    bx
  207.     push    cx
  208.     clc
  209.     mov    tempax,0        ; assume failure status
  210.     mov    ah,getintv        ; get interrupt vector
  211.     mov    al,8            ; vector number
  212.     int    dos
  213.     jc    unhook2            ; c = failed
  214.     mov    ax,es            ; es:bx is current owner, us?
  215.     mov    cx,cs
  216.     cmp    ax,cx            ; seg should be right here
  217.     jne    unhook2            ; ne = is not
  218.     cmp    bx,offset ourtimer    ; should be the same too
  219.     jne    unhook2            ; ne = is not, let them have the int
  220.     mov    ax,word ptr DGROUP:oldint8+2    ; segment
  221.     mov    dx,word ptr DGROUP:oldint8    ; offset
  222.     mov    cx,dx
  223.     or    cx,ax            ; was it used by us?
  224.     jz    unhook2            ; z = no, leave alone
  225.     push    ds
  226.     mov    ds,ax
  227.     mov    al,8            ; for Int 8
  228.     mov    ah,setintv        ; set interrupt address from ds:dx
  229.     int    dos
  230.     pop    ds
  231.     and    _tcpflag,not 2        ; Int 8 no longer touches TCP
  232.     mov    word ptr DGROUP:oldint8,0
  233.     mov    word ptr DGROUP:oldint8+2,0
  234.     mov    hooked,0        ; say not hooked
  235.     mov    tempax,1        ; success status
  236.     jmp    short unhook3
  237. unhook2:mov    tempax,0        ; failure
  238. unhook3:mov    ax,tempax        ; return status (1=success, 0=fail)
  239.     pop    cx
  240.     pop    bx
  241.     pop    es
  242.     pop    bp
  243.     ret
  244. unhookvect endp
  245.  
  246. ; Int 8 routine to call the TCP code if Kermit main body does not.
  247. ; For use only by Telnet code as an internal procedure.
  248. ourtimer proc near
  249.     assume    ds:DGROUP, es:nothing
  250.     push    ds
  251.     push    ax
  252.     mov    ax,dgroup        ; set addressibility to our dgroup
  253.     mov    ds,ax
  254.     pushf                ; simulate interrupt invokation
  255.     call    dword ptr DGROUP:oldint8 ; call previous owner of Int 8
  256.     mov    ax,DGROUP        ; set addressibility to our dgroup
  257.     mov    ds,ax
  258.     test    _tcpflag,1+2        ; is TCP code running now?
  259.     jnz    ourtim2            ; nz = yes, so we don't run now
  260.     mov    al,int8cnt        ; get our times-called counter
  261.     inc    al            ; up once again
  262.     and    al,3            ; keep 2 bits, about .25 sec @18.2t/s
  263.     mov    int8cnt,al        ; store
  264.     or    al,al            ; is it zero?
  265.     jnz    ourtim2            ; nz = no, go away for awhile
  266.     or    _tcpflag,2        ; say we are running the TCP code
  267.     push    bp
  268.     push    bx
  269.     push    cx
  270.     push    dx
  271.     push    si
  272.     push    di
  273.     push    es
  274.     mov    ax,DGROUP
  275.     mov    es,ax
  276.     cli
  277.     mov    ax,ss
  278.     mov    word ptr stack8+2,ax    ; save current stack
  279.     mov    word ptr stack8,sp
  280.     mov    ax,word ptr tcpstack+2    ; get TCP stack seg
  281.     mov    ss,ax            ; set to TCP stack
  282.     mov    sp,word ptr tcpstack
  283.     sti                ; restart interrupts
  284.     xor    ax,ax            ; socket pointer, null
  285.     push    ax            ; set call frame for tcp_tick(NULL)
  286.  
  287.     call    _tcp_tick        ; process some incoming packets
  288.     pop    ax            ; clean call frame
  289.     mov    ax,DGROUP
  290.     mov    ds,ax
  291.     mov    ax,word ptr stack8+2    ; get original stack seg
  292.     cli
  293.     mov    ss,ax
  294.     mov    sp,word ptr stack8
  295.     sti
  296.     pop    es
  297.     pop    di
  298.     pop    si
  299.     pop    dx
  300.     pop    cx
  301.     pop    bx
  302.     pop    bp
  303.     and    _tcpflag,not 2        ; finished our running of TCP code
  304. ourtim2:pop    ax
  305.     pop    ds
  306.     iret
  307. ourtimer endp
  308.  
  309. ; This routine is invoked from outside by a Far call. Enter with the caller's
  310. ; registers but our CS. Switch stacks and data segments.
  311. ; This version supports 3Com BAPI calls and does the near/far stuff via
  312. ; a local buffer.
  313. ; AH holds BAPI request code
  314. ; ES:BX is pointer to user's buffer, CX holds request count.
  315.     public    ktcpcom
  316. ktcpcom     proc    FAR            ; i/o service routine
  317.     assume    ds:DGROUP, es:nothing
  318.     push    ds
  319.     push    ax
  320.     mov    ax,DGROUP        ; set addressibility to our dgroup
  321.     mov    ds,ax
  322.     pop    ax
  323.     cmp    hooked,0        ; have we inited (hooked vectors)?
  324.     je    ourser7            ; e = no, report nothing
  325.     test    _tcpflag,2        ; is Int 8 running TCP?
  326.     jz    ourser8            ; z = no, opposite should never happen
  327. ourser7:mov    ah,1            ; say no char written
  328.     xor    cx,cx            ; chars written
  329.     pop    ds
  330.     ret
  331.  
  332. ourser8:or    _tcpflag,1        ; say we are running TCP
  333.     push    es            ; save regs on the user's stack
  334.     push    di
  335.     push    si
  336.     push    dx
  337.     push    bx
  338.     push    bp
  339.     mov    kstack,sp        ; remember caller's stack now
  340.     mov    sp,word ptr tcpstack    ; move to our TCP stack
  341.     mov    word ptr _bapiadr,bx    ; remember caller's es:bx
  342.     mov    word ptr _bapiadr+2,es    ;  (i/o buffer address)
  343.     mov    _bapireq,cx        ; requested char count to TCP code
  344.     mov    _bapiret,0        ; init returned CX char count
  345.     cmp    ah,bapihere        ; presence check?
  346.     jne    ourser2            ; ne = no
  347.     mov    ax,0af01h        ; return this value
  348.     jmp    ourser4            ; done
  349.  
  350. ourser2:cmp    ah,bapiread        ; read?
  351.     jne    ourser3            ; ne = no
  352.     cmp    _msgcnt,0        ; any outstanding msgs from TCP?
  353.     je    ourser3            ; e = no msgs
  354.     call    oursmsg            ; send back the msgs instead
  355.     jnc    ourser4            ; nc = gave data, ax has status of ok
  356. ourser3:
  357.     mov    bx,DGROUP        ; set up es to dgroup too
  358.     mov    es,bx            ; bx is not needed at this time
  359.     ASSUME    DS:DATA
  360.     push    ds
  361.     mov    bx,seg data        ; address main body
  362.     mov    ds,bx
  363.     mov    es:_kserver,0        ; assume not a server
  364.     test    flags.remflg,dserver    ; Server mode?
  365.     jz    ourser3a        ; z = no
  366.     mov    es:_kserver,1        ; say being a server
  367. ourser3a:
  368.     push    ax
  369.     mov    al,tcpdebug        ; debug option
  370.     mov    es:_kdebug,al
  371.     pop    ax
  372.     pop    ds            ; return ds to dgroup
  373.  
  374.     ASSUME    DS:DGROUP, ES:DGROUP
  375.     xchg    ah,al            ; put BAPI function code in al
  376.     xor    ah,ah
  377.     push    ax            ; setup call frame
  378.  
  379.     call    _serial_handler        ; a near call, _serial_handler(ax)
  380.                     ; reg ax has return status
  381.     add    sp,2            ; clean stack
  382.     mov    cx,DGROUP        ; local addressing again
  383.     mov    ds,cx
  384.     mov    cx,_bapiret        ; CX has count of chars returned
  385. ourser4:clc                ; assume success
  386.     xchg    ah,al            ; put return status in ah
  387.     xor    al,al
  388.     cmp    ah,3            ; serious error status?
  389.     jb    ourserx            ; b = no, zero is success
  390.     stc                ; set carry too
  391. ourserx:mov    sp,kstack         ; move to caller's stack
  392.     and    _tcpflag,not 1        ; say we are not running TCP
  393.     pop    bp
  394.     pop    bx
  395.     pop    dx
  396.     pop    si
  397.     pop    di
  398.     pop    es
  399.     pop    ds
  400.     ret                ; AX and CX are changed as returns
  401. ktcpcom endp
  402.  
  403. ; Copy contents of msgbuf (local Telnet msg collector buffer) to main body.
  404. ; For use only by Telnet code as an internal procedure.
  405. ; Return CX as number of bytes delivered to Kermit main body.
  406. oursmsg    proc    near
  407.     assume    ds:DGROUP, es:nothing
  408.     cmp    _msgcnt,0
  409.     jne    oursmsg1        ; ne = have msg
  410.     stc                ; say nothing done here
  411.     ret
  412. oursmsg1:
  413.     push    es            ; debug to log file
  414.     mov    bx,seg tloghnd        ; transaction log handle segment
  415.     mov    es,bx
  416.     mov    bx,es:tloghnd        ; transaction log handle
  417.     pop    es
  418.     cmp    bx,-1            ; transaction log open?
  419.     je    oursmsg2        ; e = no, no file writing
  420.     push    ax
  421.     push    cx
  422.     mov    cx,_msgcnt
  423.     mov    dx,offset DGROUP:_msgbuf ; ds:dx is source buffer
  424.     mov    ah,write2        ; write cx bytes with handle in bx
  425.     int    dos
  426.     sub    _msgcnt,ax        ; deduct quantity written
  427.     pop    cx            ; preserve original cx
  428.     pop    ax            ; preserve original request in ax
  429.     stc                ; say no data to be read from here
  430.     ret
  431. oursmsg2:                ; debug to main body
  432.     push    ax
  433.     push    cx
  434.     mov    cx,_msgcnt
  435.     cmp    cx,_bapireq        ; longer than request?
  436.     jbe    oursmsg3        ; be = no
  437.     mov    cx,_bapireq        ; do this much now
  438. oursmsg3:
  439.     push    cx
  440.     push    es
  441.     mov    si,DGROUP
  442.     mov    ds,si
  443.     mov    si,offset DGROUP:_msgbuf ; whence it comes
  444.     les    di,_bapiadr        ; where it goes
  445.     cld
  446.     rep    movsb            ; copy Telnet buffer to main body
  447.     pop    es
  448.     pop    cx            ; return count in cx
  449.     mov    _bapiret,cx        ; return count to user
  450.     sub    _msgcnt,cx        ; deduct chars relayed
  451.     cmp    _msgcnt,0        ; examine remainder
  452.     je    oursmsg4        ; le = none
  453.     push    es
  454.     mov    si,DGROUP
  455.     mov    es,si
  456.     mov    si,offset DGROUP:_msgbuf ; whence it comes
  457.     mov    di,si
  458.     add    si,cx            ; number bytes read
  459.     mov    cx,_msgcnt        ; number of bytes remaining
  460.     cld
  461.     rep    movsb
  462.     pop    es
  463. oursmsg4:pop    cx            ; caller's request count
  464.     pop    ax            ; and function code
  465.     mov    cx,_bapiret        ; original count minus filled here
  466.     xor    ax,ax            ; return status of success
  467.     clc                ; filled caller's buffer
  468.     ret                ; cx has delivered byte count
  469. oursmsg    endp
  470.  
  471.  
  472. ; tcpaddress db    'unknown',(32-($-tcpaddress)) dup (0),0
  473. ; tcpsubnet  db    '255.255.255.0',(32-($-tcpsubnet)) dup (0),0
  474. ; tcpdomain  db    'unknown',(32-($-tcpdomain)) dup (0),0
  475. ; tcpgateway db    'unknown',(32-($-tcpgateway)) dup (0),0
  476. ; tcpprimens db    'unknown',(32-($-tcpprimens)) dup (0),0
  477. ; tcpsecondns db 'unknown',(32-($-tcpsecondns)) dup (0),0
  478. ; tcphost db    (60 -($-tcphost)) dup (0),0
  479. ; tcpbcast db    '255.255.255.255',(32-($-tcpbcast)) dup (0),0
  480. ; tcpport dw    23
  481. ; tcppdint dw    0
  482. ; tcpttbuf db    32 dup (0),0        ; term-type-override buffer
  483. ; tcpmss   dw    1500
  484. ; 
  485. ; tcpdata dw    offset tcpaddress ; externally visible far pointers
  486. ;     dw    offset tcpsubnet    + 2
  487. ;     dw    offset tcpdomain    + 4
  488. ;     dw    offset tcpgateway    + 6
  489. ;     dw    offset tcpprimens    + 8
  490. ;     dw    offset tcpsecondns    + 10
  491. ;    dw    offset tcphost        + 12
  492. ;    dw    offset tcpbcast        + 14
  493. ;    dw    offset tcpport        + 16
  494. ;    dw    offset tcppdint        + 18
  495. ;    dw    offset tcpttbuf        + 20
  496. ;    dw    offset tcpbtpserver    + 22
  497. ;    dw    offset tcpnewline    + 24
  498. ;    dw    offset tcpdebug        + 26
  499. ;    dw    offset tcpmode        + 28
  500. ;    dw    offset tcpmss        + 30
  501. ;
  502. ; Open a TCP/IP Telnet connection. Returns -1 if failure or if success it
  503. ; returns the small int session ident code. Creates a new session; use
  504. ; ktcpswap to reactivate existing sessions.
  505.     public    ktcpopen
  506. ktcpopen proc    far
  507.     ASSUME    DS:DATA, ES:DGROUP
  508.     push    es            ; save regs on main Kermit stack
  509.     push    ds
  510.     push    di
  511.     push    si
  512.     push    dx
  513.     push    cx
  514.     push    bx
  515.     push    bp
  516.     mov    ax,DGROUP
  517.     mov    es,ax            ; destination is the TCP module
  518.     cld
  519.     mov    si,offset tcpaddress    ; get offset of our IP address
  520.     mov    di,offset DGROUP:_kmyip    ; our storage slot
  521.     mov    cx,16            ; max bytes
  522. start5:    lodsb
  523.     stosb
  524.     or    al,al
  525.     loopne    start5            ; copy IP address string, asciiz
  526.     xor    al,al            ; extra terminator
  527.     stosb
  528.     mov    si,offset tcpsubnet    ; subnet mask
  529.     mov    di,offset DGROUP:_knetmask
  530.     mov    cx,16
  531. start6:    lodsb
  532.     stosb
  533.     or    al,al
  534.     loopne    start6
  535.     xor    al,al
  536.     stosb
  537.     mov    si,offset tcpdomain    ; domain
  538.     mov    di,offset DGROUP:_kdomain
  539.     mov    cx,32
  540. start7:    lodsb
  541.     stosb
  542.     or    al,al
  543.     loopne    start7
  544.     xor    al,al
  545.     stosb
  546.     mov    si,offset tcpgateway        ; gateway
  547.     mov    di,offset DGROUP:_kgateway
  548.     mov    cx,16
  549. start8:    lodsb
  550.     stosb
  551.     or    al,al
  552.     loopne    start8
  553.     xor    al,al
  554.     stosb
  555.     mov    si,offset tcpprimens        ; primary nameserver
  556.     mov    di,offset DGROUP:_kns1
  557.     mov    cx,16
  558. start9:    lodsb
  559.     stosb
  560.     or    al,al
  561.     loopne    start9
  562.     xor    al,al
  563.     stosb
  564.     mov    si,offset tcpsecondns        ; secondary nameserver
  565.     mov    di,offset DGROUP:_kns2
  566.     mov    cx,16
  567. start10:lodsb
  568.     stosb
  569.     or    al,al
  570.     loopne    start10
  571.     xor    al,al
  572.     stosb
  573.     mov    si,offset tcphost        ; remote host IP
  574.     mov    di,offset DGROUP:_khost
  575.     mov    cx,60
  576. start11:lodsb
  577.     stosb
  578.     or    al,al
  579.     loopne    start11
  580.     xor    al,al
  581.     stosb
  582.     mov    si,offset tcpbcast        ; IP broadcast
  583.     mov    di,offset DGROUP:_kbcast
  584.     mov    cx,16
  585. start12:lodsb
  586.     stosb
  587.     or    al,al
  588.     loopne    start12
  589.     xor    al,al
  590.     stosb
  591.     mov    ax,tcpport        ; port
  592.     mov    es:_kport,ax
  593.     mov    ax,tcppdint        ; Packet Driver Interrupt
  594.     mov    es:_kpdint,ax        ; 0 means scan
  595.     mov    si,offset tcpttbuf    ; offset of term-type string
  596.     mov    di,offset DGROUP:_ktttype ; local storage of the string
  597.     mov    cx,32
  598. start13:lodsb
  599.     stosb
  600.     or    al,al
  601.     loopne    start13
  602.     xor    al,al
  603.     stosb
  604.     mov    al,tcpdebug        ; debug-Options
  605.     mov    es:_kdebug,al
  606.     mov    al,tcpmode        ; mode
  607.     mov    es:_ktnmode,al
  608.     mov    ax,tcpmss        ; MSS override
  609.     mov    es:_ktcpmss,ax
  610.  
  611.     mov    si,portval
  612.     mov    al,[si].ecoflg        ; mainline SET echo flag
  613.     mov    es:_echo,al        ; init Options to this value
  614.  
  615.     mov    es:_display_mode,0    ; presume quiet screen
  616.     test    flags.remflg,dquiet    ; quiet display mode?
  617.     jnz    start14            ; nz = yes. Don't write to screen
  618.     inc    es:_display_mode    ; say can write to screen
  619. start14:mov    es:_kserver,0        ; assume not a server
  620.     test    flags.remflg,dserver    ; Server mode?
  621.     jz    start16            ; z = no
  622.     mov    es:_kserver,1        ; say being a server (do Listen)
  623. start16:mov    ax,flags.vtflg        ; get terminal type index
  624.     mov    es:_kterm,ax
  625.  
  626. start20:mov    bx,portval
  627.     mov    al,[bx].ecoflg        ; get mainline SET echo flag
  628.     mov    es:_echo,al        ; init Telnet echo status
  629.     mov    bx,tcptos        ; top of stack for tcp code
  630.  
  631.     assume    ds:DGROUP, ES:NOTHING
  632.     
  633.     mov    ax,dgroup        ; set addressibility to our dgroup
  634.     mov    ds,ax
  635.     mov    es,ax
  636.                     ; cold vs warm start
  637.     mov    word ptr kstack,sp    ; store Kermit's stack ptr
  638.     cmp    word ptr tcpstack+2,0    ; defined setup yet?
  639.     je    start1            ; e = no, get stack segment
  640.     mov    ax,word ptr tcpstack    ; set sp to existing TCP sp
  641.     mov    sp,ax            ; warm restart
  642.     jmp    short start2
  643.  
  644. start1:    mov    word ptr tcpstack+2,ax    ; set TCP stack seg to DGROUP
  645.     mov    word ptr tcpstack,bx    ; cold start
  646.     mov    sp,bx            ; new TCP stack pointer, DGROUP based
  647.  
  648. start2:    mov    bp,sp            ; preset this as insurance
  649.     or    _tcpflag,1        ; say this is running TCP code
  650.  
  651.     call    _tnmain            ; call the C code
  652.     mov    sp,word ptr kstack    ; restore for Kermit's main stack
  653.  
  654.     ASSUME    ES:DATA
  655.     mov    bx,data            ; main Kermit data segment
  656.     mov    es,bx
  657.     mov    bx,_tcp_status        ; status from msntnd.c
  658.     mov    es:tcp_status,bx    ; return tcp_status to main body
  659.     mov    bx,_kpdint        ; report back Packet Driver Int
  660.     mov    es:tcppdint,bx        ; store value in main data seg
  661.     ASSUME    ES:NOTHING
  662.     and    _tcpflag,not 1        ; finished running tcp code
  663.     pop    bp            ; restore regs, Kermit's main stack
  664.     pop    bx
  665.     pop    cx
  666.     pop    dx
  667.     pop    si
  668.     pop    di
  669.     pop    ds
  670.     pop    es
  671.     ret                ; return to caller, status in AX
  672. ktcpopen endp
  673.  
  674. ; Close session whose session ident is in register AL. If AL holds -1
  675. ; then shut down all sessions and shutdown Telnet. Returns ident of next
  676. ; active session (cyclic from the current session ident) or -1 if none
  677. ; remains active.
  678.     public    ktcpclose
  679. ktcpclose proc    far
  680.     assume    ds:dgroup, es:nothing
  681.     push    es            ; save regs on the user's stack
  682.     push    ds
  683.     push    di
  684.     push    si
  685.     push    dx
  686.     push    cx
  687.     push    bx
  688.     push    bp
  689.     mov    cx,dgroup        ; set addressibility to dgroup
  690.     mov    ds,cx
  691.     mov    es,cx
  692.     mov    kstack,sp        ; remember Kermit's main sp
  693.     cmp    word ptr tcpstack+2,0    ; have setup stack?
  694.     jne    ktcpclo4        ; ne = yes
  695.     mov    ax,-1            ; set failure status
  696.     jmp    short ktcpclo6        ; e = no, skip this routine
  697.  
  698. ktcpclo4:or    _tcpflag,1        ; say we are running TCP code
  699.     mov    cx,word ptr tcpstack    ; set sp to TCP sp
  700.     mov    sp,cx
  701.     mov    bp,sp            ; preset this as insurance
  702.     cbw                ; sign extend
  703.     cmp    al,-1            ; close all sessions and TCP/IP?
  704.     je    ktcpclo5        ; e = yes
  705.     push    ax            ; AL = session number
  706.     call    _session_close        ; close this session
  707.     add    sp,2            ; returns status in AL
  708.     jmp    short ktcpclo6        ; common completion code
  709.  
  710. ktcpclo5:                ; forceful shutdown of TCP/IP Telnet
  711.     xor    ax,ax
  712.     push    ax            ; tnexit(0) setup
  713.     call    _tnexit
  714.     add    sp,2            ; returns status in AX
  715. ktcpclo6:cbw                ; sign extend
  716.     mov    sp,kstack
  717.     mov    _tcpflag,0        ; no one is running the TCP code
  718.     pop    bp            ; restore regs, Kermit's main stack
  719.     pop    bx
  720.     pop    cx
  721.     pop    dx
  722.     pop    si
  723.     pop    di
  724.     pop    ds
  725.     pop    es
  726.     ret                ; return to caller
  727. ktcpclose endp
  728.  
  729. ; Change active sessions. Enter with AL holding desired session ident.
  730. ; Returns -1 if failure, else returns active session ident.
  731.     public    ktcpswap
  732. ktcpswap proc    far
  733.     assume    ds:dgroup, es:nothing
  734.     push    es            ; save regs on the user's stack
  735.     push    ds
  736.     push    di
  737.     push    si
  738.     push    dx
  739.     push    cx
  740.     push    bx
  741.     push    bp
  742.     mov    cx,dgroup        ; set addressibility to our dgroup
  743.     mov    ds,cx
  744.     mov    es,cx
  745.     cmp    word ptr tcpstack+2,0    ; have setup stack?
  746.     jne    ktcpswap1        ; ne = yes
  747.     mov    ax,-1            ; set failure status
  748.     jmp    short ktcpswap2        ; fail
  749. ktcpswap1:or    _tcpflag,1        ; say we are running TCP code
  750.     mov    kstack,sp        ; remember Kermit's main sp
  751.     mov    sp,word ptr tcpstack    ; move to our TCP stack
  752.     mov    bp,sp            ; preset this as insurance
  753.  
  754.     cbw                ; sign extend now
  755.     push    AX            ; new session number
  756.     call    _session_change
  757.     add    sp,2            ; pop argument, status is in AX
  758.     mov    _tcpflag,0        ; no one is running the TCP code
  759.     mov    sp,kstack
  760. ktcpswap2:pop    bp            ; restore regs, Kermit's main stack
  761.     pop    bx
  762.     pop    cx
  763.     pop    dx
  764.     pop    si
  765.     pop    di
  766.     pop    ds
  767.     pop    es
  768.     ret                ; return to caller
  769. ktcpswap endp
  770.  
  771. ; Copies TCP/IP info from Telnet space to main Kermit space via table of
  772. ; pointers tcpdata (in segment data, file mssset.asm).
  773. ; For use only by Telnet code as an internal procedure.
  774.     public    _readback
  775. _readback proc    near
  776.     assume    ds:dgroup, es:nothing
  777.     push    bp
  778.     mov    bp,sp
  779.     push    si
  780.     push    di
  781.     push    es
  782.     mov    si,offset dgroup:_kmyip
  783.     push    si
  784.     push    si                ; argument
  785.     call    _strlen                ; get length of string
  786.     add    sp,2                ; ax has string length
  787.     pop    si
  788.  
  789.     ASSUME    ES:DATA
  790.  
  791.     mov    di,DATA
  792.     mov    es,di
  793.     mov    di,offset tcpaddress        ; offset of the string
  794.     mov    cx,ax                ; length
  795.     cld
  796.     rep    movsb
  797.     xor    al,al
  798.     stosb                    ; terminator
  799.     mov    si,offset dgroup:_knetmask
  800.     mov    di,offset tcpsubnet
  801.     mov    cx,17
  802.     rep    movsb
  803.     stosb                    ; terminator
  804.     mov    si,offset dgroup:_kdomain
  805.     mov    di,offset tcpdomain
  806.     mov    cx,32
  807.     rep    movsb
  808.     stosb                    ; terminator
  809.     mov    si,offset dgroup:_kgateway
  810.     mov    di,offset tcpgateway
  811.     mov    cx,17
  812.     rep    movsb
  813.     stosb                    ; terminator
  814.     mov    si,offset dgroup:_kns1
  815.     mov    di,offset tcpprimens
  816.     mov    cx,17
  817.     rep    movsb
  818.     stosb                    ; terminator
  819.     mov    si,offset dgroup:_kns2
  820.     mov    di,offset tcpsecondns
  821.     mov    cx,17
  822.     rep    movsb
  823.     stosb                    ; terminator
  824.     mov    si,offset dgroup:_khost
  825.     mov    di,offset tcphost
  826.     mov    cx,60
  827.     rep    movsb
  828.     stosb                    ; terminator
  829.     mov    di,offset tcpbtpserver
  830.     mov    cx,16
  831.     mov    si,offset dgroup:_kbtpserver
  832.     rep    movsb
  833.     stosb                    ; terminator
  834.     mov    di,offset tcpbtpkind
  835.     mov    al,_bootmethod
  836.     stosb
  837.     pop    es
  838.     pop    di
  839.     pop    si
  840.     pop    bp
  841.     ret
  842. _readback endp
  843.  
  844. ; Track Telnet echo variable (0 do not do local echo) into terminal emulator
  845. ; and Kermit main body. Call this each time Telnet options change echo.
  846. ; For use only by Telnet code as an internal procedure.
  847.     public    _kecho
  848. _kecho    proc    near
  849.     assume    ds:data, es:dgroup
  850.     push    bp
  851.     mov    bp,sp
  852.     push    ds
  853.     push    es
  854.     push    si
  855.     push    ax
  856.     mov    ax,data            ; Kermit main data segment
  857.     mov    ds,ax
  858.     mov    ax,DGROUP
  859.     mov    es,ax
  860.     mov    ax,[bp+4+0]        ; get Telnet _echo variable
  861.     and    yflags,not lclecho    ; assume no local echo in emulator
  862.     or    al,al            ; Telnet local echo is off?
  863.     jz    kecho1            ; z = yes
  864.     mov    al,lclecho        ; lclecho flag for emulator
  865. kecho1:    or    yflags,al        ; set terminal emulator
  866.     mov    si,portval
  867.     mov    [si].ecoflg,al        ; set mainline SET echo flag
  868. ifndef    no_terminal
  869.     cmp    ttyact,0        ; acting as a Terminal?
  870.     je    kecho2            ; e = no
  871.     call    dword ptr ftogmod    ; toggle mode line
  872.     call    dword ptr ftogmod    ; and again
  873. endif    ; no_terminal
  874. kecho2:    pop    ax
  875.     pop    si
  876.     pop    es
  877.     pop    ds
  878.     pop    bp
  879.     ret
  880. _kecho    endp
  881.  
  882. ; Track Telnet dobinary variable into Kermit main body. 
  883. ; Call this each time Telnet options change dobinary.
  884. ; For use only by Telnet code as an internal procedure.
  885.     public    _kmode
  886. _kmode    proc    near
  887.     assume    ds:data, es:nothing
  888.     push    bp
  889.     mov    bp,sp
  890.     push    ds
  891.     push    ax
  892.     push    bx
  893.     mov    ax,data            ; Kermit main data segment
  894.     mov    ds,ax
  895.     mov    al,[bp+4+0]        ; get Telnet _dobinary variable
  896.     mov    tcpmode,al        ; update main body
  897.     pop    bx
  898.     pop    ax
  899.     pop    ds
  900.     pop    bp
  901.     ret
  902. _kmode    endp
  903.  
  904. ; Get current terminal emulation screen lines and columns
  905.     public    _get_kscreen
  906. _get_kscreen    proc    near
  907.     assume    ds:data, es:DGROUP
  908.     push    ds
  909.     push    es
  910.     mov    ax,seg data        ; address main body
  911.     mov    ds,ax
  912.     mov    ax,DGROUP
  913.     mov    es,ax
  914.     mov    al,ds:crt_lins        ; get display height
  915.     mov    es:_kterm_lines,al
  916.     mov    al,ds:crt_cols        ; get display width
  917.     mov    es:_kterm_cols,al
  918.     pop    es
  919.     pop    ds
  920.     ret
  921. _get_kscreen    endp
  922.  
  923. ; Report s->rto to tcp_rto variable for mainline Kermit
  924.     public    _krto
  925. _krto    proc    near
  926.     ASSUME    ES:DATA
  927.     push    bp
  928.     mov    bp,sp
  929.     push    es
  930.     mov    ax,seg DATA
  931.     mov    es,ax
  932.     mov    ax,[bp+4]        ; get s->rto
  933.     mov    es:tcp_rto,ax        ; report to mainline code
  934.     pop    es
  935.     pop    bp
  936.     ret
  937.     ASSUME    ES:NOTHING
  938. _krto    endp
  939. _TEXT    ends
  940.         end
  941.  
  942.