![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_update.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / named|
Return to db_update.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / named |
1.1 ! root 1: /* ! 2: * Copyright (c) 1986 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that the above copyright notice and this paragraph are ! 7: * duplicated in all such forms and that any documentation, ! 8: * advertising materials, and other materials related to such ! 9: * distribution and use acknowledge that the software was developed ! 10: * by the University of California, Berkeley. The name of the ! 11: * University may not be used to endorse or promote products derived ! 12: * from this software without specific prior written permission. ! 13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 16: */ ! 17: ! 18: #ifndef lint ! 19: static char sccsid[] = "@(#)db_update.c 4.17 (Berkeley) 6/18/88"; ! 20: #endif /* not lint */ ! 21: ! 22: #include <sys/types.h> ! 23: #include <sys/socket.h> ! 24: #include <sys/time.h> ! 25: #include <netinet/in.h> ! 26: #include <stdio.h> ! 27: #include <syslog.h> ! 28: #include <arpa/nameser.h> ! 29: #include "ns.h" ! 30: #include "db.h" ! 31: ! 32: extern struct timeval tt; ! 33: extern FILE *ddt; ! 34: extern struct zoneinfo zones[]; ! 35: extern struct sockaddr_in from_addr; /* Source addr of last packet */ ! 36: extern int needs_prime_cache; ! 37: ! 38: int max_cache_ttl = (7*24*60*60); /* ONE_WEEK maximum ttl */ ! 39: int min_cache_ttl = (5*60); /* 5 minute minimum ttl */ ! 40: ! 41: /* ! 42: * Update data base. Flags control the action. ! 43: * Inverse query tables modified. ! 44: */ ! 45: db_update(name, odp, newdp, flags, htp) ! 46: char name[]; ! 47: struct databuf *odp, *newdp; ! 48: int flags; ! 49: struct hashbuf *htp; ! 50: { ! 51: register struct namebuf *np; ! 52: register struct databuf *dp, *pdp; ! 53: char *fname; ! 54: int foundRR = 0; ! 55: ! 56: #ifdef DEBUG ! 57: if (debug >= 3) ! 58: fprintf(ddt,"db_update(%s, 0x%x, 0x%x, 0%o, 0x%x)%s\n", ! 59: name, odp, newdp, flags, htp, ! 60: (odp && (odp->d_flags&DB_F_HINT)) ? " hint":"" ); ! 61: #endif ! 62: np = nlookup(name, &htp, &fname, newdp != NULL); ! 63: if (np == NULL || fname != name) ! 64: return (NONAME); ! 65: ! 66: /* Reflect certain updates in hint cache also... */ ! 67: /* Don't stick data we are authoritative for in hints. */ ! 68: if (!(flags & DB_NOHINTS) && (odp != NULL) && ! 69: (odp->d_zone <= 0) && !(odp->d_flags & DB_F_HINT) && ! 70: ((name[0] == '\0' && odp->d_type == T_NS) || ! 71: (odp->d_type == T_A))) ! 72: { ! 73: register struct databuf *dp; ! 74: #ifdef DEBUG ! 75: if (debug >= 3) ! 76: fprintf(ddt,"db_update: hint '%s' %d\n", ! 77: name, odp->d_ttl); ! 78: #endif ! 79: dp = savedata(odp->d_class, odp->d_type, odp->d_ttl, ! 80: odp->d_data, odp->d_size); ! 81: dp->d_zone = DB_Z_CACHE; ! 82: dp->d_flags = DB_F_HINT; ! 83: if (db_update(name, dp,dp, (flags|DB_NOHINTS), fcachetab) != OK) { ! 84: #ifdef DEBUG ! 85: if (debug > 2) ! 86: fprintf(ddt, "db_update: hint %x freed\n", dp); ! 87: #endif ! 88: (void) free((char *)dp); ! 89: } ! 90: } ! 91: ! 92: if (odp != NULL) { ! 93: pdp = NULL; ! 94: for (dp = np->n_data; dp != NULL; ) { ! 95: if (!match(dp, odp->d_class, odp->d_type)) { ! 96: if ((dp->d_type == T_CNAME || ! 97: odp->d_type == T_CNAME) && ! 98: zones[odp->d_zone].z_type != Z_CACHE) { ! 99: syslog(LOG_ERR, ! 100: "%s has CNAME and other data (illegal)\n", ! 101: name); ! 102: #ifdef DEBUG ! 103: if (debug) ! 104: fprintf(ddt, ! 105: "db_update: %s: CNAME and more (%d, %d)\n", ! 106: name, odp->d_type, dp->d_type); ! 107: #endif ! 108: } ! 109: goto skip; ! 110: } ! 111: #ifdef DEBUG ! 112: if (debug >= 5) ! 113: fprintf(ddt,"db_update: flags = %#x, sizes = %d, %d (%d)\n", ! 114: flags, odp->d_size, dp->d_size, ! 115: db_cmp(dp, odp)); ! 116: #endif ! 117: if (flags & DB_NOTAUTH && dp->d_zone) { ! 118: #ifdef DEBUG ! 119: if (debug) ! 120: fprintf(ddt, ! 121: "%s attempted update to auth zone %d '%s'\n", ! 122: inet_ntoa(from_addr.sin_addr), ! 123: dp->d_zone, zones[dp->d_zone].z_origin); ! 124: #endif ! 125: return (AUTH); ! 126: } ! 127: if ((flags & DB_NODATA) && !db_cmp(dp, odp)) { ! 128: /* refresh ttl if cache entry */ ! 129: if (dp->d_zone == 0) { ! 130: fixttl(odp); ! 131: if (odp->d_ttl > dp->d_ttl) ! 132: dp->d_ttl = odp->d_ttl; ! 133: #ifdef DEBUG ! 134: if (debug >= 3) ! 135: fprintf(ddt,"db_update: new ttl %d, +%d\n", ! 136: dp->d_ttl, dp->d_ttl - tt.tv_sec); ! 137: #endif ! 138: } ! 139: return (DATAEXISTS); ! 140: } ! 141: /* ! 142: * If the old databuf has some data, check that the ! 143: * data matches that in the new databuf (so UPDATED ! 144: * will delete only the matching RR) ! 145: */ ! 146: if (odp->d_size > 0) { ! 147: if (db_cmp(dp, odp)) ! 148: goto skip; ! 149: } ! 150: foundRR = 1; ! 151: if (flags & DB_DELETE) ! 152: dp = rm_datum(dp, np, pdp); ! 153: else { ! 154: skip: pdp = dp; ! 155: dp = dp->d_next; ! 156: } ! 157: } ! 158: if (!foundRR) { ! 159: if (flags & DB_DELETE) ! 160: return(NODATA); ! 161: if (flags & DB_MEXIST) ! 162: return(NODATA); ! 163: } ! 164: } ! 165: if (newdp == NULL) ! 166: return (OK); ! 167: fixttl(newdp); ! 168: #ifdef DEBUG ! 169: if (debug >= 3) ! 170: fprintf(ddt,"db_update: adding%s %x\n", ! 171: (newdp->d_flags&DB_F_HINT) ? " hint":"", newdp); ! 172: #endif ! 173: if (!(newdp->d_flags & DB_F_HINT)) ! 174: addinv(np, newdp); /* modify inverse query tables */ ! 175: ! 176: /* Add to end of list, generally preserving order */ ! 177: newdp->d_next = NULL; ! 178: if ((dp = np->n_data) == NULL) { ! 179: np->n_data = newdp; ! 180: return (OK); ! 181: } ! 182: /* XXX: need to check for duplicate WKS records and flag error */ ! 183: while (dp->d_next != NULL) { ! 184: if ((flags & DB_NODATA) && !db_cmp(dp, newdp)) ! 185: return (DATAEXISTS); ! 186: dp = dp->d_next; ! 187: } ! 188: if ((flags & DB_NODATA) && !db_cmp(dp, newdp)) ! 189: return (DATAEXISTS); ! 190: dp->d_next = newdp; ! 191: return (OK); ! 192: } ! 193: ! 194: fixttl(dp) ! 195: register struct databuf *dp; ! 196: { ! 197: if (dp->d_zone == 0 && !(dp->d_flags & DB_F_HINT)) { ! 198: if (dp->d_ttl <= tt.tv_sec) ! 199: return; ! 200: else if (dp->d_ttl < tt.tv_sec+min_cache_ttl) ! 201: dp->d_ttl = tt.tv_sec+min_cache_ttl; ! 202: else if (dp->d_ttl > tt.tv_sec+max_cache_ttl) ! 203: dp->d_ttl = tt.tv_sec+max_cache_ttl; ! 204: } ! 205: return; ! 206: } ! 207: ! 208: struct invbuf *invtab[INVHASHSZ]; /* Inverse query hash table */ ! 209: ! 210: /* ! 211: * Add data 'dp' to inverse query tables for name 'np'. ! 212: */ ! 213: addinv(np, dp) ! 214: struct namebuf *np; ! 215: struct databuf *dp; ! 216: { ! 217: register struct invbuf *ip; ! 218: register int hval, i; ! 219: ! 220: switch (dp->d_type) { ! 221: case T_A: ! 222: case T_UID: ! 223: case T_GID: ! 224: break; ! 225: ! 226: default: ! 227: return; ! 228: } ! 229: ! 230: hval = dhash(dp->d_data, dp->d_size); ! 231: for (ip = invtab[hval]; ip != NULL; ip = ip->i_next) ! 232: for (i = 0; i < INVBLKSZ; i++) ! 233: if (ip->i_dname[i] == NULL) { ! 234: ip->i_dname[i] = np; ! 235: return; ! 236: } ! 237: ip = saveinv(); ! 238: ip->i_next = invtab[hval]; ! 239: invtab[hval] = ip; ! 240: ip->i_dname[0] = np; ! 241: } ! 242: ! 243: /* ! 244: * Remove data 'odp' from inverse query table. ! 245: */ ! 246: rminv(odp) ! 247: struct databuf *odp; ! 248: { ! 249: register struct invbuf *ip; ! 250: register struct databuf *dp; ! 251: struct namebuf *np; ! 252: register int i; ! 253: ! 254: for (ip = invtab[dhash(odp->d_data, odp->d_size)]; ip != NULL; ! 255: ip = ip->i_next) { ! 256: for (i = 0; i < INVBLKSZ; i++) { ! 257: if ((np = ip->i_dname[i]) == NULL) ! 258: break; ! 259: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 260: if (!match(dp, odp->d_class, odp->d_type)) ! 261: continue; ! 262: if (db_cmp(dp, odp)) ! 263: continue; ! 264: while (i < INVBLKSZ-1) { ! 265: ip->i_dname[i] = ip->i_dname[i+1]; ! 266: i++; ! 267: } ! 268: ip->i_dname[i] = NULL; ! 269: return; ! 270: } ! 271: } ! 272: } ! 273: } ! 274: ! 275: /* ! 276: * Compute hash value from data. ! 277: */ ! 278: dhash(dp, dlen) ! 279: char *dp; ! 280: int dlen; ! 281: { ! 282: register char *cp; ! 283: register unsigned hval; ! 284: register int n; ! 285: ! 286: n = dlen; ! 287: if (n > 8) ! 288: n = 8; ! 289: hval = 0; ! 290: for (cp = dp; --n >= 0; ) { ! 291: hval <<= 1; ! 292: hval += *cp++; ! 293: } ! 294: return (hval % INVHASHSZ); ! 295: } ! 296: ! 297: /* ! 298: * Compare data sections from databufs for equivalence. Must be case ! 299: * insensitive for some domain names. We assume that they are the ! 300: * same type when they are passed. Return 0 if equivalent, nonzero ! 301: * otherwise. ! 302: */ ! 303: ! 304: db_cmp(dp1, dp2) ! 305: register struct databuf *dp1, *dp2; ! 306: ! 307: { ! 308: register char *cp1, *cp2; ! 309: int len; ! 310: ! 311: if (dp1->d_size != dp2->d_size) ! 312: return(1); ! 313: if (dp1->d_mark != dp2->d_mark) ! 314: return(1); /* old and new RR's are distinct */ ! 315: switch (dp1->d_type) { ! 316: ! 317: case T_A: ! 318: case T_UID: ! 319: case T_GID: ! 320: case T_WKS: ! 321: case T_NULL: ! 322: #ifdef ALLOW_T_UNSPEC ! 323: case T_UNSPEC: ! 324: #endif ALLOW_T_UNSPEC ! 325: return(bcmp(dp1->d_data, dp2->d_data, dp1->d_size)); ! 326: ! 327: case T_NS: ! 328: case T_CNAME: ! 329: case T_PTR: ! 330: case T_MB: ! 331: case T_MG: ! 332: case T_MR: ! 333: case T_UINFO: ! 334: return(strcasecmp(dp1->d_data, dp2->d_data)); ! 335: ! 336: case T_HINFO: ! 337: cp1 = dp1->d_data; ! 338: cp2 = dp2->d_data; ! 339: len = *cp1; ! 340: if (strncasecmp(++cp1, ++cp2, len)) ! 341: return(1); ! 342: cp1 += len; ! 343: cp2 += len; ! 344: len = *cp1; ! 345: return(strncasecmp(++cp1, ++cp2, len)); ! 346: ! 347: case T_SOA: ! 348: case T_MINFO: ! 349: if (strcasecmp(dp1->d_data, dp2->d_data)) ! 350: return(1); ! 351: cp1 = dp1->d_data + strlen(dp1->d_data) + 1; ! 352: cp2 = dp2->d_data + strlen(dp2->d_data) + 1; ! 353: if (dp1->d_type != T_SOA) ! 354: return(strcasecmp(cp1, cp2)); ! 355: if (strcasecmp(cp1, cp2)) ! 356: return(1); ! 357: cp1 += strlen(cp1) + 1; ! 358: cp2 += strlen(cp2) + 1; ! 359: return(bcmp(cp1, cp2, sizeof(u_long) * 5)); ! 360: ! 361: case T_MX: ! 362: cp1 = dp1->d_data; ! 363: cp2 = dp2->d_data; ! 364: if (*cp1++ != *cp2++ || *cp1++ != *cp2++) /* cmp prio */ ! 365: return(1); ! 366: return(strcasecmp(cp1, cp2)); ! 367: ! 368: default: ! 369: return (1); ! 370: } ! 371: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.