Lines Matching refs:req
131 #define ASSERT_VALID_REQUEST(req) \ argument
132 EVUTIL_ASSERT((req)->handle && (req)->handle->current_req == (req))
393 static void evdns_request_insert(struct request *req, struct request **head);
394 static void evdns_request_remove(struct request *req, struct request **head);
397 static int evdns_request_transmit(struct request *req);
400 static int search_try_next(struct evdns_request *const req);
405 static void request_submit(struct request *const req);
407 static int server_request_free(struct server_request *req);
408 static void server_request_free_answers(struct server_request *req);
470 struct request *req = REQ_HEAD(base, trans_id); in request_find_from_trans_id() local
471 struct request *const started_at = req; in request_find_from_trans_id()
475 if (req) { in request_find_from_trans_id()
477 if (req->trans_id == trans_id) return req; in request_find_from_trans_id()
478 req = req->next; in request_find_from_trans_id()
479 } while (req != started_at); in request_find_from_trans_id()
545 request_swap_ns(struct request *req, struct nameserver *ns) { in request_swap_ns() argument
546 if (ns && req->ns != ns) { in request_swap_ns()
547 EVUTIL_ASSERT(req->ns->requests_inflight > 0); in request_swap_ns()
548 req->ns->requests_inflight--; in request_swap_ns()
551 req->ns = ns; in request_swap_ns()
559 struct request *req, *started_at; in nameserver_failed() local
603 req = started_at = base->req_heads[i]; in nameserver_failed()
604 if (req) { in nameserver_failed()
606 if (req->tx_count == 0 && req->ns == ns) { in nameserver_failed()
609 request_swap_ns(req, nameserver_pick(base)); in nameserver_failed()
611 req = req->next; in nameserver_failed()
612 } while (req != started_at); in nameserver_failed()
639 request_trans_id_set(struct request *const req, const u16 trans_id) { in request_trans_id_set() argument
640 req->trans_id = trans_id; in request_trans_id_set()
641 *((u16 *) req->request) = htons(trans_id); in request_trans_id_set()
649 request_finished(struct request *const req, struct request **head, int free_handle) { in request_finished() argument
650 struct evdns_base *base = req->base; in request_finished()
653 ASSERT_VALID_REQUEST(req); in request_finished()
656 evdns_request_remove(req, head); in request_finished()
658 log(EVDNS_LOG_DEBUG, "Removing timeout for request %p", req); in request_finished()
660 evtimer_del(&req->timeout_event); in request_finished()
662 req->ns->requests_inflight--; in request_finished()
667 event_debug_unassign(&req->timeout_event); in request_finished()
669 if (req->ns && in request_finished()
670 req->ns->requests_inflight == 0 && in request_finished()
671 req->base->disable_when_inactive) { in request_finished()
672 event_del(&req->ns->event); in request_finished()
673 evtimer_del(&req->ns->timeout_event); in request_finished()
676 if (!req->request_appended) { in request_finished()
678 mm_free(req->request); in request_finished()
684 if (req->handle) { in request_finished()
685 EVUTIL_ASSERT(req->handle->current_req == req); in request_finished()
688 search_request_finished(req->handle); in request_finished()
689 req->handle->current_req = NULL; in request_finished()
690 if (! req->handle->pending_cb) { in request_finished()
693 mm_free(req->handle); in request_finished()
695 req->handle = NULL; /* If we have a bug, let's crash in request_finished()
698 req->handle->current_req = NULL; in request_finished()
702 mm_free(req); in request_finished()
715 request_reissue(struct request *req) { in request_reissue() argument
716 const struct nameserver *const last_ns = req->ns; in request_reissue()
717 ASSERT_LOCKED(req->base); in request_reissue()
718 ASSERT_VALID_REQUEST(req); in request_reissue()
722 request_swap_ns(req, nameserver_pick(req->base)); in request_reissue()
723 if (req->ns == last_ns) { in request_reissue()
730 req->reissue_count++; in request_reissue()
731 req->tx_count = 0; in request_reissue()
732 req->transmit_me = 1; in request_reissue()
747 struct request *req; in evdns_requests_pump_waiting_queue() local
750 req = base->req_waiting_head; in evdns_requests_pump_waiting_queue()
752 req->ns = nameserver_pick(base); in evdns_requests_pump_waiting_queue()
753 if (!req->ns) in evdns_requests_pump_waiting_queue()
757 req->ns->requests_inflight++; in evdns_requests_pump_waiting_queue()
759 evdns_request_remove(req, &base->req_waiting_head); in evdns_requests_pump_waiting_queue()
764 request_trans_id_set(req, transaction_id_pick(base)); in evdns_requests_pump_waiting_queue()
766 evdns_request_insert(req, &REQ_HEAD(base, req->trans_id)); in evdns_requests_pump_waiting_queue()
767 evdns_request_transmit(req); in evdns_requests_pump_waiting_queue()
830 reply_schedule_callback(struct request *const req, u32 ttl, u32 err, struct reply *reply) in reply_schedule_callback() argument
840 ASSERT_LOCKED(req->base); in reply_schedule_callback()
842 d->request_type = req->request_type; in reply_schedule_callback()
843 d->user_callback = req->user_callback; in reply_schedule_callback()
851 if (req->handle) { in reply_schedule_callback()
852 req->handle->pending_cb = 1; in reply_schedule_callback()
853 d->handle = req->handle; in reply_schedule_callback()
858 event_get_priority(&req->timeout_event), in reply_schedule_callback()
860 req->user_pointer); in reply_schedule_callback()
862 req->base->event_base, in reply_schedule_callback()
868 reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) { in reply_handle() argument
876 ASSERT_LOCKED(req->base); in reply_handle()
877 ASSERT_VALID_REQUEST(req); in reply_handle()
900 if (req->reissue_count < req->base->global_max_reissues) { in reply_handle()
904 nameserver_failed(req->ns, msg); in reply_handle()
905 if (!request_reissue(req)) return; in reply_handle()
917 (struct sockaddr *)&req->ns->address, in reply_handle()
920 evdns_request_timeout_callback(0, 0, req); in reply_handle()
924 if (req->handle == req->ns->probe_request) { in reply_handle()
926 req->ns->probe_request = NULL; in reply_handle()
929 nameserver_up(req->ns); in reply_handle()
932 if (req->handle->search_state && in reply_handle()
933 req->request_type != TYPE_PTR) { in reply_handle()
936 if (!search_try_next(req->handle)) { in reply_handle()
947 reply_schedule_callback(req, ttl, error, NULL); in reply_handle()
948 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1); in reply_handle()
951 reply_schedule_callback(req, ttl, 0, reply); in reply_handle()
952 if (req->handle == req->ns->probe_request) in reply_handle()
953 req->ns->probe_request = NULL; /* Avoid double-free */ in reply_handle()
954 nameserver_up(req->ns); in reply_handle()
955 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1); in reply_handle()
1028 struct request *req = NULL; in reply_parse() local
1042 req = request_find_from_trans_id(base, trans_id); in reply_parse()
1043 if (!req) return -1; in reply_parse()
1044 EVUTIL_ASSERT(req->base == base); in reply_parse()
1064 reply.type = req->request_type; in reply_parse()
1076 if (name_parse(req->request, req->request_len, &k, in reply_parse()
1110 if (req->request_type != TYPE_A) { in reply_parse()
1128 if (req->request_type != TYPE_PTR) { in reply_parse()
1139 if (!req->put_cname_in_ptr || *req->put_cname_in_ptr) { in reply_parse()
1145 *req->put_cname_in_ptr = mm_strdup(cname); in reply_parse()
1148 if (req->request_type != TYPE_AAAA) { in reply_parse()
1204 reply_handle(req, flags, ttl_r, &reply); in reply_parse()
1207 if (req) in reply_parse()
1208 reply_handle(req, flags, 0, NULL); in reply_parse()
1436 struct server_request *req = port->pending_replies; in server_port_flush() local
1438 while (req) { in server_port_flush()
1439 int r = sendto(port->socket, req->response, (int)req->response_len, 0, in server_port_flush()
1440 (struct sockaddr*) &req->addr, (ev_socklen_t)req->addrlen); in server_port_flush()
1447 if (server_request_free(req)) { in server_port_flush()
1451 EVUTIL_ASSERT(req != port->pending_replies); in server_port_flush()
1452 req = port->pending_replies; in server_port_flush()
1761 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_add_reply() local
1766 EVDNS_LOCK(req->port); in evdns_server_request_add_reply()
1767 if (req->response) /* have we already answered? */ in evdns_server_request_add_reply()
1772 itemp = &req->answer; in evdns_server_request_add_reply()
1773 countp = &req->n_answer; in evdns_server_request_add_reply()
1776 itemp = &req->authority; in evdns_server_request_add_reply()
1777 countp = &req->n_authority; in evdns_server_request_add_reply()
1780 itemp = &req->additional; in evdns_server_request_add_reply()
1781 countp = &req->n_additional; in evdns_server_request_add_reply()
1826 EVDNS_UNLOCK(req->port); in evdns_server_request_add_reply()
1832 evdns_server_request_add_a_reply(struct evdns_server_request *req, const char *name, int n, const v… in evdns_server_request_add_a_reply() argument
1835 req, EVDNS_ANSWER_SECTION, name, TYPE_A, CLASS_INET, in evdns_server_request_add_a_reply()
1841 evdns_server_request_add_aaaa_reply(struct evdns_server_request *req, const char *name, int n, cons… in evdns_server_request_add_aaaa_reply() argument
1844 req, EVDNS_ANSWER_SECTION, name, TYPE_AAAA, CLASS_INET, in evdns_server_request_add_aaaa_reply()
1850 evdns_server_request_add_ptr_reply(struct evdns_server_request *req, struct in_addr *in, const char… in evdns_server_request_add_ptr_reply() argument
1868 req, EVDNS_ANSWER_SECTION, inaddr_name, TYPE_PTR, CLASS_INET, in evdns_server_request_add_ptr_reply()
1874 evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char… in evdns_server_request_add_cname_reply() argument
1877 req, EVDNS_ANSWER_SECTION, name, TYPE_CNAME, CLASS_INET, in evdns_server_request_add_cname_reply()
1885 struct server_request *req = TO_SERVER_REQUEST(exreq); in evdns_server_request_set_flags() local
1886 req->base.flags &= ~(EVDNS_FLAGS_AA|EVDNS_FLAGS_RD); in evdns_server_request_set_flags()
1887 req->base.flags |= flags; in evdns_server_request_set_flags()
1891 evdns_server_request_format_response(struct server_request *req, int err) in evdns_server_request_format_response() argument
1906 flags = req->base.flags; in evdns_server_request_format_response()
1910 APPEND16(req->trans_id); in evdns_server_request_format_response()
1912 APPEND16(req->base.nquestions); in evdns_server_request_format_response()
1913 APPEND16(req->n_answer); in evdns_server_request_format_response()
1914 APPEND16(req->n_authority); in evdns_server_request_format_response()
1915 APPEND16(req->n_additional); in evdns_server_request_format_response()
1918 for (i=0; i < req->base.nquestions; ++i) { in evdns_server_request_format_response()
1919 const char *s = req->base.questions[i]->name; in evdns_server_request_format_response()
1925 APPEND16(req->base.questions[i]->type); in evdns_server_request_format_response()
1926 APPEND16(req->base.questions[i]->dns_question_class); in evdns_server_request_format_response()
1933 item = req->answer; in evdns_server_request_format_response()
1935 item = req->authority; in evdns_server_request_format_response()
1937 item = req->additional; in evdns_server_request_format_response()
1974 req->response_len = j; in evdns_server_request_format_response()
1976 if (!(req->response = mm_malloc(req->response_len))) { in evdns_server_request_format_response()
1977 server_request_free_answers(req); in evdns_server_request_format_response()
1981 memcpy(req->response, buf, req->response_len); in evdns_server_request_format_response()
1982 server_request_free_answers(req); in evdns_server_request_format_response()
1991 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_respond() local
1992 struct evdns_server_port *port = req->port; in evdns_server_request_respond()
1996 if (!req->response) { in evdns_server_request_respond()
1997 if ((r = evdns_server_request_format_response(req, err))<0) in evdns_server_request_respond()
2001 r = sendto(port->socket, req->response, (int)req->response_len, 0, in evdns_server_request_respond()
2002 (struct sockaddr*) &req->addr, (ev_socklen_t)req->addrlen); in evdns_server_request_respond()
2009 req->prev_pending = port->pending_replies->prev_pending; in evdns_server_request_respond()
2010 req->next_pending = port->pending_replies; in evdns_server_request_respond()
2011 req->prev_pending->next_pending = in evdns_server_request_respond()
2012 req->next_pending->prev_pending = req; in evdns_server_request_respond()
2014 req->prev_pending = req->next_pending = req; in evdns_server_request_respond()
2015 port->pending_replies = req; in evdns_server_request_respond()
2030 if (server_request_free(req)) { in evdns_server_request_respond()
2046 server_request_free_answers(struct server_request *req) in server_request_free_answers() argument
2052 list = &req->answer; in server_request_free_answers()
2054 list = &req->authority; in server_request_free_answers()
2056 list = &req->additional; in server_request_free_answers()
2074 server_request_free(struct server_request *req) in server_request_free() argument
2077 if (req->base.questions) { in server_request_free()
2078 for (i = 0; i < req->base.nquestions; ++i) in server_request_free()
2079 mm_free(req->base.questions[i]); in server_request_free()
2080 mm_free(req->base.questions); in server_request_free()
2083 if (req->port) { in server_request_free()
2084 EVDNS_LOCK(req->port); in server_request_free()
2086 if (req->port->pending_replies == req) { in server_request_free()
2087 if (req->next_pending && req->next_pending != req) in server_request_free()
2088 req->port->pending_replies = req->next_pending; in server_request_free()
2090 req->port->pending_replies = NULL; in server_request_free()
2092 rc = --req->port->refcnt; in server_request_free()
2095 if (req->response) { in server_request_free()
2096 mm_free(req->response); in server_request_free()
2099 server_request_free_answers(req); in server_request_free()
2101 if (req->next_pending && req->next_pending != req) { in server_request_free()
2102 req->next_pending->prev_pending = req->prev_pending; in server_request_free()
2103 req->prev_pending->next_pending = req->next_pending; in server_request_free()
2107 EVDNS_UNLOCK(req->port); /* ????? nickm */ in server_request_free()
2108 server_port_free(req->port); in server_request_free()
2109 mm_free(req); in server_request_free()
2113 EVDNS_UNLOCK(req->port); in server_request_free()
2114 mm_free(req); in server_request_free()
2139 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_drop() local
2140 server_request_free(req); in evdns_server_request_drop()
2148 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_get_requesting_addr() local
2149 if (addr_len < (int)req->addrlen) in evdns_server_request_get_requesting_addr()
2151 memcpy(sa, &(req->addr), req->addrlen); in evdns_server_request_get_requesting_addr()
2152 return req->addrlen; in evdns_server_request_get_requesting_addr()
2162 struct request *const req = (struct request *) arg; in evdns_request_timeout_callback() local
2163 struct evdns_base *base = req->base; in evdns_request_timeout_callback()
2171 if (req->tx_count >= req->base->global_max_retransmits) { in evdns_request_timeout_callback()
2172 struct nameserver *ns = req->ns; in evdns_request_timeout_callback()
2175 arg, req->tx_count); in evdns_request_timeout_callback()
2176 reply_schedule_callback(req, 0, DNS_ERR_TIMEOUT, NULL); in evdns_request_timeout_callback()
2178 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1); in evdns_request_timeout_callback()
2183 arg, req->tx_count); in evdns_request_timeout_callback()
2184 (void) evtimer_del(&req->timeout_event); in evdns_request_timeout_callback()
2185 request_swap_ns(req, nameserver_pick(base)); in evdns_request_timeout_callback()
2186 evdns_request_transmit(req); in evdns_request_timeout_callback()
2188 req->ns->timedout++; in evdns_request_timeout_callback()
2189 if (req->ns->timedout > req->base->global_max_nameserver_timeout) { in evdns_request_timeout_callback()
2190 req->ns->timedout = 0; in evdns_request_timeout_callback()
2191 nameserver_failed(req->ns, "request timed out."); in evdns_request_timeout_callback()
2205 evdns_request_transmit_to(struct request *req, struct nameserver *server) { in evdns_request_transmit_to() argument
2207 ASSERT_LOCKED(req->base); in evdns_request_transmit_to()
2208 ASSERT_VALID_REQUEST(req); in evdns_request_transmit_to()
2211 req->base->disable_when_inactive && in evdns_request_transmit_to()
2216 r = sendto(server->socket, (void*)req->request, req->request_len, 0, in evdns_request_transmit_to()
2222 nameserver_failed(req->ns, evutil_socket_error_to_string(err)); in evdns_request_transmit_to()
2224 } else if (r != (int)req->request_len) { in evdns_request_transmit_to()
2238 evdns_request_transmit(struct request *req) { in evdns_request_transmit() argument
2241 ASSERT_LOCKED(req->base); in evdns_request_transmit()
2242 ASSERT_VALID_REQUEST(req); in evdns_request_transmit()
2245 req->transmit_me = 1; in evdns_request_transmit()
2246 EVUTIL_ASSERT(req->trans_id != 0xffff); in evdns_request_transmit()
2248 if (!req->ns) in evdns_request_transmit()
2254 if (req->ns->choked) { in evdns_request_transmit()
2260 r = evdns_request_transmit_to(req, req->ns); in evdns_request_transmit()
2264 req->ns->choked = 1; in evdns_request_transmit()
2265 nameserver_write_waiting(req->ns, 1); in evdns_request_transmit()
2275 "Setting timeout for request %p, sent to nameserver %p", req, req->ns); in evdns_request_transmit()
2276 if (evtimer_add(&req->timeout_event, &req->base->global_timeout) < 0) { in evdns_request_transmit()
2279 req); in evdns_request_transmit()
2282 req->tx_count++; in evdns_request_transmit()
2283 req->transmit_me = 0; in evdns_request_transmit()
2317 struct request *req; in nameserver_send_probe() local
2329 …req = request_new(ns->base, handle, TYPE_A, "google.com", DNS_QUERY_NO_SEARCH, nameserver_probe_ca… in nameserver_send_probe()
2330 if (!req) { in nameserver_send_probe()
2336 request_trans_id_set(req, transaction_id_pick(ns->base)); in nameserver_send_probe()
2337 req->ns = ns; in nameserver_send_probe()
2338 request_submit(req); in nameserver_send_probe()
2352 struct request *const started_at = base->req_heads[i], *req = started_at; in evdns_transmit() local
2355 if (req->transmit_me) { in evdns_transmit()
2357 evdns_request_transmit(req); in evdns_transmit()
2360 req = req->next; in evdns_transmit()
2361 } while (req != started_at); in evdns_transmit()
2428 struct request *req, *req_started_at; in evdns_base_clear_nameservers_and_suspend() local
2429 req = req_started_at = base->req_heads[i]; in evdns_base_clear_nameservers_and_suspend()
2430 while (req) { in evdns_base_clear_nameservers_and_suspend()
2431 struct request *next = req->next; in evdns_base_clear_nameservers_and_suspend()
2432 req->tx_count = req->reissue_count = 0; in evdns_base_clear_nameservers_and_suspend()
2433 req->ns = NULL; in evdns_base_clear_nameservers_and_suspend()
2435 (void) evtimer_del(&req->timeout_event); in evdns_base_clear_nameservers_and_suspend()
2436 req->trans_id = 0; in evdns_base_clear_nameservers_and_suspend()
2437 req->transmit_me = 0; in evdns_base_clear_nameservers_and_suspend()
2440 evdns_request_insert(req, &base->req_waiting_head); in evdns_base_clear_nameservers_and_suspend()
2449 req = next; in evdns_base_clear_nameservers_and_suspend()
2683 evdns_request_remove(struct request *req, struct request **head) in evdns_request_remove() argument
2685 ASSERT_LOCKED(req->base); in evdns_request_remove()
2686 ASSERT_VALID_REQUEST(req); in evdns_request_remove()
2696 if (ptr == req) { in evdns_request_remove()
2704 EVUTIL_ASSERT(req->next); in evdns_request_remove()
2708 if (req->next == req) { in evdns_request_remove()
2712 req->next->prev = req->prev; in evdns_request_remove()
2713 req->prev->next = req->next; in evdns_request_remove()
2714 if (*head == req) *head = req->next; in evdns_request_remove()
2716 req->next = req->prev = NULL; in evdns_request_remove()
2721 evdns_request_insert(struct request *req, struct request **head) { in evdns_request_insert() argument
2722 ASSERT_LOCKED(req->base); in evdns_request_insert()
2723 ASSERT_VALID_REQUEST(req); in evdns_request_insert()
2725 *head = req; in evdns_request_insert()
2726 req->next = req->prev = req; in evdns_request_insert()
2730 req->prev = (*head)->prev; in evdns_request_insert()
2731 req->prev->next = req; in evdns_request_insert()
2732 req->next = *head; in evdns_request_insert()
2733 (*head)->prev = req; in evdns_request_insert()
2758 struct request *const req = in request_new() local
2766 if (!req) return NULL; in request_new()
2769 mm_free(req); in request_new()
2773 memset(req, 0, sizeof(struct request)); in request_new()
2774 req->base = base; in request_new()
2776 evtimer_assign(&req->timeout_event, req->base->event_base, evdns_request_timeout_callback, req); in request_new()
2795 req->request = ((u8 *) req) + sizeof(struct request); in request_new()
2797 req->request_appended = 1; in request_new()
2799 type, CLASS_INET, req->request, request_max_len); in request_new()
2803 req->request_len = rlen; in request_new()
2804 req->trans_id = trans_id; in request_new()
2805 req->tx_count = 0; in request_new()
2806 req->request_type = type; in request_new()
2807 req->user_pointer = user_ptr; in request_new()
2808 req->user_callback = callback; in request_new()
2809 req->ns = issuing_now ? nameserver_pick(base) : NULL; in request_new()
2810 req->next = req->prev = NULL; in request_new()
2811 req->handle = handle; in request_new()
2813 handle->current_req = req; in request_new()
2817 return req; in request_new()
2819 mm_free(req); in request_new()
2824 request_submit(struct request *const req) { in request_submit() argument
2825 struct evdns_base *base = req->base; in request_submit()
2827 ASSERT_VALID_REQUEST(req); in request_submit()
2828 if (req->ns) { in request_submit()
2831 evdns_request_insert(req, &REQ_HEAD(base, req->trans_id)); in request_submit()
2834 req->ns->requests_inflight++; in request_submit()
2836 evdns_request_transmit(req); in request_submit()
2838 evdns_request_insert(req, &base->req_waiting_head); in request_submit()
2847 struct request *req; in evdns_cancel_request() local
2865 req = handle->current_req; in evdns_cancel_request()
2866 ASSERT_VALID_REQUEST(req); in evdns_cancel_request()
2868 reply_schedule_callback(req, 0, DNS_ERR_CANCEL, NULL); in evdns_cancel_request()
2869 if (req->ns) { in evdns_cancel_request()
2871 request_finished(req, &REQ_HEAD(base, req->trans_id), 1); in evdns_cancel_request()
2874 request_finished(req, &base->req_waiting_head, 1); in evdns_cancel_request()
2884 struct request *req; in evdns_base_resolve_ipv4() local
2891 req = in evdns_base_resolve_ipv4()
2894 if (req) in evdns_base_resolve_ipv4()
2895 request_submit(req); in evdns_base_resolve_ipv4()
2923 struct request *req; in evdns_base_resolve_ipv6() local
2930 req = request_new(base, handle, TYPE_AAAA, name, flags, in evdns_base_resolve_ipv6()
2932 if (req) in evdns_base_resolve_ipv6()
2933 request_submit(req); in evdns_base_resolve_ipv6()
2956 struct request *req; in evdns_base_resolve_reverse() local
2970 req = request_new(base, handle, TYPE_PTR, buf, flags, callback, ptr); in evdns_base_resolve_reverse()
2971 if (req) in evdns_base_resolve_reverse()
2972 request_submit(req); in evdns_base_resolve_reverse()
2992 struct request *req; in evdns_base_resolve_reverse_ipv6() local
3010 req = request_new(base, handle, TYPE_PTR, buf, flags, callback, ptr); in evdns_base_resolve_reverse_ipv6()
3011 if (req) in evdns_base_resolve_reverse_ipv6()
3012 request_submit(req); in evdns_base_resolve_reverse_ipv6()
3216 struct request *req; in search_request_new() local
3218 req = request_new(base, handle, type, name, flags, user_callback, user_arg); in search_request_new()
3219 if (!req) return NULL; in search_request_new()
3224 req = request_new(base, handle, type, new_name, flags, user_callback, user_arg); in search_request_new()
3226 if (!req) return NULL; in search_request_new()
3233 if (req) in search_request_new()
3234 mm_free(req); in search_request_new()
3240 request_submit(req); in search_request_new()
3241 return req; in search_request_new()
3243 struct request *const req = request_new(base, handle, type, name, flags, user_callback, user_arg); in search_request_new() local
3244 if (!req) return NULL; in search_request_new()
3245 request_submit(req); in search_request_new()
3246 return req; in search_request_new()
3257 struct request *req = handle->current_req; in search_try_next() local
3258 struct evdns_base *base = req->base; in search_try_next()
3270 …ewreq = request_new(base, NULL, req->request_type, handle->search_origname, handle->search_flags, … in search_try_next()
3283 …newreq = request_new(base, NULL, req->request_type, new_name, handle->search_flags, req->user_call… in search_try_next()
3291 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 0); in search_try_next()
3389 struct request **old_heads = base->req_heads, **new_heads, *req; in evdns_base_set_max_requests_inflight() local
3403 req = old_heads[i]; in evdns_base_set_max_requests_inflight()
3404 evdns_request_remove(req, &old_heads[i]); in evdns_base_set_max_requests_inflight()
3405 evdns_request_insert(req, &new_heads[req->trans_id % n_heads]); in evdns_base_set_max_requests_inflight()
4389 struct getaddrinfo_subrequest *req = arg; in evdns_getaddrinfo_gotresolve() local
4403 EVUTIL_ASSERT(req->type == DNS_IPv4_A || req->type == DNS_IPv6_AAAA); in evdns_getaddrinfo_gotresolve()
4404 if (req->type == DNS_IPv4_A) { in evdns_getaddrinfo_gotresolve()
4405 data = EVUTIL_UPCAST(req, struct evdns_getaddrinfo_request, ipv4_request); in evdns_getaddrinfo_gotresolve()
4408 data = EVUTIL_UPCAST(req, struct evdns_getaddrinfo_request, ipv6_request); in evdns_getaddrinfo_gotresolve()
4416 if (req->type == DNS_IPv4_A) in evdns_getaddrinfo_gotresolve()
4430 req->r = NULL; in evdns_getaddrinfo_gotresolve()
4551 if (req->type == DNS_IPv4_A) in evdns_getaddrinfo_gotresolve()