Deleted Added
sdiff udiff text old ( 266114 ) new ( 276605 )
full compact
outside_network.c (266114) outside_network.c (276605)
1/*
2 * services/outside_network.c - implement sending of queries and wait answer.
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 44 unchanged lines hidden (view full) ---

53#include "util/data/msgencode.h"
54#include "util/data/dname.h"
55#include "util/netevent.h"
56#include "util/log.h"
57#include "util/net_help.h"
58#include "util/random.h"
59#include "util/fptr_wlist.h"
60#include "ldns/sbuffer.h"
1/*
2 * services/outside_network.c - implement sending of queries and wait answer.
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 44 unchanged lines hidden (view full) ---

53#include "util/data/msgencode.h"
54#include "util/data/dname.h"
55#include "util/netevent.h"
56#include "util/log.h"
57#include "util/net_help.h"
58#include "util/random.h"
59#include "util/fptr_wlist.h"
60#include "ldns/sbuffer.h"
61#include "dnstap/dnstap.h"
61#ifdef HAVE_OPENSSL_SSL_H
62#include <openssl/ssl.h>
63#endif
64
65#ifdef HAVE_NETDB_H
66#include <netdb.h>
67#endif
68#include <fcntl.h>
69
70/** number of times to retry making a random ID that is unique. */
71#define MAX_ID_RETRY 1000
72/** number of times to retry finding interface, port that can be opened. */
73#define MAX_PORT_RETRY 10000
74/** number of retries on outgoing UDP queries */
75#define OUTBOUND_UDP_RETRY 1
76
77/** initiate TCP transaction for serviced query */
62#ifdef HAVE_OPENSSL_SSL_H
63#include <openssl/ssl.h>
64#endif
65
66#ifdef HAVE_NETDB_H
67#include <netdb.h>
68#endif
69#include <fcntl.h>
70
71/** number of times to retry making a random ID that is unique. */
72#define MAX_ID_RETRY 1000
73/** number of times to retry finding interface, port that can be opened. */
74#define MAX_PORT_RETRY 10000
75/** number of retries on outgoing UDP queries */
76#define OUTBOUND_UDP_RETRY 1
77
78/** initiate TCP transaction for serviced query */
78static void serviced_tcp_initiate(struct outside_network* outnet,
79 struct serviced_query* sq, sldns_buffer* buff);
79static void serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff);
80/** with a fd available, randomize and send UDP */
80/** with a fd available, randomize and send UDP */
81static int randomize_and_send_udp(struct outside_network* outnet,
82 struct pending* pend, sldns_buffer* packet, int timeout);
81static int randomize_and_send_udp(struct pending* pend, sldns_buffer* packet,
82 int timeout);
83
83
84/** remove waiting tcp from the outnet waiting list */
85static void waiting_list_remove(struct outside_network* outnet,
86 struct waiting_tcp* w);
87
84int
85pending_cmp(const void* key1, const void* key2)
86{
87 struct pending *p1 = (struct pending*)key1;
88 struct pending *p2 = (struct pending*)key2;
89 if(p1->id < p2->id)
90 return -1;
91 if(p1->id > p2->id)

--- 113 unchanged lines hidden (view full) ---

205#ifdef INET6
206 if(addr_is_ip6(&w->addr, w->addrlen))
207 s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
208 else
209#endif
210 s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
211 if(s == -1) {
212#ifndef USE_WINSOCK
88int
89pending_cmp(const void* key1, const void* key2)
90{
91 struct pending *p1 = (struct pending*)key1;
92 struct pending *p2 = (struct pending*)key2;
93 if(p1->id < p2->id)
94 return -1;
95 if(p1->id > p2->id)

--- 113 unchanged lines hidden (view full) ---

209#ifdef INET6
210 if(addr_is_ip6(&w->addr, w->addrlen))
211 s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
212 else
213#endif
214 s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
215 if(s == -1) {
216#ifndef USE_WINSOCK
213 log_err("outgoing tcp: socket: %s", strerror(errno));
217 log_err_addr("outgoing tcp: socket", strerror(errno),
218 &w->addr, w->addrlen);
214#else
219#else
215 log_err("outgoing tcp: socket: %s",
216 wsa_strerror(WSAGetLastError()));
220 log_err_addr("outgoing tcp: socket",
221 wsa_strerror(WSAGetLastError()), &w->addr, w->addrlen);
217#endif
222#endif
218 log_addr(0, "failed address", &w->addr, w->addrlen);
219 return 0;
220 }
221 if(!pick_outgoing_tcp(w, s))
222 return 0;
223
224 fd_set_nonblock(s);
225 if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
226#ifndef USE_WINSOCK
227#ifdef EINPROGRESS
228 if(errno != EINPROGRESS) {
229#else
230 if(1) {
231#endif
232 if(tcp_connect_errno_needs_log(
233 (struct sockaddr*)&w->addr, w->addrlen))
223 return 0;
224 }
225 if(!pick_outgoing_tcp(w, s))
226 return 0;
227
228 fd_set_nonblock(s);
229 if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
230#ifndef USE_WINSOCK
231#ifdef EINPROGRESS
232 if(errno != EINPROGRESS) {
233#else
234 if(1) {
235#endif
236 if(tcp_connect_errno_needs_log(
237 (struct sockaddr*)&w->addr, w->addrlen))
234 log_err("outgoing tcp: connect: %s",
235 strerror(errno));
238 log_err_addr("outgoing tcp: connect",
239 strerror(errno), &w->addr, w->addrlen);
236 close(s);
237#else /* USE_WINSOCK */
238 if(WSAGetLastError() != WSAEINPROGRESS &&
239 WSAGetLastError() != WSAEWOULDBLOCK) {
240 closesocket(s);
241#endif
240 close(s);
241#else /* USE_WINSOCK */
242 if(WSAGetLastError() != WSAEINPROGRESS &&
243 WSAGetLastError() != WSAEWOULDBLOCK) {
244 closesocket(s);
245#endif
242 log_addr(0, "failed address", &w->addr, w->addrlen);
243 return 0;
244 }
245 }
246 if(w->outnet->sslctx && w->ssl_upstream) {
247 pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
248 if(!pend->c->ssl) {
249 pend->c->fd = s;
250 comm_point_close(pend->c);
251 return 0;
252 }
253#ifdef USE_WINSOCK
254 comm_point_tcp_win_bio_cb(pend->c, pend->c->ssl);
255#endif
256 pend->c->ssl_shake_state = comm_ssl_shake_write;
257 }
258 w->pkt = NULL;
259 w->next_waiting = (void*)pend;
260 pend->id = LDNS_ID_WIRE(pkt);
246 return 0;
247 }
248 }
249 if(w->outnet->sslctx && w->ssl_upstream) {
250 pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
251 if(!pend->c->ssl) {
252 pend->c->fd = s;
253 comm_point_close(pend->c);
254 return 0;
255 }
256#ifdef USE_WINSOCK
257 comm_point_tcp_win_bio_cb(pend->c, pend->c->ssl);
258#endif
259 pend->c->ssl_shake_state = comm_ssl_shake_write;
260 }
261 w->pkt = NULL;
262 w->next_waiting = (void*)pend;
263 pend->id = LDNS_ID_WIRE(pkt);
264 w->outnet->num_tcp_outgoing++;
261 w->outnet->tcp_free = pend->next_free;
262 pend->next_free = NULL;
263 pend->query = w;
264 pend->c->repinfo.addrlen = w->addrlen;
265 memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen);
266 sldns_buffer_clear(pend->c->buffer);
267 sldns_buffer_write(pend->c->buffer, pkt, pkt_len);
268 sldns_buffer_flip(pend->c->buffer);

--- 104 unchanged lines hidden (view full) ---

373 outnet->udp_wait_first = pend->next_waiting;
374 if(!pend->next_waiting) outnet->udp_wait_last = NULL;
375 sldns_buffer_clear(outnet->udp_buff);
376 sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
377 sldns_buffer_flip(outnet->udp_buff);
378 free(pend->pkt); /* freeing now makes get_mem correct */
379 pend->pkt = NULL;
380 pend->pkt_len = 0;
265 w->outnet->tcp_free = pend->next_free;
266 pend->next_free = NULL;
267 pend->query = w;
268 pend->c->repinfo.addrlen = w->addrlen;
269 memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen);
270 sldns_buffer_clear(pend->c->buffer);
271 sldns_buffer_write(pend->c->buffer, pkt, pkt_len);
272 sldns_buffer_flip(pend->c->buffer);

--- 104 unchanged lines hidden (view full) ---

377 outnet->udp_wait_first = pend->next_waiting;
378 if(!pend->next_waiting) outnet->udp_wait_last = NULL;
379 sldns_buffer_clear(outnet->udp_buff);
380 sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
381 sldns_buffer_flip(outnet->udp_buff);
382 free(pend->pkt); /* freeing now makes get_mem correct */
383 pend->pkt = NULL;
384 pend->pkt_len = 0;
381 if(!randomize_and_send_udp(outnet, pend, outnet->udp_buff,
385 if(!randomize_and_send_udp(pend, outnet->udp_buff,
382 pend->timeout)) {
383 /* callback error on pending */
384 if(pend->cb) {
385 fptr_ok(fptr_whitelist_pending_udp(pend->cb));
386 (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
387 NETEVENT_CLOSED, NULL);
388 }
389 pending_delete(outnet, pend);

--- 193 unchanged lines hidden (view full) ---

583
584struct outside_network*
585outside_network_create(struct comm_base *base, size_t bufsize,
586 size_t num_ports, char** ifs, int num_ifs, int do_ip4,
587 int do_ip6, size_t num_tcp, struct infra_cache* infra,
588 struct ub_randstate* rnd, int use_caps_for_id, int* availports,
589 int numavailports, size_t unwanted_threshold,
590 void (*unwanted_action)(void*), void* unwanted_param, int do_udp,
386 pend->timeout)) {
387 /* callback error on pending */
388 if(pend->cb) {
389 fptr_ok(fptr_whitelist_pending_udp(pend->cb));
390 (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
391 NETEVENT_CLOSED, NULL);
392 }
393 pending_delete(outnet, pend);

--- 193 unchanged lines hidden (view full) ---

587
588struct outside_network*
589outside_network_create(struct comm_base *base, size_t bufsize,
590 size_t num_ports, char** ifs, int num_ifs, int do_ip4,
591 int do_ip6, size_t num_tcp, struct infra_cache* infra,
592 struct ub_randstate* rnd, int use_caps_for_id, int* availports,
593 int numavailports, size_t unwanted_threshold,
594 void (*unwanted_action)(void*), void* unwanted_param, int do_udp,
591 void* sslctx, int delayclose)
595 void* sslctx, int delayclose, struct dt_env* dtenv)
592{
593 struct outside_network* outnet = (struct outside_network*)
594 calloc(1, sizeof(struct outside_network));
595 size_t k;
596 if(!outnet) {
597 log_err("malloc failed");
598 return NULL;
599 }
600 comm_base_timept(base, &outnet->now_secs, &outnet->now_tv);
601 outnet->base = base;
602 outnet->num_tcp = num_tcp;
596{
597 struct outside_network* outnet = (struct outside_network*)
598 calloc(1, sizeof(struct outside_network));
599 size_t k;
600 if(!outnet) {
601 log_err("malloc failed");
602 return NULL;
603 }
604 comm_base_timept(base, &outnet->now_secs, &outnet->now_tv);
605 outnet->base = base;
606 outnet->num_tcp = num_tcp;
607 outnet->num_tcp_outgoing = 0;
603 outnet->infra = infra;
604 outnet->rnd = rnd;
605 outnet->sslctx = sslctx;
608 outnet->infra = infra;
609 outnet->rnd = rnd;
610 outnet->sslctx = sslctx;
611#ifdef USE_DNSTAP
612 outnet->dtenv = dtenv;
613#else
614 (void)dtenv;
615#endif
606 outnet->svcd_overhead = 0;
607 outnet->want_to_quit = 0;
608 outnet->unwanted_threshold = unwanted_threshold;
609 outnet->unwanted_action = unwanted_action;
610 outnet->unwanted_param = unwanted_param;
611 outnet->use_caps_for_id = use_caps_for_id;
612 outnet->do_udp = do_udp;
613#ifndef S_SPLINT_S

--- 372 unchanged lines hidden (view full) ---

986 }
987 log_assert(pend->pc);
988 pend->pc->num_outstanding++;
989
990 return 1;
991}
992
993static int
616 outnet->svcd_overhead = 0;
617 outnet->want_to_quit = 0;
618 outnet->unwanted_threshold = unwanted_threshold;
619 outnet->unwanted_action = unwanted_action;
620 outnet->unwanted_param = unwanted_param;
621 outnet->use_caps_for_id = use_caps_for_id;
622 outnet->do_udp = do_udp;
623#ifndef S_SPLINT_S

--- 372 unchanged lines hidden (view full) ---

996 }
997 log_assert(pend->pc);
998 pend->pc->num_outstanding++;
999
1000 return 1;
1001}
1002
1003static int
994randomize_and_send_udp(struct outside_network* outnet, struct pending* pend,
995 sldns_buffer* packet, int timeout)
1004randomize_and_send_udp(struct pending* pend, sldns_buffer* packet, int timeout)
996{
997 struct timeval tv;
1005{
1006 struct timeval tv;
1007 struct outside_network* outnet = pend->sq->outnet;
998
999 /* select id */
1000 if(!select_id(outnet, pend, packet)) {
1001 return 0;
1002 }
1003
1004 /* select src_if, port */
1005 if(addr_is_ip6(&pend->addr, pend->addrlen)) {

--- 16 unchanged lines hidden (view full) ---

1022
1023 /* system calls to set timeout after sending UDP to make roundtrip
1024 smaller. */
1025#ifndef S_SPLINT_S
1026 tv.tv_sec = timeout/1000;
1027 tv.tv_usec = (timeout%1000)*1000;
1028#endif
1029 comm_timer_set(pend->timer, &tv);
1008
1009 /* select id */
1010 if(!select_id(outnet, pend, packet)) {
1011 return 0;
1012 }
1013
1014 /* select src_if, port */
1015 if(addr_is_ip6(&pend->addr, pend->addrlen)) {

--- 16 unchanged lines hidden (view full) ---

1032
1033 /* system calls to set timeout after sending UDP to make roundtrip
1034 smaller. */
1035#ifndef S_SPLINT_S
1036 tv.tv_sec = timeout/1000;
1037 tv.tv_usec = (timeout%1000)*1000;
1038#endif
1039 comm_timer_set(pend->timer, &tv);
1040
1041#ifdef USE_DNSTAP
1042 if(outnet->dtenv &&
1043 (outnet->dtenv->log_resolver_query_messages ||
1044 outnet->dtenv->log_forwarder_query_messages))
1045 dt_msg_send_outside_query(outnet->dtenv, &pend->addr, comm_udp,
1046 pend->sq->zone, pend->sq->zonelen, packet);
1047#endif
1030 return 1;
1031}
1032
1033struct pending*
1048 return 1;
1049}
1050
1051struct pending*
1034pending_udp_query(struct outside_network* outnet, sldns_buffer* packet,
1035 struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
1036 comm_point_callback_t* cb, void* cb_arg)
1052pending_udp_query(struct serviced_query* sq, struct sldns_buffer* packet,
1053 int timeout, comm_point_callback_t* cb, void* cb_arg)
1037{
1038 struct pending* pend = (struct pending*)calloc(1, sizeof(*pend));
1039 if(!pend) return NULL;
1054{
1055 struct pending* pend = (struct pending*)calloc(1, sizeof(*pend));
1056 if(!pend) return NULL;
1040 pend->outnet = outnet;
1041 pend->addrlen = addrlen;
1042 memmove(&pend->addr, addr, addrlen);
1057 pend->outnet = sq->outnet;
1058 pend->sq = sq;
1059 pend->addrlen = sq->addrlen;
1060 memmove(&pend->addr, &sq->addr, sq->addrlen);
1043 pend->cb = cb;
1044 pend->cb_arg = cb_arg;
1045 pend->node.key = pend;
1061 pend->cb = cb;
1062 pend->cb_arg = cb_arg;
1063 pend->node.key = pend;
1046 pend->timer = comm_timer_create(outnet->base, pending_udp_timer_cb,
1064 pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb,
1047 pend);
1048 if(!pend->timer) {
1049 free(pend);
1050 return NULL;
1051 }
1052
1065 pend);
1066 if(!pend->timer) {
1067 free(pend);
1068 return NULL;
1069 }
1070
1053 if(outnet->unused_fds == NULL) {
1071 if(sq->outnet->unused_fds == NULL) {
1054 /* no unused fd, cannot create a new port (randomly) */
1055 verbose(VERB_ALGO, "no fds available, udp query waiting");
1056 pend->timeout = timeout;
1057 pend->pkt_len = sldns_buffer_limit(packet);
1058 pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet),
1059 pend->pkt_len);
1060 if(!pend->pkt) {
1061 comm_timer_delete(pend->timer);
1062 free(pend);
1063 return NULL;
1064 }
1065 /* put at end of waiting list */
1072 /* no unused fd, cannot create a new port (randomly) */
1073 verbose(VERB_ALGO, "no fds available, udp query waiting");
1074 pend->timeout = timeout;
1075 pend->pkt_len = sldns_buffer_limit(packet);
1076 pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet),
1077 pend->pkt_len);
1078 if(!pend->pkt) {
1079 comm_timer_delete(pend->timer);
1080 free(pend);
1081 return NULL;
1082 }
1083 /* put at end of waiting list */
1066 if(outnet->udp_wait_last)
1067 outnet->udp_wait_last->next_waiting = pend;
1084 if(sq->outnet->udp_wait_last)
1085 sq->outnet->udp_wait_last->next_waiting = pend;
1068 else
1086 else
1069 outnet->udp_wait_first = pend;
1070 outnet->udp_wait_last = pend;
1087 sq->outnet->udp_wait_first = pend;
1088 sq->outnet->udp_wait_last = pend;
1071 return pend;
1072 }
1089 return pend;
1090 }
1073 if(!randomize_and_send_udp(outnet, pend, packet, timeout)) {
1074 pending_delete(outnet, pend);
1091 if(!randomize_and_send_udp(pend, packet, timeout)) {
1092 pending_delete(sq->outnet, pend);
1075 return NULL;
1076 }
1077 return pend;
1078}
1079
1080void
1081outnet_tcptimer(void* arg)
1082{
1083 struct waiting_tcp* w = (struct waiting_tcp*)arg;
1084 struct outside_network* outnet = w->outnet;
1085 comm_point_callback_t* cb;
1086 void* cb_arg;
1087 if(w->pkt) {
1088 /* it is on the waiting list */
1093 return NULL;
1094 }
1095 return pend;
1096}
1097
1098void
1099outnet_tcptimer(void* arg)
1100{
1101 struct waiting_tcp* w = (struct waiting_tcp*)arg;
1102 struct outside_network* outnet = w->outnet;
1103 comm_point_callback_t* cb;
1104 void* cb_arg;
1105 if(w->pkt) {
1106 /* it is on the waiting list */
1089 struct waiting_tcp* p=outnet->tcp_wait_first, *prev=NULL;
1090 while(p) {
1091 if(p == w) {
1092 if(prev) prev->next_waiting = w->next_waiting;
1093 else outnet->tcp_wait_first=w->next_waiting;
1094 outnet->tcp_wait_last = prev;
1095 break;
1096 }
1097 prev = p;
1098 p=p->next_waiting;
1099 }
1107 waiting_list_remove(outnet, w);
1100 } else {
1101 /* it was in use */
1102 struct pending_tcp* pend=(struct pending_tcp*)w->next_waiting;
1103 comm_point_close(pend->c);
1104 pend->query = NULL;
1105 pend->next_free = outnet->tcp_free;
1106 outnet->tcp_free = pend;
1107 }
1108 cb = w->cb;
1109 cb_arg = w->cb_arg;
1110 waiting_tcp_delete(w);
1111 fptr_ok(fptr_whitelist_pending_tcp(cb));
1112 (void)(*cb)(NULL, cb_arg, NETEVENT_TIMEOUT, NULL);
1113 use_free_buffer(outnet);
1114}
1115
1108 } else {
1109 /* it was in use */
1110 struct pending_tcp* pend=(struct pending_tcp*)w->next_waiting;
1111 comm_point_close(pend->c);
1112 pend->query = NULL;
1113 pend->next_free = outnet->tcp_free;
1114 outnet->tcp_free = pend;
1115 }
1116 cb = w->cb;
1117 cb_arg = w->cb_arg;
1118 waiting_tcp_delete(w);
1119 fptr_ok(fptr_whitelist_pending_tcp(cb));
1120 (void)(*cb)(NULL, cb_arg, NETEVENT_TIMEOUT, NULL);
1121 use_free_buffer(outnet);
1122}
1123
1116struct waiting_tcp*
1117pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet,
1118 struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
1119 comm_point_callback_t* callback, void* callback_arg, int ssl_upstream)
1124struct waiting_tcp*
1125pending_tcp_query(struct serviced_query* sq, sldns_buffer* packet,
1126 int timeout, comm_point_callback_t* callback, void* callback_arg)
1120{
1127{
1121 struct pending_tcp* pend = outnet->tcp_free;
1128 struct pending_tcp* pend = sq->outnet->tcp_free;
1122 struct waiting_tcp* w;
1123 struct timeval tv;
1124 uint16_t id;
1125 /* if no buffer is free allocate space to store query */
1126 w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp)
1127 + (pend?0:sldns_buffer_limit(packet)));
1128 if(!w) {
1129 return NULL;
1130 }
1129 struct waiting_tcp* w;
1130 struct timeval tv;
1131 uint16_t id;
1132 /* if no buffer is free allocate space to store query */
1133 w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp)
1134 + (pend?0:sldns_buffer_limit(packet)));
1135 if(!w) {
1136 return NULL;
1137 }
1131 if(!(w->timer = comm_timer_create(outnet->base, outnet_tcptimer, w))) {
1138 if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) {
1132 free(w);
1133 return NULL;
1134 }
1135 w->pkt = NULL;
1136 w->pkt_len = 0;
1139 free(w);
1140 return NULL;
1141 }
1142 w->pkt = NULL;
1143 w->pkt_len = 0;
1137 id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
1144 id = ((unsigned)ub_random(sq->outnet->rnd)>>8) & 0xffff;
1138 LDNS_ID_SET(sldns_buffer_begin(packet), id);
1145 LDNS_ID_SET(sldns_buffer_begin(packet), id);
1139 memcpy(&w->addr, addr, addrlen);
1140 w->addrlen = addrlen;
1141 w->outnet = outnet;
1146 memcpy(&w->addr, &sq->addr, sq->addrlen);
1147 w->addrlen = sq->addrlen;
1148 w->outnet = sq->outnet;
1142 w->cb = callback;
1143 w->cb_arg = callback_arg;
1149 w->cb = callback;
1150 w->cb_arg = callback_arg;
1144 w->ssl_upstream = ssl_upstream;
1151 w->ssl_upstream = sq->ssl_upstream;
1145#ifndef S_SPLINT_S
1146 tv.tv_sec = timeout;
1147 tv.tv_usec = 0;
1148#endif
1149 comm_timer_set(w->timer, &tv);
1150 if(pend) {
1151 /* we have a buffer available right now */
1152 if(!outnet_tcp_take_into_use(w, sldns_buffer_begin(packet),
1153 sldns_buffer_limit(packet))) {
1154 waiting_tcp_delete(w);
1155 return NULL;
1156 }
1152#ifndef S_SPLINT_S
1153 tv.tv_sec = timeout;
1154 tv.tv_usec = 0;
1155#endif
1156 comm_timer_set(w->timer, &tv);
1157 if(pend) {
1158 /* we have a buffer available right now */
1159 if(!outnet_tcp_take_into_use(w, sldns_buffer_begin(packet),
1160 sldns_buffer_limit(packet))) {
1161 waiting_tcp_delete(w);
1162 return NULL;
1163 }
1164#ifdef USE_DNSTAP
1165 if(sq->outnet->dtenv &&
1166 (sq->outnet->dtenv->log_resolver_query_messages ||
1167 sq->outnet->dtenv->log_forwarder_query_messages))
1168 dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr,
1169 comm_tcp, sq->zone, sq->zonelen, packet);
1170#endif
1157 } else {
1158 /* queue up */
1159 w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp);
1160 w->pkt_len = sldns_buffer_limit(packet);
1161 memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len);
1162 w->next_waiting = NULL;
1171 } else {
1172 /* queue up */
1173 w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp);
1174 w->pkt_len = sldns_buffer_limit(packet);
1175 memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len);
1176 w->next_waiting = NULL;
1163 if(outnet->tcp_wait_last)
1164 outnet->tcp_wait_last->next_waiting = w;
1165 else outnet->tcp_wait_first = w;
1166 outnet->tcp_wait_last = w;
1177 if(sq->outnet->tcp_wait_last)
1178 sq->outnet->tcp_wait_last->next_waiting = w;
1179 else sq->outnet->tcp_wait_first = w;
1180 sq->outnet->tcp_wait_last = w;
1167 }
1168 return w;
1169}
1170
1171/** create query for serviced queries */
1172static void
1173serviced_gen_query(sldns_buffer* buff, uint8_t* qname, size_t qnamelen,
1174 uint16_t qtype, uint16_t qclass, uint16_t flags)

--- 25 unchanged lines hidden (view full) ---

1200 key.addrlen = addrlen;
1201 key.outnet = outnet;
1202 return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
1203}
1204
1205/** Create new serviced entry */
1206static struct serviced_query*
1207serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
1181 }
1182 return w;
1183}
1184
1185/** create query for serviced queries */
1186static void
1187serviced_gen_query(sldns_buffer* buff, uint8_t* qname, size_t qnamelen,
1188 uint16_t qtype, uint16_t qclass, uint16_t flags)

--- 25 unchanged lines hidden (view full) ---

1214 key.addrlen = addrlen;
1215 key.outnet = outnet;
1216 return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
1217}
1218
1219/** Create new serviced entry */
1220static struct serviced_query*
1221serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
1208 int want_dnssec, int tcp_upstream, int ssl_upstream,
1222 int want_dnssec, int nocaps, int tcp_upstream, int ssl_upstream,
1209 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
1210 size_t zonelen, int qtype)
1211{
1212 struct serviced_query* sq = (struct serviced_query*)malloc(sizeof(*sq));
1213#ifdef UNBOUND_DEBUG
1214 rbnode_t* ins;
1215#endif
1216 if(!sq)

--- 10 unchanged lines hidden (view full) ---

1227 free(sq->qbuf);
1228 free(sq);
1229 return NULL;
1230 }
1231 sq->zonelen = zonelen;
1232 sq->qtype = qtype;
1233 sq->dnssec = dnssec;
1234 sq->want_dnssec = want_dnssec;
1223 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
1224 size_t zonelen, int qtype)
1225{
1226 struct serviced_query* sq = (struct serviced_query*)malloc(sizeof(*sq));
1227#ifdef UNBOUND_DEBUG
1228 rbnode_t* ins;
1229#endif
1230 if(!sq)

--- 10 unchanged lines hidden (view full) ---

1241 free(sq->qbuf);
1242 free(sq);
1243 return NULL;
1244 }
1245 sq->zonelen = zonelen;
1246 sq->qtype = qtype;
1247 sq->dnssec = dnssec;
1248 sq->want_dnssec = want_dnssec;
1249 sq->nocaps = nocaps;
1235 sq->tcp_upstream = tcp_upstream;
1236 sq->ssl_upstream = ssl_upstream;
1237 memcpy(&sq->addr, addr, addrlen);
1238 sq->addrlen = addrlen;
1239 sq->outnet = outnet;
1240 sq->cblist = NULL;
1241 sq->pending = NULL;
1242 sq->status = serviced_initial;

--- 71 unchanged lines hidden (view full) ---

1314 uint8_t* d = qbuf + 10;
1315 long int random = 0;
1316 int bits = 0;
1317 log_assert(len >= 10 + 5 /* offset qname, root, qtype, qclass */);
1318 lablen = *d++;
1319 while(lablen) {
1320 while(lablen--) {
1321 /* only perturb A-Z, a-z */
1250 sq->tcp_upstream = tcp_upstream;
1251 sq->ssl_upstream = ssl_upstream;
1252 memcpy(&sq->addr, addr, addrlen);
1253 sq->addrlen = addrlen;
1254 sq->outnet = outnet;
1255 sq->cblist = NULL;
1256 sq->pending = NULL;
1257 sq->status = serviced_initial;

--- 71 unchanged lines hidden (view full) ---

1329 uint8_t* d = qbuf + 10;
1330 long int random = 0;
1331 int bits = 0;
1332 log_assert(len >= 10 + 5 /* offset qname, root, qtype, qclass */);
1333 lablen = *d++;
1334 while(lablen) {
1335 while(lablen--) {
1336 /* only perturb A-Z, a-z */
1322 if(isalpha((int)*d)) {
1337 if(isalpha((unsigned char)*d)) {
1323 /* get a random bit */
1324 if(bits == 0) {
1325 random = ub_random(rnd);
1326 bits = 30;
1327 }
1328 if(random & 0x1) {
1338 /* get a random bit */
1339 if(bits == 0) {
1340 random = ub_random(rnd);
1341 bits = 30;
1342 }
1343 if(random & 0x1) {
1329 *d = (uint8_t)toupper((int)*d);
1344 *d = (uint8_t)toupper((unsigned char)*d);
1330 } else {
1345 } else {
1331 *d = (uint8_t)tolower((int)*d);
1346 *d = (uint8_t)tolower((unsigned char)*d);
1332 }
1333 random >>= 1;
1334 bits--;
1335 }
1336 d++;
1337 }
1338 lablen = *d++;
1339 }

--- 4 unchanged lines hidden (view full) ---

1344 }
1345}
1346
1347/** put serviced query into a buffer */
1348static void
1349serviced_encode(struct serviced_query* sq, sldns_buffer* buff, int with_edns)
1350{
1351 /* if we are using 0x20 bits for ID randomness, perturb them */
1347 }
1348 random >>= 1;
1349 bits--;
1350 }
1351 d++;
1352 }
1353 lablen = *d++;
1354 }

--- 4 unchanged lines hidden (view full) ---

1359 }
1360}
1361
1362/** put serviced query into a buffer */
1363static void
1364serviced_encode(struct serviced_query* sq, sldns_buffer* buff, int with_edns)
1365{
1366 /* if we are using 0x20 bits for ID randomness, perturb them */
1352 if(sq->outnet->use_caps_for_id) {
1367 if(sq->outnet->use_caps_for_id && !sq->nocaps) {
1353 serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
1354 }
1355 /* generate query */
1356 sldns_buffer_clear(buff);
1357 sldns_buffer_write_u16(buff, 0); /* id placeholder */
1358 sldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
1359 sldns_buffer_flip(buff);
1360 if(with_edns) {

--- 58 unchanged lines hidden (view full) ---

1419 sq->status = serviced_query_UDP;
1420 }
1421 }
1422 serviced_encode(sq, buff, (sq->status == serviced_query_UDP_EDNS) ||
1423 (sq->status == serviced_query_UDP_EDNS_FRAG));
1424 sq->last_sent_time = *sq->outnet->now_tv;
1425 sq->edns_lame_known = (int)edns_lame_known;
1426 verbose(VERB_ALGO, "serviced query UDP timeout=%d msec", rtt);
1368 serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
1369 }
1370 /* generate query */
1371 sldns_buffer_clear(buff);
1372 sldns_buffer_write_u16(buff, 0); /* id placeholder */
1373 sldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
1374 sldns_buffer_flip(buff);
1375 if(with_edns) {

--- 58 unchanged lines hidden (view full) ---

1434 sq->status = serviced_query_UDP;
1435 }
1436 }
1437 serviced_encode(sq, buff, (sq->status == serviced_query_UDP_EDNS) ||
1438 (sq->status == serviced_query_UDP_EDNS_FRAG));
1439 sq->last_sent_time = *sq->outnet->now_tv;
1440 sq->edns_lame_known = (int)edns_lame_known;
1441 verbose(VERB_ALGO, "serviced query UDP timeout=%d msec", rtt);
1427 sq->pending = pending_udp_query(sq->outnet, buff, &sq->addr,
1428 sq->addrlen, rtt, serviced_udp_callback, sq);
1442 sq->pending = pending_udp_query(sq, buff, rtt,
1443 serviced_udp_callback, sq);
1429 if(!sq->pending)
1430 return 0;
1431 return 1;
1432}
1433
1434/** check that perturbed qname is identical */
1435static int
1436serviced_check_qname(sldns_buffer* pkt, uint8_t* qbuf, size_t qbuflen)

--- 132 unchanged lines hidden (view full) ---

1569 struct comm_reply r2;
1570 sq->pending = NULL; /* removed after this callback */
1571 if(error != NETEVENT_NOERROR)
1572 log_addr(VERB_QUERY, "tcp error for address",
1573 &sq->addr, sq->addrlen);
1574 if(error==NETEVENT_NOERROR)
1575 infra_update_tcp_works(sq->outnet->infra, &sq->addr,
1576 sq->addrlen, sq->zone, sq->zonelen);
1444 if(!sq->pending)
1445 return 0;
1446 return 1;
1447}
1448
1449/** check that perturbed qname is identical */
1450static int
1451serviced_check_qname(sldns_buffer* pkt, uint8_t* qbuf, size_t qbuflen)

--- 132 unchanged lines hidden (view full) ---

1584 struct comm_reply r2;
1585 sq->pending = NULL; /* removed after this callback */
1586 if(error != NETEVENT_NOERROR)
1587 log_addr(VERB_QUERY, "tcp error for address",
1588 &sq->addr, sq->addrlen);
1589 if(error==NETEVENT_NOERROR)
1590 infra_update_tcp_works(sq->outnet->infra, &sq->addr,
1591 sq->addrlen, sq->zone, sq->zonelen);
1592#ifdef USE_DNSTAP
1593 if(sq->outnet->dtenv &&
1594 (sq->outnet->dtenv->log_resolver_response_messages ||
1595 sq->outnet->dtenv->log_forwarder_response_messages))
1596 dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr,
1597 c->type, sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen,
1598 &sq->last_sent_time, sq->outnet->now_tv, c->buffer);
1599#endif
1577 if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS &&
1578 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1579 LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin(
1580 c->buffer)) == LDNS_RCODE_NOTIMPL) ) {
1581 /* attempt to fallback to nonEDNS */
1582 sq->status = serviced_query_TCP_EDNS_fallback;
1600 if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS &&
1601 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1602 LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin(
1603 c->buffer)) == LDNS_RCODE_NOTIMPL) ) {
1604 /* attempt to fallback to nonEDNS */
1605 sq->status = serviced_query_TCP_EDNS_fallback;
1583 serviced_tcp_initiate(sq->outnet, sq, c->buffer);
1606 serviced_tcp_initiate(sq, c->buffer);
1584 return 0;
1585 } else if(error==NETEVENT_NOERROR &&
1586 sq->status == serviced_query_TCP_EDNS_fallback &&
1587 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1588 LDNS_RCODE_NOERROR || LDNS_RCODE_WIRE(
1589 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
1590 || LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1591 == LDNS_RCODE_YXDOMAIN)) {

--- 35 unchanged lines hidden (view full) ---

1627 }
1628 memcpy(&rep->addr, &sq->addr, sq->addrlen);
1629 rep->addrlen = sq->addrlen;
1630 serviced_callbacks(sq, error, c, rep);
1631 return 0;
1632}
1633
1634static void
1607 return 0;
1608 } else if(error==NETEVENT_NOERROR &&
1609 sq->status == serviced_query_TCP_EDNS_fallback &&
1610 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1611 LDNS_RCODE_NOERROR || LDNS_RCODE_WIRE(
1612 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
1613 || LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1614 == LDNS_RCODE_YXDOMAIN)) {

--- 35 unchanged lines hidden (view full) ---

1650 }
1651 memcpy(&rep->addr, &sq->addr, sq->addrlen);
1652 rep->addrlen = sq->addrlen;
1653 serviced_callbacks(sq, error, c, rep);
1654 return 0;
1655}
1656
1657static void
1635serviced_tcp_initiate(struct outside_network* outnet,
1636 struct serviced_query* sq, sldns_buffer* buff)
1658serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff)
1637{
1638 verbose(VERB_ALGO, "initiate TCP query %s",
1639 sq->status==serviced_query_TCP_EDNS?"EDNS":"");
1640 serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1641 sq->last_sent_time = *sq->outnet->now_tv;
1659{
1660 verbose(VERB_ALGO, "initiate TCP query %s",
1661 sq->status==serviced_query_TCP_EDNS?"EDNS":"");
1662 serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1663 sq->last_sent_time = *sq->outnet->now_tv;
1642 sq->pending = pending_tcp_query(outnet, buff, &sq->addr,
1643 sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback,
1644 sq, sq->ssl_upstream);
1664 sq->pending = pending_tcp_query(sq, buff, TCP_AUTH_QUERY_TIMEOUT,
1665 serviced_tcp_callback, sq);
1645 if(!sq->pending) {
1646 /* delete from tree so that a retry by above layer does not
1647 * clash with this entry */
1648 log_err("serviced_tcp_initiate: failed to send tcp query");
1649 serviced_callbacks(sq, NETEVENT_CLOSED, NULL, NULL);
1650 }
1651}
1652

--- 7 unchanged lines hidden (view full) ---

1660 sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
1661 &rtt))
1662 return 0;
1663 if(vs != -1)
1664 sq->status = serviced_query_TCP_EDNS;
1665 else sq->status = serviced_query_TCP;
1666 serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1667 sq->last_sent_time = *sq->outnet->now_tv;
1666 if(!sq->pending) {
1667 /* delete from tree so that a retry by above layer does not
1668 * clash with this entry */
1669 log_err("serviced_tcp_initiate: failed to send tcp query");
1670 serviced_callbacks(sq, NETEVENT_CLOSED, NULL, NULL);
1671 }
1672}
1673

--- 7 unchanged lines hidden (view full) ---

1681 sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
1682 &rtt))
1683 return 0;
1684 if(vs != -1)
1685 sq->status = serviced_query_TCP_EDNS;
1686 else sq->status = serviced_query_TCP;
1687 serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1688 sq->last_sent_time = *sq->outnet->now_tv;
1668 sq->pending = pending_tcp_query(sq->outnet, buff, &sq->addr,
1669 sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback,
1670 sq, sq->ssl_upstream);
1689 sq->pending = pending_tcp_query(sq, buff, TCP_AUTH_QUERY_TIMEOUT,
1690 serviced_tcp_callback, sq);
1671 return sq->pending != NULL;
1672}
1673
1674int
1675serviced_udp_callback(struct comm_point* c, void* arg, int error,
1676 struct comm_reply* rep)
1677{
1678 struct serviced_query* sq = (struct serviced_query*)arg;

--- 44 unchanged lines hidden (view full) ---

1723 serviced_callbacks(sq, NETEVENT_TIMEOUT, c, rep);
1724 return 0;
1725 }
1726 } else if(error != NETEVENT_NOERROR) {
1727 /* udp returns error (due to no ID or interface available) */
1728 serviced_callbacks(sq, error, c, rep);
1729 return 0;
1730 }
1691 return sq->pending != NULL;
1692}
1693
1694int
1695serviced_udp_callback(struct comm_point* c, void* arg, int error,
1696 struct comm_reply* rep)
1697{
1698 struct serviced_query* sq = (struct serviced_query*)arg;

--- 44 unchanged lines hidden (view full) ---

1743 serviced_callbacks(sq, NETEVENT_TIMEOUT, c, rep);
1744 return 0;
1745 }
1746 } else if(error != NETEVENT_NOERROR) {
1747 /* udp returns error (due to no ID or interface available) */
1748 serviced_callbacks(sq, error, c, rep);
1749 return 0;
1750 }
1751#ifdef USE_DNSTAP
1752 if(outnet->dtenv &&
1753 (outnet->dtenv->log_resolver_response_messages ||
1754 outnet->dtenv->log_forwarder_response_messages))
1755 dt_msg_send_outside_response(outnet->dtenv, &sq->addr, c->type,
1756 sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen,
1757 &sq->last_sent_time, sq->outnet->now_tv, c->buffer);
1758#endif
1731 if(!fallback_tcp) {
1732 if( (sq->status == serviced_query_UDP_EDNS
1733 ||sq->status == serviced_query_UDP_EDNS_FRAG)
1734 && (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1735 == LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(
1736 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL)) {
1737 /* try to get an answer by falling back without EDNS */
1738 verbose(VERB_ALGO, "serviced query: attempt without EDNS");

--- 72 unchanged lines hidden (view full) ---

1811 /* fallback to TCP */
1812 /* this discards partial UDP contents */
1813 if(sq->status == serviced_query_UDP_EDNS ||
1814 sq->status == serviced_query_UDP_EDNS_FRAG ||
1815 sq->status == serviced_query_UDP_EDNS_fallback)
1816 /* if we have unfinished EDNS_fallback, start again */
1817 sq->status = serviced_query_TCP_EDNS;
1818 else sq->status = serviced_query_TCP;
1759 if(!fallback_tcp) {
1760 if( (sq->status == serviced_query_UDP_EDNS
1761 ||sq->status == serviced_query_UDP_EDNS_FRAG)
1762 && (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1763 == LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(
1764 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL)) {
1765 /* try to get an answer by falling back without EDNS */
1766 verbose(VERB_ALGO, "serviced query: attempt without EDNS");

--- 72 unchanged lines hidden (view full) ---

1839 /* fallback to TCP */
1840 /* this discards partial UDP contents */
1841 if(sq->status == serviced_query_UDP_EDNS ||
1842 sq->status == serviced_query_UDP_EDNS_FRAG ||
1843 sq->status == serviced_query_UDP_EDNS_fallback)
1844 /* if we have unfinished EDNS_fallback, start again */
1845 sq->status = serviced_query_TCP_EDNS;
1846 else sq->status = serviced_query_TCP;
1819 serviced_tcp_initiate(outnet, sq, c->buffer);
1847 serviced_tcp_initiate(sq, c->buffer);
1820 return 0;
1821 }
1822 /* yay! an answer */
1823 serviced_callbacks(sq, error, c, rep);
1824 return 0;
1825}
1826
1827struct serviced_query*
1828outnet_serviced_query(struct outside_network* outnet,
1829 uint8_t* qname, size_t qnamelen, uint16_t qtype, uint16_t qclass,
1848 return 0;
1849 }
1850 /* yay! an answer */
1851 serviced_callbacks(sq, error, c, rep);
1852 return 0;
1853}
1854
1855struct serviced_query*
1856outnet_serviced_query(struct outside_network* outnet,
1857 uint8_t* qname, size_t qnamelen, uint16_t qtype, uint16_t qclass,
1830 uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream,
1831 int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen,
1832 uint8_t* zone, size_t zonelen, comm_point_callback_t* callback,
1833 void* callback_arg, sldns_buffer* buff)
1858 uint16_t flags, int dnssec, int want_dnssec, int nocaps,
1859 int tcp_upstream, int ssl_upstream, struct sockaddr_storage* addr,
1860 socklen_t addrlen, uint8_t* zone, size_t zonelen,
1861 comm_point_callback_t* callback, void* callback_arg,
1862 sldns_buffer* buff)
1834{
1835 struct serviced_query* sq;
1836 struct service_callback* cb;
1837 serviced_gen_query(buff, qname, qnamelen, qtype, qclass, flags);
1838 sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen);
1839 /* duplicate entries are included in the callback list, because
1840 * there is a counterpart registration by our caller that needs to
1841 * be doubly-removed (with callbacks perhaps). */
1842 if(!(cb = (struct service_callback*)malloc(sizeof(*cb))))
1843 return NULL;
1844 if(!sq) {
1845 /* make new serviced query entry */
1863{
1864 struct serviced_query* sq;
1865 struct service_callback* cb;
1866 serviced_gen_query(buff, qname, qnamelen, qtype, qclass, flags);
1867 sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen);
1868 /* duplicate entries are included in the callback list, because
1869 * there is a counterpart registration by our caller that needs to
1870 * be doubly-removed (with callbacks perhaps). */
1871 if(!(cb = (struct service_callback*)malloc(sizeof(*cb))))
1872 return NULL;
1873 if(!sq) {
1874 /* make new serviced query entry */
1846 sq = serviced_create(outnet, buff, dnssec, want_dnssec,
1875 sq = serviced_create(outnet, buff, dnssec, want_dnssec, nocaps,
1847 tcp_upstream, ssl_upstream, addr, addrlen, zone,
1848 zonelen, (int)qtype);
1849 if(!sq) {
1850 free(cb);
1851 return NULL;
1852 }
1853 /* perform first network action */
1854 if(outnet->do_udp && !(tcp_upstream || ssl_upstream)) {

--- 169 unchanged lines hidden --- 		1876 tcp_upstream, ssl_upstream, addr, addrlen, zone,
1877 zonelen, (int)qtype);
1878 if(!sq) {
1879 free(cb);
1880 return NULL;
1881 }
1882 /* perform first network action */
1883 if(outnet->do_udp && !(tcp_upstream || ssl_upstream)) {

--- 169 unchanged lines hidden ---