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