Return to blockdata.c CVS log

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

dnsmasq 2.71

    1: /* dnsmasq is Copyright (c) 2000-2014 Simon Kelley
    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: #ifdef HAVE_DNSSEC
   20: 
   21: static struct blockdata *keyblock_free;
   22: static unsigned int blockdata_count, blockdata_hwm, blockdata_alloced;
   23: 
   24: static void blockdata_expand(int n)
   25: {
   26:   struct blockdata *new = whine_malloc(n * sizeof(struct blockdata));
   27:   
   28:   if (n > 0 && new)
   29:     {
   30:       int i;
   31:       
   32:       new[n-1].next = keyblock_free;
   33:       keyblock_free = new;
   34: 
   35:       for (i = 0; i < n - 1; i++)
   36: 	new[i].next = &new[i+1];
   37: 
   38:       blockdata_alloced += n;
   39:     }
   40: }
   41: 
   42: /* Preallocate some blocks, proportional to cachesize, to reduce heap fragmentation. */
   43: void blockdata_init(void)
   44: {
   45:   keyblock_free = NULL;
   46:   blockdata_alloced = 0;
   47:   blockdata_count = 0;
   48:   blockdata_hwm = 0;
   49: 
   50:   /* Note that daemon->cachesize is enforced to have non-zero size if OPT_DNSSEC_VALID is set */  
   51:   if (option_bool(OPT_DNSSEC_VALID))
   52:     blockdata_expand((daemon->cachesize * 100) / sizeof(struct blockdata));
   53: }
   54: 
   55: void blockdata_report(void)
   56: {
   57:   if (option_bool(OPT_DNSSEC_VALID))
   58:     my_syslog(LOG_INFO, _("DNSSEC memory in use %u, max %u, allocated %u"), 
   59: 	      blockdata_count * sizeof(struct blockdata),  
   60: 	      blockdata_hwm * sizeof(struct blockdata),  
   61: 	      blockdata_alloced * sizeof(struct blockdata));
   62: } 
   63: 
   64: struct blockdata *blockdata_alloc(char *data, size_t len)
   65: {
   66:   struct blockdata *block, *ret = NULL;
   67:   struct blockdata **prev = &ret;
   68:   size_t blen;
   69: 
   70:   while (len > 0)
   71:     {
   72:       if (!keyblock_free)
   73: 	blockdata_expand(50);
   74:       
   75:       if (keyblock_free)
   76: 	{
   77: 	  block = keyblock_free;
   78: 	  keyblock_free = block->next;
   79: 	  blockdata_count++; 
   80: 	}
   81:       else
   82: 	{
   83: 	  /* failed to alloc, free partial chain */
   84: 	  blockdata_free(ret);
   85: 	  return NULL;
   86: 	}
   87:        
   88:       if (blockdata_hwm < blockdata_count)
   89: 	blockdata_hwm = blockdata_count; 
   90:       
   91:       blen = len > KEYBLOCK_LEN ? KEYBLOCK_LEN : len;
   92:       memcpy(block->key, data, blen);
   93:       data += blen;
   94:       len -= blen;
   95:       *prev = block;
   96:       prev = &block->next;
   97:       block->next = NULL;
   98:     }
   99:   
  100:   return ret;
  101: }
  102: 
  103: void blockdata_free(struct blockdata *blocks)
  104: {
  105:   struct blockdata *tmp;
  106:   
  107:   if (blocks)
  108:     {
  109:       for (tmp = blocks; tmp->next; tmp = tmp->next)
  110: 	blockdata_count--;
  111:       tmp->next = keyblock_free;
  112:       keyblock_free = blocks; 
  113:       blockdata_count--;
  114:     }
  115: }
  116: 
  117: /* if data == NULL, return pointer to static block of sufficient size */
  118: void *blockdata_retrieve(struct blockdata *block, size_t len, void *data)
  119: {
  120:   size_t blen;
  121:   struct  blockdata *b;
  122:   void *new, *d;
  123:   
  124:   static unsigned int buff_len = 0;
  125:   static unsigned char *buff = NULL;
  126:    
  127:   if (!data)
  128:     {
  129:       if (len > buff_len)
  130: 	{
  131: 	  if (!(new = whine_malloc(len)))
  132: 	    return NULL;
  133: 	  if (buff)
  134: 	    free(buff);
  135: 	  buff = new;
  136: 	}
  137:       data = buff;
  138:     }
  139:   
  140:   for (d = data, b = block; len > 0 && b;  b = b->next)
  141:     {
  142:       blen = len > KEYBLOCK_LEN ? KEYBLOCK_LEN : len;
  143:       memcpy(d, b->key, blen);
  144:       d += blen;
  145:       len -= blen;
  146:     }
  147: 
  148:   return data;
  149: }
  150:  
  151: #endif