static component_ref _make_component_ref(
_manager* pmanager,
entity_key ekey,
_storage* pstorage,
component_key ckey
)
{
return component_ref(
pmanager,
ekey,
pstorage,
ckey
);
}
bool
query_match_provider (
query_t *queryPtr,
port_t *providerPtr
) {
component_t *componentPtr;
bool result = true;
TRACE3 (("called with queryPtr=%p, providerPtr=%p", queryPtr, providerPtr));
assert (queryPtr != NULL);
assert (providerPtr != NULL);
/* If a specific component is queried, make first sure that the provider component matches! */
if (queryPtr->queriedComponent != NULL) {
result = false;
componentPtr = component_ref (providerPtr->componentHandle);
if (componentPtr != NULL) {
if (strcmp (queryPtr->queriedComponent, componentPtr->name) == 0) {
result = true;
}
else {
TRACE2 ((
"component names do not match (%s vs %s)",
queryPtr->queriedComponent, componentPtr->name
));
}
component_unref (componentPtr);
}
}
/* Now match the actual interfaces if the provider wasn't already ruled out. */
if (result == true) {
result = interfaces_match (
&providerPtr->interfaceSpec,
providerPtr->port,
NULL,
&queryPtr->queriedInterface,
queryPtr->queriedPort,
NULL,
MATCHF_NONE
);
}
TRACE3 (("exiting with result=%s", (result) ? "true" : "false"));
return result;
}
xc_result_t
xCOM_QueryPort (
xc_handle_t componentHandle,
const char *portName,
unsigned int queryFlags,
xc_handle_t *queryHandlePtr,
unsigned int *matchCountPtr
) {
component_t *componentPtr;
port_t *portPtr;
xc_result_t result;
TRACE3 ((
"called with componentHandle=%u, portName='%s', queryFlags=%u, "
"queryHandlePtr=%p, matchCountPtr=%p", componentHandle, portName,
queryFlags, queryHandlePtr, matchCountPtr
));
if ((componentHandle == XC_INVALID_HANDLE) || (portName == NULL)) {
TRACE1 (("Invalid arguments!"));
result = XC_ERR_INVAL;
}
else {
componentPtr = component_ref (componentHandle);
if (componentPtr != NULL) {
portPtr = component_ref_port (componentPtr, portName);
if (portPtr != NULL) {
if (XC_PORTF_IS_REQUIRED (portPtr->flags) && XC_PORTF_IS_RUNTIME (portPtr->flags)) {
result = query_new (
componentHandle,
portPtr->name,
portPtr->interfaceSpec.name,
portPtr->interfaceSpec.vmajor,
portPtr->interfaceSpec.vminor,
portPtr->componentName,
portPtr->port,
queryFlags,
queryHandlePtr,
matchCountPtr
);
}
else {
TRACE1 (("port '%s' of '%s' is not a runtime import!", portPtr->name, componentPtr->name));
result = XC_ERR_INVAL;
}
component_unref_port (componentPtr, portPtr);
}
else {
TRACE1 (("no port named '%s' in %s", portName, componentPtr->name));
result = XC_ERR_NOENT;
}
component_unref (componentPtr);
}
else {
TRACE1 (("Invalid component handle %u!", componentHandle));
result = XC_ERR_NOENT;
}
}
TRACE3 (("exiting with result=%d", result));
return result;
}
xc_result_t
query_new (
xc_handle_t componentHandle,
const char *portName,
const char *interfaceName,
unsigned int interfaceMajorVersion,
unsigned int interfaceMinorVersion,
const char *queriedComponentName,
const char *queriedPortName,
unsigned int queryFlags,
xc_handle_t *queryHandlePtr,
unsigned int *matchCountPtr
) {
query_t *queryPtr;
xc_result_t result = XC_OK;
TRACE3 ((
"called with componentHandle=%u, portName='%s', interfaceName='%s', "
"interfaceMajorVersion=%u, interfaceMinorVersion=%u, queriedComponentName='%s', "
"queriedPortName='%s', queryFlags=0x%x, queryHandlePtr=%p, matchCountPtr=%p",
componentHandle, portName, interfaceName, interfaceMajorVersion, interfaceMinorVersion,
queriedComponentName, queriedPortName, queryFlags, queryHandlePtr, matchCountPtr
));
assert (interfaceName != NULL);
assert (queryHandlePtr != NULL);
pthread_mutex_lock (&lock);
queryPtr = (query_t *) malloc (sizeof (*queryPtr));
if (queryPtr != NULL) {
/* Initialize things to be allocated to sane values. */
queryPtr->queryHandle = XC_INVALID_HANDLE;
queryPtr->queriedComponent = NULL;
queryPtr->queriedPort = NULL;
queryPtr->componentPtr = NULL;
queryPtr->firstImportPtr = NULL;
queryPtr->lastImportPtr = NULL;
queryPtr->importPtr = NULL;
queryPtr->clientPortName = NULL;
XC_CLIST_INIT (&queryPtr->imports);
queryPtr->componentHandle = componentHandle;
queryPtr->queriedInterface.vmajor = interfaceMajorVersion;
queryPtr->queriedInterface.vminor = interfaceMinorVersion;
/* Resolve component handle */
if (componentHandle != XC_INVALID_HANDLE) {
queryPtr->componentPtr = component_ref (componentHandle);
if (queryPtr->componentPtr == NULL) {
TRACE1 (("invalid component handle %u", componentHandle));
result = XC_ERR_NOENT;
}
}
/* Copy client port name. */
if (portName != NULL) {
queryPtr->clientPortName = strdup (portName);
if (queryPtr->clientPortName == NULL) {
TRACE1 (("Out of memory!"));
result = XC_ERR_NOMEM;
}
}
/* Copy interface name. */
if (result == XC_OK) {
queryPtr->queriedInterface.name = strdup (interfaceName);
if (queryPtr->queriedInterface.name == NULL) {
TRACE1 (("Out of memory!"));
result = XC_ERR_NOMEM;
}
}
/* Copy queried component name if specified. */
if ((result == XC_OK) && (queriedComponentName != NULL)) {
queryPtr->queriedComponent = strdup (queriedComponentName);
if (queryPtr->queriedComponent == NULL) {
TRACE1 (("Out of memory!"));
result = XC_ERR_NOMEM;
}
}
/* Copy queried port name if specified. */
if ((result == XC_OK) && (queriedPortName != NULL)) {
queryPtr->queriedPort = strdup (queriedPortName);
if (queryPtr->queriedPort == NULL) {
TRACE1 (("Out of memory!"));
result = XC_ERR_NOMEM;
}
}
/* Get a handle for this query. */
if (result == XC_OK) {
queryPtr->queryHandle = handle_dir_push (queryHandles, queryPtr);
}
else {
TRACE1 (("Out of memory!"));
result = XC_ERR_NOMEM;
}
if (result == XC_OK) {
result = query_get_candidates (queryPtr, matchCountPtr);
}
if (result == XC_OK) {
*queryHandlePtr = queryPtr->queryHandle;
}
else {
query_free (queryPtr);
}
}
pthread_mutex_unlock (&lock);
TRACE3 (("exiting with result=%d", result));
return result;
}