1 /* $NetBSD: syncptr.c,v 1.5 2020/05/24 19:46:16 christos Exp $ */ 2 3 /* 4 * Automatic A/AAAA/PTR record synchronization. 5 * 6 * Copyright (C) 2009-2015 Red Hat ; see COPYRIGHT for license 7 */ 8 9 #include "syncptr.h" 10 11 #include <isc/event.h> 12 #include <isc/eventclass.h> 13 #include <isc/netaddr.h> 14 #include <isc/task.h> 15 #include <isc/util.h> 16 17 #include <dns/byaddr.h> 18 #include <dns/db.h> 19 #include <dns/name.h> 20 #include <dns/view.h> 21 #include <dns/zone.h> 22 23 #include "instance.h" 24 #include "util.h" 25 26 /* Almost random value. See eventclass.h */ 27 #define SYNCPTR_WRITE_EVENT (ISC_EVENTCLASS(1025) + 1) 28 29 /* 30 * Event used for making changes to reverse zones. 31 */ 32 typedef struct syncptrevent syncptrevent_t; 33 struct syncptrevent { 34 ISC_EVENT_COMMON(syncptrevent_t); 35 isc_mem_t *mctx; 36 dns_zone_t *zone; 37 dns_diff_t diff; 38 dns_fixedname_t ptr_target_name; /* referenced by owner name in 39 * tuple */ 40 isc_buffer_t b; /* referenced by target name in tuple */ 41 unsigned char buf[DNS_NAME_MAXWIRE]; 42 }; 43 44 /* 45 * Write diff generated in syncptr() to reverse zone. 46 * 47 * This function will be called asynchronously and syncptr() will not get 48 * any result from it. 49 * 50 */ 51 static void 52 syncptr_write(isc_task_t *task, isc_event_t *event) { 53 syncptrevent_t *pevent = (syncptrevent_t *)event; 54 dns_dbversion_t *version = NULL; 55 dns_db_t *db = NULL; 56 isc_result_t result; 57 58 REQUIRE(event->ev_type == SYNCPTR_WRITE_EVENT); 59 60 UNUSED(task); 61 62 log_write(ISC_LOG_INFO, "ENTER: syncptr_write"); 63 64 result = dns_zone_getdb(pevent->zone, &db); 65 if (result != ISC_R_SUCCESS) { 66 log_write(ISC_LOG_ERROR, 67 "syncptr_write: dns_zone_getdb -> %s\n", 68 isc_result_totext(result)); 69 goto cleanup; 70 } 71 72 result = dns_db_newversion(db, &version); 73 if (result != ISC_R_SUCCESS) { 74 log_write(ISC_LOG_ERROR, 75 "syncptr_write: dns_db_newversion -> %s\n", 76 isc_result_totext(result)); 77 goto cleanup; 78 } 79 result = dns_diff_apply(&pevent->diff, db, version); 80 if (result != ISC_R_SUCCESS) { 81 log_write(ISC_LOG_ERROR, 82 "syncptr_write: dns_diff_apply -> %s\n", 83 isc_result_totext(result)); 84 goto cleanup; 85 } 86 87 cleanup: 88 if (db != NULL) { 89 if (version != NULL) { 90 dns_db_closeversion(db, &version, true); 91 } 92 dns_db_detach(&db); 93 } 94 dns_zone_detach(&pevent->zone); 95 dns_diff_clear(&pevent->diff); 96 isc_event_free(&event); 97 } 98 99 /* 100 * Find a reverse zone for given IP address. 101 * 102 * @param[in] rdata IP address as A/AAAA record 103 * @param[out] name Owner name for the PTR record 104 * @param[out] zone DNS zone for reverse record matching the IP address 105 * 106 * @retval ISC_R_SUCCESS DNS name derived from given IP address belongs to an 107 * reverse zone managed by this driver instance. 108 * PTR record synchronization can continue. 109 * @retval ISC_R_NOTFOUND Suitable reverse zone was not found because it 110 * does not exist or is not managed by this driver. 111 */ 112 static isc_result_t 113 syncptr_find_zone(sample_instance_t *inst, dns_rdata_t *rdata, dns_name_t *name, 114 dns_zone_t **zone) { 115 isc_result_t result; 116 isc_netaddr_t isc_ip; /* internal net address representation */ 117 dns_rdata_in_a_t ipv4; 118 dns_rdata_in_aaaa_t ipv6; 119 120 REQUIRE(inst != NULL); 121 REQUIRE(zone != NULL && *zone == NULL); 122 123 switch (rdata->type) { 124 case dns_rdatatype_a: 125 CHECK(dns_rdata_tostruct(rdata, &ipv4, inst->mctx)); 126 isc_netaddr_fromin(&isc_ip, &ipv4.in_addr); 127 break; 128 129 case dns_rdatatype_aaaa: 130 CHECK(dns_rdata_tostruct(rdata, &ipv6, inst->mctx)); 131 isc_netaddr_fromin6(&isc_ip, &ipv6.in6_addr); 132 break; 133 134 default: 135 fatal_error("unsupported address type 0x%x", rdata->type); 136 break; 137 } 138 139 /* 140 * Convert IP address to PTR owner name. 141 * 142 * @example 143 * 192.168.0.1 -> 1.0.168.192.in-addr.arpa 144 */ 145 result = dns_byaddr_createptrname(&isc_ip, 0, name); 146 if (result != ISC_R_SUCCESS) { 147 log_write(ISC_LOG_ERROR, 148 "syncptr_find_zone: dns_byaddr_createptrname -> %s\n", 149 isc_result_totext(result)); 150 goto cleanup; 151 } 152 153 /* Find a zone containing owner name of the PTR record. */ 154 result = dns_zt_find(inst->view->zonetable, name, 0, NULL, zone); 155 if (result == DNS_R_PARTIALMATCH) { 156 result = ISC_R_SUCCESS; 157 } else if (result != ISC_R_SUCCESS) { 158 log_write(ISC_LOG_ERROR, 159 "syncptr_find_zone: dns_zt_find -> %s\n", 160 isc_result_totext(result)); 161 goto cleanup; 162 } 163 164 /* Make sure that the zone is managed by this driver. */ 165 if (*zone != inst->zone1 && *zone != inst->zone2) { 166 dns_zone_detach(zone); 167 log_write(ISC_LOG_INFO, "syncptr_find_zone: zone not managed"); 168 result = ISC_R_NOTFOUND; 169 } 170 171 cleanup: 172 if (rdata->type == dns_rdatatype_a) { 173 dns_rdata_freestruct(&ipv4); 174 } else { 175 dns_rdata_freestruct(&ipv6); 176 } 177 178 return (result); 179 } 180 181 /* 182 * Generate update event for PTR record to reflect change in A/AAAA record. 183 * 184 * @pre Reverse zone is managed by this driver. 185 * 186 * @param[in] a_name DNS domain of modified A/AAAA record 187 * @param[in] af Address family 188 * @param[in] ip_str IP address as a string (IPv4 or IPv6) 189 * @param[in] mod_op LDAP_MOD_DELETE if A/AAAA record is being deleted 190 * or LDAP_MOD_ADD if A/AAAA record is being added. 191 * 192 * @retval ISC_R_SUCCESS Event for PTR record update was generated and send. 193 * Change to reverse zone will be done asynchronously. 194 * @retval other Synchronization failed - reverse doesn't exist, 195 * is not managed by this driver instance, 196 * memory allocation error, etc. 197 */ 198 static isc_result_t 199 syncptr(sample_instance_t *inst, dns_name_t *name, dns_rdata_t *addr_rdata, 200 dns_ttl_t ttl, dns_diffop_t op) { 201 isc_result_t result; 202 isc_mem_t *mctx = inst->mctx; 203 dns_fixedname_t ptr_name; 204 dns_zone_t *ptr_zone = NULL; 205 dns_rdata_ptr_t ptr_struct; 206 dns_rdata_t ptr_rdata = DNS_RDATA_INIT; 207 dns_difftuple_t *tp = NULL; 208 isc_task_t *task = NULL; 209 syncptrevent_t *pevent = NULL; 210 211 dns_fixedname_init(&ptr_name); 212 DNS_RDATACOMMON_INIT(&ptr_struct, dns_rdatatype_ptr, dns_rdataclass_in); 213 dns_name_init(&ptr_struct.ptr, NULL); 214 215 pevent = (syncptrevent_t *)isc_event_allocate( 216 inst->mctx, inst, SYNCPTR_WRITE_EVENT, syncptr_write, NULL, 217 sizeof(syncptrevent_t)); 218 isc_buffer_init(&pevent->b, pevent->buf, sizeof(pevent->buf)); 219 dns_fixedname_init(&pevent->ptr_target_name); 220 221 /* Check if reverse zone is managed by this driver */ 222 result = syncptr_find_zone(inst, addr_rdata, 223 dns_fixedname_name(&ptr_name), &ptr_zone); 224 if (result != ISC_R_SUCCESS) { 225 log_error_r("PTR record synchronization skipped: reverse zone " 226 "is not managed by driver instance '%s'", 227 inst->db_name); 228 goto cleanup; 229 } 230 231 /* Reverse zone is managed by this driver, prepare PTR record */ 232 pevent->zone = NULL; 233 dns_zone_attach(ptr_zone, &pevent->zone); 234 dns_name_copynf(name, dns_fixedname_name(&pevent->ptr_target_name)); 235 dns_name_clone(dns_fixedname_name(&pevent->ptr_target_name), 236 &ptr_struct.ptr); 237 dns_diff_init(inst->mctx, &pevent->diff); 238 result = dns_rdata_fromstruct(&ptr_rdata, dns_rdataclass_in, 239 dns_rdatatype_ptr, &ptr_struct, 240 &pevent->b); 241 if (result != ISC_R_SUCCESS) { 242 log_write(ISC_LOG_ERROR, 243 "syncptr: dns_rdata_fromstruct -> %s\n", 244 isc_result_totext(result)); 245 goto cleanup; 246 } 247 248 /* Create diff */ 249 result = dns_difftuple_create(mctx, op, dns_fixedname_name(&ptr_name), 250 ttl, &ptr_rdata, &tp); 251 if (result != ISC_R_SUCCESS) { 252 log_write(ISC_LOG_ERROR, 253 "syncptr: dns_difftuple_create -> %s\n", 254 isc_result_totext(result)); 255 goto cleanup; 256 } 257 dns_diff_append(&pevent->diff, &tp); 258 259 /* 260 * Send update event to the reverse zone. 261 * It will be processed asynchronously. 262 */ 263 dns_zone_gettask(ptr_zone, &task); 264 isc_task_send(task, (isc_event_t **)&pevent); 265 266 cleanup: 267 if (ptr_zone != NULL) { 268 dns_zone_detach(&ptr_zone); 269 } 270 if (tp != NULL) { 271 dns_difftuple_free(&tp); 272 } 273 if (task != NULL) { 274 isc_task_detach(&task); 275 } 276 if (pevent != NULL) { 277 isc_event_free((isc_event_t **)&pevent); 278 } 279 280 return (result); 281 } 282 283 /* 284 * Generate update event for every rdata in rdataset. 285 * 286 * @param[in] name Owner name for A/AAAA records in rdataset. 287 * @param[in] rdataset A/AAAA records. 288 * @param[in] op DNS_DIFFOP_ADD / DNS_DIFFOP_DEL for adding / deleting 289 * the rdata 290 */ 291 isc_result_t 292 syncptrs(sample_instance_t *inst, dns_name_t *name, dns_rdataset_t *rdataset, 293 dns_diffop_t op) { 294 isc_result_t result; 295 dns_rdata_t rdata = DNS_RDATA_INIT; 296 297 for (result = dns_rdataset_first(rdataset); result == ISC_R_SUCCESS; 298 result = dns_rdataset_next(rdataset)) 299 { 300 dns_rdataset_current(rdataset, &rdata); 301 result = syncptr(inst, name, &rdata, rdataset->ttl, op); 302 if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) { 303 goto cleanup; 304 } 305 } 306 if (result == ISC_R_NOMORE) { 307 result = ISC_R_SUCCESS; 308 } 309 310 cleanup: 311 return (result); 312 } 313