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; }