/** Append name-value pair */ APT_DECLARE(apt_bool_t) apt_pair_array_append(apt_pair_arr_t *arr, const apt_str_t *name, const apt_str_t *value, apr_pool_t *pool) { apt_pair_t *pair = apr_array_push(arr); apt_pair_init(pair); if(name) { apt_string_copy(&pair->name,name,pool); } if(value) { apt_string_copy(&pair->value,value,pool); } return TRUE; }
/** Copy MRCP control offer */ MRCP_DECLARE(mrcp_control_descriptor_t*) mrcp_control_offer_copy(const mrcp_control_descriptor_t *offer, apr_pool_t *pool) { mrcp_control_descriptor_t *descriptor = mrcp_control_descriptor_create(pool); if(offer) { *descriptor = *offer; descriptor->cmid_arr = apr_array_copy(pool,offer->cmid_arr); apt_string_copy(&descriptor->ip,&offer->ip,pool); apt_string_copy(&descriptor->resource_name,&offer->resource_name,pool); apt_string_copy(&descriptor->session_id,&offer->session_id,pool); } return descriptor; }
/** Parse MRCP speech-length value */ static apt_bool_t mrcp_speech_length_value_parse(mrcp_speech_length_value_t *speech_length, const apt_str_t *value, apr_pool_t *pool) { if(!value->length) { return FALSE; } switch(*value->buf) { case '+': speech_length->type = SPEECH_LENGTH_TYPE_NUMERIC_POSITIVE; break; case '-': speech_length->type = SPEECH_LENGTH_TYPE_NUMERIC_NEGATIVE; break; default : speech_length->type = SPEECH_LENGTH_TYPE_TEXT; } if(speech_length->type == SPEECH_LENGTH_TYPE_TEXT) { apt_string_copy(&speech_length->value.tag,value,pool); } else { mrcp_numeric_speech_length_t *numeric = &speech_length->value.numeric; apt_str_t str; apt_text_stream_t stream; stream.text = *value; apt_text_stream_reset(&stream); stream.pos++; if(apt_text_field_read(&stream,APT_TOKEN_SP,TRUE,&str) == FALSE) { return FALSE; } numeric->length = apt_size_value_parse(&str); if(apt_text_field_read(&stream,APT_TOKEN_SP,TRUE,&str) == FALSE) { return FALSE; } numeric->unit = apt_string_table_value_parse(speech_unit_string_table,SPEECH_UNIT_COUNT,&str); } return TRUE; }
/** Parse RTSP header field */ static apt_bool_t rtsp_header_field_parse(rtsp_header_t *header, rtsp_header_field_id id, const apt_str_t *value, apr_pool_t *pool) { apt_bool_t status = TRUE; switch(id) { case RTSP_HEADER_FIELD_CSEQ: header->cseq = apt_size_value_parse(value); break; case RTSP_HEADER_FIELD_TRANSPORT: status = rtsp_transport_parse(&header->transport,value,pool); break; case RTSP_HEADER_FIELD_SESSION_ID: status = rtsp_session_id_parse(&header->session_id,value,pool); break; case RTSP_HEADER_FIELD_RTP_INFO: apt_string_copy(&header->rtp_info,value,pool); break; case RTSP_HEADER_FIELD_CONTENT_TYPE: header->content_type = apt_string_table_id_find(rtsp_content_type_string_table,RTSP_CONTENT_TYPE_COUNT,value); break; case RTSP_HEADER_FIELD_CONTENT_LENGTH: header->content_length = apt_size_value_parse(value); break; default: status = FALSE; } return status; }
static size_t string_table_read(apt_str_table_item_t table[], apr_size_t max_count, FILE *file, apr_pool_t *pool) { apt_str_table_item_t *item; size_t count = 0; apt_str_t line; apt_text_stream_t text_stream; text_stream.text.length = fread(parse_buffer, 1, sizeof(parse_buffer)-1, file); parse_buffer[text_stream.text.length] = '\0'; text_stream.text.buf = parse_buffer; text_stream.pos = parse_buffer; do { if(apt_text_line_read(&text_stream,&line) == FALSE || !line.length) { break; } item = &table[count]; apt_string_copy(&item->value,&line,pool); item->key = 0; count++; } while(count < max_count); return count; }
/** Generate MRCP speech-length value */ static apt_bool_t mrcp_speech_length_generate(mrcp_speech_length_value_t *speech_length, apt_str_t *str, apr_pool_t *pool) { if(speech_length->type == SPEECH_LENGTH_TYPE_TEXT) { apt_str_t *tag = &speech_length->value.tag; if(tag->length) { apt_string_copy(str,tag,pool); } } else { char buf[256]; apt_text_stream_t stream; apt_text_stream_init(&stream,buf,sizeof(buf)); if(speech_length->type == SPEECH_LENGTH_TYPE_NUMERIC_POSITIVE) { *stream.pos++ = '+'; } else { *stream.pos++ = '-'; } apt_text_size_value_insert(&stream,speech_length->value.numeric.length); *stream.pos++ = APT_TOKEN_SP; apt_string_table_value_generate(speech_unit_string_table,SPEECH_UNIT_COUNT,speech_length->value.numeric.unit,&stream); apt_string_assign_n(str,stream.text.buf, stream.pos - stream.text.buf, pool); } return TRUE; }
static apt_bool_t mrcp_client_resource_discover(mrcp_client_session_t *session) { mrcp_session_descriptor_t *descriptor = NULL; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Discover Resources "APT_PTR_FMT, MRCP_SESSION_PTR(&session->base)); session->answer = NULL; mrcp_client_session_state_set(session,SESSION_STATE_DISCOVERING); if(mrcp_session_version_get(session) == MRCP_VERSION_1) { mrcp_resource_t *resource; mrcp_resource_id i; for(i=0; i<MRCP_RESOURCE_TYPE_COUNT; i++) { resource = mrcp_resource_get(session->profile->resource_factory,i); if(!resource) continue; descriptor = mrcp_session_descriptor_create(session->base.pool); apt_string_copy(&descriptor->resource_name,&resource->name,session->base.pool); if(mrcp_session_discover_request(&session->base,descriptor) == TRUE) { mrcp_client_session_subrequest_add(session); } } } else { if(mrcp_session_discover_request(&session->base,descriptor) == TRUE) { mrcp_client_session_subrequest_add(session); } } if(session->subrequest_count == 0) { session->status = MRCP_SIG_STATUS_CODE_FAILURE; mrcp_app_sig_response_raise(session,TRUE); } return TRUE; }
/** Duplicate generic-header */ static apt_bool_t mrcp_generic_header_duplicate(mrcp_header_accessor_t *accessor, const mrcp_header_accessor_t *src, size_t id, apr_pool_t *pool) { mrcp_generic_header_t *generic_header = accessor->data; const mrcp_generic_header_t *src_generic_header = src->data; apt_bool_t status = TRUE; if(!generic_header || !src_generic_header) { return FALSE; } switch(id) { case GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST: break; case GENERIC_HEADER_PROXY_SYNC_ID: apt_string_copy(&generic_header->proxy_sync_id,&src_generic_header->proxy_sync_id,pool); break; case GENERIC_HEADER_ACCEPT_CHARSET: apt_string_copy(&generic_header->accept_charset,&src_generic_header->accept_charset,pool); break; case GENERIC_HEADER_CONTENT_TYPE: apt_string_copy(&generic_header->content_type,&src_generic_header->content_type,pool); break; case GENERIC_HEADER_CONTENT_ID: apt_string_copy(&generic_header->content_id,&src_generic_header->content_id,pool); break; case GENERIC_HEADER_CONTENT_BASE: apt_string_copy(&generic_header->content_base,&src_generic_header->content_base,pool); break; case GENERIC_HEADER_CONTENT_ENCODING: apt_string_copy(&generic_header->content_encoding,&src_generic_header->content_encoding,pool); break; case GENERIC_HEADER_CONTENT_LOCATION: apt_string_copy(&generic_header->content_location,&src_generic_header->content_location,pool); break; case GENERIC_HEADER_CONTENT_LENGTH: generic_header->content_length = src_generic_header->content_length; break; case GENERIC_HEADER_CACHE_CONTROL: apt_string_copy(&generic_header->cache_control,&src_generic_header->cache_control,pool); break; case GENERIC_HEADER_LOGGING_TAG: apt_string_copy(&generic_header->logging_tag,&src_generic_header->logging_tag,pool); break; case GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS: generic_header->vendor_specific_params = apt_pair_array_copy(src_generic_header->vendor_specific_params,pool); break; default: status = FALSE; } return status; }
/** Parse id@resource string */ APT_DECLARE(apt_bool_t) apt_id_resource_parse(const apt_str_t *str, char separator, apt_str_t *id, apt_str_t *resource, apr_pool_t *pool) { apt_str_t field = *str; const char *pos = strchr(str->buf,separator); if(!pos) { return FALSE; } field.length = pos - field.buf; if(field.length >= str->length) { return FALSE; } apt_string_copy(id,&field,pool); field.buf += field.length + 1; field.length = str->length - (field.length + 1); apt_string_copy(resource,&field,pool); return TRUE; }
/** Parse name=value pair */ static apt_bool_t apt_pair_parse(apt_pair_t *pair, const apt_str_t *field, apr_pool_t *pool) { apt_text_stream_t stream; apt_str_t item; stream.text = *field; apt_text_stream_reset(&stream); /* read name */ if(apt_text_field_read(&stream,'=',TRUE,&item) == FALSE) { return FALSE; } apt_string_copy(&pair->name,&item,pool); /* read value */ apt_text_field_read(&stream,';',TRUE,&item); apt_string_copy(&pair->value,&item,pool); return TRUE; }
/** Parse generic-header */ static apt_bool_t mrcp_generic_header_parse(mrcp_header_accessor_t *accessor, size_t id, const apt_str_t *value, apr_pool_t *pool) { apt_bool_t status = TRUE; mrcp_generic_header_t *generic_header = accessor->data; switch(id) { case GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST: mrcp_request_id_list_parse(&generic_header->active_request_id_list,value); break; case GENERIC_HEADER_PROXY_SYNC_ID: apt_string_copy(&generic_header->proxy_sync_id,value,pool); break; case GENERIC_HEADER_ACCEPT_CHARSET: apt_string_copy(&generic_header->accept_charset,value,pool); break; case GENERIC_HEADER_CONTENT_TYPE: apt_string_copy(&generic_header->content_type,value,pool); break; case GENERIC_HEADER_CONTENT_ID: apt_string_copy(&generic_header->content_id,value,pool); break; case GENERIC_HEADER_CONTENT_BASE: apt_string_copy(&generic_header->content_base,value,pool); break; case GENERIC_HEADER_CONTENT_ENCODING: apt_string_copy(&generic_header->content_encoding,value,pool); break; case GENERIC_HEADER_CONTENT_LOCATION: apt_string_copy(&generic_header->content_location,value,pool); break; case GENERIC_HEADER_CONTENT_LENGTH: generic_header->content_length = apt_size_value_parse(value); break; case GENERIC_HEADER_CACHE_CONTROL: apt_string_copy(&generic_header->cache_control,value,pool); break; case GENERIC_HEADER_LOGGING_TAG: apt_string_copy(&generic_header->logging_tag,value,pool); break; case GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS: if(!generic_header->vendor_specific_params) { generic_header->vendor_specific_params = apt_pair_array_create(1,pool); } apt_pair_array_parse(generic_header->vendor_specific_params,value,pool); break; default: status = FALSE; } return status; }
/** Parse text value of RTSP transport attrib (source/destination, e.t.c) */ static apt_bool_t rtsp_transport_attrib_value_parse(apt_str_t *value, apt_text_stream_t *stream, apr_pool_t *pool) { apt_str_t field; /* read value */ if(apt_text_field_read(stream,';',TRUE,&field) == FALSE) { return FALSE; } apt_string_copy(value,&field,pool); return TRUE; }
static apt_bool_t apt_string_table_value_pgenerate(const apt_str_table_item_t *string_table, apr_size_t count, apr_size_t id, apt_str_t *str, apr_pool_t *pool) { const apt_str_t *name = apt_string_table_str_get(string_table,count,id); if(!name) { return FALSE; } apt_string_copy(str,name,pool); return TRUE; }
/** Parse MRCP v2 start-line */ static apt_bool_t mrcp_v2_start_line_parse(mrcp_start_line_t *start_line, apt_text_stream_t *stream, apr_pool_t *pool) { apt_str_t field; if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse message-length in v2 start-line"); return FALSE; } start_line->length = apt_size_value_parse(&field); if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse request-id in v2 start-line"); return FALSE; } start_line->request_id = mrcp_request_id_parse(&field); if(start_line->request_id == 0 && *field.buf != '0') { /* parsing MRCP v2 request or event */ start_line->message_type = MRCP_MESSAGE_TYPE_REQUEST; apt_string_copy(&start_line->method_name,&field,pool); if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse request-id in v2 start-line"); return FALSE; } start_line->request_id = mrcp_request_id_parse(&field); if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == TRUE) { /* parsing MRCP v2 event */ start_line->request_state = mrcp_request_state_parse(&field); start_line->message_type = MRCP_MESSAGE_TYPE_EVENT; } } else { /* parsing MRCP v2 response */ start_line->message_type = MRCP_MESSAGE_TYPE_RESPONSE; if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse status-code in v2 start-line"); return FALSE; } start_line->status_code = mrcp_status_code_parse(&field); if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse request-state in v2 start-line"); return FALSE; } start_line->request_state = mrcp_request_state_parse(&field); } return TRUE; }
/** Parse RTSP transport */ static apt_bool_t rtsp_session_id_parse(apt_str_t *session_id, const apt_str_t *value, apr_pool_t *pool) { char *sep; if(!value->buf) { return FALSE; } apt_string_copy(session_id,value,pool); sep = strchr(session_id->buf,';'); if(sep) { session_id->length = sep - session_id->buf; *sep = '\0'; } return TRUE; }
/** Parse MRCP start-line */ MRCP_DECLARE(apt_bool_t) mrcp_start_line_parse(mrcp_start_line_t *start_line, apt_text_stream_t *text_stream, apr_pool_t *pool) { apt_text_stream_t line; apt_str_t field; apt_bool_t status = TRUE; start_line->message_type = MRCP_MESSAGE_TYPE_UNKNOWN; if(apt_text_line_read(text_stream,&line.text) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse MRCP start-line"); return FALSE; } apt_text_stream_reset(&line); if(apt_text_field_read(&line,APT_TOKEN_SP,TRUE,&field) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot read the first field in start-line"); return FALSE; } if(field.buf == strstr(field.buf,MRCP_NAME)) { start_line->version = mrcp_version_parse(&field); if(start_line->version == MRCP_VERSION_1) { /* parsing MRCP v1 response */ start_line->message_type = MRCP_MESSAGE_TYPE_RESPONSE; status = mrcp_response_line_parse(start_line,&line); } else if(start_line->version == MRCP_VERSION_2) { /* parsing MRCP v2 start-line (request/response/event) */ status = mrcp_v2_start_line_parse(start_line,&line,pool); } else { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown MRCP version"); return FALSE; } } else { /* parsing MRCP v1 request or event */ apt_string_copy(&start_line->method_name,&field,pool); status = mrcp_request_line_parse(start_line,&line); } return status; }
/** Set (copy) MRCP header fields */ MRCP_DECLARE(apt_bool_t) mrcp_header_fields_set(mrcp_message_header_t *header, const mrcp_message_header_t *src_header, apr_pool_t *pool) { apt_header_field_t *header_field; const apt_header_field_t *src_header_field; for(src_header_field = APR_RING_FIRST(&src_header->header_section.ring); src_header_field != APR_RING_SENTINEL(&src_header->header_section.ring, apt_header_field_t, link); src_header_field = APR_RING_NEXT(src_header_field, link)) { header_field = apt_header_section_field_get(&header->header_section,src_header_field->id); if(header_field) { /* this header field has already been set, just copy its value */ apt_string_copy(&header_field->value,&src_header_field->value,pool); } else { /* copy the entire header field and add it to the header section */ header_field = apt_header_field_copy(src_header_field,pool); apt_header_section_field_add(&header->header_section,header_field); } mrcp_header_accessor_value_duplicate(header,header_field,src_header,src_header_field,pool); } return TRUE; }
/** Create message and read start line */ static apt_bool_t mrcp_parser_on_start(apt_message_parser_t *parser, apt_message_context_t *context, apt_text_stream_t *stream, apr_pool_t *pool) { mrcp_message_t *mrcp_message; apt_str_t start_line; /* read start line */ if(apt_text_line_read(stream,&start_line) == FALSE) { return FALSE; } /* create new MRCP message */ mrcp_message = mrcp_message_create(pool); /* parse start-line */ if(mrcp_start_line_parse(&mrcp_message->start_line,&start_line,mrcp_message->pool) == FALSE) { return FALSE; } if(mrcp_message->start_line.version == MRCP_VERSION_1) { mrcp_parser_t *mrcp_parser = apt_message_parser_object_get(parser); if(!mrcp_parser->resource) { return FALSE; } apt_string_copy( &mrcp_message->channel_id.resource_name, &mrcp_parser->resource->name, pool); if(mrcp_message_resource_set(mrcp_message,mrcp_parser->resource) == FALSE) { return FALSE; } } context->message = mrcp_message; context->header = &mrcp_message->header.header_section; context->body = &mrcp_message->body; return TRUE; }
/** Parse MRCP recognizer header */ static apt_bool_t mrcp_recog_header_parse(mrcp_recog_header_t *recog_header, apr_size_t id, const apt_str_t *value, apr_pool_t *pool) { apt_bool_t status = TRUE; switch(id) { case RECOGNIZER_HEADER_N_BEST_LIST_LENGTH: recog_header->n_best_list_length = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_NO_INPUT_TIMEOUT: recog_header->no_input_timeout = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_RECOGNITION_TIMEOUT: recog_header->recognition_timeout = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_WAVEFORM_URI: apt_string_copy(&recog_header->waveform_uri,value,pool); break; case RECOGNIZER_HEADER_COMPLETION_CAUSE: recog_header->completion_cause = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_RECOGNIZER_CONTEXT_BLOCK: apt_string_copy(&recog_header->recognizer_context_block,value,pool); break; case RECOGNIZER_HEADER_START_INPUT_TIMERS: apt_boolean_value_parse(value,&recog_header->start_input_timers); break; case RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT: recog_header->speech_complete_timeout = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_SPEECH_INCOMPLETE_TIMEOUT: recog_header->speech_incomplete_timeout = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_DTMF_INTERDIGIT_TIMEOUT: recog_header->dtmf_interdigit_timeout = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_DTMF_TERM_TIMEOUT: recog_header->dtmf_term_timeout = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_DTMF_TERM_CHAR: recog_header->dtmf_term_char = *value->buf; break; case RECOGNIZER_HEADER_FAILED_URI: apt_string_copy(&recog_header->failed_uri,value,pool); break; case RECOGNIZER_HEADER_FAILED_URI_CAUSE: apt_string_copy(&recog_header->failed_uri_cause,value,pool); break; case RECOGNIZER_HEADER_SAVE_WAVEFORM: apt_boolean_value_parse(value,&recog_header->save_waveform); break; case RECOGNIZER_HEADER_NEW_AUDIO_CHANNEL: apt_boolean_value_parse(value,&recog_header->new_audio_channel); break; case RECOGNIZER_HEADER_SPEECH_LANGUAGE: apt_string_copy(&recog_header->speech_language,value,pool); break; case RECOGNIZER_HEADER_INPUT_TYPE: apt_string_copy(&recog_header->input_type,value,pool); break; case RECOGNIZER_HEADER_MEDIA_TYPE: apt_string_copy(&recog_header->media_type,value,pool); break; case RECOGNIZER_HEADER_INPUT_WAVEFORM_URI: apt_string_copy(&recog_header->input_waveform_uri,value,pool); break; case RECOGNIZER_HEADER_COMPLETION_REASON: apt_string_copy(&recog_header->completion_reason,value,pool); break; case RECOGNIZER_HEADER_VER_BUFFER_UTTERANCE: apt_boolean_value_parse(value,&recog_header->ver_buffer_utterance); break; case RECOGNIZER_HEADER_RECOGNITION_MODE: apt_string_copy(&recog_header->recognition_mode,value,pool); break; case RECOGNIZER_HEADER_CANCEL_IF_QUEUE: apt_boolean_value_parse(value,&recog_header->cancel_if_queue); break; case RECOGNIZER_HEADER_HOTWORD_MAX_DURATION: recog_header->hotword_max_duration = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_HOTWORD_MIN_DURATION: recog_header->hotword_min_duration = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_INTERPRET_TEXT: apt_string_copy(&recog_header->interpret_text,value,pool); break; case RECOGNIZER_HEADER_DTMF_BUFFER_TIME: recog_header->dtmf_buffer_time = apt_size_value_parse(value); break; case RECOGNIZER_HEADER_CLEAR_DTMF_BUFFER: apt_boolean_value_parse(value,&recog_header->clear_dtmf_buffer); break; case RECOGNIZER_HEADER_EARLY_NO_MATCH: apt_boolean_value_parse(value,&recog_header->early_no_match); break; default: status = FALSE; } return status; }
/** Duplicate MRCP recognizer header */ static apt_bool_t mrcp_recog_header_duplicate(mrcp_header_accessor_t *accessor, const mrcp_header_accessor_t *src, apr_size_t id, apr_pool_t *pool) { mrcp_recog_header_t *recog_header = accessor->data; const mrcp_recog_header_t *src_recog_header = src->data; apt_bool_t status = TRUE; if(!recog_header || !src_recog_header) { return FALSE; } switch(id) { case RECOGNIZER_HEADER_CONFIDENCE_THRESHOLD: recog_header->confidence_threshold = src_recog_header->confidence_threshold; break; case RECOGNIZER_HEADER_SENSITIVITY_LEVEL: recog_header->sensitivity_level = src_recog_header->sensitivity_level; break; case RECOGNIZER_HEADER_SPEED_VS_ACCURACY: recog_header->speed_vs_accuracy = src_recog_header->speed_vs_accuracy; break; case RECOGNIZER_HEADER_N_BEST_LIST_LENGTH: recog_header->n_best_list_length = src_recog_header->n_best_list_length; break; case RECOGNIZER_HEADER_NO_INPUT_TIMEOUT: recog_header->no_input_timeout = src_recog_header->no_input_timeout; break; case RECOGNIZER_HEADER_RECOGNITION_TIMEOUT: recog_header->recognition_timeout = src_recog_header->recognition_timeout; break; case RECOGNIZER_HEADER_WAVEFORM_URI: apt_string_copy(&recog_header->waveform_uri,&src_recog_header->waveform_uri,pool); break; case RECOGNIZER_HEADER_COMPLETION_CAUSE: recog_header->completion_cause = src_recog_header->completion_cause; break; case RECOGNIZER_HEADER_RECOGNIZER_CONTEXT_BLOCK: apt_string_copy(&recog_header->recognizer_context_block,&src_recog_header->recognizer_context_block,pool); break; case RECOGNIZER_HEADER_START_INPUT_TIMERS: recog_header->start_input_timers = src_recog_header->start_input_timers; break; case RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT: recog_header->speech_complete_timeout = src_recog_header->speech_complete_timeout; break; case RECOGNIZER_HEADER_SPEECH_INCOMPLETE_TIMEOUT: recog_header->speech_incomplete_timeout = src_recog_header->speech_incomplete_timeout; break; case RECOGNIZER_HEADER_DTMF_INTERDIGIT_TIMEOUT: recog_header->dtmf_interdigit_timeout = src_recog_header->dtmf_interdigit_timeout; break; case RECOGNIZER_HEADER_DTMF_TERM_TIMEOUT: recog_header->dtmf_term_timeout = src_recog_header->dtmf_term_timeout; break; case RECOGNIZER_HEADER_DTMF_TERM_CHAR: recog_header->dtmf_term_char = src_recog_header->dtmf_term_char; break; case RECOGNIZER_HEADER_FAILED_URI: apt_string_copy(&recog_header->failed_uri,&src_recog_header->failed_uri,pool); break; case RECOGNIZER_HEADER_FAILED_URI_CAUSE: apt_string_copy(&recog_header->failed_uri_cause,&src_recog_header->failed_uri_cause,pool); break; case RECOGNIZER_HEADER_SAVE_WAVEFORM: recog_header->save_waveform = src_recog_header->save_waveform; break; case RECOGNIZER_HEADER_NEW_AUDIO_CHANNEL: recog_header->new_audio_channel = src_recog_header->new_audio_channel; break; case RECOGNIZER_HEADER_SPEECH_LANGUAGE: apt_string_copy(&recog_header->speech_language,&src_recog_header->speech_language,pool); break; case RECOGNIZER_HEADER_INPUT_TYPE: apt_string_copy(&recog_header->input_type,&src_recog_header->input_type,pool); break; case RECOGNIZER_HEADER_INPUT_WAVEFORM_URI: apt_string_copy(&recog_header->input_waveform_uri,&src_recog_header->input_waveform_uri,pool); break; case RECOGNIZER_HEADER_COMPLETION_REASON: apt_string_copy(&recog_header->completion_reason,&src_recog_header->completion_reason,pool); break; case RECOGNIZER_HEADER_MEDIA_TYPE: apt_string_copy(&recog_header->media_type,&src_recog_header->media_type,pool); break; case RECOGNIZER_HEADER_VER_BUFFER_UTTERANCE: recog_header->ver_buffer_utterance = src_recog_header->ver_buffer_utterance; break; case RECOGNIZER_HEADER_RECOGNITION_MODE: apt_string_copy(&recog_header->recognition_mode,&src_recog_header->recognition_mode,pool); break; case RECOGNIZER_HEADER_CANCEL_IF_QUEUE: recog_header->cancel_if_queue = src_recog_header->cancel_if_queue; break; case RECOGNIZER_HEADER_HOTWORD_MAX_DURATION: recog_header->hotword_max_duration = src_recog_header->hotword_max_duration; break; case RECOGNIZER_HEADER_HOTWORD_MIN_DURATION: recog_header->hotword_min_duration = src_recog_header->hotword_min_duration; break; case RECOGNIZER_HEADER_INTERPRET_TEXT: apt_string_copy(&recog_header->interpret_text,&src_recog_header->interpret_text,pool); break; case RECOGNIZER_HEADER_DTMF_BUFFER_TIME: recog_header->dtmf_buffer_time = src_recog_header->dtmf_buffer_time; break; case RECOGNIZER_HEADER_CLEAR_DTMF_BUFFER: recog_header->clear_dtmf_buffer = src_recog_header->clear_dtmf_buffer; break; case RECOGNIZER_HEADER_EARLY_NO_MATCH: recog_header->early_no_match = src_recog_header->early_no_match; break; default: status = FALSE; } return status; }
static apt_bool_t mrcp_unirtsp_on_session_response(rtsp_client_t *rtsp_client, rtsp_client_session_t *rtsp_session, rtsp_message_t *request, rtsp_message_t *response) { apt_bool_t status = FALSE; mrcp_unirtsp_agent_t *agent = rtsp_client_object_get(rtsp_client); mrcp_unirtsp_session_t *session = rtsp_client_session_object_get(rtsp_session); if(!agent || !session) { return FALSE; } switch(request->start_line.common.request_line.method_id) { case RTSP_METHOD_SETUP: { const apt_str_t *session_id; const char *force_destination_ip = NULL; mrcp_session_descriptor_t *descriptor; if(session->rtsp_settings->force_destination == TRUE) { force_destination_ip = session->rtsp_settings->server_ip; } descriptor = mrcp_descriptor_generate_by_rtsp_response( request, response, force_destination_ip, session->rtsp_settings->resource_map, session->mrcp_session->pool, session->home); if(!descriptor) { return FALSE; } session_id = rtsp_client_session_id_get(session->rtsp_session); if(session_id) { apt_string_copy( &session->mrcp_session->id, session_id, session->mrcp_session->pool); } status = mrcp_session_answer(session->mrcp_session,descriptor); break; } case RTSP_METHOD_TEARDOWN: { mrcp_session_descriptor_t *descriptor; descriptor = mrcp_descriptor_generate_by_rtsp_response( request, response, NULL, session->rtsp_settings->resource_map, session->mrcp_session->pool, session->home); if(!descriptor) { return FALSE; } status = mrcp_session_answer(session->mrcp_session,descriptor); break; } case RTSP_METHOD_ANNOUNCE: { mrcp_unirtsp_agent_t *agent = rtsp_client_object_get(rtsp_client); const char *resource_name = mrcp_name_get_by_rtsp_name( session->rtsp_settings->resource_map, request->start_line.common.request_line.resource_name); mrcp_unirtsp_on_announce_response(agent,session,response,resource_name); break; } case RTSP_METHOD_DESCRIBE: { mrcp_unirtsp_agent_t *agent = rtsp_client_object_get(rtsp_client); mrcp_unirtsp_on_resource_discover(agent,session,request,response); break; } default: break; } return status; }
/** Get the next content part */ APT_DECLARE(apt_bool_t) apt_multipart_content_get(apt_multipart_content_t *multipart_content, apt_str_t *content_type, apt_str_t *content) { apt_str_t boundary; apt_pair_t header; apt_bool_t is_final = FALSE; apt_text_stream_t *stream = &multipart_content->stream; if(!content || !content_type) { return FALSE; } apt_string_reset(content); /* skip preamble */ apt_text_skip_to_char(stream,'-'); if(apt_text_is_eos(stream) == TRUE) { return FALSE; } /* skip initial hyphens */ apt_text_chars_skip(stream,'-'); if(apt_text_is_eos(stream) == TRUE) { return FALSE; } /* read line and the boundary */ if(apt_text_line_read(stream,&boundary) == FALSE) { return FALSE; } /* remove optional trailing spaces */ while(boundary.length && boundary.buf[boundary.length-1] == APT_TOKEN_SP) boundary.length--; /* check whether this is the final boundary */ if(boundary.length >= 2) { if(boundary.buf[boundary.length-1] == '-' && boundary.buf[boundary.length-2] == '-') { /* final boundary */ boundary.length -= 2; is_final = TRUE; } } /* compare boundaries */ if(apt_string_is_empty(&multipart_content->boundary) == TRUE) { /* no boundary was specified from user space, learn boundary from the content */ multipart_content->boundary = boundary; } else { if(apt_string_compare(&multipart_content->boundary,&boundary) == FALSE) { /* invalid boundary */ return FALSE; } } if(is_final == TRUE) { /* final boundary => return TRUE, content remains empty */ return TRUE; } /* read header fields */ do { if(apt_text_header_read(stream,&header) == TRUE) { if(header.name.length) { if(apt_string_compare(&multipart_content->content_type_header,&header.name) == TRUE) { apt_string_copy(content_type,&header.value,multipart_content->pool); } else if(apt_string_compare(&multipart_content->content_length_header,&header.name) == TRUE) { if(header.value.buf) { content->length = atol(header.value.buf); if(content->length) { content->buf = apr_palloc(multipart_content->pool,content->length+1); content->buf[content->length] = '\0'; } } } } else { /* empty header => exit */ break; } } } while(apt_text_is_eos(stream) == FALSE); if(!content->length || content->length + stream->pos > stream->end) { return FALSE; } /* read content */ memcpy(content->buf,stream->pos,content->length); stream->pos += content->length; return TRUE; }
/** Set resource name to be used while parsing (MRCPv1 only) */ MRCP_DECLARE(void) mrcp_parser_resource_name_set(mrcp_parser_t *parser, const apt_str_t *resource_name) { if(resource_name) { apt_string_copy(&parser->resource_name,resource_name,parser->pool); } }