WebSVN – Kolibri OS – Diff – /programs/network/zeroconf/zeroconf.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2010-2016. 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 ""
 
; CONFIGURATION
 
TIMEOUT                 = 5             ; in seconds
BUFFER                  = 1024          ; in bytes
DHCP_TRIES              = 3             ; number of times to try contacting DHCP server
__DEBUG__               = 1             ; enable/disable
__DEBUG_LEVEL__         = 2             ; 1 = all, 2 = errors
 
; CONFIGURATION FOR LINK-LOCAL
 
PROBE_WAIT              = 1             ; second  (initial random delay)
PROBE_MIN               = 1             ; second  (minimum delay till repeated probe)
PROBE_MAX               = 2             ; seconds (maximum delay till repeated probe)
PROBE_NUM               = 3             ;         (number of probe packets)
 
ANNOUNCE_NUM            = 2             ;         (number of announcement packets)
ANNOUNCE_INTERVAL       = 2             ; seconds (time between announcement packets)
ANNOUNCE_WAIT           = 2             ; seconds (delay before announcing)
 
MAX_CONFLICTS           = 10            ;         (max conflicts before rate limiting)
 
RATE_LIMIT_INTERVAL     = 60            ; seconds (delay between successive attempts)
 
DEFEND_INTERVAL         = 10            ; seconds (min. wait between defensive ARPs)
 
MAX_INTERFACES          = 8
 
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      0, 0                    ; I_Param, I_Path
 
 
include '../../proc32.inc'
include '../../macros.inc'
include '../../debug-fdo.inc'
include '../../network.inc'
include 'dhcp.inc'
include '../../dll.inc'
 
struct  dhcp_msg
        op              db ?    ; Operation Code
        htype           db ?    ; Hardware type
        hlen            db ?    ; Hardware address length
        hops            db ?
        xid             dd ?    ; Transaction Identifier
        secs            dw ?    ; Seconds since boot
        flags           dw ?
        ciaddr          dd ?    ; Client IP address
        yiaddr          dd ?    ; "Your" IP address
        siaddr          dd ?    ; Server IP address
        giaddr          dd ?    ; Gateway IP address
        chaddr          rb 16   ; Client hardware address
        sname           rb 64   ; Server name
        file            rb 128  ; boot filename
        cookie          dd ?    ; Magic cookie (0x63538263)
        options         rb 512
ends
 
struct  interface
        number          dd ?
        state           dd ?    ; 0 - disconnected, 1 - connected
        mode            dd ?    ; 0 - disabled, 1 - static, 2 - dhcp, 3 - auto (zero config)
        tries           dd ?
        lease           dd ?
        ServerIP        dd ?
        ip              dd ?
        subnet          dd ?
        dns             dd ?
        gateway         dd ?
        socketNum       dd ?
        timeout         dd ?
        ip_conflicts    dd ?
ends
 
START:
        mcall   68, 11                  ; init heap
 
        stdcall dll.Load, @IMPORT       ; load libraries
        or      eax, eax
        jnz     exit_immediately
 
        DEBUGF  2, "Zero-config service loaded\n"
 
        mcall   40, EVM_STACK2          ; We only want low-level network events
 
; Set up interface list
        mov     edi, device_list
        xor     ebx, ebx
  @@:
        inc     ebx
        mov     eax, ebx
        stosd
        mov     ecx, sizeof.interface/4-1
        xor     eax,eax
        rep stosd
        cmp     ebx, MAX_INTERFACES
        jb      @b
 
        mov     ebp, device_list
mainloop:
        cmp     [ebp + interface.state], 0
        je      .link_up?
        jmp     .maintain_link
 
  .next:
        cmp     [ebp + interface.number], MAX_INTERFACES
        je      .wait
        add     ebp, sizeof.interface
        jmp     mainloop
 
  .wait:
        mcall   10                      ; Wait for event
        mov     ebp, device_list
        jmp     mainloop
 
  .link_up?:
        mov     bh, byte[ebp + interface.number]
        mov     bl, 0                   ; Get device type
        mcall   74
        cmp     eax, 1                  ; Ethernet
        jne     mainloop.next
 
        mov     bl, 10                  ; Get Link status
        mcall   74
        test    eax, eax
        jz      mainloop.next
 
        mov     [ebp + interface.state], 1
 
        call    create_str_ini_int
 
; Try to read settings from .ini file
        invoke  ini.get_str, ini_path, str_ini_int, str_ip_type, inibuf, 16, str_null
        test    eax, eax
        jz      @f
; If settings not found, use default settings from 'ip?' section
        mov     dword[str_ini_int], 'ip?'
  @@:
 
        mov     ebx, API_ETH + 0
        mov     bh, byte[ebp + interface.number]
        mcall   76                      ; get MAC of the ethernet interface
        mov     word[tx_msg.chaddr], bx
        mov     dword[tx_msg.chaddr+2], eax
        DEBUGF  1, "MAC: %x-%x-%x-%x-%x-%x\n", \
        [tx_msg.chaddr+0]:2, [tx_msg.chaddr+1]:2, [tx_msg.chaddr+2]:2, \
        [tx_msg.chaddr+3]:2, [tx_msg.chaddr+4]:2, [tx_msg.chaddr+5]:2
 
        invoke  ini.get_str, ini_path, str_ini_int, str_ip_type, inibuf, 16, str_null
        test    eax, eax
        jnz     .invalid
        mov     eax, dword[inibuf]
        or      eax, 0x20202020
        mov     [ebp + interface.mode], 0
        cmp     eax, 'disa'
        je      .next
        mov     [ebp + interface.mode], 1
        cmp     eax, 'stat'
        je      static
        mov     [ebp + interface.mode], 2
        cmp     eax, 'dhcp'
        je      dhcp
        mov     [ebp + interface.mode], 3
        cmp     eax, 'auto'
        je      dhcp
 
  .invalid:
        DEBUGF  2, "Invalid settings for interface: %s.\n", str_ini_int
        jmp     .next
 
  .maintain_link:
 
; Check for IP conflicts
        mov     ebx, API_ARP
        mov     bh, byte[ebp + interface.number]
        mov     bl, 7
        mcall   76                      ; Number of IP conflicts
        cmp     eax, [ebp + interface.ip_conflicts]
        je      @f
        mov     [ebp + interface.ip_conflicts], eax
        DEBUGF  2, "IP address conflict on interface %u\n", [ebp + interface.number]
        ; Notify user of the IP address conflict
        mov     [notify_struct.msg], str_conflict
        mcall   70, notify_struct
  @@:
 
; Check if device is still there
        mov     bh, byte[ebp + interface.number]
        mov     bl, 0                   ; Get device type
        mcall   74
        test    eax, eax                ; No device
        jz      .link_down
 
; Check if link is still there
        mov     bl, 10                  ; Get Link status
        mcall   74
        test    eax, eax
        jnz     .next
 
  .link_down:
        mov     [ebp + interface.state], 0
 
; Notify user that the link is down
        mov     [notify_struct.msg], str_disconnected
        mcall   70, notify_struct
 
; CHECKME: should we do this in kernel instead? Should we even do this at all?
        xor     ecx, ecx
        mov     ebx, API_IPv4 + 3
        mov     bh, byte[ebp + interface.number]
        mcall   76                      ; ip
        mov     bl, 5
        mcall   76                      ; dns
        mov     bl, 7
        mcall   76                      ; subnet
        mov     bl, 9
        mcall   76                      ; gateway
 
        jmp     .next
 
link_up:
 
; Read number of previous IP conflicts
        mov     ebx, API_ARP
        mov     bh, byte[ebp + interface.number]
        mov     bl, 7
        mcall   76
        mov     [ebp + interface.ip_conflicts], eax
 
; Notify user that the link is up and running
        mov     [notify_struct.msg], str_connected
        mcall   70, notify_struct
 
  .fail:
        mcall   40, EVM_STACK2
        jmp     mainloop.next
 
static:
        DEBUGF  1, "Applying Static IP settings\n"
 
        invoke  ini.get_str, ini_path, str_ini_int, str_ip, inibuf, 16, str_null
        mov     esi, inibuf
        call    ip_str_to_dword
        mov     ebx, API_IPv4 + 3       ; set IP
        mov     bh, byte[ebp + interface.number]
        mcall   76
 
        invoke  ini.get_str, ini_path, str_ini_int, str_subnet, inibuf, 16, str_null
        mov     esi, inibuf
        call    ip_str_to_dword
        mov     ebx, API_IPv4 + 7       ; set subnet
        mov     bh, byte[ebp + interface.number]
        mcall   76
 
        invoke  ini.get_str, ini_path, str_ini_int, str_gateway, inibuf, 16, str_null
        mov     esi, inibuf
        call    ip_str_to_dword
        mov     ebx, API_IPv4 + 9       ; set gateway
        mov     bh, byte[ebp + interface.number]
        mcall   76
 
  .dns:
        invoke  ini.get_str, ini_path, str_ini_int, str_dns, inibuf, 16, str_null
        mov     esi, inibuf
        call    ip_str_to_dword
        mov     ebx, API_IPv4 + 5       ; set DNS
        mov     bh, byte[ebp + interface.number]
        mcall   76
 
        jmp     link_up
 
 
dhcp:
 
        DEBUGF  2, "Trying to contact DHCP server\n"
 
        mcall   40, EVM_STACK
 
        mcall   75, 0, AF_INET4, SOCK_DGRAM, 0                          ; open socket (parameters: domain, type, reserved)
        cmp     eax, -1
        je      dhcp_error
        mov     [ebp + interface.socketNum], eax
 
        DEBUGF  1, "Socket %x opened\n", eax
 
        mcall   75, 2, [ebp + interface.socketNum], sock_local, 18      ; bind socket to local port 68
        cmp     eax, -1
        je      socket_error
 
        DEBUGF  1, "Socket Bound to local port 68\n"
 
        pushd   [ebp + interface.number]
        pushd   4                       ; length of option
        pushd   SO_BINDTODEVICE
        pushd   SOL_SOCKET
        mcall   75, 8, [ebp + interface.socketNum], esp
        add     esp, 16
        cmp     eax, -1
        je      socket_error
 
        DEBUGF  1, "Socket Bound to local interface %u\n", [ebp + interface.number]
 
        mcall   75, 4, [ebp + interface.socketNum], sock_remote, 18     ; connect to 255.255.255.255 on port 67
        cmp     eax, -1
        je      socket_error
 
        DEBUGF  1, "Connected to 255.255.255.255 on port 67\n"
 
        ; Read preferred IP address from settings file
        invoke  ini.get_str, ini_path, str_ini_int, str_ip, inibuf, 16, str_null
        mov     esi, inibuf
        call    ip_str_to_dword
        mov     [ebp + interface.ip], ecx
 
        call    random
        mov     [tx_msg.xid], eax                                       ; randomize session ID
        mov     [tx_msg_type], 1                                        ; DHCP discover
 
build_dhcp_packet:
 
        DEBUGF  1, "Building DHCP packet\n"
 
        mov     [ebp + interface.tries], DHCP_TRIES
 
        ; Boot protocol legacy
        mov     [tx_msg.op], 1                                          ; Boot request
        mov     [tx_msg.htype], 1                                       ; Ethernet
        mov     [tx_msg.hlen], 6                                        ; Ethernet address h/w len
        mov     [tx_msg.hops], 0
        mcall   26, 9                                                   ; Time since boot
        xor     edx, edx
        mov     ebx, 100
        div     ebx                                                     ; Divide by 100 to get number of seconds
        xchg    al, ah                                                  ; Convert to big endian
        mov     [tx_msg.secs], ax
        mov     [tx_msg.flags], 0
 
        ; DHCP extension
        mov     [tx_msg.cookie], 0x63538263                             ; magic cookie
 
        mov     word[tx_msg+240], 0x0135                                ; option DHCP msg type
        mov     al,[tx_msg_type]
        mov     [tx_msg+240+2], al
 
        mov     word[tx_msg+240+3], 0x0433                              ; option Lease time
        mov     dword[tx_msg+240+5], -1                                 ; infinite
 
        mov     word[tx_msg+240+9], 0x0432                              ; option requested IP address
        mov     eax,[ebp + interface.ip]
        mov     [tx_msg+240+11], eax
 
        mov     word[tx_msg+240+15], 0x0437                             ; option request list
        mov     dword[tx_msg+240+17], 0x0f060301
 
        cmp     [tx_msg_type], 1                                        ; Check which msg we are sending
        jne     .request
 
        mov     byte[tx_msg+240+21], 0xff                               ; end of options marker
 
        mov     [tx_msg_len], 262                                       ; length
        jmp     send_dhcp_packet
 
  .request:
        mov     word[tx_msg+240+21], 0x0436                             ; server IP
        mov     eax,[ebp + interface.ServerIP]
        mov     [tx_msg+240+23], eax
 
        mov     byte[tx_msg+240+27], 0xff                               ; end of options marker
 
        mov     [tx_msg_len], 268                                       ; length
 
 
send_dhcp_packet:
        DEBUGF  1, "Sending DHCP packet\n"
        lea     edx, [tx_msg]
        mcall   75, 6, [ebp + interface.socketNum], , [tx_msg_len]
 
; Wait for reply
        mcall   26, 9
        add     eax, TIMEOUT*100
        mov     [ebp + interface.timeout], eax
        mov     ebx, TIMEOUT*100
  .wait:
        mcall   23                                                      ; Wait for event with timeout
read_packet:                                                            ; we have data - this will be the response
        lea     edx, [rx_msg]
        mcall   75, 7, [ebp + interface.socketNum], , BUFFER, MSG_DONTWAIT    ; read data from socket
        cmp     eax, -1
        jne     .got_data
 
        mcall   26, 9
        mov     ebx, eax
        sub     ebx, [ebp + interface.timeout]
        ja      send_dhcp_packet.wait
 
        DEBUGF  1, "No answer from DHCP server\n"
        dec     [ebp + interface.tries]
        jnz     send_dhcp_packet
        jmp     dhcp_fail
 
  .got_data:
        DEBUGF  1, "%d bytes received\n", eax
        mov     [rx_msg_len], 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     [tx_msg_type], 1                ; did we send a discover?
        je      discover_sent
        cmp     [tx_msg_type], 3                ; did we send a request?
        je      request_sent
        jmp     exit_immediately
 
discover_sent:
        call    parse_dhcp_reply
        cmp     [rx_msg_type], 2                ; Was the response an offer?
        jne     read_packet
 
        DEBUGF  1, "Got offer, making request\n"
        mov     [tx_msg_type], 3                ; make it a request
        jmp     build_dhcp_packet
 
request_sent:
        call    parse_dhcp_reply
        cmp     [rx_msg_type], 5                ; Was the response an ACK? It should be
        jne     read_packet                     ; NO - read next packets
 
        DEBUGF  2, "IP address %u.%u.%u.%u assigned to network interface %u by DHCP\n",\
        [ebp+interface.ip+0]:1, [ebp+interface.ip+1]:1, [ebp+interface.ip+2]:1, [ebp+interface.ip+3]:1, [ebp + interface.number]:1
 
        mcall   close, [ebp + interface.socketNum]
 
        mov     ebx, API_IPv4 + 3
        mov     bh, byte[ebp + interface.number]
        mcall   76, , [ebp + interface.ip]            ; ip
        mov     bl, 7
        mcall   76, , [ebp + interface.subnet]        ; subnet
        mov     bl, 9
        mcall   76, , [ebp + interface.gateway]       ; gateway
 
        invoke  ini.get_str, ini_path, str_ini_int, str_dns_type, inibuf, 16, str_null
        test    eax, eax
        jnz     @f
        mov     eax, dword[inibuf]
        or      eax, 0x202020
        cmp     eax, 'stat'
        je      static.dns
  @@:
        mov     ebx, API_IPv4 + 5
        mov     bh, byte[ebp + interface.number]
        mcall   76, , [ebp + interface.dns]           ; dns
 
        jmp     link_up
 
 
parse_dhcp_reply:
 
        DEBUGF  1, "Parsing response\n"
        mov     [rx_msg_type], 0
 
; Verify if session ID matches
        mov     eax, [tx_msg.xid]
        cmp     [rx_msg.xid], eax
        jne     .done
 
        pushd   [rx_msg.yiaddr]
        pop     [ebp + interface.ip]
        DEBUGF  1, "Client: %u.%u.%u.%u\n", \
        [rx_msg.yiaddr]:1, [rx_msg.yiaddr+1]:1, [rx_msg.yiaddr+2]:1, [rx_msg.yiaddr+3]:1
 
; Verify magic cookie
        cmp     [rx_msg.cookie], 0x63538263
        jne     .done
 
; Parse the DHCP options
        lea     esi, [rx_msg]
        mov     ecx, 240                        ; point to the first option
  .next_option:
; TODO: check if we still are inside the buffer!
        add     esi, ecx
 
        lodsb                                   ; get message identifier
        mov     bl, al
        cmp     bl, 0xff                        ; End of options?
        je      .done
        test    bl, bl
        jz      .pad
 
        lodsb                                   ; load data length
        movzx   ecx, al
        cmp     bl, dhcp_msg_type               ; Msg type is a single byte option
        je      .msgtype
        cmp     bl, dhcp_dhcp_server_id
        je      .server
        cmp     bl, dhcp_address_time
        je      .lease
        cmp     bl, dhcp_subnet_mask
        je      .subnet
        cmp     bl, dhcp_router
        je      .router
        cmp     bl, dhcp_domain_server
        je      .dns
 
        DEBUGF  1, "Unsupported DHCP option: %u\n", bl
        jmp     .next_option
 
  .pad:
        xor     ecx, ecx
        inc     ecx
        jmp     .next_option
 
  .msgtype:
        mov     al, [esi]
        mov     [rx_msg_type], al
 
        DEBUGF  1, "DHCP Msg type: %u\n", al
        jmp     .next_option                    ; Get next option
 
  .server:
        pushd   [esi]
        pop     [ebp + interface.ServerIP]
        DEBUGF  1, "Server: %u.%u.%u.%u\n", [esi]:1, [esi+1]:1, [esi+2]:1, [esi+3]:1
        jmp     .next_option
 
  .lease:
        pusha
        mov     eax,[esi]
        bswap   eax
        mov     [ebp + interface.lease], eax
        DEBUGF  1, "Lease: %d\n", eax
        popa
        jmp     .next_option
 
  .subnet:
        pushd   [esi]
        pop     [ebp + interface.subnet]
        DEBUGF  1, "Subnet: %u.%u.%u.%u\n", [esi]:1, [esi+1]:1, [esi+2]:1, [esi+3]:1
        jmp     .next_option
 
  .router:
        pushd   [esi]
        pop     [ebp + interface.gateway]
        DEBUGF  1, "Gateway: %u.%u.%u.%u\n", [esi]:1, [esi+1]:1, [esi+2]:1, [esi+3]:1
        jmp     .next_option
 
  .dns:
        pushd   [esi]
        pop     [ebp + interface.dns]
        DEBUGF  1, "DNS: %u.%u.%u.%u\n", [esi]:1, [esi+1]:1, [esi+2]:1, [esi+3]:1
        jmp     .next_option
 
  .done:
        ret
 
exit_immediately:
        DEBUGF  2, "Zeroconf failed!\n"
        mcall   -1
 
socket_error:
        DEBUGF  2, "Socket error!\n"
 
dhcp_fail:
        mcall   close, [ebp + interface.socketNum]
 
dhcp_error:
        DEBUGF  2, "DHCP failed\n"
        cmp     [ebp + interface.mode], 3               ; zero config mode?
        jne     link_up
 
link_local:
 
; TODO: send ARP probes before setting the IP address in stack!
 
        call    random
        mov     cx, ax
        shl     ecx, 16
        mov     cx, 0xfea9                              ; IP 169.254.0.0 link local net, see RFC3927
        mov     ebx, API_IPv4 + 3
        mov     bh, byte[ebp + interface.number]
        mcall   76, , ecx                               ; mask is 255.255.0.0
        DEBUGF  2, "IP address 169.254.%u.%u assigned to network interface %u through Link-Local\n",\
        [generator+0]:1, [generator+1]:1, [ebp + interface.number]:1
        mov     bl, 7
        mcall   76, , 0xffff
        mov     bl, 9
        mcall   76, , 0x0
        mov     bl, 5
        mcall   76, , 0x0
 
        jmp     link_up
 
 
random:  ; Pseudo random actually
 
        mov     eax,[generator]
        add     eax, -43ab45b5h
        ror     eax, 1
        bswap   eax
        xor     eax, dword[tx_msg.chaddr]
        ror     eax, 1
        xor     eax, dword[tx_msg.chaddr+2]
        mov     [generator], eax
 
        ret
 
 
 
create_str_ini_int:
        mov     eax, [ebp + interface.number]
        mov     ebx, 10
        xor     edx, edx
        push    0
  @@:
        div     ebx
        add     dl, '0'
        push    edx
        test    eax, eax
        jnz     @r
  @@:
        mov     edi, str_ini_int+2
  @@:
        pop     eax
        stosb
        test    eax, eax
        jnz     @r
 
        ret
 
 
 
; In: esi = ptr to ASCIIZ IP address
; Out: ecx = IP (0 on error)
 
ip_str_to_dword:
 
        xor     ecx, ecx        ; end result
  .charloop:
        lodsb
        test    al, al
        jz      .finish
        cmp     al, '.'
        je      .dot
        sub     al, '0'
        jb      .fail
        cmp     al, 9
        ja      .fail
        mov     dl, cl
        shl     cl, 2
        jc      .fail
        add     cl, dl
        jc      .fail
        add     cl, cl
        jc      .fail
        add     cl, al
        jc      .fail
        jmp     .charloop
  .dot:
        shl     ecx, 8
        jc      .fail
        xor     cl, cl
        jmp     .charloop
  .finish:
        bswap   ecx             ; we want little endian order
        ret
 
  .fail:
        xor     ecx, ecx
        ret
 
; DATA AREA
 
align 16
@IMPORT:
 
library \
        libini,         'libini.obj'
 
import  libini, \
        ini.get_str,    'ini_get_str',\
        ini.set_str,    'ini_set_str'
 
include_debug_strings
 
str_ip          db 'ip', 0
str_subnet      db 'subnet', 0
str_gateway     db 'gateway', 0
str_dns         db 'dns', 0
 
str_ip_type     db 'ip_type', 0
str_dns_type    db 'dns_type', 0
 
str_ini_int     db 'ip1', 0
                rb 10
 
str_null        db 0
 
sock_local:
        dw AF_INET4
        dw 68 shl 8     ; local port
        dd 0            ; local IP
        rb 10
 
 
sock_remote:
        dw AF_INET4
        dw 67 shl 8     ; destination port
        dd -1           ; destination IP
        rb 10
 
notify_struct:
        dd 7            ; run application
        dd 0
 .msg   dd 0
        dd 0
        dd 0
        db '/sys/@notify', 0
 
str_connected           db '"You are now connected to the network." -N', 0
str_disconnected        db '"You are now disconnected from the network." -N', 0
str_conflict            db '"An IP address conflict has been detected on the network." -W', 0
 
ini_path                db '/sys/settings/network.ini',0
 
IM_END:
 
generator       dd ?
 
inibuf          rb 16
 
tx_msg_len      dd ?
rx_msg_len      dd ?
tx_msg_type     db ?
rx_msg_type     db ?
tx_msg          dhcp_msg
rx_msg          dhcp_msg
 
device_list     rd MAX_INTERFACES*sizeof.interface
 
I_END:

Rev 6123	Rev 6228
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2010-2016. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2010-2016. 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	; CONFIGURATION	21	; CONFIGURATION
22		22
23	TIMEOUT = 5 ; in seconds	23	TIMEOUT = 5 ; in seconds
24	BUFFER = 1024 ; in bytes	24	BUFFER = 1024 ; in bytes
25	DHCP_TRIES = 3 ; number of times to try contacting DHCP server	25	DHCP_TRIES = 3 ; number of times to try contacting DHCP server
26	__DEBUG__ = 1 ; enable/disable	26	__DEBUG__ = 1 ; enable/disable
27	__DEBUG_LEVEL__ = 2 ; 1 = all, 2 = errors	27	__DEBUG_LEVEL__ = 2 ; 1 = all, 2 = errors
28		28
29	; CONFIGURATION FOR LINK-LOCAL	29	; CONFIGURATION FOR LINK-LOCAL
30		30
31	PROBE_WAIT = 1 ; second (initial random delay)	31	PROBE_WAIT = 1 ; second (initial random delay)
32	PROBE_MIN = 1 ; second (minimum delay till repeated probe)	32	PROBE_MIN = 1 ; second (minimum delay till repeated probe)
33	PROBE_MAX = 2 ; seconds (maximum delay till repeated probe)	33	PROBE_MAX = 2 ; seconds (maximum delay till repeated probe)
34	PROBE_NUM = 3 ; (number of probe packets)	34	PROBE_NUM = 3 ; (number of probe packets)
35		35
36	ANNOUNCE_NUM = 2 ; (number of announcement packets)	36	ANNOUNCE_NUM = 2 ; (number of announcement packets)
37	ANNOUNCE_INTERVAL = 2 ; seconds (time between announcement packets)	37	ANNOUNCE_INTERVAL = 2 ; seconds (time between announcement packets)
38	ANNOUNCE_WAIT = 2 ; seconds (delay before announcing)	38	ANNOUNCE_WAIT = 2 ; seconds (delay before announcing)
39		39
40	MAX_CONFLICTS = 10 ; (max conflicts before rate limiting)	40	MAX_CONFLICTS = 10 ; (max conflicts before rate limiting)
41		41
42	RATE_LIMIT_INTERVAL = 60 ; seconds (delay between successive attempts)	42	RATE_LIMIT_INTERVAL = 60 ; seconds (delay between successive attempts)
43		43
44	DEFEND_INTERVAL = 10 ; seconds (min. wait between defensive ARPs)	44	DEFEND_INTERVAL = 10 ; seconds (min. wait between defensive ARPs)
45		45
46	MAX_INTERFACES = 8	46	MAX_INTERFACES = 8
47		47
48	use32	48	use32
49	org 0x0	49	org 0x0
50		50
51	db 'MENUET01' ; 8 byte id	51	db 'MENUET01' ; 8 byte id
52	dd 0x01 ; header version	52	dd 0x01 ; header version
53	dd START ; start of code	53	dd START ; start of code
54	dd IM_END ; size of image	54	dd IM_END ; size of image
55	dd (I_END+0x100) ; memory for app	55	dd (I_END+0x100) ; memory for app
56	dd (I_END+0x100) ; esp	56	dd (I_END+0x100) ; esp
57	dd 0, 0 ; I_Param, I_Path	57	dd 0, 0 ; I_Param, I_Path
58		58
59		59
60	include '../../proc32.inc'	60	include '../../proc32.inc'
61	include '../../macros.inc'	61	include '../../macros.inc'
62	include '../../debug-fdo.inc'	62	include '../../debug-fdo.inc'
63	include '../../network.inc'	63	include '../../network.inc'
64	include 'dhcp.inc'	64	include 'dhcp.inc'
65	include '../../dll.inc'	65	include '../../dll.inc'
66		66
67	struct dhcp_msg	67	struct dhcp_msg
68	op db ? ; Operation Code	68	op db ? ; Operation Code
69	htype db ? ; Hardware type	69	htype db ? ; Hardware type
70	hlen db ? ; Hardware address length	70	hlen db ? ; Hardware address length
71	hops db ?	71	hops db ?
72	xid dd ? ; Transaction Identifier	72	xid dd ? ; Transaction Identifier
73	secs dw ? ; Seconds since boot	73	secs dw ? ; Seconds since boot
74	flags dw ?	74	flags dw ?
75	ciaddr dd ? ; Client IP address	75	ciaddr dd ? ; Client IP address
76	yiaddr dd ? ; "Your" IP address	76	yiaddr dd ? ; "Your" IP address
77	siaddr dd ? ; Server IP address	77	siaddr dd ? ; Server IP address
78	giaddr dd ? ; Gateway IP address	78	giaddr dd ? ; Gateway IP address
79	chaddr rb 16 ; Client hardware address	79	chaddr rb 16 ; Client hardware address
80	sname rb 64 ; Server name	80	sname rb 64 ; Server name
81	file rb 128 ; boot filename	81	file rb 128 ; boot filename
82	cookie dd ? ; Magic cookie (0x63538263)	82	cookie dd ? ; Magic cookie (0x63538263)
83	options rb 512	83	options rb 512
84	ends	84	ends
85		85
86	struct interface	86	struct interface
87	number dd ?	87	number dd ?
88	state dd ? ; 0 - disconnected, 1 - connected	88	state dd ? ; 0 - disconnected, 1 - connected
89	mode dd ? ; 0 - disabled, 1 - static, 2 - dhcp, 3 - auto (zero config)	89	mode dd ? ; 0 - disabled, 1 - static, 2 - dhcp, 3 - auto (zero config)
90	tries dd ?	90	tries dd ?
91	lease dd ?	91	lease dd ?
92	ServerIP dd ?	92	ServerIP dd ?
93	ip dd ?	93	ip dd ?
94	subnet dd ?	94	subnet dd ?
95	dns dd ?	95	dns dd ?
96	gateway dd ?	96	gateway dd ?
97	socketNum dd ?	97	socketNum dd ?
98	timeout dd ?	98	timeout dd ?
99	ip_conflicts dd ?	99	ip_conflicts dd ?
100	ends	100	ends
101		101
102	START:	102	START:
103	mcall 68, 11 ; init heap	103	mcall 68, 11 ; init heap
104		104
105	stdcall dll.Load, @IMPORT ; load libraries	105	stdcall dll.Load, @IMPORT ; load libraries
106	or eax, eax	106	or eax, eax
107	jnz exit_immediately	107	jnz exit_immediately
108		108
109	DEBUGF 2, "Zero-config service loaded\n"	109	DEBUGF 2, "Zero-config service loaded\n"
110		110
111	mcall 40, EVM_STACK2 ; We only want low-level network events	111	mcall 40, EVM_STACK2 ; We only want low-level network events
112		112
113	; Set up interface list	113	; Set up interface list
114	mov edi, device_list	114	mov edi, device_list
115	xor ebx, ebx	115	xor ebx, ebx
116	@@:	116	@@:
117	inc ebx	117	inc ebx
118	mov eax, ebx	118	mov eax, ebx
119	stosd	119	stosd
120	mov ecx, sizeof.interface/4-1	120	mov ecx, sizeof.interface/4-1
121	xor eax,eax	121	xor eax,eax
122	rep stosd	122	rep stosd
123	cmp ebx, MAX_INTERFACES	123	cmp ebx, MAX_INTERFACES
124	jb @b	124	jb @b
125		125
126	mov ebp, device_list	126	mov ebp, device_list
127	mainloop:	127	mainloop:
128	cmp [ebp + interface.state], 0	128	cmp [ebp + interface.state], 0
129	je .link_up?	129	je .link_up?
130	jmp .maintain_link	130	jmp .maintain_link
131		131
132	.next:	132	.next:
133	cmp [ebp + interface.number], MAX_INTERFACES	133	cmp [ebp + interface.number], MAX_INTERFACES
134	je .wait	134	je .wait
135	add ebp, sizeof.interface	135	add ebp, sizeof.interface
136	jmp mainloop	136	jmp mainloop
137		137
138	.wait:	138	.wait:
139	mcall 10 ; Wait for event	139	mcall 10 ; Wait for event
140	mov ebp, device_list	140	mov ebp, device_list
141	jmp mainloop	141	jmp mainloop
142		142
143	.link_up?:	143	.link_up?:
144	mov bh, byte[ebp + interface.number]	144	mov bh, byte[ebp + interface.number]
145	mov bl, 0 ; Get device type	145	mov bl, 0 ; Get device type
146	mcall 74	146	mcall 74
147	cmp eax, 1 ; Ethernet	147	cmp eax, 1 ; Ethernet
148	jne mainloop.next	148	jne mainloop.next
149		149
150	mov bl, 10 ; Get Link status	150	mov bl, 10 ; Get Link status
151	mcall 74	151	mcall 74
152	test eax, eax	152	test eax, eax
153	jz mainloop.next	153	jz mainloop.next
154		154
155	mov [ebp + interface.state], 1	155	mov [ebp + interface.state], 1
156		156
157	call create_str_ini_int	157	call create_str_ini_int
158		158
159	; Try to read settings from .ini file	159	; Try to read settings from .ini file
160	invoke ini.get_str, ini_path, str_ini_int, str_ip_type, inibuf, 16, str_null	160	invoke ini.get_str, ini_path, str_ini_int, str_ip_type, inibuf, 16, str_null
161	test eax, eax	161	test eax, eax
162	jz @f	162	jz @f
163	; If settings not found, use default settings from 'ip?' section	163	; If settings not found, use default settings from 'ip?' section
164	mov dword[str_ini_int], 'ip?'	164	mov dword[str_ini_int], 'ip?'
165	@@:	165	@@:
166		166
167	mov ebx, API_ETH + 0	167	mov ebx, API_ETH + 0
168	mov bh, byte[ebp + interface.number]	168	mov bh, byte[ebp + interface.number]
169	mcall 76 ; get MAC of the ethernet interface	169	mcall 76 ; get MAC of the ethernet interface
170	mov word[tx_msg.chaddr], bx	170	mov word[tx_msg.chaddr], bx
171	mov dword[tx_msg.chaddr+2], eax	171	mov dword[tx_msg.chaddr+2], eax
172	DEBUGF 1, "MAC: %x-%x-%x-%x-%x-%x\n", \	172	DEBUGF 1, "MAC: %x-%x-%x-%x-%x-%x\n", \
173	[tx_msg.chaddr+0]:2, [tx_msg.chaddr+1]:2, [tx_msg.chaddr+2]:2, \	173	[tx_msg.chaddr+0]:2, [tx_msg.chaddr+1]:2, [tx_msg.chaddr+2]:2, \
174	[tx_msg.chaddr+3]:2, [tx_msg.chaddr+4]:2, [tx_msg.chaddr+5]:2	174	[tx_msg.chaddr+3]:2, [tx_msg.chaddr+4]:2, [tx_msg.chaddr+5]:2
175		175
176	invoke ini.get_str, ini_path, str_ini_int, str_ip_type, inibuf, 16, str_null	176	invoke ini.get_str, ini_path, str_ini_int, str_ip_type, inibuf, 16, str_null
177	test eax, eax	177	test eax, eax
178	jnz .invalid	178	jnz .invalid
179	mov eax, dword[inibuf]	179	mov eax, dword[inibuf]
180	or eax, 0x20202020	180	or eax, 0x20202020
181	mov [ebp + interface.mode], 0	181	mov [ebp + interface.mode], 0
182	cmp eax, 'disa'	182	cmp eax, 'disa'
183	je .next	183	je .next
184	mov [ebp + interface.mode], 1	184	mov [ebp + interface.mode], 1
185	cmp eax, 'stat'	185	cmp eax, 'stat'
186	je static	186	je static
187	mov [ebp + interface.mode], 2	187	mov [ebp + interface.mode], 2
188	cmp eax, 'dhcp'	188	cmp eax, 'dhcp'
189	je dhcp	189	je dhcp
190	mov [ebp + interface.mode], 3	190	mov [ebp + interface.mode], 3
191	cmp eax, 'auto'	191	cmp eax, 'auto'
192	je dhcp	192	je dhcp
193		193
194	.invalid:	194	.invalid:
195	DEBUGF 2, "Invalid settings for interface: %s.\n", str_ini_int	195	DEBUGF 2, "Invalid settings for interface: %s.\n", str_ini_int
196	jmp .next	196	jmp .next
197		197
198	.maintain_link:	198	.maintain_link:
199		199
200	; Check for IP conflicts	200	; Check for IP conflicts
201	mov ebx, API_ARP	201	mov ebx, API_ARP
202	mov bh, byte[ebp + interface.number]	202	mov bh, byte[ebp + interface.number]
203	mov bl, 7	203	mov bl, 7
204	mcall 76 ; Number of IP conflicts	204	mcall 76 ; Number of IP conflicts
205	cmp eax, [ebp + interface.ip_conflicts]	205	cmp eax, [ebp + interface.ip_conflicts]
206	je @f	206	je @f
207	mov [ebp + interface.ip_conflicts], eax	207	mov [ebp + interface.ip_conflicts], eax
208	DEBUGF 2, "IP address conflict on interface %u\n", [ebp + interface.number]	208	DEBUGF 2, "IP address conflict on interface %u\n", [ebp + interface.number]
209	; Notify user of the IP address conflict	209	; Notify user of the IP address conflict
210	mov [notify_struct.msg], str_conflict	210	mov [notify_struct.msg], str_conflict
211	mcall 70, notify_struct	211	mcall 70, notify_struct
212	@@:	212	@@:
213		213
214	; Check if device is still there	214	; Check if device is still there
215	mov bh, byte[ebp + interface.number]	215	mov bh, byte[ebp + interface.number]
216	mov bl, 0 ; Get device type	216	mov bl, 0 ; Get device type
217	mcall 74	217	mcall 74
218	test eax, eax ; No device	218	test eax, eax ; No device
219	jz .link_down	219	jz .link_down
220		220
221	; Check if link is still there	221	; Check if link is still there
222	mov bl, 10 ; Get Link status	222	mov bl, 10 ; Get Link status
223	mcall 74	223	mcall 74
224	test eax, eax	224	test eax, eax
225	jnz .next	225	jnz .next
226		226
227	.link_down:	227	.link_down:
228	mov [ebp + interface.state], 0	228	mov [ebp + interface.state], 0
229		229
230	; Notify user that the link is down	230	; Notify user that the link is down
231	mov [notify_struct.msg], str_disconnected	231	mov [notify_struct.msg], str_disconnected
232	mcall 70, notify_struct	232	mcall 70, notify_struct
233		233
234	; CHECKME: should we do this in kernel instead? Should we even do this at all?	234	; CHECKME: should we do this in kernel instead? Should we even do this at all?
235	xor ecx, ecx	235	xor ecx, ecx
236	mov ebx, API_IPv4 + 3	236	mov ebx, API_IPv4 + 3
237	mov bh, byte[ebp + interface.number]	237	mov bh, byte[ebp + interface.number]
238	mcall 76 ; ip	238	mcall 76 ; ip
239	mov bl, 5	239	mov bl, 5
240	mcall 76 ; dns	240	mcall 76 ; dns
241	mov bl, 7	241	mov bl, 7
242	mcall 76 ; subnet	242	mcall 76 ; subnet
243	mov bl, 9	243	mov bl, 9
244	mcall 76 ; gateway	244	mcall 76 ; gateway
245		245
246	jmp .next	246	jmp .next
247		247
248	link_up:	248	link_up:
249		249
250	; Read number of previous IP conflicts	250	; Read number of previous IP conflicts
251	mov ebx, API_ARP	251	mov ebx, API_ARP
252	mov bh, byte[ebp + interface.number]	252	mov bh, byte[ebp + interface.number]
253	mov bl, 7	253	mov bl, 7
254	mcall 76	254	mcall 76
255	mov [ebp + interface.ip_conflicts], eax	255	mov [ebp + interface.ip_conflicts], eax
256		256
257	; Notify user that the link is up and running	257	; Notify user that the link is up and running
258	mov [notify_struct.msg], str_connected	258	mov [notify_struct.msg], str_connected
259	mcall 70, notify_struct	259	mcall 70, notify_struct
260		260
261	.fail:	261	.fail:
262	mcall 40, EVM_STACK2	262	mcall 40, EVM_STACK2
263	jmp mainloop.next	263	jmp mainloop.next
264		264
265	static:	265	static:
266	DEBUGF 1, "Applying Static IP settings\n"	266	DEBUGF 1, "Applying Static IP settings\n"
267		267
268	invoke ini.get_str, ini_path, str_ini_int, str_ip, inibuf, 16, str_null	268	invoke ini.get_str, ini_path, str_ini_int, str_ip, inibuf, 16, str_null
269	mov esi, inibuf	269	mov esi, inibuf
270	call ip_str_to_dword	270	call ip_str_to_dword
271	mov ebx, API_IPv4 + 3 ; set IP	271	mov ebx, API_IPv4 + 3 ; set IP
272	mov bh, byte[ebp + interface.number]	272	mov bh, byte[ebp + interface.number]
273	mcall 76	273	mcall 76
274		274
275	invoke ini.get_str, ini_path, str_ini_int, str_subnet, inibuf, 16, str_null	275	invoke ini.get_str, ini_path, str_ini_int, str_subnet, inibuf, 16, str_null
276	mov esi, inibuf	276	mov esi, inibuf
277	call ip_str_to_dword	277	call ip_str_to_dword
278	mov ebx, API_IPv4 + 7 ; set subnet	278	mov ebx, API_IPv4 + 7 ; set subnet
279	mov bh, byte[ebp + interface.number]	279	mov bh, byte[ebp + interface.number]
280	mcall 76	280	mcall 76
281		281
282	invoke ini.get_str, ini_path, str_ini_int, str_gateway, inibuf, 16, str_null	282	invoke ini.get_str, ini_path, str_ini_int, str_gateway, inibuf, 16, str_null
283	mov esi, inibuf	283	mov esi, inibuf
284	call ip_str_to_dword	284	call ip_str_to_dword
285	mov ebx, API_IPv4 + 9 ; set gateway	285	mov ebx, API_IPv4 + 9 ; set gateway
286	mov bh, byte[ebp + interface.number]	286	mov bh, byte[ebp + interface.number]
287	mcall 76	287	mcall 76
288		288
289	.dns:	289	.dns:
290	invoke ini.get_str, ini_path, str_ini_int, str_dns, inibuf, 16, str_null	290	invoke ini.get_str, ini_path, str_ini_int, str_dns, inibuf, 16, str_null
291	mov esi, inibuf	291	mov esi, inibuf
292	call ip_str_to_dword	292	call ip_str_to_dword
293	mov ebx, API_IPv4 + 5 ; set DNS	293	mov ebx, API_IPv4 + 5 ; set DNS
294	mov bh, byte[ebp + interface.number]	294	mov bh, byte[ebp + interface.number]
295	mcall 76	295	mcall 76
296		296
297	jmp link_up	297	jmp link_up
298		298
299		299
300	dhcp:	300	dhcp:
301		301
302	DEBUGF 2, "Trying to contact DHCP server\n"	302	DEBUGF 2, "Trying to contact DHCP server\n"
303		303
304	mcall 40, EVM_STACK	304	mcall 40, EVM_STACK
305		305
306	mcall 75, 0, AF_INET4, SOCK_DGRAM, 0 ; open socket (parameters: domain, type, reserved)	306	mcall 75, 0, AF_INET4, SOCK_DGRAM, 0 ; open socket (parameters: domain, type, reserved)
307	cmp eax, -1	307	cmp eax, -1
308	je dhcp_error	308	je dhcp_error
309	mov [ebp + interface.socketNum], eax	309	mov [ebp + interface.socketNum], eax
310		310
311	DEBUGF 1, "Socket %x opened\n", eax	311	DEBUGF 1, "Socket %x opened\n", eax
312		312
313	mcall 75, 2, [ebp + interface.socketNum], sock_local, 18 ; bind socket to local port 68	313	mcall 75, 2, [ebp + interface.socketNum], sock_local, 18 ; bind socket to local port 68
314	cmp eax, -1	314	cmp eax, -1
315	je socket_error	315	je socket_error
316		316
317	DEBUGF 1, "Socket Bound to local port 68\n"	317	DEBUGF 1, "Socket Bound to local port 68\n"
318		318
319	pushd [ebp + interface.number]	319	pushd [ebp + interface.number]
320	pushd 4 ; length of option	320	pushd 4 ; length of option
321	pushd SO_BINDTODEVICE	321	pushd SO_BINDTODEVICE
322	pushd SOL_SOCKET	322	pushd SOL_SOCKET
323	mcall 75, 8, [ebp + interface.socketNum], esp	323	mcall 75, 8, [ebp + interface.socketNum], esp
324	add esp, 16	324	add esp, 16
325	cmp eax, -1	325	cmp eax, -1
326	je socket_error	326	je socket_error
327		327
328	DEBUGF 1, "Socket Bound to local interface %u\n", [ebp + interface.number]	328	DEBUGF 1, "Socket Bound to local interface %u\n", [ebp + interface.number]
329		329
330	mcall 75, 4, [ebp + interface.socketNum], sock_remote, 18 ; connect to 255.255.255.255 on port 67	330	mcall 75, 4, [ebp + interface.socketNum], sock_remote, 18 ; connect to 255.255.255.255 on port 67
331	cmp eax, -1	331	cmp eax, -1
332	je socket_error	332	je socket_error
333		333
334	DEBUGF 1, "Connected to 255.255.255.255 on port 67\n"	334	DEBUGF 1, "Connected to 255.255.255.255 on port 67\n"
335		335
336	; Read preferred IP address from settings file	336	; Read preferred IP address from settings file
337	invoke ini.get_str, ini_path, str_ini_int, str_ip, inibuf, 16, str_null	337	invoke ini.get_str, ini_path, str_ini_int, str_ip, inibuf, 16, str_null
338	mov esi, inibuf	338	mov esi, inibuf
339	call ip_str_to_dword	339	call ip_str_to_dword
340	mov [ebp + interface.ip], ecx	340	mov [ebp + interface.ip], ecx
341		341
342	call random	342	call random
343	mov [tx_msg.xid], eax ; randomize session ID	343	mov [tx_msg.xid], eax ; randomize session ID
344	mov [tx_msg_type], 1 ; DHCP discover	344	mov [tx_msg_type], 1 ; DHCP discover
345		345
346	build_dhcp_packet:	346	build_dhcp_packet:
347		347
348	DEBUGF 1, "Building DHCP packet\n"	348	DEBUGF 1, "Building DHCP packet\n"
349		349
350	mov [ebp + interface.tries], DHCP_TRIES	350	mov [ebp + interface.tries], DHCP_TRIES
351		351
352	; Boot protocol legacy	352	; Boot protocol legacy
353	mov [tx_msg.op], 1 ; Boot request	353	mov [tx_msg.op], 1 ; Boot request
354	mov [tx_msg.htype], 1 ; Ethernet	354	mov [tx_msg.htype], 1 ; Ethernet
355	mov [tx_msg.hlen], 6 ; Ethernet address h/w len	355	mov [tx_msg.hlen], 6 ; Ethernet address h/w len
356	mov [tx_msg.hops], 0	356	mov [tx_msg.hops], 0
357	mcall 26, 9 ; Time since boot	357	mcall 26, 9 ; Time since boot
358	xor edx, edx	358	xor edx, edx
359	mov ebx, 100	359	mov ebx, 100
360	div ebx ; Divide by 100 to get number of seconds	360	div ebx ; Divide by 100 to get number of seconds
-		361	xchg al, ah ; Convert to big endian
361	mov [tx_msg.secs], ax	362	mov [tx_msg.secs], ax
362	mov [tx_msg.flags], 0	363	mov [tx_msg.flags], 0
363		364
364	; DHCP extension	365	; DHCP extension
365	mov [tx_msg.cookie], 0x63538263 ; magic cookie	366	mov [tx_msg.cookie], 0x63538263 ; magic cookie
366		367
367	mov word[tx_msg+240], 0x0135 ; option DHCP msg type	368	mov word[tx_msg+240], 0x0135 ; option DHCP msg type
368	mov al,[tx_msg_type]	369	mov al,[tx_msg_type]
369	mov [tx_msg+240+2], al	370	mov [tx_msg+240+2], al
370		371
371	mov word[tx_msg+240+3], 0x0433 ; option Lease time	372	mov word[tx_msg+240+3], 0x0433 ; option Lease time
372	mov dword[tx_msg+240+5], -1 ; infinite	373	mov dword[tx_msg+240+5], -1 ; infinite
373		374
374	mov word[tx_msg+240+9], 0x0432 ; option requested IP address	375	mov word[tx_msg+240+9], 0x0432 ; option requested IP address
375	mov eax,[ebp + interface.ip]	376	mov eax,[ebp + interface.ip]
376	mov [tx_msg+240+11], eax	377	mov [tx_msg+240+11], eax
377		378
378	mov word[tx_msg+240+15], 0x0437 ; option request list	379	mov word[tx_msg+240+15], 0x0437 ; option request list
379	mov dword[tx_msg+240+17], 0x0f060301	380	mov dword[tx_msg+240+17], 0x0f060301
380		381
381	cmp [tx_msg_type], 1 ; Check which msg we are sending	382	cmp [tx_msg_type], 1 ; Check which msg we are sending
382	jne .request	383	jne .request
383		384
384	mov byte[tx_msg+240+21], 0xff ; end of options marker	385	mov byte[tx_msg+240+21], 0xff ; end of options marker
385		386
386	mov [tx_msg_len], 262 ; length	387	mov [tx_msg_len], 262 ; length
387	jmp send_dhcp_packet	388	jmp send_dhcp_packet
388		389
389	.request:	390	.request:
390	mov word[tx_msg+240+21], 0x0436 ; server IP	391	mov word[tx_msg+240+21], 0x0436 ; server IP
391	mov eax,[ebp + interface.ServerIP]	392	mov eax,[ebp + interface.ServerIP]
392	mov [tx_msg+240+23], eax	393	mov [tx_msg+240+23], eax
393		394
394	mov byte[tx_msg+240+27], 0xff ; end of options marker	395	mov byte[tx_msg+240+27], 0xff ; end of options marker
395		396
396	mov [tx_msg_len], 268 ; length	397	mov [tx_msg_len], 268 ; length
397		398
398		399
399	send_dhcp_packet:	400	send_dhcp_packet:
400	DEBUGF 1, "Sending DHCP packet\n"	401	DEBUGF 1, "Sending DHCP packet\n"
401	lea edx, [tx_msg]	402	lea edx, [tx_msg]
402	mcall 75, 6, [ebp + interface.socketNum], , [tx_msg_len]	403	mcall 75, 6, [ebp + interface.socketNum], , [tx_msg_len]
403		404
404	; Wait for reply	405	; Wait for reply
405	mcall 26, 9	406	mcall 26, 9
406	add eax, TIMEOUT*100	407	add eax, TIMEOUT*100
407	mov [ebp + interface.timeout], eax	408	mov [ebp + interface.timeout], eax
408	mov ebx, TIMEOUT*100	409	mov ebx, TIMEOUT*100
409	.wait:	410	.wait:
410	mcall 23 ; Wait for event with timeout	411	mcall 23 ; Wait for event with timeout
411	read_packet: ; we have data - this will be the response	412	read_packet: ; we have data - this will be the response
412	lea edx, [rx_msg]	413	lea edx, [rx_msg]
413	mcall 75, 7, [ebp + interface.socketNum], , BUFFER, MSG_DONTWAIT ; read data from socket	414	mcall 75, 7, [ebp + interface.socketNum], , BUFFER, MSG_DONTWAIT ; read data from socket
414	cmp eax, -1	415	cmp eax, -1
415	jne .got_data	416	jne .got_data
416		417
417	mcall 26, 9	418	mcall 26, 9
418	mov ebx, eax	419	mov ebx, eax
419	sub ebx, [ebp + interface.timeout]	420	sub ebx, [ebp + interface.timeout]
420	ja send_dhcp_packet.wait	421	ja send_dhcp_packet.wait
421		422
422	DEBUGF 1, "No answer from DHCP server\n"	423	DEBUGF 1, "No answer from DHCP server\n"
423	dec [ebp + interface.tries]	424	dec [ebp + interface.tries]
424	jnz send_dhcp_packet	425	jnz send_dhcp_packet
425	jmp dhcp_fail	426	jmp dhcp_fail
426		427
427	.got_data:	428	.got_data:
428	DEBUGF 1, "%d bytes received\n", eax	429	DEBUGF 1, "%d bytes received\n", eax
429	mov [rx_msg_len], eax	430	mov [rx_msg_len], eax
430		431
431	; depending on which msg we sent, handle the response	432	; depending on which msg we sent, handle the response
432	; accordingly.	433	; accordingly.
433	; If the response is to a dhcp discover, then:	434	; If the response is to a dhcp discover, then:
434	; 1) If response is DHCP OFFER then	435	; 1) If response is DHCP OFFER then
435	; 1.1) record server IP, lease time & IP address.	436	; 1.1) record server IP, lease time & IP address.
436	; 1.2) send a request packet	437	; 1.2) send a request packet
437	; If the response is to a dhcp request, then:	438	; If the response is to a dhcp request, then:
438	; 1) If the response is DHCP ACK then	439	; 1) If the response is DHCP ACK then
439	; 1.1) extract the DNS & subnet fields. Set them in the stack	440	; 1.1) extract the DNS & subnet fields. Set them in the stack
440		441
441	cmp [tx_msg_type], 1 ; did we send a discover?	442	cmp [tx_msg_type], 1 ; did we send a discover?
442	je discover_sent	443	je discover_sent
443	cmp [tx_msg_type], 3 ; did we send a request?	444	cmp [tx_msg_type], 3 ; did we send a request?
444	je request_sent	445	je request_sent
445	jmp exit_immediately	446	jmp exit_immediately
446		447
447	discover_sent:	448	discover_sent:
448	call parse_dhcp_reply	449	call parse_dhcp_reply
449	cmp [rx_msg_type], 2 ; Was the response an offer?	450	cmp [rx_msg_type], 2 ; Was the response an offer?
450	jne read_packet	451	jne read_packet
451		452
452	DEBUGF 1, "Got offer, making request\n"	453	DEBUGF 1, "Got offer, making request\n"
453	mov [tx_msg_type], 3 ; make it a request	454	mov [tx_msg_type], 3 ; make it a request
454	jmp build_dhcp_packet	455	jmp build_dhcp_packet
455		456
456	request_sent:	457	request_sent:
457	call parse_dhcp_reply	458	call parse_dhcp_reply
458	cmp [rx_msg_type], 5 ; Was the response an ACK? It should be	459	cmp [rx_msg_type], 5 ; Was the response an ACK? It should be
459	jne read_packet ; NO - read next packets	460	jne read_packet ; NO - read next packets
460		461
461	DEBUGF 2, "IP address %u.%u.%u.%u assigned to network interface %u by DHCP\n",\	462	DEBUGF 2, "IP address %u.%u.%u.%u assigned to network interface %u by DHCP\n",\
462	[ebp+interface.ip+0]:1, [ebp+interface.ip+1]:1, [ebp+interface.ip+2]:1, [ebp+interface.ip+3]:1, [ebp + interface.number]:1	463	[ebp+interface.ip+0]:1, [ebp+interface.ip+1]:1, [ebp+interface.ip+2]:1, [ebp+interface.ip+3]:1, [ebp + interface.number]:1
463		464
464	mcall close, [ebp + interface.socketNum]	465	mcall close, [ebp + interface.socketNum]
465		466
466	mov ebx, API_IPv4 + 3	467	mov ebx, API_IPv4 + 3
467	mov bh, byte[ebp + interface.number]	468	mov bh, byte[ebp + interface.number]
468	mcall 76, , [ebp + interface.ip] ; ip	469	mcall 76, , [ebp + interface.ip] ; ip
469	mov bl, 7	470	mov bl, 7
470	mcall 76, , [ebp + interface.subnet] ; subnet	471	mcall 76, , [ebp + interface.subnet] ; subnet
471	mov bl, 9	472	mov bl, 9
472	mcall 76, , [ebp + interface.gateway] ; gateway	473	mcall 76, , [ebp + interface.gateway] ; gateway
473		474
474	invoke ini.get_str, ini_path, str_ini_int, str_dns_type, inibuf, 16, str_null	475	invoke ini.get_str, ini_path, str_ini_int, str_dns_type, inibuf, 16, str_null
475	test eax, eax	476	test eax, eax
476	jnz @f	477	jnz @f
477	mov eax, dword[inibuf]	478	mov eax, dword[inibuf]
478	or eax, 0x202020	479	or eax, 0x202020
479	cmp eax, 'stat'	480	cmp eax, 'stat'
480	je static.dns	481	je static.dns
481	@@:	482	@@:
482	mov ebx, API_IPv4 + 5	483	mov ebx, API_IPv4 + 5
483	mov bh, byte[ebp + interface.number]	484	mov bh, byte[ebp + interface.number]
484	mcall 76, , [ebp + interface.dns] ; dns	485	mcall 76, , [ebp + interface.dns] ; dns
485		486
486	jmp link_up	487	jmp link_up
487		488
488		489
489	parse_dhcp_reply:	490	parse_dhcp_reply:
490		491
491	DEBUGF 1, "Parsing response\n"	492	DEBUGF 1, "Parsing response\n"
492	mov [rx_msg_type], 0	493	mov [rx_msg_type], 0
493		494
494	; Verify if session ID matches	495	; Verify if session ID matches
495	mov eax, [tx_msg.xid]	496	mov eax, [tx_msg.xid]
496	cmp [rx_msg.xid], eax	497	cmp [rx_msg.xid], eax
497	jne .done	498	jne .done
498		499
499	pushd [rx_msg.yiaddr]	500	pushd [rx_msg.yiaddr]

Subversion Repositories Kolibri OS

(root)/programs/network/zeroconf/zeroconf.asm – Rev 6123 → 6228