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