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 #include <Pegasus/Common/SCMOClassCache.h>
|
38 r.kieninger 1.1
39 PEGASUS_USING_STD;
40
41 PEGASUS_NAMESPACE_BEGIN
42
|
43 marek 1.2.2.5 // C++ objects interface handling
44
45 // Instance Names handling
46 Array<CIMObjectPath>& CIMResponseData::getInstanceNames()
47 {
48 PEGASUS_DEBUG_ASSERT(
49 (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
50 _resolveToCIM();
51 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
52 return _instanceNames;
53 }
54
55 // Instance handling
56 CIMInstance& CIMResponseData::getInstance()
57 {
58 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
59 _resolveToCIM();
60 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
61 return _instances[0];
62 }
63
64 marek 1.2.2.5 // Instances handling
65 Array<CIMInstance>& CIMResponseData::getInstances()
66 {
67 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);
68 _resolveToCIM();
69 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
70 return _instances;
71 }
72
73 // Objects handling
74 Array<CIMObject>& CIMResponseData::getObjects()
75 {
76 PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);
77 _resolveToCIM();
78 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
79 return _objects;
80 }
81
82 // SCMO representation, single instance stored as one element array
83 // object paths are represented as SCMOInstance
84 Array<SCMOInstance>& CIMResponseData::getSCMO()
85 marek 1.2.2.5 {
86 _resolveToSCMO();
87 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);
88 return _scmoInstances;
89 }
90
|
91 marek 1.2.2.6 void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)
92 {
93 // Just assignment bears danger of us being dependent on the original array
94 // content staying valid
|
95 marek 1.2.2.8 _scmoInstances=x;
96 /*
|
97 marek 1.2.2.6 for (Uint32 loop=0, max=x.size(); loop<max; loop++)
98 {
99 _scmoInstances.append(x[loop]);
100 }
|
101 marek 1.2.2.8 */
|
102 marek 1.2.2.6 // _scmoInstances.appendArray(x);
103 _encoding |= RESP_ENC_SCMO;
104 }
105
106
|
107 marek 1.2.2.5 // Binary data is just a data stream
108 Array<Uint8>& CIMResponseData::getBinary()
109 {
|
110 marek 1.2.2.10 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_BINARY);
|
111 marek 1.2.2.5 return _binaryData;
112 }
113
114 bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)
|
115 r.kieninger 1.2.2.1 {
116 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
117 marek 1.2.2.5 "CIMResponseData::setBinary");
|
118 r.kieninger 1.2.2.1
119 if (hasLen)
120 {
121 if (!in.getUint8A(_binaryData))
122 {
123 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
124 "Failed to get binary object path data!");
125 PEG_METHOD_EXIT();
126 return false;
127 }
128 }
129 else
130 {
131 size_t remainingDataLength = in.capacity() - in.size();
132 _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);
133 }
|
134 marek 1.2.2.5 _encoding |= RESP_ENC_BINARY;
|
135 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
136 return true;
|
137 marek 1.2.2.5 }
|
138 r.kieninger 1.2.2.1
|
139 marek 1.2.2.5 bool CIMResponseData::setXml(CIMBuffer& in)
|
140 r.kieninger 1.2.2.1 {
141 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
142 marek 1.2.2.5 "CIMResponseData::setXml");
|
143 r.kieninger 1.2.2.1
|
144 marek 1.2.2.5 if (_dataType == RESP_INSTNAMES)
|
145 r.kieninger 1.2.2.1 {
|
146 marek 1.2.2.5 Uint32 count;
|
147 marek 1.2.2.6
|
148 marek 1.2.2.5 if (!in.getUint32(count))
|
149 r.kieninger 1.2.2.1 {
150 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
|
151 marek 1.2.2.5 "Failed to get XML objectpath data (number of paths)!");
|
152 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
153 return false;
154 }
|
155 marek 1.2.2.6
|
156 marek 1.2.2.5 for (Uint32 i = 0; i < count; i++)
|
157 r.kieninger 1.2.2.1 {
|
158 marek 1.2.2.5 Array<Sint8> ref;
159 CIMNamespaceName ns;
160 String host;
|
161 marek 1.2.2.6
|
162 marek 1.2.2.5 if (!in.getSint8A(ref))
163 {
164 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
165 "Failed to get XML objectpath data (references)!");
166 PEG_METHOD_EXIT();
167 return false;
168 }
|
169 marek 1.2.2.6
|
170 marek 1.2.2.5 if (!in.getString(host))
171 {
172 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
173 "Failed to get XML instance data (host)!");
174 PEG_METHOD_EXIT();
175 return false;
176 }
|
177 marek 1.2.2.6
|
178 marek 1.2.2.5 if (!in.getNamespaceName(ns))
179 {
180 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
181 "Failed to get XML instance data (namespace)!");
182 PEG_METHOD_EXIT();
183 return false;
184 }
|
185 marek 1.2.2.6
|
186 marek 1.2.2.5 _referencesData.append(ref);
187 _hostsData.append(host);
188 _nameSpacesData.append(ns);
|
189 r.kieninger 1.2.2.1 }
190 }
|
191 marek 1.2.2.5 // TODO: Code the left out types
|
192 r.kieninger 1.2.2.1
|
193 marek 1.2.2.5 _encoding |= RESP_ENC_XML;
|
194 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
195 return true;
|
196 marek 1.2.2.5 }
197
198 // function used by OperationAggregator to aggregate response data in a
199 // single ResponseData object
200 void CIMResponseData::appendResponseData(const CIMResponseData & x)
201 {
202 // as the Messages set the data types, this should be impossible
203 PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
204 _encoding |= x._encoding;
205
206 // add all binary data
207 _binaryData.appendArray(x._binaryData);
|
208 r.kieninger 1.2.2.1
|
209 marek 1.2.2.5 // add all the C++ stuff
210 _instanceNames.appendArray(x._instanceNames);
211 _instances.appendArray(x._instances);
212 _objects.appendArray(x._objects);
|
213 r.kieninger 1.2.2.1
|
214 marek 1.2.2.5 // add the SCMO instances
215 _scmoInstances.appendArray(x._scmoInstances);
|
216 r.kieninger 1.2.2.1
|
217 marek 1.2.2.5 // add Xml encodings too
218 _referencesData.appendArray(x._referencesData);
219 _instanceData.appendArray(x._instanceData);
220 _hostsData.appendArray(x._hostsData);
221 _nameSpacesData.appendArray(x._nameSpacesData);
222 }
|
223 r.kieninger 1.2.2.1
|
224 marek 1.2.2.5 // Encoding responses into output format
225 void CIMResponseData::encodeBinaryResponse(CIMBuffer& out)
|
226 r.kieninger 1.2.2.1 {
227 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
228 marek 1.2.2.5 "CIMResponseData::encodeBinaryResponse");
|
229 r.kieninger 1.2.2.1
|
230 marek 1.2.2.5 // Need to do a complete job here by transferring all contained data
231 // into binary format and handing it out in the CIMBuffer
232 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
233 r.kieninger 1.2.2.1 {
|
234 marek 1.2.2.5 // Binary does NOT need a marker as it consists of C++ and SCMO
|
235 r.kieninger 1.2.2.1 const Array<Uint8>& data = _binaryData;
236 out.putBytes(data.getData(), data.size());
237 }
|
238 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
239 r.kieninger 1.2.2.1 {
|
240 marek 1.2.2.6 // TODO: Set Marker for C++ data
|
241 marek 1.2.2.5 switch (_dataType)
|
242 r.kieninger 1.2.2.1 {
|
243 marek 1.2.2.5 case RESP_INSTNAMES:
244 {
245 out.putObjectPathA(_instanceNames, false);
246 break;
247 }
248 case RESP_INSTANCE:
249 {
250 if (0 != _instances.size())
251 {
252 out.putInstance(_instances[0], false, false);
253 }
254 break;
255 }
256 case RESP_INSTANCES:
257 {
258 out.putInstanceA(_instances, false);
259 break;
260 }
261 case RESP_OBJECTS:
262 {
263 out.putObjectA(_objects);
264 marek 1.2.2.5 break;
265 }
266 case RESP_OBJECTPATHS:
267 {
268 // TODO: Determine what to do here
269 break;
270 }
271 default:
272 {
|
273 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
274 marek 1.2.2.5 }
|
275 r.kieninger 1.2.2.1 }
276 }
|
277 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
278 r.kieninger 1.2.2.1 {
|
279 marek 1.2.2.5 // TODO: Set Marker for SCMO data
|
280 r.kieninger 1.2.2.1
|
281 marek 1.2.2.5 // Call magic here to transform a SCMO object into binary format
282 fprintf(stderr, "Watch wat ya do'n! SCMO to binary ? NO OOP yet.\n");
283 fflush(stderr);
284 }
285 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
286 r.kieninger 1.2.2.1 {
|
287 marek 1.2.2.5 // This actually should not happen following general code logic
|
288 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
289 r.kieninger 1.2.2.1 }
290
291 PEG_METHOD_EXIT();
292 }
293
|
294 marek 1.2.2.9 void CIMResponseData::completeHostNameAndNamespace(
295 const String & hn,
296 const CIMNamespaceName & ns)
297 {
298 // Internal XML always has host name and namespace
299 // binary data shhould not ever be present here
300 PEGASUS_DEBUG_ASSERT((RESP_ENC_BINARY != (_encoding & RESP_ENC_BINARY)));
301
302 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
303 {
304 switch (_dataType)
305 {
306 case RESP_OBJECTS:
307 {
308 for (Uint32 j = 0, n = _objects.size(); j < n; j++)
309 {
310 const CIMObject& object = _objects[j];
311 CIMObjectPath& p =
312 const_cast<CIMObjectPath&>(object.getPath());
313 if (p.getHost().size()==0)
314 {
315 marek 1.2.2.9 p.setHost(hn);
316 }
317 if (p.getNameSpace().isNull())
318 {
319 p.setNameSpace(ns);
320 }
321 }
322 break;
323 }
324 case RESP_OBJECTPATHS:
325 {
326 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
327 {
328 CIMObjectPath& p = _instanceNames[j];
329 if (p.getHost().size() == 0)
330 p.setHost(hn);
331 if (p.getNameSpace().isNull())
332 p.setNameSpace(ns);
333 }
334 break;
335 }
336 marek 1.2.2.9 default:
337 {
338 PEGASUS_DEBUG_ASSERT(false);
339 }
340 }
341 }
342 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
343 {
344 CString hnCString=hn.getCString();
345 const char* hnChars = hnCString;
346 Uint32 hnLen = strlen(hnChars);
347 CString nsCString=ns.getString().getCString();
348 const char* nsChars=nsCString;
349 Uint32 nsLen = strlen(nsChars);
350 switch (_dataType)
351 {
352 case RESP_OBJECTS:
353 case RESP_OBJECTPATHS:
354 {
355 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
356 {
357 marek 1.2.2.9 SCMOInstance & scmoInst=_scmoInstances[j];
358 if (0 == scmoInst.getHostName())
359 {
360 scmoInst.setHostName_l(hnChars,hnLen);
361 }
362 if (0 == scmoInst.getNameSpace())
363 {
364 scmoInst.setNameSpace_l(nsChars,nsLen);
365 }
366 }
367 break;
368 }
369 default:
370 {
371 PEGASUS_DEBUG_ASSERT(false);
372 }
373 }
374 }
375 }
376
|
377 marek 1.2.2.5 void CIMResponseData::encodeXmlResponse(Buffer& out)
|
378 r.kieninger 1.2.2.1 {
|
379 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL3,
380 "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)\n",
|
381 marek 1.2.2.5 _encoding,
|
382 marek 1.2.2.10 _dataType));
|
383 r.kieninger 1.2.2.1
|
384 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
385 r.kieninger 1.2.2.1 {
|
386 marek 1.2.2.5 switch (_dataType)
|
387 r.kieninger 1.2.2.1 {
|
388 marek 1.2.2.5 case RESP_INSTNAMES:
389 {
390 const Array<ArraySint8>& a = _referencesData;
391 for (Uint32 i = 0, n = a.size(); i < n; i++)
392 {
393 out.append((char*)a[i].getData(), a[i].size() - 1);
394 }
395 break;
396 }
397 case RESP_INSTANCE:
398 {
399 out.append(
400 (char*)_instanceData.getData(),
401 _instanceData.size()-1);
402 break;
403 }
404 case RESP_INSTANCES:
405 {
406 const Array<ArraySint8>& a = _instanceData;
407 const Array<ArraySint8>& b = _referencesData;
|
408 r.kieninger 1.2.2.1
|
409 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
410 {
411 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
412 out.append((char*)b[i].getData(), b[i].size() - 1);
413 out.append((char*)a[i].getData(), a[i].size() - 1);
414 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
415 }
416 break;
417 }
418 case RESP_OBJECTS:
|
419 r.kieninger 1.2.2.1 {
|
420 marek 1.2.2.5 const Array<ArraySint8>& a = _instanceData;
421 const Array<ArraySint8>& b = _referencesData;
|
422 r.kieninger 1.2.2.1
|
423 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
424 {
425 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
426 out.append((char*)b[i].getData(), b[i].size() - 1);
427 out.append((char*)a[i].getData(), a[i].size() - 1);
428 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
429 }
430 break;
431 }
432 case RESP_OBJECTPATHS:
433 {
434 // TODO: Check what to do in this case
435 const Array<ArraySint8>& a = _instanceData;
436 const Array<ArraySint8>& b = _referencesData;
437
438 for (Uint32 i = 0, n = a.size(); i < n; i++)
439 {
440 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
441 out.append((char*)b[i].getData(), b[i].size() - 1);
442 out.append((char*)a[i].getData(), a[i].size() - 1);
443 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
444 marek 1.2.2.5 }
445 }
446 default:
447 {
|
448 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
449 r.kieninger 1.2.2.1 }
450 }
451 }
452
|
453 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
454 r.kieninger 1.2.2.1 {
|
455 marek 1.2.2.5 switch (_dataType)
|
456 r.kieninger 1.2.2.1 {
|
457 marek 1.2.2.5 case RESP_INSTNAMES:
458 {
459 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
460 {
461 XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);
462 }
463 break;
464 }
465 case RESP_INSTANCE:
466 {
467 if (_instances.size()>0)
468 {
469 XmlWriter::appendInstanceElement(out, _instances[0]);
470 }
471 break;
472 }
473 case RESP_INSTANCES:
474 {
475 for (Uint32 i = 0, n = _instances.size(); i < n; i++)
476 {
477 XmlWriter::appendValueNamedInstanceElement(
478 marek 1.2.2.5 out, _instances[i]);
479 }
480 break;
481 }
482 case RESP_OBJECTS:
483 {
484 for (Uint32 i = 0; i < _objects.size(); i++)
485 {
486 XmlWriter::appendValueObjectWithPathElement(
487 out,
488 _objects[i]);
489 }
490 break;
491 }
492 case RESP_OBJECTPATHS:
493 {
494 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
495 {
496 out << "<OBJECTPATH>\n";
497 XmlWriter::appendValueReferenceElement(
498 out,
499 marek 1.2.2.5 _instanceNames[i],
500 false);
501 out << "</OBJECTPATH>\n";
502 }
503 break;
504 }
505 default:
506 {
|
507 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
508 marek 1.2.2.5 }
|
509 r.kieninger 1.2.2.1 }
510 }
|
511 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
512 r.kieninger 1.2.2.1 {
|
513 marek 1.2.2.5 switch (_dataType)
|
514 r.kieninger 1.2 {
|
515 marek 1.2.2.5 case RESP_INSTNAMES:
516 {
517 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
518 {
519 SCMOXmlWriter::appendInstanceNameElement(
520 out,
521 _scmoInstances[i]);
522 }
523 break;
524 }
525 case RESP_INSTANCE:
526 {
527 if (_scmoInstances.size() > 0)
528 {
529 SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);
530 }
531 break;
532 }
533 case RESP_INSTANCES:
534 {
535 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
536 marek 1.2.2.5 {
537 SCMOXmlWriter::appendValueSCMOInstanceElement(
538 out,
539 _scmoInstances[i]);
540 }
541 break;
542 }
543 case RESP_OBJECTS:
544 {
545 for (Uint32 i = 0; i < _scmoInstances.size(); i++)
546 {
547 SCMOXmlWriter::appendValueObjectWithPathElement(
548 out,
549 _scmoInstances[i]);
550 }
551 break;
552 }
553 case RESP_OBJECTPATHS:
554 {
|
555 marek 1.2.2.7 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
556 {
557 out << "<OBJECTPATH>\n";
558 SCMOXmlWriter::appendValueReferenceElement(
559 out,
560 _scmoInstances[i],
561 false);
562 out << "</OBJECTPATH>\n";
563 }
|
564 marek 1.2.2.5 break;
565 }
566 default:
567 {
|
568 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
569 marek 1.2.2.5 }
|
570 r.kieninger 1.2 }
|
571 r.kieninger 1.1 }
|
572 marek 1.2.2.5 }
|
573 r.kieninger 1.1
|
574 marek 1.2.2.5 // contrary to encodeXmlResponse this function encodes the Xml in a format
575 // not usable by clients
576 void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
577 {
578 // TODO: Implement
579 // Need the full switch here again
580 // Should use the internal data available SCMO, C++ and InternalXML
581 // to generate the InternalXML by CIMInternalEncoder and SCMOInternalEncoder
582 fprintf(stderr, "Watch wat ya do'n! SCMO to InternalXml ? NO OOP yet.\n");
583 fflush(stderr);
584 }
|
585 r.kieninger 1.1
|
586 marek 1.2.2.5 void CIMResponseData::_resolveToCIM()
|
587 r.kieninger 1.1 {
|
588 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
589 "CIMResponseData::_resolveToCIM(encoding=%X,content=%X)\n",
|
590 marek 1.2.2.5 _encoding,
|
591 marek 1.2.2.10 _dataType));
592
|
593 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
594 r.kieninger 1.1 {
|
595 marek 1.2.2.5 _resolveXmlToCIM();
|
596 r.kieninger 1.1 }
|
597 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
598 r.kieninger 1.1 {
|
599 marek 1.2.2.5 _resolveBinary();
|
600 r.kieninger 1.1 }
|
601 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
602 r.kieninger 1.1 {
|
603 marek 1.2.2.5 _resolveSCMOToCIM();
|
604 r.kieninger 1.1 }
|
605 marek 1.2.2.5 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
606 }
|
607 r.kieninger 1.1
|
608 marek 1.2.2.5 void CIMResponseData::_resolveToSCMO()
609 {
|
610 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
611 "CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)\n",
|
612 marek 1.2.2.5 _encoding,
|
613 marek 1.2.2.10 _dataType));
614
|
615 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
616 r.kieninger 1.1 {
|
617 marek 1.2.2.5 _resolveXmlToSCMO();
|
618 r.kieninger 1.1 }
|
619 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
620 r.kieninger 1.1 {
|
621 marek 1.2.2.5 _resolveBinary();
|
622 r.kieninger 1.1 }
|
623 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
624 r.kieninger 1.1 {
|
625 marek 1.2.2.5 _resolveCIMToSCMO();
|
626 r.kieninger 1.1 }
|
627 marek 1.2.2.5 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);
|
628 r.kieninger 1.1 }
629
|
630 marek 1.2.2.5 // helper functions to transform different formats into one-another
631 // functions work on the internal data and calling of them should be
632 // avoided whenever possible
633 void CIMResponseData::_resolveBinary()
|
634 r.kieninger 1.1 {
|
635 marek 1.2.2.5 // Call magic here to resolve binary format
636 fprintf(stderr, "Watch wat ya do'n! binary ? NO OOP yet.\n");
637 fflush(stderr);
|
638 r.kieninger 1.1
|
639 marek 1.2.2.5 switch (_dataType)
|
640 r.kieninger 1.1 {
|
641 marek 1.2.2.5 case RESP_INSTNAMES:
642 {
643 break;
644 }
645 case RESP_INSTANCE:
646 {
647 break;
648 }
649 case RESP_INSTANCES:
650 {
651 break;
652 }
653 case RESP_OBJECTS:
654 {
655 break;
656 }
657 case RESP_OBJECTPATHS:
658 {
659 break;
660 }
661 default:
662 marek 1.2.2.5 {
|
663 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
664 marek 1.2.2.5 }
|
665 r.kieninger 1.1 }
666 }
667
|
668 marek 1.2.2.5 void CIMResponseData::_resolveXmlToCIM()
|
669 r.kieninger 1.1 {
|
670 marek 1.2.2.5 switch (_dataType)
671 {
|
672 marek 1.2.2.10 // same encoding for instance names and object paths
673 case RESP_OBJECTPATHS:
|
674 marek 1.2.2.5 case RESP_INSTNAMES:
675 {
676 for (Uint32 i = 0; i < _referencesData.size(); i++)
677 {
678 CIMObjectPath cop;
679 // Deserialize path:
680 {
681 XmlParser parser((char*)_referencesData[i].getData());
682
683 if (XmlReader::getInstanceNameElement(parser, cop))
684 {
685 if (!_nameSpacesData[i].isNull())
686 cop.setNameSpace(_nameSpacesData[i]);
687
688 if (_hostsData[i].size())
689 cop.setHost(_hostsData[i]);
690 }
691 }
692 _instanceNames.append(cop);
693 }
694 break;
695 marek 1.2.2.5 }
696 case RESP_INSTANCE:
697 {
698 CIMInstance cimInstance;
699 // Deserialize instance:
700 {
701 XmlParser parser((char*)_instanceData[0].getData());
|
702 r.kieninger 1.1
|
703 marek 1.2.2.5 if (!XmlReader::getInstanceElement(parser, cimInstance))
704 {
705 cimInstance = CIMInstance();
706 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
707 "Failed to resolve XML instance, parser error!");
708 }
709 }
710 // Deserialize path:
711 {
712 XmlParser parser((char*)_referencesData[0].getData());
713 CIMObjectPath cimObjectPath;
|
714 r.kieninger 1.1
|
715 marek 1.2.2.5 if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
716 {
717 if (_hostsData.size())
718 {
719 cimObjectPath.setHost(_hostsData[0]);
720 }
721 if (!_nameSpacesData[0].isNull())
722 {
723 cimObjectPath.setNameSpace(_nameSpacesData[0]);
724 }
725 cimInstance.setPath(cimObjectPath);
726 // only if everything works we add the CIMInstance to the
727 // array
728 _instances.append(cimInstance);
729 }
730 }
731 break;
732 }
733 case RESP_INSTANCES:
734 {
735 for (Uint32 i = 0; i < _instanceData.size(); i++)
736 marek 1.2.2.5 {
737 CIMInstance cimInstance;
738 // Deserialize instance:
739 {
740 XmlParser parser((char*)_instanceData[i].getData());
741
742 if (!XmlReader::getInstanceElement(parser, cimInstance))
743 {
744 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
745 "Failed to resolve XML instance."
746 " Creating empty instance!");
747 cimInstance = CIMInstance();
748 }
749 }
750
751 // Deserialize path:
752 {
753 XmlParser parser((char*)_referencesData[i].getData());
754 CIMObjectPath cimObjectPath;
755
756 if (XmlReader::getInstanceNameElement(parser,cimObjectPath))
757 marek 1.2.2.5 {
758 if (!_nameSpacesData[i].isNull())
759 cimObjectPath.setNameSpace(_nameSpacesData[i]);
760
761 if (_hostsData[i].size())
762 cimObjectPath.setHost(_hostsData[i]);
763
764 cimInstance.setPath(cimObjectPath);
765 }
766 }
|
767 r.kieninger 1.1
|
768 marek 1.2.2.5 _instances.append(cimInstance);
769 }
770 break;
771 }
772 case RESP_OBJECTS:
773 {
774 for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
775 {
776 CIMObject cimObject;
777
778 // Deserialize Objects:
779 {
780 XmlParser parser((char*)_instanceData[i].getData());
781
782 CIMInstance cimInstance;
783 CIMClass cimClass;
784
785 if (XmlReader::getInstanceElement(parser, cimInstance))
786 {
787 cimObject = CIMObject(cimInstance);
788 }
789 marek 1.2.2.5 else if (XmlReader::getClassElement(parser, cimClass))
790 {
791 cimObject = CIMObject(cimClass);
792 }
793 else
794 {
795 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
796 "Failed to get XML object data!");
797 }
798 }
799
800 // Deserialize paths:
801 {
802 XmlParser parser((char*)_referencesData[i].getData());
803 CIMObjectPath cimObjectPath;
804
805 if (XmlReader::getValueReferenceElement(
806 parser,
807 cimObjectPath))
808 {
809 if (!_nameSpacesData[i].isNull())
810 marek 1.2.2.5 cimObjectPath.setNameSpace(_nameSpacesData[i]);
811
812 if (_hostsData[i].size())
813 cimObjectPath.setHost(_hostsData[i]);
814
815 cimObject.setPath(cimObjectPath);
816 }
817 }
818 _objects.append(cimObject);
819 }
820 break;
821 }
822 default:
823 {
|
824 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
825 marek 1.2.2.5 }
826 }
827 // Xml was resolved, release Xml content now
828 _referencesData.clear();
829 _hostsData.clear();
830 _nameSpacesData.clear();
831 _instanceData.clear();
832 // remove Xml Encoding flag
|
833 marek 1.2.2.8 _encoding &=(~RESP_ENC_XML);
|
834 marek 1.2.2.5 // add CIM Encoding flag
835 _encoding |=RESP_ENC_CIM;
|
836 r.kieninger 1.1 }
837
|
838 marek 1.2.2.5 void CIMResponseData::_resolveXmlToSCMO()
|
839 r.kieninger 1.2.2.4 {
|
840 marek 1.2.2.5 // Not optimal, can probably be improved
841 // but on the other hand, since using the binary format this case should
842 // actually not ever happen.
843 _resolveXmlToCIM();
844 _resolveCIMToSCMO();
845 }
|
846 r.kieninger 1.2.2.4
|
847 marek 1.2.2.5 void CIMResponseData::_resolveSCMOToCIM()
848 {
849 switch(_dataType)
|
850 r.kieninger 1.2.2.4 {
|
851 marek 1.2.2.5 case RESP_INSTNAMES:
852 case RESP_OBJECTPATHS:
|
853 r.kieninger 1.1 {
|
854 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
855 {
856 CIMObjectPath newObjectPath;
857 _scmoInstances[x].getCIMObjectPath(newObjectPath);
858 _instanceNames.append(newObjectPath);
859 }
860 break;
|
861 r.kieninger 1.1 }
|
862 marek 1.2.2.5 case RESP_INSTANCE:
|
863 r.kieninger 1.1 {
|
864 marek 1.2.2.8 if (_scmoInstances.size() > 0)
865 {
866 CIMInstance newInstance;
867 _scmoInstances[0].getCIMInstance(newInstance);
868 _instances.append(newInstance);
869 }
|
870 marek 1.2.2.5 break;
|
871 marek 1.2.2.2 }
|
872 marek 1.2.2.5 case RESP_INSTANCES:
|
873 r.kieninger 1.2 {
|
874 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
875 r.kieninger 1.1 {
|
876 marek 1.2.2.5 CIMInstance newInstance;
877 _scmoInstances[x].getCIMInstance(newInstance);
878 _instances.append(newInstance);
|
879 r.kieninger 1.1 }
|
880 marek 1.2.2.5 break;
|
881 r.kieninger 1.1 }
|
882 marek 1.2.2.5 case RESP_OBJECTS:
|
883 r.kieninger 1.1 {
|
884 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
885 r.kieninger 1.1 {
|
886 marek 1.2.2.5 CIMInstance newInstance;
887 _scmoInstances[x].getCIMInstance(newInstance);
888 _objects.append(CIMObject(newInstance));
|
889 r.kieninger 1.1 }
|
890 marek 1.2.2.5 break;
|
891 r.kieninger 1.1 }
|
892 marek 1.2.2.5 default:
|
893 r.kieninger 1.2.2.1 {
|
894 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
895 r.kieninger 1.2.2.1 }
896 }
|
897 marek 1.2.2.5 _scmoInstances.clear();
898 // remove CIM Encoding flag
|
899 marek 1.2.2.8 _encoding &=(~RESP_ENC_SCMO);
|
900 marek 1.2.2.5 // add SCMO Encoding flag
901 _encoding |=RESP_ENC_CIM;
|
902 r.kieninger 1.2.2.1 }
903
|
904 marek 1.2.2.5 void CIMResponseData::_resolveCIMToSCMO()
|
905 r.kieninger 1.1 {
|
906 marek 1.2.2.5 switch (_dataType)
|
907 r.kieninger 1.2 {
|
908 marek 1.2.2.5 case RESP_INSTNAMES:
|
909 r.kieninger 1.2 {
|
910 marek 1.2.2.5 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
911 {
912 SCMOInstance addme =
913 _getSCMOFromCIMObjectPath(_instanceNames[i]);
914 _scmoInstances.append(addme);
915 }
|
916 marek 1.2.2.8 _instanceNames.clear();
|
917 marek 1.2.2.5 break;
|
918 r.kieninger 1.2 }
|
919 marek 1.2.2.5 case RESP_INSTANCE:
|
920 r.kieninger 1.1 {
|
921 marek 1.2.2.8 if (_instances.size() > 0)
922 {
923 SCMOInstance addme =
924 _getSCMOFromCIMInstance(_instances[0]);
925 _scmoInstances.append(addme);
926 _instances.clear();
927 }
|
928 marek 1.2.2.5 break;
|
929 r.kieninger 1.1 }
|
930 marek 1.2.2.5 case RESP_INSTANCES:
|
931 r.kieninger 1.1 {
|
932 marek 1.2.2.5 for (Uint32 i=0,n=_instances.size();i<n;i++)
933 {
|
934 marek 1.2.2.8 SCMOInstance addme = _getSCMOFromCIMInstance(_instances[i]);
|
935 marek 1.2.2.5 _scmoInstances.append(addme);
936 }
|
937 marek 1.2.2.8 _instances.clear();
|
938 marek 1.2.2.5 break;
|
939 r.kieninger 1.1 }
|
940 marek 1.2.2.5 case RESP_OBJECTS:
|
941 r.kieninger 1.1 {
|
942 marek 1.2.2.8 for (Uint32 i=0,n=_objects.size();i<n;i++)
943 {
|
944 marek 1.2.2.9 SCMOInstance addme= _getSCMOFromCIMObject(_objects[i]);
|
945 marek 1.2.2.8 _scmoInstances.append(addme);
946 }
947 _objects.clear();
|
948 marek 1.2.2.5 break;
|
949 r.kieninger 1.1 }
|
950 marek 1.2.2.9 case RESP_OBJECTPATHS:
951 {
952 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
953 {
954 SCMOInstance addme =
955 _getSCMOFromCIMObjectPath(_instanceNames[i]);
956 if (0 == _instanceNames[i].getKeyBindings().size())
957 {
958 // if there is no keybinding, this is a class
959 addme.setIsClassOnly(true);
960 }
961 _scmoInstances.append(addme);
962 }
963 _instanceNames.clear();
964 break;
965 }
|
966 marek 1.2.2.5 default:
|
967 r.kieninger 1.1 {
|
968 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
969 r.kieninger 1.1 }
970 }
971
|
972 marek 1.2.2.5 // remove CIM Encoding flag
|
973 marek 1.2.2.8 _encoding &=(~RESP_ENC_CIM);
|
974 marek 1.2.2.5 // add SCMO Encoding flag
975 _encoding |=RESP_ENC_SCMO;
|
976 r.kieninger 1.1 }
977
|
978 marek 1.2.2.5
979 // Function to convert a CIMInstance into an SCMOInstance
980 SCMOInstance CIMResponseData::_getSCMOFromCIMInstance(
981 const CIMInstance& cimInst)
|
982 r.kieninger 1.1 {
|
983 marek 1.2.2.10 bool isDirty=false;
|
984 marek 1.2.2.5 const CIMObjectPath& cimPath = cimInst.getPath();
|
985 r.kieninger 1.1
|
986 marek 1.2.2.5 const CString nameSpace = cimPath.getNameSpace().getString().getCString();
987 const CString className = cimPath.getClassName().getString().getCString();
|
988 r.kieninger 1.1
|
989 marek 1.2.2.5 SCMOClass * scmoClass = _getSCMOClass(
990 (const char*)nameSpace,
991 (const char*)className);
|
992 marek 1.2.2.10 // if class cannot be found we get 0 back from class cache
993 if (0 == scmoClass)
994 {
995 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
996 "In _getSCMOFromCIMInstance() could not resolve class for "
997 "nameSpace=\"%s\", className=\"%s\"\n",
998 (const char*) nameSpace,
999 (const char*) className));
|
1000 r.kieninger 1.1
|
1001 marek 1.2.2.10 isDirty=true;
1002 scmoClass = new SCMOClass("","");
1003 }
|
1004 marek 1.2.2.5 SCMOInstance scmoInst = SCMOInstance(*scmoClass, cimInst);
|
1005 r.kieninger 1.1
|
1006 marek 1.2.2.10 if (isDirty)
1007 {
1008 scmoInst.markAsCompromised();
1009 }
|
1010 marek 1.2.2.5 return scmoInst;
|
1011 r.kieninger 1.1 }
1012
|
1013 marek 1.2.2.9 SCMOInstance CIMResponseData::_getSCMOFromCIMObject(
1014 const CIMObject& cimObj)
1015 {
1016 if (cimObj.isClass())
1017 {
1018 CIMClass retClass(cimObj);
1019 SCMOInstance theInstance(retClass);
1020 theInstance.setIsClassOnly(true);
1021 return theInstance;
1022 }
1023 return _getSCMOFromCIMInstance(CIMInstance(cimObj));
1024 }
1025
|
1026 marek 1.2.2.5 // Function to convert a CIMObjectPath into an SCMOInstance
1027 SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath(
1028 const CIMObjectPath& cimPath)
|
1029 r.kieninger 1.1 {
|
1030 marek 1.2.2.10 bool isDirty=false;
|
1031 marek 1.2.2.5 CString nameSpace = cimPath.getNameSpace().getString().getCString();
1032 CString className = cimPath.getClassName().getString().getCString();
|
1033 r.kieninger 1.1
|
1034 marek 1.2.2.5 SCMOClass * scmoClass = _getSCMOClass(
1035 (const char*)nameSpace,
1036 (const char*)className);
|
1037 r.kieninger 1.1
|
1038 marek 1.2.2.10 // if class cannot be found we get 0 back from class cache
1039 if (0 == scmoClass)
1040 {
1041 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
1042 "In _getSCMOFromCIMObjectPath() could not resolve class for "
1043 "nameSpace=\"%s\", className=\"%s\"\n",
1044 (const char*) nameSpace,
1045 (const char*) className));
|
1046 r.kieninger 1.1
|
1047 marek 1.2.2.10 isDirty=true;
1048 scmoClass = new SCMOClass("","");
1049 }
|
1050 marek 1.2.2.5 SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath);
|
1051 marek 1.2.2.10 if (isDirty)
1052 {
1053 scmoRef.markAsCompromised();
1054 }
|
1055 marek 1.2.2.5 return scmoRef;
|
1056 r.kieninger 1.1 }
1057
|
1058 marek 1.2.2.5 SCMOClass* CIMResponseData::_getSCMOClass(
1059 const char* nameSpace,
1060 const char* cls)
|
1061 r.kieninger 1.1 {
|
1062 marek 1.2.2.5 SCMOClassCache* local = SCMOClassCache::getInstance();
1063 return local->getSCMOClass(
1064 nameSpace,
1065 strlen(nameSpace),
1066 cls,
1067 strlen(cls));
|
1068 r.kieninger 1.1 }
1069
1070 PEGASUS_NAMESPACE_END
|
Return to
CIMResponseData.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common