provider_address * resolve_instance (
CONST CMPIBroker * broker,
CONST CMPIContext * ctx,
CONST CMPIObjectPath * cop,
const char * provider,
CMPIStatus * rc)
{
CMPIStatus irc;
const char *ip;
provider_address *a = NULL;
CMPIData info = CMGetContextEntry(ctx,"CMPIRRemoteInfo",&irc);
if (irc.rc == CMPI_RC_OK)
{
ip = CMGetCharsPtr(info.value.string,&irc);
switch (ip[1])
{
case '0':
a = outofprocess_resolver(broker,provider);
break;
case '1':
a = namespace_resolver(broker,provider,ip+3);
break;
}
}
TRACE_NORMAL(("Resolve requested for provider: %s", provider ));
if (rc)
{
*rc = irc;
}
return a;
}
static void TCPCOMM_attachThread(int socket, CONST CMPIBroker * broker,
CONST CMPIContext * context)
{
CMPIStatus rc;
CMPIData ctxid = CMGetContextEntry(context, RCMPI_CTX_ID, NULL);
CONST CMPIContext *ctx = get_context(ctxid.value.uint32);
rc = CBAttachThread(broker, ctx);
(__sft)->serialize_CMPIStatus(socket, &rc);
}
static int
_testCMPIcontext(const CMPIContext *ctx)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIValue value;
CMPIData data;
CMPIUint32 count = 0;
CMPIUint32 count_for_new_context = 0;
count = CMGetContextEntryCount(ctx, &rc);
value.uint32 = 40;
rc = CMAddContextEntry(ctx, "name1", &value, CMPI_uint32);
value.real32 = (CMPIReal32) 40.123;
rc = CMAddContextEntry(ctx, "name2", &value, CMPI_real32);
data = CMGetContextEntry(ctx, "name1", &rc);
data = CMGetContextEntry(ctx, "name2", &rc);
count_for_new_context = CMGetContextEntryCount(ctx, &rc);
CMGetContextEntry(ctx, "noEntry", &rc);
if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) {
return 1;
}
return 0;
}
SCMOClass* mbGetSCMOClass(
const char* nameSpace,
Uint32 nsL,
const char* cls,
Uint32 clsL)
{
PEG_METHOD_ENTER(TRC_CMPIPROVIDERINTERFACE, "CMPI_Broker:mbGetSCMOClass()");
const CMPIBroker * mb = CMPI_ThreadContext::getBroker();
CMPI_Broker *xBroker = (CMPI_Broker*)mb;
const char* ns=nameSpace;
if (0 == nsL)
{
//If we don't have a namespace here, we use the initnamespace from
// the thread context, since we need one to be able to lookup the class
const CMPIContext* ctx = CMPI_ThreadContext::getContext();
if (0!=ctx)
{
CMPIStatus rc;
CMPIData nsCtxData = CMGetContextEntry(ctx, CMPIInitNameSpace,&rc);
if (rc.rc == CMPI_RC_OK)
{
ns = CMGetCharsPtr(nsCtxData.value.string, 0);
nsL = strlen(ns);
}
}
}
SCMOClass* scmoCls =
xBroker->classCache.getSCMOClass(xBroker, ns, nsL, cls, clsL);
PEG_METHOD_EXIT();
return scmoCls;
}
static CMPIStatus ClassProviderInvokeMethod(CMPIMethodMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIArray *ar;
int rc;
ClassRegister *cReg;
_SFCB_ENTER(TRACE_PROVIDERS, "ClassProviderInvokeMethod");
cReg=getNsReg(ref, &rc);
if (cReg==NULL) {
CMPIStatus st = { CMPI_RC_ERR_INVALID_NAMESPACE, NULL };
_SFCB_RETURN(st);
}
if (strcasecmp(methodName, "getchildren") == 0) {
CMPIData cn = CMGetArg(in, "class", NULL);
_SFCB_TRACE(1,("--- getchildren %s",(char*)cn.value.string->hdl));
cReg->ft->wLock(cReg);
if (cn.type == CMPI_string && cn.value.string && cn.value.string->hdl) {
char *child;
int l=0, i=0;
UtilList *ul = getChildren(cReg, (char *) cn.value.string->hdl);
if (ul) l = ul->ft->size(ul);
ar = CMNewArray(_broker, l, CMPI_string, NULL);
if (ul) for (child = (char *) ul->ft->getFirst(ul); child; child = (char *)
ul->ft->getNext(ul)) {
CMSetArrayElementAt(ar, i++, child, CMPI_chars);
}
st = CMAddArg(out, "children", &ar, CMPI_stringA);
}
else {
}
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "getallchildren") == 0) {
int ignprov=0;
CMPIStatus st;
CMPIData cn = CMGetArg(in, "class", &st);
cReg->ft->wLock(cReg);
if (st.rc!=CMPI_RC_OK) {
cn = CMGetArg(in, "classignoreprov", NULL);
ignprov=1;
}
_SFCB_TRACE(1,("--- getallchildren %s",(char*)cn.value.string->hdl));
if (cn.type == CMPI_string && cn.value.string && cn.value.string->hdl) {
int n=0,i=0;
loopOnChildCount(cReg,(char *)cn.value.string->hdl,&n,ignprov);
_SFCB_TRACE(1,("--- count %d",n));
ar = CMNewArray(_broker, n, CMPI_string, NULL);
if (n) {
_SFCB_TRACE(1,("--- loop %s",(char*)cn.value.string->hdl));
loopOnChildChars(cReg, (char *)cn.value.string->hdl,ar,&i,ignprov);
}
st = CMAddArg(out, "children", &ar, CMPI_stringA);
}
else {
}
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "getassocs") == 0) {
ar = CMNewArray(_broker, cReg->topAssocs, CMPI_string, NULL);
ClassBase *cb = (ClassBase *) (cReg + 1);
UtilHashTable *ct = cb->ht;
HashTableIterator *i;
char *cn;
ClassRecord *crec;
int n;
cReg->ft->wLock(cReg);
for (n = 0, i = ct->ft->getFirst(ct, (void **) &cn, (void **) &crec); i;
i = ct->ft->getNext(ct, i, (void **) &cn, (void **) &crec)) {
if(crec->flags & CREC_isAssociation && crec->parent == NULL) {
/* add top-level association class */
CMSetArrayElementAt(ar, n++, cn, CMPI_chars);
}
}
CMAddArg(out, "assocs", &ar, CMPI_stringA);
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "ischild") == 0) {
char *parent=(char*)CMGetClassName(ref,NULL)->hdl;
char *chldn=(char*)CMGetArg(in, "child", NULL).value.string->hdl;
st.rc = traverseChildren(cReg, parent, chldn);
}
else if (strcasecmp(methodName, "_startup") == 0) {
/* check to see if cacheLimit was specified in providerRegister */
CMPIStatus parm_st = { CMPI_RC_OK, NULL };
CMPIData parmdata = CMGetContextEntry(ctx, "sfcbProviderParameters", &parm_st);
if (parm_st.rc == CMPI_RC_OK ) {
const char* parms = CMGetCharPtr(parmdata.value.string);
/* cacheLimit is currently the only param, so just take whatever is after the '=' */
const char* val = strchr(parms,'=');
/* conversion to uint may cause wrapping; won't catch negatives */
cacheLimit = ((val != NULL) && (cacheLimit = atoi(val+sizeof(char)))>0) ? cacheLimit : 10;
}
st.rc=CMPI_RC_OK;
}
else {
mlogf(M_ERROR,M_SHOW,"--- ClassProvider: Invalid invokeMethod request %s\n", methodName);
st.rc = CMPI_RC_ERR_METHOD_NOT_FOUND;
}
_SFCB_RETURN(st);
}
