Embed:
(wiki syntax)
Show/hide line numbers
test_mdns.c
00001 /* 00002 * Copyright (c) 2015 Verisure Innovation AB 00003 * All rights reserved. 00004 * 00005 * Redistribution and use in source and binary forms, with or without modification, 00006 * are permitted provided that the following conditions are met: 00007 * 00008 * 1. Redistributions of source code must retain the above copyright notice, 00009 * this list of conditions and the following disclaimer. 00010 * 2. Redistributions in binary form must reproduce the above copyright notice, 00011 * this list of conditions and the following disclaimer in the documentation 00012 * and/or other materials provided with the distribution. 00013 * 3. The name of the author may not be used to endorse or promote products 00014 * derived from this software without specific prior written permission. 00015 * 00016 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 00017 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 00018 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 00019 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 00020 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 00021 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 00022 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 00023 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 00024 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 00025 * OF SUCH DAMAGE. 00026 * 00027 * This file is part of the lwIP TCP/IP stack. 00028 * 00029 * Author: Erik Ekman <erik@kryo.se> 00030 * 00031 */ 00032 00033 #include "test_mdns.h" 00034 00035 #include "lwip/pbuf.h" 00036 #include "lwip/apps/mdns.h" 00037 #include "lwip/apps/mdns_priv.h" 00038 00039 START_TEST(readname_basic) 00040 { 00041 static const u8_t data[] = { 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00 }; 00042 struct pbuf *p; 00043 struct mdns_domain domain; 00044 u16_t offset; 00045 LWIP_UNUSED_ARG(_i); 00046 00047 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00048 p->payload = (void *)(size_t)data; 00049 fail_if(p == NULL); 00050 offset = mdns_readname(p, 0, &domain); 00051 pbuf_free(p); 00052 fail_unless(offset == sizeof(data)); 00053 fail_unless(domain.length == sizeof(data)); 00054 fail_if(memcmp(&domain.name, data, sizeof(data))); 00055 } 00056 END_TEST 00057 00058 START_TEST(readname_anydata) 00059 { 00060 static const u8_t data[] = { 0x05, 0x00, 0xFF, 0x08, 0xc0, 0x0f, 0x04, 0x7f, 0x80, 0x82, 0x88, 0x00 }; 00061 struct pbuf *p; 00062 struct mdns_domain domain; 00063 u16_t offset; 00064 LWIP_UNUSED_ARG(_i); 00065 00066 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00067 p->payload = (void *)(size_t)data; 00068 fail_if(p == NULL); 00069 offset = mdns_readname(p, 0, &domain); 00070 pbuf_free(p); 00071 fail_unless(offset == sizeof(data)); 00072 fail_unless(domain.length == sizeof(data)); 00073 fail_if(memcmp(&domain.name, data, sizeof(data))); 00074 } 00075 END_TEST 00076 00077 START_TEST(readname_short_buf) 00078 { 00079 static const u8_t data[] = { 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a' }; 00080 struct pbuf *p; 00081 struct mdns_domain domain; 00082 u16_t offset; 00083 LWIP_UNUSED_ARG(_i); 00084 00085 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00086 p->payload = (void *)(size_t)data; 00087 fail_if(p == NULL); 00088 offset = mdns_readname(p, 0, &domain); 00089 pbuf_free(p); 00090 fail_unless(offset == MDNS_READNAME_ERROR); 00091 } 00092 END_TEST 00093 00094 START_TEST(readname_long_label) 00095 { 00096 static const u8_t data[] = { 00097 0x05, 'm', 'u', 'l', 't', 'i', 00098 0x52, 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 00099 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 00100 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 00101 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 00102 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 00103 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 0x00 00104 }; 00105 struct pbuf *p; 00106 struct mdns_domain domain; 00107 u16_t offset; 00108 LWIP_UNUSED_ARG(_i); 00109 00110 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00111 p->payload = (void *)(size_t)data; 00112 fail_if(p == NULL); 00113 offset = mdns_readname(p, 0, &domain); 00114 pbuf_free(p); 00115 fail_unless(offset == MDNS_READNAME_ERROR); 00116 } 00117 END_TEST 00118 00119 START_TEST(readname_overflow) 00120 { 00121 static const u8_t data[] = { 00122 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00123 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00124 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00125 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00126 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00127 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00128 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00129 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00130 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00131 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00132 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00133 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00134 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00135 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00136 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00137 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00138 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00139 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00140 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00141 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00142 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00143 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00144 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00145 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00146 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00147 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00148 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00149 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00150 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00151 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00152 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00153 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00154 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00155 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00156 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00157 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00158 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00159 0x00 00160 }; 00161 struct pbuf *p; 00162 struct mdns_domain domain; 00163 u16_t offset; 00164 LWIP_UNUSED_ARG(_i); 00165 00166 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00167 p->payload = (void *)(size_t)data; 00168 fail_if(p == NULL); 00169 offset = mdns_readname(p, 0, &domain); 00170 pbuf_free(p); 00171 fail_unless(offset == MDNS_READNAME_ERROR); 00172 } 00173 END_TEST 00174 00175 START_TEST(readname_jump_earlier) 00176 { 00177 static const u8_t data[] = { 00178 /* Some padding needed, not supported to jump to bytes containing dns header */ 00179 /* 0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 00180 /* 10 */ 0x0f, 0x0e, 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xab, 00181 /* 20 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x0c 00182 }; 00183 static const u8_t fullname[] = { 00184 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00 00185 }; 00186 struct pbuf *p; 00187 struct mdns_domain domain; 00188 u16_t offset; 00189 LWIP_UNUSED_ARG(_i); 00190 00191 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00192 p->payload = (void *)(size_t)data; 00193 fail_if(p == NULL); 00194 offset = mdns_readname(p, 20, &domain); 00195 pbuf_free(p); 00196 fail_unless(offset == sizeof(data)); 00197 fail_unless(domain.length == sizeof(fullname)); 00198 00199 fail_if(memcmp(&domain.name, fullname, sizeof(fullname))); 00200 } 00201 END_TEST 00202 00203 START_TEST(readname_jump_earlier_jump) 00204 { 00205 static const u8_t data[] = { 00206 /* Some padding needed, not supported to jump to bytes containing dns header */ 00207 /* 0x00 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 00208 /* 0x08 */ 0x00, 0x00, 0x00, 0x00, 0x03, 0x0b, 0x0a, 0xf2, 00209 /* 0x10 */ 0x04, 'c', 'a', 's', 't', 0x00, 0xc0, 0x10, 00210 /* 0x18 */ 0x05, 'm', 'u', 'l', 't', 'i', 0xc0, 0x16 00211 }; 00212 static const u8_t fullname[] = { 00213 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00 00214 }; 00215 struct pbuf *p; 00216 struct mdns_domain domain; 00217 u16_t offset; 00218 LWIP_UNUSED_ARG(_i); 00219 00220 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00221 p->payload = (void *)(size_t)data; 00222 fail_if(p == NULL); 00223 offset = mdns_readname(p, 0x18, &domain); 00224 pbuf_free(p); 00225 fail_unless(offset == sizeof(data)); 00226 fail_unless(domain.length == sizeof(fullname)); 00227 00228 fail_if(memcmp(&domain.name, fullname, sizeof(fullname))); 00229 } 00230 END_TEST 00231 00232 START_TEST(readname_jump_maxdepth) 00233 { 00234 static const u8_t data[] = { 00235 /* Some padding needed, not supported to jump to bytes containing dns header */ 00236 /* 0x00 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 00237 /* 0x08 */ 0x00, 0x00, 0x00, 0x00, 0x03, 0x0b, 0x0a, 0xf2, 00238 /* 0x10 */ 0x04, 'n', 'a', 'm', 'e', 0xc0, 0x27, 0x03, 00239 /* 0x18 */ 0x03, 'd', 'n', 's', 0xc0, 0x10, 0xc0, 0x10, 00240 /* 0x20 */ 0x04, 'd', 'e', 'e', 'p', 0xc0, 0x18, 0x00, 00241 /* 0x28 */ 0x04, 'c', 'a', 's', 't', 0xc0, 0x20, 0xb0, 00242 /* 0x30 */ 0x05, 'm', 'u', 'l', 't', 'i', 0xc0, 0x28 00243 }; 00244 static const u8_t fullname[] = { 00245 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 00246 0x04, 'd', 'e', 'e', 'p', 0x03, 'd', 'n', 's', 00247 0x04, 'n', 'a', 'm', 'e', 0x00 00248 }; 00249 struct pbuf *p; 00250 struct mdns_domain domain; 00251 u16_t offset; 00252 LWIP_UNUSED_ARG(_i); 00253 00254 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00255 p->payload = (void *)(size_t)data; 00256 fail_if(p == NULL); 00257 offset = mdns_readname(p, 0x30, &domain); 00258 pbuf_free(p); 00259 fail_unless(offset == sizeof(data)); 00260 fail_unless(domain.length == sizeof(fullname)); 00261 00262 fail_if(memcmp(&domain.name, fullname, sizeof(fullname))); 00263 } 00264 END_TEST 00265 00266 START_TEST(readname_jump_later) 00267 { 00268 static const u8_t data[] = { 00269 /* 0x00 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x10, 0x00, 0x01, 0x40, 00270 /* 0x10 */ 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xab 00271 }; 00272 static const u8_t fullname[] = { 00273 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00 00274 }; 00275 struct pbuf *p; 00276 struct mdns_domain domain; 00277 u16_t offset; 00278 LWIP_UNUSED_ARG(_i); 00279 00280 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00281 p->payload = (void *)(size_t)data; 00282 fail_if(p == NULL); 00283 offset = mdns_readname(p, 0, &domain); 00284 pbuf_free(p); 00285 fail_unless(offset == 13); 00286 fail_unless(domain.length == sizeof(fullname)); 00287 00288 fail_if(memcmp(&domain.name, fullname, sizeof(fullname))); 00289 } 00290 END_TEST 00291 00292 START_TEST(readname_half_jump) 00293 { 00294 static const u8_t data[] = { 00295 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0 00296 }; 00297 struct pbuf *p; 00298 struct mdns_domain domain; 00299 u16_t offset; 00300 LWIP_UNUSED_ARG(_i); 00301 00302 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00303 p->payload = (void *)(size_t)data; 00304 fail_if(p == NULL); 00305 offset = mdns_readname(p, 0, &domain); 00306 pbuf_free(p); 00307 fail_unless(offset == MDNS_READNAME_ERROR); 00308 } 00309 END_TEST 00310 00311 START_TEST(readname_jump_toolong) 00312 { 00313 static const u8_t data[] = { 00314 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc2, 0x10, 0x00, 0x01, 0x40 00315 }; 00316 struct pbuf *p; 00317 struct mdns_domain domain; 00318 u16_t offset; 00319 LWIP_UNUSED_ARG(_i); 00320 00321 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00322 p->payload = (void *)(size_t)data; 00323 fail_if(p == NULL); 00324 offset = mdns_readname(p, 0, &domain); 00325 pbuf_free(p); 00326 fail_unless(offset == MDNS_READNAME_ERROR); 00327 } 00328 END_TEST 00329 00330 START_TEST(readname_jump_loop_label) 00331 { 00332 static const u8_t data[] = { 00333 /* 0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 00334 /* 10 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x10 00335 }; 00336 struct pbuf *p; 00337 struct mdns_domain domain; 00338 u16_t offset; 00339 LWIP_UNUSED_ARG(_i); 00340 00341 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00342 p->payload = (void *)(size_t)data; 00343 fail_if(p == NULL); 00344 offset = mdns_readname(p, 10, &domain); 00345 pbuf_free(p); 00346 fail_unless(offset == MDNS_READNAME_ERROR); 00347 } 00348 END_TEST 00349 00350 START_TEST(readname_jump_loop_jump) 00351 { 00352 static const u8_t data[] = { 00353 /* 0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 00354 /* 10 */ 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0xc0, 0x15 00355 }; 00356 struct pbuf *p; 00357 struct mdns_domain domain; 00358 u16_t offset; 00359 LWIP_UNUSED_ARG(_i); 00360 00361 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00362 p->payload = (void *)(size_t)data; 00363 fail_if(p == NULL); 00364 offset = mdns_readname(p, 10, &domain); 00365 pbuf_free(p); 00366 fail_unless(offset == MDNS_READNAME_ERROR); 00367 } 00368 END_TEST 00369 00370 START_TEST(add_label_basic) 00371 { 00372 static const u8_t data[] = { 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00 }; 00373 struct mdns_domain domain; 00374 err_t res; 00375 LWIP_UNUSED_ARG(_i); 00376 00377 memset(&domain, 0, sizeof(domain)); 00378 res = mdns_domain_add_label(&domain, "multi", 5); 00379 fail_unless(res == ERR_OK); 00380 res = mdns_domain_add_label(&domain, "cast", 4); 00381 fail_unless(res == ERR_OK); 00382 res = mdns_domain_add_label(&domain, NULL, 0); 00383 fail_unless(res == ERR_OK); 00384 fail_unless(domain.length == sizeof(data)); 00385 fail_if(memcmp(&domain.name, data, sizeof(data))); 00386 } 00387 END_TEST 00388 00389 START_TEST(add_label_long_label) 00390 { 00391 static const char *toolong = "abcdefghijklmnopqrstuvwxyz0123456789-abcdefghijklmnopqrstuvwxyz0123456789-abcdefghijklmnopqrstuvwxyz0123456789-"; 00392 struct mdns_domain domain; 00393 err_t res; 00394 LWIP_UNUSED_ARG(_i); 00395 00396 memset(&domain, 0, sizeof(domain)); 00397 res = mdns_domain_add_label(&domain, "multi", 5); 00398 fail_unless(res == ERR_OK); 00399 res = mdns_domain_add_label(&domain, toolong, (u8_t)strlen(toolong)); 00400 fail_unless(res == ERR_VAL); 00401 } 00402 END_TEST 00403 00404 START_TEST(add_label_full) 00405 { 00406 static const char *label = "0123456789abcdef0123456789abcdef"; 00407 struct mdns_domain domain; 00408 err_t res; 00409 LWIP_UNUSED_ARG(_i); 00410 00411 memset(&domain, 0, sizeof(domain)); 00412 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00413 fail_unless(res == ERR_OK); 00414 fail_unless(domain.length == 33); 00415 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00416 fail_unless(res == ERR_OK); 00417 fail_unless(domain.length == 66); 00418 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00419 fail_unless(res == ERR_OK); 00420 fail_unless(domain.length == 99); 00421 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00422 fail_unless(res == ERR_OK); 00423 fail_unless(domain.length == 132); 00424 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00425 fail_unless(res == ERR_OK); 00426 fail_unless(domain.length == 165); 00427 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00428 fail_unless(res == ERR_OK); 00429 fail_unless(domain.length == 198); 00430 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00431 fail_unless(res == ERR_OK); 00432 fail_unless(domain.length == 231); 00433 res = mdns_domain_add_label(&domain, label, (u8_t)strlen(label)); 00434 fail_unless(res == ERR_VAL); 00435 fail_unless(domain.length == 231); 00436 res = mdns_domain_add_label(&domain, label, 25); 00437 fail_unless(res == ERR_VAL); 00438 fail_unless(domain.length == 231); 00439 res = mdns_domain_add_label(&domain, label, 24); 00440 fail_unless(res == ERR_VAL); 00441 fail_unless(domain.length == 231); 00442 res = mdns_domain_add_label(&domain, label, 23); 00443 fail_unless(res == ERR_OK); 00444 fail_unless(domain.length == 255); 00445 res = mdns_domain_add_label(&domain, NULL, 0); 00446 fail_unless(res == ERR_OK); 00447 fail_unless(domain.length == 256); 00448 res = mdns_domain_add_label(&domain, NULL, 0); 00449 fail_unless(res == ERR_VAL); 00450 fail_unless(domain.length == 256); 00451 } 00452 END_TEST 00453 00454 START_TEST(domain_eq_basic) 00455 { 00456 static const u8_t data[] = { 00457 0x05, 'm', 'u', 'l', 't', 'i', 0x04, 'c', 'a', 's', 't', 0x00 00458 }; 00459 struct mdns_domain domain1, domain2; 00460 err_t res; 00461 LWIP_UNUSED_ARG(_i); 00462 00463 memset(&domain1, 0, sizeof(domain1)); 00464 res = mdns_domain_add_label(&domain1, "multi", 5); 00465 fail_unless(res == ERR_OK); 00466 res = mdns_domain_add_label(&domain1, "cast", 4); 00467 fail_unless(res == ERR_OK); 00468 res = mdns_domain_add_label(&domain1, NULL, 0); 00469 fail_unless(res == ERR_OK); 00470 fail_unless(domain1.length == sizeof(data)); 00471 00472 memset(&domain2, 0, sizeof(domain2)); 00473 res = mdns_domain_add_label(&domain2, "multi", 5); 00474 fail_unless(res == ERR_OK); 00475 res = mdns_domain_add_label(&domain2, "cast", 4); 00476 fail_unless(res == ERR_OK); 00477 res = mdns_domain_add_label(&domain2, NULL, 0); 00478 fail_unless(res == ERR_OK); 00479 00480 fail_unless(mdns_domain_eq(&domain1, &domain2)); 00481 } 00482 END_TEST 00483 00484 START_TEST(domain_eq_diff) 00485 { 00486 struct mdns_domain domain1, domain2; 00487 err_t res; 00488 LWIP_UNUSED_ARG(_i); 00489 00490 memset(&domain1, 0, sizeof(domain1)); 00491 res = mdns_domain_add_label(&domain1, "multi", 5); 00492 fail_unless(res == ERR_OK); 00493 res = mdns_domain_add_label(&domain1, "base", 4); 00494 fail_unless(res == ERR_OK); 00495 res = mdns_domain_add_label(&domain1, NULL, 0); 00496 fail_unless(res == ERR_OK); 00497 00498 memset(&domain2, 0, sizeof(domain2)); 00499 res = mdns_domain_add_label(&domain2, "multi", 5); 00500 fail_unless(res == ERR_OK); 00501 res = mdns_domain_add_label(&domain2, "cast", 4); 00502 fail_unless(res == ERR_OK); 00503 res = mdns_domain_add_label(&domain2, NULL, 0); 00504 fail_unless(res == ERR_OK); 00505 00506 fail_if(mdns_domain_eq(&domain1, &domain2)); 00507 } 00508 END_TEST 00509 00510 START_TEST(domain_eq_case) 00511 { 00512 struct mdns_domain domain1, domain2; 00513 err_t res; 00514 LWIP_UNUSED_ARG(_i); 00515 00516 memset(&domain1, 0, sizeof(domain1)); 00517 res = mdns_domain_add_label(&domain1, "multi", 5); 00518 fail_unless(res == ERR_OK); 00519 res = mdns_domain_add_label(&domain1, "cast", 4); 00520 fail_unless(res == ERR_OK); 00521 res = mdns_domain_add_label(&domain1, NULL, 0); 00522 fail_unless(res == ERR_OK); 00523 00524 memset(&domain2, 0, sizeof(domain2)); 00525 res = mdns_domain_add_label(&domain2, "MulTI", 5); 00526 fail_unless(res == ERR_OK); 00527 res = mdns_domain_add_label(&domain2, "casT", 4); 00528 fail_unless(res == ERR_OK); 00529 res = mdns_domain_add_label(&domain2, NULL, 0); 00530 fail_unless(res == ERR_OK); 00531 00532 fail_unless(mdns_domain_eq(&domain1, &domain2)); 00533 } 00534 END_TEST 00535 00536 START_TEST(domain_eq_anydata) 00537 { 00538 static const u8_t data1[] = { 0x05, 0xcc, 0xdc, 0x00, 0xa0 }; 00539 static const u8_t data2[] = { 0x7f, 0x8c, 0x01, 0xff, 0xcf }; 00540 struct mdns_domain domain1, domain2; 00541 err_t res; 00542 LWIP_UNUSED_ARG(_i); 00543 00544 memset(&domain1, 0, sizeof(domain1)); 00545 res = mdns_domain_add_label(&domain1, (const char*)data1, sizeof(data1)); 00546 fail_unless(res == ERR_OK); 00547 res = mdns_domain_add_label(&domain1, "cast", 4); 00548 fail_unless(res == ERR_OK); 00549 res = mdns_domain_add_label(&domain1, (const char*)data2, sizeof(data2)); 00550 fail_unless(res == ERR_OK); 00551 res = mdns_domain_add_label(&domain1, NULL, 0); 00552 fail_unless(res == ERR_OK); 00553 00554 memset(&domain2, 0, sizeof(domain2)); 00555 res = mdns_domain_add_label(&domain2, (const char*)data1, sizeof(data1)); 00556 fail_unless(res == ERR_OK); 00557 res = mdns_domain_add_label(&domain2, "casT", 4); 00558 fail_unless(res == ERR_OK); 00559 res = mdns_domain_add_label(&domain2, (const char*)data2, sizeof(data2)); 00560 fail_unless(res == ERR_OK); 00561 res = mdns_domain_add_label(&domain2, NULL, 0); 00562 fail_unless(res == ERR_OK); 00563 00564 fail_unless(mdns_domain_eq(&domain1, &domain2)); 00565 } 00566 END_TEST 00567 00568 START_TEST(domain_eq_length) 00569 { 00570 struct mdns_domain domain1, domain2; 00571 err_t res; 00572 LWIP_UNUSED_ARG(_i); 00573 00574 memset(&domain1, 0, sizeof(domain1)); 00575 memset(domain1.name, 0xAA, sizeof(MDNS_DOMAIN_MAXLEN)); 00576 res = mdns_domain_add_label(&domain1, "multi", 5); 00577 fail_unless(res == ERR_OK); 00578 res = mdns_domain_add_label(&domain1, "cast", 4); 00579 fail_unless(res == ERR_OK); 00580 00581 memset(&domain2, 0, sizeof(domain2)); 00582 memset(domain2.name, 0xBB, sizeof(MDNS_DOMAIN_MAXLEN)); 00583 res = mdns_domain_add_label(&domain2, "multi", 5); 00584 fail_unless(res == ERR_OK); 00585 res = mdns_domain_add_label(&domain2, "cast", 4); 00586 fail_unless(res == ERR_OK); 00587 00588 fail_unless(mdns_domain_eq(&domain1, &domain2)); 00589 } 00590 END_TEST 00591 00592 START_TEST(compress_full_match) 00593 { 00594 static const u8_t data[] = { 00595 0x00, 0x00, 00596 0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00 00597 }; 00598 struct pbuf *p; 00599 struct mdns_domain domain; 00600 u16_t offset; 00601 u16_t length; 00602 err_t res; 00603 LWIP_UNUSED_ARG(_i); 00604 00605 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00606 p->payload = (void *)(size_t)data; 00607 fail_if(p == NULL); 00608 00609 memset(&domain, 0, sizeof(domain)); 00610 res = mdns_domain_add_label(&domain, "foobar", 6); 00611 fail_unless(res == ERR_OK); 00612 res = mdns_domain_add_label(&domain, "local", 5); 00613 fail_unless(res == ERR_OK); 00614 res = mdns_domain_add_label(&domain, NULL, 0); 00615 fail_unless(res == ERR_OK); 00616 00617 offset = 2; 00618 length = mdns_compress_domain(p, &offset, &domain); 00619 /* Write 0 bytes, then a jump to addr 2 */ 00620 fail_unless(length == 0); 00621 fail_unless(offset == 2); 00622 00623 pbuf_free(p); 00624 } 00625 END_TEST 00626 00627 START_TEST(compress_full_match_subset) 00628 { 00629 static const u8_t data[] = { 00630 0x00, 0x00, 00631 0x02, 'g', 'o', 0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00 00632 }; 00633 struct pbuf *p; 00634 struct mdns_domain domain; 00635 u16_t offset; 00636 u16_t length; 00637 err_t res; 00638 LWIP_UNUSED_ARG(_i); 00639 00640 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00641 p->payload = (void *)(size_t)data; 00642 fail_if(p == NULL); 00643 00644 memset(&domain, 0, sizeof(domain)); 00645 res = mdns_domain_add_label(&domain, "foobar", 6); 00646 fail_unless(res == ERR_OK); 00647 res = mdns_domain_add_label(&domain, "local", 5); 00648 fail_unless(res == ERR_OK); 00649 res = mdns_domain_add_label(&domain, NULL, 0); 00650 fail_unless(res == ERR_OK); 00651 00652 offset = 2; 00653 length = mdns_compress_domain(p, &offset, &domain); 00654 /* Write 0 bytes, then a jump to addr 5 */ 00655 fail_unless(length == 0); 00656 fail_unless(offset == 5); 00657 00658 pbuf_free(p); 00659 } 00660 END_TEST 00661 00662 START_TEST(compress_full_match_jump) 00663 { 00664 static const u8_t data[] = { 00665 /* 0x00 */ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 00666 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 00667 /* 0x10 */ 0x04, 'l', 'w', 'i', 'p', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xc0, 0x00, 0x02, 0x00, 00668 /* 0x20 */ 0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0xc0, 0x15 00669 }; 00670 struct pbuf *p; 00671 struct mdns_domain domain; 00672 u16_t offset; 00673 u16_t length; 00674 err_t res; 00675 LWIP_UNUSED_ARG(_i); 00676 00677 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00678 p->payload = (void *)(size_t)data; 00679 fail_if(p == NULL); 00680 00681 memset(&domain, 0, sizeof(domain)); 00682 res = mdns_domain_add_label(&domain, "foobar", 6); 00683 fail_unless(res == ERR_OK); 00684 res = mdns_domain_add_label(&domain, "local", 5); 00685 fail_unless(res == ERR_OK); 00686 res = mdns_domain_add_label(&domain, NULL, 0); 00687 fail_unless(res == ERR_OK); 00688 00689 offset = 0x20; 00690 length = mdns_compress_domain(p, &offset, &domain); 00691 /* Write 0 bytes, then a jump to addr 0x20 */ 00692 fail_unless(length == 0); 00693 fail_unless(offset == 0x20); 00694 00695 pbuf_free(p); 00696 } 00697 END_TEST 00698 00699 START_TEST(compress_no_match) 00700 { 00701 static const u8_t data[] = { 00702 0x00, 0x00, 00703 0x04, 'l', 'w', 'i', 'p', 0x05, 'w', 'i', 'k', 'i', 'a', 0x03, 'c', 'o', 'm', 0x00 00704 }; 00705 struct pbuf *p; 00706 struct mdns_domain domain; 00707 u16_t offset; 00708 u16_t length; 00709 err_t res; 00710 LWIP_UNUSED_ARG(_i); 00711 00712 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00713 p->payload = (void *)(size_t)data; 00714 fail_if(p == NULL); 00715 00716 memset(&domain, 0, sizeof(domain)); 00717 res = mdns_domain_add_label(&domain, "foobar", 6); 00718 fail_unless(res == ERR_OK); 00719 res = mdns_domain_add_label(&domain, "local", 5); 00720 fail_unless(res == ERR_OK); 00721 res = mdns_domain_add_label(&domain, NULL, 0); 00722 fail_unless(res == ERR_OK); 00723 00724 offset = 2; 00725 length = mdns_compress_domain(p, &offset, &domain); 00726 /* Write all bytes, no jump */ 00727 fail_unless(length == domain.length); 00728 00729 pbuf_free(p); 00730 } 00731 END_TEST 00732 00733 START_TEST(compress_2nd_label) 00734 { 00735 static const u8_t data[] = { 00736 0x00, 0x00, 00737 0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00 00738 }; 00739 struct pbuf *p; 00740 struct mdns_domain domain; 00741 u16_t offset; 00742 u16_t length; 00743 err_t res; 00744 LWIP_UNUSED_ARG(_i); 00745 00746 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00747 p->payload = (void *)(size_t)data; 00748 fail_if(p == NULL); 00749 00750 memset(&domain, 0, sizeof(domain)); 00751 res = mdns_domain_add_label(&domain, "lwip", 4); 00752 fail_unless(res == ERR_OK); 00753 res = mdns_domain_add_label(&domain, "local", 5); 00754 fail_unless(res == ERR_OK); 00755 res = mdns_domain_add_label(&domain, NULL, 0); 00756 fail_unless(res == ERR_OK); 00757 00758 offset = 2; 00759 length = mdns_compress_domain(p, &offset, &domain); 00760 /* Write 5 bytes, then a jump to addr 9 */ 00761 fail_unless(length == 5); 00762 fail_unless(offset == 9); 00763 00764 pbuf_free(p); 00765 } 00766 END_TEST 00767 00768 START_TEST(compress_2nd_label_short) 00769 { 00770 static const u8_t data[] = { 00771 0x00, 0x00, 00772 0x04, 'l', 'w', 'i', 'p', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00 00773 }; 00774 struct pbuf *p; 00775 struct mdns_domain domain; 00776 u16_t offset; 00777 u16_t length; 00778 err_t res; 00779 LWIP_UNUSED_ARG(_i); 00780 00781 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00782 p->payload = (void *)(size_t)data; 00783 fail_if(p == NULL); 00784 00785 memset(&domain, 0, sizeof(domain)); 00786 res = mdns_domain_add_label(&domain, "foobar", 6); 00787 fail_unless(res == ERR_OK); 00788 res = mdns_domain_add_label(&domain, "local", 5); 00789 fail_unless(res == ERR_OK); 00790 res = mdns_domain_add_label(&domain, NULL, 0); 00791 fail_unless(res == ERR_OK); 00792 00793 offset = 2; 00794 length = mdns_compress_domain(p, &offset, &domain); 00795 /* Write 5 bytes, then a jump to addr 7 */ 00796 fail_unless(length == 7); 00797 fail_unless(offset == 7); 00798 00799 pbuf_free(p); 00800 } 00801 END_TEST 00802 00803 START_TEST(compress_jump_to_jump) 00804 { 00805 static const u8_t data[] = { 00806 /* 0x00 */ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 00807 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 00808 /* 0x10 */ 0x04, 'l', 'w', 'i', 'p', 0x05, 'l', 'o', 'c', 'a', 'l', 0x00, 0xc0, 0x00, 0x02, 0x00, 00809 /* 0x20 */ 0x07, 'b', 'a', 'n', 'a', 'n', 'a', 's', 0xc0, 0x15 00810 }; 00811 struct pbuf *p; 00812 struct mdns_domain domain; 00813 u16_t offset; 00814 u16_t length; 00815 err_t res; 00816 LWIP_UNUSED_ARG(_i); 00817 00818 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00819 p->payload = (void *)(size_t)data; 00820 fail_if(p == NULL); 00821 00822 memset(&domain, 0, sizeof(domain)); 00823 res = mdns_domain_add_label(&domain, "foobar", 6); 00824 fail_unless(res == ERR_OK); 00825 res = mdns_domain_add_label(&domain, "local", 5); 00826 fail_unless(res == ERR_OK); 00827 res = mdns_domain_add_label(&domain, NULL, 0); 00828 fail_unless(res == ERR_OK); 00829 00830 offset = 0x20; 00831 length = mdns_compress_domain(p, &offset, &domain); 00832 /* Dont compress if jump would be to a jump */ 00833 fail_unless(length == domain.length); 00834 00835 offset = 0x10; 00836 length = mdns_compress_domain(p, &offset, &domain); 00837 /* Write 7 bytes, then a jump to addr 0x15 */ 00838 fail_unless(length == 7); 00839 fail_unless(offset == 0x15); 00840 00841 pbuf_free(p); 00842 } 00843 END_TEST 00844 00845 START_TEST(compress_long_match) 00846 { 00847 static const u8_t data[] = { 00848 0x00, 0x00, 00849 0x06, 'f', 'o', 'o', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l', 0x03, 'c', 'o', 'm', 0x00 00850 }; 00851 struct pbuf *p; 00852 struct mdns_domain domain; 00853 u16_t offset; 00854 u16_t length; 00855 err_t res; 00856 LWIP_UNUSED_ARG(_i); 00857 00858 p = pbuf_alloc(PBUF_RAW, sizeof(data), PBUF_ROM); 00859 p->payload = (void *)(size_t)data; 00860 fail_if(p == NULL); 00861 00862 memset(&domain, 0, sizeof(domain)); 00863 res = mdns_domain_add_label(&domain, "foobar", 6); 00864 fail_unless(res == ERR_OK); 00865 res = mdns_domain_add_label(&domain, "local", 5); 00866 fail_unless(res == ERR_OK); 00867 res = mdns_domain_add_label(&domain, NULL, 0); 00868 fail_unless(res == ERR_OK); 00869 00870 offset = 2; 00871 length = mdns_compress_domain(p, &offset, &domain); 00872 fail_unless(length == domain.length); 00873 00874 pbuf_free(p); 00875 } 00876 END_TEST 00877 00878 Suite* mdns_suite(void) 00879 { 00880 testfunc tests[] = { 00881 TESTFUNC(readname_basic), 00882 TESTFUNC(readname_anydata), 00883 TESTFUNC(readname_short_buf), 00884 TESTFUNC(readname_long_label), 00885 TESTFUNC(readname_overflow), 00886 TESTFUNC(readname_jump_earlier), 00887 TESTFUNC(readname_jump_earlier_jump), 00888 TESTFUNC(readname_jump_maxdepth), 00889 TESTFUNC(readname_jump_later), 00890 TESTFUNC(readname_half_jump), 00891 TESTFUNC(readname_jump_toolong), 00892 TESTFUNC(readname_jump_loop_label), 00893 TESTFUNC(readname_jump_loop_jump), 00894 00895 TESTFUNC(add_label_basic), 00896 TESTFUNC(add_label_long_label), 00897 TESTFUNC(add_label_full), 00898 00899 TESTFUNC(domain_eq_basic), 00900 TESTFUNC(domain_eq_diff), 00901 TESTFUNC(domain_eq_case), 00902 TESTFUNC(domain_eq_anydata), 00903 TESTFUNC(domain_eq_length), 00904 00905 TESTFUNC(compress_full_match), 00906 TESTFUNC(compress_full_match_subset), 00907 TESTFUNC(compress_full_match_jump), 00908 TESTFUNC(compress_no_match), 00909 TESTFUNC(compress_2nd_label), 00910 TESTFUNC(compress_2nd_label_short), 00911 TESTFUNC(compress_jump_to_jump), 00912 TESTFUNC(compress_long_match), 00913 }; 00914 return create_suite("MDNS", tests, sizeof(tests)/sizeof(testfunc), NULL, NULL); 00915 }
Generated on Tue Jul 12 2022 12:22:24 by
1.7.2