0,0 → 1,2255 |
; |
; 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 'MENUET00' ; 8 byte id |
dd 38 ; required os |
dd STARTAPP ; program start |
dd I_END ; program image size |
dd 0x100000 ; required amount of memory |
; esp = 0x7FFF0 |
dd 0x00000000 ; reserved=no extended header |
|
|
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 |
int 0x40 |
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 |
|
call draw_window ; at first, draw the window |
|
|
apploop: |
mov eax, 23 ; wait here for event |
mov ebx, 20 |
int 0x40 |
|
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 |
|
red: ; redraw |
call draw_window |
jmp apploop |
|
key: ; key - ignore |
mov eax, 2 ; just read it |
int 0x40 |
jmp apploop |
|
button: ; button |
mov eax, 17 ; get id |
int 0x40 |
|
cmp ah, 1 ; close program ? |
jne noclose |
|
mov esi, hangupWait |
mov edi, hangupSend |
mov edx, 1000 ; Allow sendwait 10s |
call sendwait |
|
call disable_port |
|
mov eax, -1 ; close this program |
int 0x40 |
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] |
int 0x40 |
|
mov eax,11 ; This will return 0 most of the time |
int 0x40 |
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 |
int 0x40 ; 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 |
int 0x40 |
cmp eax, 3 |
jne PPPLred |
; button pressed |
mov eax, 17 ; get id |
int 0x40 |
|
|
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 |
int 0x40 |
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 |
int 0x40 ; 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 |
int 0x40 |
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 |
int 0x40 |
|
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] |
int 0x40 ; 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 |
int 0x40 |
|
; 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 |
int 0x40 |
|
|
|
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 |
int 0x40 |
|
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 |
int 0x40 |
end if |
|
mov eax, 45 ; free irq 4 |
mov ebx, 1 |
mov ecx, [comirq] |
int 0x40 |
|
mov eax, 46 ; free port area |
mov ebx, 1 |
|
mov ecx, [comport] |
and ecx, 0xFF0 |
mov edx, ecx |
or edx, 0x00F |
int 0x40 |
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 |
int 0x40 ; reseve port memory to this process |
|
mov eax, 45 ; reserve irq 3 |
mov ebx, 0 |
mov ecx, 3 |
int 0x40 |
|
|
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 |
int 0x40 |
|
mov ecx, 0x2f8 ; interrupt enable register |
inc ecx |
mov bl, 0 ; No interruts enabled |
mov eax, 43 ; send data to device (modem) |
int 0x40 |
|
mov ecx, 0x2f8 ; Divisor latch LSB |
mov bl, BAUDRATE ; set baud rate |
mov eax, 43 ; send data to device (modem) |
int 0x40 |
|
mov ecx, 0x2f8 ; Data format register |
add ecx, 3 |
mov bl, 3 ; 8 data bits |
mov eax, 43 ; send data to device (modem) |
int 0x40 |
|
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) |
int 0x40 |
|
; 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) |
; int 0x40 |
|
end if |
|
mov eax, 46 |
mov ebx, 0 |
mov ecx, [comport] |
and ecx, 0xFF0 |
mov edx, ecx |
or edx, 0x00F |
int 0x40 ; reseve port memory to this process |
|
mov eax, 45 ; reserve irq 4 |
mov ebx, 0 |
mov ecx, [comirq] |
int 0x40 |
|
mov eax, 44 ; setup irq table |
mov ebx, irqtable |
mov ecx, [comirq] |
int 0x40 |
|
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 |
int 0x40 |
|
mov ecx, [comport] ; interrupt enable register |
inc ecx |
mov bl, 0 ; No interruts enabled |
mov eax, 43 ; send data to device (modem) |
int 0x40 |
|
mov ecx, [comport] ; Divisor latch LSB |
mov bl, BAUDRATE ; set baud rate |
mov eax, 43 ; send data to device (modem) |
int 0x40 |
|
mov ecx, [comport] ; Data format register |
add ecx, 3 |
mov bl, 3 ; 8 data bits |
mov eax, 43 ; send data to device (modem) |
int 0x40 |
|
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) |
int 0x40 |
|
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) |
int 0x40 |
|
mov ecx, [comirq] |
add ecx, 16 |
mov ebx, 1 |
shl ebx, cl |
add ebx, 111b |
mov eax,40 ; enable irq 4 data |
int 0x40 |
|
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 |
int 0x40 |
; 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,0x03224466 ; color of work area RRGGBB |
mov esi,0x00334455 ; color of grab bar RRGGBB |
mov edi,0x00ddeeff ; color of frames RRGGBB |
int 0x40 |
; WINDOW LABEL |
mov eax, 4 ; function 4 : write text to window |
mov ebx, 8*65536+8 ; [x start] *65536 + [y start] |
mov ecx, 0x00ffffff ; color of text RRGGBB |
mov edx, labelt ; pointer to text beginning |
mov esi, labellen-labelt ; text length |
int 0x40 |
; 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 |
int 0x40 |
|
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 |
int 0x40 |
; 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 |
int 0x40 |
|
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 |
int 0x40 |
|
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 |
int 0x40 |
|
; Draw IP address |
mov edx, 10*65536+60 |
mov esi, 0x00FFFFFF |
mov ebx, 0x00030000 |
movzx ecx, byte [addr1] |
mov eax, 47 |
int 0x40 |
mov edx, 31*65536+60 |
mov esi, 0x00FFFFFF |
mov ebx, 0x00030000 |
movzx ecx, byte [addr2] |
mov eax, 47 |
int 0x40 |
mov edx, 52*65536+60 |
mov esi, 0x00FFFFFF |
mov ebx, 0x00030000 |
movzx ecx, byte [addr3] |
mov eax, 47 |
int 0x40 |
mov edx, 73*65536+60 |
mov esi, 0x00FFFFFF |
mov ebx, 0x00030000 |
movzx ecx, byte [addr4] |
mov eax, 47 |
int 0x40 |
|
; Status byte |
mov edx, 100*65536+60 |
mov esi, 0x00FFFFFF |
mov ebx, 0x00010000 |
movzx ecx, byte [state] |
mov eax, 47 |
int 0x40 |
|
; 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 |
int 0x40 |
|
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 |
int 0x40 |
|
call draw_window_limited |
|
mov eax, 12 ; end of redraw |
mov ebx, 2 |
int 0x40 |
|
ret |
|
|
|
draw_window_limited: |
mov eax,13 |
mov ebx,80*65536+10*6 |
mov ecx,80*65536+10 |
mov edx,0x03224466 |
int 0x40 |
mov eax,13 |
mov ebx,80*65536+10*6 |
mov ecx,100*65536+10 |
mov edx,0x03224466 |
int 0x40 |
|
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] |
int 0x40 |
|
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] |
int 0x40 |
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 |
int 0x40 ; 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 |
int 0x40 ; 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 |
int 0x40 |
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] |
int 0x40 |
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 |
int 0x40 ; 10ms delay |
pop edi |
|
; send the character |
pop eax |
mov bl, [edi + eax] |
|
mov ecx, [comport] |
inc eax |
push eax |
mov eax, 43 |
int 0x40 |
|
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 |
int 0x40 |
and bl, 0x40 |
cmp bl, 0 |
jz wait_txd2t ; loop until free |
|
pop ebx |
|
|
; send the character |
|
mov ecx, 0x2f8 |
mov eax, 43 |
int 0x40 |
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 |
int 0x40 |
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 |
labelt db 'PPP Dialer' |
labellen: |
|
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 |
|
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |