WebSVN – Kolibri OS – Diff – /kernel/branches/net/applications/zeroconf/zeroconf.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2010-2013. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  zeroconfig.asm - Zeroconfig service for KolibriOS              ;;
;;                                                                 ;;
;;  Written by hidnplayr@kolibrios.org                             ;;
;;    Some code contributed by Derpenguin                          ;;
;;                                                                 ;;
;;  DHCP code is based on that by Mike Hibbet                      ;;
;       (DHCP client for menuetos)                                 ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format binary as ""
 
use32
               org    0x0
 
               db     'MENUET01'            ; 8 byte id
               dd     0x01                  ; header version
               dd     START                 ; start of code
               dd     IM_END                ; size of image
               dd     (I_END+0x100)         ; memory for app
               dd     (I_END+0x100)         ; esp
               dd     0x0 , path            ; I_Param , I_Icon
 
; CONFIGURATION
 
TIMEOUT             equ 60                  ; in seconds
BUFFER              equ 1024                ; in bytes
__DEBUG__           equ 1                   ; enable/disable
__DEBUG_LEVEL__     equ 1                   ; 1 = all, 2 = errors
 
; CONFIGURATION FOR LINK-LOCAL
 
PROBE_WAIT          equ 1                   ; second  (initial random delay)
PROBE_MIN           equ 1                   ; second  (minimum delay till repeated probe)
PROBE_MAX           equ 2                   ; seconds (maximum delay till repeated probe)
PROBE_NUM           equ 3                   ;         (number of probe packets)
 
ANNOUNCE_NUM        equ 2                   ;         (number of announcement packets)
ANNOUNCE_INTERVAL   equ 2                   ; seconds (time between announcement packets)
ANNOUNCE_WAIT       equ 2                   ; seconds (delay before announcing)
 
MAX_CONFLICTS       equ 10                  ;         (max conflicts before rate limiting)
 
RATE_LIMIT_INTERVAL equ 60                  ; seconds (delay between successive attempts)
 
DEFEND_INTERVAL     equ 10                  ; seconds (min. wait between defensive ARPs)
 
 
include '../proc32.inc'
include '../macros.inc'
include '../debug-fdo.inc'
include '../network.inc'
include 'dhcp.inc'
include '../dll.inc'
 
 
Ip2dword:
    push    edx
 
    ; This code validates if the query is an IP containing 4 numbers and 3 dots
 
    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],':'
    jz      @f
 
    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
 
    ; The following code will convert this IP into a dword and output it in eax
    ; If there is also a port number specified, this will be returned in ebx, otherwise ebx is -1
 
    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               ; we want little endian order
 
    ret
 
no_IP:
    pop     edx
    xor     edx, edx
 
    ret
 
 
 
 
 
 
START:
        mcall   40, EVM_STACK2
 
        DEBUGF  1,">Zero-config service loaded\n"
 
  .wait:
        mcall   76, API_ETH + 4 ; get MAC of ethernet interface 0
        cmp     eax, -1
        jne     .start
 
        mcall   10
        jmp     .wait
 
  .start:
        mcall   40, EVM_STACK
        mov     word[MAC], bx
        mov     dword[MAC+2], eax
 
        DEBUGF  1,"->MAC: %x-%x-%x-%x-%x-%x\n",[MAC]:2,[MAC+1]:2,[MAC+2]:2,[MAC+3]:2,[MAC+4]:2,[MAC+5]:2
 
        mov     edi, path       ; Calculate the length of zero-terminated string
        xor     al, al
        mov     ecx, 1024
        repne   scasb
        dec     edi
 
        mov     esi, filename   ; append with .ini
        movsd
        movsb
 
        DEBUGF  1,"->Loading ini %s\n", path
 
        mcall   68, 11
 
        stdcall dll.Load,@IMPORT
        or      eax, eax
        jnz     try_dhcp
 
        invoke  ini.get_str, path, str_ipconfig, str_type, inibuf, 16, 0
 
        cmp     dword[inibuf], 'stat'
        jne     try_dhcp
 
        invoke  ini.get_str, path, str_ipconfig, str_ip, inibuf, 16, 0
        mov     edx, inibuf
        call    Ip2dword
        mcall   76, API_IPv4 + 3, edx
 
        invoke  ini.get_str, path, str_ipconfig, str_gateway, inibuf, 16, 0
        mov     edx, inibuf
        call    Ip2dword
        mcall   76, API_IPv4 + 9, edx
 
        invoke  ini.get_str, path, str_ipconfig, str_dns, inibuf, 16, 0
        mov     edx, inibuf
        call    Ip2dword
        mcall   76, API_IPv4 + 5, edx
 
        invoke  ini.get_str, path, str_ipconfig, str_subnet, inibuf, 16, 0
        mov     edx, inibuf
        call    Ip2dword
        mcall   76, API_IPv4 + 7, edx
 
 
        mcall   -1
 
 
try_dhcp:
 
        DEBUGF  1,"->Trying DHCP\n"
 
        mcall   75, 0, AF_INET4, SOCK_DGRAM, 0          ; open socket (parameters: domain, type, reserved)
        cmp     eax, -1
        je      error
        mov     [socketNum], eax
 
        DEBUGF  1,"->Socket %x opened\n", eax
 
        mcall   75, 2, [socketNum], sockaddr1, 18       ; bind socket to local port 68
        cmp     eax, -1
        je      error
 
        DEBUGF  1,"->Socket Bound to local port 68\n"
 
        mcall   75, 4, [socketNum], sockaddr2, 18       ; connect to 255.255.255.255 on port 67
        cmp     eax, -1
        je      error
 
        DEBUGF  1,"->Connected to 255.255.255.255 on port 67\n"
 
        mov     [dhcpMsgType], 0x01                     ; DHCP discover
        mov     [dhcpLease], esi                        ; esi is still -1 (-1 = forever)
 
        mcall   26, 9                                   ; Get system time
        imul    eax, 100
        mov     [currTime], eax
 
build_request:                                          ; Creates a DHCP request packet.
 
        DEBUGF  1,"->Building request\n"
 
        stdcall mem.Alloc, BUFFER
        mov     [dhcpMsg], eax
        test    eax, eax
        jz      dhcp_error
 
            ;;; todo: skip this bullcrap
 
        mov     edi, eax
        mov     ecx, BUFFER
        xor     eax, eax
        rep     stosb
 
            ;; todo: put this in a buffer instead of writing bytes and words!
 
        mov     edx, [dhcpMsg]
 
        ; Boot protocol legacy
        mov     [edx], byte 0x01                ; Boot request
        mov     [edx+1], byte 0x01              ; Ethernet
        mov     [edx+2], byte 0x06              ; Ethernet h/w len
        mov     [edx+4], dword 0x11223344       ; xid                 ;;;;;;;
        mov     eax, [currTime]
        mov     [edx+8], eax                    ; secs, our uptime
        mov     [edx+10], byte 0x80             ; broadcast flag set
        mov     eax, dword [MAC]                ; first 4 bytes of MAC
        mov     [edx+28],dword eax
        mov     ax, word [MAC+4]                ; last 2 bytes of MAC
        mov     [edx+32],word ax
 
        ; DHCP extension
        mov     [edx+236], dword 0x63538263     ; magic cookie
        mov     [edx+240], word 0x0135          ; option DHCP msg type
        mov     al, [dhcpMsgType]
        mov     [edx+240+2], al
        mov     [edx+240+3], word 0x0433        ; option Lease time = infinity
        mov     eax, [dhcpLease]
        mov     [edx+240+5], eax
        mov     [edx+240+9], word 0x0432        ; option requested IP address
        mov     eax, [dhcp.ip]
        mov     [edx+240+11], eax
        mov     [edx+240+15], word 0x0437       ; option request list
        mov     [edx+240+17], dword 0x0f060301
 
        cmp     [dhcpMsgType], byte 0x01        ; Check which msg we are sending
        jne     request_options
 
        mov     [edx+240+21], byte 0xff         ; "Discover" options
 
        mov     [dhcpMsgLen], dword 262         ; end of options marker
        jmp     send_dhcpmsg
 
request_options:
        mov     [edx+240+21], word 0x0436       ; server IP
        mov     eax, [dhcpServerIP]
        mov     [edx+240+23], eax
 
        mov     [edx+240+27], byte 0xff         ; end of options marker
 
        mov     [dhcpMsgLen], dword 268
 
send_dhcpmsg:
        mcall   75, 6, [socketNum], [dhcpMsg], [dhcpMsgLen]     ; write to socket ( send broadcast request )
 
        mov     eax, [dhcpMsg]                          ; Setup the DHCP buffer to receive response
        mov     [dhcpMsgLen], eax                       ; Used as a pointer to the data
 
        mcall   23, TIMEOUT*10                          ; wait for data
 
read_data:                                              ; we have data - this will be the response
        mcall   75, 7, [socketNum], [dhcpMsg], BUFFER   ; read data from socket
 
        DEBUGF  1,"->%d bytes received\n", eax
 
        cmp     eax, -1
        je      dhcp_error
 
        mov     [dhcpMsgLen], eax
 
; depending on which msg we sent, handle the response
; accordingly.
; If the response is to a dhcp discover, then:
;  1) If response is DHCP OFFER then
;  1.1) record server IP, lease time & IP address.
;  1.2) send a request packet
; If the response is to a dhcp request, then:
;  1) If the response is DHCP ACK then
;  1.1) extract the DNS & subnet fields. Set them in the stack
 
        cmp     [dhcpMsgType], 0x01             ; did we send a discover?
        je      discover
 
        cmp     [dhcpMsgType], 0x03             ; did we send a request?
        je      request
 
        call    dhcp_end                        ; we should never reach here ;)
        jmp     exit
 
discover:
        call    parse_response
 
        cmp     [dhcpMsgType], 0x02             ; Was the response an offer?
        je      send_request
 
        call    dhcp_end
        jmp     link_local
 
send_request:
        mov     [dhcpMsgType], 0x03             ; make it a request
        jmp     build_request
 
request:
        call    parse_response
 
 
        cmp     [dhcpMsgType], 0x05             ; Was the response an ACK? It should be
        jne     read_data                       ; NO - read next packets
 
        call    dhcp_end
 
        mcall   76, API_IPv4 + 3, [dhcp.ip]             ; ip
        mcall   76, API_IPv4 + 5, [dhcp.dns]            ; dns
        mcall   76, API_IPv4 + 7, [dhcp.subnet]         ; subnet
        mcall   76, API_IPv4 + 9, [dhcp.gateway]        ; gateway
 
        jmp     exit
 
dhcp_end:
        mcall   close, [socketNum]
        stdcall mem.Free, [dhcpMsg]
 
        ret
 
;***************************************************************************
;   Function
;      parseResponse
;
;   Description
;      extracts the fields ( client IP address and options ) from
;      a DHCP response
;      The values go into
;       dhcpMsgType,dhcpLease,dhcpClientIP,dhcpServerIP,
;       dhcpDNSIP, dhcpSubnet
;      The message is stored in dhcpMsg
;
;***************************************************************************
parse_response:
 
        DEBUGF  1,"Data received, parsing response\n"
        mov     edx, [dhcpMsg]
 
        push    dword [edx+16]
        pop     [dhcp.ip]
        DEBUGF  1,"Client: %u.%u.%u.%u\n", [edx+16]:1, [edx+17]:1, [edx+18]:1, [edx+19]:1
 
; TODO: check if there really are options
 
        mov     al, 240                         ; Point to first option
        movzx   ecx, al
 
  .next_option:
        add     edx, ecx
 
        mov     al, [edx]                       ; get message identifier
 
        cmp     al, 0xff                        ; End of options?
        je      .done
 
        cmp     al, 0
        je      .pad
 
; TODO: check if we still are inside the buffer
 
        inc     edx
        movzx   ecx, byte [edx]                 ; get data length
        inc     edx                             ; point to data
 
        cmp     al, dhcp_msg_type               ; Msg type is a single byte option
        je      .msgtype
 
        cmp     al, dhcp_dhcp_server_id
        je      .server
 
        cmp     al, dhcp_address_time
        je      .lease
 
        cmp     al, dhcp_subnet_mask
        je      .subnet
 
        cmp     al, dhcp_router
        je      .router
 
        cmp     al, dhcp_domain_server
        je      .dns
 
        DEBUGF  1,"Unsupported DHCP option: %u\n", al
 
        jmp     .next_option
 
  .pad:
        xor     ecx, ecx
        inc     ecx
        jmp     .next_option
 
  .msgtype:
        mov     al, [edx]
        mov     [dhcpMsgType], al
 
        DEBUGF  1,"DHCP Msg type: %u\n", al
        jmp     .next_option                    ; Get next option
 
  .server:
        mov     eax, [edx]
        mov     [dhcpServerIP], eax
        DEBUGF  1,"Server: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
        jmp     .next_option
 
  .lease:
        pusha
        mov     eax,[edx]
        bswap   eax
        mov     [dhcpLease],eax
        DEBUGF  1,"lease: %d\n",eax
        popa
        jmp     .next_option
 
  .subnet:
        push    dword [edx]
        pop     [dhcp.subnet]
        DEBUGF  1,"Subnet: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
        jmp     .next_option
 
  .router:
        push    dword [edx]
        pop     [dhcp.gateway]
        DEBUGF  1,"Gateway: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
        jmp     .next_option
 
  .dns:
        push    dword [edx]
        pop     [dhcp.dns]
        DEBUGF  1,"DNS: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
        jmp     .next_option
 
  .done:
        ret
 
 
 
 
dhcp_error:
 
        call    dhcp_end
 
link_local:
        call    random
 
        mov     cx, ax
        shl     ecx, 16
        mov     cx, 0xfea9                              ; IP 169.254.0.0 link local net, see RFC3927
        mcall   76, API_IPv4 + 3, ecx                   ; mask is 255.255.0.0
        DEBUGF  1,"Link Local IP assinged: 169.254.%u.%u\n", [generator+2]:1, [generator+3]:1
        mcall   76, API_IPv4 + 7, 0xffff
        mcall   76, API_IPv4 + 9, 0x0
        mcall   76, API_IPv4 + 5, 0x0
 
        mcall   5, PROBE_WAIT*100
 
        xor     esi, esi
   probe_loop:
        call    random                                  ; create a pseudo random number in eax (seeded by MAC)
 
        cmp     al, PROBE_MIN*100                       ; check if al is bigger then PROBE_MIN
        jae     @f                                      ; all ok
        add     al, (PROBE_MAX-PROBE_MIN)*100           ; al is too small
   @@:
 
        cmp     al, PROBE_MAX*100
        jbe     @f
        sub     al, (PROBE_MAX-PROBE_MIN)*100
   @@:
 
        movzx   ebx,al
        DEBUGF  1,"Waiting %u0ms\n",ebx
        mcall   5
 
        DEBUGF  1,"Sending Probe\n"
        mcall   76, API_ARP + 6
        inc     esi
 
        cmp     esi, PROBE_NUM
        jb      probe_loop
 
; now we wait further ANNOUNCE_WAIT seconds and send ANNOUNCE_NUM ARP announces. If any other host has assingned
; IP within this time, we should create another adress, that have to be done later
 
        DEBUGF  1,"Waiting %us\n", ANNOUNCE_WAIT
        mcall   5, ANNOUNCE_WAIT*100
        xor   esi, esi
   announce_loop:
 
        DEBUGF  1,"Sending Announce\n"
        mcall   76, API_ARP + 6
 
        inc     esi
        cmp     esi,ANNOUNCE_NUM
        je      @f
 
        DEBUGF  1,"Waiting %us\n", ANNOUNCE_INTERVAL
        mcall   5, ANNOUNCE_INTERVAL*100
        jmp     announce_loop
   @@:
 
 
error:
        DEBUGF  1,"Socket error\n"
exit:   ; we should, instead of closing, detect ARP conflicts and detect if cable keeps connected ;)
        mcall   -1
 
 
random:  ; Pseudo random actually
 
        mov     eax, [generator]
        add     eax, -43ab45b5h
        ror     eax, 1
        bswap   eax
        xor     eax, dword[MAC]
        ror     eax, 1
        xor     eax, dword[MAC+2]
        mov     [generator], eax
 
        ret
 
; DATA AREA
 
align 16
@IMPORT:
 
library \
        libini,'libini.obj'
 
import  libini, \
        ini.get_str,'ini_get_str'
 
include_debug_strings
 
filename        db '.ini', 0
str_ip          db 'ip', 0
str_subnet      db 'subnet', 0
str_gateway     db 'gateway', 0
str_dns         db 'dns', 0
str_ipconfig    db 'ipconfig', 0
str_type        db 'type', 0
 
 
sockaddr1:
 
        dw AF_INET4
        dw 68 shl 8     ; local port
        dd 0            ; local IP
 
        rb 10
 
 
sockaddr2:
 
        dw AF_INET4
        dw 67 shl 8     ; destination port
        dd -1           ; destination IP
 
        rb 10
 
 
IM_END:
 
inibuf          rb 16
 
dhcpMsgType     db  ?
dhcpLease       dd  ?
dhcpServerIP    dd  ?
 
dhcp:
.ip             dd  ?
.subnet         dd  ?
.dns            dd  ?
.gateway        dd  ?
 
 
dhcpMsgLen      dd  ?
socketNum       dd  ?
 
MAC             dp  ?
 
currTime        dd  ?
generator       dd  ?
 
dhcpMsg         dd  ?
 
I_END_2:
 
path            rb  1024+5
 
                rb  65536
 
I_END:

Rev 3340	Rev 3361
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2010-2013. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2010-2013. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; zeroconfig.asm - Zeroconfig service for KolibriOS ;;	6	;; zeroconfig.asm - Zeroconfig service for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by hidnplayr@kolibrios.org ;;	8	;; Written by hidnplayr@kolibrios.org ;;
9	;; Some code contributed by Derpenguin ;;	9	;; Some code contributed by Derpenguin ;;
10	;; ;;	10	;; ;;
11	;; DHCP code is based on that by Mike Hibbet ;;	11	;; DHCP code is based on that by Mike Hibbet ;;
12	; (DHCP client for menuetos) ;;	12	; (DHCP client for menuetos) ;;
13	;; ;;	13	;; ;;
14	;; GNU GENERAL PUBLIC LICENSE ;;	14	;; GNU GENERAL PUBLIC LICENSE ;;
15	;; Version 2, June 1991 ;;	15	;; Version 2, June 1991 ;;
16	;; ;;	16	;; ;;
17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18		18
19	format binary as ""	19	format binary as ""
20		20
21	use32	21	use32
22	org 0x0	22	org 0x0
23		23
24	db 'MENUET01' ; 8 byte id	24	db 'MENUET01' ; 8 byte id
25	dd 0x01 ; header version	25	dd 0x01 ; header version
26	dd START ; start of code	26	dd START ; start of code
27	dd IM_END ; size of image	27	dd IM_END ; size of image
28	dd (I_END+0x100) ; memory for app	28	dd (I_END+0x100) ; memory for app
29	dd (I_END+0x100) ; esp	29	dd (I_END+0x100) ; esp
30	dd 0x0 , path ; I_Param , I_Icon	30	dd 0x0 , path ; I_Param , I_Icon
31		31
32	; CONFIGURATION	32	; CONFIGURATION
33		33
34	TIMEOUT equ 60 ; in seconds	34	TIMEOUT equ 60 ; in seconds
35	BUFFER equ 1024 ; in bytes	35	BUFFER equ 1024 ; in bytes
36	__DEBUG__ equ 1 ; enable/disable	36	__DEBUG__ equ 1 ; enable/disable
37	__DEBUG_LEVEL__ equ 1 ; 1 = all, 2 = errors	37	__DEBUG_LEVEL__ equ 1 ; 1 = all, 2 = errors
38		38
39	; CONFIGURATION FOR LINK-LOCAL	39	; CONFIGURATION FOR LINK-LOCAL
40		40
41	PROBE_WAIT equ 1 ; second (initial random delay)	41	PROBE_WAIT equ 1 ; second (initial random delay)
42	PROBE_MIN equ 1 ; second (minimum delay till repeated probe)	42	PROBE_MIN equ 1 ; second (minimum delay till repeated probe)
43	PROBE_MAX equ 2 ; seconds (maximum delay till repeated probe)	43	PROBE_MAX equ 2 ; seconds (maximum delay till repeated probe)
44	PROBE_NUM equ 3 ; (number of probe packets)	44	PROBE_NUM equ 3 ; (number of probe packets)
45		45
46	ANNOUNCE_NUM equ 2 ; (number of announcement packets)	46	ANNOUNCE_NUM equ 2 ; (number of announcement packets)
47	ANNOUNCE_INTERVAL equ 2 ; seconds (time between announcement packets)	47	ANNOUNCE_INTERVAL equ 2 ; seconds (time between announcement packets)
48	ANNOUNCE_WAIT equ 2 ; seconds (delay before announcing)	48	ANNOUNCE_WAIT equ 2 ; seconds (delay before announcing)
49		49
50	MAX_CONFLICTS equ 10 ; (max conflicts before rate limiting)	50	MAX_CONFLICTS equ 10 ; (max conflicts before rate limiting)
51		51
52	RATE_LIMIT_INTERVAL equ 60 ; seconds (delay between successive attempts)	52	RATE_LIMIT_INTERVAL equ 60 ; seconds (delay between successive attempts)
53		53
54	DEFEND_INTERVAL equ 10 ; seconds (min. wait between defensive ARPs)	54	DEFEND_INTERVAL equ 10 ; seconds (min. wait between defensive ARPs)
55		55
56		56
57	include '../proc32.inc'	57	include '../proc32.inc'
58	include '../macros.inc'	58	include '../macros.inc'
59	include '../debug-fdo.inc'	59	include '../debug-fdo.inc'
60	include '../network.inc'	60	include '../network.inc'
61	include 'dhcp.inc'	61	include 'dhcp.inc'
62	include '../dll.inc'	62	include '../dll.inc'
63		63
64		64
65	Ip2dword:	65	Ip2dword:
66	push edx	66	push edx
67		67
68	; This code validates if the query is an IP containing 4 numbers and 3 dots	68	; This code validates if the query is an IP containing 4 numbers and 3 dots
69		69
70	xor al, al ; make al (dot count) zero	70	xor al, al ; make al (dot count) zero
71		71
72	@@:	72	@@:
73	cmp byte[edx],'0' ; check if this byte is a number, if not jump to no_IP	73	cmp byte[edx],'0' ; check if this byte is a number, if not jump to no_IP
74	jl no_IP ;	74	jl no_IP ;
75	cmp byte[edx],'9' ;	75	cmp byte[edx],'9' ;
76	jg no_IP ;	76	jg no_IP ;
77		77
78	inc edx ; the byte was a number, so lets check the next byte	78	inc edx ; the byte was a number, so lets check the next byte
79		79
80	cmp byte[edx],0 ; is this byte zero? (have we reached end of query?)	80	cmp byte[edx],0 ; is this byte zero? (have we reached end of query?)
81	jz @f ; jump to next @@ then	81	jz @f ; jump to next @@ then
82	cmp byte[edx],':'	82	cmp byte[edx],':'
83	jz @f	83	jz @f
84		84
85	cmp byte[edx],'.' ; is this byte a dot?	85	cmp byte[edx],'.' ; is this byte a dot?
86	jne @r ; if not, jump to previous @@	86	jne @r ; if not, jump to previous @@
87		87
88	inc al ; the byte was a dot so increment al(dot count)	88	inc al ; the byte was a dot so increment al(dot count)
89	inc edx ; next byte	89	inc edx ; next byte
90	jmp @r ; lets check for numbers again (jump to previous @@)	90	jmp @r ; lets check for numbers again (jump to previous @@)
91		91
92	@@: ; we reach this when end of query reached	92	@@: ; we reach this when end of query reached
93	cmp al,3 ; check if there where 3 dots	93	cmp al,3 ; check if there where 3 dots
94	jnz no_IP ; if not, jump to no_IP	94	jnz no_IP ; if not, jump to no_IP
95		95
96	; The following code will convert this IP into a dword and output it in eax	96	; The following code will convert this IP into a dword and output it in eax
97	; If there is also a port number specified, this will be returned in ebx, otherwise ebx is -1	97	; If there is also a port number specified, this will be returned in ebx, otherwise ebx is -1
98		98
99	pop esi ; edx (query address) was pushed onto stack and is now popped in esi	99	pop esi ; edx (query address) was pushed onto stack and is now popped in esi
100		100
101	xor edx, edx ; result	101	xor edx, edx ; result
102	xor eax, eax ; current character	102	xor eax, eax ; current character
103	xor ebx, ebx ; current byte	103	xor ebx, ebx ; current byte
104		104
105	.outer_loop:	105	.outer_loop:
106	shl edx, 8	106	shl edx, 8
107	add edx, ebx	107	add edx, ebx
108	xor ebx, ebx	108	xor ebx, ebx
109	.inner_loop:	109	.inner_loop:
110	lodsb	110	lodsb
111	test eax, eax	111	test eax, eax
112	jz .finish	112	jz .finish
113	cmp al, '.'	113	cmp al, '.'
114	jz .outer_loop	114	jz .outer_loop
115	sub eax, '0'	115	sub eax, '0'
116	imul ebx, 10	116	imul ebx, 10
117	add ebx, eax	117	add ebx, eax
118	jmp .inner_loop	118	jmp .inner_loop
119	.finish:	119	.finish:
120	shl edx, 8	120	shl edx, 8
121	add edx, ebx	121	add edx, ebx
122		122
123	bswap edx ; we want little endian order	123	bswap edx ; we want little endian order
124		124
125	ret	125	ret
126		126
127	no_IP:	127	no_IP:
128	pop edx	128	pop edx
129	xor edx, edx	129	xor edx, edx
130		130
131	ret	131	ret
132		132
133		133
134		134
135		135
136		136
137		137
138	START:	138	START:
139	mcall 40, EVM_STACK2	139	mcall 40, EVM_STACK2
140		140
141	DEBUGF 1,">Zero-config service loaded\n"	141	DEBUGF 1,">Zero-config service loaded\n"
142		142
143	.wait:	143	.wait:
144	mcall 76, API_ETH + 4 ; get MAC of ethernet interface 0	144	mcall 76, API_ETH + 4 ; get MAC of ethernet interface 0
145	cmp eax, -1	145	cmp eax, -1
146	jne .start	146	jne .start
147		147
148	mcall 10	148	mcall 10
149	jmp .wait	149	jmp .wait
150		150
151	.start:	151	.start:
152	mcall 40, EVM_STACK	152	mcall 40, EVM_STACK
153	mov word[MAC], bx	153	mov word[MAC], bx
154	mov dword[MAC+2], eax	154	mov dword[MAC+2], eax
155		155
156	DEBUGF 1,"->MAC: %x-%x-%x-%x-%x-%x\n",[MAC]:2,[MAC+1]:2,[MAC+2]:2,[MAC+3]:2,[MAC+4]:2,[MAC+5]:2	156	DEBUGF 1,"->MAC: %x-%x-%x-%x-%x-%x\n",[MAC]:2,[MAC+1]:2,[MAC+2]:2,[MAC+3]:2,[MAC+4]:2,[MAC+5]:2
157		157
158	mov edi, path ; Calculate the length of zero-terminated string	158	mov edi, path ; Calculate the length of zero-terminated string
159	xor al, al	159	xor al, al
160	mov ecx, 1024	160	mov ecx, 1024
161	repne scasb	161	repne scasb
162	dec edi	162	dec edi
163		163
164	mov esi, filename ; append with .ini	164	mov esi, filename ; append with .ini
165	movsd	165	movsd
166	movsb	166	movsb
167		167
168	DEBUGF 1,"->Loading ini %s\n", path	168	DEBUGF 1,"->Loading ini %s\n", path
169		169
170	mcall 68, 11	170	mcall 68, 11
171		171
172	stdcall dll.Load,@IMPORT	172	stdcall dll.Load,@IMPORT
173	or eax, eax	173	or eax, eax
174	jnz try_dhcp	174	jnz try_dhcp
175		175
176	invoke ini.get_str, path, str_ipconfig, str_type, inibuf, 16, 0	176	invoke ini.get_str, path, str_ipconfig, str_type, inibuf, 16, 0
177		177
178	cmp dword[inibuf], 'stat'	178	cmp dword[inibuf], 'stat'
179	jne try_dhcp	179	jne try_dhcp
180		180
181	invoke ini.get_str, path, str_ipconfig, str_ip, inibuf, 16, 0	181	invoke ini.get_str, path, str_ipconfig, str_ip, inibuf, 16, 0
182	mov edx, inibuf	182	mov edx, inibuf
183	call Ip2dword	183	call Ip2dword
184	mcall 76, API_IPv4 + 3, edx	184	mcall 76, API_IPv4 + 3, edx
185		185
186	invoke ini.get_str, path, str_ipconfig, str_gateway, inibuf, 16, 0	186	invoke ini.get_str, path, str_ipconfig, str_gateway, inibuf, 16, 0
187	mov edx, inibuf	187	mov edx, inibuf
188	call Ip2dword	188	call Ip2dword
189	mcall 76, API_IPv4 + 9, edx	189	mcall 76, API_IPv4 + 9, edx
190		190
191	invoke ini.get_str, path, str_ipconfig, str_dns, inibuf, 16, 0	191	invoke ini.get_str, path, str_ipconfig, str_dns, inibuf, 16, 0
192	mov edx, inibuf	192	mov edx, inibuf
193	call Ip2dword	193	call Ip2dword
194	mcall 76, API_IPv4 + 5, edx	194	mcall 76, API_IPv4 + 5, edx
195		195
196	invoke ini.get_str, path, str_ipconfig, str_subnet, inibuf, 16, 0	196	invoke ini.get_str, path, str_ipconfig, str_subnet, inibuf, 16, 0
197	mov edx, inibuf	197	mov edx, inibuf
198	call Ip2dword	198	call Ip2dword
199	mcall 76, API_IPv4 + 7, edx	199	mcall 76, API_IPv4 + 7, edx
200		200
201		201
202	mcall -1	202	mcall -1
203		203
204		204
205	try_dhcp:	205	try_dhcp:
206		206
207	DEBUGF 1,"->Trying DHCP\n"	207	DEBUGF 1,"->Trying DHCP\n"
208		208
209	mcall 75, 0, AF_INET4, SOCK_DGRAM, 0 ; open socket (parameters: domain, type, reserved)	209	mcall 75, 0, AF_INET4, SOCK_DGRAM, 0 ; open socket (parameters: domain, type, reserved)
210	cmp eax, -1	210	cmp eax, -1
211	je error	211	je error
212	mov [socketNum], eax	212	mov [socketNum], eax
213		213
214	DEBUGF 1,"->Socket %x opened\n", eax	214	DEBUGF 1,"->Socket %x opened\n", eax
215		215
216	mcall 75, 2, [socketNum], sockaddr1, 18 ; bind socket to local port 68	216	mcall 75, 2, [socketNum], sockaddr1, 18 ; bind socket to local port 68
217	cmp eax, -1	217	cmp eax, -1
218	je error	218	je error
219		219
220	DEBUGF 1,"->Socket Bound to local port 68\n"	220	DEBUGF 1,"->Socket Bound to local port 68\n"
221		221
222	mcall 75, 4, [socketNum], sockaddr2, 18 ; connect to 255.255.255.255 on port 67	222	mcall 75, 4, [socketNum], sockaddr2, 18 ; connect to 255.255.255.255 on port 67
223	cmp eax, -1	223	cmp eax, -1
224	je error	224	je error
225		225
226	DEBUGF 1,"->Connected to 255.255.255.255 on port 67\n"	226	DEBUGF 1,"->Connected to 255.255.255.255 on port 67\n"
227		227
228	mov [dhcpMsgType], 0x01 ; DHCP discover	228	mov [dhcpMsgType], 0x01 ; DHCP discover
229	mov [dhcpLease], esi ; esi is still -1 (-1 = forever)	229	mov [dhcpLease], esi ; esi is still -1 (-1 = forever)
230		230
231	mcall 26, 9 ; Get system time	231	mcall 26, 9 ; Get system time
232	imul eax, 100	232	imul eax, 100
233	mov [currTime], eax	233	mov [currTime], eax
234		234
235	build_request: ; Creates a DHCP request packet.	235	build_request: ; Creates a DHCP request packet.
236		236
237	DEBUGF 1,"->Building request\n"	237	DEBUGF 1,"->Building request\n"
238		238
239	stdcall mem.Alloc, BUFFER	239	stdcall mem.Alloc, BUFFER
240	mov [dhcpMsg], eax	240	mov [dhcpMsg], eax
241	test eax, eax	241	test eax, eax
242	jz apipa	242	jz dhcp_error
243		243
244	;;; todo: skip this bullcrap	244	;;; todo: skip this bullcrap
245		245
246	mov edi, eax	246	mov edi, eax
247	mov ecx, BUFFER	247	mov ecx, BUFFER
248	xor eax, eax	248	xor eax, eax
249	rep stosb	249	rep stosb
250		250
251	;; todo: put this in a buffer instead of writing bytes and words!	251	;; todo: put this in a buffer instead of writing bytes and words!
252		252
253	mov edx, [dhcpMsg]	253	mov edx, [dhcpMsg]
-		254
254		255	; Boot protocol legacy
255	mov [edx], byte 0x01 ; Boot request	256	mov [edx], byte 0x01 ; Boot request
256	mov [edx+1], byte 0x01 ; Ethernet	257	mov [edx+1], byte 0x01 ; Ethernet
257	mov [edx+2], byte 0x06 ; Ethernet h/w len	258	mov [edx+2], byte 0x06 ; Ethernet h/w len
258	mov [edx+4], dword 0x11223344 ; xid ;;;;;;;	259	mov [edx+4], dword 0x11223344 ; xid ;;;;;;;
259	mov eax, [currTime]	260	mov eax, [currTime]
260	mov [edx+8], eax ; secs, our uptime	261	mov [edx+8], eax ; secs, our uptime
261	mov [edx+10], byte 0x80 ; broadcast flag set	262	mov [edx+10], byte 0x80 ; broadcast flag set
262	mov eax, dword [MAC] ; first 4 bytes of MAC	263	mov eax, dword [MAC] ; first 4 bytes of MAC
263	mov [edx+28],dword eax	264	mov [edx+28],dword eax
264	mov ax, word [MAC+4] ; last 2 bytes of MAC	265	mov ax, word [MAC+4] ; last 2 bytes of MAC
265	mov [edx+32],word ax	266	mov [edx+32],word ax
-		267
-		268	; DHCP extension
266	mov [edx+236], dword 0x63538263 ; magic cookie	269	mov [edx+236], dword 0x63538263 ; magic cookie
267	mov [edx+240], word 0x0135 ; option DHCP msg type	270	mov [edx+240], word 0x0135 ; option DHCP msg type
268	mov al, [dhcpMsgType]	271	mov al, [dhcpMsgType]
269	mov [edx+240+2], al	272	mov [edx+240+2], al
270	mov [edx+240+3], word 0x0433 ; option Lease time = infinity	273	mov [edx+240+3], word 0x0433 ; option Lease time = infinity
271	mov eax, [dhcpLease]	274	mov eax, [dhcpLease]
272	mov [edx+240+5], eax	275	mov [edx+240+5], eax
273	mov [edx+240+9], word 0x0432 ; option requested IP address	276	mov [edx+240+9], word 0x0432 ; option requested IP address
274	mov eax, [dhcp.ip]	277	mov eax, [dhcp.ip]
275	mov [edx+240+11], eax	278	mov [edx+240+11], eax
276	mov [edx+240+15], word 0x0437 ; option request list	279	mov [edx+240+15], word 0x0437 ; option request list
277	mov [edx+240+17], dword 0x0f060301	280	mov [edx+240+17], dword 0x0f060301
278		281
279	cmp [dhcpMsgType], byte 0x01 ; Check which msg we are sending	282	cmp [dhcpMsgType], byte 0x01 ; Check which msg we are sending
280	jne request_options	283	jne request_options
281		284
282	mov [edx+240+21], byte 0xff ; "Discover" options	285	mov [edx+240+21], byte 0xff ; "Discover" options
283		286
284	mov [dhcpMsgLen], dword 262 ; end of options marker	287	mov [dhcpMsgLen], dword 262 ; end of options marker
285	jmp send_dhcpmsg	288	jmp send_dhcpmsg
286		289
287	request_options:	290	request_options:
288	mov [edx+240+21], word 0x0436 ; server IP	291	mov [edx+240+21], word 0x0436 ; server IP
289	mov eax, [dhcpServerIP]	292	mov eax, [dhcpServerIP]
290	mov [edx+240+23], eax	293	mov [edx+240+23], eax
291		294
292	mov [edx+240+27], byte 0xff ; end of options marker	295	mov [edx+240+27], byte 0xff ; end of options marker
293		296
294	mov [dhcpMsgLen], dword 268	297	mov [dhcpMsgLen], dword 268
295		298
296	send_dhcpmsg:	299	send_dhcpmsg:
297	mcall 75, 6, [socketNum], [dhcpMsg], [dhcpMsgLen] ; write to socket ( send broadcast request )	300	mcall 75, 6, [socketNum], [dhcpMsg], [dhcpMsgLen] ; write to socket ( send broadcast request )
298		301
299	mov eax, [dhcpMsg] ; Setup the DHCP buffer to receive response	302	mov eax, [dhcpMsg] ; Setup the DHCP buffer to receive response
300	mov [dhcpMsgLen], eax ; Used as a pointer to the data	303	mov [dhcpMsgLen], eax ; Used as a pointer to the data
301		304
302	mcall 23, TIMEOUT*10 ; wait for data	305	mcall 23, TIMEOUT*10 ; wait for data
303		306
304	read_data: ; we have data - this will be the response	307	read_data: ; we have data - this will be the response
305	mcall 75, 7, [socketNum], [dhcpMsg], BUFFER ; read data from socket	308	mcall 75, 7, [socketNum], [dhcpMsg], BUFFER ; read data from socket
306		309
307	DEBUGF 1,"->%d bytes received\n", eax	310	DEBUGF 1,"->%d bytes received\n", eax
308		311
309	cmp eax, -1	312	cmp eax, -1
310	je error	313	je dhcp_error
311		314
312	mov [dhcpMsgLen], eax	315	mov [dhcpMsgLen], eax
313		316
314	; depending on which msg we sent, handle the response	317	; depending on which msg we sent, handle the response
315	; accordingly.	318	; accordingly.
316	; If the response is to a dhcp discover, then:	319	; If the response is to a dhcp discover, then:
317	; 1) If response is DHCP OFFER then	320	; 1) If response is DHCP OFFER then
318	; 1.1) record server IP, lease time & IP address.	321	; 1.1) record server IP, lease time & IP address.
319	; 1.2) send a request packet	322	; 1.2) send a request packet
320	; If the response is to a dhcp request, then:	323	; If the response is to a dhcp request, then:
321	; 1) If the response is DHCP ACK then	324	; 1) If the response is DHCP ACK then
322	; 1.1) extract the DNS & subnet fields. Set them in the stack	325	; 1.1) extract the DNS & subnet fields. Set them in the stack
323		326
324	cmp [dhcpMsgType], 0x01 ; did we send a discover?	327	cmp [dhcpMsgType], 0x01 ; did we send a discover?
325	je discover	328	je discover
326		329
327	cmp [dhcpMsgType], 0x03 ; did we send a request?	330	cmp [dhcpMsgType], 0x03 ; did we send a request?
328	je request	331	je request
329		332
330	call dhcp_end ; we should never reach here ;)	333	call dhcp_end ; we should never reach here ;)
331	jmp exit	334	jmp exit
332		335
333	discover:	336	discover:
334	call parse_response	337	call parse_response
335		338
336	cmp [dhcpMsgType], 0x02 ; Was the response an offer?	339	cmp [dhcpMsgType], 0x02 ; Was the response an offer?
337	je send_request	340	je send_request
338		341
339	call dhcp_end	342	call dhcp_end
340	jmp link_local	343	jmp link_local
341		344
342	send_request:	345	send_request:
343	mov [dhcpMsgType], 0x03 ; make it a request	346	mov [dhcpMsgType], 0x03 ; make it a request
344	jmp build_request	347	jmp build_request
345		348
346	request:	349	request:
347	call parse_response	350	call parse_response
348	call dhcp_end	-
349		351
350	cmp [dhcpMsgType], 0x05 ; Was the response an ACK? It should be	352	cmp [dhcpMsgType], 0x05 ; Was the response an ACK? It should be
-		353	jne read_data ; NO - read next packets
-		354
351	jne link_local ; NO - so we do link-local	355	call dhcp_end
352		356
353	mcall 76, API_IPv4 + 3, [dhcp.ip] ; ip	357	mcall 76, API_IPv4 + 3, [dhcp.ip] ; ip
354	mcall 76, API_IPv4 + 5, [dhcp.dns] ; dns	358	mcall 76, API_IPv4 + 5, [dhcp.dns] ; dns
355	mcall 76, API_IPv4 + 7, [dhcp.subnet] ; subnet	359	mcall 76, API_IPv4 + 7, [dhcp.subnet] ; subnet
356	mcall 76, API_IPv4 + 9, [dhcp.gateway] ; gateway	360	mcall 76, API_IPv4 + 9, [dhcp.gateway] ; gateway
357		361
358	jmp exit	362	jmp exit
359		363
360	dhcp_end:	364	dhcp_end:
361	mcall close, [socketNum]	365	mcall close, [socketNum]
362	stdcall mem.Free, [dhcpMsg]	366	stdcall mem.Free, [dhcpMsg]
363		367
364	ret	368	ret
365		369
366	;***************************************************************************	370	;***************************************************************************
367	; Function	371	; Function
368	; parseResponse	372	; parseResponse
369	;	373	;
370	; Description	374	; Description
371	; extracts the fields ( client IP address and options ) from	375	; extracts the fields ( client IP address and options ) from
372	; a DHCP response	376	; a DHCP response
373	; The values go into	377	; The values go into
374	; dhcpMsgType,dhcpLease,dhcpClientIP,dhcpServerIP,	378	; dhcpMsgType,dhcpLease,dhcpClientIP,dhcpServerIP,
375	; dhcpDNSIP, dhcpSubnet	379	; dhcpDNSIP, dhcpSubnet
376	; The message is stored in dhcpMsg	380	; The message is stored in dhcpMsg
377	;	381	;
378	;***************************************************************************	382	;***************************************************************************
379	parse_response:	383	parse_response:
380		384
381	DEBUGF 1,"Data received, parsing response\n"	385	DEBUGF 1,"Data received, parsing response\n"
382	mov edx, [dhcpMsg]	386	mov edx, [dhcpMsg]
383		387
384	push dword [edx+16]	388	push dword [edx+16]
385	pop [dhcp.ip]	389	pop [dhcp.ip]
386	DEBUGF 1,"Client: %u.%u.%u.%u\n", [edx+16]:1, [edx+17]:1, [edx+18]:1, [edx+19]:1	390	DEBUGF 1,"Client: %u.%u.%u.%u\n", [edx+16]:1, [edx+17]:1, [edx+18]:1, [edx+19]:1
387		391
388	; TODO: check if there really are options	392	; TODO: check if there really are options
389		393
390	mov al, 240 ; Point to first option	394	mov al, 240 ; Point to first option
391	movzx ecx, al	395	movzx ecx, al
392		396
393	.next_option:	397	.next_option:
394	add edx, ecx	398	add edx, ecx
395		399
396	mov al, [edx] ; get message identifier	400	mov al, [edx] ; get message identifier
397		401
398	cmp al, 0xff ; End of options?	402	cmp al, 0xff ; End of options?
399	je .done	403	je .done
400		404
401	cmp al, 0	405	cmp al, 0
402	je .pad	406	je .pad
403		407
404	; TODO: check if we still are inside the buffer	408	; TODO: check if we still are inside the buffer
405		409
406	inc edx	410	inc edx
407	movzx ecx, byte [edx] ; get data length	411	movzx ecx, byte [edx] ; get data length
408	inc edx ; point to data	412	inc edx ; point to data
409		413
410	cmp al, dhcp_msg_type ; Msg type is a single byte option	414	cmp al, dhcp_msg_type ; Msg type is a single byte option
411	je .msgtype	415	je .msgtype
412		416
413	cmp al, dhcp_dhcp_server_id	417	cmp al, dhcp_dhcp_server_id
414	je .server	418	je .server
415		419
416	cmp al, dhcp_address_time	420	cmp al, dhcp_address_time
417	je .lease	421	je .lease
418		422
419	cmp al, dhcp_subnet_mask	423	cmp al, dhcp_subnet_mask
420	je .subnet	424	je .subnet
421		425
422	cmp al, dhcp_router	426	cmp al, dhcp_router
423	je .router	427	je .router
424		428
425	cmp al, dhcp_domain_server	429	cmp al, dhcp_domain_server
426	je .dns	430	je .dns
427		431
428	DEBUGF 1,"Unsupported DHCP option: %u\n", al	432	DEBUGF 1,"Unsupported DHCP option: %u\n", al
429		433
430	jmp .next_option	434	jmp .next_option
431		435
432	.pad:	436	.pad:
433	xor ecx, ecx	437	xor ecx, ecx
434	inc ecx	438	inc ecx
435	jmp .next_option	439	jmp .next_option
436		440
437	.msgtype:	441	.msgtype:
438	mov al, [edx]	442	mov al, [edx]
439	mov [dhcpMsgType], al	443	mov [dhcpMsgType], al
440		444
441	DEBUGF 1,"DHCP Msg type: %u\n", al	445	DEBUGF 1,"DHCP Msg type: %u\n", al
442	jmp .next_option ; Get next option	446	jmp .next_option ; Get next option
443		447
444	.server:	448	.server:
445	mov eax, [edx]	449	mov eax, [edx]
446	mov [dhcpServerIP], eax	450	mov [dhcpServerIP], eax
447	DEBUGF 1,"Server: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1	451	DEBUGF 1,"Server: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
448	jmp .next_option	452	jmp .next_option
449		453
450	.lease:	454	.lease:
451	pusha	455	pusha
452	mov eax,[edx]	456	mov eax,[edx]
453	bswap eax	457	bswap eax
454	mov [dhcpLease],eax	458	mov [dhcpLease],eax
455	DEBUGF 1,"lease: %d\n",eax	459	DEBUGF 1,"lease: %d\n",eax
456	popa	460	popa
457	jmp .next_option	461	jmp .next_option
458		462
459	.subnet:	463	.subnet:
460	push dword [edx]	464	push dword [edx]
461	pop [dhcp.subnet]	465	pop [dhcp.subnet]
462	DEBUGF 1,"Subnet: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1	466	DEBUGF 1,"Subnet: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
463	jmp .next_option	467	jmp .next_option
464		468
465	.router:	469	.router:
466	push dword [edx]	470	push dword [edx]
467	pop [dhcp.gateway]	471	pop [dhcp.gateway]
468	DEBUGF 1,"Gateway: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1	472	DEBUGF 1,"Gateway: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
469	jmp .next_option	473	jmp .next_option
470		474
471	.dns:	475	.dns:
472	push dword [edx]	476	push dword [edx]
473	pop [dhcp.dns]	477	pop [dhcp.dns]
474	DEBUGF 1,"DNS: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1	478	DEBUGF 1,"DNS: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
475	jmp .next_option	479	jmp .next_option
476		480
477	.done:	481	.done:
478	ret	482	ret
479		483
480		484
481		485
482	apipa:	-
483	mcall close, [socketNum]	486	dhcp_error:
484	stdcall mem.Free, [dhcpMsg]	-
485		487	call dhcp_end
486		488
487	link_local:	489	link_local:
488	call random	490	call random
489	mov ecx, 0xfea9 ; IP 169.254.0.0 link local net, see RFC3927	-
490	mov cx, ax	491	mov cx, ax
-		492	shl ecx, 16
-		493	mov cx, 0xfea9 ; IP 169.254.0.0 link local net, see RFC3927
491	mcall 76, API_IPv4 + 3, ecx ; mask is 255.255.0.0	494	mcall 76, API_IPv4 + 3, ecx ; mask is 255.255.0.0
492	DEBUGF 1,"Link Local IP assinged: 169.254.%u.%u\n", [generator+2]:1, [generator+3]:1	495	DEBUGF 1,"Link Local IP assinged: 169.254.%u.%u\n", [generator+2]:1, [generator+3]:1
493	mcall 76, API_IPv4 + 5, 0xffff	496	mcall 76, API_IPv4 + 7, 0xffff

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/applications/zeroconf/zeroconf.asm – Rev 3340 → 3361