Merge pull request #807 from mtomaschewski/timer-time

time: use boot time for timer instead of real time (bsc#1129986)

autoip4/autoip.h

@@ -42,7 +42,7 @@ struct ni_autoip_device {
 	    unsigned int	nprobes;
 	    unsigned int	nclaims;
 	    unsigned int	nconflicts;
-	    time_t		last_defense;
+	    struct timeval	last_defense;
 	} autoip;
 
 	ni_auto4_request_t 	request;

autoip4/fsm.c

@@ -147,25 +147,30 @@ ni_autoip_fsm_conflict(ni_autoip_device_t *dev)
 void
 ni_autoip_fsm_defend(ni_autoip_device_t *dev, const ni_hwaddr_t *hwa)
 {
-	time_t now = time(NULL);
+	struct timeval now, delta;
 
 	if (dev->fsm.state != NI_AUTOIP_STATE_CLAIMED) {
 		ni_error("%s: shouldn't be called in state %s", __FUNCTION__,
 				ni_autoip_fsm_state_name(dev->fsm.state));
 		return;
 	}
 
-	if (dev->autoip.last_defense && now - dev->autoip.last_defense < IPV4LL_DEFEND_INTERVAL) {
-		ni_debug_autoip("%s: failed to defend address %s (claimed by %s)", dev->ifname,
-				inet_ntoa(dev->autoip.candidate),
-				ni_link_address_print(hwa));
-		ni_autoip_fsm_conflict(dev);
-	} else {
-		dev->autoip.last_defense = now;
-		ni_arp_send_reply(dev->arp_socket,
-				dev->autoip.candidate,
-				hwa, dev->autoip.candidate);
+	ni_timer_get_time(&now);
+	if (timerisset(&dev->autoip.last_defense) && timercmp(&now, &dev->autoip.last_defense, >)) {
+		timersub(&now, &dev->autoip.last_defense, &delta);
+		if (delta.tv_sec < IPV4LL_DEFEND_INTERVAL) {
+			ni_debug_autoip("%s: failed to defend address %s (claimed by %s)", dev->ifname,
+					inet_ntoa(dev->autoip.candidate),
+					ni_link_address_print(hwa));
+			ni_autoip_fsm_conflict(dev);
+			return;
+		}
 	}
+
+	dev->autoip.last_defense = now;
+	ni_arp_send_reply(dev->arp_socket,
+			dev->autoip.candidate,
+			hwa, dev->autoip.candidate);
 }
 
 ni_addrconf_lease_t *
@@ -261,13 +266,13 @@ ni_autoip_send_arp(ni_autoip_device_t *dev)
 			dev->fsm.state = NI_AUTOIP_STATE_CLAIMED;
 			ni_autoip_fsm_commit_lease(dev, ni_autoip_fsm_build_lease(dev));
 			dev->autoip.nconflicts = 0;
-			dev->autoip.last_defense = 0;
+			timerclear(&dev->autoip.last_defense);
 		}
 	} else {
 		dev->fsm.state = NI_AUTOIP_STATE_CLAIMED;
 		ni_autoip_fsm_commit_lease(dev, ni_autoip_fsm_build_lease(dev));
 		dev->autoip.nconflicts = 0;
-		dev->autoip.last_defense = 0;
+		timerclear(&dev->autoip.last_defense);
 	}
 	return 0;
 }

include/wicked/socket.h

@@ -39,6 +39,8 @@ extern void *		ni_timer_cancel(const ni_timer_t *);
 extern const ni_timer_t *ni_timer_rearm(const ni_timer_t *, unsigned long);
 extern long		ni_timer_next_timeout(void);
 extern int		ni_timer_get_time(struct timeval *tv);
+extern int		ni_time_timer_to_real(const struct timeval *, struct timeval *);
+extern int		ni_time_real_to_timer(const struct timeval *, struct timeval *);
 
 extern ni_socket_t *	ni_socket_hold(ni_socket_t *);
 extern void		ni_socket_release(ni_socket_t *);

include/wicked/wireless.h

@@ -168,7 +168,7 @@ struct ni_wireless_network {
 	unsigned int			fragment_size;		/* used with EAP */
 
 	struct ni_wireless_scan_info {
-		time_t			timestamp;
+		struct timeval 		timestamp;
 		ni_bool_t		updating;		/* retrieving new scan info */
 		int			noise;
 		double			level;			/* in dBm*/
@@ -267,16 +267,16 @@ struct ni_wireless {
 
 struct ni_wireless_scan {
 	/* Scanning interval */
-	unsigned int		interval;
+	unsigned int			interval;
 
 	/* Time in seconds after which we forget BSSes */
-	unsigned int		max_age;
+	unsigned int			max_age;
 
-	time_t			timestamp;
-	time_t			lifetime;
-	ni_wireless_network_array_t networks;
+	struct timeval			timestamp;
+	unsigned int			lifetime;
+	ni_wireless_network_array_t	networks;
 
-	const ni_timer_t *	timer;
+	const ni_timer_t *		timer;
 };
 
 extern void		ni_wireless_set_scanning(ni_bool_t enable);

src/async-resolver.c

@@ -96,21 +96,20 @@ gaicb_list_resolve(struct gaicb **greqs, unsigned int nreqs, unsigned int timeou
 			return -1;
 		}
 
-		gettimeofday(&deadline, NULL);
+		ni_timer_get_time(&deadline);
 		deadline.tv_sec += timeout;
 
 		while (1) {
 			struct timeval delta;
 			struct timespec ts;
 			int status;
 
-			gettimeofday(&now, NULL);
+			ni_timer_get_time(&now);
 			if (timercmp(&now, &deadline, >=))
 				break;
 
 			timersub(&deadline, &now, &delta);
-			ts.tv_sec = delta.tv_sec;
-			ts.tv_nsec = 1000 * delta.tv_usec;
+			TIMEVAL_TO_TIMESPEC(&delta, &ts);
 
 			status = gai_suspend((const struct gaicb * const *) greqs, nreqs, &ts);
 			if (status == EAI_ALLDONE || status == EAI_AGAIN)

src/capture.c

@@ -343,7 +343,7 @@ ni_capture_force_retransmit(ni_capture_t *capture, unsigned int delay)
 	if (timerisset(&capture->retrans.deadline)) {
 		struct timeval *deadline = &capture->retrans.deadline;
 
-		gettimeofday(deadline, NULL);
+		ni_timer_get_time(deadline);
 		deadline->tv_sec += delay;
 	}
 }

src/dbus-objects/wireless.c

@@ -468,7 +468,7 @@ __ni_objectmodel_wireless_get_scan(const ni_dbus_object_t *object,
 	if (!(scan = __ni_objectmodel_get_scan(object, error)))
 		return TRUE;
 
-	ni_dbus_dict_add_uint32(result, "timestamp", scan->timestamp);
+	ni_dbus_dict_add_int64(result, "timestamp", scan->timestamp.tv_sec);
 	for (i = 0; i < scan->networks.count; ++i) {
 		child = ni_dbus_dict_add(result, "network");
 		ni_dbus_variant_init_dict(child);
@@ -488,17 +488,19 @@ __ni_objectmodel_wireless_set_scan(ni_dbus_object_t *object,
 	ni_wireless_t *wlan;
 	ni_wireless_scan_t *scan;
 	const ni_dbus_variant_t *child;
-	uint32_t valu32;
+	int64_t value64;
 
 	if (!(wlan = __ni_objectmodel_wireless_write_handle(object, error)))
 		return FALSE;
 
 	if ((scan = wlan->scan) != NULL)
 		ni_wireless_scan_free(scan);
-	wlan->scan = scan = ni_wireless_scan_new(NULL, 0);
 
-	if (ni_dbus_dict_get_uint32(argument, "timestamp", &valu32))
-		scan->timestamp = valu32;
+	wlan->scan = scan = ni_wireless_scan_new(NULL, 0);
+	if (ni_dbus_dict_get_int64(argument, "timestamp", &value64)) {
+		scan->timestamp.tv_sec = value64;
+		scan->timestamp.tv_usec = 0;
+	}
 
 	child = NULL;
 	while ((child = ni_dbus_dict_get_next(argument, "network", child)) != NULL) {

src/dhcp4/device.c

@@ -58,7 +58,7 @@ ni_dhcp4_device_new(const char *ifname, const ni_linkinfo_t *link)
 		return NULL;
 	}
 
-	dev->start_time = time(NULL);
+	ni_timer_get_time(&dev->start_time);
 	dev->fsm.state = NI_DHCP4_STATE_INIT;
 
 	/* append to end of list */
@@ -184,10 +184,14 @@ ni_dhcp4_device_put(ni_dhcp4_device_t *dev)
 unsigned int
 ni_dhcp4_device_uptime(const ni_dhcp4_device_t *dev, unsigned int clamp)
 {
-	unsigned int uptime;
-
-	uptime = time(NULL) - dev->start_time;
-	return (uptime < clamp)? uptime : clamp;
+	struct timeval now, uptime;
+
+	ni_timer_get_time(&now);
+	if (timercmp(&now, &dev->start_time, >))
+		timersub(&now, &dev->start_time, &uptime);
+	else
+		timerclear(&uptime);
+	return (uptime.tv_sec < clamp) ? uptime.tv_sec : clamp;
 }
 
 void
@@ -693,7 +697,7 @@ ni_dhcp4_device_send_message(ni_dhcp4_device_t *dev, unsigned int msg_code, cons
 	}
 
 	ni_debug_dhcp("%s: sending %s with xid 0x%x in state %s", dev->ifname,
-			ni_dhcp4_message_name(msg_code), htonl(dev->dhcp4.xid),
+			ni_dhcp4_message_name(msg_code), dev->dhcp4.xid,
 			ni_dhcp4_fsm_state_name(dev->fsm.state));
 
 	if ((rv = ni_dhcp4_device_prepare_message(dev)) < 0)
@@ -751,7 +755,7 @@ ni_dhcp4_device_send_message_unicast(ni_dhcp4_device_t *dev, unsigned int msg_co
 		return -1;
 	}
 
-	ni_debug_dhcp("sending %s with xid 0x%x", ni_dhcp4_message_name(msg_code), htonl(dev->dhcp4.xid));
+	ni_debug_dhcp("sending %s with xid 0x%x", ni_dhcp4_message_name(msg_code), dev->dhcp4.xid);
 
 	if (ni_dhcp4_device_prepare_message(dev) < 0)
 		return -1;

src/dhcp4/dhcp4.h

@@ -51,7 +51,7 @@ typedef struct ni_dhcp4_device {
 
 	ni_capture_devinfo_t	system;
 
-	time_t			start_time;	/* when we starting managing */
+	struct timeval		start_time;	/* when we starting managing */
 
 	ni_dhcp4_request_t *	request;
 	ni_dhcp4_config_t *	config;