Subversion Repositories Kolibri OS

;

; 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