OMX_ERRORTYPE
tiz_vector_init (tiz_vector_t ** app_vector, size_t a_elem_size)
{
tiz_vector_t * p_vec = NULL;
assert (app_vector);
assert (a_elem_size > 0);
if (NULL
== (p_vec = (tiz_vector_t *) tiz_mem_calloc (1, sizeof (tiz_vector_t))))
{
return OMX_ErrorInsufficientResources;
}
if (NULL == (p_vec->p_icd = (UT_icd *) tiz_mem_calloc (1, sizeof (UT_icd))))
{
tiz_mem_free (p_vec);
return OMX_ErrorInsufficientResources;
}
p_vec->p_icd->sz = a_elem_size;
utarray_new (p_vec->p_uta, p_vec->p_icd);
*app_vector = p_vec;
TIZ_LOG (TIZ_PRIORITY_TRACE, "Initializing vector [%p] with elem size [%d]",
p_vec, a_elem_size);
return OMX_ErrorNone;
}
static bool
dump_rmdb (const char * p_dest_path)
{
bool rv = false;
/* Dump the rm db */
size_t total_len = strlen (pg_dump_script)
+ strlen (pg_rmdb_path)
+ strlen (p_dest_path) + 4;
char *p_cmd = tiz_mem_calloc (1, total_len);
if (p_cmd)
{
snprintf(p_cmd, total_len -1, "%s %s %s",
pg_dump_script, pg_rmdb_path, p_dest_path);
if (-1 != system (p_cmd))
{
TIZ_LOG(TIZ_TRACE, "Successfully run [%s] script...", p_cmd);
rv = true;
}
else
{
TIZ_LOG(TIZ_TRACE,
"Error while executing db dump shell script...");
}
tiz_mem_free (p_cmd);
}
return rv;
}
static bool
refresh_rm_db (void)
{
bool rv = false;
/* Re-fresh the rm db */
size_t total_len = strlen (pg_init_script)
+ strlen (pg_sqlite_script)
+ strlen (pg_rmdb_path) + 4;
char *p_cmd = tiz_mem_calloc (1, total_len);
if (p_cmd)
{
snprintf(p_cmd, total_len -1, "%s %s %s",
pg_init_script, pg_sqlite_script, pg_rmdb_path);
if (-1 != system (p_cmd))
{
TIZ_LOG(TIZ_TRACE, "Successfully run [%s] script...", p_cmd);
rv = true;
}
else
{
TIZ_LOG(TIZ_TRACE,
"Error while executing db init shell script...");
}
tiz_mem_free (p_cmd);
}
return rv;
}
OMX_ERRORTYPE tiz_shuffle_lst_init (tiz_shuffle_lst_ptr_t *app_shuffle_lst,
const size_t a_list_size)
{
OMX_ERRORTYPE rc = OMX_ErrorInsufficientResources;
tiz_shuffle_lst_t *p_shuffle_lst = NULL;
assert (NULL != app_shuffle_lst);
assert (a_list_size > 0);
p_shuffle_lst = tiz_mem_calloc (1, sizeof(tiz_shuffle_lst_t));
if (p_shuffle_lst)
{
p_shuffle_lst->length = a_list_size;
if (OMX_ErrorNone == (rc = init_lst (p_shuffle_lst)))
{
srand (time (NULL));
shuffle_lst (p_shuffle_lst->p_lst, p_shuffle_lst->length);
}
}
if (OMX_ErrorNone != rc)
{
destroy_lst (p_shuffle_lst);
p_shuffle_lst = NULL;
}
*app_shuffle_lst = p_shuffle_lst;
return rc;
}
static OMX_ERRORTYPE
obtain_url (cc_http_prc_t * ap_prc)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
const long pathname_max = PATH_MAX + NAME_MAX;
assert (ap_prc);
assert (!ap_prc->p_content_uri_);
ap_prc->p_content_uri_
= tiz_mem_calloc (1, sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1);
tiz_check_null_ret_oom (ap_prc->p_content_uri_);
ap_prc->p_content_uri_->nSize
= sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1;
ap_prc->p_content_uri_->nVersion.nVersion = OMX_VERSION;
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamContentURI, ap_prc->p_content_uri_));
TIZ_NOTICE (handleOf (ap_prc), "URI [%s]",
ap_prc->p_content_uri_->contentURI);
/* Verify we are getting an http scheme */
if (strncasecmp ((const char *) ap_prc->p_content_uri_->contentURI, "http://",
7)
&& strncasecmp ((const char *) ap_prc->p_content_uri_->contentURI,
"https://", 8))
{
rc = OMX_ErrorContentURIError;
}
return rc;
}
static OMX_ERRORTYPE
obtain_next_url (dirble_prc_t * ap_prc, int a_skip_value)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
const long pathname_max = PATH_MAX + NAME_MAX;
assert (ap_prc);
assert (ap_prc->p_dirble_);
if (!ap_prc->p_uri_param_)
{
ap_prc->p_uri_param_ = tiz_mem_calloc (
1, sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1);
}
tiz_check_null_ret_oom (ap_prc->p_uri_param_ != NULL);
ap_prc->p_uri_param_->nSize
= sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1;
ap_prc->p_uri_param_->nVersion.nVersion = OMX_VERSION;
{
const char * p_next_url
= a_skip_value > 0 ? tiz_dirble_get_next_url (ap_prc->p_dirble_,
ap_prc->remove_current_url_)
: tiz_dirble_get_prev_url (
ap_prc->p_dirble_, ap_prc->remove_current_url_);
ap_prc->remove_current_url_ = false;
tiz_check_null_ret_oom (p_next_url != NULL);
{
const OMX_U32 url_len = strnlen (p_next_url, pathname_max);
TIZ_TRACE (handleOf (ap_prc), "URL [%s]", p_next_url);
/* Verify we are getting an http scheme */
if (!p_next_url || !url_len
|| (memcmp (p_next_url, "http://", 7) != 0
&& memcmp (p_next_url, "https://", 8) != 0))
{
rc = OMX_ErrorContentURIError;
}
else
{
strncpy ((char *) ap_prc->p_uri_param_->contentURI, p_next_url,
url_len);
ap_prc->p_uri_param_->contentURI[url_len] = '\000';
/* Song metadata is now available, update the IL client */
rc = update_metadata (ap_prc);
}
}
}
return rc;
}
static bool
refresh_rm_db (void)
{
bool rv = false;
const char *p_rmdb_path = NULL;
const char *p_sqlite_path = NULL;
const char *p_init_path = NULL;
const char *p_rmd_path = NULL;
p_rmdb_path = tiz_rcfile_get_value("resource-management", "rmdb");
p_sqlite_path = tiz_rcfile_get_value("resource-management",
"rmdb.sqlite_script");
p_init_path = tiz_rcfile_get_value("resource-management",
"rmdb.init_script");
p_rmd_path = tiz_rcfile_get_value("resource-management", "rmd.path");
if (!p_rmdb_path || !p_sqlite_path || !p_init_path || !p_rmd_path)
{
TIZ_LOG(TIZ_PRIORITY_TRACE, "Test data not available...");
}
else
{
pg_rmd_path = strndup (p_rmd_path, PATH_MAX);
TIZ_LOG(TIZ_PRIORITY_TRACE, "RM daemon [%s] ...", pg_rmd_path);
/* Re-fresh the rm db */
size_t total_len = strlen (p_init_path)
+ strlen (p_sqlite_path)
+ strlen (p_rmdb_path) + 4;
char *p_cmd = tiz_mem_calloc (1, total_len);
if (p_cmd)
{
snprintf(p_cmd, total_len -1, "%s %s %s",
p_init_path, p_sqlite_path, p_rmdb_path);
if (-1 != system (p_cmd))
{
TIZ_LOG(TIZ_PRIORITY_TRACE, "Successfully run [%s] script...", p_cmd);
rv = true;
}
else
{
TIZ_LOG(TIZ_PRIORITY_TRACE,
"Error while executing db init shell script...");
}
tiz_mem_free (p_cmd);
}
}
return rv;
}
static void
obtain_audio_encoding_from_headers (scloud_prc_t * ap_prc,
const char * ap_header, const size_t a_size)
{
assert (ap_prc);
assert (ap_header);
{
const char * p_end = ap_header + a_size;
const char * p_value = (const char *) memchr (ap_header, ':', a_size);
char name[64];
if (p_value && (size_t) (p_value - ap_header) < sizeof (name))
{
memcpy (name, ap_header, p_value - ap_header);
name[p_value - ap_header] = 0;
/* skip the colon */
++p_value;
/* strip the value */
while (p_value < p_end && !is_valid_character (*p_value))
{
++p_value;
}
while (p_end > p_value && !is_valid_character (p_end[-1]))
{
--p_end;
}
{
char * p_info = tiz_mem_calloc (1, (p_end - p_value) + 1);
memcpy (p_info, p_value, p_end - p_value);
p_info[(p_end - p_value)] = '\0';
TIZ_TRACE (handleOf (ap_prc), "header name : [%s]", name);
TIZ_TRACE (handleOf (ap_prc), "header value : [%s]", p_info);
if (strncasecmp (name, "Content-Type", 12) == 0)
{
obtain_coding_type (ap_prc, p_info);
/* Now set the new coding type value on the output port */
(void) set_audio_coding_on_port (ap_prc);
}
else if (strncasecmp (name, "Content-Length", 14) == 0)
{
obtain_content_length (ap_prc, p_info);
}
tiz_mem_free (p_info);
}
}
}
}
static OMX_ERRORTYPE httpr_mp3port_SetConfig (const void *ap_obj,
OMX_HANDLETYPE ap_hdl,
OMX_INDEXTYPE a_index,
OMX_PTR ap_struct)
{
httpr_mp3port_t *p_obj = (httpr_mp3port_t *)ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index));
assert (NULL != p_obj);
if (OMX_TizoniaIndexConfigIcecastMetadata == a_index)
{
OMX_TIZONIA_ICECASTMETADATATYPE *p_metadata
= (OMX_TIZONIA_ICECASTMETADATATYPE *)ap_struct;
OMX_U32 stream_title_len
= strnlen ((char *)p_metadata->cStreamTitle,
OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE + 1);
if (stream_title_len > OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE)
{
rc = OMX_ErrorBadParameter;
}
else
{
TIZ_TRACE (ap_hdl, "stream_title_len [%d] Stream title [%s]...",
stream_title_len, p_metadata->cStreamTitle);
tiz_mem_free (p_obj->p_stream_title_);
p_obj->p_stream_title_ = tiz_mem_calloc (1, stream_title_len + 1);
if (NULL != p_obj->p_stream_title_)
{
strncpy (p_obj->p_stream_title_, (char *)p_metadata->cStreamTitle,
stream_title_len);
p_obj->p_stream_title_[stream_title_len] = '\000';
}
TIZ_TRACE (ap_hdl, "stream_title_len [%d] Stream title [%s]...",
stream_title_len, p_obj->p_stream_title_);
}
}
else
{
/* Delegate to the base port */
rc = super_SetConfig (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl,
a_index, ap_struct);
}
return rc;
}
static OMX_ERRORTYPE
fr_proc_allocate_resources (void *ap_obj, OMX_U32 a_pid)
{
fr_prc_t *p_obj = ap_obj;
const tiz_srv_t *p_parent = ap_obj;
OMX_ERRORTYPE ret_val = OMX_ErrorNone;
void *p_krn = tiz_get_krn (p_parent->p_hdl_);
assert (ap_obj);
if (!(p_obj->p_uri_param_))
{
p_obj->p_uri_param_ = tiz_mem_calloc
(1, sizeof (OMX_PARAM_CONTENTURITYPE) + OMX_MAX_STRINGNAME_SIZE);
if (NULL == p_obj->p_uri_param_)
{
TIZ_LOG (TIZ_ERROR, "Error allocating memory "
"for the content uri struct");
return OMX_ErrorInsufficientResources;
}
p_obj->p_uri_param_->nSize = sizeof (OMX_PARAM_CONTENTURITYPE)
+ OMX_MAX_STRINGNAME_SIZE - 1;
p_obj->p_uri_param_->nVersion.nVersion = OMX_VERSION;
}
if (OMX_ErrorNone != (ret_val = tiz_api_GetParameter
(p_krn,
p_parent->p_hdl_,
OMX_IndexParamContentURI, p_obj->p_uri_param_)))
{
TIZ_LOG (TIZ_ERROR, "Error retrieving URI param from port");
return ret_val;
}
TIZ_LOG (TIZ_NOTICE, "Retrieved URI [%s]",
p_obj->p_uri_param_->contentURI);
if ((p_obj->p_file_
= fopen ((const char *) p_obj->p_uri_param_->contentURI, "r")) == 0)
{
TIZ_LOG (TIZ_ERROR, "Error opening file from URI string");
return OMX_ErrorInsufficientResources;
}
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
store_metadata (dirble_prc_t * ap_prc, const char * ap_header_name,
const char * ap_header_info)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
OMX_CONFIG_METADATAITEMTYPE * p_meta = NULL;
size_t metadata_len = 0;
size_t info_len = 0;
assert (ap_prc);
if (ap_header_name && ap_header_info)
{
info_len = strnlen (ap_header_info, OMX_MAX_STRINGNAME_SIZE - 1) + 1;
metadata_len = sizeof (OMX_CONFIG_METADATAITEMTYPE) + info_len;
if (NULL == (p_meta = (OMX_CONFIG_METADATAITEMTYPE *) tiz_mem_calloc (
1, metadata_len)))
{
rc = OMX_ErrorInsufficientResources;
}
else
{
const size_t name_len
= strnlen (ap_header_name, OMX_MAX_STRINGNAME_SIZE - 1) + 1;
strncpy ((char *) p_meta->nKey, ap_header_name, name_len - 1);
p_meta->nKey[name_len - 1] = '\0';
p_meta->nKeySizeUsed = name_len;
strncpy ((char *) p_meta->nValue, ap_header_info, info_len - 1);
p_meta->nValue[info_len - 1] = '\0';
p_meta->nValueMaxSize = info_len;
p_meta->nValueSizeUsed = info_len;
p_meta->nSize = metadata_len;
p_meta->nVersion.nVersion = OMX_VERSION;
p_meta->eScopeMode = OMX_MetadataScopeAllLevels;
p_meta->nScopeSpecifier = 0;
p_meta->nMetadataItemIndex = 0;
p_meta->eSearchMode = OMX_MetadataSearchValueSizeByIndex;
p_meta->eKeyCharset = OMX_MetadataCharsetASCII;
p_meta->eValueCharset = OMX_MetadataCharsetASCII;
rc = tiz_krn_store_metadata (tiz_get_krn (handleOf (ap_prc)), p_meta);
}
}
return rc;
}
static OMX_ERRORTYPE
httpr_prc_config_change (const void * ap_prc, const OMX_U32 a_pid,
const OMX_INDEXTYPE a_config_idx)
{
const httpr_prc_t * p_prc = ap_prc;
OMX_ERRORTYPE rc = OMX_ErrorNone;
assert (ap_prc);
if (p_prc->p_server_ && OMX_TizoniaIndexConfigIcecastMetadata == a_config_idx
&& ARATELIA_HTTP_RENDERER_PORT_INDEX == a_pid)
{
OMX_TIZONIA_ICECASTMETADATATYPE * p_metadata
= (OMX_TIZONIA_ICECASTMETADATATYPE *) tiz_mem_calloc (
1, sizeof (OMX_TIZONIA_ICECASTMETADATATYPE)
+ OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE + 1);
tiz_check_null_ret_oom (p_metadata);
/* Retrieve the updated icecast metadata from the input port */
TIZ_INIT_OMX_PORT_STRUCT (*p_metadata, ARATELIA_HTTP_RENDERER_PORT_INDEX);
p_metadata->nSize = sizeof (OMX_TIZONIA_ICECASTMETADATATYPE)
+ OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE;
if (OMX_ErrorNone
!= (rc = tiz_api_GetConfig (
tiz_get_krn (handleOf (p_prc)), handleOf (p_prc),
OMX_TizoniaIndexConfigIcecastMetadata, p_metadata)))
{
TIZ_ERROR (handleOf (p_prc),
"[%s] : Error retrieving "
"OMX_TizoniaIndexConfigIcecastMetadata from port",
tiz_err_to_str (rc));
}
else
{
httpr_srv_set_stream_title (p_prc->p_server_,
p_metadata->cStreamTitle);
}
tiz_mem_free (p_metadata);
p_metadata = NULL;
}
return rc;
}
static OMX_ERRORTYPE
_ctx_init (cc_ctx_t * app_ctx)
{
int i;
check_common_context_t *p_ctx =
tiz_mem_calloc (1, sizeof (check_common_context_t));
if (!p_ctx)
{
return OMX_ErrorInsufficientResources;
}
for (i=0 ; i < MAX_EVENTS ; i++)
{
p_ctx->signaled[i] = OMX_FALSE;
p_ctx->event[i] = OMX_EventMax;
}
if (tiz_mutex_init (&p_ctx->mutex))
{
tiz_mem_free (p_ctx);
return OMX_ErrorInsufficientResources;
}
if (tiz_cond_init (&p_ctx->cond))
{
tiz_mutex_destroy (&p_ctx->mutex);
tiz_mem_free (p_ctx);
return OMX_ErrorInsufficientResources;
}
p_ctx->state = OMX_StateMax;
p_ctx->p_hdr = NULL;
p_ctx->flags = 0;
p_ctx->port = 0;
p_ctx->index = 0;
* app_ctx = p_ctx;
return OMX_ErrorNone;
}
OMX_ERRORTYPE graph::gmusicops::dump_metadata_item (const OMX_U32 index)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
OMX_CONFIG_METADATAITEMTYPE *p_meta = NULL;
size_t metadata_len = 0;
size_t value_len = 0;
value_len = OMX_MAX_STRINGNAME_SIZE;
metadata_len = sizeof(OMX_CONFIG_METADATAITEMTYPE) + value_len;
if (NULL == (p_meta = (OMX_CONFIG_METADATAITEMTYPE *)tiz_mem_calloc (
1, metadata_len)))
{
rc = OMX_ErrorInsufficientResources;
}
else
{
p_meta->nSize = metadata_len;
p_meta->nVersion.nVersion = OMX_VERSION;
p_meta->eScopeMode = OMX_MetadataScopeAllLevels;
p_meta->nScopeSpecifier = 0;
p_meta->nMetadataItemIndex = index;
p_meta->eSearchMode = OMX_MetadataSearchValueSizeByIndex;
p_meta->eKeyCharset = OMX_MetadataCharsetASCII;
p_meta->eValueCharset = OMX_MetadataCharsetASCII;
p_meta->nKeySizeUsed = 0;
p_meta->nValue[0] = '\0';
p_meta->nValueMaxSize = OMX_MAX_STRINGNAME_SIZE;
p_meta->nValueSizeUsed = 0;
rc = OMX_GetConfig (handles_[0], OMX_IndexConfigMetadataItem, p_meta);
if (OMX_ErrorNone == rc)
{
TIZ_PRINTF_CYN (" %s%s : %s\n", index ? " " : "", p_meta->nKey,
p_meta->nValue);
}
tiz_mem_free (p_meta);
p_meta = NULL;
}
return rc;
}
OMX_ERRORTYPE
graph::httpservops::configure_stream_metadata ()
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
// Set the stream title on to the renderer's input port
OMX_TIZONIA_ICECASTMETADATATYPE *p_metadata = NULL;
if (NULL == (p_metadata = (OMX_TIZONIA_ICECASTMETADATATYPE *)tiz_mem_calloc (
1, sizeof(OMX_TIZONIA_ICECASTMETADATATYPE)
+ OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE)))
{
rc = OMX_ErrorInsufficientResources;
}
else
{
p_metadata->nVersion.nVersion = OMX_VERSION;
p_metadata->nPortIndex = 0;
// Obtain the stream title
std::string stream_title = probe_ptr_->get_stream_title ();
snprintf ((char *)p_metadata->cStreamTitle,
OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE, "StreamTitle='%s';",
stream_title.c_str ());
p_metadata->nSize = sizeof(OMX_TIZONIA_ICECASTMETADATATYPE)
+ strlen ((char *)p_metadata->cStreamTitle);
TIZ_LOG (TIZ_PRIORITY_TRACE, "p_metadata->cStreamTitle [%s]...",
p_metadata->cStreamTitle);
rc = OMX_SetConfig (handles_[1], static_cast< OMX_INDEXTYPE >(
OMX_TizoniaIndexConfigIcecastMetadata),
p_metadata);
tiz_mem_free (p_metadata);
p_metadata = NULL;
}
return rc;
}
static OMX_ERRORTYPE
alloc_uri (oggdmux_prc_t * ap_prc)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
const long pathname_max = PATH_MAX + NAME_MAX;
assert (ap_prc);
assert (!ap_prc->p_uri_);
if (!(ap_prc->p_uri_ = tiz_mem_calloc (
1, sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1)))
{
TIZ_ERROR (handleOf (ap_prc),
"Error allocating memory for the content uri struct");
rc = OMX_ErrorInsufficientResources;
}
else
{
ap_prc->p_uri_->nSize
= sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1;
ap_prc->p_uri_->nVersion.nVersion = OMX_VERSION;
if (OMX_ErrorNone
!= (rc = tiz_api_GetParameter (
tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamContentURI, ap_prc->p_uri_)))
{
TIZ_ERROR (handleOf (ap_prc),
"[%s] : Error retrieving the URI param from port",
tiz_err_to_str (rc));
}
else
{
TIZ_NOTICE (handleOf (ap_prc), "URI [%s]",
ap_prc->p_uri_->contentURI);
}
}
return rc;
}
OMX_ERRORTYPE
tiz_rcfile_init (tiz_rcfile_t **pp_rc)
{
int i;
tiz_rcfile_t *p_rc = NULL;
char *p_env_str = NULL;
assert (pp_rc);
/* load rc files */
TIZ_LOG (TIZ_PRIORITY_TRACE, "Looking for [%d] rc files...", g_nrcfiles);
snprintf(rcfiles[0].name, sizeof(rcfiles[0].name) - 1, "%s",
getenv("TIZONIA_RC_FILE") ? getenv("TIZONIA_RC_FILE") : "");
snprintf (rcfiles[1].name, sizeof(rcfiles[0].name) - 1, "%s/tizonia.conf",
SYSCONFDIR);
if (g_nrcfiles >= 3 && (p_env_str = getenv ("HOME")))
{
TIZ_LOG (TIZ_PRIORITY_TRACE, "HOME [%s] ...", p_env_str);
snprintf (rcfiles[2].name, sizeof(rcfiles[2].name) - 1,
"%s/.tizonia.conf", p_env_str ? p_env_str : "");
}
if (!(p_rc = (tiz_rcfile_t *)tiz_mem_calloc (1, sizeof(tiz_rcfile_t))))
{
TIZ_LOG (TIZ_PRIORITY_TRACE,
"Could not allocate memory "
"for tiz_rcfile_t...");
return OMX_ErrorInsufficientResources;
}
for (i = 0; i < g_nrcfiles; i++)
{
TIZ_LOG (TIZ_PRIORITY_TRACE, "Checking for rc file at [%s]",
rcfiles[i].name);
/* Check file existence and user's read access */
if (0 != access (rcfiles[i].name, R_OK))
{
TIZ_LOG (TIZ_PRIORITY_TRACE,
"rc file [%s] does not exist or "
"user has no read access permission",
rcfiles[i].name);
continue;
}
/* Store stat's ctime */
if (stat_ctime (rcfiles[i].name, &rcfiles[i].ctime) != 0)
{
TIZ_LOG (TIZ_PRIORITY_TRACE, "stat_ctime for [%s] failed",
rcfiles[i].name);
}
rcfiles[i].exists = 1;
if (0 != load_rc_file (&rcfiles[i], p_rc))
{
TIZ_LOG (TIZ_PRIORITY_TRACE, "Loading [%s] rc file failed",
rcfiles[i].name);
}
else
{
TIZ_LOG (TIZ_PRIORITY_TRACE, "Loading [%s] rc file succeeded",
rcfiles[i].name);
}
}
if (p_rc->count)
{
*pp_rc = p_rc;
}
else
{
*pp_rc = NULL;
}
return OMX_ErrorNone;
}
static /*@null@ */ void *
os_calloc (/*@null@ */ tiz_soa_t * p_soa, size_t a_size)
{
return p_soa ? tiz_soa_calloc (p_soa, a_size) : tiz_mem_calloc (1, a_size);
}
static int get_node (const tiz_rcfile_t *ap_rc, char *str, keyval_t **app_kv)
{
int ret = 0;
char *needle = strstr (str, "=");
char *key = strndup (trimwhitespace (str), needle - str);
char *value_start = str + (needle - str) + 1;
char *value = strndup (trimlistseparator (trimwhitespace (value_start)),
strlen (str) - (needle - str));
keyval_t *p_kv = NULL;
value_t *p_v = NULL;
value_t *p_next_v = NULL;
assert (ap_rc);
assert (str);
assert (app_kv);
TIZ_LOG (TIZ_PRIORITY_TRACE, "key : [%s]", trimwhitespace (key));
TIZ_LOG (TIZ_PRIORITY_TRACE, "val : [%s]",
trimlistseparator (trimwhitespace (value)));
/* Find if the key exists already */
p_kv = find_node (ap_rc, key);
if (!p_kv)
{
p_kv = (keyval_t *)tiz_mem_calloc (1, sizeof(keyval_t));
p_v = (value_t *)tiz_mem_calloc (1, sizeof(value_t));
if (!p_kv || !p_v)
{
tiz_mem_free (p_kv);
p_kv = NULL;
tiz_mem_free (p_v);
p_v = NULL;
tiz_mem_free (value);
value = NULL;
tiz_mem_free (key);
key = NULL;
ret = -1;
}
else
{
p_v->p_value = value;
p_kv->p_key = key;
p_kv->p_value_list = p_v;
p_kv->p_value_iter = p_v;
p_kv->valcount++;
p_kv->p_next = NULL;
ret = 1;
}
}
else
{
/* There is already a node with that key */
/* Need to check if this node holds value lists */
if (is_list (key))
{
/* Add another value to the list */
TIZ_LOG (TIZ_PRIORITY_TRACE, "Found list Key [%s]", key);
p_v = (value_t *)tiz_mem_calloc (1, sizeof(value_t));
p_v->p_value = value;
p_next_v = p_kv->p_value_list;
for (;;)
{
if (!p_next_v->p_next)
{
p_next_v->p_next = p_v;
p_kv->valcount++;
TIZ_LOG (TIZ_PRIORITY_TRACE,
"Added value - "
"new valcount [%d]",
p_kv->valcount);
break;
}
p_next_v = p_next_v->p_next;
}
ret = 0;
}
else
{
/* Replace the existing value */
TIZ_LOG (TIZ_PRIORITY_TRACE,
"Replacing existing value [%s] "
"key [%s]",
p_kv->p_value_list->p_value, p_kv->p_key);
tiz_mem_free (p_kv->p_value_list->p_value);
p_kv->p_value_list->p_value = value;
p_kv->valcount = 1;
ret = 0;
}
tiz_mem_free (key);
}
if (-1 != ret)
{
*app_kv = p_kv;
}
return ret;
}
static /*@null@ */ void *
pqueue_calloc ( /*@null@ */ tiz_soa_t * p_soa, size_t a_size)
{
return NULL != p_soa
? tiz_soa_calloc (p_soa, a_size) : tiz_mem_calloc (1, a_size);
}
static int extractkeyval (FILE *ap_file, char *ap_str, keyval_t **app_last_kv,
tiz_rcfile_t *ap_tiz_rcfile)
{
int len;
int ret = 0;
int is_new = 0;
keyval_t *p_kv = NULL;
value_t *p_v = NULL, *p_next_v = NULL;
is_new = get_node (ap_tiz_rcfile, ap_str, &p_kv);
if (!p_kv)
{
TIZ_LOG (TIZ_PRIORITY_TRACE,
"Could not allocate memory "
"for keyval_t...");
return OMX_ErrorInsufficientResources;
}
/* Check if this is an existent node or not */
if (is_new)
{
/* This is a new node */
TIZ_LOG (TIZ_PRIORITY_TRACE,
"Linking new kv [%p] [%p] pair - "
"value [%s]",
app_last_kv, p_kv, p_kv->p_value_list->p_value);
(*app_last_kv) = p_kv;
p_v = p_kv->p_value_list;
}
else
{
p_v = p_kv->p_value_list;
for (;;)
{
if (!p_v->p_next)
{
break;
}
p_v = p_v->p_next;
}
}
while (fgets (pat, PAT_SIZE, ap_file) != NULL)
{
if (strstr (pat, ";"))
{
TIZ_LOG (TIZ_PRIORITY_TRACE, "val : [%s]",
trimlistseparator (trimwhitespace (pat)));
p_next_v = (value_t *)tiz_mem_calloc (1, sizeof(value_t));
/* TODO : Use strndup */
p_next_v->p_value = strdup (trimlistseparator (trimwhitespace (pat)));
p_v->p_next = p_next_v;
p_v = p_next_v;
p_kv->valcount++;
TIZ_LOG (TIZ_PRIORITY_TRACE,
"Added value - "
"new valcount [%d]",
p_kv->valcount);
}
else
{
len = strlen (pat);
if (pat[len - 1] == '\n')
{
pat[len - 1] = '\0';
}
if (strlen (pat) > 1)
{
ret = 1;
}
break;
}
}
TIZ_LOG (TIZ_PRIORITY_TRACE, "ret : [%d]", ret);
return ret;
}
