1 karl 1.9 //%2006////////////////////////////////////////////////////////////////////////
|
2 kumpf 1.1 //
|
3 karl 1.6 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 karl 1.4 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.6 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.7 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.9 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 kumpf 1.1 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
20 //
21 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 // Author: Chip Vincent (cvincent@us.ibm.com)
33 //
34 kumpf 1.1 // Modified By: Barbara Packard (barbara_packard@hp.com)
|
35 kumpf 1.3 // Paulo Sehn (paulo_sehn@hp.com)
36 // Adriano Zanuz (adriano.zanuz@hp.com)
37 // Jair Santos, Hewlett-Packard Company (jair.santos@hp.com)
|
38 kumpf 1.5 // Terry Martin, Hewlett-Packard Company (terry.martin@hp.com)
|
39 kumpf 1.3 //
|
40 kumpf 1.1 //%/////////////////////////////////////////////////////////////////////////////
41
42 #include "StdAfx.h"
43
44 #include "WMIValue.h"
45 #include "WMIString.h"
46 #include "WMIType.h"
47 #include "WMIDateTime.h"
48 #include "WMIObjectPath.h"
49
50 PEGASUS_NAMESPACE_BEGIN
51
52 static const char _NULL_INTERVAL_TYPE_STRING[] = "00000000000000.000000:000";
53 static const char _NULL_DATE_TYPE_STRING[] = "00000000000000.000000-000";
54
55 WMIValue::WMIValue(const CIMValue & value) : CIMValue(value)
56 {
57 }
58
59 WMIValue::WMIValue(const CComVariant & vValue)
60 {
61 kumpf 1.1 CIMValue val;
62 val = getValue(vValue);
63 *this = CIMValue(val);
64 }
65
66 WMIValue::WMIValue(VARTYPE vt, void *pVal)
67 {
68 CIMValue val;
69 val = getCIMValueFromVariant(vt, pVal);
70 *this = CIMValue(val);
71 }
72
73 WMIValue::WMIValue(VARTYPE vt, void *pVal, const CIMTYPE type)
74 {
75 CIMValue val;
76 val = getCIMValueFromVariant(vt, pVal, type);
77 *this = CIMValue(val);
78 }
79
80
81 WMIValue::WMIValue(const VARIANT & value, const CIMTYPE type)
82 kumpf 1.1 {
83 CIMValue val;
84 CComVariant vValue;
85 vValue = value;
86
87 if ((vValue.vt != VT_NULL) && ((type & ~CIM_FLAG_ARRAY) != CIM_REFERENCE))
88 {
89 val = getValue(vValue, type);
90 }
91 else
92 {
|
93 kumpf 1.2 // for class definitions, the value will be null and will except
|
94 kumpf 1.1 _variant_t vt(value);
95
96 switch(type & ~CIM_FLAG_ARRAY)
97 {
98 case CIM_BOOLEAN:
99 try
100 {
101 val.set(Boolean(bool(vt)));
102 }
103 catch(...)
104 {
105 val.setNullValue(CIMTYPE_BOOLEAN, false, 0);
106 }
107
108 break;
109 case CIM_BOOLEAN | CIM_FLAG_ARRAY:
110 //val.setNullValue(CIMType(CIMTYPE_BOOLEAN), true. 0);
111
112 break;
113 case CIM_SINT8:
114 try
115 kumpf 1.1 {
116 val.set(Sint8(BYTE(vt)));
117 }
118 catch(...)
119 {
120 val.setNullValue(CIMTYPE_SINT8, false, 0);
121 }
122
123 break;
124 case CIM_SINT8 | CIM_FLAG_ARRAY:
125 //val.setNullValue(CIMTYPE_SINT8, true. 0);
126
127 break;
128 case CIM_UINT8:
129 try
130 {
131 val.set(Uint8(BYTE(vt)));
132 }
133 catch(...)
134 {
|
135 kumpf 1.2 val.setNullValue(CIMTYPE_UINT8, false, 0);
|
136 kumpf 1.1 }
137
138 break;
139 case CIM_UINT8 | CIM_FLAG_ARRAY:
140 //val.setNullValue(CIMTYPE_UINT8, true. 0);
141
142 break;
143 case CIM_SINT16:
144 try
145 {
146 val.set(Sint16(short(vt)));
147 }
148 catch(...)
149 {
150 val.setNullValue(CIMTYPE_SINT16, false, 0);
151 }
152
153 break;
154 case CIM_SINT16 | CIM_FLAG_ARRAY:
155 //val.setNullValue(CIMTYPE_SINT16, true. 0);
156
157 kumpf 1.1 break;
158 case CIM_UINT16:
159 try
160 {
161 val.set(Uint16(short(vt)));
162 }
163 catch(...)
164 {
165 val.setNullValue(CIMTYPE_UINT16, false, 0);
166 }
167
168 break;
169 case CIM_UINT16 | CIM_FLAG_ARRAY:
170 //val.setNullValue(CIMTYPE_UINT16, true. 0);
171
172 break;
173 case CIM_SINT32:
174 try
175 {
176 val.set(Sint32(long(vt)));
177 }
178 kumpf 1.1 catch(...)
179 {
180 val.setNullValue(CIMTYPE_SINT32, false, 0);
181 }
182
183 break;
184 case CIM_SINT32 | CIM_FLAG_ARRAY:
185 //val.setNullValue(CIMTYPE_SINT32, true. 0);
186
187 break;
188 case CIM_UINT32:
189 try
190 {
191 val.set(Uint32(long(vt)));
192 }
193 catch(...)
194 {
195 val.setNullValue(CIMTYPE_UINT32, false);
196 }
197
198 break;
199 kumpf 1.1 case CIM_UINT32 | CIM_FLAG_ARRAY:
200 //val.setNullValue(CIMTYPE_UINT32, true. 0);
201
202 break;
203 case CIM_SINT64:
204 try
205 {
206 _bstr_t bstr(vt);
207
208 val.set(Sint64(_wtoi64(bstr)));
209 }
210 catch(...)
211 {
212 val.setNullValue(CIMTYPE_SINT64, false, 0);
213 }
214
215 break;
216 case CIM_SINT64 | CIM_FLAG_ARRAY:
217 //val.setNullValue(CIMTYPE_SINT64, true. 0);
218
219 break;
220 kumpf 1.1 case CIM_UINT64:
221 try
222 {
223 _bstr_t bstr(vt);
224
225 val.set(Uint64(_wtoi64(bstr)));
226 }
227 catch(...)
228 {
229 val.setNullValue(CIMTYPE_UINT64, false, 0);
230 }
231
232 break;
233 case CIM_UINT64 | CIM_FLAG_ARRAY:
234 //val.setNullValue(CIMTYPE_UINT64, true. 0);
235
236 break;
237 case CIM_REAL32:
238 try
239 {
240 val.set(Real32(float(vt)));
241 kumpf 1.1 }
242 catch(...)
243 {
244 val.setNullValue(CIMTYPE_REAL32, false, 0);
245 }
246
247 break;
248 case CIM_REAL32 | CIM_FLAG_ARRAY:
249 //val.setNullValue(CIMTYPE_REAL32, true. 0);
250
251 break;
252 case CIM_REAL64:
253 try
254 {
255 val.set(Real64(double(vt)));
256 }
257 catch(...)
258 {
259 val.setNullValue(CIMTYPE_REAL64, false, 0);
260 }
261
262 kumpf 1.1 break;
263 case CIM_REAL64 | CIM_FLAG_ARRAY:
264 //val.setNullValue(CIMTYPE_REAL64, true. 0);
265
266 break;
267 case CIM_STRING:
268 try
269 {
270 val.set(WMIString(_bstr_t(vt)));
271 }
272 catch(...)
273 {
|
274 marek 1.11 PEG_TRACE_CSTRING(TRC_WMIPROVIDER, Tracer::LEVEL3,
275 "WMIValue::WMIValue - Constructor failed; setting NULL string");
|
276 kumpf 1.3 val.setNullValue(CIMTYPE_STRING, false, 0);
|
277 kumpf 1.1 }
278
279 break;
280 case CIM_STRING | CIM_FLAG_ARRAY:
281 //val.setNullValue(CIMTYPE_STRING, true. 0);
282
283 break;
284 case CIM_DATETIME:
285 try
286 {
287 val.set(WMIDateTime(_bstr_t(vt)));
288 }
289 catch(...)
290 {
291 val.setNullValue(CIMTYPE_DATETIME, false, 0);
292 }
293
294 break;
295 case CIM_DATETIME | CIM_FLAG_ARRAY:
296 //val.setNullValue(CIMTYPE_DATETIME, true. 0);
297
298 kumpf 1.1 break;
299 case CIM_REFERENCE:
300 try
301 {
302 val.set(WMIObjectPath(_bstr_t(vt)));
303 }
304 catch(...)
305 {
306 val.setNullValue(CIMTYPE_REFERENCE, false);
307 }
308
309 break;
310 case CIM_CHAR16:
311 try
312 {
313 val.set(Char16(short(vt)));
314 }
315 catch(...)
316 {
317 val.setNullValue(CIMTYPE_CHAR16, false);
318 }
319 kumpf 1.1
320 break;
321 case CIM_CHAR16 | CIM_FLAG_ARRAY:
322 //val.setNullValue(CIMTYPE_CHAR16, true. 0);
323
324 break;
325 case CIM_OBJECT:
326
327 break;
328 case CIM_EMPTY:
329
330 break;
331 case CIM_ILLEGAL:
332 default:
333
334 break;
335 }
|
336 kumpf 1.3 }
337
|
338 kumpf 1.5 vValue.Clear();
|
339 kumpf 1.1 *this = CIMValue(val);
340 }
341
342 /////////////////////////////////////////////////////////////////////////////
343 // WMIValue::getCIMValueFromVariant - helper function to convert a variant
344 // value to a CIM value
345 //
346 // ///////////////////////////////////////////////////////////////////////////
347 CIMValue WMIValue::getCIMValueFromVariant(VARTYPE vt, void *pVal, const CIMTYPE Type)
348 {
|
349 kumpf 1.5 PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMIValue::getCIMValueFromVariant()");
350
|
351 kumpf 1.1 CIMValue cimValue;
|
352 kumpf 1.5 String str;
|
353 kumpf 1.1
354 switch (vt)
355 {
|
356 kumpf 1.2 case VT_I2:
357 // have to screw around here because automation type
358 // is not necessarily the mof type...
359 if (CIM_SINT8 == Type)
360 {
361 return (CIMValue((Sint8)*((BYTE *)pVal)));
362 }
363 else if (CIM_CHAR16 == Type)
364 {
365 return (CIMValue((Char16)*((short *)pVal)));
366 }
367 else
368 {
369 return (CIMValue((Sint16)*((short *)pVal)));
370 }
371
372 break;
|
373 kumpf 1.1
|
374 kumpf 1.2 case VT_I4:
375 // have to screw around here because automation type
376 // is not necessarily the mof type...
377 if (CIM_UINT16 == Type)
378 {
379 return (CIMValue((Uint16)*((unsigned short *)pVal)));
380 }
381 else if (CIM_UINT32 == Type)
382 {
383 return (CIMValue((Uint32)*((unsigned long *)pVal)));
384 }
385 else
386 {
387 return (CIMValue((Sint32)*((int *)pVal)));
388 }
389 break;
390
391 case VT_R4:
392 return (CIMValue((Real32)*((float *)pVal)));
393 break;
394
395 kumpf 1.2 case VT_R8:
396 return (CIMValue((Real64)*((double *)pVal)));
397 break;
|
398 kumpf 1.1
|
399 kumpf 1.2 case VT_DATE:
|
400 kumpf 1.1 {
|
401 kumpf 1.2 ////ATTN: it needs to be checked to see if this really
402 // works!!
403 DATE date;
404 CIMDateTime tmp;
405 SYSTEMTIME sTime;
|
406 kumpf 1.5
|
407 kumpf 1.2 date = *(DATE *)pVal;
|
408 kumpf 1.1
|
409 kumpf 1.2 if (VariantTimeToSystemTime(date, &sTime))
410 {
411 WBEMTime wTime(sTime);
|
412 kumpf 1.5 BSTR bs = wTime.GetDMTF();
413 str = (LPCTSTR)_bstr_t(bs, FALSE);
414 SysFreeString(bs);
415
|
416 marek 1.10 PEG_TRACE((TRC_WMIPROVIDER,Tracer::LEVEL3,
417 "WMIValue::getValue() - Date is %s", (LPCSTR)str.getCString()));
|
418 kumpf 1.2 }
419 else
420 {
|
421 kumpf 1.5 //ATTN: just to have something for now
422 str = _NULL_INTERVAL_TYPE_STRING;
|
423 kumpf 1.2 }
|
424 kumpf 1.1
|
425 kumpf 1.5 tmp.set(str);
426
|
427 kumpf 1.2 return CIMValue(tmp);
428 }
|
429 kumpf 1.1 break;
430
|
431 kumpf 1.2 case VT_BSTR:
|
432 kumpf 1.5 {
433 BSTR bsTemp = *((BSTR *)pVal);
434 // Not making a copy when constructing the _bstr_t,
435 // For some reason, setting fCopy to TRUE causes a memory leak
436 // to be reported (even though the destructor is freeing the string!)
437 // This seems to work, but needs to be looked at closer some day:
438 _bstr_t bstr(bsTemp, FALSE);
|
439 mateus.baur 1.8 str.assign((Char16*)((wchar_t*)bstr));
|
440 kumpf 1.2
441 //By Jair - Due to Windows automation limitations
442 //the 64 integer bit numbers and the datetime routine
443 //are being cast as strings. We must to handle this in
444 //order to correctly answer the dispatcher.
445 if (CIM_SINT64 == Type)
446 {
|
447 kumpf 1.5 return (CIMValue(Sint64(_wtoi64(bstr))));
|
448 kumpf 1.2 }
449 else if (CIM_UINT64 == Type)
450 {
|
451 kumpf 1.5 return (CIMValue(Uint64(_wtoi64(bstr))));
|
452 kumpf 1.2 }
453 else if (CIM_DATETIME == Type)
454 {
455 CIMDateTime dt;
456
457 //By Jair - Exchanging asterisks for zeros
458 Uint32 iCount = 0;
|
459 kumpf 1.1
|
460 kumpf 1.5 for (Uint32 i = 0; i < str.size(); i++)
|
461 kumpf 1.2 {
462 if (str[i] == '*')
463 {
464 str[i] = '0';
465 iCount++;
466 }
467 }
|
468 kumpf 1.1
|
469 kumpf 1.2 //if there are only asterisks, then pass a NULL interval
|
470 kumpf 1.5 if (iCount == str.size() - 2)
|
471 kumpf 1.2 {
|
472 kumpf 1.5 str = _NULL_INTERVAL_TYPE_STRING;
|
473 kumpf 1.2 }
|
474 kumpf 1.1
|
475 kumpf 1.5 dt.set(str);
|
476 kumpf 1.3
|
477 kumpf 1.2 return (CIMValue(WMIDateTime(dt)));
478 }
479 else
480 {
|
481 kumpf 1.5 if (0 == str.size())
|
482 kumpf 1.2 {
483 return CIMValue(String(""));
484 }
485 else
486 {
|
487 kumpf 1.5 return CIMValue(str);
|
488 kumpf 1.2 }
489 }
|
490 kumpf 1.5 }
491 break;
|
492 kumpf 1.1
|
493 kumpf 1.2 case VT_BOOL:
494 return ((*(VARIANT_BOOL *)pVal) ? CIMValue(true) : CIMValue(false));
495 break;
|
496 kumpf 1.1
|
497 kumpf 1.2 case VT_I1:
498 return (CIMValue((Sint8)*((char *)pVal)));
499 break;
|
500 kumpf 1.1
|
501 kumpf 1.2 case VT_UI1:
502 return (CIMValue((Uint8)*((BYTE *)pVal)));
503 break;
|
504 kumpf 1.1
|
505 kumpf 1.2 case VT_UI2:
506 return (CIMValue((Uint16)*((unsigned short *)pVal)));
507 break;
|
508 kumpf 1.1
|
509 kumpf 1.2 case VT_UI4:
510 return (CIMValue((Uint32)*((unsigned long *)pVal)));
511 break;
|
512 kumpf 1.1
|
513 kumpf 1.2 case VT_I8:
514 ////ATTN: Will this conversion work??
515 return (CIMValue((Sint64)*((_int64 *)pVal)));
516 break;
|
517 kumpf 1.1
|
518 kumpf 1.2 case VT_UI8:
519 ////ATTN: Will this conversion work??
520 return (CIMValue((Uint64)*((unsigned _int64 *)pVal)));
521 break;
|
522 kumpf 1.1
|
523 kumpf 1.2 case VT_INT:
524 if (sizeof(int) == 8)
525 {
526 return (CIMValue((Sint64)*((_int64 *)pVal)));
527 }
528 else
529 {
530 return (CIMValue((Sint32)*((long *)pVal)));
531 }
532 break;
|
533 kumpf 1.1
|
534 kumpf 1.2 case VT_UINT:
535 if (sizeof(int) == 8)
536 {
537 return (CIMValue((Uint64)*((unsigned _int64 *)pVal)));
538 }
539 else
540 {
541 return (CIMValue((Uint32)*((unsigned long *)pVal)));
542 }
543 break;
|
544 kumpf 1.1
|
545 kumpf 1.2 default:
546 throw TypeMismatchException();
547 break;
|
548 kumpf 1.1 };
549 }
550
551 /////////////////////////////////////////////////////////////////////////////
552 // WMIValue::getValue - converts a variant to a Pegasus CIMValue
553 //
554 // ///////////////////////////////////////////////////////////////////////////
555 CIMValue WMIValue::getValue(const CComVariant & vValue, const CIMTYPE Type)
556 {
557 bool isRef = isReferenceType(vValue.vt);
558 bool isArray = isArrayType(vValue.vt);
559
560 if (isArray)
561 {
562 return getArrayValue(vValue, Type);
563 }
564
565 VARTYPE vt = isRef ? vValue.vt ^ VT_BYREF : vValue.vt;
566
567 void *pValue;
568
569 kumpf 1.1 // just getting the address of the value field, type doesn't matter
|
570 kumpf 1.2 if (isRef)
|
571 kumpf 1.1 {
572 pValue = (void *)vValue.plVal;
573 }
574 else
575 {
576 pValue = (void *)&(vValue.lVal);
577 }
578
|
579 kumpf 1.2 return (getCIMValueFromVariant(vt, pValue, Type));
|
580 kumpf 1.1 }
581
582 /////////////////////////////////////////////////////////////////////////////
583 // WMICollector::getArrayValueAux - helper function for getArrayValue
584 //
585 // ///////////////////////////////////////////////////////////////////////////
586 template<class T>
587 CIMValue getArrayValueAux(LPSAFEARRAY psa, VARTYPE vt, const CIMTYPE Type, T*)
588 {
589 long index, numElements, i;
590 UINT uSize;
591 BYTE *pValue;
592 HRESULT hr;
593
594 Array <T> array;
595
596 index = psa->rgsabound[0].lLbound; // get the beginning index
597 numElements = psa->rgsabound[0].cElements; // elements in the array
598 uSize = SafeArrayGetElemsize(psa); // size of each element
599
600 pValue = new BYTE[uSize];
601 kumpf 1.1 void *pVal = (void *)pValue;
602
603 hr = SafeArrayGetVartype(psa, &vt);
604
|
605 kumpf 1.2 for (i = 0; ((i < numElements) && (SUCCEEDED(hr))); i++, index++)
|
606 kumpf 1.1 {
607 hr = SafeArrayGetElement(psa, &index, pVal);
608
609 if (SUCCEEDED(hr))
610 {
611 CIMValue cimValue = WMIValue(vt, pVal, Type);
612
613 T x;
614 cimValue.get(x);
615 array.append(x);
616 }
617 }
618
619 delete [] pValue;
620
621 if (SUCCEEDED(hr))
622 {
623 return CIMValue(array);
624 }
625 else
626 {
|
627 marek 1.10 PEG_TRACE((TRC_WMIPROVIDER,Tracer::LEVEL3,
628 "WMIValue::getArrayValueAux() - SafeArray result is %x", hr));
|
629 kumpf 1.3 throw CIMException(CIM_ERR_FAILED, "getArrayValueAux()");
|
630 kumpf 1.1 }
631 }
632
633 /////////////////////////////////////////////////////////////////////////////
634 // WMIValue::getArrayValue- converts a variant array to a
635 // Pegasus CIMValue of type array
636 // - uses all the SafeArray garbage
637 // NOTE:
638 // We are assuming one-dimensional arrays
639 //
640 // ///////////////////////////////////////////////////////////////////////////
641 CIMValue WMIValue::getArrayValue(const CComVariant& vValue, const CIMTYPE Type)
642 {
643
644 LPSAFEARRAY psa = NULL;
645 HRESULT hr;
646
647 CIMTYPE type = Type & (~CIM_FLAG_ARRAY);
648
649 if (!(isArrayType(vValue.vt)))
650 {
651 kumpf 1.1 return (getValue(vValue));
652 }
653
654 if (isReferenceType(vValue.vt))
655 {
656 psa = *V_ARRAYREF(&vValue);
657 }
658 else
659 {
660 psa = V_ARRAY(&vValue);
661 }
662
663 VARTYPE vt = VT_NULL;
664 CIMType cimType;
665
666 hr = SafeArrayGetVartype(psa, &vt);
667
|
668 kumpf 1.2 // check for Mof and Automation type discrepancy
|
669 kumpf 1.1 if (VT_I4 == vt)
670 {
671 if (CIM_UINT16 == type)
672 {
673 cimType = CIMTYPE_UINT16;
674 }
675 else if (CIM_UINT32 == type)
676 {
677 cimType = CIMTYPE_UINT32;
678 }
679 else
680 {
681 cimType = vartypeToCIMType(vt);
682 }
683 }
|
684 kumpf 1.2 else if (VT_I2 == vt)
685 {
686 if (CIM_SINT8 == type)
687 {
688 cimType = CIMTYPE_SINT8;
689 }
690 else if (CIM_CHAR16 == type)
691 {
692 cimType = CIMTYPE_CHAR16;
693 }
694 else
695 {
696 cimType = vartypeToCIMType(vt);
697 }
698 }
699 else if (VT_BSTR == vt)
700 {
701 if (CIM_SINT64 == type)
702 {
703 cimType = CIMTYPE_SINT64;
704 }
705 kumpf 1.2 else if (CIM_UINT64 == type)
706 {
707 cimType = CIMTYPE_UINT64;
708 }
709 else if (CIM_DATETIME == type)
710 {
711 cimType = CIMTYPE_DATETIME;
712 }
713 else
714 {
715 cimType = vartypeToCIMType(vt);
716 }
717 }
|
718 kumpf 1.1 else
719 {
720 cimType = vartypeToCIMType(vt);
721 }
722
723 if (SUCCEEDED(hr))
724 {
725 switch (cimType)
726 {
|
727 kumpf 1.2 case CIMTYPE_BOOLEAN:
728 return getArrayValueAux(psa, vt, type, (Boolean*)0);
|
729 kumpf 1.1
|
730 kumpf 1.2 case CIMTYPE_STRING:
731 return getArrayValueAux(psa, vt, type, (String*)0);
|
732 kumpf 1.1
|
733 kumpf 1.2 case CIMTYPE_CHAR16:
734 return getArrayValueAux(psa, vt, type, (Char16*)0);
|
735 kumpf 1.1
|
736 kumpf 1.2 case CIMTYPE_UINT8:
737 return getArrayValueAux(psa, vt, type, (Uint8*)0);
|
738 kumpf 1.1
|
739 kumpf 1.2 case CIMTYPE_UINT16:
740 return getArrayValueAux(psa, vt, type, (Uint16*)0);
|
741 kumpf 1.1
|
742 kumpf 1.2 case CIMTYPE_UINT32:
743 return getArrayValueAux(psa, vt, type, (Uint32*)0);
|
744 kumpf 1.1
|
745 kumpf 1.2 case CIMTYPE_UINT64:
746 return getArrayValueAux(psa, vt, type, (Uint64*)0);
|
747 kumpf 1.1
|
748 kumpf 1.2 case CIMTYPE_SINT8:
749 return getArrayValueAux(psa, vt, type, (Sint8*)0);
|
750 kumpf 1.1
|
751 kumpf 1.2 case CIMTYPE_SINT16:
752 return getArrayValueAux(psa, vt, type, (Sint16*)0);
|
753 kumpf 1.1
|
754 kumpf 1.2 case CIMTYPE_SINT32:
755 return getArrayValueAux(psa, vt, type, (Sint32*)0);
|
756 kumpf 1.1
|
757 kumpf 1.2 case CIMTYPE_SINT64:
758 return getArrayValueAux(psa, vt, type, (Sint64*)0);
|
759 kumpf 1.1
|
760 kumpf 1.2 case CIMTYPE_DATETIME:
761 return getArrayValueAux(psa, vt, type, (CIMDateTime*)0);
|
762 kumpf 1.1
|
763 kumpf 1.2 case CIMTYPE_REAL32:
764 return getArrayValueAux(psa, vt, type, (Real32*)0);
|
765 kumpf 1.1
|
766 kumpf 1.2 case CIMTYPE_REAL64:
767 return getArrayValueAux(psa, vt, type, (Real64*)0);
|
768 kumpf 1.1
|
769 kumpf 1.2 default:
770 break;
|
771 kumpf 1.1 }
772 }
773
774 // if we get here, we are in trouble...
|
775 kumpf 1.3 throw CIMException(CIM_ERR_FAILED, "getArrayValue()");
|
776 kumpf 1.1 }
777
778
779 VARIANT WMIValue::toVariant()
780 {
781 CComVariant cv;
782 VARIANT v;
783 cv.Detach(&v);
|
784 kumpf 1.5 cv.Clear();
|
785 kumpf 1.1 return v;
786
787 }
|
788 kumpf 1.2
789 /////////////////////////////////////////////////////////////////////////////
790 // WMIValue::getAsVariant - helper function to convert a CIM value
791 // to a variant including arrays
792 //
793 // ///////////////////////////////////////////////////////////////////////////
|
794 kumpf 1.3 void WMIValue::getAsVariant(CComVariant *var)
|
795 kumpf 1.2 {
796 HRESULT hr;
797 CMyString tmp;
|
798 kumpf 1.1
|
799 kumpf 1.2 SAFEARRAY * pSA = NULL;
800 SAFEARRAYBOUND rgsabound;
801
802 switch (CIMTypeToWMIType(getType()))
803 {
804 case CIM_BOOLEAN:
805 if (!isArray())
806 {
807 Boolean value;
808
809 var->vt = VT_BOOL;
810 get(value);
811 var->boolVal = value;
812 }
813 else
814 {
815 //creates the safearray
816 rgsabound.lLbound = 0;
817 rgsabound.cElements = getArraySize();
818 pSA = SafeArrayCreate(VT_BOOL, 1, &rgsabound);
819
820 kumpf 1.2 if (!pSA)
821 {
822 throw CIMException (CIM_ERR_FAILED);
823 }
824
825 Array<Boolean> arValue;
826 get(arValue);
827
828 //sets the values to the array
829 for (long i = 0; i < getArraySize(); i++)
830 {
831 if (hr = SafeArrayPutElement(pSA, &i, &arValue[i]))
832 {
833 SafeArrayDestroy(pSA);
834 throw CIMException(CIM_ERR_FAILED);
835 }
836 }
837
838 //sets the value to the variant
839 // by Jair - due to WMI coercion rules
840 // the array of boolean must be set as an array of uint8.
841 kumpf 1.2 var->vt = VT_ARRAY | VT_UI1;
842 var->parray = pSA;
|
843 kumpf 1.3
|
844 kumpf 1.2 }
845 break;
846
847 case CIM_SINT8:
848 if (!isArray())
849 {
850 Sint8 value;
851
852 var->vt = VT_I2;
853 get(value);
854 var->iVal = value;
855 }
856 else
857 {
858 //creates the safearray
859 rgsabound.lLbound = 0;
860 rgsabound.cElements = getArraySize();
861 pSA = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
862
863 if (!pSA)
864 {
865 kumpf 1.2 throw CIMException (CIM_ERR_FAILED);
866 }
867
868 Array<Sint8> arValue;
869 get(arValue);
870
871 //put the values to the array
872 for (long i = 0; i < getArraySize(); i++)
873 {
874 tmp.Format("%d", 21, arValue[i]);
875
876 CComVariant vOut;
877 vOut.vt = VT_BSTR;
878 vOut.bstrVal = tmp.Bstr();
879
880 if ((hr = SafeArrayPutElement(pSA, &i, vOut.bstrVal)))
881 {
882 SafeArrayDestroy(pSA);
883 throw CIMException (CIM_ERR_FAILED);
884 }
|
885 kumpf 1.5 vOut.Clear();
|
886 kumpf 1.2 }
887
888 // by Jair - due to WMI coercion rules
889 // the array of boolean must be set as an array of uint8.
890 var->vt = VT_ARRAY | VT_BSTR;
891 var->parray = pSA;
|
892 kumpf 1.3
|
893 kumpf 1.2 }
894 break;
895
896 case CIM_UINT8:
897 if (!isArray())
898 {
899 Uint8 value;
900
901 var->vt = VT_UI1;
902 get(value);
903 var->bVal = value;
904 }
905 else
906 {
907 //create the safearray
908 rgsabound.lLbound = 0;
909 rgsabound.cElements = getArraySize();
910 pSA = SafeArrayCreate(VT_UI1, 1, &rgsabound);
911
912 if (!pSA)
913 {
914 kumpf 1.2 throw CIMException(CIM_ERR_FAILED);
915 }
916
917 Array<Uint8> arValue;
918 get(arValue);
919
920 //put the values into the safearray
921 for (long i = 0; i < getArraySize(); i++)
922 {
923 if ((hr = SafeArrayPutElement(pSA, &i, &arValue[i])))
924 {
925 SafeArrayDestroy(pSA);
926 throw CIMException(CIM_ERR_FAILED);
927 }
928 }
929
930 //sets the value to the variant
931 var->vt = VT_ARRAY | VT_UI1;
932 var->parray = pSA;
|
933 kumpf 1.3
|
934 kumpf 1.2 }
935 break;
936
937 case CIM_SINT16:
938 if (!isArray ())
939 {
940 Sint16 value;
941
942 var->vt = VT_I2;
943 get(value);
944 var->iVal = value;
945 }
946 else
947 {
948 rgsabound.lLbound = 0;
949 rgsabound.cElements = getArraySize();
950 pSA = SafeArrayCreate(VT_I2, 1, &rgsabound);
951
952 if (!pSA)
953 {
954 throw CIMException (CIM_ERR_FAILED);
955 kumpf 1.2 }
956
957 Array<Sint16> arValue;
958 get(arValue);
959
960 for (long i = 0; i < getArraySize(); i++)
961 {
962 if ((hr = SafeArrayPutElement(pSA, &i, &arValue[i])))
963 {
964 SafeArrayDestroy(pSA);
965 throw CIMException(CIM_ERR_FAILED);
966 }
967 }
968
969 var->vt = VT_ARRAY | VT_I2;
970 var->parray = pSA;
|
971 kumpf 1.3
|
972 kumpf 1.2 }
973 break;
974
975 case CIM_UINT16:
976 if (!isArray())
977 {
978 Uint16 value;
979
980 var->vt = VT_I4;
981 get(value);
982 var->lVal = value;
983 }
984 else
985 {
986 rgsabound.lLbound = 0;
987 rgsabound.cElements = getArraySize();
988 pSA = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
989
990 if (!pSA)
991 {
992 throw CIMException (CIM_ERR_FAILED);
993 kumpf 1.2 }
994
995 Array<Uint16> arValue;
996 get(arValue);
997
998 for (long i = 0; i < getArraySize(); i++)
999 {
1000 tmp.Format("%u", 21, arValue[i]);
1001
1002 CComVariant vOut;
1003 vOut.vt = VT_BSTR;
1004 vOut.bstrVal = tmp.Bstr();
1005
1006 if ((hr = SafeArrayPutElement(pSA, &i, vOut.bstrVal)))
1007 {
1008 SafeArrayDestroy(pSA);
1009 throw CIMException(CIM_ERR_FAILED);
1010 }
|
1011 kumpf 1.5 vOut.Clear();
|
1012 kumpf 1.2 }
1013
1014 var->vt = VT_ARRAY | VT_BSTR;
1015 var->parray = pSA;
|
1016 kumpf 1.3
|
1017 kumpf 1.2 }
1018 break;
1019
1020 case CIM_SINT32:
1021 if (!isArray())
1022 {
1023 Sint32 value;
1024
1025 var->vt = VT_I4;
1026 get(value);
1027 var->lVal = value;
1028 }
1029 else
1030 {
1031 rgsabound.lLbound = 0;
1032 rgsabound.cElements = getArraySize();
1033 pSA = SafeArrayCreate(VT_I4, 1, &rgsabound);
1034
1035 if (!pSA)
1036 {
1037 throw CIMException (CIM_ERR_FAILED);
1038 kumpf 1.2 }
1039
1040 Array<Sint32> arValue;
1041 get(arValue);
1042
1043 for (long i = 0; i < getArraySize(); i++)
1044 {
1045 if ((hr = SafeArrayPutElement(pSA, &i, &arValue[i])))
1046 {
1047 SafeArrayDestroy(pSA);
1048 throw CIMException(CIM_ERR_FAILED);
1049 }
1050 }
1051
1052 var->vt = VT_ARRAY | VT_I4;
1053 var->parray = pSA;
|
1054 kumpf 1.3
|
1055 kumpf 1.2 }
1056 break;
1057
1058 case CIM_UINT32:
1059 if (!isArray ())
1060 {
1061 Uint32 value;
1062
1063 var->vt = VT_I4;
1064 get(value);
1065 var->lVal = value;
1066 }
1067 else
1068 {
1069 rgsabound.lLbound = 0;
1070 rgsabound.cElements = getArraySize();
1071 pSA = SafeArrayCreate(VT_I4, 1, &rgsabound);
1072
1073 if (!pSA)
1074 {
1075 throw CIMException (CIM_ERR_FAILED);
1076 kumpf 1.2 }
1077
1078 Array<Uint32> arValue;
1079 get(arValue);
1080
1081 for (long i = 0; i < getArraySize(); i++)
1082 {
1083 if ((hr = SafeArrayPutElement(pSA, &i, &arValue[i])))
1084 {
1085 SafeArrayDestroy(pSA);
1086 throw CIMException(CIM_ERR_FAILED);
1087 }
1088 }
1089
1090 var->vt = VT_ARRAY | VT_I4;
1091 var->parray = pSA;
|
1092 kumpf 1.3
|
1093 kumpf 1.2 }
1094 break;
1095
1096 case CIM_UINT64:
1097 if (!isArray())
1098 {
1099 Uint64 value;
1100
1101 get(value);
1102 tmp.Format("%I64u", 21, value);
1103 var->vt = VT_BSTR;
1104 var->bstrVal = tmp.Bstr();
1105 }
1106 else
1107 {
1108 rgsabound.lLbound = 0;
1109 rgsabound.cElements = getArraySize();
1110 pSA = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
1111
1112 if (!pSA)
1113 {
1114 kumpf 1.2 throw CIMException(CIM_ERR_FAILED);
1115 }
1116
1117 Array<Uint64> arValue;
1118 get(arValue);
1119
1120 for (long i = 0; i < getArraySize(); i++)
1121 {
1122 tmp.Format("%I64u", 21, arValue[i]);
1123
1124 CComVariant vOut;
1125 vOut.vt = VT_BSTR;
1126 vOut.bstrVal = tmp.Bstr();
1127
1128 if ((hr = SafeArrayPutElement(pSA, &i, vOut.bstrVal)))
1129 {
1130 SafeArrayDestroy(pSA);
1131 throw CIMException (CIM_ERR_FAILED);
1132 }
|
1133 kumpf 1.5 vOut.Clear();
|
1134 kumpf 1.2 }
1135
1136 var->vt = VT_ARRAY | VT_BSTR;
1137 var->parray = pSA;
|
1138 kumpf 1.3
|
1139 kumpf 1.2 }
1140 break;
1141
1142 case CIM_SINT64:
1143 if (!isArray ())
1144 {
1145 Sint64 value;
1146
1147 get(value);
1148 tmp.Format("%I64d", 21, value);
1149 var->vt = VT_BSTR;
1150 var->bstrVal = tmp.Bstr();
1151 }
1152 else
1153 {
1154 rgsabound.lLbound = 0;
1155 rgsabound.cElements = getArraySize();
1156 pSA = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
1157
1158 if (!pSA)
1159 {
1160 kumpf 1.2 throw CIMException (CIM_ERR_FAILED);
1161 }
1162
1163 Array<Sint64> arValue;
1164 get(arValue);
1165
1166 for (long i = 0; i < getArraySize(); i++)
1167 {
1168 CComVariant vOut;
1169
1170 tmp.Format("%I64d", 21, arValue[i]);
1171 vOut.vt = VT_BSTR;
1172 vOut.bstrVal = tmp.Bstr();
1173
1174 if ((hr = SafeArrayPutElement(pSA, &i, vOut.bstrVal)))
1175 {
1176 SafeArrayDestroy(pSA);
1177 throw CIMException(CIM_ERR_FAILED);
1178 }
|
1179 kumpf 1.5 vOut.Clear();
|
1180 kumpf 1.2 }
1181
1182 var->vt = VT_ARRAY | VT_BSTR;
1183 var->parray = pSA;
|
1184 kumpf 1.3
|
1185 kumpf 1.2 }
1186 break;
1187
1188 case CIM_REAL32:
1189 if (!isArray ())
1190 {
1191 Real32 value;
1192
1193 var->vt = VT_R4;
1194 get(value);
1195 var->fltVal = value;
1196 }
1197 else
1198 {
1199 rgsabound.lLbound = 0;
1200 rgsabound.cElements = getArraySize();
1201 pSA = SafeArrayCreate(VT_R4, 1, &rgsabound);
1202
1203 if (!pSA)
1204 {
1205 throw CIMException (CIM_ERR_FAILED);
1206 kumpf 1.2 }
1207
1208 Array<Real32> arValue;
1209 get(arValue);
1210
1211 for (long i = 0; i < getArraySize(); i++)
1212 {
1213 if ((hr = SafeArrayPutElement(pSA, &i, &arValue[i])))
1214 {
1215 SafeArrayDestroy(pSA);
1216 throw CIMException(CIM_ERR_FAILED);
1217 }
1218 }
1219
1220 var->vt = VT_ARRAY | VT_R4;
1221 var->parray = pSA;
|
1222 kumpf 1.3
|
1223 kumpf 1.2 }
1224 break;
1225
1226 case CIM_REAL64:
1227 if (!isArray ())
1228 {
1229 Real64 value;
1230
1231 var->vt = VT_R8;
1232 get(value);
1233 var->dblVal = value;
1234 }
1235 else
1236 {
1237 rgsabound.lLbound = 0;
1238 rgsabound.cElements = getArraySize();
1239 pSA = SafeArrayCreate(VT_R8, 1, &rgsabound);
1240
1241 if (!pSA)
1242 {
1243 throw CIMException (CIM_ERR_FAILED);
1244 kumpf 1.2 }
1245
1246 Array<Real64> arValue;
1247 get(arValue);
1248
1249 for (long i = 0; i < getArraySize(); i++)
1250 {
1251 if ((hr = SafeArrayPutElement(pSA, &i, &arValue[i])))
1252 {
1253 SafeArrayDestroy(pSA);
1254 throw CIMException(CIM_ERR_FAILED);
1255 }
1256 }
1257
1258 var->vt = VT_ARRAY | VT_R8;
1259 var->parray = pSA;
|
1260 kumpf 1.3
|
1261 kumpf 1.2 }
1262 break;
1263
1264 case CIM_CHAR16:
1265 if (!isArray ())
1266 {
1267 Char16 value;
1268
1269 var->vt = VT_I2;
1270 get(value);
1271 var->iVal = value;
1272 }
1273 else
1274 {
1275 rgsabound.lLbound = 0;
1276 rgsabound.cElements = getArraySize();
1277 pSA = SafeArrayCreate(VT_I2, 1, &rgsabound);
1278
1279 if (!pSA)
1280 {
1281 throw CIMException (CIM_ERR_FAILED);
1282 kumpf 1.2 }
1283
1284 Array<Char16> arValue;
1285 get(arValue);
1286
1287 for (long i = 0; i < getArraySize(); i++)
1288 {
1289 if ((hr = SafeArrayPutElement(pSA, &i, &arValue[i])))
1290 {
1291 SafeArrayDestroy(pSA);
1292 throw CIMException(CIM_ERR_FAILED);
1293 }
1294 }
1295
1296 var->vt = VT_ARRAY | VT_I2;
1297 var->parray = pSA;
|
1298 kumpf 1.3
|
1299 kumpf 1.2 }
1300 break;
1301
1302 case CIM_STRING:
1303 if (!isArray())
1304 {
1305 String data;
1306
1307 get (data);
1308 var->vt = VT_BSTR;
|
1309 mateus.baur 1.8 var->bstrVal = SysAllocString((const WCHAR *)data.getChar16Data());
|
1310 kumpf 1.2 }
1311 else
1312 {
1313 // creates an array of BSTRs
1314 rgsabound.lLbound = 0;
1315 rgsabound.cElements = getArraySize();
1316 pSA = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
1317
1318 if (!pSA)
1319 {
1320 throw CIMException (CIM_ERR_FAILED);
1321 }
1322
1323 Array<String> arValue;
1324 get(arValue);
1325
1326 for (long i = 0; i < getArraySize(); i++)
1327 {
1328 CComVariant vOut;
1329
1330 vOut.vt = VT_BSTR; // set type
|
1331 mateus.baur 1.8 vOut.bstrVal = SysAllocString((const WCHAR *)arValue[i].getChar16Data());
|
1332 kumpf 1.2
1333 if ((hr = SafeArrayPutElement(pSA, &i, vOut.bstrVal)))
1334 {
1335 SafeArrayDestroy(pSA);
1336 throw CIMException(CIM_ERR_FAILED);
1337 }
|
1338 kumpf 1.5 vOut.Clear();
|
1339 kumpf 1.2 }
1340
1341 var->vt = VT_ARRAY | VT_BSTR;
1342 var->parray = pSA;
|
1343 kumpf 1.3
|
1344 kumpf 1.2 }
1345 break;
1346
1347 case CIM_DATETIME:
1348 if(!isArray())
1349 {
1350 CIMDateTime value;
1351
1352 get(value);
1353 tmp = value.toString();
1354 var->vt = VT_BSTR;
1355 var->bstrVal = tmp.Bstr();
1356 }
1357 else
1358 {
1359 // creates an array of BSTRs
1360 rgsabound.lLbound = 0;
1361 rgsabound.cElements = getArraySize();
1362 pSA = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
1363
1364 if (!pSA)
1365 kumpf 1.2 {
1366 throw CIMException (CIM_ERR_FAILED);
1367 }
1368
1369 Array<CIMDateTime> arValue;
1370 get(arValue);
1371
1372 for (long i = 0; i < getArraySize(); i++)
1373 {
1374 CComVariant vOut;
1375
1376 tmp = arValue[i].toString();
1377 vOut.vt = VT_BSTR; // set type
1378 vOut.bstrVal = tmp.Bstr();
1379
1380 if ((hr = SafeArrayPutElement(pSA, &i, vOut.bstrVal)))
1381 {
1382 SafeArrayDestroy(pSA);
1383 throw CIMException(CIM_ERR_FAILED);
1384 }
|
1385 kumpf 1.5 vOut.Clear();
|
1386 kumpf 1.2 }
1387
1388 var->vt = VT_ARRAY | VT_BSTR;
1389 var->parray = pSA;
1390 }
1391 break;
1392
1393 case CIM_REFERENCE:
1394 {
1395 CIMObjectPath value;
1396 String sObjName;
1397
1398 get(value);
1399 sObjName = value.toString();
1400
1401 // Check if has =R".." for a reference instance and
1402 // if so, remove the R
1403 Uint32 pos = sObjName.find(qString(Q_REF_KEY));
1404 bool bHaveReference = (PEG_NOT_FOUND != pos);
1405
1406 if (bHaveReference)
1407 kumpf 1.2 {
1408 while (PEG_NOT_FOUND != pos)
1409 {
1410 sObjName.remove(pos + 1, 1); //removing R
1411 pos = sObjName.find(qString(Q_REF_KEY));
1412 }
1413 }
1414 tmp = sObjName;
1415
1416 var->vt = VT_BSTR;
1417 var->bstrVal = tmp.Bstr();
1418 }
1419 break;
1420
1421 case CIM_OBJECT:
1422 case CIM_FLAG_ARRAY:
1423 case CIM_EMPTY:
1424 case CIM_ILLEGAL:
1425 default:
1426 throw TypeMismatchException();
1427
1428 kumpf 1.2 break;
1429 }
1430 }
|
1431 kumpf 1.1
1432 PEGASUS_NAMESPACE_END
|
Return to
WMIValue.cpp
CVS log
Up to [Pegasus] / pegasus / src / WMIMapper / WMIProvider