Does further A lookups and uses answers.
[adns] / src / query.c
CommitLineData
e576be50 1/*
2 * query.c
3 * - overall query management (allocation, completion)
4 * - per-query memory management
5 * - query submission and cancellation (user-visible and internal)
6 */
7/*
8 * This file is part of adns, which is Copyright (C) 1997, 1998 Ian Jackson
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 */
4353a5c4 24
4bec51a4 25#include "internal.h"
656b2da9 26
e576be50 27#include <stdlib.h>
28#include <unistd.h>
29#include <errno.h>
656b2da9 30
e576be50 31#include <sys/time.h>
656b2da9 32
e576be50 33#include "internal.h"
ddfda861 34
e576be50 35int adns__internal_submit(adns_state ads, adns_query *query_r,
3955725c 36 const typeinfo *typei, vbuf *qumsg_vb, int id,
e576be50 37 adns_queryflags flags, struct timeval now,
38 adns_status failstat, const qcontext *ctx) {
39 adns_query qu;
e576be50 40
41 qu= malloc(sizeof(*qu)); if (!qu) goto x_nomemory;
42 qu->answer= malloc(sizeof(*qu->answer)); if (!qu->answer) goto x_freequ_nomemory;
43
3955725c 44 qu->ads= ads;
e576be50 45 qu->state= query_udp;
46 qu->back= qu->next= qu->parent= 0;
47 LIST_INIT(qu->children);
48 qu->siblings.next= qu->siblings.back= 0;
551ff40f 49 LIST_INIT(qu->allocations);
e576be50 50 qu->interim_allocd= 0;
3955725c 51 qu->final_allocspace= 0;
e576be50 52
3955725c 53 qu->typei= typei;
e576be50 54 adns__vbuf_init(&qu->vb);
55
56 qu->cname_dgram= 0;
57 qu->cname_dglen= qu->cname_begin= 0;
4bec51a4 58
e576be50 59 qu->id= id;
60 qu->flags= flags;
61 qu->udpretries= 0;
62 qu->udpnextserver= 0;
63 qu->udpsent= qu->tcpfailed= 0;
64 timerclear(&qu->timeout);
65 memcpy(&qu->context,ctx,sizeof(qu->context));
e576be50 66
67 qu->answer->status= adns_s_ok;
68 qu->answer->cname= 0;
3955725c 69 qu->answer->type= typei->type;
e576be50 70 qu->answer->nrrs= 0;
71 qu->answer->rrs= 0;
3955725c 72 qu->answer->rrsz= typei->rrsz;
e576be50 73
74 *query_r= qu;
ddfda861 75
a49a6d7b 76 qu->query_dglen= qumsg_vb->used;
77 if (qumsg_vb->used) {
78 qu->query_dgram= malloc(qumsg_vb->used);
79 if (!qu->query_dgram) {
80 adns__query_fail(qu,adns_s_nolocalmem);
81 return adns_s_ok;
82 }
83 memcpy(qu->query_dgram,qumsg_vb->buf,qumsg_vb->used);
84 } else {
85 qu->query_dgram= 0;
ddfda861 86 }
e576be50 87 qu->vb= *qumsg_vb;
88 adns__vbuf_init(qumsg_vb);
89
90 if (failstat) {
3955725c 91 adns__query_fail(qu,failstat);
92 return adns_s_ok;
656b2da9 93 }
3955725c 94 adns__query_udp(qu,now);
e576be50 95 adns__autosys(ads,now);
96
3955725c 97 return adns_s_ok;
e576be50 98
99 x_freequ_nomemory:
100 free(qu);
101 x_nomemory:
3955725c 102 adns__vbuf_free(qumsg_vb);
103 return adns_s_nolocalmem;
4bec51a4 104}
105
e576be50 106int adns_submit(adns_state ads,
107 const char *owner,
108 adns_rrtype type,
109 adns_queryflags flags,
110 void *context,
111 adns_query *query_r) {
112 qcontext ctx;
3955725c 113 int id, r, ol;
e576be50 114 vbuf vb;
3955725c 115 adns_status stat;
116 const typeinfo *typei;
117 struct timeval now;
e576be50 118
3955725c 119 typei= adns__findtype(type);
120 if (!typei) return adns_s_notimplemented;
121
e576be50 122 ctx.ext= context;
123 r= gettimeofday(&now,0); if (r) return errno;
124 id= 0;
125
126 adns__vbuf_init(&vb);
127
128 ol= strlen(owner);
ffbda80c 129 if (ol<=1 || ol>DNS_MAXDOMAIN+1) { stat= adns_s_domaintoolong; goto xit; }
e576be50 130
131 if (owner[ol-1]=='.' && owner[ol-2]!='\\') { flags &= ~adns_qf_search; ol--; }
132
3955725c 133 stat= adns__mkquery(ads,&vb,&id, owner,ol, typei,flags);
e576be50 134
135 xit:
3955725c 136 return adns__internal_submit(ads,query_r, typei,&vb,id, flags,now, stat,&ctx);
ddfda861 137}
138
e576be50 139int adns_synchronous(adns_state ads,
140 const char *owner,
141 adns_rrtype type,
142 adns_queryflags flags,
143 adns_answer **answer_r) {
144 adns_query qu;
145 int r;
146
147 r= adns_submit(ads,owner,type,flags,0,&qu);
148 if (r) return r;
4bec51a4 149
88372443 150 r= adns_wait(ads,&qu,answer_r,0);
3955725c 151 if (r) adns_cancel(qu);
ddfda861 152
88372443 153 return r;
e576be50 154}
155
f759e52e 156static void *alloc_common(adns_query qu, size_t sz) {
e576be50 157 allocnode *an;
158
a49a6d7b 159 if (!sz) return qu; /* Any old pointer will do */
e576be50 160 assert(!qu->final_allocspace);
e576be50 161 an= malloc(MEM_ROUND(MEM_ROUND(sizeof(*an)) + sz));
e062dcae 162 if (!an) return 0;
551ff40f 163 LIST_LINK_TAIL(qu->allocations,an);
e576be50 164 return (byte*)an + MEM_ROUND(sizeof(*an));
165}
4bec51a4 166
f759e52e 167void *adns__alloc_interim(adns_query qu, size_t sz) {
168 sz= MEM_ROUND(sz);
169 qu->interim_allocd += sz;
170 return alloc_common(qu,sz);
171}
172
173void *adns__alloc_mine(adns_query qu, size_t sz) {
174 return alloc_common(qu,MEM_ROUND(sz));
175}
176
551ff40f 177void adns__transfer_interim(adns_query from, adns_query to, void *block, size_t sz) {
178 allocnode *an;
179
180 if (!block) return;
181 an= (void*)((byte*)block - MEM_ROUND(sizeof(*an)));
182
183 assert(!to->final_allocspace);
184 assert(!from->final_allocspace);
185
186 LIST_UNLINK(from->allocations,an);
187 LIST_LINK_TAIL(to->allocations,an);
188
189 from->interim_allocd -= sz;
190 to->interim_allocd += sz;
191}
192
e576be50 193void *adns__alloc_final(adns_query qu, size_t sz) {
194 /* When we're in the _final stage, we _subtract_ from interim_alloc'd
195 * each allocation, and use final_allocspace to point to the next free
196 * bit.
197 */
198 void *rp;
199
200 sz= MEM_ROUND(sz);
201 rp= qu->final_allocspace;
202 assert(rp);
203 qu->interim_allocd -= sz;
204 assert(qu->interim_allocd>=0);
205 qu->final_allocspace= (byte*)rp + sz;
206 return rp;
207}
208
3955725c 209void adns__reset_cnameonly(adns_query qu) {
88372443 210 /* fixme: cancel children */
9557e604 211 assert(!qu->final_allocspace);
e576be50 212 qu->answer->nrrs= 0;
213 qu->answer->rrs= 0;
214 qu->interim_allocd= qu->answer->cname ? MEM_ROUND(strlen(qu->answer->cname)+1) : 0;
4353a5c4 215}
216
88372443 217static void free_query_allocs(adns_query qu) {
218 allocnode *an, *ann;
219 adns_query cqu, ncqu;
220
221 for (cqu= qu->children.head; cqu; cqu= ncqu) {
222 ncqu= cqu->siblings.next;
223 adns_cancel(cqu);
224 }
551ff40f 225 for (an= qu->allocations.head; an; an= ann) { ann= an->next; free(an); }
88372443 226 adns__vbuf_free(&qu->vb);
227}
228
1dfe95d8 229void adns_cancel(adns_query qu) {
88372443 230 switch (qu->state) {
231 case query_udp: case query_tcpwait: case query_tcpsent:
1dfe95d8 232 LIST_UNLINK(qu->ads->timew,qu);
88372443 233 break;
234 case query_child:
1dfe95d8 235 LIST_UNLINK(qu->ads->childw,qu);
88372443 236 break;
237 case query_done:
1dfe95d8 238 LIST_UNLINK(qu->ads->output,qu);
88372443 239 break;
240 default:
241 abort();
242 }
243 free_query_allocs(qu);
244 free(qu->answer);
245 free(qu);
246}
551ff40f 247
248static void makefinal_query(adns_query qu) {
98a3f706 249 adns_answer *ans;
88372443 250 int rrn;
8e5b0abb 251
88372443 252 ans= qu->answer;
551ff40f 253
88372443 254 if (qu->interim_allocd) {
88372443 255 ans= realloc(qu->answer, MEM_ROUND(MEM_ROUND(sizeof(*ans)) + qu->interim_allocd));
551ff40f 256 if (!ans) goto x_nomem;
e062dcae 257 qu->answer= ans;
258 }
8e5b0abb 259
88372443 260 qu->final_allocspace= (byte*)ans + MEM_ROUND(sizeof(*ans));
8e5b0abb 261 adns__makefinal_str(qu,&ans->cname);
88372443 262
8e5b0abb 263 if (ans->nrrs) {
88372443 264 adns__makefinal_block(qu, &ans->rrs.untyped, ans->nrrs*ans->rrsz);
8e5b0abb 265
88372443 266 for (rrn=0; rrn<ans->nrrs; rrn++)
267 qu->typei->makefinal(qu, ans->rrs.bytes + rrn*ans->rrsz);
88372443 268 }
551ff40f 269
88372443 270 free_query_allocs(qu);
551ff40f 271 return;
8e5b0abb 272
551ff40f 273 x_nomem:
274 qu->answer->status= adns_s_nolocalmem;
275 qu->answer->cname= 0;
276 adns__reset_cnameonly(qu);
277 free_query_allocs(qu);
278}
279
280void adns__query_done(adns_query qu) {
281 adns_answer *ans;
282 adns_query parent;
283
4353a5c4 284 qu->id= -1;
551ff40f 285 ans= qu->answer;
286
287 if (ans->nrrs && qu->typei->diff_needswap) {
288 if (!adns__vbuf_ensure(&qu->vb,qu->typei->rrsz)) {
289 adns__query_fail(qu,adns_s_nolocalmem);
290 return;
291 }
292 adns__isort(ans->rrs.bytes, ans->nrrs, ans->rrsz,
293 qu->vb.buf, qu->typei->diff_needswap);
294 }
e553d072 295
551ff40f 296 parent= qu->parent;
297 if (parent) {
298 LIST_UNLINK_PART(parent->children,qu,siblings.);
299 qu->context.intern.callback(parent,qu);
300 free_query_allocs(qu);
301 free(qu);
302 if (!parent->children.head) adns__query_done(parent);
303 } else {
304 makefinal_query(qu);
305 LIST_LINK_TAIL(qu->ads->output,qu);
306 }
656b2da9 307}
308
3955725c 309void adns__query_fail(adns_query qu, adns_status stat) {
310 adns__reset_cnameonly(qu);
8e5b0abb 311 qu->answer->status= stat;
3955725c 312 adns__query_done(qu);
656b2da9 313}
e576be50 314
315void adns__makefinal_str(adns_query qu, char **strp) {
316 int l;
317 char *before, *after;
318
319 before= *strp;
9557e604 320 if (!before) return;
e576be50 321 l= strlen(before)+1;
322 after= adns__alloc_final(qu,l);
323 memcpy(after,before,l);
324 *strp= after;
325}
326
3955725c 327void adns__makefinal_block(adns_query qu, void **blpp, size_t sz) {
9557e604 328 void *before, *after;
e576be50 329
9557e604 330 before= *blpp;
331 if (!before) return;
e576be50 332 after= adns__alloc_final(qu,sz);
9557e604 333 memcpy(after,before,sz);
e576be50 334 *blpp= after;
335}