WebSVN – Kolibri OS – Diff – /programs/network/autodhcp/trunk/autodhcp.asm

-;
 ; Automated dhcp client
+; v 1.3
+;
-; v 1.1
-;
-; by the hidden player
+; with thanks to authors of DHCP client for menuetos: Mike Hibbet
+;
+; by HidnPlayr & Derpenguin
 DEBUG equ 1
+TIMEOUT equ 60 ; in seconds
+BUFFER	equ 1024
+__DEBUG__ equ 1
-TIMEOUT equ 60 ; in seconds
+__DEBUG_LEVEL__ equ 1; 1 = all, 2 = errors
 use32
 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		      ; memory for app
+	       dd     I_END		      ; esp
+	       dd     0x0 , 0x0 	      ; I_Param , I_Icon
+;include 'macros.inc'
+include 'eth.inc'
+include 'debug-fdo.inc'
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 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)   ;
-	       dd     I_END		      ; esp
-	       dd     0x0 , 0x0 	      ; I_Param , I_Icon
+				       ;                                               ;
-include 'macros.inc'
-if DEBUG = 1
+DEFEND_INTERVAL     equ 10	       ; seconds (min. wait between defensive ARPs)    ;
-include 'debug.inc'
+				       ;                                               ;
-end if
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-START:				; start of execution
+START:				       ; start of execution
-    mov     eax,40		   ; Report events
-    mov     ebx,10000000b	   ; Only Stack
-    int     0x40
+    mov     eax,40		       ; Report events
-    mov     eax,52		   ; first, enable the stack
-    mov     ebx,2
+    mov     ebx,10000000b	       ; Only Stack
-    mov     ecx,0x00000383
+    int     0x40
-    int     0x40
+    mov     eax,52		       ; first, enable the stack (packet driver)
+    mov     ebx,2
-if DEBUG = 1
+    mov     ecx,0x00000383
+    int     0x40
-    newline
+    DEBUGF  1,"DHCP: Stack Initialized.\n"
+    eth.status eax		       ; Read the Stack status
-    dps  "DHCP: Stack Initialized"
+    test    eax,eax		       ; if eax is zero, no driver was found
+    jnz     @f
-    newline
+    DEBUGF  1,"DHCP: No Card detected\n"
-end if
+    jmp     close
-    mov     eax, 53		   ; then, read in the status
-    mov     ebx, 255
+   @@:
-    mov     ecx, 6
+    DEBUGF  1,"DHCP: Detected card: %x\n",eax
-    int     0x40
+   @@:
-    cmp     eax,0		   ; if eax is zero, no driver was found
-    jne     @f
-if DEBUG = 1
+    eth.check_cable eax
+    test    al,al
-    dps  "DHCP: No Card detected"
+    jnz     @f
-    newline
+    DEBUGF  1,"DHCP: Ethernet Cable not connected\n"
-end if
-    jmp  close
-   @@:
-if DEBUG = 1
-    dps  "DHCP: Detected card: "
+    mov     eax,5
+    mov     ebx,500		       ; loop until cable is connected (check every 5 sec)
+    int     0x40
+    jmp     @r
+   @@:
+    DEBUGF  1,"DHCP: Ethernet Cable status: %d\n",al
-    dph  eax
+    eth.read_mac MAC
+    DEBUGF  1,"DHCP: MAC address: %x-%x-%x-%x-%x-%x\n",[MAC]:2,[MAC+1]:2,[MAC+2]:2,[MAC+3]:2,[MAC+4]:2,[MAC+5]:2
-    newline
-end if
+;    jmp     apipa   ; comment this out if you want to skip DHCP and continue with link-local
-    ; now that the stack is running, lets start the dhcp request
-    ; First, open socket
+;***************************************************************************
+;
+;  DHCP rubish starts here
-    mov     eax, 53
+;
-    mov     ebx, 0
+;***************************************************************************
-    mov     ecx, 68		    ; local port dhcp client
+    eth.check_port 68,eax	       ; Check if port 68 is available
+    cmp     eax,1
+    je	    @f
-    mov     edx, 67		    ; remote port - dhcp server
+    DEBUGF  1,"DHCP: Port 68 is already in use.\n"
-    mov     esi, -1		    ; broadcast
+    jmp     close
     int     0x40
    @@:
-    mov     [socketNum], eax
+    eth.open_udp 68,67,-1,[socketNum]  ; open socket (local,remote,ip,socket)
     DEBUGF  1,"DHCP: Socket opened: %d\n",eax
-if DEBUG = 1
+				       ; Setup the first msg we will send
-    dps   "DHCP: Socket opened: "
+    mov     byte [dhcpMsgType], 0x01   ; DHCP discover
-    dpd   eax
+    mov     dword [dhcpLease], esi     ; esi is still -1 (-1 = forever)
-    newline
-end if
     mov     eax,26
-    ; Setup the first msg we will send
+    mov     ebx,9
-    mov     byte [dhcpMsgType], 0x01 ; DHCP discover
+    int     0x40
-    mov     dword [dhcpLease], esi   ; esi is still -1 (-1 = forever)
+    imul    eax,100
     mov     [currTime],eax
 ;***************************************************************************
-;   Function
+;***************************************************************************
-;      buildRequest
+;   Function
 ;      buildRequest
+;
+;   Description
-;   Description
+;      Creates a DHCP request packet.
+;
+;***************************************************************************
+buildRequest:
+    xor     eax,eax			    ; Clear dhcpMsg to all zeros
+    mov     edi,dhcpMsg
+    mov     ecx,BUFFER
-;      Creates a DHCP request packet.
+    cld
-;
-;***************************************************************************
+    rep     stosb
 buildRequest:
-    ; Clear dhcpMsg to all zeros
+    mov     edx, dhcpMsg
-    xor     eax,eax
-    mov     edi,dhcpMsg
-    mov     ecx,512
+    mov     [edx], byte 0x01		    ; Boot request
-    cld
+    mov     [edx+1], byte 0x01		    ; Ethernet
-    rep     stosb
+    mov     [edx+2], byte 0x06		    ; Ethernet h/w len
-    mov     edx, dhcpMsg
+    mov     [edx+4], dword 0x11223344	    ; xid
+    mov     eax,[currTime]
-    mov     [edx], byte 0x01		    ; Boot request
-    mov     [edx+1], byte 0x01		    ; Ethernet
+    mov     [edx+8], eax		    ; secs, our uptime
-    mov     [edx+2], byte 0x06		    ; Ethernet h/w len
+    mov     [edx+10], byte 0x80 	    ; broadcast flag set
-    mov     [edx+4], dword 0x11223344	    ; xid
-    mov     [edx+10], byte 0x80 	    ; broadcast flag set
-    mov     [edx+236], dword 0x63538263     ; magic number
+    mov     eax, dword [MAC]		    ; first 4 bytes of MAC
-    ; option DHCP msg type
-    mov     [edx+240], word 0x0135
+    mov     [edx+28],dword eax
-    mov     al, [dhcpMsgType]
+    mov     ax, word [MAC+4]		    ; last 2 bytes of MAC
-    mov     [edx+240+2], al
+    mov     [edx+32],word ax
-    ; option Lease time = infinity
-    mov     [edx+240+3], word 0x0433
-    mov     eax, [dhcpLease]
+    mov     [edx+236], dword 0x63538263     ; magic number
     mov     [edx+240+5], eax
     mov     [edx+240], word 0x0135	    ; option DHCP msg type
-;    ; option requested IP address
-    mov     [edx+240+9], word 0x0432
+    mov     al, [dhcpMsgType]
-;    mov     eax, [dhcpClientIP]
+    mov     [edx+240+2], al
 ;    mov     [edx+240+11], eax
+    mov     [edx+240+3], word 0x0433	    ; option Lease time = infinity
-    ; option request list
-    mov     [edx+240+15], word 0x0437
-    mov     [edx+240+17], dword 0x0f060301
-    ; Check which msg we are sending
-    cmp     [dhcpMsgType], byte 0x01
-    jne     br001
-    ; "Discover" options
+    mov     eax, [dhcpLease]
-    ; end of options marker
+    mov     [edx+240+5], eax
-    mov     [edx+240+21], byte 0xff
-    mov     [dhcpMsgLen], dword 262
-    jmp     ctr000
+    mov     [edx+240+9], word 0x0432	    ; option requested IP address
-br001:
+    mov     eax, [dhcpClientIP]
-    ; "Request" options
-    ; server IP
-    mov     [edx+240+21], word 0x0436
+    mov     [edx+240+11], eax
-    mov     eax, [dhcpServerIP]
-    mov     [edx+240+23], eax
+    mov     [edx+240+15], word 0x0437	    ; option request list
-    ; end of options marker
-    mov     [edx+240+27], byte 0xff
+    mov     [edx+240+17], dword 0x0f060301
-    mov     [dhcpMsgLen], dword 268
-ctr000:
-    ; write to socket ( send broadcast request )
-    mov     eax, 53
-    mov     ebx, 4
-    mov     ecx, [socketNum]
-    mov     edx, [dhcpMsgLen]
-    mov     esi, dhcpMsg
-    int     0x40
+    cmp     [dhcpMsgType], byte 0x01	    ; Check which msg we are sending
-    ; Setup the DHCP buffer to receive response
-    mov     eax, dhcpMsg
-    mov     [dhcpMsgLen], eax	   ; Used as a pointer to the data
-    ; now, we wait for data from remote
-wait_for_data:
-    mov     eax,23		   ; wait here for event   NOTE a TIME-OUT should be placed here
+    jne     br001
+    mov     [edx+240+21], byte 0xff	    ; "Discover" options
-    mov     ebx,TIMEOUT*100
-    int     0x40
+    mov     [dhcpMsgLen], dword 262	    ; end of options marker
     jmp     ctr000
     ; Any data in the UDP receive buffer?
-    mov     eax, 53
+br001:					    ; "Request" options
     mov     ebx, 2
-    mov     ecx, [socketNum]
+    mov     [edx+240+21], word 0x0436	    ; server IP
-    int     0x40
+    mov     eax, [dhcpServerIP]
-    cmp     eax, 0
+    mov     [edx+240+23], eax
     jne     ctr002
     mov     [edx+240+27], byte 0xff	    ; end of options marker
-if DEBUG = 1
-    dps  "DHCP: Timeout!"
-    newline
-end if
+    mov     [dhcpMsgLen], dword 268
-    jmp    close
+ctr000:
-    ; we have data - this will be the response
-ctr002:
+    eth.write_udp [socketNum],[dhcpMsgLen],dhcpMsg    ; write to socket ( send broadcast request )
     mov     eax, 53
-    mov     ebx, 3
-    mov     ecx, [socketNum]
+    mov     eax, dhcpMsg		    ; Setup the DHCP buffer to receive response
-    int     0x40		; read byte - block (high byte)
+    mov     [dhcpMsgLen], eax		    ; Used as a pointer to the data
-    ; Store the data in the response buffer
-    mov     eax, [dhcpMsgLen]
-    mov     [eax], bl
+    mov     eax,23			    ; wait here for event (data from remote)
-    inc     dword [dhcpMsgLen]
+    mov     ebx,TIMEOUT*10
+    int     0x40
-    mov     eax, 53
-    mov     ebx, 2
-    mov     ecx, [socketNum]
-    int     0x40		; any more data?
+    eth.poll [socketNum]
+    test    eax,eax
-    cmp     eax, 0
-    jne     ctr002		; yes, so get it
-    ; 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
-    ;  2) else exit ( display error )
-    ; If the response is to a dhcp request, then:
-    ;  1) If the response is DHCP ACK then
+    jnz     ctr002
     ;  1.1) extract the DNS & subnet fields. Set them in the stack
-    ;  2) else exit ( display error )
+    DEBUGF  2,"DHCP: Timeout!\n"
     eth.close_udp [socketNum]
 ;       dhcpDNSIP, dhcpSubnet
 ;      The message is stored in dhcpMsg
+;
 ;***************************************************************************
 parseResponse:
-if DEBUG = 1
-    dps  "DHCP: Data received, parsing response"
+    DEBUGF  1,"DHCP: Data received, parsing response\n"
-    newline
-end if
     mov     edx, dhcpMsg
-    pusha
-    mov     eax,52	    ; Set Client IP
+    pusha
-    mov     ebx,3
+    eth.set_IP [edx+16]
-    mov     ecx, [edx+16]
-    int     0x40
-if DEBUG = 1
+    mov     eax,[edx]
-    dps  "DHCP: Client: "
-    xor   esi,esi
-   .loop:
-    pusha
+    mov     [dhcpClientIP],eax
-    movzx eax,byte[edx+esi+16]
-    call  debug_outdec
-    popa
-    inc   esi
-    cmp   esi,4
-    jne   .loop
-    newline
-end if
     DEBUGF  1,"DHCP: Client: %u.%u.%u.%u\n",[edx+16]:1,[edx+17]:1,[edx+18]:1,[edx+19]:1
-    popa
-    ; Scan options
+    popa
-    add     edx, 240	    ; Point to first option
     add     edx, 240	    ; Point to first option
 pr001:
-    ; Get option id
+pr001:
     mov     al, [edx]
     mov     [dhcpMsgType], al
     add     edx, 3
     jmp     pr001	    ; Get next option
-pr002:
-    ; All other (accepted) options are 4 bytes in length
+pr002:
     inc     edx
     movzx   ecx, byte [edx]
     inc     edx 	    ; point to data
     cmp     al, 54	    ; server id
     jne     pr0021
+    mov     eax, [edx]	    ; All options are 4 bytes, so get it
-    mov     eax, [edx]	    ; All options are 4 bytes, so get it
+    mov     [dhcpServerIP], eax
-    mov     [dhcpServerIP], eax
+    DEBUGF  1,"DHCP: Server: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
     jmp     pr003
-pr0021:
-    cmp     al, 51	    ; lease
+pr0021:
-    jne     pr0022
+    cmp     al, 51	    ; lease
-if DEBUG = 1
+    jne     pr0022
+    pusha
+    DEBUGF  1,"DHCP: lease: "
-    pusha
+    mov eax,[edx]
-    dps  "DHCP: lease:  "
+    bswap eax
+    mov  [dhcpLease],eax
-    cmp  dword[edx],-1
+    cmp  dword[edx],-1	    ; i really don't know, how to test it
     jne  no_lease_forever
-    dps  "forever"
-    jmp  lease_newline
+    DEBUGF  1,"forever\n"
-   no_lease_forever:
+    jmp  @f
-    dpd  [edx]
-   lease_newline:
+   no_lease_forever:
-    newline
+    DEBUGF  1,"%d\n",eax
-    popa
+   @@:
-end if
+    popa
-    jmp     pr003
-pr0022:
+    jmp     pr003
-    cmp     al, 1	    ; subnet mask
-    jne     pr0023
-    pusha
-    mov     eax,52
-    mov     ebx,12
-    mov     ecx,[edx]
-    int     0x40
-if DEBUG = 1
-    dps  "DHCP: Subnet: "
 pr0022:
-    xor   esi,esi
-   .loop:
+    cmp     al, 1	    ; subnet mask
-    pusha
+    jne     pr0023
-    movzx eax,byte[edx+esi]
+    pusha
+    eth.set_SUBNET [edx]
+    DEBUGF  1,"DHCP: Subnet: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
+    popa
     call  debug_outdec
-    popa
+    jmp     pr003
     inc   esi
-    cmp   esi,4
+pr0023:
-    jne   .loop
+    cmp     al, 3	    ; gateway ip
-    newline
-end if
+    jne     pr0024
-    popa
+    pusha
+    eth.set_GATEWAY [edx]
+    DEBUGF  1,"DHCP: Gateway: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
-    jmp     pr003
+    popa
-pr0023:
-    cmp     al, 6	    ; dns ip
-    jne     pr0024
+pr0024:
-    pusha
+    cmp     al, 6	    ; dns ip
+    jne     pr003
-    mov     eax,52
+    pusha
-    mov     ebx,14
+    eth.set_DNS [edx]
+    DEBUGF  1,"DHCP: DNS: %u.%u.%u.%u\n",[edx]:1,[edx+1]:1,[edx+2]:1,[edx+3]:1
-    mov     ecx,[edx]
+    popa
+pr003:
+    add     edx, ecx
+    jmp     pr001
+pr_exit:
+;    DEBUGF  1,"DHCP: Sending ARP probe\n"
+;    eth.ARP_ANNOUNCE [dhcpClientIP]      ; send an ARP announc packet
+    eth.get_GATEWAY eax 		  ; if gateway was not set, set it to the DHCP SERVER IP
+    test  eax,eax
+    jnz   close
+    eth.set_GATEWAY [dhcpServerIP]
+    jmp close
+apipa:
+    call random
-    int     0x40
+    mov  ecx,0xfea9			 ; IP 169.254.0.0 link local net, see RFC3927
+    mov  cx,ax
+    eth.set_IP ecx			 ; mask is 255.255.0.0
+    DEBUGF 1,"ZeroConf: Link Local IP assinged: 169.254.%u.%u\n",[generator+2]:1,[generator+3]:1
+    eth.set_SUBNET 0xffff
+    eth.set_GATEWAY 0x0
-if DEBUG = 1
+    eth.set_DNS 0x0
-    dps  "DHCP: DNS IP: "
+    mov   eax,5
+    mov   ebx,PROBE_WAIT*100
+    int   0x40
-    xor   esi,esi
+    xor esi,esi
-   .loop:
+   probe_loop:
-    pusha
+    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
-    movzx eax,byte[edx+esi]
+    jge   @f			       ; all ok
-    call  debug_outdec
+    add   al,(PROBE_MAX-PROBE_MIN)*100 ; al is too small
+   @@:
     popa
+    cmp   al,PROBE_MAX*100
-    inc   esi
-    cmp   esi,4
+    jle   @f
-    jne   .loop
+    sub   al,(PROBE_MAX-PROBE_MIN)*100
-    newline
+   @@:
-end if
+    movzx ebx,al
+    DEBUGF  1,"ZeroConf: Waiting %u0ms\n",ebx
-    popa
+    mov   eax,5
+    int   0x40
-pr0024:
-    cmp     al, 3	    ; gateway ip
-    jne     pr003
-    pusha
+    DEBUGF  1,"ZeroConf: Sending Probe\n"
-    mov     eax,52
+;    eth.ARP_PROBE MAC2
+    inc   esi
+    cmp   esi,PROBE_NUM
+    jl	  probe_loop
-    mov     ebx,11
+; now we wait further ANNOUNCE_WAIT seconds and send ANNOUNCE_NUM ARP announces. If any other host has assingnd
-    mov     ecx,[edx]
+; IP within this time, we should create another adress, that have to be done later
-    int     0x40
+    DEBUGF  1,"ZeroConf: Waiting %us\n",ANNOUNCE_WAIT
+    mov   eax,5
+    mov   ebx,ANNOUNCE_WAIT*100
-if DEBUG = 1
+    int   0x40
+    xor   esi,esi
-    dps  "DHCP: Gateway:"
+   announce_loop:
-    xor   esi,esi
+    DEBUGF  1,"ZeroConf: Sending Announce\n"
-   .loop:
+;    eth.ARP_ANNOUNCE MAC2
-    pusha
+    inc   esi
-    movzx eax,byte[edx+esi]
+    cmp   esi,ANNOUNCE_NUM
-    call  debug_outdec
+    je	  @f
-    popa
+    DEBUGF  1,"ZeroConf: Waiting %us\n",ANNOUNCE_INTERVAL
+    mov   eax,5
+    mov   ebx,ANNOUNCE_INTERVAL*100
+    int   0x40
     jmp   announce_loop
-    inc   esi
+   @@:

Subversion Repositories Kolibri OS

(root)/programs/network/autodhcp/trunk/autodhcp.asm – Rev 109 → 336