Return to db_update.c CVS log

Up to [CSRG BSD Unix] / 43BSD / etc / named

Annotation of 43BSD/etc/named/db_update.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)db_update.c        4.3 (Berkeley) 5/30/86";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1986 Regents of the University of California
        !             7:  *     All Rights Reserved
        !             8:  */
        !             9: 
        !            10: #include <sys/types.h>
        !            11: #include <sys/time.h>
        !            12: #include <stdio.h>
        !            13: #include <syslog.h>
        !            14: #include <arpa/nameser.h>
        !            15: #include "db.h"
        !            16: 
        !            17: struct timeval tt;
        !            18: extern FILE *ddt;
        !            19: 
        !            20: /*
        !            21:  * Update data base. Flags control the action.
        !            22:  * Inverse query tables modified.
        !            23:  */
        !            24: db_update(name, odp, newdp, flags)
        !            25:        char name[];
        !            26:        struct databuf *odp, *newdp;
        !            27:        int flags;
        !            28: {
        !            29:        register struct namebuf *np;
        !            30:        register struct databuf *dp, *pdp;
        !            31:        struct hashbuf *htp = hashtab;
        !            32:        char *fname;
        !            33: 
        !            34: #ifdef DEBUG
        !            35:        extern int debug;
        !            36: 
        !            37:        if (debug >= 3)
        !            38:                fprintf(ddt,"db_update( %s )\n",name);
        !            39: #endif
        !            40:        np = nlookup(name, &htp, &fname, newdp != NULL);
        !            41:        if (np == NULL || fname != name)
        !            42:                return (NONAME);
        !            43:        if (odp != NULL) {
        !            44:                pdp = NULL;
        !            45:                for (dp = np->n_data; dp != NULL; pdp = dp, dp = dp->d_next) {
        !            46:                        if (!match(dp, odp->d_class, odp->d_type))
        !            47:                                continue;
        !            48: #ifdef DEBUG
        !            49:                        if (debug >= 5)
        !            50:                                fprintf(ddt,"f = %#x, size = %d, %d (%d)\n",
        !            51:                                    flags, odp->d_size, dp->d_size,
        !            52:                                    db_cmp(dp, odp));
        !            53: #endif
        !            54:                        if ((flags & DB_NODATA) &&
        !            55:                            !db_cmp(dp, odp)) {
        !            56:                                /* refresh ttl if cache entry */
        !            57:                                if (dp->d_zone == 0) {
        !            58:                                        if (dp->d_ttl < tt.tv_sec ) {
        !            59:                                                dp->d_ttl = odp->d_ttl;
        !            60:                                                return (OK);
        !            61:                                        }
        !            62:                                        if (dp->d_ttl < odp->d_ttl)
        !            63:                                                dp->d_ttl = odp->d_ttl;
        !            64:                                }
        !            65:                                return (DATAEXISTS);
        !            66:                        }
        !            67:                        if ((flags & DB_MEXIST) && db_cmp(dp, odp))
        !            68:                                return (NODATA);
        !            69:                        if (flags & DB_DELETE) {
        !            70:                                if (pdp == NULL)
        !            71:                                        np->n_data = dp->d_next;
        !            72:                                else
        !            73:                                        pdp->d_next = dp->d_next;
        !            74:                                rminv(dp);
        !            75:                                (void) free((char *)dp);
        !            76:                        }
        !            77:                }
        !            78:        }
        !            79:        if (newdp == NULL)
        !            80:                return (OK);
        !            81:        addinv(np, newdp);      /* modify inverse query tables */
        !            82: 
        !            83:        /* Add to end of list, generally preserving order */
        !            84:        newdp->d_next = NULL;
        !            85:        if ((dp = np->n_data) == NULL)  {
        !            86:                np->n_data = newdp;
        !            87:                return (OK);
        !            88:        }
        !            89:        while (dp->d_next != NULL) {
        !            90:                dp = dp->d_next;
        !            91:                /* NEEDS: check for duplicate WKS records and flag error */
        !            92:        }
        !            93:        dp->d_next = newdp;
        !            94:        return (OK);
        !            95: }
        !            96: 
        !            97: struct invbuf *invtab[INVHASHSZ];      /* Inverse query hash table */
        !            98: 
        !            99: /*
        !           100:  * Add data 'dp' to inverse query tables for name 'np'.
        !           101:  */
        !           102: addinv(np, dp)
        !           103:        struct namebuf *np;
        !           104:        struct databuf *dp;
        !           105: {
        !           106:        register struct invbuf *ip;
        !           107:        register int hval, i;
        !           108: 
        !           109:        switch (dp->d_type) {
        !           110:        case T_A:
        !           111:        case T_UID:
        !           112:        case T_GID:
        !           113:                break;
        !           114: 
        !           115:        default:
        !           116:                return;
        !           117:        }
        !           118: 
        !           119:        hval = dhash(dp->d_data, dp->d_size);
        !           120:        for (ip = invtab[hval]; ip != NULL; ip = ip->i_next)
        !           121:                for (i = 0; i < INVBLKSZ; i++)
        !           122:                        if (ip->i_dname[i] == NULL) {
        !           123:                                ip->i_dname[i] = np;
        !           124:                                return;
        !           125:                        }
        !           126:        ip = saveinv();
        !           127:        ip->i_next = invtab[hval];
        !           128:        invtab[hval] = ip;
        !           129:        ip->i_dname[0] = np;
        !           130: }
        !           131: 
        !           132: /*
        !           133:  * Remove data 'odp' from inverse query table.
        !           134:  */
        !           135: rminv(odp)
        !           136:        struct databuf *odp;
        !           137: {
        !           138:        register struct invbuf *ip;
        !           139:        register struct databuf *dp;
        !           140:        struct namebuf *np;
        !           141:        register int i;
        !           142: 
        !           143:        for (ip = invtab[dhash(odp->d_data, odp->d_size)]; ip != NULL;
        !           144:            ip = ip->i_next) {
        !           145:                for (i = 0; i < INVBLKSZ; i++) {
        !           146:                        if ((np = ip->i_dname[i]) == NULL)
        !           147:                                break;
        !           148:                        for (dp = np->n_data; dp != NULL; dp = dp->d_next) {
        !           149:                                if (!match(dp, odp->d_class, odp->d_type))
        !           150:                                        continue;
        !           151:                                if (db_cmp(dp, odp))
        !           152:                                        continue;
        !           153:                                while (i < INVBLKSZ-1) {
        !           154:                                        ip->i_dname[i] = ip->i_dname[i+1];
        !           155:                                        i++;
        !           156:                                }
        !           157:                                ip->i_dname[i] = NULL;
        !           158:                                return;
        !           159:                        }
        !           160:                }
        !           161:        }
        !           162: }
        !           163: 
        !           164: /*
        !           165:  * Compute hash value from data.
        !           166:  */
        !           167: dhash(dp, dlen)
        !           168:        char *dp;
        !           169:        int dlen;
        !           170: {
        !           171:        register char *cp;
        !           172:        register unsigned hval;
        !           173:        register int n;
        !           174: 
        !           175:        n = dlen;
        !           176:        if (n > 8)
        !           177:                n = 8;
        !           178:        hval = 0;
        !           179:        for (cp = dp; --n >= 0; ) {
        !           180:                hval <<= 1;
        !           181:                hval += *cp++;
        !           182:        }
        !           183:        return (hval % INVHASHSZ);
        !           184: }
        !           185: 
        !           186: /*
        !           187:  * Compare data sections from databufs for equivalence.  Must be case
        !           188:  * insensitive for some domain names.  We assume that they are the
        !           189:  * same type when they are passed.  Return 0 if equivalent, nonzero
        !           190:  * otherwise.
        !           191:  */
        !           192: 
        !           193: db_cmp(dp1, dp2)
        !           194:        register struct databuf *dp1, *dp2;
        !           195: 
        !           196: {
        !           197:        register char *cp1, *cp2;
        !           198:        int len;
        !           199: 
        !           200:        if (dp1->d_size != dp2->d_size)
        !           201:                return(1);
        !           202:        switch (dp1->d_type) {
        !           203: 
        !           204:        case T_A:
        !           205:        case T_UID:
        !           206:        case T_GID:
        !           207:        case T_WKS:
        !           208:        case T_NULL:
        !           209:                return(bcmp(dp1->d_data, dp2->d_data, dp1->d_size));
        !           210: 
        !           211:        case T_NS:
        !           212:        case T_CNAME:
        !           213:        case T_PTR:
        !           214:        case T_MB:
        !           215:        case T_MG:
        !           216:        case T_MR:
        !           217:        case T_UINFO:
        !           218:                return(cistrcmp(dp1->d_data, dp2->d_data));
        !           219: 
        !           220:        case T_HINFO:
        !           221:                cp1 = dp1->d_data;
        !           222:                cp2 = dp2->d_data;
        !           223:                len = *cp1;
        !           224:                if (cistrncmp(++cp1, ++cp2, len))
        !           225:                        return(1);
        !           226:                cp1 += len;
        !           227:                cp2 += len;
        !           228:                len = *cp1;
        !           229:                return(cistrncmp(++cp1, ++cp2, len));
        !           230: 
        !           231:        case T_SOA:
        !           232:        case T_MINFO:
        !           233:                if (cistrcmp(dp1->d_data, dp2->d_data))
        !           234:                        return(1);
        !           235:                cp1 = dp1->d_data + strlen(dp1->d_data) + 1;
        !           236:                cp2 = dp2->d_data + strlen(dp2->d_data) + 1;
        !           237:                if (dp1->d_type != T_SOA)
        !           238:                        return(cistrcmp(cp1, cp2));
        !           239:                if (cistrcmp(cp1, cp2))
        !           240:                        return(1);
        !           241:                cp1 += strlen(cp1) + 1;
        !           242:                cp2 += strlen(cp2) + 1;
        !           243:                return(bcmp(cp1, cp2, sizeof(u_long) * 5));
        !           244:        
        !           245:        case T_MX:
        !           246:                cp1 = dp1->d_data;
        !           247:                cp2 = dp2->d_data;
        !           248:                if (*cp1++ != *cp2++ || *cp1++ != *cp2++)       /* cmp prio */
        !           249:                        return(1);
        !           250:                return(cistrcmp(cp1, cp2));
        !           251: 
        !           252:        default:
        !           253:                return (1);
        !           254:        }
        !           255: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.