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
53 PEGASUS_NAMESPACE_BEGIN
54
55 //==============================================================================
56 //
57 // Local definitions:
58 //
59 //==============================================================================
60
61 static const Uint32 _MAGIC = 0xF00DFACE;
62 static const Uint32 _REVERSE_MAGIC = 0xCEFA0DF0;
63 static const Uint32 _VERSION = 1;
64 static const size_t _DEFAULT_CIM_BUFFER_SIZE = 16*1024;
65
66 enum Operation
67 {
68 OP_Invalid,
69 OP_GetClass,
70 OP_GetInstance,
71 mike 1.1 OP_IndicationDelivery,
72 OP_DeleteClass,
73 OP_DeleteInstance,
74 OP_CreateClass,
75 OP_CreateInstance,
76 OP_ModifyClass,
77 OP_ModifyInstance,
78 OP_EnumerateClasses,
79 OP_EnumerateClassNames,
80 OP_EnumerateInstances,
81 OP_EnumerateInstanceNames,
82 OP_ExecQuery,
83 OP_Associators,
84 OP_AssociatorNames,
85 OP_References,
86 OP_ReferenceNames,
87 OP_GetProperty,
88 OP_SetProperty,
89 OP_GetQualifier,
90 OP_SetQualifier,
91 OP_DeleteQualifier,
92 mike 1.1 OP_EnumerateQualifiers,
93 OP_InvokeMethod,
|
94 kumpf 1.2 OP_Count
|
95 mike 1.1 };
96
97 struct CIMBufferReleaser
98 {
99 CIMBufferReleaser(CIMBuffer& buf) : _buf(buf)
100 {
101 }
102
103 ~CIMBufferReleaser()
104 {
105 _buf.release();
106 }
107
108 private:
109 CIMBuffer& _buf;
110 };
111
112 static Operation _NameToOp(const CIMName& name)
113 {
114 const String& s = name.getString();
115
116 mike 1.1 switch (s[0])
117 {
118 case 'A':
119 if (_EQUAL(s, "Associators"))
120 return OP_Associators;
121 if (_EQUAL(s, "AssociatorNames"))
122 return OP_AssociatorNames;
123 break;
124 case 'C':
125 if (_EQUAL(s, "CreateInstance"))
126 return OP_CreateInstance;
127 if (_EQUAL(s, "CreateClass"))
128 return OP_CreateClass;
129 break;
130 case 'D':
131 if (_EQUAL(s, "DeleteInstance"))
132 return OP_DeleteInstance;
133 if (_EQUAL(s, "DeleteClass"))
134 return OP_DeleteClass;
135 if (_EQUAL(s, "DeleteQualifier"))
136 return OP_DeleteQualifier;
137 mike 1.1 break;
138 case 'E':
139 if (_EQUAL(s, "EnumerateInstances"))
140 return OP_EnumerateInstances;
141 if (_EQUAL(s, "EnumerateInstanceNames"))
142 return OP_EnumerateInstanceNames;
143 if (_EQUAL(s, "ExecQuery"))
144 return OP_ExecQuery;
145 if (_EQUAL(s, "EnumerateClassNames"))
146 return OP_EnumerateClassNames;
147 if (_EQUAL(s, "EnumerateClasses"))
148 return OP_EnumerateClasses;
149 if (_EQUAL(s, "EnumerateQualifiers"))
150 return OP_EnumerateQualifiers;
151 break;
152 case 'G':
153 if (_EQUAL(s, "GetInstance"))
154 return OP_GetInstance;
155 if (_EQUAL(s, "GetClass"))
156 return OP_GetClass;
157 if (_EQUAL(s, "GetQualifier"))
158 mike 1.1 return OP_GetQualifier;
159 if (_EQUAL(s, "GetProperty"))
160 return OP_GetProperty;
161 break;
162 case 'I':
163 if (_EQUAL(s, "InvokeMethod"))
164 return OP_InvokeMethod;
165 if (_EQUAL(s, "IndicationDelivery"))
166 return OP_IndicationDelivery;
167 break;
168 case 'M':
169 if (_EQUAL(s, "ModifyInstance"))
170 return OP_ModifyInstance;
171 if (_EQUAL(s, "ModifyClass"))
172 return OP_ModifyClass;
173 break;
174 case 'R':
175 if (_EQUAL(s, "References"))
176 return OP_References;
177 if (_EQUAL(s, "ReferenceNames"))
178 return OP_ReferenceNames;
179 mike 1.1 break;
180 case 'S':
181 if (_EQUAL(s, "SetQualifier"))
182 return OP_SetQualifier;
183 if (_EQUAL(s, "SetProperty"))
184 return OP_SetProperty;
185 break;
186 }
187
188 // Unknown, se we will assume it is an extrinsic method!
189 return OP_InvokeMethod;
190 }
191
192 static void _putHeader(
193 CIMBuffer& out,
194 Uint32 flags,
195 const String& messageId,
196 Operation operation)
197 {
198 // [MAGIC]
199 out.putUint32(_MAGIC);
200 mike 1.1
201 // [VERSION]
202 out.putUint32(_VERSION);
203
204 // [FLAGS]
205 out.putUint32(flags);
206
207 // [MESSAGEID]
208 out.putString(messageId);
209
210 // [OPERATION]
211 out.putUint32(operation);
212 }
213
214 static bool _getHeader(
215 CIMBuffer& in,
216 Uint32& flags,
217 String& messageId,
218 Operation& operation_)
219 {
220 Uint32 magic;
221 mike 1.1 Uint32 version;
222
223 // [MAGIC]
224 if (!in.getUint32(magic))
225 return false;
226
227 if (magic != _MAGIC)
228 {
229 if (magic != _REVERSE_MAGIC)
230 return false;
231
232 // Sender has opposite endianess so turn on endian swapping:
233 in.setSwap(true);
234 }
235
236 // [VERSION]
237 if (!in.getUint32(version) || version != _VERSION)
238 return false;
239
240 // [FLAGS]
241 if (!in.getUint32(flags))
242 mike 1.1 return false;
243
244 // [MESSAGEID]
245 if (!in.getString(messageId))
246 return false;
247
248 // [OPERATION]
249 {
250 Uint32 op;
251
252 if (!in.getUint32(op) || op == OP_Invalid || op >= OP_Count)
253 return false;
254
255 operation_ = Operation(op);
256 }
257
258 return true;
259 }
260
261 //==============================================================================
262 //
263 mike 1.1 // EnumerateInstances
264 //
265 //==============================================================================
266
267 static void _encodeEnumerateInstancesRequest(
268 CIMBuffer& buf,
269 CIMEnumerateInstancesRequestMessage* msg,
270 CIMName& name)
271 {
272 /* See ../Client/CIMOperationRequestEncoder.cpp */
273
274 static const CIMName NAME("EnumerateInstances");
275 name = NAME;
276
277 // [HEADER]
278
279 Uint32 flags = 0;
280
281 if (msg->deepInheritance)
282 flags |= DEEP_INHERITANCE;
283
284 mike 1.1 if (msg->includeQualifiers)
285 flags |= INCLUDE_QUALIFIERS;
286
287 if (msg->includeClassOrigin)
288 flags |= INCLUDE_CLASS_ORIGIN;
289
290 _putHeader(buf, flags, msg->messageId, OP_EnumerateInstances);
291
292 // [NAMESPACE]
293 buf.putNamespaceName(msg->nameSpace);
294
295 // [CLASSNAME]
296 buf.putName(msg->className);
297
298 // [PROPERTY-LIST]
299 buf.putPropertyList(msg->propertyList);
300 }
301
302 static CIMEnumerateInstancesRequestMessage* _decodeEnumerateInstancesRequest(
303 CIMBuffer& in,
304 Uint32 queueId,
305 mike 1.1 Uint32 returnQueueId,
306 Uint32 flags,
307 const String& messageId)
308 {
309 /* See ../Server/CIMOperationRequestDecoder.cpp */
310
311 STAT_GETSTARTTIME
312
313 Boolean deepInheritance = flags & DEEP_INHERITANCE;
314 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
315 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
316
317 // [NAMESPACE]
318
319 CIMNamespaceName nameSpace;
320
321 if (!in.getNamespaceName(nameSpace))
322 return 0;
323
324 // [CLASSNAME]
325 CIMName className;
326 mike 1.1
327 if (!in.getName(className))
328 return 0;
329
330 // [PROPERTY-LIST]
331 CIMPropertyList propertyList;
332 if (!in.getPropertyList(propertyList))
333 return 0;
334
335 AutoPtr<CIMEnumerateInstancesRequestMessage> request(
336 new CIMEnumerateInstancesRequestMessage(
337 messageId,
338 nameSpace,
339 className,
340 deepInheritance,
341 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
342 false,
343 #else
344 includeQualifiers,
345 #endif
346 includeClassOrigin,
347 mike 1.1 propertyList,
348 QueueIdStack(queueId, returnQueueId)));
349
350 request->binaryRequest = true;
351
352 STAT_SERVERSTART
353
354 return request.release();
355 }
356
357 static void _encodeEnumerateInstancesResponseBody(
358 CIMBuffer& out,
|
359 r.kieninger 1.8 CIMInstancesResponseData& data,
|
360 mike 1.1 CIMName& name)
361 {
362 /* See ../Server/CIMOperationResponseEncoder.cpp */
363
364 static const CIMName NAME("EnumerateInstances");
365 name = NAME;
366
|
367 r.kieninger 1.8 data.encodeBinaryResponse(out);
|
368 mike 1.1 }
369
370 static CIMEnumerateInstancesResponseMessage* _decodeEnumerateInstancesResponse(
371 CIMBuffer& in,
372 Uint32 flags,
373 const String& messageId)
374 {
375 /* See ../Client/CIMOperationResponseDecoder.cpp */
376
377 Array<CIMInstance> instances;
378
379 while (in.more())
380 {
381 Array<CIMInstance> tmp;
382
383 if (!in.getInstanceA(tmp))
384 return 0;
385
386 instances.append(tmp.getData(), tmp.size());
387 }
388
389 mike 1.1 CIMEnumerateInstancesResponseMessage* msg;
390 CIMException cimException;
391
392 msg = new CIMEnumerateInstancesResponseMessage(
393 messageId,
394 cimException,
395 QueueIdStack());
396
|
397 r.kieninger 1.8 msg->getResponseData().setNamedInstances(instances);
|
398 mike 1.1 msg->binaryRequest = true;
399 return msg;
400 }
401
402 //==============================================================================
403 //
404 // EnumerateInstanceNames
405 //
406 //==============================================================================
407
|
408 kumpf 1.6 static CIMEnumerateInstanceNamesRequestMessage*
|
409 mike 1.1 _decodeEnumerateInstanceNamesRequest(
410 CIMBuffer& in,
411 Uint32 queueId,
412 Uint32 returnQueueId,
413 Uint32 flags,
414 const String& messageId)
415 {
416 STAT_GETSTARTTIME
417
418 // [NAMESPACE]
419 CIMNamespaceName nameSpace;
420
421 if (!in.getNamespaceName(nameSpace))
422 return 0;
423
424 // [CLASSNAME]
425 CIMName className;
426
427 if (!in.getName(className))
428 return 0;
429
430 mike 1.1 AutoPtr<CIMEnumerateInstanceNamesRequestMessage> request(
431 new CIMEnumerateInstanceNamesRequestMessage(
432 messageId,
433 nameSpace,
434 className,
435 QueueIdStack(queueId, returnQueueId)));
436
437 request->binaryRequest = true;
438
439 STAT_SERVERSTART
440
441 return request.release();
442 }
443
|
444 kumpf 1.6 static CIMEnumerateInstanceNamesResponseMessage*
|
445 mike 1.1 _decodeEnumerateInstanceNamesResponse(
446 CIMBuffer& in,
447 Uint32 flags,
448 const String& messageId)
449 {
450 Array<CIMObjectPath> instanceNames;
451
452 while (in.more())
453 {
454 Array<CIMObjectPath> tmp;
455
456 if (!in.getObjectPathA(tmp))
457 return 0;
458
459 instanceNames.append(tmp.getData(), tmp.size());
460 }
461
462 CIMEnumerateInstanceNamesResponseMessage* msg;
463 CIMException cimException;
464
465 msg = new CIMEnumerateInstanceNamesResponseMessage(
466 mike 1.1 messageId,
467 cimException,
468 QueueIdStack(),
469 instanceNames);
470
471 msg->binaryRequest = true;
472 return msg;
473 }
474
475 static void _encodeEnumerateInstanceNamesRequest(
476 CIMBuffer& buf,
477 CIMEnumerateInstanceNamesRequestMessage* msg,
478 CIMName& name)
479 {
480 static const CIMName NAME("EnumerateInstanceNames");
481 name = NAME;
482
483 // [HEADER]
484
485 _putHeader(buf, 0, msg->messageId, OP_EnumerateInstanceNames);
486
487 mike 1.1 // [NAMESPACE]
488 buf.putNamespaceName(msg->nameSpace);
489
490 // [CLASSNAME]
491 buf.putName(msg->className);
492 }
493
494 static void _encodeEnumerateInstanceNamesResponseBody(
495 CIMBuffer& out,
496 CIMEnumerateInstanceNamesResponseMessage* msg,
497 CIMName& name)
498 {
499 static const CIMName NAME("EnumerateInstanceNames");
500 name = NAME;
501
502 out.putObjectPathA(msg->instanceNames, false);
503 }
504
505 //==============================================================================
506 //
507 // GetInstance
508 mike 1.1 //
509 //==============================================================================
510
511 static CIMGetInstanceRequestMessage* _decodeGetInstanceRequest(
512 CIMBuffer& in,
513 Uint32 queueId,
514 Uint32 returnQueueId,
515 Uint32 flags,
516 const String& messageId)
517 {
518 STAT_GETSTARTTIME
519
520 // [FLAGS]
521
522 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
523 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
524
525 // [NAMESPACE]
526 CIMNamespaceName nameSpace;
527
528 if (!in.getNamespaceName(nameSpace))
529 mike 1.1 return 0;
530
531 // [INSTANCE-NAME]
532 CIMObjectPath instanceName;
533
534 if (!in.getObjectPath(instanceName))
535 return 0;
536
537 // [PROPERTY-LIST]
538 CIMPropertyList propertyList;
539 if (!in.getPropertyList(propertyList))
540 return 0;
541
542 AutoPtr<CIMGetInstanceRequestMessage> request(
543 new CIMGetInstanceRequestMessage(
544 messageId,
545 nameSpace,
546 instanceName,
547 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
548 false,
549 #else
550 mike 1.1 includeQualifiers,
551 #endif
552 includeClassOrigin,
553 propertyList,
554 QueueIdStack(queueId, returnQueueId)));
555
556 request->binaryRequest = true;
557
558 STAT_SERVERSTART
559
560 return request.release();
561 }
562
563 static CIMGetInstanceResponseMessage* _decodeGetInstanceResponse(
564 CIMBuffer& in,
565 Uint32 flags,
566 const String& messageId)
567 {
568 CIMInstance instance;
569
570 if (!in.getInstance(instance))
571 mike 1.1 return 0;
572
573 CIMGetInstanceResponseMessage* msg;
574 CIMException cimException;
575
576 msg = new CIMGetInstanceResponseMessage(
577 messageId,
578 cimException,
579 QueueIdStack());
580
|
581 r.kieninger 1.8 msg->getResponseData().setCimInstance(instance);
|
582 mike 1.1 msg->binaryRequest = true;
583 return msg;
584 }
585
586 static void _encodeGetInstanceRequest(
587 CIMBuffer& buf,
588 CIMGetInstanceRequestMessage* msg,
589 CIMName& name)
590 {
591 static const CIMName NAME("GetInstance");
592 name = NAME;
593
594 // [HEADER]
595
596 Uint32 flags = 0;
597
598 if (msg->includeQualifiers)
599 flags |= INCLUDE_QUALIFIERS;
600
601 if (msg->includeClassOrigin)
602 flags |= INCLUDE_CLASS_ORIGIN;
603 mike 1.1
604 _putHeader(buf, flags, msg->messageId, OP_GetInstance);
605
606 // [NAMESPACE]
607 buf.putNamespaceName(msg->nameSpace);
608
609 // [INSTANCE-NAME]
610 buf.putObjectPath(msg->instanceName);
611
612 // [PROPERTY-LIST]
613 buf.putPropertyList(msg->propertyList);
614 }
615
616 static void _encodeGetInstanceResponseBody(
617 CIMBuffer& out,
|
618 r.kieninger 1.8 CIMInstanceResponseData& data,
|
619 mike 1.1 CIMName& name)
620 {
621 static const CIMName NAME("GetInstance");
622 name = NAME;
623
|
624 r.kieninger 1.8 data.encodeBinaryResponse(out);
|
625 mike 1.1 }
626
627 //==============================================================================
628 //
629 // CreateInstance
630 //
631 //==============================================================================
632
633 static void _encodeCreateInstanceRequest(
634 CIMBuffer& buf,
635 CIMCreateInstanceRequestMessage* msg,
636 CIMName& name)
637 {
638 static const CIMName NAME("CreateInstance");
639 name = NAME;
640
641 // [HEADER]
642 _putHeader(buf, 0, msg->messageId, OP_CreateInstance);
643
644 // [NAMESPACE]
645 buf.putNamespaceName(msg->nameSpace);
646 mike 1.1
647 // [NEW-INSTANCE]
648 buf.putInstance(msg->newInstance, false);
649 }
650
651 static CIMCreateInstanceRequestMessage* _decodeCreateInstanceRequest(
652 CIMBuffer& in,
653 Uint32 queueId,
654 Uint32 returnQueueId,
655 Uint32 flags,
656 const String& messageId)
657 {
658 STAT_GETSTARTTIME
659
660 // [NAMESPACE]
661
662 CIMNamespaceName nameSpace;
663
664 if (!in.getNamespaceName(nameSpace))
665 return 0;
666
667 mike 1.1 // [NEW-INSTANCE]
668
669 CIMInstance newInstance;
670
671 if (!in.getInstance(newInstance))
672 return 0;
673
674 AutoPtr<CIMCreateInstanceRequestMessage> request(
675 new CIMCreateInstanceRequestMessage(
676 messageId,
677 nameSpace,
678 newInstance,
679 QueueIdStack(queueId, returnQueueId)));
680
681 request->binaryRequest = true;
682
683 STAT_SERVERSTART
684
685 return request.release();
686 }
687
688 mike 1.1 static void _encodeCreateInstanceResponseBody(
689 CIMBuffer& out,
690 CIMCreateInstanceResponseMessage* msg,
691 CIMName& name)
692 {
693 static const CIMName NAME("CreateInstance");
694 name = NAME;
695
696 out.putObjectPath(msg->instanceName, false);
697 }
698
699 static CIMCreateInstanceResponseMessage* _decodeCreateInstanceResponse(
700 CIMBuffer& in,
701 Uint32 flags,
702 const String& messageId)
703 {
704 CIMObjectPath instanceName;
705
706 if (!in.getObjectPath(instanceName))
707 return 0;
708
709 mike 1.1 CIMCreateInstanceResponseMessage* msg;
710 CIMException cimException;
711
712 msg = new CIMCreateInstanceResponseMessage(
713 messageId,
714 cimException,
715 QueueIdStack(),
716 instanceName);
717
718 msg->binaryRequest = true;
719
720 return msg;
721 }
722
723 //==============================================================================
724 //
725 // ModifyInstance
726 //
727 //==============================================================================
728
729 static void _encodeModifyInstanceRequest(
730 mike 1.1 CIMBuffer& buf,
731 CIMModifyInstanceRequestMessage* msg,
732 CIMName& name)
733 {
734 /* See ../Client/CIMOperationRequestEncoder.cpp */
735
736 static const CIMName NAME("ModifyInstance");
737 name = NAME;
738
739 // [HEADER]
740
741 Uint32 flags = 0;
742
743 if (msg->includeQualifiers)
744 flags |= INCLUDE_QUALIFIERS;
745
746 _putHeader(buf, flags, msg->messageId, OP_ModifyInstance);
747
748 // [NAMESPACE]
749 buf.putNamespaceName(msg->nameSpace);
750
751 mike 1.1 // [MODIFIED-INSTANCE]
752 buf.putInstance(msg->modifiedInstance, false);
753
754 // [PROPERTY-LIST]
755 buf.putPropertyList(msg->propertyList);
756 }
757
758 static CIMModifyInstanceRequestMessage* _decodeModifyInstanceRequest(
759 CIMBuffer& in,
760 Uint32 queueId,
761 Uint32 returnQueueId,
762 Uint32 flags,
763 const String& messageId)
764 {
765 /* See ../Server/CIMOperationRequestDecoder.cpp */
766
767 STAT_GETSTARTTIME
768
769 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
770
771 // [NAMESPACE]
772 mike 1.1
773 CIMNamespaceName nameSpace;
774
775 if (!in.getNamespaceName(nameSpace))
776 return 0;
777
778 // [MODIFIED-INSTANCE]
779 CIMInstance modifiedInstance;
780
781 if (!in.getInstance(modifiedInstance))
782 return 0;
783
784 // [PROPERTY-LIST]
785 CIMPropertyList propertyList;
786 if (!in.getPropertyList(propertyList))
787 return 0;
788
789 AutoPtr<CIMModifyInstanceRequestMessage> request(
790 new CIMModifyInstanceRequestMessage(
791 messageId,
792 nameSpace,
793 mike 1.1 modifiedInstance,
794 includeQualifiers,
795 propertyList,
796 QueueIdStack(queueId, returnQueueId)));
797
798 request->binaryRequest = true;
799
800 STAT_SERVERSTART
801
802 return request.release();
803 }
804
805 static void _encodeModifyInstanceResponseBody(
806 CIMBuffer& out,
807 CIMModifyInstanceResponseMessage* msg,
808 CIMName& name)
809 {
810 /* See ../Server/CIMOperationResponseEncoder.cpp */
811
812 static const CIMName NAME("ModifyInstance");
813 name = NAME;
814 mike 1.1 }
815
816 static CIMModifyInstanceResponseMessage* _decodeModifyInstanceResponse(
817 CIMBuffer& in,
818 Uint32 flags,
819 const String& messageId)
820 {
821 /* See ../Client/CIMOperationResponseDecoder.cpp */
822
823 Array<CIMInstance> instances;
824
825 while (in.more())
826 {
827 Array<CIMInstance> tmp;
828
829 if (!in.getInstanceA(tmp))
830 return 0;
831
832 instances.append(tmp.getData(), tmp.size());
833 }
834
835 mike 1.1 CIMModifyInstanceResponseMessage* msg;
836 CIMException cimException;
837
838 msg = new CIMModifyInstanceResponseMessage(
839 messageId,
840 cimException,
841 QueueIdStack());
842
843 msg->binaryRequest = true;
844 return msg;
845 }
846
847 //==============================================================================
848 //
849 // DeleteInstance
850 //
851 //==============================================================================
852
853 static void _encodeDeleteInstanceRequest(
854 CIMBuffer& buf,
855 CIMDeleteInstanceRequestMessage* msg,
856 mike 1.1 CIMName& name)
857 {
858 /* See ../Client/CIMOperationRequestEncoder.cpp */
859
860 static const CIMName NAME("DeleteInstance");
861 name = NAME;
862
863 // [HEADER]
864 _putHeader(buf, 0, msg->messageId, OP_DeleteInstance);
865
866 // [NAMESPACE]
867 buf.putNamespaceName(msg->nameSpace);
868
869 // [INSTANCE-NAME]
870 buf.putObjectPath(msg->instanceName, false);
871 }
872
873 static CIMDeleteInstanceRequestMessage* _decodeDeleteInstanceRequest(
874 CIMBuffer& in,
875 Uint32 queueId,
876 Uint32 returnQueueId,
877 mike 1.1 Uint32 flags,
878 const String& messageId)
879 {
880 /* See ../Server/CIMOperationRequestDecoder.cpp */
881
882 STAT_GETSTARTTIME
883
884 // [NAMESPACE]
885 CIMNamespaceName nameSpace;
886
887 if (!in.getNamespaceName(nameSpace))
888 return 0;
889
890 // [INSTANCE-NAME]
891 CIMObjectPath instanceName;
892
893 if (!in.getObjectPath(instanceName))
894 return 0;
895
896 AutoPtr<CIMDeleteInstanceRequestMessage> request(
897 new CIMDeleteInstanceRequestMessage(
898 mike 1.1 messageId,
899 nameSpace,
900 instanceName,
901 QueueIdStack(queueId, returnQueueId)));
902
903 request->binaryRequest = true;
904
905 STAT_SERVERSTART
906
907 return request.release();
908 }
909
910 static void _encodeDeleteInstanceResponseBody(
911 CIMBuffer& out,
912 CIMDeleteInstanceResponseMessage* msg,
913 CIMName& name)
914 {
915 /* See ../Server/CIMOperationResponseEncoder.cpp */
916
917 static const CIMName NAME("DeleteInstance");
918 name = NAME;
919 mike 1.1 }
920
921 static CIMDeleteInstanceResponseMessage* _decodeDeleteInstanceResponse(
922 CIMBuffer& in,
923 Uint32 flags,
924 const String& messageId)
925 {
926 /* See ../Client/CIMOperationResponseDecoder.cpp */
927
928 CIMDeleteInstanceResponseMessage* msg;
929 CIMException cimException;
930
931 msg = new CIMDeleteInstanceResponseMessage(
932 messageId,
933 cimException,
934 QueueIdStack());
935
936 msg->binaryRequest = true;
937 return msg;
938 }
939
940 mike 1.1 //==============================================================================
941 //
942 // Associators
943 //
944 //==============================================================================
945
946 static void _encodeAssociatorsRequest(
947 CIMBuffer& buf,
948 CIMAssociatorsRequestMessage* msg,
949 CIMName& name)
950 {
951 /* See ../Client/CIMOperationRequestEncoder.cpp */
952
953 static const CIMName NAME("Associators");
954 name = NAME;
955
956 // [HEADER]
957
958 Uint32 flags = 0;
959
960 if (msg->includeQualifiers)
961 mike 1.1 flags |= INCLUDE_QUALIFIERS;
962
963 if (msg->includeClassOrigin)
964 flags |= INCLUDE_CLASS_ORIGIN;
965
966 _putHeader(buf, flags, msg->messageId, OP_Associators);
967
968 // [NAMESPACE]
969 buf.putNamespaceName(msg->nameSpace);
970
971 // [OBJECT-NAME]
972 buf.putObjectPath(msg->objectName);
973
974 // [ASSOC-CLASS]
975 buf.putName(msg->assocClass);
976
977 // [RESULT-CLASS]
978 buf.putName(msg->resultClass);
979
980 // [ROLE]
981 buf.putString(msg->role);
982 mike 1.1
983 // [RESULT-ROLE]
984 buf.putString(msg->resultRole);
985
986 // [PROPERTY-LIST]
987 buf.putPropertyList(msg->propertyList);
988 }
989
990 static CIMAssociatorsRequestMessage* _decodeAssociatorsRequest(
991 CIMBuffer& in,
992 Uint32 queueId,
993 Uint32 returnQueueId,
994 Uint32 flags,
995 const String& messageId)
996 {
997 /* See ../Server/CIMOperationRequestDecoder.cpp */
998
999 STAT_GETSTARTTIME
1000
1001 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
1002 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
1003 mike 1.1
1004 // [NAMESPACE]
1005
1006 CIMNamespaceName nameSpace;
1007
1008 if (!in.getNamespaceName(nameSpace))
1009 return 0;
1010
1011 // [OBJECT-NAME]
1012 CIMObjectPath objectName;
1013
1014 if (!in.getObjectPath(objectName))
1015 return 0;
1016
1017 // [ASSOC-CLASS]
1018
1019 CIMName assocClass;
1020
1021 if (!in.getName(assocClass))
1022 return 0;
1023
1024 mike 1.1 // [RESULT-CLASS]
1025
1026 CIMName resultClass;
1027
1028 if (!in.getName(resultClass))
1029 return 0;
1030
1031 // [ROLE]
1032
1033 String role;
1034
1035 if (!in.getString(role))
1036 return 0;
1037
1038 // [RESULT-ROLE]
1039
1040 String resultRole;
1041
1042 if (!in.getString(resultRole))
1043 return 0;
1044
1045 mike 1.1 // [PROPERTY-LIST]
1046
1047 CIMPropertyList propertyList;
1048
1049 if (!in.getPropertyList(propertyList))
1050 return 0;
1051
1052 AutoPtr<CIMAssociatorsRequestMessage> request(
1053 new CIMAssociatorsRequestMessage(
1054 messageId,
1055 nameSpace,
1056 objectName,
1057 assocClass,
1058 resultClass,
1059 role,
1060 resultRole,
1061 includeQualifiers,
1062 includeClassOrigin,
1063 propertyList,
1064 QueueIdStack(queueId, returnQueueId)));
1065
1066 mike 1.1 request->binaryRequest = true;
1067
1068 STAT_SERVERSTART
1069
1070 return request.release();
1071 }
1072
1073 static void _encodeAssociatorsResponseBody(
1074 CIMBuffer& out,
|
1075 r.kieninger 1.8 CIMObjectsResponseData& data,
|
1076 mike 1.1 CIMName& name)
1077 {
1078 /* See ../Server/CIMOperationResponseEncoder.cpp */
1079
1080 static const CIMName NAME("Associators");
1081 name = NAME;
1082
|
1083 r.kieninger 1.8
1084 data.encodeBinaryResponse(out);
|
1085 mike 1.1 }
1086
1087 static CIMAssociatorsResponseMessage* _decodeAssociatorsResponse(
1088 CIMBuffer& in,
1089 Uint32 flags,
1090 const String& messageId)
1091 {
1092 /* See ../Client/CIMOperationResponseDecoder.cpp */
1093
1094 Array<CIMObject> cimObjects;
1095
1096 while (in.more())
1097 {
1098 Array<CIMObject> tmp;
1099
1100 if (!in.getObjectA(tmp))
1101 return 0;
1102
1103 cimObjects.append(tmp.getData(), tmp.size());
1104 }
1105
1106 mike 1.1 CIMAssociatorsResponseMessage* msg;
1107 CIMException cimException;
1108
1109 msg = new CIMAssociatorsResponseMessage(
1110 messageId,
1111 cimException,
|
1112 r.kieninger 1.8 QueueIdStack());
|
1113 mike 1.1
|
1114 r.kieninger 1.8 msg->getResponseData().setCIMObjects(cimObjects);
|
1115 mike 1.1 msg->binaryRequest = true;
1116 return msg;
1117 }
1118
1119 //==============================================================================
1120 //
1121 // AssociatorNames
1122 //
1123 //==============================================================================
1124
1125 static void _encodeAssociatorNamesRequest(
1126 CIMBuffer& buf,
1127 CIMAssociatorNamesRequestMessage* msg,
1128 CIMName& name)
1129 {
1130 /* See ../Client/CIMOperationRequestEncoder.cpp */
1131
1132 static const CIMName NAME("AssociatorNames");
1133 name = NAME;
1134
1135 // [HEADER]
1136 mike 1.1 Uint32 flags = 0;
1137
1138 _putHeader(buf, flags, msg->messageId, OP_AssociatorNames);
1139
1140 // [NAMESPACE]
1141 buf.putNamespaceName(msg->nameSpace);
1142
1143 // [OBJECT-NAME]
1144 buf.putObjectPath(msg->objectName);
1145
1146 // [ASSOC-CLASS]
1147 buf.putName(msg->assocClass);
1148
1149 // [RESULT-CLASS]
1150 buf.putName(msg->resultClass);
1151
1152 // [ROLE]
1153 buf.putString(msg->role);
1154
1155 // [RESULT-ROLE]
1156 buf.putString(msg->resultRole);
1157 mike 1.1 }
1158
1159 static CIMAssociatorNamesRequestMessage* _decodeAssociatorNamesRequest(
1160 CIMBuffer& in,
1161 Uint32 queueId,
1162 Uint32 returnQueueId,
1163 Uint32 flags,
1164 const String& messageId)
1165 {
1166 /* See ../Server/CIMOperationRequestDecoder.cpp */
1167
1168 STAT_GETSTARTTIME
1169
1170 // [NAMESPACE]
1171
1172 CIMNamespaceName nameSpace;
1173
1174 if (!in.getNamespaceName(nameSpace))
1175 return 0;
1176
1177 // [OBJECT-NAME]
1178 mike 1.1 CIMObjectPath objectName;
1179
1180 if (!in.getObjectPath(objectName))
1181 return 0;
1182
1183 // [ASSOC-CLASS]
1184
1185 CIMName assocClass;
1186
1187 if (!in.getName(assocClass))
1188 return 0;
1189
1190 // [RESULT-CLASS]
1191
1192 CIMName resultClass;
1193
1194 if (!in.getName(resultClass))
1195 return 0;
1196
1197 // [ROLE]
1198
1199 mike 1.1 String role;
1200
1201 if (!in.getString(role))
1202 return 0;
1203
1204 // [RESULT-ROLE]
1205
1206 String resultRole;
1207
1208 if (!in.getString(resultRole))
1209 return 0;
1210
1211 AutoPtr<CIMAssociatorNamesRequestMessage> request(
1212 new CIMAssociatorNamesRequestMessage(
1213 messageId,
1214 nameSpace,
1215 objectName,
1216 assocClass,
1217 resultClass,
1218 role,
1219 resultRole,
1220 mike 1.1 QueueIdStack(queueId, returnQueueId)));
1221
1222 request->binaryRequest = true;
1223
1224 STAT_SERVERSTART
1225
1226 return request.release();
1227 }
1228
1229 static void _encodeAssociatorNamesResponseBody(
1230 CIMBuffer& out,
1231 CIMAssociatorNamesResponseMessage* msg,
1232 CIMName& name)
1233 {
1234 /* See ../Server/CIMOperationResponseEncoder.cpp */
1235
1236 static const CIMName NAME("AssociatorNames");
1237 name = NAME;
1238
1239 out.putObjectPathA(msg->objectNames);
1240 }
1241 mike 1.1
1242 static CIMAssociatorNamesResponseMessage* _decodeAssociatorNamesResponse(
1243 CIMBuffer& in,
1244 Uint32 flags,
1245 const String& messageId)
1246 {
1247 /* See ../Client/CIMOperationResponseDecoder.cpp */
1248
1249 Array<CIMObjectPath> objectNames;
1250
1251 while (in.more())
1252 {
1253 Array<CIMObjectPath> tmp;
1254
1255 if (!in.getObjectPathA(tmp))
1256 return 0;
1257
1258 objectNames.append(tmp.getData(), tmp.size());
1259 }
1260
1261 CIMAssociatorNamesResponseMessage* msg;
1262 mike 1.1 CIMException cimException;
1263
1264 msg = new CIMAssociatorNamesResponseMessage(
1265 messageId,
1266 cimException,
1267 QueueIdStack(),
1268 objectNames);
1269
1270 msg->binaryRequest = true;
1271 return msg;
1272 }
1273
1274 //==============================================================================
1275 //
1276 // References
1277 //
1278 //==============================================================================
1279
1280 static void _encodeReferencesRequest(
1281 CIMBuffer& buf,
1282 CIMReferencesRequestMessage* msg,
1283 mike 1.1 CIMName& name)
1284 {
1285 /* See ../Client/CIMOperationRequestEncoder.cpp */
1286
1287 static const CIMName NAME("References");
1288 name = NAME;
1289
1290 // [HEADER]
1291
1292 Uint32 flags = 0;
1293
1294 if (msg->includeQualifiers)
1295 flags |= INCLUDE_QUALIFIERS;
1296
1297 if (msg->includeClassOrigin)
1298 flags |= INCLUDE_CLASS_ORIGIN;
1299
1300 _putHeader(buf, flags, msg->messageId, OP_References);
1301
1302 // [NAMESPACE]
1303 buf.putNamespaceName(msg->nameSpace);
1304 mike 1.1
1305 // [OBJECT-NAME]
1306 buf.putObjectPath(msg->objectName);
1307
1308 // [RESULT-CLASS]
1309 buf.putName(msg->resultClass);
1310
1311 // [ROLE]
1312 buf.putString(msg->role);
1313
1314 // [PROPERTY-LIST]
1315 buf.putPropertyList(msg->propertyList);
1316 }
1317
1318 static CIMReferencesRequestMessage* _decodeReferencesRequest(
1319 CIMBuffer& in,
1320 Uint32 queueId,
1321 Uint32 returnQueueId,
1322 Uint32 flags,
1323 const String& messageId)
1324 {
1325 mike 1.1 /* See ../Server/CIMOperationRequestDecoder.cpp */
1326
1327 STAT_GETSTARTTIME
1328
1329 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
1330 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
1331
1332 // [NAMESPACE]
1333
1334 CIMNamespaceName nameSpace;
1335
1336 if (!in.getNamespaceName(nameSpace))
1337 return 0;
1338
1339 // [OBJECT-NAME]
1340
1341 CIMObjectPath objectName;
1342
1343 if (!in.getObjectPath(objectName))
1344 return 0;
1345
1346 mike 1.1 // [RESULT-CLASS]
1347
1348 CIMName resultClass;
1349
1350 if (!in.getName(resultClass))
1351 return 0;
1352
1353 // [ROLE]
1354
1355 String role;
1356
1357 if (!in.getString(role))
1358 return 0;
1359
1360 // [PROPERTY-LIST]
1361
1362 CIMPropertyList propertyList;
1363
1364 if (!in.getPropertyList(propertyList))
1365 return 0;
1366
1367 mike 1.1 AutoPtr<CIMReferencesRequestMessage> request(
1368 new CIMReferencesRequestMessage(
1369 messageId,
1370 nameSpace,
1371 objectName,
1372 resultClass,
1373 role,
1374 includeQualifiers,
1375 includeClassOrigin,
1376 propertyList,
1377 QueueIdStack(queueId, returnQueueId)));
1378
1379 request->binaryRequest = true;
1380
1381 STAT_SERVERSTART
1382
1383 return request.release();
1384 }
1385
1386 static void _encodeReferencesResponseBody(
1387 CIMBuffer& out,
1388 mike 1.1 CIMReferencesResponseMessage* msg,
1389 CIMName& name)
1390 {
1391 /* See ../Server/CIMOperationResponseEncoder.cpp */
1392
1393 static const CIMName NAME("References");
1394 name = NAME;
1395
1396 out.putObjectA(msg->cimObjects);
1397 }
1398
1399 static CIMReferencesResponseMessage* _decodeReferencesResponse(
1400 CIMBuffer& in,
1401 Uint32 flags,
1402 const String& messageId)
1403 {
1404 /* See ../Client/CIMOperationResponseDecoder.cpp */
1405
1406 Array<CIMObject> cimObjects;
1407
1408 while (in.more())
1409 mike 1.1 {
1410 Array<CIMObject> tmp;
1411
1412 if (!in.getObjectA(tmp))
1413 {
1414 return 0;
1415 }
1416
1417 cimObjects.append(tmp.getData(), tmp.size());
1418 }
1419
1420 CIMReferencesResponseMessage* msg;
1421 CIMException cimException;
1422
1423 msg = new CIMReferencesResponseMessage(
1424 messageId,
1425 cimException,
1426 QueueIdStack(),
1427 cimObjects);
1428
1429 msg->binaryRequest = true;
1430 mike 1.1 return msg;
1431 }
1432
1433 //==============================================================================
1434 //
1435 // ReferenceNames
1436 //
1437 //==============================================================================
1438
1439 static void _encodeReferenceNamesRequest(
1440 CIMBuffer& buf,
1441 CIMReferenceNamesRequestMessage* msg,
1442 CIMName& name)
1443 {
1444 /* See ../Client/CIMOperationRequestEncoder.cpp */
1445
1446 static const CIMName NAME("ReferenceNames");
1447 name = NAME;
1448
1449 // [HEADER]
1450 Uint32 flags = 0;
1451 mike 1.1
1452 _putHeader(buf, flags, msg->messageId, OP_ReferenceNames);
1453
1454 // [NAMESPACE]
1455 buf.putNamespaceName(msg->nameSpace);
1456
1457 // [OBJECT-NAME]
1458 buf.putObjectPath(msg->objectName);
1459
1460 // [RESULT-CLASS]
1461 buf.putName(msg->resultClass);
1462
1463 // [ROLE]
1464 buf.putString(msg->role);
1465 }
1466
1467 static CIMReferenceNamesRequestMessage* _decodeReferenceNamesRequest(
1468 CIMBuffer& in,
1469 Uint32 queueId,
1470 Uint32 returnQueueId,
1471 Uint32 flags,
1472 mike 1.1 const String& messageId)
1473 {
1474 /* See ../Server/CIMOperationRequestDecoder.cpp */
1475
1476 STAT_GETSTARTTIME
1477
1478 // [NAMESPACE]
1479
1480 CIMNamespaceName nameSpace;
1481
1482 if (!in.getNamespaceName(nameSpace))
1483 return 0;
1484
1485 // [OBJECT-NAME]
1486 CIMObjectPath objectName;
1487
1488 if (!in.getObjectPath(objectName))
1489 return 0;
1490
1491 // [RESULT-CLASS]
1492
1493 mike 1.1 CIMName resultClass;
1494
1495 if (!in.getName(resultClass))
1496 return 0;
1497
1498 // [ROLE]
1499
1500 String role;
1501
1502 if (!in.getString(role))
1503 return 0;
1504
1505 AutoPtr<CIMReferenceNamesRequestMessage> request(
1506 new CIMReferenceNamesRequestMessage(
1507 messageId,
1508 nameSpace,
1509 objectName,
1510 resultClass,
1511 role,
1512 QueueIdStack(queueId, returnQueueId)));
1513
1514 mike 1.1 request->binaryRequest = true;
1515
1516 STAT_SERVERSTART
1517
1518 return request.release();
1519 }
1520
1521 static void _encodeReferenceNamesResponseBody(
1522 CIMBuffer& out,
1523 CIMReferenceNamesResponseMessage* msg,
1524 CIMName& name)
1525 {
1526 /* See ../Server/CIMOperationResponseEncoder.cpp */
1527
1528 static const CIMName NAME("ReferenceNames");
1529 name = NAME;
1530
1531 out.putObjectPathA(msg->objectNames);
1532 }
1533
1534 static CIMReferenceNamesResponseMessage* _decodeReferenceNamesResponse(
1535 mike 1.1 CIMBuffer& in,
1536 Uint32 flags,
1537 const String& messageId)
1538 {
1539 /* See ../Client/CIMOperationResponseDecoder.cpp */
1540
1541 Array<CIMObjectPath> objectNames;
1542
1543 while (in.more())
1544 {
1545 Array<CIMObjectPath> tmp;
1546
1547 if (!in.getObjectPathA(tmp))
1548 return 0;
1549
1550 objectNames.append(tmp.getData(), tmp.size());
1551 }
1552
1553 CIMReferenceNamesResponseMessage* msg;
1554 CIMException cimException;
1555
1556 mike 1.1 msg = new CIMReferenceNamesResponseMessage(
1557 messageId,
1558 cimException,
1559 QueueIdStack(),
1560 objectNames);
1561
1562 msg->binaryRequest = true;
1563 return msg;
1564 }
1565
1566 //==============================================================================
1567 //
1568 // GetClass
1569 //
1570 //==============================================================================
1571
1572 static void _encodeGetClassRequest(
1573 CIMBuffer& buf,
1574 CIMGetClassRequestMessage* msg,
1575 CIMName& name)
1576 {
1577 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
1578
1579 static const CIMName NAME("GetClass");
1580 name = NAME;
1581
1582 // [HEADER]
1583
1584 Uint32 flags = 0;
1585
1586 if (msg->localOnly)
1587 flags |= LOCAL_ONLY;
1588
1589 if (msg->includeQualifiers)
1590 flags |= INCLUDE_QUALIFIERS;
1591
1592 if (msg->includeClassOrigin)
1593 flags |= INCLUDE_CLASS_ORIGIN;
1594
1595 _putHeader(buf, flags, msg->messageId, OP_GetClass);
1596
1597 // [NAMESPACE]
1598 mike 1.1 buf.putNamespaceName(msg->nameSpace);
1599
1600 // [CLASSNAME]
1601 buf.putName(msg->className);
1602
1603 // [PROPERTY-LIST]
1604 buf.putPropertyList(msg->propertyList);
1605 }
1606
1607 static CIMGetClassRequestMessage* _decodeGetClassRequest(
1608 CIMBuffer& in,
1609 Uint32 queueId,
1610 Uint32 returnQueueId,
1611 Uint32 flags,
1612 const String& messageId)
1613 {
1614 /* See ../Server/CIMOperationRequestDecoder.cpp */
1615
1616 STAT_GETSTARTTIME
1617
1618 Boolean localOnly = flags & LOCAL_ONLY;
1619 mike 1.1 Boolean includeQualifiers = flags & INCLUDE_QUALIFIERS;
1620 Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
1621
1622 // [NAMESPACE]
1623
1624 CIMNamespaceName nameSpace;
1625
1626 if (!in.getNamespaceName(nameSpace))
1627 return 0;
1628
1629 // [CLASSNAME]
1630 CIMName className;
1631
1632 if (!in.getName(className))
1633 return 0;
1634
1635 // [PROPERTY-LIST]
1636 CIMPropertyList propertyList;
1637 if (!in.getPropertyList(propertyList))
1638 return 0;
1639
1640 mike 1.1 AutoPtr<CIMGetClassRequestMessage> request(new CIMGetClassRequestMessage(
1641 messageId,
1642 nameSpace,
1643 className,
1644 localOnly,
1645 includeQualifiers,
1646 includeClassOrigin,
1647 propertyList,
1648 QueueIdStack(queueId, returnQueueId)));
1649
1650 request->binaryRequest = true;
1651
1652 STAT_SERVERSTART
1653
1654 return request.release();
1655 }
1656
1657 static void _encodeGetClassResponseBody(
1658 CIMBuffer& out,
1659 CIMGetClassResponseMessage* msg,
1660 CIMName& name)
1661 mike 1.1 {
1662 /* See ../Server/CIMOperationResponseEncoder.cpp */
1663
1664 static const CIMName NAME("GetClass");
1665 name = NAME;
1666
1667 out.putClass(msg->cimClass);
1668 }
1669
1670 static CIMGetClassResponseMessage* _decodeGetClassResponse(
1671 CIMBuffer& in,
1672 Uint32 flags,
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 mike 1.1 CIMGetClassResponseMessage* msg;
1683 CIMException cimException;
1684
1685 msg = new CIMGetClassResponseMessage(
1686 messageId,
1687 cimException,
1688 QueueIdStack(),
1689 cimClass);
1690
1691 msg->binaryRequest = true;
1692 return msg;
1693 }
1694
1695 //==============================================================================
1696 //
1697 // EnumerateClasses
1698 //
1699 //==============================================================================
1700
1701 static void _encodeEnumerateClassesRequest(
1702 CIMBuffer& buf,
1703 mike 1.1 CIMEnumerateClassesRequestMessage* msg,
1704 CIMName& name)
1705 {
1706 /* See ../Client/CIMOperationRequestEncoder.cpp */
1707
1708 static const CIMName NAME("EnumerateClasses");
1709 name = NAME;
1710
1711 // [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 mike 1.1 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 // [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 mike 1.1 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
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 mike 1.1 new CIMEnumerateClassesRequestMessage(
1767 messageId,
1768 nameSpace,
1769 className,
1770 deepInheritance,
1771 localOnly,
1772 includeQualifiers,
1773 includeClassOrigin,
1774 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 mike 1.1 {
1788 /* See ../Server/CIMOperationResponseEncoder.cpp */
1789
1790 static const CIMName NAME("EnumerateClasses");
1791 name = NAME;
1792
1793 out.putClassA(msg->cimClasses);
1794 }
1795
1796 static CIMEnumerateClassesResponseMessage* _decodeEnumerateClassesResponse(
1797 CIMBuffer& in,
1798 Uint32 flags,
1799 const String& messageId)
1800 {
1801 /* See ../Client/CIMOperationResponseDecoder.cpp */
1802
1803 Array<CIMClass> cimClasses;
1804
1805 while (in.more())
1806 {
1807 Array<CIMClass> tmp;
1808 mike 1.1
1809 if (!in.getClassA(tmp))
1810 return 0;
1811
1812 cimClasses.append(tmp.getData(), tmp.size());
1813 }
1814
1815 CIMEnumerateClassesResponseMessage* msg;
1816 CIMException cimException;
1817
1818 msg = new CIMEnumerateClassesResponseMessage(
1819 messageId,
1820 cimException,
1821 QueueIdStack(),
1822 cimClasses);
1823
1824 msg->binaryRequest = true;
1825 return msg;
1826 }
1827
1828 //==============================================================================
1829 mike 1.1 //
1830 // EnumerateClassNames
1831 //
1832 //==============================================================================
1833
1834 static void _encodeEnumerateClassNamesRequest(
1835 CIMBuffer& buf,
1836 CIMEnumerateClassNamesRequestMessage* msg,
1837 CIMName& name)
1838 {
1839 /* See ../Client/CIMOperationRequestEncoder.cpp */
1840
1841 static const CIMName NAME("EnumerateClassNames");
1842 name = NAME;
1843
1844 // [HEADER]
1845
1846 Uint32 flags = 0;
1847
1848 if (msg->deepInheritance)
1849 flags |= DEEP_INHERITANCE;
1850 mike 1.1
1851 _putHeader(buf, flags, msg->messageId, OP_EnumerateClassNames);
1852
1853 // [NAMESPACE]
1854 buf.putNamespaceName(msg->nameSpace);
1855
1856 // [CLASSNAME]
1857 buf.putName(msg->className);
1858 }
1859
1860 static CIMEnumerateClassNamesRequestMessage* _decodeEnumerateClassNamesRequest(
1861 CIMBuffer& in,
1862 Uint32 queueId,
1863 Uint32 returnQueueId,
1864 Uint32 flags,
1865 const String& messageId)
1866 {
1867 /* See ../Server/CIMOperationRequestDecoder.cpp */
1868
1869 STAT_GETSTARTTIME
1870
1871 mike 1.1 Boolean deepInheritance = flags & DEEP_INHERITANCE;
1872
1873 // [NAMESPACE]
1874
1875 CIMNamespaceName nameSpace;
1876
1877 if (!in.getNamespaceName(nameSpace))
1878 return 0;
1879
1880 // [CLASSNAME]
1881 CIMName className;
1882
1883 if (!in.getName(className))
1884 return 0;
1885
1886 AutoPtr<CIMEnumerateClassNamesRequestMessage> request(
1887 new CIMEnumerateClassNamesRequestMessage(
1888 messageId,
1889 nameSpace,
1890 className,
1891 deepInheritance,
1892 mike 1.1 QueueIdStack(queueId, returnQueueId)));
1893
1894 request->binaryRequest = true;
1895
1896 STAT_SERVERSTART
1897
1898 return request.release();
1899 }
1900
1901 static void _encodeEnumerateClassNamesResponseBody(
1902 CIMBuffer& out,
1903 CIMEnumerateClassNamesResponseMessage* msg,
1904 CIMName& name)
1905 {
1906 /* See ../Server/CIMOperationResponseEncoder.cpp */
1907
1908 static const CIMName NAME("EnumerateClassNames");
1909 name = NAME;
1910
1911 out.putNameA(msg->classNames);
1912 }
1913 mike 1.1
|
1914 kumpf 1.6 static CIMEnumerateClassNamesResponseMessage*
|
1915 mike 1.1 _decodeEnumerateClassNamesResponse(
1916 CIMBuffer& in,
1917 Uint32 flags,
1918 const String& messageId)
1919 {
1920 /* See ../Client/CIMOperationResponseDecoder.cpp */
1921
1922 Array<CIMName> classNames;
1923
1924 while (in.more())
1925 {
1926 Array<CIMName> tmp;
1927
1928 if (!in.getNameA(tmp))
1929 return 0;
1930
1931 classNames.append(tmp.getData(), tmp.size());
1932 }
1933
1934 CIMEnumerateClassNamesResponseMessage* msg;
1935 CIMException cimException;
1936 mike 1.1
1937 msg = new CIMEnumerateClassNamesResponseMessage(
1938 messageId,
1939 cimException,
1940 QueueIdStack(),
1941 classNames);
1942
1943 msg->binaryRequest = true;
1944 return msg;
1945 }
1946
1947 //==============================================================================
1948 //
1949 // CreateClass
1950 //
1951 //==============================================================================
1952
1953 static void _encodeCreateClassRequest(
1954 CIMBuffer& buf,
1955 CIMCreateClassRequestMessage* msg,
1956 CIMName& name)
1957 mike 1.1 {
1958 /* See ../Client/CIMOperationRequestEncoder.cpp */
1959
1960 static const CIMName NAME("CreateClass");
1961 name = NAME;
1962
1963 // [HEADER]
1964 _putHeader(buf, 0, msg->messageId, OP_CreateClass);
1965
1966 // [NAMESPACE]
1967 buf.putNamespaceName(msg->nameSpace);
1968
1969 // [NEW-CLASS]
1970 buf.putClass(msg->newClass);
1971 }
1972
1973 static CIMCreateClassRequestMessage* _decodeCreateClassRequest(
1974 CIMBuffer& in,
1975 Uint32 queueId,
1976 Uint32 returnQueueId,
1977 Uint32 flags,
1978 mike 1.1 const String& messageId)
1979 {
1980 /* See ../Server/CIMOperationRequestDecoder.cpp */
1981
1982 STAT_GETSTARTTIME
1983
1984 // [NAMESPACE]
1985
1986 CIMNamespaceName nameSpace;
1987
1988 if (!in.getNamespaceName(nameSpace))
1989 return 0;
1990
1991 // [NEW-CLASS]
1992 CIMClass newClass;
1993
1994 if (!in.getClass(newClass))
1995 return 0;
1996
1997 AutoPtr<CIMCreateClassRequestMessage> request(
1998 new CIMCreateClassRequestMessage(
1999 mike 1.1 messageId,
2000 nameSpace,
2001 newClass,
2002 QueueIdStack(queueId, returnQueueId)));
2003
2004 request->binaryRequest = true;
2005
2006 STAT_SERVERSTART
2007
2008 return request.release();
2009 }
2010
2011 static void _encodeCreateClassResponseBody(
2012 CIMBuffer& out,
2013 CIMCreateClassResponseMessage* msg,
2014 CIMName& name)
2015 {
2016 /* See ../Server/CIMOperationResponseEncoder.cpp */
2017
2018 static const CIMName NAME("CreateClass");
2019 name = NAME;
2020 mike 1.1 }
2021
2022 static CIMCreateClassResponseMessage* _decodeCreateClassResponse(
2023 CIMBuffer& in,
2024 Uint32 flags,
2025 const String& messageId)
2026 {
2027 /* See ../Client/CIMOperationResponseDecoder.cpp */
2028
2029 CIMCreateClassResponseMessage* msg;
2030 CIMException cimException;
2031
2032 msg = new CIMCreateClassResponseMessage(
2033 messageId,
2034 cimException,
2035 QueueIdStack());
2036
2037 msg->binaryRequest = true;
2038 return msg;
2039 }
2040
2041 mike 1.1 //==============================================================================
2042 //
2043 // DeleteClass
2044 //
2045 //==============================================================================
2046
2047 static void _encodeDeleteClassRequest(
2048 CIMBuffer& buf,
2049 CIMDeleteClassRequestMessage* msg,
2050 CIMName& name)
2051 {
2052 /* See ../Client/CIMOperationRequestEncoder.cpp */
2053
2054 static const CIMName NAME("DeleteClass");
2055 name = NAME;
2056
2057 // [HEADER]
2058 _putHeader(buf, 0, msg->messageId, OP_DeleteClass);
2059
2060 // [NAMESPACE]
2061 buf.putNamespaceName(msg->nameSpace);
2062 mike 1.1
2063 // [CLASSNAME]
2064 buf.putName(msg->className);
2065 }
2066
2067 static CIMDeleteClassRequestMessage* _decodeDeleteClassRequest(
2068 CIMBuffer& in,
2069 Uint32 queueId,
2070 Uint32 returnQueueId,
2071 Uint32 flags,
2072 const String& messageId)
2073 {
2074 /* See ../Server/CIMOperationRequestDecoder.cpp */
2075
2076 STAT_GETSTARTTIME
2077
2078 // [NAMESPACE]
2079
2080 CIMNamespaceName nameSpace;
2081
2082 if (!in.getNamespaceName(nameSpace))
2083 mike 1.1 return 0;
2084
2085 // [CLASSNAME]
2086 CIMName className;
2087
2088 if (!in.getName(className))
2089 return 0;
2090
2091 AutoPtr<CIMDeleteClassRequestMessage> request(
2092 new CIMDeleteClassRequestMessage(
2093 messageId,
2094 nameSpace,
2095 className,
2096 QueueIdStack(queueId, returnQueueId)));
2097
2098 request->binaryRequest = true;
2099
2100 STAT_SERVERSTART
2101
2102 return request.release();
2103 }
2104 mike 1.1
2105 static void _encodeDeleteClassResponseBody(
2106 CIMBuffer& out,
2107 CIMDeleteClassResponseMessage* msg,
2108 CIMName& name)
2109 {
2110 /* See ../Server/CIMOperationResponseEncoder.cpp */
2111
2112 static const CIMName NAME("DeleteClass");
2113 name = NAME;
2114 }
2115
2116 static CIMDeleteClassResponseMessage* _decodeDeleteClassResponse(
2117 CIMBuffer& in,
2118 Uint32 flags,
2119 const String& messageId)
2120 {
2121 /* See ../Client/CIMOperationResponseDecoder.cpp */
2122
2123 CIMDeleteClassResponseMessage* msg;
2124 CIMException cimException;
2125 mike 1.1
2126 msg = new CIMDeleteClassResponseMessage(
2127 messageId,
2128 cimException,
2129 QueueIdStack());
2130
2131 msg->binaryRequest = true;
2132 return msg;
2133 }
2134
2135 //==============================================================================
2136 //
2137 // ModifyClass
2138 //
2139 //==============================================================================
2140
2141 static void _encodeModifyClassRequest(
2142 CIMBuffer& buf,
2143 CIMModifyClassRequestMessage* msg,
2144 CIMName& name)
2145 {
2146 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
2147
2148 static const CIMName NAME("ModifyClass");
2149 name = NAME;
2150
2151 // [HEADER]
2152 _putHeader(buf, 0, msg->messageId, OP_ModifyClass);
2153
2154 // [NAMESPACE]
2155 buf.putNamespaceName(msg->nameSpace);
2156
2157 // [NEW-CLASS]
2158 buf.putClass(msg->modifiedClass);
2159 }
2160
2161 static CIMModifyClassRequestMessage* _decodeModifyClassRequest(
2162 CIMBuffer& in,
2163 Uint32 queueId,
2164 Uint32 returnQueueId,
2165 Uint32 flags,
2166 const String& messageId)
2167 mike 1.1 {
2168 /* See ../Server/CIMOperationRequestDecoder.cpp */
2169
2170 STAT_GETSTARTTIME
2171
2172 // [NAMESPACE]
2173
2174 CIMNamespaceName nameSpace;
2175
2176 if (!in.getNamespaceName(nameSpace))
2177 return 0;
2178
2179 // [MODIFIED-CLASS]
2180 CIMClass modifiedClass;
2181
2182 if (!in.getClass(modifiedClass))
2183 return 0;
2184
2185 AutoPtr<CIMModifyClassRequestMessage> request(
2186 new CIMModifyClassRequestMessage(
2187 messageId,
2188 mike 1.1 nameSpace,
2189 modifiedClass,
2190 QueueIdStack(queueId, returnQueueId)));
2191
2192 request->binaryRequest = true;
2193
2194 STAT_SERVERSTART
2195
2196 return request.release();
2197 }
2198
2199 static void _encodeModifyClassResponseBody(
2200 CIMBuffer& out,
2201 CIMModifyClassResponseMessage* msg,
2202 CIMName& name)
2203 {
2204 /* See ../Server/CIMOperationResponseEncoder.cpp */
2205
2206 static const CIMName NAME("ModifyClass");
2207 name = NAME;
2208 }
2209 mike 1.1
2210 static CIMModifyClassResponseMessage* _decodeModifyClassResponse(
2211 CIMBuffer& in,
2212 Uint32 flags,
2213 const String& messageId)
2214 {
2215 /* See ../Client/CIMOperationResponseDecoder.cpp */
2216
2217 CIMModifyClassResponseMessage* msg;
2218 CIMException cimException;
2219
2220 msg = new CIMModifyClassResponseMessage(
2221 messageId,
2222 cimException,
2223 QueueIdStack());
2224
2225 msg->binaryRequest = true;
2226 return msg;
2227 }
2228
2229 //==============================================================================
2230 mike 1.1 //
2231 // SetQualifier
2232 //
2233 //==============================================================================
2234
2235 static void _encodeSetQualifierRequest(
2236 CIMBuffer& buf,
2237 CIMSetQualifierRequestMessage* msg,
2238 CIMName& name)
2239 {
2240 /* See ../Client/CIMOperationRequestEncoder.cpp */
2241
2242 static const CIMName NAME("SetQualifier");
2243 name = NAME;
2244
2245 // [HEADER]
2246 _putHeader(buf, 0, msg->messageId, OP_SetQualifier);
2247
2248 // [NAMESPACE]
2249 buf.putNamespaceName(msg->nameSpace);
2250
2251 mike 1.1 // [QUALIFIER-DECLARATION]
2252 buf.putQualifierDecl(msg->qualifierDeclaration);
2253 }
2254
2255 static CIMSetQualifierRequestMessage* _decodeSetQualifierRequest(
2256 CIMBuffer& in,
2257 Uint32 queueId,
2258 Uint32 returnQueueId,
2259 Uint32 flags,
2260 const String& messageId)
2261 {
2262 /* See ../Server/CIMOperationRequestDecoder.cpp */
2263
2264 STAT_GETSTARTTIME
2265
2266 // [NAMESPACE]
2267
2268 CIMNamespaceName nameSpace;
2269
2270 if (!in.getNamespaceName(nameSpace))
2271 return 0;
2272 mike 1.1
2273 // [QUALIFIER.DECLARATION]
2274
2275 CIMQualifierDecl qualifierDeclaration;
2276
2277 if (!in.getQualifierDecl(qualifierDeclaration))
2278 return 0;
2279
2280 AutoPtr<CIMSetQualifierRequestMessage> request(
2281 new CIMSetQualifierRequestMessage(
2282 messageId,
2283 nameSpace,
2284 qualifierDeclaration,
2285 QueueIdStack(queueId, returnQueueId)));
2286
2287 request->binaryRequest = true;
2288
2289 STAT_SERVERSTART
2290
2291 return request.release();
2292 }
2293 mike 1.1
2294 static void _encodeSetQualifierResponseBody(
2295 CIMBuffer& out,
2296 CIMSetQualifierResponseMessage* msg,
2297 CIMName& name)
2298 {
2299 /* See ../Server/CIMOperationResponseEncoder.cpp */
2300
2301 static const CIMName NAME("SetQualifier");
2302 name = NAME;
2303 }
2304
2305 static CIMSetQualifierResponseMessage* _decodeSetQualifierResponse(
2306 CIMBuffer& in,
2307 Uint32 flags,
2308 const String& messageId)
2309 {
2310 /* See ../Client/CIMOperationResponseDecoder.cpp */
2311
2312 CIMSetQualifierResponseMessage* msg;
2313 CIMException cimException;
2314 mike 1.1
2315 msg = new CIMSetQualifierResponseMessage(
2316 messageId,
2317 cimException,
2318 QueueIdStack());
2319
2320 msg->binaryRequest = true;
2321 return msg;
2322 }
2323
2324 //==============================================================================
2325 //
2326 // GetQualifier
2327 //
2328 //==============================================================================
2329
2330 static void _encodeGetQualifierRequest(
2331 CIMBuffer& buf,
2332 CIMGetQualifierRequestMessage* msg,
2333 CIMName& name)
2334 {
2335 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
2336
2337 static const CIMName NAME("GetQualifier");
2338 name = NAME;
2339
2340 // [HEADER]
2341 _putHeader(buf, 0, msg->messageId, OP_GetQualifier);
2342
2343 // [NAMESPACE]
2344 buf.putNamespaceName(msg->nameSpace);
2345
2346 // [QUALIFIER-NAME]
2347 buf.putName(msg->qualifierName);
2348 }
2349
2350 static CIMGetQualifierRequestMessage* _decodeGetQualifierRequest(
2351 CIMBuffer& in,
2352 Uint32 queueId,
2353 Uint32 returnQueueId,
2354 Uint32 flags,
2355 const String& messageId)
2356 mike 1.1 {
2357 /* See ../Server/CIMOperationRequestDecoder.cpp */
2358
2359 STAT_GETSTARTTIME
2360
2361 // [NAMESPACE]
2362
2363 CIMNamespaceName nameSpace;
2364
2365 if (!in.getNamespaceName(nameSpace))
2366 return 0;
2367
2368 // [QUALIFIER-NAME]
2369 CIMName qualifierName;
2370
2371 if (!in.getName(qualifierName))
2372 return 0;
2373
2374 AutoPtr<CIMGetQualifierRequestMessage> request(
2375 new CIMGetQualifierRequestMessage(
2376 messageId,
2377 mike 1.1 nameSpace,
2378 qualifierName,
2379 QueueIdStack(queueId, returnQueueId)));
2380
2381 request->binaryRequest = true;
2382
2383 STAT_SERVERSTART
2384
2385 return request.release();
2386 }
2387
2388 static void _encodeGetQualifierResponseBody(
2389 CIMBuffer& out,
2390 CIMGetQualifierResponseMessage* msg,
2391 CIMName& name)
2392 {
2393 /* See ../Server/CIMOperationResponseEncoder.cpp */
2394
2395 static const CIMName NAME("GetQualifier");
2396 name = NAME;
2397
2398 mike 1.1 out.putQualifierDecl(msg->cimQualifierDecl);
2399 }
2400
2401 static CIMGetQualifierResponseMessage* _decodeGetQualifierResponse(
2402 CIMBuffer& in,
2403 Uint32 flags,
2404 const String& messageId)
2405 {
2406 /* See ../Client/CIMOperationResponseDecoder.cpp */
2407
2408 CIMQualifierDecl cimQualifierDecl;
2409
2410 if (!in.getQualifierDecl(cimQualifierDecl))
2411 return 0;
2412
2413 CIMGetQualifierResponseMessage* msg;
2414 CIMException cimException;
2415
2416 msg = new CIMGetQualifierResponseMessage(
2417 messageId,
2418 cimException,
2419 mike 1.1 QueueIdStack(),
2420 cimQualifierDecl);
2421
2422 msg->binaryRequest = true;
2423 return msg;
2424 }
2425
2426 //==============================================================================
2427 //
2428 // DeleteQualifier
2429 //
2430 //==============================================================================
2431
2432 static void _encodeDeleteQualifierRequest(
2433 CIMBuffer& buf,
2434 CIMDeleteQualifierRequestMessage* msg,
2435 CIMName& name)
2436 {
2437 /* See ../Client/CIMOperationRequestEncoder.cpp */
2438
2439 static const CIMName NAME("DeleteQualifier");
2440 mike 1.1 name = NAME;
2441
2442 // [HEADER]
2443 _putHeader(buf, 0, msg->messageId, OP_DeleteQualifier);
2444
2445 // [NAMESPACE]
2446 buf.putNamespaceName(msg->nameSpace);
2447
2448 // [QUALIFIER-NAME]
2449 buf.putName(msg->qualifierName);
2450 }
2451
2452 static CIMDeleteQualifierRequestMessage* _decodeDeleteQualifierRequest(
2453 CIMBuffer& in,
2454 Uint32 queueId,
2455 Uint32 returnQueueId,
2456 Uint32 flags,
2457 const String& messageId)
2458 {
2459 /* See ../Server/CIMOperationRequestDecoder.cpp */
2460
2461 mike 1.1 STAT_GETSTARTTIME
2462
2463 // [NAMESPACE]
2464
2465 CIMNamespaceName nameSpace;
2466
2467 if (!in.getNamespaceName(nameSpace))
2468 return 0;
2469
2470 // [QUALIFIER-NAME]
2471 CIMName qualifierName;
2472
2473 if (!in.getName(qualifierName))
2474 return 0;
2475
2476 AutoPtr<CIMDeleteQualifierRequestMessage> request(
2477 new CIMDeleteQualifierRequestMessage(
2478 messageId,
2479 nameSpace,
2480 qualifierName,
2481 QueueIdStack(queueId, returnQueueId)));
2482 mike 1.1
2483 request->binaryRequest = true;
2484
2485 STAT_SERVERSTART
2486
2487 return request.release();
2488 }
2489
2490 static void _encodeDeleteQualifierResponseBody(
2491 CIMBuffer& out,
2492 CIMDeleteQualifierResponseMessage* msg,
2493 CIMName& name)
2494 {
2495 /* See ../Server/CIMOperationResponseEncoder.cpp */
2496
2497 static const CIMName NAME("DeleteQualifier");
2498 name = NAME;
2499 }
2500
2501 static CIMDeleteQualifierResponseMessage* _decodeDeleteQualifierResponse(
2502 CIMBuffer& in,
2503 mike 1.1 Uint32 flags,
2504 const String& messageId)
2505 {
2506 /* See ../Client/CIMOperationResponseDecoder.cpp */
2507
2508 CIMDeleteQualifierResponseMessage* msg;
2509 CIMException cimException;
2510
2511 msg = new CIMDeleteQualifierResponseMessage(
2512 messageId,
2513 cimException,
2514 QueueIdStack());
2515
2516 msg->binaryRequest = true;
2517 return msg;
2518 }
2519
2520 //==============================================================================
2521 //
2522 // EnumerateQualifiers
2523 //
2524 mike 1.1 //==============================================================================
2525
2526 static void _encodeEnumerateQualifiersRequest(
2527 CIMBuffer& buf,
2528 CIMEnumerateQualifiersRequestMessage* msg,
2529 CIMName& name)
2530 {
2531 /* See ../Client/CIMOperationRequestEncoder.cpp */
2532
2533 static const CIMName NAME("EnumerateQualifiers");
2534 name = NAME;
2535
2536 // [HEADER]
2537 _putHeader(buf, 0, msg->messageId, OP_EnumerateQualifiers);
2538
2539 // [NAMESPACE]
2540 buf.putNamespaceName(msg->nameSpace);
2541 }
2542
2543 static CIMEnumerateQualifiersRequestMessage* _decodeEnumerateQualifiersRequest(
2544 CIMBuffer& in,
2545 mike 1.1 Uint32 queueId,
2546 Uint32 returnQueueId,
2547 Uint32 flags,
2548 const String& messageId)
2549 {
2550 /* See ../Server/CIMOperationRequestDecoder.cpp */
2551
2552 STAT_GETSTARTTIME
2553
2554 // [NAMESPACE]
2555
2556 CIMNamespaceName nameSpace;
2557
2558 if (!in.getNamespaceName(nameSpace))
2559 return 0;
2560
2561 AutoPtr<CIMEnumerateQualifiersRequestMessage> request(
2562 new CIMEnumerateQualifiersRequestMessage(
2563 messageId,
2564 nameSpace,
2565 QueueIdStack(queueId, returnQueueId)));
2566 mike 1.1
2567 request->binaryRequest = true;
2568
2569 STAT_SERVERSTART
2570
2571 return request.release();
2572 }
2573
2574 static void _encodeEnumerateQualifiersResponseBody(
2575 CIMBuffer& out,
2576 CIMEnumerateQualifiersResponseMessage* msg,
2577 CIMName& name)
2578 {
2579 /* See ../Server/CIMOperationResponseEncoder.cpp */
2580
2581 static const CIMName NAME("EnumerateQualifiers");
2582 name = NAME;
2583
2584 out.putQualifierDeclA(msg->qualifierDeclarations);
2585 }
2586
|
2587 kumpf 1.6 static CIMEnumerateQualifiersResponseMessage*
|
2588 mike 1.1 _decodeEnumerateQualifiersResponse(
2589 CIMBuffer& in,
2590 Uint32 flags,
2591 const String& messageId)
2592 {
2593 /* See ../Client/CIMOperationResponseDecoder.cpp */
2594
2595 Array<CIMQualifierDecl> qualifierDecls;
2596
2597 while (in.more())
2598 {
2599 Array<CIMQualifierDecl> tmp;
2600
2601 if (!in.getQualifierDeclA(tmp))
2602 return 0;
2603
2604 qualifierDecls.append(tmp.getData(), tmp.size());
2605 }
2606
2607 CIMEnumerateQualifiersResponseMessage* msg;
2608 CIMException cimException;
2609 mike 1.1
2610 msg = new CIMEnumerateQualifiersResponseMessage(
2611 messageId,
2612 cimException,
2613 QueueIdStack(),
2614 qualifierDecls);
2615
2616 msg->binaryRequest = true;
2617 return msg;
2618 }
2619
2620 //==============================================================================
2621 //
2622 // GetProperty
2623 //
2624 //==============================================================================
2625
2626 static void _encodeGetPropertyRequest(
2627 CIMBuffer& buf,
2628 CIMGetPropertyRequestMessage* msg,
2629 CIMName& name)
2630 mike 1.1 {
2631 /* See ../Client/CIMOperationRequestEncoder.cpp */
2632
2633 static const CIMName NAME("GetProperty");
2634 name = NAME;
2635
2636 // [HEADER]
2637 _putHeader(buf, 0, msg->messageId, OP_GetProperty);
2638
2639 // [NAMESPACE]
2640 buf.putNamespaceName(msg->nameSpace);
2641
2642 // [INSTANCE-NAME]
2643 buf.putObjectPath(msg->instanceName);
2644
2645 // [PROPERTY-NAME]
2646 buf.putName(msg->propertyName);
2647 }
2648
2649 static CIMGetPropertyRequestMessage* _decodeGetPropertyRequest(
2650 CIMBuffer& in,
2651 mike 1.1 Uint32 queueId,
2652 Uint32 returnQueueId,
2653 Uint32 flags,
2654 const String& messageId)
2655 {
2656 /* See ../Server/CIMOperationRequestDecoder.cpp */
2657
2658 STAT_GETSTARTTIME
2659
2660 // [NAMESPACE]
2661
2662 CIMNamespaceName nameSpace;
2663
2664 if (!in.getNamespaceName(nameSpace))
2665 return 0;
2666
2667 // [INSTANCE-NAME]
2668 CIMObjectPath instanceName;
2669
2670 if (!in.getObjectPath(instanceName))
2671 return 0;
2672 mike 1.1
2673 // [PROPERTY-NAME]
2674 CIMName propertyName;
2675
2676 if (!in.getName(propertyName))
2677 return 0;
2678
2679 AutoPtr<CIMGetPropertyRequestMessage> request(
2680 new CIMGetPropertyRequestMessage(
2681 messageId,
2682 nameSpace,
2683 instanceName,
2684 propertyName,
2685 QueueIdStack(queueId, returnQueueId)));
2686
2687 request->binaryRequest = true;
2688
2689 STAT_SERVERSTART
2690
2691 return request.release();
2692 }
2693 mike 1.1
2694 static void _encodeGetPropertyResponseBody(
2695 CIMBuffer& out,
2696 CIMGetPropertyResponseMessage* msg,
2697 CIMName& name)
2698 {
2699 /* See ../Server/CIMOperationResponseEncoder.cpp */
2700
2701 static const CIMName NAME("GetProperty");
2702 name = NAME;
2703
2704 // [VALUE]
2705 out.putValue(msg->value);
2706 }
2707
2708 static CIMGetPropertyResponseMessage* _decodeGetPropertyResponse(
2709 CIMBuffer& in,
2710 Uint32 flags,
2711 const String& messageId)
2712 {
2713 /* See ../Client/CIMOperationResponseDecoder.cpp */
2714 mike 1.1
2715 // [VALUE]
2716 CIMValue value;
2717
2718 if (!in.getValue(value))
2719 return 0;
2720
2721 // Unfortunately the CIM GetProperty() method is only able to return
2722 // a string since there is no containing element that specifies its
2723 // type. So even though the binary protocol properly transmits the type,
2724 // we are force to convert that type to string to match the XML protocol
2725 // behavior.
2726
2727 if (value.isNull())
2728 value.setNullValue(CIMTYPE_STRING, false);
2729 else
2730 value.set(value.toString());
2731
2732 CIMGetPropertyResponseMessage* msg;
2733 CIMException cimException;
2734
2735 mike 1.1 msg = new CIMGetPropertyResponseMessage(
2736 messageId,
2737 cimException,
2738 QueueIdStack(),
2739 value);
2740
2741 msg->binaryRequest = true;
2742 return msg;
2743 }
2744
2745 //==============================================================================
2746 //
2747 // SetProperty
2748 //
2749 //==============================================================================
2750
2751 static void _encodeSetPropertyRequest(
2752 CIMBuffer& buf,
2753 CIMSetPropertyRequestMessage* msg,
2754 CIMName& name)
2755 {
2756 mike 1.1 /* See ../Client/CIMOperationRequestEncoder.cpp */
2757
2758 static const CIMName NAME("SetProperty");
2759 name = NAME;
2760
2761 // [HEADER]
2762 _putHeader(buf, 0, msg->messageId, OP_SetProperty);
2763
2764 // [NAMESPACE]
2765 buf.putNamespaceName(msg->nameSpace);
2766
2767 // [INSTANCE-NAME]
2768 buf.putObjectPath(msg->instanceName);
2769
2770 // [PROPERTY-NAME]
2771 buf.putName(msg->propertyName);
2772
2773 // [VALUE]
2774 buf.putValue(msg->newValue);
2775 }
2776
2777 mike 1.1 static CIMSetPropertyRequestMessage* _decodeSetPropertyRequest(
2778 CIMBuffer& in,
2779 Uint32 queueId,
2780 Uint32 returnQueueId,
2781 Uint32 flags,
2782 const String& messageId)
2783 {
2784 /* See ../Server/CIMOperationRequestDecoder.cpp */
2785
2786 STAT_GETSTARTTIME
2787
2788 // [NAMESPACE]
2789
2790 CIMNamespaceName nameSpace;
2791
2792 if (!in.getNamespaceName(nameSpace))
2793 return 0;
2794
2795 // [INSTANCE-NAME]
2796
2797 CIMObjectPath instanceName;
2798 mike 1.1
2799 if (!in.getObjectPath(instanceName))
2800 return 0;
2801
2802 // [PROPERTY-NAME]
2803
2804 CIMName propertyName;
2805
2806 if (!in.getName(propertyName))
2807 return 0;
2808
2809 // [PROPERTY-VALUE]
2810
2811 CIMValue propertyValue;
2812
2813 if (!in.getValue(propertyValue))
2814 return 0;
2815
2816 AutoPtr<CIMSetPropertyRequestMessage> request(
2817 new CIMSetPropertyRequestMessage(
2818 messageId,
2819 mike 1.1 nameSpace,
2820 instanceName,
2821 propertyName,
2822 propertyValue,
2823 QueueIdStack(queueId, returnQueueId)));
2824
2825 request->binaryRequest = true;
2826
2827 STAT_SERVERSTART
2828
2829 return request.release();
2830 }
2831
2832 static void _encodeSetPropertyResponseBody(
2833 CIMBuffer& out,
2834 CIMSetPropertyResponseMessage* msg,
2835 CIMName& name)
2836 {
2837 /* See ../Server/CIMOperationResponseEncoder.cpp */
2838
2839 static const CIMName NAME("SetProperty");
2840 mike 1.1 name = NAME;
2841 }
2842
2843 static CIMSetPropertyResponseMessage* _decodeSetPropertyResponse(
2844 CIMBuffer& in,
2845 Uint32 flags,
2846 const String& messageId)
2847 {
2848 /* See ../Client/CIMOperationResponseDecoder.cpp */
2849
2850 CIMSetPropertyResponseMessage* msg;
2851 CIMException cimException;
2852
2853 msg = new CIMSetPropertyResponseMessage(
2854 messageId,
2855 cimException,
2856 QueueIdStack());
2857
2858 msg->binaryRequest = true;
2859 return msg;
2860 }
2861 mike 1.1
2862 //==============================================================================
2863 //
2864 // InvokeMethod
2865 //
2866 //==============================================================================
2867
2868 static void _encodeInvokeMethodRequest(
2869 CIMBuffer& buf,
2870 CIMInvokeMethodRequestMessage* msg,
2871 CIMName& name)
2872 {
2873 /* See ../Client/CIMOperationRequestEncoder.cpp */
2874
2875 name = msg->methodName;
2876
2877 // [HEADER]
2878 _putHeader(buf, 0, msg->messageId, OP_InvokeMethod);
2879
2880 // [NAMESPACE]
2881 buf.putNamespaceName(msg->nameSpace);
2882 mike 1.1
2883 // [INSTANCE-NAME]
2884 buf.putObjectPath(msg->instanceName);
2885
2886 // [METHOD-NAME]
2887 buf.putName(msg->methodName);
2888
2889 // [IN-PARAMETERS]
2890 buf.putParamValueA(msg->inParameters);
2891 }
2892
2893 static CIMInvokeMethodRequestMessage* _decodeInvokeMethodRequest(
2894 CIMBuffer& in,
2895 Uint32 queueId,
2896 Uint32 returnQueueId,
2897 Uint32 flags,
2898 const String& messageId)
2899 {
2900 /* See ../Server/CIMOperationRequestDecoder.cpp */
2901
2902 STAT_GETSTARTTIME
2903 mike 1.1
2904 // [NAMESPACE]
2905
2906 CIMNamespaceName nameSpace;
2907
2908 if (!in.getNamespaceName(nameSpace))
2909 return 0;
2910
2911 // [INSTANCE-NAME]
2912
2913 CIMObjectPath instanceName;
2914
2915 if (!in.getObjectPath(instanceName))
2916 return 0;
2917
2918 // [METHOD-NAME]
2919
2920 CIMName methodName;
2921
2922 if (!in.getName(methodName))
2923 return 0;
2924 mike 1.1
2925 // [IN-PARAMETERS]
2926
2927 Array<CIMParamValue> inParameters;
2928
2929 if (!in.getParamValueA(inParameters))
2930 return 0;
2931
2932 AutoPtr<CIMInvokeMethodRequestMessage> request(
2933 new CIMInvokeMethodRequestMessage(
2934 messageId,
2935 nameSpace,
2936 instanceName,
2937 methodName,
2938 inParameters,
2939 QueueIdStack(queueId, returnQueueId)));
2940
2941 request->binaryRequest = true;
2942
2943 STAT_SERVERSTART
2944
2945 mike 1.1 return request.release();
2946 }
2947
2948 static void _encodeInvokeMethodResponseBody(
2949 CIMBuffer& out,
2950 CIMInvokeMethodResponseMessage* msg,
2951 CIMName& name)
2952 {
2953 /* See ../Server/CIMOperationResponseEncoder.cpp */
2954
2955 name = msg->methodName;
2956
2957 // [METHOD-NAME]
2958 out.putName(msg->methodName);
2959
2960 // [RETURN-VALUE]
2961 out.putValue(msg->retValue);
2962
2963 // [OUT-PARAMETERS]
2964 out.putParamValueA(msg->outParameters);
2965 }
2966 mike 1.1
2967 static CIMInvokeMethodResponseMessage* _decodeInvokeMethodResponse(
2968 CIMBuffer& in,
2969 Uint32 flags,
2970 const String& messageId)
2971 {
2972 /* See ../Client/CIMOperationResponseDecoder.cpp */
2973
2974 // [METHOD-NAME]
2975
2976 CIMName methodName;
2977
2978 if (!in.getName(methodName))
2979 return 0;
2980
2981 // [RETURN-VALUE]
2982
2983 CIMValue returnValue;
2984
2985 if (!in.getValue(returnValue))
2986 return 0;
2987 mike 1.1
2988 // [OUT-PARAMETERS]
2989
2990 Array<CIMParamValue> outParameters;
2991
2992 if (!in.getParamValueA(outParameters))
2993 return 0;
2994
2995 CIMInvokeMethodResponseMessage* msg;
2996 CIMException cimException;
2997
2998 msg = new CIMInvokeMethodResponseMessage(
2999 messageId,
3000 cimException,
3001 QueueIdStack(),
3002 returnValue,
3003 outParameters,
3004 methodName);
3005
3006 msg->binaryRequest = true;
3007
3008 mike 1.1 return msg;
3009 }
3010
3011 //==============================================================================
3012 //
3013 // ExecQuery
3014 //
3015 //==============================================================================
3016
3017 static void _encodeExecQueryRequest(
3018 CIMBuffer& buf,
3019 CIMExecQueryRequestMessage* msg,
3020 CIMName& name)
3021 {
3022 /* See ../Client/CIMOperationRequestEncoder.cpp */
3023
3024 static const CIMName NAME("ExecQuery");
3025 name = NAME;
3026
3027 // [HEADER]
3028 _putHeader(buf, 0, msg->messageId, OP_ExecQuery);
3029 mike 1.1
3030 // [NAMESPACE]
3031 buf.putNamespaceName(msg->nameSpace);
3032
3033 // [QUERY-LANGUAGE]
3034 buf.putString(msg->queryLanguage);
3035
3036 // [QUERY]
3037 buf.putString(msg->query);
3038 }
3039
3040 static CIMExecQueryRequestMessage* _decodeExecQueryRequest(
3041 CIMBuffer& in,
3042 Uint32 queueId,
3043 Uint32 returnQueueId,
3044 Uint32 flags,
3045 const String& messageId)
3046 {
3047 /* See ../Server/CIMOperationRequestDecoder.cpp */
3048
3049 STAT_GETSTARTTIME
3050 mike 1.1
3051 // [NAMESPACE]
3052
3053 CIMNamespaceName nameSpace;
3054
3055 if (!in.getNamespaceName(nameSpace))
3056 return 0;
3057
3058 // [QUERY-LANGUAGE]]
3059 String queryLanguage;
3060
3061 if (!in.getString(queryLanguage))
3062 return 0;
3063
3064 // [QUERY]]
3065 String query;
3066
3067 if (!in.getString(query))
3068 return 0;
3069
3070 AutoPtr<CIMExecQueryRequestMessage> request(
3071 mike 1.1 new CIMExecQueryRequestMessage(
3072 messageId,
3073 nameSpace,
3074 queryLanguage,
3075 query,
3076 QueueIdStack(queueId, returnQueueId)));
3077
3078 request->binaryRequest = true;
3079
3080 STAT_SERVERSTART
3081
3082 return request.release();
3083 }
3084
3085 static void _encodeExecQueryResponseBody(
3086 CIMBuffer& out,
|
3087 r.kieninger 1.8 CIMObjectsResponseData& data,
|
3088 mike 1.1 CIMName& name)
3089 {
3090 /* See ../Server/CIMOperationResponseEncoder.cpp */
3091
3092 static const CIMName NAME("ExecQuery");
3093 name = NAME;
3094
|
3095 r.kieninger 1.8 data.encodeBinaryResponse(out);
|
3096 mike 1.1 }
3097
3098 static CIMExecQueryResponseMessage* _decodeExecQueryResponse(
3099 CIMBuffer& in,
3100 Uint32 flags,
3101 const String& messageId)
3102 {
3103 /* See ../Client/CIMOperationResponseDecoder.cpp */
3104
3105 Array<CIMObject> cimObjects;
3106
3107 while (in.more())
3108 {
3109 Array<CIMObject> tmp;
3110
3111 if (!in.getObjectA(tmp))
3112 return 0;
3113
3114 cimObjects.append(tmp.getData(), tmp.size());
3115 }
3116
3117 mike 1.1 CIMExecQueryResponseMessage* msg;
3118 CIMException cimException;
3119
3120 msg = new CIMExecQueryResponseMessage(
3121 messageId,
3122 cimException,
|
3123 r.kieninger 1.8 QueueIdStack());
|
3124 mike 1.1
|
3125 r.kieninger 1.8 msg->getResponseData().setCIMObjects(cimObjects);
|
3126 mike 1.1 msg->binaryRequest = true;
3127 return msg;
3128 }
3129
3130 //==============================================================================
3131 //
3132 // BinaryCodec::hexDump()
3133 //
3134 //==============================================================================
3135
3136 #if defined(PEGASUS_DEBUG)
3137
3138 void BinaryCodec::hexDump(const void* data, size_t size)
3139 {
3140 unsigned char* p = (unsigned char*)data;
3141 unsigned char buf[16];
3142 size_t n = 0;
3143
3144 for (size_t i = 0, col = 0; i < size; i++)
3145 {
3146 unsigned char c = p[i];
3147 mike 1.1 buf[n++] = c;
3148
3149 if (col == 0)
3150 printf("%06X ", (unsigned int)i);
3151
3152 printf("%02X ", c);
3153
3154 if (col + 1 == sizeof(buf) || i + 1 == size)
3155 {
3156 for (size_t j = col + 1; j < sizeof(buf); j++)
3157 printf(" ");
3158
3159 for (size_t j = 0; j < n; j++)
3160 {
3161 c = buf[j];
3162
3163 if (c >= ' ' && c <= '~')
3164 printf("%c", buf[j]);
3165 else
3166 printf(".");
3167 }
3168 mike 1.1
3169 printf("\n");
3170 n = 0;
3171 }
3172
3173 if (col + 1 == sizeof(buf))
3174 col = 0;
3175 else
3176 col++;
3177 }
3178
3179 printf("\n");
3180 }
3181
3182 #endif /* defined(PEGASUS_DEBUG) */
3183
3184 //==============================================================================
3185 //
3186 // BinaryCodec::decodeRequest()
3187 //
3188 //==============================================================================
3189 mike 1.1
3190 CIMOperationRequestMessage* BinaryCodec::decodeRequest(
3191 const Buffer& in,
3192 Uint32 queueId,
3193 Uint32 returnQueueId)
3194 {
3195 CIMBuffer buf((char*)in.getData(), in.size());
3196 CIMBufferReleaser buf_(buf);
3197
3198 // Turn on validation:
3199 #if defined(ENABLE_VALIDATION)
3200 buf.setValidate(true);
3201 #endif
3202
3203 Uint32 flags;
3204 String messageId;
3205 Operation operation;
3206
3207
3208 if (!_getHeader(buf, flags, messageId, operation))
3209 {
3210 mike 1.1 return 0;
3211 }
3212
3213 switch (operation)
3214 {
3215 case OP_EnumerateInstances:
3216 return _decodeEnumerateInstancesRequest(
3217 buf, queueId, returnQueueId, flags, messageId);
3218 case OP_EnumerateInstanceNames:
3219 return _decodeEnumerateInstanceNamesRequest(
3220 buf, queueId, returnQueueId, flags, messageId);
3221 case OP_GetInstance:
3222 return _decodeGetInstanceRequest(
3223 buf, queueId, returnQueueId, flags, messageId);
3224 case OP_CreateInstance:
3225 return _decodeCreateInstanceRequest(
3226 buf, queueId, returnQueueId, flags, messageId);
3227 case OP_ModifyInstance:
3228 return _decodeModifyInstanceRequest(
3229 buf, queueId, returnQueueId, flags, messageId);
3230 case OP_DeleteInstance:
3231 mike 1.1 return _decodeDeleteInstanceRequest(
3232 buf, queueId, returnQueueId, flags, messageId);
3233 case OP_Associators:
3234 return _decodeAssociatorsRequest(
3235 buf, queueId, returnQueueId, flags, messageId);
3236 case OP_AssociatorNames:
3237 return _decodeAssociatorNamesRequest(
3238 buf, queueId, returnQueueId, flags, messageId);
3239 case OP_References:
3240 return _decodeReferencesRequest(
3241 buf, queueId, returnQueueId, flags, messageId);
3242 case OP_ReferenceNames:
3243 return _decodeReferenceNamesRequest(
3244 buf, queueId, returnQueueId, flags, messageId);
3245 case OP_GetClass:
3246 return _decodeGetClassRequest(
3247 buf, queueId, returnQueueId, flags, messageId);
3248 case OP_EnumerateClasses:
3249 return _decodeEnumerateClassesRequest(
3250 buf, queueId, returnQueueId, flags, messageId);
3251 case OP_EnumerateClassNames:
3252 mike 1.1 return _decodeEnumerateClassNamesRequest(
3253 buf, queueId, returnQueueId, flags, messageId);
3254 case OP_CreateClass:
3255 return _decodeCreateClassRequest(
3256 buf, queueId, returnQueueId, flags, messageId);
3257 case OP_DeleteClass:
3258 return _decodeDeleteClassRequest(
3259 buf, queueId, returnQueueId, flags, messageId);
3260 case OP_ModifyClass:
3261 return _decodeModifyClassRequest(
3262 buf, queueId, returnQueueId, flags, messageId);
3263 case OP_SetQualifier:
3264 return _decodeSetQualifierRequest(
3265 buf, queueId, returnQueueId, flags, messageId);
3266 case OP_GetQualifier:
3267 return _decodeGetQualifierRequest(
3268 buf, queueId, returnQueueId, flags, messageId);
3269 case OP_DeleteQualifier:
3270 return _decodeDeleteQualifierRequest(
3271 buf, queueId, returnQueueId, flags, messageId);
3272 case OP_EnumerateQualifiers:
3273 mike 1.1 return _decodeEnumerateQualifiersRequest(
3274 buf, queueId, returnQueueId, flags, messageId);
3275 case OP_GetProperty:
3276 return _decodeGetPropertyRequest(
3277 buf, queueId, returnQueueId, flags, messageId);
3278 case OP_SetProperty:
3279 return _decodeSetPropertyRequest(
3280 buf, queueId, returnQueueId, flags, messageId);
3281 case OP_InvokeMethod:
3282 return _decodeInvokeMethodRequest(
3283 buf, queueId, returnQueueId, flags, messageId);
3284 case OP_ExecQuery:
3285 return _decodeExecQueryRequest(
3286 buf, queueId, returnQueueId, flags, messageId);
3287 default:
3288 // Unexpected message type
3289 PEGASUS_ASSERT(0);
3290 return 0;
3291 }
3292 }
3293
3294 mike 1.1 //==============================================================================
3295 //
3296 // BinaryCodec::decodeResponse()
3297 //
3298 //==============================================================================
3299
3300 CIMResponseMessage* BinaryCodec::decodeResponse(
3301 const Buffer& in)
3302 {
3303 CIMBuffer buf((char*)in.getData(), in.size());
3304 CIMBufferReleaser buf_(buf);
3305
3306 // Turn on validation:
3307 #if defined(ENABLE_VALIDATION)
3308 buf.setValidate(true);
3309 #endif
3310
3311 Uint32 flags;
3312 String messageId;
3313 Operation operation;
3314
3315 mike 1.1 if (!_getHeader(buf, flags, messageId, operation))
3316 {
3317 throw CIMException(CIM_ERR_FAILED, "Corrupt binary message header");
3318 return 0;
3319 }
3320
3321 CIMResponseMessage* msg = 0;
3322
3323 switch (operation)
3324 {
3325 case OP_EnumerateInstances:
3326 msg = _decodeEnumerateInstancesResponse(buf, flags, messageId);
3327 break;
3328 case OP_EnumerateInstanceNames:
3329 msg = _decodeEnumerateInstanceNamesResponse(buf, flags, messageId);
3330 break;
3331 case OP_GetInstance:
3332 msg = _decodeGetInstanceResponse(buf, flags, messageId);
3333 break;
3334 case OP_CreateInstance:
3335 msg = _decodeCreateInstanceResponse(buf, flags, messageId);
3336 mike 1.1 break;
3337 case OP_ModifyInstance:
3338 msg = _decodeModifyInstanceResponse(buf, flags, messageId);
3339 break;
3340 case OP_DeleteInstance:
3341 msg = _decodeDeleteInstanceResponse(buf, flags, messageId);
3342 break;
3343 case OP_Associators:
3344 msg = _decodeAssociatorsResponse(buf, flags, messageId);
3345 break;
3346 case OP_AssociatorNames:
3347 msg = _decodeAssociatorNamesResponse(buf, flags, messageId);
3348 break;
3349 case OP_References:
3350 msg = _decodeReferencesResponse(buf, flags, messageId);
3351 break;
3352 case OP_ReferenceNames:
3353 msg = _decodeReferenceNamesResponse(buf, flags, messageId);
3354 break;
3355 case OP_GetClass:
3356 msg = _decodeGetClassResponse(buf, flags, messageId);
3357 mike 1.1 break;
3358 case OP_EnumerateClasses:
3359 msg = _decodeEnumerateClassesResponse(buf, flags, messageId);
3360 break;
3361 case OP_EnumerateClassNames:
3362 msg = _decodeEnumerateClassNamesResponse(buf, flags, messageId);
3363 break;
3364 case OP_CreateClass:
3365 msg = _decodeCreateClassResponse(buf, flags, messageId);
3366 break;
3367 case OP_DeleteClass:
3368 msg = _decodeDeleteClassResponse(buf, flags, messageId);
3369 break;
3370 case OP_ModifyClass:
3371 msg = _decodeModifyClassResponse(buf, flags, messageId);
3372 break;
3373 case OP_SetQualifier:
3374 msg = _decodeSetQualifierResponse(buf, flags, messageId);
3375 break;
3376 case OP_GetQualifier:
3377 msg = _decodeGetQualifierResponse(buf, flags, messageId);
3378 mike 1.1 break;
3379 case OP_DeleteQualifier:
3380 msg = _decodeDeleteQualifierResponse(buf, flags, messageId);
3381 break;
3382 case OP_EnumerateQualifiers:
3383 msg = _decodeEnumerateQualifiersResponse(buf, flags, messageId);
3384 break;
3385 case OP_GetProperty:
3386 msg = _decodeGetPropertyResponse(buf, flags, messageId);
3387 break;
3388 case OP_SetProperty:
3389 msg = _decodeSetPropertyResponse(buf, flags, messageId);
3390 break;
3391 case OP_InvokeMethod:
3392 msg = _decodeInvokeMethodResponse(buf, flags, messageId);
3393 break;
3394 case OP_ExecQuery:
3395 msg = _decodeExecQueryResponse(buf, flags, messageId);
3396 break;
3397 default:
3398 // Unexpected message type
3399 mike 1.1 PEGASUS_ASSERT(0);
3400 break;
3401 }
3402
3403 if (!msg)
3404 throw CIMException(CIM_ERR_FAILED, "Received corrupted binary message");
3405
3406 return msg;
3407 }
3408
3409 //==============================================================================
3410 //
3411 // BinaryCodec::formatSimpleIMethodRspMessage()
3412 //
3413 //==============================================================================
3414
3415 Buffer BinaryCodec::formatSimpleIMethodRspMessage(
3416 const CIMName& iMethodName,
3417 const String& messageId,
3418 HttpMethod httpMethod,
3419 const ContentLanguageList& httpContentLanguages,
3420 mike 1.1 const Buffer& body,
3421 Uint64 serverResponseTime,
3422 Boolean isFirst,
3423 Boolean isLast)
3424 {
3425 Buffer out;
3426
3427 if (isFirst == true)
3428 {
3429 // Write HTTP header:
|
3430 kumpf 1.6 XmlWriter::appendMethodResponseHeader(out, httpMethod,
|
3431 mike 1.1 httpContentLanguages, 0, serverResponseTime, true);
3432
3433 // Binary message header:
3434 CIMBuffer cb(128);
3435 _putHeader(cb, 0, messageId, _NameToOp(iMethodName));
3436 out.append(cb.getData(), cb.size());
3437 }
3438
3439 if (body.size() != 0)
3440 {
3441 out.append(body.getData(), body.size());
3442 }
3443
3444 return out;
3445 }
3446
3447 //==============================================================================
3448 //
3449 // BinaryCodec::encodeRequest()
3450 //
3451 //==============================================================================
3452 mike 1.1
3453 bool BinaryCodec::encodeRequest(
3454 Buffer& out,
3455 const char* host,
3456 const String& authHeader,
3457 CIMOperationRequestMessage* msg,
3458 bool binaryResponse)
3459 {
3460 CIMBuffer buf;
3461 CIMName name;
3462
3463 switch (msg->getType())
3464 {
3465 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
3466 {
3467 _encodeEnumerateInstancesRequest(buf,
3468 (CIMEnumerateInstancesRequestMessage*)msg, name);
3469 break;
3470 }
3471
3472 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
3473 mike 1.1 {
3474 _encodeEnumerateInstanceNamesRequest(buf,
3475 (CIMEnumerateInstanceNamesRequestMessage*)msg, name);
3476 break;
3477 }
3478
3479 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
3480 {
3481 _encodeGetInstanceRequest(buf,
3482 (CIMGetInstanceRequestMessage*)msg, name);
3483 break;
3484 }
3485
3486 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
3487 {
3488 _encodeCreateInstanceRequest(buf,
3489 (CIMCreateInstanceRequestMessage*)msg, name);
3490 break;
3491 }
3492
3493 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
3494 mike 1.1 {
3495 _encodeModifyInstanceRequest(buf,
3496 (CIMModifyInstanceRequestMessage*)msg, name);
3497 break;
3498 }
3499
3500 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
3501 {
3502 _encodeDeleteInstanceRequest(buf,
3503 (CIMDeleteInstanceRequestMessage*)msg, name);
3504 break;
3505 }
3506
3507 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
3508 {
3509 _encodeAssociatorsRequest(buf,
3510 (CIMAssociatorsRequestMessage*)msg, name);
3511 break;
3512 }
3513
3514 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
3515 mike 1.1 {
3516 _encodeAssociatorNamesRequest(buf,
3517 (CIMAssociatorNamesRequestMessage*)msg, name);
3518 break;
3519 }
3520
3521 case CIM_REFERENCES_REQUEST_MESSAGE:
3522 {
3523 _encodeReferencesRequest(buf,
3524 (CIMReferencesRequestMessage*)msg, name);
3525 break;
3526 }
3527
3528 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
3529 {
3530 _encodeReferenceNamesRequest(buf,
3531 (CIMReferenceNamesRequestMessage*)msg, name);
3532 break;
3533 }
3534
3535 case CIM_GET_CLASS_REQUEST_MESSAGE:
3536 mike 1.1 {
3537 _encodeGetClassRequest(buf,
3538 (CIMGetClassRequestMessage*)msg, name);
3539 break;
3540 }
3541
3542 case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
3543 {
3544 _encodeEnumerateClassesRequest(buf,
3545 (CIMEnumerateClassesRequestMessage*)msg, name);
3546 break;
3547 }
3548
3549 case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
3550 {
3551 _encodeEnumerateClassNamesRequest(buf,
3552 (CIMEnumerateClassNamesRequestMessage*)msg, name);
3553 break;
3554 }
3555
3556 case CIM_CREATE_CLASS_REQUEST_MESSAGE:
3557 mike 1.1 {
3558 _encodeCreateClassRequest(buf,
3559 (CIMCreateClassRequestMessage*)msg, name);
3560 break;
3561 }
3562
3563 case CIM_DELETE_CLASS_REQUEST_MESSAGE:
3564 {
3565 _encodeDeleteClassRequest(buf,
3566 (CIMDeleteClassRequestMessage*)msg, name);
3567 break;
3568 }
3569
3570 case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
3571 {
3572 _encodeModifyClassRequest(buf,
3573 (CIMModifyClassRequestMessage*)msg, name);
3574 break;
3575 }
3576
3577 case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
3578 mike 1.1 {
3579 _encodeSetQualifierRequest(buf,
3580 (CIMSetQualifierRequestMessage*)msg, name);
3581 break;
3582 }
3583
3584 case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
3585 {
3586 _encodeGetQualifierRequest(buf,
3587 (CIMGetQualifierRequestMessage*)msg, name);
3588 break;
3589 }
3590
3591 case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
3592 {
3593 _encodeDeleteQualifierRequest(buf,
3594 (CIMDeleteQualifierRequestMessage*)msg, name);
3595 break;
3596 }
3597
3598 case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
3599 mike 1.1 {
3600 _encodeEnumerateQualifiersRequest(buf,
3601 (CIMEnumerateQualifiersRequestMessage*)msg, name);
3602 break;
3603 }
3604
3605 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
3606 {
3607 _encodeGetPropertyRequest(buf,
3608 (CIMGetPropertyRequestMessage*)msg, name);
3609 break;
3610 }
3611
3612 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
3613 {
3614 _encodeSetPropertyRequest(buf,
3615 (CIMSetPropertyRequestMessage*)msg, name);
3616 break;
3617 }
3618
3619 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
3620 mike 1.1 {
3621 _encodeInvokeMethodRequest(buf,
3622 (CIMInvokeMethodRequestMessage*)msg, name);
3623 break;
3624 }
3625
3626 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
3627 {
3628 _encodeExecQueryRequest(buf,
3629 (CIMExecQueryRequestMessage*)msg, name);
3630 break;
3631 }
3632
3633 default:
3634 // Unexpected message type
3635 PEGASUS_ASSERT(0);
3636 return false;
3637 }
3638
3639 // [HTTP-HEADERS]
3640 XmlWriter::appendMethodCallHeader(
3641 mike 1.1 out,
3642 host,
3643 name,
3644 msg->nameSpace.getString(),
3645 authHeader,
3646 msg->getHttpMethod(),
3647 AcceptLanguageListContainer(msg->operationContext.get(
3648 AcceptLanguageListContainer::NAME)).getLanguages(),
3649 ContentLanguageListContainer(msg->operationContext.get(
3650 ContentLanguageListContainer::NAME)).getLanguages(),
|
3651 kumpf 1.6 buf.size(),
|
3652 mike 1.1 true, /* binaryRequest */
3653 binaryResponse);
3654
3655 out.append(buf.getData(), buf.size());
3656
3657 return true;
3658 }
3659
3660 //==============================================================================
3661 //
3662 // BinaryCodec::encodeResponseBody()
3663 //
3664 //==============================================================================
3665
3666 bool BinaryCodec::encodeResponseBody(
3667 Buffer& out,
3668 const CIMResponseMessage* msg,
3669 CIMName& name)
3670 {
3671 CIMBuffer buf;
3672
3673 mike 1.1 switch (msg->getType())
3674 {
3675 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
3676 {
|
3677 r.kieninger 1.8 _encodeEnumerateInstancesResponseBody(
3678 buf,
3679 ((CIMEnumerateInstancesResponseMessage*)msg)->getResponseData(),
3680 name);
|
3681 mike 1.1 break;
3682 }
3683
3684 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
3685 {
3686 _encodeEnumerateInstanceNamesResponseBody(buf,
3687 (CIMEnumerateInstanceNamesResponseMessage*)msg, name);
3688 break;
3689 }
3690
3691 case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
3692 {
|
3693 r.kieninger 1.8 _encodeGetInstanceResponseBody(
3694 buf,
3695 ((CIMGetInstanceResponseMessage*)msg)->getResponseData(),
3696 name);
|
3697 mike 1.1 break;
3698 }
3699
3700 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
3701 {
3702 _encodeCreateInstanceResponseBody(buf,
3703 (CIMCreateInstanceResponseMessage*)msg, name);
3704 break;
3705 }
3706
3707 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
3708 {
3709 _encodeModifyInstanceResponseBody(buf,
3710 (CIMModifyInstanceResponseMessage*)msg, name);
3711 break;
3712 }
3713
3714 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
3715 {
3716 _encodeDeleteInstanceResponseBody(buf,
3717 (CIMDeleteInstanceResponseMessage*)msg, name);
3718 mike 1.1 break;
3719 }
3720
3721 case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
3722 {
|
3723 r.kieninger 1.8 _encodeAssociatorsResponseBody(
3724 buf,
3725 ((CIMAssociatorsResponseMessage*)msg)->getResponseData(),
3726 name);
|
3727 mike 1.1 break;
3728 }
3729
3730 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
3731 {
3732 _encodeAssociatorNamesResponseBody(buf,
3733 (CIMAssociatorNamesResponseMessage*)msg, name);
3734 break;
3735 }
3736
3737 case CIM_REFERENCES_RESPONSE_MESSAGE:
3738 {
3739 _encodeReferencesResponseBody(buf,
3740 (CIMReferencesResponseMessage*)msg, name);
3741 break;
3742 }
3743
3744 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
3745 {
3746 _encodeReferenceNamesResponseBody(buf,
3747 (CIMReferenceNamesResponseMessage*)msg, name);
3748 mike 1.1 break;
3749 }
3750
3751 case CIM_GET_CLASS_RESPONSE_MESSAGE:
3752 {
3753 _encodeGetClassResponseBody(buf,
3754 (CIMGetClassResponseMessage*)msg, name);
3755 break;
3756 }
3757
3758 case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
3759 {
3760 _encodeEnumerateClassesResponseBody(buf,
3761 (CIMEnumerateClassesResponseMessage*)msg, name);
3762 break;
3763 }
3764
3765 case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
3766 {
3767 _encodeEnumerateClassNamesResponseBody(buf,
3768 (CIMEnumerateClassNamesResponseMessage*)msg, name);
3769 mike 1.1 break;
3770 }
3771
3772 case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
3773 {
3774 _encodeCreateClassResponseBody(buf,
3775 (CIMCreateClassResponseMessage*)msg, name);
3776 break;
3777 }
3778
3779 case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
3780 {
3781 _encodeDeleteClassResponseBody(buf,
3782 (CIMDeleteClassResponseMessage*)msg, name);
3783 break;
3784 }
3785
3786 case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
3787 {
3788 _encodeModifyClassResponseBody(buf,
3789 (CIMModifyClassResponseMessage*)msg, name);
3790 mike 1.1 break;
3791 }
3792
3793 case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
3794 {
3795 _encodeSetQualifierResponseBody(buf,
3796 (CIMSetQualifierResponseMessage*)msg, name);
3797 break;
3798 }
3799
3800 case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
3801 {
3802 _encodeGetQualifierResponseBody(buf,
3803 (CIMGetQualifierResponseMessage*)msg, name);
3804 break;
3805 }
3806
3807 case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
3808 {
3809 _encodeDeleteQualifierResponseBody(buf,
3810 (CIMDeleteQualifierResponseMessage*)msg, name);
3811 mike 1.1 break;
3812 }
3813
3814 case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
3815 {
3816 _encodeEnumerateQualifiersResponseBody(buf,
3817 (CIMEnumerateQualifiersResponseMessage*)msg, name);
3818 break;
3819 }
3820
3821 case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
3822 {
3823 _encodeGetPropertyResponseBody(buf,
3824 (CIMGetPropertyResponseMessage*)msg, name);
3825 break;
3826 }
3827
3828 case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
3829 {
3830 _encodeSetPropertyResponseBody(buf,
3831 (CIMSetPropertyResponseMessage*)msg, name);
3832 mike 1.1 break;
3833 }
3834
3835 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
3836 {
3837 _encodeInvokeMethodResponseBody(buf,
3838 (CIMInvokeMethodResponseMessage*)msg, name);
3839 break;
3840 }
3841
3842 case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
3843 {
|
3844 r.kieninger 1.8 _encodeExecQueryResponseBody(
3845 buf,
3846 ((CIMExecQueryResponseMessage*)msg)->getResponseData(),
3847 name);
|
3848 mike 1.1 break;
3849 }
3850
3851 default:
3852 // Unexpected message type
3853 PEGASUS_ASSERT(0);
3854 return false;
3855 }
3856
3857 out.append(buf.getData(), buf.size());
3858 return true;
3859 }
3860
3861 PEGASUS_NAMESPACE_END
|
Return to
BinaryCodec.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common