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; }
static getdns_return_t set_cookie(getdns_dict *exts, char *cookie) { uint8_t data[40]; size_t i; getdns_return_t r = GETDNS_RETURN_GENERIC_ERROR; getdns_bindata bindata; getdns_dict *opt_parameters = getdns_dict_create(); getdns_list *options = getdns_list_create(); getdns_dict *option = getdns_dict_create(); if (*cookie == '=') cookie++; for (i = 0; i < 40 && *cookie; i++) { if (*cookie >= '0' && *cookie <= '9') data[i] = (uint8_t)(*cookie - '0') << 4; else if (*cookie >= 'a' && *cookie <= 'f') data[i] = (uint8_t)(*cookie - 'a' + 10) << 4; else if (*cookie >= 'A' && *cookie <= 'F') data[i] = (uint8_t)(*cookie - 'A' + 10) << 4; else goto done; cookie++; if (*cookie >= '0' && *cookie <= '9') data[i] |= (uint8_t)(*cookie - '0'); else if (*cookie >= 'a' && *cookie <= 'f') data[i] |= (uint8_t)(*cookie - 'a' + 10); else if (*cookie >= 'A' && *cookie <= 'F') data[i] |= (uint8_t)(*cookie - 'A' + 10); else goto done; cookie++;; } bindata.data = data; bindata.size = i; if ((r = getdns_dict_set_int(option, "option_code", 65001))) goto done; if ((r = getdns_dict_set_bindata(option, "option_data", &bindata))) goto done; if ((r = getdns_list_set_dict(options, 0, option))) goto done; if ((r = getdns_dict_set_list(opt_parameters, "options", options))) goto done; r = getdns_dict_set_dict(exts, "add_opt_parameters", opt_parameters); done: getdns_dict_destroy(option); getdns_list_destroy(options); getdns_dict_destroy(opt_parameters); return r; }
static getdns_return_t validate_chain(getdns_dict *response) { getdns_return_t r; getdns_list *validation_chain; getdns_list *replies_tree; getdns_dict *reply; getdns_list *to_validate; getdns_list *trust_anchor; size_t i; int s; if (!(to_validate = getdns_list_create())) return GETDNS_RETURN_MEMORY_ERROR; trust_anchor = getdns_root_trust_anchor(NULL); if ((r = getdns_dict_get_list( response, "validation_chain", &validation_chain))) goto error; if ((r = getdns_dict_get_list( response, "replies_tree", &replies_tree))) goto error; fprintf(stdout, "replies_tree dnssec_status: "); switch ((s = getdns_validate_dnssec( replies_tree, validation_chain, trust_anchor))) { case GETDNS_DNSSEC_SECURE: fprintf(stdout, "GETDNS_DNSSEC_SECURE\n"); break; case GETDNS_DNSSEC_BOGUS: fprintf(stdout, "GETDNS_DNSSEC_BOGUS\n"); break; case GETDNS_DNSSEC_INDETERMINATE: fprintf(stdout, "GETDNS_DNSSEC_INDETERMINATE\n"); break; case GETDNS_DNSSEC_INSECURE: fprintf(stdout, "GETDNS_DNSSEC_INSECURE\n"); break; case GETDNS_DNSSEC_NOT_PERFORMED: fprintf(stdout, "GETDNS_DNSSEC_NOT_PERFORMED\n"); break; default: fprintf(stdout, "%d\n", (int)s); } i = 0; while (!(r = getdns_list_get_dict(replies_tree, i++, &reply))) { if ((r = getdns_list_set_dict(to_validate, 0, reply))) goto error; fprintf( stdout , "reply %zu, dnssec_status: ", i); switch ((s = getdns_validate_dnssec( to_validate, validation_chain, trust_anchor))) { case GETDNS_DNSSEC_SECURE: fprintf(stdout, "GETDNS_DNSSEC_SECURE\n"); break; case GETDNS_DNSSEC_BOGUS: fprintf(stdout, "GETDNS_DNSSEC_BOGUS\n"); break; case GETDNS_DNSSEC_INDETERMINATE: fprintf(stdout, "GETDNS_DNSSEC_INDETERMINATE\n"); break; case GETDNS_DNSSEC_INSECURE: fprintf(stdout, "GETDNS_DNSSEC_INSECURE\n"); break; case GETDNS_DNSSEC_NOT_PERFORMED: fprintf(stdout, "GETDNS_DNSSEC_NOT_PERFORMED\n"); break; default: fprintf(stdout, "%d\n", (int)s); } } if (r == GETDNS_RETURN_NO_SUCH_LIST_ITEM) r = GETDNS_RETURN_GOOD; error: getdns_list_destroy(trust_anchor); getdns_list_destroy(to_validate); return GETDNS_RETURN_GOOD; }
/** * test the list get and set routines */ void tst_bindatasetget(void) { char msg[TSTMSGBUF]; size_t index = 0; getdns_return_t retval; struct getdns_list *list = NULL; struct getdns_bindata *new_bindata = NULL; struct getdns_bindata *ans_bindata = NULL; tstmsg_case_begin("tst_bindatasetget"); list = getdns_list_create(); /* test get function against empty list and with bogus params */ tstmsg_case_msg("getdns_list_get_bindata() empty list"); retval = getdns_list_get_bindata(NULL, index, &ans_bindata); snprintf(msg, sizeof(msg), "getdns_list_get_bindata(NULL, index, &ans_bindata),retval = %d", retval); tstmsg_case_msg(msg); retval = getdns_list_get_bindata(list, index, NULL); snprintf(msg, sizeof(msg), "getdns_list_get_bindata(list, index, NULL),retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_list_get_bindata(list, 0, &ans_bindata)"); retval = getdns_list_get_bindata(list, 0, &ans_bindata); snprintf(msg, sizeof(msg), "getdns_list_get_bindata,retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_list_get_bindata(list, 1, &ans_bindata)"); retval = getdns_list_get_bindata(list, 1, &ans_bindata); snprintf(msg, sizeof(msg), "getdns_list_get_bindata,retval = %d", retval); tstmsg_case_msg(msg); /* test set function against empty list with bogus params */ tstmsg_case_msg("getdns_list_set_bindata(list, -1, ans_bindata)"); retval = getdns_list_set_bindata(list, -1, NULL); snprintf(msg, sizeof(msg), "getdns_list_set_bindata,retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_list_set_bindata(list, 1, ans_bindata)"); retval = getdns_list_set_bindata(list, 1, NULL); snprintf(msg, sizeof(msg), "getdns_list_set_bindata,retval = %d", retval); tstmsg_case_msg(msg); /* test set and get legitimate use case */ new_bindata = (struct getdns_bindata *) malloc(sizeof(struct getdns_bindata)); new_bindata->size = strlen("foobar") + 1; new_bindata->data = (uint8_t *) "foobar"; getdns_list_set_bindata(list, index, new_bindata); retval = getdns_list_get_bindata(list, index, &ans_bindata); snprintf(msg, sizeof(msg), "getdns_list_set/get_bindata,retval = %d, bindata->data = %d,%s", retval, (int) ans_bindata->size, (char *) ans_bindata->data); tstmsg_case_msg(msg); getdns_list_destroy(list); tstmsg_case_end(); return; } /* tst_bindatasetget */
/** * 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 */
/** * test the int get and set routines */ void tst_intsetget(void) { char msg[TSTMSGBUF]; size_t index = 0; uint32_t ans_int; getdns_return_t retval; struct getdns_list *list = NULL; tstmsg_case_begin("tst_intsetget"); list = getdns_list_create(); /* test int get function against empty list and with bogus params */ tstmsg_case_msg("getdns_list_get_int() empty list"); retval = getdns_list_get_int(NULL, index, &ans_int); snprintf(msg, sizeof(msg), "getdns_list_get_int(NULL, index, &ans_int),retval = %d", retval); tstmsg_case_msg(msg); retval = getdns_list_get_int(list, index, NULL); snprintf(msg, sizeof(msg), "getdns_list_get_int(list, index, NULL),retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_list_get_int(list, 0, &ans_int)"); retval = getdns_list_get_int(list, 0, &ans_int); snprintf(msg, sizeof(msg), "getdns_list_get_int,retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_list_get_int(list, 1, &ans_int)"); retval = getdns_list_get_int(list, 1, &ans_int); snprintf(msg, sizeof(msg), "getdns_list_get_int,retval = %d", retval); tstmsg_case_msg(msg); /* test int set function against empty list with bogus params */ tstmsg_case_msg("getdns_list_set_int(list, -1, ans_int)"); retval = getdns_list_set_int(list, -1, ans_int); snprintf(msg, sizeof(msg), "getdns_list_set_int,retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_list_set_int(list, 1, ans_int)"); retval = getdns_list_set_int(list, 1, ans_int); snprintf(msg, sizeof(msg), "getdns_list_set_int,retval = %d", retval); tstmsg_case_msg(msg); /* test set and get legitimate use case */ getdns_list_set_int(list, index, 42); retval = getdns_list_get_int(list, index, &ans_int); snprintf(msg, sizeof(msg), "getdns_list_set/get_int,retval = %d, ans = %d", retval, ans_int); tstmsg_case_msg(msg); getdns_list_destroy(list); tstmsg_case_end(); return; } /* tst_intsetget */
/** * test the list get and set routines */ void tst_listsetget(void) { char msg[TSTMSGBUF]; char key[20]; size_t index; uint32_t int1; uint32_t int2; getdns_return_t retval; struct getdns_list *newlist; struct getdns_list *anslist; struct getdns_dict *dict = NULL; tstmsg_case_begin("tst_listsetget"); dict = getdns_dict_create(); /* test get function against empty list and with bogus params */ strcpy(key, "foo"); tstmsg_case_msg("getdns_dict_get_list() empty dict"); retval = getdns_dict_get_list(NULL, key, &anslist); snprintf(msg, sizeof(msg), "test 13: getdns_dict_get_list(NULL, key, &anslist),retval = %d", retval); tstmsg_case_msg(msg); retval = getdns_dict_get_list(dict, key, NULL); snprintf(msg, sizeof(msg), "test 14: getdns_dict_get_list(dict, key, NULL),retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_dict_get_list(dict, NULL, &anslist)"); retval = getdns_dict_get_list(dict, NULL, &anslist); snprintf(msg, sizeof(msg), "test 15: getdns_dict_get_list,retval = %d", retval); tstmsg_case_msg(msg); tstmsg_case_msg("getdns_dict_get_list(dict, key, &anslist)"); retval = getdns_dict_get_list(dict, key, &anslist); snprintf(msg, sizeof(msg), "test 16: getdns_list_get_list,retval = %d", retval); tstmsg_case_msg(msg); getdns_dict_destroy(dict); /* TODO: test getdns_dict_set functions with bogus params */ /* test set and get legitimate use case */ dict = getdns_dict_create(); strcpy(key, "foo"); newlist = getdns_list_create(); getdns_list_add_item(newlist, &index); getdns_list_set_int(newlist, index, 42); getdns_list_add_item(newlist, &index); getdns_list_set_int(newlist, index, 52); tstmsg_case_msg("getdns_dict_set_list(dict, key, newlist)"); retval = getdns_dict_set_list(dict, key, newlist); snprintf(msg, sizeof(msg), "test 17: getdns_dict_set_list,retval=%d,key=%s", retval, key); tstmsg_case_msg(msg); getdns_list_destroy(newlist); tstmsg_case_msg("getdns_dict_get_list(dict, key, &anslist)"); retval = getdns_dict_get_list(dict, key, &anslist); getdns_list_get_int(anslist, 0, &int1); getdns_list_get_int(anslist, 1, &int2); snprintf(msg, sizeof(msg), "test 18: getdns_dict_get_list,retval=%d,key=%s,int1=%d,int2=%d", retval, key, int1, int2); tstmsg_case_msg(msg); getdns_dict_destroy(dict); tstmsg_case_end(); return; } /* tst_listsetget */