static struct native_enum * __new_enumeration (
int mm_add,
CMPIArray * array,
CMPIStatus * rc )
{
static CMPIEnumerationFT eft = {
NATIVE_FT_VERSION,
__eft_release,
__eft_clone,
__eft_getNext,
__eft_hasNext,
__eft_toArray
};
static CMPIEnumeration e = {
"CMPIEnumeration",
&eft
};
struct native_enum * enumeration =
(struct native_enum *)
tool_mm_alloc ( mm_add, sizeof ( struct native_enum ) );
enumeration->enumeration = e;
enumeration->mem_state = mm_add;
enumeration->data =
( mm_add == TOOL_MM_NO_ADD )?
CMClone ( array, rc ): array;
CMSetStatus ( rc, CMPI_RC_OK );
return enumeration;
}
static CMPIEnumeration * __eft_clone (
CONST CMPIEnumeration * enumeration,
CMPIStatus * rc )
{
CMPIStatus tmp;
struct native_enum * e = (struct native_enum *) enumeration;
CMPIArray * data;
if (!checkArgs(enumeration, rc))
{
return 0;
}
data = CMClone ( e->data, &tmp );
if (tmp.rc != CMPI_RC_OK)
{
CMSetStatus ( rc, CMPI_RC_ERR_FAILED );
return NULL;
}
return
(CMPIEnumeration *) __new_enumeration (
TOOL_MM_NO_ADD,
data,
rc );
}
static NativeSubCond *__new_subcond(int mode, CMPIValuePtr ptr, CMPIStatus * rc)
{
static CMPISubCondFT eft = {
NATIVE_FT_VERSION,
__eft_release,
__eft_clone,
__eft_getCount,
__eft_getPredicateAt,
__eft_getPredicate
};
static CMPISubCond c = {
"CMPISubCond",
&eft
};
int state;
NativeSubCond cond,*tCond;
memset(&cond, 0, sizeof(cond));
cond.sc = c;
cond.cond=ptr;
tCond=memAddEncObj(mode, &cond, sizeof(cond),&state);
tCond->mem_state=state;
if (rc) CMSetStatus(rc, CMPI_RC_OK);
return tCond;
}
static CMPIArray * __eft_toArray ( CMPIEnumeration * enumeration,
CMPIStatus * rc )
{
struct native_enum * e = (struct native_enum *) enumeration;
CMSetStatus ( rc, CMPI_RC_OK );
return e->data;
}
static NativeResult *
__new_empty_result(int mode, CMPIStatus *rc)
{
static CMPIResultFT rft = {
NATIVE_FT_VERSION,
__rft_release,
__rft_clone,
__rft_returnData,
__rft_returnInstance,
__rft_returnObjectPath,
__rft_returnDone
};
static CMPIResult r = {
"CMPIResult",
&rft
};
int state;
NativeResult result,
*tRslt;
memset(&result, 0, sizeof(NativeResult));
result.result = r;
tRslt = memAddEncObj(mode, &result, sizeof(result), &state);
tRslt->mem_state = state;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return tRslt;
}
static struct native_selectexp * __new_exp (
int mm_add,
CMPIUint64 id,
CMPIStatus * rc )
{
static CMPISelectExpFT eft = {
NATIVE_FT_VERSION,
__eft_release,
__eft_clone,
__eft_evaluate,
__eft_getString,
__eft_getDOC,
__eft_getCOD,
__eft_evaluateUsingAccessor
};
static CMPISelectExp e = {
"CMPISelectExp",
&eft
};
struct native_selectexp * exp =
(struct native_selectexp *)
tool_mm_alloc ( mm_add, sizeof ( struct native_selectexp ) );
exp->exp = e;
exp->mem_state = mm_add;
exp->id = id;
CMSetStatus ( rc, CMPI_RC_OK );
return exp;
}
static NativePredicate *
__new_predicate(int mode, QLOperation * op, CMPIStatus *rc)
{
static CMPIPredicateFT eft = {
NATIVE_FT_VERSION,
__eft_release,
__eft_clone,
__eft_getData,
__eft_evaluate
};
static CMPIPredicate p = {
"CMPIPredicate",
&eft
};
int state;
NativePredicate pred,
*tPred;
memset(&pred, 0, sizeof(pred));
pred.pred = p;
pred.op = op;
tPred = memAddEncObj(mode, &pred, sizeof(pred), &state);
tPred->mem_state = state;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return tPred;
}
static struct native_enum * __new_enumeration ( CMPIArray * array,
CMPIStatus * rc )
{
static CMPIEnumerationFT eft = {
NATIVE_FT_VERSION,
__eft_release,
__eft_clone,
__eft_getNext,
__eft_hasNext,
__eft_toArray
};
static const CMPIEnumeration e = {
"CMPIEnumeration",
&eft
};
struct native_enum * enumeration = (struct native_enum *)
calloc ( 1, sizeof ( struct native_enum ) );
enumeration->enumeration = e;
enumeration->data = array; /* CMClone ( array, rc ) ? */
CMSetStatus ( rc, CMPI_RC_OK );
return enumeration;
}
static NativeSelectExp *
__new_exp(int mode, const char *queryString,
const char *language, const char *sns, CMPIArray **projection,
CMPIStatus *rc)
{
int state,
irc;
NativeSelectExp exp,
*tExp;
memset(&exp, 0, sizeof(exp));
exp.exp = eFt;
/*
* fprintf(stderr,"*** new select expression: %s %s\n",queryString,
* language);
*/
exp.qs =
parseQuery(mode, (char *) queryString, (char *) language,
(char *) sns, &irc);
if (irc) {
if (rc)
CMSetStatus(rc, CMPI_RC_ERR_INVALID_QUERY);
return NULL;
}
exp.queryString = strdup(queryString);
exp.language = strdup(language);
if (sns)
exp.sns = strdup(sns);
if (projection) {
char **list = exp.qs->spNames;
int i;
CMPIArray *ar =
*projection = TrackedCMPIArray(exp.qs->spNext, CMPI_string, NULL);
for (i = 0; *list; list++, i++)
CMSetArrayElementAt(ar, i, (CMPIValue *) * list, CMPI_chars);
}
tExp = memAddEncObj(mode, &exp, sizeof(exp), &state);
tExp->mem_state = state;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return tExp;
}
static CMPIUint64 dtGetBinaryFormat(const CMPIDateTime* eDt, CMPIStatus* rc) {
CIMDateTime* dt=(CIMDateTime*)eDt->hdl;
if (!dt) {
if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
return 0;
}
CMPIUint64 days,hours,mins,secs,usecs,utc,lTime;
struct tm tm,tmt;
CString tStr=dt->toString().getCString();
char cStr[26];
memset( cStr, 0, 26);
memcpy (cStr, (const char*)tStr, 25);
if (dt->isInterval()) {
cStr[21]=0;
usecs=atoi(cStr+15);
cStr[15]=0;
secs=atoi(cStr+12);
cStr[12]=0;
mins=atoi(cStr+10);
cStr[10]=0;
hours=atoi(cStr+8);
cStr[8]=0;
days=atoi(cStr);
lTime=(days*PEGASUS_UINT64_LITERAL(86400000000))+
(hours*PEGASUS_UINT64_LITERAL(3600000000))+
(mins*60000000)+(secs*1000000)+usecs;
}
else {
time_t tt=time(NULL);
#ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC
tmt=*localtime(&tt);
#else
localtime_r(&tt,&tmt);
#endif
memset(&tm,0,sizeof(tm));
tm.tm_isdst=tmt.tm_isdst;
utc=atoi(cStr+21);
cStr[21]=0;
usecs=atoi(cStr+15);
cStr[15]=0;
tm.tm_sec=atoi(cStr+12);
cStr[12]=0;
tm.tm_min=atoi(cStr+10);
cStr[10]=0;
tm.tm_hour=atoi(cStr+8);
cStr[8]=0;
tm.tm_mday=atoi(cStr+6);
cStr[6]=0;
tm.tm_mon=(atoi(cStr+4)-1);
cStr[4]=0;
tm.tm_year=(atoi(cStr)-1900);
lTime=mktime(&tm);
lTime*=1000000;
lTime+=usecs;
}
return lTime;
}
static CMPIBoolean
__eft_evaluate(const CMPIPredicate *pred,
CMPIAccessor * acc, void *v, CMPIStatus *rc)
{
if (rc)
CMSetStatus(rc, CMPI_RC_ERR_NOT_SUPPORTED);
return 0;
}
CMPIData KFindProperty(
const CMPIInstance* ci,
const char* name,
CMPIStatus* status)
{
CMPICount count;
CMPICount i;
CMPIData cd;
count = CMGetPropertyCount(ci, NULL);
for (i = 0; i < count; i++)
{
CMPIString* pn = NULL;
CMPIStatus st;
cd = CMGetPropertyAt(ci, i, &pn, &st);
if (!KOkay(st) || !pn)
{
memset(&cd, 0, sizeof(cd));
if (status)
CMSetStatus(status, CMPI_RC_ERR_FAILED);
return cd;
}
if (strcasecmp(KChars(pn), name) == 0)
{
if (status)
CMSetStatus(status, CMPI_RC_OK);
return cd;
}
}
/* Not found! */
memset(&cd, 0, sizeof(cd));
if (status)
CMSetStatus(status, CMPI_RC_ERR_NOT_FOUND);
return cd;
}
static CMPICount
getQualifierCount(CMPIConstClass * cc, CMPIStatus *rc)
{
ClClass *cls = (ClClass *) cc->hdl;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return (CMPICount) ClClassGetQualifierCount(cls);
}
static CMPIData mbInvokeMethod(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const char *method, const CMPIArgs *in, CMPIArgs *out,
CMPIStatus *rc) {
CMPIData data={0,CMPI_nullValue,{0}};
mb=CM_BROKER;
if (rc) CMSetStatus(rc,CMPI_RC_ERR_NOT_SUPPORTED);
return data;
}
static unsigned int
__aft_getArgCount(const CMPIArgs * args, CMPIStatus *rc)
{
ClArgs *ca = (ClArgs *) args->hdl;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return (CMPICount) ClArgsGetArgCount(ca);
}
CMPIPredicate* sbcGetPredicateAt(const CMPISubCond* eSbc,
unsigned int index, CMPIStatus* rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_SubCond:sbcGetPredicateAt()");
const CMPI_SubCond *sbc = (CMPI_SubCond*)eSbc->hdl;
if( !sbc )
{
PEG_TRACE_CSTRING(
TRC_CMPIPROVIDERINTERFACE,
Tracer::LEVEL1,
"Invalid handle in CMPI_SubCond:sbcGetPredicateAt");
CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
PEG_METHOD_EXIT();
return 0;
}
CMPI_TableauRow* row = (CMPI_TableauRow* )sbc->priv;
if( row )
{
if( index<=row->size() )
{
const CMPI_term_el *term=(row->getData())+index;
CMPIPredicate *prd=(CMPIPredicate*)new CMPI_Predicate(term);
/**
CMPI_Object puts in the hdl the pointer to the
CMPI_Predicate The sbcRelease will use that pointer to
de-allocate the CMPI_Predicate
structure.
*/
CMPI_Object *obj = new CMPI_Object(prd);
CMSetStatus(rc,CMPI_RC_OK);
CMPIPredicate* cmpiPredicate =
reinterpret_cast<CMPIPredicate*>(obj);
PEG_METHOD_EXIT();
return cmpiPredicate;
}
}
CMSetStatus(rc, CMPI_RC_ERR_NO_SUCH_PROPERTY);
PEG_METHOD_EXIT();
return NULL;
}
static CMPIErrorType errGetErrorType(const CMPIError* eErr, CMPIStatus* rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Error:errGetErrorType()");
CIMError* cer=(CIMError*)eErr->hdl;
if (!cer)
{
PEG_TRACE_CSTRING(
TRC_CMPIPROVIDERINTERFACE,
Tracer::LEVEL1,
"Received invalid Handle - cer...");
CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
PEG_METHOD_EXIT();
return UnknownErrorType;
}
CMPIBoolean notNull;
CIMError::ErrorTypeEnum pgErrorType;
try
{
notNull = cer->getErrorType(pgErrorType);
if (!notNull)
{
PEG_TRACE_CSTRING(
TRC_CMPIPROVIDERINTERFACE,
Tracer::LEVEL1,
"Received invalid Parameter...");
CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
PEG_METHOD_EXIT();
return UnknownErrorType;
}
}
catch (...)
{
CMSetStatus(rc, CMPI_RC_ERR_FAILED);
PEG_METHOD_EXIT();
return UnknownErrorType;
}
CMSetStatus(rc,CMPI_RC_OK);
PEG_METHOD_EXIT();
return(CMPIErrorType)pgErrorType;
}
static CMPIContext * __cft_clone ( CONST CMPIContext * ctx, CMPIStatus * rc )
{
if (!checkArgs(ctx, rc))
{
return 0;
}
CMSetStatus ( rc, CMPI_RC_ERR_NOT_SUPPORTED );
return NULL;
}
static CMPIString *
__dtft_getStringFormat(const CMPIDateTime *dt, CMPIStatus *rc)
{
struct native_datetime *ndt = (struct native_datetime *) dt;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return sfcb_native_new_CMPIString(ndt->cimDt, rc, 0);
}
void
dateTime2chars(CMPIDateTime *dt, CMPIStatus *rc, char *str_time)
{
struct native_datetime *ndt = (struct native_datetime *) dt;
strcpy(str_time, ndt->cimDt);
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
}
/*
* ! \param dt the native CMPIDateTime to be extracted. \param rc return
* code pointer
*
* \return an amount of microseconds.
*/
static CMPIUint64
__dtft_getBinaryFormat(const CMPIDateTime *dt, CMPIStatus *rc)
{
struct native_datetime *ndt = (struct native_datetime *) dt;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return chars2bin(ndt->cimDt, rc);
}
static void
bin2chars(CMPIUint64 msecs, CMPIBoolean interval, CMPIStatus *rc,
char *str_time)
{
/** /brief bin2chars(): Converts microseconds since epoch to a string time.
*
* Uses the current timezone as the basis for the conversion, but will determine
* if DST was in effect at the time in the input.
*/
time_t secs = msecs / 1000000ULL;
unsigned long usecs = msecs % 1000000ULL;
if (interval) {
unsigned long long useconds,
seconds,
mins,
hrs,
days;
/* ddddddddhhmmss.mmmmmm:000, at most 8 characters for day */
const unsigned long long day_limit = 99999999;
seconds = msecs / 1000000ULL;
useconds = msecs % 1000000ULL;
mins = seconds / 60ULL;
seconds %= 60ULL;
hrs = mins / 60ULL;
mins %= 60ULL;
/* Modify to avoid datetime string overflow when the time duration overflow */
days = ((hrs / 24ULL) > day_limit) ? day_limit : (hrs / 24ULL);
hrs %= 24ULL;
sprintf(str_time, "%8.8llu%2.2llu%2.2llu%2.2llu.%6.6llu:000",
days, hrs, mins, seconds, useconds);
}
else {
struct tm tm_time;
char us_utc_time[11];
if (localtime_r(&secs, &tm_time) == NULL) {
if (rc)
CMSetStatus(rc, CMPI_RC_ERR_FAILED);
return;
}
tzset();
snprintf(us_utc_time, 11, "%6.6ld%+4.3ld",
usecs, (tm_time.tm_isdst != 0) * 60 - timezone / 60);
strftime(str_time, 26, "%Y%m%d%H%M%S.", &tm_time);
strcat(str_time, us_utc_time);
}
}
static CMPIBoolean
__dtft_isInterval(const CMPIDateTime *dt, CMPIStatus *rc)
{
struct native_datetime *ndt = (struct native_datetime *) dt;
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return ndt->cimDt[21] == ':' ? 1 : 0;
}
CMPIData
getPropertyQualsAt(CMPIConstClass * cc, CMPICount i, CMPIString **name,
unsigned long *quals, CMPIString **refName,
CMPIStatus *rc)
{
ClClass *cls = (ClClass *) cc->hdl;
char *n;
char *rName = NULL;
CMPIData rv = { 0, CMPI_notFound, {0} };
if (ClClassGetPropertyAt(cls, i, &rv, name ? &n : NULL, quals, &rName)) {
if (rc)
CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND);
return rv;
}
if (rv.type == CMPI_chars) {
rv.value.string = sfcb_native_new_CMPIString(rv.value.chars, NULL, 0);
rv.type = CMPI_string;
} else if (rv.type == CMPI_ref) {
if ((rv.state & CMPI_nullValue) == 0)
rv.value.ref = getObjectPath((char *)
ClObjectGetClString(&cls->hdr,
(ClString *) &
rv.value.chars),
NULL);
}
if (rv.type & CMPI_ARRAY && rv.value.array) {
rv.value.array =
native_make_CMPIArray((CMPIData *) rv.value.array, NULL,
&cls->hdr);
}
if (name) {
*name = sfcb_native_new_CMPIString(n, NULL, 0);
}
if (refName && rName) {
*refName = sfcb_native_new_CMPIString(rName, NULL, 0);
} else {
if (refName) {
*refName = NULL;
}
}
if (rc)
CMSetStatus(rc, CMPI_RC_OK);
return rv;
}
/**
* cmciRelease
**/
CMPIStatus
cmciRelease(CMCIClient* cmciClient)
{
CMPIStatus rc;
cmciClient->ft->release (cmciClient);
CMSetStatus(&rc, CMPI_RC_OK);
return rc;
}
static CMPICount __eft_getCount(const CMPISubCond* cond, CMPIStatus* rc)
{
NativeSubCond *c = (NativeSubCond *) cond;
CMPIArray *conds=(CMPIArray*)c->cond.ptr;
CMPICount count=0;
if (conds) count=CMGetArrayCount(conds,NULL);
if (rc) CMSetStatus(rc, CMPI_RC_OK);
return count;
}
PEGASUS_STATIC CMPIType arrayGetType(
const CMPIArray* eArray,
CMPIStatus* rc)
{
CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
if (!arr)
{
CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
return 0;
}
CMPIData *dta = (CMPIData*)arr->hdl;
if (!dta)
{
CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
return CMPI_null;
}
CMSetStatus(rc,CMPI_RC_OK);
return dta->type;
}
PEGASUS_STATIC CMPICount arrayGetSize(
const CMPIArray* eArray,
CMPIStatus* rc)
{
CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
if (!arr)
{
CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
return 0;
}
CMPIData *dta = (CMPIData*)arr->hdl;
if (!dta)
{
CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
return 0;
}
CMSetStatus(rc,CMPI_RC_OK);
return dta->value.uint32;
}
static CMPIDateTime* dtClone(const CMPIDateTime* eDt, CMPIStatus* rc)
{
OpenWBEM::CIMDateTime * dt=(OpenWBEM::CIMDateTime*)eDt->hdl;
//OpenWBEM::CIMDateTime * cDt=new OpenWBEM::CIMDateTime(dt->toString());
OpenWBEM::CIMDateTime * cDt = new OpenWBEM::CIMDateTime(*dt);
CMPIDateTime* neDt=(CMPIDateTime*)new CMPI_Object(cDt,CMPI_DateTime_Ftab);
CMSetStatus(rc,CMPI_RC_OK);
return neDt;
}
static CMPIBoolean enumHasNext(
const CMPIEnumeration* eEnumObj,
CMPIStatus* rc)
{
const CMPIEnumeration* eEnum = (CMPIEnumeration*)eEnumObj->hdl;
if (!eEnum || !eEnum->hdl)
{
PEG_TRACE_CSTRING(
TRC_CMPIPROVIDERINTERFACE,
Tracer::LEVEL1,
"Received invalid Handle - eEnum || eEnum->hdl...");
CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
return false;
}
CMSetStatus(rc, CMPI_RC_OK);
if ((void*)eEnum->ft == (void*)CMPI_ObjEnumeration_Ftab)
{
CMPI_ObjEnumeration* ie = (CMPI_ObjEnumeration*)eEnum;
if (ie->cursor<ie->max)
{
return true;
}
}
else if ((void*)eEnum->ft == (void*)CMPI_InstEnumeration_Ftab)
{
CMPI_InstEnumeration* ie = (CMPI_InstEnumeration*)eEnum;
if (ie->cursor<ie->max)
{
return true;
}
}
else
{
CMPI_OpEnumeration* oe = (CMPI_OpEnumeration*)eEnum;
if (oe->cursor<oe->max)
{
return true;
}
}
return false;
}
