Return to blockdata.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src

Annotation of embedaddon/dnsmasq/src/blockdata.c, revision 1.1.1.3

1.1.1.3 ! misho       1: /* dnsmasq is Copyright (c) 2000-2021 Simon Kelley
1.1       misho       2: 
                      3:    This program is free software; you can redistribute it and/or modify
                      4:    it under the terms of the GNU General Public License as published by
                      5:    the Free Software Foundation; version 2 dated June, 1991, or
                      6:    (at your option) version 3 dated 29 June, 2007.
                      7:  
                      8:    This program is distributed in the hope that it will be useful,
                      9:    but WITHOUT ANY WARRANTY; without even the implied warranty of
                     10:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     11:    GNU General Public License for more details.
                     12:      
                     13:    You should have received a copy of the GNU General Public License
                     14:    along with this program.  If not, see <http://www.gnu.org/licenses/>.
                     15: */
                     16: 
                     17: #include "dnsmasq.h"
                     18: 
                     19: static struct blockdata *keyblock_free;
                     20: static unsigned int blockdata_count, blockdata_hwm, blockdata_alloced;
                     21: 
                     22: static void blockdata_expand(int n)
                     23: {
                     24:   struct blockdata *new = whine_malloc(n * sizeof(struct blockdata));
                     25:   
1.1.1.3 ! misho      26:   if (new)
1.1       misho      27:     {
                     28:       int i;
                     29:       
                     30:       new[n-1].next = keyblock_free;
                     31:       keyblock_free = new;
                     32: 
                     33:       for (i = 0; i < n - 1; i++)
                     34:        new[i].next = &new[i+1];
                     35: 
                     36:       blockdata_alloced += n;
                     37:     }
                     38: }
                     39: 
                     40: /* Preallocate some blocks, proportional to cachesize, to reduce heap fragmentation. */
                     41: void blockdata_init(void)
                     42: {
                     43:   keyblock_free = NULL;
                     44:   blockdata_alloced = 0;
                     45:   blockdata_count = 0;
                     46:   blockdata_hwm = 0;
                     47: 
                     48:   /* Note that daemon->cachesize is enforced to have non-zero size if OPT_DNSSEC_VALID is set */  
                     49:   if (option_bool(OPT_DNSSEC_VALID))
1.1.1.3 ! misho      50:     blockdata_expand(daemon->cachesize);
1.1       misho      51: }
                     52: 
                     53: void blockdata_report(void)
                     54: {
1.1.1.3 ! misho      55:   my_syslog(LOG_INFO, _("pool memory in use %u, max %u, allocated %u"), 
        !            56:            blockdata_count * sizeof(struct blockdata),  
        !            57:            blockdata_hwm * sizeof(struct blockdata),  
        !            58:            blockdata_alloced * sizeof(struct blockdata));
1.1       misho      59: } 
                     60: 
1.1.1.3 ! misho      61: static struct blockdata *blockdata_alloc_real(int fd, char *data, size_t len)
1.1       misho      62: {
                     63:   struct blockdata *block, *ret = NULL;
                     64:   struct blockdata **prev = &ret;
                     65:   size_t blen;
                     66: 
                     67:   while (len > 0)
                     68:     {
                     69:       if (!keyblock_free)
                     70:        blockdata_expand(50);
                     71:       
                     72:       if (keyblock_free)
                     73:        {
                     74:          block = keyblock_free;
                     75:          keyblock_free = block->next;
                     76:          blockdata_count++; 
                     77:        }
                     78:       else
                     79:        {
                     80:          /* failed to alloc, free partial chain */
                     81:          blockdata_free(ret);
                     82:          return NULL;
                     83:        }
                     84:        
                     85:       if (blockdata_hwm < blockdata_count)
                     86:        blockdata_hwm = blockdata_count; 
                     87:       
                     88:       blen = len > KEYBLOCK_LEN ? KEYBLOCK_LEN : len;
1.1.1.3 ! misho      89:       if (data)
        !            90:        {
        !            91:          memcpy(block->key, data, blen);
        !            92:          data += blen;
        !            93:        }
        !            94:       else if (!read_write(fd, block->key, blen, 1))
        !            95:        {
        !            96:          /* failed read free partial chain */
        !            97:          blockdata_free(ret);
        !            98:          return NULL;
        !            99:        }
1.1       misho     100:       len -= blen;
                    101:       *prev = block;
                    102:       prev = &block->next;
                    103:       block->next = NULL;
                    104:     }
                    105:   
                    106:   return ret;
                    107: }
                    108: 
1.1.1.3 ! misho     109: struct blockdata *blockdata_alloc(char *data, size_t len)
        !           110: {
        !           111:   return blockdata_alloc_real(0, data, len);
        !           112: }
        !           113: 
1.1       misho     114: void blockdata_free(struct blockdata *blocks)
                    115: {
                    116:   struct blockdata *tmp;
                    117:   
                    118:   if (blocks)
                    119:     {
                    120:       for (tmp = blocks; tmp->next; tmp = tmp->next)
                    121:        blockdata_count--;
                    122:       tmp->next = keyblock_free;
                    123:       keyblock_free = blocks; 
                    124:       blockdata_count--;
                    125:     }
                    126: }
                    127: 
                    128: /* if data == NULL, return pointer to static block of sufficient size */
                    129: void *blockdata_retrieve(struct blockdata *block, size_t len, void *data)
                    130: {
                    131:   size_t blen;
                    132:   struct  blockdata *b;
                    133:   void *new, *d;
                    134:   
                    135:   static unsigned int buff_len = 0;
                    136:   static unsigned char *buff = NULL;
                    137:    
                    138:   if (!data)
                    139:     {
                    140:       if (len > buff_len)
                    141:        {
                    142:          if (!(new = whine_malloc(len)))
                    143:            return NULL;
                    144:          if (buff)
                    145:            free(buff);
                    146:          buff = new;
                    147:        }
                    148:       data = buff;
                    149:     }
                    150:   
                    151:   for (d = data, b = block; len > 0 && b;  b = b->next)
                    152:     {
                    153:       blen = len > KEYBLOCK_LEN ? KEYBLOCK_LEN : len;
                    154:       memcpy(d, b->key, blen);
                    155:       d += blen;
                    156:       len -= blen;
                    157:     }
                    158: 
                    159:   return data;
                    160: }
1.1.1.3 ! misho     161: 
        !           162: 
        !           163: void blockdata_write(struct blockdata *block, size_t len, int fd)
        !           164: {
        !           165:   for (; len > 0 && block; block = block->next)
        !           166:     {
        !           167:       size_t blen = len > KEYBLOCK_LEN ? KEYBLOCK_LEN : len;
        !           168:       read_write(fd, block->key, blen, 0);
        !           169:       len -= blen;
        !           170:     }
        !           171: }
        !           172: 
        !           173: struct blockdata *blockdata_read(int fd, size_t len)
        !           174: {
        !           175:   return blockdata_alloc_real(fd, NULL, len);
        !           176: }
        !           177: