Ejemplo n.º 1
0
getdns_return_t getdns_pubkey_pinset_sanity_check(
	const getdns_list* pinset,
	getdns_list* errorlist)
{
	size_t errorcount = 0, preverrs = 0, pins = 0, i;
	getdns_bindata err;
	getdns_dict * pin;
	getdns_bindata * data;

	if (errorlist)
		if (getdns_list_get_length(errorlist, &preverrs))
			return GETDNS_RETURN_INVALID_PARAMETER;
	
	if (getdns_list_get_length(pinset, &pins))
		PKP_SC_HARDERR("Can't get length of pinset",
			       GETDNS_RETURN_INVALID_PARAMETER);
	if (pins < 2)
		PKP_SC_ERR("This pinset has fewer than 2 pins");
	for (i = 0; i < pins; i++)
	{
		/* is it a dict? */
		if (getdns_list_get_dict(pinset, i, &pin)) {
			PKP_SC_ERR("Could not retrieve a pin");
		} else {
		/* does the pin have the right digest type? */
			if (getdns_dict_get_bindata(pin, "digest", &data)) {
				PKP_SC_ERR("Pin has no 'digest' entry");
			} else {
				if (data->size != sha256.size ||
				    memcmp(data->data, sha256.data, sha256.size))
					PKP_SC_ERR("Pin has 'digest' other than sha256");
			}
			/* if it does, is the value the right length? */
			if (getdns_dict_get_bindata(pin, "value", &data)) {
				PKP_SC_ERR("Pin has no 'value' entry");
			} else {
				if (data->size != SHA256_DIGEST_LENGTH)
					PKP_SC_ERR("Pin has the wrong size 'value' (should be 32 octets for sha256)");
			}
			
		/* should we choke if it has some other key? for
		 * extensibility, we will not treat this as an
		 * error.*/
		}
	}
	
	if (errorcount > 0)
		return GETDNS_RETURN_GENERIC_ERROR;
	return GETDNS_RETURN_GOOD;
}
Ejemplo n.º 2
0
getdns_list* GNUtil::convertToList(Local<Array> array) {
    uint32_t len = array->Length();
    getdns_list* result = getdns_list_create();
    for (uint32_t i = 0; i < len; ++i) {
        size_t idx = getdns_list_get_length(result, &idx);
        Local<Value> val = array->Get(i);
        GetdnsType type = getGetdnsType(val);
        switch (type) {
            case IntType:
                getdns_list_set_int(result, idx, val->ToUint32()->Value());
                break;
            case BoolType:
                if (val->IsTrue()) {
                    getdns_list_set_int(result, idx, GETDNS_EXTENSION_TRUE);
                } else {
                    getdns_list_set_int(result, idx, GETDNS_EXTENSION_FALSE);
                }
                break;
            case StringType:
                {
                    struct getdns_bindata strdata;
                    String::Utf8Value utf8Str(val->ToString());
                    int len = utf8Str.length();
                    strdata.data = (uint8_t*) *utf8Str;
                    strdata.size = len;
                    getdns_list_set_bindata(result, idx, &strdata);
                }
                break;
            case BinDataType:
                {
                    struct getdns_bindata bdata;
                    bdata.data = (uint8_t*) node::Buffer::Data(val);
                    bdata.size = node::Buffer::Length(val);
                    getdns_list_set_bindata(result, idx, &bdata);
                }
                break;
            case ListType:
                {
                    Local<Array> subArray = Local<Array>::Cast(val);
                    struct getdns_list* sublist = GNUtil::convertToList(subArray);
                    getdns_list_set_list(result, idx, sublist);
                    getdns_list_destroy(sublist);
                }
                break;
            case DictType:
                {
                    Local<Object> subObj = val->ToObject();
                    struct getdns_dict* subdict = GNUtil::convertToDict(subObj);
                    if (subdict) {
                        getdns_list_set_dict(result, idx, subdict);
                        getdns_dict_destroy(subdict);
                    }
                }
                break;
            default:
                break;
        }
    }
    return result;
}
Ejemplo n.º 3
0
Local<Value> GNUtil::convertToJSObj(struct getdns_dict* dict) {
    if (!dict) {
        return Nan::Null();
    }

    // try it as an IP
    char* ipStr = getdns_dict_to_ip_string(dict);
    if (ipStr) {
        Local<Value> result = Nan::New<String>(ipStr).ToLocalChecked();
        free(ipStr);
        return result;
    }

    getdns_list* names;
    getdns_dict_get_names(dict, &names);
    size_t len = 0;
    Local<Object> result = Nan::New<Object>();
    getdns_list_get_length(names, &len);
    for (size_t i = 0; i < len; ++i) {
        getdns_bindata* nameBin;
        getdns_list_get_bindata(names, i, &nameBin);
        Local<Value> name = Nan::New<String>((char*) nameBin->data).ToLocalChecked();
        getdns_data_type type;
        getdns_dict_get_data_type(dict, (char*)nameBin->data, &type);
        switch (type) {
            case t_bindata:
            {
                getdns_bindata* data = NULL;
                getdns_dict_get_bindata(dict, (char*)nameBin->data, &data);
                result->Set(name, convertBinData(data, (char*) nameBin->data));
                break;
            }
            case t_int:
            {
                uint32_t res = 0;
                getdns_dict_get_int(dict, (char*)nameBin->data, &res);
                result->Set(name, Nan::New<Integer>(res));
                break;
            }
            case t_dict:
            {
                getdns_dict* subdict = NULL;
                getdns_dict_get_dict(dict, (char*)nameBin->data, &subdict);
                result->Set(name, GNUtil::convertToJSObj(subdict));
                break;
            }
            case t_list:
            {
                getdns_list* list = NULL;
                getdns_dict_get_list(dict, (char*)nameBin->data, &list);
                result->Set(name, GNUtil::convertToJSArray(list));
                break;
            }
            default:
                break;
        }
    }
    getdns_list_destroy(names);
    return result;
}
Ejemplo n.º 4
0
/*
 *  assert_ptr_in_answer asserts that a PTR record was
 *  returned in the answer sections.
 */
void assert_ptr_in_answer(struct extracted_response *ex_response)
{
  uint32_t ancount;
  size_t length;
  struct getdns_dict *rr_dict;
  uint32_t type;
  uint32_t ptr_records = 0;
  size_t i;

  ASSERT_RC(getdns_dict_get_int(ex_response->header, "ancount", &ancount),
    GETDNS_RETURN_GOOD, "Failed to extract \"nscount\"");
  ck_assert_msg(ancount >= 1, "Expected ancount >= 1, got %d", ancount);

  ASSERT_RC(getdns_list_get_length(ex_response->answer, &length),
    GETDNS_RETURN_GOOD, "Failed to extract \"answer\" length");
  ck_assert_msg(length == ancount, "Expected \"answer\" length == ancount: %d, got %d", ancount, length);

  for(i = 0; i < length; i++)
  {
    ASSERT_RC(getdns_list_get_dict(ex_response->answer, i, &rr_dict),
      GETDNS_RETURN_GOOD, "Failed to extract \"answer\" record");
    ASSERT_RC(getdns_dict_get_int(rr_dict, "type", &type),
      GETDNS_RETURN_GOOD, "Failed to extract \"type\" from answer record");
    if(type == GETDNS_RRTYPE_PTR)
      ptr_records++;
  }

  ck_assert_msg(ptr_records == 1, "Expected to find one PTR record in answer section, got %d", ptr_records);
}
Ejemplo n.º 5
0
/*
 *  assert_soa_in_authority asserts that a SOA record was
 *  returned in the authority sections.
 */
void assert_soa_in_authority(struct extracted_response *ex_response)
{
  uint32_t nscount;
  size_t length;
  struct getdns_dict *rr_dict;
  uint32_t type;
  uint32_t soa_records = 0;
  size_t i;

  ASSERT_RC(getdns_dict_get_int(ex_response->header, "nscount", &nscount),
    GETDNS_RETURN_GOOD, "Failed to extract \"nscount\"");
  ck_assert_msg(nscount >= 1, "Expected nscount >= 1, got %d", nscount);

  ASSERT_RC(getdns_list_get_length(ex_response->authority, &length),
    GETDNS_RETURN_GOOD, "Failed to extract \"authority\" length");
  ck_assert_msg(length == nscount, "Expected \"authority\" length == nscount: %d, got %d", nscount, length);

  for(i = 0; i < length; i++)
  {
    ASSERT_RC(getdns_list_get_dict(ex_response->authority, i, &rr_dict),
      GETDNS_RETURN_GOOD, "Failed to extract \"authority\" record");
    ASSERT_RC(getdns_dict_get_int(rr_dict, "type", &type),
      GETDNS_RETURN_GOOD, "Failed to extract \"type\" from authority record");
    if(type == GETDNS_RRTYPE_SOA)
      soa_records++;
  }

  ck_assert_msg(soa_records == 1, "Expected to find one SOA record in authority section, got %d", soa_records);
}
Ejemplo n.º 6
0
getdns_return_t
_getdns_get_pubkey_pinset_from_list(const getdns_list *pinset_list,
				    struct mem_funcs *mf,
				    sha256_pin_t **pinset_out)
{
	getdns_return_t r;
	size_t pins, i;
	sha256_pin_t *out = NULL, *onext = NULL;
	getdns_dict * pin;
	getdns_bindata * data = NULL;
	
	if (r = getdns_list_get_length(pinset_list, &pins), r)
		return r;
	for (i = 0; i < pins; i++)
	{
		if (r = getdns_list_get_dict(pinset_list, i, &pin), r)
			goto fail;
		/* does the pin have the right digest type? */
		if (r = getdns_dict_get_bindata(pin, "digest", &data), r)
			goto fail;
		if (data->size != sha256.size ||
		    memcmp(data->data, sha256.data, sha256.size)) {
			r = GETDNS_RETURN_INVALID_PARAMETER;
			goto fail;
		}
		/* if it does, is the value the right length? */
		if (r = getdns_dict_get_bindata(pin, "value", &data), r)
			goto fail;
		if (data->size != SHA256_DIGEST_LENGTH) {
			r = GETDNS_RETURN_INVALID_PARAMETER;
			goto fail;
		}
		/* make a new pin */
		onext = GETDNS_MALLOC(*mf, sha256_pin_t);
		if (onext == NULL) {
			r = GETDNS_RETURN_MEMORY_ERROR;
			goto fail;
		}
		onext->next = out;
		memcpy(onext->pin, data->data, SHA256_DIGEST_LENGTH);
		out = onext;
	}
	
	*pinset_out = out;
	return GETDNS_RETURN_GOOD;
 fail:
	while (out) {
		onext = out->next;
		GETDNS_FREE(*mf, out);
		out = onext;
	}
	return r;
}
Ejemplo n.º 7
0
/*
 *  assert_nodata asserts that ancount in the header and the
 *  of the answer section (list) are both zero.
 */
void assert_nodata(struct extracted_response *ex_response)
{
  uint32_t ancount;
  size_t length;

  ASSERT_RC(getdns_dict_get_int(ex_response->header, "ancount", &ancount),
    GETDNS_RETURN_GOOD, "Failed to extract \"ancount\"");
  ck_assert_msg(ancount == 0, "Expected ancount == 0, got %d", ancount);

  ASSERT_RC(getdns_list_get_length(ex_response->answer, &length),
    GETDNS_RETURN_GOOD, "Failed to extract \"answer\" length");
  ck_assert_msg(length == 0, "Expected \"answer\" length == 0, got %d", length);
}
Ejemplo n.º 8
0
Local<Value> GNUtil::convertToJSArray(struct getdns_list* list) {
    if (!list) {
        return Nan::Null();
    }
    size_t len;
    getdns_list_get_length(list, &len);
    Local<Array> array = Nan::New<Array>();
    for (size_t i = 0; i < len; ++i) {
        getdns_data_type type;
        getdns_list_get_data_type(list, i, &type);
        switch (type) {
            case t_bindata:
            {
                getdns_bindata* data = NULL;
                getdns_list_get_bindata(list, i, &data);
                array->Set(i, convertBinData(data, NULL));
                break;
            }
            case t_int:
            {
                uint32_t res = 0;
                getdns_list_get_int(list, i, &res);
                array->Set(i, Nan::New<Integer>(res));
                break;
            }
            case t_dict:
            {
                getdns_dict* dict = NULL;
                getdns_list_get_dict(list, i, &dict);
                array->Set(i, GNUtil::convertToJSObj(dict));
                break;
            }
            case t_list:
            {
                getdns_list* sublist = NULL;
                getdns_list_get_list(list, i, &sublist);
                array->Set(i, GNUtil::convertToJSArray(sublist));
                break;
            }
            default:
                break;
        }
    }
    return array;
}
Ejemplo n.º 9
0
/*
 *  assert_address_records_in_answer asserts that ancount in the header
 *  is >= 1, ancount is equal to the length of "answer", and that all of
 *  the records in the answer section are A and/or AAAA resource records
 *  based on the value of the a/aaaa arguments.
 */
void assert_address_in_answer(struct extracted_response *ex_response, int a, int aaaa)
{
  uint32_t ancount;
  size_t length;
  struct getdns_dict *rr_dict;
  uint32_t type;
  uint32_t address_records = 0;
  size_t i;

  ASSERT_RC(getdns_dict_get_int(ex_response->header, "ancount", &ancount),
    GETDNS_RETURN_GOOD, "Failed to extract \"ancount\"");
  ck_assert_msg(ancount >= 1, "Expected ancount >= 1, got %d", ancount);

  ASSERT_RC(getdns_list_get_length(ex_response->answer, &length),
    GETDNS_RETURN_GOOD, "Failed to extract \"answer\" length");
  ck_assert_msg(length == ancount, "Expected \"answer\" length == ancount: %d, got %d", ancount, length);

  for(i = 0; i < length; i++)
  {
    ASSERT_RC(getdns_list_get_dict(ex_response->answer, i, &rr_dict),
      GETDNS_RETURN_GOOD, "Failed to extract \"answer\" record");
    ASSERT_RC(getdns_dict_get_int(rr_dict, "type", &type),
      GETDNS_RETURN_GOOD, "Failed to extract \"type\" from answer record");
    switch (type)
    {
      case GETDNS_RRTYPE_A:
        if(a && type == GETDNS_RRTYPE_A)
          address_records++;
      case GETDNS_RRTYPE_AAAA:
        if(aaaa && type == GETDNS_RRTYPE_AAAA)
          address_records++;
    }
  }
  ck_assert_msg(ancount == address_records, "ancount: %d address records mismatch: %d",
    ancount, address_records);
}
Ejemplo n.º 10
0
/* Set up the callback function, which will also do the processing of the results */
void callback(getdns_context        *context,
              getdns_callback_type_t callback_type,
              getdns_dict           *response, 
              void                  *userarg,
              getdns_transaction_t   transaction_id)
{
	getdns_return_t r;  /* Holder for all function returns */
	getdns_list    *replies_tree;
	size_t          n_replies, i;

	(void) context; (void) userarg; /* unused parameters */

	switch(callback_type) {
	case GETDNS_CALLBACK_CANCEL:
		printf("Transaction with ID %"PRIu64" was cancelled.\n", transaction_id);
		return;
	case GETDNS_CALLBACK_TIMEOUT:
		printf("Transaction with ID %"PRIu64" timed out.\n", transaction_id);
		return;
	case GETDNS_CALLBACK_ERROR:
		printf("An error occurred for transaction ID %"PRIu64".\n", transaction_id);
		return;
	default: break;
	}
	assert( callback_type == GETDNS_CALLBACK_COMPLETE );

	if ((r = getdns_dict_get_list(response, "replies_tree", &replies_tree)))
		fprintf(stderr, "Could not get \"replies_tree\" from response");

	else if ((r = getdns_list_get_length(replies_tree, &n_replies)))
		fprintf(stderr, "Could not get replies_tree\'s length");

	else for (i = 0; i < n_replies && r == GETDNS_RETURN_GOOD; i++) {
		getdns_dict *reply;
		getdns_list *answer;
		size_t       n_answers, j;

		if ((r = getdns_list_get_dict(replies_tree, i, &reply)))
			fprintf(stderr, "Could not get address %zu from just_address_answers", i);

		else if ((r = getdns_dict_get_list(reply, "answer", &answer)))
			fprintf(stderr, "Could not get \"address_data\" from address");

		else if ((r = getdns_list_get_length(answer, &n_answers)))
			fprintf(stderr, "Could not get answer section\'s length");

		else for (j = 0; j < n_answers && r == GETDNS_RETURN_GOOD; j++) {
			getdns_dict    *rr;
			getdns_bindata *address = NULL;

			if ((r = getdns_list_get_dict(answer, j, &rr)))
				fprintf(stderr, "Could net get rr %zu from answer section", j);

			else if (getdns_dict_get_bindata(rr, "/rdata/ipv4_address", &address) == GETDNS_RETURN_GOOD)
				printf("The IPv4 address is ");

			else if (getdns_dict_get_bindata(rr, "/rdata/ipv6_address", &address) == GETDNS_RETURN_GOOD)
				printf("The IPv6 address is ");

			if (address) {
				char *address_str;
				if (!(address_str = getdns_display_ip_address(address))) {
					fprintf(stderr, "Could not convert second address to string");
					r = GETDNS_RETURN_MEMORY_ERROR;
					break;
				}
				printf("%s\n", address_str);
				free(address_str);
			}
		}
	}
	if (r) {
		assert( r != GETDNS_RETURN_GOOD );
		fprintf(stderr, ": %d\n", r);
	}
	getdns_dict_destroy(response); 
}
Ejemplo n.º 11
0
/*---------------------------------------- getkeyviadane
  fetch the smime/a key identified by the encoded keyid and host name
  populate *certtxt with the key record, caller must free certtxt
*/
void
getkeyviadane(char *dname, int rrtype, char **certtxt)
{
    int      i;
    uint32_t status;
    size_t   nans;
    size_t   numrrs;
    int      rrnum;
    char     getdnserr[MAX_ERROR_STRING+1];
    uint32_t recrrtype;
    getdns_return_t getdnsret;
    getdns_context  *getdnsctx = NULL;
    getdns_dict     *getdnsrsp = NULL;
    getdns_dict     *dnsrec    = NULL;
    getdns_dict     *rr        = NULL;
    getdns_dict     *rrdata    = NULL;
    getdns_list     *dnsreplytree = NULL;
    getdns_list     *dnsans    = NULL;
    getdns_bindata  *rawrdata  = NULL;

    *certtxt = NULL;

    // create the context for DNS resolution using local OS system settings

    getdnsret = getdns_context_create(&getdnsctx, 1);
    if(getdnsret != GETDNS_RETURN_GOOD)
    {
        getdns_strerror(getdnsret, getdnserr, MAX_ERROR_STRING);
        fprintf(stderr, "error creating getdns context, %d, %s\n"
         , getdnsret, getdnserr);
        return;
    }

    // getdns_context_set_resolution_type(getdnsctx, GETDNS_RESOLUTION_STUB);

    // perform the DNS resolution request

    getdnsret = getdns_general_sync(getdnsctx, dname, rrtype, NULL, &getdnsrsp);
    if(getdnsret != GETDNS_RETURN_GOOD)
    {
        getdns_strerror(getdnsret, getdnserr, MAX_ERROR_STRING);
        fprintf(stderr, "DNS request failed, %d, %s\n", getdnsret, getdnserr);

        getdns_dict_destroy(getdnsrsp);
        getdns_context_destroy(getdnsctx);

        return;
    }

    // sanity check the result of the query

    getdnsret = getdns_dict_get_int(getdnsrsp, (char *) "status", &status);
    if(getdnsret != GETDNS_RETURN_GOOD || status != GETDNS_RESPSTATUS_GOOD)
    {
        fprintf(stderr, "DNS request did not return results\n");

        getdns_dict_destroy(getdnsrsp);
        getdns_context_destroy(getdnsctx);

        return;
    }

    getdnsret = getdns_dict_get_list(getdnsrsp, (char *)"replies_tree", &dnsreplytree);
    if(getdnsret != GETDNS_RETURN_GOOD)
    {
        fprintf(stderr, "DNS reply tree empty\n");

        getdns_dict_destroy(getdnsrsp);
        getdns_context_destroy(getdnsctx);

        return;
    }

    nans = 0;
    getdns_list_get_length(dnsreplytree, &nans); 
    for(i=0; i<nans && *certtxt == NULL; i++)
    {
        // extract a record from the reply tree, extract answer from that record

        getdns_list_get_dict(dnsreplytree, i, &dnsrec);

        getdnsret = getdns_dict_get_list(dnsrec, (char *)"answer", &dnsans);
        if(getdnsret != GETDNS_RETURN_GOOD)
        {
            fprintf(stderr, "answer missing from DNS reply tree, exiting\n");
            exit(1);
        }

        // walk the RRs in the DNS answer

        getdns_list_get_length(dnsans, &numrrs);
        for(rrnum=0; rrnum < numrrs && *certtxt == NULL; rrnum++)
        {
            getdns_list_get_dict(dnsans, rrnum, &rr);
            recrrtype = 0;
            getdns_dict_get_int(rr, (char *)"type", &recrrtype);
            if(recrrtype == rrtype)
            {
                getdns_dict_get_dict(rr, (char *)"rdata", &rrdata);
                getdnsret = getdns_dict_get_bindata(rrdata, (char *)"rdata_raw"
                 , &rawrdata);
                if(getdnsret != GETDNS_RETURN_GOOD)
                {
                    fprintf(stderr, "error, rdata missing address\n");
                }
                else
                {
                    *certtxt = (char *) malloc(rawrdata->size + 1);
                    memcpy(*certtxt, rawrdata->data, rawrdata->size);
                    *certtxt[rawrdata->size] = '\0';
                }
            }
        } // for rrnum
    } // for i in nans

    getdns_dict_destroy(getdnsrsp);
    getdns_context_destroy(getdnsctx);

    return;
} // getkeyviadane
Ejemplo n.º 12
0
int
main(int argc, char *argv[])
{
    char *name = "getdnsapi.net";
    getdns_context *context;
    getdns_return_t ret;
    getdns_dict *extensions;
    getdns_dict *response;
    uint32_t status;
    uint32_t dnssec_status;
    uint32_t type;
    getdns_list *replies_tree;
    size_t nanswers;
    int  i;
    char element[MAXELEM];

    if (argc > 1)
        name = argv[1];

    if ((ret = getdns_context_create(&context, 1)) != GETDNS_RETURN_GOOD)  {
        fprintf(stderr, "getdns_context_create: %s\n",
		    getdns_get_errorstr_by_id(ret));
        return 1;
    }

    extensions = getdns_dict_create();
    if ((ret = getdns_dict_set_int(extensions, "/dnssec_return_status",
                                   GETDNS_EXTENSION_TRUE)) != GETDNS_RETURN_GOOD)  {
      	fprintf(stderr, "getdns_dict_set_int(dnssec_return_status): %s\n",
                getdns_get_errorstr_by_id(ret));
        return 1;
    }
    if ((ret = getdns_address_sync(context, name, extensions, &response)) !=
        GETDNS_RETURN_GOOD)  {
	      fprintf(stderr, "getdns_address_sync: %s\n",
                getdns_get_errorstr_by_id(ret));
        return 1;
    }

    (void)getdns_dict_get_int(response, "status", &status);
    if (status != GETDNS_RESPSTATUS_GOOD)  {
        printf("Bad status: ");
        switch (status) {
        case GETDNS_RESPSTATUS_NO_NAME:
            printf("GETDNS_RESPSTATUS_NO_NAME\n");
            break;
        case GETDNS_RESPSTATUS_ALL_TIMEOUT:
            printf("GETDNS_RESPSTATUS_ALL_TIMEOUT\n");
            break;
        default:
            break;
        }
    }

    if ((ret = getdns_dict_get_list(response, "/replies_tree", &replies_tree)) !=
        GETDNS_RETURN_GOOD)  {
        fprintf(stderr, "getdns_dict_get_list(replies_tree): %s\n",
		getdns_get_errorstr_by_id(ret));
        return 1;
    }

    (void)getdns_list_get_length(replies_tree, &nanswers);
    printf("%d answers\n", (int)nanswers);

    for ( i = 0 ; i < (int)nanswers ; i++ )  {
        snprintf(element, MAXELEM, "/replies_tree/%d/dnssec_status", i);
        (void)getdns_dict_get_int(response, element, &dnssec_status);
	      snprintf(element, MAXELEM, "/replies_tree/%d/answer/0/type", i);
        (void)getdns_dict_get_int(response, element, &type);
        printf("dnssec_status for %s record: %s\n", address_type_to_string(type),
               dnssec_status_to_string(dnssec_status));
      }


    /*
     * handy debugging tool - uncomment if wanted
     */

    /* printf("%s\n", getdns_pretty_print_dict(response)); */

    return 0;

}
Ejemplo n.º 13
0
/**
 * test the create, destroy and allocation functions
 */
void
tst_create(void)
{
	char msg[TSTMSGBUF];
	size_t index;
	int i;
	getdns_return_t retval;
	struct getdns_list *list = NULL;

	/* make sure we can do a simple create/destroy first */

	tstmsg_case_begin("tst_create");

	tstmsg_case_msg("getdns_list_create");
	list = getdns_list_create();

	if (list != NULL) {
		tstmsg_case_msg("getdns_list_destroy(list)");
		getdns_list_destroy(list);
	}

	tstmsg_case_msg("getdns_list_destroy(NULL)");
	getdns_list_destroy(NULL);

	/* add items until we force it to allocate more storage */

	tstmsg_case_msg("getdns_list_set_int(list, i) past block size");
	list = getdns_list_create();
	for (i = 0; i < GETDNS_LIST_BLOCKSZ + 2; i++) {
		retval = getdns_list_set_int(list, i, i);
		if (retval != GETDNS_RETURN_GOOD) {
			snprintf(msg, sizeof(msg), "getdns_list_set_int,i=%d,retval = %d",
			    i, retval);
			tstmsg_case_msg(msg);
		}
	}

	tstmsg_case_msg("getdns_list_get_length(list)");
	retval = getdns_list_get_length(list, &index);
	snprintf(msg, sizeof(msg), "list length = %d", (int) index);
	tstmsg_case_msg(msg);

	tstmsg_case_msg("getdns_list_get_length()");
	retval = getdns_list_get_length(NULL, &index);
	snprintf(msg, sizeof(msg), "NUll, %i, retval = %d", (int)index, retval);
	tstmsg_case_msg(msg);

	retval = getdns_list_get_length(NULL, NULL);
	snprintf(msg, sizeof(msg), "NUll, NULL, retval = %d", retval);
	tstmsg_case_msg(msg);

	retval = getdns_list_get_length(list, NULL);
	snprintf(msg, sizeof(msg), "list, NULL, retval = %d", retval);
	tstmsg_case_msg(msg);

	getdns_list_destroy(list);

	tstmsg_case_end();

	return;
}				/* tst_create */
Ejemplo n.º 14
0
/**
 * exercise the getdns_dict_get_names function
 */
void
tst_getnames(void)
{
	size_t index;
	size_t llen;
	uint32_t ansint;
	int i;
	getdns_return_t result;
	getdns_data_type dtype;
	struct getdns_dict *dict = NULL;
	struct getdns_list *list = NULL;

	tstmsg_case_begin("tst_getnames");

	dict = getdns_dict_create();

	/* degenerative use cases */

	tstmsg_case_msg("getdns_dict_get_names(NULL, &list)");
	getdns_dict_get_names(NULL, &list);
	getdns_list_destroy(list);

	tstmsg_case_msg("getdns_dict_get_names(dict, NULL)");
	getdns_dict_get_names(dict, NULL);

	tstmsg_case_msg
	    ("getdns_dict_get_names(dict, &list), empty dictionary");
	getdns_dict_get_names(dict, &list);
	getdns_list_destroy(list);

	/* legit use case, add items out of order to exercise tree */
	/* TODO: add elements of type dict, bindata, list to the dict */

	i = 0;
	getdns_dict_set_int(dict, "foo", i++);
	getdns_dict_set_int(dict, "bar", i++);
	getdns_dict_set_int(dict, "quz", i++);
	getdns_dict_set_int(dict, "alpha", i++);

	getdns_dict_get_names(dict, &list);

	result = getdns_list_get_length(list, &llen);
	if (result != GETDNS_RETURN_GOOD) {
		tstmsg_case_msg
		    ("getdns_list_get_length failed, exiting");
		return;
	}
	if (llen != i) {
		tstmsg_case_msg
		    ("getdns_list_get_length returned unreasonable length, exiting");
		return;
	}

	for (index = 0; index < llen; index++) {
		getdns_list_get_data_type(list, index, &dtype);
		printf("    list item %d: ", (int) index);
		switch (dtype) {
		case t_bindata:
			printf("NOTIMPLEMENTED");
			break;

		case t_dict:
			printf("NOTIMPLEMENTED");
			break;

		case t_int:
			getdns_list_get_int(list, index, &ansint);
			printf("t_int, value=%d\n", ansint);
			break;

		case t_list:
			printf("NOTIMPLEMENTED");
			break;

		default:
			printf("data type invalid");
			break;
		}
	}

	getdns_dict_destroy(dict);
	getdns_list_destroy(list);

	tstmsg_case_end();
}				/* tst_getnames */