1 files changed, 4 insertions, 3 deletions

diff --git a/libical/src/libical/icalmemory.c b/libical/src/libical/icalmemory.c
index 058ef37..18d7ef9 100644
--- a/libical/src/libical/icalmemory.c
+++ b/libical/src/libical/icalmemory.c
@@ -24,98 +24,98 @@
     2.1, available at: http://www.fsf.org/copyleft/lesser.html
 
   Or:
 
     The Mozilla Public License Version 1.0. You may obtain a copy of
     the License at http://www.mozilla.org/MPL/
 
  The Original Code is icalmemory.h
 
  ======================================================================*/
 
 /**
  * @file icalmemory.c
  * @brief Common memory management routines.
  *
  * libical often passes strings back to the caller. To make these
  * interfaces simple, I did not want the caller to have to pass in a
  * memory buffer, but having libical pass out newly allocated memory
  * makes it difficult to de-allocate the memory.
  * 
  * The ring buffer in this scheme makes it possible for libical to pass
  * out references to memory which the caller does not own, and be able
  * to de-allocate the memory later. The ring allows libical to have
  * several buffers active simultaneously, which is handy when creating
  * string representations of components. 
  */
 
 #define ICALMEMORY_C
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #ifdef DMALLOC
 #include "dmalloc.h"
 #endif
 
 #include "icalmemory.h"
 #include "icalerror.h"
 
 #include <stdio.h> /* for printf (debugging) */
 #include <stdlib.h> /* for malloc, realloc */
 #include <string.h> /* for memset(), strdup */
 
 #ifdef WIN32
 #include <windows.h>
 #endif
 
-#define BUFFER_RING_SIZE 2500
-#define MIN_BUFFER_SIZE 200
+#define BUFFER_RING_SIZE 50
+#define MIN_BUFFER_SIZE 64
 
 
 /* HACK. Not threadsafe */
 
 typedef struct {
         int pos;
         void *ring[BUFFER_RING_SIZE];
 } buffer_ring;
 
 void icalmemory_free_tmp_buffer (void* buf);
 void icalmemory_free_ring_byval(buffer_ring *br);
 
 static buffer_ring* global_buffer_ring = 0;
 
 #ifdef HAVE_PTHREAD
 #include <pthread.h>
 
 static pthread_key_t  ring_key;
 static pthread_once_t ring_key_once = PTHREAD_ONCE_INIT;
 
 static void ring_destroy(void * buf) {
     if (buf) icalmemory_free_ring_byval((buffer_ring *) buf);
     pthread_setspecific(ring_key, NULL);
 }
 
 static void ring_key_alloc(void) {  
     pthread_key_create(&ring_key, ring_destroy);
 }
 #endif
 
 
 static buffer_ring * buffer_ring_new(void) {
         buffer_ring *br;
         int i;
 
         br = (buffer_ring *)malloc(sizeof(buffer_ring));
 
         for(i=0; i<BUFFER_RING_SIZE; i++){
             br->ring[i]  = 0;
         }
         br->pos = 0;
         return(br);
 }
 
 
 #ifdef HAVE_PTHREAD
 static buffer_ring* get_buffer_ring_pthread(void) {
     buffer_ring *br;
@@ -168,98 +168,99 @@ void  icalmemory_add_tmp_buffer(void* buf)
     /* Assign the buffer to a slot */
     br->ring[br->pos] = buf; 
 }
 
 
 /**
  * Create a new temporary buffer on the ring. Libical owns these and
  * will deallocate them. 
  */
 
 void*
 icalmemory_tmp_buffer (size_t size)
 {
     char *buf;
 
     if (size < MIN_BUFFER_SIZE){
         size = MIN_BUFFER_SIZE;
     }
     
     buf = (void*)malloc(size);
 
     if( buf == 0){
         icalerror_set_errno(ICAL_NEWFAILED_ERROR);
         return 0;
     }
 
     memset(buf,0,size); 
 
     icalmemory_add_tmp_buffer(buf);
 
     return buf;
 }
 
 /** get rid of this buffer ring */
 void icalmemory_free_ring_byval(buffer_ring *br) {
    int i;
    for(i=0; i<BUFFER_RING_SIZE; i++){
     if ( br->ring[i] != 0){
        free( br->ring[i]);
     }
     }
    free(br);
 }
 
 void icalmemory_free_ring()
 {
    buffer_ring *br;
    br = get_buffer_ring();
-
    icalmemory_free_ring_byval(br);
+   if ( global_buffer_ring == br )
+       global_buffer_ring = 0; 
 }
 
 
 
 /** Like strdup, but the buffer is on the ring. */
 char*
 icalmemory_tmp_copy(const char* str)
 {
     char* b = icalmemory_tmp_buffer(strlen(str)+1);
 
     strcpy(b,str);
 
     return b;
 }
     
 
 char* icalmemory_strdup(const char *s)
 {
     return strdup(s);
 }
 
 void
 icalmemory_free_tmp_buffer (void* buf)
 {
    if(buf == 0)
    {
        return;
    }
 
    free(buf);
 }
 
 
 /*
  * These buffer routines create memory the old fashioned way -- so the
  * caller will have to deallocate the new memory 
  */
 
 void* icalmemory_new_buffer(size_t size)
 {
     void *b = malloc(size);
 
     if( b == 0){
         icalerror_set_errno(ICAL_NEWFAILED_ERROR);
         return 0;
     }
 
     memset(b,0,size);