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

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                                 ;;
-;; Copyright (C) KolibriOS team 2010-2014. All rights reserved.    ;;
+;; Copyright (C) KolibriOS team 2010-2015. All rights reserved.    ;;
 ;; Distributed under terms of the GNU General Public License       ;;
 ;;                                                                 ;;
 ;;  zeroconfig.asm - Zeroconfig service for KolibriOS              ;;
 ;;                                                                 ;;
 ;;  Written by hidnplayr@kolibrios.org                             ;;
 include '../../debug-fdo.inc'
 include '../../network.inc'
 include 'dhcp.inc'
 include '../../dll.inc'
+START:
-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
-   @@:
+        mcall   68, 11
-    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
+        stdcall dll.Load,@IMPORT
-    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
+        or      eax, eax
-    jnz     no_IP             ; if not, jump to no_IP
+        jnz     fail
-    ; The following code will convert this IP into a dword and output it in eax
+        DEBUGF  2,"Zero-config service loaded\n"
-    ; If there is also a port number specified, this will be returned in ebx, otherwise ebx is -1
+        mcall   40, EVM_STACK2
+wait_for_link_up:
-    pop     esi               ; edx (query address) was pushed onto stack and is now popped in esi
-    xor     edx, edx          ; result
+        mov     bh, [device]
-    xor     eax, eax          ; current character
+        mov     bl, 0           ; Get device type
-    xor     ebx, ebx          ; current byte
-  .outer_loop:
+        mcall   74
-    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
+        cmp     eax, 1          ; Ethernet
-    bswap   edx               ; we want little endian order
-    ret
-no_IP:
-    pop     edx
-    xor     edx, edx
-    ret
         jne     .wait
-START:
-        mcall   40, EVM_STACK2
-        DEBUGF  2,"Zero-config service loaded\n"
   .wait:
-        mov     ebx, API_ETH + 0
+        mov     bl, 10          ; Get Link status
-        mov     bh, [device]
+        mcall   74
+        test    eax, eax
+        jnz     .go
-        mcall   76                              ; get MAC of ethernet interface 1
+  .wait:
-        cmp     eax, -1
+        mcall   10
-        jne     .start
+        jmp     wait_for_link_up
+  .go:
-        mcall   10
+        mov     ebx, API_ETH + 0
+        mov     bh, [device]
-        jmp     .wait
+        mcall   76              ; get MAC of the ethernet interface
-  .start:
+        mov     word[MAC], bx
+        mov     dword[MAC+2], eax
+        DEBUGF  1,"MAC: %x-%x-%x-%x-%x-%x\n", [MAC+0]:2, [MAC+1]:2, [MAC+2]:2, [MAC+3]:2, [MAC+4]:2, [MAC+5]:2
+        invoke  ini.get_str, path, str_ipconfig, str_type, inibuf, 16, 0
-        mov     word[MAC], bx
+        cmp     dword[inibuf], 'stat'
+        je      static
+        jmp     try_dhcp
+wait_for_link_down:
-        mov     dword[MAC+2], eax
+; TODO: detect ARP conflicts
-        DEBUGF  1,"MAC: %x-%x-%x-%x-%x-%x\n", [MAC+0]:2, [MAC+1]:2, [MAC+2]:2, [MAC+3]:2, [MAC+4]:2, [MAC+5]:2
+        mcall   40, EVM_STACK2
+  .loop:
+        mcall   10
+        mov     bh, [device]
+        mov     bl, 0           ; Get device type
+        mcall   74
+        cmp     eax, 0          ; No device
+        je      .down
+        mov     bl, 10          ; Get Link status
+        mcall   74
+        test    eax, eax
+        jnz     .loop
+  .down:
+        xor     ecx, ecx
+        mov     ebx, API_IPv4 + 3
         mov     bh, [device]
-        mcall   40, EVM_STACK
+        mcall   76              ; ip
+        mov     bl, 5
-        mcall   68, 11
+        mcall   76              ; dns
         mov     bl, 7
-        stdcall dll.Load,@IMPORT
+        mcall   76              ; subnet
-        or      eax, eax
+        mov     bl, 9
-        jnz     try_dhcp
+        mcall   76              ; gateway
-        invoke  ini.get_str, path, str_ipconfig, str_type, inibuf, 16, 0
+        jmp     wait_for_link_up
-        cmp     dword[inibuf], 'stat'
+static:
-        jne     try_dhcp
+        DEBUGF  1,"Applying Static IP settings\n"
         invoke  ini.get_str, path, str_ipconfig, str_ip, inibuf, 16, 0
         mov     edx, inibuf
-        call    Ip2dword
+        call    ip_str_to_dword
         mov     ecx, edx
         mov     ebx, API_IPv4 + 3       ; set IP
         mov     bh, [device]
         mcall   76
         invoke  ini.get_str, path, str_ipconfig, str_gateway, inibuf, 16, 0
         mov     edx, inibuf
-        call    Ip2dword
+        call    ip_str_to_dword
         mov     ecx, edx
         mov     ebx, API_IPv4 + 9       ; set gateway
         mov     bh, [device]
-        mcall   76
+        mcall   76
+        invoke  ini.get_str, path, str_ipconfig, str_dns, inibuf, 16, 0
-        invoke  ini.get_str, path, str_ipconfig, str_dns, inibuf, 16, 0
+        mov     edx, inibuf
-        mov     edx, inibuf
+        call    ip_str_to_dword
+        mov     ecx, edx
+        mov     ebx, API_IPv4 + 5       ; set DNS
-        call    Ip2dword
+        mov     bh, [device]
-        mov     ecx, edx
+        mcall   76
-        mov     ebx, API_IPv4 + 5       ; set DNS
-        mov     bh, [device]
+        invoke  ini.get_str, path, str_ipconfig, str_subnet, inibuf, 16, 0
-        mcall   76
+        mov     edx, inibuf
         call    ip_str_to_dword
-        invoke  ini.get_str, path, str_ipconfig, str_subnet, inibuf, 16, 0
+        mov     ecx, edx
-        mov     edx, inibuf
+        mov     ebx, API_IPv4 + 7       ; set subnet
-        call    Ip2dword
+        mov     bh, [device]
-        mov     ecx, edx
+        mcall   76
         mov     ebx, API_IPv4 + 7       ; set subnet
-        mov     bh, [device]
+        mov     [notify_struct.msg], str_connected
-        mcall   76
+        mcall   70, notify_struct
         jmp     wait_for_link_down
         mov     [tries], DHCP_TRIES
         DEBUGF  1,"Building request\n"
         stdcall mem.Alloc, BUFFER
-        mov     [dhcpMsg], eax
+        stdcall mem.Alloc, BUFFER
-        test    eax, eax
-        jz      dhcp_error
+        test    eax, eax
         jz      dhcp_fail2
-            ;;; todo: skip this bullcrap
+        mov     [dhcpMsg], eax
         mov     edi, eax
         mov     ecx, BUFFER
         xor     eax, eax
         rep     stosb
-            ;; todo: put this in a buffer instead of writing bytes and words!
+            ;; todo: put this in one buffer we can copy, 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
-        mcall   75, 6, [socketNum], [dhcpMsg], [dhcpMsgLen]     ; write to socket ( send broadcast request )
+        mcall   75, 6, [socketNum], [dhcpMsg], [dhcpMsgLen]             ; write to socket (send broadcast request)
         mcall   26, 9
         add     eax, TIMEOUT*100
         mov     [timeout], eax
   .wait:
-        mcall   23, TIMEOUT                                             ; wait for data
+        mcall   23, TIMEOUT                                             ; wait for data (with timeout)
 read_data:                                                              ; we have data - this will be the response
         mcall   75, 7, [socketNum], [dhcpMsg], BUFFER, MSG_DONTWAIT     ; read data from socket
         cmp     eax, -1
         jb      send_dhcpmsg.wait
         DEBUGF  2,"No answer from DHCP server\n"
         dec     [tries]
         jnz     send_dhcpmsg                    ; try again
-        jmp     dhcp_error                      ; fail
+        jmp     dhcp_fail
   @@:
         je      discover
         cmp     [dhcpMsgType], 0x03             ; did we send a request?
         je      request
-        call    dhcp_end                        ; we should never reach here ;)
+        ; we should never reach here ;)
-        jmp     exit
+        jmp     fail
-discover:
-        call    parse_response
+discover:
-        cmp     [dhcpMsgType2], 0x02            ; Was the response an offer?
-        je      send_request
         call    parse_response
         call    dhcp_end
-        jmp     link_local
+        cmp     [dhcpMsgType2], 0x02            ; Was the response an offer?
         jne     dhcp_fail
 send_request:
         DEBUGF  1, "Got offer, making request\n"
         mov     [dhcpMsgType], 0x03             ; make it a request
         jmp     build_request
 request:
         call    parse_response
         cmp     [dhcpMsgType2], 0x05            ; Was the response an ACK? It should be
         jne     read_data                       ; NO - read next packets
         mov     bl, 7
         mcall   76, , [dhcp.subnet]             ; subnet
         mov     bl, 9
         mcall   76, , [dhcp.gateway]            ; gateway
-        jmp     exit
-dhcp_end:
-        mcall   close, [socketNum]
-        stdcall mem.Free, [dhcpMsg]
         jmp     wait_for_link_down
         ret
 ;***************************************************************************
   .lease:
         pusha
         mov     eax,[edx]
         bswap   eax
         mov     [dhcpLease],eax
-        DEBUGF  1,"lease: %d\n",eax
+        DEBUGF  1,"Lease: %d\n",eax
         popa
         jmp     .next_option
   .subnet:
         jmp     .next_option
   .done:
+        ret
+dhcp_fail:
-        ret
+        mcall   close, [socketNum]
         stdcall mem.Free, [dhcpMsg]
-dhcp_error:
+dhcp_fail2:
-        call    dhcp_end
+        DEBUGF  1,"DHCP failed\n"
         DEBUGF  1,"Waiting %us\n", ANNOUNCE_INTERVAL
         mcall   5, ANNOUNCE_INTERVAL*100
         jmp     announce_loop
    @@:
-        jmp     exit
+        jmp     wait_for_link_down
-error:
+socket_error:
         DEBUGF  2,"Socket error\n"
-exit:   ; we should, instead of closing, detect ARP conflicts and detect if cable keeps connected ;)
+fail:
         xor     eax, dword[MAC+2]
         mov     [generator], eax
+        ret
+ip_str_to_dword:
+    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
+    ret
 ; DATA AREA

Subversion Repositories Kolibri OS

(root)/programs/network/zeroconf/zeroconf.asm @ 5419 – Rev 4805 → 5391