Return to db_save.c CVS log

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

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

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)db_save.c  4.3 (Berkeley) 6/4/86";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1986 Regents of the University of California
        !             7:  *     All Rights Reserved
        !             8:  */
        !             9: 
        !            10: /*
        !            11:  * Buffer allocation and deallocation routines.
        !            12:  */
        !            13: 
        !            14: #include <sys/types.h>
        !            15: #include <stdio.h>
        !            16: #include <syslog.h>
        !            17: #include "db.h"
        !            18: 
        !            19: #ifdef DEBUG
        !            20: extern int debug;
        !            21: extern FILE *ddt;
        !            22: #endif
        !            23: 
        !            24: extern char *malloc();
        !            25: extern char *strcpy();
        !            26: 
        !            27: /*
        !            28:  * Allocate a name buffer & save name.
        !            29:  */
        !            30: struct namebuf *
        !            31: savename(name)
        !            32:        char *name;
        !            33: {
        !            34:        register struct namebuf *np;
        !            35: 
        !            36:        np = (struct namebuf *) malloc(sizeof(struct namebuf));
        !            37:        if (np == NULL) {
        !            38:                syslog(LOG_ERR, "savename: %m");
        !            39:                exit(1);
        !            40:        }
        !            41:        np->n_dname = savestr(name);
        !            42:        np->n_next = NULL;
        !            43:        np->n_data = NULL;
        !            44:        np->n_hash = NULL;
        !            45:        return (np);
        !            46: }
        !            47: 
        !            48: /*
        !            49:  * Allocate a data buffer & save data.
        !            50:  */
        !            51: struct databuf *
        !            52: savedata(class, type, ttl, data, size)
        !            53:        int class, type;
        !            54:        u_long ttl;
        !            55:        char *data;
        !            56:        int size;
        !            57: {
        !            58:        register struct databuf *dp;
        !            59: 
        !            60:        dp = (struct databuf *) malloc((unsigned)DATASIZE(size));
        !            61:        if (dp == NULL) {
        !            62:                syslog(LOG_ERR, "savedata: %m");
        !            63:                exit(1);
        !            64:        }
        !            65:        dp->d_next = NULL;
        !            66:        dp->d_type = type;
        !            67:        dp->d_class = class;
        !            68:        dp->d_ttl = ttl;
        !            69:        dp->d_size = size;
        !            70:        bcopy(data, dp->d_data, dp->d_size);
        !            71:        return (dp);
        !            72: }
        !            73: 
        !            74: int hashsizes[] = {    /* hashtable sizes */
        !            75:        11,
        !            76:        113,
        !            77:        977,
        !            78:        4073,
        !            79:        16001,
        !            80:        0
        !            81: };
        !            82: 
        !            83: /*
        !            84:  * Allocate a data buffer & save data.
        !            85:  */
        !            86: struct hashbuf *
        !            87: savehash(oldhtp)
        !            88:        struct hashbuf *oldhtp;
        !            89: {
        !            90:        register struct hashbuf *htp;
        !            91:        register int n;
        !            92:        int newsize;
        !            93: 
        !            94:        if (oldhtp == NULL)
        !            95:                newsize = hashsizes[0];
        !            96:        else {
        !            97:                for (n = 0; newsize = hashsizes[n++]; )
        !            98:                        if (oldhtp->h_size == newsize) {
        !            99:                                newsize = hashsizes[n];
        !           100:                                break;
        !           101:                        }
        !           102:                if (newsize == 0)
        !           103:                        newsize = oldhtp->h_size * 2 + 1;
        !           104:        }
        !           105:        htp = (struct hashbuf *) malloc((unsigned)HASHSIZE(newsize));
        !           106:        if (htp == NULL) {
        !           107:                syslog(LOG_ERR, "savehash: %m");
        !           108:                exit(1);
        !           109:        }
        !           110:        htp->h_size = newsize;
        !           111:        bzero((char *) htp->h_tab, newsize * sizeof(struct hashbuf *));
        !           112:        if (oldhtp == NULL) {
        !           113:                htp->h_cnt = 0;
        !           114:                return (htp);
        !           115:        }
        !           116: #ifdef DEBUG
        !           117:        if (debug > 3)
        !           118:                fprintf(ddt,"savehash(%#x) cnt=%d, sz=%d, newsz=%d\n",
        !           119:                        oldhtp, oldhtp->h_cnt, oldhtp->h_size, newsize);
        !           120: #endif
        !           121:        htp->h_cnt = oldhtp->h_cnt;
        !           122:        for (n = 0; n < oldhtp->h_size; n++) {
        !           123:                register struct namebuf *np;
        !           124:                struct namebuf *nnp;
        !           125:                register unsigned hval;
        !           126:                register char *cp;
        !           127: 
        !           128:                for (np = oldhtp->h_tab[n]; np != NULL; np = nnp) {
        !           129:                        hval = 0;
        !           130:                        for (cp = np->n_dname; *cp; ) {
        !           131:                                hval <<= HASHSHIFT;
        !           132:                                hval += *cp++ & HASHMASK;
        !           133:                        }
        !           134:                        hval %= htp->h_size;
        !           135:                        nnp = np->n_next;
        !           136:                        np->n_next = htp->h_tab[hval];
        !           137:                        htp->h_tab[hval] = np;
        !           138:                }
        !           139:        }
        !           140:        free((char *) oldhtp);
        !           141:        return (htp);
        !           142: }
        !           143: 
        !           144: /*
        !           145:  * Allocate an inverse query buffer.
        !           146:  */
        !           147: struct invbuf *
        !           148: saveinv()
        !           149: {
        !           150:        register struct invbuf *ip;
        !           151: 
        !           152:        ip = (struct invbuf *) malloc(sizeof(struct invbuf));
        !           153:        if (ip == NULL) {
        !           154:                syslog(LOG_ERR, "saveinv: %m");
        !           155:                exit(1);
        !           156:        }
        !           157:        ip->i_next = NULL;
        !           158:        bzero((char *)ip->i_dname, sizeof(ip->i_dname));
        !           159:        return (ip);
        !           160: }
        !           161: 
        !           162: /*
        !           163:  * Make a copy of a string and return a pointer to it.
        !           164:  */
        !           165: char *
        !           166: savestr(str)
        !           167:        char *str;
        !           168: {
        !           169:        char *cp;
        !           170: 
        !           171:        cp = malloc((unsigned)strlen(str) + 1);
        !           172:        if (cp == NULL) {
        !           173:                syslog(LOG_ERR, "savestr: %m");
        !           174:                exit(1);
        !           175:        }
        !           176:        (void) strcpy(cp, str);
        !           177:        return (cp);
        !           178: }

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