26 #include <arpa/nameser.h>
27 #include <arpa/inet.h>
50 .
name =
"A snake that swallowed a deer",
52 .resolve = stub_resolve,
53 .cancel = stub_cancel,
58 info->name =
"resolver_register_unregister";
59 info->category =
"/main/dns/";
60 info->summary =
"Test nominal resolver registration and unregistration";
62 "The test performs the following steps:\n"
63 "\t* Register a valid resolver.\n"
64 "\t* Unregister the resolver.\n"
65 "If either step fails, the test fails";
66 return AST_TEST_NOT_RUN;
72 ast_test_status_update(
test,
"Unable to register a perfectly good resolver\n");
85 .resolve = stub_resolve,
86 .cancel = stub_cancel,
91 .resolve = stub_resolve,
92 .cancel = stub_cancel,
96 .
name =
"incomplete2",
98 .cancel = stub_cancel,
102 .
name =
"incomplete3",
103 .resolve = stub_resolve,
109 info->name =
"resolver_register_off_nominal";
110 info->category =
"/main/dns/";
111 info->summary =
"Test off-nominal resolver registration";
113 "Test off-nominal resolver registration:\n"
114 "\t* Register a duplicate resolver\n"
115 "\t* Register a resolver without a name\n"
116 "\t* Register a resolver without a resolve() method\n"
117 "\t* Register a resolver without a cancel() method";
118 return AST_TEST_NOT_RUN;
124 ast_test_status_update(
test,
"Failed to register valid resolver\n");
125 return AST_TEST_FAIL;
129 ast_test_status_update(
test,
"Successfully registered the same resolver multiple times\n");
130 return AST_TEST_FAIL;
136 ast_test_status_update(
test,
"Successfully registered a NULL resolver\n");
137 return AST_TEST_FAIL;
141 ast_test_status_update(
test,
"Successfully registered a DNS resolver with no name\n");
142 return AST_TEST_FAIL;
146 ast_test_status_update(
test,
"Successfully registered a DNS resolver with no resolve() method\n");
147 return AST_TEST_FAIL;
151 ast_test_status_update(
test,
"Successfully registered a DNS resolver with no cancel() method\n");
152 return AST_TEST_FAIL;
155 return AST_TEST_PASS;
161 .
name =
"I do not exist",
162 .priority = 20141004,
163 .resolve = stub_resolve,
164 .cancel = stub_cancel,
169 info->name =
"resolver_unregister_off_nominal";
170 info->category =
"/main/dns/";
171 info->summary =
"Test off-nominal DNS resolver unregister";
173 "The test attempts the following:\n"
174 "\t* Unregister a resolver that is not registered.\n"
175 "\t* Unregister a NULL pointer.\n"
176 "Because unregistering a resolver does not return an indicator of success, the best\n"
177 "this test can do is verify that nothing blows up when this is attempted.";
178 return AST_TEST_NOT_RUN;
186 return AST_TEST_PASS;
198 RAII_VAR(
struct digits *, average, NULL, ao2_cleanup);
199 RAII_VAR(
struct digits *, polydactyl, NULL, ao2_cleanup);
201 struct digits *data_ptr;
205 info->name =
"resolver_data";
206 info->category =
"/main/dns/";
207 info->summary =
"Test getting and setting data on a DNS resolver";
208 info->description =
"This test does the following:\n"
209 "\t* Ensure that requesting resolver data results in a NULL return if no data has been set.\n"
210 "\t* Ensure that setting resolver data does not result in an error.\n"
211 "\t* Ensure that retrieving the set resolver data returns the data we expect\n"
212 "\t* Ensure that setting new resolver data on the query does not result in an error\n"
213 "\t* Ensure that retrieving the resolver data returns the new data that we set";
214 return AST_TEST_NOT_RUN;
219 memset(&some_query, 0,
sizeof(some_query));
221 average = ao2_alloc(
sizeof(*average), NULL);
222 polydactyl = ao2_alloc(
sizeof(*average), NULL);
224 if (!average || !polydactyl) {
225 ast_test_status_update(
test,
"Allocation failure during unit test\n");
226 return AST_TEST_FAIL;
232 ast_test_status_update(
test,
"Retrieved non-NULL resolver data from query unexpectedly\n");
233 return AST_TEST_FAIL;
237 ast_test_status_update(
test,
"Failed to set resolver data on query\n");
238 return AST_TEST_FAIL;
247 ast_test_status_update(
test,
"Unable to retrieve resolver data from DNS query\n");
248 return AST_TEST_FAIL;
251 if (data_ptr != average) {
252 ast_test_status_update(
test,
"Unexpected resolver data retrieved from DNS query\n");
253 return AST_TEST_FAIL;
258 ast_test_status_update(
test,
"Successfully overwrote resolver data on a query. We shouldn't be able to do that\n");
259 return AST_TEST_FAIL;
262 return AST_TEST_PASS;
265 static int test_results(
struct ast_test *
test,
const struct ast_dns_query *query,
266 unsigned int expected_secure,
unsigned int expected_bogus,
267 unsigned int expected_rcode,
const char *expected_canonical,
268 const char *expected_answer,
size_t answer_size)
274 ast_test_status_update(test,
"Unable to retrieve result from query\n");
283 ast_test_status_update(test,
"Unexpected values in result from query\n");
294 #define DNS_ANSWER "Grumble Grumble"
295 #define DNS_ANSWER_SIZE strlen(DNS_ANSWER)
313 enum ast_test_result_state res = AST_TEST_PASS;
317 info->name =
"resolver_set_result";
318 info->category =
"/main/dns/";
319 info->summary =
"Test setting and getting results on DNS queries";
321 "This test performs the following:\n"
322 "\t* Sets a result that is not secure, bogus, and has rcode 0\n"
323 "\t* Sets a result that is not secure, has rcode 0, but is secure\n"
324 "\t* Sets a result that is not bogus, has rcode 0, but is secure\n"
325 "\t* Sets a result that is not secure or bogus, but has rcode NXDOMAIN\n"
326 "After each result is set, we ensure that parameters retrieved from\n"
327 "the result have the expected values.";
328 return AST_TEST_NOT_RUN;
333 memset(&some_query, 0,
sizeof(some_query));
335 for (i = 0; i < ARRAY_LEN(results); ++i) {
337 results[i].rcode,
"asterisk.org", DNS_ANSWER, DNS_ANSWER_SIZE)) {
338 ast_test_status_update(test,
"Unable to add DNS result to query\n");
342 if (test_results(test, &some_query, results[i].secure, results[i].bogus,
343 results[i].rcode,
"asterisk.org", DNS_ANSWER, DNS_ANSWER_SIZE)) {
362 info->name =
"resolver_set_result_off_nominal";
363 info->category =
"/main/dns/";
364 info->summary =
"Test setting off-nominal DNS results";
366 "This test performs the following:\n"
367 "\t* Attempt to add a DNS result that is both bogus and secure\n"
368 "\t* Attempt to add a DNS result that has no canonical name";
369 return AST_TEST_NOT_RUN;
374 memset(&some_query, 0,
sizeof(some_query));
377 DNS_ANSWER, DNS_ANSWER_SIZE)) {
378 ast_test_status_update(test,
"Successfully added a result that was both secure and bogus\n");
381 return AST_TEST_FAIL;
385 DNS_ANSWER, DNS_ANSWER_SIZE)) {
386 ast_test_status_update(test,
"Successfully added result with no canonical name\n");
389 return AST_TEST_FAIL;
392 return AST_TEST_PASS;
395 static int test_record(
struct ast_test *test,
const struct ast_dns_record *record,
396 int rr_type,
int rr_class,
int ttl,
const char *data,
const size_t size)
399 ast_test_status_update(test,
"Unexpected rr_type from DNS record\n");
404 ast_test_status_update(test,
"Unexpected rr_class from DNS record\n");
409 ast_test_status_update(test,
"Unexpected ttl from DNS record\n");
414 ast_test_status_update(test,
"Unexpected data in DNS record\n");
427 static const char *V4 =
"127.0.0.1";
428 static const size_t V4_BUFSIZE =
sizeof(
struct in_addr);
429 char v4_buf[V4_BUFSIZE];
431 static const char *V6 =
"::1";
432 static const size_t V6_BUFSIZE =
sizeof(
struct in6_addr);
433 char v6_buf[V6_BUFSIZE];
435 struct dns_record_details {
443 { T_A, C_IN, 12345, v4_buf, V4_BUFSIZE, 0, },
444 { T_AAAA, C_IN, 12345, v6_buf, V6_BUFSIZE, 0, },
447 int num_records_visited = 0;
451 info->name =
"resolver_add_record";
452 info->category =
"/main/dns/";
453 info->summary =
"Test adding DNS records to a query";
455 "This test performs the following:\n"
456 "\t* Ensure a nominal A record can be added to a query result\n"
457 "\t* Ensures that the record can be retrieved\n"
458 "\t* Ensure that a second record can be added to the query result\n"
459 "\t* Ensures that both records can be retrieved";
460 return AST_TEST_NOT_RUN;
465 memset(&some_query, 0,
sizeof(some_query));
468 DNS_ANSWER, DNS_ANSWER_SIZE)) {
469 ast_test_status_update(test,
"Unable to set result for DNS query\n");
470 return AST_TEST_FAIL;
475 ast_test_status_update(test,
"Unable to retrieve result from query\n");
476 return AST_TEST_FAIL;
479 inet_pton(AF_INET, V4, v4_buf);
483 records[0].ttl, records[0].data, records[0].size)) {
484 ast_test_status_update(test,
"Unable to add nominal record to query result\n");
485 return AST_TEST_FAIL;
491 ast_test_status_update(test,
"Unable to retrieve record from result\n");
492 return AST_TEST_FAIL;
495 if (test_record(test, record, records[0].type, records[0].
class, records[0].ttl,
496 records[0].data, records[0].size)) {
497 return AST_TEST_FAIL;
501 ast_test_status_update(test,
"Multiple records returned when only one was expected\n");
502 return AST_TEST_FAIL;
505 inet_pton(AF_INET6, V6, v6_buf);
508 records[1].ttl, records[1].data, records[1].size)) {
509 ast_test_status_update(test,
"Unable to add second record to query result\n");
510 return AST_TEST_FAIL;
520 res = test_record(test, record, records[0].type, records[0].
class, records[0].ttl, records[0].data, records[0].size);
521 records[0].visited = 1;
523 res = test_record(test, record, records[1].type, records[1].
class, records[1].ttl, records[1].data, records[1].size);
524 records[1].visited = 1;
526 ast_test_status_update(test,
"Unknown record type found in DNS results\n");
527 return AST_TEST_FAIL;
531 return AST_TEST_FAIL;
534 ++num_records_visited;
537 if (!records[0].visited || !records[1].visited) {
538 ast_test_status_update(test,
"Did not visit all added DNS records\n");
539 return AST_TEST_FAIL;
542 if (num_records_visited != ARRAY_LEN(records)) {
543 ast_test_status_update(test,
"Did not visit the expected number of DNS records\n");
544 return AST_TEST_FAIL;
547 return AST_TEST_PASS;
554 static const char *V4 =
"127.0.0.1";
555 static const size_t V4_BUFSIZE =
sizeof(
struct in_addr);
556 char v4_buf[V4_BUFSIZE];
560 info->name =
"resolver_add_record_off_nominal";
561 info->category =
"/main/dns/";
562 info->summary =
"Test adding off-nominal DNS records to a query";
564 "This test performs the following:\n"
565 "\t* Ensure a nominal A record cannot be added if no result has been set.\n"
566 "\t* Ensure that an A record with invalid RR types cannot be added to a query\n"
567 "\t* Ensure that an A record with invalid RR classes cannot be added to a query\n"
568 "\t* Ensure that an A record with invalid TTL cannot be added to a query\n"
569 "\t* Ensure that an A record with NULL data cannot be added to a query\n"
570 "\t* Ensure that an A record with invalid length cannot be added to a query";
571 return AST_TEST_NOT_RUN;
576 memset(&some_query, 0,
sizeof(some_query));
578 inet_ntop(AF_INET, V4, v4_buf, V4_BUFSIZE);
582 ast_test_status_update(test,
"Successfully added DNS record to query before setting a result\n");
583 return AST_TEST_FAIL;
587 DNS_ANSWER, DNS_ANSWER_SIZE)) {
588 ast_test_status_update(test,
"Unable to set result for DNS query\n");
589 return AST_TEST_FAIL;
597 ast_test_status_update(test,
"Successfully added DNS record with negative RR type\n");
598 return AST_TEST_FAIL;
602 ast_test_status_update(test,
"Successfully added DNS record with too large RR type\n");
603 return AST_TEST_FAIL;
608 ast_test_status_update(test,
"Successfully added DNS record with negative RR class\n");
609 return AST_TEST_FAIL;
613 ast_test_status_update(test,
"Successfully added DNS record with too large RR class\n");
614 return AST_TEST_FAIL;
619 ast_test_status_update(test,
"Successfully added DNS record with negative TTL\n");
620 return AST_TEST_FAIL;
625 ast_test_status_update(test,
"Successfully added a DNS record with no data\n");
626 return AST_TEST_FAIL;
631 ast_test_status_update(test,
"Successfully added a DNS record with length zero\n");
632 return AST_TEST_FAIL;
635 return AST_TEST_PASS;
655 } test_resolver_data;
670 static void *resolution_thread(
void *dns_query)
673 struct timespec timeout;
675 static const char *V4 =
"127.0.0.1";
676 static const size_t V4_BUFSIZE =
sizeof(
struct in_addr);
677 char v4_buf[V4_BUFSIZE];
682 ast_mutex_lock(&test_resolver_data.
lock);
683 while (!test_resolver_data.
canceled) {
684 if (ast_cond_timedwait(&test_resolver_data.
cancel_cond, &test_resolver_data.
lock, &timeout) == ETIMEDOUT) {
688 ast_mutex_unlock(&test_resolver_data.
lock);
698 inet_pton(AF_INET, V4, v4_buf);
717 pthread_t resolver_thread;
720 return ast_pthread_create_detached(&resolver_thread, NULL, resolution_thread,
ao2_bump(query));
733 ast_mutex_lock(&test_resolver_data.
lock);
736 ast_mutex_unlock(&test_resolver_data.
lock);
746 static void resolver_data_init(
void)
752 ast_mutex_init(&test_resolver_data.
lock);
753 ast_cond_init(&test_resolver_data.
cancel_cond, NULL);
761 static void resolver_data_cleanup(
void)
763 ast_mutex_destroy(&test_resolver_data.
lock);
777 .resolve = test_resolve,
778 .cancel = test_cancel,
784 enum ast_test_result_state res = AST_TEST_PASS;
788 info->name =
"resolver_resolve_sync";
789 info->category =
"/main/dns/";
790 info->summary =
"Test a nominal synchronous DNS resolution";
792 "This test performs a synchronous DNS resolution of a domain. The goal of this\n"
793 "test is not to check the records for accuracy. Rather, the goal is to ensure that\n"
794 "the resolver is called into as expected, that the query completes entirely before\n"
795 "returning from the synchronous resolution, that nothing tried to cancel the resolution\n,"
796 "and that some records were returned.";
797 return AST_TEST_NOT_RUN;
803 ast_test_status_update(test,
"Unable to register test resolver\n");
804 return AST_TEST_FAIL;
807 resolver_data_init();
810 ast_test_status_update(test,
"Resolution of address failed\n");
816 ast_test_status_update(test,
"DNS resolution returned a NULL result\n");
822 ast_test_status_update(test,
"DNS resolution did not call resolver's resolve() method\n");
828 ast_test_status_update(test,
"Resolver's cancel() method called for no reason\n");
834 ast_test_status_update(test,
"Synchronous resolution completed early?\n");
840 ast_test_status_update(test,
"Synchronous resolution yielded no records.\n");
847 resolver_data_cleanup();
865 .
name =
"Uwe Boll's Filmography",
867 .resolve = fail_resolve,
868 .cancel = stub_cancel,
873 struct dns_resolve_data {
879 { NULL, T_A, C_IN, &result },
880 {
"asterisk.org", -1, C_IN, &result },
881 {
"asterisk.org", 65536 + 1, C_IN, &result },
882 {
"asterisk.org", T_A, -1, &result },
883 {
"asterisk.org", T_A, 65536 + 1, &result },
884 {
"asterisk.org", T_A, C_IN, NULL },
889 enum ast_test_result_state res = AST_TEST_PASS;
893 info->name =
"resolver_resolve_sync_off_nominal";
894 info->category =
"/main/dns/";
895 info->summary =
"Test off-nominal synchronous DNS resolution";
897 "This test performs several off-nominal synchronous DNS resolutions:\n"
898 "\t* Attempt resolution with NULL name\n"
899 "\t* Attempt resolution with invalid RR type\n"
900 "\t* Attempt resolution with invalid RR class\n"
901 "\t* Attempt resolution with NULL result pointer\n"
902 "\t* Attempt resolution with resolver that returns an error";
903 return AST_TEST_NOT_RUN;
909 ast_test_status_update(test,
"Failed to register test resolver\n");
910 return AST_TEST_FAIL;
913 for (i = 0; i < ARRAY_LEN(resolves); ++i) {
914 if (!
ast_dns_resolve(resolves[i].name, resolves[i].rr_type, resolves[i].rr_class, resolves[i].result)) {
915 ast_test_status_update(test,
"Successfully resolved DNS query with invalid parameters\n");
918 ast_test_status_update(test,
"Failed resolution set a non-NULL result\n");
928 ast_test_status_update(test,
"Failed to register the terrible resolver\n");
929 return AST_TEST_FAIL;
933 ast_test_status_update(test,
"DNS resolution succeeded when we expected it not to\n");
935 return AST_TEST_FAIL;
941 ast_test_status_update(test,
"Failed DNS resolution set the result to something non-NULL\n");
943 return AST_TEST_FAIL;
966 static void async_data_destructor(
void *obj)
970 ast_mutex_destroy(&async_data->lock);
971 ast_cond_destroy(&async_data->cond);
987 async_data = ao2_alloc(
sizeof(*async_data), async_data_destructor);
992 async_data->complete = 0;
993 ast_mutex_init(&async_data->lock);
994 ast_cond_init(&async_data->cond, NULL);
1008 static void async_callback(
const struct ast_dns_query *query)
1012 ast_mutex_lock(&async_data->lock);
1013 async_data->complete = 1;
1014 ast_cond_signal(&async_data->cond);
1015 ast_mutex_unlock(&async_data->lock);
1023 enum ast_test_result_state res = AST_TEST_PASS;
1024 struct timespec timeout;
1028 info->name =
"resolver_resolve_async";
1029 info->category =
"/main/dns/";
1030 info->summary =
"Test a nominal asynchronous DNS resolution";
1032 "This test performs an asynchronous DNS resolution of a domain. The goal of this\n"
1033 "test is not to check the records for accuracy. Rather, the goal is to ensure that\n"
1034 "the resolver is called into as expected, that we regain control before the query\n"
1035 "is completed, and to ensure that nothing tried to cancel the resolution.";
1036 return AST_TEST_NOT_RUN;
1042 ast_test_status_update(test,
"Unable to register test resolver\n");
1043 return AST_TEST_FAIL;
1046 resolver_data_init();
1048 async_data = async_data_alloc();
1050 ast_test_status_update(test,
"Failed to allocate asynchronous data\n");
1051 res = AST_TEST_FAIL;
1057 ast_test_status_update(test,
"Asynchronous resolution of address failed\n");
1058 res = AST_TEST_FAIL;
1063 ast_test_status_update(test,
"DNS resolution did not call resolver's resolve() method\n");
1064 res = AST_TEST_FAIL;
1069 ast_test_status_update(test,
"Resolver's cancel() method called for no reason\n");
1070 res = AST_TEST_FAIL;
1075 timeout.tv_sec += 10;
1076 ast_mutex_lock(&async_data->lock);
1077 while (!async_data->complete) {
1078 if (ast_cond_timedwait(&async_data->cond, &async_data->lock, &timeout) == ETIMEDOUT) {
1082 ast_mutex_unlock(&async_data->lock);
1084 if (!async_data->complete) {
1085 ast_test_status_update(test,
"Asynchronous resolution timed out\n");
1086 res = AST_TEST_FAIL;
1091 ast_test_status_update(test,
"Asynchronous resolution completed early?\n");
1092 res = AST_TEST_FAIL;
1098 ast_test_status_update(test,
"Asynchronous resolution yielded no result\n");
1099 res = AST_TEST_FAIL;
1104 ast_test_status_update(test,
"Asynchronous result had no records\n");
1105 res = AST_TEST_FAIL;
1111 resolver_data_cleanup();
1116 static void stub_callback(
const struct ast_dns_query *query)
1124 .
name =
"Ed Wood's Filmography",
1126 .resolve = fail_resolve,
1127 .cancel = stub_cancel,
1130 struct dns_resolve_data {
1136 { NULL, T_A, C_IN, stub_callback },
1137 {
"asterisk.org", -1, C_IN, stub_callback },
1138 {
"asterisk.org", 65536 + 1, C_IN, stub_callback },
1139 {
"asterisk.org", T_A, -1, stub_callback },
1140 {
"asterisk.org", T_A, 65536 + 1, stub_callback },
1141 {
"asterisk.org", T_A, C_IN, NULL },
1145 enum ast_test_result_state res = AST_TEST_PASS;
1150 info->name =
"resolver_resolve_async_off_nominal";
1151 info->category =
"/main/dns/";
1152 info->summary =
"Test off-nominal asynchronous DNS resolution";
1154 "This test performs several off-nominal asynchronous DNS resolutions:\n"
1155 "\t* Attempt resolution with NULL name\n"
1156 "\t* Attempt resolution with invalid RR type\n"
1157 "\t* Attempt resolution with invalid RR class\n"
1158 "\t* Attempt resolution with NULL callback pointer\n"
1159 "\t* Attempt resolution with resolver that returns an error";
1160 return AST_TEST_NOT_RUN;
1166 ast_test_status_update(test,
"Failed to register test resolver\n");
1167 return AST_TEST_FAIL;
1170 for (i = 0; i < ARRAY_LEN(resolves); ++i) {
1172 resolves[i].callback, NULL);
1174 ast_test_status_update(test,
"Successfully performed asynchronous resolution with invalid data\n");
1176 res = AST_TEST_FAIL;
1183 ast_test_status_update(test,
"Failed to register the DNS resolver\n");
1184 return AST_TEST_FAIL;
1192 ast_test_status_update(test,
"Successfully performed asynchronous resolution with invalid data\n");
1194 return AST_TEST_FAIL;
1205 enum ast_test_result_state res = AST_TEST_PASS;
1206 struct timespec timeout;
1210 info->name =
"resolver_resolve_async_cancel";
1211 info->category =
"/main/dns/";
1212 info->summary =
"Test canceling an asynchronous DNS resolution";
1214 "This test performs an asynchronous DNS resolution of a domain and then cancels\n"
1215 "the resolution. The goal of this test is to ensure that the cancel() callback of\n"
1216 "the resolver is called and that it properly interrupts the resolution such that no\n"
1217 "records are returned.";
1218 return AST_TEST_NOT_RUN;
1224 ast_test_status_update(test,
"Unable to register test resolver\n");
1225 return AST_TEST_FAIL;
1228 resolver_data_init();
1230 async_data = async_data_alloc();
1232 ast_test_status_update(test,
"Failed to allocate asynchronous data\n");
1233 res = AST_TEST_FAIL;
1239 ast_test_status_update(test,
"Asynchronous resolution of address failed\n");
1240 res = AST_TEST_FAIL;
1245 ast_test_status_update(test,
"DNS resolution did not call resolver's resolve() method\n");
1246 res = AST_TEST_FAIL;
1251 ast_test_status_update(test,
"Resolver's cancel() method called for no reason\n");
1252 res = AST_TEST_FAIL;
1258 if (!test_resolver_data.
canceled) {
1259 ast_test_status_update(test,
"Resolver's cancel() method was not called\n");
1260 res = AST_TEST_FAIL;
1265 timeout.tv_sec += 10;
1266 ast_mutex_lock(&async_data->lock);
1267 while (!async_data->complete) {
1268 if (ast_cond_timedwait(&async_data->cond, &async_data->lock, &timeout) == ETIMEDOUT) {
1272 ast_mutex_unlock(&async_data->lock);
1274 if (!async_data->complete) {
1275 ast_test_status_update(test,
"Asynchronous resolution timed out\n");
1276 res = AST_TEST_FAIL;
1281 ast_test_status_update(test,
"Resolution completed without cancelation\n");
1282 res = AST_TEST_FAIL;
1288 ast_test_status_update(test,
"Canceled resolution had a result\n");
1289 res = AST_TEST_FAIL;
1295 resolver_data_cleanup();
1299 static int unload_module(
void)
1301 AST_TEST_UNREGISTER(resolver_register_unregister);
1302 AST_TEST_UNREGISTER(resolver_register_off_nominal);
1303 AST_TEST_UNREGISTER(resolver_unregister_off_nominal);
1305 AST_TEST_UNREGISTER(resolver_set_result);
1306 AST_TEST_UNREGISTER(resolver_set_result_off_nominal);
1307 AST_TEST_UNREGISTER(resolver_add_record);
1308 AST_TEST_UNREGISTER(resolver_add_record_off_nominal);
1309 AST_TEST_UNREGISTER(resolver_resolve_sync);
1310 AST_TEST_UNREGISTER(resolver_resolve_sync_off_nominal);
1311 AST_TEST_UNREGISTER(resolver_resolve_async);
1312 AST_TEST_UNREGISTER(resolver_resolve_async_off_nominal);
1313 AST_TEST_UNREGISTER(resolver_resolve_async_cancel);
1318 static int load_module(
void)
1320 AST_TEST_REGISTER(resolver_register_unregister);
1321 AST_TEST_REGISTER(resolver_register_off_nominal);
1322 AST_TEST_REGISTER(resolver_unregister_off_nominal);
1324 AST_TEST_REGISTER(resolver_set_result);
1325 AST_TEST_REGISTER(resolver_set_result_off_nominal);
1326 AST_TEST_REGISTER(resolver_add_record);
1327 AST_TEST_REGISTER(resolver_add_record_off_nominal);
1328 AST_TEST_REGISTER(resolver_resolve_sync);
1329 AST_TEST_REGISTER(resolver_resolve_sync_off_nominal);
1330 AST_TEST_REGISTER(resolver_resolve_async);
1331 AST_TEST_REGISTER(resolver_resolve_async_off_nominal);
1332 AST_TEST_REGISTER(resolver_resolve_async_cancel);
int ast_dns_record_get_ttl(const struct ast_dns_record *record)
Get the TTL of a DNS record.
unsigned int ast_dns_result_get_secure(const struct ast_dns_result *result)
Get whether the result is secure or not.
const struct ast_dns_record * ast_dns_record_get_next(const struct ast_dns_record *record)
Get the next DNS record.
Data used by async result callback.
struct ast_dns_query * query
The underlying DNS query.
Asterisk main include file. File version handling, generic pbx functions.
const char * ast_dns_record_get_data(const struct ast_dns_record *record)
Retrieve the raw DNS record.
unsigned int ast_dns_result_get_bogus(const struct ast_dns_result *result)
Get whether the result is bogus or not.
int ast_dns_resolve(const char *name, int rr_type, int rr_class, struct ast_dns_result **result)
Synchronously resolve a DNS query.
void ast_dns_result_free(struct ast_dns_result *result)
Free the DNS result information.
int ast_dns_resolver_add_record(struct ast_dns_query *query, int rr_type, int rr_class, int ttl, const char *data, const size_t size)
Add a DNS record to the result of a DNS query.
void ast_dns_resolver_unregister(struct ast_dns_resolver *resolver)
Unregister a DNS resolver.
void(* ast_dns_resolve_callback)(const struct ast_dns_query *query)
Callback invoked when a query completes.
struct ast_dns_query_active * ast_dns_resolve_async(const char *name, int rr_type, int rr_class, ast_dns_resolve_callback callback, void *data)
Asynchronously resolve a DNS query.
const char * ast_dns_result_get_answer(const struct ast_dns_result *result)
Get the raw DNS answer from a DNS result.
void * ast_dns_resolver_get_data(const struct ast_dns_query *query)
Retrieve resolver specific data.
const char * name
The name of the resolver implementation.
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
static void cleanup(void)
Clean up any old apps that we don't need any more.
File-scoped data used during resolver tests.
void * ast_dns_query_get_data(const struct ast_dns_query *query)
Get the user specific data of a DNS query.
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
int ast_dns_resolver_register(struct ast_dns_resolver *resolver)
Register a DNS resolver.
The result of a DNS query.
void ast_dns_resolver_completed(struct ast_dns_query *query)
Mark a DNS query as having been completed.
struct ast_dns_result * ast_dns_query_get_result(const struct ast_dns_query *query)
Get the result information for a DNS query.
int ast_dns_resolver_set_data(struct ast_dns_query *query, void *data)
Set resolver specific data on a query.
DNS resolver implementation.
Internal DNS structure definitions.
const struct ast_dns_record * ast_dns_result_get_records(const struct ast_dns_result *result)
Get the first record of a DNS Result.
int ast_dns_resolve_cancel(struct ast_dns_query_active *active)
Cancel an asynchronous DNS resolution.
struct timespec ast_tsnow(void)
Returns current timespec. Meant to avoid calling ast_tvnow() just to create a timespec from the timev...
#define AST_TEST_DEFINE(hdr)
const char * ast_dns_result_get_canonical(const struct ast_dns_result *result)
Get the canonical name of the result.
int ast_dns_record_get_rr_class(const struct ast_dns_record *record)
Get the resource record class of a DNS record.
int ast_dns_record_get_rr_type(const struct ast_dns_record *record)
Get the resource record type of a DNS record.
#define ASTERISK_GPL_KEY
The text the key() function should return.
int ast_dns_resolver_set_result(struct ast_dns_query *query, unsigned int secure, unsigned int bogus, unsigned int rcode, const char *canonical, const char *answer, size_t answer_size)
Set result information for a DNS query.
Asterisk module definitions.
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
unsigned int ast_dns_result_get_rcode(const struct ast_dns_result *result)
Get the error rcode of a DN result.
Structure for mutex and tracking information.