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