chunk.c

/* Copyright 2008 Michael Marsh, University of Maryland.
 *
 * This file is part of pydtn.
 *
 * pydtn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * pydtn is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with pydtn.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The views and conclusions contained in the software and documentation
 * are those of the authors and should not be interpreted as representing
 * official policies, either expressed or implied, of the University
 * of Maryland.
 *
 * pydtn extends and embeds the Python interpreter, which is
 * Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
 * and is released under the PSF License Agreement.
 *
 * RANLUX random number generation uses the Boost library,
 * Copyright 1994-2006 by various authors (details in individual files),
 * which is released under the Boost Software License, Version 1.0.
 */

#include "aodv.h"
#include <string.h>

aodv_chunk_t*
new_aodv_chunk( unsigned int length )
{
   aodv_chunk_t* chunk;

   chunk = (aodv_chunk_t*) malloc( sizeof(aodv_chunk_t) );
   if ( NULL == chunk )
   {
      return NULL;
   }

   chunk->length = length;
   chunk->next = NULL;
   chunk->data = NULL;
   if ( length > 0 )
   {
      chunk->data = (unsigned char*) calloc( length, sizeof(unsigned char) );
      if ( NULL == chunk->data )
      {
         free( chunk );
         return NULL;
      }
   }

   return chunk;
}

void
free_aodv_chunk( aodv_chunk_t* chunk )
{
   aodv_chunk_t* curr = chunk;
   aodv_chunk_t* next;
   while ( NULL != curr )
   {
      next = curr->next;
      free( curr->data );
      free( curr );
      curr = next;
   }
}

aodv_chunk_t*
collapse_chunk( const aodv_chunk_t* bigchunk )
{
   unsigned char*       p_data;
   aodv_chunk_t*        collapsed;
   unsigned int         length;
   const aodv_chunk_t*  curr;

   length = 0;
   curr = bigchunk;
   while ( NULL != curr )
   {
      length += curr->length;
      curr = curr->next;
   }

   collapsed = new_aodv_chunk( length );
   if ( NULL == collapsed )
   {
      return NULL;
   }

   curr = bigchunk;
   p_data = collapsed->data;
   while ( NULL != curr )
   {
      memcpy(p_data,curr->data,curr->length);
      p_data += curr->length;
      curr = curr->next;
   }

   return collapsed;
}

---