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