void update_struct(student *list_student, marks *list_marks)
{
FILE *fp;
char *buffer;
fp = open_file("students.txt", "rb");
buffer = create_buffer(fp);
fclose(fp);
split_buffer(buffer, list_student);
fp = open_file("marks.txt", "rb");
buffer = create_buffer(fp);
fclose(fp);
split_marks_buffer(buffer, list_marks);
}
void client_ptr(t_all *all, t_client *client)
{
char buff[512];
int len;
t_client *tmp;
if ((len = read(client->fd, buff, 511)) <= 0)
{
remove_client(all, client);
return ;
}
buff[len] = 0;
tmp = all->actual;
while (tmp)
{
tmp->len = len;
tmp = tmp->next;
}
FD_SET(client->fd, &(all->fds->fd_write));
all->buf.push(&(all->buf), buff);
split_buffer(all, client);
}
static rc_t vdi_on_newline( ictx * ctx, const String * Line )
{
rc_t rc = 0;
Vector v;
uint32_t args = split_buffer( &v, Line, " \t" ); /* from vdb-dump-helper.c */
if ( args > 0 )
{
const String * S = VectorGet( &v, 0 );
if ( S != NULL )
{
int32_t cmd_idx = index_of_match( S, 6,
"quit", "exit", "help", "repo", "test", "print" );
ctx->done = ( cmd_idx == 0 || cmd_idx == 1 );
if ( !ctx->done )
{
switch( cmd_idx )
{
case 2 : rc = vdi_help( &v ); break; /* above */
case 3 : rc = vdi_repo( &v ); break; /* in vdb-dump-repo */
case 4 : rc = vdi_test( &v ); break;
case 5 : rc = vdp_print_interactive( &v, ctx->vsctx ); break; /* in vdb-dump-print */
default : rc = KOutMsg( "??? {%S}", S ); break;
}
if ( rc == 0 )
{
if ( ctx->interactive )
rc = KOutMsg( "%S", &( ctx->PROMPT ) );
else
rc = KOutMsg( "\n" );
}
}
}
}
destroy_String_vector( &v ); /* from vdb-dump-helper.c */
return rc;
}
/* Searches all of the free buffers across all pages for one that
properly fits the requested size (adjusted for alloc header).
This searches all pages for given buffer size before moving on
to the bigger size, splitting the larger buffer down if necessary.
If none of the pages can fit the requested size, a new page is
allocated and a page header created and allocated. In the special
case of the buffer request being > PAGESIZE/2 a new page is always
allocated.
*/
void* get_free_buffer(int size)
{
pageheaderT* page_header = PAGE_HEADER(first_page);
pageheaderT* prev_page = NULL;
int i = 0;
int search_size = round_up(REALSIZE(size));
allocheaderT* to_be_allocated;
freelistL* buffer_size = get_required_buffer(search_size, page_header);
// Loops through each buffer size
while (search_size <= PAGESIZE)
{
// Loops through each page until it goes through all of them or
// finds a free buffer.
while (page_header != NULL && buffer_size->first_block == NULL)
{
prev_page = page_header;
page_header = page_header->next;
buffer_size = get_required_buffer(search_size, page_header);
}
// None found, increase size and repeat
if (buffer_size == NULL)
{
i++;
page_header = PAGE_HEADER(first_page);
prev_page = NULL;
search_size = search_size * 2;
buffer_size = get_required_buffer(search_size, page_header);
}
// Found. Splits depending on the number of times through the loop,
// removes the buffer from the free list, and returns it.
else
{
to_be_allocated = buffer_size->first_block;
if (i == 0)
{
buffer_size->first_block = to_be_allocated->next;
}
else
{
for(; i > 0; i--)
{
buffer_size = split_buffer(buffer_size, page_header);
}
to_be_allocated = buffer_size->first_block;
buffer_size->first_block = to_be_allocated->next;
}
page_header->used += 1;
return to_be_allocated;
}
}
// No buffers found. Find the last page again.
while (page_header != NULL)
{
prev_page = page_header;
page_header = page_header->next;
}
// Create a new page, split it up to insert the header.
kma_page_t* new_page = init_page();
page_header = PAGE_HEADER(new_page);
prev_page->next = page_header;
buffer_size = get_required_buffer(sizeof(pageheaderT), page_header);
to_be_allocated = buffer_size->first_block;
i = 0;
while (buffer_size != NULL && buffer_size->first_block == NULL)
{
buffer_size = buffer_size->bigger_size;
i++;
}
for(; i > 0; i--)
{
buffer_size = split_buffer(buffer_size, page_header);
}
to_be_allocated = buffer_size->first_block;
buffer_size->first_block = to_be_allocated->next;
// If size > PAGESIZE/2, clears free headers and allocates the
// whole page.
if (round_up(REALSIZE(size)) == PAGESIZE)
{
page_header->free_headers.buffer32.first_block = NULL;
page_header->free_headers.buffer64.first_block = NULL;
page_header->free_headers.buffer128.first_block = NULL;
page_header->free_headers.buffer256.first_block = NULL;
page_header->free_headers.buffer512.first_block = NULL;
page_header->free_headers.buffer1024.first_block = NULL;
page_header->free_headers.buffer2048.first_block = NULL;
page_header->free_headers.buffer4096.first_block = NULL;
page_header->free_headers.buffer8192.first_block = NULL;
page_header->used += 1;
return (void*)((long int) page_header + sizeof(pageheaderT));
}
// Now that the page has been created, try allocating again.
return get_free_buffer(size);
}
