Lines Matching refs:req
321 static void evdns_request_insert(struct request *req, struct request **head);
324 static int evdns_request_transmit(struct request *req);
327 static int search_try_next(struct request *const req);
332 static void request_submit(struct request *const req);
334 static int server_request_free(struct server_request *req);
335 static void server_request_free_answers(struct server_request *req);
434 struct request *req = req_head, *const started_at = req_head;
436 if (req) {
438 if (req->trans_id == trans_id) return req;
439 req = req->next;
440 } while (req != started_at);
487 struct request *req, *started_at;
518 req = req_head;
520 if (req) {
522 if (req->tx_count == 0 && req->ns == ns) {
525 req->ns = nameserver_pick();
527 req = req->next;
528 } while (req != started_at);
545 request_trans_id_set(struct request *const req, const u16 trans_id) {
546 req->trans_id = trans_id;
547 *((u16 *) req->request) = htons(trans_id);
554 request_finished(struct request *const req, struct request **head) {
556 if (req->next == req) {
560 req->next->prev = req->prev;
561 req->prev->next = req->next;
562 if (*head == req) *head = req->next;
567 (unsigned long) req);
568 evtimer_del(&req->timeout_event);
570 search_request_finished(req);
573 if (!req->request_appended) {
575 free(req->request);
581 free(req);
593 request_reissue(struct request *req) {
594 const struct nameserver *const last_ns = req->ns;
598 req->ns = nameserver_pick();
599 if (req->ns == last_ns) {
606 req->reissue_count++;
607 req->tx_count = 0;
608 req->transmit_me = 1;
619 struct request *req;
624 req = req_waiting_head;
627 req = req_waiting_head;
628 req->next->prev = req->prev;
629 req->prev->next = req->next;
630 req_waiting_head = req->next;
636 req->ns = nameserver_pick();
637 request_trans_id_set(req, transaction_id_pick());
639 evdns_request_insert(req, &req_head);
640 evdns_request_transmit(req);
646 reply_callback(struct request *const req, u32 ttl, u32 err, struct reply *reply) {
647 switch (req->request_type) {
650 req->user_callback(DNS_ERR_NONE, DNS_IPv4_A,
653 req->user_pointer);
655 req->user_callback(err, 0, 0, 0, NULL, req->user_pointer);
660 req->user_callback(DNS_ERR_NONE, DNS_PTR, 1, ttl,
661 &name, req->user_pointer);
663 req->user_callback(err, 0, 0, 0, NULL,
664 req->user_pointer);
669 req->user_callback(DNS_ERR_NONE, DNS_IPv6_AAAA,
672 req->user_pointer);
674 req->user_callback(err, 0, 0, 0, NULL, req->user_pointer);
682 reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) {
706 if (req->reissue_count < global_max_reissues) {
711 nameserver_failed(req->ns, msg);
712 if (!request_reissue(req)) return;
723 debug_ntoa(req->ns->address));
727 nameserver_up(req->ns);
730 if (req->search_state && req->request_type != TYPE_PTR) {
733 if (!search_try_next(req)) {
739 request_finished(req, &req_head);
745 reply_callback(req, 0, error, NULL);
746 request_finished(req, &req_head);
749 reply_callback(req, ttl, 0, reply);
750 nameserver_up(req->ns);
751 request_finished(req, &req_head);
823 struct request *req = NULL;
835 req = request_find_from_trans_id(trans_id);
836 if (!req) return -1;
860 if (name_parse(req->request, req->request_len, &k, cmp_name, sizeof(cmp_name))<0) \
866 reply.type = req->request_type;
893 if (req->request_type != TYPE_A) {
911 if (req->request_type != TYPE_PTR) {
922 if (req->request_type != TYPE_AAAA) {
945 reply_handle(req, flags, ttl_r, &reply);
948 if (req)
949 reply_handle(req, flags, 0, NULL);
1102 const struct request *req = req_head, *started_at;
1107 req = started_at = req_head;
1108 if (req) {
1110 if (req->trans_id == trans_id) break;
1111 req = req->next;
1112 } while (req != started_at);
1115 if (req == started_at) return trans_id;
1222 struct server_request *req = port->pending_replies;
1223 int r = sendto(port->socket, req->response, req->response_len, 0,
1224 (struct sockaddr*) &req->addr, req->addrlen);
1231 if (server_request_free(req)) {
1232 /* we released the last reference to req->port. */
1513 struct server_request *req = TO_SERVER_REQUEST(_req);
1517 if (req->response) /* have we already answered? */
1522 itemp = &req->answer;
1523 countp = &req->n_answer;
1526 itemp = &req->authority;
1527 countp = &req->n_authority;
1530 itemp = &req->additional;
1531 countp = &req->n_additional;
1579 evdns_server_request_add_a_reply(struct evdns_server_request *req, const char *name, int n, void *addrs, int ttl)
1582 req, EVDNS_ANSWER_SECTION, name, TYPE_A, CLASS_INET,
1588 evdns_server_request_add_aaaa_reply(struct evdns_server_request *req, const char *name, int n, void *addrs, int ttl)
1591 req, EVDNS_ANSWER_SECTION, name, TYPE_AAAA, CLASS_INET,
1597 evdns_server_request_add_ptr_reply(struct evdns_server_request *req, struct in_addr *in, const char *inaddr_name, const char *hostname, int ttl)
1613 req, EVDNS_ANSWER_SECTION, inaddr_name, TYPE_PTR, CLASS_INET,
1619 evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char *cname, int ttl)
1622 req, EVDNS_ANSWER_SECTION, name, TYPE_CNAME, CLASS_INET,
1628 evdns_server_request_format_response(struct server_request *req, int err)
1643 flags = req->base.flags;
1647 APPEND16(req->trans_id);
1649 APPEND16(req->base.nquestions);
1650 APPEND16(req->n_answer);
1651 APPEND16(req->n_authority);
1652 APPEND16(req->n_additional);
1655 for (i=0; i < req->base.nquestions; ++i) {
1656 const char *s = req->base.questions[i]->name;
1662 APPEND16(req->base.questions[i]->type);
1663 APPEND16(req->base.questions[i]->dns_question_class);
1670 item = req->answer;
1672 item = req->authority;
1674 item = req->additional;
1711 req->response_len = j;
1713 if (!(req->response = malloc(req->response_len))) {
1714 server_request_free_answers(req);
1718 memcpy(req->response, buf, req->response_len);
1719 server_request_free_answers(req);
1728 struct server_request *req = TO_SERVER_REQUEST(_req);
1729 struct evdns_server_port *port = req->port;
1731 if (!req->response) {
1732 if ((r = evdns_server_request_format_response(req, err))<0)
1736 r = sendto(port->socket, req->response, req->response_len, 0,
1737 (struct sockaddr*) &req->addr, req->addrlen);
1744 req->prev_pending = port->pending_replies->prev_pending;
1745 req->next_pending = port->pending_replies;
1746 req->prev_pending->next_pending =
1747 req->next_pending->prev_pending = req;
1749 req->prev_pending = req->next_pending = req;
1750 port->pending_replies = req;
1764 if (server_request_free(req))
1773 /* Free all storage held by RRs in req. */
1775 server_request_free_answers(struct server_request *req)
1781 list = &req->answer;
1783 list = &req->authority;
1785 list = &req->additional;
1800 /* Free all storage held by req, and remove links to it. */
1803 server_request_free(struct server_request *req)
1806 if (req->base.questions) {
1807 for (i = 0; i < req->base.nquestions; ++i)
1808 free(req->base.questions[i]);
1809 free(req->base.questions);
1812 if (req->port) {
1813 if (req->port->pending_replies == req) {
1814 if (req->next_pending)
1815 req->port->pending_replies = req->next_pending;
1817 req->port->pending_replies = NULL;
1819 rc = --req->port->refcnt;
1822 if (req->response) {
1823 free(req->response);
1826 server_request_free_answers(req);
1828 if (req->next_pending && req->next_pending != req) {
1829 req->next_pending->prev_pending = req->prev_pending;
1830 req->prev_pending->next_pending = req->next_pending;
1834 server_port_free(req->port);
1835 free(req);
1838 free(req);
1861 struct server_request *req = TO_SERVER_REQUEST(_req);
1862 server_request_free(req);
1870 struct server_request *req = TO_SERVER_REQUEST(_req);
1871 if (addr_len < (int)req->addrlen)
1873 memcpy(sa, &(req->addr), req->addrlen);
1874 return req->addrlen;
1884 struct request *const req = (struct request *) arg;
1890 req->ns->timedout++;
1891 if (req->ns->timedout > global_max_nameserver_timeout) {
1892 req->ns->timedout = 0;
1893 nameserver_failed(req->ns, "request timed out.");
1896 (void) evtimer_del(&req->timeout_event);
1897 if (req->tx_count >= global_max_retransmits) {
1899 reply_callback(req, 0, DNS_ERR_TIMEOUT, NULL);
1900 request_finished(req, &req_head);
1903 evdns_request_transmit(req);
1914 evdns_request_transmit_to(struct request *req, struct nameserver *server) {
1918 sin.sin_addr.s_addr = req->ns->address;
1919 sin.sin_port = req->ns->port;
1922 r = sendto(server->socket, req->request, req->request_len, 0,
1927 nameserver_failed(req->ns, strerror(err));
1929 } else if (r != (int)req->request_len) {
1943 evdns_request_transmit(struct request *req) {
1948 req->transmit_me = 1;
1949 if (req->trans_id == 0xffff) abort();
1951 if (req->ns->choked) {
1957 r = evdns_request_transmit_to(req, req->ns);
1961 req->ns->choked = 1;
1962 nameserver_write_waiting(req->ns, 1);
1971 "Setting timeout for request %lx", (unsigned long) req);
1972 if (evtimer_add(&req->timeout_event, &global_timeout) < 0) {
1975 (unsigned long) req);
1978 req->tx_count++;
1979 req->transmit_me = 0;
2000 struct request *req;
2006 req = request_new(TYPE_A, "www.google.com", DNS_QUERY_NO_SEARCH, nameserver_probe_callback, ns);
2007 if (!req) return;
2009 request_trans_id_set(req, transaction_id_pick());
2010 req->ns = ns;
2011 request_submit(req);
2022 struct request *const started_at = req_head, *req = req_head;
2025 if (req->transmit_me) {
2027 evdns_request_transmit(req);
2030 req = req->next;
2031 } while (req != started_at);
2057 struct request *req = req_head, *req_started_at = req_head;
2076 while (req) {
2077 struct request *next = req->next;
2078 req->tx_count = req->reissue_count = 0;
2079 req->ns = NULL;
2081 (void) evtimer_del(&req->timeout_event);
2082 req->trans_id = 0;
2083 req->transmit_me = 0;
2086 evdns_request_insert(req, &req_waiting_head);
2095 req = next;
2210 evdns_request_insert(struct request *req, struct request **head) {
2212 *head = req;
2213 req->next = req->prev = req;
2217 req->prev = (*head)->prev;
2218 req->prev->next = req;
2219 req->next = *head;
2220 (*head)->prev = req;
2243 struct request *const req =
2248 if (!req) return NULL;
2249 memset(req, 0, sizeof(struct request));
2251 evtimer_set(&req->timeout_event, evdns_request_timeout_callback, req);
2254 req->request = ((u8 *) req) + sizeof(struct request);
2256 req->request_appended = 1;
2258 type, CLASS_INET, req->request, request_max_len);
2261 req->request_len = rlen;
2262 req->trans_id = trans_id;
2263 req->tx_count = 0;
2264 req->request_type = type;
2265 req->user_pointer = user_ptr;
2266 req->user_callback = callback;
2267 req->ns = issuing_now ? nameserver_pick() : NULL;
2268 req->next = req->prev = NULL;
2270 return req;
2272 free(req);
2277 request_submit(struct request *const req) {
2278 if (req->ns) {
2281 evdns_request_insert(req, &req_head);
2283 evdns_request_transmit(req);
2285 evdns_request_insert(req, &req_waiting_head);
2295 struct request *const req =
2297 if (req == NULL)
2299 request_submit(req);
2311 struct request *const req =
2313 if (req == NULL)
2315 request_submit(req);
2324 struct request *req;
2334 req = request_new(TYPE_PTR, buf, flags, callback, ptr);
2335 if (!req) return 1;
2336 request_submit(req);
2344 struct request *req;
2358 req = request_new(TYPE_PTR, buf, flags, callback, ptr);
2359 if (!req) return 1;
2360 request_submit(req);
2526 struct request *req;
2528 req = request_new(type, name, flags, user_callback, user_arg);
2529 if (!req) return 1;
2530 req->search_index = -1;
2534 req = request_new(type, new_name, flags, user_callback, user_arg);
2536 if (!req) return 1;
2537 req->search_index = 0;
2539 req->search_origname = strdup(name);
2540 req->search_state = global_search_state;
2541 req->search_flags = flags;
2543 request_submit(req);
2546 struct request *const req = request_new(type, name, flags, user_callback, user_arg);
2547 if (!req) return 1;
2548 request_submit(req);
2559 search_try_next(struct request *const req) {
2560 if (req->search_state) {
2564 req->search_index++;
2565 if (req->search_index >= req->search_state->num_domains) {
2568 if (string_num_dots(req->search_origname) < req->search_state->ndots) {
2570 newreq = request_new(req->request_type, req->search_origname, req->search_flags, req->user_callback, req->user_pointer);
2571 log(EVDNS_LOG_DEBUG, "Search: trying raw query %s", req->search_origname);
2580 new_name = search_make_new(req->search_state, req->search_index, req->search_origname);
2582 log(EVDNS_LOG_DEBUG, "Search: now trying %s (%d)", new_name, req->search_index);
2583 newreq = request_new(req->request_type, new_name, req->search_flags, req->user_callback, req->user_pointer);
2586 newreq->search_origname = req->search_origname;
2587 req->search_origname = NULL;
2588 newreq->search_state = req->search_state;
2589 newreq->search_flags = req->search_flags;
2590 newreq->search_index = req->search_index;
2599 search_request_finished(struct request *const req) {
2600 if (req->search_state) {
2601 search_state_decref(req->search_state);
2602 req->search_state = NULL;
2604 if (req->search_origname) {
2605 free(req->search_origname);
2606 req->search_origname = NULL;
3095 evdns_server_callback(struct evdns_server_request *req, void *data)
3101 for (i = 0; i < req->nquestions; ++i) {
3103 if (req->questions[i]->type == EVDNS_TYPE_A &&
3104 req->questions[i]->dns_question_class == EVDNS_CLASS_INET) {
3105 printf(" -- replying for %s (A)\n", req->questions[i]->name);
3106 r = evdns_server_request_add_a_reply(req, req->questions[i]->name,
3110 } else if (req->questions[i]->type == EVDNS_TYPE_PTR &&
3111 req->questions[i]->dns_question_class == EVDNS_CLASS_INET) {
3112 printf(" -- replying for %s (PTR)\n", req->questions[i]->name);
3113 r = evdns_server_request_add_ptr_reply(req, NULL, req->questions[i]->name,
3116 printf(" -- skipping %s [%d %d]\n", req->questions[i]->name,
3117 req->questions[i]->type, req->questions[i]->dns_question_class);
3121 r = evdns_request_respond(req, 0);
