/* Create RTSP connection */
static apt_bool_t rtsp_client_connection_create(rtsp_client_t *client, rtsp_client_session_t *session)
{
rtsp_client_connection_t *rtsp_connection;
apr_pool_t *pool = apt_pool_create();
if(!pool) {
return FALSE;
}
rtsp_connection = apr_palloc(pool,sizeof(rtsp_client_connection_t));
rtsp_connection->pool = pool;
rtsp_connection->sock = NULL;
APR_RING_ELEM_INIT(rtsp_connection,link);
if(rtsp_client_connect(client,rtsp_connection,session->server_ip.buf,session->server_port) == FALSE) {
apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Connect to RTSP Server %s:%hu",
session->server_ip.buf,session->server_port);
apr_pool_destroy(pool);
return FALSE;
}
rtsp_connection->handle_table = apr_hash_make(pool);
rtsp_connection->session_table = apr_hash_make(pool);
rtsp_connection->inprogress_request_queue = apt_list_create(pool);
apt_text_stream_init(&rtsp_connection->rx_stream,rtsp_connection->rx_buffer,sizeof(rtsp_connection->rx_buffer)-1);
apt_text_stream_init(&rtsp_connection->tx_stream,rtsp_connection->tx_buffer,sizeof(rtsp_connection->tx_buffer)-1);
rtsp_connection->parser = rtsp_parser_create(pool);
rtsp_connection->generator = rtsp_generator_create(pool);
rtsp_connection->last_cseq = 0;
rtsp_connection->client = client;
APR_RING_INSERT_TAIL(&client->connection_list,rtsp_connection,rtsp_client_connection_t,link);
session->connection = rtsp_connection;
return TRUE;
}
/* Create RTSP connection */
static apt_bool_t rtsp_client_connection_create(rtsp_client_t *client, rtsp_client_session_t *session)
{
rtsp_client_connection_t *rtsp_connection;
apt_net_client_connection_t *connection = apt_net_client_connect(client->task,session->server_ip.buf,session->server_port);
if(!connection) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Connect to RTSP Server %s:%d",session->server_ip.buf,session->server_port);
return FALSE;
}
rtsp_connection = apr_palloc(connection->pool,sizeof(rtsp_client_connection_t));
rtsp_connection->handle_table = apr_hash_make(connection->pool);
rtsp_connection->session_table = apr_hash_make(connection->pool);
rtsp_connection->inprogress_request_queue = apt_list_create(connection->pool);
apt_text_stream_init(&rtsp_connection->rx_stream,rtsp_connection->rx_buffer,sizeof(rtsp_connection->rx_buffer)-1);
apt_text_stream_init(&rtsp_connection->tx_stream,rtsp_connection->tx_buffer,sizeof(rtsp_connection->tx_buffer)-1);
rtsp_connection->parser = rtsp_parser_create(connection->pool);
rtsp_connection->generator = rtsp_generator_create(connection->pool);
rtsp_connection->last_cseq = 0;
rtsp_connection->base = connection;
connection->obj = rtsp_connection;
if(!client->connection_list) {
client->connection_list = apt_list_create(client->sub_pool);
}
rtsp_connection->client = client;
rtsp_connection->it = apt_list_push_back(client->connection_list,rtsp_connection,connection->pool);
session->connection = rtsp_connection;
return TRUE;
}
/* Accept RTSP connection */
static apt_bool_t rtsp_server_connection_accept(rtsp_server_t *server)
{
rtsp_server_connection_t *rtsp_connection;
char *local_ip = NULL;
char *remote_ip = NULL;
apr_sockaddr_t *l_sockaddr = NULL;
apr_sockaddr_t *r_sockaddr = NULL;
apr_pool_t *pool = apt_pool_create();
if(!pool) {
return FALSE;
}
rtsp_connection = apr_palloc(pool,sizeof(rtsp_server_connection_t));
rtsp_connection->pool = pool;
rtsp_connection->sock = NULL;
rtsp_connection->client_ip = NULL;
APR_RING_ELEM_INIT(rtsp_connection,link);
if(apr_socket_accept(&rtsp_connection->sock,server->listen_sock,rtsp_connection->pool) != APR_SUCCESS) {
apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Accept RTSP Connection");
apr_pool_destroy(pool);
return FALSE;
}
if(apr_socket_addr_get(&l_sockaddr,APR_LOCAL,rtsp_connection->sock) != APR_SUCCESS ||
apr_socket_addr_get(&r_sockaddr,APR_REMOTE,rtsp_connection->sock) != APR_SUCCESS) {
apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Get RTSP Socket Address");
apr_pool_destroy(pool);
return FALSE;
}
apr_sockaddr_ip_get(&local_ip,l_sockaddr);
apr_sockaddr_ip_get(&remote_ip,r_sockaddr);
rtsp_connection->client_ip = remote_ip;
rtsp_connection->id = apr_psprintf(pool,"%s:%hu <-> %s:%hu",
local_ip,l_sockaddr->port,
remote_ip,r_sockaddr->port);
memset(&rtsp_connection->sock_pfd,0,sizeof(apr_pollfd_t));
rtsp_connection->sock_pfd.desc_type = APR_POLL_SOCKET;
rtsp_connection->sock_pfd.reqevents = APR_POLLIN;
rtsp_connection->sock_pfd.desc.s = rtsp_connection->sock;
rtsp_connection->sock_pfd.client_data = rtsp_connection;
if(apt_poller_task_descriptor_add(server->task,&rtsp_connection->sock_pfd) != TRUE) {
apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset %s",rtsp_connection->id);
apr_socket_close(rtsp_connection->sock);
apr_pool_destroy(pool);
return FALSE;
}
apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Accepted TCP Connection %s",rtsp_connection->id);
rtsp_connection->session_table = apr_hash_make(rtsp_connection->pool);
apt_text_stream_init(&rtsp_connection->rx_stream,rtsp_connection->rx_buffer,sizeof(rtsp_connection->rx_buffer)-1);
apt_text_stream_init(&rtsp_connection->tx_stream,rtsp_connection->tx_buffer,sizeof(rtsp_connection->tx_buffer)-1);
rtsp_connection->parser = rtsp_parser_create(rtsp_connection->pool);
rtsp_connection->generator = rtsp_generator_create(rtsp_connection->pool);
rtsp_connection->server = server;
APR_RING_INSERT_TAIL(&server->connection_list,rtsp_connection,rtsp_server_connection_t,link);
return TRUE;
}
/** Create an empty multipart content */
APT_DECLARE(apt_multipart_content_t*) apt_multipart_content_create(apr_size_t max_content_size, const apt_str_t *boundary, apr_pool_t *pool)
{
char *buffer;
apt_multipart_content_t *multipart_content = apr_palloc(pool,sizeof(apt_multipart_content_t));
multipart_content->pool = pool;
if(max_content_size == 0) {
max_content_size = DEFAULT_MULTIPART_CONTENT_SIZE;
}
if(boundary) {
multipart_content->boundary = *boundary;
}
else {
multipart_content->boundary.buf = DEFAULT_BOUNDARY;
multipart_content->boundary.length = sizeof(DEFAULT_BOUNDARY)-1;
}
multipart_content->hyphens.buf = DEFAULT_HYPHENS;
multipart_content->hyphens.length = sizeof(DEFAULT_HYPHENS)-1;
buffer = apr_palloc(pool,max_content_size+1);
apt_text_stream_init(&multipart_content->stream,buffer,max_content_size);
return multipart_content;
}
static apt_bool_t test_stream_generate(rtsp_generator_t *generator, rtsp_message_t *message)
{
char buffer[500];
apt_text_stream_t stream;
apt_message_status_e status;
apt_bool_t continuation;
do {
apt_text_stream_init(&stream,buffer,sizeof(buffer)-1);
continuation = FALSE;
status = rtsp_generator_run(generator,message,&stream);
if(status == APT_MESSAGE_STATUS_COMPLETE) {
stream.text.length = stream.pos - stream.text.buf;
*stream.pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Generated RTSP Stream [%"APR_SIZE_T_FMT" bytes]\n%s",stream.text.length,stream.text.buf);
}
else if(status == APT_MESSAGE_STATUS_INCOMPLETE) {
*stream.pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Generated RTSP Stream [%"APR_SIZE_T_FMT" bytes] continuation awaited\n%s",stream.text.length,stream.text.buf);
continuation = TRUE;
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Generate RTSP Stream");
}
}
while(continuation == TRUE);
return TRUE;
}
static apt_bool_t test_stream_generate(mrcp_generator_t *generator, mrcp_message_t *message)
{
char buffer[500];
apt_text_stream_t stream;
mrcp_stream_result_e result;
apt_bool_t continuation;
mrcp_generator_message_set(generator,message);
do {
apt_text_stream_init(&stream,buffer,sizeof(buffer)-1);
continuation = FALSE;
result = mrcp_generator_run(generator,&stream);
if(result == MRCP_STREAM_MESSAGE_COMPLETE) {
stream.text.length = stream.pos - stream.text.buf;
*stream.pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Generated MRCP Stream [%lu bytes]\n%s",stream.text.length,stream.text.buf);
}
else if(result == MRCP_STREAM_MESSAGE_TRUNCATED) {
*stream.pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Generated MRCP Stream [%lu bytes] continuation awaiting\n%s",stream.text.length,stream.text.buf);
continuation = TRUE;
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Generate MRCP Stream");
}
}
while(continuation == TRUE);
return TRUE;
}
static void mpf_mixer_trace(mpf_object_t *object)
{
mpf_mixer_t *mixer = (mpf_mixer_t*) object;
apr_size_t i;
mpf_audio_stream_t *source;
char buf[2048];
apr_size_t offset;
apt_text_stream_t output;
apt_text_stream_init(&output,buf,sizeof(buf)-1);
for(i=0; i<mixer->source_count; i++) {
source = mixer->source_arr[i];
if(source) {
mpf_audio_stream_trace(source,STREAM_DIRECTION_RECEIVE,&output);
apt_text_char_insert(&output,';');
}
}
offset = output.pos - output.text.buf;
output.pos += apr_snprintf(output.pos, output.text.length - offset,
"->Mixer->");
mpf_audio_stream_trace(mixer->sink,STREAM_DIRECTION_SEND,&output);
*output.pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Media Path %s %s",
object->name,
output.text.buf);
}
/** 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;
}
/* New RTSP connection accepted */
static apt_bool_t rtsp_server_on_connect(apt_net_server_task_t *task, apt_net_server_connection_t *connection)
{
rtsp_server_t *server = apt_net_server_task_object_get(task);
rtsp_server_connection_t *rtsp_connection = apr_palloc(connection->pool,sizeof(rtsp_server_connection_t));
rtsp_connection->session_table = apr_hash_make(connection->pool);
apt_text_stream_init(&rtsp_connection->rx_stream,rtsp_connection->rx_buffer,sizeof(rtsp_connection->rx_buffer)-1);
apt_text_stream_init(&rtsp_connection->tx_stream,rtsp_connection->tx_buffer,sizeof(rtsp_connection->tx_buffer)-1);
rtsp_connection->parser = rtsp_parser_create(connection->pool);
rtsp_connection->generator = rtsp_generator_create(connection->pool);
rtsp_connection->base = connection;
connection->obj = rtsp_connection;
if(!server->connection_list) {
server->connection_list = apt_list_create(server->sub_pool);
}
rtsp_connection->server = server;
rtsp_connection->it = apt_list_push_back(server->connection_list,rtsp_connection,connection->pool);
return TRUE;
}
static apt_bool_t mrcp_unirtsp_on_session_control(mrcp_session_t *mrcp_session, mrcp_message_t *mrcp_message)
{
mrcp_unirtsp_session_t *session = mrcp_session->obj;
mrcp_unirtsp_agent_t *agent = mrcp_session->signaling_agent->obj;
char buffer[500];
apt_text_stream_t stream;
rtsp_message_t *rtsp_message = NULL;
apt_str_t *body;
apt_text_stream_init(&stream,buffer,sizeof(buffer));
mrcp_message->start_line.version = MRCP_VERSION_1;
if(mrcp_message_generate(agent->sig_agent->resource_factory,mrcp_message,&stream) != TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Generate MRCPv1 Message");
return FALSE;
}
stream.text.length = stream.pos - stream.text.buf;
if(mrcp_message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
/* send RTSP response (OK) */
const rtsp_message_t *request = rtsp_server_session_request_get(session->rtsp_session);
if(request) {
rtsp_message = rtsp_response_create(request,RTSP_STATUS_CODE_OK,RTSP_REASON_PHRASE_OK,mrcp_session->pool);
}
}
else if(mrcp_message->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT) {
/* send RTSP announce */
rtsp_message = rtsp_request_create(mrcp_session->pool);
rtsp_message->start_line.common.request_line.resource_name = rtsp_name_get_by_mrcp_name(
agent->config->resource_map,
mrcp_message->channel_id.resource_name.buf);
rtsp_message->start_line.common.request_line.method_id = RTSP_METHOD_ANNOUNCE;
}
if(!rtsp_message) {
return FALSE;
}
body = &rtsp_message->body;
body->length = mrcp_message->start_line.length;
body->buf = apr_palloc(rtsp_message->pool,body->length+1);
memcpy(body->buf,stream.text.buf,stream.text.length);
if(mrcp_message->body.length) {
memcpy(body->buf+stream.text.length,mrcp_message->body.buf,mrcp_message->body.length);
}
body->buf[body->length] = '\0';
rtsp_message->header.content_type = RTSP_CONTENT_TYPE_MRCP;
rtsp_header_property_add(&rtsp_message->header,RTSP_HEADER_FIELD_CONTENT_TYPE,rtsp_message->pool);
rtsp_message->header.content_length = body->length;
rtsp_header_property_add(&rtsp_message->header,RTSP_HEADER_FIELD_CONTENT_LENGTH,rtsp_message->pool);
rtsp_server_session_respond(agent->rtsp_server,session->rtsp_session,rtsp_message);
return TRUE;
}
/** Generate array of name-value pairs */
APT_DECLARE(apt_bool_t) apt_pair_array_generate(const apt_pair_arr_t *arr, apt_str_t *str, apr_pool_t *pool)
{
char buf[512];
apt_text_stream_t stream;
apt_text_stream_init(&stream,buf,sizeof(buf));
if(apt_text_pair_array_insert(&stream,arr) == FALSE) {
return FALSE;
}
apt_string_assign_n(str, stream.text.buf, stream.pos - stream.text.buf, pool);
return TRUE;
}
static apt_bool_t test_file_process(apt_test_suite_t *suite, const char *file_path)
{
apr_file_t *file;
char buffer[500];
apt_text_stream_t stream;
rtsp_parser_t *parser;
rtsp_generator_t *generator;
apr_size_t length;
apr_size_t offset;
rtsp_message_t *message;
apt_message_status_e msg_status;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Open File [%s]",file_path);
if(apr_file_open(&file,file_path,APR_FOPEN_READ | APR_FOPEN_BINARY,APR_OS_DEFAULT,suite->pool) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open File");
return FALSE;
}
parser = rtsp_parser_create(suite->pool);
generator = rtsp_generator_create(suite->pool);
apt_text_stream_init(&stream,buffer,sizeof(buffer)-1);
do {
/* calculate offset remaining from the previous receive / if any */
offset = stream.pos - stream.text.buf;
/* calculate available length */
length = sizeof(buffer) - 1 - offset;
if(apr_file_read(file,stream.pos,&length) != APR_SUCCESS) {
break;
}
/* calculate actual length of the stream */
stream.text.length = offset + length;
stream.pos[length] = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Parse RTSP Stream [%"APR_SIZE_T_FMT" bytes]\n%s",length,stream.pos);
/* reset pos */
apt_text_stream_reset(&stream);
do {
msg_status = rtsp_parser_run(parser,&stream,&message);
rtsp_message_handler(generator,message,msg_status);
}
while(apt_text_is_eos(&stream) == FALSE);
/* scroll remaining stream */
apt_text_stream_scroll(&stream);
}
while(apr_file_eof(file) != APR_EOF);
apr_file_close(file);
return TRUE;
}
static apt_bool_t mrcp_client_agent_messsage_send(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel, mrcp_message_t *message)
{
apt_bool_t status = FALSE;
mrcp_connection_t *connection = channel->connection;
apt_text_stream_t stream;
apt_message_status_e result;
if(!connection || !connection->sock) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Null MRCPv2 Connection "APT_SIDRES_FMT,MRCP_MESSAGE_SIDRES(message));
mrcp_client_agent_request_cancel(agent,channel,message);
return FALSE;
}
do {
apt_text_stream_init(&stream,connection->tx_buffer,connection->tx_buffer_size);
result = mrcp_generator_run(connection->generator,message,&stream);
if(result != APT_MESSAGE_STATUS_INVALID) {
stream.text.length = stream.pos - stream.text.buf;
*stream.pos = '\0';
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,channel->log_obj,"Send MRCPv2 Data %s [%"APR_SIZE_T_FMT" bytes]\n%.*s",
connection->id,
stream.text.length,
connection->verbose == TRUE ? stream.text.length : 0,
stream.text.buf);
if(apr_socket_send(connection->sock,stream.text.buf,&stream.text.length) == APR_SUCCESS) {
status = TRUE;
}
else {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Failed to Send MRCPv2 Data %s",
connection->id);
}
}
else {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Failed to Generate MRCPv2 Data %s",
connection->id);
}
}
while(result == APT_MESSAGE_STATUS_INCOMPLETE);
if(status == TRUE) {
channel->active_request = message;
if(channel->request_timer && agent->request_timeout) {
apt_timer_set(channel->request_timer,agent->request_timeout);
}
}
else {
mrcp_client_agent_request_cancel(agent,channel,message);
}
return status;
}
static apt_bool_t test_file_process(apt_test_suite_t *suite, mrcp_resource_factory_t *factory, mrcp_version_e version, const char *file_path)
{
apr_file_t *file;
char buffer[500];
apt_text_stream_t stream;
mrcp_parser_t *parser;
mrcp_generator_t *generator;
apr_size_t length;
apr_size_t offset;
apt_str_t resource_name;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Open File [%s]",file_path);
if(apr_file_open(&file,file_path,APR_FOPEN_READ | APR_FOPEN_BINARY,APR_OS_DEFAULT,suite->pool) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open File");
return FALSE;
}
parser = mrcp_parser_create(factory,suite->pool);
generator = mrcp_generator_create(factory,suite->pool);
apt_string_reset(&resource_name);
if(version == MRCP_VERSION_1) {
resource_name_read(file,parser);
}
apt_text_stream_init(&stream,buffer,sizeof(buffer)-1);
do {
/* init length of the stream */
stream.text.length = sizeof(buffer)-1;
/* calculate offset remaining from the previous receive / if any */
offset = stream.pos - stream.text.buf;
/* calculate available length */
length = stream.text.length - offset;
if(apr_file_read(file,stream.pos,&length) != APR_SUCCESS) {
break;
}
/* calculate actual length of the stream */
stream.text.length = offset + length;
stream.pos[length] = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Parse MRCP Stream [%lu bytes]\n%s",length,stream.pos);
/* reset pos */
stream.pos = stream.text.buf;
mrcp_stream_walk(parser,&stream,mrcp_message_handler,generator);
}
while(apr_file_eof(file) != APR_EOF);
apr_file_close(file);
return TRUE;
}
/** Generate mrcp request-id list */
static apt_bool_t mrcp_request_id_list_generate(mrcp_request_id_list_t *request_id_list, apt_str_t *str, apr_pool_t *pool)
{
apr_size_t i;
char buf[256];
apt_text_stream_t stream;
apt_text_stream_init(&stream,buf,sizeof(buf));
for(i=0; i<request_id_list->count; i++) {
mrcp_request_id_generate(request_id_list->ids[i],&stream);
if(i < request_id_list->count-1) {
*stream.pos++ = ',';
}
}
apt_string_assign_n(str,stream.text.buf, stream.pos - stream.text.buf, pool);
return TRUE;
}
static apt_bool_t mrcp_client_agent_messsage_send(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel, mrcp_message_t *message)
{
apt_bool_t status = FALSE;
mrcp_connection_t *connection = channel->connection;
apt_text_stream_t *stream;
mrcp_stream_result_e result;
if(!connection || !connection->sock) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No MRCPv2 Connection");
return FALSE;
}
stream = &connection->tx_stream;
mrcp_generator_message_set(connection->generator,message);
do {
apt_text_stream_init(&connection->tx_stream,connection->tx_buffer,sizeof(connection->tx_buffer)-1);
result = mrcp_generator_run(connection->generator,stream);
if(result == MRCP_STREAM_MESSAGE_COMPLETE || result == MRCP_STREAM_MESSAGE_TRUNCATED) {
stream->text.length = stream->pos - stream->text.buf;
*stream->pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Send MRCPv2 Stream %s [%lu bytes]\n%s",
connection->id,
stream->text.length,
stream->text.buf);
if(apr_socket_send(connection->sock,stream->text.buf,&stream->text.length) == APR_SUCCESS) {
status = TRUE;
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Send MRCPv2 Stream");
}
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Generate MRCPv2 Stream");
}
}
while(result == MRCP_STREAM_MESSAGE_TRUNCATED);
if(status == FALSE) {
mrcp_message_t *response = mrcp_response_create(message,message->pool);
response->start_line.method_id = message->start_line.method_id;
response->start_line.method_name = message->start_line.method_name;
response->start_line.status_code = MRCP_STATUS_CODE_METHOD_FAILED;
mrcp_connection_message_receive(agent->vtable,channel,response);
}
return TRUE;
}
static apt_bool_t mrcp_unirtsp_session_control(mrcp_session_t *mrcp_session, mrcp_message_t *mrcp_message)
{
mrcp_unirtsp_session_t *session = mrcp_session->obj;
mrcp_unirtsp_agent_t *agent = mrcp_session->signaling_agent->obj;
char buffer[2000];
apt_text_stream_t stream;
rtsp_message_t *rtsp_message = NULL;
apt_str_t *body;
apt_text_stream_init(&stream,buffer,sizeof(buffer));
mrcp_message->start_line.version = MRCP_VERSION_1;
if(mrcp_message_generate(agent->sig_agent->resource_factory,mrcp_message,&stream) != TRUE) {
apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Generate MRCPv1 Message");
return FALSE;
}
stream.text.length = stream.pos - stream.text.buf;
rtsp_message = rtsp_request_create(mrcp_session->pool);
rtsp_message->start_line.common.request_line.resource_name = rtsp_name_get_by_mrcp_name(
session->rtsp_settings->resource_map,
mrcp_message->channel_id.resource_name.buf);
rtsp_message->start_line.common.request_line.method_id = RTSP_METHOD_ANNOUNCE;
body = &rtsp_message->body;
body->length = mrcp_message->start_line.length;
body->buf = apr_palloc(rtsp_message->pool,body->length+1);
memcpy(body->buf,stream.text.buf,stream.text.length);
if(mrcp_message->body.length) {
memcpy(body->buf+stream.text.length,mrcp_message->body.buf,mrcp_message->body.length);
}
body->buf[body->length] = '\0';
rtsp_message->header.content_type = RTSP_CONTENT_TYPE_MRCP;
rtsp_header_property_add(&rtsp_message->header,RTSP_HEADER_FIELD_CONTENT_TYPE,rtsp_message->pool);
rtsp_message->header.content_length = body->length;
rtsp_header_property_add(&rtsp_message->header,RTSP_HEADER_FIELD_CONTENT_LENGTH,rtsp_message->pool);
session->mrcp_message = mrcp_message;
rtsp_client_session_request(agent->rtsp_client,session->rtsp_session,rtsp_message);
return TRUE;
}
/** Assign body to multipart content to get (parse) each content part from */
APT_DECLARE(apt_multipart_content_t*) apt_multipart_content_assign(const apt_str_t *body, const apt_str_t *boundary, apr_pool_t *pool)
{
apt_multipart_content_t *multipart_content = apr_palloc(pool,sizeof(apt_multipart_content_t));
multipart_content->pool = pool;
if(!body) {
return FALSE;
}
if(boundary) {
multipart_content->boundary = *boundary;
}
else {
apt_string_reset(&multipart_content->boundary);
}
apt_string_reset(&multipart_content->hyphens);
apt_text_stream_init(&multipart_content->stream,body->buf,body->length);
return multipart_content;
}
static void mpf_bridge_trace(mpf_object_t *object)
{
mpf_bridge_t *bridge = (mpf_bridge_t*) object;
char buf[1024];
apr_size_t offset;
apt_text_stream_t output;
apt_text_stream_init(&output,buf,sizeof(buf)-1);
mpf_audio_stream_trace(bridge->source,STREAM_DIRECTION_RECEIVE,&output);
offset = output.pos - output.text.buf;
output.pos += apr_snprintf(output.pos, output.text.length - offset,
"->Bridge->");
mpf_audio_stream_trace(bridge->sink,STREAM_DIRECTION_SEND,&output);
*output.pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Media Path %s %s",object->name,output.text.buf);
}
static apt_bool_t mrcp_server_agent_messsage_send(mrcp_connection_agent_t *agent, mrcp_connection_t *connection, mrcp_message_t *message)
{
apt_bool_t status = FALSE;
apt_text_stream_t stream;
apt_message_status_e result;
if(!connection || !connection->sock) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Null MRCPv2 Connection "APT_SIDRES_FMT,MRCP_MESSAGE_SIDRES(message));
return FALSE;
}
do {
apt_text_stream_init(&stream,connection->tx_buffer,connection->tx_buffer_size);
result = mrcp_generator_run(connection->generator,message,&stream);
if(result != APT_MESSAGE_STATUS_INVALID) {
stream.text.length = stream.pos - stream.text.buf;
*stream.pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Send MRCPv2 Data %s [%"APR_SIZE_T_FMT" bytes]\n%.*s",
connection->id,
stream.text.length,
connection->verbose == TRUE ? stream.text.length : 0,
stream.text.buf);
if(apr_socket_send(connection->sock,stream.text.buf,&stream.text.length) == APR_SUCCESS) {
status = TRUE;
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Send MRCPv2 Data");
}
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Generate MRCPv2 Data");
}
}
while(result == APT_MESSAGE_STATUS_INCOMPLETE);
return status;
}
static apt_bool_t mrcp_server_agent_messsage_send(mrcp_connection_agent_t *agent, mrcp_connection_t *connection, mrcp_message_t *message)
{
apt_bool_t status = FALSE;
apt_text_stream_t *stream;
mrcp_stream_result_e result;
if(!connection || !connection->sock) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No MRCPv2 Connection");
return FALSE;
}
stream = &connection->tx_stream;
mrcp_generator_message_set(connection->generator,message);
do {
apt_text_stream_init(&connection->tx_stream,connection->tx_buffer,sizeof(connection->tx_buffer)-1);
result = mrcp_generator_run(connection->generator,stream);
if(result == MRCP_STREAM_MESSAGE_COMPLETE || result == MRCP_STREAM_MESSAGE_TRUNCATED) {
stream->text.length = stream->pos - stream->text.buf;
*stream->pos = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Send MRCPv2 Stream %s [%lu bytes]\n%s",
connection->id,
stream->text.length,
stream->text.buf);
if(apr_socket_send(connection->sock,stream->text.buf,&stream->text.length) == APR_SUCCESS) {
status = TRUE;
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Send MRCPv2 Stream");
}
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Generate MRCPv2 Stream");
}
}
while(result == MRCP_STREAM_MESSAGE_TRUNCATED);
return status;
}
static apt_bool_t resource_name_read(apr_file_t *file, mrcp_parser_t *parser)
{
char buffer[100];
apt_text_stream_t stream;
apt_bool_t status = FALSE;
apt_text_stream_init(&stream,buffer,sizeof(buffer)-1);
if(apr_file_read(file,stream.pos,&stream.text.length) != APR_SUCCESS) {
return FALSE;
}
/* skip the first line in a test file, which indicates resource name */
if(*stream.pos =='/' && *(stream.pos+1)=='/') {
apt_str_t line;
stream.pos += 2;
if(apt_text_line_read(&stream,&line) == TRUE) {
apr_off_t offset = stream.pos - stream.text.buf;
apr_file_seek(file,APR_SET,&offset);
mrcp_parser_resource_name_set(parser,&line);
status = TRUE;
}
}
return status;
}
/** Parse MRCP start-line */
MRCP_DECLARE(apt_bool_t) mrcp_start_line_parse(mrcp_start_line_t *start_line, apt_str_t *str, 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;
apt_text_stream_init(&line,str->buf,str->length);
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;
}
static apt_bool_t mrcp_server_agent_connection_accept(mrcp_connection_agent_t *agent)
{
char *local_ip = NULL;
char *remote_ip = NULL;
apr_socket_t *sock;
apr_pool_t *pool;
apt_pollset_t *pollset = apt_poller_task_pollset_get(agent->task);
mrcp_connection_t *connection;
if(!agent->null_connection) {
pool = apt_pool_create();
if(apr_socket_accept(&sock,agent->listen_sock,pool) != APR_SUCCESS) {
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Rejected TCP/MRCPv2 Connection");
apr_socket_close(sock);
apr_pool_destroy(pool);
return FALSE;
}
pool = agent->null_connection->pool;
if(apr_socket_accept(&sock,agent->listen_sock,pool) != APR_SUCCESS) {
return FALSE;
}
connection = mrcp_connection_create();
connection->sock = sock;
if(apr_socket_addr_get(&connection->r_sockaddr,APR_REMOTE,sock) != APR_SUCCESS ||
apr_socket_addr_get(&connection->l_sockaddr,APR_LOCAL,sock) != APR_SUCCESS) {
apr_socket_close(sock);
mrcp_connection_destroy(connection);
return FALSE;
}
apr_sockaddr_ip_get(&local_ip,connection->l_sockaddr);
apr_sockaddr_ip_get(&remote_ip,connection->r_sockaddr);
apt_string_set(&connection->remote_ip,remote_ip);
connection->id = apr_psprintf(connection->pool,"%s:%hu <-> %s:%hu",
local_ip,connection->l_sockaddr->port,
remote_ip,connection->r_sockaddr->port);
memset(&connection->sock_pfd,0,sizeof(apr_pollfd_t));
connection->sock_pfd.desc_type = APR_POLL_SOCKET;
connection->sock_pfd.reqevents = APR_POLLIN;
connection->sock_pfd.desc.s = connection->sock;
connection->sock_pfd.client_data = connection;
if(apt_pollset_add(pollset, &connection->sock_pfd) != TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset");
apr_socket_close(sock);
mrcp_connection_destroy(connection);
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Accepted TCP/MRCPv2 Connection %s",connection->id);
connection->agent = agent;
connection->it = apt_list_push_back(agent->connection_list,connection,connection->pool);
connection->parser = mrcp_parser_create(agent->resource_factory,connection->pool);
connection->generator = mrcp_generator_create(agent->resource_factory,connection->pool);
connection->tx_buffer_size = agent->tx_buffer_size;
connection->tx_buffer = apr_palloc(connection->pool,connection->tx_buffer_size+1);
connection->rx_buffer_size = agent->rx_buffer_size;
connection->rx_buffer = apr_palloc(connection->pool,connection->rx_buffer_size+1);
apt_text_stream_init(&connection->rx_stream,connection->rx_buffer,connection->rx_buffer_size);
return TRUE;
}
static apt_bool_t mrcp_server_agent_connection_accept(mrcp_connection_agent_t *agent)
{
char *local_ip = NULL;
char *remote_ip = NULL;
mrcp_connection_t *connection = mrcp_connection_create();
if(apr_socket_accept(&connection->sock,agent->listen_sock,connection->pool) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Accept Connection");
mrcp_connection_destroy(connection);
return FALSE;
}
if(apr_socket_addr_get(&connection->r_sockaddr,APR_REMOTE,connection->sock) != APR_SUCCESS ||
apr_socket_addr_get(&connection->l_sockaddr,APR_LOCAL,connection->sock) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Socket Address");
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return FALSE;
}
apr_sockaddr_ip_get(&local_ip,connection->l_sockaddr);
apr_sockaddr_ip_get(&remote_ip,connection->r_sockaddr);
apt_string_set(&connection->remote_ip,remote_ip);
connection->id = apr_psprintf(connection->pool,"%s:%hu <-> %s:%hu",
local_ip,connection->l_sockaddr->port,
remote_ip,connection->r_sockaddr->port);
if(apr_hash_count(agent->pending_channel_table) == 0) {
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Reject Unexpected TCP/MRCPv2 Connection %s",connection->id);
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return FALSE;
}
memset(&connection->sock_pfd,0,sizeof(apr_pollfd_t));
connection->sock_pfd.desc_type = APR_POLL_SOCKET;
connection->sock_pfd.reqevents = APR_POLLIN;
connection->sock_pfd.desc.s = connection->sock;
connection->sock_pfd.client_data = connection;
if(apt_poller_task_descriptor_add(agent->task, &connection->sock_pfd) != TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset %s",connection->id);
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Accepted TCP/MRCPv2 Connection %s",connection->id);
connection->agent = agent;
APR_RING_INSERT_TAIL(&agent->connection_list,connection,mrcp_connection_t,link);
connection->parser = mrcp_parser_create(agent->resource_factory,connection->pool);
connection->generator = mrcp_generator_create(agent->resource_factory,connection->pool);
connection->tx_buffer_size = agent->tx_buffer_size;
connection->tx_buffer = apr_palloc(connection->pool,connection->tx_buffer_size+1);
connection->rx_buffer_size = agent->rx_buffer_size;
connection->rx_buffer = apr_palloc(connection->pool,connection->rx_buffer_size+1);
apt_text_stream_init(&connection->rx_stream,connection->rx_buffer,connection->rx_buffer_size);
if(apt_log_masking_get() != APT_LOG_MASKING_NONE) {
connection->verbose = FALSE;
mrcp_parser_verbose_set(connection->parser,TRUE);
mrcp_generator_verbose_set(connection->generator,TRUE);
}
return TRUE;
}
static mrcp_connection_t* mrcp_client_agent_connection_create(mrcp_connection_agent_t *agent, mrcp_control_descriptor_t *descriptor)
{
char *local_ip = NULL;
char *remote_ip = NULL;
mrcp_connection_t *connection = mrcp_connection_create();
apr_sockaddr_info_get(&connection->r_sockaddr,descriptor->ip.buf,APR_INET,descriptor->port,0,connection->pool);
if(!connection->r_sockaddr) {
mrcp_connection_destroy(connection);
return NULL;
}
if(apr_socket_create(&connection->sock,connection->r_sockaddr->family,SOCK_STREAM,APR_PROTO_TCP,connection->pool) != APR_SUCCESS) {
mrcp_connection_destroy(connection);
return NULL;
}
apr_socket_opt_set(connection->sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(connection->sock, -1);
apr_socket_opt_set(connection->sock, APR_SO_REUSEADDR, 1);
if(apr_socket_connect(connection->sock, connection->r_sockaddr) != APR_SUCCESS) {
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
if(apr_socket_addr_get(&connection->l_sockaddr,APR_LOCAL,connection->sock) != APR_SUCCESS) {
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
apr_sockaddr_ip_get(&local_ip,connection->l_sockaddr);
apr_sockaddr_ip_get(&remote_ip,connection->r_sockaddr);
connection->id = apr_psprintf(connection->pool,"%s:%hu <-> %s:%hu",
local_ip,connection->l_sockaddr->port,
remote_ip,connection->r_sockaddr->port);
memset(&connection->sock_pfd,0,sizeof(apr_pollfd_t));
connection->sock_pfd.desc_type = APR_POLL_SOCKET;
connection->sock_pfd.reqevents = APR_POLLIN;
connection->sock_pfd.desc.s = connection->sock;
connection->sock_pfd.client_data = connection;
if(apt_poller_task_descriptor_add(agent->task, &connection->sock_pfd) != TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset %s",connection->id);
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Established TCP/MRCPv2 Connection %s",connection->id);
connection->agent = agent;
APR_RING_INSERT_TAIL(&agent->connection_list,connection,mrcp_connection_t,link);
connection->parser = mrcp_parser_create(agent->resource_factory,connection->pool);
connection->generator = mrcp_generator_create(agent->resource_factory,connection->pool);
connection->tx_buffer_size = agent->tx_buffer_size;
connection->tx_buffer = apr_palloc(connection->pool,connection->tx_buffer_size+1);
connection->rx_buffer_size = agent->rx_buffer_size;
connection->rx_buffer = apr_palloc(connection->pool,connection->rx_buffer_size+1);
apt_text_stream_init(&connection->rx_stream,connection->rx_buffer,connection->rx_buffer_size);
if(apt_log_masking_get() != APT_LOG_MASKING_NONE) {
connection->verbose = FALSE;
mrcp_parser_verbose_set(connection->parser,TRUE);
mrcp_generator_verbose_set(connection->generator,TRUE);
}
return connection;
}
