68#include "lib/random.h"
78#ifndef RESOLV_CONF_SUPPORTS_MDNS
79#define RESOLV_SUPPORTS_MDNS 0
81#define RESOLV_SUPPORTS_MDNS RESOLV_CONF_SUPPORTS_MDNS
86#if RESOLV_SUPPORTS_MDNS
91#define LOG_MODULE "Resolv"
92#define LOG_LEVEL LOG_LEVEL_NONE
94int strcasecmp(
const char *s1,
const char *s2);
95int strncasecmp(
const char *s1,
const char *s2,
size_t n);
97#ifndef RESOLV_CONF_MDNS_INCLUDE_GLOBAL_V6_ADDRS
98#define RESOLV_CONF_MDNS_INCLUDE_GLOBAL_V6_ADDRS 0
102#ifndef RESOLV_CONF_MAX_RETRIES
103#define RESOLV_CONF_MAX_RETRIES 4
106#ifndef RESOLV_CONF_MAX_MDNS_RETRIES
107#define RESOLV_CONF_MAX_MDNS_RETRIES 3
110#ifndef RESOLV_CONF_MAX_DOMAIN_NAME_SIZE
111#define RESOLV_CONF_MAX_DOMAIN_NAME_SIZE 32
114#ifdef RESOLV_CONF_AUTO_REMOVE_TRAILING_DOTS
115#define RESOLV_AUTO_REMOVE_TRAILING_DOTS RESOLV_CONF_AUTO_REMOVE_TRAILING_DOTS
117#define RESOLV_AUTO_REMOVE_TRAILING_DOTS RESOLV_SUPPORTS_MDNS
120#ifdef RESOLV_CONF_VERIFY_ANSWER_NAMES
121#define RESOLV_VERIFY_ANSWER_NAMES RESOLV_CONF_VERIFY_ANSWER_NAMES
123#define RESOLV_VERIFY_ANSWER_NAMES RESOLV_SUPPORTS_MDNS
126#ifdef RESOLV_CONF_SUPPORTS_RECORD_EXPIRATION
127#define RESOLV_SUPPORTS_RECORD_EXPIRATION RESOLV_CONF_SUPPORTS_RECORD_EXPIRATION
129#define RESOLV_SUPPORTS_RECORD_EXPIRATION 1
132#if RESOLV_SUPPORTS_MDNS && !RESOLV_VERIFY_ANSWER_NAMES
133#error RESOLV_SUPPORTS_MDNS cannot be set without RESOLV_CONF_VERIFY_ANSWER_NAMES
136#if !defined(CONTIKI_TARGET_NAME) && defined(BOARD)
137#define stringy2(x) #x
138#define stringy(x) stringy2(x)
139#define CONTIKI_TARGET_NAME stringy(BOARD)
142#ifndef CONTIKI_CONF_DEFAULT_HOSTNAME
143#ifdef CONTIKI_TARGET_NAME
144#define CONTIKI_CONF_DEFAULT_HOSTNAME "contiki-"CONTIKI_TARGET_NAME
146#define CONTIKI_CONF_DEFAULT_HOSTNAME "contiki"
151#define DNS_TYPE_CNAME 5
152#define DNS_TYPE_PTR 12
153#define DNS_TYPE_MX 15
154#define DNS_TYPE_TXT 16
155#define DNS_TYPE_AAAA 28
156#define DNS_TYPE_SRV 33
157#define DNS_TYPE_ANY 255
158#define DNS_TYPE_NSEC 47
160#define NATIVE_DNS_TYPE DNS_TYPE_AAAA
162#define DNS_CLASS_IN 1
163#define DNS_CLASS_ANY 255
170#define MDNS_PORT 5353
173#ifndef MDNS_RESPONDER_PORT
174#define MDNS_RESPONDER_PORT 5354
180 uint8_t flags1, flags2;
181#define DNS_FLAG1_RESPONSE 0x80
182#define DNS_FLAG1_OPCODE_STATUS 0x10
183#define DNS_FLAG1_OPCODE_INVERSE 0x08
184#define DNS_FLAG1_OPCODE_STANDARD 0x00
185#define DNS_FLAG1_AUTHORATIVE 0x04
186#define DNS_FLAG1_TRUNC 0x02
187#define DNS_FLAG1_RD 0x01
188#define DNS_FLAG2_RA 0x80
189#define DNS_FLAG2_ERR_MASK 0x0f
190#define DNS_FLAG2_ERR_NONE 0x00
191#define DNS_FLAG2_ERR_NAME 0x03
192 uint16_t numquestions;
210#define STATE_UNUSED 0
213#define STATE_ASKING 3
220#if RESOLV_SUPPORTS_RECORD_EXPIRATION
221 unsigned long expiration;
226#if RESOLV_SUPPORTS_MDNS
230 char name[RESOLV_CONF_MAX_DOMAIN_NAME_SIZE + 1];
233#ifndef UIP_CONF_RESOLV_ENTRIES
234#define RESOLV_ENTRIES 4
236#define RESOLV_ENTRIES UIP_CONF_RESOLV_ENTRIES
239static struct namemap names[RESOLV_ENTRIES];
242static struct etimer retry;
245PROCESS(resolv_process,
"DNS resolver");
247static void resolv_found(
char *name, uip_ipaddr_t *
ipaddr);
255#if RESOLV_SUPPORTS_MDNS
256static char resolv_hostname[RESOLV_CONF_MAX_DOMAIN_NAME_SIZE + 1];
259 MDNS_STATE_WAIT_BEFORE_PROBE,
264static uint8_t mdns_state;
266static const uip_ipaddr_t resolv_mdns_addr =
267{ { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
268 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb } };
271static int mdns_needs_host_announce;
273PROCESS(mdns_probe_process,
"mDNS probe");
285decode_name(
const unsigned char *query,
char *dest,
286 const unsigned char *packet,
size_t packet_len)
288 int dest_len = RESOLV_CONF_MAX_DOMAIN_NAME_SIZE;
289 unsigned char label_len = *query++;
291 LOG_DBG(
"decoding name: \"");
293 while(dest_len && label_len) {
294 if(label_len & 0xc0) {
295 const uint16_t offset = query[0] + ((label_len & ~0xC0) << 8);
296 if(offset >= packet_len) {
297 LOG_ERR(
"Offset %"PRIu16
" exceeds packet length %zu\n",
301 LOG_DBG_(
"<skip-to-%d>", offset);
302 query = packet + offset;
303 label_len = *query++;
310 if(query - packet + label_len > packet_len) {
311 LOG_ERR(
"Cannot read outside the packet data\n");
315 for(; label_len; --label_len) {
316 LOG_DBG_(
"%c", *query);
320 if(--dest_len == 0) {
327 label_len = *query++;
338 return dest_len != 0;
343#if RESOLV_SUPPORTS_MDNS
345dns_name_isequal(
const unsigned char *queryptr,
const char *name,
346 const unsigned char *packet)
348 unsigned char label_len = *queryptr++;
354 while(label_len > 0) {
355 if(label_len & 0xc0) {
356 queryptr = packet + queryptr[0] + ((label_len & ~0xC0) << 8);
357 label_len = *queryptr++;
360 for(; label_len; --label_len) {
365 if(tolower(*name++) != tolower(*queryptr++)) {
370 label_len = *queryptr++;
372 if(label_len != 0 && *name++ !=
'.') {
387static unsigned char *
388skip_name(
unsigned char *query)
390 LOG_DBG(
"skip name: ");
393 unsigned char n = *query;
395 LOG_DBG_(
"<skip-to-%d>", query[0] + ((n & ~0xC0) << 8));
403 LOG_DBG_(
"%c", *query);
408 }
while(*query != 0);
415static unsigned char *
416encode_name(
unsigned char *query,
const char *nameptr)
422 char *nptr = (
char *)query;
426 for(n = 0; *nameptr !=
'.' && *nameptr != 0; ++nameptr) {
432 }
while(*nameptr != 0);
440#if RESOLV_SUPPORTS_MDNS
444mdns_announce_requested(
void)
446 mdns_needs_host_announce = 1;
452start_name_collision_check(clock_time_t after)
460static unsigned char *
461mdns_write_announce_records(
unsigned char *queryptr, uint8_t *
count)
465 for(i = 0; i < UIP_DS6_ADDR_NB; ++i) {
467#
if !RESOLV_CONF_MDNS_INCLUDE_GLOBAL_V6_ADDRS
472 queryptr = encode_name(queryptr, resolv_hostname);
476 *queryptr++ =
sizeof(
struct dns_hdr);
479 *queryptr++ = (uint8_t)(NATIVE_DNS_TYPE >> 8);
480 *queryptr++ = (uint8_t)NATIVE_DNS_TYPE;
482 *queryptr++ = (uint8_t)((DNS_CLASS_IN | 0x8000) >> 8);
483 *queryptr++ = (uint8_t)(DNS_CLASS_IN | 0x8000);
491 *queryptr++ =
sizeof(uip_ipaddr_t);
495 queryptr +=
sizeof(uip_ipaddr_t);
506mdns_prep_host_announce_packet(
void)
508 static const struct {
522 sizeof(
struct dns_hdr),
535 struct dns_hdr *hdr = (
struct dns_hdr *)
uip_appdata;
536 unsigned char *queryptr = (
unsigned char *)
uip_appdata +
sizeof(*hdr);
537 uint8_t total_answers = 0;
540 memset((
void *)hdr, 0,
sizeof(*hdr));
541 hdr->flags1 |= DNS_FLAG1_RESPONSE | DNS_FLAG1_AUTHORATIVE;
543 queryptr = mdns_write_announce_records(queryptr, &total_answers);
549 queryptr = encode_name(queryptr, resolv_hostname);
553 *queryptr++ =
sizeof(*hdr);
556 memcpy((
void *)queryptr, (
void *)&nsec_record,
sizeof(nsec_record));
558 queryptr +=
sizeof(nsec_record);
562 ((uint8_t *)&hdr->numanswers)[1] = total_answers;
563 ((uint8_t *)&hdr->numextrarr)[1] = 1;
570try_next_server(
struct namemap *namemapptr)
572 namemapptr->server++;
574 LOG_DBG(
"Using server ");
576 LOG_DBG_(
", num %u\n", namemapptr->server);
577 namemapptr->retries = 0;
580 LOG_DBG(
"No nameserver, num %u\n", namemapptr->server);
581 namemapptr->server = 0;
594 for(i = 0; i < RESOLV_ENTRIES; ++i) {
595 struct namemap *namemapptr = &names[i];
596 if(namemapptr->state == STATE_NEW || namemapptr->state == STATE_ASKING) {
598 if(namemapptr->state == STATE_ASKING) {
599 if(namemapptr->tmr == 0 || --namemapptr->tmr == 0) {
600#if RESOLV_SUPPORTS_MDNS
601 if(++namemapptr->retries ==
602 (namemapptr->is_mdns ? RESOLV_CONF_MAX_MDNS_RETRIES :
610 if(try_next_server(namemapptr) == 0) {
612 namemapptr->state = STATE_ERROR;
614#if RESOLV_SUPPORTS_RECORD_EXPIRATION
619 resolv_found(namemapptr->name, NULL);
623 namemapptr->tmr = namemapptr->retries * namemapptr->retries * 3;
625#if RESOLV_SUPPORTS_MDNS
626 if(namemapptr->is_probe) {
636 namemapptr->state = STATE_ASKING;
638 namemapptr->retries = 0;
641 struct dns_hdr *hdr = (
struct dns_hdr *)
uip_appdata;
642 memset(hdr, 0,
sizeof(
struct dns_hdr));
644 namemapptr->id = hdr->id;
646#if RESOLV_SUPPORTS_MDNS
647 if(!namemapptr->is_mdns || namemapptr->is_probe) {
648 hdr->flags1 = DNS_FLAG1_RD;
650 if(namemapptr->is_mdns) {
654 hdr->flags1 = DNS_FLAG1_RD;
658 uint8_t *query = (
unsigned char *)
uip_appdata +
sizeof(*hdr);
659 query = encode_name(query, namemapptr->name);
661#if RESOLV_SUPPORTS_MDNS
662 if(namemapptr->is_probe) {
663 *query++ = (uint8_t)((DNS_TYPE_ANY) >> 8);
664 *query++ = (uint8_t)((DNS_TYPE_ANY));
668 *query++ = (uint8_t)(NATIVE_DNS_TYPE >> 8);
669 *query++ = (uint8_t)NATIVE_DNS_TYPE;
671 *query++ = (uint8_t)(DNS_CLASS_IN >> 8);
672 *query++ = (uint8_t)DNS_CLASS_IN;
673#if RESOLV_SUPPORTS_MDNS
674 if(namemapptr->is_mdns) {
675 if(namemapptr->is_probe) {
683 query = mdns_write_announce_records(query, &
count);
688 &resolv_mdns_addr,
UIP_HTONS(MDNS_PORT));
690 LOG_DBG(
"(i=%d) Sent MDNS %s for \"%s\"\n", i,
691 namemapptr->is_probe ?
"probe" :
"request", namemapptr->name);
695 (
const uip_ipaddr_t *)
699 LOG_DBG(
"(i=%d) Sent DNS request for \"%s\"\n", i,
707 LOG_DBG(
"(i=%d) Sent DNS request for \"%s\"\n", i,
722 struct dns_hdr const *hdr = (
struct dns_hdr *)
uip_appdata;
723 unsigned char *queryptr = (
unsigned char *)hdr +
sizeof(*hdr);
724 const uint8_t is_request = (hdr->flags1 & ~1) == 0 && hdr->flags2 == 0;
729 uint8_t nquestions = (uint8_t)uip_ntohs(hdr->numquestions);
730 uint8_t nanswers = (uint8_t)uip_ntohs(hdr->numanswers);
732 queryptr = (
unsigned char *)hdr +
sizeof(*hdr);
735 LOG_DBG(
"flags1=0x%02X flags2=0x%02X nquestions=%d, nanswers=%d, " \
736 "nauthrr=%d, nextrarr=%d\n",
737 hdr->flags1, hdr->flags2, (uint8_t)nquestions, (uint8_t)nanswers,
738 (uint8_t)uip_ntohs(hdr->numauthrr),
739 (uint8_t)uip_ntohs(hdr->numextrarr));
741 if(is_request && nquestions == 0) {
743 LOG_DBG(
"Skipping request with no questions\n");
749 for(; nquestions > 0;
750 queryptr = skip_name(queryptr) +
sizeof(
struct dns_question),
753#if RESOLV_SUPPORTS_MDNS
763 struct dns_question *question =
764 (
struct dns_question *)skip_name(queryptr);
766#if !ARCH_DOESNT_NEED_ALIGNED_STRUCTS
767 static struct dns_question aligned;
768 memcpy(&aligned, question,
sizeof(aligned));
772 LOG_DBG(
"Question %d: type=%d class=%d\n", ++i,
775 if((uip_ntohs(question->class) & 0x7FFF) != DNS_CLASS_IN ||
776 (question->type !=
UIP_HTONS(DNS_TYPE_ANY) &&
777 question->type !=
UIP_HTONS(NATIVE_DNS_TYPE))) {
782 if(!dns_name_isequal(queryptr, resolv_hostname,
uip_appdata)) {
786 LOG_DBG(
"Received MDNS request for us\n");
788 if(mdns_state == MDNS_STATE_READY) {
792 if(UIP_UDP_BUF->srcport ==
UIP_HTONS(MDNS_PORT)) {
793 mdns_announce_requested();
796 mdns_prep_host_announce_packet(),
798 UIP_UDP_BUF->srcport);
804 LOG_DBG(
"But we are still probing. Waiting...\n");
810 nauthrr = (uint8_t)uip_ntohs(hdr->numauthrr);
826 struct namemap *namemapptr = NULL;
828#if RESOLV_SUPPORTS_MDNS
829 if(UIP_UDP_BUF->srcport ==
UIP_HTONS(MDNS_PORT) && hdr->id == 0) {
839 for(i = 0; i < RESOLV_ENTRIES; ++i) {
840 namemapptr = &names[i];
841 if(namemapptr->state == STATE_ASKING &&
842 namemapptr->id == hdr->id) {
847 if(i >= RESOLV_ENTRIES || i < 0 || namemapptr->state != STATE_ASKING) {
848 LOG_DBG(
"DNS response has bad ID (%04X)\n", uip_ntohs(hdr->id));
852 LOG_DBG(
"Incoming response for \"%s\"\n", namemapptr->name);
855 namemapptr->state = STATE_ERROR;
856 namemapptr->err = hdr->flags2 & DNS_FLAG2_ERR_MASK;
858#if RESOLV_SUPPORTS_RECORD_EXPIRATION
864 if(namemapptr->err != 0) {
865 namemapptr->state = STATE_ERROR;
866 resolv_found(namemapptr->name, NULL);
874 while(nanswers > 0) {
875 struct dns_answer *ans = (
struct dns_answer *)skip_name(queryptr);
877#if !ARCH_DOESNT_NEED_ALIGNED_STRUCTS
879 static struct dns_answer aligned;
880 memcpy(&aligned, ans,
sizeof(aligned));
885 if(LOG_DBG_ENABLED) {
886 char debug_name[RESOLV_CONF_MAX_DOMAIN_NAME_SIZE + 1];
888 LOG_DBG(
"Answer %d: \"%s\", type %d, class %d, ttl %"PRIu32
", length %d\n",
889 ++i, debug_name, uip_ntohs(ans->type),
890 uip_ntohs(ans->class) & 0x7FFF,
891 (uint32_t)((uint32_t)uip_ntohs(ans->ttl[0]) << 16) |
892 (uint32_t)uip_ntohs(ans->ttl[1]), uip_ntohs(ans->len));
898 if((uip_ntohs(ans->class) & 0x7FFF) != DNS_CLASS_IN ||
899 ans->len !=
UIP_HTONS(
sizeof(uip_ipaddr_t))) {
900 goto skip_to_next_answer;
903 if(ans->type !=
UIP_HTONS(NATIVE_DNS_TYPE)) {
904 goto skip_to_next_answer;
907#if RESOLV_SUPPORTS_MDNS
908 if(UIP_UDP_BUF->srcport ==
UIP_HTONS(MDNS_PORT) && hdr->id == 0) {
909 int8_t available_i = RESOLV_ENTRIES;
911 LOG_DBG(
"MDNS query\n");
916 for(i = 0; i < RESOLV_ENTRIES; ++i) {
917 namemapptr = &names[i];
918 if(dns_name_isequal(queryptr, namemapptr->name,
uip_appdata)) {
921 if((namemapptr->state == STATE_UNUSED)
922#
if RESOLV_SUPPORTS_RECORD_EXPIRATION
923 || (namemapptr->state == STATE_DONE &&
930 if(i == RESOLV_ENTRIES) {
931 LOG_DBG(
"Unsolicited MDNS response\n");
933 namemapptr = &names[i];
934 if(!decode_name(queryptr, namemapptr->name,
936 LOG_DBG(
"MDNS name too big to cache\n");
938 goto skip_to_next_answer;
941 if(i == RESOLV_ENTRIES) {
942 LOG_DBG(
"Not enough room to keep track of unsolicited MDNS answer\n");
944 if(dns_name_isequal(queryptr, resolv_hostname,
uip_appdata)) {
946 resolv_found(resolv_hostname, (uip_ipaddr_t *)ans->ipaddr);
949 goto skip_to_next_answer;
951 namemapptr = &names[i];
968 LOG_DBG(
"Answer for \"%s\" is usable\n", namemapptr->name);
970 namemapptr->state = STATE_DONE;
971#if RESOLV_SUPPORTS_RECORD_EXPIRATION
972 namemapptr->expiration = (uint32_t)uip_ntohs(ans->ttl[0]) << 16 |
973 (uint32_t)uip_ntohs(ans->ttl[1]);
974 LOG_DBG(
"Expires in %lu seconds\n", namemapptr->expiration);
981 resolv_found(namemapptr->name, &namemapptr->ipaddr);
985 queryptr = (
unsigned char *)skip_name(queryptr) + 10 +
uip_htons(ans->len);
991#if RESOLV_SUPPORTS_MDNS
992 if(nanswers == 0 && UIP_UDP_BUF->srcport !=
UIP_HTONS(MDNS_PORT)
998 if(try_next_server(namemapptr)) {
999 namemapptr->state = STATE_ASKING;
1000 process_post(&resolv_process, PROCESS_EVENT_TIMER, NULL);
1005#if RESOLV_SUPPORTS_MDNS
1011resolv_set_hostname(
const char *hostname)
1013 strncpy(resolv_hostname, hostname, RESOLV_CONF_MAX_DOMAIN_NAME_SIZE);
1016 if(strlen(resolv_hostname) < 7 ||
1017 strcasecmp(resolv_hostname + strlen(resolv_hostname) - 6,
".local") != 0) {
1018 strncat(resolv_hostname,
".local",
1019 RESOLV_CONF_MAX_DOMAIN_NAME_SIZE - strlen(resolv_hostname));
1022 LOG_DBG(
"hostname changed to \"%s\"\n", resolv_hostname);
1024 start_name_collision_check(0);
1032resolv_get_hostname(
void)
1034 return resolv_hostname;
1042 static struct etimer delay;
1045 mdns_state = MDNS_STATE_WAIT_BEFORE_PROBE;
1047 LOG_DBG(
"mdns-probe: Process (re)started\n");
1051 LOG_DBG(
"mdns-probe: Probing will begin in %ld clocks\n",
1052 (
long)*(clock_time_t *)data);
1063 mdns_state = MDNS_STATE_PROBING;
1068 }
while(strcasecmp(resolv_hostname, data) != 0);
1070 mdns_state = MDNS_STATE_READY;
1071 mdns_announce_requested();
1073 LOG_DBG(
"mdns-probe: Finished probing\n");
1086 memset(names, 0,
sizeof(names));
1090 LOG_DBG(
"Process started\n");
1092 resolv_conn =
udp_new(NULL, 0, NULL);
1093 if(resolv_conn == NULL) {
1094 LOG_ERR(
"No UDP connection available, exiting the process!\n");
1098#if RESOLV_SUPPORTS_MDNS
1099 LOG_DBG(
"Supports MDNS\n");
1102 uip_ds6_maddr_add(&resolv_mdns_addr);
1104 resolv_set_hostname(CONTIKI_CONF_DEFAULT_HOSTNAME);
1110 if(ev == PROCESS_EVENT_TIMER) {
1117#if RESOLV_SUPPORTS_MDNS
1118 if(mdns_needs_host_announce) {
1121 LOG_DBG(
"Announcing that we are \"%s\"\n",
1125 len = mdns_prep_host_announce_packet();
1127 len, &resolv_mdns_addr,
UIP_HTONS(MDNS_PORT));
1128 mdns_needs_host_announce = 0;
1143#if RESOLV_SUPPORTS_MDNS
1144 if(mdns_needs_host_announce) {
1156 static uint8_t initialized = 0;
1163#if RESOLV_AUTO_REMOVE_TRAILING_DOTS
1165remove_trailing_dots(
const char *name)
1167 static char dns_name_without_dots[RESOLV_CONF_MAX_DOMAIN_NAME_SIZE + 1];
1168 size_t len = strlen(name);
1170 if(len && name[len - 1] ==
'.') {
1171 strncpy(dns_name_without_dots, name, RESOLV_CONF_MAX_DOMAIN_NAME_SIZE);
1172 while(len && (dns_name_without_dots[len - 1] ==
'.')) {
1173 dns_name_without_dots[--len] = 0;
1175 name = dns_name_without_dots;
1180#define remove_trailing_dots(x) (x)
1191 uint8_t lseqi = 0, lseq = 0, i = 0;
1192 struct namemap *nameptr = 0;
1197 name = remove_trailing_dots(name);
1199 for(i = 0; i < RESOLV_ENTRIES; ++i) {
1200 nameptr = &names[i];
1201 if(0 == strcasecmp(nameptr->name, name)) {
1204 if((nameptr->state == STATE_UNUSED)
1205#
if RESOLV_SUPPORTS_RECORD_EXPIRATION
1206 || (nameptr->state == STATE_DONE &&
clock_seconds() > nameptr->expiration)
1211 }
else if(seqno - nameptr->seqno > lseq) {
1212 lseq = seqno - nameptr->seqno;
1217 if(i == RESOLV_ENTRIES) {
1219 nameptr = &names[i];
1222 LOG_DBG(
"Starting query for \"%s\"\n", name);
1224 memset(nameptr, 0,
sizeof(*nameptr));
1226 strncpy(nameptr->name, name,
sizeof(nameptr->name) - 1);
1227 nameptr->state = STATE_NEW;
1228 nameptr->seqno = seqno;
1231#if RESOLV_SUPPORTS_MDNS
1233 size_t name_len = strlen(name);
1234 const char local_suffix[] =
"local";
1236 if(name_len > (
sizeof(local_suffix) - 1) &&
1237 strcasecmp(name + name_len - (
sizeof(local_suffix) - 1),
1238 local_suffix) == 0) {
1239 LOG_DBG(
"Using MDNS to look up \"%s\"\n", name);
1240 nameptr->is_mdns =
true;
1242 nameptr->is_mdns =
false;
1245 nameptr->is_probe = mdns_state == MDNS_STATE_PROBING &&
1246 strcmp(nameptr->name, resolv_hostname) == 0;
1268 name = remove_trailing_dots(name);
1270#if UIP_CONF_LOOPBACK_INTERFACE
1271 if(strcmp(name,
"localhost") == 0) {
1272 static uip_ipaddr_t loopback =
1273 { { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1274 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
1284 for(i = 0; i < RESOLV_ENTRIES; ++i) {
1285 struct namemap *nameptr = &names[i];
1287 if(strcasecmp(name, nameptr->name) == 0) {
1288 switch(nameptr->state) {
1291#if RESOLV_SUPPORTS_RECORD_EXPIRATION
1304#if RESOLV_SUPPORTS_RECORD_EXPIRATION
1313 *
ipaddr = &nameptr->ipaddr;
1321 if(LOG_DBG_ENABLED) {
1325 LOG_DBG(
"Found \"%s\" in cache => ", name);
1327 LOG_DBG_6ADDR(
addr);
1332 LOG_DBG(
"\"%s\" is NOT cached\n", name);
1345resolv_found(
char *name, uip_ipaddr_t *
ipaddr)
1347#if RESOLV_SUPPORTS_MDNS
1348 if(strncasecmp(resolv_hostname, name, strlen(resolv_hostname)) == 0 &&
1352 if(mdns_state == MDNS_STATE_PROBING) {
1356 LOG_DBG(
"Name collision detected for \"%s\"\n", name);
1359 resolv_hostname[strlen(resolv_hostname) - 6] = 0;
1362 for(i = 0; i < 3; ++i) {
1365 char append_str[4] =
"-XX";
1367 append_str[2] = (((val & 0xF) > 9) ?
'a' :
'0') + (val & 0xF);
1369 append_str[1] = (((val & 0xF) > 9) ?
'a' :
'0') + (val & 0xF);
1371 strncat(resolv_hostname, append_str,
1372 sizeof(resolv_hostname) - strlen(resolv_hostname) - 1);
1376 strncat(resolv_hostname,
".local",
1377 RESOLV_CONF_MAX_DOMAIN_NAME_SIZE - strlen(resolv_hostname));
1380 }
else if(mdns_state == MDNS_STATE_READY) {
1385 LOG_DBG(
"Possible name collision, probing...\n");
1386 start_name_collision_check(0);
1391 LOG_DBG(
"Found address for \"%s\" => ", name);
1395 LOG_DBG(
"Unable to retrieve address for \"%s\"\n", name);
unsigned long clock_seconds(void)
Get the current value of the platform seconds.
unsigned short random_rand(void)
Generates a new random number using the cc2538 RNG.
PROCESS_THREAD(cc2538_rf_process, ev, data)
Implementation of the cc2538 RF driver process.
static volatile uint64_t count
Num.
#define CLOCK_SECOND
A second, measured in system clock time.
void etimer_set(struct etimer *et, clock_time_t interval)
Set an event timer.
#define PROCESS(name, strname)
Declare a process.
#define PROCESS_EXIT()
Exit the currently running process.
#define PROCESS_WAIT_EVENT()
Wait for an event to be posted to the process.
int process_post(struct process *p, process_event_t ev, process_data_t data)
Post an asynchronous event.
void process_exit(struct process *p)
Cause a process to exit.
process_event_t process_alloc_event(void)
Allocate a global event number.
#define PROCESS_BEGIN()
Define the beginning of a process.
#define PROCESS_WAIT_EVENT_UNTIL(c)
Wait for an event to be posted to the process, with an extra condition.
#define PROCESS_END()
Define the end of a process.
void process_start(struct process *p, process_data_t data)
Start a process.
process_event_t tcpip_event
The uIP event.
struct uip_udp_conn * udp_new(const uip_ipaddr_t *ripaddr, uint16_t port, void *appstate)
Create a new UDP connection.
void tcpip_poll_udp(struct uip_udp_conn *conn)
Cause a specified UDP connection to be polled.
uip_lladdr_t uip_lladdr
Host L2 address.
void * uip_appdata
Pointer to the application data in the packet buffer.
#define UIP_LLADDR_LEN
802.15.4 address
#define uip_is_addr_linklocal(a)
is addr (a) a link local unicast address, see RFC 4291 i.e.
uip_ipaddr_t * uip_nameserver_get(uint8_t num)
Get a Nameserver ip address given in RA.
uip_ds6_netif_t uip_ds6_if
The single interface.
#define UIP_IP_BUF
Direct access to IPv6 header.
#define uip_datalen()
The length of any incoming data that is currently available (if available) in the uip_appdata buffer.
#define uip_newdata()
Is new incoming data available?
#define uip_poll()
Is the connection being polled by uIP?
#define uip_udp_bind(conn, port)
Bind a UDP connection to a local port.
#define UIP_HTONS(n)
Convert 16-bit quantity from host byte order to network byte order.
#define uip_ipaddr_copy(dest, src)
Copy an IP address from one place to another.
uint16_t uip_htons(uint16_t val)
Convert a 16-bit quantity from host byte order to network byte order.
void resolv_query(const char *name)
Queues a name so that a question for the name will be sent out.
#define RESOLV_CONF_MAX_RETRIES
The maximum number of retries when asking for a name.
resolv_status_t resolv_lookup(const char *name, uip_ipaddr_t **ipaddr)
Look up a hostname in the array of known hostnames.
static void newdata(void)
process_event_t resolv_event_found
Event that is broadcasted when a DNS name has been resolved.
Header file for the logging system.
uIP DNS resolver code header file.
@ RESOLV_STATUS_RESOLVING
This hostname is in the process of being resolved.
@ RESOLV_STATUS_EXPIRED
Hostname was found, but it's status has expired.
@ RESOLV_STATUS_NOT_FOUND
The server has returned a not-found response for this domain name.
@ RESOLV_STATUS_CACHED
Hostname is fresh and usable.
@ RESOLV_STATUS_UNCACHED
Hostname was not found in the cache.
Representation of a uIP UDP connection.
Header for the Contiki/uIP interface.
Header file for IPv6-related data structures.
uIP Name Server interface
static uip_ipaddr_t ipaddr
Pointer to prefix information option in uip_buf.
static uip_ds6_addr_t * addr
Pointer to a nbr cache entry.
Header file for module for sending UDP packets through uIP.