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