//=================================================================================================
// HTTP action object definition
//
static tsk_object_t* thttp_action_ctor(tsk_object_t * self, va_list * app)
{
thttp_action_t *action = self;
if(action){
va_list* app_2;
thttp_action_param_type_t curr;
action->type = va_arg(*app, thttp_action_type_t);
action->url = tsk_strdup(va_arg(*app, const char*));
action->method = tsk_strdup(va_arg(*app, const char*));
app_2 = va_arg(*app, va_list*);
action->options = tsk_list_create();
action->headers = tsk_list_create();
if(!app_2){ /* XCAP stack will pass null va_list */
goto bail;
}
while((curr = va_arg(*app_2, thttp_action_param_type_t)) != thttp_aptype_null){
switch(curr){
case thttp_aptype_option:
{ /* (thttp_action_option_t)ID_ENUM, (const char*)VALUE_STR */
thttp_action_option_t id = va_arg(*app_2, thttp_action_option_t);
const char* value = va_arg(*app_2, const char *);
tsk_options_add_option(&action->options, id, value);
break;
}
case thttp_aptype_header:
{ /* (const char*)NAME_STR, (const char*)VALUE_STR */
const char* name = va_arg(*app_2, const char *);
const char* value = va_arg(*app_2, const char *);
tsk_params_add_param(&action->headers, name, value);
break;
}
case thttp_aptype_payload:
{ /* (const void*)PAY_PTR, (tsk_size_t)PAY_SIZE */
const void* payload = va_arg(*app_2, const void *);
tsk_size_t size = va_arg(*app_2, tsk_size_t);
if(payload && size){
TSK_OBJECT_SAFE_FREE(action->payload);
action->payload = tsk_buffer_create(payload, size);
}
break;
}
default:
{ /* va_list will be unsafe ==> exit */
TSK_DEBUG_ERROR("NOT SUPPORTED.");
goto bail;
}
} /* switch */
} /* while */
}
bail:
return self;
}
int tsk_params_add_param_2(tsk_params_L_t **self, const tsk_param_t* param)
{
if(!self || !param || !param){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
return tsk_params_add_param(self, param->name, param->value);
}
/** internal fuction used to config a SIP action */
int _tsip_action_set(tsip_action_handle_t* self, va_list* app)
{
tsip_action_param_type_t curr;
tsip_action_t* action = self;
if(!action){ /* Nothing to do */
return 0;
}
while((curr = va_arg(*app, tsip_action_param_type_t)) != aptype_null){
switch(curr){
case aptype_header:
{ /* (const char*)NAME_STR, (const char*)VALUE_STR */
const char* name = va_arg(*app, const char *);
const char* value = va_arg(*app, const char *);
tsk_params_add_param(&action->headers, name, value);
break;
}
case aptype_config:
{ /* (const tsip_action_handle_t*)ACTION_CONFIG_HANDLE */
const tsip_action_t* handle = va_arg(*app, const tsip_action_handle_t *);
if(handle && handle->type == tsip_atype_config){
/* Copy headers */
if(!TSK_LIST_IS_EMPTY(handle->headers)){
tsk_list_pushback_list(action->headers, handle->headers);
}
/* Copy payload */
if(handle->payload && handle->payload->data && handle->payload->size){
TSK_OBJECT_SAFE_FREE(action->payload);
action->payload = tsk_buffer_create(handle->payload->data, handle->payload->size);
}
/* Copy resp line */
action->line_resp.code = handle->line_resp.code;
tsk_strupdate(&action->line_resp.phrase, handle->line_resp.phrase);
/* Copy media params */
if(!TSK_LIST_IS_EMPTY(handle->media.params)){
if(!action->media.params){
action->media.params = tmedia_params_create();
}
tsk_list_pushback_list(action->media.params, handle->media.params);
}
}
else if(handle){ /* Only invalid type should cause error */
TSK_DEBUG_ERROR("Invalid action configuration handle.");
return -2;
}
break;
}
case aptype_payload:
{ /* (const void*)PAY_PTR, (tsk_size_t)PAY_SIZE */
const void* payload = va_arg(*app, const void *);
tsk_size_t size = va_arg(*app, tsk_size_t);
if(payload && size){
TSK_OBJECT_SAFE_FREE(action->payload);
action->payload = tsk_buffer_create(payload, size);
}
break;
}
case aptype_resp_line:
{ /* (int32_t)CODE_INT, (const char*)PHRASE_STR */
int32_t code = va_arg(*app, int32_t);
const char* phrase = va_arg(*app, const void *);
action->line_resp.code = (short)code;
tsk_strupdate(&action->line_resp.phrase, phrase);
break;
}
case aptype_media:
{ /* ... */
tmedia_params_L_t* params;
if((params = tmedia_params_create_2(app))){
if(action->media.params){
tsk_list_pushback_list(action->media.params, params);
}
else{
action->media.params = tsk_object_ref(params);
}
TSK_OBJECT_SAFE_FREE(params);
}
break;
}
default:
{ /* va_list will be unsafe ==> exit */
TSK_DEBUG_ERROR("NOT SUPPORTED.");
return -3;
}
} /* switch */
} /* while */
return 0;
}
/** Internal function used to set options.
*/
int __txcap_stack_set(txcap_stack_t* self, va_list *app)
{
txcap_stack_param_type_t curr;
tsk_bool_t cred_updated = tsk_false;
if(!self || !self->http_session){
return -1;
}
while((curr = va_arg(*app, txcap_stack_param_type_t)) != xcapp_null){
switch(curr){
case xcapp_option:
{ /* (txcap_stack_option_t)ID_ENUM, (const char*)VALUE_STR */
txcap_stack_option_t ID_ENUM = va_arg(*app, txcap_stack_option_t);
const char* VALUE_STR = va_arg(*app, const char*);
switch(ID_ENUM){
case TXCAP_STACK_OPTION_ROOT:
{
tsk_strupdate(&self->xcap_root, VALUE_STR);
break;
}
/* PASSWORD and XUI are not used as options in the HTTP/HTTPS stack */
case TXCAP_STACK_OPTION_PASSWORD:
{
tsk_strupdate(&self->password, VALUE_STR);
cred_updated = tsk_true;
break;
}
case TXCAP_STACK_OPTION_XUI:
{
tsk_strupdate(&self->xui, VALUE_STR);
cred_updated = tsk_true;
break;
}
case TXCAP_STACK_OPTION_LOCAL_IP:
{
thttp_stack_set(self->http_stack, THTTP_STACK_SET_LOCAL_IP(VALUE_STR),
THTTP_STACK_SET_NULL());
break;
}
case TXCAP_STACK_OPTION_LOCAL_PORT:
{
int port = atoi(VALUE_STR);
thttp_stack_set(self->http_stack, THTTP_STACK_SET_LOCAL_PORT(port),
THTTP_STACK_SET_NULL());
break;
}
default:
{ /* HTTP Options: MUST be changed to valid HTTP option enum */
switch(ID_ENUM){
case TXCAP_STACK_OPTION_TIMEOUT:
tsk_options_add_option(&((thttp_session_t*)self->http_session)->options, THTTP_SESSION_OPTION_TIMEOUT, VALUE_STR);
break;
case TXCAP_STACK_OPTION_TTL:
tsk_options_add_option(&((thttp_session_t*)self->http_session)->options, THTTP_SESSION_OPTION_TTL, VALUE_STR);
break;
default:
TSK_DEBUG_WARN("%d is an invalid XCAP option", ID_ENUM);
break;
}
break;
}
}
break;
}
case xcapp_header:
{ /* (const char*)NAME_STR, (const char*)VALUE_STR */
const char* NAME_STR = va_arg(*app, const char*);
const char* VALUE_STR = va_arg(*app, const char*);
if(VALUE_STR == (const char*)-1){
tsk_params_remove_param(((thttp_session_t*)self->http_session)->headers, NAME_STR);
}
else{
tsk_params_add_param(&((thttp_session_t*)self->http_session)->headers, NAME_STR, VALUE_STR);
}
break;
}
case xcapp_userdata:
{ /* (const void*)CTX_PTR */
const void* CTX_PTR = va_arg(*app, const void*);
((thttp_session_t*)self->http_session)->userdata = CTX_PTR;
break;
}
case xcapp_auid:
{ /* (const char*)ID_STR, (const char*)MIME_TYPE_STR, (const char*)NS_STR, (const char*)DOC_NAME_STR, (tsk_bool_t)IS_GLOBAL_BOOL */
const char* ID_STR = va_arg(*app, const char*);
const char* MIME_TYPE_STR = va_arg(*app, const char*);
const char* NS_STR = va_arg(*app, const char*);
const char* DOC_NAME_STR = va_arg(*app, const char*);
tsk_bool_t IS_GLOBAL_BOOL = va_arg(*app, tsk_bool_t);
if(txcap_auid_register(self->auids, ID_STR, MIME_TYPE_STR, NS_STR, DOC_NAME_STR, IS_GLOBAL_BOOL)){
// do nothing
}
break;
}
default:
{
TSK_DEBUG_ERROR("NOT SUPPORTED.");
goto bail;
}
} /* switch */
} /* while */
if(cred_updated && self->http_session){
/* credentials */
thttp_session_set(self->http_session,
THTTP_SESSION_SET_CRED(self->xui, self->password),
THTTP_SESSION_SET_NULL());
}
return 0;
bail:
return -2;
}
