Lines Matching refs:req
132 #define ASSERT_VALID_REQUEST(req) \ argument
133 EVUTIL_ASSERT((req)->handle && (req)->handle->current_req == (req))
397 static void evdns_request_insert(struct request *req, struct request **head);
398 static void evdns_request_remove(struct request *req, struct request **head);
401 static int evdns_request_transmit(struct request *req);
404 static int search_try_next(struct evdns_request *const req);
409 static void request_submit(struct request *const req);
411 static int server_request_free(struct server_request *req);
412 static void server_request_free_answers(struct server_request *req);
474 struct request *req = REQ_HEAD(base, trans_id); in request_find_from_trans_id() local
475 struct request *const started_at = req; in request_find_from_trans_id()
479 if (req) { in request_find_from_trans_id()
481 if (req->trans_id == trans_id) return req; in request_find_from_trans_id()
482 req = req->next; in request_find_from_trans_id()
483 } while (req != started_at); in request_find_from_trans_id()
549 request_swap_ns(struct request *req, struct nameserver *ns) { in request_swap_ns() argument
550 if (ns && req->ns != ns) { in request_swap_ns()
551 EVUTIL_ASSERT(req->ns->requests_inflight > 0); in request_swap_ns()
552 req->ns->requests_inflight--; in request_swap_ns()
555 req->ns = ns; in request_swap_ns()
563 struct request *req, *started_at; in nameserver_failed() local
607 req = started_at = base->req_heads[i]; in nameserver_failed()
608 if (req) { in nameserver_failed()
610 if (req->tx_count == 0 && req->ns == ns) { in nameserver_failed()
613 request_swap_ns(req, nameserver_pick(base)); in nameserver_failed()
615 req = req->next; in nameserver_failed()
616 } while (req != started_at); in nameserver_failed()
643 request_trans_id_set(struct request *const req, const u16 trans_id) { in request_trans_id_set() argument
644 req->trans_id = trans_id; in request_trans_id_set()
645 *((u16 *) req->request) = htons(trans_id); in request_trans_id_set()
653 request_finished(struct request *const req, struct request **head, int free_handle) { in request_finished() argument
654 struct evdns_base *base = req->base; in request_finished()
657 ASSERT_VALID_REQUEST(req); in request_finished()
660 evdns_request_remove(req, head); in request_finished()
662 log(EVDNS_LOG_DEBUG, "Removing timeout for request %p", req); in request_finished()
664 evtimer_del(&req->timeout_event); in request_finished()
666 req->ns->requests_inflight--; in request_finished()
671 event_debug_unassign(&req->timeout_event); in request_finished()
673 if (req->ns && in request_finished()
674 req->ns->requests_inflight == 0 && in request_finished()
675 req->base->disable_when_inactive) { in request_finished()
676 event_del(&req->ns->event); in request_finished()
677 evtimer_del(&req->ns->timeout_event); in request_finished()
680 if (!req->request_appended) { in request_finished()
682 mm_free(req->request); in request_finished()
688 if (req->handle) { in request_finished()
689 EVUTIL_ASSERT(req->handle->current_req == req); in request_finished()
692 search_request_finished(req->handle); in request_finished()
693 req->handle->current_req = NULL; in request_finished()
694 if (! req->handle->pending_cb) { in request_finished()
697 mm_free(req->handle); in request_finished()
699 req->handle = NULL; /* If we have a bug, let's crash in request_finished()
702 req->handle->current_req = NULL; in request_finished()
706 mm_free(req); in request_finished()
719 request_reissue(struct request *req) { in request_reissue() argument
720 const struct nameserver *const last_ns = req->ns; in request_reissue()
721 ASSERT_LOCKED(req->base); in request_reissue()
722 ASSERT_VALID_REQUEST(req); in request_reissue()
726 request_swap_ns(req, nameserver_pick(req->base)); in request_reissue()
727 if (req->ns == last_ns) { in request_reissue()
734 req->reissue_count++; in request_reissue()
735 req->tx_count = 0; in request_reissue()
736 req->transmit_me = 1; in request_reissue()
751 struct request *req; in evdns_requests_pump_waiting_queue() local
754 req = base->req_waiting_head; in evdns_requests_pump_waiting_queue()
756 req->ns = nameserver_pick(base); in evdns_requests_pump_waiting_queue()
757 if (!req->ns) in evdns_requests_pump_waiting_queue()
761 req->ns->requests_inflight++; in evdns_requests_pump_waiting_queue()
763 evdns_request_remove(req, &base->req_waiting_head); in evdns_requests_pump_waiting_queue()
768 request_trans_id_set(req, transaction_id_pick(base)); in evdns_requests_pump_waiting_queue()
770 evdns_request_insert(req, &REQ_HEAD(base, req->trans_id)); in evdns_requests_pump_waiting_queue()
771 evdns_request_transmit(req); in evdns_requests_pump_waiting_queue()
834 reply_schedule_callback(struct request *const req, u32 ttl, u32 err, struct reply *reply) in reply_schedule_callback() argument
844 ASSERT_LOCKED(req->base); in reply_schedule_callback()
846 d->request_type = req->request_type; in reply_schedule_callback()
847 d->user_callback = req->user_callback; in reply_schedule_callback()
855 if (req->handle) { in reply_schedule_callback()
856 req->handle->pending_cb = 1; in reply_schedule_callback()
857 d->handle = req->handle; in reply_schedule_callback()
862 event_get_priority(&req->timeout_event), in reply_schedule_callback()
864 req->user_pointer); in reply_schedule_callback()
866 req->base->event_base, in reply_schedule_callback()
885 reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) { in reply_handle() argument
893 ASSERT_LOCKED(req->base); in reply_handle()
894 ASSERT_VALID_REQUEST(req); in reply_handle()
917 if (req->reissue_count < req->base->global_max_reissues) { in reply_handle()
921 nameserver_failed(req->ns, msg); in reply_handle()
922 if (!request_reissue(req)) return; in reply_handle()
934 (struct sockaddr *)&req->ns->address, in reply_handle()
937 evdns_request_timeout_callback(0, 0, req); in reply_handle()
941 if (req->handle == req->ns->probe_request) { in reply_handle()
943 req->ns->probe_request = NULL; in reply_handle()
946 nameserver_up(req->ns); in reply_handle()
949 if (req->handle->search_state && in reply_handle()
950 req->request_type != TYPE_PTR) { in reply_handle()
953 if (!search_try_next(req->handle)) { in reply_handle()
964 reply_schedule_callback(req, ttl, error, NULL); in reply_handle()
965 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1); in reply_handle()
968 reply_schedule_callback(req, ttl, 0, reply); in reply_handle()
969 if (req->handle == req->ns->probe_request) in reply_handle()
970 req->ns->probe_request = NULL; /* Avoid double-free */ in reply_handle()
971 nameserver_up(req->ns); in reply_handle()
972 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1); in reply_handle()
1045 struct request *req = NULL; in reply_parse() local
1059 req = request_find_from_trans_id(base, trans_id); in reply_parse()
1060 if (!req) return -1; in reply_parse()
1061 EVUTIL_ASSERT(req->base == base); in reply_parse()
1081 reply.type = req->request_type; in reply_parse()
1093 if (name_parse(req->request, req->request_len, &k, in reply_parse()
1127 if (req->request_type != TYPE_A) { in reply_parse()
1145 if (req->request_type != TYPE_PTR) { in reply_parse()
1156 if (!req->put_cname_in_ptr || *req->put_cname_in_ptr) { in reply_parse()
1162 *req->put_cname_in_ptr = mm_strdup(cname); in reply_parse()
1165 if (req->request_type != TYPE_AAAA) { in reply_parse()
1221 reply_handle(req, flags, ttl_r, &reply); in reply_parse()
1224 if (req) in reply_parse()
1225 reply_handle(req, flags, 0, NULL); in reply_parse()
1451 struct server_request *req = port->pending_replies; in server_port_flush() local
1453 while (req) { in server_port_flush()
1454 int r = sendto(port->socket, req->response, (int)req->response_len, 0, in server_port_flush()
1455 (struct sockaddr*) &req->addr, (ev_socklen_t)req->addrlen); in server_port_flush()
1462 if (server_request_free(req)) { in server_port_flush()
1466 EVUTIL_ASSERT(req != port->pending_replies); in server_port_flush()
1467 req = port->pending_replies; in server_port_flush()
1777 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_add_reply() local
1782 EVDNS_LOCK(req->port); in evdns_server_request_add_reply()
1783 if (req->response) /* have we already answered? */ in evdns_server_request_add_reply()
1788 itemp = &req->answer; in evdns_server_request_add_reply()
1789 countp = &req->n_answer; in evdns_server_request_add_reply()
1792 itemp = &req->authority; in evdns_server_request_add_reply()
1793 countp = &req->n_authority; in evdns_server_request_add_reply()
1796 itemp = &req->additional; in evdns_server_request_add_reply()
1797 countp = &req->n_additional; in evdns_server_request_add_reply()
1842 EVDNS_UNLOCK(req->port); in evdns_server_request_add_reply()
1848 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
1851 req, EVDNS_ANSWER_SECTION, name, TYPE_A, CLASS_INET, in evdns_server_request_add_a_reply()
1857 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
1860 req, EVDNS_ANSWER_SECTION, name, TYPE_AAAA, CLASS_INET, in evdns_server_request_add_aaaa_reply()
1866 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
1884 req, EVDNS_ANSWER_SECTION, inaddr_name, TYPE_PTR, CLASS_INET, in evdns_server_request_add_ptr_reply()
1890 evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char… in evdns_server_request_add_cname_reply() argument
1893 req, EVDNS_ANSWER_SECTION, name, TYPE_CNAME, CLASS_INET, in evdns_server_request_add_cname_reply()
1901 struct server_request *req = TO_SERVER_REQUEST(exreq); in evdns_server_request_set_flags() local
1902 req->base.flags &= ~(EVDNS_FLAGS_AA|EVDNS_FLAGS_RD); in evdns_server_request_set_flags()
1903 req->base.flags |= flags; in evdns_server_request_set_flags()
1907 evdns_server_request_format_response(struct server_request *req, int err) in evdns_server_request_format_response() argument
1922 flags = req->base.flags; in evdns_server_request_format_response()
1926 APPEND16(req->trans_id); in evdns_server_request_format_response()
1928 APPEND16(req->base.nquestions); in evdns_server_request_format_response()
1929 APPEND16(req->n_answer); in evdns_server_request_format_response()
1930 APPEND16(req->n_authority); in evdns_server_request_format_response()
1931 APPEND16(req->n_additional); in evdns_server_request_format_response()
1934 for (i=0; i < req->base.nquestions; ++i) { in evdns_server_request_format_response()
1935 const char *s = req->base.questions[i]->name; in evdns_server_request_format_response()
1941 APPEND16(req->base.questions[i]->type); in evdns_server_request_format_response()
1942 APPEND16(req->base.questions[i]->dns_question_class); in evdns_server_request_format_response()
1949 item = req->answer; in evdns_server_request_format_response()
1951 item = req->authority; in evdns_server_request_format_response()
1953 item = req->additional; in evdns_server_request_format_response()
1990 req->response_len = j; in evdns_server_request_format_response()
1992 if (!(req->response = mm_malloc(req->response_len))) { in evdns_server_request_format_response()
1993 server_request_free_answers(req); in evdns_server_request_format_response()
1997 memcpy(req->response, buf, req->response_len); in evdns_server_request_format_response()
1998 server_request_free_answers(req); in evdns_server_request_format_response()
2007 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_respond() local
2008 struct evdns_server_port *port = req->port; in evdns_server_request_respond()
2012 if (!req->response) { in evdns_server_request_respond()
2013 if ((r = evdns_server_request_format_response(req, err))<0) in evdns_server_request_respond()
2017 r = sendto(port->socket, req->response, (int)req->response_len, 0, in evdns_server_request_respond()
2018 (struct sockaddr*) &req->addr, (ev_socklen_t)req->addrlen); in evdns_server_request_respond()
2025 req->prev_pending = port->pending_replies->prev_pending; in evdns_server_request_respond()
2026 req->next_pending = port->pending_replies; in evdns_server_request_respond()
2027 req->prev_pending->next_pending = in evdns_server_request_respond()
2028 req->next_pending->prev_pending = req; in evdns_server_request_respond()
2030 req->prev_pending = req->next_pending = req; in evdns_server_request_respond()
2031 port->pending_replies = req; in evdns_server_request_respond()
2046 if (server_request_free(req)) { in evdns_server_request_respond()
2062 server_request_free_answers(struct server_request *req) in server_request_free_answers() argument
2068 list = &req->answer; in server_request_free_answers()
2070 list = &req->authority; in server_request_free_answers()
2072 list = &req->additional; in server_request_free_answers()
2090 server_request_free(struct server_request *req) in server_request_free() argument
2093 if (req->base.questions) { in server_request_free()
2094 for (i = 0; i < req->base.nquestions; ++i) in server_request_free()
2095 mm_free(req->base.questions[i]); in server_request_free()
2096 mm_free(req->base.questions); in server_request_free()
2099 if (req->port) { in server_request_free()
2100 EVDNS_LOCK(req->port); in server_request_free()
2102 if (req->port->pending_replies == req) { in server_request_free()
2103 if (req->next_pending && req->next_pending != req) in server_request_free()
2104 req->port->pending_replies = req->next_pending; in server_request_free()
2106 req->port->pending_replies = NULL; in server_request_free()
2108 rc = --req->port->refcnt; in server_request_free()
2111 if (req->response) { in server_request_free()
2112 mm_free(req->response); in server_request_free()
2115 server_request_free_answers(req); in server_request_free()
2117 if (req->next_pending && req->next_pending != req) { in server_request_free()
2118 req->next_pending->prev_pending = req->prev_pending; in server_request_free()
2119 req->prev_pending->next_pending = req->next_pending; in server_request_free()
2123 EVDNS_UNLOCK(req->port); /* ????? nickm */ in server_request_free()
2124 server_port_free(req->port); in server_request_free()
2125 mm_free(req); in server_request_free()
2129 EVDNS_UNLOCK(req->port); in server_request_free()
2130 mm_free(req); in server_request_free()
2155 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_drop() local
2156 server_request_free(req); in evdns_server_request_drop()
2164 struct server_request *req = TO_SERVER_REQUEST(req_); in evdns_server_request_get_requesting_addr() local
2165 if (addr_len < (int)req->addrlen) in evdns_server_request_get_requesting_addr()
2167 memcpy(sa, &(req->addr), req->addrlen); in evdns_server_request_get_requesting_addr()
2168 return req->addrlen; in evdns_server_request_get_requesting_addr()
2178 struct request *const req = (struct request *) arg; in evdns_request_timeout_callback() local
2179 struct evdns_base *base = req->base; in evdns_request_timeout_callback()
2187 if (req->tx_count >= req->base->global_max_retransmits) { in evdns_request_timeout_callback()
2188 struct nameserver *ns = req->ns; in evdns_request_timeout_callback()
2191 arg, req->tx_count); in evdns_request_timeout_callback()
2192 reply_schedule_callback(req, 0, DNS_ERR_TIMEOUT, NULL); in evdns_request_timeout_callback()
2194 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1); in evdns_request_timeout_callback()
2199 arg, req->tx_count); in evdns_request_timeout_callback()
2200 (void) evtimer_del(&req->timeout_event); in evdns_request_timeout_callback()
2201 request_swap_ns(req, nameserver_pick(base)); in evdns_request_timeout_callback()
2202 evdns_request_transmit(req); in evdns_request_timeout_callback()
2204 req->ns->timedout++; in evdns_request_timeout_callback()
2205 if (req->ns->timedout > req->base->global_max_nameserver_timeout) { in evdns_request_timeout_callback()
2206 req->ns->timedout = 0; in evdns_request_timeout_callback()
2207 nameserver_failed(req->ns, "request timed out."); in evdns_request_timeout_callback()
2221 evdns_request_transmit_to(struct request *req, struct nameserver *server) { in evdns_request_transmit_to() argument
2223 ASSERT_LOCKED(req->base); in evdns_request_transmit_to()
2224 ASSERT_VALID_REQUEST(req); in evdns_request_transmit_to()
2227 req->base->disable_when_inactive && in evdns_request_transmit_to()
2232 r = sendto(server->socket, (void*)req->request, req->request_len, 0, in evdns_request_transmit_to()
2238 nameserver_failed(req->ns, evutil_socket_error_to_string(err)); in evdns_request_transmit_to()
2240 } else if (r != (int)req->request_len) { in evdns_request_transmit_to()
2254 evdns_request_transmit(struct request *req) { in evdns_request_transmit() argument
2257 ASSERT_LOCKED(req->base); in evdns_request_transmit()
2258 ASSERT_VALID_REQUEST(req); in evdns_request_transmit()
2261 req->transmit_me = 1; in evdns_request_transmit()
2262 EVUTIL_ASSERT(req->trans_id != 0xffff); in evdns_request_transmit()
2264 if (!req->ns) in evdns_request_transmit()
2270 if (req->ns->choked) { in evdns_request_transmit()
2276 r = evdns_request_transmit_to(req, req->ns); in evdns_request_transmit()
2280 req->ns->choked = 1; in evdns_request_transmit()
2281 nameserver_write_waiting(req->ns, 1); in evdns_request_transmit()
2292 "Setting timeout for request %p, sent to nameserver %p", req, req->ns); in evdns_request_transmit()
2293 if (evtimer_add(&req->timeout_event, &req->base->global_timeout) < 0) { in evdns_request_transmit()
2296 req); in evdns_request_transmit()
2299 req->tx_count++; in evdns_request_transmit()
2300 req->transmit_me = 0; in evdns_request_transmit()
2334 struct request *req; in nameserver_send_probe() local
2346 …req = request_new(ns->base, handle, TYPE_A, "google.com", DNS_QUERY_NO_SEARCH, nameserver_probe_ca… in nameserver_send_probe()
2347 if (!req) { in nameserver_send_probe()
2353 request_trans_id_set(req, transaction_id_pick(ns->base)); in nameserver_send_probe()
2354 req->ns = ns; in nameserver_send_probe()
2355 request_submit(req); in nameserver_send_probe()
2369 struct request *const started_at = base->req_heads[i], *req = started_at; in evdns_transmit() local
2372 if (req->transmit_me) { in evdns_transmit()
2374 evdns_request_transmit(req); in evdns_transmit()
2377 req = req->next; in evdns_transmit()
2378 } while (req != started_at); in evdns_transmit()
2445 struct request *req, *req_started_at; in evdns_base_clear_nameservers_and_suspend() local
2446 req = req_started_at = base->req_heads[i]; in evdns_base_clear_nameservers_and_suspend()
2447 while (req) { in evdns_base_clear_nameservers_and_suspend()
2448 struct request *next = req->next; in evdns_base_clear_nameservers_and_suspend()
2449 req->tx_count = req->reissue_count = 0; in evdns_base_clear_nameservers_and_suspend()
2450 req->ns = NULL; in evdns_base_clear_nameservers_and_suspend()
2452 (void) evtimer_del(&req->timeout_event); in evdns_base_clear_nameservers_and_suspend()
2453 req->trans_id = 0; in evdns_base_clear_nameservers_and_suspend()
2454 req->transmit_me = 0; in evdns_base_clear_nameservers_and_suspend()
2457 evdns_request_insert(req, &base->req_waiting_head); in evdns_base_clear_nameservers_and_suspend()
2466 req = next; in evdns_base_clear_nameservers_and_suspend()
2717 evdns_request_remove(struct request *req, struct request **head) in evdns_request_remove() argument
2719 ASSERT_LOCKED(req->base); in evdns_request_remove()
2720 ASSERT_VALID_REQUEST(req); in evdns_request_remove()
2730 if (ptr == req) { in evdns_request_remove()
2738 EVUTIL_ASSERT(req->next); in evdns_request_remove()
2742 if (req->next == req) { in evdns_request_remove()
2746 req->next->prev = req->prev; in evdns_request_remove()
2747 req->prev->next = req->next; in evdns_request_remove()
2748 if (*head == req) *head = req->next; in evdns_request_remove()
2750 req->next = req->prev = NULL; in evdns_request_remove()
2755 evdns_request_insert(struct request *req, struct request **head) { in evdns_request_insert() argument
2756 ASSERT_LOCKED(req->base); in evdns_request_insert()
2757 ASSERT_VALID_REQUEST(req); in evdns_request_insert()
2759 *head = req; in evdns_request_insert()
2760 req->next = req->prev = req; in evdns_request_insert()
2764 req->prev = (*head)->prev; in evdns_request_insert()
2765 req->prev->next = req; in evdns_request_insert()
2766 req->next = *head; in evdns_request_insert()
2767 (*head)->prev = req; in evdns_request_insert()
2792 struct request *const req = in request_new() local
2800 if (!req) return NULL; in request_new()
2803 mm_free(req); in request_new()
2807 memset(req, 0, sizeof(struct request)); in request_new()
2808 req->base = base; in request_new()
2810 evtimer_assign(&req->timeout_event, req->base->event_base, evdns_request_timeout_callback, req); in request_new()
2829 req->request = ((u8 *) req) + sizeof(struct request); in request_new()
2831 req->request_appended = 1; in request_new()
2833 type, CLASS_INET, req->request, request_max_len); in request_new()
2837 req->request_len = rlen; in request_new()
2838 req->trans_id = trans_id; in request_new()
2839 req->tx_count = 0; in request_new()
2840 req->request_type = type; in request_new()
2841 req->user_pointer = user_ptr; in request_new()
2842 req->user_callback = callback; in request_new()
2843 req->ns = issuing_now ? nameserver_pick(base) : NULL; in request_new()
2844 req->next = req->prev = NULL; in request_new()
2845 req->handle = handle; in request_new()
2847 handle->current_req = req; in request_new()
2851 return req; in request_new()
2853 mm_free(req); in request_new()
2858 request_submit(struct request *const req) { in request_submit() argument
2859 struct evdns_base *base = req->base; in request_submit()
2861 ASSERT_VALID_REQUEST(req); in request_submit()
2862 if (req->ns) { in request_submit()
2865 evdns_request_insert(req, &REQ_HEAD(base, req->trans_id)); in request_submit()
2868 req->ns->requests_inflight++; in request_submit()
2870 evdns_request_transmit(req); in request_submit()
2872 evdns_request_insert(req, &base->req_waiting_head); in request_submit()
2881 struct request *req; in evdns_cancel_request() local
2899 req = handle->current_req; in evdns_cancel_request()
2900 ASSERT_VALID_REQUEST(req); in evdns_cancel_request()
2902 reply_schedule_callback(req, 0, DNS_ERR_CANCEL, NULL); in evdns_cancel_request()
2903 if (req->ns) { in evdns_cancel_request()
2905 request_finished(req, &REQ_HEAD(base, req->trans_id), 1); in evdns_cancel_request()
2908 request_finished(req, &base->req_waiting_head, 1); in evdns_cancel_request()
2918 struct request *req; in evdns_base_resolve_ipv4() local
2925 req = in evdns_base_resolve_ipv4()
2928 if (req) in evdns_base_resolve_ipv4()
2929 request_submit(req); in evdns_base_resolve_ipv4()
2957 struct request *req; in evdns_base_resolve_ipv6() local
2964 req = request_new(base, handle, TYPE_AAAA, name, flags, in evdns_base_resolve_ipv6()
2966 if (req) in evdns_base_resolve_ipv6()
2967 request_submit(req); in evdns_base_resolve_ipv6()
2990 struct request *req; in evdns_base_resolve_reverse() local
3004 req = request_new(base, handle, TYPE_PTR, buf, flags, callback, ptr); in evdns_base_resolve_reverse()
3005 if (req) in evdns_base_resolve_reverse()
3006 request_submit(req); in evdns_base_resolve_reverse()
3026 struct request *req; in evdns_base_resolve_reverse_ipv6() local
3044 req = request_new(base, handle, TYPE_PTR, buf, flags, callback, ptr); in evdns_base_resolve_reverse_ipv6()
3045 if (req) in evdns_base_resolve_reverse_ipv6()
3046 request_submit(req); in evdns_base_resolve_reverse_ipv6()
3250 struct request *req; in search_request_new() local
3252 req = request_new(base, handle, type, name, flags, user_callback, user_arg); in search_request_new()
3253 if (!req) return NULL; in search_request_new()
3258 req = request_new(base, handle, type, new_name, flags, user_callback, user_arg); in search_request_new()
3260 if (!req) return NULL; in search_request_new()
3267 if (req) in search_request_new()
3268 mm_free(req); in search_request_new()
3274 request_submit(req); in search_request_new()
3275 return req; in search_request_new()
3277 struct request *const req = request_new(base, handle, type, name, flags, user_callback, user_arg); in search_request_new() local
3278 if (!req) return NULL; in search_request_new()
3279 request_submit(req); in search_request_new()
3280 return req; in search_request_new()
3291 struct request *req = handle->current_req; in search_try_next() local
3292 struct evdns_base *base = req->base; in search_try_next()
3304 …ewreq = request_new(base, NULL, req->request_type, handle->search_origname, handle->search_flags, … in search_try_next()
3317 …newreq = request_new(base, NULL, req->request_type, new_name, handle->search_flags, req->user_call… in search_try_next()
3325 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 0); in search_try_next()
3429 struct request **old_heads = base->req_heads, **new_heads, *req; in evdns_base_set_max_requests_inflight() local
3443 req = old_heads[i]; in evdns_base_set_max_requests_inflight()
3444 evdns_request_remove(req, &old_heads[i]); in evdns_base_set_max_requests_inflight()
3445 evdns_request_insert(req, &new_heads[req->trans_id % n_heads]); in evdns_base_set_max_requests_inflight()
4462 struct getaddrinfo_subrequest *req = arg; in evdns_getaddrinfo_gotresolve() local
4476 EVUTIL_ASSERT(req->type == DNS_IPv4_A || req->type == DNS_IPv6_AAAA); in evdns_getaddrinfo_gotresolve()
4477 if (req->type == DNS_IPv4_A) { in evdns_getaddrinfo_gotresolve()
4478 data = EVUTIL_UPCAST(req, struct evdns_getaddrinfo_request, ipv4_request); in evdns_getaddrinfo_gotresolve()
4481 data = EVUTIL_UPCAST(req, struct evdns_getaddrinfo_request, ipv6_request); in evdns_getaddrinfo_gotresolve()
4489 if (req->type == DNS_IPv4_A) in evdns_getaddrinfo_gotresolve()
4503 req->r = NULL; in evdns_getaddrinfo_gotresolve()
4624 if (req->type == DNS_IPv4_A) in evdns_getaddrinfo_gotresolve()