X-Git-Url: https://git.decadent.org.uk/gitweb/?p=odhcp6c.git;a=blobdiff_plain;f=src%2Fdhcpv6.c;h=f905a7836d2ba601d5b98c5a10d72e77bd53da34;hp=6a38e8536f5a9232b261ca71fea2b543db95dab8;hb=e1b11c518aded9136b4f44759c6e2a6be4161ee9;hpb=a30b75599548b302a2fb829ff18073d9167ba895

diff --git a/src/dhcpv6.c b/src/dhcpv6.c
index 6a38e85..f905a78 100644
--- a/src/dhcpv6.c
+++ b/src/dhcpv6.c
@@ -60,9 +60,9 @@ static int dhcpv6_commit_advert(void);
 static struct dhcpv6_retx dhcpv6_retx[_DHCPV6_MSG_MAX] = {
 	[DHCPV6_MSG_UNKNOWN] = {false, 1, 120, "<POLL>",
 			dhcpv6_handle_reconfigure, NULL},
-	[DHCPV6_MSG_SOLICIT] = {true, 1, 7200, "SOLICIT",
+	[DHCPV6_MSG_SOLICIT] = {true, 1, 120, "SOLICIT",
 			dhcpv6_handle_advert, dhcpv6_commit_advert},
-	[DHCPV6_MSG_REQUEST] = {true, 30, 10, "REQUEST",
+	[DHCPV6_MSG_REQUEST] = {true, 1, 30, "REQUEST",
 			dhcpv6_handle_reply, NULL},
 	[DHCPV6_MSG_RENEW] = {false, 10, 600, "RENEW",
 			dhcpv6_handle_reply, NULL},
@@ -82,7 +82,7 @@ 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;
+static enum odhcp6c_ia_mode na_mode = IA_MODE_NONE, pd_mode = IA_MODE_NONE;
 static bool accept_reconfig = false;
 
 // Reconfigure key
@@ -90,9 +90,10 @@ static uint8_t reconf_key[16];
 
 
 
-int init_dhcpv6(const char *ifname, int request_pd)
+int init_dhcpv6(const char *ifname, int request_pd, int sol_timeout)
 {
 	request_prefix = request_pd;
+	dhcpv6_retx[DHCPV6_MSG_SOLICIT].max_timeo = sol_timeout;
 
 	sock = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
 
@@ -136,12 +137,19 @@ int init_dhcpv6(const char *ifname, int request_pd)
 	}
 
 	// Create ORO
-	uint16_t oro[] = {htons(DHCPV6_OPT_DNS_SERVERS),
+	uint16_t oro[] = {
+			htons(DHCPV6_OPT_SIP_SERVER_D),
+			htons(DHCPV6_OPT_SIP_SERVER_A),
+			htons(DHCPV6_OPT_DNS_SERVERS),
 			htons(DHCPV6_OPT_DNS_DOMAIN),
 			htons(DHCPV6_OPT_NTP_SERVER),
 			htons(DHCPV6_OPT_SIP_SERVER_A),
-			htons(DHCPV6_OPT_SIP_SERVER_D),
-			htons(DHCPV6_OPT_PD_EXCLUDE)};
+			htons(DHCPV6_OPT_AFTR_NAME),
+			htons(DHCPV6_OPT_PD_EXCLUDE),
+#ifdef EXT_PREFIX_CLASS
+			htons(DHCPV6_OPT_PREFIX_CLASS),
+#endif
+	};
 	odhcp6c_add_state(STATE_ORO, oro, sizeof(oro));
 
 
@@ -160,9 +168,10 @@ int init_dhcpv6(const char *ifname, int request_pd)
 }
 
 
-void dhcpv6_set_ia_na_mode(enum odhcp6c_ia_mode mode)
+void dhcpv6_set_ia_mode(enum odhcp6c_ia_mode na, enum odhcp6c_ia_mode pd)
 {
-	na_mode = mode;
+	na_mode = na;
+	pd_mode = pd;
 }
 
 
@@ -240,9 +249,7 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 		.type = htons(DHCPV6_OPT_IA_PREFIX),
 		.len = htons(25), .prefix = request_prefix
 	};
-	if (request_prefix > 0 && ia_pd_len == 0 &&
-			(type == DHCPV6_MSG_SOLICIT ||
-			type == DHCPV6_MSG_REQUEST)) {
+	if (request_prefix > 0 && ia_pd_len == 0 && type == DHCPV6_MSG_SOLICIT) {
 		ia_pd = (uint8_t*)&pref;
 		ia_pd_len = sizeof(pref);
 	}
@@ -306,7 +313,7 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 		{&oro_refresh, 0},
 		{cl_id, cl_id_len},
 		{srv_id, srv_id_len},
-		{&reconf_accept, 0},
+		{&reconf_accept, sizeof(reconf_accept)},
 		{&fqdn, fqdn_len},
 		{&hdr_ia_na, sizeof(hdr_ia_na)},
 		{ia_na, ia_na_len},
@@ -324,9 +331,8 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
 	}
 
 	// Disable IAs if not used
-	if (type == DHCPV6_MSG_SOLICIT) {
-		iov[5].iov_len = sizeof(reconf_accept);
-	} else if (type != DHCPV6_MSG_REQUEST) {
+	if (type != DHCPV6_MSG_SOLICIT) {
+		iov[5].iov_len = 0;
 		if (ia_na_len == 0)
 			iov[7].iov_len = 0;
 		if (ia_pd_len == 0)
@@ -348,14 +354,14 @@ static int64_t dhcpv6_rand_delay(int64_t time)
 {
 	int random;
 	odhcp6c_random(&random, sizeof(random));
-	return (time * (random % 1000)) / 10000;
+	return (time * ((int64_t)random % 1000LL)) / 10000LL;
 }
 
 
 int dhcpv6_request(enum dhcpv6_msg type)
 {
 	uint8_t buf[1536];
-	uint32_t timeout = UINT32_MAX;
+	uint64_t timeout = UINT32_MAX;
 	struct dhcpv6_retx *retx = &dhcpv6_retx[type];
 
 	if (retx->delay) {
@@ -364,25 +370,28 @@ int dhcpv6_request(enum dhcpv6_msg type)
 		nanosleep(&ts, NULL);
 	}
 
-	if (type == DHCPV6_MSG_RELEASE || type == DHCPV6_MSG_DECLINE)
+	if (type == DHCPV6_MSG_REQUEST)
+		timeout = 60;
+	else if (type == DHCPV6_MSG_RELEASE || type == DHCPV6_MSG_DECLINE)
 		timeout = 3;
 	else if (type == DHCPV6_MSG_UNKNOWN)
 		timeout = t1;
 	else if (type == DHCPV6_MSG_RENEW)
-		timeout = t2 - t1;
+		timeout = (t2 > t1) ? t2 - t1 : 0;
 	else if (type == DHCPV6_MSG_REBIND)
-		timeout = t3 - t2;
+		timeout = (t3 > t2) ? t3 - t2 : 0;
 
 	if (timeout == 0)
 		return -1;
 
-	syslog(LOG_NOTICE, "Sending %s (timeout %us)", retx->name, timeout);
+	syslog(LOG_NOTICE, "Sending %s (timeout %us)", retx->name, (unsigned)timeout);
 
 	uint64_t start = odhcp6c_get_milli_time(), round_start = start, elapsed;
 
 	// Generate transaction ID
-	uint8_t trid[3];
-	odhcp6c_random(trid, sizeof(trid));
+	uint8_t trid[3] = {0, 0, 0};
+	if (type != DHCPV6_MSG_UNKNOWN)
+		odhcp6c_random(trid, sizeof(trid));
 	ssize_t len = -1;
 	int64_t rto = 0;
 
@@ -439,7 +448,7 @@ int dhcpv6_request(enum dhcpv6_msg type)
 					len = retx->handler_reply(
 							type, opt, opt_end);
 
-				if (round_end - round_start > 1000)
+				if (len > 0 && round_end - round_start > 1000)
 					round_end = 1000 + round_start;
 			}
 		}
@@ -556,25 +565,26 @@ static int dhcpv6_handle_reconfigure(_unused enum dhcpv6_msg orig,
 
 
 // Collect all advertised servers
-static int dhcpv6_handle_advert(_unused enum dhcpv6_msg orig,
+static int dhcpv6_handle_advert(enum dhcpv6_msg orig,
 		const void *opt, const void *end)
 {
 	uint16_t olen, otype;
 	uint8_t *odata;
-	struct dhcpv6_server_cand cand = {false, false, 0, 0, {0}};
+	struct dhcpv6_server_cand cand = {false, false, 0, 0, {0}, NULL, NULL, 0, 0};
+	bool have_na = false;
+	int have_pd = 0;
 
 	dhcpv6_for_each_option(opt, end, otype, olen, odata) {
+		if (orig == DHCPV6_MSG_SOLICIT &&
+				(otype == DHCPV6_OPT_IA_PD || otype == DHCPV6_OPT_IA_NA) &&
+				olen > sizeof(struct dhcpv6_ia_hdr)) {
+			struct dhcpv6_ia_hdr *ia_hdr = (void*)(&odata[-4]);
+			dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
+		}
+
 		if (otype == DHCPV6_OPT_SERVERID && olen <= 130) {
 			memcpy(cand.duid, odata, olen);
 			cand.duid_len = olen;
-		} else if (otype == DHCPV6_OPT_STATUS && olen >= 2 && !odata[0]
-				&& odata[1] == DHCPV6_NoAddrsAvail) {
-			if (na_mode == IA_MODE_FORCE) {
-				return -1;
-			} else {
-				cand.has_noaddravail = true;
-				cand.preference -= 1000;
-			}
 		} else if (otype == DHCPV6_OPT_STATUS && olen >= 2 && !odata[0]
 				&& odata[1] == DHCPV6_NoPrefixAvail) {
 			cand.preference -= 2000;
@@ -584,21 +594,50 @@ static int dhcpv6_handle_advert(_unused enum dhcpv6_msg orig,
 		} else if (otype == DHCPV6_OPT_RECONF_ACCEPT) {
 			cand.wants_reconfigure = true;
 		} else if (otype == DHCPV6_OPT_IA_PD && request_prefix) {
-			struct dhcpv6_ia_hdr *h = (void*)odata;
+			struct dhcpv6_ia_hdr *h = (struct dhcpv6_ia_hdr*)&odata[-4];
 			uint8_t *oend = odata + olen, *d;
 			dhcpv6_for_each_option(&h[1], oend, otype, olen, d) {
-				if (otype == DHCPV6_OPT_IA_PREFIX)
-					cand.preference += 2000;
-				else if (otype == DHCPV6_OPT_STATUS &&
-						olen >= 2 && d[0] == 0 &&
-						d[1] == DHCPV6_NoPrefixAvail)
-					cand.preference -= 2000;
+				if (otype == DHCPV6_OPT_IA_PREFIX && (olen + 4) >=
+						(uint16_t)sizeof(struct dhcpv6_ia_prefix)) {
+					struct dhcpv6_ia_prefix *p = (struct dhcpv6_ia_prefix*)&d[-4];
+					have_pd = p->prefix;
+				}
 			}
+		} else if (otype == DHCPV6_OPT_IA_NA) {
+			struct dhcpv6_ia_hdr *h = (struct dhcpv6_ia_hdr*)&odata[-4];
+			uint8_t *oend = odata + olen, *d;
+			dhcpv6_for_each_option(&h[1], oend, otype, olen, d)
+				if (otype == DHCPV6_OPT_IA_ADDR)
+					have_na = true;
 		}
 	}
 
-	if (cand.duid_len > 0)
+	if ((!have_na && na_mode == IA_MODE_FORCE) ||
+			(!have_pd && pd_mode == IA_MODE_FORCE))
+		return -1;
+
+	if (na_mode != IA_MODE_NONE && !have_na) {
+		cand.has_noaddravail = true;
+		cand.preference -= 1000;
+	}
+
+	if (pd_mode != IA_MODE_NONE) {
+		if (have_pd)
+			cand.preference += 2000 + (128 - have_pd);
+		else
+			cand.preference -= 2000;
+	}
+
+	if (cand.duid_len > 0) {
+		cand.ia_na = odhcp6c_move_state(STATE_IA_NA, &cand.ia_na_len);
+		cand.ia_pd = odhcp6c_move_state(STATE_IA_PD, &cand.ia_pd_len);
 		odhcp6c_add_state(STATE_SERVER_CAND, &cand, sizeof(cand));
+	}
+
+	if (orig == DHCPV6_MSG_SOLICIT) {
+		odhcp6c_clear_state(STATE_IA_NA);
+		odhcp6c_clear_state(STATE_IA_PD);
+	}
 
 	return -1;
 }
@@ -631,8 +670,14 @@ static int dhcpv6_commit_advert(void)
 		odhcp6c_add_state(STATE_SERVER_ID, hdr, sizeof(hdr));
 		odhcp6c_add_state(STATE_SERVER_ID, c->duid, c->duid_len);
 		accept_reconfig = c->wants_reconfigure;
+		odhcp6c_add_state(STATE_IA_NA, c->ia_na, c->ia_na_len);
+		odhcp6c_add_state(STATE_IA_PD, c->ia_pd, c->ia_pd_len);
 	}
 
+	for (size_t i = 0; i < cand_len / sizeof(*c); ++i) {
+		free(cand[i].ia_na);
+		free(cand[i].ia_pd);
+	}
 	odhcp6c_clear_state(STATE_SERVER_CAND);
 
 	if (!c)
@@ -663,13 +708,15 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
 	uint8_t *odata;
 	uint16_t otype, olen;
 
-	static time_t last_update = 0;
-	time_t now = odhcp6c_get_milli_time() / 1000;
-
-	uint32_t elapsed = now - last_update;
 	odhcp6c_expire();
 
 	if (orig == DHCPV6_MSG_UNKNOWN) {
+		static time_t last_update = 0;
+		time_t now = odhcp6c_get_milli_time() / 1000;
+
+		uint32_t elapsed = (last_update > 0) ? now - last_update : 0;
+		last_update = now;
+
 		t1 -= elapsed;
 		t2 -= elapsed;
 		t3 -= elapsed;
@@ -686,6 +733,12 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
 		t1 = t2 = t3 = UINT32_MAX;
 	}
 
+	if (orig == DHCPV6_MSG_REQUEST) {
+		// Delete NA and PD we have in the state from the Advert
+		odhcp6c_clear_state(STATE_IA_NA);
+		odhcp6c_clear_state(STATE_IA_PD);
+	}
+
 	if (opt) {
 		odhcp6c_clear_state(STATE_DNS);
 		odhcp6c_clear_state(STATE_SEARCH);
@@ -693,6 +746,7 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
 		odhcp6c_clear_state(STATE_SNTP_FQDN);
 		odhcp6c_clear_state(STATE_SIP_IP);
 		odhcp6c_clear_state(STATE_SIP_FQDN);
+		odhcp6c_clear_state(STATE_AFTR_NAME);
 	}
 
 	// Parse and find all matching IAs
@@ -707,42 +761,39 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
 			if (ia_hdr->iaid != 1 || l_t2 < l_t1)
 				continue;
 
-			bool error = false;
+			int error = 0;
 			uint16_t stype, slen;
 			uint8_t *sdata;
 			// Test status and bail if error
 			dhcpv6_for_each_option(&ia_hdr[1], odata + olen,
 					stype, slen, sdata)
-				if (stype == DHCPV6_OPT_STATUS && slen >= 2 &&
-						(sdata[0] || sdata[1]))
-					error = true;
-
-			if (error)
-				continue;
-
-			// Update times
-			if (l_t1 > 0 && t1 > l_t1)
-				t1 = l_t1;
-
-			if (l_t2 > 0 && t2 > l_t2)
-				t2 = l_t2;
+				if (stype == DHCPV6_OPT_STATUS && slen >= 2)
+					error = ((int)sdata[0]) << 8 | ((int)sdata[1]);
+
+			if (error) {
+				syslog(LOG_WARNING, "Server returned IAID status %i!", error);
+				if (error != 2)
+					raise(SIGUSR2);
+				break;
+			}
 
 			uint32_t n = dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
 
-			if (n < t1)
-				t1 = n;
+			if (!l_t1)
+				l_t1 = 300;
 
-			if (n < t2)
-				t2 = n;
+			if (!l_t2)
+				l_t2 = 600;
 
 			if (n < t3)
 				t3 = n;
 
-			if (t2 >= t3)
-				t2 = 8 * t3 / 10;
+			// Update times
+			if (l_t1 > 0 && t1 > l_t1)
+				t1 = l_t1;
 
-			if (t1 >= t2)
-				t1 = 5 * t2 / 8;
+			if (l_t2 > 0 && t2 > l_t2)
+				t2 = l_t2;
 
 		} else if (otype == DHCPV6_OPT_DNS_SERVERS) {
 			if (olen % 16 == 0)
@@ -778,6 +829,11 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
 			if (r->protocol == 3 && r->algorithm == 1 &&
 					r->reconf_type == 1)
 				memcpy(reconf_key, r->key, sizeof(r->key));
+		} 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);
 		} else if (otype != DHCPV6_OPT_CLIENTID &&
 				otype != DHCPV6_OPT_SERVERID) {
 			odhcp6c_add_state(STATE_CUSTOM_OPTS,
@@ -785,6 +841,15 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
 		}
 	}
 
+	if (t1 == UINT32_MAX)
+		t1 = 300;
+
+	if (t2 == UINT32_MAX)
+		t2 = 600;
+
+	if (t3 == UINT32_MAX)
+		t3 = 3600;
+
 	return true;
 }
 
@@ -795,11 +860,11 @@ static uint32_t dhcpv6_parse_ia(void *opt, void *end)
 	uint16_t otype, olen;
 	uint8_t *odata;
 
-	struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT,
-			0, 0, IN6ADDR_ANY_INIT, 0, 0};
-
 	// Update address IA
 	dhcpv6_for_each_option(opt, end, otype, olen, odata) {
+		struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, 0, 0,
+				IN6ADDR_ANY_INIT, 0, 0, 0};
+
 		if (otype == DHCPV6_OPT_IA_PREFIX) {
 			struct dhcpv6_ia_prefix *prefix = (void*)&odata[-4];
 			if (olen + 4U < sizeof(*prefix))
@@ -813,11 +878,19 @@ static uint32_t dhcpv6_parse_ia(void *opt, void *end)
 
 			entry.length = prefix->prefix;
 			entry.target = prefix->addr;
+			uint16_t stype, slen;
+			uint8_t *sdata;
+
+#ifdef EXT_PREFIX_CLASS
+                        // Find prefix class, if any
+			dhcpv6_for_each_option(&prefix[1], odata + olen,
+					stype, slen, sdata)
+				if (stype == DHCPV6_OPT_PREFIX_CLASS && slen == 2)
+					entry.class = sdata[0] << 8 | sdata[1];
+#endif
 
 			// Parse PD-exclude
 			bool ok = true;
-			uint16_t stype, slen;
-			uint8_t *sdata;
 			dhcpv6_for_each_option(odata + sizeof(*prefix) - 4U,
 					odata + olen, stype, slen, sdata) {
 				if (stype != DHCPV6_OPT_PD_EXCLUDE || slen < 2)
@@ -872,9 +945,18 @@ static uint32_t dhcpv6_parse_ia(void *opt, void *end)
 			entry.length = 128;
 			entry.target = addr->addr;
 
+#ifdef EXT_PREFIX_CLASS
+			uint16_t stype, slen;
+			uint8_t *sdata;
+			// Find prefix class, if any
+			dhcpv6_for_each_option(&addr[1], odata + olen,
+					stype, slen, sdata)
+				if (stype == DHCPV6_OPT_PREFIX_CLASS && slen == 2)
+					entry.class = sdata[0] << 8 | sdata[1];
+#endif
+
 			odhcp6c_update_entry(STATE_IA_NA, &entry);
 		}
-
 		if (entry.valid > 0 && timeout > entry.valid)
 			timeout = entry.valid;
 	}