Ticket #13385: dhcp.patch

src/servers/net/DHCPClient.cpp

@@ -39 +39 @@
 #define DHCP_CLIENT_PORT    68
 #define DHCP_SERVER_PORT    67
 
-#define DEFAULT_TIMEOUT     4   // secs
-#define MAX_TIMEOUT         64  // secs
+#define DEFAULT_TIMEOUT     0.25    // secs
+#define MAX_TIMEOUT         64      // secs
+
+#define AS_USECS(t) (1000000 * t)
 
 #define MAX_RETRIES         5
 
@@ -152 +154 @@
     static const char* TypeToString(message_type type);
 } _PACKED;
 
+struct socket_timeout {
+    socket_timeout(int socket)
+        :
+        timeout(AS_USECS(DEFAULT_TIMEOUT)),
+        tries(0)
+    {
+        UpdateSocket(socket);
+    }
+
+    time_t timeout; // in micro secs
+    int tries;
+
+    bool Shift(int socket, bigtime_t stateMaxTime, const char* device);
+    void UpdateSocket(int socket) const;
+};
+
 #define DHCP_FLAG_BROADCAST     0x8000
 
 #define ARP_HARDWARE_TYPE_ETHER 1
@@ -417 +435 @@
 }
 
 
+void
+socket_timeout::UpdateSocket(int socket) const
+{
+    struct timeval value;
+    value.tv_sec = timeout / 1000000;
+    value.tv_usec = timeout % 1000000;
+    setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &value, sizeof(value));
+}
+
+
+bool
+socket_timeout::Shift(int socket, bigtime_t stateMaxTime, const char* device)
+{
+    tries++;
+    timeout += timeout;
+    if (timeout > AS_USECS(MAX_TIMEOUT))
+        timeout = AS_USECS(MAX_TIMEOUT);
+
+    if (tries > MAX_RETRIES) {
+        if (stateMaxTime == -1)
+            return false;
+        bigtime_t remaining = (stateMaxTime - system_time()) / 2 + 1;
+        timeout = std::min(remaining, (bigtime_t)AS_USECS(MAX_TIMEOUT));
+    }
+
+    syslog(LOG_DEBUG, "%s: Timeout shift: %lu secs (try %lu)\n",
+        device, timeout, tries);
+
+    UpdateSocket(socket);
+    return true;
+}
+
+
 //  #pragma mark -
 
 
@@ -652 +703 @@
     BNetworkAddress broadcast;
     broadcast.SetToBroadcast(AF_INET, DHCP_SERVER_PORT);
 
-    time_t timeout;
-    uint32 tries;
-    _ResetTimeout(socket, state, timeout, tries);
+    socket_timeout timeout(socket);
 
     dhcp_message discover(DHCP_DISCOVER);
     _PrepareMessage(discover, state);
@@ -684 +733 @@
             0, (struct sockaddr*)&from, &fromLength);
         if (bytesReceived < 0 && errno == B_TIMED_OUT) {
             // depending on the state, we'll just try again
-            if (!_TimeoutShift(socket, state, timeout, tries))
+            if (!_TimeoutShift(socket, state, timeout))
                 return B_TIMED_OUT;
             skipRequest = false;
             continue;
@@ -893 +942 @@
 }
 
 
-void
-DHCPClient::_ResetTimeout(int socket, dhcp_state& state, time_t& timeout,
-    uint32& tries)
-{
-    timeout = DEFAULT_TIMEOUT;
-    tries = 0;
-
-    struct timeval value;
-    value.tv_sec = timeout;
-    value.tv_usec = rand() % 1000000;
-    setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &value, sizeof(value));
-}
-
-
 bool
-DHCPClient::_TimeoutShift(int socket, dhcp_state& state, time_t& timeout,
-    uint32& tries)
+DHCPClient::_TimeoutShift(int socket, dhcp_state& state,
+    socket_timeout& timeout)
 {
-    if (state == RENEWING && system_time() > fRebindingTime) {
-        state = REBINDING;
+    bigtime_t stateMaxTime = -1;
+    if (state == RENEWING)
+        stateMaxTime = fRebindingTime;
+    else if (state == REBINDING)
+        stateMaxTime = fLeaseTime;
+
+    if (system_time() > stateMaxTime) {
+        state = state == REBINDING ? INIT : REBINDING;
         return false;
     }
 
-    if (state == REBINDING && system_time() > fLeaseTime) {
-        state = INIT;
-        return false;
-    }
-
-    tries++;
-    timeout += timeout;
-    if (timeout > MAX_TIMEOUT)
-        timeout = MAX_TIMEOUT;
-
-    if (tries > MAX_RETRIES) {
-        bigtime_t remaining = 0;
-        if (state == RENEWING)
-            remaining = (fRebindingTime - system_time()) / 2 + 1;
-        else if (state == REBINDING)
-            remaining = (fLeaseTime - system_time()) / 2 + 1;
-        else
-            return false;
-
-        timeout = std::max(remaining / 1000000, bigtime_t(60));
-    }
-
-    syslog(LOG_DEBUG, "%s: Timeout shift: %lu secs (try %lu)\n",
-        Device(), timeout, tries);
-
-    struct timeval value;
-    value.tv_sec = timeout;
-    value.tv_usec = rand() % 1000000;
-    setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &value, sizeof(value));
-
-    return true;
+    return timeout.Shift(socket, stateMaxTime, Device());
 }
 
 

src/servers/net/DHCPClient.h

@@ -18 +18 @@
 
 class BMessageRunner;
 class dhcp_message;
+class socket_timeout;
 
 
 enum dhcp_state {
@@ -55 +56 @@
             status_t            _SendMessage(int socket, dhcp_message& message,
                                     const BNetworkAddress& address) const;
             dhcp_state          _CurrentState() const;
-            void                _ResetTimeout(int socket, dhcp_state& state,
-                                    time_t& timeout, uint32& tries);
             bool                _TimeoutShift(int socket, dhcp_state& state,
-                                    time_t& timeout, uint32& tries);
+                                    socket_timeout& timeout);
             void                _RestartLease(bigtime_t lease);
 
     static  BString             _AddressToString(const uint8* data);