/**
* get_todo_post_params - retrieve a new todo post and put it in the todo list
*
* @client_socket: socket file descriptor of the client
* @msg: full recieved message from the client
* @msg_len: length of message received
* @todo_list: todo list
* @id_count: pointer to id iterator
*
* Return: The error message and the new head todo list node
*/
int post_todo(int client_socket, char *msg,
ssize_t msg_len, list_t **todo_list, int *id_count)
{
int i, error, print_start, header_found = 0;
list_t *new_todo;
if (check_for_header(msg, "Content-Length") < 0)
return (411);
new_todo = initialize_todo(id_count);
error = 0;
find_parameters(msg, msg_len, new_todo);
if (new_todo->description == NULL || new_todo->title == NULL)
error = 422;
if (error)
free(new_todo);
else
{
add_todo_node(new_todo, todo_list, id_count);
post_todo_success(new_todo, client_socket);
}
return (error);
}
/**
* Parse URI
*
* @v uri_string URI as a string
* @ret uri URI
*
* Splits a URI into its component parts. The return URI structure is
* dynamically allocated and must eventually be freed by calling
* uri_put().
*/
struct uri * parse_uri ( const char *uri_string ) {
struct uri *uri;
struct parameters *params;
char *raw;
char *tmp;
char *path;
char *authority;
size_t raw_len;
unsigned int field;
/* Allocate space for URI struct and a copy of the string */
raw_len = ( strlen ( uri_string ) + 1 /* NUL */ );
uri = zalloc ( sizeof ( *uri ) + raw_len );
if ( ! uri )
return NULL;
ref_init ( &uri->refcnt, uri_free );
raw = ( ( ( void * ) uri ) + sizeof ( *uri ) );
/* Copy in the raw string */
memcpy ( raw, uri_string, raw_len );
/* Identify the parameter list, if present */
if ( ( tmp = strstr ( raw, "##params" ) ) ) {
*tmp = '\0';
tmp += 8 /* "##params" */;
params = find_parameters ( *tmp ? ( tmp + 1 ) : NULL );
if ( params ) {
uri->params = claim_parameters ( params );
} else {
/* Ignore non-existent submission blocks */
}
}
/* Chop off the fragment, if it exists */
if ( ( tmp = strchr ( raw, '#' ) ) ) {
*(tmp++) = '\0';
uri->fragment = tmp;
}
/* Identify absolute/relative URI */
if ( ( tmp = strchr ( raw, ':' ) ) ) {
/* Absolute URI: identify hierarchical/opaque */
uri->scheme = raw;
*(tmp++) = '\0';
if ( *tmp == '/' ) {
/* Absolute URI with hierarchical part */
path = tmp;
} else {
/* Absolute URI with opaque part */
uri->opaque = tmp;
path = NULL;
}
} else {
/* Relative URI */
path = raw;
}
/* If we don't have a path (i.e. we have an absolute URI with
* an opaque portion, we're already finished processing
*/
if ( ! path )
goto done;
/* Chop off the query, if it exists */
if ( ( tmp = strchr ( path, '?' ) ) ) {
*(tmp++) = '\0';
uri->query = tmp;
}
/* If we have no path remaining, then we're already finished
* processing.
*/
if ( ! path[0] )
goto done;
/* Identify net/absolute/relative path */
if ( strncmp ( path, "//", 2 ) == 0 ) {
/* Net path. If this is terminated by the first '/'
* of an absolute path, then we have no space for a
* terminator after the authority field, so shuffle
* the authority down by one byte, overwriting one of
* the two slashes.
*/
authority = ( path + 2 );
if ( ( tmp = strchr ( authority, '/' ) ) ) {
/* Shuffle down */
uri->path = tmp;
memmove ( ( authority - 1 ), authority,
( tmp - authority ) );
authority--;
*(--tmp) = '\0';
}
} else {
/* Absolute/relative path */
uri->path = path;
authority = NULL;
}
/* If we don't have an authority (i.e. we have a non-net
* path), we're already finished processing
*/
if ( ! authority )
goto done;
/* Split authority into user[:password] and host[:port] portions */
if ( ( tmp = strchr ( authority, '@' ) ) ) {
/* Has user[:password] */
*(tmp++) = '\0';
uri->host = tmp;
uri->user = authority;
if ( ( tmp = strchr ( authority, ':' ) ) ) {
/* Has password */
*(tmp++) = '\0';
uri->password = tmp;
}
} else {
/* No user:password */
uri->host = authority;
}
/* Split host into host[:port] */
if ( ( uri->host[ strlen ( uri->host ) - 1 ] != ']' ) &&
( tmp = strrchr ( uri->host, ':' ) ) ) {
*(tmp++) = '\0';
uri->port = tmp;
}
/* Decode fields in-place */
for ( field = 0 ; field < URI_FIELDS ; field++ ) {
if ( uri_field ( uri, field ) )
uri_decode ( ( char * ) uri_field ( uri, field ) );
}
done:
DBGC ( uri, "URI parsed \"%s\" to", uri_string );
uri_dump ( uri );
DBGC ( uri, "\n" );
return uri;
}
