lib: dns: Clean up allocated structure on error exit.
[sfrench/samba-autobuild/.git] / lib / addns / dnsrecord.c
1 /*
2   Linux DNS client library implementation
3   Copyright (C) 2006 Krishna Ganugapati <krishnag@centeris.com>
4   Copyright (C) 2006 Gerald Carter <jerry@samba.org>
5
6      ** NOTE! The following LGPL license applies to the libaddns
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9
10   This library is free software; you can redistribute it and/or
11   modify it under the terms of the GNU Lesser General Public
12   License as published by the Free Software Foundation; either
13   version 2.1 of the License, or (at your option) any later version.
14
15   This library 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 GNU
18   Lesser General Public License for more details.
19
20   You should have received a copy of the GNU Lesser General Public
21   License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "dns.h"
25 #include "lib/util/genrand.h"
26
27 DNS_ERROR dns_create_query( TALLOC_CTX *mem_ctx, const char *name,
28                             uint16_t q_type, uint16_t q_class,
29                             struct dns_request **preq )
30 {
31         struct dns_request *req = NULL;
32         struct dns_question *q = NULL;
33         DNS_ERROR err;
34
35         if (!(req = talloc_zero(mem_ctx, struct dns_request)) ||
36             !(req->questions = talloc_array(req, struct dns_question *, 1)) ||
37             !(req->questions[0] = talloc(req->questions,
38                                          struct dns_question))) {
39                 TALLOC_FREE(req);
40                 return ERROR_DNS_NO_MEMORY;
41         }
42
43         generate_random_buffer((uint8_t *)&req->id, sizeof(req->id));
44
45         req->num_questions = 1;
46         q = req->questions[0];
47
48         err = dns_domain_name_from_string(q, name, &q->name);
49         if (!ERR_DNS_IS_OK(err)) {
50                 TALLOC_FREE(req);
51                 return err;
52         }
53
54         q->q_type = q_type;
55         q->q_class = q_class;
56
57         *preq = req;
58         return ERROR_DNS_SUCCESS;
59 }
60
61 DNS_ERROR dns_create_update( TALLOC_CTX *mem_ctx, const char *name,
62                              struct dns_update_request **preq )
63 {
64         struct dns_update_request *req = NULL;
65         struct dns_zone *z = NULL;
66         DNS_ERROR err;
67
68         if (!(req = talloc_zero(mem_ctx, struct dns_update_request)) ||
69             !(req->zones = talloc_array(req, struct dns_zone *, 1)) ||
70             !(req->zones[0] = talloc(req->zones, struct dns_zone))) {
71                 TALLOC_FREE(req);
72                 return ERROR_DNS_NO_MEMORY;
73         }
74
75         req->id = random();
76         req->flags = 0x2800;    /* Dynamic update */
77
78         req->num_zones = 1;
79         z = req->zones[0];
80
81         err = dns_domain_name_from_string(z, name, &z->name);
82         if (!ERR_DNS_IS_OK(err)) {
83                 TALLOC_FREE(req);
84                 return err;
85         }
86
87         z->z_type = QTYPE_SOA;
88         z->z_class = DNS_CLASS_IN;
89
90         *preq = req;
91         return ERROR_DNS_SUCCESS;
92 }
93
94 DNS_ERROR dns_create_rrec(TALLOC_CTX *mem_ctx, const char *name,
95                           uint16_t type, uint16_t r_class, uint32_t ttl,
96                           uint16_t data_length, uint8_t *data,
97                           struct dns_rrec **prec)
98 {
99         struct dns_rrec *rec = NULL;
100         DNS_ERROR err;
101
102         if (!(rec = talloc(mem_ctx, struct dns_rrec))) {
103                 return ERROR_DNS_NO_MEMORY;
104         }
105
106         err = dns_domain_name_from_string(rec, name, &rec->name);
107         if (!(ERR_DNS_IS_OK(err))) {
108                 TALLOC_FREE(rec);
109                 return err;
110         }
111
112         rec->type = type;
113         rec->r_class = r_class;
114         rec->ttl = ttl;
115         rec->data_length = data_length;
116         rec->data = talloc_move(rec, &data);
117
118         *prec = rec;
119         return ERROR_DNS_SUCCESS;
120 }
121
122 DNS_ERROR dns_create_a_record(TALLOC_CTX *mem_ctx, const char *host,
123                               uint32_t ttl, const struct sockaddr_storage *pss,
124                               struct dns_rrec **prec)
125 {
126         uint8_t *data;
127         DNS_ERROR err;
128         struct in_addr ip;
129
130         if (pss->ss_family != AF_INET) {
131                 return ERROR_DNS_INVALID_PARAMETER;
132         }
133
134         ip = ((const struct sockaddr_in *)pss)->sin_addr;
135         if (!(data = (uint8_t *)talloc_memdup(mem_ctx, (const void *)&ip.s_addr,
136                                             sizeof(ip.s_addr)))) {
137                 return ERROR_DNS_NO_MEMORY;
138         }
139
140         err = dns_create_rrec(mem_ctx, host, QTYPE_A, DNS_CLASS_IN, ttl,
141                               sizeof(ip.s_addr), data, prec);
142
143         if (!ERR_DNS_IS_OK(err)) {
144                 TALLOC_FREE(data);
145         }
146
147         return err;
148 }
149
150 DNS_ERROR dns_create_aaaa_record(TALLOC_CTX *mem_ctx, const char *host,
151                                  uint32_t ttl, const struct sockaddr_storage *pss,
152                                  struct dns_rrec **prec)
153 {
154 #ifdef HAVE_IPV6
155         uint8_t *data;
156         DNS_ERROR err;
157         struct in6_addr ip6;
158
159         if (pss->ss_family != AF_INET6) {
160                 return ERROR_DNS_INVALID_PARAMETER;
161         }
162
163         ip6 = ((const struct sockaddr_in6 *)pss)->sin6_addr;
164         if (!(data = (uint8_t *)talloc_memdup(mem_ctx, (const void *)&ip6.s6_addr,
165                                             sizeof(ip6.s6_addr)))) {
166                 return ERROR_DNS_NO_MEMORY;
167         }
168
169         err = dns_create_rrec(mem_ctx, host, QTYPE_AAAA, DNS_CLASS_IN, ttl,
170                               sizeof(ip6.s6_addr), data, prec);
171
172         if (!ERR_DNS_IS_OK(err)) {
173                 TALLOC_FREE(data);
174         }
175
176         return err;
177 #else
178         return ERROR_DNS_INVALID_PARAMETER;
179 #endif
180 }
181
182 DNS_ERROR dns_create_name_in_use_record(TALLOC_CTX *mem_ctx,
183                                         const char *name,
184                                         const struct sockaddr_storage *ss,
185                                         struct dns_rrec **prec)
186 {
187         if (ss != NULL) {
188                 switch (ss->ss_family) {
189                 case AF_INET:
190                         return dns_create_a_record(mem_ctx, name, 0, ss, prec);
191 #ifdef HAVE_IPV6
192                 case AF_INET6:
193                         return dns_create_aaaa_record(mem_ctx, name, 0, ss, prec);
194 #endif
195                 default:
196                         return ERROR_DNS_INVALID_PARAMETER;
197                 }
198         }
199
200         return dns_create_rrec(mem_ctx, name, QTYPE_ANY, DNS_CLASS_IN, 0, 0,
201                                NULL, prec);
202 }
203
204 DNS_ERROR dns_create_name_not_in_use_record(TALLOC_CTX *mem_ctx,
205                                             const char *name, uint32_t type,
206                                             struct dns_rrec **prec)
207 {
208         return dns_create_rrec(mem_ctx, name, type, DNS_CLASS_NONE, 0,
209                                0, NULL, prec);
210 }
211
212 DNS_ERROR dns_create_delete_record(TALLOC_CTX *mem_ctx, const char *name,
213                                    uint16_t type, uint16_t r_class,
214                                    struct dns_rrec **prec)
215 {
216         return dns_create_rrec(mem_ctx, name, type, r_class, 0, 0, NULL, prec);
217 }
218
219 DNS_ERROR dns_create_tkey_record(TALLOC_CTX *mem_ctx, const char *keyname,
220                                  const char *algorithm_name, time_t inception,
221                                  time_t expiration, uint16_t mode, uint16_t error,
222                                  uint16_t key_length, const uint8_t *key,
223                                  struct dns_rrec **prec)
224 {
225         struct dns_buffer *buf = NULL;
226         struct dns_domain_name *algorithm = NULL;
227         DNS_ERROR err;
228
229         if (!(buf = dns_create_buffer(mem_ctx))) {
230                 return ERROR_DNS_NO_MEMORY;
231         }
232
233         err = dns_domain_name_from_string(buf, algorithm_name, &algorithm);
234         if (!ERR_DNS_IS_OK(err)) goto error;
235
236         dns_marshall_domain_name(buf, algorithm);
237         dns_marshall_uint32(buf, inception);
238         dns_marshall_uint32(buf, expiration);
239         dns_marshall_uint16(buf, mode);
240         dns_marshall_uint16(buf, error);
241         dns_marshall_uint16(buf, key_length);
242         dns_marshall_buffer(buf, key, key_length);
243         dns_marshall_uint16(buf, 0); /* Other Size */
244
245         if (!ERR_DNS_IS_OK(buf->error)) {
246                 err = buf->error;
247                 goto error;
248         }
249
250         err = dns_create_rrec(mem_ctx, keyname, QTYPE_TKEY, DNS_CLASS_ANY, 0,
251                               buf->offset, buf->data, prec);
252
253  error:
254         TALLOC_FREE(buf);
255         return err;
256 }
257
258 DNS_ERROR dns_unmarshall_tkey_record(TALLOC_CTX *mem_ctx, struct dns_rrec *rec,
259                                      struct dns_tkey_record **ptkey)
260 {
261         struct dns_tkey_record *tkey;
262         struct dns_buffer buf;
263         uint32_t tmp_inception, tmp_expiration;
264         
265         if (!(tkey = talloc(mem_ctx, struct dns_tkey_record))) {
266                 return ERROR_DNS_NO_MEMORY;
267         }
268
269         buf.data = rec->data;
270         buf.size = rec->data_length;
271         buf.offset = 0;
272         buf.error = ERROR_DNS_SUCCESS;
273
274         dns_unmarshall_domain_name(tkey, &buf, &tkey->algorithm);
275         dns_unmarshall_uint32(&buf, &tmp_inception);
276         dns_unmarshall_uint32(&buf, &tmp_expiration);
277         dns_unmarshall_uint16(&buf, &tkey->mode);
278         dns_unmarshall_uint16(&buf, &tkey->error);
279         dns_unmarshall_uint16(&buf, &tkey->key_length);
280
281         if (!ERR_DNS_IS_OK(buf.error)) goto error;
282
283         if (tkey->key_length) {
284                 if (!(tkey->key = talloc_array(tkey, uint8_t, tkey->key_length))) {
285                         buf.error = ERROR_DNS_NO_MEMORY;
286                         goto error;
287                 }
288         } else {
289                 tkey->key = NULL;
290         }
291
292         dns_unmarshall_buffer(&buf, tkey->key, tkey->key_length);
293         if (!ERR_DNS_IS_OK(buf.error)) goto error;
294
295         tkey->inception = (time_t)tmp_inception;
296         tkey->expiration = (time_t)tmp_expiration;
297
298         *ptkey = tkey;
299         return ERROR_DNS_SUCCESS;
300
301  error:
302         TALLOC_FREE(tkey);
303         return buf.error;
304 }
305
306 DNS_ERROR dns_create_tsig_record(TALLOC_CTX *mem_ctx, const char *keyname,
307                                  const char *algorithm_name,
308                                  time_t time_signed, uint16_t fudge,
309                                  uint16_t mac_length, const uint8_t *mac,
310                                  uint16_t original_id, uint16_t error,
311                                  struct dns_rrec **prec)
312 {
313         struct dns_buffer *buf = NULL;
314         struct dns_domain_name *algorithm = NULL;
315         DNS_ERROR err;
316
317         if (!(buf = dns_create_buffer(mem_ctx))) {
318                 return ERROR_DNS_NO_MEMORY;
319         }
320
321         err = dns_domain_name_from_string(buf, algorithm_name, &algorithm);
322         if (!ERR_DNS_IS_OK(err)) goto error;
323
324         dns_marshall_domain_name(buf, algorithm);
325         dns_marshall_uint16(buf, 0); /* time prefix */
326         dns_marshall_uint32(buf, time_signed);
327         dns_marshall_uint16(buf, fudge);
328         dns_marshall_uint16(buf, mac_length);
329         dns_marshall_buffer(buf, mac, mac_length);
330         dns_marshall_uint16(buf, original_id);
331         dns_marshall_uint16(buf, error);
332         dns_marshall_uint16(buf, 0); /* Other Size */
333
334         if (!ERR_DNS_IS_OK(buf->error)) {
335                 err = buf->error;
336                 goto error;
337         }
338
339         err = dns_create_rrec(mem_ctx, keyname, QTYPE_TSIG, DNS_CLASS_ANY, 0,
340                               buf->offset, buf->data, prec);
341
342  error:
343         TALLOC_FREE(buf);
344         return err;
345 }
346
347 DNS_ERROR dns_add_rrec(TALLOC_CTX *mem_ctx, struct dns_rrec *rec,
348                        uint16_t *num_records, struct dns_rrec ***records)
349 {
350         struct dns_rrec **new_records;
351
352         if (!(new_records = talloc_realloc(mem_ctx, *records,
353                                                  struct dns_rrec *,
354                                                  (*num_records)+1))) {
355                 return ERROR_DNS_NO_MEMORY;
356         }
357
358         new_records[*num_records] = talloc_move(new_records, &rec);
359
360         *num_records += 1;
361         *records = new_records;
362         return ERROR_DNS_SUCCESS;
363 }
364
365 /*
366  * Create a request that probes a server whether the list of IP addresses
367  * provides meets our expectations
368  */
369
370 DNS_ERROR dns_create_probe(TALLOC_CTX *mem_ctx, const char *zone,
371                            const char *host, int num_ips,
372                            const struct sockaddr_storage *sslist,
373                            struct dns_update_request **preq)
374 {
375         struct dns_update_request *req = NULL;
376         struct dns_rrec *rec = NULL;
377         DNS_ERROR err;
378         uint16_t i;
379
380         err = dns_create_update(mem_ctx, zone, &req);
381         if (!ERR_DNS_IS_OK(err)) return err;
382
383         err = dns_create_name_not_in_use_record(req, host, QTYPE_CNAME, &rec);
384         if (!ERR_DNS_IS_OK(err)) goto error;
385
386         err = dns_add_rrec(req, rec, &req->num_preqs, &req->preqs);
387         if (!ERR_DNS_IS_OK(err)) goto error;
388
389         for (i=0; i<num_ips; i++) {
390                 err = dns_create_name_in_use_record(req, host,
391                                                     &sslist[i], &rec);
392                 if (!ERR_DNS_IS_OK(err)) goto error;
393
394                 err = dns_add_rrec(req, rec, &req->num_preqs, &req->preqs);
395                 if (!ERR_DNS_IS_OK(err)) goto error;
396         }
397
398         *preq = req;
399         return ERROR_DNS_SUCCESS;
400
401  error:
402         TALLOC_FREE(req);
403         return err;
404 }
405                            
406 DNS_ERROR dns_create_update_request(TALLOC_CTX *mem_ctx,
407                                     const char *domainname,
408                                     const char *hostname,
409                                     const struct sockaddr_storage *ss_addrs,
410                                     size_t num_addrs,
411                                     struct dns_update_request **preq)
412 {
413         struct dns_update_request *req = NULL;
414         struct dns_rrec *rec = NULL;
415         DNS_ERROR err;
416         size_t i;
417
418         err = dns_create_update(mem_ctx, domainname, &req);
419         if (!ERR_DNS_IS_OK(err)) return err;
420
421         /*
422          * Use the same prereq as WinXP -- No CNAME records for this host.
423          */
424
425         err = dns_create_rrec(req, hostname, QTYPE_CNAME, DNS_CLASS_NONE,
426                               0, 0, NULL, &rec);
427         if (!ERR_DNS_IS_OK(err)) goto error;
428
429         err = dns_add_rrec(req, rec, &req->num_preqs, &req->preqs);
430         if (!ERR_DNS_IS_OK(err)) goto error;
431
432         /*
433          * Delete any existing A records
434          */
435
436         err = dns_create_delete_record(req, hostname, QTYPE_A, DNS_CLASS_ANY,
437                                        &rec);
438         if (!ERR_DNS_IS_OK(err)) goto error;
439
440         err = dns_add_rrec(req, rec, &req->num_updates, &req->updates);
441         if (!ERR_DNS_IS_OK(err)) goto error;
442
443         /*
444          * .. and add our IPs
445          */
446
447         for ( i=0; i<num_addrs; i++ ) {
448
449                 switch(ss_addrs[i].ss_family) {
450                 case AF_INET:
451                         err = dns_create_a_record(req, hostname, 3600, &ss_addrs[i], &rec);
452                         break;
453 #ifdef HAVE_IPV6
454                 case AF_INET6:
455                         err = dns_create_aaaa_record(req, hostname, 3600, &ss_addrs[i], &rec);
456                         break;
457 #endif
458                 default:
459                         continue;
460                 }
461                 if (!ERR_DNS_IS_OK(err))
462                         goto error;
463
464                 err = dns_add_rrec(req, rec, &req->num_updates, &req->updates);
465                 if (!ERR_DNS_IS_OK(err))
466                         goto error;
467         }
468
469         *preq = req;
470         return ERROR_DNS_SUCCESS;
471
472  error:
473         TALLOC_FREE(req);
474         return err;
475 }