mirror of
https://github.com/lwip-tcpip/lwip.git
synced 2024-12-27 06:14:09 +00:00
3043d9d023
mDNS.c needed to become cleaner. Domain related functions are moved to the mdns_domain.c util module. The output related functions are split off (clear separation between defining the packet and generating the packet). The output functions can now be found in mdns_out.c. mDNS move probe question packet generation to mdns_send_outpacket The probe any questions were added to the pbuf in the send_probe routine. It is better if we move all pbuf generation to the output function so later on packets can be delayed etc. keep it all in one place. mDNS: move legacy question generation to mdns_send_outpacket It's better to do the pbuf generation in one place. Especially important for message delaying etc. mDNS take out domain related functionality and put in other file. The mDNS file is getting very big and a lot still needs to be added. For clarity reasons it's better to split these domain functions from the main mDNS file. mDNS split off output related functionality and put in other file A lot of functions are only needed for the generation of the pbuf, by separating them into another file we clean up the mdns file. We only need the mdns_send_outpacket function as interface. Packet definition is now completely separated from packet generation.
917 lines
28 KiB
C
917 lines
28 KiB
C
/*
|
|
* Copyright (c) 2015 Verisure Innovation AB
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
|
* OF SUCH DAMAGE.
|
|
*
|
|
* This file is part of the lwIP TCP/IP stack.
|
|
*
|
|
* Author: Erik Ekman <erik@kryo.se>
|
|
*
|
|
*/
|
|
|
|
#include "test_mdns.h"
|
|
|
|
#include "lwip/pbuf.h"
|
|
#include "lwip/apps/mdns.h"
|
|
#include "lwip/apps/mdns_domain.h"
|
|
#include "lwip/apps/mdns_priv.h"
|
|
|
|
START_TEST(readname_basic)
|
|
{
|
|
static const u8_t data[] = { 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00 };
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == sizeof(data));
|
|
fail_unless(domain.length == sizeof(data));
|
|
fail_if(memcmp(&domain.name, data, sizeof(data)));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_anydata)
|
|
{
|
|
static const u8_t data[] = { 0x05, 0x00, 0xFF, 0x08, 0xc0, 0x0f, 0x04, 0x7f, 0x80, 0x82, 0x88, 0x00 };
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == sizeof(data));
|
|
fail_unless(domain.length == sizeof(data));
|
|
fail_if(memcmp(&domain.name, data, sizeof(data)));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_short_buf)
|
|
{
|
|
static const u8_t data[] = { 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a' };
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == MDNS_READNAME_ERROR);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_long_label)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i',
|
|
0x52, 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a',
|
|
'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a',
|
|
'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a',
|
|
'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a',
|
|
'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a',
|
|
'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == MDNS_READNAME_ERROR);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_overflow)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == MDNS_READNAME_ERROR);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_jump_earlier)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* Some padding needed, not supported to jump to bytes containing dns header */
|
|
/* 0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/* 10 */ 0x0f, 0x0e, 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xab,
|
|
/* 20 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x0c
|
|
};
|
|
static const u8_t fullname[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 20, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == sizeof(data));
|
|
fail_unless(domain.length == sizeof(fullname));
|
|
|
|
fail_if(memcmp(&domain.name, fullname, sizeof(fullname)));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_jump_earlier_jump)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* Some padding needed, not supported to jump to bytes containing dns header */
|
|
/* 0x00 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/* 0x08 */ 0x00, 0x00, 0x00, 0x00, 0x03, 0x0b, 0x0a, 0xf2,
|
|
/* 0x10 */ 0x04, 'c', 'a', 's', 't', 0x00, 0xc0, 0x10,
|
|
/* 0x18 */ 0x05, 'm', 'u', 'l', 't', 'i', 0xc0, 0x16
|
|
};
|
|
static const u8_t fullname[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0x18, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == sizeof(data));
|
|
fail_unless(domain.length == sizeof(fullname));
|
|
|
|
fail_if(memcmp(&domain.name, fullname, sizeof(fullname)));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_jump_maxdepth)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* Some padding needed, not supported to jump to bytes containing dns header */
|
|
/* 0x00 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/* 0x08 */ 0x00, 0x00, 0x00, 0x00, 0x03, 0x0b, 0x0a, 0xf2,
|
|
/* 0x10 */ 0x04, 'n', 'a', 'm', 'e', 0xc0, 0x27, 0x03,
|
|
/* 0x18 */ 0x03, 'd', 'n', 's', 0xc0, 0x10, 0xc0, 0x10,
|
|
/* 0x20 */ 0x04, 'd', 'e', 'e', 'p', 0xc0, 0x18, 0x00,
|
|
/* 0x28 */ 0x04, 'c', 'a', 's', 't', 0xc0, 0x20, 0xb0,
|
|
/* 0x30 */ 0x05, 'm', 'u', 'l', 't', 'i', 0xc0, 0x28
|
|
};
|
|
static const u8_t fullname[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't',
|
|
0x04, 'd', 'e', 'e', 'p', 0x03, 'd', 'n', 's',
|
|
0x04, 'n', 'a', 'm', 'e', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0x30, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == sizeof(data));
|
|
fail_unless(domain.length == sizeof(fullname));
|
|
|
|
fail_if(memcmp(&domain.name, fullname, sizeof(fullname)));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_jump_later)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* 0x00 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x10, 0x00, 0x01, 0x40,
|
|
/* 0x10 */ 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xab
|
|
};
|
|
static const u8_t fullname[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == 13);
|
|
fail_unless(domain.length == sizeof(fullname));
|
|
|
|
fail_if(memcmp(&domain.name, fullname, sizeof(fullname)));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_half_jump)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == MDNS_READNAME_ERROR);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_jump_toolong)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc2, 0x10, 0x00, 0x01, 0x40
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 0, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == MDNS_READNAME_ERROR);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_jump_loop_label)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* 0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/* 10 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x10
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 10, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == MDNS_READNAME_ERROR);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(readname_jump_loop_jump)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* 0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/* 10 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x15
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
offset = mdns_readname(p, 10, &domain);
|
|
pbuf_free(p);
|
|
fail_unless(offset == MDNS_READNAME_ERROR);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(add_label_basic)
|
|
{
|
|
static const u8_t data[] = { 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00 };
|
|
struct mdns_domain domain;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == sizeof(data));
|
|
fail_if(memcmp(&domain.name, data, sizeof(data)));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(add_label_long_label)
|
|
{
|
|
static const char *toolong = "abcdefghijklmnopqrstuvwxyz0123456789-abcdefghijklmnopqrstuvwxyz0123456789-abcdefghijklmnopqrstuvwxyz0123456789-";
|
|
struct mdns_domain domain;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, toolong, (u8_t)strlen(toolong));
|
|
fail_unless(res == ERR_VAL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(add_label_full)
|
|
{
|
|
static const char *label = "0123456789abcdef0123456789abcdef";
|
|
struct mdns_domain domain;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 33);
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 66);
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 99);
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 132);
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 165);
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 198);
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 231);
|
|
res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label));
|
|
fail_unless(res == ERR_VAL);
|
|
fail_unless(domain.length == 231);
|
|
res = mdns_domain_add_label(&domain, label, 25);
|
|
fail_unless(res == ERR_VAL);
|
|
fail_unless(domain.length == 231);
|
|
res = mdns_domain_add_label(&domain, label, 24);
|
|
fail_unless(res == ERR_VAL);
|
|
fail_unless(domain.length == 231);
|
|
res = mdns_domain_add_label(&domain, label, 23);
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 255);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain.length == 256);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_VAL);
|
|
fail_unless(domain.length == 256);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(domain_eq_basic)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00
|
|
};
|
|
struct mdns_domain domain1, domain2;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain1, 0, sizeof(domain1));
|
|
res = mdns_domain_add_label(&domain1, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
fail_unless(domain1.length == sizeof(data));
|
|
|
|
memset(&domain2, 0, sizeof(domain2));
|
|
res = mdns_domain_add_label(&domain2, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
fail_unless(mdns_domain_eq(&domain1, &domain2));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(domain_eq_diff)
|
|
{
|
|
struct mdns_domain domain1, domain2;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain1, 0, sizeof(domain1));
|
|
res = mdns_domain_add_label(&domain1, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, "base", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
memset(&domain2, 0, sizeof(domain2));
|
|
res = mdns_domain_add_label(&domain2, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
fail_if(mdns_domain_eq(&domain1, &domain2));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(domain_eq_case)
|
|
{
|
|
struct mdns_domain domain1, domain2;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain1, 0, sizeof(domain1));
|
|
res = mdns_domain_add_label(&domain1, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
memset(&domain2, 0, sizeof(domain2));
|
|
res = mdns_domain_add_label(&domain2, "MulTI", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, "casT", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
fail_unless(mdns_domain_eq(&domain1, &domain2));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(domain_eq_anydata)
|
|
{
|
|
static const u8_t data1[] = { 0x05, 0xcc, 0xdc, 0x00, 0xa0 };
|
|
static const u8_t data2[] = { 0x7f, 0x8c, 0x01, 0xff, 0xcf };
|
|
struct mdns_domain domain1, domain2;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain1, 0, sizeof(domain1));
|
|
res = mdns_domain_add_label(&domain1, (const char*)data1, sizeof(data1));
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, (const char*)data2, sizeof(data2));
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
memset(&domain2, 0, sizeof(domain2));
|
|
res = mdns_domain_add_label(&domain2, (const char*)data1, sizeof(data1));
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, "casT", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, (const char*)data2, sizeof(data2));
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
fail_unless(mdns_domain_eq(&domain1, &domain2));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(domain_eq_length)
|
|
{
|
|
struct mdns_domain domain1, domain2;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
memset(&domain1, 0, sizeof(domain1));
|
|
memset(domain1.name, 0xAA, sizeof(MDNS_DOMAIN_MAXLEN));
|
|
res = mdns_domain_add_label(&domain1, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain1, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
memset(&domain2, 0, sizeof(domain2));
|
|
memset(domain2.name, 0xBB, sizeof(MDNS_DOMAIN_MAXLEN));
|
|
res = mdns_domain_add_label(&domain2, "multi", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain2, "cast", 4);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
fail_unless(mdns_domain_eq(&domain1, &domain2));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_full_match)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x00, 0x00,
|
|
0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "foobar", 6);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 2;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Write 0 bytes, then a jump to addr 2 */
|
|
fail_unless(length == 0);
|
|
fail_unless(offset == 2);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_full_match_subset)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x00, 0x00,
|
|
0x02, 'g', 'o', 0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "foobar", 6);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 2;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Write 0 bytes, then a jump to addr 5 */
|
|
fail_unless(length == 0);
|
|
fail_unless(offset == 5);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_full_match_jump)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* 0x00 */ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
/* 0x10 */ 0x04, 'l', 'w', 'i', 'p', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xc0, 0x00, 0x02, 0x00,
|
|
/* 0x20 */ 0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0xc0, 0x15
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "foobar", 6);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 0x20;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Write 0 bytes, then a jump to addr 0x20 */
|
|
fail_unless(length == 0);
|
|
fail_unless(offset == 0x20);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_no_match)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x00, 0x00,
|
|
0x04, 'l', 'w', 'i', 'p', 0x05, 'w', 'i', 'k', 'i', 'a', 0x03, 'c', 'o', 'm', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "foobar", 6);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 2;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Write all bytes, no jump */
|
|
fail_unless(length == domain.length);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_2nd_label)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x00, 0x00,
|
|
0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "lwip", 4);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 2;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Write 5 bytes, then a jump to addr 9 */
|
|
fail_unless(length == 5);
|
|
fail_unless(offset == 9);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_2nd_label_short)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x00, 0x00,
|
|
0x04, 'l', 'w', 'i', 'p', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "foobar", 6);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 2;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Write 5 bytes, then a jump to addr 7 */
|
|
fail_unless(length == 7);
|
|
fail_unless(offset == 7);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_jump_to_jump)
|
|
{
|
|
static const u8_t data[] = {
|
|
/* 0x00 */ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
/* 0x10 */ 0x04, 'l', 'w', 'i', 'p', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xc0, 0x00, 0x02, 0x00,
|
|
/* 0x20 */ 0x07, 'b', 'a', 'n', 'a', 'n', 'a', 's', 0xc0, 0x15
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "foobar", 6);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 0x20;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Dont compress if jump would be to a jump */
|
|
fail_unless(length == domain.length);
|
|
|
|
offset = 0x10;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
/* Write 7 bytes, then a jump to addr 0x15 */
|
|
fail_unless(length == 7);
|
|
fail_unless(offset == 0x15);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(compress_long_match)
|
|
{
|
|
static const u8_t data[] = {
|
|
0x00, 0x00,
|
|
0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x03, 'c', 'o', 'm', 0x00
|
|
};
|
|
struct pbuf *p;
|
|
struct mdns_domain domain;
|
|
u16_t offset;
|
|
u16_t length;
|
|
err_t res;
|
|
LWIP_UNUSED_ARG(_i);
|
|
|
|
p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM);
|
|
fail_if(p == NULL);
|
|
p->payload = (void *)(size_t)data;
|
|
|
|
memset(&domain, 0, sizeof(domain));
|
|
res = mdns_domain_add_label(&domain, "foobar", 6);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, "local", 5);
|
|
fail_unless(res == ERR_OK);
|
|
res = mdns_domain_add_label(&domain, NULL, 0);
|
|
fail_unless(res == ERR_OK);
|
|
|
|
offset = 2;
|
|
length = mdns_compress_domain(p, &offset, &domain);
|
|
fail_unless(length == domain.length);
|
|
|
|
pbuf_free(p);
|
|
}
|
|
END_TEST
|
|
|
|
Suite* mdns_suite(void)
|
|
{
|
|
testfunc tests[] = {
|
|
TESTFUNC(readname_basic),
|
|
TESTFUNC(readname_anydata),
|
|
TESTFUNC(readname_short_buf),
|
|
TESTFUNC(readname_long_label),
|
|
TESTFUNC(readname_overflow),
|
|
TESTFUNC(readname_jump_earlier),
|
|
TESTFUNC(readname_jump_earlier_jump),
|
|
TESTFUNC(readname_jump_maxdepth),
|
|
TESTFUNC(readname_jump_later),
|
|
TESTFUNC(readname_half_jump),
|
|
TESTFUNC(readname_jump_toolong),
|
|
TESTFUNC(readname_jump_loop_label),
|
|
TESTFUNC(readname_jump_loop_jump),
|
|
|
|
TESTFUNC(add_label_basic),
|
|
TESTFUNC(add_label_long_label),
|
|
TESTFUNC(add_label_full),
|
|
|
|
TESTFUNC(domain_eq_basic),
|
|
TESTFUNC(domain_eq_diff),
|
|
TESTFUNC(domain_eq_case),
|
|
TESTFUNC(domain_eq_anydata),
|
|
TESTFUNC(domain_eq_length),
|
|
|
|
TESTFUNC(compress_full_match),
|
|
TESTFUNC(compress_full_match_subset),
|
|
TESTFUNC(compress_full_match_jump),
|
|
TESTFUNC(compress_no_match),
|
|
TESTFUNC(compress_2nd_label),
|
|
TESTFUNC(compress_2nd_label_short),
|
|
TESTFUNC(compress_jump_to_jump),
|
|
TESTFUNC(compress_long_match),
|
|
};
|
|
return create_suite("MDNS", tests, sizeof(tests)/sizeof(testfunc), NULL, NULL);
|
|
}
|