WebSVN – Kolibri OS – Diff – /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

Rev 485	Rev 551
1	;	1	;
2	; PPP.ASM	2	; PPP.ASM
3	;	3	;
4	; Compile with FASM for Menuet	4	; Compile with FASM for Menuet
5	; This program dials into an ISP and establishes a PPP connection	5	; This program dials into an ISP and establishes a PPP connection
6	;	6	;
7	; Version 11 26th January 2004	7	; Version 11 26th January 2004
8	;	8	;
9	; This code is a port of the PPP dialer program by Microchip, from	9	; This code is a port of the PPP dialer program by Microchip, from
10	; their application note AN724	10	; their application note AN724
11	; It has been ported by Mike Hibbett mikeh@oceanfree.net for Menuet	11	; It has been ported by Mike Hibbett mikeh@oceanfree.net for Menuet
12	;	12	;
13	; 26/1/04 - Mike Hibbett - added support for com port selected by	13	; 26/1/04 - Mike Hibbett - added support for com port selected by
14	; stackcfg	14	; stackcfg
15	; 2/5/03 - Shrirang - Added Abort Strings To sendwait to get out early	15	; 2/5/03 - Shrirang - Added Abort Strings To sendwait to get out early
16	; if modem sends abort strings like NO CARRIER etc.	16	; if modem sends abort strings like NO CARRIER etc.
17	;	17	;
18	; The original copyright statement follows	18	; The original copyright statement follows
19	;//////////////////////////////////////////////////////////////////////////	19	;//////////////////////////////////////////////////////////////////////////
20	;//	20	;//
21	;//PING.C version 1.10 July 29/99 (C)opyright by Microchip Technology Inc	21	;//PING.C version 1.10 July 29/99 (C)opyright by Microchip Technology Inc
22	;//	22	;//
23	;//////////////////////////////////////////////////////////////////////////	23	;//////////////////////////////////////////////////////////////////////////
24		24
25	FALSE equ 0	25	FALSE equ 0
26	TRUE equ 1	26	TRUE equ 1
27	DEBUG_OUTPUT equ TRUE ; If FALSE, not debugging info outputted	27	DEBUG_OUTPUT equ TRUE ; If FALSE, not debugging info outputted
28	DEBUG_PPP_OUTPUT equ TRUE ; write PPP status msgs to debug board?	28	DEBUG_PPP_OUTPUT equ TRUE ; write PPP status msgs to debug board?
29	DEBUG_PORT2_OUTPUT equ TRUE ; write debug data also to com2	29	DEBUG_PORT2_OUTPUT equ TRUE ; write debug data also to com2
30		30
31		31
32	BAUD_9600 equ 12	32	BAUD_9600 equ 12
33	BAUD_57600 equ 2	33	BAUD_57600 equ 2
34	; The next line sets the baud rate of the connection to the modem	34	; The next line sets the baud rate of the connection to the modem
35	BAUDRATE equ BAUD_57600	35	BAUDRATE equ BAUD_57600
36		36
37		37
38	LINE_END equ 0x0D ; End of input data character	38	LINE_END equ 0x0D ; End of input data character
39		39
40		40
41	; Defines for Internet constants	41	; Defines for Internet constants
42	REQ equ 1 ; Request options list for PPP negotiations	42	REQ equ 1 ; Request options list for PPP negotiations
43	PPP_ACK equ 2 ; Acknowledge options list for PPP negotiations	43	PPP_ACK equ 2 ; Acknowledge options list for PPP negotiations
44	PPP_NAK equ 3 ; Not acknowledged options list for PPP neg	44	PPP_NAK equ 3 ; Not acknowledged options list for PPP neg
45	REJ equ 4 ; Reject options list for PPP negotiations	45	REJ equ 4 ; Reject options list for PPP negotiations
46	TERM equ 5 ; Termination packet for LCP to close connectio	46	TERM equ 5 ; Termination packet for LCP to close connectio
47	LCP_ECHO_REQ equ 9	47	LCP_ECHO_REQ equ 9
48	LCP_ECHO_REP equ 10	48	LCP_ECHO_REP equ 10
49	IP equ 0x0021 ; Internet Protocol packet	49	IP equ 0x0021 ; Internet Protocol packet
50	IPCP equ 0x8021 ; Internet Protocol Configure Protocol packet	50	IPCP equ 0x8021 ; Internet Protocol Configure Protocol packet
51	CCP equ 0x80FD ; Compression Configure Protocol packet	51	CCP equ 0x80FD ; Compression Configure Protocol packet
52	LCP equ 0xC021 ; Link Configure Protocol packet	52	LCP equ 0xC021 ; Link Configure Protocol packet
53	PAP equ 0xC023 ; Password Authenication Protocol packet	53	PAP equ 0xC023 ; Password Authenication Protocol packet
54		54
55		55
56	MaxRx equ 1500	56	MaxRx equ 1500
57	MaxTx equ 1500	57	MaxTx equ 1500
58		58
59		59
60		60
61		61
62	use32	62	use32
63	org 0x0	63	org 0x0
64	db 'MENUET01' ; header	64	db 'MENUET01' ; header
65	dd 0x01 ; header version	65	dd 0x01 ; header version
66	dd STARTAPP ; entry point	66	dd STARTAPP ; entry point
67	dd I_END ; image size	67	dd I_END ; image size
68	dd I_END+0x10000 ; required memory	68	dd I_END+0x10000 ; required memory
69	dd I_END+0x10000 ; esp	69	dd I_END+0x10000 ; esp
70	dd 0x0 , 0x0 ; I_Param , I_Path	70	dd 0x0 , 0x0 ; I_Param , I_Path
71		71
72		72
73	include "lang.inc"	73	include "lang.inc"
74	include "..\..\..\macros.inc"	74	include "..\..\..\macros.inc"
75	include "chat.inc" ; Hosts modem chatting routine	75	include "chat.inc" ; Hosts modem chatting routine
76		76
77		77
78	STARTAPP:	78	STARTAPP:
79	; mov eax, 0x3f8	79	; mov eax, 0x3f8
80	; mov [comport], eax	80	; mov [comport], eax
81	; mov eax, 4	81	; mov eax, 4
82	; mov [comirq], eax	82	; mov [comirq], eax
83		83
84	; Get the com port & IRQ to use from the kernel stack config option	84	; Get the com port & IRQ to use from the kernel stack config option
85		85
86	mov eax, 52 ; Stack Interface	86	mov eax, 52 ; Stack Interface
87	mov ebx, 0 ; read configuration word	87	mov ebx, 0 ; read configuration word
88	mcall	88	mcall
89	mov ecx, eax	89	mov ecx, eax
90	shr ecx, 16 ; get the port address	90	shr ecx, 16 ; get the port address
91	mov [comport], ecx	91	mov [comport], ecx
92	shr eax, 8	92	shr eax, 8
93	and eax, 0x000000FF ; get the irq	93	and eax, 0x000000FF ; get the irq
94	mov [comirq], eax	94	mov [comirq], eax
95		95
96		96
97	mov eax, [comport]	97	mov eax, [comport]
98	add eax, 0x01000000	98	add eax, 0x01000000
99	mov [irqtable], eax	99	mov [irqtable], eax
100		100
101		101
102	call enable_port	102	call enable_port
103		103
104	appdsp:	104	appdsp:
105	mov eax, welcomep	105	mov eax, welcomep
106	mov [prompt], eax ; set up prompt to display	106	mov [prompt], eax ; set up prompt to display
107	mov al, [welcomep_len]	107	mov al, [welcomep_len]
108	mov [prompt_len], al	108	mov [prompt_len], al
109		109
110	red:	110	red:
111	call draw_window ; at first, draw the window	111	call draw_window ; at first, draw the window
112		112
113	apploop:	113	apploop:
114	mov eax, 23 ; wait here for event	114	mov eax, 23 ; wait here for event
115	mov ebx, 20	115	mov ebx, 20
116	mcall	116	mcall
117		117
118	cmp eax, 1 ; redraw request ?	118	cmp eax, 1 ; redraw request ?
119	je red	119	je red
120	cmp eax, 2 ; key in buffer ?	120	cmp eax, 2 ; key in buffer ?
121	je key	121	je key
122	cmp eax, 3 ; button in buffer ?	122	cmp eax, 3 ; button in buffer ?
123	je button	123	je button
124	mov ebx, [comirq]	124	mov ebx, [comirq]
125	add ebx, 16	125	add ebx, 16
126	cmp eax, ebx	126	cmp eax, ebx
127	je flush_input ; Dont want serial data yet	127	je flush_input ; Dont want serial data yet
128	jmp apploop	128	jmp apploop
129		129
130	key: ; key - ignore	130	key: ; key - ignore
131	mov eax, 2 ; just read it	131	mov eax, 2 ; just read it
132	mcall	132	mcall
133	jmp apploop	133	jmp apploop
134		134
135	button: ; button	135	button: ; button
136	mov eax, 17 ; get id	136	mov eax, 17 ; get id
137	mcall	137	mcall
138		138
139	cmp ah, 1 ; close program ?	139	cmp ah, 1 ; close program ?
140	jne noclose	140	jne noclose
141		141
142	mov esi, hangupWait	142	mov esi, hangupWait
143	mov edi, hangupSend	143	mov edi, hangupSend
144	mov edx, 1000 ; Allow sendwait 10s	144	mov edx, 1000 ; Allow sendwait 10s
145	call sendwait	145	call sendwait
146		146
147	call disable_port	147	call disable_port
148		148
149	or eax, -1 ; close this program	149	or eax, -1 ; close this program
150	mcall	150	mcall
151	jmp apploop	151	jmp apploop
152		152
153	noclose:	153	noclose:
154	cmp ah, 2 ; Dial Button pressed?	154	cmp ah, 2 ; Dial Button pressed?
155	jne apploop	155	jne apploop
156		156
157	mov eax, conp	157	mov eax, conp
158	mov [prompt], eax ; set up prompt to display	158	mov [prompt], eax ; set up prompt to display
159	mov al,[conp_len]	159	mov al,[conp_len]
160	mov [prompt_len], al	160	mov [prompt_len], al
161	call draw_window	161	call draw_window
162		162
163	jmp dialloop ; connect to the host	163	jmp dialloop ; connect to the host
164		164
165		165
166	; Data received, so get it, and throw it away at this point	166	; Data received, so get it, and throw it away at this point
167	flush_input:	167	flush_input:
168	mov eax,42	168	mov eax,42
169	mov ebx, [comirq]	169	mov ebx, [comirq]
170	mcall	170	mcall
171		171
172	mov eax,11 ; This will return 0 most of the time	172	mov eax,11 ; This will return 0 most of the time
173	mcall	173	mcall
174	mov ebx, [comirq]	174	mov ebx, [comirq]
175	add ebx, 16	175	add ebx, 16
176	cmp eax, ebx	176	cmp eax, ebx
177	je flush_input	177	je flush_input
178	jmp apploop	178	jmp apploop
179		179
180		180
181	dialloop:	181	dialloop:
182	call modem_chat ; Try chatting with the modem	182	call modem_chat ; Try chatting with the modem
183		183
184	cmp eax, 1 ; Did it work? ( = 1)	184	cmp eax, 1 ; Did it work? ( = 1)
185	jne appdsp	185	jne appdsp
186		186
187	; OK, we are now connected.	187	; OK, we are now connected.
188		188
189	mov eax, pppOnp	189	mov eax, pppOnp
190	mov [prompt], eax ; set up prompt to display	190	mov [prompt], eax ; set up prompt to display
191	mov al,[pppOnp_len]	191	mov al,[pppOnp_len]
192	mov [prompt_len], al	192	mov [prompt_len], al
193	call draw_window	193	call draw_window
194		194
195	mov eax, 23	195	mov eax, 23
196	mov ebx, 100	196	mov ebx, 100
197	mcall ; wait for 1s to display message	197	mcall ; wait for 1s to display message
198		198
199	call PPPStateMachine ; This is the main code	199	call PPPStateMachine ; This is the main code
200		200
201	jmp appdsp	201	jmp appdsp
202		202
203		203
204		204
205		205
206	;****************************************************************************	206	;****************************************************************************
207	; Function	207	; Function
208	; PPPStateMachine	208	; PPPStateMachine
209	;	209	;
210	; Description	210	; Description
211	; Handles PPP link establishment	211	; Handles PPP link establishment
212	;	212	;
213	;****************************************************************************	213	;****************************************************************************
214	PPPStateMachine:	214	PPPStateMachine:
215	; Start the timer	215	; Start the timer
216	xor eax, eax	216	xor eax, eax
217	call settimer	217	call settimer
218		218
219	PPPLoop:	219	PPPLoop:
220		220
221	mov eax, 11 ; check event	221	mov eax, 11 ; check event
222	mcall	222	mcall
223	cmp eax, 3	223	cmp eax, 3
224	jne PPPLred	224	jne PPPLred
225	; button pressed	225	; button pressed
226	mov eax, 17 ; get id	226	mov eax, 17 ; get id
227	mcall	227	mcall
228		228
229		229
230	mov eax, hangp	230	mov eax, hangp
231	mov [prompt], eax ; set up prompt to display	231	mov [prompt], eax ; set up prompt to display
232	mov al,[hangp_len]	232	mov al,[hangp_len]
233	mov [prompt_len], al	233	mov [prompt_len], al
234	call draw_window	234	call draw_window
235		235
236	mov esi, hangupWait	236	mov esi, hangupWait
237	mov edi, hangupSend	237	mov edi, hangupSend
238	mov edx, 1000 ; Allow sendwait 10s	238	mov edx, 1000 ; Allow sendwait 10s
239	call sendwait	239	call sendwait
240		240
241	call disable_port	241	call disable_port
242	mov eax, -1 ; close this program	242	mov eax, -1 ; close this program
243	mcall	243	mcall
244	jmp PPPLoop	244	jmp PPPLoop
245		245
246	PPPLred:	246	PPPLred:
247	cmp eax, 1 ; redraw request ?	247	cmp eax, 1 ; redraw request ?
248	jne PPPLoop0	248	jne PPPLoop0
249		249
250	call draw_window	250	call draw_window
251	jmp PPPLoop	251	jmp PPPLoop
252		252
253	PPPLoop0:	253	PPPLoop0:
254	mov ebx, [comirq]	254	mov ebx, [comirq]
255	add ebx, 16	255	add ebx, 16
256	cmp eax, ebx	256	cmp eax, ebx
257	jne ppp_002 ; check for tx to send	257	jne ppp_002 ; check for tx to send
258		258
259		259
260	; we have data in the rx buffer, get it	260	; we have data in the rx buffer, get it
261		261
262	mov eax, 42	262	mov eax, 42
263	mov ebx, [comirq] ; ecx will return 0 =data read, 1 =no data	263	mov ebx, [comirq] ; ecx will return 0 =data read, 1 =no data
264	mcall ; or 2 =not irq owner	264	mcall ; or 2 =not irq owner
265		265
266	inc dword [rxbytes]	266	inc dword [rxbytes]
267		267
268	cmp bl, 0x7E	268	cmp bl, 0x7E
269	jne ppp_001a	269	jne ppp_001a
270		270
271	mov eax, [rx_ptr]	271	mov eax, [rx_ptr]
272	cmp eax, 0	272	cmp eax, 0
273	jz ppp_001	273	jz ppp_001
274	mov eax, [checksum1]	274	mov eax, [checksum1]
275	cmp eax, 0xf0b8	275	cmp eax, 0xf0b8
276	jne ppp_001	276	jne ppp_001
277		277
278		278
279	movzx eax, byte [rx_str + 3]	279	movzx eax, byte [rx_str + 3]
280	mov ah, [rx_str + 2]	280	mov ah, [rx_str + 2]
281	mov [packet], eax	281	mov [packet], eax
282		282
283	ppp_001:	283	ppp_001:
284	mov eax, [extended]	284	mov eax, [extended]
285	and eax, 0x7e	285	and eax, 0x7e
286	mov [extended], eax	286	mov [extended], eax
287	xor eax, eax	287	xor eax, eax
288	mov [rx_ptr], eax	288	mov [rx_ptr], eax
289		289
290	mov eax, 0xffff	290	mov eax, 0xffff
291	mov [checksum1], eax	291	mov [checksum1], eax
292	jmp ppp_003	292	jmp ppp_003
293		293
294	ppp_001a:	294	ppp_001a:
295	cmp bl, 0x7D	295	cmp bl, 0x7D
296	jne ppp_001b	296	jne ppp_001b
297		297
298	mov eax, [extended]	298	mov eax, [extended]
299	or eax, 0x01	299	or eax, 0x01
300	mov [extended], eax	300	mov [extended], eax
301	jmp ppp_003	301	jmp ppp_003
302		302
303	ppp_001b:	303	ppp_001b:
304	mov eax, [extended]	304	mov eax, [extended]
305	test eax, 0x01	305	test eax, 0x01
306	jz ppp_001c	306	jz ppp_001c
307		307
308	xor bl, 0x20	308	xor bl, 0x20
309	and eax, 0xFE	309	and eax, 0xFE
310	mov [extended], eax	310	mov [extended], eax
311		311
312	ppp_001c:	312	ppp_001c:
313	mov edx, [rx_ptr]	313	mov edx, [rx_ptr]
314	cmp edx, 0	314	cmp edx, 0
315	jnz ppp_001d	315	jnz ppp_001d
316	cmp bl, 0xff	316	cmp bl, 0xff
317	je ppp_001d	317	je ppp_001d
318		318
319	mov [rx_str + edx], byte 0xff	319	mov [rx_str + edx], byte 0xff
320	inc edx	320	inc edx
321		321
322	ppp_001d:	322	ppp_001d:
323	cmp edx, 1	323	cmp edx, 1
324	jnz ppp_001e	324	jnz ppp_001e
325	cmp bl, 0x03	325	cmp bl, 0x03
326	je ppp_001e	326	je ppp_001e
327		327
328	mov [rx_str + edx], byte 0x03	328	mov [rx_str + edx], byte 0x03
329	inc edx	329	inc edx
330		330
331	ppp_001e:	331	ppp_001e:
332	cmp edx, 2	332	cmp edx, 2
333	jnz ppp_001f	333	jnz ppp_001f
334	test bl, 0x01	334	test bl, 0x01
335	jz ppp_001f	335	jz ppp_001f
336		336
337	mov [rx_str + edx], byte 0	337	mov [rx_str + edx], byte 0
338	inc edx	338	inc edx
339		339
340	ppp_001f:	340	ppp_001f:
341	mov [rx_str + edx], bl	341	mov [rx_str + edx], bl
342	inc edx	342	inc edx
343	mov [rx_ptr], edx	343	mov [rx_ptr], edx
344		344
345	cmp edx, MaxRx	345	cmp edx, MaxRx
346	jle ppp_001g	346	jle ppp_001g
347	mov edx, MaxRx	347	mov edx, MaxRx
348	mov [rx_ptr], edx	348	mov [rx_ptr], edx
349		349
350	ppp_001g:	350	ppp_001g:
351	; do checksum calc	351	; do checksum calc
352	mov eax, [checksum1]	352	mov eax, [checksum1]
353	xor bh, bh	353	xor bh, bh
354	xor ax, bx	354	xor ax, bx
355	call calc	355	call calc
356	mov ebx, [checksum1]	356	mov ebx, [checksum1]
357	and ebx, 0xffff	357	and ebx, 0xffff
358	shr ebx, 8	358	shr ebx, 8
359	xor eax, ebx	359	xor eax, ebx
360	mov [checksum1], eax	360	mov [checksum1], eax
361	jmp ppp_003	361	jmp ppp_003
362		362
363	ppp_002:	363	ppp_002:
364	mov eax, [tx_end]	364	mov eax, [tx_end]
365	cmp eax, 0	365	cmp eax, 0
366	jz ppp_003	366	jz ppp_003
367		367
368	mov ebx, [tx_ptr]	368	mov ebx, [tx_ptr]
369	mov cl, [tx_str + ebx]	369	mov cl, [tx_str + ebx]
370		370
371	cmp ebx, eax	371	cmp ebx, eax
372	jne ppp_002a	372	jne ppp_002a
373	mov [tx_end], dword 0	373	mov [tx_end], dword 0
374	mov cl, '~'	374	mov cl, '~'
375	jmp ppp_002d	375	jmp ppp_002d
376		376
377	ppp_002a:	377	ppp_002a:
378	mov eax, [extended]	378	mov eax, [extended]
379	and eax, 0x02	379	and eax, 0x02
380	jz ppp_002b	380	jz ppp_002b
381		381
382	xor cl, 0x20	382	xor cl, 0x20
383	mov eax, [extended]	383	mov eax, [extended]
384	and eax, 0xFD	384	and eax, 0xFD
385	mov [extended], eax	385	mov [extended], eax
386	inc [tx_ptr]	386	inc [tx_ptr]
387	jmp ppp_002d	387	jmp ppp_002d
388		388
389	ppp_002b:	389	ppp_002b:
390	cmp cl, 0x20	390	cmp cl, 0x20
391	jl ppp_002b1	391	jl ppp_002b1
392	cmp cl, 0x7d	392	cmp cl, 0x7d
393	je ppp_002b1	393	je ppp_002b1
394	cmp cl, 0x7e	394	cmp cl, 0x7e
395	je ppp_002b1	395	je ppp_002b1
396	jmp ppp_002c	396	jmp ppp_002c
397		397
398	ppp_002b1:	398	ppp_002b1:
399	mov eax, [extended]	399	mov eax, [extended]
400	or eax, 0x02	400	or eax, 0x02
401	mov [extended], eax	401	mov [extended], eax
402	mov cl, 0x7d	402	mov cl, 0x7d
403	jmp ppp_002d	403	jmp ppp_002d
404		404
405	ppp_002c:	405	ppp_002c:
406	mov eax, [tx_ptr]	406	mov eax, [tx_ptr]
407	cmp eax, 0	407	cmp eax, 0
408	jnz ppp_002c1	408	jnz ppp_002c1
409	mov cl, '~'	409	mov cl, '~'
410		410
411	ppp_002c1:	411	ppp_002c1:
412	inc [tx_ptr]	412	inc [tx_ptr]
413		413
414	ppp_002d:	414	ppp_002d:
415	; Test for tx ready.	415	; Test for tx ready.
416		416
417	push ecx	417	push ecx
418		418
419	wait_txd2:	419	wait_txd2:
420	mov eax,43	420	mov eax,43
421	mov ecx, [comport]	421	mov ecx, [comport]
422	add ecx, 0x80000000 + 5	422	add ecx, 0x80000000 + 5
423	mcall	423	mcall
424	and bl, 0x40	424	and bl, 0x40
425	cmp bl, 0	425	cmp bl, 0
426	jz wait_txd2 ; loop until free	426	jz wait_txd2 ; loop until free
427		427
428	pop ebx	428	pop ebx
429		429
430		430
431	; send the character	431	; send the character
432		432
433	inc dword [txbytes]	433	inc dword [txbytes]
434		434
435	mov ecx, [comport]	435	mov ecx, [comport]
436	mov eax, 43	436	mov eax, 43
437	mcall	437	mcall
438		438
439	ppp_003:	439	ppp_003:
440	mov eax, [packet]	440	mov eax, [packet]
441	cmp eax, LCP	441	cmp eax, LCP
442	jne ppp_004	442	jne ppp_004
443		443
444	mov al, [rx_str + 4]	444	mov al, [rx_str + 4]
445	cmp al, REQ	445	cmp al, REQ
446	jne ppp_003b	446	jne ppp_003b
447		447
448	; Debugging output to debug board	448	; Debugging output to debug board
449	pusha	449	pusha
450	mov esi, RX_LCP_REQ	450	mov esi, RX_LCP_REQ
451	call debug_output	451	call debug_output
452	popa	452	popa
453		453
454	mov eax, [state]	454	mov eax, [state]
455	and eax, 0xfd	455	and eax, 0xfd
456	mov [state], eax	456	mov [state], eax
457		457
458	mov ebx, 0xc6	458	mov ebx, 0xc6
459	push eax	459	push eax
460	call TestOptions	460	call TestOptions
461	pop eax	461	pop eax
462	cmp edx, 0	462	cmp edx, 0
463	jz ppp_003g	463	jz ppp_003g
464		464
465	cmp edx, 1	465	cmp edx, 1
466	jle ppp_003h	466	jle ppp_003h
467		467
468	mov edx, PPP_ACK	468	mov edx, PPP_ACK
469	cmp eax, 3	469	cmp eax, 3
470	jge ppp_003i	470	jge ppp_003i
471		471
472	or eax, 0x02	472	or eax, 0x02
473	mov [state], eax	473	mov [state], eax
474	jmp ppp_003i	474	jmp ppp_003i
475		475
476	ppp_003h:	476	ppp_003h:
477	mov bl, 0xc0	477	mov bl, 0xc0
478	mov [rx_str + 10], bl	478	mov [rx_str + 10], bl
479	mov edx, PPP_NAK	479	mov edx, PPP_NAK
480	jmp ppp_003i	480	jmp ppp_003i
481		481
482	ppp_003g:	482	ppp_003g:
483	mov edx, REJ	483	mov edx, REJ
484		484
485	ppp_003i:	485	ppp_003i:
486		486
487	mov ebx, LCP	487	mov ebx, LCP
488	mov ecx, edx	488	mov ecx, edx
489	movzx edx, byte [rx_str + 5]	489	movzx edx, byte [rx_str + 5]
490	mov esi, rx_str + 7	490	mov esi, rx_str + 7
491	call MakePacket	491	call MakePacket
492		492
493	mov eax, 0	493	mov eax, 0
494	call settimer	494	call settimer
495	jmp ppp_003a	495	jmp ppp_003a
496		496
497	ppp_003b:	497	ppp_003b:
498	cmp al, PPP_ACK	498	cmp al, PPP_ACK
499	jne ppp_003c	499	jne ppp_003c
500		500

Subversion Repositories Kolibri OS

(root)/programs/network/ppp/trunk/ppp.asm – Rev 485 → 551