//*************************************************
int http_parse_request_body(http_request_t *request) {
char ch, *p, *q;
enum {
header_start = 0,
header_key,
spaces_before_colon,
spaces_after_colon,
header_value,
header_cr,
header_crlf,
header_crlfcr
} state;
state = request->state;
debug("ready to parese request body, start = %d, last= %d", (int)request->pos, (int)request->last);
http_header_t *hd;
for (p = request->pos; p < request->last; p++) {
ch = *p;
switch (state) {
case header_start:
if (ch == CR || ch == LF)
break;
request->cur_header_key_start = p;
state = header_key;
break;
case header_key:
if (ch == ' ') {
request->cur_header_key_end = p;
state = spaces_before_colon;
break;
}
if (ch == ':') {
request->cur_header_key_end = p;
state = spaces_after_colon;
break;
}
break;
case spaces_before_colon:
if (ch == ' ')
break;
else if (ch == ':') {
state = spaces_after_colon;
break;
}
else
return HTTP_PARSE_INVALID_HEADER;
case spaces_after_colon:
if (ch == ' ')
break;
state = header_value;
request->cur_header_value_start = p;
break;
case header_value:
if (ch == CR) {
request->cur_header_value_end = p;
state = header_cr;
}
if (ch == LF) {
request->cur_header_value_end = p;
state = header_crlf;
}
break;
case header_cr:
if (ch == LF) {
state = header_crlf;
hd = (http_header_t *)malloc(sizeof(http_header_t));
hd->key_start = request->cur_header_key_start;
hd->key_end = request->cur_header_key_end;
hd->value_start = request->cur_header_value_start;
hd->value_end = request->cur_header_value_end;
list_node_t *node = (list_node_t *)malloc(sizeof(list_node_t));
node->ptr = (void *)hd;
list_tail_add(request->head, node);
request->num_headers++;
break;
}
else {
return HTTP_PARSE_INVALID_HEADER;
}
case header_crlf:
if (ch == CR) {
state = header_crlfcr;
}
else {
request->cur_header_key_start = p;
state = header_key;
}
break;
case header_crlfcr:
switch (ch) {
case LF:
goto done;
default:
return HTTP_PARSE_INVALID_HEADER;
}
break;
}
}
request->pos = p;
request->state = state;
return SERVER_AGAIN;
done:
request->pos = p + 1;
request->state = header_start;
return SERVER_OK;
}
os_status osTasksInitialize(int max_task)
{
int counter;
os_ecb_t *new_event;
os_status status;
/* Always reserve task idle for background. */
g_total_tasks_number = (uint32_t)max_task;
OS_ASSERT_COND(TASK_IDLE_ID == 0);
INIT_LIST_OBJECT(&g_unused_tasks_list);
INIT_LIST_OBJECT(&g_unused_events_list);
INIT_LIST_OBJECT(&g_sorted_expiration_list);
/* Perform core specific tasks initializations */
status = coreTasksInitialize();
OS_ASSERT_COND(status == OS_SUCCESS);
/* Initialize a task with dummy lowest + 1priority to prevent if != NULL in taskHighestSet. */
g_running_task = osMalloc(sizeof(os_tcb_t), OS_MEM_LOCAL);
if(g_running_task == NULL)
{
RETURN_ERROR(OS_ERR_NO_MEMORY);
}
g_running_task->priority = 32;
/* Allocate ECB structures. */
if(g_total_events_number > 0)
{
g_all_events_array = osMalloc(g_total_events_number * sizeof(os_ecb_t), OS_MEM_LOCAL);
if (g_all_events_array == NULL)
{
RETURN_ERROR(OS_ERR_NO_MEMORY);
}
}
/* Connect all the ECBs in a doubly linked list. */
for (counter = 0; counter < g_total_events_number; counter++)
{
new_event = ((os_ecb_t *)g_all_events_array) + counter;
new_event->event_id = (uint32_t)counter;
new_event->event_type = EVENT_TYPE_UNUSED;
list_tail_add(&new_event->event_list, &g_unused_events_list);
}
/* Allocate TCB structures. */
g_all_tasks_array = osMalloc(g_total_tasks_number * sizeof(os_tcb_t), OS_MEM_LOCAL);
if (g_all_tasks_array == NULL)
{
RETURN_ERROR(OS_ERR_NO_MEMORY);
}
/* Connect all the TCBs in a doubly linked list. */
/* first one is reserved for background. */
g_all_tasks_array [TASK_IDLE_ID].task_event = NULL;
g_all_tasks_array [TASK_IDLE_ID].task_message = 0;
g_all_tasks_array [TASK_IDLE_ID].task_status = OS_TASK_ACQUIRED;
g_all_tasks_array [TASK_IDLE_ID].expiration_tick = 0;
g_all_tasks_array [TASK_IDLE_ID].task_id = TASK_IDLE_ID;
g_all_tasks_array [TASK_IDLE_ID].task_handle = 0;
g_all_tasks_array [TASK_IDLE_ID].private_data = 0;
/* TASK_IDLE_ID must be 0 in order to refrain from holes in the linked list */
OS_ASSERT_COMPILER_COND(TASK_IDLE_ID == 0);
OS_ASSERT_COMPILER_COND(g_total_tasks_number > 0);
for (counter = (TASK_IDLE_ID + 1); counter < g_total_tasks_number ; counter++)
{
g_all_tasks_array [counter].task_event = NULL;
g_all_tasks_array [counter].task_message = 0;
g_all_tasks_array [counter].task_status = OS_TASK_UNUSED;
g_all_tasks_array [counter].expiration_tick = 0;
g_all_tasks_array [counter].task_id = (uint32_t)(counter+1) ;
g_all_tasks_array [counter].task_handle = (os_task_handle)counter;
g_all_tasks_array [counter].private_data = 0;
list_tail_add(&(g_all_tasks_array + counter)->pend_list, &g_unused_tasks_list);
}
/* Init empty ready list for each priority. */
for (counter = 0; counter < OS_NUM_OF_PRIORITIES; counter++)
{
INIT_LIST_OBJECT(&g_ready_tasks[counter]);
}
return OS_SUCCESS;
}
