apps/mdns/mdns.c

96 /* Stored offsets to beginning of domain names
243   /** Offsets for written domain names in packet.
264   struct mdns_domain domain;
291 mdns_domain_add_label_base(struct mdns_domain *domain, u8_t len)
296   if (len > 0 && (1 + len + domain->length >= MDNS_DOMAIN_MAXLEN)) {
300   if (len == 0 && (1 + domain->length > MDNS_DOMAIN_MAXLEN)) {
303   domain->name[domain->length] = len;
304   domain->length++;
309  * Add a label part to a domain
310  * @param domain The domain to add a label to
316 mdns_domain_add_label(struct mdns_domain *domain, const char *label, u8_t len)
318   err_t err = mdns_domain_add_label_base(domain, len);
323     MEMCPY(&domain->name[domain->length], label, len);
324     domain->length += len;
330  * Add a label part to a domain (@see mdns_domain_add_label but copy directly from pbuf)
333 mdns_domain_add_label_pbuf(struct mdns_domain *domain, const struct pbuf *p, u16_t offset, u8_t len)
335   err_t err = mdns_domain_add_label_base(domain, len);
340     if (pbuf_copy_partial(p, &domain->name[domain->length], len, offset) != len) {
342       domain->length--;
345     domain->length += len;
355 mdns_readname_loop(struct pbuf *p, u16_t offset, struct mdns_domain *domain, unsigned depth)
380         res = mdns_readname_loop(p, jumpaddr, domain, depth + 1);
395       if (c + domain->length >= MDNS_DOMAIN_MAXLEN) {
398       res = mdns_domain_add_label_pbuf(domain, p, offset, c);
413  * Read possibly compressed domain name from packet buffer
415  * @param offset start position of domain name in packet
416  * @param domain The domain name destination
417  * @return The new offset after the domain, or MDNS_READNAME_ERROR
421 mdns_readname(struct pbuf *p, u16_t offset, struct mdns_domain *domain)
423   memset(domain, 0, sizeof(struct mdns_domain));
424   return mdns_readname_loop(p, offset, domain, 0);
428  * Print domain name to debug output
429  * @param domain The domain name
432 mdns_domain_debug_print(struct mdns_domain *domain)
434   u8_t *src = domain->name;
502  * Build domain for reverse lookup of IPv4 address
504  * @param domain Where to write the domain name
506  * @return ERR_OK if domain was written, an err_t otherwise
509 mdns_build_reverse_v4_domain(struct mdns_domain *domain, const ip4_addr_t *addr)
516   if (!domain || !addr) {
519   memset(domain, 0, sizeof(struct mdns_domain));
526     res = mdns_domain_add_label(domain, buf, (u8_t)strlen(buf));
529   res = mdns_domain_add_label(domain, REVERSE_PTR_V4_DOMAIN, (u8_t)(sizeof(REVERSE_PTR_V4_DOMAIN) - 1));
531   res = mdns_domain_add_label(domain, REVERSE_PTR_TOPDOMAIN, (u8_t)(sizeof(REVERSE_PTR_TOPDOMAIN) - 1));
533   res = mdns_domain_add_label(domain, NULL, 0);
542  * Build domain for reverse lookup of IP address
544  * @param domain Where to write the domain name
546  * @return ERR_OK if domain was written, an err_t otherwise
549 mdns_build_reverse_v6_domain(struct mdns_domain *domain, const ip6_addr_t *addr)
555   if (!domain || !addr) {
558   memset(domain, 0, sizeof(struct mdns_domain));
570       res = mdns_domain_add_label(domain, &buf, sizeof(buf));
575   res = mdns_domain_add_label(domain, REVERSE_PTR_V6_DOMAIN, (u8_t)(sizeof(REVERSE_PTR_V6_DOMAIN) - 1));
577   res = mdns_domain_add_label(domain, REVERSE_PTR_TOPDOMAIN, (u8_t)(sizeof(REVERSE_PTR_TOPDOMAIN) - 1));
579   res = mdns_domain_add_label(domain, NULL, 0);
586 /* Add .local. to domain */
588 mdns_add_dotlocal(struct mdns_domain *domain)
590   err_t res = mdns_domain_add_label(domain, TOPDOMAIN_LOCAL, (u8_t)(sizeof(TOPDOMAIN_LOCAL) - 1));
593   return mdns_domain_add_label(domain, NULL, 0);
597  * Build the <hostname>.local. domain name
598  * @param domain Where to write the domain name
600  * @return ERR_OK if domain <hostname>.local. was written, an err_t otherwise
603 mdns_build_host_domain(struct mdns_domain *domain, struct mdns_host *mdns)
607   memset(domain, 0, sizeof(struct mdns_domain));
609   res = mdns_domain_add_label(domain, mdns->name, (u8_t)strlen(mdns->name));
611   return mdns_add_dotlocal(domain);
615  * Build the lookup-all-services special DNS-SD domain name
616  * @param domain Where to write the domain name
617  * @return ERR_OK if domain _services._dns-sd._udp.local. was written, an err_t otherwise
620 mdns_build_dnssd_domain(struct mdns_domain *domain)
624   memset(domain, 0, sizeof(struct mdns_domain));
625   res = mdns_domain_add_label(domain, "_services", (u8_t)(sizeof("_services") - 1));
627   res = mdns_domain_add_label(domain, "_dns-sd", (u8_t)(sizeof("_dns-sd") - 1));
629   res = mdns_domain_add_label(domain, dnssd_protos[DNSSD_PROTO_UDP], (u8_t)strlen(dnssd_protos[DNSSD_PROTO_UDP]));
631   return mdns_add_dotlocal(domain);
635  * Build domain name for a service
636  * @param domain Where to write the domain name
638  * @param include_name Whether to include the service name in the domain
639  * @return ERR_OK if domain was written. If service name is included,
644 mdns_build_service_domain(struct mdns_domain *domain, struct mdns_service *service, int include_name)
648   memset(domain, 0, sizeof(struct mdns_domain));
650     res = mdns_domain_add_label(domain, service->name, (u8_t)strlen(service->name));
653   res = mdns_domain_add_label(domain, service->service, (u8_t)strlen(service->service));
655   res = mdns_domain_add_label(domain, dnssd_protos[service->proto], (u8_t)strlen(dnssd_protos[service->proto]));
657   return mdns_add_dotlocal(domain);
689         if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) {
702       if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) {
711   if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) {
748   if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain) &&
755   if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain) &&
762   if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) {
776  * Return bytes needed to write before jump for best result of compressing supplied domain
777  * against domain in outpacket starting at specified offset.
780  * @param offset Start position of a domain written earlier. If this location is suitable
781  *               for compression, the pointer is updated to where in the domain to jump to.
782  * @param domain The domain to write
783  * @return Number of bytes to write of the new domain before writing a jump to the offset.
784  *         If compression can not be done against this previous domain name, the full new
785  *         domain length is returned.
788 mdns_compress_domain(struct pbuf *pbuf, u16_t *offset, struct mdns_domain *domain)
796     return domain->length;
800     return domain->length;
803   ptr = domain->name;
804   while (writelen < domain->length) {
805     u8_t domainlen = (u8_t)(domain->length - writelen);
808       /* Compare domains if target is long enough, and we have enough left of the domain */
815           memcmp(&domain->name[writelen], &target.name[targetpos], domainlen) == 0) {
820     /* Skip to next label in domain */
826   return domain->length;
830  * Write domain to outpacket. Compression will be attempted,
831  * unless domain->skip_compression is set.
833  * @param domain The domain name to write
837 mdns_write_domain(struct mdns_outpacket *outpkt, struct mdns_domain *domain)
841   u16_t writelen = domain->length;
845   if (!domain->skip_compression) {
849         u16_t len = mdns_compress_domain(outpkt->pbuf, &offset, domain);
860     res = pbuf_take_at(outpkt->pbuf, domain->name, writelen, outpkt->write_offset);
865     /* Store offset of this new domain */
889  * A question contains domain, type and class. Since an answer also starts with these fields this function is also
892  * @param domain The domain name the answer is for
900 mdns_add_question(struct mdns_outpacket *outpkt, struct mdns_domain *domain, u16_t type, u16_t klass, u16_t unicast)
916   question_len = domain->length + sizeof(type) + sizeof(klass);
923   res = mdns_write_domain(outpkt, domain);
953  * size of (compressed) domain. Most uses will need either buf or answer_domain,
954  * special case is SRV that starts with 3 u16 and then a domain name.
956  * @param domain The domain name the answer is for
960  *                    this reply replaces any earlier answer for this domain/type/class
964  * @param answer_domain A domain to write after any buffer data as answer
968 mdns_add_answer(struct mdns_outpacket *reply, struct mdns_domain *domain, u16_t type, u16_t klass, u16_t cache_flush,
988   answer_len = domain->length + sizeof(type) + sizeof(klass) + sizeof(ttl) + sizeof(field16)/*rd_length*/;
1001   mdns_add_question(reply, domain, type, klass, cache_flush);
1042  * Reads a domain, type and class from the packet
1045  * @param info The struct to fill with domain, type and class
1052   pkt->parse_offset = mdns_readname(pkt->pbuf, pkt->parse_offset, &info->domain);
1588     LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Query for domain "));
1589     mdns_domain_debug_print(&q.info.domain);
1611       res = mdns_add_question(&reply, &q.info.domain, q.info.type, q.info.klass, 0);
1631     LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Known answer for domain "));
1632     mdns_domain_debug_print(&ans.info.domain);
1649         /* Read domain and compare */
1703           /* Read domain and compare */
1809     LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Answer for domain "));
1810     mdns_domain_debug_print(&ans.info.domain);
1816       struct mdns_domain domain;
1820       res = mdns_build_host_domain(&domain, mdns);
1821       if (res == ERR_OK && mdns_domain_eq(&ans.info.domain, &domain)) {
1822         LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Probe response matches host domain!"));
1831         res = mdns_build_service_domain(&domain, service, 1);
1832         if ((res == ERR_OK) && mdns_domain_eq(&ans.info.domain, &domain)) {
1833           LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Probe response matches service domain!"));
1952   struct mdns_domain domain;
1962   mdns_build_host_domain(&domain, mdns);
1963   res = mdns_add_question(&pkt, &domain, DNS_RRTYPE_ANY, DNS_RRCLASS_IN, 1);
1973     mdns_build_service_domain(&domain, service, 1);
1974     res = mdns_add_question(&pkt, &domain, DNS_RRTYPE_ANY, DNS_RRCLASS_IN, 1);