async-dns-tcp-fallback

Author: lws-team

lib/system/async-dns/async-dns-parse.c

@@ -37,7 +37,7 @@ lws_adns_parse_label(const uint8_t *pkt, int len, const uint8_t *ls, int budget,
 	int n, readsize = 0, consumed = -1;
 	uint8_t ll;
 
-	if (len < DHO_SIZEOF || len > 1500)
+	if (len < DHO_SIZEOF || len > LWS_ADNS_MAX_PAYLOAD)
 		return -1;
 
 	if (budget < 1)
@@ -184,7 +184,7 @@ lws_adns_iterate(lws_adns_q_t *q, const uint8_t *pkt, int len,
 	char *sp, inq;
 	uint32_t ttl;
 
-	if (len < DHO_SIZEOF || len > 1500)
+	if (len < DHO_SIZEOF || len > LWS_ADNS_MAX_PAYLOAD)
 		return -1;
 
 	lws_strncpy(stack[0].name, expname, sizeof(stack[0].name));
@@ -570,7 +570,7 @@ lws_adns_parse_udp(lws_async_dns_t *dns, const uint8_t *pkt, size_t len)
 
 	/* we have to at least have the header */
 
-	if (len < DHO_SIZEOF || len > 1500)
+	if (len < DHO_SIZEOF || len > LWS_ADNS_MAX_PAYLOAD)
 		return;
 
 	/* we asked with one query, so anything else is bogus */
@@ -605,6 +605,25 @@ lws_adns_parse_udp(lws_async_dns_t *dns, const uint8_t *pkt, size_t len)
 
 	q->responded = (uint8_t)(q->responded | n);
 
+	/* did we get truncated? */
+	if ((lws_ser_ru16be(pkt + DHO_FLAGS) & 0x0200) && !q->is_tcp) {
+		lwsl_notice("%s: ADNS truncated, falling back to TCP for %s\n",
+			    __func__, ((const char *)&q[1]) + DNS_MAX);
+		
+		q->responded = (uint8_t)(q->responded & ~n);
+		q->asked = 0;
+		q->sent[0] = 0;
+#if defined(LWS_WITH_IPV6)
+		q->sent[1] = 0;
+#endif
+		if (lws_async_dns_create_tcp_wsi(q)) {
+			q->go_nogo = METRES_NOGO;
+			goto fail_out;
+		}
+
+		return;
+	}
+
 	/* we want to confirm the results against what we last requested... */
 
 	nmcname = ((const char *)&q[1]);

lib/system/async-dns/async-dns.c

@@ -39,6 +39,18 @@ lws_adns_q_destroy(lws_adns_q_t *q)
 	lws_sul_cancel(&q->sul);
 	lws_sul_cancel(&q->write_sul);
 	lws_dll2_remove(&q->list);
+
+	if (q->wsi_tcp) {
+		q->wsi_tcp->a.opaque_user_data = NULL;
+		lws_set_timeout(q->wsi_tcp, 1, LWS_TO_KILL_ASYNC);
+		q->wsi_tcp = NULL;
+	}
+
+	if (q->tcp_rx_buf) {
+		lws_free(q->tcp_rx_buf);
+		q->tcp_rx_buf = NULL;
+	}
+
 	if (q->firstcache) {
 		q->firstcache->refcount--;
 		q->firstcache = NULL;
@@ -268,8 +280,13 @@ lws_async_dns_writeable(struct lws *wsi, lws_adns_q_t *q)
 	assert(p < pkt + sizeof(pkt) - LWS_PRE);
 	n = lws_ptr_diff(p, pkt + LWS_PRE);
 
-	m = lws_write(wsi, pkt + LWS_PRE, (unsigned int)n, 0);
-	if (m != n) {
+	if (!wsi->udp) {
+		lws_ser_wu16be(pkt + LWS_PRE - 2, (uint16_t)n);
+		m = lws_write(wsi, pkt + LWS_PRE - 2, (unsigned int)n + 2, 0);
+	} else
+		m = lws_write(wsi, pkt + LWS_PRE, (unsigned int)n, 0);
+
+	if (m != (wsi->udp ? n : n + 2)) {
 		lwsl_wsi_notice(wsi, "dns write failed %d %d errno %d",
 			    m, n, errno);
 		goto qfail;
@@ -305,6 +322,81 @@ callback_async_dns(struct lws *wsi, enum lws_callback_reasons reason,
 		   void *user, void *in, size_t len)
 {
 	struct lws_async_dns *dns = &(lws_get_context(wsi)->async_dns);
+
+	if (!wsi->udp) {
+		lws_adns_q_t *q = (lws_adns_q_t *)wsi->a.opaque_user_data;
+
+		if (!q)
+			return 0;
+
+		switch (reason) {
+		case LWS_CALLBACK_RAW_CONNECTED:
+			lws_callback_on_writable(wsi);
+			break;
+		case LWS_CALLBACK_RAW_CLOSE:
+			q->wsi_tcp = NULL;
+			if (q->go_nogo != METRES_GO) {
+				lws_async_dns_complete(q, NULL);
+				lws_adns_q_destroy(q);
+			}
+			break;
+		case LWS_CALLBACK_RAW_RX:
+			/* accumulate bytes */
+			if (!q->has_tcp_len) {
+				const uint8_t *in8 = (const uint8_t *)in;
+
+				while (len && !q->has_tcp_len) {
+					q->tcp_rx_len = (uint16_t)((q->tcp_rx_len << 8) | *in8++);
+					q->tcp_rx_pos++;
+					len--;
+					if (q->tcp_rx_pos == 2) {
+						if (q->tcp_rx_len < DHO_SIZEOF ||
+						    q->tcp_rx_len > LWS_ADNS_MAX_PAYLOAD) {
+							lwsl_wsi_notice(wsi, "adns tcp len bad");
+							return -1;
+						}
+						q->has_tcp_len = 1;
+						q->tcp_rx_pos = 0;
+						q->tcp_rx_buf = lws_malloc(q->tcp_rx_len + 1, "adns tcp");
+						if (!q->tcp_rx_buf) {
+							lwsl_wsi_err(wsi, "OOM");
+							return -1;
+						}
+					}
+				}
+				in = (void *)in8;
+			}
+
+			if (q->has_tcp_len && len) {
+				size_t chunk = len;
+				if (q->tcp_rx_pos + chunk > (size_t)q->tcp_rx_len)
+					chunk = (size_t)(q->tcp_rx_len - q->tcp_rx_pos);
+				memcpy(q->tcp_rx_buf + q->tcp_rx_pos, in, chunk);
+				q->tcp_rx_pos = (uint16_t)(q->tcp_rx_pos + chunk);
+
+				if (q->tcp_rx_pos == q->tcp_rx_len) {
+					/* we have the whole message */
+					lws_adns_parse_udp(dns, q->tcp_rx_buf, q->tcp_rx_len);
+					/* TCP connection is done */
+					return -1;
+				}
+			}
+			break;
+		case LWS_CALLBACK_RAW_WRITEABLE:
+			if (!q->is_retry && q->sent[0]
+#if defined(LWS_WITH_IPV6)
+	         && q->sent[0] == q->sent[1]
+#endif
+			)
+				break;
+			lws_async_dns_writeable(wsi, q);
+			break;
+		default:
+			break;
+		}
+		return 0;
+	}
+
 	lws_async_dns_server_t *dsrv =
 			(lws_async_dns_server_t *)wsi->a.opaque_user_data;
 
@@ -335,7 +427,7 @@ callback_async_dns(struct lws *wsi, enum lws_callback_reasons reason,
 
 			if (//lws_dll2_is_detached(&q->sul.list) &&
 			    !q->is_synthetic &&
-			    (!q->asked || q->responded != q->asked))
+			    (!q->asked || q->responded != q->asked) && !q->is_tcp)
 				lws_async_dns_writeable(wsi, q);
 		} lws_end_foreach_dll_safe(d, d1);
 		break;
@@ -1221,3 +1313,36 @@ lws_async_dns_query(struct lws_context *context, int tsi, const char *name,
 
 	return LADNS_RET_FAILED;
 }
+
+int
+lws_async_dns_create_tcp_wsi(lws_adns_q_t *q)
+{
+	struct lws_client_connect_info i;
+	char ads[48];
+
+	if (q->wsi_tcp)
+		return 0;
+
+	memset(&i, 0, sizeof(i));
+	i.context = q->context;
+
+	lws_sa46_write_numeric_address(&q->dsrv->sa46, ads, sizeof(ads));
+	i.address = ads;
+	i.port = 53;
+	i.ssl_connection = 0;
+	i.method = "RAW";
+	i.local_protocol_name = lws_async_dns_protocol.name;
+	i.opaque_user_data = q;
+
+	q->is_tcp = 1;
+	q->has_tcp_len = 0;
+	q->tcp_rx_pos = 0;
+	
+	q->wsi_tcp = lws_client_connect_via_info(&i);
+	if (!q->wsi_tcp) {
+		lwsl_cx_err(q->context, "adns tcp connect fail");
+		return 1;
+	}
+
+	return 0;
+}

lib/system/async-dns/private-lib-async-dns.h

@@ -28,6 +28,7 @@
 #define DNS_PACKET_LEN		1400	/* Buffer size for DNS packet	*/
 #define MAX_CACHE_ENTRIES	10	/* Dont cache more than that	*/
 #define DNS_QUERY_TIMEOUT	30	/* Query timeout, seconds	*/
+#define LWS_ADNS_MAX_PAYLOAD	1500	/* Maximum TCP payload size    */
 
 #if defined(LWS_WITH_SYS_ASYNC_DNS)
 
@@ -92,6 +93,13 @@ typedef struct lws_adns_q {
 
 	uint8_t			is_retry:1;
 	uint8_t			is_synthetic:1; /* test will deliver canned */
+	uint8_t			is_tcp:1;
+	uint8_t			has_tcp_len:1;
+
+	struct lws		*wsi_tcp;
+	uint8_t			*tcp_rx_buf;
+	uint16_t		tcp_rx_len;
+	uint16_t		tcp_rx_pos;
 
 	/* name overallocated here */
 } lws_adns_q_t;
@@ -139,6 +147,9 @@ lws_async_dns_trim_cache(lws_async_dns_t *dns);
 int
 lws_async_dns_get_new_tid(struct lws_context *context, lws_adns_q_t *q);
 
+int
+lws_async_dns_create_tcp_wsi(lws_adns_q_t *q);
+
 
 
 /* require: context lock on this set */

minimal-examples-lowlevel/api-tests/api-test-async-dns/main.c

@@ -12,7 +12,7 @@
 #include <libwebsockets.h>
 #include <signal.h>
 
-static int interrupted, dtest, ok, fail, _exp = 37;
+static int interrupted, dtest, ok, fail, _exp = 38;
 struct lws_context *context;
 
 /*
@@ -113,9 +113,8 @@ static struct async_dns_tests {
 //	{ "c-msn-com-europe-vip.trafficmanager.net", TEST_FLAG_NOCHECK_RESULT_IP |
 //		       LWS_ADNS_SYNTHETIC | LWS_ADNS_RECORD_A, 0,
 //		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } },
-//	{ "c-msn-com-europe-vip.trafficmanager.net", TEST_FLAG_NOCHECK_RESULT_IP |
-//		       LWS_ADNS_SYNTHETIC | LWS_ADNS_RECORD_A, 0,
-//		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } },
+	{ "tcp-fallback.libwebsockets.org", LWS_ADNS_SYNTHETIC | LWS_ADNS_RECORD_A, 0,
+		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } },
 	{ "mudpuddle.shwaine.com", LWS_ADNS_RECORD_A, 4,
 		{ 174, 134, 58, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } },
 	{ "awsrealm.majicrealm.com", LWS_ADNS_RECORD_A, 4,
@@ -182,6 +181,18 @@ static uint8_t canned_c_msn_com[] = {
 	49,3,116,109,49,6,100,110,115,45,116,109,3,99,111,109,0,10,104,111,115,
 	116,109,97,115,116,101,114,192,33,7,11,234,133,0,0,3,132,0,0,1,44,0,36,
 	234,0,0,0,0,30,
+}, canned_tc_libwebsockets_org[] = {
+	0x00, 0x00, 
+	0x83, 0x80, 
+	0x00, 0x01, 
+	0x00, 0x00, 
+	0x00, 0x00, 
+	0x00, 0x00, 
+	12, 't', 'c', 'p', '-', 'f', 'a', 'l', 'l', 'b', 'a', 'c', 'k',
+	13, 'l', 'i', 'b', 'w', 'e', 'b', 's', 'o', 'c', 'k', 'e', 't', 's',
+	3, 'o', 'r', 'g', 0,
+	0x00, 0x01, 
+	0x00, 0x01  
 };
 
 static lws_sorted_usec_list_t sul, sul_timeout;
@@ -261,6 +272,13 @@ next_test_cb(lws_sorted_usec_list_t *sul)
 				canned_c_msn_com_europe_vip_trafficmanager_net,
 				sizeof(canned_c_msn_com_europe_vip_trafficmanager_net));
 		}
+		if (!strcmp(adt[dtest].dns_name, "tcp-fallback.libwebsockets.org")) {
+			canned_tc_libwebsockets_org[0] = (uint8_t)(lws_adns_get_tid(q) >> 8);
+			canned_tc_libwebsockets_org[1] = (uint8_t)lws_adns_get_tid(q);
+			lws_adns_parse_udp(lws_adns_get_async_dns(q),
+					canned_tc_libwebsockets_org,
+					sizeof(canned_tc_libwebsockets_org));
+		}
 	}
 }