1 r.kieninger 1.1 //%LICENSE////////////////////////////////////////////////////////////////
2 //
3 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 r.kieninger 1.1 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //////////////////////////////////////////////////////////////////////////
29 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include "CIMResponseData.h"
|
33 marek 1.2.2.5 #include <Pegasus/Common/Tracer.h>
34 #include <Pegasus/Common/XmlWriter.h>
35 #include <Pegasus/Common/SCMOXmlWriter.h>
36 #include <Pegasus/Common/XmlReader.h>
|
37 marek 1.2.2.15 #include <Pegasus/Common/CIMInternalXmlEncoder.h>
38 #include <Pegasus/Common/SCMOInternalXmlEncoder.h>
|
39 r.kieninger 1.1
40 PEGASUS_USING_STD;
41
42 PEGASUS_NAMESPACE_BEGIN
43
|
44 marek 1.2.2.5 // C++ objects interface handling
45
46 // Instance Names handling
47 Array<CIMObjectPath>& CIMResponseData::getInstanceNames()
48 {
49 PEGASUS_DEBUG_ASSERT(
50 (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
51 _resolveToCIM();
|
52 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding==RESP_ENC_CIM || _encoding == 0);
|
53 marek 1.2.2.5 return _instanceNames;
54 }
55
56 // Instance handling
57 CIMInstance& CIMResponseData::getInstance()
58 {
59 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
60 _resolveToCIM();
|
61 marek 1.2.2.15 if (0 == _instances.size())
62 {
63 _instances.append(CIMInstance());
64 }
|
65 marek 1.2.2.5 return _instances[0];
66 }
67
68 // Instances handling
69 Array<CIMInstance>& CIMResponseData::getInstances()
70 {
71 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);
72 _resolveToCIM();
73 return _instances;
74 }
75
76 // Objects handling
77 Array<CIMObject>& CIMResponseData::getObjects()
78 {
79 PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);
80 _resolveToCIM();
81 return _objects;
82 }
83
84 // SCMO representation, single instance stored as one element array
85 // object paths are represented as SCMOInstance
86 marek 1.2.2.5 Array<SCMOInstance>& CIMResponseData::getSCMO()
87 {
88 _resolveToSCMO();
89 return _scmoInstances;
90 }
91
|
92 marek 1.2.2.6 void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)
93 {
|
94 marek 1.2.2.8 _scmoInstances=x;
|
95 marek 1.2.2.6 _encoding |= RESP_ENC_SCMO;
96 }
97
98
|
99 marek 1.2.2.5 // Binary data is just a data stream
100 Array<Uint8>& CIMResponseData::getBinary()
101 {
|
102 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_BINARY || _encoding == 0);
|
103 marek 1.2.2.5 return _binaryData;
104 }
105
106 bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)
|
107 r.kieninger 1.2.2.1 {
108 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
109 marek 1.2.2.5 "CIMResponseData::setBinary");
|
110 r.kieninger 1.2.2.1
111 if (hasLen)
112 {
113 if (!in.getUint8A(_binaryData))
114 {
115 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
116 "Failed to get binary object path data!");
117 PEG_METHOD_EXIT();
118 return false;
119 }
120 }
121 else
122 {
123 size_t remainingDataLength = in.capacity() - in.size();
124 _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);
125 }
|
126 marek 1.2.2.5 _encoding |= RESP_ENC_BINARY;
|
127 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
128 return true;
|
129 marek 1.2.2.5 }
|
130 r.kieninger 1.2.2.1
|
131 marek 1.2.2.5 bool CIMResponseData::setXml(CIMBuffer& in)
|
132 r.kieninger 1.2.2.1 {
|
133 marek 1.2.2.15 switch (_dataType)
|
134 r.kieninger 1.2.2.1 {
|
135 marek 1.2.2.15 case RESP_INSTANCE:
|
136 r.kieninger 1.2.2.1 {
|
137 marek 1.2.2.15 Array<Sint8> inst;
|
138 marek 1.2.2.5 Array<Sint8> ref;
139 CIMNamespaceName ns;
140 String host;
|
141 marek 1.2.2.15 if (!in.getSint8A(inst))
142 {
143 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
144 "Failed to get XML instance data!");
145 return false;
146 }
147 _instanceData.insert(0,inst);
|
148 marek 1.2.2.5 if (!in.getSint8A(ref))
149 {
150 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
|
151 marek 1.2.2.15 "Failed to get XML instance data (reference)!");
|
152 marek 1.2.2.5 return false;
153 }
|
154 marek 1.2.2.15 _referencesData.insert(0,ref);
|
155 marek 1.2.2.5 if (!in.getString(host))
156 {
157 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
158 "Failed to get XML instance data (host)!");
159 return false;
160 }
|
161 marek 1.2.2.15 _hostsData.insert(0,host);
|
162 marek 1.2.2.5 if (!in.getNamespaceName(ns))
163 {
164 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
165 "Failed to get XML instance data (namespace)!");
166 return false;
167 }
|
168 marek 1.2.2.15 _nameSpacesData.insert(0,ns);
169 break;
170 }
171 case RESP_INSTANCES:
172 {
173 Uint32 count;
174 if (!in.getUint32(count))
175 {
176 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
177 "Failed to get XML instance data (number of instance)!");
178 return false;
179 }
180 for (Uint32 i = 0; i < count; i++)
181 {
182 Array<Sint8> inst;
183 Array<Sint8> ref;
184 CIMNamespaceName ns;
185 String host;
186 if (!in.getSint8A(inst))
187 {
188 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
189 marek 1.2.2.15 "Failed to get XML instance data (instances)!");
190 return false;
191 }
192 if (!in.getSint8A(ref))
193 {
194 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
195 "Failed to get XML instance data (references)!");
196 return false;
197 }
198 if (!in.getString(host))
199 {
200 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
201 "Failed to get XML instance data (host)!");
202 return false;
203 }
204 if (!in.getNamespaceName(ns))
205 {
206 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
207 "Failed to get XML instance data (namespace)!");
208 return false;
209 }
210 marek 1.2.2.15 _instanceData.append(inst);
211 _referencesData.append(ref);
212 _hostsData.append(host);
213 _nameSpacesData.append(ns);
214 }
215 break;
216 }
217 case RESP_OBJECTS:
218 {
219 Uint32 count;
220 if (!in.getUint32(count))
221 {
222 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
223 "Failed to get XML object data (number of objects)!");
224 return false;
225 }
226 for (Uint32 i = 0; i < count; i++)
227 {
228 Array<Sint8> obj;
229 Array<Sint8> ref;
230 CIMNamespaceName ns;
231 marek 1.2.2.15 String host;
232 if (!in.getSint8A(obj))
233 {
234 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
235 "Failed to get XML object data (object)!");
236 return false;
237 }
238 if (!in.getSint8A(ref))
239 {
240 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
241 "Failed to get XML object data (reference)!");
242 return false;
243 }
244 if (!in.getString(host))
245 {
246 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
247 "Failed to get XML object data (host)!");
248 return false;
249 }
250 if (!in.getNamespaceName(ns))
251 {
252 marek 1.2.2.15 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
253 "Failed to get XML object data (namespace)!");
254 return false;
255 }
256 _instanceData.append(obj);
257 _referencesData.append(ref);
258 _hostsData.append(host);
259 _nameSpacesData.append(ns);
260 }
261 break;
262 }
263 // internal xml encoding of instance names and object paths not
264 // done today
265 case RESP_INSTNAMES:
266 case RESP_OBJECTPATHS:
267 default:
268 {
269 PEGASUS_DEBUG_ASSERT(false);
|
270 r.kieninger 1.2.2.1 }
271 }
|
272 marek 1.2.2.5 _encoding |= RESP_ENC_XML;
|
273 r.kieninger 1.2.2.1 return true;
|
274 marek 1.2.2.5 }
275
276 // function used by OperationAggregator to aggregate response data in a
277 // single ResponseData object
278 void CIMResponseData::appendResponseData(const CIMResponseData & x)
279 {
280 // as the Messages set the data types, this should be impossible
281 PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
282 _encoding |= x._encoding;
283
284 // add all binary data
285 _binaryData.appendArray(x._binaryData);
|
286 r.kieninger 1.2.2.1
|
287 marek 1.2.2.5 // add all the C++ stuff
288 _instanceNames.appendArray(x._instanceNames);
289 _instances.appendArray(x._instances);
290 _objects.appendArray(x._objects);
|
291 r.kieninger 1.2.2.1
|
292 marek 1.2.2.5 // add the SCMO instances
293 _scmoInstances.appendArray(x._scmoInstances);
|
294 r.kieninger 1.2.2.1
|
295 marek 1.2.2.5 // add Xml encodings too
296 _referencesData.appendArray(x._referencesData);
297 _instanceData.appendArray(x._instanceData);
298 _hostsData.appendArray(x._hostsData);
299 _nameSpacesData.appendArray(x._nameSpacesData);
300 }
|
301 r.kieninger 1.2.2.1
|
302 marek 1.2.2.5 // Encoding responses into output format
303 void CIMResponseData::encodeBinaryResponse(CIMBuffer& out)
|
304 r.kieninger 1.2.2.1 {
305 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
306 marek 1.2.2.5 "CIMResponseData::encodeBinaryResponse");
|
307 r.kieninger 1.2.2.1
|
308 marek 1.2.2.5 // Need to do a complete job here by transferring all contained data
309 // into binary format and handing it out in the CIMBuffer
310 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
311 r.kieninger 1.2.2.1 {
|
312 marek 1.2.2.5 // Binary does NOT need a marker as it consists of C++ and SCMO
|
313 r.kieninger 1.2.2.1 const Array<Uint8>& data = _binaryData;
314 out.putBytes(data.getData(), data.size());
315 }
|
316 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
317 r.kieninger 1.2.2.1 {
|
318 r.kieninger 1.2.2.16 out.putTypeMarker(BIN_TYPE_MARKER_CPPD);
|
319 marek 1.2.2.5 switch (_dataType)
|
320 r.kieninger 1.2.2.1 {
|
321 marek 1.2.2.5 case RESP_INSTNAMES:
322 {
|
323 thilo.boehm 1.2.2.19 out.putObjectPathA(_instanceNames);
|
324 marek 1.2.2.5 break;
325 }
326 case RESP_INSTANCE:
327 {
|
328 marek 1.2.2.15 if (0 == _instances.size())
|
329 marek 1.2.2.5 {
|
330 marek 1.2.2.15 _instances.append(CIMInstance());
|
331 marek 1.2.2.5 }
|
332 marek 1.2.2.15 out.putInstance(_instances[0], false, false);
|
333 marek 1.2.2.5 break;
334 }
335 case RESP_INSTANCES:
336 {
337 out.putInstanceA(_instances, false);
338 break;
339 }
340 case RESP_OBJECTS:
341 {
342 out.putObjectA(_objects);
343 break;
344 }
345 case RESP_OBJECTPATHS:
346 {
|
347 thilo.boehm 1.2.2.19 out.putObjectPathA(_instanceNames);
|
348 marek 1.2.2.5 break;
349 }
350 default:
351 {
|
352 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
353 marek 1.2.2.5 }
|
354 r.kieninger 1.2.2.1 }
355 }
|
356 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
357 r.kieninger 1.2.2.1 {
|
358 r.kieninger 1.2.2.16 out.putTypeMarker(BIN_TYPE_MARKER_SCMO);
359 out.putSCMOInstanceA(_scmoInstances);
|
360 marek 1.2.2.5 }
361 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
362 r.kieninger 1.2.2.1 {
|
363 marek 1.2.2.5 // This actually should not happen following general code logic
|
364 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
365 r.kieninger 1.2.2.1 }
366
367 PEG_METHOD_EXIT();
368 }
369
|
370 marek 1.2.2.13 void CIMResponseData::completeNamespace(const SCMOInstance * x)
|
371 marek 1.2.2.12 {
|
372 marek 1.2.2.13 const char * ns;
373 Uint64 len;
374 ns = x->getNameSpace_l(len);
|
375 marek 1.2.2.12 // Both internal XML as well as binary always contain a namespace
376 // don't have to do anything for those two encodings
|
377 r.kieninger 1.2.2.18 if ((RESP_ENC_BINARY == (_encoding&RESP_ENC_BINARY)) && (len != 0))
378 {
379 _defaultNamespace = (char*)malloc(len+1);
380 if (0==_defaultNamespace)
381 {
382 return;
383 }
384 memcpy(_defaultNamespace, ns, len+1);
385 _defaultNamespaceLen = len;
386 }
387
388
|
389 marek 1.2.2.12 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
390 {
391 CIMNamespaceName nsName(ns);
392 switch (_dataType)
393 {
394 case RESP_INSTANCE:
395 {
|
396 marek 1.2.2.15 if (_instances.size() > 0)
397 {
|
398 marek 1.2.2.12 const CIMInstance& inst = _instances[0];
399 CIMObjectPath& p =
400 const_cast<CIMObjectPath&>(inst.getPath());
401 if (p.getNameSpace().isNull())
402 {
403 p.setNameSpace(nsName);
404 }
|
405 marek 1.2.2.15 }
|
406 marek 1.2.2.12 }
407 case RESP_INSTANCES:
408 {
409 for (Uint32 j = 0, n = _instances.size(); j < n; j++)
410 {
411 const CIMInstance& inst = _instances[j];
412 CIMObjectPath& p =
413 const_cast<CIMObjectPath&>(inst.getPath());
414 if (p.getNameSpace().isNull())
415 {
416 p.setNameSpace(nsName);
417 }
418 }
419 break;
420 }
421 case RESP_OBJECTS:
422 {
423 for (Uint32 j = 0, n = _objects.size(); j < n; j++)
424 {
425 const CIMObject& object = _objects[j];
426 CIMObjectPath& p =
427 marek 1.2.2.12 const_cast<CIMObjectPath&>(object.getPath());
428 if (p.getNameSpace().isNull())
429 {
430 p.setNameSpace(nsName);
431 }
432 }
433 break;
434 }
435 case RESP_INSTNAMES:
436 case RESP_OBJECTPATHS:
437 {
438 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
439 {
440 CIMObjectPath& p = _instanceNames[j];
441 if (p.getNameSpace().isNull())
442 {
443 p.setNameSpace(nsName);
444 }
445 }
446 break;
447 }
448 marek 1.2.2.12 default:
449 {
450 PEGASUS_DEBUG_ASSERT(false);
451 }
452 }
453 }
454 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
455 {
456 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
457 {
458 SCMOInstance & scmoInst=_scmoInstances[j];
459 if (0 == scmoInst.getNameSpace())
460 {
461 scmoInst.setNameSpace_l(ns,len);
462 }
463 }
464 }
465 }
466
467
|
468 marek 1.2.2.9 void CIMResponseData::completeHostNameAndNamespace(
469 const String & hn,
470 const CIMNamespaceName & ns)
471 {
|
472 r.kieninger 1.2.2.17 // Only perform this operation when we have instantiated data.
473 // Do nothing for binary and internal xml data.
|
474 marek 1.2.2.9
475 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
476 {
477 switch (_dataType)
478 {
479 case RESP_OBJECTS:
480 {
481 for (Uint32 j = 0, n = _objects.size(); j < n; j++)
482 {
483 const CIMObject& object = _objects[j];
484 CIMObjectPath& p =
485 const_cast<CIMObjectPath&>(object.getPath());
486 if (p.getHost().size()==0)
487 {
488 p.setHost(hn);
489 }
490 if (p.getNameSpace().isNull())
491 {
492 p.setNameSpace(ns);
493 }
494 }
495 marek 1.2.2.9 break;
496 }
497 case RESP_OBJECTPATHS:
498 {
499 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
500 {
501 CIMObjectPath& p = _instanceNames[j];
502 if (p.getHost().size() == 0)
503 p.setHost(hn);
504 if (p.getNameSpace().isNull())
505 p.setNameSpace(ns);
506 }
507 break;
508 }
509 default:
510 {
511 PEGASUS_DEBUG_ASSERT(false);
512 }
513 }
514 }
515 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
516 marek 1.2.2.9 {
517 CString hnCString=hn.getCString();
518 const char* hnChars = hnCString;
519 Uint32 hnLen = strlen(hnChars);
520 CString nsCString=ns.getString().getCString();
521 const char* nsChars=nsCString;
522 Uint32 nsLen = strlen(nsChars);
523 switch (_dataType)
524 {
525 case RESP_OBJECTS:
526 case RESP_OBJECTPATHS:
527 {
528 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
529 {
530 SCMOInstance & scmoInst=_scmoInstances[j];
531 if (0 == scmoInst.getHostName())
532 {
533 scmoInst.setHostName_l(hnChars,hnLen);
534 }
535 if (0 == scmoInst.getNameSpace())
536 {
537 marek 1.2.2.9 scmoInst.setNameSpace_l(nsChars,nsLen);
538 }
539 }
540 break;
541 }
542 default:
543 {
544 PEGASUS_DEBUG_ASSERT(false);
545 }
546 }
547 }
548 }
549
|
550 marek 1.2.2.5 void CIMResponseData::encodeXmlResponse(Buffer& out)
|
551 r.kieninger 1.2.2.1 {
|
552 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL3,
553 "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)\n",
|
554 marek 1.2.2.5 _encoding,
|
555 marek 1.2.2.10 _dataType));
|
556 r.kieninger 1.2.2.1
|
557 r.kieninger 1.2.2.18 // already existing Internal XML does not need to be encoded further
558 // binary input is not actually impossible here, but we have an established
559 // fallback
560 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
561 {
562 _resolveBinary();
563 }
564
|
565 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
566 r.kieninger 1.2.2.1 {
|
567 marek 1.2.2.5 switch (_dataType)
|
568 r.kieninger 1.2.2.1 {
|
569 marek 1.2.2.5 case RESP_INSTANCE:
570 {
|
571 marek 1.2.2.15 const Array<ArraySint8>& a = _instanceData;
572 out.append((char*)a[0].getData(), a[0].size() - 1);
|
573 marek 1.2.2.5 break;
574 }
575 case RESP_INSTANCES:
576 {
577 const Array<ArraySint8>& a = _instanceData;
578 const Array<ArraySint8>& b = _referencesData;
|
579 r.kieninger 1.2.2.1
|
580 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
581 {
582 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
583 out.append((char*)b[i].getData(), b[i].size() - 1);
584 out.append((char*)a[i].getData(), a[i].size() - 1);
585 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
586 }
587 break;
588 }
589 case RESP_OBJECTS:
|
590 r.kieninger 1.2.2.1 {
|
591 marek 1.2.2.5 const Array<ArraySint8>& a = _instanceData;
592 const Array<ArraySint8>& b = _referencesData;
|
593 r.kieninger 1.2.2.1
|
594 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
595 {
596 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
597 out.append((char*)b[i].getData(), b[i].size() - 1);
598 out.append((char*)a[i].getData(), a[i].size() - 1);
599 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
600 }
601 break;
602 }
|
603 marek 1.2.2.15 // internal xml encoding of instance names and object paths not
604 // done today
605 case RESP_INSTNAMES:
|
606 marek 1.2.2.5 case RESP_OBJECTPATHS:
607 default:
608 {
|
609 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
610 r.kieninger 1.2.2.1 }
611 }
612 }
613
|
614 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
615 r.kieninger 1.2.2.1 {
|
616 marek 1.2.2.5 switch (_dataType)
|
617 r.kieninger 1.2.2.1 {
|
618 marek 1.2.2.5 case RESP_INSTNAMES:
619 {
620 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
621 {
622 XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);
623 }
624 break;
625 }
626 case RESP_INSTANCE:
627 {
|
628 marek 1.2.2.15 if (_instances.size() > 0)
|
629 marek 1.2.2.5 {
630 XmlWriter::appendInstanceElement(out, _instances[0]);
631 }
632 break;
633 }
634 case RESP_INSTANCES:
635 {
636 for (Uint32 i = 0, n = _instances.size(); i < n; i++)
637 {
638 XmlWriter::appendValueNamedInstanceElement(
639 out, _instances[i]);
640 }
641 break;
642 }
643 case RESP_OBJECTS:
644 {
645 for (Uint32 i = 0; i < _objects.size(); i++)
646 {
647 XmlWriter::appendValueObjectWithPathElement(
648 out,
649 _objects[i]);
650 marek 1.2.2.5 }
651 break;
652 }
653 case RESP_OBJECTPATHS:
654 {
655 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
656 {
657 out << "<OBJECTPATH>\n";
658 XmlWriter::appendValueReferenceElement(
659 out,
660 _instanceNames[i],
661 false);
662 out << "</OBJECTPATH>\n";
663 }
664 break;
665 }
666 default:
667 {
|
668 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
669 marek 1.2.2.5 }
|
670 r.kieninger 1.2.2.1 }
671 }
|
672 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
673 r.kieninger 1.2.2.1 {
|
674 marek 1.2.2.5 switch (_dataType)
|
675 r.kieninger 1.2 {
|
676 marek 1.2.2.5 case RESP_INSTNAMES:
677 {
678 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
679 {
680 SCMOXmlWriter::appendInstanceNameElement(
681 out,
682 _scmoInstances[i]);
683 }
684 break;
685 }
686 case RESP_INSTANCE:
687 {
688 if (_scmoInstances.size() > 0)
689 {
690 SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);
691 }
692 break;
693 }
694 case RESP_INSTANCES:
695 {
696 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
697 marek 1.2.2.5 {
698 SCMOXmlWriter::appendValueSCMOInstanceElement(
699 out,
700 _scmoInstances[i]);
701 }
702 break;
703 }
704 case RESP_OBJECTS:
705 {
706 for (Uint32 i = 0; i < _scmoInstances.size(); i++)
707 {
708 SCMOXmlWriter::appendValueObjectWithPathElement(
709 out,
710 _scmoInstances[i]);
711 }
712 break;
713 }
714 case RESP_OBJECTPATHS:
715 {
|
716 marek 1.2.2.7 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
717 {
718 out << "<OBJECTPATH>\n";
719 SCMOXmlWriter::appendValueReferenceElement(
720 out,
721 _scmoInstances[i],
722 false);
723 out << "</OBJECTPATH>\n";
724 }
|
725 marek 1.2.2.5 break;
726 }
727 default:
728 {
|
729 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
730 marek 1.2.2.5 }
|
731 r.kieninger 1.2 }
|
732 r.kieninger 1.1 }
|
733 marek 1.2.2.5 }
|
734 r.kieninger 1.1
|
735 marek 1.2.2.5 // contrary to encodeXmlResponse this function encodes the Xml in a format
736 // not usable by clients
737 void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
738 {
|
739 r.kieninger 1.2.2.18 PEG_TRACE((TRC_XML, Tracer::LEVEL3,
740 "CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X)\n",
741 _encoding,
742 _dataType));
743
|
744 marek 1.2.2.15 // already existing Internal XML does not need to be encoded further
745 // binary input is not actually impossible here, but we have an established
746 // fallback
747 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
748 {
749 _resolveBinary();
750 }
|
751 r.kieninger 1.2.2.18 if ((0 == _encoding) ||
752 (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)))
|
753 marek 1.2.2.15 {
754 switch (_dataType)
755 {
756 case RESP_INSTANCE:
757 {
758 if (0 == _instances.size())
759 {
760 _instances.append(CIMInstance());
761 }
762 CIMInternalXmlEncoder::_putXMLInstance(out, _instances[0]);
763 break;
764 }
765 case RESP_INSTANCES:
766 {
767 Uint32 n = _instances.size();
768 out.putUint32(n);
769 for (Uint32 i = 0; i < n; i++)
770 {
771 CIMInternalXmlEncoder::_putXMLNamedInstance(
772 out,
773 _instances[i]);
774 marek 1.2.2.15 }
775 break;
776 }
777 case RESP_OBJECTS:
778 {
779 Uint32 n = _objects.size();
780 out.putUint32(n);
781 for (Uint32 i = 0; i < n; i++)
782 {
783 CIMInternalXmlEncoder::_putXMLObject(out, _objects[i]);
784 }
785 break;
786 }
787 // internal xml encoding of instance names and object paths not
788 // done today
789 case RESP_INSTNAMES:
790 case RESP_OBJECTPATHS:
791 default:
792 {
793 PEGASUS_DEBUG_ASSERT(false);
794 }
795 marek 1.2.2.15 }
796 }
797 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
798 {
799 switch (_dataType)
800 {
801 case RESP_INSTANCE:
802 {
803 if (0 == _scmoInstances.size())
804 {
805 _scmoInstances.append(SCMOInstance());
806 }
807 SCMOInternalXmlEncoder::_putXMLInstance(out, _scmoInstances[0]);
808 break;
809 }
810 case RESP_INSTANCES:
811 {
812 Uint32 n = _scmoInstances.size();
813 out.putUint32(n);
814 for (Uint32 i = 0; i < n; i++)
815 {
816 marek 1.2.2.15 SCMOInternalXmlEncoder::_putXMLNamedInstance(
817 out,
818 _scmoInstances[i]);
819 }
820 break;
821 }
822 case RESP_OBJECTS:
823 {
824 Uint32 n = _scmoInstances.size();
825 out.putUint32(n);
826 for (Uint32 i = 0; i < n; i++)
827 {
828 SCMOInternalXmlEncoder::_putXMLObject(
829 out,
830 _scmoInstances[i]);
831 }
832 break;
833 }
834 // internal xml encoding of instance names and object paths not
835 // done today
836 case RESP_INSTNAMES:
837 marek 1.2.2.15 case RESP_OBJECTPATHS:
838 default:
839 {
840 PEGASUS_DEBUG_ASSERT(false);
841 }
842 }
843 }
|
844 marek 1.2.2.5 }
|
845 r.kieninger 1.1
|
846 marek 1.2.2.5 void CIMResponseData::_resolveToCIM()
|
847 r.kieninger 1.1 {
|
848 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
849 "CIMResponseData::_resolveToCIM(encoding=%X,content=%X)\n",
|
850 marek 1.2.2.5 _encoding,
|
851 marek 1.2.2.10 _dataType));
852
|
853 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
854 r.kieninger 1.1 {
|
855 marek 1.2.2.5 _resolveXmlToCIM();
|
856 r.kieninger 1.1 }
|
857 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
858 r.kieninger 1.1 {
|
859 marek 1.2.2.5 _resolveBinary();
|
860 r.kieninger 1.1 }
|
861 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
862 r.kieninger 1.1 {
|
863 marek 1.2.2.5 _resolveSCMOToCIM();
|
864 r.kieninger 1.1 }
|
865 r.kieninger 1.2.2.16
|
866 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0);
|
867 marek 1.2.2.5 }
|
868 r.kieninger 1.1
|
869 marek 1.2.2.5 void CIMResponseData::_resolveToSCMO()
870 {
|
871 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
872 "CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)\n",
|
873 marek 1.2.2.5 _encoding,
|
874 marek 1.2.2.10 _dataType));
875
|
876 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
877 r.kieninger 1.1 {
|
878 marek 1.2.2.5 _resolveXmlToSCMO();
|
879 r.kieninger 1.1 }
|
880 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
881 r.kieninger 1.1 {
|
882 marek 1.2.2.5 _resolveBinary();
|
883 r.kieninger 1.1 }
|
884 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
885 r.kieninger 1.1 {
|
886 marek 1.2.2.5 _resolveCIMToSCMO();
|
887 r.kieninger 1.1 }
|
888 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO || _encoding == 0);
|
889 r.kieninger 1.1 }
890
|
891 marek 1.2.2.5 // helper functions to transform different formats into one-another
892 // functions work on the internal data and calling of them should be
893 // avoided whenever possible
894 void CIMResponseData::_resolveBinary()
|
895 r.kieninger 1.1 {
|
896 r.kieninger 1.2.2.16 PEG_METHOD_ENTER(TRC_DISPATCHER,
897 "CIMResponseData::_resolveBinary");
|
898 r.kieninger 1.1
|
899 r.kieninger 1.2.2.16 CIMBuffer in((char*)_binaryData.getData(), _binaryData.size());
900
901 while (in.more())
|
902 r.kieninger 1.1 {
|
903 r.kieninger 1.2.2.16 Uint32 binaryTypeMarker=0;
904 if(!in.getTypeMarker(binaryTypeMarker))
|
905 marek 1.2.2.5 {
|
906 r.kieninger 1.2.2.16 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
907 "Failed to get type marker for binary objects!");
908 PEG_METHOD_EXIT();
909 in.release();
910 return;
|
911 marek 1.2.2.5 }
|
912 r.kieninger 1.2.2.16
913 if (BIN_TYPE_MARKER_SCMO==binaryTypeMarker)
|
914 marek 1.2.2.5 {
|
915 r.kieninger 1.2.2.16 if (!in.getSCMOInstanceA(_scmoInstances))
916 {
917 _encoding &=(~RESP_ENC_BINARY);
918 in.release();
919 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
920 "Failed to resolve binary SCMOInstances!");
921 PEG_METHOD_EXIT();
922 return;
923 }
924
925 _encoding |= RESP_ENC_SCMO;
|
926 marek 1.2.2.5 }
|
927 r.kieninger 1.2.2.16 else
|
928 marek 1.2.2.5 {
|
929 r.kieninger 1.2.2.16 switch (_dataType)
930 {
931 // TODO: Decide what to decode based on marker
932 case RESP_INSTNAMES:
933 case RESP_OBJECTPATHS:
934 {
935 if (!in.getObjectPathA(_instanceNames))
936 {
937 _encoding &=(~RESP_ENC_BINARY);
938 in.release();
939 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
940 "Failed to resolve binary CIMObjectPaths!");
941 PEG_METHOD_EXIT();
942 return;
943 }
944 break;
945 }
946 case RESP_INSTANCE:
947 {
948 CIMInstance instance;
949 if (!in.getInstance(instance))
950 r.kieninger 1.2.2.16 {
951 _encoding &=(~RESP_ENC_BINARY);
952 _encoding |= RESP_ENC_CIM;
953 _instances.append(instance);
954 in.release();
955 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
956 "Failed to resolve binary instance!");
957 PEG_METHOD_EXIT();
958 return;
959 }
960
961 _instances.append(instance);
962 break;
963 }
964 case RESP_INSTANCES:
965 {
966 if (!in.getInstanceA(_instances))
967 {
968 _encoding &=(~RESP_ENC_BINARY);
969 in.release();
970 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
971 r.kieninger 1.2.2.16 "Failed to resolve binary CIMInstances!");
972 PEG_METHOD_EXIT();
973 return;
974 }
975 break;
976 }
977 case RESP_OBJECTS:
978 {
979 if (!in.getObjectA(_objects))
980 {
981 in.release();
982 _encoding &=(~RESP_ENC_BINARY);
983 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
984 "Failed to resolve binary CIMObjects!");
985 PEG_METHOD_EXIT();
986 return;
987 }
988 break;
989 }
990 default:
991 {
992 r.kieninger 1.2.2.16 PEGASUS_DEBUG_ASSERT(false);
993 }
994 } // switch
995 _encoding |= RESP_ENC_CIM;
996 } // else SCMO
|
997 r.kieninger 1.1 }
|
998 r.kieninger 1.2.2.16
999 _encoding &=(~RESP_ENC_BINARY);
1000
1001 in.release();
1002 PEG_METHOD_EXIT();
|
1003 r.kieninger 1.1 }
1004
|
1005 marek 1.2.2.5 void CIMResponseData::_resolveXmlToCIM()
|
1006 r.kieninger 1.1 {
|
1007 marek 1.2.2.5 switch (_dataType)
1008 {
|
1009 marek 1.2.2.10 // same encoding for instance names and object paths
1010 case RESP_OBJECTPATHS:
|
1011 marek 1.2.2.5 case RESP_INSTNAMES:
1012 {
1013 for (Uint32 i = 0; i < _referencesData.size(); i++)
1014 {
1015 CIMObjectPath cop;
1016 // Deserialize path:
1017 {
1018 XmlParser parser((char*)_referencesData[i].getData());
1019
1020 if (XmlReader::getInstanceNameElement(parser, cop))
1021 {
1022 if (!_nameSpacesData[i].isNull())
1023 cop.setNameSpace(_nameSpacesData[i]);
1024
1025 if (_hostsData[i].size())
1026 cop.setHost(_hostsData[i]);
1027 }
1028 }
1029 _instanceNames.append(cop);
1030 }
1031 break;
1032 marek 1.2.2.5 }
1033 case RESP_INSTANCE:
1034 {
1035 CIMInstance cimInstance;
1036 // Deserialize instance:
1037 {
1038 XmlParser parser((char*)_instanceData[0].getData());
|
1039 r.kieninger 1.1
|
1040 marek 1.2.2.5 if (!XmlReader::getInstanceElement(parser, cimInstance))
1041 {
1042 cimInstance = CIMInstance();
1043 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
1044 "Failed to resolve XML instance, parser error!");
1045 }
1046 }
1047 // Deserialize path:
1048 {
1049 XmlParser parser((char*)_referencesData[0].getData());
1050 CIMObjectPath cimObjectPath;
|
1051 r.kieninger 1.1
|
1052 marek 1.2.2.5 if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
1053 {
1054 if (_hostsData.size())
1055 {
1056 cimObjectPath.setHost(_hostsData[0]);
1057 }
1058 if (!_nameSpacesData[0].isNull())
1059 {
1060 cimObjectPath.setNameSpace(_nameSpacesData[0]);
1061 }
1062 cimInstance.setPath(cimObjectPath);
1063 // only if everything works we add the CIMInstance to the
1064 // array
1065 _instances.append(cimInstance);
1066 }
1067 }
1068 break;
1069 }
1070 case RESP_INSTANCES:
1071 {
1072 for (Uint32 i = 0; i < _instanceData.size(); i++)
1073 marek 1.2.2.5 {
1074 CIMInstance cimInstance;
1075 // Deserialize instance:
1076 {
1077 XmlParser parser((char*)_instanceData[i].getData());
1078
1079 if (!XmlReader::getInstanceElement(parser, cimInstance))
1080 {
1081 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
1082 "Failed to resolve XML instance."
1083 " Creating empty instance!");
1084 cimInstance = CIMInstance();
1085 }
1086 }
1087
1088 // Deserialize path:
1089 {
1090 XmlParser parser((char*)_referencesData[i].getData());
1091 CIMObjectPath cimObjectPath;
1092
1093 if (XmlReader::getInstanceNameElement(parser,cimObjectPath))
1094 marek 1.2.2.5 {
1095 if (!_nameSpacesData[i].isNull())
1096 cimObjectPath.setNameSpace(_nameSpacesData[i]);
1097
1098 if (_hostsData[i].size())
1099 cimObjectPath.setHost(_hostsData[i]);
1100
1101 cimInstance.setPath(cimObjectPath);
1102 }
1103 }
|
1104 r.kieninger 1.1
|
1105 marek 1.2.2.5 _instances.append(cimInstance);
1106 }
1107 break;
1108 }
1109 case RESP_OBJECTS:
1110 {
1111 for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
1112 {
1113 CIMObject cimObject;
1114
1115 // Deserialize Objects:
1116 {
1117 XmlParser parser((char*)_instanceData[i].getData());
1118
1119 CIMInstance cimInstance;
1120 CIMClass cimClass;
1121
1122 if (XmlReader::getInstanceElement(parser, cimInstance))
1123 {
1124 cimObject = CIMObject(cimInstance);
1125 }
1126 marek 1.2.2.5 else if (XmlReader::getClassElement(parser, cimClass))
1127 {
1128 cimObject = CIMObject(cimClass);
1129 }
1130 else
1131 {
1132 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
1133 "Failed to get XML object data!");
1134 }
1135 }
1136
1137 // Deserialize paths:
1138 {
1139 XmlParser parser((char*)_referencesData[i].getData());
1140 CIMObjectPath cimObjectPath;
1141
1142 if (XmlReader::getValueReferenceElement(
1143 parser,
1144 cimObjectPath))
1145 {
1146 if (!_nameSpacesData[i].isNull())
1147 marek 1.2.2.5 cimObjectPath.setNameSpace(_nameSpacesData[i]);
1148
1149 if (_hostsData[i].size())
1150 cimObjectPath.setHost(_hostsData[i]);
1151
1152 cimObject.setPath(cimObjectPath);
1153 }
1154 }
1155 _objects.append(cimObject);
1156 }
1157 break;
1158 }
1159 default:
1160 {
|
1161 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
1162 marek 1.2.2.5 }
1163 }
1164 // Xml was resolved, release Xml content now
1165 _referencesData.clear();
1166 _hostsData.clear();
1167 _nameSpacesData.clear();
1168 _instanceData.clear();
1169 // remove Xml Encoding flag
|
1170 marek 1.2.2.8 _encoding &=(~RESP_ENC_XML);
|
1171 marek 1.2.2.5 // add CIM Encoding flag
1172 _encoding |=RESP_ENC_CIM;
|
1173 r.kieninger 1.1 }
1174
|
1175 marek 1.2.2.5 void CIMResponseData::_resolveXmlToSCMO()
|
1176 r.kieninger 1.2.2.4 {
|
1177 marek 1.2.2.5 // Not optimal, can probably be improved
1178 // but on the other hand, since using the binary format this case should
1179 // actually not ever happen.
1180 _resolveXmlToCIM();
1181 _resolveCIMToSCMO();
1182 }
|
1183 r.kieninger 1.2.2.4
|
1184 marek 1.2.2.5 void CIMResponseData::_resolveSCMOToCIM()
1185 {
1186 switch(_dataType)
|
1187 r.kieninger 1.2.2.4 {
|
1188 marek 1.2.2.5 case RESP_INSTNAMES:
1189 case RESP_OBJECTPATHS:
|
1190 r.kieninger 1.1 {
|
1191 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
1192 {
1193 CIMObjectPath newObjectPath;
1194 _scmoInstances[x].getCIMObjectPath(newObjectPath);
1195 _instanceNames.append(newObjectPath);
1196 }
1197 break;
|
1198 r.kieninger 1.1 }
|
1199 marek 1.2.2.5 case RESP_INSTANCE:
|
1200 r.kieninger 1.1 {
|
1201 marek 1.2.2.8 if (_scmoInstances.size() > 0)
1202 {
1203 CIMInstance newInstance;
1204 _scmoInstances[0].getCIMInstance(newInstance);
1205 _instances.append(newInstance);
1206 }
|
1207 marek 1.2.2.5 break;
|
1208 marek 1.2.2.2 }
|
1209 marek 1.2.2.5 case RESP_INSTANCES:
|
1210 r.kieninger 1.2 {
|
1211 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
1212 r.kieninger 1.1 {
|
1213 marek 1.2.2.5 CIMInstance newInstance;
1214 _scmoInstances[x].getCIMInstance(newInstance);
1215 _instances.append(newInstance);
|
1216 r.kieninger 1.1 }
|
1217 marek 1.2.2.5 break;
|
1218 r.kieninger 1.1 }
|
1219 marek 1.2.2.5 case RESP_OBJECTS:
|
1220 r.kieninger 1.1 {
|
1221 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
1222 r.kieninger 1.1 {
|
1223 marek 1.2.2.5 CIMInstance newInstance;
1224 _scmoInstances[x].getCIMInstance(newInstance);
1225 _objects.append(CIMObject(newInstance));
|
1226 r.kieninger 1.1 }
|
1227 marek 1.2.2.5 break;
|
1228 r.kieninger 1.1 }
|
1229 marek 1.2.2.5 default:
|
1230 r.kieninger 1.2.2.1 {
|
1231 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
1232 r.kieninger 1.2.2.1 }
1233 }
|
1234 marek 1.2.2.5 _scmoInstances.clear();
1235 // remove CIM Encoding flag
|
1236 marek 1.2.2.8 _encoding &=(~RESP_ENC_SCMO);
|
1237 marek 1.2.2.5 // add SCMO Encoding flag
1238 _encoding |=RESP_ENC_CIM;
|
1239 r.kieninger 1.2.2.1 }
1240
|
1241 marek 1.2.2.5 void CIMResponseData::_resolveCIMToSCMO()
|
1242 r.kieninger 1.1 {
|
1243 marek 1.2.2.5 switch (_dataType)
|
1244 r.kieninger 1.2 {
|
1245 marek 1.2.2.5 case RESP_INSTNAMES:
|
1246 r.kieninger 1.2 {
|
1247 marek 1.2.2.5 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
1248 {
|
1249 r.kieninger 1.2.2.18 SCMOInstance addme(
1250 _instanceNames[i],
1251 _defaultNamespace,
1252 _defaultNamespaceLen);
|
1253 marek 1.2.2.5 _scmoInstances.append(addme);
1254 }
|
1255 marek 1.2.2.8 _instanceNames.clear();
|
1256 marek 1.2.2.5 break;
|
1257 r.kieninger 1.2 }
|
1258 marek 1.2.2.5 case RESP_INSTANCE:
|
1259 r.kieninger 1.1 {
|
1260 marek 1.2.2.8 if (_instances.size() > 0)
1261 {
|
1262 r.kieninger 1.2.2.18 SCMOInstance addme(
1263 _instances[0],
1264 _defaultNamespace,
1265 _defaultNamespaceLen);
|
1266 marek 1.2.2.15 _scmoInstances.clear();
|
1267 marek 1.2.2.8 _scmoInstances.append(addme);
1268 _instances.clear();
1269 }
|
1270 marek 1.2.2.5 break;
|
1271 r.kieninger 1.1 }
|
1272 marek 1.2.2.5 case RESP_INSTANCES:
|
1273 r.kieninger 1.1 {
|
1274 marek 1.2.2.5 for (Uint32 i=0,n=_instances.size();i<n;i++)
1275 {
|
1276 r.kieninger 1.2.2.18 SCMOInstance addme(
1277 _instances[i],
1278 _defaultNamespace,
1279 _defaultNamespaceLen);
|
1280 marek 1.2.2.5 _scmoInstances.append(addme);
1281 }
|
1282 marek 1.2.2.8 _instances.clear();
|
1283 marek 1.2.2.5 break;
|
1284 r.kieninger 1.1 }
|
1285 marek 1.2.2.5 case RESP_OBJECTS:
|
1286 r.kieninger 1.1 {
|
1287 marek 1.2.2.8 for (Uint32 i=0,n=_objects.size();i<n;i++)
1288 {
|
1289 r.kieninger 1.2.2.18 SCMOInstance addme(
1290 _objects[i],
1291 _defaultNamespace,
1292 _defaultNamespaceLen);
|
1293 marek 1.2.2.8 _scmoInstances.append(addme);
1294 }
1295 _objects.clear();
|
1296 marek 1.2.2.5 break;
|
1297 r.kieninger 1.1 }
|
1298 marek 1.2.2.9 case RESP_OBJECTPATHS:
1299 {
1300 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
1301 {
|
1302 r.kieninger 1.2.2.18 SCMOInstance addme(
1303 _instanceNames[i],
1304 _defaultNamespace,
1305 _defaultNamespaceLen);
|
1306 thilo.boehm 1.2.2.14 // TODO: More description about this.
|
1307 marek 1.2.2.9 if (0 == _instanceNames[i].getKeyBindings().size())
1308 {
1309 // if there is no keybinding, this is a class
1310 addme.setIsClassOnly(true);
1311 }
1312 _scmoInstances.append(addme);
1313 }
1314 _instanceNames.clear();
1315 break;
1316 }
|
1317 marek 1.2.2.5 default:
|
1318 r.kieninger 1.1 {
|
1319 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
1320 r.kieninger 1.1 }
1321 }
1322
|
1323 marek 1.2.2.5 // remove CIM Encoding flag
|
1324 marek 1.2.2.8 _encoding &=(~RESP_ENC_CIM);
|
1325 marek 1.2.2.5 // add SCMO Encoding flag
1326 _encoding |=RESP_ENC_SCMO;
|
1327 r.kieninger 1.1 }
1328
1329 PEGASUS_NAMESPACE_END
|
Return to
CIMResponseData.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common