void destroy_callbackfn(struct getdns_context *context,
getdns_callback_type_t callback_type,
struct getdns_dict *response,
void *userarg,
getdns_transaction_t transaction_id) {
int* flag = (int*)userarg;
*flag = 1;
getdns_dict_destroy(response);
getdns_context_destroy(context);
}
int main()
{
getdns_return_t r;
getdns_context *ctx = NULL;
if ((r = getdns_context_create(&ctx, 1)))
fprintf(stderr, "Could not create context");
if (ctx)
getdns_context_destroy(ctx);
if (r) {
fprintf(stderr, ": %s\n", getdns_get_errorstr_by_id(r));
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
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()
{
getdns_return_t r; /* Holder for all function returns */
getdns_context *context = NULL;
struct event_base *event_base = NULL;
getdns_dict *extensions = NULL;
char *query_name = "www.example.com";
/* Could add things here to help identify this call */
char *userarg = NULL;
getdns_transaction_t transaction_id;
if ((r = getdns_context_create(&context, 1)))
fprintf(stderr, "Trying to create the context failed");
else if (!(event_base = event_base_new()))
fprintf(stderr, "Trying to create the event base failed.\n");
else if ((r = getdns_extension_set_libevent_base(context, event_base)))
fprintf(stderr, "Setting the event base failed");
else if ((r = getdns_address( context, query_name, extensions
, userarg, &transaction_id, callback)))
fprintf(stderr, "Error scheduling asynchronous request");
else if (event_base_dispatch(event_base) < 0)
fprintf(stderr, "Error dispatching events\n");
/* Clean up */
if (event_base)
event_base_free(event_base);
if (context)
getdns_context_destroy(context);
/* Assuming we get here, leave gracefully */
exit(EXIT_SUCCESS);
}
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;
}
/*---------------------------------------- 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
int
main(int argc, char** argv)
{
const char *transport = argc > 2 ? argv[2] : "udp_tcp";
const char *resolution = argc > 3 ? argv[3] : "stub";
/* Create the DNS context for this call */
struct getdns_context *this_context = NULL;
getdns_return_t return_value =
getdns_context_create(&this_context, 1);
if (return_value != GETDNS_RETURN_GOOD) {
fprintf(stderr, "Trying to create the context failed: %d",
return_value);
return (GETDNS_RETURN_GENERIC_ERROR);
}
if (strncmp(resolution, RESOLUTION_STUB, 4) == 0)
getdns_context_set_resolution_type(this_context, GETDNS_RESOLUTION_STUB);
else if (strncmp(resolution, RESOLUTION_REC, 4) != 0) {
fprintf(stderr, "Invalid resolution %s, must be one of stub or rec\n", transport);
exit(EXIT_FAILURE);
}
/* Order matters*/
if (strncmp(transport, TRANSPORT_TCP, 3) == 0)
getdns_context_set_dns_transport(this_context, GETDNS_TRANSPORT_TCP_ONLY);
else if (strncmp(transport, TRANSPORT_UDP_TCP, 7) == 0)
getdns_context_set_dns_transport(this_context, GETDNS_TRANSPORT_UDP_FIRST_AND_FALL_BACK_TO_TCP);
else if (strncmp(transport, TRANSPORT_UDP, 3) == 0)
getdns_context_set_dns_transport(this_context, GETDNS_TRANSPORT_UDP_ONLY);
else if (strncmp(transport, TRANSPORT_PIPELINE, 8) == 0)
getdns_context_set_dns_transport(this_context, GETDNS_TRANSPORT_TCP_ONLY_KEEP_CONNECTIONS_OPEN);
else if (strncmp(transport, TRANSPORT_TLS_KEEPOPEN, 3) == 0)
getdns_context_set_dns_transport(this_context, GETDNS_TRANSPORT_TLS_ONLY_KEEP_CONNECTIONS_OPEN);
else if (strncmp(transport, TRANSPORT_TLS_TCP_KEEPOPEN, 12) == 0)
getdns_context_set_dns_transport(this_context, GETDNS_TRANSPORT_TLS_FIRST_AND_FALL_BACK_TO_TCP_KEEP_CONNECTIONS_OPEN);
else if (strncmp(transport, TRANSPORT_UDP_TCP, 3) != 0) {
fprintf(stderr, "Invalid transport %s, must be one of udp, udp_tcp, tcp or pipeline\n", transport);
exit(EXIT_FAILURE);
}
getdns_context_set_timeout(this_context, 5000);
/* Create an event base and put it in the context using the unknown function name */
/* Set up the getdns call */
const char *this_name = argc > 1 ? argv[1] : "getdnsapi.net";
char *this_userarg = "somestring"; // Could add things here to help identify this call
getdns_transaction_t this_transaction_id = 0;
/* Make the call */
getdns_return_t dns_request_return =
getdns_address(this_context, this_name,
NULL, this_userarg, &this_transaction_id, this_callbackfn);
if (dns_request_return == GETDNS_RETURN_BAD_DOMAIN_NAME) {
fprintf(stderr, "A bad domain name was used: %s. Exiting.",
this_name);
getdns_context_destroy(this_context);
return (GETDNS_RETURN_GENERIC_ERROR);
}
else {
getdns_context_run(this_context);
}
getdns_transport_t get_transport;
return_value = getdns_context_get_dns_transport(this_context, &get_transport);
if (return_value != GETDNS_RETURN_GOOD) {
fprintf(stderr, "Trying to get transport type failed: %d\n",
return_value);
return (GETDNS_RETURN_GENERIC_ERROR);
}
fprintf(stderr, "Transport type is %d\n", get_transport);
size_t transport_count = 0;
getdns_transport_list_t *get_transport_list;
return_value = getdns_context_get_dns_transport_list(this_context, &transport_count, &get_transport_list);
if (return_value != GETDNS_RETURN_GOOD) {
fprintf(stderr, "Trying to get transport type failed: %d\n",
return_value);
return (GETDNS_RETURN_GENERIC_ERROR);
}
size_t i;
for (i = 0; i < transport_count; i++) {
fprintf(stderr, "Transport %d is %d\n", (int)i, get_transport_list[i]);
}
free(get_transport_list);
/* Clean up */
getdns_context_destroy(this_context);
/* Assuming we get here, leave gracefully */
exit(EXIT_SUCCESS);
} /* main */
