X-Git-Url: http://git.openwrt.org/?a=blobdiff_plain;f=src%2Fdhcpv6.c;h=51b99924991e1ea46f06142a1f9e20bf3c65ff9e;hb=eac1961983b8e7a74c494feedcb878170b135072;hp=742c3b007987eca7871fb4494eaf88a2ecd3f270;hpb=a477e955b41d2e18ad402e91603bdf0d108490e7;p=project%2Fodhcp6c.git

diff --git a/src/dhcpv6.c b/src/dhcpv6.c
index 742c3b0..51b9992 100644
--- a/src/dhcpv6.c
+++ b/src/dhcpv6.c
@@ -59,9 +59,9 @@ static bool dhcpv6_response_is_valid(const void *buf, ssize_t len,
 		const uint8_t transaction[3], enum dhcpv6_msg type,
 		const struct in6_addr *daddr);
 
-static int dhcpv6_parse_ia(void *opt, void *end);
+static unsigned int dhcpv6_parse_ia(void *opt, void *end);
 
-static int dhcpv6_calc_refresh_timers(void);
+static unsigned int dhcpv6_calc_refresh_timers(void);
 static void dhcpv6_handle_status_code(_unused const enum dhcpv6_msg orig,
 		const uint16_t code, const void *status_msg, const int len,
 		int *ret);
@@ -103,7 +103,6 @@ static int ifindex = -1;
 static int64_t t1 = 0, t2 = 0, t3 = 0;
 
 // IA states
-static int request_prefix = -1;
 static enum odhcp6c_ia_mode na_mode = IA_MODE_NONE, pd_mode = IA_MODE_NONE;
 static bool accept_reconfig = false;
 // Server unicast address
@@ -123,6 +122,77 @@ static uint32_t ntohl_unaligned(const uint8_t *data)
 	return ntohl(buf);
 }
 
+static char *dhcpv6_msg_to_str(enum dhcpv6_msg msg)
+{
+	switch (msg) {
+	case DHCPV6_MSG_SOLICIT:
+		return "SOLICIT";
+
+	case DHCPV6_MSG_ADVERT:
+		return "ADVERTISE";
+
+	case DHCPV6_MSG_REQUEST:
+		return "REQUEST";
+
+	case DHCPV6_MSG_RENEW:
+		return "RENEW";
+
+	case DHCPV6_MSG_REBIND:
+		return "REBIND";
+
+	case DHCPV6_MSG_REPLY:
+		return "REPLY";
+
+	case DHCPV6_MSG_RELEASE:
+		return "RELEASE";
+
+	case DHCPV6_MSG_DECLINE:
+		return "DECLINE";
+
+	case DHCPV6_MSG_RECONF:
+		return "RECONFIGURE";
+
+	case DHCPV6_MSG_INFO_REQ:
+		return "INFORMATION REQUEST";
+
+	default:
+		break;
+	}
+
+	return "UNKNOWN";
+}
+
+static char *dhcpv6_status_code_to_str(uint16_t code)
+{
+	switch (code) {
+	case DHCPV6_Success:
+		return "Success";
+
+	case DHCPV6_UnspecFail:
+		return "Unspecified Failure";
+
+	case DHCPV6_NoAddrsAvail:
+		return "No Address Available";
+
+	case DHCPV6_NoBinding:
+		return "No Binding";
+
+	case DHCPV6_NotOnLink:
+		return "Not On Link";
+
+	case DHCPV6_UseMulticast:
+		return "Use Multicast";
+
+	case DHCPV6_NoPrefixAvail:
+		return "No Prefix Available";
+
+	default:
+		break;
+	}
+
+	return "Unknown";
+}
+
 int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
 {
 	client_options = options;
@@ -130,13 +200,14 @@ int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
 
 	sock = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
 	if (sock < 0)
-		return -1;
+		goto failure;
 
 	// Detect interface
 	struct ifreq ifr;
-	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+	memset(&ifr, 0, sizeof(ifr));
+	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
 	if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0)
-		return -1;
+		goto failure;
 
 	ifindex = ifr.ifr_ifindex;
 
@@ -182,13 +253,10 @@ int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
 			htons(DHCPV6_OPT_SIP_SERVER_A),
 			htons(DHCPV6_OPT_DNS_SERVERS),
 			htons(DHCPV6_OPT_DNS_DOMAIN),
-			htons(DHCPV6_OPT_UNICAST),
 			htons(DHCPV6_OPT_SNTP_SERVERS),
 			htons(DHCPV6_OPT_NTP_SERVER),
 			htons(DHCPV6_OPT_AFTR_NAME),
 			htons(DHCPV6_OPT_PD_EXCLUDE),
-			htons(DHCPV6_OPT_SOL_MAX_RT),
-			htons(DHCPV6_OPT_INF_MAX_RT),
 #ifdef EXT_CER_ID
 			htons(DHCPV6_OPT_CER_ID),
 #endif
@@ -198,27 +266,46 @@ int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
 		};
 		odhcp6c_add_state(STATE_ORO, oro, sizeof(oro));
 	}
+	// Required oro
+	uint16_t req_oro[] = {
+		htons(DHCPV6_OPT_INF_MAX_RT),
+		htons(DHCPV6_OPT_SOL_MAX_RT),
+		htons(DHCPV6_OPT_INFO_REFRESH),
+	};
+	odhcp6c_add_state(STATE_ORO, req_oro, sizeof(req_oro));
 
 	// Configure IPv6-options
 	int val = 1;
-	setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val));
-	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
-	setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &val, sizeof(val));
-	setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname));
+	if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val)) < 0)
+		goto failure;
+
+	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0)
+		goto failure;
+
+	if (setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &val, sizeof(val)) < 0)
+		goto failure;
+
+	if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname)) < 0)
+		goto failure;
 
 	struct sockaddr_in6 client_addr = { .sin6_family = AF_INET6,
 		.sin6_port = htons(DHCPV6_CLIENT_PORT), .sin6_flowinfo = 0 };
 
 	if (bind(sock, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0)
-		return -1;
+		goto failure;
 
 	return 0;
+
+failure:
+	if (sock >= 0)
+		close(sock);
+
+	return -1;
 }
 
 enum {
 	IOV_HDR=0,
 	IOV_ORO,
-	IOV_ORO_REFRESH,
 	IOV_CL_ID,
 	IOV_SRV_ID,
 	IOV_OPTS,
@@ -380,9 +467,6 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 		}
 	}
 
-	if (ia_pd_entries > 0)
-		request_prefix = 1;
-
 	// Build IA_NAs
 	size_t ia_na_entries, ia_na_len = 0;
 	void *ia_na = NULL;
@@ -420,16 +504,39 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 		uint16_t length;
 	} reconf_accept = {htons(DHCPV6_OPT_RECONF_ACCEPT), 0};
 
-	// Request Information Refresh
-	uint16_t oro_refresh = htons(DHCPV6_OPT_INFO_REFRESH);
-
 	// Option list
 	size_t opts_len;
 	void *opts = odhcp6c_get_state(STATE_OPTS, &opts_len);
 
+	// Option Request List
+	size_t oro_entries, oro_len = 0;
+	uint16_t *oro, *s_oro = odhcp6c_get_state(STATE_ORO, &oro_entries);
+
+	oro_entries /= sizeof(*s_oro);
+	oro = alloca(oro_entries * sizeof(*oro));
+
+	for (size_t i = 0; i < oro_entries; i++) {
+		struct odhcp6c_opt *opt = odhcp6c_find_opt(htons(s_oro[i]));
+
+		if (opt) {
+			if (!(opt->flags & OPT_ORO))
+				continue;
+
+			if ((opt->flags & OPT_ORO_SOLICIT) && type != DHCPV6_MSG_SOLICIT)
+				continue;
+
+			if ((opt->flags & OPT_ORO_STATELESS) && type != DHCPV6_MSG_INFO_REQ)
+				continue;
+
+			if ((opt->flags & OPT_ORO_STATEFUL) && type == DHCPV6_MSG_INFO_REQ)
+				continue;
+		}
+
+		oro[oro_len++] = s_oro[i];
+	}
+	oro_len *= sizeof(*oro);
+
 	// Prepare Header
-	size_t oro_len;
-	void *oro = odhcp6c_get_state(STATE_ORO, &oro_len);
 	struct {
 		uint8_t type;
 		uint8_t trid[3];
@@ -448,7 +555,6 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 	struct iovec iov[IOV_TOTAL] = {
 		[IOV_HDR] = {&hdr, sizeof(hdr)},
 		[IOV_ORO] = {oro, oro_len},
-		[IOV_ORO_REFRESH] = {&oro_refresh, 0},
 		[IOV_CL_ID] = {cl_id, cl_id_len},
 		[IOV_SRV_ID] = {srv_id, srv_id_len},
 		[IOV_OPTS] = { opts, opts_len },
@@ -460,12 +566,8 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 	};
 
 	size_t cnt = IOV_TOTAL;
-	if (type == DHCPV6_MSG_INFO_REQ) {
-		cnt = 9;
-		iov[IOV_ORO_REFRESH].iov_len = sizeof(oro_refresh);
-		hdr.oro_len = htons(oro_len + sizeof(oro_refresh));
-	} else if (!request_prefix)
-		cnt = 13;
+	if (type == DHCPV6_MSG_INFO_REQ)
+		cnt = IOV_HDR_IA_NA;
 
 	// Disable IAs if not used
 	if (type != DHCPV6_MSG_SOLICIT && ia_na_len == 0)
@@ -505,7 +607,8 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 	if (sendmsg(sock, &msg, 0) < 0) {
 		char in6_str[INET6_ADDRSTRLEN];
 
-		syslog(LOG_ERR, "Failed to send DHCPV6 message to %s (%s)",
+		syslog(LOG_ERR, "Failed to send %s message to %s (%s)",
+			dhcpv6_msg_to_str(type),
 			inet_ntop(AF_INET6, (const void *)&srv.sin6_addr,
 				in6_str, sizeof(in6_str)), strerror(errno));
 	}
@@ -607,6 +710,7 @@ int dhcpv6_request(enum dhcpv6_msg type)
 					.msg_iov = &iov, .msg_iovlen = 1, .msg_control = cmsg_buf.buf,
 					.msg_controllen = sizeof(cmsg_buf)};
 			struct in6_pktinfo *pktinfo = NULL;
+			const struct dhcpv6_header *hdr = (const struct dhcpv6_header *)buf;
 
 			// Check for pending signal
 			if (odhcp6c_signal_process())
@@ -615,8 +719,10 @@ int dhcpv6_request(enum dhcpv6_msg type)
 			// Set timeout for receiving
 			uint64_t t = round_end - round_start;
 			struct timeval tv = {t / 1000, (t % 1000) * 1000};
-			setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
-					&tv, sizeof(tv));
+			if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
+					&tv, sizeof(tv)) < 0)
+				syslog(LOG_ERR, "setsockopt SO_RCVTIMEO failed (%s)",
+						strerror(errno));
 
 			// Receive cycle
 			len = recvmsg(sock, &msg, 0);
@@ -648,8 +754,8 @@ int dhcpv6_request(enum dhcpv6_msg type)
 
 			round_start = odhcp6c_get_milli_time();
 			elapsed = round_start - start;
-			syslog(LOG_NOTICE, "Got a valid reply after %"PRIu64"ms",
-					elapsed);
+			syslog(LOG_NOTICE, "Got a valid %s after %"PRIu64"ms",
+			       dhcpv6_msg_to_str(hdr->msg_type), elapsed);
 
 			if (retx->handler_reply)
 				len = retx->handler_reply(type, rc, opt, opt_end, &addr);
@@ -774,8 +880,21 @@ int dhcpv6_poll_reconfigure(void)
 {
 	int ret = dhcpv6_request(DHCPV6_MSG_UNKNOWN);
 
-	if (ret != -1)
+	switch (ret) {
+	/*
+	 * Only RENEW/REBIND/INFORMATION REQUEST
+	 * message transmission can be requested
+	 * by a RECONFIGURE
+	 */
+	case DHCPV6_MSG_RENEW:
+	case DHCPV6_MSG_REBIND:
+	case DHCPV6_MSG_INFO_REQ:
 		ret = dhcpv6_request(ret);
+		break;
+
+	default:
+		break;
+	}
 
 	return ret;
 }
@@ -785,7 +904,7 @@ static int dhcpv6_handle_reconfigure(enum dhcpv6_msg orig, const int rc,
 {
 	uint16_t otype, olen;
 	uint8_t *odata;
-	int msg = -1;
+	enum dhcpv6_msg msg = DHCPV6_MSG_UNKNOWN;
 
 	dhcpv6_for_each_option(opt, end, otype, olen, odata) {
 		if (otype == DHCPV6_OPT_RECONF_MESSAGE && olen == 1) {
@@ -800,6 +919,8 @@ static int dhcpv6_handle_reconfigure(enum dhcpv6_msg orig, const int rc,
 			// Fall through
 			case DHCPV6_MSG_INFO_REQ:
 				msg = odata[0];
+				syslog(LOG_NOTICE, "Need to respond with %s in reply to %s",
+				       dhcpv6_msg_to_str(msg), dhcpv6_msg_to_str(DHCPV6_MSG_RECONF));
 				break;
 
 			default:
@@ -808,9 +929,10 @@ static int dhcpv6_handle_reconfigure(enum dhcpv6_msg orig, const int rc,
 		}
 	}
 
-	dhcpv6_handle_reply(orig, rc, NULL, NULL, NULL);
+	if (msg != DHCPV6_MSG_UNKNOWN)
+		dhcpv6_handle_reply(orig, rc, NULL, NULL, NULL);
 
-	return msg;
+	return (msg == DHCPV6_MSG_UNKNOWN? -1: (int)msg);
 }
 
 // Collect all advertised servers
@@ -827,7 +949,8 @@ static int dhcpv6_handle_advert(enum dhcpv6_msg orig, const int rc,
 
 	dhcpv6_for_each_option(opt, end, otype, olen, odata) {
 		if (orig == DHCPV6_MSG_SOLICIT &&
-				(otype == DHCPV6_OPT_IA_PD || otype == DHCPV6_OPT_IA_NA) &&
+				((otype == DHCPV6_OPT_IA_PD && pd_mode != IA_MODE_NONE) ||
+				 (otype == DHCPV6_OPT_IA_NA && na_mode != IA_MODE_NONE)) &&
 				olen > -4 + sizeof(struct dhcpv6_ia_hdr)) {
 			struct dhcpv6_ia_hdr *ia_hdr = (void*)(&odata[-4]);
 			dhcpv6_parse_ia(ia_hdr, odata + olen + sizeof(*ia_hdr));
@@ -840,7 +963,9 @@ static int dhcpv6_handle_advert(enum dhcpv6_msg orig, const int rc,
 				cand.preference >= 0) {
 			cand.preference = pref = odata[0];
 		} else if (otype == DHCPV6_OPT_UNICAST && olen == sizeof(cand.server_addr)) {
-			cand.server_addr = *(struct in6_addr *)odata;
+			if (!(client_options & DHCPV6_IGNORE_OPT_UNICAST))
+				cand.server_addr = *(struct in6_addr *)odata;
+
 		} else if (otype == DHCPV6_OPT_RECONF_ACCEPT) {
 			cand.wants_reconfigure = true;
 		} else if (otype == DHCPV6_OPT_SOL_MAX_RT && olen == 4) {
@@ -855,7 +980,7 @@ static int dhcpv6_handle_advert(enum dhcpv6_msg orig, const int rc,
 					inf_max_rt <= DHCPV6_INF_MAX_RT_MAX)
 				cand.inf_max_rt = inf_max_rt;
 
-		} else if (otype == DHCPV6_OPT_IA_PD && request_prefix &&
+		} else if (otype == DHCPV6_OPT_IA_PD &&
 					olen >= -4 + sizeof(struct dhcpv6_ia_hdr)) {
 			struct dhcpv6_ia_hdr *h = (struct dhcpv6_ia_hdr*)&odata[-4];
 			uint8_t *oend = odata + olen, *d;
@@ -934,6 +1059,8 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
 	uint16_t otype, olen;
 	uint32_t refresh = 86400;
 	int ret = 1;
+	unsigned int state_IAs;
+	unsigned int updated_IAs = 0;
 	bool handled_status_codes[_DHCPV6_Status_Max] = { false, };
 
 	odhcp6c_expire();
@@ -988,7 +1115,7 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
 
 		// Parse and find all matching IAs
 		dhcpv6_for_each_option(opt, end, otype, olen, odata) {
-			bool passthru = true;
+			struct odhcp6c_opt *dopt = odhcp6c_find_opt(otype);
 
 			if ((otype == DHCPV6_OPT_IA_PD || otype == DHCPV6_OPT_IA_NA)
 					&& olen > -4 + sizeof(struct dhcpv6_ia_hdr)) {
@@ -1030,18 +1157,18 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
 				if (code != DHCPV6_Success)
 					continue;
 
-				dhcpv6_parse_ia(ia_hdr, odata + olen);
-				passthru = false;
+				updated_IAs += dhcpv6_parse_ia(ia_hdr, odata + olen);
 			} else if (otype == DHCPV6_OPT_UNICAST && olen == sizeof(server_addr)) {
-				server_addr = *(struct in6_addr *)odata;
-				passthru = false;
-			} else if (otype == DHCPV6_OPT_STATUS && olen >= 2) {
+				if (!(client_options & DHCPV6_IGNORE_OPT_UNICAST))
+					server_addr = *(struct in6_addr *)odata;
+
+			}
+			else if (otype == DHCPV6_OPT_STATUS && olen >= 2) {
 				uint8_t *mdata = (olen > 2) ? &odata[2] : NULL;
 				uint16_t mlen = (olen > 2) ? olen - 2 : 0;
 				uint16_t code = ((int)odata[0]) << 8 | ((int)odata[1]);
 
 				dhcpv6_handle_status_code(orig, code, mdata, mlen, &ret);
-				passthru = false;
 			} else if (otype == DHCPV6_OPT_DNS_SERVERS) {
 				if (olen % 16 == 0)
 					odhcp6c_add_state(STATE_DNS, odata, olen);
@@ -1071,7 +1198,6 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
 				odhcp6c_add_state(STATE_SIP_FQDN, odata, olen);
 			else if (otype == DHCPV6_OPT_INFO_REFRESH && olen >= 4) {
 				refresh = ntohl_unaligned(odata);
-				passthru = false;
 			} else if (otype == DHCPV6_OPT_AUTH) {
 				if (olen == -4 + sizeof(struct dhcpv6_auth_reconfigure)) {
 					struct dhcpv6_auth_reconfigure *r = (void*)&odata[-4];
@@ -1079,25 +1205,21 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
 							r->reconf_type == 1)
 						memcpy(reconf_key, r->key, sizeof(r->key));
 				}
-				passthru = false;
 			} else if (otype == DHCPV6_OPT_AFTR_NAME && olen > 3) {
 				size_t cur_len;
 				odhcp6c_get_state(STATE_AFTR_NAME, &cur_len);
 				if (cur_len == 0)
 					odhcp6c_add_state(STATE_AFTR_NAME, odata, olen);
-				passthru = false;
 			} else if (otype == DHCPV6_OPT_SOL_MAX_RT && olen == 4) {
 				uint32_t sol_max_rt = ntohl_unaligned(odata);
 				if (sol_max_rt >= DHCPV6_SOL_MAX_RT_MIN &&
 						sol_max_rt <= DHCPV6_SOL_MAX_RT_MAX)
 					dhcpv6_retx[DHCPV6_MSG_SOLICIT].max_timeo = sol_max_rt;
-				passthru = false;
 			} else if (otype == DHCPV6_OPT_INF_MAX_RT && olen == 4) {
 				uint32_t inf_max_rt = ntohl_unaligned(odata);
 				if (inf_max_rt >= DHCPV6_INF_MAX_RT_MIN &&
 						inf_max_rt <= DHCPV6_INF_MAX_RT_MAX)
 					dhcpv6_retx[DHCPV6_MSG_INFO_REQ].max_timeo = inf_max_rt;
-				passthru = false;
 	#ifdef EXT_CER_ID
 			} else if (otype == DHCPV6_OPT_CER_ID && olen == -4 +
 					sizeof(struct dhcpv6_cer_id)) {
@@ -1105,75 +1227,103 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
 				struct in6_addr any = IN6ADDR_ANY_INIT;
 				if (memcmp(&cer_id->addr, &any, sizeof(any)))
 					odhcp6c_add_state(STATE_CER, &cer_id->addr, sizeof(any));
-				passthru = false;
 	#endif
 			} else if (otype == DHCPV6_OPT_S46_CONT_MAPT) {
 				odhcp6c_add_state(STATE_S46_MAPT, odata, olen);
-				passthru = false;
 			} else if (otype == DHCPV6_OPT_S46_CONT_MAPE) {
 				size_t mape_len;
 				odhcp6c_get_state(STATE_S46_MAPE, &mape_len);
 				if (mape_len == 0)
 					odhcp6c_add_state(STATE_S46_MAPE, odata, olen);
-				passthru = false;
 			} else if (otype == DHCPV6_OPT_S46_CONT_LW) {
 				odhcp6c_add_state(STATE_S46_LW, odata, olen);
-				passthru = false;
-			} else if (otype == DHCPV6_OPT_CLIENTID ||
-					otype == DHCPV6_OPT_SERVERID ||
-					otype == DHCPV6_OPT_IA_TA ||
-					otype == DHCPV6_OPT_PREF ||
-					otype == DHCPV6_OPT_UNICAST ||
-					otype == DHCPV6_OPT_FQDN ||
-					otype == DHCPV6_OPT_RECONF_ACCEPT)
-				passthru = false;
-			else
+			} else
 				odhcp6c_add_state(STATE_CUSTOM_OPTS, &odata[-4], olen + 4);
 
-			if (passthru)
+			if (!dopt || !(dopt->flags & OPT_NO_PASSTHRU))
 				odhcp6c_add_state(STATE_PASSTHRU, &odata[-4], olen + 4);
 		}
 	}
 
+	// Bail out if fatal status code was received
+	if (ret <= 0)
+		return ret;
+
 	switch (orig) {
 	case DHCPV6_MSG_REQUEST:
 	case DHCPV6_MSG_REBIND:
 	case DHCPV6_MSG_RENEW:
-		// Update refresh timers if no fatal status code was received
-		if ((ret > 0) && (ret = dhcpv6_calc_refresh_timers())) {
-			if (orig == DHCPV6_MSG_REQUEST) {
-				// All server candidates can be cleared if not yet bound
-				if (!odhcp6c_is_bound())
-					dhcpv6_clear_all_server_cand();
-
-				odhcp6c_clear_state(STATE_SERVER_ADDR);
-				odhcp6c_add_state(STATE_SERVER_ADDR, &from->sin6_addr, 16);
-			} else if (orig == DHCPV6_MSG_RENEW) {
-				// Send further renews if T1 is not set
-				if (!t1)
-					ret = -1;
-
-			} else if (orig == DHCPV6_MSG_REBIND) {
-				// Send further rebinds if T1 and T2 is not set
-				if (!t1 && !t2)
-					ret = -1;
-
-				odhcp6c_clear_state(STATE_SERVER_ADDR);
-				odhcp6c_add_state(STATE_SERVER_ADDR, &from->sin6_addr, 16);
-			}
+		state_IAs = dhcpv6_calc_refresh_timers();
+		// In case there're no state IA entries
+		// keep sending request/renew/rebind messages
+		if (state_IAs == 0) {
+			ret = 0;
+			break;
 		}
-		break;
 
-	case DHCPV6_MSG_INFO_REQ:
-		if (ret > 0) {
+		if (orig == DHCPV6_MSG_REQUEST) {
 			// All server candidates can be cleared if not yet bound
 			if (!odhcp6c_is_bound())
 				dhcpv6_clear_all_server_cand();
 
-			t1 = refresh;
+			odhcp6c_clear_state(STATE_SERVER_ADDR);
+			odhcp6c_add_state(STATE_SERVER_ADDR, &from->sin6_addr, 16);
+		} else if (orig == DHCPV6_MSG_RENEW) {
+			// Send further renews if T1 is not set and if
+			// there're IAs which were not in the Reply message
+			if (!t1 && state_IAs != updated_IAs) {
+				if (updated_IAs)
+					// Publish updates
+					script_call("updated", 0, false);
+
+				/*
+				 * RFC8415 states following in §18.2.10.1 :
+				 * Sends a Renew/Rebind if any of the IAs are not in the Reply
+				 * message, but as this likely indicates that the server that
+				 * responded does not support that IA type, sending immediately is
+				 * unlikely to produce a different result.  Therefore, the client
+				 * MUST rate-limit its transmissions (see Section 14.1) and MAY just
+				 * wait for the normal retransmission time (as if the Reply message
+				 * had not been received).  The client continues to use other
+				 * bindings for which the server did return information
+				 */
+				ret = -1;
+			}
+		} else if (orig == DHCPV6_MSG_REBIND) {
+			odhcp6c_clear_state(STATE_SERVER_ADDR);
+			odhcp6c_add_state(STATE_SERVER_ADDR, &from->sin6_addr, 16);
+
+			// Send further rebinds if T1 and T2 is not set and if
+			// there're IAs which were not in the Reply message
+			if (!t1 && !t2 && state_IAs != updated_IAs) {
+				if (updated_IAs)
+					// Publish updates
+					script_call("updated", 0, false);
+
+				/*
+				 * RFC8415 states following in §18.2.10.1 :
+				 * Sends a Renew/Rebind if any of the IAs are not in the Reply
+				 * message, but as this likely indicates that the server that
+				 * responded does not support that IA type, sending immediately is
+				 * unlikely to produce a different result.  Therefore, the client
+				 * MUST rate-limit its transmissions (see Section 14.1) and MAY just
+				 * wait for the normal retransmission time (as if the Reply message
+				 * had not been received).  The client continues to use other
+				 * bindings for which the server did return information
+				 */
+				ret = -1;
+			}
 		}
 		break;
 
+	case DHCPV6_MSG_INFO_REQ:
+		// All server candidates can be cleared if not yet bound
+		if (!odhcp6c_is_bound())
+			dhcpv6_clear_all_server_cand();
+
+		t1 = refresh;
+		break;
+
 	default:
 		break;
 	}
@@ -1181,13 +1331,14 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
 	return ret;
 }
 
-static int dhcpv6_parse_ia(void *opt, void *end)
+static unsigned int dhcpv6_parse_ia(void *opt, void *end)
 {
 	struct dhcpv6_ia_hdr *ia_hdr = (struct dhcpv6_ia_hdr *)opt;
-	int parsed_ia = 0;
+	unsigned int updated_IAs = 0;
 	uint32_t t1, t2;
 	uint16_t otype, olen;
 	uint8_t *odata;
+	char buf[INET6_ADDRSTRLEN];
 
 	t1 = ntohl(ia_hdr->t1);
 	t2 = ntohl(ia_hdr->t2);
@@ -1195,10 +1346,12 @@ static int dhcpv6_parse_ia(void *opt, void *end)
 	if (t1 > t2)
 		return 0;
 
+	syslog(LOG_INFO, "%s %04x T1 %d T2 %d", ntohs(ia_hdr->type) == DHCPV6_OPT_IA_PD ? "IA_PD" : "IA_NA", ntohl(ia_hdr->iaid), t1, t2);
+
 	// Update address IA
 	dhcpv6_for_each_option(&ia_hdr[1], end, otype, olen, odata) {
-		struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, 0, 0, 0,
-				IN6ADDR_ANY_INIT, 0, 0, 0, 0, 0};
+		struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, 0, 0,
+				IN6ADDR_ANY_INIT, 0, 0, 0, 0, 0, 0};
 
 		entry.iaid = ia_hdr->iaid;
 
@@ -1260,8 +1413,12 @@ static int dhcpv6_parse_ia(void *opt, void *end)
 			}
 
 			if (ok) {
-				odhcp6c_update_entry(STATE_IA_PD, &entry, 0, 0);
-				parsed_ia++;
+				if (odhcp6c_update_entry(STATE_IA_PD, &entry, 0, 0))
+					updated_IAs++;
+
+				syslog(LOG_INFO, "%s/%d preferred %d valid %d",
+				       inet_ntop(AF_INET6, &entry.target, buf, sizeof(buf)),
+				       entry.length, entry.preferred , entry.valid);
 			}
 
 			entry.priority = 0;
@@ -1285,14 +1442,19 @@ static int dhcpv6_parse_ia(void *opt, void *end)
 			entry.length = 128;
 			entry.target = addr->addr;
 
-			odhcp6c_update_entry(STATE_IA_NA, &entry, 0, 0);
-			parsed_ia++;
+			if (odhcp6c_update_entry(STATE_IA_NA, &entry, 0, 0))
+				updated_IAs++;
+
+			syslog(LOG_INFO, "%s preferred %d valid %d",
+			       inet_ntop(AF_INET6, &entry.target, buf, sizeof(buf)),
+			       entry.preferred , entry.valid);
 		}
 	}
-	return parsed_ia;
+
+	return updated_IAs;
 }
 
-static int dhcpv6_calc_refresh_timers(void)
+static unsigned int dhcpv6_calc_refresh_timers(void)
 {
 	struct odhcp6c_entry *e;
 	size_t ia_na_entries, ia_pd_entries, i;
@@ -1330,9 +1492,11 @@ static int dhcpv6_calc_refresh_timers(void)
 		t1 = l_t1;
 		t2 = l_t2;
 		t3 = l_t3;
+
+		syslog(LOG_INFO, "T1 %"PRId64"s, T2 %"PRId64"s, T3 %"PRId64"s", t1, t2, t3);
 	}
 
-	return (int)(ia_pd_entries + ia_na_entries);
+	return (unsigned int)(ia_pd_entries + ia_na_entries);
 }
 
 static void dhcpv6_log_status_code(const uint16_t code, const char *scope,
@@ -1354,8 +1518,8 @@ static void dhcpv6_log_status_code(const uint16_t code, const char *scope,
 
 	*dst = 0;
 
-	syslog(LOG_WARNING, "Server returned %s status %i %s",
-		scope, code, buf);
+	syslog(LOG_WARNING, "Server returned %s status '%s %s'",
+		scope, dhcpv6_status_code_to_str(code), buf);
 }
 
 static void dhcpv6_handle_status_code(const enum dhcpv6_msg orig,
@@ -1506,7 +1670,7 @@ int dhcpv6_promote_server_cand(void)
 	if (cand->ia_pd_len) {
 		odhcp6c_add_state(STATE_IA_PD, cand->ia_pd, cand->ia_pd_len);
 		free(cand->ia_pd);
-		if (request_prefix)
+		if (pd_mode != IA_MODE_NONE)
 			ret = DHCPV6_STATEFUL;
 	}