Little checkin problem in last patch.
[kopensolaris-gnu/glibc.git] / hesiod / hesiod.c
1 #if defined(LIBC_SCCS) && !defined(lint)
2 static const char rcsid[] = "$BINDId: hesiod.c,v 1.21 2000/02/28 14:51:08 vixie Exp $";
3 #endif
4
5 /*
6  * Copyright (c) 1996,1999 by Internet Software Consortium.
7  *
8  * Permission to use, copy, modify, and distribute this software for any
9  * purpose with or without fee is hereby granted, provided that the above
10  * copyright notice and this permission notice appear in all copies.
11  *
12  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
13  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
14  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
15  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
18  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
19  * SOFTWARE.
20  */
21
22 /*
23  * This file is primarily maintained by <tytso@mit.edu> and <ghudson@mit.edu>.
24  */
25
26 /*
27  * hesiod.c --- the core portion of the hesiod resolver.
28  *
29  * This file is derived from the hesiod library from Project Athena;
30  * It has been extensively rewritten by Theodore Ts'o to have a more
31  * thread-safe interface.
32  */
33
34 /* Imports */
35
36 #include <sys/types.h>
37 #include <netinet/in.h>
38 #include <arpa/nameser.h>
39
40 #include <errno.h>
41 #include <netdb.h>
42 #include <resolv.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46
47 #include "hesiod.h"
48 #include "hesiod_p.h"
49 #undef DEF_RHS
50
51 #define _PATH_HESIOD_CONF "/etc/hesiod.conf"
52
53 /* Forward */
54
55 int             hesiod_init(void **context);
56 void            hesiod_end(void *context);
57 char *          hesiod_to_bind(void *context, const char *name,
58                                const char *type);
59 char **         hesiod_resolve(void *context, const char *name,
60                                const char *type);
61 void            hesiod_free_list(void *context, char **list);
62
63 static int      parse_config_file(struct hesiod_p *ctx, const char *filename);
64 static char **  get_txt_records(struct hesiod_p *ctx, int class,
65                                 const char *name);
66 static int      init(struct hesiod_p *ctx);
67
68 /* Public */
69
70 /*
71  * This function is called to initialize a hesiod_p.
72  */
73 int
74 hesiod_init(void **context) {
75         struct hesiod_p *ctx;
76         const char *configname;
77         char *cp;
78
79         ctx = malloc(sizeof(struct hesiod_p));
80         if (ctx == 0)
81                 return (-1);
82
83         ctx->LHS = NULL;
84         ctx->RHS = NULL;
85         ctx->res = NULL;
86         /* Set default query classes. */
87         ctx->classes[0] = C_IN;
88         ctx->classes[1] = C_HS;
89
90         configname = __secure_getenv("HESIOD_CONFIG");
91         if (!configname)
92           configname = _PATH_HESIOD_CONF;
93         if (parse_config_file(ctx, configname) < 0) {
94 #ifdef DEF_RHS
95                 /*
96                  * Use compiled in defaults.
97                  */
98                 ctx->LHS = malloc(strlen(DEF_LHS)+1);
99                 ctx->RHS = malloc(strlen(DEF_RHS)+1);
100                 if (ctx->LHS == 0 || ctx->RHS == 0)
101                         goto cleanup;
102                 strcpy(ctx->LHS, DEF_LHS);
103                 strcpy(ctx->RHS, DEF_RHS);
104 #else
105                 goto cleanup;
106 #endif
107         }
108         /*
109          * The default RHS can be overridden by an environment
110          * variable.
111          */
112         if ((cp = __secure_getenv("HES_DOMAIN")) != NULL) {
113                 free(ctx->RHS);
114                 ctx->RHS = malloc(strlen(cp)+2);
115                 if (!ctx->RHS)
116                         goto cleanup;
117                 if (cp[0] == '.')
118                         strcpy(ctx->RHS, cp);
119                 else {
120                         ctx->RHS[0] = '.';
121                         strcpy(ctx->RHS + 1, cp);
122                 }
123         }
124
125         /*
126          * If there is no default hesiod realm set, we return an
127          * error.
128          */
129         if (!ctx->RHS) {
130                 __set_errno(ENOEXEC);
131                 goto cleanup;
132         }
133
134 #if 0
135         if (res_ninit(ctx->res) < 0)
136                 goto cleanup;
137 #endif
138
139         *context = ctx;
140         return (0);
141
142  cleanup:
143         hesiod_end(ctx);
144         return (-1);
145 }
146
147 /*
148  * This function deallocates the hesiod_p
149  */
150 void
151 hesiod_end(void *context) {
152         struct hesiod_p *ctx = (struct hesiod_p *) context;
153         int save_errno = errno;
154
155         if (ctx->res)
156                 res_nclose(ctx->res);
157         free(ctx->RHS);
158         free(ctx->LHS);
159         if (ctx->res && ctx->free_res)
160                 (*ctx->free_res)(ctx->res);
161         free(ctx);
162         __set_errno(save_errno);
163 }
164
165 /*
166  * This function takes a hesiod (name, type) and returns a DNS
167  * name which is to be resolved.
168  */
169 char *
170 hesiod_to_bind(void *context, const char *name, const char *type) {
171         struct hesiod_p *ctx = (struct hesiod_p *) context;
172         char *bindname;
173         char **rhs_list = NULL;
174         const char *RHS, *cp;
175         char *endp;
176
177         /* Decide what our RHS is, and set cp to the end of the actual name. */
178         if ((cp = strchr(name, '@')) != NULL) {
179                 if (strchr(cp + 1, '.'))
180                         RHS = cp + 1;
181                 else if ((rhs_list = hesiod_resolve(context, cp + 1,
182                     "rhs-extension")) != NULL)
183                         RHS = *rhs_list;
184                 else {
185                         __set_errno(ENOENT);
186                         return (NULL);
187                 }
188         } else {
189                 RHS = ctx->RHS;
190                 cp = name + strlen(name);
191         }
192
193         /*
194          * Allocate the space we need, including up to three periods and
195          * the terminating NUL.
196          */
197         if ((bindname = malloc((cp - name) + strlen(type) + strlen(RHS) +
198             (ctx->LHS ? strlen(ctx->LHS) : 0) + 4)) == NULL) {
199                 if (rhs_list)
200                         hesiod_free_list(context, rhs_list);
201                 return NULL;
202         }
203
204         /* Now put together the DNS name. */
205         endp = (char *) __mempcpy (bindname, name, cp - name);
206         *endp++ = '.';
207         endp = (char *) __stpcpy (endp, type);
208         if (ctx->LHS) {
209                 if (ctx->LHS[0] != '.')
210                         *endp++ = '.';
211                 endp = __stpcpy (endp, ctx->LHS);
212         }
213         if (RHS[0] != '.')
214                 *endp++ = '.';
215         strcpy (endp, RHS);
216
217         if (rhs_list)
218                 hesiod_free_list(context, rhs_list);
219
220         return (bindname);
221 }
222
223 /*
224  * This is the core function.  Given a hesiod (name, type), it
225  * returns an array of strings returned by the resolver.
226  */
227 char **
228 hesiod_resolve(void *context, const char *name, const char *type) {
229         struct hesiod_p *ctx = (struct hesiod_p *) context;
230         char *bindname = hesiod_to_bind(context, name, type);
231         char **retvec;
232
233         if (bindname == NULL)
234                 return (NULL);
235         if (init(ctx) == -1) {
236                 free(bindname);
237                 return (NULL);
238         }
239
240         retvec = get_txt_records(ctx, ctx->classes[0], bindname);
241
242         if (retvec == NULL && (errno == ENOENT || errno == ECONNREFUSED) && ctx->classes[1])
243                 retvec = get_txt_records(ctx, ctx->classes[1], bindname);
244
245
246         free(bindname);
247         return (retvec);
248 }
249
250 void
251 hesiod_free_list(void *context, char **list) {
252         char **p;
253
254         for (p = list; *p; p++)
255                 free(*p);
256         free(list);
257 }
258
259 /*
260  * This function parses the /etc/hesiod.conf file
261  */
262 static int
263 parse_config_file(struct hesiod_p *ctx, const char *filename) {
264         char buf[MAXDNAME+7];
265         FILE *fp;
266
267         /*
268          * Clear the existing configuration variable, just in case
269          * they're set.
270          */
271         free(ctx->RHS);
272         free(ctx->LHS);
273         ctx->RHS = ctx->LHS = 0;
274         /* Set default query classes. */
275         ctx->classes[0] = C_IN;
276         ctx->classes[1] = C_HS;
277
278         /*
279          * Now open and parse the file...
280          */
281         if (!(fp = fopen(filename, "r")))
282                 return (-1);
283
284         while (fgets(buf, sizeof(buf), fp) != NULL) {
285                 char *key, *data, *cp, **cpp;
286
287                 cp = buf;
288                 if (*cp == '#' || *cp == '\n' || *cp == '\r')
289                         continue;
290                 while(*cp == ' ' || *cp == '\t')
291                         cp++;
292                 key = cp;
293                 while(*cp != ' ' && *cp != '\t' && *cp != '=')
294                         cp++;
295                 *cp++ = '\0';
296
297                 while(*cp == ' ' || *cp == '\t' || *cp == '=')
298                         cp++;
299                 data = cp;
300                 while(*cp != ' ' && *cp != '\n' && *cp != '\r')
301                         cp++;
302                 *cp++ = '\0';
303
304                 cpp = NULL;
305                 if (strcasecmp(key, "lhs") == 0)
306                         cpp = &ctx->LHS;
307                 else if (strcasecmp(key, "rhs") == 0)
308                         cpp = &ctx->RHS;
309                 if (cpp) {
310                         *cpp = strdup(data);
311                         if (!*cpp)
312                                 goto cleanup;
313                 } else if (strcasecmp(key, "classes") == 0) {
314                         int n = 0;
315                         while (*data && n < 2) {
316                                 cp = strchrnul(data, ',');
317                                 if (*cp != '\0')
318                                         *cp++ = '\0';
319                                 if (strcasecmp(data, "IN") == 0)
320                                         ctx->classes[n++] = C_IN;
321                                 else if (strcasecmp(data, "HS") == 0)
322                                         ctx->classes[n++] = C_HS;
323                                 data = cp;
324                         }
325                         if (n == 0) {
326                                 /* Restore the default.  Better than
327                                    nother at all.  */
328                                 ctx->classes[0] = C_IN;
329                                 ctx->classes[1] = C_HS;
330                         } else if (n == 1
331                                    || ctx->classes[0] == ctx->classes[1])
332                                 ctx->classes[1] = 0;
333                 }
334         }
335         fclose(fp);
336         return (0);
337
338  cleanup:
339         fclose(fp);
340         free(ctx->RHS);
341         free(ctx->LHS);
342         ctx->RHS = ctx->LHS = 0;
343         return (-1);
344 }
345
346 /*
347  * Given a DNS class and a DNS name, do a lookup for TXT records, and
348  * return a list of them.
349  */
350 static char **
351 get_txt_records(struct hesiod_p *ctx, int class, const char *name) {
352         struct {
353                 int type;               /* RR type */
354                 int class;              /* RR class */
355                 int dlen;               /* len of data section */
356                 u_char *data;           /* pointer to data */
357         } rr;
358         HEADER *hp;
359         u_char qbuf[MAX_HESRESP], abuf[MAX_HESRESP];
360         u_char *cp, *erdata, *eom;
361         char *dst, *edst, **list;
362         int ancount, qdcount;
363         int i, j, n, skip;
364
365         /*
366          * Construct the query and send it.
367          */
368         n = res_nmkquery(ctx->res, QUERY, name, class, T_TXT, NULL, 0,
369                          NULL, qbuf, MAX_HESRESP);
370         if (n < 0) {
371                 __set_errno(EMSGSIZE);
372                 return (NULL);
373         }
374         n = res_nsend(ctx->res, qbuf, n, abuf, MAX_HESRESP);
375         if (n < 0) {
376                 __set_errno(ECONNREFUSED);
377                 return (NULL);
378         }
379         if (n < HFIXEDSZ) {
380                 __set_errno(EMSGSIZE);
381                 return (NULL);
382         }
383
384         /*
385          * OK, parse the result.
386          */
387         hp = (HEADER *) abuf;
388         ancount = ntohs(hp->ancount);
389         qdcount = ntohs(hp->qdcount);
390         cp = abuf + sizeof(HEADER);
391         eom = abuf + n;
392
393         /* Skip query, trying to get to the answer section which follows. */
394         for (i = 0; i < qdcount; i++) {
395                 skip = dn_skipname(cp, eom);
396                 if (skip < 0 || cp + skip + QFIXEDSZ > eom) {
397                         __set_errno(EMSGSIZE);
398                         return (NULL);
399                 }
400                 cp += skip + QFIXEDSZ;
401         }
402
403         list = malloc((ancount + 1) * sizeof(char *));
404         if (!list)
405                 return (NULL);
406         j = 0;
407         for (i = 0; i < ancount; i++) {
408                 skip = dn_skipname(cp, eom);
409                 if (skip < 0) {
410                         __set_errno(EMSGSIZE);
411                         goto cleanup;
412                 }
413                 cp += skip;
414                 if (cp + 3 * INT16SZ + INT32SZ > eom) {
415                         __set_errno(EMSGSIZE);
416                         goto cleanup;
417                 }
418                 rr.type = ns_get16(cp);
419                 cp += INT16SZ;
420                 rr.class = ns_get16(cp);
421                 cp += INT16SZ + INT32SZ;        /* skip the ttl, too */
422                 rr.dlen = ns_get16(cp);
423                 cp += INT16SZ;
424                 if (cp + rr.dlen > eom) {
425                         __set_errno(EMSGSIZE);
426                         goto cleanup;
427                 }
428                 rr.data = cp;
429                 cp += rr.dlen;
430                 if (rr.class != class || rr.type != T_TXT)
431                         continue;
432                 if (!(list[j] = malloc(rr.dlen)))
433                         goto cleanup;
434                 dst = list[j++];
435                 edst = dst + rr.dlen;
436                 erdata = rr.data + rr.dlen;
437                 cp = rr.data;
438                 while (cp < erdata) {
439                         n = (unsigned char) *cp++;
440                         if (cp + n > eom || dst + n > edst) {
441                                 __set_errno(EMSGSIZE);
442                                 goto cleanup;
443                         }
444                         memcpy(dst, cp, n);
445                         cp += n;
446                         dst += n;
447                 }
448                 if (cp != erdata) {
449                         __set_errno(EMSGSIZE);
450                         goto cleanup;
451                 }
452                 *dst = '\0';
453         }
454         list[j] = NULL;
455         if (j == 0) {
456                 __set_errno(ENOENT);
457                 goto cleanup;
458         }
459         return (list);
460
461  cleanup:
462         for (i = 0; i < j; i++)
463                 free(list[i]);
464         free(list);
465         return (NULL);
466 }
467
468 struct __res_state *
469 __hesiod_res_get(void *context) {
470         struct hesiod_p *ctx = context;
471
472         if (!ctx->res) {
473                 struct __res_state *res;
474                 res = (struct __res_state *)calloc(1, sizeof *res);
475                 if (res == NULL)
476                         return (NULL);
477                 __hesiod_res_set(ctx, res, free);
478         }
479
480         return (ctx->res);
481 }
482
483 void
484 __hesiod_res_set(void *context, struct __res_state *res,
485                  void (*free_res)(void *)) {
486         struct hesiod_p *ctx = context;
487
488         if (ctx->res && ctx->free_res) {
489                 res_nclose(ctx->res);
490                 (*ctx->free_res)(ctx->res);
491         }
492
493         ctx->res = res;
494         ctx->free_res = free_res;
495 }
496
497 static int
498 init(struct hesiod_p *ctx) {
499
500         if (!ctx->res && !__hesiod_res_get(ctx))
501                 return (-1);
502
503         if (__res_maybe_init (ctx->res, 0) == -1)
504                 return (-1);
505
506         return (0);
507 }