1 mike 1.2 //%/////////////////////////////////////////////////////////////////////////////
2 //
|
3 kumpf 1.11 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
|
4 mike 1.2 // The Open Group, Tivoli Systems
5 //
6 // Permission is hereby granted, free of charge, to any person obtaining a copy
7 // of this software and associated documentation files (the "Software"), to
8 // deal in the Software without restriction, including without limitation the
9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 // sell copies of the Software, and to permit persons to whom the Software is
11 // furnished to do so, subject to the following conditions:
|
12 kumpf 1.11 //
|
13 mike 1.2 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 //
22 //==============================================================================
23 //
24 // Author: Mike Brasher (mbrasher@bmc.com)
25 //
26 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
27 // Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
28 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
29 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include <Pegasus/Common/Config.h>
33 #include <iostream>
|
34 kumpf 1.10 #include <Pegasus/Common/Constants.h>
|
35 mike 1.2 #include <Pegasus/Common/System.h>
36 #include <Pegasus/Common/XmlWriter.h>
37 #include <Pegasus/Common/HTTPMessage.h>
38 #include "CIMOperationRequestEncoder.h"
39
40 PEGASUS_USING_STD;
41
42 PEGASUS_NAMESPACE_BEGIN
43
44 CIMOperationRequestEncoder::CIMOperationRequestEncoder(
45 MessageQueue* outputQueue, ClientAuthenticator* authenticator)
46 :
|
47 kumpf 1.10 MessageQueue(PEGASUS_QUEUENAME_OPREQENCODER),
|
48 mike 1.2 _outputQueue(outputQueue),
49 _authenticator(authenticator)
50 {
51 String tmpHostName = System::getHostName();
52 _hostName = tmpHostName.allocateCString();
53 }
54
55 CIMOperationRequestEncoder::~CIMOperationRequestEncoder()
56 {
57 delete [] _hostName;
58 }
59
60 void CIMOperationRequestEncoder::handleEnqueue()
61 {
62 Message* message = dequeue();
63
64 if (!message)
65 return;
66
67 _authenticator->setRequestMessage(message);
68
69 mike 1.2 switch (message->getType())
70 {
71 case CIM_CREATE_CLASS_REQUEST_MESSAGE:
72 _encodeCreateClassRequest(
73 (CIMCreateClassRequestMessage*)message);
74 break;
75
76 case CIM_GET_CLASS_REQUEST_MESSAGE:
77 _encodeGetClassRequest((CIMGetClassRequestMessage*)message);
78 break;
79
80 case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
81 _encodeModifyClassRequest(
82 (CIMModifyClassRequestMessage*)message);
83 break;
84
85 case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
86 _encodeEnumerateClassNamesRequest(
87 (CIMEnumerateClassNamesRequestMessage*)message);
88 break;
89
90 mike 1.2 case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
91 _encodeEnumerateClassesRequest(
92 (CIMEnumerateClassesRequestMessage*)message);
93 break;
94
95 case CIM_DELETE_CLASS_REQUEST_MESSAGE:
96 _encodeDeleteClassRequest(
97 (CIMDeleteClassRequestMessage*)message);
98 break;
99
100 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
101 _encodeCreateInstanceRequest(
102 (CIMCreateInstanceRequestMessage*)message);
103 break;
104
105 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
106 _encodeGetInstanceRequest((CIMGetInstanceRequestMessage*)message);
107 break;
108
109 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
110 _encodeModifyInstanceRequest(
111 mike 1.2 (CIMModifyInstanceRequestMessage*)message);
112 break;
113
114 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
115 _encodeEnumerateInstanceNamesRequest(
116 (CIMEnumerateInstanceNamesRequestMessage*)message);
117 break;
118
119 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
120 _encodeEnumerateInstancesRequest(
121 (CIMEnumerateInstancesRequestMessage*)message);
122 break;
123
124 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
125 _encodeDeleteInstanceRequest(
126 (CIMDeleteInstanceRequestMessage*)message);
127 break;
128
129 case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
130 _encodeSetQualifierRequest(
131 (CIMSetQualifierRequestMessage*)message);
132 mike 1.2 break;
133
134 case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
135 _encodeGetQualifierRequest(
136 (CIMGetQualifierRequestMessage*)message);
137 break;
138
139 case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
140 _encodeEnumerateQualifiersRequest(
141 (CIMEnumerateQualifiersRequestMessage*)message);
142 break;
143
144 case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
145 _encodeDeleteQualifierRequest(
146 (CIMDeleteQualifierRequestMessage*)message);
147 break;
148
149 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
150 _encodeReferenceNamesRequest(
151 (CIMReferenceNamesRequestMessage*)message);
152 break;
153 mike 1.2
154 case CIM_REFERENCES_REQUEST_MESSAGE:
155 _encodeReferencesRequest(
156 (CIMReferencesRequestMessage*)message);
157 break;
158
159 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
160 _encodeAssociatorNamesRequest(
161 (CIMAssociatorNamesRequestMessage*)message);
162 break;
163
164 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
165 _encodeAssociatorsRequest(
166 (CIMAssociatorsRequestMessage*)message);
167 break;
168
169 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
|
170 kumpf 1.9 _encodeExecQueryRequest(
171 (CIMExecQueryRequestMessage*)message);
|
172 mike 1.2 break;
173
174 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
175 _encodeGetPropertyRequest((CIMGetPropertyRequestMessage*)message);
176 break;
177
178 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
179 _encodeSetPropertyRequest((CIMSetPropertyRequestMessage*)message);
180 break;
181
182 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
183 _encodeInvokeMethodRequest(
184 (CIMInvokeMethodRequestMessage*)message);
185 break;
186 }
187
188 //ATTN: Do not delete the message here.
189 //
190 // ClientAuthenticator needs this message for resending the request on
191 // authentication challenge from the server. The message is deleted in
192 // the decoder after receiving the valid response from thr server.
193 mike 1.2 //
194 //delete message;
195 }
196
197 void CIMOperationRequestEncoder::_encodeCreateClassRequest(
198 CIMCreateClassRequestMessage* message)
199 {
200 Array<Sint8> params;
|
201 kumpf 1.4 XmlWriter::appendClassIParameter(params, "NewClass", message->newClass);
|
202 mike 1.2
203 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
204 message->nameSpace, "CreateClass", message->messageId,
205 _authenticator->buildRequestAuthHeader(), params);
206
207 _outputQueue->enqueue(new HTTPMessage(buffer));
208 }
209
210 void CIMOperationRequestEncoder::_encodeGetClassRequest(
211 CIMGetClassRequestMessage* message)
212 {
213 Array<Sint8> params;
214
|
215 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
216 mike 1.2 params, "ClassName", message->className);
217
218 if (message->localOnly != true)
|
219 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "LocalOnly", false);
|
220 mike 1.2
221 if (message->includeQualifiers != true)
|
222 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "IncludeQualifiers", false);
|
223 mike 1.2
224 if (message->includeClassOrigin != false)
|
225 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "IncludeClassOrigin", true);
|
226 mike 1.2
227 if (!message->propertyList.isNull())
|
228 kumpf 1.4 XmlWriter::appendPropertyListIParameter(
|
229 mike 1.2 params, message->propertyList);
230
231 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(
232 _hostName, message->nameSpace, "GetClass", message->messageId,
233 _authenticator->buildRequestAuthHeader(), params);
234
235 _outputQueue->enqueue(new HTTPMessage(buffer));
236 }
237
238 void CIMOperationRequestEncoder::_encodeModifyClassRequest(
239 CIMModifyClassRequestMessage* message)
240 {
241 Array<Sint8> params;
242
|
243 kumpf 1.4 XmlWriter::appendClassIParameter(
|
244 mike 1.2 params, "ModifiedClass", message->modifiedClass);
245
246 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
247 message->nameSpace, "ModifyClass", message->messageId,
248 _authenticator->buildRequestAuthHeader(), params);
249
250
251 _outputQueue->enqueue(new HTTPMessage(buffer));
252 }
253
254 void CIMOperationRequestEncoder::_encodeEnumerateClassNamesRequest(
255 CIMEnumerateClassNamesRequestMessage* message)
256 {
257 Array<Sint8> params;
258
259 if (message->className.size())
|
260 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
261 mike 1.2 params, "ClassName", message->className);
262
263 if (message->deepInheritance != false)
|
264 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "DeepInheritance", true);
|
265 mike 1.2
266 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
267 message->nameSpace, "EnumerateClassNames", message->messageId,
268 _authenticator->buildRequestAuthHeader(), params);
269
270 _outputQueue->enqueue(new HTTPMessage(buffer));
271 }
272
273 void CIMOperationRequestEncoder::_encodeEnumerateClassesRequest(
274 CIMEnumerateClassesRequestMessage* message)
275 {
276 Array<Sint8> params;
277
278 if (message->className.size())
|
279 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
280 mike 1.2 params, "ClassName", message->className);
281
282 if (message->deepInheritance != false)
|
283 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "DeepInheritance", true);
|
284 mike 1.2
285 if (message->localOnly != true)
|
286 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "LocalOnly", false);
|
287 mike 1.2
288 if (message->includeQualifiers != true)
|
289 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
290 mike 1.2 params, "IncludeQualifiers", false);
291
292 if (message->includeClassOrigin != false)
|
293 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
294 mike 1.2 params, "IncludeClassOrigin", true);
295
296 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
297 message->nameSpace, "EnumerateClasses", message->messageId,
298 _authenticator->buildRequestAuthHeader(), params);
299
300 _outputQueue->enqueue(new HTTPMessage(buffer));
301 }
302
303 void CIMOperationRequestEncoder::_encodeDeleteClassRequest(
304 CIMDeleteClassRequestMessage* message)
305 {
306 Array<Sint8> params;
307
308 if (message->className.size())
|
309 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
310 mike 1.2 params, "ClassName", message->className);
311
312 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
313 message->nameSpace, "DeleteClass", message->messageId,
314 _authenticator->buildRequestAuthHeader(), params);
315
316 _outputQueue->enqueue(new HTTPMessage(buffer));
317 }
318
319 void CIMOperationRequestEncoder::_encodeCreateInstanceRequest(
320 CIMCreateInstanceRequestMessage* message)
321 {
322 Array<Sint8> params;
323
|
324 kumpf 1.4 XmlWriter::appendInstanceIParameter(
|
325 mike 1.2 params, "NewInstance", message->newInstance);
326
327 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
328 message->nameSpace, "CreateInstance", message->messageId,
329 _authenticator->buildRequestAuthHeader(), params);
330
331 _outputQueue->enqueue(new HTTPMessage(buffer));
332 }
333
334 void CIMOperationRequestEncoder::_encodeGetInstanceRequest(
335 CIMGetInstanceRequestMessage* message)
336 {
337 Array<Sint8> params;
338
|
339 kumpf 1.4 XmlWriter::appendInstanceNameIParameter(
|
340 mike 1.2 params, "InstanceName", message->instanceName);
341
342 if (message->localOnly != true)
|
343 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
344 mike 1.2 params, "LocalOnly", false);
345
346 if (message->includeQualifiers != false)
|
347 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
348 mike 1.2 params, "IncludeQualifiers", true);
349
350 if (message->includeClassOrigin != false)
|
351 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
352 mike 1.2 params, "IncludeClassOrigin", true);
353
354 if (!message->propertyList.isNull())
|
355 kumpf 1.4 XmlWriter::appendPropertyListIParameter(
|
356 mike 1.2 params, message->propertyList);
357
358 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
359 message->nameSpace, "GetInstance", message->messageId,
360 _authenticator->buildRequestAuthHeader(), params);
361
362 _outputQueue->enqueue(new HTTPMessage(buffer));
363 }
364
365 void CIMOperationRequestEncoder::_encodeModifyInstanceRequest(
366 CIMModifyInstanceRequestMessage* message)
367 {
368 Array<Sint8> params;
|
369 kumpf 1.4 XmlWriter::appendNamedInstanceIParameter(
|
370 mike 1.2 params, "ModifiedInstance", message->modifiedInstance);
371
372 if (message->includeQualifiers != true)
|
373 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
374 mike 1.2 params, "IncludeQualifiers", false);
375
376 if (!message->propertyList.isNull())
|
377 kumpf 1.4 XmlWriter::appendPropertyListIParameter(
|
378 mike 1.2 params, message->propertyList);
379
380 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
381 message->nameSpace, "ModifyInstance", message->messageId,
382 _authenticator->buildRequestAuthHeader(), params);
383
384 _outputQueue->enqueue(new HTTPMessage(buffer));
385 }
386
387 void CIMOperationRequestEncoder::_encodeEnumerateInstanceNamesRequest(
388 CIMEnumerateInstanceNamesRequestMessage* message)
389 {
390 Array<Sint8> params;
391
|
392 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
393 mike 1.2 params, "ClassName", message->className);
394
395 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
396 message->nameSpace, "EnumerateInstanceNames", message->messageId,
397 _authenticator->buildRequestAuthHeader(), params);
398
399 _outputQueue->enqueue(new HTTPMessage(buffer));
400 }
401
402 void CIMOperationRequestEncoder::_encodeEnumerateInstancesRequest(
403 CIMEnumerateInstancesRequestMessage* message)
404 {
405 Array<Sint8> params;
406
|
407 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
408 mike 1.2 params, "ClassName", message->className);
409
410 if (message->localOnly != true)
|
411 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "LocalOnly", false);
|
412 mike 1.2
413 if (message->deepInheritance != true)
|
414 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "DeepInheritance", false);
|
415 mike 1.2
416 if (message->includeQualifiers != false)
|
417 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
418 mike 1.2 params, "IncludeQualifiers", true);
419
420 if (message->includeClassOrigin != false)
|
421 kumpf 1.4 XmlWriter::appendBooleanIParameter(
|
422 mike 1.2 params, "IncludeClassOrigin", true);
423
424 if (!message->propertyList.isNull())
|
425 kumpf 1.4 XmlWriter::appendPropertyListIParameter(
|
426 mike 1.2 params, message->propertyList);
427
428 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
429 message->nameSpace, "EnumerateInstances", message->messageId,
430 _authenticator->buildRequestAuthHeader(), params);
431
432 _outputQueue->enqueue(new HTTPMessage(buffer));
433 }
434
435 void CIMOperationRequestEncoder::_encodeDeleteInstanceRequest(
436 CIMDeleteInstanceRequestMessage* message)
437 {
438 Array<Sint8> params;
439
|
440 kumpf 1.4 XmlWriter::appendInstanceNameIParameter(
|
441 mike 1.2 params, "InstanceName", message->instanceName);
442
443 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
444 message->nameSpace, "DeleteInstance", message->messageId,
445 _authenticator->buildRequestAuthHeader(), params);
446
447 _outputQueue->enqueue(new HTTPMessage(buffer));
448 }
449
450 void CIMOperationRequestEncoder::_encodeGetPropertyRequest(
451 CIMGetPropertyRequestMessage* message)
452 {
453 Array<Sint8> params;
454
|
455 kumpf 1.4 XmlWriter::appendInstanceNameIParameter(
|
456 mike 1.2 params, "InstanceName", message->instanceName);
457
|
458 kumpf 1.4 XmlWriter::appendPropertyNameIParameter(
|
459 mike 1.2 params, message->propertyName);
460
461 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
462 message->nameSpace, "GetProperty", message->messageId,
463 _authenticator->buildRequestAuthHeader(), params);
464
465 _outputQueue->enqueue(new HTTPMessage(buffer));
466 }
467
468 void CIMOperationRequestEncoder::_encodeSetPropertyRequest(
469 CIMSetPropertyRequestMessage* message)
470 {
471 Array<Sint8> params;
472
|
473 kumpf 1.4 XmlWriter::appendInstanceNameIParameter(
|
474 mike 1.2 params, "InstanceName", message->instanceName);
475
|
476 kumpf 1.4 XmlWriter::appendPropertyNameIParameter(
|
477 mike 1.2 params, message->propertyName);
478
479 if (!message->newValue.isNull())
|
480 kumpf 1.4 XmlWriter::appendPropertyValueIParameter(
|
481 mike 1.2 params, "NewValue", message->newValue);
482
483 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
484 message->nameSpace, "SetProperty", message->messageId,
485 _authenticator->buildRequestAuthHeader(), params);
486
487 _outputQueue->enqueue(new HTTPMessage(buffer));
488 }
489
490 void CIMOperationRequestEncoder::_encodeSetQualifierRequest(
491 CIMSetQualifierRequestMessage* message)
492 {
493 Array<Sint8> params;
|
494 kumpf 1.4 XmlWriter::appendQualifierDeclarationIParameter(
|
495 mike 1.2 params, "QualifierDeclaration", message->qualifierDeclaration);
496
497 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
498 message->nameSpace, "SetQualifier", message->messageId,
499 _authenticator->buildRequestAuthHeader(), params);
500
501 _outputQueue->enqueue(new HTTPMessage(buffer));
502 }
503
504 void CIMOperationRequestEncoder::_encodeGetQualifierRequest(
505 CIMGetQualifierRequestMessage* message)
506 {
507 Array<Sint8> params;
508
509 if (message->qualifierName.size())
|
510 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
511 mike 1.2 params, "QualifierName", message->qualifierName);
512
513 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
514 message->nameSpace, "GetQualifier", message->messageId,
515 _authenticator->buildRequestAuthHeader(), params);
516
517 _outputQueue->enqueue(new HTTPMessage(buffer));
518 }
519
520 void CIMOperationRequestEncoder::_encodeEnumerateQualifiersRequest(
521 CIMEnumerateQualifiersRequestMessage* message)
522 {
523 Array<Sint8> params;
524
525 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
526 message->nameSpace, "EnumerateQualifiers", message->messageId,
527 _authenticator->buildRequestAuthHeader(), params);
528
529 _outputQueue->enqueue(new HTTPMessage(buffer));
530 }
531
532 mike 1.2 void CIMOperationRequestEncoder::_encodeDeleteQualifierRequest(
533 CIMDeleteQualifierRequestMessage* message)
534 {
535 Array<Sint8> params;
536
537 if (message->qualifierName.size())
|
538 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
539 mike 1.2 params, "QualifierName", message->qualifierName);
540
541 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
542 message->nameSpace, "DeleteQualifier", message->messageId,
543 _authenticator->buildRequestAuthHeader(), params);
544
545 _outputQueue->enqueue(new HTTPMessage(buffer));
546 }
547
548 void CIMOperationRequestEncoder::_encodeReferenceNamesRequest(
549 CIMReferenceNamesRequestMessage* message)
550 {
551 Array<Sint8> params;
552
|
553 kumpf 1.4 XmlWriter::appendObjectNameIParameter(
|
554 mike 1.2 params, "ObjectName", message->objectName);
555
|
556 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
557 mike 1.2 params, "ResultClass", message->resultClass);
558
559 XmlWriter::appendStringIParameter(
560 params, "Role", message->role);
561
562 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
563 message->nameSpace, "ReferenceNames", message->messageId,
564 _authenticator->buildRequestAuthHeader(), params);
565
566 _outputQueue->enqueue(new HTTPMessage(buffer));
567 }
568
569 void CIMOperationRequestEncoder::_encodeReferencesRequest(
570 CIMReferencesRequestMessage* message)
571 {
572 Array<Sint8> params;
573
|
574 kumpf 1.4 XmlWriter::appendObjectNameIParameter(
|
575 mike 1.2 params, "ObjectName", message->objectName);
576
|
577 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
578 mike 1.2 params, "ResultClass", message->resultClass);
579
580 XmlWriter::appendStringIParameter(
581 params, "Role", message->role);
582
583 if (message->includeQualifiers != false)
|
584 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "IncludeQualifiers", true);
|
585 mike 1.2
586 if (message->includeClassOrigin != false)
|
587 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "IncludeClassOrigin", true);
|
588 mike 1.2
589 if (!message->propertyList.isNull())
|
590 kumpf 1.4 XmlWriter::appendPropertyListIParameter(
|
591 mike 1.2 params, message->propertyList);
592
593 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
594 message->nameSpace, "References", message->messageId,
595 _authenticator->buildRequestAuthHeader(), params);
596
597 _outputQueue->enqueue(new HTTPMessage(buffer));
598 }
599
600 void CIMOperationRequestEncoder::_encodeAssociatorNamesRequest(
601 CIMAssociatorNamesRequestMessage* message)
602 {
603 Array<Sint8> params;
604
|
605 kumpf 1.4 XmlWriter::appendObjectNameIParameter(
|
606 mike 1.2 params, "ObjectName", message->objectName);
607
|
608 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
609 mike 1.2 params, "AssocClass", message->assocClass);
610
|
611 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
612 mike 1.2 params, "ResultClass", message->resultClass);
613
614 XmlWriter::appendStringIParameter(
615 params, "Role", message->role);
616
617 XmlWriter::appendStringIParameter(
618 params, "ResultRole", message->resultRole);
619
620 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
621 message->nameSpace, "AssociatorNames", message->messageId,
622 _authenticator->buildRequestAuthHeader(), params);
623
624 _outputQueue->enqueue(new HTTPMessage(buffer));
625 }
626
627 void CIMOperationRequestEncoder::_encodeAssociatorsRequest(
628 CIMAssociatorsRequestMessage* message)
629 {
630 Array<Sint8> params;
631
|
632 kumpf 1.4 XmlWriter::appendObjectNameIParameter(
|
633 mike 1.2 params, "ObjectName", message->objectName);
634
|
635 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
636 mike 1.2 params, "AssocClass", message->assocClass);
637
|
638 kumpf 1.4 XmlWriter::appendClassNameIParameter(
|
639 mike 1.2 params, "ResultClass", message->resultClass);
640
641 XmlWriter::appendStringIParameter(
642 params, "Role", message->role);
643
644 XmlWriter::appendStringIParameter(
645 params, "ResultRole", message->resultRole);
646
647 if (message->includeQualifiers != false)
|
648 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "IncludeQualifiers", true);
|
649 mike 1.2
650 if (message->includeClassOrigin != false)
|
651 kumpf 1.4 XmlWriter::appendBooleanIParameter(params, "IncludeClassOrigin", true);
|
652 mike 1.2
653 if (!message->propertyList.isNull())
|
654 kumpf 1.4 XmlWriter::appendPropertyListIParameter(
|
655 mike 1.2 params, message->propertyList);
656
657 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
658 message->nameSpace, "Associators", message->messageId,
|
659 kumpf 1.9 _authenticator->buildRequestAuthHeader(), params);
660
661 _outputQueue->enqueue(new HTTPMessage(buffer));
662 }
663
664 void CIMOperationRequestEncoder::_encodeExecQueryRequest(
665 CIMExecQueryRequestMessage* message)
666 {
667 Array<Sint8> params;
668
669 XmlWriter::appendStringIParameter(
670 params, "QueryLanguage", message->queryLanguage);
671
672 XmlWriter::appendStringIParameter(
673 params, "Query", message->query);
674
675 Array<Sint8> buffer = XmlWriter::formatSimpleIMethodReqMessage(_hostName,
676 message->nameSpace, "ExecQuery", message->messageId,
|
677 mike 1.2 _authenticator->buildRequestAuthHeader(), params);
678
679 _outputQueue->enqueue(new HTTPMessage(buffer));
680 }
681
682 void CIMOperationRequestEncoder::_encodeInvokeMethodRequest(
683 CIMInvokeMethodRequestMessage* message)
684 {
685 Array<Sint8> buffer = XmlWriter::formatSimpleMethodReqMessage(_hostName,
|
686 kumpf 1.8 message->nameSpace, message->instanceName,
|
687 kumpf 1.7 _CString(message->methodName),
|
688 kumpf 1.6 message->inParameters, message->messageId,
689 _authenticator->buildRequestAuthHeader());
|
690 mike 1.2
691 _outputQueue->enqueue(new HTTPMessage(buffer));
692 }
693
694 PEGASUS_NAMESPACE_END
|
Return to
CIMOperationRequestEncoder.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Client