//
// The function to handle a client connection
//
void handle_connection(int fd)
{
http_req req;
FILE *rx, *tx;
exit_msg((fd < 0) || (fd > FD_SETSIZE), "bad fd");
// for streams with sockets, need one for read and one for write
rx = fdopen(fd, "r");
tx = fdopen(dup(fd), "w");
init_req(&req);
http_get_request(rx, &req);
http_process_request(&req);
http_response(tx, &req);
shutdown(fileno(rx), SHUT_RDWR);
fclose(rx);
fclose(tx);
free_req(&req);
return;
}
/*
* http_handle_receive()
*
* Work out what the request we received was, and handle it.
*/
void http_handle_receive(http_conn* conn, int http_instance)
{
int data_used, rx_code;
if (conn->state == READY)
{
rx_code = recv(conn->fd, conn->rx_wr_pos,
(HTTP_RX_BUF_SIZE - (conn->rx_wr_pos - conn->rx_buffer) -1),
0);
/*
* If a valid data received, take care of buffer pointer & string
* termination and move on. Otherwise, we need to return and wait for more
* data to arrive (until we time out).
*/
if(rx_code > 0)
{
/* Increment rx_wr_pos by the amount of data received. */
conn->rx_wr_pos += rx_code;
/* Place a zero just after the data received to serve as a terminator. */
*(conn->rx_wr_pos+1) = 0;
if(strstr(conn->rx_buffer, HTTP_END_OF_HEADERS))
{
conn->state = PROCESS;
}
/* If the connection is a file upload, skip right to DATA.*/
if(conn->file_upload == 1)
{
conn->state = DATA;
}
}
}
if(conn->state == PROCESS)
{
/*
* If we (think) we have valid headers, keep the connection alive a bit
* longer.
*/
conn->activity_time = alt_nticks();
/*
* Attempt to process the fundamentals of the HTTP request. We may
* error out and reset if the request wasn't complete, or something
* was asked from us that we can't handle.
*/
if (http_process_request(conn))
{
fprintf(stderr, "[http_handle_receive] http_process_request failed\n");
conn->state = RESET;
http_manage_connection(conn, http_instance);
}
/*
* Step through the headers to see if there is any other useful
* information about our pending transaction to extract. After that's
* done, send some headers of our own back to let the client know
* what's happening. Also, once all in-coming headers have been parsed
* we can manage our RX buffer to prepare for the next in-coming
* connection.
*/
while(conn->state == PROCESS)
{
if(http_read_line(conn))
{
fprintf(stderr, "[http_handle_receive] error reading headers\n");
conn->state = RESET;
http_manage_connection(conn, http_instance);
break;
}
if(http_process_headers(conn))
{
if( (conn->rx_rd_pos = strstr(conn->rx_rd_pos, HTTP_CR_LF)) )
{
conn->rx_rd_pos += 2;
conn->state = DATA;
conn->activity_time = alt_nticks();
}
else
{
fprintf(stderr, "[http_handle_receive] Can't find end of headers!\n");
conn->state = RESET;
http_manage_connection(conn, http_instance);
break;
}
}
} /* while(conn->state == PROCESS) */
if( http_prepare_response(conn) )
{
conn->state = RESET;
fprintf(stderr, "[http_handle_receive] Error preparing response\n");
http_manage_connection(conn, http_instance);
}
/*
* Manage RX Buffer: Slide any un-read data in our input buffer
* down over previously-read data that can now be overwritten, and
* zero-out any bytes in question at the top of our new un-read space.
*/
if(conn->rx_rd_pos > (conn->rx_buffer + HTTP_RX_BUF_SIZE))
{
conn->rx_rd_pos = conn->rx_buffer + HTTP_RX_BUF_SIZE;
}
data_used = conn->rx_rd_pos - conn->rx_buffer;
memmove(conn->rx_buffer,conn->rx_rd_pos,conn->rx_wr_pos-conn->rx_rd_pos);
conn->rx_rd_pos = conn->rx_buffer;
conn->rx_wr_pos -= data_used;
memset(conn->rx_wr_pos, 0, data_used);
}
if (conn->state == DATA && conn->file_upload == 1 )
{
/* Jump to the file_upload() function....process more received data. */
upload_field.func(conn);
}
}
char *http_post_content(char *url, char **type, int *code, int *size, const char *contype, char *post) {
return http_process_request(url, HTTP_POST, type, code, size, contype, post);
}
char *http_get_content(char *url, char **type, int *code, int *size) {
return http_process_request(url, HTTP_GET, type, code, size, NULL, NULL);
}