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