1 martin 1.3 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.4 //
|
3 martin 1.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 martin 1.4 //
|
10 martin 1.3 // 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 martin 1.4 //
|
17 martin 1.3 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.4 //
|
20 martin 1.3 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.4 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.3 // 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 martin 1.4 //
|
28 martin 1.3 //////////////////////////////////////////////////////////////////////////
|
29 mike 1.1 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include <Pegasus/Common/StatisticalData.h>
33 #include "XmlWriter.h"
34 #include "BinaryCodec.h"
35 #include "CIMBuffer.h"
36 #include "StringConversion.h"
37 #include "Print.h"
38
39 #define ENABLE_VALIDATION
40
41 #if defined(_EQUAL)
42 # undef _EQUAL
43 #endif
44
45 #define _EQUAL(X, Y) (X.size() == (sizeof(Y)-1) && String::equalNoCase(X, Y))
46
47 // Header flags:
48 #define LOCAL_ONLY (1 << 0)
49 #define INCLUDE_QUALIFIERS (1 << 1)
50 mike 1.1 #define INCLUDE_CLASS_ORIGIN (1 << 2)
51 #define DEEP_INHERITANCE (1 << 3)
|
52 karl 1.12.2.1 #define CONTINUE_ON_ERROR (1 << 4)
|
53 mike 1.1
54 PEGASUS_NAMESPACE_BEGIN
55
56 //==============================================================================
57 //
58 // Local definitions:
59 //
60 //==============================================================================
61
62 static const Uint32 _MAGIC = 0xF00DFACE;
63 static const Uint32 _REVERSE_MAGIC = 0xCEFA0DF0;
64 static const Uint32 _VERSION = 1;
65 static const size_t _DEFAULT_CIM_BUFFER_SIZE = 16*1024;
66
67 enum Operation
68 {
69 OP_Invalid,
70 OP_GetClass,
71 OP_GetInstance,
72 OP_IndicationDelivery,
73 OP_DeleteClass,
74 mike 1.1 OP_DeleteInstance,
75 OP_CreateClass,
76 OP_CreateInstance,
77 OP_ModifyClass,
78 OP_ModifyInstance,
79 OP_EnumerateClasses,
80 OP_EnumerateClassNames,
81 OP_EnumerateInstances,
82 OP_EnumerateInstanceNames,
83 OP_ExecQuery,
84 OP_Associators,
85 OP_AssociatorNames,
86 OP_References,
87 OP_ReferenceNames,
88 OP_GetProperty,
89 OP_SetProperty,
90 OP_GetQualifier,
91 OP_SetQualifier,
92 OP_DeleteQualifier,
93 OP_EnumerateQualifiers,
94 OP_InvokeMethod,
|
95 karl 1.12.2.4 // EXP_PULL_BEGIN
|
96 karl 1.12.2.1 OP_OpenEnumerateInstances,
97 OP_OpenEnumerateInstancePaths,
98 OP_OpenReferenceInstances,
99 OP_OpenReferenceInstancePaths,
100 OP_OpenAssociatorInstances,
101 OP_OpenAssociatorInstancePaths,
102 OP_PullInstancesWithPath,
103 OP_PullInstancePaths,
104 OP_CloseEnumeration,
105 OP_EnumerationCount,
|
106 karl 1.12.2.6 OP_OpenQueryInstances,
|
107 karl 1.12.2.4 // EXP_PULL_END
|
108 kumpf 1.2 OP_Count
|
109 mike 1.1 };
110
111 static Operation _NameToOp(const CIMName& name)
112 {
113 const String& s = name.getString();
114
115 switch (s[0])
116 {
117 case 'A':
118 if (_EQUAL(s, "Associators"))
119 return OP_Associators;
120 if (_EQUAL(s, "AssociatorNames"))
121 return OP_AssociatorNames;
122 break;
123 case 'C':
124 if (_EQUAL(s, "CreateInstance"))
125 return OP_CreateInstance;
126 if (_EQUAL(s, "CreateClass"))
127 return OP_CreateClass;
|
128 karl 1.12.2.4 //EXP_PULL_BEGIN
|
129 karl 1.12.2.1 if (_EQUAL(s, "CloseEnumeration"))
130 return OP_CloseEnumeration;
|
131 karl 1.12.2.4 // EXP_PULL_END
|
132 mike 1.1 break;
133 case 'D':
134 if (_EQUAL(s, "DeleteInstance"))
135 return OP_DeleteInstance;
136 if (_EQUAL(s, "DeleteClass"))
137 return OP_DeleteClass;
138 if (_EQUAL(s, "DeleteQualifier"))
139 return OP_DeleteQualifier;
140 break;
141 case 'E':
142 if (_EQUAL(s, "EnumerateInstances"))
143 return OP_EnumerateInstances;
144 if (_EQUAL(s, "EnumerateInstanceNames"))
145 return OP_EnumerateInstanceNames;
146 if (_EQUAL(s, "ExecQuery"))
147 return OP_ExecQuery;
148 if (_EQUAL(s, "EnumerateClassNames"))
149 return OP_EnumerateClassNames;
150 if (_EQUAL(s, "EnumerateClasses"))
151 return OP_EnumerateClasses;
152 if (_EQUAL(s, "EnumerateQualifiers"))
153 mike 1.1 return OP_EnumerateQualifiers;
154 break;
155 case 'G':
156 if (_EQUAL(s, "GetInstance"))
157 return OP_GetInstance;
158 if (_EQUAL(s, "GetClass"))
159 return OP_GetClass;
160 if (_EQUAL(s, "GetQualifier"))
161 return OP_GetQualifier;
162 if (_EQUAL(s, "GetProperty"))
163 return OP_GetProperty;
164 break;
165 case 'I':
166 if (_EQUAL(s, "InvokeMethod"))
167 return OP_InvokeMethod;
168 if (_EQUAL(s, "IndicationDelivery"))
169 return OP_IndicationDelivery;
170 break;
171 case 'M':
172 if (_EQUAL(s, "ModifyInstance"))
173 return OP_ModifyInstance;
174 mike 1.1 if (_EQUAL(s, "ModifyClass"))
175 return OP_ModifyClass;
176 break;
|
177 karl 1.12.2.4 // EXP_PULL_BEGIN
|
178 karl 1.12.2.1 case 'O':
179 if (_EQUAL(s, "OpenEnumerateInstances"))
180 return OP_OpenEnumerateInstances;
181 if (_EQUAL(s, "OpenEnumerateInstancePaths"))
182 return OP_OpenEnumerateInstancePaths;
183 if (_EQUAL(s, "OpenReferenceInstances"))
184 return OP_OpenReferenceInstances;
185 if (_EQUAL(s, "OpenReferenceInstancePaths"))
186 return OP_OpenReferenceInstancePaths;
187 if (_EQUAL(s, "OpenAssociatorInstances"))
188 return OP_OpenAssociatorInstances;
189 if (_EQUAL(s, "OpenAssociatorInstancePaths"))
190 return OP_OpenAssociatorInstancePaths;
|
191 karl 1.12.2.6 if (_EQUAL(s, "OpenQueryInstances"))
192 return OP_OpenQueryInstances;;
|
193 karl 1.12.2.1 break;
194 case 'P':
195 if (_EQUAL(s, "PullInstancesWithPath"))
196 return OP_PullInstancesWithPath;
197 if (_EQUAL(s, "PullInstancePaths"))
198 return OP_PullInstancePaths;
199 break;
|
200 karl 1.12.2.4 // EXP_PULL_END
|
201 mike 1.1 case 'R':
202 if (_EQUAL(s, "References"))
203 return OP_References;
204 if (_EQUAL(s, "ReferenceNames"))
205 return OP_ReferenceNames;
206 break;
207 case 'S':
208 if (_EQUAL(s, "SetQualifier"))
209 return OP_SetQualifier;
210 if (_EQUAL(s, "SetProperty"))
211 return OP_SetProperty;
212 break;
213 }
214
215 // Unknown, se we will assume it is an extrinsic method!
216 return OP_InvokeMethod;
217 }
218
219 static void _putHeader(
220 CIMBuffer& out,
221 Uint32 flags,
222 mike 1.1 const String& messageId,
223 Operation operation)
224 {
225 // [MAGIC]
226 out.putUint32(_MAGIC);
227
228 // [VERSION]
229 out.putUint32(_VERSION);
230
231 // [FLAGS]
232 out.putUint32(flags);
233
234 // [MESSAGEID]
235 out.putString(messageId);
236
237 // [OPERATION]
238 out.putUint32(operation);
239 }
240
241 static bool _getHeader(
242 CIMBuffer& in,
243 mike 1.1 Uint32& flags,
244 String& messageId,
245 Operation& operation_)
246 {
247 Uint32 magic;
248 Uint32 version;
249
250 // [MAGIC]
251 if (!in.getUint32(magic))
252 return false;
253
254 if (magic != _MAGIC)
255 {
256 if (magic != _REVERSE_MAGIC)
257 return false;
258
259 // Sender has opposite endianess so turn on endian swapping:
260 in.setSwap(true);
261 }
262
263 // [VERSION]
264 mike 1.1 if (!in.getUint32(version) || version != _VERSION)
265 return false;
266
267 // [FLAGS]
268 if (!in.getUint32(flags))
269 return false;
270
271 // [MESSAGEID]
272 if (!in.getString(messageId))
273 return false;
274
275 // [OPERATION]
276 {
277 Uint32 op;
278
279 if (!in.getUint32(op) || op == OP_Invalid || op >= OP_Count)
280 return false;
281
282 operation_ = Operation(op);
283 }
284
285 mike 1.1 return true;
286 }
287
288 //==============================================================================
289 //
290 // EnumerateInstances
291 //
292 //==============================================================================
293
294 static void _encodeEnumerateInstancesRequest(
295 CIMBuffer& buf,
296 CIMEnumerateInstancesRequestMessage* msg,
297 CIMName& name)
298 {
299 /* See ../Client/CIMOperationRequestEncoder.cpp */
300
301 static const CIMName NAME("EnumerateInstances");
302 name = NAME;
303
304 // [HEADER]
305
306 mike 1.1 Uint32 flags = 0;
307
308 if (msg->deepInheritance)
309 flags |= DEEP_INHERITANCE;
310
311 if (msg->includeQualifiers)
312 flags |= INCLUDE_QUALIFIERS;
313
314 if (msg->includeClassOrigin)
315 flags |= INCLUDE_CLASS_ORIGIN;
316
317 _putHeader(buf, flags, msg->messageId, OP_EnumerateInstances);
318
319 // [NAMESPACE]
320 buf.putNamespaceName(msg->nameSpace);
321
322 // [CLASSNAME]
323 buf.putName(msg->className);
324
325 // [PROPERTY-LIST]
326 buf.putPropertyList(msg->propertyList);
327 mike 1.1 }
328
329 static CIMEnumerateInstancesRequestMessage* _decodeEnumerateInstancesRequest(
330 CIMBuffer& in,
331 Uint32 queueId,
332 Uint32 returnQueueId,
333 Uint32 flags,
334 const String& messageId)
335 {
336 /* See ../Server/CIMOperationRequestDecoder.cpp */
337
338 STAT_GETSTARTTIME
339
340 Boolean deepInheritance = flags & DEEP_INHERITANCE;
|
341 karl 1.12.2.5 #ifndef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
342 mike 1.1 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
|
343 karl 1.12.2.5 #endif
|
344 mike 1.1 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
345
346 // [NAMESPACE]
347
348 CIMNamespaceName nameSpace;
349
350 if (!in.getNamespaceName(nameSpace))
351 return 0;
352
353 // [CLASSNAME]
354 CIMName className;
355
356 if (!in.getName(className))
357 return 0;
358
359 // [PROPERTY-LIST]
360 CIMPropertyList propertyList;
361 if (!in.getPropertyList(propertyList))
362 return 0;
363
364 AutoPtr<CIMEnumerateInstancesRequestMessage> request(
365 mike 1.1 new CIMEnumerateInstancesRequestMessage(
366 messageId,
367 nameSpace,
368 className,
369 deepInheritance,
370 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
371 false,
372 #else
373 includeQualifiers,
374 #endif
375 includeClassOrigin,
376 propertyList,
377 QueueIdStack(queueId, returnQueueId)));
378
379 request->binaryRequest = true;
380
381 STAT_SERVERSTART
382
383 return request.release();
384 }
385
386 mike 1.1 static void _encodeEnumerateInstancesResponseBody(
387 CIMBuffer& out,
|
388 thilo.boehm 1.10 CIMResponseData& data,
|
389 karl 1.12.2.3 CIMName& name,
390 bool isFirst)
|
391 mike 1.1 {
392 /* See ../Server/CIMOperationResponseEncoder.cpp */
393
394 static const CIMName NAME("EnumerateInstances");
395 name = NAME;
396
|
397 karl 1.12.2.3 // Only write the property list on the first provider response
398 if (isFirst)
399 {
400 // [PROPERTY-LIST]
401 out.putPropertyList(data.getPropertyList());
402 }
|
403 r.kieninger 1.8 data.encodeBinaryResponse(out);
|
404 mike 1.1 }
405
406 static CIMEnumerateInstancesResponseMessage* _decodeEnumerateInstancesResponse(
407 CIMBuffer& in,
408 const String& messageId)
409 {
410 CIMEnumerateInstancesResponseMessage* msg;
411 CIMException cimException;
412
413 msg = new CIMEnumerateInstancesResponseMessage(
414 messageId,
415 cimException,
416 QueueIdStack());
417
|
418 karl 1.12.2.1 // Instead of resolving the binary data here, we delegate this
|
419 r.kieninger 1.9 // to a later point in time when the data is actually retrieved through
|
420 karl 1.12.2.1 // a call to CIMResponseData::getInstances, which
421 // resolves the binary data as it is passed to the next interface.
|
422 r.kieninger 1.9 // This allows an alternate client implementation to gain direct access
423 // to the binary data and pass this for example to the JNI implementation
424 // of the JSR48 CIM Client for Java.
|
425 thilo.boehm 1.10 CIMResponseData& responseData = msg->getResponseData();
|
426 karl 1.12.2.3
427 // [PROPERTY-LIST]
428 CIMPropertyList propertyList;
429 if (!in.getPropertyList(propertyList))
430 {
431 return 0;
432 }
433 responseData.setPropertyList(propertyList);
434
|
435 karl 1.12 responseData.setRemainingBinaryData(in);
|
436 r.kieninger 1.9
437 msg->binaryRequest=true;
|
438 mike 1.1 return msg;
439 }
440
441 //==============================================================================
442 //
443 // EnumerateInstanceNames
444 //
445 //==============================================================================
446
|
447 kumpf 1.6 static CIMEnumerateInstanceNamesRequestMessage*
|
448 mike 1.1 _decodeEnumerateInstanceNamesRequest(
449 CIMBuffer& in,
450 Uint32 queueId,
451 Uint32 returnQueueId,
452 const String& messageId)
453 {
454 STAT_GETSTARTTIME
455
456 // [NAMESPACE]
457 CIMNamespaceName nameSpace;
458
459 if (!in.getNamespaceName(nameSpace))
460 return 0;
461
462 // [CLASSNAME]
463 CIMName className;
464
465 if (!in.getName(className))
466 return 0;
467
468 AutoPtr<CIMEnumerateInstanceNamesRequestMessage> request(
469 mike 1.1 new CIMEnumerateInstanceNamesRequestMessage(
470 messageId,
471 nameSpace,
472 className,
473 QueueIdStack(queueId, returnQueueId)));
474
475 request->binaryRequest = true;
476
477 STAT_SERVERSTART
478
479 return request.release();
480 }
481
|
482 kumpf 1.6 static CIMEnumerateInstanceNamesResponseMessage*
|
483 mike 1.1 _decodeEnumerateInstanceNamesResponse(
484 CIMBuffer& in,
485 const String& messageId)
486 {
487 CIMEnumerateInstanceNamesResponseMessage* msg;
488 CIMException cimException;
489
490 msg = new CIMEnumerateInstanceNamesResponseMessage(
491 messageId,
492 cimException,
|
493 thilo.boehm 1.10 QueueIdStack());
494
|
495 karl 1.12.2.1 // Instead of resolving the binary data here, we delegate this
|
496 thilo.boehm 1.10 // to a later point in time when the data is actually retrieved through
|
497 karl 1.12.2.1 // a call to CIMResponseData::getInstanceNames, which
498 // resolves the binary data as it is passed to the next interface.
|
499 thilo.boehm 1.10 // This allows an alternate client implementation to gain direct access
500 // to the binary data and pass this for example to the JNI implementation
501 // of the JSR48 CIM Client for Java.
502 CIMResponseData& responseData = msg->getResponseData();
|
503 karl 1.12 responseData.setRemainingBinaryData(in);
|
504 mike 1.1
505 msg->binaryRequest = true;
506 return msg;
507 }
508
509 static void _encodeEnumerateInstanceNamesRequest(
510 CIMBuffer& buf,
511 CIMEnumerateInstanceNamesRequestMessage* msg,
512 CIMName& name)
513 {
514 static const CIMName NAME("EnumerateInstanceNames");
515 name = NAME;
516
517 // [HEADER]
518
519 _putHeader(buf, 0, msg->messageId, OP_EnumerateInstanceNames);
520
521 // [NAMESPACE]
522 buf.putNamespaceName(msg->nameSpace);
523
524 // [CLASSNAME]
525 mike 1.1 buf.putName(msg->className);
526 }
527
528 static void _encodeEnumerateInstanceNamesResponseBody(
529 CIMBuffer& out,
|
530 thilo.boehm 1.10 CIMResponseData& data,
|
531 mike 1.1 CIMName& name)
532 {
533 static const CIMName NAME("EnumerateInstanceNames");
534 name = NAME;
535
|
536 thilo.boehm 1.10 data.encodeBinaryResponse(out);
|
537 mike 1.1 }
538
539 //==============================================================================
540 //
541 // GetInstance
542 //
543 //==============================================================================
544
545 static CIMGetInstanceRequestMessage* _decodeGetInstanceRequest(
546 CIMBuffer& in,
547 Uint32 queueId,
548 Uint32 returnQueueId,
549 Uint32 flags,
550 const String& messageId)
551 {
552 STAT_GETSTARTTIME
553
554 // [FLAGS]
|
555 karl 1.12.2.5 #ifndef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
556 mike 1.1 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
|
557 karl 1.12.2.5 #endif
|
558 mike 1.1 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
559
560 // [NAMESPACE]
561 CIMNamespaceName nameSpace;
562
563 if (!in.getNamespaceName(nameSpace))
564 return 0;
565
566 // [INSTANCE-NAME]
567 CIMObjectPath instanceName;
568
569 if (!in.getObjectPath(instanceName))
570 return 0;
571
572 // [PROPERTY-LIST]
573 CIMPropertyList propertyList;
574 if (!in.getPropertyList(propertyList))
575 return 0;
576
577 AutoPtr<CIMGetInstanceRequestMessage> request(
578 new CIMGetInstanceRequestMessage(
579 mike 1.1 messageId,
580 nameSpace,
581 instanceName,
582 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
583 false,
584 #else
585 includeQualifiers,
586 #endif
587 includeClassOrigin,
588 propertyList,
589 QueueIdStack(queueId, returnQueueId)));
590
591 request->binaryRequest = true;
592
593 STAT_SERVERSTART
594
595 return request.release();
596 }
597
598 static CIMGetInstanceResponseMessage* _decodeGetInstanceResponse(
599 CIMBuffer& in,
600 mike 1.1 const String& messageId)
601 {
602 CIMGetInstanceResponseMessage* msg;
603 CIMException cimException;
604
605 msg = new CIMGetInstanceResponseMessage(
606 messageId,
607 cimException,
608 QueueIdStack());
609
|
610 karl 1.12.2.1 // Instead of resolving the binary data here, we delegate this
|
611 r.kieninger 1.9 // to a later point in time when the data is actually retrieved through
|
612 karl 1.12.2.1 // a call to CIMResponseData::getInstances, which
613 // resolves the binary data as it is passed to the next interface.
|
614 r.kieninger 1.9 // This allows an alternate client implementation to gain direct access
615 // to the binary data and pass this for example to the JNI implementation
616 // of the JSR48 CIM Client for Java.
|
617 thilo.boehm 1.10 CIMResponseData& responseData = msg->getResponseData();
|
618 karl 1.12 responseData.setRemainingBinaryData(in);
|
619 r.kieninger 1.9
|
620 mike 1.1 msg->binaryRequest = true;
621 return msg;
622 }
623
624 static void _encodeGetInstanceRequest(
625 CIMBuffer& buf,
626 CIMGetInstanceRequestMessage* msg,
627 CIMName& name)
628 {
629 static const CIMName NAME("GetInstance");
630 name = NAME;
631
632 // [HEADER]
633
634 Uint32 flags = 0;
635
636 if (msg->includeQualifiers)
637 flags |= INCLUDE_QUALIFIERS;
638
639 if (msg->includeClassOrigin)
640 flags |= INCLUDE_CLASS_ORIGIN;
641 mike 1.1
642 _putHeader(buf, flags, msg->messageId, OP_GetInstance);
643
644 // [NAMESPACE]
645 buf.putNamespaceName(msg->nameSpace);
646
647 // [INSTANCE-NAME]
648 buf.putObjectPath(msg->instanceName);
649
650 // [PROPERTY-LIST]
651 buf.putPropertyList(msg->propertyList);
652 }
653
654 static void _encodeGetInstanceResponseBody(
655 CIMBuffer& out,
|
656 thilo.boehm 1.10 CIMResponseData& data,
|
657 mike 1.1 CIMName& name)
658 {
659 static const CIMName NAME("GetInstance");
660 name = NAME;
661
|
662 r.kieninger 1.8 data.encodeBinaryResponse(out);
|
663 mike 1.1 }
664
665 //==============================================================================
666 //
667 // CreateInstance
668 //
669 //==============================================================================
670
671 static void _encodeCreateInstanceRequest(
672 CIMBuffer& buf,
673 CIMCreateInstanceRequestMessage* msg,
674 CIMName& name)
675 {
676 static const CIMName NAME("CreateInstance");
677 name = NAME;
678
679 // [HEADER]
680 _putHeader(buf, 0, msg->messageId, OP_CreateInstance);
681
682 // [NAMESPACE]
683 buf.putNamespaceName(msg->nameSpace);
684 mike 1.1
685 // [NEW-INSTANCE]
686 buf.putInstance(msg->newInstance, false);
687 }
688
689 static CIMCreateInstanceRequestMessage* _decodeCreateInstanceRequest(
690 CIMBuffer& in,
691 Uint32 queueId,
692 Uint32 returnQueueId,
693 const String& messageId)
694 {
695 STAT_GETSTARTTIME
696
697 // [NAMESPACE]
698
699 CIMNamespaceName nameSpace;
700
701 if (!in.getNamespaceName(nameSpace))
702 return 0;
703
704 // [NEW-INSTANCE]
705 mike 1.1
706 CIMInstance newInstance;
707
708 if (!in.getInstance(newInstance))
709 return 0;
710
711 AutoPtr<CIMCreateInstanceRequestMessage> request(
712 new CIMCreateInstanceRequestMessage(
713 messageId,
714 nameSpace,
715 newInstance,
716 QueueIdStack(queueId, returnQueueId)));
717
718 request->binaryRequest = true;
719
720 STAT_SERVERSTART
721
722 return request.release();
723 }
724
725 static void _encodeCreateInstanceResponseBody(
726 mike 1.1 CIMBuffer& out,
727 CIMCreateInstanceResponseMessage* msg,
728 CIMName& name)
729 {
730 static const CIMName NAME("CreateInstance");
731 name = NAME;
732
733 out.putObjectPath(msg->instanceName, false);
734 }
735
736 static CIMCreateInstanceResponseMessage* _decodeCreateInstanceResponse(
737 CIMBuffer& in,
738 const String& messageId)
739 {
740 CIMObjectPath instanceName;
741
742 if (!in.getObjectPath(instanceName))
743 return 0;
744
745 CIMCreateInstanceResponseMessage* msg;
746 CIMException cimException;
747 mike 1.1
748 msg = new CIMCreateInstanceResponseMessage(
749 messageId,
750 cimException,
751 QueueIdStack(),
752 instanceName);
753
754 msg->binaryRequest = true;
755
756 return msg;
757 }
758
759 //==============================================================================
760 //
761 // ModifyInstance
762 //
763 //==============================================================================
764
765 static void _encodeModifyInstanceRequest(
766 CIMBuffer& buf,
767 CIMModifyInstanceRequestMessage* msg,
768 mike 1.1 CIMName& name)
769 {
770 /* See ../Client/CIMOperationRequestEncoder.cpp */
771
772 static const CIMName NAME("ModifyInstance");
773 name = NAME;
774
775 // [HEADER]
776
777 Uint32 flags = 0;
778
779 if (msg->includeQualifiers)
780 flags |= INCLUDE_QUALIFIERS;
781
782 _putHeader(buf, flags, msg->messageId, OP_ModifyInstance);
783
784 // [NAMESPACE]
785 buf.putNamespaceName(msg->nameSpace);
786
787 // [MODIFIED-INSTANCE]
788 buf.putInstance(msg->modifiedInstance, false);
789 mike 1.1
790 // [PROPERTY-LIST]
791 buf.putPropertyList(msg->propertyList);
792 }
793
794 static CIMModifyInstanceRequestMessage* _decodeModifyInstanceRequest(
795 CIMBuffer& in,
796 Uint32 queueId,
797 Uint32 returnQueueId,
798 Uint32 flags,
799 const String& messageId)
800 {
801 /* See ../Server/CIMOperationRequestDecoder.cpp */
802
803 STAT_GETSTARTTIME
804
805 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
806
807 // [NAMESPACE]
808
809 CIMNamespaceName nameSpace;
810 mike 1.1
811 if (!in.getNamespaceName(nameSpace))
812 return 0;
813
814 // [MODIFIED-INSTANCE]
815 CIMInstance modifiedInstance;
816
817 if (!in.getInstance(modifiedInstance))
818 return 0;
819
820 // [PROPERTY-LIST]
821 CIMPropertyList propertyList;
822 if (!in.getPropertyList(propertyList))
823 return 0;
824
825 AutoPtr<CIMModifyInstanceRequestMessage> request(
826 new CIMModifyInstanceRequestMessage(
827 messageId,
828 nameSpace,
829 modifiedInstance,
830 includeQualifiers,
831 mike 1.1 propertyList,
832 QueueIdStack(queueId, returnQueueId)));
833
834 request->binaryRequest = true;
835
836 STAT_SERVERSTART
837
838 return request.release();
839 }
840
841 static void _encodeModifyInstanceResponseBody(
842 CIMName& name)
843 {
844 /* See ../Server/CIMOperationResponseEncoder.cpp */
845
846 static const CIMName NAME("ModifyInstance");
847 name = NAME;
848 }
849
850 static CIMModifyInstanceResponseMessage* _decodeModifyInstanceResponse(
851 CIMBuffer& in,
852 mike 1.1 const String& messageId)
853 {
854 /* See ../Client/CIMOperationResponseDecoder.cpp */
855
856 Array<CIMInstance> instances;
857
858 while (in.more())
859 {
860 Array<CIMInstance> tmp;
861
862 if (!in.getInstanceA(tmp))
863 return 0;
864
865 instances.append(tmp.getData(), tmp.size());
866 }
867
868 CIMModifyInstanceResponseMessage* msg;
869 CIMException cimException;
870
871 msg = new CIMModifyInstanceResponseMessage(
872 messageId,
873 mike 1.1 cimException,
874 QueueIdStack());
875
876 msg->binaryRequest = true;
877 return msg;
878 }
879
880 //==============================================================================
881 //
882 // DeleteInstance
883 //
884 //==============================================================================
885
886 static void _encodeDeleteInstanceRequest(
887 CIMBuffer& buf,
888 CIMDeleteInstanceRequestMessage* msg,
889 CIMName& name)
890 {
891 /* See ../Client/CIMOperationRequestEncoder.cpp */
892
893 static const CIMName NAME("DeleteInstance");
894 mike 1.1 name = NAME;
895
896 // [HEADER]
897 _putHeader(buf, 0, msg->messageId, OP_DeleteInstance);
898
899 // [NAMESPACE]
900 buf.putNamespaceName(msg->nameSpace);
901
902 // [INSTANCE-NAME]
903 buf.putObjectPath(msg->instanceName, false);
904 }
905
906 static CIMDeleteInstanceRequestMessage* _decodeDeleteInstanceRequest(
907 CIMBuffer& in,
908 Uint32 queueId,
909 Uint32 returnQueueId,
910 const String& messageId)
911 {
912 /* See ../Server/CIMOperationRequestDecoder.cpp */
913
914 STAT_GETSTARTTIME
915 mike 1.1
916 // [NAMESPACE]
917 CIMNamespaceName nameSpace;
918
919 if (!in.getNamespaceName(nameSpace))
920 return 0;
921
922 // [INSTANCE-NAME]
923 CIMObjectPath instanceName;
924
925 if (!in.getObjectPath(instanceName))
926 return 0;
927
928 AutoPtr<CIMDeleteInstanceRequestMessage> request(
929 new CIMDeleteInstanceRequestMessage(
930 messageId,
931 nameSpace,
932 instanceName,
933 QueueIdStack(queueId, returnQueueId)));
934
935 request->binaryRequest = true;
936 mike 1.1
937 STAT_SERVERSTART
938
939 return request.release();
940 }
941
942 static void _encodeDeleteInstanceResponseBody(
943 CIMName& name)
944 {
945 /* See ../Server/CIMOperationResponseEncoder.cpp */
946
947 static const CIMName NAME("DeleteInstance");
948 name = NAME;
949 }
950
951 static CIMDeleteInstanceResponseMessage* _decodeDeleteInstanceResponse(
952 const String& messageId)
953 {
954 /* See ../Client/CIMOperationResponseDecoder.cpp */
955
956 CIMDeleteInstanceResponseMessage* msg;
957 mike 1.1 CIMException cimException;
958
959 msg = new CIMDeleteInstanceResponseMessage(
960 messageId,
961 cimException,
962 QueueIdStack());
963
964 msg->binaryRequest = true;
965 return msg;
966 }
967
968 //==============================================================================
969 //
970 // Associators
971 //
972 //==============================================================================
973
974 static void _encodeAssociatorsRequest(
975 CIMBuffer& buf,
976 CIMAssociatorsRequestMessage* msg,
977 CIMName& name)
978 mike 1.1 {
979 /* See ../Client/CIMOperationRequestEncoder.cpp */
980
981 static const CIMName NAME("Associators");
982 name = NAME;
983
984 // [HEADER]
985
986 Uint32 flags = 0;
987
988 if (msg->includeQualifiers)
989 flags |= INCLUDE_QUALIFIERS;
990
991 if (msg->includeClassOrigin)
992 flags |= INCLUDE_CLASS_ORIGIN;
993
994 _putHeader(buf, flags, msg->messageId, OP_Associators);
995
996 // [NAMESPACE]
997 buf.putNamespaceName(msg->nameSpace);
998
999 mike 1.1 // [OBJECT-NAME]
1000 buf.putObjectPath(msg->objectName);
1001
1002 // [ASSOC-CLASS]
1003 buf.putName(msg->assocClass);
1004
1005 // [RESULT-CLASS]
1006 buf.putName(msg->resultClass);
1007
1008 // [ROLE]
1009 buf.putString(msg->role);
1010
1011 // [RESULT-ROLE]
1012 buf.putString(msg->resultRole);
1013
1014 // [PROPERTY-LIST]
1015 buf.putPropertyList(msg->propertyList);
1016 }
1017
1018 static CIMAssociatorsRequestMessage* _decodeAssociatorsRequest(
1019 CIMBuffer& in,
1020 mike 1.1 Uint32 queueId,
1021 Uint32 returnQueueId,
1022 Uint32 flags,
1023 const String& messageId)
1024 {
1025 /* See ../Server/CIMOperationRequestDecoder.cpp */
1026
1027 STAT_GETSTARTTIME
1028
1029 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
1030 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
1031
1032 // [NAMESPACE]
1033
1034 CIMNamespaceName nameSpace;
1035
1036 if (!in.getNamespaceName(nameSpace))
1037 return 0;
1038
1039 // [OBJECT-NAME]
1040 CIMObjectPath objectName;
1041 mike 1.1
1042 if (!in.getObjectPath(objectName))
1043 return 0;
1044
1045 // [ASSOC-CLASS]
1046
1047 CIMName assocClass;
1048
1049 if (!in.getName(assocClass))
1050 return 0;
1051
1052 // [RESULT-CLASS]
1053
1054 CIMName resultClass;
1055
1056 if (!in.getName(resultClass))
1057 return 0;
1058
1059 // [ROLE]
1060
1061 String role;
1062 mike 1.1
1063 if (!in.getString(role))
1064 return 0;
1065
1066 // [RESULT-ROLE]
1067
1068 String resultRole;
1069
1070 if (!in.getString(resultRole))
1071 return 0;
1072
1073 // [PROPERTY-LIST]
1074
1075 CIMPropertyList propertyList;
1076
1077 if (!in.getPropertyList(propertyList))
1078 return 0;
1079
1080 AutoPtr<CIMAssociatorsRequestMessage> request(
1081 new CIMAssociatorsRequestMessage(
1082 messageId,
1083 mike 1.1 nameSpace,
1084 objectName,
1085 assocClass,
1086 resultClass,
1087 role,
1088 resultRole,
1089 includeQualifiers,
1090 includeClassOrigin,
1091 propertyList,
1092 QueueIdStack(queueId, returnQueueId)));
1093
1094 request->binaryRequest = true;
1095
1096 STAT_SERVERSTART
1097
1098 return request.release();
1099 }
1100
1101 static void _encodeAssociatorsResponseBody(
1102 CIMBuffer& out,
|
1103 thilo.boehm 1.10 CIMResponseData& data,
|
1104 mike 1.1 CIMName& name)
1105 {
1106 /* See ../Server/CIMOperationResponseEncoder.cpp */
1107
1108 static const CIMName NAME("Associators");
1109 name = NAME;
1110
|
1111 r.kieninger 1.8
1112 data.encodeBinaryResponse(out);
|
1113 mike 1.1 }
1114
1115 static CIMAssociatorsResponseMessage* _decodeAssociatorsResponse(
1116 CIMBuffer& in,
1117 const String& messageId)
1118 {
1119 CIMAssociatorsResponseMessage* msg;
1120 CIMException cimException;
1121
1122 msg = new CIMAssociatorsResponseMessage(
1123 messageId,
1124 cimException,
|
1125 r.kieninger 1.8 QueueIdStack());
|
1126 mike 1.1
|
1127 karl 1.12.2.1 // Instead of resolving the binary data here, we delegate this
|
1128 r.kieninger 1.9 // to a later point in time when the data is actually retrieved through
|
1129 karl 1.12.2.1 // a call to CIMResponseData::getObjects, which
1130 // resolves the binary data as it is passed to the next interface.
|
1131 r.kieninger 1.9 // This allows an alternate client implementation to gain direct access
1132 // to the binary data and pass this for example to the JNI implementation
1133 // of the JSR48 CIM Client for Java.
|
1134 thilo.boehm 1.10 CIMResponseData& responseData = msg->getResponseData();
|
1135 karl 1.12 responseData.setRemainingBinaryData(in);
|
1136 r.kieninger 1.9
|
1137 mike 1.1 msg->binaryRequest = true;
1138 return msg;
1139 }
1140
1141 //==============================================================================
1142 //
1143 // AssociatorNames
1144 //
1145 //==============================================================================
1146
1147 static void _encodeAssociatorNamesRequest(
1148 CIMBuffer& buf,
1149 CIMAssociatorNamesRequestMessage* msg,
1150 CIMName& name)
1151 {
1152 /* See ../Client/CIMOperationRequestEncoder.cpp */
1153
1154 static const CIMName NAME("AssociatorNames");
1155 name = NAME;
1156
1157 // [HEADER]
1158 mike 1.1 Uint32 flags = 0;
1159
1160 _putHeader(buf, flags, msg->messageId, OP_AssociatorNames);
1161
1162 // [NAMESPACE]
1163 buf.putNamespaceName(msg->nameSpace);
1164
1165 // [OBJECT-NAME]
1166 buf.putObjectPath(msg->objectName);
1167
1168 // [ASSOC-CLASS]
1169 buf.putName(msg->assocClass);
1170
1171 // [RESULT-CLASS]
1172 buf.putName(msg->resultClass);
1173
1174 // [ROLE]
1175 buf.putString(msg->role);
1176
1177 // [RESULT-ROLE]
1178 buf.putString(msg->resultRole);
1179 mike 1.1 }
1180
1181 static CIMAssociatorNamesRequestMessage* _decodeAssociatorNamesRequest(
1182 CIMBuffer& in,
1183 Uint32 queueId,
1184 Uint32 returnQueueId,
1185 const String& messageId)
1186 {
1187 /* See ../Server/CIMOperationRequestDecoder.cpp */
1188
1189 STAT_GETSTARTTIME
1190
1191 // [NAMESPACE]
1192
1193 CIMNamespaceName nameSpace;
1194
1195 if (!in.getNamespaceName(nameSpace))
1196 return 0;
1197
1198 // [OBJECT-NAME]
1199 CIMObjectPath objectName;
1200 mike 1.1
1201 if (!in.getObjectPath(objectName))
1202 return 0;
1203
1204 // [ASSOC-CLASS]
1205
1206 CIMName assocClass;
1207
1208 if (!in.getName(assocClass))
1209 return 0;
1210
1211 // [RESULT-CLASS]
1212
1213 CIMName resultClass;
1214
1215 if (!in.getName(resultClass))
1216 return 0;
1217
1218 // [ROLE]
1219
1220 String role;
1221 mike 1.1
1222 if (!in.getString(role))
1223 return 0;
1224
1225 // [RESULT-ROLE]
1226
1227 String resultRole;
1228
1229 if (!in.getString(resultRole))
1230 return 0;
1231
1232 AutoPtr<CIMAssociatorNamesRequestMessage> request(
1233 new CIMAssociatorNamesRequestMessage(
1234 messageId,
1235 nameSpace,
1236 objectName,
1237 assocClass,
1238 resultClass,
1239 role,
1240 resultRole,
1241 QueueIdStack(queueId, returnQueueId)));
1242 mike 1.1
1243 request->binaryRequest = true;
1244
1245 STAT_SERVERSTART
1246
1247 return request.release();
1248 }
1249
1250 static void _encodeAssociatorNamesResponseBody(
1251 CIMBuffer& out,
|
1252 thilo.boehm 1.10 CIMResponseData& data,
|
1253 mike 1.1 CIMName& name)
1254 {
1255 /* See ../Server/CIMOperationResponseEncoder.cpp */
1256
1257 static const CIMName NAME("AssociatorNames");
1258 name = NAME;
|
1259 thilo.boehm 1.10 data.encodeBinaryResponse(out);
|
1260 mike 1.1 }
1261
1262 static CIMAssociatorNamesResponseMessage* _decodeAssociatorNamesResponse(
1263 CIMBuffer& in,
1264 const String& messageId)
1265 {
1266 CIMAssociatorNamesResponseMessage* msg;
1267 CIMException cimException;
1268
1269 msg = new CIMAssociatorNamesResponseMessage(
1270 messageId,
1271 cimException,
|
1272 thilo.boehm 1.10 QueueIdStack());
1273
|
1274 karl 1.12.2.1 // Instead of resolving the binary data here, we delegate this
|
1275 thilo.boehm 1.10 // to a later point in time when the data is actually retrieved through
|
1276 karl 1.12.2.1 // a call to CIMResponseData::getInstanceNames, which
1277 // resolves the binary data as it is passed to the next interface.
|
1278 thilo.boehm 1.10 // This allows an alternate client implementation to gain direct access
1279 // to the binary data and pass this for example to the JNI implementation
1280 // of the JSR48 CIM Client for Java.
1281 CIMResponseData& responseData = msg->getResponseData();
|
1282 karl 1.12 responseData.setRemainingBinaryData(in);
|
1283 mike 1.1
1284 msg->binaryRequest = true;
1285 return msg;
1286 }
1287
1288 //==============================================================================
1289 //
1290 // References
1291 //
1292 //==============================================================================
1293
1294 static void _encodeReferencesRequest(
1295 CIMBuffer& buf,
1296 CIMReferencesRequestMessage* msg,
1297 CIMName& name)
1298 {
1299 /* See ../Client/CIMOperationRequestEncoder.cpp */
1300
1301 static const CIMName NAME("References");
1302 name = NAME;
1303
1304 mike 1.1 // [HEADER]
1305
1306 Uint32 flags = 0;
1307
1308 if (msg->includeQualifiers)
1309 flags |= INCLUDE_QUALIFIERS;
1310
1311 if (msg->includeClassOrigin)
1312 flags |= INCLUDE_CLASS_ORIGIN;
1313
1314 _putHeader(buf, flags, msg->messageId, OP_References);
1315
1316 // [NAMESPACE]
1317 buf.putNamespaceName(msg->nameSpace);
1318
1319 // [OBJECT-NAME]
1320 buf.putObjectPath(msg->objectName);
1321
1322 // [RESULT-CLASS]
1323 buf.putName(msg->resultClass);
1324
1325 mike 1.1 // [ROLE]
1326 buf.putString(msg->role);
1327
1328 // [PROPERTY-LIST]
1329 buf.putPropertyList(msg->propertyList);
1330 }
1331
1332 static CIMReferencesRequestMessage* _decodeReferencesRequest(
1333 CIMBuffer& in,
1334 Uint32 queueId,
1335 Uint32 returnQueueId,
1336 Uint32 flags,
1337 const String& messageId)
1338 {
1339 /* See ../Server/CIMOperationRequestDecoder.cpp */
1340
1341 STAT_GETSTARTTIME
1342
1343 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
1344 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
1345
1346 mike 1.1 // [NAMESPACE]
1347
1348 CIMNamespaceName nameSpace;
1349
1350 if (!in.getNamespaceName(nameSpace))
1351 return 0;
1352
1353 // [OBJECT-NAME]
1354
1355 CIMObjectPath objectName;
1356
1357 if (!in.getObjectPath(objectName))
1358 return 0;
1359
1360 // [RESULT-CLASS]
1361
1362 CIMName resultClass;
1363
1364 if (!in.getName(resultClass))
1365 return 0;
1366
1367 mike 1.1 // [ROLE]
1368
1369 String role;
1370
1371 if (!in.getString(role))
1372 return 0;
1373
1374 // [PROPERTY-LIST]
1375
1376 CIMPropertyList propertyList;
1377
1378 if (!in.getPropertyList(propertyList))
1379 return 0;
1380
1381 AutoPtr<CIMReferencesRequestMessage> request(
1382 new CIMReferencesRequestMessage(
1383 messageId,
1384 nameSpace,
1385 objectName,
1386 resultClass,
1387 role,
1388 mike 1.1 includeQualifiers,
1389 includeClassOrigin,
1390 propertyList,
1391 QueueIdStack(queueId, returnQueueId)));
1392
1393 request->binaryRequest = true;
1394
1395 STAT_SERVERSTART
1396
1397 return request.release();
1398 }
1399
1400 static void _encodeReferencesResponseBody(
1401 CIMBuffer& out,
|
1402 thilo.boehm 1.10 CIMResponseData& data,
|
1403 mike 1.1 CIMName& name)
1404 {
1405 /* See ../Server/CIMOperationResponseEncoder.cpp */
1406
1407 static const CIMName NAME("References");
1408 name = NAME;
1409
|
1410 thilo.boehm 1.10 data.encodeBinaryResponse(out);
|
1411 mike 1.1 }
1412
1413 static CIMReferencesResponseMessage* _decodeReferencesResponse(
1414 CIMBuffer& in,
1415 const String& messageId)
1416 {
1417 CIMReferencesResponseMessage* msg;
1418 CIMException cimException;
1419
1420 msg = new CIMReferencesResponseMessage(
1421 messageId,
1422 cimException,
|
1423 thilo.boehm 1.10 QueueIdStack());
1424
1425 // Instead of resolving the binary data right here, we delegate this
1426 // to a later point in time when the data is actually retrieved through
1427 // a call to getNamedInstances, which is going to resolve the binary
1428 // data when the callback function is registered.
1429 // This allows an alternate client implementation to gain direct access
1430 // to the binary data and pass this for example to the JNI implementation
1431 // of the JSR48 CIM Client for Java.
1432 CIMResponseData& responseData = msg->getResponseData();
|
1433 karl 1.12 responseData.setRemainingBinaryData(in);
|
1434 mike 1.1
1435 msg->binaryRequest = true;
1436 return msg;
1437 }
1438
1439 //==============================================================================
1440 //
1441 // ReferenceNames
1442 //
1443 //==============================================================================
1444
1445 static void _encodeReferenceNamesRequest(
1446 CIMBuffer& buf,
1447 CIMReferenceNamesRequestMessage* msg,
1448 CIMName& name)
1449 {
1450 /* See ../Client/CIMOperationRequestEncoder.cpp */
1451
1452 static const CIMName NAME("ReferenceNames");
1453 name = NAME;
1454
1455 mike 1.1 // [HEADER]
1456 Uint32 flags = 0;
1457
1458 _putHeader(buf, flags, msg->messageId, OP_ReferenceNames);
1459
1460 // [NAMESPACE]
1461 buf.putNamespaceName(msg->nameSpace);
1462
1463 // [OBJECT-NAME]
1464 buf.putObjectPath(msg->objectName);
1465
1466 // [RESULT-CLASS]
1467 buf.putName(msg->resultClass);
1468
1469 // [ROLE]
1470 buf.putString(msg->role);
1471 }
1472
1473 static CIMReferenceNamesRequestMessage* _decodeReferenceNamesRequest(
1474 CIMBuffer& in,
1475 Uint32 queueId,
1476 mike 1.1 Uint32 returnQueueId,
1477 const String& messageId)
1478 {
1479 /* See ../Server/CIMOperationRequestDecoder.cpp */
1480
1481 STAT_GETSTARTTIME
1482
1483 // [NAMESPACE]
1484
1485 CIMNamespaceName nameSpace;
1486
1487 if (!in.getNamespaceName(nameSpace))
1488 return 0;
1489
1490 // [OBJECT-NAME]
1491 CIMObjectPath objectName;
1492
1493 if (!in.getObjectPath(objectName))
1494 return 0;
1495
1496 // [RESULT-CLASS]
1497 mike 1.1
1498 CIMName resultClass;
1499
1500 if (!in.getName(resultClass))
1501 return 0;
1502
1503 // [ROLE]
1504
1505 String role;
1506
1507 if (!in.getString(role))
1508 return 0;
1509
1510 AutoPtr<CIMReferenceNamesRequestMessage> request(
1511 new CIMReferenceNamesRequestMessage(
1512 messageId,
1513 nameSpace,
1514 objectName,
1515 resultClass,
1516 role,
1517 QueueIdStack(queueId, returnQueueId)));
1518 mike 1.1
1519 request->binaryRequest = true;
1520
1521 STAT_SERVERSTART
1522
1523 return request.release();
1524 }
1525
1526 static void _encodeReferenceNamesResponseBody(
1527 CIMBuffer& out,
|
1528 thilo.boehm 1.10 CIMResponseData& data,
|
1529 mike 1.1 CIMName& name)
1530 {
1531 /* See ../Server/CIMOperationResponseEncoder.cpp */
1532
1533 static const CIMName NAME("ReferenceNames");
1534 name = NAME;
|
1535 thilo.boehm 1.10 data.encodeBinaryResponse(out);
|
1536 mike 1.1 }
1537
1538 static CIMReferenceNamesResponseMessage* _decodeReferenceNamesResponse(
1539 CIMBuffer& in,
1540 const String& messageId)
1541 {
1542 /* See ../Client/CIMOperationResponseDecoder.cpp */
1543
1544 CIMReferenceNamesResponseMessage* msg;
1545 CIMException cimException;
1546
1547 msg = new CIMReferenceNamesResponseMessage(
1548 messageId,
1549 cimException,
|
1550 thilo.boehm 1.10 QueueIdStack());
1551
|
1552 karl 1.12.2.1 // Instead of resolving the binary data here, we delegate this
|
1553 thilo.boehm 1.10 // to a later point in time when the data is actually retrieved through
|
1554 karl 1.12.2.1 // a call to CIMResponseData::getInstanceNames, which
1555 // resolves the binary data as it is passed to the next interface.
|
1556 thilo.boehm 1.10 // This allows an alternate client implementation to gain direct access
1557 // to the binary data and pass this for example to the JNI implementation
1558 // of the JSR48 CIM Client for Java.
1559 CIMResponseData& responseData = msg->getResponseData();
|
1560 karl 1.12 responseData.setRemainingBinaryData(in);
|
1561 mike 1.1
1562 msg->binaryRequest = true;
|
1563 thilo.boehm 1.10
|
1564 mike 1.1 return msg;
1565 }
1566
1567 //==============================================================================
1568 //
1569 // GetClass
1570 //
1571 //==============================================================================
1572
1573 static void _encodeGetClassRequest(
1574 CIMBuffer& buf,
1575 CIMGetClassRequestMessage* msg,
1576 CIMName& name)
1577 {
1578 /* See ../Client/CIMOperationRequestEncoder.cpp */
1579
1580 static const CIMName NAME("GetClass");
1581 name = NAME;
1582
1583 // [HEADER]
1584
1585 mike 1.1 Uint32 flags = 0;
1586
1587 if (msg->localOnly)
1588 flags |= LOCAL_ONLY;
1589
1590 if (msg->includeQualifiers)
1591 flags |= INCLUDE_QUALIFIERS;
1592
1593 if (msg->includeClassOrigin)
1594 flags |= INCLUDE_CLASS_ORIGIN;
1595
1596 _putHeader(buf, flags, msg->messageId, OP_GetClass);
1597
1598 // [NAMESPACE]
1599 buf.putNamespaceName(msg->nameSpace);
1600
1601 // [CLASSNAME]
1602 buf.putName(msg->className);
1603
1604 // [PROPERTY-LIST]
1605 buf.putPropertyList(msg->propertyList);
1606 mike 1.1 }
1607
1608 static CIMGetClassRequestMessage* _decodeGetClassRequest(
1609 CIMBuffer& in,
1610 Uint32 queueId,
1611 Uint32 returnQueueId,
1612 Uint32 flags,
1613 const String& messageId)
1614 {
1615 /* See ../Server/CIMOperationRequestDecoder.cpp */
1616
1617 STAT_GETSTARTTIME
1618
1619 Boolean localOnly = flags & LOCAL_ONLY;
1620 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
1621 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
1622
1623 // [NAMESPACE]
1624
1625 CIMNamespaceName nameSpace;
1626
1627 mike 1.1 if (!in.getNamespaceName(nameSpace))
1628 return 0;
1629
1630 // [CLASSNAME]
1631 CIMName className;
1632
1633 if (!in.getName(className))
1634 return 0;
1635
1636 // [PROPERTY-LIST]
1637 CIMPropertyList propertyList;
1638 if (!in.getPropertyList(propertyList))
1639 return 0;
1640
1641 AutoPtr<CIMGetClassRequestMessage> request(new CIMGetClassRequestMessage(
1642 messageId,
1643 nameSpace,
1644 className,
1645 localOnly,
1646 includeQualifiers,
1647 includeClassOrigin,
1648 mike 1.1 propertyList,
1649 QueueIdStack(queueId, returnQueueId)));
1650
1651 request->binaryRequest = true;
1652
1653 STAT_SERVERSTART
1654
1655 return request.release();
1656 }
1657
1658 static void _encodeGetClassResponseBody(
1659 CIMBuffer& out,
1660 CIMGetClassResponseMessage* msg,
1661 CIMName& name)
1662 {
1663 /* See ../Server/CIMOperationResponseEncoder.cpp */
1664
1665 static const CIMName NAME("GetClass");
1666 name = NAME;
1667
1668 out.putClass(msg->cimClass);
1669 mike 1.1 }
1670
1671 static CIMGetClassResponseMessage* _decodeGetClassResponse(
1672 CIMBuffer& in,
1673 const String& messageId)
1674 {
1675 /* See ../Client/CIMOperationResponseDecoder.cpp */
1676
1677 CIMClass cimClass;
1678
1679 if (!in.getClass(cimClass))
1680 return 0;
1681
1682 CIMGetClassResponseMessage* msg;
1683 CIMException cimException;
1684
1685 msg = new CIMGetClassResponseMessage(
1686 messageId,
1687 cimException,
1688 QueueIdStack(),
1689 cimClass);
1690 mike 1.1
1691 msg->binaryRequest = true;
1692 return msg;
1693 }
1694
1695 //==============================================================================
1696 //
1697 // EnumerateClasses
1698 //
1699 //==============================================================================
1700
1701 static void _encodeEnumerateClassesRequest(
1702 CIMBuffer& buf,
1703 CIMEnumerateClassesRequestMessage* msg,
1704 CIMName& name)
1705 {
1706 /* See ../Client/CIMOperationRequestEncoder.cpp */
1707
1708 static const CIMName NAME("EnumerateClasses");
1709 name = NAME;
1710
1711 mike 1.1 // [HEADER]
1712
1713 Uint32 flags = 0;
1714
1715 if (msg->localOnly)
1716 flags |= LOCAL_ONLY;
1717
1718 if (msg->deepInheritance)
1719 flags |= DEEP_INHERITANCE;
1720
1721 if (msg->includeQualifiers)
1722 flags |= INCLUDE_QUALIFIERS;
1723
1724 if (msg->includeClassOrigin)
1725 flags |= INCLUDE_CLASS_ORIGIN;
1726
1727 _putHeader(buf, flags, msg->messageId, OP_EnumerateClasses);
1728
1729 // [NAMESPACE]
1730 buf.putNamespaceName(msg->nameSpace);
1731
1732 mike 1.1 // [CLASSNAME]
1733 buf.putName(msg->className);
1734 }
1735
1736 static CIMEnumerateClassesRequestMessage* _decodeEnumerateClassesRequest(
1737 CIMBuffer& in,
1738 Uint32 queueId,
1739 Uint32 returnQueueId,
1740 Uint32 flags,
1741 const String& messageId)
1742 {
1743 /* See ../Server/CIMOperationRequestDecoder.cpp */
1744
1745 STAT_GETSTARTTIME
1746
1747 Boolean localOnly = flags & LOCAL_ONLY;
1748 Boolean deepInheritance = flags & DEEP_INHERITANCE;
1749 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
1750 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
1751
1752 // [NAMESPACE]
1753 mike 1.1
1754 CIMNamespaceName nameSpace;
1755
1756 if (!in.getNamespaceName(nameSpace))
1757 return 0;
1758
1759 // [CLASSNAME]
1760 CIMName className;
1761
1762 if (!in.getName(className))
1763 return 0;
1764
1765 AutoPtr<CIMEnumerateClassesRequestMessage> request(
1766 new CIMEnumerateClassesRequestMessage(
1767 messageId,
1768 nameSpace,
1769 className,
1770 deepInheritance,
1771 localOnly,
1772 includeQualifiers,
1773 includeClassOrigin,
1774 mike 1.1 QueueIdStack(queueId, returnQueueId)));
1775
1776 request->binaryRequest = true;
1777
1778 STAT_SERVERSTART
1779
1780 return request.release();
1781 }
1782
1783 static void _encodeEnumerateClassesResponseBody(
1784 CIMBuffer& out,
1785 CIMEnumerateClassesResponseMessage* msg,
1786 CIMName& name)
1787 {
1788 /* See ../Server/CIMOperationResponseEncoder.cpp */
1789
1790 static const CIMName NAME("EnumerateClasses");
1791 name = NAME;
1792
1793 out.putClassA(msg->cimClasses);
1794 }
1795 mike 1.1
1796 static CIMEnumerateClassesResponseMessage* _decodeEnumerateClassesResponse(
1797 CIMBuffer& in,
1798 const String& messageId)
1799 {
1800 /* See ../Client/CIMOperationResponseDecoder.cpp */
1801
1802 Array<CIMClass> cimClasses;
1803
1804 while (in.more())
1805 {
1806 Array<CIMClass> tmp;
1807
1808 if (!in.getClassA(tmp))
1809 return 0;
1810
1811 cimClasses.append(tmp.getData(), tmp.size());
1812 }
1813
1814 CIMEnumerateClassesResponseMessage* msg;
1815 CIMException cimException;
1816 mike 1.1
1817 msg = new CIMEnumerateClassesResponseMessage(
1818 messageId,
1819 cimException,
1820 QueueIdStack(),
1821 cimClasses);
1822
1823 msg->binaryRequest = true;
1824 return msg;
1825 }
1826
1827 //==============================================================================
1828 //
1829 // EnumerateClassNames
1830 //
1831 //==============================================================================
1832
1833 static void _encodeEnumerateClassNamesRequest(
1834 CIMBuffer& buf,
1835 CIMEnumerateClassNamesRequestMessage* msg,
1836 CIMName& name)
1837 mike 1.1 {
1838 /* See ../Client/CIMOperationRequestEncoder.cpp */
1839
1840 static const CIMName NAME("EnumerateClassNames");
1841 name = NAME;
1842
1843 // [HEADER]
1844
1845 Uint32 flags = 0;
1846
1847 if (msg->deepInheritance)
1848 flags |= DEEP_INHERITANCE;
1849
1850 _putHeader(buf, flags, msg->messageId, OP_EnumerateClassNames);
1851
1852 // [NAMESPACE]
1853 buf.putNamespaceName(msg->nameSpace);
1854
1855 // [CLASSNAME]
1856 buf.putName(msg->className);
1857 }
1858 mike 1.1
1859 static CIMEnumerateClassNamesRequestMessage* _decodeEnumerateClassNamesRequest(
1860 CIMBuffer& in,
1861 Uint32 queueId,
1862 Uint32 returnQueueId,
1863 Uint32 flags,
1864 const String& messageId)
1865 {
1866 /* See ../Server/CIMOperationRequestDecoder.cpp */
1867
1868 STAT_GETSTARTTIME
1869
1870 Boolean deepInheritance = flags & DEEP_INHERITANCE;
1871
1872 // [NAMESPACE]
1873
1874 CIMNamespaceName nameSpace;
1875
1876 if (!in.getNamespaceName(nameSpace))
1877 return 0;
1878
1879 mike 1.1 // [CLASSNAME]
1880 CIMName className;
1881
1882 if (!in.getName(className))
1883 return 0;
1884
1885 AutoPtr<CIMEnumerateClassNamesRequestMessage> request(
1886 new CIMEnumerateClassNamesRequestMessage(
1887 messageId,
1888 nameSpace,
1889 className,
1890 deepInheritance,
1891 QueueIdStack(queueId, returnQueueId)));
1892
1893 request->binaryRequest = true;
1894
1895 STAT_SERVERSTART
1896
1897 return request.release();
1898 }
1899
1900 mike 1.1 static void _encodeEnumerateClassNamesResponseBody(
1901 CIMBuffer& out,
1902 CIMEnumerateClassNamesResponseMessage* msg,
1903 CIMName& name)
1904 {
1905 /* See ../Server/CIMOperationResponseEncoder.cpp */
1906
1907 static const CIMName NAME("EnumerateClassNames");
1908 name = NAME;
1909
1910 out.putNameA(msg->classNames);
1911 }
1912
|
1913 kumpf 1.6 static CIMEnumerateClassNamesResponseMessage*
|
1914 mike 1.1 _decodeEnumerateClassNamesResponse(
1915 CIMBuffer& in,
1916 const String& messageId)
1917 {
1918 /* See ../Client/CIMOperationResponseDecoder.cpp */
1919
1920 Array<CIMName> classNames;
1921
1922 while (in.more())
1923 {
1924 Array<CIMName> tmp;
1925
1926 if (!in.getNameA(tmp))
1927 return 0;
1928
1929 classNames.append(tmp.getData(), tmp.size());
1930 }
1931
1932 CIMEnumerateClassNamesResponseMessage* msg;
1933 CIMException cimException;
1934
1935 mike 1.1 msg = new CIMEnumerateClassNamesResponseMessage(
1936 messageId,
1937 cimException,
1938 QueueIdStack(),
1939 classNames);
1940
1941 msg->binaryRequest = true;
1942 return msg;
1943 }
1944
1945 //==============================================================================
1946 //
1947 // CreateClass
1948 //
1949 //==============================================================================
1950
1951 static void _encodeCreateClassRequest(
1952 CIMBuffer& buf,
1953 CIMCreateClassRequestMessage* msg,
1954 CIMName& name)
1955 {
1956 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
1957
1958 static const CIMName NAME("CreateClass");
1959 name = NAME;
1960
1961 // [HEADER]
1962 _putHeader(buf, 0, msg->messageId, OP_CreateClass);
1963
1964 // [NAMESPACE]
1965 buf.putNamespaceName(msg->nameSpace);
1966
1967 // [NEW-CLASS]
1968 buf.putClass(msg->newClass);
1969 }
1970
1971 static CIMCreateClassRequestMessage* _decodeCreateClassRequest(
1972 CIMBuffer& in,
1973 Uint32 queueId,
1974 Uint32 returnQueueId,
1975 const String& messageId)
1976 {
1977 mike 1.1 /* See ../Server/CIMOperationRequestDecoder.cpp */
1978
1979 STAT_GETSTARTTIME
1980
1981 // [NAMESPACE]
1982
1983 CIMNamespaceName nameSpace;
1984
1985 if (!in.getNamespaceName(nameSpace))
1986 return 0;
1987
1988 // [NEW-CLASS]
1989 CIMClass newClass;
1990
1991 if (!in.getClass(newClass))
1992 return 0;
1993
1994 AutoPtr<CIMCreateClassRequestMessage> request(
1995 new CIMCreateClassRequestMessage(
1996 messageId,
1997 nameSpace,
1998 mike 1.1 newClass,
1999 QueueIdStack(queueId, returnQueueId)));
2000
2001 request->binaryRequest = true;
2002
2003 STAT_SERVERSTART
2004
2005 return request.release();
2006 }
2007
2008 static void _encodeCreateClassResponseBody(
2009 CIMName& name)
2010 {
2011 /* See ../Server/CIMOperationResponseEncoder.cpp */
2012
2013 static const CIMName NAME("CreateClass");
2014 name = NAME;
2015 }
2016
2017 static CIMCreateClassResponseMessage* _decodeCreateClassResponse(
2018 const String& messageId)
2019 mike 1.1 {
2020 /* See ../Client/CIMOperationResponseDecoder.cpp */
2021
2022 CIMCreateClassResponseMessage* msg;
2023 CIMException cimException;
2024
2025 msg = new CIMCreateClassResponseMessage(
2026 messageId,
2027 cimException,
2028 QueueIdStack());
2029
2030 msg->binaryRequest = true;
2031 return msg;
2032 }
2033
2034 //==============================================================================
2035 //
2036 // DeleteClass
2037 //
2038 //==============================================================================
2039
2040 mike 1.1 static void _encodeDeleteClassRequest(
2041 CIMBuffer& buf,
2042 CIMDeleteClassRequestMessage* msg,
2043 CIMName& name)
2044 {
2045 /* See ../Client/CIMOperationRequestEncoder.cpp */
2046
2047 static const CIMName NAME("DeleteClass");
2048 name = NAME;
2049
2050 // [HEADER]
2051 _putHeader(buf, 0, msg->messageId, OP_DeleteClass);
2052
2053 // [NAMESPACE]
2054 buf.putNamespaceName(msg->nameSpace);
2055
2056 // [CLASSNAME]
2057 buf.putName(msg->className);
2058 }
2059
2060 static CIMDeleteClassRequestMessage* _decodeDeleteClassRequest(
2061 mike 1.1 CIMBuffer& in,
2062 Uint32 queueId,
2063 Uint32 returnQueueId,
2064 const String& messageId)
2065 {
2066 /* See ../Server/CIMOperationRequestDecoder.cpp */
2067
2068 STAT_GETSTARTTIME
2069
2070 // [NAMESPACE]
2071
2072 CIMNamespaceName nameSpace;
2073
2074 if (!in.getNamespaceName(nameSpace))
2075 return 0;
2076
2077 // [CLASSNAME]
2078 CIMName className;
2079
2080 if (!in.getName(className))
2081 return 0;
2082 mike 1.1
2083 AutoPtr<CIMDeleteClassRequestMessage> request(
2084 new CIMDeleteClassRequestMessage(
2085 messageId,
2086 nameSpace,
2087 className,
2088 QueueIdStack(queueId, returnQueueId)));
2089
2090 request->binaryRequest = true;
2091
2092 STAT_SERVERSTART
2093
2094 return request.release();
2095 }
2096
2097 static void _encodeDeleteClassResponseBody(
2098 CIMName& name)
2099 {
2100 /* See ../Server/CIMOperationResponseEncoder.cpp */
2101
2102 static const CIMName NAME("DeleteClass");
2103 mike 1.1 name = NAME;
2104 }
2105
2106 static CIMDeleteClassResponseMessage* _decodeDeleteClassResponse(
2107 const String& messageId)
2108 {
2109 /* See ../Client/CIMOperationResponseDecoder.cpp */
2110
2111 CIMDeleteClassResponseMessage* msg;
2112 CIMException cimException;
2113
2114 msg = new CIMDeleteClassResponseMessage(
2115 messageId,
2116 cimException,
2117 QueueIdStack());
2118
2119 msg->binaryRequest = true;
2120 return msg;
2121 }
2122
2123 //==============================================================================
2124 mike 1.1 //
2125 // ModifyClass
2126 //
2127 //==============================================================================
2128
2129 static void _encodeModifyClassRequest(
2130 CIMBuffer& buf,
2131 CIMModifyClassRequestMessage* msg,
2132 CIMName& name)
2133 {
2134 /* See ../Client/CIMOperationRequestEncoder.cpp */
2135
2136 static const CIMName NAME("ModifyClass");
2137 name = NAME;
2138
2139 // [HEADER]
2140 _putHeader(buf, 0, msg->messageId, OP_ModifyClass);
2141
2142 // [NAMESPACE]
2143 buf.putNamespaceName(msg->nameSpace);
2144
2145 mike 1.1 // [NEW-CLASS]
2146 buf.putClass(msg->modifiedClass);
2147 }
2148
2149 static CIMModifyClassRequestMessage* _decodeModifyClassRequest(
2150 CIMBuffer& in,
2151 Uint32 queueId,
2152 Uint32 returnQueueId,
2153 const String& messageId)
2154 {
2155 /* See ../Server/CIMOperationRequestDecoder.cpp */
2156
2157 STAT_GETSTARTTIME
2158
2159 // [NAMESPACE]
2160
2161 CIMNamespaceName nameSpace;
2162
2163 if (!in.getNamespaceName(nameSpace))
2164 return 0;
2165
2166 mike 1.1 // [MODIFIED-CLASS]
2167 CIMClass modifiedClass;
2168
2169 if (!in.getClass(modifiedClass))
2170 return 0;
2171
2172 AutoPtr<CIMModifyClassRequestMessage> request(
2173 new CIMModifyClassRequestMessage(
2174 messageId,
2175 nameSpace,
2176 modifiedClass,
2177 QueueIdStack(queueId, returnQueueId)));
2178
2179 request->binaryRequest = true;
2180
2181 STAT_SERVERSTART
2182
2183 return request.release();
2184 }
2185
2186 static void _encodeModifyClassResponseBody(
2187 mike 1.1 CIMName& name)
2188 {
2189 /* See ../Server/CIMOperationResponseEncoder.cpp */
2190
2191 static const CIMName NAME("ModifyClass");
2192 name = NAME;
2193 }
2194
2195 static CIMModifyClassResponseMessage* _decodeModifyClassResponse(
2196 const String& messageId)
2197 {
2198 /* See ../Client/CIMOperationResponseDecoder.cpp */
2199
2200 CIMModifyClassResponseMessage* msg;
2201 CIMException cimException;
2202
2203 msg = new CIMModifyClassResponseMessage(
2204 messageId,
2205 cimException,
2206 QueueIdStack());
2207
2208 mike 1.1 msg->binaryRequest = true;
2209 return msg;
2210 }
2211
2212 //==============================================================================
2213 //
2214 // SetQualifier
2215 //
2216 //==============================================================================
2217
2218 static void _encodeSetQualifierRequest(
2219 CIMBuffer& buf,
2220 CIMSetQualifierRequestMessage* msg,
2221 CIMName& name)
2222 {
2223 /* See ../Client/CIMOperationRequestEncoder.cpp */
2224
2225 static const CIMName NAME("SetQualifier");
2226 name = NAME;
2227
2228 // [HEADER]
2229 mike 1.1 _putHeader(buf, 0, msg->messageId, OP_SetQualifier);
2230
2231 // [NAMESPACE]
2232 buf.putNamespaceName(msg->nameSpace);
2233
2234 // [QUALIFIER-DECLARATION]
2235 buf.putQualifierDecl(msg->qualifierDeclaration);
2236 }
2237
2238 static CIMSetQualifierRequestMessage* _decodeSetQualifierRequest(
2239 CIMBuffer& in,
2240 Uint32 queueId,
2241 Uint32 returnQueueId,
2242 const String& messageId)
2243 {
2244 /* See ../Server/CIMOperationRequestDecoder.cpp */
2245
2246 STAT_GETSTARTTIME
2247
2248 // [NAMESPACE]
2249
2250 mike 1.1 CIMNamespaceName nameSpace;
2251
2252 if (!in.getNamespaceName(nameSpace))
2253 return 0;
2254
2255 // [QUALIFIER.DECLARATION]
2256
2257 CIMQualifierDecl qualifierDeclaration;
2258
2259 if (!in.getQualifierDecl(qualifierDeclaration))
2260 return 0;
2261
2262 AutoPtr<CIMSetQualifierRequestMessage> request(
2263 new CIMSetQualifierRequestMessage(
2264 messageId,
2265 nameSpace,
2266 qualifierDeclaration,
2267 QueueIdStack(queueId, returnQueueId)));
2268
2269 request->binaryRequest = true;
2270
2271 mike 1.1 STAT_SERVERSTART
2272
2273 return request.release();
2274 }
2275
2276 static void _encodeSetQualifierResponseBody(
2277 CIMName& name)
2278 {
2279 /* See ../Server/CIMOperationResponseEncoder.cpp */
2280
2281 static const CIMName NAME("SetQualifier");
2282 name = NAME;
2283 }
2284
2285 static CIMSetQualifierResponseMessage* _decodeSetQualifierResponse(
2286 const String& messageId)
2287 {
2288 /* See ../Client/CIMOperationResponseDecoder.cpp */
2289
2290 CIMSetQualifierResponseMessage* msg;
2291 CIMException cimException;
2292 mike 1.1
2293 msg = new CIMSetQualifierResponseMessage(
2294 messageId,
2295 cimException,
2296 QueueIdStack());
2297
2298 msg->binaryRequest = true;
2299 return msg;
2300 }
2301
2302 //==============================================================================
2303 //
2304 // GetQualifier
2305 //
2306 //==============================================================================
2307
2308 static void _encodeGetQualifierRequest(
2309 CIMBuffer& buf,
2310 CIMGetQualifierRequestMessage* msg,
2311 CIMName& name)
2312 {
2313 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
2314
2315 static const CIMName NAME("GetQualifier");
2316 name = NAME;
2317
2318 // [HEADER]
2319 _putHeader(buf, 0, msg->messageId, OP_GetQualifier);
2320
2321 // [NAMESPACE]
2322 buf.putNamespaceName(msg->nameSpace);
2323
2324 // [QUALIFIER-NAME]
2325 buf.putName(msg->qualifierName);
2326 }
2327
2328 static CIMGetQualifierRequestMessage* _decodeGetQualifierRequest(
2329 CIMBuffer& in,
2330 Uint32 queueId,
2331 Uint32 returnQueueId,
2332 const String& messageId)
2333 {
2334 mike 1.1 /* See ../Server/CIMOperationRequestDecoder.cpp */
2335
2336 STAT_GETSTARTTIME
2337
2338 // [NAMESPACE]
2339
2340 CIMNamespaceName nameSpace;
2341
2342 if (!in.getNamespaceName(nameSpace))
2343 return 0;
2344
2345 // [QUALIFIER-NAME]
2346 CIMName qualifierName;
2347
2348 if (!in.getName(qualifierName))
2349 return 0;
2350
2351 AutoPtr<CIMGetQualifierRequestMessage> request(
2352 new CIMGetQualifierRequestMessage(
2353 messageId,
2354 nameSpace,
2355 mike 1.1 qualifierName,
2356 QueueIdStack(queueId, returnQueueId)));
2357
2358 request->binaryRequest = true;
2359
2360 STAT_SERVERSTART
2361
2362 return request.release();
2363 }
2364
2365 static void _encodeGetQualifierResponseBody(
2366 CIMBuffer& out,
2367 CIMGetQualifierResponseMessage* msg,
2368 CIMName& name)
2369 {
2370 /* See ../Server/CIMOperationResponseEncoder.cpp */
2371
2372 static const CIMName NAME("GetQualifier");
2373 name = NAME;
2374
2375 out.putQualifierDecl(msg->cimQualifierDecl);
2376 mike 1.1 }
2377
2378 static CIMGetQualifierResponseMessage* _decodeGetQualifierResponse(
2379 CIMBuffer& in,
2380 const String& messageId)
2381 {
2382 /* See ../Client/CIMOperationResponseDecoder.cpp */
2383
2384 CIMQualifierDecl cimQualifierDecl;
2385
2386 if (!in.getQualifierDecl(cimQualifierDecl))
2387 return 0;
2388
2389 CIMGetQualifierResponseMessage* msg;
2390 CIMException cimException;
2391
2392 msg = new CIMGetQualifierResponseMessage(
2393 messageId,
2394 cimException,
2395 QueueIdStack(),
2396 cimQualifierDecl);
2397 mike 1.1
2398 msg->binaryRequest = true;
2399 return msg;
2400 }
2401
2402 //==============================================================================
2403 //
2404 // DeleteQualifier
2405 //
2406 //==============================================================================
2407
2408 static void _encodeDeleteQualifierRequest(
2409 CIMBuffer& buf,
2410 CIMDeleteQualifierRequestMessage* msg,
2411 CIMName& name)
2412 {
2413 /* See ../Client/CIMOperationRequestEncoder.cpp */
2414
2415 static const CIMName NAME("DeleteQualifier");
2416 name = NAME;
2417
2418 mike 1.1 // [HEADER]
2419 _putHeader(buf, 0, msg->messageId, OP_DeleteQualifier);
2420
2421 // [NAMESPACE]
2422 buf.putNamespaceName(msg->nameSpace);
2423
2424 // [QUALIFIER-NAME]
2425 buf.putName(msg->qualifierName);
2426 }
2427
2428 static CIMDeleteQualifierRequestMessage* _decodeDeleteQualifierRequest(
2429 CIMBuffer& in,
2430 Uint32 queueId,
2431 Uint32 returnQueueId,
2432 const String& messageId)
2433 {
2434 /* See ../Server/CIMOperationRequestDecoder.cpp */
2435
2436 STAT_GETSTARTTIME
2437
2438 // [NAMESPACE]
2439 mike 1.1
2440 CIMNamespaceName nameSpace;
2441
2442 if (!in.getNamespaceName(nameSpace))
2443 return 0;
2444
2445 // [QUALIFIER-NAME]
2446 CIMName qualifierName;
2447
2448 if (!in.getName(qualifierName))
2449 return 0;
2450
2451 AutoPtr<CIMDeleteQualifierRequestMessage> request(
2452 new CIMDeleteQualifierRequestMessage(
2453 messageId,
2454 nameSpace,
2455 qualifierName,
2456 QueueIdStack(queueId, returnQueueId)));
2457
2458 request->binaryRequest = true;
2459
2460 mike 1.1 STAT_SERVERSTART
2461
2462 return request.release();
2463 }
2464
2465 static void _encodeDeleteQualifierResponseBody(
2466 CIMName& name)
2467 {
2468 /* See ../Server/CIMOperationResponseEncoder.cpp */
2469
2470 static const CIMName NAME("DeleteQualifier");
2471 name = NAME;
2472 }
2473
2474 static CIMDeleteQualifierResponseMessage* _decodeDeleteQualifierResponse(
2475 const String& messageId)
2476 {
2477 /* See ../Client/CIMOperationResponseDecoder.cpp */
2478
2479 CIMDeleteQualifierResponseMessage* msg;
2480 CIMException cimException;
2481 mike 1.1
2482 msg = new CIMDeleteQualifierResponseMessage(
2483 messageId,
2484 cimException,
2485 QueueIdStack());
2486
2487 msg->binaryRequest = true;
2488 return msg;
2489 }
2490
2491 //==============================================================================
2492 //
2493 // EnumerateQualifiers
2494 //
2495 //==============================================================================
2496
2497 static void _encodeEnumerateQualifiersRequest(
2498 CIMBuffer& buf,
2499 CIMEnumerateQualifiersRequestMessage* msg,
2500 CIMName& name)
2501 {
2502 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
2503
2504 static const CIMName NAME("EnumerateQualifiers");
2505 name = NAME;
2506
2507 // [HEADER]
2508 _putHeader(buf, 0, msg->messageId, OP_EnumerateQualifiers);
2509
2510 // [NAMESPACE]
2511 buf.putNamespaceName(msg->nameSpace);
2512 }
2513
2514 static CIMEnumerateQualifiersRequestMessage* _decodeEnumerateQualifiersRequest(
2515 CIMBuffer& in,
2516 Uint32 queueId,
2517 Uint32 returnQueueId,
2518 const String& messageId)
2519 {
2520 /* See ../Server/CIMOperationRequestDecoder.cpp */
2521
2522 STAT_GETSTARTTIME
2523 mike 1.1
2524 // [NAMESPACE]
2525
2526 CIMNamespaceName nameSpace;
2527
2528 if (!in.getNamespaceName(nameSpace))
2529 return 0;
2530
2531 AutoPtr<CIMEnumerateQualifiersRequestMessage> request(
2532 new CIMEnumerateQualifiersRequestMessage(
2533 messageId,
2534 nameSpace,
2535 QueueIdStack(queueId, returnQueueId)));
2536
2537 request->binaryRequest = true;
2538
2539 STAT_SERVERSTART
2540
2541 return request.release();
2542 }
2543
2544 mike 1.1 static void _encodeEnumerateQualifiersResponseBody(
2545 CIMBuffer& out,
2546 CIMEnumerateQualifiersResponseMessage* msg,
2547 CIMName& name)
2548 {
2549 /* See ../Server/CIMOperationResponseEncoder.cpp */
2550
2551 static const CIMName NAME("EnumerateQualifiers");
2552 name = NAME;
2553
2554 out.putQualifierDeclA(msg->qualifierDeclarations);
2555 }
2556
|
2557 kumpf 1.6 static CIMEnumerateQualifiersResponseMessage*
|
2558 mike 1.1 _decodeEnumerateQualifiersResponse(
2559 CIMBuffer& in,
2560 const String& messageId)
2561 {
2562 /* See ../Client/CIMOperationResponseDecoder.cpp */
2563
2564 Array<CIMQualifierDecl> qualifierDecls;
2565
2566 while (in.more())
2567 {
2568 Array<CIMQualifierDecl> tmp;
2569
2570 if (!in.getQualifierDeclA(tmp))
2571 return 0;
2572
2573 qualifierDecls.append(tmp.getData(), tmp.size());
2574 }
2575
2576 CIMEnumerateQualifiersResponseMessage* msg;
2577 CIMException cimException;
2578
2579 mike 1.1 msg = new CIMEnumerateQualifiersResponseMessage(
2580 messageId,
2581 cimException,
2582 QueueIdStack(),
2583 qualifierDecls);
2584
2585 msg->binaryRequest = true;
2586 return msg;
2587 }
2588
2589 //==============================================================================
2590 //
2591 // GetProperty
2592 //
2593 //==============================================================================
2594
2595 static void _encodeGetPropertyRequest(
2596 CIMBuffer& buf,
2597 CIMGetPropertyRequestMessage* msg,
2598 CIMName& name)
2599 {
2600 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
2601
2602 static const CIMName NAME("GetProperty");
2603 name = NAME;
2604
2605 // [HEADER]
2606 _putHeader(buf, 0, msg->messageId, OP_GetProperty);
2607
2608 // [NAMESPACE]
2609 buf.putNamespaceName(msg->nameSpace);
2610
2611 // [INSTANCE-NAME]
2612 buf.putObjectPath(msg->instanceName);
2613
2614 // [PROPERTY-NAME]
2615 buf.putName(msg->propertyName);
2616 }
2617
2618 static CIMGetPropertyRequestMessage* _decodeGetPropertyRequest(
2619 CIMBuffer& in,
2620 Uint32 queueId,
2621 mike 1.1 Uint32 returnQueueId,
2622 const String& messageId)
2623 {
2624 /* See ../Server/CIMOperationRequestDecoder.cpp */
2625
2626 STAT_GETSTARTTIME
2627
2628 // [NAMESPACE]
2629
2630 CIMNamespaceName nameSpace;
2631
2632 if (!in.getNamespaceName(nameSpace))
2633 return 0;
2634
2635 // [INSTANCE-NAME]
2636 CIMObjectPath instanceName;
2637
2638 if (!in.getObjectPath(instanceName))
2639 return 0;
2640
2641 // [PROPERTY-NAME]
2642 mike 1.1 CIMName propertyName;
2643
2644 if (!in.getName(propertyName))
2645 return 0;
2646
2647 AutoPtr<CIMGetPropertyRequestMessage> request(
2648 new CIMGetPropertyRequestMessage(
2649 messageId,
2650 nameSpace,
2651 instanceName,
2652 propertyName,
2653 QueueIdStack(queueId, returnQueueId)));
2654
2655 request->binaryRequest = true;
2656
2657 STAT_SERVERSTART
2658
2659 return request.release();
2660 }
2661
2662 static void _encodeGetPropertyResponseBody(
2663 mike 1.1 CIMBuffer& out,
2664 CIMGetPropertyResponseMessage* msg,
2665 CIMName& name)
2666 {
2667 /* See ../Server/CIMOperationResponseEncoder.cpp */
2668
2669 static const CIMName NAME("GetProperty");
2670 name = NAME;
2671
2672 // [VALUE]
2673 out.putValue(msg->value);
2674 }
2675
2676 static CIMGetPropertyResponseMessage* _decodeGetPropertyResponse(
2677 CIMBuffer& in,
2678 const String& messageId)
2679 {
2680 /* See ../Client/CIMOperationResponseDecoder.cpp */
2681
2682 // [VALUE]
2683 CIMValue value;
2684 mike 1.1
2685 if (!in.getValue(value))
2686 return 0;
2687
2688 // Unfortunately the CIM GetProperty() method is only able to return
2689 // a string since there is no containing element that specifies its
2690 // type. So even though the binary protocol properly transmits the type,
2691 // we are force to convert that type to string to match the XML protocol
2692 // behavior.
2693
2694 if (value.isNull())
2695 value.setNullValue(CIMTYPE_STRING, false);
2696 else
2697 value.set(value.toString());
2698
2699 CIMGetPropertyResponseMessage* msg;
2700 CIMException cimException;
2701
2702 msg = new CIMGetPropertyResponseMessage(
2703 messageId,
2704 cimException,
2705 mike 1.1 QueueIdStack(),
2706 value);
2707
2708 msg->binaryRequest = true;
2709 return msg;
2710 }
2711
2712 //==============================================================================
2713 //
2714 // SetProperty
2715 //
2716 //==============================================================================
2717
2718 static void _encodeSetPropertyRequest(
2719 CIMBuffer& buf,
2720 CIMSetPropertyRequestMessage* msg,
2721 CIMName& name)
2722 {
2723 /* See ../Client/CIMOperationRequestEncoder.cpp */
2724
2725 static const CIMName NAME("SetProperty");
2726 mike 1.1 name = NAME;
2727
2728 // [HEADER]
2729 _putHeader(buf, 0, msg->messageId, OP_SetProperty);
2730
2731 // [NAMESPACE]
2732 buf.putNamespaceName(msg->nameSpace);
2733
2734 // [INSTANCE-NAME]
2735 buf.putObjectPath(msg->instanceName);
2736
2737 // [PROPERTY-NAME]
2738 buf.putName(msg->propertyName);
2739
2740 // [VALUE]
2741 buf.putValue(msg->newValue);
2742 }
2743
2744 static CIMSetPropertyRequestMessage* _decodeSetPropertyRequest(
2745 CIMBuffer& in,
2746 Uint32 queueId,
2747 mike 1.1 Uint32 returnQueueId,
2748 const String& messageId)
2749 {
2750 /* See ../Server/CIMOperationRequestDecoder.cpp */
2751
2752 STAT_GETSTARTTIME
2753
2754 // [NAMESPACE]
2755
2756 CIMNamespaceName nameSpace;
2757
2758 if (!in.getNamespaceName(nameSpace))
2759 return 0;
2760
2761 // [INSTANCE-NAME]
2762
2763 CIMObjectPath instanceName;
2764
2765 if (!in.getObjectPath(instanceName))
2766 return 0;
2767
2768 mike 1.1 // [PROPERTY-NAME]
2769
2770 CIMName propertyName;
2771
2772 if (!in.getName(propertyName))
2773 return 0;
2774
2775 // [PROPERTY-VALUE]
2776
2777 CIMValue propertyValue;
2778
2779 if (!in.getValue(propertyValue))
2780 return 0;
2781
2782 AutoPtr<CIMSetPropertyRequestMessage> request(
2783 new CIMSetPropertyRequestMessage(
2784 messageId,
2785 nameSpace,
2786 instanceName,
2787 propertyName,
2788 propertyValue,
2789 mike 1.1 QueueIdStack(queueId, returnQueueId)));
2790
2791 request->binaryRequest = true;
2792
2793 STAT_SERVERSTART
2794
2795 return request.release();
2796 }
2797
2798 static void _encodeSetPropertyResponseBody(
2799 CIMName& name)
2800 {
2801 /* See ../Server/CIMOperationResponseEncoder.cpp */
2802
2803 static const CIMName NAME("SetProperty");
2804 name = NAME;
2805 }
2806
2807 static CIMSetPropertyResponseMessage* _decodeSetPropertyResponse(
2808 const String& messageId)
2809 {
2810 mike 1.1 /* See ../Client/CIMOperationResponseDecoder.cpp */
2811
2812 CIMSetPropertyResponseMessage* msg;
2813 CIMException cimException;
2814
2815 msg = new CIMSetPropertyResponseMessage(
2816 messageId,
2817 cimException,
2818 QueueIdStack());
2819
2820 msg->binaryRequest = true;
2821 return msg;
2822 }
2823
2824 //==============================================================================
2825 //
2826 // InvokeMethod
2827 //
2828 //==============================================================================
2829
2830 static void _encodeInvokeMethodRequest(
2831 mike 1.1 CIMBuffer& buf,
2832 CIMInvokeMethodRequestMessage* msg,
2833 CIMName& name)
2834 {
2835 /* See ../Client/CIMOperationRequestEncoder.cpp */
2836
2837 name = msg->methodName;
2838
2839 // [HEADER]
2840 _putHeader(buf, 0, msg->messageId, OP_InvokeMethod);
2841
2842 // [NAMESPACE]
2843 buf.putNamespaceName(msg->nameSpace);
2844
2845 // [INSTANCE-NAME]
2846 buf.putObjectPath(msg->instanceName);
2847
2848 // [METHOD-NAME]
2849 buf.putName(msg->methodName);
2850
2851 // [IN-PARAMETERS]
2852 mike 1.1 buf.putParamValueA(msg->inParameters);
2853 }
2854
2855 static CIMInvokeMethodRequestMessage* _decodeInvokeMethodRequest(
2856 CIMBuffer& in,
2857 Uint32 queueId,
2858 Uint32 returnQueueId,
2859 const String& messageId)
2860 {
2861 /* See ../Server/CIMOperationRequestDecoder.cpp */
2862
2863 STAT_GETSTARTTIME
2864
2865 // [NAMESPACE]
2866
2867 CIMNamespaceName nameSpace;
2868
2869 if (!in.getNamespaceName(nameSpace))
2870 return 0;
2871
2872 // [INSTANCE-NAME]
2873 mike 1.1
2874 CIMObjectPath instanceName;
2875
2876 if (!in.getObjectPath(instanceName))
2877 return 0;
2878
2879 // [METHOD-NAME]
2880
2881 CIMName methodName;
2882
2883 if (!in.getName(methodName))
2884 return 0;
2885
2886 // [IN-PARAMETERS]
2887
2888 Array<CIMParamValue> inParameters;
2889
2890 if (!in.getParamValueA(inParameters))
2891 return 0;
2892
2893 AutoPtr<CIMInvokeMethodRequestMessage> request(
2894 mike 1.1 new CIMInvokeMethodRequestMessage(
2895 messageId,
2896 nameSpace,
2897 instanceName,
2898 methodName,
2899 inParameters,
2900 QueueIdStack(queueId, returnQueueId)));
2901
2902 request->binaryRequest = true;
2903
2904 STAT_SERVERSTART
2905
2906 return request.release();
2907 }
2908
2909 static void _encodeInvokeMethodResponseBody(
2910 CIMBuffer& out,
2911 CIMInvokeMethodResponseMessage* msg,
2912 CIMName& name)
2913 {
2914 /* See ../Server/CIMOperationResponseEncoder.cpp */
2915 mike 1.1
2916 name = msg->methodName;
2917
2918 // [METHOD-NAME]
2919 out.putName(msg->methodName);
2920
2921 // [RETURN-VALUE]
2922 out.putValue(msg->retValue);
2923
2924 // [OUT-PARAMETERS]
2925 out.putParamValueA(msg->outParameters);
2926 }
2927
2928 static CIMInvokeMethodResponseMessage* _decodeInvokeMethodResponse(
2929 CIMBuffer& in,
2930 const String& messageId)
2931 {
2932 /* See ../Client/CIMOperationResponseDecoder.cpp */
2933
2934 // [METHOD-NAME]
2935
2936 mike 1.1 CIMName methodName;
2937
2938 if (!in.getName(methodName))
2939 return 0;
2940
2941 // [RETURN-VALUE]
2942
2943 CIMValue returnValue;
2944
2945 if (!in.getValue(returnValue))
2946 return 0;
2947
2948 // [OUT-PARAMETERS]
2949
2950 Array<CIMParamValue> outParameters;
2951
2952 if (!in.getParamValueA(outParameters))
2953 return 0;
2954
2955 CIMInvokeMethodResponseMessage* msg;
2956 CIMException cimException;
2957 mike 1.1
2958 msg = new CIMInvokeMethodResponseMessage(
2959 messageId,
2960 cimException,
2961 QueueIdStack(),
2962 returnValue,
2963 outParameters,
2964 methodName);
2965
2966 msg->binaryRequest = true;
2967
2968 return msg;
2969 }
2970
2971 //==============================================================================
2972 //
2973 // ExecQuery
2974 //
2975 //==============================================================================
2976
2977 static void _encodeExecQueryRequest(
2978 mike 1.1 CIMBuffer& buf,
2979 CIMExecQueryRequestMessage* msg,
2980 CIMName& name)
2981 {
2982 /* See ../Client/CIMOperationRequestEncoder.cpp */
2983
2984 static const CIMName NAME("ExecQuery");
2985 name = NAME;
2986
2987 // [HEADER]
2988 _putHeader(buf, 0, msg->messageId, OP_ExecQuery);
2989
2990 // [NAMESPACE]
2991 buf.putNamespaceName(msg->nameSpace);
2992
2993 // [QUERY-LANGUAGE]
2994 buf.putString(msg->queryLanguage);
2995
2996 // [QUERY]
2997 buf.putString(msg->query);
2998 }
2999 mike 1.1
3000 static CIMExecQueryRequestMessage* _decodeExecQueryRequest(
3001 CIMBuffer& in,
3002 Uint32 queueId,
3003 Uint32 returnQueueId,
3004 const String& messageId)
3005 {
3006 /* See ../Server/CIMOperationRequestDecoder.cpp */
3007
3008 STAT_GETSTARTTIME
3009
3010 // [NAMESPACE]
3011
3012 CIMNamespaceName nameSpace;
3013
3014 if (!in.getNamespaceName(nameSpace))
3015 return 0;
3016
3017 // [QUERY-LANGUAGE]]
3018 String queryLanguage;
3019
3020 mike 1.1 if (!in.getString(queryLanguage))
3021 return 0;
3022
3023 // [QUERY]]
3024 String query;
3025
3026 if (!in.getString(query))
3027 return 0;
3028
3029 AutoPtr<CIMExecQueryRequestMessage> request(
3030 new CIMExecQueryRequestMessage(
3031 messageId,
3032 nameSpace,
3033 queryLanguage,
3034 query,
3035 QueueIdStack(queueId, returnQueueId)));
3036
3037 request->binaryRequest = true;
3038
3039 STAT_SERVERSTART
3040
3041 mike 1.1 return request.release();
3042 }
3043
3044 static void _encodeExecQueryResponseBody(
3045 CIMBuffer& out,
|
3046 thilo.boehm 1.10 CIMResponseData& data,
|
3047 mike 1.1 CIMName& name)
3048 {
3049 /* See ../Server/CIMOperationResponseEncoder.cpp */
3050
3051 static const CIMName NAME("ExecQuery");
3052 name = NAME;
3053
|
3054 r.kieninger 1.8 data.encodeBinaryResponse(out);
|
3055 mike 1.1 }
3056
3057 static CIMExecQueryResponseMessage* _decodeExecQueryResponse(
3058 CIMBuffer& in,
3059 const String& messageId)
3060 {
3061 CIMExecQueryResponseMessage* msg;
3062 CIMException cimException;
3063
3064 msg = new CIMExecQueryResponseMessage(
3065 messageId,
3066 cimException,
|
3067 r.kieninger 1.8 QueueIdStack());
|
3068 mike 1.1
|
3069 r.kieninger 1.9 // Instead of resolving the binary data right here, we delegate this
3070 // to a later point in time when the data is actually retrieved through
3071 // a call to getNamedInstances, which is going to resolve the binary
3072 // data when the callback function is registered.
3073 // This allows an alternate client implementation to gain direct access
3074 // to the binary data and pass this for example to the JNI implementation
3075 // of the JSR48 CIM Client for Java.
|
3076 thilo.boehm 1.10 CIMResponseData& responseData = msg->getResponseData();
|
3077 karl 1.12 responseData.setRemainingBinaryData(in);
|
3078 r.kieninger 1.9
|
3079 mike 1.1 msg->binaryRequest = true;
3080 return msg;
3081 }
|
3082 karl 1.12.2.4 // EXP_PULL_BEGIN
|
3083 mike 1.1 //==============================================================================
3084 //
|
3085 karl 1.12.2.1 // OpenEnumerateInstances
|
3086 mike 1.1 //
3087 //==============================================================================
3088
|
3089 karl 1.12.2.1 static void _encodeOpenEnumerateInstancesRequest(
3090 CIMBuffer& buf,
3091 CIMOpenEnumerateInstancesRequestMessage* msg,
3092 CIMName& name)
|
3093 mike 1.1 {
|
3094 karl 1.12.2.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
|
3095 mike 1.1
|
3096 karl 1.12.2.1 static const CIMName NAME("OpenEnumerateInstances");
3097 name = NAME;
|
3098 mike 1.1
|
3099 karl 1.12.2.1 // [HEADER]
|
3100 mike 1.1
|
3101 karl 1.12.2.1 Uint32 flags = 0;
|
3102 mike 1.1
|
3103 karl 1.12.2.1 if (msg->deepInheritance)
3104 flags |= DEEP_INHERITANCE;
|
3105 mike 1.1
|
3106 karl 1.12.2.1 if (msg->includeClassOrigin)
3107 flags |= INCLUDE_CLASS_ORIGIN;
|
3108 mike 1.1
|
3109 karl 1.12.2.1 if (msg->continueOnError)
3110 flags |= CONTINUE_ON_ERROR;
|
3111 mike 1.1
|
3112 karl 1.12.2.1 _putHeader(buf, flags, msg->messageId, OP_OpenEnumerateInstances);
|
3113 mike 1.1
|
3114 karl 1.12.2.1 // [NAMESPACE]
3115 buf.putNamespaceName(msg->nameSpace);
|
3116 mike 1.1
|
3117 karl 1.12.2.1 // [CLASSNAME]
3118 buf.putName(msg->className);
|
3119 mike 1.1
|
3120 karl 1.12.2.1 // [PROPERTY-LIST]
3121 buf.putPropertyList(msg->propertyList);
|
3122 mike 1.1
|
3123 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
3124 karl 1.12.2.1 buf.putUint32Arg(msg->operationTimeout);
3125 buf.putString(msg->filterQueryLanguage);
3126 buf.putString(msg->filterQuery);
3127 }
|
3128 mike 1.1
|
3129 karl 1.12.2.1 static CIMOpenEnumerateInstancesRequestMessage*
3130 _decodeOpenEnumerateInstancesRequest(
3131 CIMBuffer& in,
|
3132 mike 1.1 Uint32 queueId,
|
3133 karl 1.12.2.1 Uint32 returnQueueId,
3134 Uint32 flags,
3135 const String& messageId)
|
3136 mike 1.1 {
|
3137 karl 1.12.2.1 /* See ../Server/CIMOperationRequestDecoder.cpp */
|
3138 mike 1.1
|
3139 karl 1.12.2.1 STAT_GETSTARTTIME
|
3140 mike 1.1
|
3141 karl 1.12.2.1 Boolean deepInheritance = flags & DEEP_INHERITANCE;
3142 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
3143 Boolean continueOnError = flags & CONTINUE_ON_ERROR;
|
3144 mike 1.1
|
3145 karl 1.12.2.1 // [NAMESPACE]
3146 CIMNamespaceName nameSpace;
3147 if (!in.getNamespaceName(nameSpace))
|
3148 mike 1.1 return 0;
3149
|
3150 karl 1.12.2.1 // [CLASSNAME]
3151 CIMName className;
3152 if (!in.getName(className))
3153 return 0;
|
3154 mike 1.1
|
3155 karl 1.12.2.1 // [PROPERTY-LIST]
3156 CIMPropertyList propertyList;
3157 if (!in.getPropertyList(propertyList))
3158 return 0;
|
3159 mike 1.1
|
3160 karl 1.12.2.1 // These can all be one common function.
|
3161 karl 1.12.2.5 Uint32 maxObjectCount;
3162 if (!in.getUint32(maxObjectCount))
|
3163 karl 1.12.2.1 return 0;
3164 Uint32Arg operationTimeout;
3165 if (!in.getUint32Arg(operationTimeout))
3166 return 0;
3167 String filterQueryLanguage;
3168 if (!in.getString(filterQueryLanguage))
3169 return 0;
3170 String filterQuery;
3171 if (!in.getString(filterQuery))
3172 return 0;
3173
3174 AutoPtr<CIMOpenEnumerateInstancesRequestMessage> request(
3175 new CIMOpenEnumerateInstancesRequestMessage(
3176 messageId,
3177 nameSpace,
3178 className,
3179 deepInheritance,
3180 includeClassOrigin,
3181 propertyList,
3182 filterQueryLanguage,
3183 filterQuery,
3184 karl 1.12.2.1 operationTimeout,
3185 continueOnError,
3186 maxObjectCount,
3187 QueueIdStack(queueId, returnQueueId)));
3188
3189 request->binaryRequest = true;
3190
3191 STAT_SERVERSTART
3192
3193 return request.release();
3194 }
|
3195 karl 1.12.2.4
|
3196 karl 1.12.2.1 // For the pull Response messages the interface is the message and the,
3197 // not just the responseData.
3198 static void _encodeOpenEnumerateInstancesResponseBody(
3199 CIMBuffer& out,
3200 CIMOpenEnumerateInstancesResponseMessage* msg,
3201 CIMResponseData& data,
3202 CIMName& name)
|
3203 mike 1.1 {
|
3204 karl 1.12.2.1 /* See ../Server/CIMOperationResponseEncoder.cpp */
|
3205 mike 1.1
|
3206 karl 1.12.2.1 static const CIMName NAME("OpenEnumerateInstances");
3207 name = NAME;
3208
3209 // [endOfSequence]
3210 out.putBoolean(msg->endOfSequence);
3211
3212 // [enumerationContext]
3213 out.putString(msg->enumerationContext);
3214
3215 data.encodeBinaryResponse(out);
|
3216 r.kieninger 1.9 }
3217
|
3218 karl 1.12.2.1 static CIMOpenEnumerateInstancesResponseMessage*
3219 _decodeOpenEnumerateInstancesResponse(
3220 CIMBuffer& in,
3221 const String& messageId)
|
3222 r.kieninger 1.9 {
|
3223 karl 1.12.2.1 CIMException cimException;
3224
3225 // KS_TODO Should we set validation???
|
3226 karl 1.12 // Turn on validation: This is a debugging tool
|
3227 karl 1.12.2.1 //#if defined(ENABLE_VALIDATION)
3228 // buf.setValidate(true);
3229 //#endif
|
3230 mike 1.1
|
3231 karl 1.12.2.1 Boolean endOfSequence;
3232 if (!in.getBoolean(endOfSequence))
3233 return 0;
|
3234 mike 1.1
|
3235 karl 1.12.2.1 String enumerationContext;
3236 if (!in.getString(enumerationContext))
|
3237 mike 1.1 return 0;
3238
|
3239 karl 1.12.2.1 CIMOpenEnumerateInstancesResponseMessage* msg =
3240 new CIMOpenEnumerateInstancesResponseMessage(
3241 messageId,
3242 cimException,
3243 endOfSequence,
3244 enumerationContext,
3245 QueueIdStack());
|
3246 mike 1.1
|
3247 karl 1.12.2.1 // Instead of resolving the binary data here, we delegate this
3248 // to a later point in time when the data is actually retrieved through
3249 // a call to CIMResponseData::getInstances, which
3250 // resolves the binary data as it is passed to the next interface.
3251 // This allows an alternate client implementation to gain direct access
3252 // to the binary data and pass this for example to the JNI implementation
3253 // of the JSR48 CIM Client for Java.
3254 CIMResponseData& responseData = msg->getResponseData();
3255 responseData.setRemainingBinaryData(in);
3256
3257 msg->binaryRequest=true;
3258 return msg;
3259 }
|
3260 karl 1.12.2.4
|
3261 karl 1.12.2.1 //==============================================================================
3262 //
3263 // OpenEnumerateInstancesPaths
3264 //
3265 //==============================================================================
3266
3267 static void _encodeOpenEnumerateInstancePathsRequest(
3268 CIMBuffer& buf,
3269 CIMOpenEnumerateInstancePathsRequestMessage* msg,
3270 CIMName& name)
3271 {
3272 /* See ../Client/CIMOperationRequestEncoder.cpp */
3273
3274 static const CIMName NAME("OpenEnumerateInstancePaths");
3275 name = NAME;
3276
3277 // [HEADER]
3278
3279 Uint32 flags = 0;
3280
3281 if (msg->continueOnError)
3282 karl 1.12.2.1 flags |= CONTINUE_ON_ERROR;
3283
3284 _putHeader(buf, flags, msg->messageId, OP_OpenEnumerateInstancePaths);
3285
3286 // [NAMESPACE]
3287 buf.putNamespaceName(msg->nameSpace);
3288
3289 // [CLASSNAME]
3290 buf.putName(msg->className);
3291
|
3292 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
3293 karl 1.12.2.1 buf.putUint32Arg(msg->operationTimeout);
3294 buf.putString(msg->filterQueryLanguage);
3295 buf.putString(msg->filterQuery);
3296 }
3297
3298 static CIMOpenEnumerateInstancePathsRequestMessage*
3299 _decodeOpenEnumerateInstancePathsRequest(
3300 CIMBuffer& in,
3301 Uint32 queueId,
3302 Uint32 returnQueueId,
3303 Uint32 flags,
3304 const String& messageId)
3305 {
3306 /* See ../Server/CIMOperationRequestDecoder.cpp */
3307
3308 STAT_GETSTARTTIME
3309
3310 Boolean continueOnError = flags & CONTINUE_ON_ERROR;
3311
3312 // [NAMESPACE]
3313
3314 karl 1.12.2.1 CIMNamespaceName nameSpace;
3315 if (!in.getNamespaceName(nameSpace))
3316 return 0;
3317
3318 // [CLASSNAME]
3319 CIMName className;
3320 if (!in.getName(className))
3321 return 0;
3322
3323 // These can all be one common function.
3324
|
3325 karl 1.12.2.5 Uint32 maxObjectCount;
3326 if (!in.getUint32(maxObjectCount))
|
3327 karl 1.12.2.1 return 0;
3328 Uint32Arg operationTimeout;
3329 if (!in.getUint32Arg(operationTimeout))
3330 return 0;
3331 String filterQueryLanguage;
3332 if (!in.getString(filterQueryLanguage))
3333 return 0;
3334 String filterQuery;
3335 if (!in.getString(filterQuery))
3336 return 0;
3337
3338 AutoPtr<CIMOpenEnumerateInstancePathsRequestMessage> request(
3339 new CIMOpenEnumerateInstancePathsRequestMessage(
3340 messageId,
3341 nameSpace,
3342 className,
3343 filterQueryLanguage,
3344 filterQuery,
3345 operationTimeout,
3346 continueOnError,
3347 maxObjectCount,
3348 karl 1.12.2.1 QueueIdStack(queueId, returnQueueId)));
3349
3350 request->binaryRequest = true;
3351
3352 STAT_SERVERSTART
3353
3354 return request.release();
3355 }
3356
3357 // For the pull Response messages the interface is the message and the,
3358 // not just the responseData.
3359 static void _encodeOpenEnumerateInstancePathsResponseBody(
3360 CIMBuffer& out,
3361 CIMOpenEnumerateInstancePathsResponseMessage* msg,
3362 CIMResponseData& data,
3363 CIMName& name)
3364 {
3365 /* See ../Server/CIMOperationResponseEncoder.cpp */
3366
3367 static const CIMName NAME("OpenEnumerateInstancePaths");
3368 name = NAME;
3369 karl 1.12.2.1
3370 // [endOfSequence]
3371 out.putBoolean(msg->endOfSequence);
3372
3373 // [enumerationContext]
3374 out.putString(msg->enumerationContext);
3375
3376 data.encodeBinaryResponse(out);
3377 }
3378
3379 static CIMOpenEnumerateInstancePathsResponseMessage*
3380 _decodeOpenEnumerateInstancePathsResponse(
3381 CIMBuffer& in,
3382 const String& messageId)
3383 {
3384 CIMException cimException;
3385
3386 Boolean endOfSequence;
3387 if (!in.getBoolean(endOfSequence))
3388 return 0;
3389
3390 karl 1.12.2.1 String enumerationContext;
3391 if (!in.getString(enumerationContext))
3392 {
3393 return 0;
3394 }
3395 CIMOpenEnumerateInstancePathsResponseMessage* msg =
3396 new CIMOpenEnumerateInstancePathsResponseMessage(
3397 messageId,
3398 cimException,
3399 endOfSequence,
3400 enumerationContext,
3401 QueueIdStack());
3402
3403 // Instead of resolving the binary data here, we delegate this
3404 // to a later point in time when the data is actually retrieved through
3405 // a call to CIMResponseData::getInstanceNames, which
3406 // resolves the binary data as it is passed to the next interface.
3407 // This allows an alternate client implementation to gain direct access
3408 // to the binary data and pass this for example to the JNI implementation
3409 // of the JSR48 CIM Client for Java.
3410 CIMResponseData& responseData = msg->getResponseData();
3411 karl 1.12.2.1 responseData.setRemainingBinaryData(in);
3412
3413 msg->binaryRequest=true;
3414 return msg;
3415 }
3416 //==============================================================================
3417 //
3418 // OpenReferenceInstances
3419 //
3420 //==============================================================================
3421
3422 static void _encodeOpenReferenceInstancesRequest(
3423 CIMBuffer& buf,
3424 CIMOpenReferenceInstancesRequestMessage* msg,
3425 CIMName& name)
3426 {
3427 /* See ../Client/CIMOperationRequestEncoder.cpp */
3428
3429 static const CIMName NAME("OpenReferenceInstances");
3430 name = NAME;
3431
3432 karl 1.12.2.1 // [HEADER]
3433
3434 Uint32 flags = 0;
3435
3436 if (msg->includeClassOrigin)
3437 flags |= INCLUDE_CLASS_ORIGIN;
3438
3439 if (msg->continueOnError)
3440 flags |= CONTINUE_ON_ERROR;
3441
3442 _putHeader(buf, flags, msg->messageId, OP_OpenReferenceInstances);
3443
3444 // [NAMESPACE]
3445 buf.putNamespaceName(msg->nameSpace);
3446
3447 // [OBJECT-NAME]
3448 buf.putObjectPath(msg->objectName);
3449
3450 // [RESULT-CLASS]
3451 buf.putName(msg->resultClass);
3452
3453 karl 1.12.2.1 // [ROLE]
3454 buf.putString(msg->role);
3455
3456 // [PROPERTY-LIST]
3457 buf.putPropertyList(msg->propertyList);
3458
|
3459 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
3460 karl 1.12.2.1 buf.putUint32Arg(msg->operationTimeout);
3461 buf.putString(msg->filterQueryLanguage);
3462 buf.putString(msg->filterQuery);
3463 }
3464
3465 static CIMOpenReferenceInstancesRequestMessage*
3466 _decodeOpenReferenceInstancesRequest(
3467 CIMBuffer& in,
3468 Uint32 queueId,
3469 Uint32 returnQueueId,
3470 Uint32 flags,
3471 const String& messageId)
3472 {
3473 /* See ../Server/CIMOperationRequestDecoder.cpp */
3474
3475 STAT_GETSTARTTIME
3476
3477 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
3478 Boolean continueOnError = flags & CONTINUE_ON_ERROR;
3479
3480 // [NAMESPACE]
3481 karl 1.12.2.1
3482 CIMNamespaceName nameSpace;
3483 if (!in.getNamespaceName(nameSpace))
3484 return 0;
3485
3486 // [OBJECT-NAME]
3487
3488 CIMObjectPath objectName;
3489
3490 if (!in.getObjectPath(objectName))
3491 return 0;
3492
3493 // [RESULT-CLASS]
3494
3495 CIMName resultClass;
3496
3497 if (!in.getName(resultClass))
3498 return 0;
3499
3500 // [ROLE]
3501
3502 karl 1.12.2.1 String role;
3503
3504 if (!in.getString(role))
3505 return 0;
3506
3507 // [PROPERTY-LIST]
3508 CIMPropertyList propertyList;
3509 if (!in.getPropertyList(propertyList))
3510 return 0;
3511
3512 // These can all be one common function.
|
3513 karl 1.12.2.5 Uint32 maxObjectCount;
3514 if (!in.getUint32(maxObjectCount))
|
3515 karl 1.12.2.1 return 0;
3516 Uint32Arg operationTimeout;
3517 if (!in.getUint32Arg(operationTimeout))
3518 return 0;
3519 String filterQueryLanguage;
3520 if (!in.getString(filterQueryLanguage))
3521 return 0;
3522 String filterQuery;
3523 if (!in.getString(filterQuery))
3524 return 0;
3525
3526 AutoPtr<CIMOpenReferenceInstancesRequestMessage> request(
3527 new CIMOpenReferenceInstancesRequestMessage(
3528 messageId,
3529 nameSpace,
3530 objectName,
3531 resultClass,
3532 role,
3533 includeClassOrigin,
3534 propertyList,
3535 filterQueryLanguage,
3536 karl 1.12.2.1 filterQuery,
3537 operationTimeout,
3538 continueOnError,
3539 maxObjectCount,
3540 QueueIdStack(queueId, returnQueueId)));
3541
3542 request->binaryRequest = true;
3543
3544 STAT_SERVERSTART
3545
3546 return request.release();
3547 }
3548 // For the pull Response messages the interface is the message and the,
3549 // not just the responseData.
3550 static void _encodeOpenReferenceInstancesResponseBody(
3551 CIMBuffer& out,
3552 CIMOpenReferenceInstancesResponseMessage* msg,
3553 CIMResponseData& data,
3554 CIMName& name)
3555 {
3556 /* See ../Server/CIMOperationResponseEncoder.cpp */
3557 karl 1.12.2.1
3558 static const CIMName NAME("OpenReferenceInstances");
3559 name = NAME;
3560
3561 // [endOfSequence]
3562 out.putBoolean(msg->endOfSequence);
3563
3564 // [enumerationContext]
3565 out.putString(msg->enumerationContext);
3566
3567 data.encodeBinaryResponse(out);
3568 }
3569
3570 static CIMOpenReferenceInstancesResponseMessage*
3571 _decodeOpenReferenceInstancesResponse(
3572 CIMBuffer& in,
3573 const String& messageId)
3574 {
3575 CIMException cimException;
3576
3577 Boolean endOfSequence;
3578 karl 1.12.2.1 if (!in.getBoolean(endOfSequence))
3579 return 0;
3580
3581 String enumerationContext;
3582 if (!in.getString(enumerationContext))
3583 return 0;
3584
3585 CIMOpenReferenceInstancesResponseMessage* msg =
|
3586 karl 1.12.2.3 new CIMOpenReferenceInstancesResponseMessage(
|
3587 karl 1.12.2.1 messageId,
3588 cimException,
3589 endOfSequence,
3590 enumerationContext,
3591 QueueIdStack());
3592
3593 // Instead of resolving the binary data here, we delegate this
3594 // to a later point in time when the data is actually retrieved through
3595 // a call to CIMResponseData::getInstances, which
3596 // resolves the binary data is passed to the next interface.
3597 // This allows an alternate client implementation to gain direct access
3598 // to the binary data and pass this for example to the JNI implementation
3599 // of the JSR48 CIM Client for Java.
3600 CIMResponseData& responseData = msg->getResponseData();
3601 responseData.setRemainingBinaryData(in);
3602
3603 msg->binaryRequest=true;
3604 return msg;
3605 }
3606 //==============================================================================
3607 //
3608 karl 1.12.2.1 // OpenReferenceInstancePaths
3609 //
3610 //==============================================================================
3611
3612 static void _encodeOpenReferenceInstancePathsRequest(
3613 CIMBuffer& buf,
3614 CIMOpenReferenceInstancePathsRequestMessage* msg,
3615 CIMName& name)
3616 {
3617 /* See ../Client/CIMOperationRequestEncoder.cpp */
3618
3619 static const CIMName NAME("OpenReferenceInstancePaths");
3620 name = NAME;
3621
3622 // [HEADER]
3623
3624 Uint32 flags = 0;
3625 if (msg->continueOnError)
3626 flags |= CONTINUE_ON_ERROR;
3627
3628 _putHeader(buf, flags, msg->messageId, OP_OpenReferenceInstancePaths);
3629 karl 1.12.2.1
3630 // [NAMESPACE]
3631 buf.putNamespaceName(msg->nameSpace);
3632
3633 // [OBJECT-NAME]
3634 buf.putObjectPath(msg->objectName);
3635
3636 // [RESULT-CLASS]
3637 buf.putName(msg->resultClass);
3638
3639 // [ROLE]
3640 buf.putString(msg->role);
3641
|
3642 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
3643 karl 1.12.2.1 buf.putUint32Arg(msg->operationTimeout);
3644 buf.putString(msg->filterQueryLanguage);
3645 buf.putString(msg->filterQuery);
3646 }
3647
3648 static CIMOpenReferenceInstancePathsRequestMessage*
3649 _decodeOpenReferenceInstancePathsRequest(
3650 CIMBuffer& in,
3651 Uint32 queueId,
3652 Uint32 returnQueueId,
3653 Uint32 flags,
3654 const String& messageId)
3655 {
|
3656 karl 1.12.2.4 /* See ../
3657 Server/CIMOperationRequestDecoder.cpp */
|
3658 karl 1.12.2.1
3659 STAT_GETSTARTTIME
3660
3661 Boolean continueOnError = flags & CONTINUE_ON_ERROR;
3662
3663 // [NAMESPACE]
3664
3665 CIMNamespaceName nameSpace;
3666 if (!in.getNamespaceName(nameSpace))
3667 return 0;
3668
3669 // [OBJECT-NAME]
3670
3671 CIMObjectPath objectName;
3672 if (!in.getObjectPath(objectName))
3673 return 0;
3674
3675 // [RESULT-CLASS]
3676
3677 CIMName resultClass;
3678 if (!in.getName(resultClass))
3679 karl 1.12.2.1 return 0;
3680
3681 // [ROLE]
3682
3683 String role;
3684 if (!in.getString(role))
3685 return 0;
3686
3687 // These can all be one common function.
|
3688 karl 1.12.2.5 Uint32 maxObjectCount;
3689 if (!in.getUint32(maxObjectCount))
|
3690 karl 1.12.2.1 return 0;
3691 Uint32Arg operationTimeout;
3692 if (!in.getUint32Arg(operationTimeout))
3693 return 0;
3694 String filterQueryLanguage;
3695 if (!in.getString(filterQueryLanguage))
3696 return 0;
3697 String filterQuery;
3698 if (!in.getString(filterQuery))
3699 return 0;
3700
3701 AutoPtr<CIMOpenReferenceInstancePathsRequestMessage> request(
3702 new CIMOpenReferenceInstancePathsRequestMessage(
3703 messageId,
3704 nameSpace,
3705 objectName,
3706 resultClass,
3707 role,
3708 filterQueryLanguage,
3709 filterQuery,
3710 operationTimeout,
3711 karl 1.12.2.1 continueOnError,
3712 maxObjectCount,
3713 QueueIdStack(queueId, returnQueueId)));
3714
3715 request->binaryRequest = true;
3716
3717 STAT_SERVERSTART
3718
3719 return request.release();
3720 }
3721 // For the pull Response messages the interface is the message and the,
3722 // not just the responseData.
3723 static void _encodeOpenReferenceInstancePathsResponseBody(
3724 CIMBuffer& out,
3725 CIMOpenReferenceInstancePathsResponseMessage* msg,
3726 CIMResponseData& data,
3727 CIMName& name)
3728 {
3729 /* See ../Server/CIMOperationResponseEncoder.cpp */
3730
3731 static const CIMName NAME("OpenReferenceInstancePaths");
3732 karl 1.12.2.1 name = NAME;
3733
3734 // [endOfSequence]
3735 out.putBoolean(msg->endOfSequence);
3736
3737 // [enumerationContext]
3738 out.putString(msg->enumerationContext);
3739
3740 data.encodeBinaryResponse(out);
3741 }
3742
3743 static CIMOpenReferenceInstancePathsResponseMessage*
3744 _decodeOpenReferenceInstancePathsResponse(
3745 CIMBuffer& in,
3746 const String& messageId)
3747 {
3748 CIMException cimException;
3749
3750 Boolean endOfSequence;
3751 if (!in.getBoolean(endOfSequence))
3752 return 0;
3753 karl 1.12.2.1
3754 String enumerationContext;
3755 if (!in.getString(enumerationContext))
3756 return 0;
3757
3758 CIMOpenReferenceInstancePathsResponseMessage* msg =
3759 new CIMOpenReferenceInstancePathsResponseMessage(
3760 messageId,
3761 cimException,
3762 endOfSequence,
3763 enumerationContext,
3764 QueueIdStack());
3765
3766 // Instead of resolving the binary data right here, we delegate this
3767 // to a later point in time when the data is actually retrieved through
3768 // a call to getNamedInstances, which is going to resolve the binary
3769 // data when the callback function is registered.
3770 // This allows an alternate client implementation to gain direct access
3771 // to the binary data and pass this for example to the JNI implementation
3772 // of the JSR48 CIM Client for Java.
3773 CIMResponseData& responseData = msg->getResponseData();
3774 karl 1.12.2.1 responseData.setRemainingBinaryData(in);
3775
3776 msg->binaryRequest=true;
3777 return msg;
3778 }
3779
3780 //==============================================================================
3781 //
3782 // OpenAssociatorInstances
3783 //
3784 //==============================================================================
3785
3786 static void _encodeOpenAssociatorInstancesRequest(
3787 CIMBuffer& buf,
3788 CIMOpenAssociatorInstancesRequestMessage* msg,
3789 CIMName& name)
3790 {
3791 /* See ../Client/CIMOperationRequestEncoder.cpp */
3792
3793 static const CIMName NAME("OpenAssociatorInstances");
3794 name = NAME;
3795 karl 1.12.2.1
3796 // [HEADER]
3797
3798 Uint32 flags = 0;
3799
3800 if (msg->includeClassOrigin)
3801 flags |= INCLUDE_CLASS_ORIGIN;
3802
3803 if (msg->continueOnError)
3804 flags |= CONTINUE_ON_ERROR;
3805
3806 _putHeader(buf, flags, msg->messageId, OP_OpenAssociatorInstances);
3807
3808 // [NAMESPACE]
3809 buf.putNamespaceName(msg->nameSpace);
3810
3811 // [OBJECT-NAME]
3812 buf.putObjectPath(msg->objectName);
3813
3814 // [ASSOC-CLASS]
3815 buf.putName(msg->assocClass);
3816 karl 1.12.2.1
3817 // [RESULT-CLASS]
3818 buf.putName(msg->resultClass);
3819
3820 // [ROLE]
3821 buf.putString(msg->role);
3822
3823 // [RESULT-ROLE]
3824 buf.putString(msg->resultRole);
3825
3826 // [PROPERTY-LIST]
3827 buf.putPropertyList(msg->propertyList);
3828
|
3829 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
3830 karl 1.12.2.1 buf.putUint32Arg(msg->operationTimeout);
3831 buf.putString(msg->filterQueryLanguage);
3832 buf.putString(msg->filterQuery);
3833 }
3834
3835 static CIMOpenAssociatorInstancesRequestMessage*
3836 _decodeOpenAssociatorInstancesRequest(
3837 CIMBuffer& in,
3838 Uint32 queueId,
3839 Uint32 returnQueueId,
3840 Uint32 flags,
3841 const String& messageId)
3842 {
3843 /* See ../Server/CIMOperationRequestDecoder.cpp */
3844
3845 STAT_GETSTARTTIME
3846
3847 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
3848 Boolean continueOnError = flags & CONTINUE_ON_ERROR;
3849
3850 // [NAMESPACE]
3851 karl 1.12.2.1
3852 CIMNamespaceName nameSpace;
3853 if (!in.getNamespaceName(nameSpace))
3854 return 0;
3855
3856 // [OBJECT-NAME]
3857
3858 CIMObjectPath objectName;
3859
3860 if (!in.getObjectPath(objectName))
3861 return 0;
3862
3863 // [ASSOC-CLASS]
3864
3865 CIMName assocClass;
3866
3867 if (!in.getName(assocClass))
3868 return 0;
3869
3870 // [RESULT-CLASS]
3871
3872 karl 1.12.2.1 CIMName resultClass;
3873
3874 if (!in.getName(resultClass))
3875 return 0;
3876
3877 // [ROLE]
3878
3879 String role;
3880
3881 if (!in.getString(role))
3882 return 0;
3883
3884 // [RESULT-ROLE]
3885
3886 String resultRole;
3887
3888 if (!in.getString(resultRole))
3889 return 0;
3890
3891 // [PROPERTY-LIST]
3892 CIMPropertyList propertyList;
3893 karl 1.12.2.1 if (!in.getPropertyList(propertyList))
3894 return 0;
3895
3896 // These can all be one common function.
|
3897 karl 1.12.2.5 Uint32 maxObjectCount;
3898 if (!in.getUint32(maxObjectCount))
|
3899 karl 1.12.2.1 return 0;
3900 Uint32Arg operationTimeout;
3901 if (!in.getUint32Arg(operationTimeout))
3902 return 0;
3903 String filterQueryLanguage;
3904 if (!in.getString(filterQueryLanguage))
3905 return 0;
3906 String filterQuery;
3907 if (!in.getString(filterQuery))
3908 return 0;
3909
3910 AutoPtr<CIMOpenAssociatorInstancesRequestMessage> request(
3911 new CIMOpenAssociatorInstancesRequestMessage(
3912 messageId,
3913 nameSpace,
3914 objectName,
3915 assocClass,
3916 resultClass,
3917 role,
3918 resultRole,
3919 includeClassOrigin,
3920 karl 1.12.2.1 propertyList,
3921 filterQueryLanguage,
3922 filterQuery,
3923 operationTimeout,
3924 continueOnError,
3925 maxObjectCount,
3926 QueueIdStack(queueId, returnQueueId)));
3927
3928 request->binaryRequest = true;
3929
3930 STAT_SERVERSTART
3931
3932 return request.release();
3933 }
3934 // For the pull Response messages the interface is the message and the,
3935 // not just the responseData.
3936 static void _encodeOpenAssociatorInstancesResponseBody(
3937 CIMBuffer& out,
3938 CIMOpenAssociatorInstancesResponseMessage* msg,
3939 CIMResponseData& data,
3940 CIMName& name)
3941 karl 1.12.2.1 {
3942 /* See ../Server/CIMOperationResponseEncoder.cpp */
3943
3944 static const CIMName NAME("OpenAssociatorInstances");
3945 name = NAME;
3946
3947 // [endOfSequence]
3948 out.putBoolean(msg->endOfSequence);
3949
3950 // [enumerationContext]
3951 out.putString(msg->enumerationContext);
3952
3953 data.encodeBinaryResponse(out);
3954 }
3955
3956 static CIMOpenAssociatorInstancesResponseMessage*
3957 _decodeOpenAssociatorInstancesResponse(
3958 CIMBuffer& in,
3959 const String& messageId)
3960 {
3961 CIMException cimException;
3962 karl 1.12.2.1
3963 Boolean endOfSequence;
3964 if (!in.getBoolean(endOfSequence))
3965 return 0;
3966
3967 String enumerationContext;
3968 if (!in.getString(enumerationContext))
3969 return 0;
3970
3971 CIMOpenAssociatorInstancesResponseMessage* msg =
3972 new CIMOpenAssociatorInstancesResponseMessage(
3973 messageId,
3974 cimException,
3975 endOfSequence,
3976 enumerationContext,
3977 QueueIdStack());
3978
3979 // Instead of resolving the binary data right here, we delegate this
3980 // to a later point in time when the data is actually retrieved through
3981 // a call to getNamedInstances, which is going to resolve the binary
3982 // data when the callback function is registered.
3983 karl 1.12.2.1 // This allows an alternate client implementation to gain direct access
3984 // to the binary data and pass this for example to the JNI implementation
3985 // of the JSR48 CIM Client for Java.
3986 CIMResponseData& responseData = msg->getResponseData();
3987 responseData.setRemainingBinaryData(in);
3988
3989 msg->binaryRequest=true;
3990 return msg;
3991 }
3992
3993 //==============================================================================
3994 //
3995 // OpenAssociatorInstancePaths
3996 //
3997 //==============================================================================
3998
3999 static void _encodeOpenAssociatorInstancePathsRequest(
4000 CIMBuffer& buf,
4001 CIMOpenAssociatorInstancePathsRequestMessage* msg,
4002 CIMName& name)
4003 {
4004 karl 1.12.2.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
4005
4006 static const CIMName NAME("OpenAssociatorInstancePaths");
4007 name = NAME;
4008
4009 // [HEADER]
4010
4011 Uint32 flags = 0;
4012
4013 if (msg->continueOnError)
4014 flags |= CONTINUE_ON_ERROR;
4015
4016 _putHeader(buf, flags, msg->messageId, OP_OpenAssociatorInstancePaths);
4017
4018 // [NAMESPACE]
4019 buf.putNamespaceName(msg->nameSpace);
4020
4021 // [OBJECT-NAME]
4022 buf.putObjectPath(msg->objectName);
4023
4024 // [ASSOC-CLASS]
4025 karl 1.12.2.1 buf.putName(msg->assocClass);
4026
4027 // [RESULT-CLASS]
4028 buf.putName(msg->resultClass);
4029
4030 // [ROLE]
4031 buf.putString(msg->role);
4032
4033 // [RESULT-ROLE]
4034 buf.putString(msg->resultRole);
4035
|
4036 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
4037 karl 1.12.2.1 buf.putUint32Arg(msg->operationTimeout);
4038 buf.putString(msg->filterQueryLanguage);
4039 buf.putString(msg->filterQuery);
4040 }
4041
4042 static CIMOpenAssociatorInstancePathsRequestMessage*
4043 _decodeOpenAssociatorInstancePathsRequest(
4044 CIMBuffer& in,
4045 Uint32 queueId,
4046 Uint32 returnQueueId,
4047 Uint32 flags,
4048 const String& messageId)
4049 {
4050 /* See ../Server/CIMOperationRequestDecoder.cpp */
4051
4052 STAT_GETSTARTTIME
4053
4054 Boolean continueOnError = flags & CONTINUE_ON_ERROR;
4055
4056 // [NAMESPACE]
4057
4058 karl 1.12.2.1 CIMNamespaceName nameSpace;
4059 if (!in.getNamespaceName(nameSpace))
4060 return 0;
4061
4062 // [OBJECT-NAME]
4063
4064 CIMObjectPath objectName;
4065 if (!in.getObjectPath(objectName))
4066 return 0;
4067
4068 // [ASSOC-CLASS]
4069
4070 CIMName assocClass;
4071 if (!in.getName(assocClass))
4072 return 0;
4073
4074 // [RESULT-CLASS]
4075
4076 CIMName resultClass;
4077 if (!in.getName(resultClass))
4078 return 0;
4079 karl 1.12.2.1
4080 // [ROLE]
4081
4082 String role;
4083 if (!in.getString(role))
4084 return 0;
4085
4086 // [RESULT-ROLE]
4087
4088 String resultRole;
4089 if (!in.getString(resultRole))
4090 return 0;
4091
4092 // These can all be one common function.
|
4093 karl 1.12.2.5 Uint32 maxObjectCount;
4094 if (!in.getUint32(maxObjectCount))
|
4095 karl 1.12.2.1 return 0;
4096 Uint32Arg operationTimeout;
4097 if (!in.getUint32Arg(operationTimeout))
4098 return 0;
4099 String filterQueryLanguage;
4100 if (!in.getString(filterQueryLanguage))
4101 return 0;
4102 String filterQuery;
4103 if (!in.getString(filterQuery))
4104 return 0;
4105
4106 AutoPtr<CIMOpenAssociatorInstancePathsRequestMessage> request(
4107 new CIMOpenAssociatorInstancePathsRequestMessage(
4108 messageId,
4109 nameSpace,
4110 objectName,
4111 assocClass,
4112 resultClass,
4113 role,
4114 resultRole,
4115 filterQueryLanguage,
4116 karl 1.12.2.1 filterQuery,
4117 operationTimeout,
4118 continueOnError,
4119 maxObjectCount,
4120 QueueIdStack(queueId, returnQueueId)));
4121
4122 request->binaryRequest = true;
4123
4124 STAT_SERVERSTART
4125
4126 return request.release();
4127 }
4128
4129 static void _encodeOpenAssociatorInstancePathsResponseBody(
4130 CIMBuffer& out,
4131 CIMOpenAssociatorInstancePathsResponseMessage* msg,
4132 CIMResponseData& data,
4133 CIMName& name)
4134 {
4135 /* See ../Server/CIMOperationResponseEncoder.cpp */
4136
4137 karl 1.12.2.1 static const CIMName NAME("OpenAssociatorInstancePaths");
4138 name = NAME;
4139
4140 // [endOfSequence]
4141 out.putBoolean(msg->endOfSequence);
4142
4143 // [enumerationContext]
4144 out.putString(msg->enumerationContext);
4145
4146 data.encodeBinaryResponse(out);
4147 }
4148
4149 static CIMOpenAssociatorInstancePathsResponseMessage*
4150 _decodeOpenAssociatorInstancePathsResponse(
4151 CIMBuffer& in,
4152 const String& messageId)
4153 {
4154 CIMException cimException;
4155
4156 Boolean endOfSequence;
4157 if (!in.getBoolean(endOfSequence))
4158 karl 1.12.2.1 return 0;
4159
4160 String enumerationContext;
4161 if (!in.getString(enumerationContext))
4162 return 0;
4163
4164 CIMOpenAssociatorInstancePathsResponseMessage* msg =
4165 new CIMOpenAssociatorInstancePathsResponseMessage(
4166 messageId,
4167 cimException,
4168 endOfSequence,
4169 enumerationContext,
4170 QueueIdStack());
4171
4172 // Instead of resolving the binary data right here, we delegate this
4173 // to a later point in time when the data is actually retrieved through
4174 // a call to getNamedInstances, which is going to resolve the binary
4175 // data when the callback function is registered.
4176 // This allows an alternate client implementation to gain direct access
4177 // to the binary data and pass this for example to the JNI implementation
4178 // of the JSR48 CIM Client for Java.
4179 karl 1.12.2.1 CIMResponseData& responseData = msg->getResponseData();
4180 responseData.setRemainingBinaryData(in);
4181
4182 msg->binaryRequest=true;
4183 return msg;
4184 }
4185
4186 //==============================================================================
4187 //
4188 // PullInstancesWithPath
4189 //
4190 //==============================================================================
4191
4192 static void _encodePullInstancesWithPathRequest(
4193 CIMBuffer& buf,
4194 CIMPullInstancesWithPathRequestMessage* msg,
4195 CIMName& name)
4196 {
4197 /* See ../Client/CIMOperationRequestEncoder.cpp */
4198
4199 static const CIMName NAME("PullInstancesWithPath");
4200 karl 1.12.2.1 name = NAME;
4201
4202 // [HEADER]
4203
4204 Uint32 flags = 0;
4205
4206 _putHeader(buf, flags, msg->messageId, OP_PullInstancesWithPath);
4207
4208 // [NAMESPACE]
4209 buf.putNamespaceName(msg->nameSpace);
4210
4211 // [EnumerationContext]
4212 buf.putString(msg->enumerationContext);
4213
|
4214 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
4215 karl 1.12.2.1 }
4216
4217 static CIMPullInstancesWithPathRequestMessage*
4218 _decodePullInstancesWithPathRequest(
4219 CIMBuffer& in,
4220 Uint32 queueId,
4221 Uint32 returnQueueId,
4222 Uint32 flags,
4223 const String& messageId)
4224 {
4225 /* See ../Server/CIMOperationRequestDecoder.cpp */
4226
4227 STAT_GETSTARTTIME
4228
4229 // [NAMESPACE]
4230
4231 CIMNamespaceName nameSpace;
4232 if (!in.getNamespaceName(nameSpace))
4233 return 0;
4234
4235 // [EnumerationContext]
4236 karl 1.12.2.1 String enumerationContext;
4237 if (!in.getString(enumerationContext))
4238 {
4239 return 0;
4240 }
4241
4242 // [MACTCOUNT]
|
4243 karl 1.12.2.5 Uint32 maxObjectCount;
4244 if (!in.getUint32(maxObjectCount))
|
4245 karl 1.12.2.1 return 0;
4246
4247 AutoPtr<CIMPullInstancesWithPathRequestMessage> request(
4248 new CIMPullInstancesWithPathRequestMessage(
4249 messageId,
4250 nameSpace,
4251 enumerationContext,
4252 maxObjectCount,
4253 QueueIdStack(queueId, returnQueueId)));
4254
4255 request->binaryRequest = true;
4256
4257 STAT_SERVERSTART
4258
4259 return request.release();
4260 }
4261
4262 // For the pull Response messages the interface is the message and the,
4263 // not just the responseData.
4264 static void _encodePullInstancesWithPathResponseBody(
4265 CIMBuffer& out,
4266 karl 1.12.2.1 CIMPullInstancesWithPathResponseMessage* msg,
4267 CIMResponseData& data,
4268 CIMName& name)
4269 {
4270 /* See ../Server/CIMOperationResponseEncoder.cpp */
4271
4272 static const CIMName NAME("PullInstancesWithPath");
4273 name = NAME;
4274 // [endOfSequence]
4275 out.putBoolean(msg->endOfSequence);
4276
4277 // [enumerationContext]
4278 out.putString(msg->enumerationContext);
4279
4280 data.encodeBinaryResponse(out);
4281 }
4282
4283 static CIMPullInstancesWithPathResponseMessage*
4284 _decodePullInstancesWithPathResponse(
4285 CIMBuffer& in,
4286 const String& messageId)
4287 karl 1.12.2.1 {
4288 CIMException cimException;
4289
4290 Boolean endOfSequence;
4291 if (!in.getBoolean(endOfSequence))
4292 return 0;
4293
4294 String enumerationContext;
4295 if (!in.getString(enumerationContext))
4296 return 0;
4297
4298 CIMPullInstancesWithPathResponseMessage* msg =
4299 new CIMPullInstancesWithPathResponseMessage(
4300 messageId,
4301 cimException,
4302 endOfSequence,
4303 enumerationContext,
4304 QueueIdStack());
4305
4306 // Instead of resolving the binary data right here, we delegate this
4307 // to a later point in time when the data is actually retrieved through
4308 karl 1.12.2.1 // a call to getNamedInstances, which is going to resolve the binary
4309 // data when the callback function is registered.
4310 // This allows an alternate client implementation to gain direct access
4311 // to the binary data and pass this for example to the JNI implementation
4312 // of the JSR48 CIM Client for Java.
4313 CIMResponseData& responseData = msg->getResponseData();
4314 responseData.setRemainingBinaryData(in);
4315
4316 msg->binaryRequest=true;
4317 return msg;
4318 }
4319 //==============================================================================
4320 //
4321 // PullInstancePaths
4322 //
4323 //==============================================================================
4324
4325 static void _encodePullInstancePathsRequest(
4326 CIMBuffer& buf,
4327 CIMPullInstancePathsRequestMessage* msg,
4328 CIMName& name)
4329 karl 1.12.2.1 {
4330 /* See ../Client/CIMOperationRequestEncoder.cpp */
4331
4332 static const CIMName NAME("PullInstancePaths");
4333 name = NAME;
4334
4335 // [HEADER]
4336
4337 Uint32 flags = 0;
4338
4339 _putHeader(buf, flags, msg->messageId, OP_PullInstancePaths);
4340
4341 // [NAMESPACE]
4342 buf.putNamespaceName(msg->nameSpace);
4343
4344 // [EnumerationContext]
4345 buf.putString(msg->enumerationContext);
4346
|
4347 karl 1.12.2.5 buf.putUint32(msg->maxObjectCount);
|
4348 karl 1.12.2.1 }
4349
4350 static CIMPullInstancePathsRequestMessage*
4351 _decodePullInstancePathsRequest(
4352 CIMBuffer& in,
4353 Uint32 queueId,
4354 Uint32 returnQueueId,
4355 Uint32 flags,
4356 const String& messageId)
4357 {
4358 /* See ../Server/CIMOperationRequestDecoder.cpp */
4359
4360 STAT_GETSTARTTIME
4361
4362 // [NAMESPACE]
4363
4364 CIMNamespaceName nameSpace;
4365 if (!in.getNamespaceName(nameSpace))
4366 return 0;
4367
4368 // [EnumerationContext]
4369 karl 1.12.2.1 String enumerationContext;
4370 if (!in.getString(enumerationContext))
4371 {
4372 return 0;
4373 }
4374
4375 // [MAXOBJECTCOUNT]
|
4376 karl 1.12.2.5 Uint32 maxObjectCount;
4377 if (!in.getUint32(maxObjectCount))
|
4378 karl 1.12.2.1 return 0;
4379
4380 AutoPtr<CIMPullInstancePathsRequestMessage> request(
4381 new CIMPullInstancePathsRequestMessage(
4382 messageId,
4383 nameSpace,
4384 enumerationContext,
4385 maxObjectCount,
4386 QueueIdStack(queueId, returnQueueId)));
4387
4388 request->binaryRequest = true;
4389
4390 STAT_SERVERSTART
4391
4392 return request.release();
4393 }
4394
4395 // For the pull Response messages the interface is the message and the,
4396 // not just the responseData.
4397 static void _encodePullInstancePathsResponseBody(
4398 CIMBuffer& out,
4399 karl 1.12.2.1 CIMPullInstancePathsResponseMessage* msg,
4400 CIMResponseData& data,
4401 CIMName& name)
4402 {
4403 /* See ../Server/CIMOperationResponseEncoder.cpp */
4404
4405 static const CIMName NAME("PullInstancePaths");
4406 name = NAME;
4407
4408 // [endOfSequence]
4409 out.putBoolean(msg->endOfSequence);
4410
4411 // [enumerationContext]
4412 out.putString(msg->enumerationContext);
4413
4414 data.encodeBinaryResponse(out);
4415 }
4416
4417 static CIMPullInstancePathsResponseMessage*
4418 _decodePullInstancePathsResponse(
4419 CIMBuffer& in,
4420 karl 1.12.2.1 const String& messageId)
4421 {
4422 CIMException cimException;
4423
4424 Boolean endOfSequence;
4425 if (!in.getBoolean(endOfSequence))
4426 return 0;
4427
4428 String enumerationContext;
4429 if (!in.getString(enumerationContext))
4430 return 0;
4431
4432 CIMPullInstancePathsResponseMessage* msg =
4433 new CIMPullInstancePathsResponseMessage(
4434 messageId,
4435 cimException,
4436 endOfSequence,
4437 enumerationContext,
4438 QueueIdStack());
4439
4440 // Instead of resolving the binary data right here, we delegate this
4441 karl 1.12.2.1 // to a later point in time when the data is actually retrieved through
4442 // a call to getNamedInstances, which is going to resolve the binary
4443 // data when the callback function is registered.
4444 // This allows an alternate client implementation to gain direct access
4445 // to the binary data and pass this for example to the JNI implementation
4446 // of the JSR48 CIM Client for Java.
4447 CIMResponseData& responseData = msg->getResponseData();
4448 responseData.setRemainingBinaryData(in);
4449
4450 msg->binaryRequest=true;
4451 return msg;
4452 }
4453 //==============================================================================
4454 //
4455 // CloseEnumeration
4456 //
4457 //==============================================================================
4458
4459 static void _encodeCloseEnumerationRequest(
4460 CIMBuffer& buf,
4461 CIMCloseEnumerationRequestMessage* msg,
4462 karl 1.12.2.1 CIMName& name)
4463 {
4464 /* See ../Client/CIMOperationRequestEncoder.cpp */
4465
4466 static const CIMName NAME("CloseEnumeration");
4467 name = NAME;
4468
4469 // [HEADER]
4470
4471 Uint32 flags = 0;
4472
4473 _putHeader(buf, flags, msg->messageId, OP_CloseEnumeration);
4474
4475 // [NAMESPACE]
4476 buf.putNamespaceName(msg->nameSpace);
4477
4478 // [EnumerationContext]
4479 buf.putString(msg->enumerationContext);
4480 }
4481
4482 static CIMCloseEnumerationRequestMessage* _decodeCloseEnumerationRequest(
4483 karl 1.12.2.1 CIMBuffer& in,
4484 Uint32 queueId,
4485 Uint32 returnQueueId,
4486 Uint32 flags,
4487 const String& messageId)
4488 {
4489 /* See ../Server/CIMOperationRequestDecoder.cpp */
4490
4491 STAT_GETSTARTTIME
4492
4493 // [NAMESPACE]
4494
4495 CIMNamespaceName nameSpace;
4496 if (!in.getNamespaceName(nameSpace))
4497 return 0;
4498
4499 // [EnumerationContext]
4500 String enumerationContext;
4501 if (!in.getString(enumerationContext))
4502 {
4503 return 0;
4504 karl 1.12.2.1 }
4505
4506 AutoPtr<CIMCloseEnumerationRequestMessage> request(
4507 new CIMCloseEnumerationRequestMessage(
4508 messageId,
4509 nameSpace,
4510 enumerationContext,
4511 QueueIdStack(queueId, returnQueueId)));
4512
4513 request->binaryRequest = true;
4514
4515 STAT_SERVERSTART
4516
4517 return request.release();
4518 }
4519
4520 static void _encodeCloseEnumerationResponseBody(
4521 CIMBuffer& out,
4522 CIMCloseEnumerationResponseMessage* msg,
4523 CIMName& name)
4524 {
4525 karl 1.12.2.1 /* See ../Server/CIMOperationResponseEncoder.cpp */
4526
4527 static const CIMName NAME("CloseEnumeration");
4528 name = NAME;
4529 }
4530
4531 static CIMCloseEnumerationResponseMessage*
4532 _decodeCloseEnumerationResponse(
4533 CIMBuffer& in,
4534 const String& messageId)
4535 {
4536 CIMException cimException;
4537
4538 CIMCloseEnumerationResponseMessage* msg =
4539 new CIMCloseEnumerationResponseMessage(
4540 messageId,
4541 cimException,
4542 QueueIdStack());
4543
4544 msg->binaryRequest=true;
4545 return msg;
4546 karl 1.12.2.1 }
4547 //==============================================================================
4548 //
4549 // EnumerationCount
4550 //
4551 //==============================================================================
4552
4553 static void _encodeEnumerationCountRequest(
4554 CIMBuffer& buf,
4555 CIMEnumerationCountRequestMessage* msg,
4556 CIMName& name)
4557 {
4558 /* See ../Client/CIMOperationRequestEncoder.cpp */
4559
4560 static const CIMName NAME("EnumerationCount");
4561 name = NAME;
4562
4563 // [HEADER]
4564 Uint32 flags = 0;
4565
4566 _putHeader(buf, flags, msg->messageId, OP_EnumerationCount);
4567 karl 1.12.2.1
4568 // [NAMESPACE]
4569 buf.putNamespaceName(msg->nameSpace);
4570
4571 // [EnumerationContext]
4572 buf.putString(msg->enumerationContext);
4573 }
4574
4575 static CIMEnumerationCountRequestMessage* _decodeEnumerationCountRequest(
4576 CIMBuffer& in,
4577 Uint32 queueId,
4578 Uint32 returnQueueId,
4579 Uint32 flags,
4580 const String& messageId)
4581 {
4582 /* See ../Server/CIMOperationRequestDecoder.cpp */
4583
4584 STAT_GETSTARTTIME
4585
4586 // [NAMESPACE]
4587
4588 karl 1.12.2.1 CIMNamespaceName nameSpace;
4589 if (!in.getNamespaceName(nameSpace))
4590 return 0;
4591
4592 // [EnumerationContext]
4593 String enumerationContext;
4594 if (!in.getString(enumerationContext))
4595 {
4596 return 0;
4597 }
4598
4599 AutoPtr<CIMEnumerationCountRequestMessage> request(
4600 new CIMEnumerationCountRequestMessage(
4601 messageId,
4602 nameSpace,
4603 enumerationContext,
4604 QueueIdStack(queueId, returnQueueId)));
4605
4606 request->binaryRequest = true;
4607
4608 STAT_SERVERSTART
4609 karl 1.12.2.1
4610 return request.release();
4611 }
4612
4613 static void _encodeEnumerationCountResponseBody(
4614 CIMBuffer& out,
4615 CIMEnumerationCountResponseMessage* msg,
4616 CIMName& name)
4617 {
4618 /* See ../Server/CIMOperationResponseEncoder.cpp */
4619
4620 static const CIMName NAME("EnumerationCount");
4621 name = NAME;
4622
4623 // [count]
4624 out.putUint64Arg(msg->count);
4625 }
4626
4627 static CIMEnumerationCountResponseMessage*
4628 _decodeEnumerationCountResponse(
4629 CIMBuffer& in,
4630 karl 1.12.2.1 const String& messageId)
4631 {
4632 CIMException cimException;
4633 Uint64 count;
4634 if (!in.getUint64(count))
4635 return 0;
4636
4637 CIMEnumerationCountResponseMessage* msg =
4638 new CIMEnumerationCountResponseMessage(
4639 messageId,
4640 cimException,
4641 QueueIdStack(),
4642 count);
4643
4644 msg->binaryRequest=true;
4645 return msg;
4646 }
|
4647 karl 1.12.2.6 //==============================================================================
4648 //
4649 // OpenQueryInstances
4650 //
4651 //==============================================================================
4652
4653 static void _encodeOpenQueryInstancesRequest(
4654 CIMBuffer& buf,
4655 CIMOpenQueryInstancesRequestMessage* msg,
4656 CIMName& name)
4657 {
4658 /* See ../Client/CIMOperationRequestEncoder.cpp */
4659
4660 static const CIMName NAME("OpenQueryInstances");
4661
4662 // [HEADER]
4663
4664 Uint32 flags = 0;
4665
4666 if (msg->continueOnError)
4667 flags |= CONTINUE_ON_ERROR;
4668 karl 1.12.2.6
4669 _putHeader(buf, flags, msg->messageId, OP_OpenQueryInstances);
4670
4671 // [NAMESPACE]
4672 buf.putNamespaceName(msg->nameSpace);
4673
4674 // [filterQuery and filterQueryLanguage]
4675 buf.putString(msg->filterQuery);
4676 buf.putString(msg->filterQueryLanguage);
4677
4678 // [returnQueryResultClass]
4679 buf.putBoolean(msg->returnQueryResultClass);
4680
4681 buf.putUint32(msg->maxObjectCount);
4682 buf.putUint32Arg(msg->operationTimeout);
4683 }
4684
4685 static CIMOpenQueryInstancesRequestMessage*
4686 _decodeOpenQueryInstancesRequest(
4687 CIMBuffer& in,
4688 Uint32 queueId,
4689 karl 1.12.2.6 Uint32 returnQueueId,
4690 Uint32 flags,
4691 const String& messageId)
4692 {
4693 /* See ../Server/CIMOperationRequestDecoder.cpp */
4694
4695 STAT_GETSTARTTIME
4696
4697 Boolean continueOnError = flags & CONTINUE_ON_ERROR;
4698
4699 // [NAMESPACE]
4700 CIMNamespaceName nameSpace;
4701 if (!in.getNamespaceName(nameSpace))
4702 return 0;
4703
4704 // [FILTERQUERY and FILTERQUERYSTRING]
4705 String filterQuery;
4706 if (!in.getString(filterQuery))
4707 return 0;
4708 String filterQueryLanguage;
4709 if (!in.getString(filterQueryLanguage))
4710 karl 1.12.2.6 return 0;
4711
4712 // [RETURNQUERYRESULTCLASS]
4713 Boolean returnQueryResultClass;
4714 if (!in.getBoolean(returnQueryResultClass))
4715 return 0;
4716
4717 // These can all be one common function.
4718 Uint32 maxObjectCount;
4719 if (!in.getUint32(maxObjectCount))
4720 return 0;
4721 Uint32Arg operationTimeout;
4722 if (!in.getUint32Arg(operationTimeout))
4723 return 0;
4724
4725 AutoPtr<CIMOpenQueryInstancesRequestMessage> request(
4726 new CIMOpenQueryInstancesRequestMessage(
4727 messageId,
4728 nameSpace,
4729 filterQuery,
4730 filterQueryLanguage,
4731 karl 1.12.2.6 returnQueryResultClass,
4732 operationTimeout,
4733 continueOnError,
4734 maxObjectCount,
4735 QueueIdStack(queueId, returnQueueId)));
4736
4737 request->binaryRequest = true;
4738
4739 STAT_SERVERSTART
4740
4741 return request.release();
4742 }
4743
4744 static void _encodeOpenQueryInstancesResponseBody(
4745 CIMBuffer& out,
4746 CIMOpenQueryInstancesResponseMessage* msg,
4747 CIMResponseData& data,
4748 CIMName& name)
4749 {
4750 /* See ../Server/CIMOperationResponseEncoder.cpp */
4751
4752 karl 1.12.2.6 out.putClass(msg->queryResultClass);
4753
4754 // [endOfSequence]
4755 out.putBoolean(msg->endOfSequence);
4756
4757 // [enumerationContext]
4758 out.putString(msg->enumerationContext);
4759
4760 data.encodeBinaryResponse(out);
4761 }
4762
4763 static CIMOpenQueryInstancesResponseMessage*
4764 _decodeOpenQueryInstancesResponse(
4765 CIMBuffer& in,
4766 const String& messageId)
4767 {
4768 CIMException cimException;
4769
4770 // KS_TODO Should we set validation???
4771 // Turn on validation: This is a debugging tool
4772 //#if defined(ENABLE_VALIDATION)
4773 karl 1.12.2.6 // buf.setValidate(true);
4774 //#endif
4775
4776 Boolean endOfSequence;
4777 if (!in.getBoolean(endOfSequence))
4778 return 0;
4779
4780 String enumerationContext;
4781 if (!in.getString(enumerationContext))
4782 return 0;
4783
4784 CIMOpenQueryInstancesResponseMessage* msg =
4785 new CIMOpenQueryInstancesResponseMessage(
4786 messageId,
4787 cimException,
4788 CIMClass(),
4789 endOfSequence,
4790 enumerationContext,
4791 QueueIdStack());
4792
4793 // Instead of resolving the binary data here, delegate this
4794 karl 1.12.2.6 // to a later point in time when the data is actually retrieved through
4795 // a call to CIMResponseData::getInstances, which
4796 // resolves the binary data as it is passed to the next interface.
4797 // This allows an alternate client implementation to gain direct access
4798 // to the binary data and pass this for example to the JNI implementation
4799 // of the JSR48 CIM Client for Java.
4800 CIMResponseData& responseData = msg->getResponseData();
4801 responseData.setRemainingBinaryData(in);
4802
4803 msg->binaryRequest=true;
4804 return msg;
4805 }
|
4806 karl 1.12.2.1
|
4807 karl 1.12.2.4 // EXP_PULL_END
|
4808 karl 1.12.2.1
4809
4810 //==============================================================================
4811 //
4812 // BinaryCodec::hexDump()
4813 //
4814 //==============================================================================
4815
4816 #if defined(PEGASUS_DEBUG)
4817
4818 void BinaryCodec::hexDump(const void* data, size_t size)
4819 {
4820 unsigned char* p = (unsigned char*)data;
4821 unsigned char buf[16];
4822 size_t n = 0;
4823
4824 for (size_t i = 0, col = 0; i < size; i++)
4825 {
4826 unsigned char c = p[i];
4827 buf[n++] = c;
4828
4829 karl 1.12.2.1 if (col == 0)
4830 printf("%06X ", (unsigned int)i);
4831
4832 printf("%02X ", c);
4833
4834 if (col + 1 == sizeof(buf) || i + 1 == size)
4835 {
4836 for (size_t j = col + 1; j < sizeof(buf); j++)
4837 printf(" ");
4838
4839 for (size_t j = 0; j < n; j++)
4840 {
4841 c = buf[j];
4842
4843 if (c >= ' ' && c <= '~')
4844 printf("%c", buf[j]);
4845 else
4846 printf(".");
4847 }
4848
4849 printf("\n");
4850 karl 1.12.2.1 n = 0;
4851 }
4852
4853 if (col + 1 == sizeof(buf))
4854 col = 0;
4855 else
4856 col++;
4857 }
4858
4859 printf("\n");
4860 }
4861
4862 #endif /* defined(PEGASUS_DEBUG) */
4863
4864 //==============================================================================
4865 //
4866 // BinaryCodec::decodeRequest()
4867 //
4868 //==============================================================================
4869
4870 CIMOperationRequestMessage* BinaryCodec::decodeRequest(
|
4871 karl 1.12.2.3 CIMBuffer& in,
|
4872 karl 1.12.2.1 Uint32 queueId,
4873 Uint32 returnQueueId)
4874 {
4875
4876 // Turn on validation:
4877 #if defined(ENABLE_VALIDATION)
|
4878 karl 1.12.2.3 in.setValidate(true);
|
4879 karl 1.12.2.1 #endif
4880
4881 Uint32 flags;
4882 String messageId;
4883 Operation operation;
4884
|
4885 karl 1.12.2.3
4886 if (!_getHeader(in, flags, messageId, operation))
|
4887 karl 1.12.2.1 {
4888 return 0;
4889 }
4890
4891 switch (operation)
4892 {
4893 case OP_EnumerateInstances:
4894 return _decodeEnumerateInstancesRequest(
|
4895 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4896 karl 1.12.2.1 case OP_EnumerateInstanceNames:
4897 return _decodeEnumerateInstanceNamesRequest(
|
4898 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4899 karl 1.12.2.1 case OP_GetInstance:
4900 return _decodeGetInstanceRequest(
|
4901 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4902 karl 1.12.2.1 case OP_CreateInstance:
4903 return _decodeCreateInstanceRequest(
|
4904 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4905 karl 1.12.2.1 case OP_ModifyInstance:
4906 return _decodeModifyInstanceRequest(
|
4907 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4908 karl 1.12.2.1 case OP_DeleteInstance:
4909 return _decodeDeleteInstanceRequest(
|
4910 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4911 karl 1.12.2.1 case OP_Associators:
4912 return _decodeAssociatorsRequest(
|
4913 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4914 karl 1.12.2.1 case OP_AssociatorNames:
4915 return _decodeAssociatorNamesRequest(
|
4916 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4917 karl 1.12.2.1 case OP_References:
4918 return _decodeReferencesRequest(
|
4919 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4920 karl 1.12.2.1 case OP_ReferenceNames:
4921 return _decodeReferenceNamesRequest(
|
4922 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4923 karl 1.12.2.1 case OP_GetClass:
4924 return _decodeGetClassRequest(
|
4925 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4926 karl 1.12.2.1 case OP_EnumerateClasses:
4927 return _decodeEnumerateClassesRequest(
|
4928 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4929 karl 1.12.2.1 case OP_EnumerateClassNames:
4930 return _decodeEnumerateClassNamesRequest(
|
4931 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4932 karl 1.12.2.1 case OP_CreateClass:
4933 return _decodeCreateClassRequest(
|
4934 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4935 karl 1.12.2.1 case OP_DeleteClass:
4936 return _decodeDeleteClassRequest(
|
4937 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4938 karl 1.12.2.1 case OP_ModifyClass:
4939 return _decodeModifyClassRequest(
|
4940 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4941 karl 1.12.2.1 case OP_SetQualifier:
4942 return _decodeSetQualifierRequest(
|
4943 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4944 karl 1.12.2.1 case OP_GetQualifier:
4945 return _decodeGetQualifierRequest(
|
4946 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4947 karl 1.12.2.1 case OP_DeleteQualifier:
4948 return _decodeDeleteQualifierRequest(
|
4949 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4950 karl 1.12.2.1 case OP_EnumerateQualifiers:
4951 return _decodeEnumerateQualifiersRequest(
|
4952 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4953 karl 1.12.2.1 case OP_GetProperty:
4954 return _decodeGetPropertyRequest(
|
4955 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4956 karl 1.12.2.1 case OP_SetProperty:
4957 return _decodeSetPropertyRequest(
|
4958 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4959 karl 1.12.2.1 case OP_InvokeMethod:
4960 return _decodeInvokeMethodRequest(
|
4961 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4962 karl 1.12.2.1 case OP_ExecQuery:
4963 return _decodeExecQueryRequest(
|
4964 karl 1.12.2.3 in, queueId, returnQueueId, messageId);
|
4965 karl 1.12.2.4 //EXP_PULL_BEGIN
|
4966 karl 1.12.2.1 case OP_OpenEnumerateInstances:
4967 return _decodeOpenEnumerateInstancesRequest(
|
4968 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4969 karl 1.12.2.1 break;
4970 case OP_OpenEnumerateInstancePaths:
4971 return _decodeOpenEnumerateInstancePathsRequest(
|
4972 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4973 karl 1.12.2.1 break;
4974 case OP_OpenReferenceInstances:
4975 return _decodeOpenReferenceInstancesRequest(
|
4976 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4977 karl 1.12.2.1 break;
4978 case OP_OpenReferenceInstancePaths:
4979 return _decodeOpenReferenceInstancePathsRequest(
|
4980 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4981 karl 1.12.2.1 break;
4982 case OP_OpenAssociatorInstances:
4983 return _decodeOpenAssociatorInstancesRequest(
|
4984 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4985 karl 1.12.2.1 break;
4986 case OP_OpenAssociatorInstancePaths:
4987 return _decodeOpenAssociatorInstancePathsRequest(
|
4988 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4989 karl 1.12.2.1 break;
4990 case OP_PullInstancesWithPath:
4991 return _decodePullInstancesWithPathRequest(
|
4992 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4993 karl 1.12.2.1 break;
4994 case OP_PullInstancePaths:
4995 return _decodePullInstancePathsRequest(
|
4996 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
4997 karl 1.12.2.1 break;
4998 case OP_CloseEnumeration:
4999 return _decodeCloseEnumerationRequest(
|
5000 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
5001 karl 1.12.2.1 break;
5002 case OP_EnumerationCount:
5003 return _decodeEnumerationCountRequest(
|
5004 karl 1.12.2.3 in, queueId, returnQueueId, flags, messageId);
|
5005 karl 1.12.2.1 break;
|
5006 karl 1.12.2.4 //EXP_PULL_END
|
5007 karl 1.12.2.1 default:
5008 // Unexpected message type
5009 PEGASUS_ASSERT(0);
5010 return 0;
5011 }
5012 }
5013
5014 //==============================================================================
5015 //
5016 // BinaryCodec::decodeResponse()
5017 //
5018 //==============================================================================
5019
5020 CIMResponseMessage* BinaryCodec::decodeResponse(
5021 const Buffer& in)
5022 {
5023 CIMBuffer buf((char*)in.getData(), in.size());
5024 CIMBufferReleaser buf_(buf);
5025
5026 return decodeResponse(buf);
5027 }
5028 karl 1.12.2.1
5029 CIMResponseMessage* BinaryCodec::decodeResponse(
5030 CIMBuffer& buf)
5031 {
|
5032 karl 1.12.2.3 // Turn on validation: This is a debugging tool
|
5033 karl 1.12.2.1 #if defined(ENABLE_VALIDATION)
5034 buf.setValidate(true);
5035 #endif
|
5036 karl 1.12.2.4
|
5037 karl 1.12.2.1 Uint32 flags;
5038 String messageId;
5039 Operation operation;
5040
5041 if (!_getHeader(buf, flags, messageId, operation))
5042 {
5043 throw CIMException(CIM_ERR_FAILED, "Corrupt binary message header");
5044 return 0;
5045 }
5046
5047 CIMResponseMessage* msg = 0;
5048
5049 switch (operation)
5050 {
5051 case OP_EnumerateInstances:
5052 msg = _decodeEnumerateInstancesResponse(buf, messageId);
5053 break;
5054 case OP_EnumerateInstanceNames:
5055 msg = _decodeEnumerateInstanceNamesResponse(buf, messageId);
5056 break;
5057 case OP_GetInstance:
|
5058 thilo.boehm 1.11 msg = _decodeGetInstanceResponse(buf, messageId);
|
5059 mike 1.1 break;
5060 case OP_CreateInstance:
|
5061 thilo.boehm 1.11 msg = _decodeCreateInstanceResponse(buf, messageId);
|
5062 mike 1.1 break;
5063 case OP_ModifyInstance:
|
5064 thilo.boehm 1.11 msg = _decodeModifyInstanceResponse(buf, messageId);
|
5065 mike 1.1 break;
5066 case OP_DeleteInstance:
|
5067 thilo.boehm 1.11 msg = _decodeDeleteInstanceResponse(messageId);
|
5068 mike 1.1 break;
5069 case OP_Associators:
|
5070 thilo.boehm 1.11 msg = _decodeAssociatorsResponse(buf, messageId);
|
5071 mike 1.1 break;
5072 case OP_AssociatorNames:
|
5073 thilo.boehm 1.11 msg = _decodeAssociatorNamesResponse(buf, messageId);
|
5074 mike 1.1 break;
5075 case OP_References:
|
5076 thilo.boehm 1.11 msg = _decodeReferencesResponse(buf, messageId);
|
5077 mike 1.1 break;
5078 case OP_ReferenceNames:
|
5079 thilo.boehm 1.11 msg = _decodeReferenceNamesResponse(buf, messageId);
|
5080 mike 1.1 break;
5081 case OP_GetClass:
|
5082 thilo.boehm 1.11 msg = _decodeGetClassResponse(buf, messageId);
|
5083 mike 1.1 break;
5084 case OP_EnumerateClasses:
|
5085 thilo.boehm 1.11 msg = _decodeEnumerateClassesResponse(buf, messageId);
|
5086 mike 1.1 break;
5087 case OP_EnumerateClassNames:
|
5088 thilo.boehm 1.11 msg = _decodeEnumerateClassNamesResponse(buf, messageId);
|
5089 mike 1.1 break;
5090 case OP_CreateClass:
|
5091 thilo.boehm 1.11 msg = _decodeCreateClassResponse(messageId);
|
5092 mike 1.1 break;
5093 case OP_DeleteClass:
|
5094 thilo.boehm 1.11 msg = _decodeDeleteClassResponse(messageId);
|
5095 mike 1.1 break;
5096 case OP_ModifyClass:
|
5097 thilo.boehm 1.11 msg = _decodeModifyClassResponse(messageId);
|
5098 mike 1.1 break;
5099 case OP_SetQualifier:
|
5100 thilo.boehm 1.11 msg = _decodeSetQualifierResponse(messageId);
|
5101 mike 1.1 break;
5102 case OP_GetQualifier:
|
5103 thilo.boehm 1.11 msg = _decodeGetQualifierResponse(buf, messageId);
|
5104 mike 1.1 break;
5105 case OP_DeleteQualifier:
|
5106 thilo.boehm 1.11 msg = _decodeDeleteQualifierResponse(messageId);
|
5107 mike 1.1 break;
5108 case OP_EnumerateQualifiers:
|
5109 thilo.boehm 1.11 msg = _decodeEnumerateQualifiersResponse(buf, messageId);
|
5110 mike 1.1 break;
5111 case OP_GetProperty:
|
5112 thilo.boehm 1.11 msg = _decodeGetPropertyResponse(buf, messageId);
|
5113 mike 1.1 break;
5114 case OP_SetProperty:
|
5115 thilo.boehm 1.11 msg = _decodeSetPropertyResponse(messageId);
|
5116 mike 1.1 break;
5117 case OP_InvokeMethod:
|
5118 thilo.boehm 1.11 msg = _decodeInvokeMethodResponse(buf, messageId);
|
5119 mike 1.1 break;
5120 case OP_ExecQuery:
|
5121 thilo.boehm 1.11 msg = _decodeExecQueryResponse(buf, messageId);
|
5122 mike 1.1 break;
|
5123 karl 1.12.2.4 //EXP_PULL_BEGIN
|
5124 karl 1.12.2.1 case OP_OpenEnumerateInstances:
5125 msg = _decodeOpenEnumerateInstancesResponse(buf, messageId);
5126 break;
5127 case OP_OpenEnumerateInstancePaths:
5128 msg = _decodeOpenEnumerateInstancePathsResponse(buf, messageId);
5129 break;
5130 case OP_OpenReferenceInstances:
5131 msg = _decodeOpenReferenceInstancesResponse(buf, messageId);
5132 break;
5133 case OP_OpenReferenceInstancePaths:
5134 msg = _decodeOpenReferenceInstancePathsResponse(buf, messageId);
5135 break;
5136 case OP_OpenAssociatorInstances:
5137 msg = _decodeOpenAssociatorInstancesResponse(buf, messageId);
5138 break;
5139 case OP_OpenAssociatorInstancePaths:
5140 msg = _decodeOpenAssociatorInstancePathsResponse(buf, messageId);
5141 break;
5142 case OP_PullInstancesWithPath:
5143 msg = _decodePullInstancesWithPathResponse(buf, messageId);
5144 break;
5145 karl 1.12.2.1 case OP_PullInstancePaths:
5146 msg = _decodePullInstancePathsResponse(buf, messageId);
5147 break;
5148 case OP_CloseEnumeration:
5149 msg = _decodeCloseEnumerationResponse(buf, messageId);
5150 break;
|
5151 karl 1.12.2.6 case OP_OpenQueryInstances:
5152 msg = _decodeCloseEnumerationResponse(buf, messageId);
5153 break;
|
5154 karl 1.12.2.4 //EXP_PULL_END
|
5155 mike 1.1 default:
5156 // Unexpected message type
|
5157 karl 1.12.2.5 PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
|
5158 mike 1.1 break;
5159 }
5160
5161 if (!msg)
|
5162 karl 1.12.2.3 throw CIMException(CIM_ERR_FAILED, "Received corrupted binary message");
|
5163 mike 1.1
5164 return msg;
5165 }
5166
5167 //==============================================================================
5168 //
5169 // BinaryCodec::formatSimpleIMethodRspMessage()
5170 //
5171 //==============================================================================
5172
5173 Buffer BinaryCodec::formatSimpleIMethodRspMessage(
5174 const CIMName& iMethodName,
5175 const String& messageId,
5176 HttpMethod httpMethod,
5177 const ContentLanguageList& httpContentLanguages,
|
5178 karl 1.12.2.1 const Buffer& rtnParams,
|
5179 mike 1.1 const Buffer& body,
5180 Uint64 serverResponseTime,
5181 Boolean isFirst,
|
5182 karl 1.12.2.5 Boolean)
|
5183 mike 1.1 {
5184 Buffer out;
|
5185 karl 1.12.2.3
|
5186 mike 1.1 if (isFirst == true)
5187 {
5188 // Write HTTP header:
|
5189 kumpf 1.6 XmlWriter::appendMethodResponseHeader(out, httpMethod,
|
5190 mike 1.1 httpContentLanguages, 0, serverResponseTime, true);
5191
|
5192 karl 1.12.2.3 for (size_t i=out.size(), k=CIMBuffer::round(i); i<k;i++)
5193 {
5194 out.append('\0');
5195 }
|
5196 mike 1.1 // Binary message header:
5197 CIMBuffer cb(128);
5198 _putHeader(cb, 0, messageId, _NameToOp(iMethodName));
5199 out.append(cb.getData(), cb.size());
5200 }
5201
5202 if (body.size() != 0)
5203 {
5204 out.append(body.getData(), body.size());
5205 }
|
5206 karl 1.12.2.1 // EXP_PULL TODO - TBD Review this.
5207 // If there are any parameters include them here.
5208 // Assumes that it is prebuilt with all components
5209 //
5210 if (rtnParams.size() != 0)
5211 {
5212 out << rtnParams;
5213 }
5214 //
5215 // //EXP_PULL_END
|
5216 mike 1.1
5217 return out;
5218 }
5219
5220 //==============================================================================
5221 //
5222 // BinaryCodec::encodeRequest()
5223 //
5224 //==============================================================================
5225
5226 bool BinaryCodec::encodeRequest(
5227 Buffer& out,
5228 const char* host,
5229 const String& authHeader,
5230 CIMOperationRequestMessage* msg,
5231 bool binaryResponse)
5232 {
5233 CIMBuffer buf;
5234 CIMName name;
5235
5236 switch (msg->getType())
5237 mike 1.1 {
5238 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
5239 {
5240 _encodeEnumerateInstancesRequest(buf,
5241 (CIMEnumerateInstancesRequestMessage*)msg, name);
5242 break;
5243 }
5244
5245 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
5246 {
5247 _encodeEnumerateInstanceNamesRequest(buf,
5248 (CIMEnumerateInstanceNamesRequestMessage*)msg, name);
5249 break;
5250 }
5251
5252 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
5253 {
5254 _encodeGetInstanceRequest(buf,
5255 (CIMGetInstanceRequestMessage*)msg, name);
5256 break;
5257 }
5258 mike 1.1
5259 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
5260 {
5261 _encodeCreateInstanceRequest(buf,
5262 (CIMCreateInstanceRequestMessage*)msg, name);
5263 break;
5264 }
5265
5266 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
5267 {
5268 _encodeModifyInstanceRequest(buf,
5269 (CIMModifyInstanceRequestMessage*)msg, name);
5270 break;
5271 }
5272
5273 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
5274 {
5275 _encodeDeleteInstanceRequest(buf,
5276 (CIMDeleteInstanceRequestMessage*)msg, name);
5277 break;
5278 }
5279 mike 1.1
5280 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
5281 {
5282 _encodeAssociatorsRequest(buf,
5283 (CIMAssociatorsRequestMessage*)msg, name);
5284 break;
5285 }
5286
5287 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
5288 {
5289 _encodeAssociatorNamesRequest(buf,
5290 (CIMAssociatorNamesRequestMessage*)msg, name);
5291 break;
5292 }
5293
5294 case CIM_REFERENCES_REQUEST_MESSAGE:
5295 {
5296 _encodeReferencesRequest(buf,
5297 (CIMReferencesRequestMessage*)msg, name);
5298 break;
5299 }
5300 mike 1.1
5301 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
5302 {
5303 _encodeReferenceNamesRequest(buf,
5304 (CIMReferenceNamesRequestMessage*)msg, name);
5305 break;
5306 }
5307
5308 case CIM_GET_CLASS_REQUEST_MESSAGE:
5309 {
5310 _encodeGetClassRequest(buf,
5311 (CIMGetClassRequestMessage*)msg, name);
5312 break;
5313 }
5314
5315 case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
5316 {
5317 _encodeEnumerateClassesRequest(buf,
5318 (CIMEnumerateClassesRequestMessage*)msg, name);
5319 break;
5320 }
5321 mike 1.1
5322 case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
5323 {
5324 _encodeEnumerateClassNamesRequest(buf,
5325 (CIMEnumerateClassNamesRequestMessage*)msg, name);
5326 break;
5327 }
5328
5329 case CIM_CREATE_CLASS_REQUEST_MESSAGE:
5330 {
5331 _encodeCreateClassRequest(buf,
5332 (CIMCreateClassRequestMessage*)msg, name);
5333 break;
5334 }
5335
5336 case CIM_DELETE_CLASS_REQUEST_MESSAGE:
5337 {
5338 _encodeDeleteClassRequest(buf,
5339 (CIMDeleteClassRequestMessage*)msg, name);
5340 break;
5341 }
5342 mike 1.1
5343 case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
5344 {
5345 _encodeModifyClassRequest(buf,
5346 (CIMModifyClassRequestMessage*)msg, name);
5347 break;
5348 }
5349
5350 case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
5351 {
5352 _encodeSetQualifierRequest(buf,
5353 (CIMSetQualifierRequestMessage*)msg, name);
5354 break;
5355 }
5356
5357 case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
5358 {
5359 _encodeGetQualifierRequest(buf,
5360 (CIMGetQualifierRequestMessage*)msg, name);
5361 break;
5362 }
5363 mike 1.1
5364 case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
5365 {
5366 _encodeDeleteQualifierRequest(buf,
5367 (CIMDeleteQualifierRequestMessage*)msg, name);
5368 break;
5369 }
5370
5371 case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
5372 {
5373 _encodeEnumerateQualifiersRequest(buf,
5374 (CIMEnumerateQualifiersRequestMessage*)msg, name);
5375 break;
5376 }
5377
5378 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
5379 {
5380 _encodeGetPropertyRequest(buf,
5381 (CIMGetPropertyRequestMessage*)msg, name);
5382 break;
5383 }
5384 mike 1.1
5385 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
5386 {
5387 _encodeSetPropertyRequest(buf,
5388 (CIMSetPropertyRequestMessage*)msg, name);
5389 break;
5390 }
5391
5392 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
5393 {
5394 _encodeInvokeMethodRequest(buf,
5395 (CIMInvokeMethodRequestMessage*)msg, name);
5396 break;
5397 }
5398
5399 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
5400 {
5401 _encodeExecQueryRequest(buf,
5402 (CIMExecQueryRequestMessage*)msg, name);
5403 break;
5404 }
|
5405 karl 1.12.2.4
5406 //EXP_PULL_BEGIN
|
5407 karl 1.12.2.1 case CIM_OPEN_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
5408 {
5409 _encodeOpenEnumerateInstancesRequest(buf,
5410 (CIMOpenEnumerateInstancesRequestMessage*)msg, name);
5411 break;
5412 }
5413
5414 case CIM_OPEN_ENUMERATE_INSTANCE_PATHS_REQUEST_MESSAGE:
5415 {
5416 _encodeOpenEnumerateInstancePathsRequest(buf,
5417 (CIMOpenEnumerateInstancePathsRequestMessage*)msg, name);
5418 break;
5419 }
5420 case CIM_OPEN_ASSOCIATOR_INSTANCES_REQUEST_MESSAGE:
5421 {
5422 _encodeOpenAssociatorInstancesRequest(buf,
5423 (CIMOpenAssociatorInstancesRequestMessage*)msg, name);
5424 break;
5425 }
5426 case CIM_OPEN_ASSOCIATOR_INSTANCE_PATHS_REQUEST_MESSAGE:
5427 {
5428 karl 1.12.2.1 _encodeOpenAssociatorInstancePathsRequest(buf,
5429 (CIMOpenAssociatorInstancePathsRequestMessage*)msg, name);
5430 break;
5431 }
5432 case CIM_OPEN_REFERENCE_INSTANCES_REQUEST_MESSAGE:
5433 {
5434 _encodeOpenReferenceInstancesRequest(buf,
5435 (CIMOpenReferenceInstancesRequestMessage*)msg, name);
5436 break;
5437 }
5438 case CIM_OPEN_REFERENCE_INSTANCE_PATHS_REQUEST_MESSAGE:
5439 {
5440 _encodeOpenReferenceInstancePathsRequest(buf,
5441 (CIMOpenReferenceInstancePathsRequestMessage*)msg, name);
5442 break;
5443 }
5444 case CIM_PULL_INSTANCES_WITH_PATH_REQUEST_MESSAGE:
5445 {
5446 _encodePullInstancesWithPathRequest(buf,
5447 (CIMPullInstancesWithPathRequestMessage*)msg, name);
5448 break;
5449 karl 1.12.2.1 }
5450 case CIM_PULL_INSTANCE_PATHS_REQUEST_MESSAGE:
5451 {
5452 _encodePullInstancePathsRequest(buf,
5453 (CIMPullInstancePathsRequestMessage*)msg, name);
5454 break;
5455 }
5456 case CIM_CLOSE_ENUMERATION_REQUEST_MESSAGE:
5457 {
5458 _encodeCloseEnumerationRequest(buf,
5459 (CIMCloseEnumerationRequestMessage*)msg, name);
5460 break;
5461 }
5462 case CIM_ENUMERATION_COUNT_REQUEST_MESSAGE:
5463 {
5464 _encodeEnumerationCountRequest(buf,
5465 (CIMEnumerationCountRequestMessage*)msg, name);
5466 break;
5467 }
|
5468 karl 1.12.2.6 case CIM_OPEN_QUERY_INSTANCES_REQUEST_MESSAGE:
5469 {
5470 _encodeOpenQueryInstancesRequest(buf,
5471 (CIMOpenQueryInstancesRequestMessage*)msg, name);
5472 break;
5473 }
|
5474 karl 1.12.2.4 //EXP_PULL_END
|
5475 mike 1.1
5476 default:
5477 // Unexpected message type
|
5478 karl 1.12.2.5 PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
|
5479 mike 1.1 return false;
5480 }
5481
5482 // [HTTP-HEADERS]
5483 XmlWriter::appendMethodCallHeader(
5484 out,
5485 host,
5486 name,
5487 msg->nameSpace.getString(),
5488 authHeader,
5489 msg->getHttpMethod(),
5490 AcceptLanguageListContainer(msg->operationContext.get(
5491 AcceptLanguageListContainer::NAME)).getLanguages(),
5492 ContentLanguageListContainer(msg->operationContext.get(
5493 ContentLanguageListContainer::NAME)).getLanguages(),
|
5494 kumpf 1.6 buf.size(),
|
5495 mike 1.1 true, /* binaryRequest */
5496 binaryResponse);
5497
|
5498 karl 1.12.2.3 // Need to pad the Buffer to the 64bit border since CIMBuffer is 64bit
5499 // aligned, but Buffer only 8bit
5500 Uint32 extraAlignBytes = CIMBuffer::round(out.size()) - out.size();
5501 for (Uint32 i=0; i < extraAlignBytes;i++)
5502 {
5503 out.append('\0');
5504 }
5505 // Need fix-up Content-length value...
5506 char * contentLengthValueStart =
5507 (char*) strstr(out.getData(), "content-length");
5508 contentLengthValueStart += sizeof("content-length: ")-1;
5509 // using sprintf to stay equal to the macro OUTPUT_CONTENTLENGTH definition
5510 // defined in XMLGenerator.h
5511 char contentLengthP[11];
5512 sprintf(contentLengthP,"%.10u", (unsigned int)buf.size()+extraAlignBytes);
5513 memcpy(contentLengthValueStart,contentLengthP,10);
5514
|
5515 mike 1.1 out.append(buf.getData(), buf.size());
5516
5517 return true;
5518 }
5519
5520 //==============================================================================
5521 //
5522 // BinaryCodec::encodeResponseBody()
5523 //
5524 //==============================================================================
5525
5526 bool BinaryCodec::encodeResponseBody(
5527 Buffer& out,
5528 const CIMResponseMessage* msg,
5529 CIMName& name)
5530 {
5531 CIMBuffer buf;
5532
5533 switch (msg->getType())
5534 {
5535 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
5536 mike 1.1 {
|
5537 r.kieninger 1.8 _encodeEnumerateInstancesResponseBody(
5538 buf,
5539 ((CIMEnumerateInstancesResponseMessage*)msg)->getResponseData(),
|
5540 karl 1.12.2.3 name,
5541 (msg->getIndex() == 0));
|
5542 mike 1.1 break;
5543 }
5544
5545 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
5546 {
|
5547 thilo.boehm 1.10 _encodeEnumerateInstanceNamesResponseBody(
5548 buf,
5549 ((CIMEnumerateInstanceNamesResponseMessage*)msg)->getResponseData(),
5550 name);
|
5551 mike 1.1 break;
5552 }
5553
5554 case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
5555 {
|
5556 r.kieninger 1.8 _encodeGetInstanceResponseBody(
5557 buf,
|
5558 thilo.boehm 1.10 ((CIMGetInstanceResponseMessage*)msg)->getResponseData(),
|
5559 r.kieninger 1.8 name);
|
5560 mike 1.1 break;
5561 }
5562
5563 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
5564 {
5565 _encodeCreateInstanceResponseBody(buf,
5566 (CIMCreateInstanceResponseMessage*)msg, name);
5567 break;
5568 }
5569
5570 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
5571 {
|
5572 thilo.boehm 1.11 _encodeModifyInstanceResponseBody(name);
|
5573 mike 1.1 break;
5574 }
5575
5576 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
5577 {
|
5578 thilo.boehm 1.11 _encodeDeleteInstanceResponseBody(name);
|
5579 mike 1.1 break;
5580 }
5581
5582 case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
5583 {
|
5584 r.kieninger 1.8 _encodeAssociatorsResponseBody(
5585 buf,
|
5586 thilo.boehm 1.10 ((CIMAssociatorsResponseMessage*)msg)->getResponseData(),
|
5587 r.kieninger 1.8 name);
|
5588 mike 1.1 break;
5589 }
5590
5591 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
5592 {
|
5593 thilo.boehm 1.10 _encodeAssociatorNamesResponseBody(
5594 buf,
5595 ((CIMAssociatorNamesResponseMessage*)msg)->getResponseData(),
5596 name);
|
5597 mike 1.1 break;
5598 }
5599
5600 case CIM_REFERENCES_RESPONSE_MESSAGE:
5601 {
|
5602 thilo.boehm 1.10 _encodeReferencesResponseBody(
5603 buf,
5604 ((CIMReferencesResponseMessage*)msg)->getResponseData(),
5605 name);
|
5606 mike 1.1 break;
5607 }
5608
5609 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
5610 {
|
5611 thilo.boehm 1.10 _encodeReferenceNamesResponseBody(
5612 buf,
5613 ((CIMReferenceNamesResponseMessage*)msg)->getResponseData(),
5614 name);
|
5615 mike 1.1 break;
5616 }
5617
5618 case CIM_GET_CLASS_RESPONSE_MESSAGE:
5619 {
5620 _encodeGetClassResponseBody(buf,
5621 (CIMGetClassResponseMessage*)msg, name);
5622 break;
5623 }
5624
5625 case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
5626 {
5627 _encodeEnumerateClassesResponseBody(buf,
5628 (CIMEnumerateClassesResponseMessage*)msg, name);
5629 break;
5630 }
5631
5632 case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
5633 {
5634 _encodeEnumerateClassNamesResponseBody(buf,
5635 (CIMEnumerateClassNamesResponseMessage*)msg, name);
5636 mike 1.1 break;
5637 }
5638
5639 case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
5640 {
|
5641 thilo.boehm 1.11 _encodeCreateClassResponseBody(name);
|
5642 mike 1.1 break;
5643 }
5644
5645 case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
5646 {
|
5647 thilo.boehm 1.11 _encodeDeleteClassResponseBody(name);
|
5648 mike 1.1 break;
5649 }
5650
5651 case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
5652 {
|
5653 thilo.boehm 1.11 _encodeModifyClassResponseBody(name);
|
5654 mike 1.1 break;
5655 }
5656
5657 case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
5658 {
|
5659 thilo.boehm 1.11 _encodeSetQualifierResponseBody(name);
|
5660 mike 1.1 break;
5661 }
5662
5663 case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
5664 {
5665 _encodeGetQualifierResponseBody(buf,
5666 (CIMGetQualifierResponseMessage*)msg, name);
5667 break;
5668 }
5669
5670 case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
5671 {
|
5672 thilo.boehm 1.11 _encodeDeleteQualifierResponseBody(name);
|
5673 mike 1.1 break;
5674 }
5675
5676 case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
5677 {
5678 _encodeEnumerateQualifiersResponseBody(buf,
5679 (CIMEnumerateQualifiersResponseMessage*)msg, name);
5680 break;
5681 }
5682
5683 case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
5684 {
5685 _encodeGetPropertyResponseBody(buf,
5686 (CIMGetPropertyResponseMessage*)msg, name);
5687 break;
5688 }
5689
5690 case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
5691 {
|
5692 thilo.boehm 1.11 _encodeSetPropertyResponseBody(name);
|
5693 mike 1.1 break;
5694 }
5695
5696 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
5697 {
5698 _encodeInvokeMethodResponseBody(buf,
5699 (CIMInvokeMethodResponseMessage*)msg, name);
5700 break;
5701 }
5702
5703 case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
5704 {
|
5705 karl 1.12.2.4 _encodeExecQueryResponseBody(
5706 buf,
|
5707 thilo.boehm 1.10 ((CIMExecQueryResponseMessage*)msg)->getResponseData(),
|
5708 r.kieninger 1.8 name);
|
5709 mike 1.1 break;
5710 }
5711
|
5712 karl 1.12.2.4 //EXP_PULL_BEGIN
|
5713 karl 1.12.2.1 case CIM_OPEN_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
5714 {
5715 _encodeOpenEnumerateInstancesResponseBody(buf,
5716 (CIMOpenEnumerateInstancesResponseMessage*)msg,
5717 ((CIMOpenEnumerateInstancesResponseMessage*)msg)->
5718 getResponseData(),
5719 name);
5720 break;
5721 }
5722
5723 case CIM_OPEN_ENUMERATE_INSTANCE_PATHS_RESPONSE_MESSAGE:
5724 {
5725 _encodeOpenEnumerateInstancePathsResponseBody(buf,
5726 (CIMOpenEnumerateInstancePathsResponseMessage*)msg,
5727 ((CIMOpenEnumerateInstancePathsResponseMessage*)msg)->
5728 getResponseData(),
5729 name);
5730 break;
5731 }
5732
5733 case CIM_OPEN_REFERENCE_INSTANCES_RESPONSE_MESSAGE:
5734 karl 1.12.2.1 {
5735 _encodeOpenReferenceInstancesResponseBody(buf,
5736 (CIMOpenReferenceInstancesResponseMessage*)msg,
5737 ((CIMOpenReferenceInstancesResponseMessage*)msg)->
5738 getResponseData(),
5739 name);
5740 break;
5741 }
5742
5743 case CIM_OPEN_REFERENCE_INSTANCE_PATHS_RESPONSE_MESSAGE:
5744 {
5745 _encodeOpenReferenceInstancePathsResponseBody(buf,
5746 (CIMOpenReferenceInstancePathsResponseMessage*)msg,
5747 ((CIMOpenReferenceInstancePathsResponseMessage*)msg)->
5748 getResponseData(),
5749 name);
5750 break;
5751 }
5752 case CIM_OPEN_ASSOCIATOR_INSTANCES_RESPONSE_MESSAGE:
5753 {
5754 _encodeOpenAssociatorInstancesResponseBody(buf,
5755 karl 1.12.2.1 (CIMOpenAssociatorInstancesResponseMessage*)msg,
5756 ((CIMOpenAssociatorInstancesResponseMessage*)msg)->
5757 getResponseData(),
5758 name);
5759 break;
5760 }
5761
5762 case CIM_OPEN_ASSOCIATOR_INSTANCE_PATHS_RESPONSE_MESSAGE:
5763 {
5764 _encodeOpenAssociatorInstancePathsResponseBody(buf,
5765 (CIMOpenAssociatorInstancePathsResponseMessage*)msg,
5766 ((CIMOpenAssociatorInstancePathsResponseMessage*)msg)->
5767 getResponseData(),
5768 name);
5769 break;
5770 }
5771
5772 case CIM_PULL_INSTANCES_WITH_PATH_RESPONSE_MESSAGE:
5773 {
5774 _encodePullInstancesWithPathResponseBody(buf,
5775 (CIMPullInstancesWithPathResponseMessage*)msg,
5776 karl 1.12.2.1 ((CIMPullInstancesWithPathResponseMessage*)msg)->
5777 getResponseData(),
5778 name);
5779 break;
5780 }
5781
5782 case CIM_PULL_INSTANCE_PATHS_RESPONSE_MESSAGE:
5783 {
5784 _encodePullInstancePathsResponseBody(buf,
5785 (CIMPullInstancePathsResponseMessage*)msg,
5786 ((CIMPullInstancePathsResponseMessage*)msg)->
5787 getResponseData(),
5788 name);
5789 break;
5790 }
5791 case CIM_CLOSE_ENUMERATION_RESPONSE_MESSAGE:
5792 {
5793 _encodeCloseEnumerationResponseBody(buf,
5794 (CIMCloseEnumerationResponseMessage*)msg,
5795 name);
5796 break;
5797 karl 1.12.2.1 }
5798 case CIM_ENUMERATION_COUNT_RESPONSE_MESSAGE:
5799 {
5800 _encodeEnumerationCountResponseBody(buf,
5801 (CIMEnumerationCountResponseMessage*)msg,
5802 name);
5803 break;
5804 }
|
5805 karl 1.12.2.4 //EXP_PULL_END
|
5806 karl 1.12.2.1
|
5807 mike 1.1 default:
5808 // Unexpected message type
|
5809 karl 1.12.2.5 PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
|
5810 mike 1.1 return false;
5811 }
5812
5813 out.append(buf.getData(), buf.size());
5814 return true;
5815 }
5816
5817 PEGASUS_NAMESPACE_END
|
Return to
BinaryCodec.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common