Ver 2.0 I complete realloc and FIFO

alloc.c

 #include "alloc.h"
+#include <unistd.h>
+
+unsigned int n_link;
+unsigned int stacked_link;
+meta * meta_header[100];
+
+char Algorithm;
+
+void * m_malloc(size_t size)
+{
+	unsigned int new_size;
+	unsigned int adjust;
+	meta * temp;
+
+	adjust = size % 4;
+	if(adjust == 0)
+		new_size = size;
+	else
+		new_size = size + (4 - adjust);
+	
+	temp = search_and_split(new_size);	
+
+	if(temp == NULL)
+	{
+		meta_header[n_link] = sbrk( sizeof(meta) ); // because meta's size = 16
+		meta_header[n_link]->free = 0;
+		meta_header[n_link]->size = new_size;
+
+		set_link();
+		n_link++;
+
+	}
+	else
+	{
+		printf("dlrjakwsi?\n");
+		return temp + 1;
+	}
+//	printf(" ")	;
+	return sbrk(size); // return address to pointer
+
+
+}
+void * m_realloc(void *ptr , size_t size)
+{
+	int flag1, flag2;
+	flag1 = 0;
+	flag2 = 0;
+	int compare_size = 0;
+	unsigned int save = 0;
+	meta * temp = NULL;
+	save = ptr;
+	temp = save - 0x10;
+//	printf("temp -> size %d and size %d\n",temp->size, size);
+//*/******************************************
+	unsigned int adjust;
+	unsigned int new_size;
+	meta * save_temp;
+	unsigned int save_size;
+	unsigned int save_tail;
+	adjust = size % 4;
+	if(adjust == 0)
+		new_size = size;
+	else
+		new_size = size + (4 - adjust);
+	
+	if(temp ->size == new_size)
+			return ptr;
+//***********************************************/	    
+	if(META.Tail == temp)
+	{
+		if(temp -> size > new_size)
+		{
+			temp -> size = new_size;
+			brk(ptr + new_size);
+			return ptr;
+		}
+	}
+
+	if ( (int) temp -> size -(int) new_size >= 20)
+	{
+		split_block(temp, new_size); // split and add meta
+		return ptr;
+	}
+	else if( (int) temp -> size > (int) new_size)
+	{
+		return ptr; // no change
+	}
+//****************************************
+	flag1 = m_search(temp);
+	if(flag1 == 1)
+	{
+		compare_size = temp -> size + temp -> next ->size + 0x10;
+		if(compare_size < new_size)
+		{
+			
+			// malloc and memcpy 
+		}
+		else if((int)compare_size >= (int)new_size + 20)
+		{
+			temp -> size = new_size;
+			save = temp;
+			temp -> next = save + new_size + 0x10;
+			temp -> next -> size = compare_size - new_size - 16;
+			temp -> next -> next = (unsigned int)temp + compare_size + 0x10;
+			return ptr;
+		}
+		else if( (int)compare_size >= (int)new_size)
+		{
+			temp -> size = compare_size;
+			temp -> next = temp -> next -> next;
+			temp -> next -> prev = temp;		
+			return ptr;
+		}
+		
+	}
+	save_temp = ptr;
+	save_size = temp -> size;
+	/*
+	m_free(ptr);
+//	brk( (unsigned int )META.Tail + META.Tail ->size + 0x10);
+	ptr = m_malloc( (size_t) new_size);
+	memmove(ptr, (void *)save_temp , save_size);
+	*/
+	return re_allocate(ptr, temp, new_size);
+
+
+
+//***************************************************
+
+
+}
+void * re_allocate(void * ptr, meta * temp, size_t new_size )
+{
+	unsigned int save_temp;
+	unsigned int save_size;
+	save_size = temp -> size;
+    save_temp = ptr;
+	m_free(ptr);
+	ptr = m_malloc( (size_t) new_size);
+	memmove(ptr, (void *)save_temp, save_size);
+	
+	return ptr;
+
+}
+void split_block(meta * temp, unsigned int new_size)
+{
+	unsigned int save;
+	save = temp;
+	meta_header[n_link] = save + 0x10 + new_size;
+	meta_header[n_link] ->free = 1;
+	
+	meta_header[n_link] -> next = temp -> next;
+	meta_header[n_link] -> next -> prev = meta_header[n_link];
+	temp ->next = meta_header[n_link];
+	meta_header[n_link] -> prev = temp;
+
+	meta_header[n_link] -> size = temp ->size - new_size - 0x10;
+	temp -> free = 0;
+	temp -> size = new_size;		
+
+	n_link++;
+	 
+	return;
+}
+
+
+int m_search(meta * ptr)
+{
+	 if(ptr ->next != NULL )
+	 {
+		if(ptr -> next -> free == 1)
+		return 1;
+	 }
+	return 0;
+}
+  
+
+
+void * m_free( void *ptr)
+{
+	meta * temp;
+	temp = ptr - 0x10;
+//	printf("size : %d \n",temp->size);
+	
+	temp ->free = 1;
+
+	if(temp -> prev != NULL && temp -> prev -> free == 1) //merge 
+	{
+		if( temp == META.Tail)
+		{
+			META.Tail = META.Tail -> prev;
+			temp -> prev -> next = temp -> next;
+			temp -> prev -> size += temp -> size + 0x10;
+		}
+		else
+		{
+			temp -> prev -> next = temp -> next;
+			temp -> next -> prev = temp -> prev;
+			temp -> prev -> size += temp -> size + 0x10;
+		}
+//		printf("check\n");
+		return m_free(temp -> prev + 1);
+	}
+	else if(temp -> next != NULL && temp ->next -> free == 1) // merge
+	{
+		if(temp -> next -> next == NULL)
+		{
+			temp ->size += temp ->next -> size + 0x10;
+			temp ->next = NULL;
+			META.Tail = temp;
+			
+
+		}
+		else
+		{
+			temp -> size += temp -> next ->size + 0x10;
+			temp -> next = temp ->next ->next;
+			temp -> next -> prev = temp;
+		}
+//		printf("yee..\n");
+		return m_free(ptr);
+	}
+	else if(temp -> next == NULL && temp -> prev == NULL)
+	{
+			printf("durldhsi??\n");
+			META.Head = NULL;
+			META.Tail = NULL;
+			brk(NULL);
+	}
+
+	else if(temp -> next == NULL)
+	{
+// ************************************
+			
+		META.Tail ->prev ->next = NULL;
+		META.Tail = META.Tail -> prev;
+		brk(ptr - 0x10);
+
+		return;
+	}
+//	printf("??\n");
+
+}
+void set_link(void)
+{
+	if(META.Head == NULL)
+	{
+
+		META.Head = meta_header[n_link];
+		META.Tail = meta_header[n_link];
+		meta_header[n_link]->prev = NULL;
+		meta_header[n_link]->next = NULL;
+		//printf("twice\n");
+	}
+	else
+	{
+		meta_header[n_link]->prev = META.Tail;
+		meta_header[n_link]->next = NULL;
+		META.Tail -> next = meta_header[n_link];
+		META.Tail = meta_header[n_link];
+
+	}
+	
+}
+meta * search_and_split(size_t size)
+{
+		
+	meta * temp = NULL;
+	temp = META.Head;
+	unsigned int diff;
+	unsigned int save;
+	while(temp != NULL)
+	{
+		if(temp->free == 1 && temp->size >= size)
+		{
+			//	printf("nonono...\n");
+			diff = temp->size - size;
+				
+				if(diff >= 20)
+				{
+					save = temp;
+					meta_header[n_link] = save + 16  +(unsigned int)size;
+					meta_header[n_link] -> free = 1;
+
+					meta_header[n_link] -> next = temp -> next;
+					meta_header[n_link] -> next -> prev = meta_header[n_link];
+					temp -> next = meta_header[n_link];
+					meta_header[n_link] -> prev = temp;
+					
+					meta_header[n_link] -> size = temp -> size - size - 16;
+					temp ->free = 0;
+					temp ->size = size;
+					n_link++;
+					return temp;
+
+
+				}
+				else 
+				{
+//					printf("temp = %p\n",temp);
+					return temp;
+
+				}
+				
+			
+			
+		}
+		temp = temp -> next;
+	}
+
+	return NULL;
+
+
+}
+void print_link(void)
+{
+	meta * temp = NULL;
+	temp = META.Head;
+	while(temp != NULL)
+	{
+		printf("----------------\n");
+		printf("size = %d\n",temp->size);
+		printf("free = %d\n",temp->free);
+		printf("address = %p\n",temp);
+		temp = temp -> next;
+	}
+
+}
+void reverse_print(void)
+{
+	meta * temp = NULL;
+	temp = META.Tail;
+	while(temp != NULL)
+	{
+		printf("----------------\n");
+		printf("size = %d\n",temp->size);
+		printf("free = %d\n",temp->free);
+		printf("address = %p\n",temp);
+		temp = temp -> prev;
+	
+	}
+
+
+}

alloc.h

@@ -2,6 +2,7 @@
 #define _ALLOC_H_
 #include <unistd.h>
 #include <stdio.h>
+#include <string.h>
 typedef struct meta_struct {
 struct meta_struct * prev;
 struct meta_struct * next;
@@ -24,10 +25,16 @@ void * m_free (void * ptr);
 
 void set_link(void);
 
+int m_search(meta *ptr);
+
 meta * search_and_split(size_t size);
 
 void print_link(void);
 
+void split_block(meta * temp, unsigned int new_size);
+
+void * re_allocate(void *ptr, meta *temp, size_t new_size);
+
 void reverse_print(void);
 
 #endif