update.c

Go to the documentation of this file.
00001 /* update.c
00002  *
00003  * Functions for RFC 2136 Dynamic Update
00004  *
00005  * Copyright (c) 2005-2008, NLnet Labs. All rights reserved.
00006  *
00007  * See LICENSE for the license.
00008  */
00009 
00010 #include <ldns/config.h>
00011 
00012 #include <ldns/ldns.h>
00013 
00014 #include <strings.h>
00015 #include <stdlib.h>
00016 #include <limits.h>
00017 
00018 /*
00019  * RFC 2136 sections mapped to RFC 1035:
00020  *              zone/ZO -- QD/question
00021  *     prerequisites/PR -- AN/answers
00022  *           updates/UP -- NS/authority records
00023  *   additional data/AD -- AR/additional records
00024  */
00025 
00026 ldns_pkt *
00027 ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class c,
00028     ldns_rr_list *pr_rrlist, ldns_rr_list *up_rrlist, ldns_rr_list *ad_rrlist)
00029 {
00030         ldns_pkt *p;
00031 
00032         if (!zone_rdf || !up_rrlist) {
00033                 return NULL;
00034         }
00035 
00036         if (c == 0) { 
00037                 c = LDNS_RR_CLASS_IN;
00038         }
00039 
00040         /* Create packet, fill in Zone Section. */
00041         p = ldns_pkt_query_new(zone_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD);
00042         if (!p) {
00043                 return NULL;
00044         }
00045         zone_rdf = NULL; /* No longer safe to use. */
00046 
00047         ldns_pkt_set_opcode(p, LDNS_PACKET_UPDATE);
00048 
00049         ldns_rr_list_deep_free(p->_authority);
00050 
00051         ldns_pkt_set_authority(p, ldns_rr_list_clone(up_rrlist));
00052 
00053         ldns_update_set_upcount(p, ldns_rr_list_rr_count(up_rrlist));
00054 
00055         if (pr_rrlist) {
00056                 ldns_rr_list_deep_free(p->_answer); /*XXX access function */
00057                 ldns_pkt_set_answer(p, ldns_rr_list_clone(pr_rrlist));
00058                 ldns_update_set_prcount(p, ldns_rr_list_rr_count(pr_rrlist));
00059         }
00060 
00061         if (ad_rrlist) {
00062                 ldns_rr_list_deep_free(p->_additional);
00063                 ldns_pkt_set_additional(p, ldns_rr_list_clone(ad_rrlist));
00064                 ldns_update_set_adcount(p, ldns_rr_list_rr_count(ad_rrlist));
00065         }
00066         return p;
00067 }
00068 
00069 ldns_status
00070 ldns_update_pkt_tsig_add(ldns_pkt *p, ldns_resolver *r)
00071 {
00072 #ifdef HAVE_SSL
00073         uint16_t fudge = 300; /* Recommended fudge. [RFC2845 6.4]  */
00074         if (ldns_resolver_tsig_keyname(r) && ldns_resolver_tsig_keydata(r))
00075                 return ldns_pkt_tsig_sign(p, ldns_resolver_tsig_keyname(r),
00076                     ldns_resolver_tsig_keydata(r), fudge,
00077                     ldns_resolver_tsig_algorithm(r), NULL);
00078 #else
00079         /* do nothing */
00080         (void)p;
00081         (void)r;
00082 #endif /* HAVE_SSL */
00083         /* No TSIG to do. */
00084         return LDNS_STATUS_OK;
00085 }
00086 
00087 /* Move to higher.c or similar? */
00088 /* XXX doc */
00089 ldns_status
00090 ldns_update_soa_mname(ldns_rdf *zone, ldns_resolver *r,
00091     ldns_rr_class c, ldns_rdf **mname)
00092 {
00093         ldns_rr         *soa_rr;
00094         ldns_pkt        *query, *resp;
00095 
00096         /* Nondestructive, so clone 'zone' here */
00097         query = ldns_pkt_query_new(ldns_rdf_clone(zone), LDNS_RR_TYPE_SOA,
00098             c, LDNS_RD);
00099         if (!query) {
00100                 return LDNS_STATUS_ERR;
00101         }
00102 
00103         ldns_pkt_set_random_id(query);
00104         if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) {
00105                 ldns_pkt_free(query);
00106                 return LDNS_STATUS_ERR;
00107         }
00108         ldns_pkt_free(query);
00109         if (!resp) {
00110                 return LDNS_STATUS_ERR;
00111         }
00112 
00113         /* Expect a SOA answer. */
00114         *mname = NULL;
00115         while ((soa_rr = ldns_rr_list_pop_rr(ldns_pkt_answer(resp)))) {
00116                 if (ldns_rr_get_type(soa_rr) != LDNS_RR_TYPE_SOA
00117                                 || ldns_rr_rdf(soa_rr, 0) == NULL)
00118                         continue;
00119                 /* [RFC1035 3.3.13] */
00120                 *mname = ldns_rdf_clone(ldns_rr_rdf(soa_rr, 0));
00121                 break;
00122         }
00123         ldns_pkt_free(resp);
00124 
00125         return *mname ? LDNS_STATUS_OK : LDNS_STATUS_ERR;
00126 }
00127 
00128 /* Try to get zone and MNAME from SOA queries. */
00129 ldns_status
00130 ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r,
00131     ldns_rr_class c, ldns_rdf **zone_rdf, ldns_rdf **mname_rdf)
00132 {
00133         ldns_rr         *soa_rr, *rr;
00134         ldns_rdf        *soa_zone = NULL, *soa_mname = NULL;
00135         ldns_rdf        *ipaddr, *fqdn_rdf, *tmp;
00136         ldns_rdf        **nslist;
00137         ldns_pkt        *query, *resp;
00138         size_t          i;
00139 
00140         /* 
00141          * XXX Ok, this cannot be the best way to find this...?
00142          * XXX (I run into weird cache-related stuff here)
00143          */
00144 
00145         /* Step 1 - first find a nameserver that should know *something* */
00146         fqdn_rdf = ldns_dname_new_frm_str(fqdn);
00147         query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD);
00148         if (!query) {
00149                 return LDNS_STATUS_ERR;
00150         }
00151         fqdn_rdf = NULL;
00152 
00153         ldns_pkt_set_random_id(query);
00154         if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) {
00155                 ldns_pkt_free(query);
00156                 return LDNS_STATUS_ERR;
00157         }
00158         ldns_pkt_free(query);
00159         if (!resp) {
00160                 return LDNS_STATUS_ERR;
00161         }
00162 
00163         /* XXX Is it safe to only look in authority section here? */
00164         while ((soa_rr = ldns_rr_list_pop_rr(ldns_pkt_authority(resp)))) {
00165                 if (ldns_rr_get_type(soa_rr) != LDNS_RR_TYPE_SOA
00166                                 || ldns_rr_rdf(soa_rr, 0) == NULL)
00167                         continue;
00168                 /* [RFC1035 3.3.13] */
00169                 soa_mname = ldns_rdf_clone(ldns_rr_rdf(soa_rr, 0));
00170                 break;
00171         }
00172         ldns_pkt_free(resp);
00173         if (!soa_rr) {
00174                 return LDNS_STATUS_ERR;
00175         }
00176 
00177         /* Step 2 - find SOA MNAME IP address, add to resolver */
00178         query = ldns_pkt_query_new(soa_mname, LDNS_RR_TYPE_A, c, LDNS_RD);
00179         if (!query) {
00180                 return LDNS_STATUS_ERR;
00181         }
00182         soa_mname = NULL;
00183 
00184         ldns_pkt_set_random_id(query);
00185         if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) {
00186                 ldns_pkt_free(query);
00187                 return LDNS_STATUS_ERR;
00188         }
00189         ldns_pkt_free(query);
00190         if (!resp) {
00191                 return LDNS_STATUS_ERR;
00192         }
00193 
00194         if (ldns_pkt_ancount(resp) == 0) {
00195                 ldns_pkt_free(resp);
00196                 return LDNS_STATUS_ERR;
00197         }
00198 
00199         /* XXX There may be more than one answer RR here. */
00200         rr = ldns_rr_list_pop_rr(ldns_pkt_answer(resp));
00201         ipaddr = ldns_rr_rdf(rr, 0);
00202 
00203         /* Put the SOA mname IP first in the nameserver list. */
00204         nslist = ldns_resolver_nameservers(r);
00205         for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
00206                 if (ldns_rdf_compare(ipaddr, nslist[i]) == 0) {
00207                         if (i) {
00208                                 tmp = nslist[0];
00209                                 nslist[0] = nslist[i];
00210                                 nslist[i] = tmp;
00211                         }
00212                         break;
00213                 }
00214         }
00215         if (i >= ldns_resolver_nameserver_count(r)) {
00216                 /* SOA mname was not part of the resolver so add it first. */
00217                 (void) ldns_resolver_push_nameserver(r, ipaddr);
00218                 nslist = ldns_resolver_nameservers(r);
00219                 i = ldns_resolver_nameserver_count(r) - 1;
00220                 tmp = nslist[0];
00221                 nslist[0] = nslist[i];
00222                 nslist[i] = tmp;
00223         }
00224         ldns_pkt_free(resp);
00225 
00226         /* Make sure to ask the first in the list, i.e SOA mname */
00227         ldns_resolver_set_random(r, false);
00228 
00229         /* Step 3 - Redo SOA query, sending to SOA MNAME directly. */
00230         fqdn_rdf = ldns_dname_new_frm_str(fqdn);
00231         query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD);
00232         if (!query) {
00233                 return LDNS_STATUS_ERR;
00234         }
00235         fqdn_rdf = NULL;
00236 
00237         ldns_pkt_set_random_id(query);
00238         if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) {
00239                 ldns_pkt_free(query);
00240                 return LDNS_STATUS_ERR;
00241         }
00242         ldns_pkt_free(query);
00243         if (!resp) {
00244                 return LDNS_STATUS_ERR;
00245         }
00246 
00247         /* XXX Is it safe to only look in authority section here, too? */
00248         while ((soa_rr = ldns_rr_list_pop_rr(ldns_pkt_authority(resp)))) {
00249                 if (ldns_rr_get_type(soa_rr) != LDNS_RR_TYPE_SOA
00250                                 || ldns_rr_rdf(soa_rr, 0) == NULL)
00251                         continue;
00252                 /* [RFC1035 3.3.13] */
00253                 soa_mname = ldns_rdf_clone(ldns_rr_rdf(soa_rr, 0));
00254                 soa_zone = ldns_rdf_clone(ldns_rr_owner(soa_rr));
00255                 break;
00256         }
00257         ldns_pkt_free(resp);
00258         if (!soa_rr) {
00259                 return LDNS_STATUS_ERR;
00260         }
00261 
00262         /* That seems to have worked, pass results to caller. */
00263         *zone_rdf = soa_zone;
00264         *mname_rdf = soa_mname;
00265         return LDNS_STATUS_OK;
00266 }       
00267 
00268 /*
00269  * ldns_update_{get,set}_{zo,pr,up,ad}count
00270  */
00271 
00272 uint16_t
00273 ldns_update_zocount(const ldns_pkt *p)
00274 {
00275         return ldns_pkt_qdcount(p);
00276 }
00277 
00278 uint16_t
00279 ldns_update_prcount(const ldns_pkt *p)
00280 {
00281         return ldns_pkt_ancount(p);
00282 }
00283 
00284 uint16_t
00285 ldns_update_upcount(const ldns_pkt *p)
00286 {
00287         return ldns_pkt_nscount(p);
00288 }
00289 
00290 uint16_t
00291 ldns_update_ad(const ldns_pkt *p)
00292 {
00293         return ldns_pkt_arcount(p);
00294 }
00295 
00296 void
00297 ldns_update_set_zo(ldns_pkt *p, uint16_t v)
00298 {
00299         ldns_pkt_set_qdcount(p, v);
00300 }
00301 
00302 void
00303 ldns_update_set_prcount(ldns_pkt *p, uint16_t v)
00304 {
00305         ldns_pkt_set_ancount(p, v);
00306 }
00307 
00308 void
00309 ldns_update_set_upcount(ldns_pkt *p, uint16_t v)
00310 {
00311         ldns_pkt_set_nscount(p, v);
00312 }
00313 
00314 void
00315 ldns_update_set_adcount(ldns_pkt *p, uint16_t v)
00316 {
00317         ldns_pkt_set_arcount(p, v);
00318 }

Generated on Wed Dec 19 16:56:50 2012 for ldns by  doxygen 1.4.7