tests/unit/unit1650.c - third_party/curl - Git at Google

 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
  *                             / __| | | | |_) | |
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
  * Copyright (C) 2018 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
  * are also available at https://curl.haxx.se/docs/copyright.html.
  *
  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  * copies of the Software, and permit persons to whom the Software is
  * furnished to do so, under the terms of the COPYING file.
  *
  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  * KIND, either express or implied.
  *
  ***************************************************************************/
 #include "curlcheck.h"

 #include "doh.h"

 static CURLcode unit_setup(void)
 {
   return CURLE_OK;
 }

 static void unit_stop(void)
 {

 }

 #ifndef CURL_DISABLE_DOH
 #define DNS_PREAMBLE "\x00\x00\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00"
 #define LABEL_TEST "\x04\x74\x65\x73\x74"
 #define LABEL_HOST "\x04\x68\x6f\x73\x74"
 #define LABEL_NAME "\x04\x6e\x61\x6d\x65"
 #define DNSA_TYPE "\x01"
 #define DNSAAAA_TYPE "\x1c"
 #define DNSA_EPILOGUE "\x00\x00" DNSA_TYPE "\x00\x01"
 #define DNSAAAA_EPILOGUE "\x00\x00" DNSAAAA_TYPE "\x00\x01"

 #define DNS_Q1 DNS_PREAMBLE LABEL_TEST LABEL_HOST LABEL_NAME DNSA_EPILOGUE
 #define DNS_Q2 DNS_PREAMBLE LABEL_TEST LABEL_HOST LABEL_NAME DNSAAAA_EPILOGUE

 struct dohrequest {
   /* input */
   const char *name;
   DNStype type;

   /* output */
   const char *packet;
   size_t size;
   int rc;
 };


 static struct dohrequest req[] = {
   {"test.host.name", DNS_TYPE_A, DNS_Q1, sizeof(DNS_Q1)-1, 0 },
   {"test.host.name", DNS_TYPE_AAAA, DNS_Q2, sizeof(DNS_Q2)-1, 0 },
   {"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
    ".host.name",
    DNS_TYPE_AAAA, NULL, 0, DOH_DNS_BAD_LABEL }
 };

 struct dohresp {
   /* input */
   const char *packet;
   size_t size;
   DNStype type;

   /* output */
   int rc;
   const char *out;
 };

 #define DNS_FOO_EXAMPLE_COM                                          \
   "\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f" \
   "\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x01\x00" \
   "\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x00\x37\x00\x04\x7f\x00\x00" \
   "\x01"

 static const char full49[] = DNS_FOO_EXAMPLE_COM;

 static struct dohresp resp[] = {
   {"\x00\x00", 2, DNS_TYPE_A, DOH_TOO_SMALL_BUFFER, NULL },
   {"\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01", 12,
    DNS_TYPE_A, DOH_DNS_BAD_ID, NULL },
   {"\x00\x00\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01", 12,
    DNS_TYPE_A, DOH_DNS_BAD_RCODE, NULL },
   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f", 16,
    DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },
   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f\x00", 17,
    DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },
   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f\x00"
    "\x00\x01\x00\x01", 21,
    DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },
   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f\x00"
    "\x00\x01\x00\x01"
    "\x04", 18,
    DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },

   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x04\x63\x75\x72"
    "\x6c\x04\x63\x75\x72\x6c\x00\x00\x05\x00\x01\xc0\x0c\x00\x05\x00"
    "\x01\x00\x00\x00\x37\x00\x11\x08\x61\x6e\x79\x77\x68\x65\x72\x65"
    "\x06\x72\x65\x61\x6c\x6c\x79\x00", 56,
    DNS_TYPE_A, DOH_OK, "anywhere.really "},

   {DNS_FOO_EXAMPLE_COM, 49, DNS_TYPE_A, DOH_OK, "127.0.0.1 "},

   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x04\x61\x61\x61"
    "\x61\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x1c"
    "\x00\x01\xc0\x0c\x00\x1c\x00\x01\x00\x00\x00\x37\x00\x10\x20\x20"
    "\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x20", 62,
    DNS_TYPE_AAAA, DOH_OK,
    "2020:2020:0000:0000:0000:0000:0000:2020 " },

   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x04\x63\x75\x72"
    "\x6c\x04\x63\x75\x72\x6c\x00\x00\x05\x00\x01\xc0\x0c\x00\x05\x00"
    "\x01\x00\x00\x00\x37\x00"
    "\x07\x03\x61\x6e\x79\xc0\x27\x00", 46,
    DNS_TYPE_A, DOH_DNS_LABEL_LOOP, NULL},

   /* packet with NSCOUNT == 1 */
   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x01\x00\x00\x04\x61\x61\x61"
    "\x61\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x1c"
    "\x00\x01\xc0\x0c\x00\x1c\x00\x01\x00\x00\x00\x37\x00\x10\x20\x20"
    "\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x20"
    LABEL_TEST LABEL_HOST LABEL_NAME DNSAAAA_EPILOGUE "\x00\x00\x00\x01"
    "\00\x04\x01\x01\x01\x01", /* RDDATA */

    62 + 30,
    DNS_TYPE_AAAA, DOH_OK,
    "2020:2020:0000:0000:0000:0000:0000:2020 " },

   /* packet with ARCOUNT == 1 */
   {"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x01\x04\x61\x61\x61"
    "\x61\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x1c"
    "\x00\x01\xc0\x0c\x00\x1c\x00\x01\x00\x00\x00\x37\x00\x10\x20\x20"
    "\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x20"
    LABEL_TEST LABEL_HOST LABEL_NAME DNSAAAA_EPILOGUE "\x00\x00\x00\x01"
    "\00\x04\x01\x01\x01\x01", /* RDDATA */

    62 + 30,
    DNS_TYPE_AAAA, DOH_OK,
    "2020:2020:0000:0000:0000:0000:0000:2020 " },

 };

 UNITTEST_START
 {
   size_t size = 0;
   unsigned char buffer[256];
   size_t i;
   unsigned char *p;
   for(i = 0; i < sizeof(req) / sizeof(req[0]); i++) {
     int rc = doh_encode(req[i].name, req[i].type,
                         buffer, sizeof(buffer), &size);
     if(rc != req[i].rc) {
       fprintf(stderr, "req %zu: Expected return code %d got %d\n", i,
               req[i].rc, rc);
       return 1;
     }
     else if(size != req[i].size) {
       fprintf(stderr, "req %zu: Expected size %zu got %zu\n", i,
               req[i].size, size);
       fprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
       return 2;
     }
     else if(req[i].packet && memcmp(req[i].packet, buffer, size)) {
       fprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
       fprintf(stderr, "... instead of: %s\n",
              hexdump((unsigned char *)req[i].packet, size));
       return 3;
     }
   }

   for(i = 0; i < sizeof(resp) / sizeof(resp[0]); i++) {
     struct dohentry d;
     int rc;
     char *ptr;
     size_t len;
     int u;
     memset(&d, 0, sizeof(d));
     rc = doh_decode((unsigned char *)resp[i].packet, resp[i].size,
                     resp[i].type, &d);
     if(rc != resp[i].rc) {
       fprintf(stderr, "resp %zu: Expected return code %d got %d\n", i,
               resp[i].rc, rc);
       return 4;
     }
     len = sizeof(buffer);
     ptr = (char *)buffer;
     for(u = 0; u < d.numaddr; u++) {
       size_t o;
       struct dohaddr *a;
       a = &d.addr[u];
       if(resp[i].type == DNS_TYPE_A) {
         p = &a->ip.v4[0];
         msnprintf(ptr, len, "%u.%u.%u.%u ", p[0], p[1], p[2], p[3]);
         o = strlen(ptr);
         len -= o;
         ptr += o;
       }
       else {
         int j;
         for(j = 0; j < 16; j += 2) {
           size_t l;
           msnprintf(ptr, len, "%s%02x%02x", j?":":"", a->ip.v6[j],
                    a->ip.v6[j + 1]);
           l = strlen(ptr);
           len -= l;
           ptr += l;
         }
         msnprintf(ptr, len, " ");
         len--;
         ptr++;
       }
     }
     for(u = 0; u < d.numcname; u++) {
       size_t o;
       msnprintf(ptr, len, "%s ", d.cname[u].alloc);
       o = strlen(ptr);
       len -= o;
       ptr += o;
     }
     de_cleanup(&d);
     if(resp[i].out && strcmp((char *)buffer, resp[i].out)) {
       fprintf(stderr, "resp %zu: Expected %s got %s\n", i,
               resp[i].out, buffer);
       return 1;
     }
   }

   {
     /* pass all sizes into the decoder until full */
     for(i = 0; i < sizeof(full49)-1; i++) {
       struct dohentry d;
       int rc;
       memset(&d, 0, sizeof(d));
       rc = doh_decode((unsigned char *)full49, i, DNS_TYPE_A, &d);
       if(!rc) {
         /* none of them should work */
         fprintf(stderr, "%zu: %d\n", i, rc);
         return 5;
       }
     }
     /* and try all pieces from the other end of the packet */
     for(i = 1; i < sizeof(full49); i++) {
       struct dohentry d;
       int rc;
       memset(&d, 0, sizeof(d));
       rc = doh_decode((unsigned char *)&full49[i], sizeof(full49)-i-1,
                       DNS_TYPE_A, &d);
       if(!rc) {
         /* none of them should work */
         fprintf(stderr, "2 %zu: %d\n", i, rc);
         return 7;
       }
     }
     {
       int rc;
       struct dohentry d;
       struct dohaddr *a;
       memset(&d, 0, sizeof(d));
       rc = doh_decode((unsigned char *)full49, sizeof(full49)-1,
                       DNS_TYPE_A, &d);
       fail_if(d.numaddr != 1, "missing address");
       a = &d.addr[0];
       p = &a->ip.v4[0];
       msnprintf((char *)buffer, sizeof(buffer),
                 "%u.%u.%u.%u", p[0], p[1], p[2], p[3]);
       if(rc || strcmp((char *)buffer, "127.0.0.1")) {
         fprintf(stderr, "bad address decoded: %s, rc == %d\n", buffer, rc);
         return 7;
       }
       fail_if(d.numcname, "bad cname counter");
     }
   }
 }
 UNITTEST_STOP

 #else /* CURL_DISABLE_DOH */
 UNITTEST_START
 {
   return 1; /* nothing to do, just fail */
 }
 UNITTEST_STOP


 #endif
	/***************************************************************************
	* _ _ ____ _
	* Project ___\| \| \| \| _ \\| \|
	* / __\| \| \| \| \|_) \| \|
	* \| (__\| \|_\| \| _ <\| \|___
	* \___\|\___/\|_\| \_\_____\|
	*
	* Copyright (C) 2018 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
	*
	* This software is licensed as described in the file COPYING, which
	* you should have received as part of this distribution. The terms
	* are also available at https://curl.haxx.se/docs/copyright.html.
	*
	* You may opt to use, copy, modify, merge, publish, distribute and/or sell
	* copies of the Software, and permit persons to whom the Software is
	* furnished to do so, under the terms of the COPYING file.
	*
	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
	* KIND, either express or implied.
	*
	***************************************************************************/
	#include "curlcheck.h"

	#include "doh.h"

	static CURLcode unit_setup(void)
	{
	return CURLE_OK;
	}

	static void unit_stop(void)
	{

	}

	#ifndef CURL_DISABLE_DOH
	#define DNS_PREAMBLE "\x00\x00\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00"
	#define LABEL_TEST "\x04\x74\x65\x73\x74"
	#define LABEL_HOST "\x04\x68\x6f\x73\x74"
	#define LABEL_NAME "\x04\x6e\x61\x6d\x65"
	#define DNSA_TYPE "\x01"
	#define DNSAAAA_TYPE "\x1c"
	#define DNSA_EPILOGUE "\x00\x00" DNSA_TYPE "\x00\x01"
	#define DNSAAAA_EPILOGUE "\x00\x00" DNSAAAA_TYPE "\x00\x01"

	#define DNS_Q1 DNS_PREAMBLE LABEL_TEST LABEL_HOST LABEL_NAME DNSA_EPILOGUE
	#define DNS_Q2 DNS_PREAMBLE LABEL_TEST LABEL_HOST LABEL_NAME DNSAAAA_EPILOGUE

	struct dohrequest {
	/* input */
	const char *name;
	DNStype type;

	/* output */
	const char *packet;
	size_t size;
	int rc;
	};


	static struct dohrequest req[] = {
	{"test.host.name", DNS_TYPE_A, DNS_Q1, sizeof(DNS_Q1)-1, 0 },
	{"test.host.name", DNS_TYPE_AAAA, DNS_Q2, sizeof(DNS_Q2)-1, 0 },
	{"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
	".host.name",
	DNS_TYPE_AAAA, NULL, 0, DOH_DNS_BAD_LABEL }
	};

	struct dohresp {
	/* input */
	const char *packet;
	size_t size;
	DNStype type;

	/* output */
	int rc;
	const char *out;
	};

	#define DNS_FOO_EXAMPLE_COM \
	"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f" \
	"\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x01\x00" \
	"\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x00\x37\x00\x04\x7f\x00\x00" \
	"\x01"

	static const char full49[] = DNS_FOO_EXAMPLE_COM;

	static struct dohresp resp[] = {
	{"\x00\x00", 2, DNS_TYPE_A, DOH_TOO_SMALL_BUFFER, NULL },
	{"\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01", 12,
	DNS_TYPE_A, DOH_DNS_BAD_ID, NULL },
	{"\x00\x00\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01", 12,
	DNS_TYPE_A, DOH_DNS_BAD_RCODE, NULL },
	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f", 16,
	DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },
	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f\x00", 17,
	DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },
	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f\x00"
	"\x00\x01\x00\x01", 21,
	DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },
	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x03\x66\x6f\x6f\x00"
	"\x00\x01\x00\x01"
	"\x04", 18,
	DNS_TYPE_A, DOH_DNS_OUT_OF_RANGE, NULL },

	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x04\x63\x75\x72"
	"\x6c\x04\x63\x75\x72\x6c\x00\x00\x05\x00\x01\xc0\x0c\x00\x05\x00"
	"\x01\x00\x00\x00\x37\x00\x11\x08\x61\x6e\x79\x77\x68\x65\x72\x65"
	"\x06\x72\x65\x61\x6c\x6c\x79\x00", 56,
	DNS_TYPE_A, DOH_OK, "anywhere.really "},

	{DNS_FOO_EXAMPLE_COM, 49, DNS_TYPE_A, DOH_OK, "127.0.0.1 "},

	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x04\x61\x61\x61"
	"\x61\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x1c"
	"\x00\x01\xc0\x0c\x00\x1c\x00\x01\x00\x00\x00\x37\x00\x10\x20\x20"
	"\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x20", 62,
	DNS_TYPE_AAAA, DOH_OK,
	"2020:2020:0000:0000:0000:0000:0000:2020 " },

	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x00\x04\x63\x75\x72"
	"\x6c\x04\x63\x75\x72\x6c\x00\x00\x05\x00\x01\xc0\x0c\x00\x05\x00"
	"\x01\x00\x00\x00\x37\x00"
	"\x07\x03\x61\x6e\x79\xc0\x27\x00", 46,
	DNS_TYPE_A, DOH_DNS_LABEL_LOOP, NULL},

	/* packet with NSCOUNT == 1 */
	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x01\x00\x00\x04\x61\x61\x61"
	"\x61\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x1c"
	"\x00\x01\xc0\x0c\x00\x1c\x00\x01\x00\x00\x00\x37\x00\x10\x20\x20"
	"\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x20"
	LABEL_TEST LABEL_HOST LABEL_NAME DNSAAAA_EPILOGUE "\x00\x00\x00\x01"
	"\00\x04\x01\x01\x01\x01", /* RDDATA */

	62 + 30,
	DNS_TYPE_AAAA, DOH_OK,
	"2020:2020:0000:0000:0000:0000:0000:2020 " },

	/* packet with ARCOUNT == 1 */
	{"\x00\x00\x01\x00\x00\x01\x00\x01\x00\x00\x00\x01\x04\x61\x61\x61"
	"\x61\x07\x65\x78\x61\x6d\x70\x6c\x65\x03\x63\x6f\x6d\x00\x00\x1c"
	"\x00\x01\xc0\x0c\x00\x1c\x00\x01\x00\x00\x00\x37\x00\x10\x20\x20"
	"\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x20"
	LABEL_TEST LABEL_HOST LABEL_NAME DNSAAAA_EPILOGUE "\x00\x00\x00\x01"
	"\00\x04\x01\x01\x01\x01", /* RDDATA */

	62 + 30,
	DNS_TYPE_AAAA, DOH_OK,
	"2020:2020:0000:0000:0000:0000:0000:2020 " },

	};

	UNITTEST_START
	{
	size_t size = 0;
	unsigned char buffer[256];
	size_t i;
	unsigned char *p;
	for(i = 0; i < sizeof(req) / sizeof(req[0]); i++) {
	int rc = doh_encode(req[i].name, req[i].type,
	buffer, sizeof(buffer), &size);
	if(rc != req[i].rc) {
	fprintf(stderr, "req %zu: Expected return code %d got %d\n", i,
	req[i].rc, rc);
	return 1;
	}
	else if(size != req[i].size) {
	fprintf(stderr, "req %zu: Expected size %zu got %zu\n", i,
	req[i].size, size);
	fprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
	return 2;
	}
	else if(req[i].packet && memcmp(req[i].packet, buffer, size)) {
	fprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
	fprintf(stderr, "... instead of: %s\n",
	hexdump((unsigned char *)req[i].packet, size));
	return 3;
	}
	}

	for(i = 0; i < sizeof(resp) / sizeof(resp[0]); i++) {
	struct dohentry d;
	int rc;
	char *ptr;
	size_t len;
	int u;
	memset(&d, 0, sizeof(d));
	rc = doh_decode((unsigned char *)resp[i].packet, resp[i].size,
	resp[i].type, &d);
	if(rc != resp[i].rc) {
	fprintf(stderr, "resp %zu: Expected return code %d got %d\n", i,
	resp[i].rc, rc);
	return 4;
	}
	len = sizeof(buffer);
	ptr = (char *)buffer;
	for(u = 0; u < d.numaddr; u++) {
	size_t o;
	struct dohaddr *a;
	a = &d.addr[u];
	if(resp[i].type == DNS_TYPE_A) {
	p = &a->ip.v4[0];
	msnprintf(ptr, len, "%u.%u.%u.%u ", p[0], p[1], p[2], p[3]);
	o = strlen(ptr);
	len -= o;
	ptr += o;
	}
	else {
	int j;
	for(j = 0; j < 16; j += 2) {
	size_t l;
	msnprintf(ptr, len, "%s%02x%02x", j?":":"", a->ip.v6[j],
	a->ip.v6[j + 1]);
	l = strlen(ptr);
	len -= l;
	ptr += l;
	}
	msnprintf(ptr, len, " ");
	len--;
	ptr++;
	}
	}
	for(u = 0; u < d.numcname; u++) {
	size_t o;
	msnprintf(ptr, len, "%s ", d.cname[u].alloc);
	o = strlen(ptr);
	len -= o;
	ptr += o;
	}
	de_cleanup(&d);
	if(resp[i].out && strcmp((char *)buffer, resp[i].out)) {
	fprintf(stderr, "resp %zu: Expected %s got %s\n", i,
	resp[i].out, buffer);
	return 1;
	}
	}

	{
	/* pass all sizes into the decoder until full */
	for(i = 0; i < sizeof(full49)-1; i++) {
	struct dohentry d;
	int rc;
	memset(&d, 0, sizeof(d));
	rc = doh_decode((unsigned char *)full49, i, DNS_TYPE_A, &d);
	if(!rc) {
	/* none of them should work */
	fprintf(stderr, "%zu: %d\n", i, rc);
	return 5;
	}
	}
	/* and try all pieces from the other end of the packet */
	for(i = 1; i < sizeof(full49); i++) {
	struct dohentry d;
	int rc;
	memset(&d, 0, sizeof(d));
	rc = doh_decode((unsigned char *)&full49[i], sizeof(full49)-i-1,
	DNS_TYPE_A, &d);
	if(!rc) {
	/* none of them should work */
	fprintf(stderr, "2 %zu: %d\n", i, rc);
	return 7;
	}
	}
	{
	int rc;
	struct dohentry d;
	struct dohaddr *a;
	memset(&d, 0, sizeof(d));
	rc = doh_decode((unsigned char *)full49, sizeof(full49)-1,
	DNS_TYPE_A, &d);
	fail_if(d.numaddr != 1, "missing address");
	a = &d.addr[0];
	p = &a->ip.v4[0];
	msnprintf((char *)buffer, sizeof(buffer),
	"%u.%u.%u.%u", p[0], p[1], p[2], p[3]);
	if(rc \|\| strcmp((char *)buffer, "127.0.0.1")) {
	fprintf(stderr, "bad address decoded: %s, rc == %d\n", buffer, rc);
	return 7;
	}
	fail_if(d.numcname, "bad cname counter");
	}
	}
	}
	UNITTEST_STOP

	#else /* CURL_DISABLE_DOH */
	UNITTEST_START
	{
	return 1; /* nothing to do, just fail */
	}
	UNITTEST_STOP


	#endif