0,0 → 1,670 |
; |
; ETH.INC |
; |
; made by hidnplayr (hidnplayr@gmail.com) for KolibriOS and DEX4U |
; |
; The given code before every macro is only a simple example |
; |
; Change the OS value to DEX4U or MEOS |
; |
; HISTORY |
; |
; v1.0: 18 august 2006 |
; |
|
MEOS equ 1 ; Dont change these ! |
DEX4U equ 2 ; |
|
OS equ MEOS ; Change these instead ;) |
TIMEOUT equ 60 ; timeout for DNS request |
BUFFER equ 512 ; Buffer size for DNS |
|
macro int1 { |
if OS eq MEOS |
mcall |
else if OS eq DEX4U |
int 0x52 |
end if |
} |
|
macro int2 { |
if OS eq MEOS |
mcall |
else if OS eq DEX4U |
int 0x53 |
end if |
} |
|
macro mov arg1,arg2 { |
|
if arg1 eq arg2 |
else |
mov arg1,arg2 |
end if |
|
} |
|
; eth.get_IP eax |
; |
; gets the current IP that is defined in Stack (return in eax in this example) |
macro eth.get_IP IP { |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,1 |
int1 |
|
mov IP ,eax |
} |
|
; eth.get_GATEWAY eax |
; |
; gets the current GATEWAY that is defined in Stack (return in eax in this example) |
macro eth.get_GATEWAY GATEWAY { |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,9 |
int1 |
move GATEWAY ,eax |
} |
|
; eth.get_SUBNET eax |
; |
; gets the current SUBNET that is defined in Stack (return in eax in this example) |
macro eth.get_SUBNET SUBNET { |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,10 |
int1 |
mov SUBNET ,eax |
} |
|
; eth.get_DNS eax |
; |
; gets the current DNS that is defined in Stack (return in eax in this example) |
macro eth.get_DNS DNS { |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,13 |
int1 |
mov DNS ,eax |
} |
|
; eth.set_IP eax |
; |
; set a new IP in stack (input in eax in this example) |
macro eth.set_IP IP { |
mov ecx,IP |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,3 |
int1 |
} |
|
; eth.set_GATEWAY eax |
; |
; set a new GATEWAY in stack (input in eax in this example) |
macro eth.set_GATEWAY GATEWAY { |
mov ecx,GATEWAY |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,11 |
int1 |
} |
|
; eth.set_SUBNET eax |
; |
; set a new SUBNET in stack (input in eax in this example) |
macro eth.set_SUBNET SUBNET { |
mov ecx,SUBNET |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,12 |
int1 |
} |
|
; eth.set_DNS eax |
; |
; set a new DNS in stack (input in eax in this example) |
macro eth.set_DNS DNS { |
mov ecx,DNS |
if OS eq MEOS |
mov eax,52 |
end if |
mov ebx,14 |
int1 |
} |
|
; eth.open eax,80,ebx,[socket] |
; |
; open a socket on local port in eax to port 80 on server on ebx |
; the socketnumber will be returned in [socket] (dword) |
macro eth.open local,remote,ip,socket { |
mov ecx, local |
mov edx, remote |
mov esi, ip |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 0 |
int2 |
|
mov socket,eax |
} |
|
; eth.close [socket] |
; |
; closes socket on socketnumber [socket] |
macro eth.close socket { |
mov ecx, socket |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 1 |
int2 |
} |
|
; eth.poll [socket],eax |
; |
; polls [socket] for data |
; eax = 0 when there is data |
macro eth.poll socket,result { |
mov ecx, socket |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 2 |
int2 |
|
mov result, eax |
} |
|
; eth.read_byte [socket], bl |
; |
; reads a byte from the socket and returns in bl |
macro eth.read_byte socket, result { |
mov ecx, socket |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 3 |
int2 |
|
mov result,bl |
} |
|
; eth.write [socket],12,msg |
; msg db 'hello world!' |
; |
; send message msg to socket |
macro eth.write socket,length,msg { |
mov ecx, socket |
mov edx, length |
mov esi, msg |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 4 |
int2 |
} |
|
; eth.open_tcp 80,80,eax,0,[socket] |
; |
; opens a tcp socket on port 80 to port 80 on IP eax with passive open |
; returns socket number in eax |
macro eth.open_tcp local,remote,ip,passive,socket { |
|
pusha |
mov ecx, local |
mov edx, remote |
mov esi, ip |
mov edi, passive ; 0 = PASSIVE open |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 5 |
int2 |
popa |
|
mov socket,eax |
} |
|
; eth.socket_status [socket],eax |
; |
; returns socket status in eax |
macro eth.socket_status socket,result { |
mov ecx, socket |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 6 |
int2 |
|
mov result,eax |
} |
|
; eth.write_tcp [socket],12,msg |
; |
; msg db 'hello world!' |
; |
; send message to TCP socket |
macro eth.write_tcp socket,length,msg { |
mov ecx, socket |
mov edx, length |
mov esi, msg |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 7 |
int2 |
} |
|
; eth.close_tcp [socket] |
; |
; closes tcp socket [socket] |
macro eth.close_tcp socket { |
mov ecx, socket |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 8 |
int2 |
} |
|
; eth.check_port 165,eax |
; |
; checks if port 165 is used |
; return is 0 when port is free |
macro eth.check_port port,result { |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 9 |
mov ecx, port |
int2 |
|
mov result,eax |
} |
|
; eth.status eax |
; |
; returns socket status in eax |
macro eth.status status { |
if OS eq MEOS |
mov eax,53 |
end if |
mov ebx, 255 |
mov ecx, 6 |
int2 |
|
mov status,eax |
} |
|
; eth.search 165,edx |
; |
; searches a free local port starting from 166 (165 + 1 !) |
; returns in edx |
macro eth.search_port port,result { |
mov edx,port |
@@: |
inc edx |
eth.check_port edx,eax |
cmp eax,0 |
je @r |
mov result,edx |
} |
|
; eth.read_data [socket],buffer,512 |
; buffer rb 512 |
; socket dd ? |
; |
; reads data from socket into a buffer, stops when there is no more data or buffer is full. |
macro eth.read_data socket,dest,endptr,bufferl { |
|
mov eax, dest |
mov endptr, eax |
|
; we have data - this will be the response |
@@: |
mov eax,endptr |
cmp eax,bufferl |
jg @f |
|
mov eax, 53 |
mov ebx, 3 |
mov ecx, socket |
mcall ; read byte - block (high byte) |
|
; Store the data in the response buffer |
mov eax, endptr |
mov [eax], bl |
inc dword endptr |
|
mov eax, 53 |
mov ebx, 2 |
mov ecx, socket |
mcall ; any more data? |
|
cmp eax, 0 |
jne @r ; yes, so get it |
@@: |
|
} |
|
; eth.wait_for_data [socket],60,abort |
; eth.read_data .... |
; abort: |
; |
; Waits for data with timeout |
|
macro eth.wait_for_data socket,TIMEOUT,abort { |
|
mov edx,TIMEOUT |
|
@@: |
eth.poll socket,eax |
|
cmp eax,0 |
jne @f |
|
dec edx |
jz abort |
|
if OS eq MEOS |
mov eax,5 ; wait here for event |
mov ebx,100 |
mcall |
else if OS eq DEX4U |
mov ax,18 |
call [SetDelay] |
call dword[stack_handler] |
end if |
|
jmp @r |
@@: |
|
} |
|
|
; The function 'resolve' resolves the address in edx and puts the resulting IP in eax. |
; When the input is an IP-adress, the function will output this IP in eax. |
; If something goes wrong, the result in eax should be 0 |
; |
; example: |
; |
; resolve query1,IP |
; resolve '192.168.0.1',IP |
; resolve query2,IP |
; |
; query1 db 'www.google.com',0 |
; query2 db '49.78.84.45',0 |
; IP dd ? |
|
macro resolve query,result { |
|
if query eqtype 0 |
mov edx,query |
else |
local ..string, ..label |
jmp ..label |
..string db query,0 |
..label: |
mov edx,..string |
end if |
|
call __resolve |
|
mov result,eax |
|
} |
|
if used __resolve |
|
__resolve: |
|
;DEBUGF 1,'Resolving started\n' |
|
|
; This code validates if the query is an IP containing 4 numbers and 3 dots |
|
|
push edx ; push edx (query address) onto stack |
xor al, al ; make al (dot count) zero |
|
@@: |
cmp byte[edx],'0' ; check if this byte is a number, if not jump to no_IP |
jl no_IP ; |
cmp byte[edx],'9' ; |
jg no_IP ; |
|
inc edx ; the byte was a number, so lets check the next byte |
|
cmp byte[edx],0 ; is this byte zero? (have we reached end of query?) |
jz @f ; jump to next @@ then |
|
cmp byte[edx],'.' ; is this byte a dot? |
jne @r ; if not, jump to previous @@ |
|
inc al ; the byte was a dot so increment al(dot count) |
inc edx ; next byte |
jmp @r ; lets check for numbers again (jump to previous @@) |
|
@@: ; we reach this when end of query reached |
cmp al,3 ; check if there where 3 dots |
jnz no_IP ; if not, jump to no_IP (this is where the DNS will take over) |
|
; The following code should convert this IP into a dword and output it in eax |
|
pop esi ; edx (query address) was pushed onto stack and is now popped in esi |
|
xor edx, edx ; result |
xor eax, eax ; current character |
xor ebx, ebx ; current byte |
|
.outer_loop: |
shl edx, 8 |
add edx, ebx |
xor ebx, ebx |
.inner_loop: |
lodsb |
test eax, eax |
jz .finish |
cmp al, '.' |
jz .outer_loop |
sub eax, '0' |
imul ebx, 10 |
add ebx, eax |
jmp .inner_loop |
.finish: |
shl edx, 8 |
add edx, ebx |
|
bswap edx |
mov eax, edx |
|
;DEBUGF 1,'The query was an IP: %x.%x.%x.%x\n',dh,dl,al,ah |
|
ret |
|
|
no_IP: |
|
pop edx |
|
; The query is not an IP address, we will send the query to a DNS server and hope for answer ;) |
|
;DEBUGF 1,'The query is no ip, Building request string from:%u\n',edx |
|
; 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 ecx, 12 ; total string length so far |
|
td002: |
mov [esi], byte 0 |
inc ecx |
|
td0021: |
mov al, [edx] |
|
cmp al, 0 |
je td001 ; we have finished the string translation |
|
cmp al, '.' |
je td004 ; we have finished the label |
|
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 ; We'll need the length of the message when we send it |
; Now, lets send this and wait for an answer |
|
eth.search_port 1024,edx ; Find a free port starting from 1025 and store in edx |
eth.get_DNS esi ; Read DNS IP from stack into esi |
eth.open edx,53,esi,[socketNum] ; First, open socket |
; DEBUGF 1,'Socket opened: %u (port %u)\n',[socketNum],ecx |
eth.write [socketNum],[dnsMsgLen],dnsMsg ; Write to socket ( request DNS lookup ) |
; DEBUGF 1,'Data written, length:%u offset:%u\n',[dnsMsgLen],dnsMsg |
; DEBUGF 1,'Waiting for data: (timeout is %us)\n',TIMEOUT |
eth.wait_for_data [socketNum],TIMEOUT,no_data; Now, we wait for data from remote |
eth.read_data [socketNum],dnsMsg,[dnsMsgLen],dnsMsg+BUFFER ; Read the data into the buffer |
; DEBUGF 1,'Data received, offset:%u buffer size:%u length:%u\n',dnsMsg,BUFFER,esi-dnsMsg |
eth.close [socketNum] ; We're done, close the socket |
; DEBUGF 1,'Closed Socket\n' |
|
; 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] |
|
mov esi, dnsMsg |
|
mov al, [esi+2] ; Is this a response to my question? |
and al, 0x80 |
cmp al, 0x80 |
jne abort |
|
;DEBUGF 1,'It was a response to my question\n' |
|
mov al, [esi+3] ; Were there any errors? |
and al, 0x0F |
cmp al, 0x00 |
jne abort |
|
;DEBUGF 1,'There were no errorst\n' |
|
mov ax, [esi+6] ; Is there ( at least 1 ) answer? |
cmp ax, 0x00 |
je abort |
|
; Header validated. Scan through and get my answer |
add esi, 12 ; Skip to the question field |
call skipName ; Skip through the question field |
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 |
add esi, 10 ; Yes! Point eax to the first byte of the IP address |
mov eax,[esi] |
|
;DEBUGF 1,'Found First Byte of IP\n' |
|
ret |
|
|
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 |
|
cmp esi, [dnsMsgLen] ; Have we reached the end of the msg? This is an error condition, should not happen |
jl ctr002z ; Check next answer |
|
abort: |
;DEBUGF 1,'Something went wrong, aborting\n' |
xor eax,eax |
|
ret |
|
|
skipName: |
; Increment esi to the first byte past the name field |
; Names may use compressed labels. Normally do. |
; RFC 1035 page 30 gives details |
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 |
|
no_data: |
eth.close [socketNum] |
xor eax,eax |
|
ret |
|
dnsMsgLen: dd 0 |
socketNum: dd 0xFFFF |
|
if ~defined dnsMsg |
dnsMsg: rb BUFFER |
end if |
|
end if |
|
|
|
|