int
main()
{
/* Create the DNS context for this call */
struct getdns_context *this_context = NULL;
getdns_return_t context_create_return =
getdns_context_create(&this_context, 1);
if (context_create_return != GETDNS_RETURN_GOOD) {
fprintf(stderr, "Trying to create the context failed: %d",
context_create_return);
return (GETDNS_RETURN_GENERIC_ERROR);
}
getdns_context_set_resolution_type(this_context, GETDNS_RESOLUTION_STUB);
struct getdns_dict *response = NULL;
getdns_return_t ret =
getdns_address_sync(this_context, "www.google.com", NULL, &response);
if (ret != GETDNS_RETURN_GOOD || response == NULL) {
fprintf(stderr, "Address sync returned error.\n");
exit(EXIT_FAILURE);
}
print_response(response);
getdns_dict_destroy(response);
ret =
getdns_service_sync(this_context, "www.google.com", NULL, &response);
if (ret != GETDNS_RETURN_GOOD || response == NULL) {
fprintf(stderr, "Service sync returned error.\n");
exit(EXIT_FAILURE);
}
print_response(response);
getdns_dict_destroy(response);
/* Clean up */
getdns_context_destroy(this_context);
/* Assuming we get here, leave gracefully */
exit(EXIT_SUCCESS);
} /* main */
int
main(int argc, char **argv)
{
getdns_dict *response = NULL;
char *response_str;
getdns_return_t r;
getdns_dict *address = NULL;
FILE *fp = NULL;
name = the_root;
if ((r = getdns_context_create(&context, 1))) {
fprintf(stderr, "Create context failed: %d\n", r);
return r;
}
extensions = getdns_dict_create();
if (! extensions) {
fprintf(stderr, "Could not create extensions dict\n");
r = GETDNS_RETURN_MEMORY_ERROR;
goto done_destroy_context;
}
if ((r = parse_args(argc, argv)))
goto done_destroy_context;
if (query_file) {
fp = fopen(query_file, "rt");
if (fp == NULL) {
fprintf(stderr, "Could not open query file: %s\n", query_file);
goto done_destroy_context;
}
}
/* Make the call */
do {
char line[1024], *token, *linev[256];
int linec;
if (interactive) {
if (!query_file) {
fprintf(stdout, "> ");
if (!fgets(line, 1024, stdin) || !*line)
break;
} else {
if (!fgets(line, 1024, fp) || !*line)
break;
fprintf(stdout,"Found query: %s", line);
}
linev[0] = argv[0];
linec = 1;
if ( ! (token = strtok(line, " \t\f\n\r")))
continue;
do linev[linec++] = token;
while (linec < 256 &&
(token = strtok(NULL, " \t\f\n\r")));
if ((r = parse_args(linec, linev))) {
if (r == CONTINUE)
continue;
else
goto done_destroy_context;
}
}
if (calltype == HOSTNAME &&
!(address = ipaddr_dict(context, name))) {
fprintf(stderr, "Could not convert \"%s\" "
"to an IP address", name);
continue;
}
if (async) {
switch (calltype) {
case GENERAL:
r = getdns_general(context, name, request_type,
extensions, &response, NULL, callback);
break;
case ADDRESS:
r = getdns_address(context, name,
extensions, &response, NULL, callback);
break;
case HOSTNAME:
r = getdns_hostname(context, address,
extensions, &response, NULL, callback);
break;
case SERVICE:
r = getdns_service(context, name,
extensions, &response, NULL, callback);
break;
default:
r = GETDNS_RETURN_GENERIC_ERROR;
break;
}
if (r)
goto done_destroy_extensions;
if (!batch_mode)
getdns_context_run(context);
} else {
switch (calltype) {
case GENERAL:
r = getdns_general_sync(context, name,
request_type, extensions, &response);
break;
case ADDRESS:
r = getdns_address_sync(context, name,
extensions, &response);
break;
case HOSTNAME:
r = getdns_hostname_sync(context, address,
extensions, &response);
break;
case SERVICE:
r = getdns_service_sync(context, name,
extensions, &response);
break;
default:
r = GETDNS_RETURN_GENERIC_ERROR;
break;
}
if (r)
goto done_destroy_extensions;
if (!quiet) {
if ((response_str = json ?
getdns_print_json_dict(response, json == 1)
: getdns_pretty_print_dict(response))) {
fprintf( stdout, "SYNC response:\n%s\n"
, response_str);
free(response_str);
} else {
r = GETDNS_RETURN_MEMORY_ERROR;
fprintf( stderr
, "Could not print response\n");
}
} else if (r == GETDNS_RETURN_GOOD)
fprintf(stdout, "Response code was: GOOD\n");
else if (interactive)
fprintf(stderr, "An error occurred: %d\n", r);
}
} while (interactive);
if (batch_mode)
getdns_context_run(context);
/* Clean up */
done_destroy_extensions:
getdns_dict_destroy(extensions);
done_destroy_context:
if (response) getdns_dict_destroy(response);
getdns_context_destroy(context);
if (fp)
fclose(fp);
if (r == CONTINUE)
return 0;
if (r)
fprintf(stderr, "An error occurred: %d\n", r);
return r;
}
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;
}
