kolibrios-fun/programs/network/ppp/trunk/ppp.asm

;
;    PPP.ASM
;
;    Compile with FASM for Menuet
;    This program dials into an ISP and establishes a PPP connection
;
;    Version 11    26th January 2004
;
;    This code is a port of the PPP dialer program by Microchip, from
;    their application note AN724
;    It has been ported by Mike Hibbett mikeh@oceanfree.net for Menuet
;
;    26/1/04 - Mike Hibbett - added support for com port selected by
;                             stackcfg
;    2/5/03 - Shrirang - Added Abort Strings To sendwait to get out early
;                        if modem sends abort strings like NO CARRIER etc.
;
;    The original copyright statement follows
;//////////////////////////////////////////////////////////////////////////
;//
;//PING.C  version 1.10  July 29/99 (C)opyright by Microchip Technology Inc
;//
;//////////////////////////////////////////////////////////////////////////

FALSE               equ 0
TRUE                equ 1
DEBUG_OUTPUT        equ TRUE       ; If FALSE, not debugging info outputted
DEBUG_PPP_OUTPUT    equ TRUE        ; write PPP status msgs to debug board?
DEBUG_PORT2_OUTPUT  equ TRUE       ; write debug data also to com2


BAUD_9600       equ         12
BAUD_57600      equ         2
; The next line sets the baud rate of the connection to the modem
BAUDRATE        equ         BAUD_57600


LINE_END        equ         0x0D        ; End of input data character


; Defines for Internet constants
REQ         equ      1   ; Request options list for PPP negotiations
PPP_ACK     equ      2   ; Acknowledge options list for PPP negotiations
PPP_NAK     equ      3   ; Not acknowledged options list for PPP neg
REJ         equ      4   ; Reject options list for PPP negotiations
TERM            equ  5   ; Termination packet for LCP to close connectio
LCP_ECHO_REQ    equ  9
LCP_ECHO_REP    equ  10
IP        equ    0x0021   ; Internet Protocol packet
IPCP      equ    0x8021   ; Internet Protocol Configure Protocol packet
CCP       equ    0x80FD   ; Compression Configure Protocol packet
LCP       equ    0xC021   ; Link Configure Protocol packet
PAP       equ    0xC023   ; Password Authenication Protocol packet


MaxRx           equ         1500
MaxTx           equ         1500




use32
 org	0x0
 db	'MENUET01'    ; header
 dd	0x01	      ; header version
 dd	STARTAPP      ; entry point
 dd	I_END	      ; image size
 dd	I_END+0x10000 ; required memory
 dd	I_END+0x10000 ; esp
 dd	0x0 , 0x0     ; I_Param , I_Path


include "lang.inc"
include "..\..\..\macros.inc"
include "chat.inc"                  ; Hosts modem chatting routine


STARTAPP:
;    mov     eax, 0x3f8
;    mov     [comport], eax
;    mov     eax, 4
;    mov     [comirq], eax

    ; Get the com port & IRQ to use from the kernel stack config option

    mov   eax, 52                 ; Stack Interface
    mov   ebx, 0     ; read configuration word
    mcall
    mov  ecx, eax
    shr  ecx, 16     ; get the port address
    mov  [comport], ecx
    shr  eax, 8
    and  eax, 0x000000FF   ; get the irq
 mov  [comirq], eax


 mov  eax, [comport]
 add  eax, 0x01000000
 mov [irqtable], eax


    call    enable_port

appdsp:
    mov     eax, welcomep
    mov     [prompt], eax               ; set up prompt to display
    mov     al, [welcomep_len]
    mov     [prompt_len], al

red:
    call    draw_window                 ; at first, draw the window

apploop:
    mov     eax, 23                     ; wait here for event
    mov     ebx, 20
    mcall

    cmp     eax, 1                      ; redraw request ?
    je      red
    cmp     eax, 2                      ; key in buffer ?
    je      key
    cmp     eax, 3                      ; button in buffer ?
    je      button
    mov     ebx, [comirq]
    add     ebx, 16
    cmp     eax, ebx
    je      flush_input                 ; Dont want serial data yet
    jmp     apploop

key:                                    ; key - ignore
    mov     eax, 2                      ; just read it
    mcall
    jmp     apploop

button:                                 ; button
    mov     eax, 17                     ; get id
    mcall

    cmp     ah, 1                       ; close program ?
    jne     noclose

    mov     esi, hangupWait
    mov     edi, hangupSend
    mov     edx, 1000                   ; Allow sendwait 10s
    call    sendwait

    call    disable_port

    or      eax, -1                     ; close this program
    mcall
    jmp     apploop

noclose:
    cmp     ah, 2                       ; Dial Button pressed?
    jne     apploop

    mov     eax, conp
    mov     [prompt], eax               ; set up prompt to display
    mov     al,[conp_len]
    mov     [prompt_len], al
    call    draw_window

    jmp     dialloop                    ; connect to the host


    ; Data received, so get it, and throw it away at this point
flush_input:
    mov  eax,42
    mov  ebx, [comirq]
    mcall

    mov  eax,11                     ; This will return 0 most of the time
    mcall
    mov     ebx, [comirq]
    add     ebx, 16
    cmp     eax, ebx
   je   flush_input
    jmp  apploop


dialloop:
    call    modem_chat                  ; Try chatting with the modem

    cmp     eax, 1                      ; Did it work? ( = 1)
    jne     appdsp

    ; OK, we are now connected.

    mov     eax, pppOnp
    mov     [prompt], eax               ; set up prompt to display
    mov     al,[pppOnp_len]
    mov     [prompt_len], al
    call    draw_window

    mov     eax, 23
    mov     ebx, 100
    mcall                        ; wait for 1s to display message

    call    PPPStateMachine         ; This is the main code

    jmp     appdsp




;****************************************************************************
;    Function
;       PPPStateMachine
;
;   Description
;       Handles PPP link establishment
;
;****************************************************************************
PPPStateMachine:
    ; Start the timer
    xor     eax, eax
    call    settimer

PPPLoop:

    mov     eax, 11                 ; check event
    mcall
    cmp     eax, 3
    jne     PPPLred
        ; button pressed
    mov     eax, 17                     ; get id
    mcall


    mov     eax, hangp
    mov     [prompt], eax               ; set up prompt to display
    mov     al,[hangp_len]
    mov     [prompt_len], al
    call    draw_window

    mov     esi, hangupWait
    mov     edi, hangupSend
    mov     edx, 1000                   ; Allow sendwait 10s
    call    sendwait

    call    disable_port
    mov     eax, -1                     ; close this program
    mcall
    jmp     PPPLoop

PPPLred:
    cmp     eax, 1                      ; redraw request ?
    jne     PPPLoop0

    call    draw_window
    jmp     PPPLoop

PPPLoop0:
    mov     ebx, [comirq]
    add     ebx, 16
    cmp     eax, ebx
    jne     ppp_002                    ; check for tx to send


    ; we have data in the rx buffer, get it

    mov     eax, 42
    mov     ebx, [comirq]      ; ecx will return 0 =data read, 1 =no data
    mcall               ; or 2 =not irq owner

    inc     dword [rxbytes]

    cmp     bl, 0x7E
    jne     ppp_001a

    mov     eax, [rx_ptr]
    cmp     eax, 0
    jz      ppp_001
    mov     eax, [checksum1]
    cmp     eax, 0xf0b8
    jne     ppp_001


    movzx   eax, byte [rx_str + 3]
    mov     ah, [rx_str + 2]
    mov     [packet], eax

ppp_001:
    mov     eax, [extended]
    and     eax, 0x7e
    mov     [extended], eax
    xor     eax, eax
    mov     [rx_ptr], eax

    mov     eax, 0xffff
    mov     [checksum1], eax
    jmp     ppp_003

ppp_001a:
    cmp     bl, 0x7D
    jne     ppp_001b

    mov     eax, [extended]
    or      eax, 0x01
    mov     [extended], eax
    jmp     ppp_003

ppp_001b:
    mov     eax, [extended]
    test    eax, 0x01
    jz      ppp_001c

    xor     bl, 0x20
    and     eax, 0xFE
    mov     [extended], eax

ppp_001c:
    mov     edx, [rx_ptr]
    cmp     edx, 0
    jnz     ppp_001d
    cmp     bl, 0xff
    je      ppp_001d

    mov     [rx_str + edx], byte 0xff
    inc     edx

ppp_001d:
    cmp     edx, 1
    jnz     ppp_001e
    cmp     bl, 0x03
    je      ppp_001e

    mov     [rx_str + edx], byte 0x03
    inc     edx

ppp_001e:
    cmp     edx, 2
    jnz     ppp_001f
    test    bl, 0x01
    jz      ppp_001f

    mov     [rx_str + edx], byte 0
    inc     edx

ppp_001f:
    mov     [rx_str + edx], bl
    inc     edx
    mov     [rx_ptr], edx

    cmp     edx, MaxRx
    jle     ppp_001g
    mov     edx, MaxRx
    mov     [rx_ptr], edx

ppp_001g:
    ; do checksum calc
    mov     eax, [checksum1]
    xor     bh, bh
    xor     ax, bx
    call    calc
    mov     ebx, [checksum1]
    and     ebx, 0xffff
    shr     ebx, 8
    xor     eax, ebx
    mov     [checksum1], eax
    jmp     ppp_003

ppp_002:
    mov     eax, [tx_end]
    cmp     eax, 0
    jz      ppp_003

    mov     ebx, [tx_ptr]
    mov     cl, [tx_str + ebx]

    cmp     ebx, eax
    jne     ppp_002a
    mov     [tx_end], dword 0
    mov     cl, '~'
    jmp     ppp_002d

ppp_002a:
    mov     eax, [extended]
    and     eax, 0x02
    jz      ppp_002b

    xor     cl, 0x20
    mov     eax, [extended]
    and     eax, 0xFD
    mov     [extended], eax
    inc     [tx_ptr]
    jmp     ppp_002d

ppp_002b:
    cmp     cl, 0x20
    jl      ppp_002b1
    cmp     cl, 0x7d
    je      ppp_002b1
    cmp     cl, 0x7e
    je      ppp_002b1
    jmp     ppp_002c

ppp_002b1:
    mov     eax, [extended]
    or      eax, 0x02
    mov     [extended], eax
    mov     cl, 0x7d
    jmp     ppp_002d

ppp_002c:
    mov     eax, [tx_ptr]
    cmp     eax, 0
    jnz     ppp_002c1
    mov     cl, '~'

ppp_002c1:
    inc     [tx_ptr]

ppp_002d:
    ; Test for tx ready.

    push    ecx

wait_txd2:
    mov     eax,43
    mov     ecx, [comport]
    add     ecx, 0x80000000 + 5
    mcall
    and     bl, 0x40
    cmp     bl, 0
    jz      wait_txd2                  ; loop until free

    pop     ebx


    ; send the character

    inc     dword [txbytes]

    mov     ecx, [comport]
    mov     eax, 43
    mcall

ppp_003:
    mov     eax, [packet]
    cmp     eax, LCP
    jne     ppp_004

    mov     al, [rx_str + 4]
    cmp     al, REQ
    jne     ppp_003b

    ; Debugging output to debug board
    pusha
    mov     esi, RX_LCP_REQ
    call    debug_output
    popa

    mov     eax, [state]
    and     eax, 0xfd
    mov     [state], eax

    mov     ebx, 0xc6
    push    eax
    call    TestOptions
    pop     eax
    cmp     edx, 0
    jz      ppp_003g

    cmp     edx, 1
    jle     ppp_003h

    mov     edx, PPP_ACK
    cmp     eax, 3
    jge     ppp_003i

    or      eax, 0x02
    mov     [state], eax
    jmp     ppp_003i

ppp_003h:
    mov     bl, 0xc0
    mov     [rx_str + 10], bl
    mov     edx, PPP_NAK
    jmp     ppp_003i

ppp_003g:
    mov     edx, REJ

ppp_003i:

    mov     ebx, LCP
    mov     ecx, edx
    movzx   edx, byte [rx_str + 5]
    mov     esi, rx_str + 7
    call    MakePacket

    mov     eax, 0
    call    settimer
    jmp     ppp_003a

ppp_003b:
    cmp     al, PPP_ACK
    jne     ppp_003c

    ; Debugging output to debug board
    pusha
    mov     esi, RX_LCP_ACK
    call    debug_output
    popa

    mov     eax, [number]
    cmp     al, [rx_str+5]
    jne     ppp_003a

    mov     eax, [state]
    cmp     eax, 3
    jge     ppp_003a
    or      eax, 0x01
    mov     [state], eax
    jmp     ppp_003a

ppp_003c:
    cmp     al, PPP_NAK
    jne     ppp_003d

    ; Debugging output to debug board
    pusha
    mov     esi, RX_LCP_NAK
    call    debug_output
    popa

    mov     eax, [state]
    and     eax, 0xfe
    mov     [state], eax
    jmp     ppp_003a

ppp_003d:
    cmp     al, REJ
    jne     ppp_003e

    ; Debugging output to debug board
    pusha
    mov     esi, RX_LCP_REJ
    call    debug_output
    popa

    mov     eax, [state]
    and     eax, 0xfe
    mov     [state], eax
    jmp     ppp_003a

ppp_003e:
    cmp     al, TERM
    jne     ppp_003j
    jmp     ppp_003a

ppp_003j:
    cmp     al, LCP_ECHO_REQ
    jne     ppp_003a

    ; Debugging output to debug board
    pusha
    mov     esi, RX_LCP_ECHO_REQ
    call    debug_output
    popa

    mov     al, 0
    mov     [rx_str+8],al
    mov     [rx_str+9],al
    mov     [rx_str+10],al
    mov     [rx_str+11],al

    mov     ebx, LCP
    mov     ecx, LCP_ECHO_REP
    movzx   edx, byte [rx_str + 5]
    mov     esi, rx_str + 7
    call    MakePacket

ppp_003a:
    mov     eax, [state]
    cmp     eax, 3
    jne     ppp_013

    mov     eax, 4
    mov     [state], eax

    jmp     ppp_013


ppp_004:
    cmp     eax, PAP
    jne     ppp_005

    mov     al, [rx_str + 4]
    cmp     al, PPP_ACK
    jne     ppp_013

    ; Debugging output to debug board
    pusha
    mov     esi, RX_PAP_ACK
    call    debug_output
    popa

    mov     eax, 5
    mov     [state],eax
    jmp     ppp_013

ppp_005:
    cmp     eax, IPCP
    jne     ppp_006

    mov     al, [rx_str + 4]
    cmp     al, REQ
    jne     ppp_005a

    ; Debugging output to debug board
    pusha
    mov     esi, RX_IPCP_REQ
    call    debug_output
    popa

    mov     ebx, 0x04
    call    TestOptions
    cmp     edx, 0
    jz      ppp_005b
    mov     ecx, PPP_ACK
    mov     eax, 6
    mov     [state], eax
    jmp     ppp_005c
ppp_005b:
    mov     ecx, REJ

ppp_005c:
    mov     ebx, IPCP
    movzx   edx, byte [rx_str + 5]
    mov     esi, rx_str + 7
    call    MakePacket
    jmp     ppp_013

ppp_005a:
    cmp     al, PPP_ACK
    jne     ppp_005d

    ; Debugging output to debug board
    pusha
    mov     esi, RX_IPCP_ACK
    call    debug_output
    popa

    mov     al, [rx_str + 5]
    mov     ecx, [number]
    cmp     al, cl
    jne     ppp_013

    mov     eax, 7
    mov     [state], eax
    mov     eax, 5800
    call    settimer

    mov     eax, IPOnp
    mov     [prompt], eax               ; set up prompt to display
    mov     al,[IPOnp_len]
    mov     [prompt_len], al
    call    draw_window

    jmp     ppp_013

ppp_005d:
    cmp     al, PPP_NAK
    jne     ppp_005e

    ; Debugging output to debug board
    pusha
    mov     esi, RX_IPCP_NAK
    call    debug_output
    popa

    mov     al, [rx_str + 10]
    mov     [addr1], al
    mov     al, [rx_str + 11]
    mov     [addr2], al
    mov     al, [rx_str + 12]
    mov     [addr3], al
    mov     al, [rx_str + 13]
    mov     [addr4], al

    pusha
    call    draw_window

    mov     eax,52
    mov     ebx,3
    mov     cl, [addr4]
    shl     ecx, 8
    mov     cl, [addr3]
    shl     ecx, 8
    mov     cl, [addr2]
    shl     ecx, 8
    mov     cl, [addr1]
    mcall                       ; Set the stacks IP address

    popa

    mov     ebx, IPCP  ;; added 28/4/03
    mov     ecx, REQ
    movzx   edx, byte [rx_str + 5]
    mov     esi, rx_str + 7
    call    MakePacket
    jmp     ppp_013

ppp_005e:
    cmp     al, REJ
    jne     ppp_005f
    jmp     ppp_013

ppp_005f:
    cmp     al, TERM
    jne     ppp_013
    jmp     ppp_013

ppp_006:
    cmp     eax, IP
    jne     ppp_007


;;
;;
;;
;; This is where we will pass the IP packet up to the stack
;;
;;
;;
    mov     eax, 52
    mov     ebx, 6
    mov     edx, 1500   ; this should be exact amount
    mov     esi, rx_str + 4
    mcall

    ; Debugging output to debug board
    pusha
    mov     esi, RX_IP
    call    debug_output
    popa

    jmp     ppp_013

ppp_007:
    cmp     eax, CCP
    jne     ppp_008

    mov     al, [rx_str + 4]
    cmp     al, REQ
    jne     ppp_013

    ; Debugging output to debug board
    pusha
    mov     esi, RX_CCP_REQ
    call    debug_output
    popa

    mov     ebx, 0x04
    call    TestOptions
    cmp     edx, 0
    jz      ppp_007b
    mov     ecx, PPP_ACK
    jmp     ppp_007c
ppp_007b:
    mov     ecx, REJ

ppp_007c:
    mov     ebx, CCP
    movzx   edx, byte [rx_str + 5]
    mov     esi, rx_str + 7
    call    MakePacket

    jmp     ppp_013

ppp_008:
    cmp     eax, 0
    jz      ppp_009

    jmp     ppp_013

ppp_009:
    mov     eax, [tx_end]
    cmp     eax, 0
    jnz     ppp_010
    call    gettimer
    cmp     eax, 100
    jle     ppp_010

    mov     eax, [state]
    cmp     eax, 0
    je      ppp_009a
    cmp     eax, 2
    jne     ppp_010

ppp_009a:

    ; Debugging output to debug board
    pusha
    mov     esi, TX_LCP_REQ
    call    debug_output
    popa

    inc     [number]
    mov     eax, 0
    call    settimer

    mov     ebx, LCP
    mov     ecx, REQ
    mov     edx, [number]
    mov     esi, LCPREQStr
    call    MakePacket

    jmp     ppp_013

ppp_010:
    mov     eax, [tx_end]
    cmp     eax, 0
    jnz     ppp_011
    call    gettimer
    cmp     eax, 100
    jle     ppp_011
    mov     eax, [state]
    cmp     eax, 4
    jne     ppp_011
    mov     eax, 0
    call    settimer
    inc     [number]

    ; Debugging output to debug board
    pusha
    mov     esi, TX_PAP_REQ
    call    debug_output
    popa

    mov     ebx, PAP
    mov     ecx, REQ
    mov     edx, [number]
    mov     esi, PAPREQStr
    call    MakePacket

    jmp     ppp_013

ppp_011:
    mov     eax, [tx_end]
    cmp     eax, 0
    jnz     ppp_012
    call    gettimer
    cmp     eax, 100
    jle     ppp_012
    mov     eax, [state]
    cmp     eax, 6
    jne     ppp_012
    inc     [number]
    mov     eax, 0
    call    settimer

    ; Debugging output to debug board
    pusha
    mov     esi, TX_IPCP_REQ
    call    debug_output
    popa

    mov     ebx, IPCP
    mov     ecx, REQ
    mov     edx, [number]
    mov     esi, IPCPREQStr
    call    MakePacket

    jmp     ppp_013

ppp_012:
    mov     eax, [tx_end]
    cmp     eax, 0
    jnz     ppp_013
    mov     eax, [state]
    cmp     eax, 7
    jne     ppp_013

    ; 10ms Delay suggested by Ville
    mov     eax,23     ; over here
    mov     ebx,1
    mcall



    call    gettimer
    cmp     eax, 200
    jle     ppp_012a

 ; every 2s, when things are quiet, redraw window
    call    draw_window_limited

    mov     eax, 0
    call    settimer

ppp_012a:

    mov     eax, 52
    mov     ebx, 8
    mov     esi, ip_buff
    mcall

    cmp     eax, 0
    je      ppp_013

    call    MakeIPPacket

    ; Debugging output to debug board
    pusha
    mov     esi, TX_IP
    call    debug_output
    popa

ppp_013:
    mov     eax, [packet]
    cmp     eax, 0
    jz      PPPLoop

    mov     eax, 0
    mov     [packet], eax

    mov     edi, rx_str
    mov     ecx, MaxRx + 1
    rep     stosb
    jmp     PPPLoop



;****************************************************************************
;    Function
;       calc
;
;   Description
;       Adds a character to the CRC checksum
;       byte in lsb of eax
;
;
;****************************************************************************
calc:
    and     eax, 0xFF
    push    ecx
    mov     ecx, 8
calc_001:
    test    al, 0x01
    jz      calc_002
    shr     eax, 1
    xor     eax, 0x8408
    and     eax, 0xffff
    jmp     calc_003
calc_002:
    shr     eax, 1
calc_003:
    loop    calc_001
    pop     ecx
    ret


;****************************************************************************
;    Function
;       add2tx
;
;   Description
;       Adds a character into the tx buffer
;       byte in low byte of eax
;
;
;****************************************************************************
add2tx:
    pusha
    mov     esi, tx_str
    add     esi, [tx_ptr]
    inc     [tx_ptr]
    mov     [esi], al               ; Save byte in buffer
    mov     ecx, [checksum2]
    and     eax, 0xff
    xor     eax, ecx
    call    calc
    shr     ecx, 8
    and     ecx, 0xff
    xor     eax, ecx
    mov     [checksum2], eax
    popa
    ret



;****************************************************************************
;    Function
;       MakeIPPacket
;
;   Description
;       Creates a PPP packet for transmission to the host from the
;       IP packet extracted from the stack
;
;       IP data is in ip_buff
;
;****************************************************************************
MakeIPPacket:
    mov     [tx_ptr], dword 1
    mov     edi, tx_str
    mov     [edi], byte ' '
    mov     eax, 0xffff
    mov     [checksum2], eax
    mov     al, 0xff
    call    add2tx
    mov     al, 3
    call    add2tx
    mov     al, IP / 256
    call    add2tx
    mov     al, IP
    call    add2tx

    movzx   ecx, byte [ip_buff + 3]
    mov     ch, byte [ip_buff + 2]

    mov     esi, ip_buff

mip001:
    mov     al, byte [esi]
    call    add2tx
    inc     esi
    loop    mip001

    mov     eax, [checksum2]
    not     eax
    call    add2tx
    shr     eax, 8
    call    add2tx

    mov     eax, [tx_ptr]
    mov     [tx_end], eax
    xor     eax, eax
    mov     [tx_ptr], eax
    ret


;****************************************************************************
;    Function
;       MakePacket
;
;   Description
;       Creates a PPP packet for transmission to the host
;
;       Packet type in ebx
;       Code is in ecx
;       num is in edx
;       str is pointed to by esi
;
;****************************************************************************
MakePacket:
    mov     [tx_ptr], dword 1
    mov     edi, tx_str
    mov     [edi], byte ' '
    mov     eax, 0xffff
    mov     [checksum2], eax
    mov     al, 0xff
    call    add2tx
    mov     al, 3
    call    add2tx
    mov     al, bh                  ; packet/256
    call    add2tx
    mov     al, bl                  ; packet&255
    call    add2tx

    cmp     ebx, IP                 ; is packet type IP?
    jne     mp_001                  ; No - its a lower layer packet

    ; Do IP packet assembly

    jmp     mp_002

mp_001:
    ; Do PPP layer packet assembly
    mov     al, cl
    call    add2tx
    mov     al, dl
    call    add2tx
    mov     al, 0
    call    add2tx

    movzx   ecx, byte [esi]         ; length = *str - 3
    sub     ecx, 3

mp_002:                             ; Now copy the data acros
    mov     al, byte [esi]
    call    add2tx
    inc     esi
    loop    mp_002

    mov     eax, [checksum2]
    not     eax
    call    add2tx
    shr     eax, 8
    call    add2tx

    mov     eax, [tx_ptr]
    mov     [tx_end], eax
    xor     eax, eax
    mov     [tx_ptr], eax
    ret


;****************************************************************************
;    Function
;       TestOptions
;
;   Description
;       Test a PPP packets options fields for valid entries
;
;       option ebx
;
;       Returns result in edx, but may also modify rx_str
;
;****************************************************************************
TestOptions:
    mov     esi, 8                  ; ptr1
    mov     edi, 8                  ; ptr2
    mov     edx, 3                  ; edx is the return value
    movzx   ecx, byte [rx_str + 7]
    add     ecx, 4                  ; ecx is size
    cmp     ecx, MaxRx
    jle     to_001
    mov     ecx, MaxRx
to_001:
    cmp     esi, ecx
    jge      to_002
    mov     al, byte [esi + rx_str]
    cmp     al, 3
    jne     to_001a
    mov     al, byte [esi + rx_str + 2]
    cmp     al, 0x80
    je      to_001a
    ; bug fix for chap authenticate reject below
    mov     al, byte [esi + rx_str + 2]
    cmp     al, 0xc2
    jne     to_001a
    and     edx, 0xfd
to_001a:
    push    ecx
    mov     cl, [esi + rx_str]
    dec     cl
    mov     eax, 1
    shl     eax, cl
    and     eax, ebx
    and     eax, 0xffff
    pop     ecx
    cmp     eax, 0
    jnz     to_001b
    xor     edx,edx
to_001b:
    movzx   eax, byte [esi+rx_str+1]
    add     esi, eax
    jmp     to_001
to_002:
    ; if (!(pass&2))...
    test    edx, 2
    jnz     to_exit
    test    edx, 1
    jz      to_002a
    mov     ebx, 0xFFFB
to_002a:
    mov     esi, 8
to_002b:                            ; for loop
    cmp     esi, ecx
    jge      to_003

    push    ecx
    mov     cl, [esi + rx_str]
    dec     cl
    mov     eax, 1
    shl     eax, cl
    and     eax, ebx
    and     eax, 0xffff
    pop     ecx
    cmp     eax, 0
    jnz     to_002c
    movzx   edx, byte [esi+rx_str+1]
to_002d:
    cmp     esi, ecx
    jge      to_002b
    cmp     edx, 0
    jz      to_002b
    mov     al, [esi + rx_str]
    mov     [edi + rx_str], al
    inc     esi
    inc     edi
    dec     edx
    jmp     to_002d
to_002c:
    movzx   eax, byte [esi+rx_str+1]
    add     esi, eax
    jmp     to_002b                 ; end of for loop
to_003:
    mov     eax, edi
    sub     al, 4
    mov     [rx_str+7], al
    xor     edx, edx
    cmp     ebx, 0xfffb
    jne     to_exit
    inc     edx
to_exit:
    ; Return value in EDX
    ret



;***************************************************************************
;    Function
;        disable_port
;
;   Description;
;       Releases this applications use of the com port
;
;***************************************************************************
disable_port:
if DEBUG_PORT2_OUTPUT = TRUE
    mov      eax, 46                 ; free port area
    mov      ebx, 1

    mov      ecx, 0x2f8
    and      ecx, 0xFF0
    mov      edx, ecx
    or       edx, 0x00F
    mcall
end if

    mov      eax, 45                 ; free irq 4
    mov      ebx, 1
    mov      ecx, [comirq]
    mcall

    mov      eax, 46                 ; free port area
    mov      ebx, 1

    mov      ecx, [comport]
    and      ecx, 0xFF0
    mov      edx, ecx
    or       edx, 0x00F
    mcall
    ret



;***************************************************************************
;    Function
;        enable_port
;
;   Description;
;    Takes control of the com port, defining the IRQ table and initialising
;     the uart chip.
;
;***************************************************************************
enable_port:
    pusha
if DEBUG_PORT2_OUTPUT = TRUE
    mov      eax, 46
    mov      ebx, 0
    mov      ecx, 0x2f8
    and      ecx, 0xFF0
    mov      edx, ecx
    or       edx, 0x00F
    mcall                     ; reseve port memory to this process

    mov      eax, 45                  ; reserve irq 3
    mov      ebx, 0
    mov      ecx, 3
    mcall


    mov      ecx, 0x2f8             ; data format register
    add      ecx, 3
    mov      bl, 0x80               ; enable access to divisor latch
    mov      eax, 43                ; send data to device - com port setup
    mcall

    mov      ecx, 0x2f8          ; interrupt enable register
    inc      ecx
    mov      bl, 0                    ; No interruts enabled
    mov      eax, 43                  ; send data to device (modem)
    mcall

    mov      ecx, 0x2f8                 ; Divisor latch LSB
    mov      bl, BAUDRATE             ; set baud rate
    mov      eax, 43                  ; send data to device (modem)
    mcall

    mov      ecx, 0x2f8             ; Data format register
    add      ecx, 3
    mov      bl, 3                    ; 8 data bits
    mov      eax, 43                  ; send data to device (modem)
    mcall

    mov      ecx, 0x2f8        ; Modem control register
    add      ecx, 4                ; ** bl must be 0x0b for modem to dial!
    mov      bl, 0x0b              ; 0x08 -> out2 enabled. No handshaking.
       ; 0xb ->  out2 enabled, RTS/DTR enabled
    mov      eax, 43               ; send data to device (modem)
    mcall

;    mov      ecx, 0x2f8        ; interrupt enable register
;    inc      ecx
;    mov      bl, 1                 ; rx data interrupt enabled, othrs not
;    mov      eax, 43               ; send data to device (modem)
;    mcall

end if

    mov      eax, 46
    mov      ebx, 0
    mov      ecx, [comport]
    and      ecx, 0xFF0
    mov      edx, ecx
    or       edx, 0x00F
    mcall                     ; reseve port memory to this process

    mov      eax, 45                  ; reserve irq 4
    mov      ebx, 0
    mov      ecx, [comirq]
    mcall

    mov      eax, 44                  ; setup irq table
    mov      ebx, irqtable
    mov      ecx, [comirq]
    mcall

    mov      ecx, [comport]             ; data format register
    add      ecx, 3
    mov      bl, 0x80               ; enable access to divisor latch
    mov      eax, 43                ; send data to device - com port setup
    mcall

    mov      ecx, [comport]          ; interrupt enable register
    inc      ecx
    mov      bl, 0                    ; No interruts enabled
    mov      eax, 43                  ; send data to device (modem)
    mcall

    mov      ecx, [comport]                 ; Divisor latch LSB
    mov      bl, BAUDRATE             ; set baud rate
    mov      eax, 43                  ; send data to device (modem)
    mcall

    mov      ecx, [comport]             ; Data format register
    add      ecx, 3
    mov      bl, 3                    ; 8 data bits
    mov      eax, 43                  ; send data to device (modem)
    mcall

    mov      ecx, [comport]        ; Modem control register
    add      ecx, 4                ; ** bl must be 0x0b for modem to dial!
    mov      bl, 0x0b              ; 0x08 -> out2 enabled. No handshaking.
       ; 0xb ->  out2 enabled, RTS/DTR enabled
    mov      eax, 43               ; send data to device (modem)
    mcall

    mov      ecx, [comport]        ; interrupt enable register
    inc      ecx
    mov      bl, 1                 ; rx data interrupt enabled, othrs not
    mov      eax, 43               ; send data to device (modem)
    mcall

    mov      ecx, [comirq]
    add      ecx, 16
    mov      ebx, 1
    shl      ebx, cl
    add      ebx, 111b
    mov      eax,40                  ; enable irq 4 data
    mcall

    popa
    ret



;**************************************************************************
;    Function
;        draw_window
;
;   Description;
;       Normal window definition and text layout for application
;**************************************************************************
draw_window:
    mov      eax, 12                 ; function 12:tell os about windowdraw
    mov      ebx, 1                  ; 1, start of draw
    mcall
         ; DRAW WINDOW
    mov      eax, 0                  ; function 0 : define and draw window
    mov      ebx, 100*65536+250      ; [x start] *65536 + [x size]
    mov      ecx, 100*65536+150      ; [y start] *65536 + [y size]
    mov      edx,0x14224466          ; color of work area RRGGBB
    mov      edi,title               ; color of frames    RRGGBB
    mcall

       ; DIAL BUTTON
    mov      eax, 8                  ; function 8 : define and draw button
    mov      ebx, (50)*65536+40      ; [x start] *65536 + [x size]
    mov      ecx, 130*65536+12       ; [y start] *65536 + [y size]
    mov      edx, 2                  ; button id
    mov      esi, 0x5599cc           ; button color RRGGBB
    mcall

    mov      ebx, 55*65536+133       ; Draw button text
    mov      ecx, 0x00FFFFFF
    mov      edx, button1_text
    xor      eax, eax
    mov      al,  [button1_text_len]
    mov      esi, eax
    mov      eax, 4
    mcall
      ; DISCONNECT BUTTON
    mov      eax, 8                  ; function 8 : define and draw button
    mov      ebx, (150)*65536+65     ; [x start] *65536 + [x size]
    mov      ecx, 130*65536+12       ; [y start] *65536 + [y size]
    mov      edx, 3                  ; button id
    mov      esi, 0x5599cc           ; button color RRGGBB
    mcall

    mov      ebx, 155*65536+133      ; Draw button text
    mov      ecx, 0x00FFFFFF
    mov      edx, button3_text
    xor      eax, eax
    mov      al,  [button3_text_len]
    mov      esi, eax
    mov      eax, 4
    mcall

    mov      ebx, 5*65536+40         ; draw info text with function 4
    mov      ecx, 0x00FFFFFF
    mov      edx, [prompt]
    xor      eax, eax
    mov      al,  [prompt_len]
    mov      esi, eax
    mov      eax, 4
    mcall

    ; Draw IP address
    mov      edx, 10*65536+60
    mov      esi, 0x00FFFFFF
    mov      ebx, 0x00030000
    movzx    ecx, byte [addr1]
    mov      eax, 47
    mcall
    mov      edx, 31*65536+60
    mov      esi, 0x00FFFFFF
    mov      ebx, 0x00030000
    movzx    ecx, byte [addr2]
    mov      eax, 47
    mcall
    mov      edx, 52*65536+60
    mov      esi, 0x00FFFFFF
    mov      ebx, 0x00030000
    movzx    ecx, byte [addr3]
    mov      eax, 47
    mcall
    mov      edx, 73*65536+60
    mov      esi, 0x00FFFFFF
    mov      ebx, 0x00030000
    movzx    ecx, byte [addr4]
    mov      eax, 47
    mcall

    ; Status byte
    mov      edx, 100*65536+60
    mov      esi, 0x00FFFFFF
    mov      ebx, 0x00010000
    movzx    ecx, byte [state]
    mov      eax, 47
    mcall

    ; bytes sent / received
    mov      eax, 4                  ; function 4 : write text to window
    mov      ebx, 10*65536+80          ; [x start] *65536 + [y start]
    mov      ecx, 0x00ffffff         ; color of text RRGGBB
    mov      edx, txmsg              ; pointer to text beginning
    mov      esi, txmsglen-txmsg    ; text length
    mcall

    mov      eax, 4                  ; function 4 : write text to window
    mov      ebx, 10*65536+100          ; [x start] *65536 + [y start]
    mov      ecx, 0x00ffffff         ; color of text RRGGBB
    mov      edx, rxmsg              ; pointer to text beginning
    mov      esi, rxmsglen-rxmsg    ; text length
    mcall

    call    draw_window_limited

    mov      eax, 12                 ; end of redraw
    mov      ebx, 2
    mcall

    ret



draw_window_limited:
    mov     eax,13
    mov     ebx,80*65536+10*6
    mov     ecx,80*65536+10
    mov     edx,0x03224466
    mcall
    mov     ecx,100*65536+10
    mcall

    mov     ebx, 0x000A0000
    mov     ecx, [txbytes]
    mov     esi, 0x00ffffff         ; color of text RRGGBB
    mov     eax, 47                  ; function 47 : write number to window
    mov     edx, 80*65536+80          ; [x start] *65536 + [y start]
    mcall

    mov     ebx, 0x000A0000
    mov     ecx, [rxbytes]
    mov     esi, 0x00ffffff         ; color of text RRGGBB
    mov     eax, 47                  ; function 47 : write number to window
    mov     edx, 80*65536+100          ; [x start] *65536 + [y start]
    mcall
    ret


;****************************************************************************
;    Function
;       settimer
;
;   Description
;       sets the general purpose timer to a given value in eax
;       All times are in 1/100s
;
;
;****************************************************************************
settimer:
    push    eax
    mov     eax, 26
    mov     ebx, 9
    mcall        ; get 100th second counter
    pop     ebx
    sub     eax, ebx    ; This could have some funny side effecs if PPP
   ; called within ebx seconds of startup
    mov     [timerValue], eax
    ret


;****************************************************************************
;    Function
;       gettimer
;
;   Description
;       gets the general purpose timer count in eax
;       All times are in 1/100s
;
;
;****************************************************************************
gettimer:
    mov     eax, 26
    mov     ebx, 9
    mcall        ; get 100th second counter

    sub     eax, [timerValue]
    ret




;****************************************************************************
;    Function
;       sendwait
;
;   Description
;       Sends a command string to the modem, then waits for a defined rsp
;
;       esi points to string to wait for
;       edi points to string to send
;       edx holds wait time, in ms
;
;       Returns 1 if OK or 0 if timeout occurred
;
;****************************************************************************
sendwait:
    mov     [sendwaitTime], edx

    ; Shrirang 2/5/03
    mov     byte [abortcnt], 0      ; reset the abort counter
    ;--!

    ; Start the timer
    xor     eax, eax
    call    settimer

    ; Check for incoming data

    xor     edx, edx
    xor     eax, eax

sw_001:
    push    eax
    push    edx

    ; Has connection timer expired?
    call    gettimer
    cmp     eax, [sendwaitTime]
    jl      sw_000

    pop     edx
    pop     eax

    xor     eax, eax

    jmp     sw_exit                 ; Exit indicating an error ( timeout )

sw_000:
    ; any data from modem?

    mov     eax,11                     ; This will return 0 most of the time
    mcall
    mov     ecx, eax
    pop     edx
    pop     eax


    cmp     ecx, 1                      ; redraw request ?
    je      red1
    cmp     ecx, 3                      ; button in buffer ?
    je      button1
    mov     ebx, [comirq]
    add     ebx, 16
    cmp     ecx,ebx
    jne     sw_002
    jmp     sw_000a

red1:
    pusha
    call    draw_window
    popa
    push    eax
    push    edx

    jmp     sw_000

button1:
    mov     eax, 0
    jmp     sw_exit

sw_000a:
    ; there was data, so get it

    push    edx
    push    eax
    mov     eax,42
    mov     ebx, [comirq]
    mcall
    pop     eax
    pop     edx


    ; Shrirang 2/5/03
    ; Now that the expected response is not got we check if we
    ; got the abort part, before we reset the fsm

    cmp     bl, 0x0d     ; AT commands normally start and end with \r\n
    je      checkabort

    cmp     bl, 0x0a
    je      checkabort

    push    eax
    xor     eax, eax
    mov     al, [abortcnt]
    mov     byte [abortres+eax], bl         ; update abort response
    inc     byte [abortcnt]
    pop     eax

    jmp     noabort


checkabort :

    cmp     byte [abortcnt], 2  ; if we got valid abort this cannot happen!
    jbe     noabortflush

    push    eax
    push    esi
    push    edi
    push    ecx

    mov     esi, abortres
    mov     edi, aborts
    xor     ecx, ecx
    mov     cl, byte [abortcnt]
    call    scanaborts                       ; scan 'em

    pop     ecx
    pop     edi
    pop     esi

    and     eax, eax
    jz      noabortdec

    pop     eax
    xor     eax, eax
    jmp     sw_exit

noabortdec:

    pop     eax

noabortflush:

    mov byte [abortcnt], 0

noabort:

;--!

    cmp     [esi+edx], bl
    je      sw_003


    xor     edx, edx

    ; Added 28/4/03
    cmp     [esi+edx], bl
    je      sw_003

    jmp     sw_001

sw_003:                             ; They are the same
    inc     edx
    cmp     [esi+edx], byte 0
    jne     sw_001


    xor     eax, eax
    inc     eax
    jmp     sw_exit

sw_002:
    ; Test for data to send to modem
    cmp     [ edi + eax ], byte 0
    je      sw_001

    ; Is it a '|' character?
    cmp     [ edi + eax ], byte '|'
    jne     sw_004

    push    eax
    call    gettimer
    cmp     eax, 100
    pop     eax
    jl      sw_001

    ; restart the timer
    push    eax
    xor     eax, eax
    call    settimer
    pop     eax

    ; Move to next character
    inc     eax
    jmp     sw_001


sw_004:
    push    edx
    push    eax

    ; restart the timer
    xor     eax, eax
    call    settimer

    ; Test for tx ready.
    ; OR, wait then send
    push    edi
    mov     eax, 5
    mov     ebx, 1
    mcall        ; 10ms delay
    pop     edi

    ; send the character
    pop     eax
    mov     bl, [edi + eax]

    mov     ecx, [comport]
    inc     eax
    push    eax
    mov     eax, 43
    mcall

    pop     eax
    pop     edx

    cmp     [ edi + eax ], byte 0
    jne     sw_001

    cmp     [ esi + edx ], byte 0
    jne     sw_001

    xor     eax, eax
    inc     eax

sw_exit:
    ; return success (1) or failure (0) in eax
    ret




if DEBUG_OUTPUT = TRUE

;****************************************************************************
;    Function
;       debug_output
;
;   Description
;       prints a description of the PPP protocol's data exchanges to the
;       debug board
;
;       esi holds ptr to msg to display
;
;       Nothing preserved; I'm assuming a pusha/popa is done before calling
;
;****************************************************************************
debug_output:
    cmp     esi, RX_IP
    jne     do_001

    call    debug_print_string

    call    debug_print_rx_ip

    mov     esi, IP_DATA1
    call    debug_print_string
    mov     esi, CRLF
    call    debug_print_string
    mov     esi, IP_DATA2
    call    debug_print_string
    ret

do_001:
    cmp     esi, TX_IP
    jne     do_002

    call    debug_print_string

    call    debug_print_tx_ip

    mov     esi, IP_DATA1
    call    debug_print_string
    mov     esi, CRLF
    call    debug_print_string
    mov     esi, IP_DATA2
    call    debug_print_string
    ret

do_002:
    ; Print PPP protocol information
if DEBUG_PPP_OUTPUT = TRUE
    call    debug_print_string
    mov     esi, CRLF
    call    debug_print_string
end if
    ret



txCom2:
    push    ecx

wait_txd2t:
    mov     eax,43
    mov     ecx,0x80000000 + 0x2f8 + 5
    mcall
    and     bl, 0x40
    cmp     bl, 0
    jz      wait_txd2t                  ; loop until free

    pop     ebx


    ; send the character

    mov     ecx, 0x2f8
    mov     eax, 43
    mcall
    ret


;****************************************************************************
;    Function
;       debug_print_string
;
;   Description
;       prints a string to the debug board
;
;       esi holds ptr to msg to display
;
;       Nothing preserved; I'm assuming a pusha/popa is done before calling
;
;****************************************************************************
debug_print_string:
    mov     cl, [esi]
    cmp     cl, 0
    jnz     dps_001
    ret

dps_001:
if DEBUG_PORT2_OUTPUT = TRUE
    pusha
    call    txCom2
    popa
end if
    mov     eax,63
    mov     ebx, 1
    push    esi
    mcall
    pop     esi
    inc     esi
    jmp     debug_print_string


; This is used for translating hex to ASCII for display or output
hexchars db '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'

IP_DATA1    db 'TCP  From: xxxxxxxx To: xxxxxxxx SrcP: xxxx DestP: xxxx',0
IP_DATA2    db 'Seq: xxxxxxxx Ack: xxxxxxxx Flags: xx  dataLen: xxxx',13,10,0



debug_print_rx_ip:
    mov     esi, rx_str + 4     ; The ip buffer address start

    mov     edi, IP_DATA1

    cmp     [esi+9], byte 1
    jne     rnICMP
    mov     eax,'ICMP'
    jmp     drp
rnICMP:
    cmp     [esi+9], byte 6
    jne     rnTCP
    mov     eax,'TCP '
    jmp     drp
rnTCP:
    cmp     [esi+9], byte 17
    jne     rnUDP
    mov     eax,'UDP '
    jmp     drp
rnUDP:

drp:
    mov     [edi], eax

    call    fillData

    ret


debug_print_tx_ip:
    mov     esi, ip_buff     ; The ip buffer address start

    mov     edi, IP_DATA1

    cmp     [esi+9], byte 1
    jne     tnICMP
    mov     eax,'ICMP'
    jmp     dtp
tnICMP:
    cmp     [esi+9], byte 6
    jne     tnTCP
    mov     eax,'TCP '
    jmp     dtp
tnTCP:
    cmp     [esi+9], byte 17
    jne     tnUDP
    mov     eax,'UDP '
    jmp     dtp
tnUDP:

dtp:
    mov     [edi], eax

    call    fillData

    ret


fillData:
    ; Display from IP
    mov     cl, [esi+12]
    mov     edx, 11
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+13]
    mov     edx, 13
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+14]
    mov     edx, 15
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+15]
    mov     edx, 17
    call    wbyte               ; byte in cl, dest in edi+edx

    ; Display to IP
    mov     cl, [esi+16]
    mov     edx, 24
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+17]
    mov     edx, 26
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+18]
    mov     edx, 28
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+19]
    mov     edx, 30
    call    wbyte               ; byte in cl, dest in edi+edx

    ; Only display extra data for TCP
    cmp     [esi+9], byte 6     ; TCP?
    je      nTCP

    ; display source port
    mov     [edi+32], byte 0
    mov     edi, IP_DATA2
    mov     [edi], byte 0
    ret

nTCP:
    mov     [edi+32], byte ' '

    mov     cl, [esi+20]
    mov     edx, 39
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+21]
    mov     edx, 41
    call    wbyte               ; byte in cl, dest in edi+edx

    mov     cl, [esi+22]
    mov     edx, 51
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+23]
    mov     edx, 53
    call    wbyte               ; byte in cl, dest in edi+edx


    mov     edi, IP_DATA2
    mov     [edi], byte 'S'

    mov     cl, [esi+24]
    mov     edx, 5
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+25]
    mov     edx, 7
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+26]
    mov     edx, 9
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+27]
    mov     edx, 11
    call    wbyte               ; byte in cl, dest in edi+edx

    mov     cl, [esi+28]
    mov     edx, 19
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+29]
    mov     edx, 21
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+30]
    mov     edx, 23
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     cl, [esi+31]
    mov     edx, 25
    call    wbyte               ; byte in cl, dest in edi+edx

    mov     cl, [esi+33]
    and     cl, 0x3F
    mov     edx, 35
    call    wbyte               ; byte in cl, dest in edi+edx

    ; Display the size of the received packet
    mov     dh, [esi + 2]
    mov     dl, [esi + 3]
    sub     dx, 40
    mov     cl, dh
    mov     edx, 48
    call    wbyte               ; byte in cl, dest in edi+edx
    mov     dh, [esi + 2]
    mov     dl, [esi + 3]
    sub     dx, 40
    mov     cl, dl
    mov     edx, 50
    call    wbyte               ; byte in cl, dest in edi+edx


    ret


wbyte:  ; byte in cl, dest in edi+edx, edi unchanged
    xor     eax, eax
    mov     al, cl
    shr     al, 4
    mov     bl, [eax + hexchars]
    mov     [edi+edx], bl
    inc edx
    mov     al, cl
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    mov     [edi+edx], bl
    ret

else
debug_output:
    ret
end if

; DATA AREA


; debug msgs
RX_IP               db  'R: ',0
TX_IP               db  'T: ',0
CRLF                db  13,10,0
RX_LCP_REQ          db  'RX_LCP_REQ',0
RX_LCP_ACK          db  'RX_LCP_ACK',0
RX_LCP_NAK          db  'RX_LCP_NAK',0
RX_LCP_REJ          db  'RX_LCP_REJ',0
RX_LCP_ECHO_REQ     db  'RX_LCP_ECHO_REQ',0
RX_PAP_ACK          db  'RX_PAP_ACK',0
RX_IPCP_REQ         db  'RX_IPCP_REQ',0
RX_IPCP_ACK         db  'RX_IPCP_ACK',0
RX_IPCP_NAK         db  'RX_IPCP_NAK ( IP Address assigned )',0
RX_CCP_REQ          db  'RX_CCP_REQ',0
TX_LCP_REQ          db  'TX_LCP_REQ',0
TX_PAP_REQ          db  'TX_PAP_REQ',0
TX_IPCP_REQ         db  'TX_IPCP_REQ',0


; Labels for GUI buttons
button1_text        db  'DIAL'
button1_text_len    db  4
button3_text        db  'DISCONNECT'
button3_text_len    db  10

comport             dd  0
comirq              dd  0

; Pointer to prompt shown to user
prompt              dd  0
prompt_len          db  0

; Application Title
title               db  'PPP Dialer',0

txmsg:              db  'Tx bytes :'
txmsglen:
rxmsg:              db  'Rx bytes :'
rxmsglen:

timerValue          dd  0
sendwaitTime        dd  0


; Prompts displayed to the user
welcomep            db  'Select an option below, see ppp.txt'
welcomep_len        db  35

dialfp              db  'Connect Failed...'
dialfp_len          db  17

connectedp          db  'Connected to Host'
connectedp_len      db  17

conp                db  'Connecting to Host'
conp_len            db  18

pppOnp              db  'PPP Started'
pppOnp_len          db  11

IPOnp               db  'IP Link established'
IPOnp_len           db  19

discp               db  'Disconnected from Host'
discp_len           db  22

hangp               db  'Hanging up Modem......'
hangp_len           db  22

PPPconSend          db  0x7e,0xff,0x7d,0x23,0x08,0x08,0x08,0x08,0
PPPconWait          db  '~~',0
hangupWait          db  'ATZ',0
hangupSend          db  '|||+++|||',10,13,'ATH',10,13,'|ATZ',10,13,0

; Shrirang 2/5/03

abortres:           times(50) db 0
abortcnt                      db 0

;--!

LCPREQStr db 0x0e,0x02,0x06,0x00, 0x0a, 0x00, 0x00, 0x07, 0x02, 0x08, 0x02
PAPREQStr           db 14, 4, 'free', 4, 'free'
IPCPREQStr          db 10, 3, 6, 0, 0, 0, 0

irqtable:           dd  0x3f8 + 0x01000000  ; read port 0x3f8, byte
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
      dd  0
checksum1           dd  0
checksum2           dd  0
packet              dd  0
state               dd  0
extended            dd  0
number              dd  0
tx_end              dd  0
tx_ptr              dd  0
rx_ptr              dd  0
addr1               db  0
addr2               db  0
addr3               db  0
addr4               db  0
rxbytes             dd  0
txbytes             dd  0


; End of application code and data marker

I_END:

rx_str:             rb MaxRx + 1
tx_str:             rb MaxTx + 1
ip_buff:            rb 1500