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,0x13224466          ; 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 109	Rev 485
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		-
64	org 0x0	63	org 0x0
65		-
66	db 'MENUET00' ; 8 byte id	64	db 'MENUET01' ; header
67	dd 38 ; required os	65	dd 0x01 ; header version
68	dd STARTAPP ; program start	66	dd STARTAPP ; entry point
69	dd I_END ; program image size	67	dd I_END ; image size
70	dd 0x100000 ; required amount of memory	68	dd I_END+0x10000 ; required memory
71	; esp = 0x7FFF0	69	dd I_END+0x10000 ; esp
72	dd 0x00000000 ; reserved=no extended header	70	dd 0x0 , 0x0 ; I_Param , I_Path
73		71
74		72
75	include "lang.inc"	73	include "lang.inc"
76	include "macros.inc"	74	include "..\..\..\macros.inc"
77	include "chat.inc" ; Hosts modem chatting routine	75	include "chat.inc" ; Hosts modem chatting routine
78		76
79		77
80	STARTAPP:	78	STARTAPP:
81	; mov eax, 0x3f8	79	; mov eax, 0x3f8
82	; mov [comport], eax	80	; mov [comport], eax
83	; mov eax, 4	81	; mov eax, 4
84	; mov [comirq], eax	82	; mov [comirq], eax
85		83
86	; 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
87		85
88	mov eax, 52 ; Stack Interface	86	mov eax, 52 ; Stack Interface
89	mov ebx, 0 ; read configuration word	87	mov ebx, 0 ; read configuration word
90	int 0x40	88	mcall
91	mov ecx, eax	89	mov ecx, eax
92	shr ecx, 16 ; get the port address	90	shr ecx, 16 ; get the port address
93	mov [comport], ecx	91	mov [comport], ecx
94	shr eax, 8	92	shr eax, 8
95	and eax, 0x000000FF ; get the irq	93	and eax, 0x000000FF ; get the irq
96	mov [comirq], eax	94	mov [comirq], eax
97		95
98		96
99	mov eax, [comport]	97	mov eax, [comport]
100	add eax, 0x01000000	98	add eax, 0x01000000
101	mov [irqtable], eax	99	mov [irqtable], eax
102		100
103		101
104	call enable_port	102	call enable_port
105		103
106	appdsp:	104	appdsp:
107	mov eax, welcomep	105	mov eax, welcomep
108	mov [prompt], eax ; set up prompt to display	106	mov [prompt], eax ; set up prompt to display
109	mov al, [welcomep_len]	107	mov al, [welcomep_len]
110	mov [prompt_len], al	108	mov [prompt_len], al
-		109
111		110	red:
112	call draw_window ; at first, draw the window	-
113		111	call draw_window ; at first, draw the window
114		112
115	apploop:	113	apploop:
116	mov eax, 23 ; wait here for event	114	mov eax, 23 ; wait here for event
117	mov ebx, 20	115	mov ebx, 20
118	int 0x40	116	mcall
119		117
120	cmp eax, 1 ; redraw request ?	118	cmp eax, 1 ; redraw request ?
121	je red	119	je red
122	cmp eax, 2 ; key in buffer ?	120	cmp eax, 2 ; key in buffer ?
123	je key	121	je key
124	cmp eax, 3 ; button in buffer ?	122	cmp eax, 3 ; button in buffer ?
125	je button	123	je button
126	mov ebx, [comirq]	124	mov ebx, [comirq]
127	add ebx, 16	125	add ebx, 16
128	cmp eax, ebx	126	cmp eax, ebx
129	je flush_input ; Dont want serial data yet	127	je flush_input ; Dont want serial data yet
130	jmp apploop	128	jmp apploop
131		-
132	red: ; redraw	-
133	call draw_window	-
134	jmp apploop	-
135		129
136	key: ; key - ignore	130	key: ; key - ignore
137	mov eax, 2 ; just read it	131	mov eax, 2 ; just read it
138	int 0x40	132	mcall
139	jmp apploop	133	jmp apploop
140		134
141	button: ; button	135	button: ; button
142	mov eax, 17 ; get id	136	mov eax, 17 ; get id
143	int 0x40	137	mcall
144		138
145	cmp ah, 1 ; close program ?	139	cmp ah, 1 ; close program ?
146	jne noclose	140	jne noclose
147		141
148	mov esi, hangupWait	142	mov esi, hangupWait
149	mov edi, hangupSend	143	mov edi, hangupSend
150	mov edx, 1000 ; Allow sendwait 10s	144	mov edx, 1000 ; Allow sendwait 10s
151	call sendwait	145	call sendwait
152		146
153	call disable_port	147	call disable_port
154		148
155	mov eax, -1 ; close this program	149	or eax, -1 ; close this program
156	int 0x40	150	mcall
157	jmp apploop	151	jmp apploop
158		152
159	noclose:	153	noclose:
160	cmp ah, 2 ; Dial Button pressed?	154	cmp ah, 2 ; Dial Button pressed?
161	jne apploop	155	jne apploop
162		156
163	mov eax, conp	157	mov eax, conp
164	mov [prompt], eax ; set up prompt to display	158	mov [prompt], eax ; set up prompt to display
165	mov al,[conp_len]	159	mov al,[conp_len]
166	mov [prompt_len], al	160	mov [prompt_len], al
167	call draw_window	161	call draw_window
168		162
169	jmp dialloop ; connect to the host	163	jmp dialloop ; connect to the host
170		164
171		165
172	; 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
173	flush_input:	167	flush_input:
174	mov eax,42	168	mov eax,42
175	mov ebx, [comirq]	169	mov ebx, [comirq]
176	int 0x40	170	mcall
177		171
178	mov eax,11 ; This will return 0 most of the time	172	mov eax,11 ; This will return 0 most of the time
179	int 0x40	173	mcall
180	mov ebx, [comirq]	174	mov ebx, [comirq]
181	add ebx, 16	175	add ebx, 16
182	cmp eax, ebx	176	cmp eax, ebx
183	je flush_input	177	je flush_input
184	jmp apploop	178	jmp apploop
185		179
186		180
187	dialloop:	181	dialloop:
188	call modem_chat ; Try chatting with the modem	182	call modem_chat ; Try chatting with the modem
189		183
190	cmp eax, 1 ; Did it work? ( = 1)	184	cmp eax, 1 ; Did it work? ( = 1)
191	jne appdsp	185	jne appdsp
192		186
193	; OK, we are now connected.	187	; OK, we are now connected.
194		188
195	mov eax, pppOnp	189	mov eax, pppOnp
196	mov [prompt], eax ; set up prompt to display	190	mov [prompt], eax ; set up prompt to display
197	mov al,[pppOnp_len]	191	mov al,[pppOnp_len]
198	mov [prompt_len], al	192	mov [prompt_len], al
199	call draw_window	193	call draw_window
200		194
201	mov eax, 23	195	mov eax, 23
202	mov ebx, 100	196	mov ebx, 100
203	int 0x40 ; wait for 1s to display message	197	mcall ; wait for 1s to display message
204		198
205	call PPPStateMachine ; This is the main code	199	call PPPStateMachine ; This is the main code
206		200
207	jmp appdsp	201	jmp appdsp
208		202
209		203
210		204
211		205
212	;****************************************************************************	206	;****************************************************************************
213	; Function	207	; Function
214	; PPPStateMachine	208	; PPPStateMachine
215	;	209	;
216	; Description	210	; Description
217	; Handles PPP link establishment	211	; Handles PPP link establishment
218	;	212	;
219	;****************************************************************************	213	;****************************************************************************
220	PPPStateMachine:	214	PPPStateMachine:
221	; Start the timer	215	; Start the timer
222	xor eax, eax	216	xor eax, eax
223	call settimer	217	call settimer
224		218
225	PPPLoop:	219	PPPLoop:
226		220
227	mov eax, 11 ; check event	221	mov eax, 11 ; check event
228	int 0x40	222	mcall
229	cmp eax, 3	223	cmp eax, 3
230	jne PPPLred	224	jne PPPLred
231	; button pressed	225	; button pressed
232	mov eax, 17 ; get id	226	mov eax, 17 ; get id
233	int 0x40	227	mcall
234		228
235		229
236	mov eax, hangp	230	mov eax, hangp
237	mov [prompt], eax ; set up prompt to display	231	mov [prompt], eax ; set up prompt to display
238	mov al,[hangp_len]	232	mov al,[hangp_len]
239	mov [prompt_len], al	233	mov [prompt_len], al
240	call draw_window	234	call draw_window
241		235
242	mov esi, hangupWait	236	mov esi, hangupWait
243	mov edi, hangupSend	237	mov edi, hangupSend
244	mov edx, 1000 ; Allow sendwait 10s	238	mov edx, 1000 ; Allow sendwait 10s
245	call sendwait	239	call sendwait
246		240
247	call disable_port	241	call disable_port
248	mov eax, -1 ; close this program	242	mov eax, -1 ; close this program
249	int 0x40	243	mcall
250	jmp PPPLoop	244	jmp PPPLoop
251		245
252	PPPLred:	246	PPPLred:
253	cmp eax, 1 ; redraw request ?	247	cmp eax, 1 ; redraw request ?
254	jne PPPLoop0	248	jne PPPLoop0
255		249
256	call draw_window	250	call draw_window
257	jmp PPPLoop	251	jmp PPPLoop
258		252
259	PPPLoop0:	253	PPPLoop0:
260	mov ebx, [comirq]	254	mov ebx, [comirq]
261	add ebx, 16	255	add ebx, 16
262	cmp eax, ebx	256	cmp eax, ebx
263	jne ppp_002 ; check for tx to send	257	jne ppp_002 ; check for tx to send
264		258
265		259
266	; we have data in the rx buffer, get it	260	; we have data in the rx buffer, get it
267		261
268	mov eax, 42	262	mov eax, 42
269	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
270	int 0x40 ; or 2 =not irq owner	264	mcall ; or 2 =not irq owner
271		265
272	inc dword [rxbytes]	266	inc dword [rxbytes]
273		267
274	cmp bl, 0x7E	268	cmp bl, 0x7E
275	jne ppp_001a	269	jne ppp_001a
276		270
277	mov eax, [rx_ptr]	271	mov eax, [rx_ptr]
278	cmp eax, 0	272	cmp eax, 0
279	jz ppp_001	273	jz ppp_001
280	mov eax, [checksum1]	274	mov eax, [checksum1]
281	cmp eax, 0xf0b8	275	cmp eax, 0xf0b8
282	jne ppp_001	276	jne ppp_001
283		277
284		278
285	movzx eax, byte [rx_str + 3]	279	movzx eax, byte [rx_str + 3]
286	mov ah, [rx_str + 2]	280	mov ah, [rx_str + 2]
287	mov [packet], eax	281	mov [packet], eax
288		282
289	ppp_001:	283	ppp_001:
290	mov eax, [extended]	284	mov eax, [extended]
291	and eax, 0x7e	285	and eax, 0x7e
292	mov [extended], eax	286	mov [extended], eax
293	xor eax, eax	287	xor eax, eax
294	mov [rx_ptr], eax	288	mov [rx_ptr], eax
295		289
296	mov eax, 0xffff	290	mov eax, 0xffff
297	mov [checksum1], eax	291	mov [checksum1], eax
298	jmp ppp_003	292	jmp ppp_003
299		293
300	ppp_001a:	294	ppp_001a:
301	cmp bl, 0x7D	295	cmp bl, 0x7D
302	jne ppp_001b	296	jne ppp_001b
303		297
304	mov eax, [extended]	298	mov eax, [extended]
305	or eax, 0x01	299	or eax, 0x01
306	mov [extended], eax	300	mov [extended], eax
307	jmp ppp_003	301	jmp ppp_003
308		302
309	ppp_001b:	303	ppp_001b:
310	mov eax, [extended]	304	mov eax, [extended]
311	test eax, 0x01	305	test eax, 0x01
312	jz ppp_001c	306	jz ppp_001c
313		307
314	xor bl, 0x20	308	xor bl, 0x20
315	and eax, 0xFE	309	and eax, 0xFE
316	mov [extended], eax	310	mov [extended], eax
317		311
318	ppp_001c:	312	ppp_001c:
319	mov edx, [rx_ptr]	313	mov edx, [rx_ptr]
320	cmp edx, 0	314	cmp edx, 0
321	jnz ppp_001d	315	jnz ppp_001d
322	cmp bl, 0xff	316	cmp bl, 0xff
323	je ppp_001d	317	je ppp_001d
324		318
325	mov [rx_str + edx], byte 0xff	319	mov [rx_str + edx], byte 0xff
326	inc edx	320	inc edx
327		321
328	ppp_001d:	322	ppp_001d:
329	cmp edx, 1	323	cmp edx, 1
330	jnz ppp_001e	324	jnz ppp_001e
331	cmp bl, 0x03	325	cmp bl, 0x03
332	je ppp_001e	326	je ppp_001e
333		327
334	mov [rx_str + edx], byte 0x03	328	mov [rx_str + edx], byte 0x03
335	inc edx	329	inc edx
336		330
337	ppp_001e:	331	ppp_001e:
338	cmp edx, 2	332	cmp edx, 2
339	jnz ppp_001f	333	jnz ppp_001f
340	test bl, 0x01	334	test bl, 0x01
341	jz ppp_001f	335	jz ppp_001f
342		336
343	mov [rx_str + edx], byte 0	337	mov [rx_str + edx], byte 0
344	inc edx	338	inc edx
345		339
346	ppp_001f:	340	ppp_001f:
347	mov [rx_str + edx], bl	341	mov [rx_str + edx], bl
348	inc edx	342	inc edx
349	mov [rx_ptr], edx	343	mov [rx_ptr], edx
350		344
351	cmp edx, MaxRx	345	cmp edx, MaxRx
352	jle ppp_001g	346	jle ppp_001g
353	mov edx, MaxRx	347	mov edx, MaxRx
354	mov [rx_ptr], edx	348	mov [rx_ptr], edx
355		349
356	ppp_001g:	350	ppp_001g:
357	; do checksum calc	351	; do checksum calc
358	mov eax, [checksum1]	352	mov eax, [checksum1]
359	xor bh, bh	353	xor bh, bh
360	xor ax, bx	354	xor ax, bx
361	call calc	355	call calc
362	mov ebx, [checksum1]	356	mov ebx, [checksum1]
363	and ebx, 0xffff	357	and ebx, 0xffff
364	shr ebx, 8	358	shr ebx, 8
365	xor eax, ebx	359	xor eax, ebx
366	mov [checksum1], eax	360	mov [checksum1], eax
367	jmp ppp_003	361	jmp ppp_003
368		362
369	ppp_002:	363	ppp_002:
370	mov eax, [tx_end]	364	mov eax, [tx_end]
371	cmp eax, 0	365	cmp eax, 0
372	jz ppp_003	366	jz ppp_003
373		367
374	mov ebx, [tx_ptr]	368	mov ebx, [tx_ptr]
375	mov cl, [tx_str + ebx]	369	mov cl, [tx_str + ebx]
376		370
377	cmp ebx, eax	371	cmp ebx, eax
378	jne ppp_002a	372	jne ppp_002a
379	mov [tx_end], dword 0	373	mov [tx_end], dword 0
380	mov cl, '~'	374	mov cl, '~'
381	jmp ppp_002d	375	jmp ppp_002d
382		376
383	ppp_002a:	377	ppp_002a:
384	mov eax, [extended]	378	mov eax, [extended]
385	and eax, 0x02	379	and eax, 0x02
386	jz ppp_002b	380	jz ppp_002b
387		381
388	xor cl, 0x20	382	xor cl, 0x20
389	mov eax, [extended]	383	mov eax, [extended]
390	and eax, 0xFD	384	and eax, 0xFD
391	mov [extended], eax	385	mov [extended], eax
392	inc [tx_ptr]	386	inc [tx_ptr]
393	jmp ppp_002d	387	jmp ppp_002d
394		388
395	ppp_002b:	389	ppp_002b:
396	cmp cl, 0x20	390	cmp cl, 0x20
397	jl ppp_002b1	391	jl ppp_002b1
398	cmp cl, 0x7d	392	cmp cl, 0x7d
399	je ppp_002b1	393	je ppp_002b1
400	cmp cl, 0x7e	394	cmp cl, 0x7e
401	je ppp_002b1	395	je ppp_002b1
402	jmp ppp_002c	396	jmp ppp_002c
403		397
404	ppp_002b1:	398	ppp_002b1:
405	mov eax, [extended]	399	mov eax, [extended]
406	or eax, 0x02	400	or eax, 0x02
407	mov [extended], eax	401	mov [extended], eax
408	mov cl, 0x7d	402	mov cl, 0x7d
409	jmp ppp_002d	403	jmp ppp_002d
410		404
411	ppp_002c:	405	ppp_002c:
412	mov eax, [tx_ptr]	406	mov eax, [tx_ptr]
413	cmp eax, 0	407	cmp eax, 0
414	jnz ppp_002c1	408	jnz ppp_002c1
415	mov cl, '~'	409	mov cl, '~'
416		410
417	ppp_002c1:	411	ppp_002c1:
418	inc [tx_ptr]	412	inc [tx_ptr]
419		413
420	ppp_002d:	414	ppp_002d:
421	; Test for tx ready.	415	; Test for tx ready.
422		416
423	push ecx	417	push ecx
424		418
425	wait_txd2:	419	wait_txd2:
426	mov eax,43	420	mov eax,43
427	mov ecx, [comport]	421	mov ecx, [comport]
428	add ecx, 0x80000000 + 5	422	add ecx, 0x80000000 + 5
429	int 0x40	423	mcall
430	and bl, 0x40	424	and bl, 0x40
431	cmp bl, 0	425	cmp bl, 0
432	jz wait_txd2 ; loop until free	426	jz wait_txd2 ; loop until free
433		427
434	pop ebx	428	pop ebx
435		429
436		430
437	; send the character	431	; send the character
438		432
439	inc dword [txbytes]	433	inc dword [txbytes]
440		434
441	mov ecx, [comport]	435	mov ecx, [comport]
442	mov eax, 43	436	mov eax, 43
443	int 0x40	437	mcall
444		438
445	ppp_003:	439	ppp_003:
446	mov eax, [packet]	440	mov eax, [packet]
447	cmp eax, LCP	441	cmp eax, LCP
448	jne ppp_004	442	jne ppp_004
449		443
450	mov al, [rx_str + 4]	444	mov al, [rx_str + 4]
451	cmp al, REQ	445	cmp al, REQ
452	jne ppp_003b	446	jne ppp_003b
453		447
454	; Debugging output to debug board	448	; Debugging output to debug board
455	pusha	449	pusha
456	mov esi, RX_LCP_REQ	450	mov esi, RX_LCP_REQ
457	call debug_output	451	call debug_output
458	popa	452	popa
459		453
460	mov eax, [state]	454	mov eax, [state]
461	and eax, 0xfd	455	and eax, 0xfd
462	mov [state], eax	456	mov [state], eax
463		457
464	mov ebx, 0xc6	458	mov ebx, 0xc6
465	push eax	459	push eax
466	call TestOptions	460	call TestOptions
467	pop eax	461	pop eax
468	cmp edx, 0	462	cmp edx, 0
469	jz ppp_003g	463	jz ppp_003g
470		464
471	cmp edx, 1	465	cmp edx, 1
472	jle ppp_003h	466	jle ppp_003h
473		467
474	mov edx, PPP_ACK	468	mov edx, PPP_ACK
475	cmp eax, 3	469	cmp eax, 3
476	jge ppp_003i	470	jge ppp_003i
477		471
478	or eax, 0x02	472	or eax, 0x02
479	mov [state], eax	473	mov [state], eax
480	jmp ppp_003i	474	jmp ppp_003i
481		475
482	ppp_003h:	476	ppp_003h:
483	mov bl, 0xc0	477	mov bl, 0xc0
484	mov [rx_str + 10], bl	478	mov [rx_str + 10], bl
485	mov edx, PPP_NAK	479	mov edx, PPP_NAK
486	jmp ppp_003i	480	jmp ppp_003i
487		481
488	ppp_003g:	482	ppp_003g:
489	mov edx, REJ	483	mov edx, REJ
490		484
491	ppp_003i:	485	ppp_003i:
492		486
493	mov ebx, LCP	487	mov ebx, LCP
494	mov ecx, edx	488	mov ecx, edx
495	movzx edx, byte [rx_str + 5]	489	movzx edx, byte [rx_str + 5]
496	mov esi, rx_str + 7	490	mov esi, rx_str + 7
497	call MakePacket	491	call MakePacket
498		492
499	mov eax, 0	493	mov eax, 0

Subversion Repositories Kolibri OS

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