WebSVN – Kolibri OS – Diff – /programs/network/dnsr/trunk/dnsr.asm


;
;    DNS Domain name -> IP lookup
;
;    Compile with FASM for Menuet
;
 
 
; If you like, you camd change the DNS server default by changing the
; IP address in the dnsServer string.
 
 
; Enabling debugging puts the received response to the
; debug board
DEBUGGING_ENABLED	    equ     1
DEBUGGING_DISABLED	    equ     0
DEBUGGING_STATE 	    equ     DEBUGGING_DISABLED
 
 
use32
 org	0x0
 db	'MENUET01'    ; header
 dd	0x01	      ; header version
 dd	START	      ; 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'
 
START:					    ; start of execution
    mov     eax,40			    ; Report events
    mov     ebx,10000111b		    ; Stack 8 + defaults
    int     0x40
 
    mov     dword [prompt], p1
    mov     dword [promptlen], p1len - p1   ; 'waiting for command'
 
red:
    call    draw_window 		    ; at first, draw the window
 
still:
    mov     eax,10			    ; wait here for event
    mcall
 
    cmp     eax,1			    ; redraw request ?
    jz	    red
    cmp     eax,2			    ; key in buffer ?
    jz	    key
    cmp     eax,3			    ; button in buffer ?
    jz	    button
 
    jmp     still
key:				; Keys are not valid at this part of the
    mov     eax,2		; loop. Just read it and ignore
    mcall
    jmp     still
 
button: 			; button
    mov     eax,17		; get id
    mcall
 
    cmp     ah,1		; button id=1 ?
    jnz     noclose
 
    ; close socket before exiting
    mov     eax, 53
    mov     ebx, 1
    mov     ecx, [socketNum]
    mcall
 
    mov     eax,0xffffffff	; close this program
    mcall
 
noclose:
    cmp     ah,3		; Resolve address?
    jnz     noresolve
 
    mov     dword [prompt], p5
    mov     dword [promptlen], p5len - p5   ; display 'Resolving'
    call    draw_window
 
    call    translateData	; Convert domain & DNS IP address
 
    call    resolveDomain
 
    jmp     still
 
 
noresolve:
    cmp     ah,4
    jz	    f1			; Enter domain name
    cmp     ah,5
    jz	    f2			; enter DNS Server IP
    jmp     still
 
 
f1:
    mov     [addr],dword query
    mov     [ya],dword 35
    jmp     rk
 
f2:
    mov     [addr],dword dnsServer
    mov     [ya],dword 35+16
 
rk:
    mov     ecx,26
    mov     edi,[addr]
    mov     al,' '
    rep     stosb
 
    call    print_text
 
    mov     edi,[addr]
 
f11:
    mov     eax,10
    mcall
    cmp     eax,2
    jz	    fbu
    jmp     still
 
fbu:
    mov     eax,2
    mcall  ; get key
    shr     eax,8
    cmp     eax,8
    jnz     nobs
    cmp     edi,[addr]
    jz	    f11
    sub     edi,1
    mov     [edi],byte ' '
    call    print_text
    jmp     f11
 
nobs:
    cmp     eax,dword 31
    jbe     f11
    cmp     eax,dword 95
    jb	    keyok
    sub     eax,32
 
keyok:
    mov     [edi],al
 
    call    print_text
 
    add     edi,1
    mov     esi,[addr]
    add     esi,26
    cmp     esi,edi
    jnz     f11
 
    jmp  still
 
 
 
print_text:
    mov     eax,13
    mov     ebx,103*65536+26*6
    mov     ecx,[ya]
    shl     ecx,16
    mov     cx,8
    mov     edx,0x224466
    mcall
 
    mov     eax,4
    mov     ebx,103*65536
    add     ebx,[ya]
    mov     ecx,0xffffff
    mov     edx,[addr]
    mov     esi,26
    mcall
 
    ret
 
 
 
;***************************************************************************
;   Function
;      translateData
;
;   Description
;      Coverts the domain name and DNS IP address typed in by the user into
;      a format suitable for the IP layer.
;
;    The ename, in query, is converted and stored in dnsMsg
;      The DNS ip, in dnsServer, is converted and stored in dnsIP
;
;***************************************************************************
translateData:
 
    ; first, get the IP address of the DNS server
    ; Then, build up the request string.
 
    xor     eax, eax
    mov     dh, 10
    mov     dl, al
    mov     [dnsIP], eax
 
    mov     esi, dnsServer
    mov     edi, dnsIP
 
    mov     ecx, 4
 
td003:
    lodsb
    sub     al, '0'
    add     dl, al
    lodsb
    cmp     al, '.'
    je	    ipNext
    cmp     al, ' '
    je	    ipNext
    mov     dh, al
    sub     dh, '0'
    mov     al, 10
    mul     dl
    add     al, dh
    mov     dl, al
    lodsb
    cmp     al, '.'
    je	    ipNext
    cmp     al, ' '
    je	    ipNext
    mov     dh, al
    sub     dh, '0'
    mov     al, 10
    mul     dl
    add     al, dh
    mov     dl, al
    lodsb
 
ipNext:
    mov     [edi], dl
    inc     edi
    mov     dl, 0
    loop    td003
 
    ; Build the request string
 
 
    mov     eax, 0x00010100
    mov     [dnsMsg], eax
    mov     eax, 0x00000100
    mov     [dnsMsg+4], eax
    mov     eax, 0x00000000
    mov     [dnsMsg+8], eax
 
    ; domain name goes in at dnsMsg+12
    mov     esi, dnsMsg + 12	    ; location of label length
    mov     edi, dnsMsg + 13	    ; label start
    mov     edx, query
    mov     ecx, 12		     ; total string length so far
 
td002:
    mov     [esi], byte 0
    inc     ecx
 
td0021:
    mov     al, [edx]
    cmp     al, ' '
    je	    td001		    ; we have finished the string translation
    cmp     al, '.'		    ; we have finished the label
    je	    td004
 
    inc     byte [esi]
    inc     ecx
    mov     [edi], al
    inc     edi
    inc     edx
    jmp     td0021
 
td004:
    mov     esi, edi
    inc     edi
    inc     edx
    jmp     td002
 
 
 
    ; write label len + label text
 
td001:
    mov     [edi], byte 0
    inc     ecx
    inc     edi
    mov     [edi], dword 0x01000100
    add     ecx, 4
 
    mov     [dnsMsgLen], ecx
 
    ret
 
 
 
 
 
;***************************************************************************
;   Function
;      resolveDomain
;
;   Description
;       Sends a question to the dns server
;       works out the IP address from the response from the DNS server
;
;***************************************************************************
resolveDomain:
    ; Get a free port number
 mov	 ecx, 1000  ; local port starting at 1000
getlp:
 inc	 ecx
 push ecx
 mov	 eax, 53
 mov	 ebx, 9
 mcall
 pop	 ecx
 cmp	 eax, 0   ; is this local port in use?
 jz  getlp	; yes - so try next
 
    ; First, open socket
    mov     eax, 53
    mov     ebx, 0
    mov     edx, 53    ; remote port - dns
    mov     esi, [dnsIP]
    mcall
 
    mov     [socketNum], eax
 
    ; write to socket ( request DNS lookup )
    mov     eax, 53
    mov     ebx, 4
    mov     ecx, [socketNum]
    mov     edx, [dnsMsgLen]
    mov     esi, dnsMsg
    mcall
 
    ; Setup the DNS response buffer
 
    mov     eax, dnsMsg
    mov     [dnsMsgLen], eax
 
    ; now, we wait for
    ; UI redraw
    ; UI close
    ; or data from remote
 
ctr001:
    mov     eax,10		   ; wait here for event
    mcall
 
    cmp     eax,1		   ; redraw request ?
    je	    ctr003
    cmp     eax,2		   ; key in buffer ?
    je	    ctr004
    cmp     eax,3		   ; button in buffer ?
    je	    ctr005
 
 
    ; Any data in the UDP receive buffer?
    mov     eax, 53
    mov     ebx, 2
    mov     ecx, [socketNum]
    mcall
 
    cmp     eax, 0
    je	    ctr001
 
    ; we have data - this will be the response
ctr002:
    mov     eax, 53
    mov     ebx, 3
    mov     ecx, [socketNum]
    mcall		 ; read byte - block (high byte)
 
    ; Store the data in the response buffer
    mov     eax, [dnsMsgLen]
    mov     [eax], bl
    inc     dword [dnsMsgLen]
 
 
if DEBUGGING_STATE = DEBUGGING_ENABLED
    call debug_print_rx_ip
end if
 
    mov     eax, 53
    mov     ebx, 2
    mov     ecx, [socketNum]
    mcall		 ; any more data?
 
    cmp     eax, 0
    jne     ctr002		; yes, so get it
 
    ; close socket
    mov     eax, 53
    mov     ebx, 1
    mov     ecx, [socketNum]
    mcall
 
    mov     [socketNum], dword 0xFFFF
 
    ; Now parse the message to get the host IP
    ; Man, this is complicated. It's described in
    ; RFC 1035
 
    ; 1) Validate that we have an answer with > 0 responses
    ; 2) Find the answer record with TYPE 0001 ( host IP )
    ; 3) Finally, copy the IP address to the display
    ; Note: The response is in dnsMsg
    ;       The end of the buffer is pointed to by [dnsMsgLen]
 
    ; Clear the IP address text
    mov     [hostIP], dword 0
 
    mov     esi, dnsMsg
 
    ; Is this a response to my question?
    mov     al, [esi+2]
    and     al, 0x80
    cmp     al, 0x80
    jne     ctr002a
 
    ; Were there any errors?
    mov     al, [esi+3]
    and     al, 0x0F
    cmp     al, 0x00
    jne     ctr002a
 
    ; Is there ( at least 1 ) answer?
    mov     ax, [esi+6]
    cmp     ax, 0x00
    je	    ctr002a
 
    ; Header validated. Scan through and get my answer
 
    add     esi, 12		; Skip to the question field
 
    ; Skip through the question field
    call    skipName
    add     esi, 4		; skip past the questions qtype, qclass
 
ctr002z:
    ; Now at the answer. There may be several answers,
    ; find the right one ( TYPE = 0x0001 )
    call    skipName
    mov     ax, [esi]
    cmp     ax, 0x0100		; Is this the IP address answer?
    jne     ctr002c
 
    ; Yes! Point esi to the first byte of the IP address
    add     esi, 10
 
    mov     eax, [esi]
    mov     [hostIP], eax
    jmp     ctr002a		; And exit...
 
 
ctr002c:			; Skip through the answer, move to the next
    add     esi, 8
    movzx   eax, byte [esi+1]
    mov     ah, [esi]
    add     esi, eax
    add     esi, 2
 
    ; Have we reached the end of the msg?
    ; This is an error condition, should not happen
    cmp     esi, [dnsMsgLen]
    jl	    ctr002z		; Check next answer
    jmp     ctr002a		; abort
 
 
ctr002a:
    mov     dword [prompt], p4	; Display IP address
    mov     dword [promptlen], p4len - p4
    call    draw_window
 
    jmp     ctr001
 
ctr003: 			; redraw
    call    draw_window
    jmp     ctr001
 
ctr004: 			; key
    mov     eax,2		; just read it and ignore
    mcall
    jmp     ctr001
 
ctr005: 			; button
    mov     eax,17		; get id
    mcall
 
    ; close socket
    mov     eax, 53
    mov     ebx, 1
    mov     ecx, [socketNum]
    mcall
 
    mov     [socketNum], dword 0xFFFF
    mov     [hostIP], dword 0
 
    mov     dword [prompt], p1
    mov     dword [promptlen], p1len - p1   ; 'waiting for command'
 
    call    draw_window 		    ; at first, draw the window
 
    ret
 
 
 
;***************************************************************************
;   Function
;      skipName
;
;   Description
;       Increment esi to the first byte past the name field
;       Names may use compressed labels. Normally do.
;       RFC 1035 page 30 gives details
;
;***************************************************************************
skipName:
    mov     al, [esi]
    cmp     al, 0
    je	    sn_exit
    and     al, 0xc0
    cmp     al, 0xc0
    je	    sn001
 
    movzx   eax, byte [esi]
    inc     eax
    add     esi, eax
    jmp     skipName
 
sn001:
    add     esi, 2			    ; A pointer is always at the end
    ret
 
sn_exit:
    inc     esi
    ret
 
 
;   *********************************************
;   *******  WINDOW DEFINITIONS AND DRAW ********
;   *********************************************
 
 
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+300	      ; [x start] *65536 + [x size]
    mov     ecx,100*65536+140	      ; [y start] *65536 + [y size]
    mov     edx,0x14224466	      ; color of work area RRGGBB
    mov     edi,title		      ; WINDOW LABEL;
    mcall
 
    mov     eax,8		      ; Resolve
    mov     ebx,20*65536+190
    mov     ecx,79*65536+15
    mov     edx,3
    mov     esi,0x557799
    mcall
 
    ;mov     eax,8
    mov     ebx,270*65536+10
    mov     ecx,34*65536+10
    inc     edx
    mcall
 
    ;mov     eax,8
    mov     ebx,270*65536+10
    mov     ecx,50*65536+10
    inc     edx
    mcall
 
    ; Copy the file name to the screen buffer
    ; file name is same length as IP address, to
    ; make the math easier later.
    cld
    mov     esi,query
    mov     edi,text+13
    mov     ecx,26
    rep     movsb
 
 
    ; copy the IP address to the screen buffer
    mov     esi,dnsServer
    mov     edi,text+40+13
    mov     ecx,26
    rep     movsb
 
    ; copy the prompt to the screen buffer
    mov     esi,[prompt]
    mov     edi,text+200
    mov     ecx,[promptlen]
    rep     movsb
 
    ; Re-draw the screen text
    cld
    mov     eax,4
    mov     ebx,25*65536+35	      ; draw info text with function 4
    mov     ecx,0xffffff
    mov     edx,text
    mov     esi,40
newline:
    mcall
    add     ebx,16
    add     edx,40
    cmp     [edx],byte 'x'
    jnz     newline
 
 
    ; Write the host IP, if we have one
    mov     eax, [hostIP]
    cmp     eax, 0
    je	    dw001
 
    ; We have an IP address... display it
    mov     edi,hostIP
    mov     edx,97*65536+115
    mov     esi,0x00ffffff
    mov     ebx,3*65536
 
ipdisplay:
    mov     eax,47
    movzx   ecx,byte [edi]
    mcall
    add     edx,6*4*65536
    inc     edi
    cmp     edi,hostIP+4
    jb	    ipdisplay
 
dw001:
    mov     eax,12		      ; function 12:tell os about windowdraw
    mov     ebx,2		      ; 2, end of draw
    mcall
 
    ret
 
 
if DEBUGGING_STATE = DEBUGGING_ENABLED
;****************************************************************************
;    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:
    mov     eax,63
    mov     ebx, 1
    push    esi
    mcall
 
    inc   word [ind]
    mov  ax, [ind]
    and ax, 0x1f
    cmp  ax, 0
    jne  ds1
 
    mov   cl, 13
    mov     eax,63
    mov     ebx, 1
    mcall
    mov   cl, 10
    mov     eax,63
    mov     ebx, 1
    mcall
 
 
ds1:
    pop     esi
    inc     esi
    jmp     debug_print_string
 
 
ind: dw 0
; 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_STR		    db	'xx',0
 
 
debug_print_rx_ip:
    pusha
    mov     edi, IP_STR
 
    xor     eax, eax
    mov     al, bl
    shr     al, 4
    mov     ah, [eax + hexchars]
    mov     [edi], ah
    inc     edi
 
    xor     eax, eax
    mov     al, bl
    and     al, 0x0f
    mov     ah, [eax + hexchars]
    mov     [edi], ah
    mov     esi, IP_STR
 
    call    debug_print_string
    popa
    ret
end if
 
 
; DATA AREA
 
addr		dd  0x0
ya		dd  0x0
 
text:
 
    if lang eq ru
    db '¬ï å®áâ   : xxxxxxxxxxxxxxx            '
    db 'DNS á¥à¢¥à : xxx.xxx.xxx.xxx            '
    db '                                        '
    db '       ®«ãç¨âì  ¤à¥á                   '
    db '                                        '
    db '                                        '
    db 'x <- END MARKER, DONT DELETE            '
 
    else
    db 'Host name  : xxxxxxxxxxxxxxx            '
    db 'DNS server : xxx.xxx.xxx.xxx            '
    db '                                        '
    db '     RESOLVE ADDRESS                    '
    db '                                        '
    db '                                        '
    db 'x <- END MARKER, DONT DELETE            '
    end if
 
if lang eq ru
title	 db   'DNS «¨¥­â',0
 
else
title	 db   'DNS Client',0
end if
 
 
prompt: dd 0
promptlen: dd 0
 
 
if lang eq ru
p1:		db '¤ã ª®¬ ­¤ë                '
p1len:
 
 
else
p1:		db 'Waiting for Command        '
p1len:
end if
 
p4:		db 'IP Address:    .   .   .   '
p4len:
 
p5:		db 'Resolving...               '
p5len:
 
 
dnsServer	db  '194.145.128.1              ' ; iolfree.ie DNS
query		db  'WWW.MENUETOS.NET           '
 
hostIP: 	dd 0
dnsIP:		dd 0
dnsMsgLen:	dd 0
socketNum:	dd 0xFFFF
dnsMsg:
I_END:

Rev 551	Rev 993
1	;	1	;
2	; DNS Domain name -> IP lookup	2	; DNS Domain name -> IP lookup
3	;	3	;
4	; Compile with FASM for Menuet	4	; Compile with FASM for Menuet
5	;	5	;
6		6
7		7
8	; If you like, you camd change the DNS server default by changing the	8	; If you like, you camd change the DNS server default by changing the
9	; IP address in the dnsServer string.	9	; IP address in the dnsServer string.
10		10
11		11
12	; Enabling debugging puts the received response to the	12	; Enabling debugging puts the received response to the
13	; debug board	13	; debug board
14	DEBUGGING_ENABLED equ 1	14	DEBUGGING_ENABLED equ 1
15	DEBUGGING_DISABLED equ 0	15	DEBUGGING_DISABLED equ 0
16	DEBUGGING_STATE equ DEBUGGING_DISABLED	16	DEBUGGING_STATE equ DEBUGGING_DISABLED
17		17
18		18
19	use32	19	use32
20	org 0x0	20	org 0x0
21	db 'MENUET01' ; header	21	db 'MENUET01' ; header
22	dd 0x01 ; header version	22	dd 0x01 ; header version
23	dd START ; entry point	23	dd START ; entry point
24	dd I_END ; image size	24	dd I_END ; image size
25	dd I_END+0x10000 ; required memory	25	dd I_END+0x10000 ; required memory
26	dd I_END+0x10000 ; esp	26	dd I_END+0x10000 ; esp
27	dd 0x0 , 0x0 ; I_Param , I_Path	27	dd 0x0 , 0x0 ; I_Param , I_Path
28		28
29	include 'lang.inc'	29	include 'lang.inc'
30	include '..\..\..\macros.inc'	30	include 'macros.inc'
31		31
32	START: ; start of execution	32	START: ; start of execution
33	mov eax,40 ; Report events	33	mov eax,40 ; Report events
34	mov ebx,10000111b ; Stack 8 + defaults	34	mov ebx,10000111b ; Stack 8 + defaults
35	int 0x40	35	int 0x40
36		36
37	mov dword [prompt], p1	37	mov dword [prompt], p1
38	mov dword [promptlen], p1len - p1 ; 'waiting for command'	38	mov dword [promptlen], p1len - p1 ; 'waiting for command'
39		39
40	red:	40	red:
41	call draw_window ; at first, draw the window	41	call draw_window ; at first, draw the window
42		42
43	still:	43	still:
44	mov eax,10 ; wait here for event	44	mov eax,10 ; wait here for event
45	mcall	45	mcall
46		46
47	cmp eax,1 ; redraw request ?	47	cmp eax,1 ; redraw request ?
48	jz red	48	jz red
49	cmp eax,2 ; key in buffer ?	49	cmp eax,2 ; key in buffer ?
50	jz key	50	jz key
51	cmp eax,3 ; button in buffer ?	51	cmp eax,3 ; button in buffer ?
52	jz button	52	jz button
53		53
54	jmp still	54	jmp still
55	key: ; Keys are not valid at this part of the	55	key: ; Keys are not valid at this part of the
56	mov eax,2 ; loop. Just read it and ignore	56	mov eax,2 ; loop. Just read it and ignore
57	mcall	57	mcall
58	jmp still	58	jmp still
59		59
60	button: ; button	60	button: ; button
61	mov eax,17 ; get id	61	mov eax,17 ; get id
62	mcall	62	mcall
63		63
64	cmp ah,1 ; button id=1 ?	64	cmp ah,1 ; button id=1 ?
65	jnz noclose	65	jnz noclose
66		66
67	; close socket before exiting	67	; close socket before exiting
68	mov eax, 53	68	mov eax, 53
69	mov ebx, 1	69	mov ebx, 1
70	mov ecx, [socketNum]	70	mov ecx, [socketNum]
71	mcall	71	mcall
72		72
73	mov eax,0xffffffff ; close this program	73	mov eax,0xffffffff ; close this program
74	mcall	74	mcall
75		75
76	noclose:	76	noclose:
77	cmp ah,3 ; Resolve address?	77	cmp ah,3 ; Resolve address?
78	jnz noresolve	78	jnz noresolve
79		79
80	mov dword [prompt], p5	80	mov dword [prompt], p5
81	mov dword [promptlen], p5len - p5 ; display 'Resolving'	81	mov dword [promptlen], p5len - p5 ; display 'Resolving'
82	call draw_window	82	call draw_window
83		83
84	call translateData ; Convert domain & DNS IP address	84	call translateData ; Convert domain & DNS IP address
85		85
86	call resolveDomain	86	call resolveDomain
87		87
88	jmp still	88	jmp still
89		89
90		90
91	noresolve:	91	noresolve:
92	cmp ah,4	92	cmp ah,4
93	jz f1 ; Enter domain name	93	jz f1 ; Enter domain name
94	cmp ah,5	94	cmp ah,5
95	jz f2 ; enter DNS Server IP	95	jz f2 ; enter DNS Server IP
96	jmp still	96	jmp still
97		97
98		98
99	f1:	99	f1:
100	mov [addr],dword query	100	mov [addr],dword query
101	mov [ya],dword 35	101	mov [ya],dword 35
102	jmp rk	102	jmp rk
103		103
104	f2:	104	f2:
105	mov [addr],dword dnsServer	105	mov [addr],dword dnsServer
106	mov [ya],dword 35+16	106	mov [ya],dword 35+16
107		107
108	rk:	108	rk:
109	mov ecx,26	109	mov ecx,26
110	mov edi,[addr]	110	mov edi,[addr]
111	mov al,' '	111	mov al,' '
112	rep stosb	112	rep stosb
113		113
114	call print_text	114	call print_text
115		115
116	mov edi,[addr]	116	mov edi,[addr]
117		117
118	f11:	118	f11:
119	mov eax,10	119	mov eax,10
120	mcall	120	mcall
121	cmp eax,2	121	cmp eax,2
122	jz fbu	122	jz fbu
123	jmp still	123	jmp still
124		124
125	fbu:	125	fbu:
126	mov eax,2	126	mov eax,2
127	mcall ; get key	127	mcall ; get key
128	shr eax,8	128	shr eax,8
129	cmp eax,8	129	cmp eax,8
130	jnz nobs	130	jnz nobs
131	cmp edi,[addr]	131	cmp edi,[addr]
132	jz f11	132	jz f11
133	sub edi,1	133	sub edi,1
134	mov [edi],byte ' '	134	mov [edi],byte ' '
135	call print_text	135	call print_text
136	jmp f11	136	jmp f11
137		137
138	nobs:	138	nobs:
139	cmp eax,dword 31	139	cmp eax,dword 31
140	jbe f11	140	jbe f11
141	cmp eax,dword 95	141	cmp eax,dword 95
142	jb keyok	142	jb keyok
143	sub eax,32	143	sub eax,32
144		144
145	keyok:	145	keyok:
146	mov [edi],al	146	mov [edi],al
147		147
148	call print_text	148	call print_text
149		149
150	add edi,1	150	add edi,1
151	mov esi,[addr]	151	mov esi,[addr]
152	add esi,26	152	add esi,26
153	cmp esi,edi	153	cmp esi,edi
154	jnz f11	154	jnz f11
155		155
156	jmp still	156	jmp still
157		157
158		158
159		159
160	print_text:	160	print_text:
161	mov eax,13	161	mov eax,13
162	mov ebx,10365536+266	162	mov ebx,10365536+266
163	mov ecx,[ya]	163	mov ecx,[ya]
164	shl ecx,16	164	shl ecx,16
165	mov cx,8	165	mov cx,8
166	mov edx,0x224466	166	mov edx,0x224466
167	mcall	167	mcall
168		168
169	mov eax,4	169	mov eax,4
170	mov ebx,103*65536	170	mov ebx,103*65536
171	add ebx,[ya]	171	add ebx,[ya]
172	mov ecx,0xffffff	172	mov ecx,0xffffff
173	mov edx,[addr]	173	mov edx,[addr]
174	mov esi,26	174	mov esi,26
175	mcall	175	mcall
176		176
177	ret	177	ret
178		178
179		179
180		180
181	;***************************************************************************	181	;***************************************************************************
182	; Function	182	; Function
183	; translateData	183	; translateData
184	;	184	;
185	; Description	185	; Description
186	; Coverts the domain name and DNS IP address typed in by the user into	186	; Coverts the domain name and DNS IP address typed in by the user into
187	; a format suitable for the IP layer.	187	; a format suitable for the IP layer.
188	;	188	;
189	; The ename, in query, is converted and stored in dnsMsg	189	; The ename, in query, is converted and stored in dnsMsg
190	; The DNS ip, in dnsServer, is converted and stored in dnsIP	190	; The DNS ip, in dnsServer, is converted and stored in dnsIP
191	;	191	;
192	;***************************************************************************	192	;***************************************************************************
193	translateData:	193	translateData:
194		194
195	; first, get the IP address of the DNS server	195	; first, get the IP address of the DNS server
196	; Then, build up the request string.	196	; Then, build up the request string.
197		197
198	xor eax, eax	198	xor eax, eax
199	mov dh, 10	199	mov dh, 10
200	mov dl, al	200	mov dl, al
201	mov [dnsIP], eax	201	mov [dnsIP], eax
202		202
203	mov esi, dnsServer	203	mov esi, dnsServer
204	mov edi, dnsIP	204	mov edi, dnsIP
205		205
206	mov ecx, 4	206	mov ecx, 4
207		207
208	td003:	208	td003:
209	lodsb	209	lodsb
210	sub al, '0'	210	sub al, '0'
211	add dl, al	211	add dl, al
212	lodsb	212	lodsb
213	cmp al, '.'	213	cmp al, '.'
214	je ipNext	214	je ipNext
215	cmp al, ' '	215	cmp al, ' '
216	je ipNext	216	je ipNext
217	mov dh, al	217	mov dh, al
218	sub dh, '0'	218	sub dh, '0'
219	mov al, 10	219	mov al, 10
220	mul dl	220	mul dl
221	add al, dh	221	add al, dh
222	mov dl, al	222	mov dl, al
223	lodsb	223	lodsb
224	cmp al, '.'	224	cmp al, '.'
225	je ipNext	225	je ipNext
226	cmp al, ' '	226	cmp al, ' '
227	je ipNext	227	je ipNext
228	mov dh, al	228	mov dh, al
229	sub dh, '0'	229	sub dh, '0'
230	mov al, 10	230	mov al, 10
231	mul dl	231	mul dl
232	add al, dh	232	add al, dh
233	mov dl, al	233	mov dl, al
234	lodsb	234	lodsb
235		235
236	ipNext:	236	ipNext:
237	mov [edi], dl	237	mov [edi], dl
238	inc edi	238	inc edi
239	mov dl, 0	239	mov dl, 0
240	loop td003	240	loop td003
241		241
242	; Build the request string	242	; Build the request string
243		243
244		244
245	mov eax, 0x00010100	245	mov eax, 0x00010100
246	mov [dnsMsg], eax	246	mov [dnsMsg], eax
247	mov eax, 0x00000100	247	mov eax, 0x00000100
248	mov [dnsMsg+4], eax	248	mov [dnsMsg+4], eax
249	mov eax, 0x00000000	249	mov eax, 0x00000000
250	mov [dnsMsg+8], eax	250	mov [dnsMsg+8], eax
251		251
252	; domain name goes in at dnsMsg+12	252	; domain name goes in at dnsMsg+12
253	mov esi, dnsMsg + 12 ; location of label length	253	mov esi, dnsMsg + 12 ; location of label length
254	mov edi, dnsMsg + 13 ; label start	254	mov edi, dnsMsg + 13 ; label start
255	mov edx, query	255	mov edx, query
256	mov ecx, 12 ; total string length so far	256	mov ecx, 12 ; total string length so far
257		257
258	td002:	258	td002:
259	mov [esi], byte 0	259	mov [esi], byte 0
260	inc ecx	260	inc ecx
261		261
262	td0021:	262	td0021:
263	mov al, [edx]	263	mov al, [edx]
264	cmp al, ' '	264	cmp al, ' '
265	je td001 ; we have finished the string translation	265	je td001 ; we have finished the string translation
266	cmp al, '.' ; we have finished the label	266	cmp al, '.' ; we have finished the label
267	je td004	267	je td004
268		268
269	inc byte [esi]	269	inc byte [esi]
270	inc ecx	270	inc ecx
271	mov [edi], al	271	mov [edi], al
272	inc edi	272	inc edi
273	inc edx	273	inc edx
274	jmp td0021	274	jmp td0021
275		275
276	td004:	276	td004:
277	mov esi, edi	277	mov esi, edi
278	inc edi	278	inc edi
279	inc edx	279	inc edx
280	jmp td002	280	jmp td002
281		281
282		282
283		283
284	; write label len + label text	284	; write label len + label text
285		285
286	td001:	286	td001:
287	mov [edi], byte 0	287	mov [edi], byte 0
288	inc ecx	288	inc ecx
289	inc edi	289	inc edi
290	mov [edi], dword 0x01000100	290	mov [edi], dword 0x01000100
291	add ecx, 4	291	add ecx, 4
292		292
293	mov [dnsMsgLen], ecx	293	mov [dnsMsgLen], ecx
294		294
295	ret	295	ret
296		296
297		297
298		298
299		299
300		300
301	;***************************************************************************	301	;***************************************************************************
302	; Function	302	; Function
303	; resolveDomain	303	; resolveDomain
304	;	304	;
305	; Description	305	; Description
306	; Sends a question to the dns server	306	; Sends a question to the dns server
307	; works out the IP address from the response from the DNS server	307	; works out the IP address from the response from the DNS server
308	;	308	;
309	;***************************************************************************	309	;***************************************************************************
310	resolveDomain:	310	resolveDomain:
311	; Get a free port number	311	; Get a free port number
312	mov ecx, 1000 ; local port starting at 1000	312	mov ecx, 1000 ; local port starting at 1000
313	getlp:	313	getlp:
314	inc ecx	314	inc ecx
315	push ecx	315	push ecx
316	mov eax, 53	316	mov eax, 53
317	mov ebx, 9	317	mov ebx, 9
318	mcall	318	mcall
319	pop ecx	319	pop ecx
320	cmp eax, 0 ; is this local port in use?	320	cmp eax, 0 ; is this local port in use?
321	jz getlp ; yes - so try next	321	jz getlp ; yes - so try next
322		322
323	; First, open socket	323	; First, open socket
324	mov eax, 53	324	mov eax, 53
325	mov ebx, 0	325	mov ebx, 0
326	mov edx, 53 ; remote port - dns	326	mov edx, 53 ; remote port - dns
327	mov esi, [dnsIP]	327	mov esi, [dnsIP]
328	mcall	328	mcall
329		329
330	mov [socketNum], eax	330	mov [socketNum], eax
331		331
332	; write to socket ( request DNS lookup )	332	; write to socket ( request DNS lookup )
333	mov eax, 53	333	mov eax, 53
334	mov ebx, 4	334	mov ebx, 4
335	mov ecx, [socketNum]	335	mov ecx, [socketNum]
336	mov edx, [dnsMsgLen]	336	mov edx, [dnsMsgLen]
337	mov esi, dnsMsg	337	mov esi, dnsMsg
338	mcall	338	mcall
339		339
340	; Setup the DNS response buffer	340	; Setup the DNS response buffer
341		341
342	mov eax, dnsMsg	342	mov eax, dnsMsg
343	mov [dnsMsgLen], eax	343	mov [dnsMsgLen], eax
344		344
345	; now, we wait for	345	; now, we wait for
346	; UI redraw	346	; UI redraw
347	; UI close	347	; UI close
348	; or data from remote	348	; or data from remote
349		349
350	ctr001:	350	ctr001:
351	mov eax,10 ; wait here for event	351	mov eax,10 ; wait here for event
352	mcall	352	mcall
353		353
354	cmp eax,1 ; redraw request ?	354	cmp eax,1 ; redraw request ?
355	je ctr003	355	je ctr003
356	cmp eax,2 ; key in buffer ?	356	cmp eax,2 ; key in buffer ?
357	je ctr004	357	je ctr004
358	cmp eax,3 ; button in buffer ?	358	cmp eax,3 ; button in buffer ?
359	je ctr005	359	je ctr005
360		360
361		361
362	; Any data in the UDP receive buffer?	362	; Any data in the UDP receive buffer?
363	mov eax, 53	363	mov eax, 53
364	mov ebx, 2	364	mov ebx, 2
365	mov ecx, [socketNum]	365	mov ecx, [socketNum]
366	mcall	366	mcall
367		367
368	cmp eax, 0	368	cmp eax, 0
369	je ctr001	369	je ctr001
370		370
371	; we have data - this will be the response	371	; we have data - this will be the response
372	ctr002:	372	ctr002:
373	mov eax, 53	373	mov eax, 53
374	mov ebx, 3	374	mov ebx, 3
375	mov ecx, [socketNum]	375	mov ecx, [socketNum]
376	mcall ; read byte - block (high byte)	376	mcall ; read byte - block (high byte)
377		377
378	; Store the data in the response buffer	378	; Store the data in the response buffer
379	mov eax, [dnsMsgLen]	379	mov eax, [dnsMsgLen]
380	mov [eax], bl	380	mov [eax], bl
381	inc dword [dnsMsgLen]	381	inc dword [dnsMsgLen]
382		382
383		383
384	if DEBUGGING_STATE = DEBUGGING_ENABLED	384	if DEBUGGING_STATE = DEBUGGING_ENABLED
385	call debug_print_rx_ip	385	call debug_print_rx_ip
386	end if	386	end if
387		387
388	mov eax, 53	388	mov eax, 53
389	mov ebx, 2	389	mov ebx, 2
390	mov ecx, [socketNum]	390	mov ecx, [socketNum]
391	mcall ; any more data?	391	mcall ; any more data?
392		392
393	cmp eax, 0	393	cmp eax, 0
394	jne ctr002 ; yes, so get it	394	jne ctr002 ; yes, so get it
395		395
396	; close socket	396	; close socket
397	mov eax, 53	397	mov eax, 53
398	mov ebx, 1	398	mov ebx, 1
399	mov ecx, [socketNum]	399	mov ecx, [socketNum]
400	mcall	400	mcall
401		401
402	mov [socketNum], dword 0xFFFF	402	mov [socketNum], dword 0xFFFF
403		403
404	; Now parse the message to get the host IP	404	; Now parse the message to get the host IP
405	; Man, this is complicated. It's described in	405	; Man, this is complicated. It's described in
406	; RFC 1035	406	; RFC 1035
407		407
408	; 1) Validate that we have an answer with > 0 responses	408	; 1) Validate that we have an answer with > 0 responses
409	; 2) Find the answer record with TYPE 0001 ( host IP )	409	; 2) Find the answer record with TYPE 0001 ( host IP )
410	; 3) Finally, copy the IP address to the display	410	; 3) Finally, copy the IP address to the display
411	; Note: The response is in dnsMsg	411	; Note: The response is in dnsMsg
412	; The end of the buffer is pointed to by [dnsMsgLen]	412	; The end of the buffer is pointed to by [dnsMsgLen]
413		413
414	; Clear the IP address text	414	; Clear the IP address text
415	mov [hostIP], dword 0	415	mov [hostIP], dword 0
416		416
417	mov esi, dnsMsg	417	mov esi, dnsMsg
418		418
419	; Is this a response to my question?	419	; Is this a response to my question?
420	mov al, [esi+2]	420	mov al, [esi+2]
421	and al, 0x80	421	and al, 0x80
422	cmp al, 0x80	422	cmp al, 0x80
423	jne ctr002a	423	jne ctr002a
424		424
425	; Were there any errors?	425	; Were there any errors?
426	mov al, [esi+3]	426	mov al, [esi+3]
427	and al, 0x0F	427	and al, 0x0F
428	cmp al, 0x00	428	cmp al, 0x00
429	jne ctr002a	429	jne ctr002a
430		430
431	; Is there ( at least 1 ) answer?	431	; Is there ( at least 1 ) answer?
432	mov ax, [esi+6]	432	mov ax, [esi+6]
433	cmp ax, 0x00	433	cmp ax, 0x00
434	je ctr002a	434	je ctr002a
435		435
436	; Header validated. Scan through and get my answer	436	; Header validated. Scan through and get my answer
437		437
438	add esi, 12 ; Skip to the question field	438	add esi, 12 ; Skip to the question field
439		439
440	; Skip through the question field	440	; Skip through the question field
441	call skipName	441	call skipName
442	add esi, 4 ; skip past the questions qtype, qclass	442	add esi, 4 ; skip past the questions qtype, qclass
443		443
444	ctr002z:	444	ctr002z:
445	; Now at the answer. There may be several answers,	445	; Now at the answer. There may be several answers,
446	; find the right one ( TYPE = 0x0001 )	446	; find the right one ( TYPE = 0x0001 )
447	call skipName	447	call skipName
448	mov ax, [esi]	448	mov ax, [esi]
449	cmp ax, 0x0100 ; Is this the IP address answer?	449	cmp ax, 0x0100 ; Is this the IP address answer?
450	jne ctr002c	450	jne ctr002c
451		451
452	; Yes! Point esi to the first byte of the IP address	452	; Yes! Point esi to the first byte of the IP address
453	add esi, 10	453	add esi, 10
454		454
455	mov eax, [esi]	455	mov eax, [esi]
456	mov [hostIP], eax	456	mov [hostIP], eax
457	jmp ctr002a ; And exit...	457	jmp ctr002a ; And exit...
458		458
459		459
460	ctr002c: ; Skip through the answer, move to the next	460	ctr002c: ; Skip through the answer, move to the next
461	add esi, 8	461	add esi, 8
462	movzx eax, byte [esi+1]	462	movzx eax, byte [esi+1]
463	mov ah, [esi]	463	mov ah, [esi]
464	add esi, eax	464	add esi, eax
465	add esi, 2	465	add esi, 2
466		466
467	; Have we reached the end of the msg?	467	; Have we reached the end of the msg?
468	; This is an error condition, should not happen	468	; This is an error condition, should not happen
469	cmp esi, [dnsMsgLen]	469	cmp esi, [dnsMsgLen]
470	jl ctr002z ; Check next answer	470	jl ctr002z ; Check next answer
471	jmp ctr002a ; abort	471	jmp ctr002a ; abort
472		472
473		473
474	ctr002a:	474	ctr002a:
475	mov dword [prompt], p4 ; Display IP address	475	mov dword [prompt], p4 ; Display IP address
476	mov dword [promptlen], p4len - p4	476	mov dword [promptlen], p4len - p4
477	call draw_window	477	call draw_window
478		478
479	jmp ctr001	479	jmp ctr001
480		480
481	ctr003: ; redraw	481	ctr003: ; redraw
482	call draw_window	482	call draw_window
483	jmp ctr001	483	jmp ctr001
484		484
485	ctr004: ; key	485	ctr004: ; key
486	mov eax,2 ; just read it and ignore	486	mov eax,2 ; just read it and ignore
487	mcall	487	mcall
488	jmp ctr001	488	jmp ctr001
489		489
490	ctr005: ; button	490	ctr005: ; button
491	mov eax,17 ; get id	491	mov eax,17 ; get id
492	mcall	492	mcall
493		493
494	; close socket	494	; close socket
495	mov eax, 53	495	mov eax, 53
496	mov ebx, 1	496	mov ebx, 1
497	mov ecx, [socketNum]	497	mov ecx, [socketNum]
498	mcall	498	mcall
499		499
500	mov [socketNum], dword 0xFFFF	500	mov [socketNum], dword 0xFFFF

Subversion Repositories Kolibri OS

(root)/programs/network/dnsr/trunk/dnsr.asm – Rev 551 → 993