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