1 karl 1.100 //%2006////////////////////////////////////////////////////////////////////////
|
2 mike 1.2 //
|
3 karl 1.88 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 karl 1.72 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.88 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.91 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.100 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 mike 1.2 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
|
15 kumpf 1.47 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
18 mike 1.2 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
|
20 karl 1.100 //
|
21 kumpf 1.47 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
|
22 mike 1.2 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
|
24 kumpf 1.47 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
27 mike 1.2 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include <Pegasus/Common/Config.h>
|
35 kumpf 1.28 #include <Pegasus/Common/Constants.h>
|
36 mike 1.2 #include <cctype>
37 #include <cstdio>
38 #include <Pegasus/Common/XmlParser.h>
39 #include <Pegasus/Common/XmlReader.h>
40 #include <Pegasus/Common/XmlWriter.h>
41 #include <Pegasus/Common/XmlConstants.h>
|
42 kumpf 1.51 #include <Pegasus/Common/System.h>
|
43 mike 1.2 #include <Pegasus/Common/Logger.h>
44 #include <Pegasus/Common/Tracer.h>
|
45 sage 1.41 #include <Pegasus/Common/StatisticalData.h>
|
46 mike 1.2 #include "CIMOperationRequestDecoder.h"
|
47 david 1.60 #include <Pegasus/Common/CommonUTF.h>
|
48 humberto 1.59 #include <Pegasus/Common/MessageLoader.h>
49
|
50 mike 1.2 PEGASUS_USING_STD;
51
52 PEGASUS_NAMESPACE_BEGIN
53
54 CIMOperationRequestDecoder::CIMOperationRequestDecoder(
|
55 kumpf 1.104 MessageQueueService* outputQueue,
56 Uint32 returnQueueId)
57 : Base(PEGASUS_QUEUENAME_OPREQDECODER),
|
58 mday 1.16 _outputQueue(outputQueue),
59 _returnQueueId(returnQueueId),
60 _serverTerminating(false)
|
61 mike 1.2 {
62 }
63
64 CIMOperationRequestDecoder::~CIMOperationRequestDecoder()
65 {
66 }
67
68 void CIMOperationRequestDecoder::sendResponse(
|
69 kumpf 1.104 Uint32 queueId,
70 Buffer& message,
71 Boolean closeConnect)
72 {
73 MessageQueue* queue = MessageQueue::lookup(queueId);
74
75 if (queue)
76 {
77 AutoPtr<HTTPMessage> httpMessage(new HTTPMessage(message));
78 httpMessage->setCloseConnect(closeConnect);
79 queue->enqueue(httpMessage.release());
80 }
|
81 mike 1.2 }
82
|
83 kumpf 1.18 void CIMOperationRequestDecoder::sendIMethodError(
|
84 kumpf 1.104 Uint32 queueId,
85 HttpMethod httpMethod,
86 const String& messageId,
87 const String& iMethodName,
88 const CIMException& cimException,
89 Boolean closeConnect)
|
90 mday 1.16 {
|
91 mike 1.96 Buffer message;
|
92 kumpf 1.19 message = XmlWriter::formatSimpleIMethodErrorRspMessage(
93 iMethodName,
94 messageId,
|
95 kumpf 1.53 httpMethod,
|
96 kumpf 1.35 cimException);
|
97 kumpf 1.18
|
98 j.alex 1.95 sendResponse(queueId, message,closeConnect);
|
99 kumpf 1.18 }
|
100 mday 1.16
|
101 kumpf 1.18 void CIMOperationRequestDecoder::sendMethodError(
|
102 kumpf 1.104 Uint32 queueId,
103 HttpMethod httpMethod,
104 const String& messageId,
105 const String& methodName,
106 const CIMException& cimException,
107 Boolean closeConnect)
|
108 kumpf 1.18 {
|
109 mike 1.96 Buffer message;
|
110 kumpf 1.19 message = XmlWriter::formatSimpleMethodErrorRspMessage(
111 methodName,
112 messageId,
|
113 kumpf 1.53 httpMethod,
|
114 kumpf 1.35 cimException);
|
115 chip 1.92
|
116 j.alex 1.95 sendResponse(queueId, message,closeConnect);
|
117 mike 1.2 }
118
|
119 kumpf 1.33 void CIMOperationRequestDecoder::sendHttpError(
|
120 kumpf 1.104 Uint32 queueId,
121 const String& status,
122 const String& cimError,
123 const String& pegasusError,
124 Boolean closeConnect)
|
125 kumpf 1.21 {
|
126 mike 1.96 Buffer message;
|
127 kumpf 1.33 message = XmlWriter::formatHttpErrorRspMessage(
128 status,
129 cimError,
|
130 kumpf 1.37 pegasusError);
|
131 chip 1.92
|
132 j.alex 1.95 sendResponse(queueId, message,closeConnect);
|
133 kumpf 1.26 }
134
|
135 kumpf 1.104 void CIMOperationRequestDecoder::handleEnqueue(Message* message)
|
136 mike 1.2 {
|
137 kumpf 1.104 if (!message)
138 return;
|
139 mike 1.2
|
140 kumpf 1.104 switch (message->getType())
141 {
142 case HTTP_MESSAGE:
143 handleHTTPMessage((HTTPMessage*)message);
144 break;
145 }
|
146 mday 1.16
|
147 kumpf 1.104 delete message;
|
148 mday 1.16 }
|
149 mike 1.2
150
|
151 mday 1.16 void CIMOperationRequestDecoder::handleEnqueue()
152 {
|
153 kumpf 1.104 Message* message = dequeue();
154 if (message)
155 handleEnqueue(message);
|
156 mike 1.2 }
157
158 //------------------------------------------------------------------------------
159 //
160 // From the HTTP/1.1 Specification (RFC 2626):
161 //
|
162 chip 1.92 // Both types of message consist of a start-line, zero or more header fields
163 // (also known as "headers"), an empty line (i.e., a line with nothing
164 // preceding the CRLF) indicating the end of the header fields, and possibly
|
165 mike 1.2 // a message-body.
166 //
167 // Example CIM request:
168 //
|
169 chip 1.92 // M-POST /cimom HTTP/1.1
170 // HOST: www.erewhon.com
171 // Content-Type: application/xml; charset="utf-8"
172 // Content-Length: xxxx
173 // Man: http://www.dmtf.org/cim/operation ; ns=73
174 // 73-CIMOperation: MethodCall
175 // 73-CIMMethod: EnumerateInstances
176 // 73-CIMObject: root/cimv2
177 //
|
178 mike 1.2 //------------------------------------------------------------------------------
179
180 void CIMOperationRequestDecoder::handleHTTPMessage(HTTPMessage* httpMessage)
181 {
|
182 kumpf 1.104 PEG_METHOD_ENTER(TRC_DISPATCHER,
183 "CIMOperationRequestDecoder::handleHTTPMessage()");
|
184 kumpf 1.20
|
185 kumpf 1.104 // Set the Accept-Language into the thread for this service.
186 // This will allow all code in this thread to get
187 // the languages for the messages returned to the client.
188 Thread::setLanguages(new AcceptLanguageList(httpMessage->acceptLanguages));
189
190 // Save queueId:
191
192 Uint32 queueId = httpMessage->queueId;
193
194 // Save userName and authType:
195
196 String userName;
197 String authType;
198 Boolean closeConnect = httpMessage->getCloseConnect();
199
200 PEG_TRACE((
201 TRC_HTTP,
202 Tracer::LEVEL3,
203 "CIMOperationRequestDecoder::handleHTTPMessage()- "
204 "httpMessage->getCloseConnect() returned %d",
205 closeConnect));
206 kumpf 1.104
|
207 sushma.fernandes 1.109 userName = httpMessage->authInfo->getAuthenticatedUser();
208 authType = httpMessage->authInfo->getAuthType();
|
209 kumpf 1.104
210 // Parse the HTTP message:
211
212 String startLine;
213 Array<HTTPHeader> headers;
214 char* content;
215 Uint32 contentLength;
216
217 httpMessage->parse(startLine, headers, contentLength);
218
219 // Parse the request line:
220
221 String methodName;
222 String requestUri;
223 String httpVersion;
224 HttpMethod httpMethod = HTTP_METHOD__POST;
225
226 HTTPMessage::parseRequestLine(
227 startLine, methodName, requestUri, httpVersion);
228
229 //
230 kumpf 1.104 // Set HTTP method for the request
231 //
232 if (methodName == "M-POST")
233 {
234 httpMethod = HTTP_METHOD_M_POST;
235 }
236
237 // Unsupported methods are caught in the HTTPAuthenticatorDelegator
238 PEGASUS_ASSERT(methodName == "M-POST" || methodName == "POST");
239
240 //
241 // Mismatch of method and version is caught in HTTPAuthenticatorDelegator
242 //
243 PEGASUS_ASSERT(!((httpMethod == HTTP_METHOD_M_POST) &&
244 (httpVersion == "HTTP/1.0")));
|
245 humberto 1.80
|
246 kumpf 1.104 // Process M-POST and POST messages:
|
247 humberto 1.80
|
248 kumpf 1.104 String cimContentType;
249 String cimOperation;
250 String cimBatch;
251 Boolean cimBatchFlag;
252 String cimProtocolVersion;
253 String cimMethod;
254 String cimObject;
255
256 if (httpVersion == "HTTP/1.1")
257 {
258 // Validate the presence of a "Host" header. The HTTP/1.1 specification
259 // says this in section 14.23 regarding the Host header field:
260 //
261 // All Internet-based HTTP/1.1 servers MUST respond with a 400 (Bad
262 // Request) status code to any HTTP/1.1 request message which lacks
263 // a Host header field.
264 //
265 // Note: The Host header value is not validated.
266
267 String hostHeader;
268 Boolean hostHeaderFound = HTTPMessage::lookupHeader(
269 kumpf 1.104 headers, "Host", hostHeader, false);
|
270 mike 1.2
|
271 kumpf 1.104 if (!hostHeaderFound)
272 {
273 MessageLoaderParms parms(
274 "Server.CIMOperationRequestDecoder.MISSING_HOST_HEADER",
275 "HTTP request message lacks a Host header field.");
276 sendHttpError(
277 queueId,
278 HTTP_STATUS_BADREQUEST,
279 "",
280 MessageLoader::getMessage(parms),
281 closeConnect);
282 PEG_METHOD_EXIT();
283 return;
284 }
285 }
|
286 mike 1.2
|
287 kumpf 1.104 // Validate the "CIMOperation" header:
|
288 mike 1.2
|
289 kumpf 1.104 Boolean operationHeaderFound = HTTPMessage::lookupHeader(
290 headers, "CIMOperation", cimOperation, true);
291 // If the CIMOperation header was missing, the HTTPAuthenticatorDelegator
292 // would not have passed the message to us.
293 PEGASUS_ASSERT(operationHeaderFound);
294
295 if (!String::equalNoCase(cimOperation, "MethodCall"))
296 {
297 // The Specification for CIM Operations over HTTP reads:
298 // 3.3.4. CIMOperation
299 // If a CIM Server receives CIM Operation request with this
300 // [CIMOperation] header, but with a missing value or a value
301 // that is not "MethodCall", then it MUST fail the request with
302 // status "400 Bad Request". The CIM Server MUST include a
303 // CIMError header in the response with a value of
304 // unsupported-operation.
305 MessageLoaderParms parms(
306 "Server.CIMOperationRequestDecoder."
307 "CIMOPERATION_VALUE_NOT_SUPPORTED",
308 "CIMOperation value \"$0\" is not supported.",cimOperation);
309 sendHttpError(
310 kumpf 1.104 queueId,
311 HTTP_STATUS_BADREQUEST,
312 "unsupported-operation",
313 MessageLoader::getMessage(parms),
314 closeConnect);
315 PEG_METHOD_EXIT();
316 return;
317 }
318
319 // Validate the "CIMBatch" header:
320
321 cimBatchFlag = HTTPMessage::lookupHeader(
322 headers, "CIMBatch", cimBatch, true);
323 if (cimBatchFlag)
324 {
325 // The Specification for CIM Operations over HTTP reads:
326 // 3.3.9. CIMBatch
327 // If a CIM Server receives CIM Operation Request for which the
328 // CIMBatch header is present, but the Server does not support
329 // Multiple Operations, then it MUST fail the request and
330 // return a status of "501 Not Implemented".
331 kumpf 1.104 sendHttpError(
332 queueId,
333 HTTP_STATUS_NOTIMPLEMENTED,
334 "multiple-requests-unsupported",
335 String::EMPTY,
336 closeConnect);
337 PEG_METHOD_EXIT();
338 return;
339 }
340
341 // Save these headers for later checking
342
343 if (!HTTPMessage::lookupHeader(
344 headers, "CIMProtocolVersion", cimProtocolVersion, true))
345 {
346 // Mandated by the Specification for CIM Operations over HTTP
347 cimProtocolVersion.assign("1.0");
348 }
349
350 if (HTTPMessage::lookupHeader(headers, "CIMMethod", cimMethod, true))
351 {
352 kumpf 1.104 if (cimMethod == String::EMPTY)
353 {
354 // This is not a valid value, and we use EMPTY to mean "absent"
355 MessageLoaderParms parms(
356 "Server.CIMOperationRequestDecoder.EMPTY_CIMMETHOD_VALUE",
357 "Empty CIMMethod value.");
358 sendHttpError(
359 queueId,
360 HTTP_STATUS_BADREQUEST,
361 "header-mismatch",
362 MessageLoader::getMessage(parms),
363 closeConnect);
364 PEG_METHOD_EXIT();
365 return;
366 }
|
367 mike 1.98
|
368 kumpf 1.104 try
369 {
370 cimMethod = XmlReader::decodeURICharacters(cimMethod);
371 }
372 catch (const ParseError&)
373 {
374 // The CIMMethod header value could not be decoded
375 MessageLoaderParms parms(
376 "Server.CIMOperationRequestDecoder."
377 "CIMMETHOD_VALUE_SYNTAX_ERROR",
378 "CIMMethod value syntax error.");
379 sendHttpError(
380 queueId,
381 HTTP_STATUS_BADREQUEST,
382 "header-mismatch",
383 MessageLoader::getMessage(parms),
384 closeConnect);
385 PEG_METHOD_EXIT();
386 return;
387 }
388 }
|
389 mike 1.2
|
390 kumpf 1.104 if (HTTPMessage::lookupHeader(headers, "CIMObject", cimObject, true))
391 {
392 if (cimObject == String::EMPTY)
393 {
394 // This is not a valid value, and we use EMPTY to mean "absent"
395 MessageLoaderParms parms(
396 "Server.CIMOperationRequestDecoder.EMPTY_CIMOBJECT_VALUE",
397 "Empty CIMObject value.");
398 sendHttpError(
399 queueId,
400 HTTP_STATUS_BADREQUEST,
401 "header-mismatch",
402 MessageLoader::getMessage(parms),
403 closeConnect);
404 PEG_METHOD_EXIT();
405 return;
406 }
|
407 mike 1.2
|
408 kumpf 1.104 try
409 {
410 cimObject = XmlReader::decodeURICharacters(cimObject);
411 }
412 catch (const ParseError&)
413 {
414 // The CIMObject header value could not be decoded
415 MessageLoaderParms parms(
416 "Server.CIMOperationRequestDecoder."
417 "CIMOBJECT_VALUE_SYNTAX_ERROR",
418 "CIMObject value syntax error.");
419 sendHttpError(
420 queueId,
421 HTTP_STATUS_BADREQUEST,
422 "header-mismatch",
423 MessageLoader::getMessage(parms),
424 closeConnect);
425 PEG_METHOD_EXIT();
426 return;
427 }
428 }
|
429 mike 1.2
|
430 kumpf 1.104 // Calculate the beginning of the content from the message size and
|
431 kumpf 1.110 // the content length.
|
432 mike 1.2
|
433 kumpf 1.104 content = (char*) httpMessage->message.getData() +
|
434 kumpf 1.110 httpMessage->message.size() - contentLength;
|
435 mike 1.2
|
436 kumpf 1.104 // Validate the "Content-Type" header:
|
437 mike 1.2
|
438 kumpf 1.104 Boolean contentTypeHeaderFound = HTTPMessage::lookupHeader(
439 headers, "Content-Type", cimContentType, true);
|
440 venkat.puvvada 1.111 if (!contentTypeHeaderFound ||
441 !HTTPMessage::isSupportedContentType (cimContentType))
|
442 kumpf 1.104 {
|
443 j.alex 1.95 MessageLoaderParms parms(
|
444 kumpf 1.104 "Server.CIMOperationRequestDecoder.CIMCONTENTTYPE_SYNTAX_ERROR",
|
445 kumpf 1.105 "HTTP Content-Type header error.");
|
446 j.alex 1.95 sendHttpError(
447 queueId,
448 HTTP_STATUS_BADREQUEST,
|
449 kumpf 1.105 "",
|
450 j.alex 1.95 MessageLoader::getMessage(parms),
451 closeConnect);
|
452 kumpf 1.104 PEG_METHOD_EXIT();
453 return;
454 }
455 // Validating content falls within UTF8
456 // (required to be complaint with section C12 of Unicode 4.0 spec,
457 // chapter 3.)
458 else
459 {
460 Uint32 count = 0;
461 while(count<contentLength)
462 {
463 if (!(isUTF8((char*)&content[count])))
464 {
465 MessageLoaderParms parms(
466 "Server.CIMOperationRequestDecoder.INVALID_UTF8_CHARACTER",
467 "Invalid UTF-8 character detected.");
468 sendHttpError(
469 queueId,
470 HTTP_STATUS_BADREQUEST,
471 "request-not-valid",
472 MessageLoader::getMessage(parms),
473 kumpf 1.104 closeConnect);
474
475 PEG_METHOD_EXIT();
476 return;
477 }
478 UTF8_NEXT(content,count);
479 }
480 }
481
482 // If it is a method call, then dispatch it to be handled:
483
484 handleMethodCall(
485 queueId,
486 httpMethod,
487 content,
488 contentLength,
489 cimProtocolVersion,
490 cimMethod,
491 cimObject,
492 authType,
493 userName,
494 kumpf 1.104 httpMessage->ipAddress,
495 httpMessage->acceptLanguages,
496 httpMessage->contentLanguages,
497 closeConnect);
498
499 PEG_METHOD_EXIT();
500 }
501
502 void CIMOperationRequestDecoder::handleMethodCall(
503 Uint32 queueId,
504 HttpMethod httpMethod,
505 char* content,
506 Uint32 contentLength, // used for statistics only
507 const String& cimProtocolVersionInHeader,
508 const String& cimMethodInHeader,
509 const String& cimObjectInHeader,
510 const String& authType,
511 const String& userName,
512 const String& ipAddress,
513 const AcceptLanguageList& httpAcceptLanguages,
514 const ContentLanguageList& httpContentLanguages,
515 kumpf 1.104 Boolean closeConnect)
516 {
517 PEG_METHOD_ENTER(TRC_DISPATCHER,
518 "CIMOperationRequestDecoder::handleMethodCall()");
519
520 //
521 // If CIMOM is shutting down, return "Service Unavailable" response
522 //
523 if (_serverTerminating)
524 {
|
525 j.alex 1.95 MessageLoaderParms parms(
|
526 kumpf 1.104 "Server.CIMOperationRequestDecoder.CIMSERVER_SHUTTING_DOWN",
527 "CIM Server is shutting down.");
|
528 j.alex 1.95 sendHttpError(
529 queueId,
|
530 kumpf 1.104 HTTP_STATUS_SERVICEUNAVAILABLE,
531 String::EMPTY,
|
532 j.alex 1.95 MessageLoader::getMessage(parms),
533 closeConnect);
|
534 kumpf 1.104 PEG_METHOD_EXIT();
535 return;
536 }
537
538 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
539 "CIMOperationRequestdecoder - XML content: $0", content));
540
541 // Create a parser:
542
543 XmlParser parser(content);
544 XmlEntry entry;
545 String messageId;
546 const char* cimMethodName = "";
547 AutoPtr<CIMOperationRequestMessage> request;
548
549 try
550 {
551 //
552 // Process <?xml ... >
553 //
554
555 kumpf 1.104 // These values are currently unused
556 const char* xmlVersion = 0;
557 const char* xmlEncoding = 0;
|
558 mike 1.2
|
559 kumpf 1.104 XmlReader::getXmlDeclaration(parser, xmlVersion, xmlEncoding);
|
560 mike 1.2
|
561 kumpf 1.104 // Expect <CIM ...>
|
562 chip 1.92
|
563 kumpf 1.104 const char* cimVersion = 0;
564 const char* dtdVersion = 0;
|
565 mike 1.2
|
566 kumpf 1.104 XmlReader::getCimStartTag(parser, cimVersion, dtdVersion);
|
567 mike 1.2
|
568 karl 1.108 if (!XmlReader::isSupportedCIMVersion(cimVersion))
|
569 kumpf 1.104 {
570 MessageLoaderParms parms(
571 "Server.CIMOperationRequestDecoder.CIM_VERSION_NOT_SUPPORTED",
572 "CIM version \"$0\" is not supported.",
573 cimVersion);
574 sendHttpError(
575 queueId,
576 HTTP_STATUS_NOTIMPLEMENTED,
577 "unsupported-cim-version",
578 MessageLoader::getMessage(parms),
579 closeConnect);
|
580 kumpf 1.23 PEG_METHOD_EXIT();
581 return;
|
582 kumpf 1.104 }
|
583 kumpf 1.23
|
584 karl 1.108 if (!XmlReader::isSupportedDTDVersion(dtdVersion))
|
585 kumpf 1.104 {
586 MessageLoaderParms parms(
587 "Server.CIMOperationRequestDecoder.DTD_VERSION_NOT_SUPPORTED",
588 "DTD version \"$0\" is not supported.",
589 dtdVersion);
590 sendHttpError(
|
591 j.alex 1.95 queueId,
|
592 kumpf 1.104 HTTP_STATUS_NOTIMPLEMENTED,
593 "unsupported-dtd-version",
594 MessageLoader::getMessage(parms),
|
595 j.alex 1.95 closeConnect);
|
596 kumpf 1.20 PEG_METHOD_EXIT();
|
597 kumpf 1.34 return;
|
598 kumpf 1.104 }
599
600 // Expect <MESSAGE ...>
601
602 String protocolVersion;
|
603 kumpf 1.73
|
604 kumpf 1.104 if (!XmlReader::getMessageStartTag(
605 parser, messageId, protocolVersion))
606 {
607 MessageLoaderParms mlParms(
608 "Server.CIMOperationRequestDecoder.EXPECTED_MESSAGE_ELEMENT",
609 "expected MESSAGE element");
|
610 mday 1.16
|
611 kumpf 1.104 throw XmlValidationError(parser.getLine(), mlParms);
612 }
|
613 mday 1.16
|
614 kumpf 1.104 // Validate that the protocol version in the header matches the XML
615 if (!String::equalNoCase(protocolVersion, cimProtocolVersionInHeader))
616 {
|
617 j.alex 1.95 MessageLoaderParms parms(
|
618 kumpf 1.104 "Server.CIMOperationRequestDecoder."
619 "CIMPROTOCOL_VERSION_MISMATCH",
620 "CIMProtocolVersion value \"$0\" does not match CIM request "
621 "protocol version \"$1\".",
622 cimProtocolVersionInHeader,
623 protocolVersion);
|
624 j.alex 1.95 sendHttpError(
625 queueId,
626 HTTP_STATUS_BADREQUEST,
627 "header-mismatch",
628 MessageLoader::getMessage(parms),
629 closeConnect);
|
630 kumpf 1.39 PEG_METHOD_EXIT();
631 return;
|
632 kumpf 1.104 }
|
633 kumpf 1.39
|
634 karl 1.108 // Accept protocol version 1.x (see Bugzilla 1556)
635 if (!XmlReader::isSupportedProtocolVersion(protocolVersion))
|
636 kumpf 1.104 {
637 // See Specification for CIM Operations over HTTP section 4.3
|
638 j.alex 1.95 MessageLoaderParms parms(
|
639 kumpf 1.104 "Server.CIMOperationRequestDecoder."
640 "CIMPROTOCOL_VERSION_NOT_SUPPORTED",
641 "CIMProtocolVersion \"$0\" is not supported.",
642 protocolVersion);
|
643 j.alex 1.95 sendHttpError(
644 queueId,
|
645 kumpf 1.104 HTTP_STATUS_NOTIMPLEMENTED,
646 "unsupported-protocol-version",
|
647 j.alex 1.95 MessageLoader::getMessage(parms),
648 closeConnect);
|
649 kumpf 1.23 PEG_METHOD_EXIT();
650 return;
|
651 kumpf 1.104 }
|
652 kumpf 1.23
|
653 kumpf 1.104 if (XmlReader::testStartTag(parser, entry, "MULTIREQ"))
654 {
655 // We wouldn't have gotten here if CIMBatch header was specified,
656 // so this must be indicative of a header mismatch
|
657 j.alex 1.95 MessageLoaderParms parms(
|
658 kumpf 1.104 "Server.CIMOperationRequestDecoder."
659 "MULTI_REQUEST_MISSING_CIMBATCH_HTTP_HEADER",
660 "Multi-request is missing CIMBatch HTTP header");
|
661 j.alex 1.95 sendHttpError(
662 queueId,
663 HTTP_STATUS_BADREQUEST,
664 "header-mismatch",
665 MessageLoader::getMessage(parms),
666 closeConnect);
|
667 kumpf 1.23 PEG_METHOD_EXIT();
668 return;
|
669 kumpf 1.104 // Future: When MULTIREQ is supported, must ensure CIMMethod and
670 // CIMObject headers are absent, and CIMBatch header is present.
671 }
672
673 // Expect <SIMPLEREQ ...>
674
675 XmlReader::expectStartTag(parser, entry, "SIMPLEREQ");
676
677 // Check for <IMETHODCALL ...>
678
679 if (XmlReader::getIMethodCallStartTag(parser, cimMethodName))
680 {
681 // The Specification for CIM Operations over HTTP reads:
682 // 3.3.6. CIMMethod
683 //
684 // This header MUST be present in any CIM Operation Request
685 // message that contains a Simple Operation Request.
686 //
687 // It MUST NOT be present in any CIM Operation Response message,
688 // nor in any CIM Operation Request message that is not a
689 // Simple Operation Request.
690 kumpf 1.104 //
691 // The name of the CIM method within a Simple Operation Request
692 // is defined to be the value of the NAME attribute of the
693 // <METHODCALL> or <IMETHODCALL> element.
694 //
695 // If a CIM Server receives a CIM Operation Request for which
696 // either:
697 //
698 // - The CIMMethod header is present but has an invalid value,
699 // or;
700 // - The CIMMethod header is not present but the Operation
701 // Request Message is a Simple Operation Request, or;
702 // - The CIMMethod header is present but the Operation Request
703 // Message is not a Simple Operation Request, or;
704 // - The CIMMethod header is present, the Operation Request
705 // Message is a Simple Operation Request, but the
706 // CIMIdentifier value (when unencoded) does not match the
707 // unique method name within the Simple Operation Request,
708 //
709 // then it MUST fail the request and return a status of
710 // "400 Bad Request" (and MUST include a CIMError header in the
711 kumpf 1.104 // response with a value of header-mismatch), subject to the
712 // considerations specified in Errors.
713 if (!String::equalNoCase(cimMethodName, cimMethodInHeader))
714 {
715 // ATTN-RK-P3-20020304: How to decode cimMethodInHeader?
716 if (cimMethodInHeader == String::EMPTY)
717 {
718 MessageLoaderParms parms(
719 "Server.CIMOperationRequestDecoder."
720 "MISSING_CIMMETHOD_HTTP_HEADER",
721 "Missing CIMMethod HTTP header.");
722 sendHttpError(
723 queueId,
724 HTTP_STATUS_BADREQUEST,
725 "header-mismatch",
726 MessageLoader::getMessage(parms),
727 closeConnect);
728 }
729 else
730 {
731 MessageLoaderParms parms(
732 kumpf 1.104 "Server.CIMOperationRequestDecoder."
733 "CIMMETHOD_VALUE_DOES_NOT_MATCH_REQUEST_METHOD",
734 "CIMMethod value \"$0\" does not match CIM request "
735 "method \"$1\".",
736 cimMethodInHeader,
737 cimMethodName);
738 sendHttpError(
739 queueId,
740 HTTP_STATUS_BADREQUEST,
741 "header-mismatch",
742 MessageLoader::getMessage(parms),
743 closeConnect);
744 }
745 PEG_METHOD_EXIT();
746 return;
747 }
|
748 kumpf 1.23
|
749 kumpf 1.104 // Expect <LOCALNAMESPACEPATH ...>
750
751 String nameSpace;
752
753 if (!XmlReader::getLocalNameSpacePathElement(parser, nameSpace))
754 {
755 MessageLoaderParms mlParms(
756 "Server.CIMOperationRequestDecoder."
757 "EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
758 "expected LOCALNAMESPACEPATH element");
759 throw XmlValidationError(parser.getLine(), mlParms);
760 }
761
762 // The Specification for CIM Operations over HTTP reads:
763 // 3.3.7. CIMObject
764 //
765 // This header MUST be present in any CIM Operation Request
766 // message that contains a Simple Operation Request.
767 //
768 // It MUST NOT be present in any CIM Operation Response message,
769 // nor in any CIM Operation Request message that is not a
770 kumpf 1.104 // Simple Operation Request.
771 //
772 // The header identifies the CIM object (which MUST be a Class
773 // or Instance for an extrinsic method, or a Namespace for an
774 // intrinsic method) on which the method is to be invoked, using
775 // a CIM object path encoded in an HTTP-safe representation.
776 //
777 // If a CIM Server receives a CIM Operation Request for which
778 // either:
779 //
780 // - The CIMObject header is present but has an invalid value,
781 // or;
782 // - The CIMObject header is not present but the Operation
783 // Request Message is a Simple Operation Request, or;
784 // - The CIMObject header is present but the Operation Request
785 // Message is not a Simple Operation Request, or;
786 // - The CIMObject header is present, the Operation Request
787 // Message is a Simple Operation Request, but the ObjectPath
788 // value does not match (where match is defined in the section
789 // section on Encoding CIM Object Paths) the Operation Request
790 // Message,
791 kumpf 1.104 //
792 // then it MUST fail the request and return a status of
793 // "400 Bad Request" (and MUST include a CIMError header in the
794 // response with a value of header-mismatch), subject to the
795 // considerations specified in Errors.
796 if (!String::equalNoCase(nameSpace, cimObjectInHeader))
797 {
798 if (cimObjectInHeader == String::EMPTY)
799 {
800 MessageLoaderParms parms(
801 "Server.CIMOperationRequestDecoder."
802 "MISSING_CIMOBJECT_HTTP_HEADER",
803 "Missing CIMObject HTTP header.");
804 sendHttpError(
805 queueId,
806 HTTP_STATUS_BADREQUEST,
807 "header-mismatch",
808 MessageLoader::getMessage(parms),
809 closeConnect);
810 }
811 else
812 kumpf 1.104 {
813 MessageLoaderParms parms(
814 "Server.CIMOperationRequestDecoder."
815 "CIMOBJECT_VALUE_DOES_NOT_MATCH_REQUEST_OBJECT:",
816 "CIMObject value \"$0\" does not match CIM request "
817 "object \"$1\".",
818 cimObjectInHeader,
819 nameSpace);
820 sendHttpError(
821 queueId,
822 HTTP_STATUS_BADREQUEST,
823 "header-mismatch",
824 MessageLoader::getMessage(parms),
825 closeConnect);
826 }
827 PEG_METHOD_EXIT();
828 return;
829 }
830
831 // This try block only catches CIMExceptions, because they must be
832 // responded to with a proper IMETHODRESPONSE. Other exceptions are
833 kumpf 1.104 // caught in the outer try block.
834 try
835 {
836 // Delegate to appropriate method to handle:
837
838 if (System::strcasecmp(cimMethodName, "GetClass") == 0)
839 request.reset(decodeGetClassRequest(
840 queueId, parser, messageId, nameSpace));
841 else if (System::strcasecmp(cimMethodName, "GetInstance") == 0)
842 request.reset(decodeGetInstanceRequest(
843 queueId, parser, messageId, nameSpace));
844 else if (System::strcasecmp(
845 cimMethodName, "EnumerateClassNames") == 0)
846 request.reset(decodeEnumerateClassNamesRequest(
847 queueId, parser, messageId, nameSpace));
848 else if (System::strcasecmp(cimMethodName, "References") == 0)
849 request.reset(decodeReferencesRequest(
850 queueId, parser, messageId, nameSpace));
851 else if (System::strcasecmp(
852 cimMethodName, "ReferenceNames") == 0)
853 request.reset(decodeReferenceNamesRequest(
854 kumpf 1.104 queueId, parser, messageId, nameSpace));
855 else if (System::strcasecmp(
856 cimMethodName, "AssociatorNames") == 0)
857 request.reset(decodeAssociatorNamesRequest(
858 queueId, parser, messageId, nameSpace));
859 else if (System::strcasecmp(cimMethodName, "Associators") == 0)
860 request.reset(decodeAssociatorsRequest(
861 queueId, parser, messageId, nameSpace));
862 else if (System::strcasecmp(
863 cimMethodName, "CreateInstance") == 0)
864 request.reset(decodeCreateInstanceRequest(
865 queueId, parser, messageId, nameSpace));
866 else if (System::strcasecmp(
867 cimMethodName, "EnumerateInstanceNames")==0)
868 request.reset(decodeEnumerateInstanceNamesRequest(
869 queueId, parser, messageId, nameSpace));
870 else if (System::strcasecmp(
871 cimMethodName, "DeleteQualifier") == 0)
872 request.reset(decodeDeleteQualifierRequest(
873 queueId, parser, messageId, nameSpace));
874 else if (System::strcasecmp(cimMethodName, "GetQualifier") == 0)
875 kumpf 1.104 request.reset(decodeGetQualifierRequest(
876 queueId, parser, messageId, nameSpace));
877 else if (System::strcasecmp(cimMethodName, "SetQualifier") == 0)
878 request.reset(decodeSetQualifierRequest(
879 queueId, parser, messageId, nameSpace));
880 else if (System::strcasecmp(
881 cimMethodName, "EnumerateQualifiers") == 0)
882 request.reset(decodeEnumerateQualifiersRequest(
883 queueId, parser, messageId, nameSpace));
884 else if (System::strcasecmp(
885 cimMethodName, "EnumerateClasses") == 0)
886 request.reset(decodeEnumerateClassesRequest(
887 queueId, parser, messageId, nameSpace));
888 else if (System::strcasecmp(
889 cimMethodName, "EnumerateInstances") == 0)
890 request.reset(decodeEnumerateInstancesRequest(
891 queueId, parser, messageId, nameSpace));
892 else if (System::strcasecmp(cimMethodName, "CreateClass") == 0)
893 request.reset(decodeCreateClassRequest(
894 queueId, parser, messageId, nameSpace));
895 else if (System::strcasecmp(cimMethodName, "ModifyClass") == 0)
896 kumpf 1.104 request.reset(decodeModifyClassRequest(
897 queueId, parser, messageId, nameSpace));
898 else if (System::strcasecmp(
899 cimMethodName, "ModifyInstance") == 0)
900 request.reset(decodeModifyInstanceRequest(
901 queueId, parser, messageId, nameSpace));
902 else if (System::strcasecmp(cimMethodName, "DeleteClass") == 0)
903 request.reset(decodeDeleteClassRequest(
904 queueId, parser, messageId, nameSpace));
905 else if (System::strcasecmp(
906 cimMethodName, "DeleteInstance") == 0)
907 request.reset(decodeDeleteInstanceRequest(
908 queueId, parser, messageId, nameSpace));
909 else if (System::strcasecmp(cimMethodName, "GetProperty") == 0)
910 request.reset(decodeGetPropertyRequest(
911 queueId, parser, messageId, nameSpace));
912 else if (System::strcasecmp(cimMethodName, "SetProperty") == 0)
913 request.reset(decodeSetPropertyRequest(
914 queueId, parser, messageId, nameSpace));
915 else if (System::strcasecmp(cimMethodName, "ExecQuery") == 0)
916 request.reset(decodeExecQueryRequest(
917 kumpf 1.104 queueId, parser, messageId, nameSpace));
918 else
919 {
920 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
921 MessageLoaderParms(
922 "Server.CIMOperationRequestDecoder."
923 "UNRECOGNIZED_INTRINSIC_METHOD",
924 "Unrecognized intrinsic method: $0",
925 cimMethodName));
926 }
927 }
928 catch (CIMException& e)
929 {
930 sendIMethodError(
931 queueId,
932 httpMethod,
933 messageId,
934 cimMethodName,
935 e,
936 closeConnect);
937
938 kumpf 1.104 PEG_METHOD_EXIT();
939 return;
940 }
941 catch (XmlException&)
942 {
943 // XmlExceptions are handled below
944 throw;
945 }
946 catch (Exception& e)
947 {
948 // Caught an unexpected exception from decoding. Since we must
949 // have had a problem reconstructing a CIM object, we'll treat
950 // it as an invalid parameter
951 sendIMethodError(
952 queueId,
953 httpMethod,
954 messageId,
955 cimMethodName,
956 PEGASUS_CIM_EXCEPTION(
957 CIM_ERR_INVALID_PARAMETER, e.getMessage()),
958 closeConnect);
959 kumpf 1.104
960 PEG_METHOD_EXIT();
961 return;
962 }
963
964 // Expect </IMETHODCALL>
965
966 XmlReader::expectEndTag(parser, "IMETHODCALL");
967 }
968 // Expect <METHODCALL ...>
969 else if (XmlReader::getMethodCallStartTag(parser, cimMethodName))
970 {
971 CIMObjectPath reference;
972
973 // The Specification for CIM Operations over HTTP reads:
974 // 3.3.6. CIMMethod
975 //
976 // This header MUST be present in any CIM Operation Request
977 // message that contains a Simple Operation Request.
978 //
979 // It MUST NOT be present in any CIM Operation Response message,
980 kumpf 1.104 // nor in any CIM Operation Request message that is not a
981 // Simple Operation Request.
982 //
983 // The name of the CIM method within a Simple Operation Request
984 // is defined to be the value of the NAME attribute of the
985 // <METHODCALL> or <IMETHODCALL> element.
986 //
987 // If a CIM Server receives a CIM Operation Request for which
988 // either:
989 //
990 // - The CIMMethod header is present but has an invalid value,
991 // or;
992 // - The CIMMethod header is not present but the Operation
993 // Request Message is a Simple Operation Request, or;
994 // - The CIMMethod header is present but the Operation Request
995 // Message is not a Simple Operation Request, or;
996 // - The CIMMethod header is present, the Operation Request
997 // Message is a Simple Operation Request, but the
998 // CIMIdentifier value (when unencoded) does not match the
999 // unique method name within the Simple Operation Request,
1000 //
1001 kumpf 1.104 // then it MUST fail the request and return a status of
1002 // "400 Bad Request" (and MUST include a CIMError header in the
1003 // response with a value of header-mismatch), subject to the
1004 // considerations specified in Errors.
1005
1006 // Extrinic methods can have UTF-8!
1007 String cimMethodNameUTF16(cimMethodName);
1008 if (cimMethodNameUTF16 != cimMethodInHeader)
1009 {
1010 // ATTN-RK-P3-20020304: How to decode cimMethodInHeader?
1011 if (cimMethodInHeader == String::EMPTY)
1012 {
1013 MessageLoaderParms parms(
1014 "Server.CIMOperationRequestDecoder."
1015 "MISSING_CIMMETHOD_HTTP_HEADER",
1016 "Missing CIMMethod HTTP header.");
1017 sendHttpError(
1018 queueId,
1019 HTTP_STATUS_BADREQUEST,
1020 "header-mismatch",
1021 MessageLoader::getMessage(parms),
1022 kumpf 1.104 closeConnect);
1023 }
1024 else
1025 {
1026 MessageLoaderParms parms(
1027 "Server.CIMOperationRequestDecoder."
1028 "CIMMETHOD_VALUE_DOES_NOT_MATCH_REQUEST_METHOD",
1029 "CIMMethod value \"$0\" does not match CIM request "
1030 "method \"$1\".",
1031 (const char*)cimMethodInHeader.getCString(),
1032 cimMethodName);
1033 sendHttpError(
1034 queueId,
1035 HTTP_STATUS_BADREQUEST,
1036 "header-mismatch",
1037 MessageLoader::getMessage(parms),
1038 closeConnect);
1039 }
1040 PEG_METHOD_EXIT();
1041 return;
1042 }
1043 kumpf 1.104
1044 //
1045 // Check for <LOCALINSTANCEPATHELEMENT> or <LOCALCLASSPATHELEMENT>
1046 //
1047 if (!(XmlReader::getLocalInstancePathElement(parser, reference) ||
1048 XmlReader::getLocalClassPathElement(parser, reference)))
1049 {
1050 MessageLoaderParms parms(
1051 "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
1052 MISSING_ELEMENT_LOCALPATH);
1053 // this throw is not updated with MLP because
1054 // MISSING_ELEMENT_LOCALPATH is a hardcoded variable,
1055 // not a message
1056 throw XmlValidationError(parser.getLine(), parms);
1057 }
1058
1059 // The Specification for CIM Operations over HTTP reads:
1060 // 3.3.7. CIMObject
1061 //
1062 // This header MUST be present in any CIM Operation Request
1063 // message that contains a Simple Operation Request.
1064 kumpf 1.104 //
1065 // It MUST NOT be present in any CIM Operation Response message,
1066 // nor in any CIM Operation Request message that is not a
1067 // Simple Operation Request.
1068 //
1069 // The header identifies the CIM object (which MUST be a Class
1070 // or Instance for an extrinsic method, or a Namespace for an
1071 // intrinsic method) on which the method is to be invoked, using
1072 // a CIM object path encoded in an HTTP-safe representation.
1073 //
1074 // If a CIM Server receives a CIM Operation Request for which
1075 // either:
1076 //
1077 // - The CIMObject header is present but has an invalid value,
1078 // or;
1079 // - The CIMObject header is not present but the Operation
1080 // Request Message is a Simple Operation Request, or;
1081 // - The CIMObject header is present but the Operation Request
1082 // Message is not a Simple Operation Request, or;
1083 // - The CIMObject header is present, the Operation Request
1084 // Message is a Simple Operation Request, but the ObjectPath
1085 kumpf 1.104 // value does not match (where match is defined in the section
1086 // section on Encoding CIM Object Paths) the Operation Request
1087 // Message,
1088 //
1089 // then it MUST fail the request and return a status of
1090 // "400 Bad Request" (and MUST include a CIMError header in the
1091 // response with a value of header-mismatch), subject to the
1092 // considerations specified in Errors.
1093 if (cimObjectInHeader == String::EMPTY)
1094 {
1095 MessageLoaderParms parms(
1096 "Server.CIMOperationRequestDecoder."
1097 "MISSING_CIMOBJECT_HTTP_HEADER",
1098 "Missing CIMObject HTTP header.");
1099 sendHttpError(
1100 queueId,
1101 HTTP_STATUS_BADREQUEST,
1102 "header-mismatch",
1103 MessageLoader::getMessage(parms),
1104 closeConnect);
1105 PEG_METHOD_EXIT();
1106 kumpf 1.104 return;
1107 }
1108
1109 CIMObjectPath headerObjectReference;
1110 try
1111 {
1112 headerObjectReference.set(cimObjectInHeader);
1113 }
1114 catch (Exception&)
1115 {
1116 MessageLoaderParms parms(
1117 "Server.CIMOperationRequestDecoder."
1118 "COULD_NOT_PARSE_CIMOBJECT_VALUE",
1119 "Could not parse CIMObject value \"$0\".",
1120 cimObjectInHeader);
1121 sendHttpError(
1122 queueId,
1123 HTTP_STATUS_BADREQUEST,
1124 "header-mismatch",
1125 MessageLoader::getMessage(parms),
1126 closeConnect);
1127 kumpf 1.104 PEG_METHOD_EXIT();
1128 return;
1129 }
1130
1131 if (!reference.identical(headerObjectReference))
1132 {
1133 MessageLoaderParms parms(
1134 "Server.CIMOperationRequestDecoder."
1135 "CIMOBJECT_VALUE_DOES_NOT_MATCH_REQUEST_OBJECT:",
1136 "CIMObject value \"$0\" does not match CIM request "
1137 "object \"$1\".",
1138 cimObjectInHeader,
1139 reference.toString());
1140 sendHttpError(
1141 queueId,
1142 HTTP_STATUS_BADREQUEST,
1143 "header-mismatch",
1144 MessageLoader::getMessage(parms),
1145 closeConnect);
1146 PEG_METHOD_EXIT();
1147 return;
1148 kumpf 1.104 }
1149
1150 // This try block only catches CIMExceptions, because they must be
1151 // responded to with a proper METHODRESPONSE. Other exceptions are
1152 // caught in the outer try block.
1153 try
1154 {
1155 // Delegate to appropriate method to handle:
1156
1157 request.reset(decodeInvokeMethodRequest(
1158 queueId,
1159 parser,
1160 messageId,
1161 reference,
1162 cimMethodNameUTF16)); // contains UTF-16 converted from UTF-8
1163 }
1164 catch (CIMException& e)
1165 {
1166 sendMethodError(
1167 queueId,
1168 httpMethod,
1169 kumpf 1.104 messageId,
1170 cimMethodNameUTF16, // contains UTF-16 converted from UTF-8
1171 e,
1172 closeConnect);
1173
1174 PEG_METHOD_EXIT();
1175 return;
1176 }
1177 catch (XmlException&)
1178 {
1179 // XmlExceptions are handled below
1180 throw;
1181 }
1182 catch (Exception& e)
1183 {
1184 // Caught an unexpected exception from decoding. Since we must
1185 // have had a problem reconstructing a CIM object, we'll treata
1186 // it as an invalid parameter
1187 sendMethodError(
1188 queueId,
1189 httpMethod,
1190 kumpf 1.104 messageId,
1191 cimMethodNameUTF16, // contains UTF-16 converted from UTF-8
1192 PEGASUS_CIM_EXCEPTION(
1193 CIM_ERR_INVALID_PARAMETER, e.getMessage()),
1194 closeConnect);
1195
1196 PEG_METHOD_EXIT();
1197 return;
1198 }
|
1199 kumpf 1.73
|
1200 kumpf 1.104 // Expect </METHODCALL>
|
1201 mday 1.16
|
1202 kumpf 1.104 XmlReader::expectEndTag(parser, "METHODCALL");
1203 }
1204 else
1205 {
1206 MessageLoaderParms mlParms(
1207 "Server.CIMOperationRequestDecoder.EXPECTED_IMETHODCALL_ELEMENT",
1208 "expected IMETHODCALL or METHODCALL element");
1209 throw XmlValidationError(parser.getLine(),mlParms);
1210 }
1211
1212 // Expect </SIMPLEREQ>
1213
1214 XmlReader::expectEndTag(parser, "SIMPLEREQ");
1215
1216 // Expect </MESSAGE>
1217
1218 XmlReader::expectEndTag(parser, "MESSAGE");
1219
1220 // Expect </CIM>
1221
1222 XmlReader::expectEndTag(parser, "CIM");
1223 kumpf 1.104 }
1224 catch (XmlValidationError& e)
1225 {
1226 Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::TRACE,
1227 "CIMOperationRequestDecoder::handleMethodCall - "
1228 "XmlValidationError exception has occurred. Message: $0",
1229 e.getMessage());
|
1230 kumpf 1.24
|
1231 kumpf 1.104 sendHttpError(
1232 queueId,
1233 HTTP_STATUS_BADREQUEST,
1234 "request-not-valid",
1235 e.getMessage(),
1236 closeConnect);
1237 PEG_METHOD_EXIT();
1238 return;
1239 }
1240 catch (XmlSemanticError& e)
1241 {
1242 Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::TRACE,
1243 "CIMOperationRequestDecoder::handleMethodCall - "
1244 "XmlSemanticError exception has occurred. Message: $0",
1245 e.getMessage());
|
1246 mday 1.16
|
1247 kumpf 1.104 // ATTN-RK-P2-20020404: Is this the correct response for these errors?
1248 sendHttpError(
1249 queueId,
1250 HTTP_STATUS_BADREQUEST,
1251 "request-not-valid",
1252 e.getMessage(),
1253 closeConnect);
1254 PEG_METHOD_EXIT();
1255 return;
1256 }
1257 catch (XmlException& e)
1258 {
1259 Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::TRACE,
1260 "CIMOperationRequestDecoder::handleMethodCall - "
1261 "XmlException has occurred. Message: $0",
1262 e.getMessage());
1263
1264 sendHttpError(
1265 queueId,
1266 HTTP_STATUS_BADREQUEST,
1267 "request-not-well-formed",
1268 kumpf 1.104 e.getMessage(),
1269 closeConnect);
1270 PEG_METHOD_EXIT();
1271 return;
1272 }
1273 catch (Exception& e)
1274 {
1275 // Don't know why I got this exception. Seems like a bad thing.
1276 // Any exceptions we're expecting should be caught separately and
1277 // dealt with appropriately. This is a last resort.
1278 sendHttpError(
1279 queueId,
1280 HTTP_STATUS_INTERNALSERVERERROR,
1281 String::EMPTY,
1282 e.getMessage(),
1283 closeConnect);
1284 PEG_METHOD_EXIT();
1285 return;
1286 }
1287 catch (...)
1288 {
1289 kumpf 1.104 // Don't know why I got whatever this is. Seems like a bad thing.
1290 // Any exceptions we're expecting should be caught separately and
1291 // dealt with appropriately. This is a last resort.
1292 sendHttpError(
1293 queueId,
1294 HTTP_STATUS_INTERNALSERVERERROR,
1295 String::EMPTY,
1296 String::EMPTY,
1297 closeConnect);
1298 PEG_METHOD_EXIT();
1299 return;
1300 }
1301
1302 STAT_BYTESREAD
1303
1304 request->authType = authType;
1305 request->userName = userName;
1306 request->ipAddress = ipAddress;
1307 request->setHttpMethod (httpMethod);
|
1308 sage 1.41
|
1309 chuck 1.58 //l10n start
1310 // l10n TODO - might want to move A-L and C-L to Message
1311 // to make this more maintainable
|
1312 kumpf 1.104 // Add the language headers to the request
1313 CIMMessage* cimmsg = dynamic_cast<CIMMessage*>(request.get());
1314 if (cimmsg != NULL)
1315 {
1316 cimmsg->operationContext.insert(IdentityContainer(userName));
1317 cimmsg->operationContext.set(
1318 AcceptLanguageListContainer(httpAcceptLanguages));
1319 cimmsg->operationContext.set(
1320 ContentLanguageListContainer(httpContentLanguages));
1321 }
1322 else
1323 {
1324 ; // l10n TODO - error back to client here
1325 }
|
1326 chip 1.92 // l10n end
|
1327 chuck 1.58
|
1328 kumpf 1.104 request->setCloseConnect(closeConnect);
1329 _outputQueue->enqueue(request.release());
|
1330 chip 1.92
|
1331 kumpf 1.104 PEG_METHOD_EXIT();
|
1332 mike 1.2 }
1333
|
1334 kumpf 1.104 CIMCreateClassRequestMessage*
1335 CIMOperationRequestDecoder::decodeCreateClassRequest(
1336 Uint32 queueId,
1337 XmlParser& parser,
1338 const String& messageId,
1339 const CIMNamespaceName& nameSpace)
1340 {
1341 PEG_METHOD_ENTER(TRC_DISPATCHER,
1342 "CIMOperationRequestDecoder::decodeCreateClassRequest()");
1343
1344 STAT_GETSTARTTIME
1345
1346 CIMClass newClass;
1347 Boolean duplicateParameter = false;
1348 Boolean gotClass = false;
1349 Boolean emptyTag;
1350
1351 for (const char* name;
1352 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1353 {
1354 if (System::strcasecmp(name, "NewClass") == 0)
1355 kumpf 1.104 {
1356 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
|
1357 kumpf 1.106 if (!XmlReader::getClassElement(parser, newClass))
1358 {
1359 throw PEGASUS_CIM_EXCEPTION(
1360 CIM_ERR_INVALID_PARAMETER, "NewClass");
1361 }
|
1362 kumpf 1.104 duplicateParameter = gotClass;
1363 gotClass = true;
1364 }
1365 else
1366 {
1367 PEG_METHOD_EXIT();
1368 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1369 }
|
1370 mike 1.2
|
1371 kumpf 1.104 if (!emptyTag)
1372 {
1373 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1374 }
|
1375 sage 1.41
|
1376 kumpf 1.104 if (duplicateParameter)
1377 {
1378 PEG_METHOD_EXIT();
1379 throw PEGASUS_CIM_EXCEPTION(
1380 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1381 }
1382 }
1383
1384 if (!gotClass)
1385 {
1386 PEG_METHOD_EXIT();
1387 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1388 }
1389
1390 AutoPtr<CIMCreateClassRequestMessage> request(
1391 new CIMCreateClassRequestMessage(
1392 messageId,
1393 nameSpace,
1394 newClass,
1395 QueueIdStack(queueId, _returnQueueId)));
1396
1397 kumpf 1.104 STAT_SERVERSTART
1398
1399 PEG_METHOD_EXIT();
1400 return request.release();
|
1401 mike 1.2 }
1402
1403 CIMGetClassRequestMessage* CIMOperationRequestDecoder::decodeGetClassRequest(
|
1404 kumpf 1.104 Uint32 queueId,
1405 XmlParser& parser,
1406 const String& messageId,
1407 const CIMNamespaceName& nameSpace)
1408 {
1409 PEG_METHOD_ENTER(TRC_DISPATCHER,
1410 "CIMOperationRequestDecoder::decodeGetClassRequest()");
1411
1412 STAT_GETSTARTTIME
1413
1414 CIMName className;
1415 Boolean localOnly = true;
1416 Boolean includeQualifiers = true;
1417 Boolean includeClassOrigin = false;
1418 CIMPropertyList propertyList;
1419 Boolean duplicateParameter = false;
1420 Boolean gotClassName = false;
1421 Boolean gotLocalOnly = false;
1422 Boolean gotIncludeQualifiers = false;
1423 Boolean gotIncludeClassOrigin = false;
1424 Boolean gotPropertyList = false;
1425 kumpf 1.104 Boolean emptyTag;
1426
1427 for (const char* name;
1428 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1429 {
1430 if (System::strcasecmp(name, "ClassName") == 0)
1431 {
1432 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1433 XmlReader::getClassNameElement(parser, className, true);
1434 duplicateParameter = gotClassName;
1435 gotClassName = true;
1436 }
1437 else if (System::strcasecmp(name, "LocalOnly") == 0)
1438 {
1439 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1440 XmlReader::getBooleanValueElement(parser, localOnly, true);
1441 duplicateParameter = gotLocalOnly;
1442 gotLocalOnly = true;
1443 }
1444 else if (System::strcasecmp(name, "IncludeQualifiers") == 0)
1445 {
1446 kumpf 1.104 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1447 XmlReader::getBooleanValueElement(parser, includeQualifiers, true);
1448 duplicateParameter = gotIncludeQualifiers;
1449 gotIncludeQualifiers = true;
1450 }
1451 else if (System::strcasecmp(name, "IncludeClassOrigin") == 0)
1452 {
1453 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1454 XmlReader::getBooleanValueElement(parser, includeClassOrigin, true);
1455 duplicateParameter = gotIncludeClassOrigin;
1456 gotIncludeClassOrigin = true;
1457 }
1458 else if (System::strcasecmp(name, "PropertyList") == 0)
1459 {
1460 if (!emptyTag)
1461 {
1462 CIMValue pl;
1463 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
1464 {
1465 Array<String> propertyListArray;
1466 pl.get(propertyListArray);
1467 kumpf 1.104 Array<CIMName> cimNameArray;
1468 for (Uint32 i = 0; i < propertyListArray.size(); i++)
1469 {
1470 cimNameArray.append(propertyListArray[i]);
1471 }
1472 propertyList.set(cimNameArray);
1473 }
1474 }
1475 duplicateParameter = gotPropertyList;
1476 gotPropertyList = true;
1477 }
1478 else
1479 {
1480 PEG_METHOD_EXIT();
1481 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1482 }
1483
1484 if (!emptyTag)
1485 {
1486 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1487 }
1488 kumpf 1.104
1489 if (duplicateParameter)
1490 {
1491 PEG_METHOD_EXIT();
1492 throw PEGASUS_CIM_EXCEPTION(
1493 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1494 }
1495 }
1496
1497 if (!gotClassName)
1498 {
1499 PEG_METHOD_EXIT();
1500 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1501 }
1502
1503 AutoPtr<CIMGetClassRequestMessage> request(new CIMGetClassRequestMessage(
1504 messageId,
1505 nameSpace,
1506 className,
1507 localOnly,
1508 includeQualifiers,
1509 kumpf 1.104 includeClassOrigin,
1510 propertyList,
1511 QueueIdStack(queueId, _returnQueueId)));
1512
1513 STAT_SERVERSTART
1514
1515 PEG_METHOD_EXIT();
1516 return request.release();
1517 }
1518
1519 CIMModifyClassRequestMessage*
1520 CIMOperationRequestDecoder::decodeModifyClassRequest(
1521 Uint32 queueId,
1522 XmlParser& parser,
1523 const String& messageId,
1524 const CIMNamespaceName& nameSpace)
1525 {
1526 STAT_GETSTARTTIME
1527
1528 CIMClass modifiedClass;
1529 Boolean duplicateParameter = false;
1530 kumpf 1.104 Boolean gotClass = false;
1531 Boolean emptyTag;
1532
1533 for (const char* name;
1534 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1535 {
1536 if (System::strcasecmp(name, "ModifiedClass") == 0)
1537 {
1538 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
|
1539 kumpf 1.106 if (!XmlReader::getClassElement(parser, modifiedClass))
1540 {
1541 throw PEGASUS_CIM_EXCEPTION(
1542 CIM_ERR_INVALID_PARAMETER, "ModifiedClass");
1543 }
|
1544 kumpf 1.104 duplicateParameter = gotClass;
1545 gotClass = true;
1546 }
1547 else
1548 {
1549 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1550 }
1551
1552 if (!emptyTag)
1553 {
1554 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1555 }
1556
1557 if (duplicateParameter)
1558 {
1559 throw PEGASUS_CIM_EXCEPTION(
1560 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1561 }
1562 }
1563
1564 if (!gotClass)
1565 kumpf 1.104 {
1566 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1567 }
1568
1569 AutoPtr<CIMModifyClassRequestMessage> request(
1570 new CIMModifyClassRequestMessage(
1571 messageId,
1572 nameSpace,
1573 modifiedClass,
1574 QueueIdStack(queueId, _returnQueueId)));
1575
1576 STAT_SERVERSTART
1577
1578 return request.release();
1579 }
1580
1581 CIMEnumerateClassNamesRequestMessage*
1582 CIMOperationRequestDecoder::decodeEnumerateClassNamesRequest(
1583 Uint32 queueId,
1584 XmlParser& parser,
1585 const String& messageId,
1586 kumpf 1.104 const CIMNamespaceName& nameSpace)
1587 {
1588 STAT_GETSTARTTIME
1589
1590 CIMName className;
1591 Boolean deepInheritance = false;
1592 Boolean duplicateParameter = false;
1593 Boolean gotClassName = false;
1594 Boolean gotDeepInheritance = false;
1595 Boolean emptyTag;
1596
1597 for (const char* name;
1598 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1599 {
1600 if (System::strcasecmp(name, "ClassName") == 0)
1601 {
1602 //
1603 // ClassName may be NULL
1604 //
1605 if (!emptyTag)
1606 {
1607 kumpf 1.104 XmlReader::getClassNameElement(parser, className, false);
1608 }
1609 duplicateParameter = gotClassName;
1610 gotClassName = true;
1611 }
1612 else if (System::strcasecmp(name, "DeepInheritance") == 0)
1613 {
1614 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1615 XmlReader::getBooleanValueElement(parser, deepInheritance, true);
1616 duplicateParameter = gotDeepInheritance;
1617 gotDeepInheritance = true;
1618 }
1619 else
1620 {
1621 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1622 }
1623
1624 if (!emptyTag)
1625 {
1626 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1627 }
1628 kumpf 1.104
1629 if (duplicateParameter)
1630 {
1631 throw PEGASUS_CIM_EXCEPTION(
1632 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1633 }
1634 }
1635
1636 AutoPtr<CIMEnumerateClassNamesRequestMessage> request(
1637 new CIMEnumerateClassNamesRequestMessage(
1638 messageId,
1639 nameSpace,
1640 className,
1641 deepInheritance,
1642 QueueIdStack(queueId, _returnQueueId)));
1643
1644 STAT_SERVERSTART
1645
1646 return request.release();
1647 }
1648
1649 kumpf 1.104 CIMEnumerateClassesRequestMessage*
1650 CIMOperationRequestDecoder::decodeEnumerateClassesRequest(
1651 Uint32 queueId,
1652 XmlParser& parser,
1653 const String& messageId,
1654 const CIMNamespaceName& nameSpace)
1655 {
1656 STAT_GETSTARTTIME
1657
1658 CIMName className;
1659 Boolean deepInheritance = false;
1660 Boolean localOnly = true;
1661 Boolean includeQualifiers = true;
1662 Boolean includeClassOrigin = false;
1663 Boolean duplicateParameter = false;
1664 Boolean gotClassName = false;
1665 Boolean gotDeepInheritance = false;
1666 Boolean gotLocalOnly = false;
1667 Boolean gotIncludeQualifiers = false;
1668 Boolean gotIncludeClassOrigin = false;
1669 Boolean emptyTag;
1670 kumpf 1.104
1671 for (const char* name;
1672 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1673 {
1674 if (System::strcasecmp(name, "ClassName") == 0)
1675 {
1676 //
1677 // ClassName may be NULL
1678 //
1679 if (!emptyTag)
1680 {
1681 XmlReader::getClassNameElement(parser, className, false);
1682 }
1683 duplicateParameter = gotClassName;
1684 gotClassName = true;
1685 }
1686 else if (System::strcasecmp(name, "DeepInheritance") == 0)
1687 {
1688 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1689 XmlReader::getBooleanValueElement(parser, deepInheritance, true);
1690 duplicateParameter = gotDeepInheritance;
1691 kumpf 1.104 gotDeepInheritance = true;
1692 }
1693 else if (System::strcasecmp(name, "LocalOnly") == 0)
1694 {
1695 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1696 XmlReader::getBooleanValueElement(parser, localOnly, true);
1697 duplicateParameter = gotLocalOnly;
1698 gotLocalOnly = true;
1699 }
1700 else if (System::strcasecmp(name, "IncludeQualifiers") == 0)
1701 {
1702 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1703 XmlReader::getBooleanValueElement(parser, includeQualifiers, true);
1704 duplicateParameter = gotIncludeQualifiers;
1705 gotIncludeQualifiers = true;
1706 }
1707 else if (System::strcasecmp(name, "IncludeClassOrigin") == 0)
1708 {
1709 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1710 XmlReader::getBooleanValueElement(parser, includeClassOrigin, true);
1711 duplicateParameter = gotIncludeClassOrigin;
1712 kumpf 1.104 gotIncludeClassOrigin = true;
1713 }
1714 else
1715 {
1716 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1717 }
1718
1719 if (!emptyTag)
1720 {
1721 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1722 }
1723
1724 if (duplicateParameter)
1725 {
1726 throw PEGASUS_CIM_EXCEPTION(
1727 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1728 }
1729 }
1730
1731 AutoPtr<CIMEnumerateClassesRequestMessage> request(
1732 new CIMEnumerateClassesRequestMessage(
1733 kumpf 1.104 messageId,
1734 nameSpace,
1735 className,
1736 deepInheritance,
1737 localOnly,
1738 includeQualifiers,
1739 includeClassOrigin,
1740 QueueIdStack(queueId, _returnQueueId)));
1741
1742 STAT_SERVERSTART
1743
1744 return request.release();
1745 }
1746
1747 CIMDeleteClassRequestMessage*
1748 CIMOperationRequestDecoder::decodeDeleteClassRequest(
1749 Uint32 queueId,
1750 XmlParser& parser,
1751 const String& messageId,
1752 const CIMNamespaceName& nameSpace)
1753 {
1754 kumpf 1.104 STAT_GETSTARTTIME
1755
1756 CIMName className;
1757 Boolean duplicateParameter = false;
1758 Boolean gotClassName = false;
1759 Boolean emptyTag;
1760
1761 for (const char* name;
1762 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1763 {
1764 if (System::strcasecmp(name, "ClassName") == 0)
1765 {
1766 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1767 XmlReader::getClassNameElement(parser, className);
1768 duplicateParameter = gotClassName;
1769 gotClassName = true;
1770 }
1771 else
1772 {
1773 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1774 }
1775 kumpf 1.104
1776 if (!emptyTag)
1777 {
1778 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1779 }
1780
1781 if (duplicateParameter)
1782 {
1783 throw PEGASUS_CIM_EXCEPTION(
1784 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1785 }
1786 }
1787
1788 if (!gotClassName)
1789 {
1790 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1791 }
1792
1793 AutoPtr<CIMDeleteClassRequestMessage> request(
1794 new CIMDeleteClassRequestMessage(
1795 messageId,
1796 kumpf 1.104 nameSpace,
1797 className,
1798 QueueIdStack(queueId, _returnQueueId)));
1799
1800 STAT_SERVERSTART
1801
1802 return request.release();
1803 }
1804
1805 CIMCreateInstanceRequestMessage*
1806 CIMOperationRequestDecoder::decodeCreateInstanceRequest(
1807 Uint32 queueId,
1808 XmlParser& parser,
1809 const String& messageId,
1810 const CIMNamespaceName& nameSpace)
1811 {
1812 STAT_GETSTARTTIME
1813
1814 CIMInstance newInstance;
1815 Boolean duplicateParameter = false;
1816 Boolean gotInstance = false;
1817 kumpf 1.104 Boolean emptyTag;
1818
1819 for (const char* name;
1820 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1821 {
1822 if (System::strcasecmp(name, "NewInstance") == 0)
1823 {
1824 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1825 XmlReader::getInstanceElement(parser, newInstance);
1826 duplicateParameter = gotInstance;
1827 gotInstance = true;
1828 }
1829 else
1830 {
1831 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1832 }
1833
1834 if (!emptyTag)
1835 {
1836 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1837 }
1838 kumpf 1.104
1839 if (duplicateParameter)
1840 {
1841 throw PEGASUS_CIM_EXCEPTION(
1842 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1843 }
1844 }
1845
1846 if (!gotInstance)
1847 {
1848 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1849 }
1850
1851 AutoPtr<CIMCreateInstanceRequestMessage> request(
1852 new CIMCreateInstanceRequestMessage(
1853 messageId,
1854 nameSpace,
1855 newInstance,
1856 QueueIdStack(queueId, _returnQueueId)));
1857
1858 STAT_SERVERSTART
1859 kumpf 1.104
1860 return request.release();
1861 }
1862
1863 CIMGetInstanceRequestMessage*
1864 CIMOperationRequestDecoder::decodeGetInstanceRequest(
1865 Uint32 queueId,
1866 XmlParser& parser,
1867 const String& messageId,
1868 const CIMNamespaceName& nameSpace)
1869 {
1870 STAT_GETSTARTTIME
1871
1872 CIMObjectPath instanceName;
1873 Boolean localOnly = true;
1874 Boolean includeQualifiers = false;
1875 Boolean includeClassOrigin = false;
1876 CIMPropertyList propertyList;
1877 Boolean duplicateParameter = false;
1878 Boolean gotInstanceName = false;
1879 Boolean gotLocalOnly = false;
1880 kumpf 1.104 Boolean gotIncludeQualifiers = false;
1881 Boolean gotIncludeClassOrigin = false;
1882 Boolean gotPropertyList = false;
1883 Boolean emptyTag;
1884
1885 for (const char* name;
1886 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1887 {
1888 if (System::strcasecmp(name, "InstanceName") == 0)
1889 {
1890 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1891 XmlReader::getInstanceNameElement(parser, instanceName);
1892 duplicateParameter = gotInstanceName;
1893 gotInstanceName = true;
1894 }
1895 else if (System::strcasecmp(name, "LocalOnly") == 0)
1896 {
1897 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1898 XmlReader::getBooleanValueElement(parser, localOnly, true);
1899 duplicateParameter = gotLocalOnly;
1900 gotLocalOnly = true;
1901 kumpf 1.104 }
1902 else if (System::strcasecmp(name, "IncludeQualifiers") == 0)
1903 {
1904 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1905 XmlReader::getBooleanValueElement(parser, includeQualifiers, true);
1906 duplicateParameter = gotIncludeQualifiers;
1907 gotIncludeQualifiers = true;
1908 }
1909 else if (System::strcasecmp(name, "IncludeClassOrigin") == 0)
1910 {
1911 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1912 XmlReader::getBooleanValueElement(parser, includeClassOrigin, true);
1913 duplicateParameter = gotIncludeClassOrigin;
1914 gotIncludeClassOrigin = true;
1915 }
1916 else if (System::strcasecmp(name, "PropertyList") == 0)
1917 {
1918 if (!emptyTag)
1919 {
1920 CIMValue pl;
1921 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
1922 kumpf 1.104 {
1923 Array<String> propertyListArray;
1924 pl.get(propertyListArray);
1925 Array<CIMName> cimNameArray;
1926 for (Uint32 i = 0; i < propertyListArray.size(); i++)
1927 {
1928 cimNameArray.append(propertyListArray[i]);
1929 }
1930 propertyList.set(cimNameArray);
1931 }
1932 }
1933 duplicateParameter = gotPropertyList;
1934 gotPropertyList = true;
1935 }
1936 else
1937 {
1938 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
1939 }
1940
1941 if (!emptyTag)
1942 {
1943 kumpf 1.104 XmlReader::expectEndTag(parser, "IPARAMVALUE");
1944 }
1945
1946 if (duplicateParameter)
1947 {
1948 throw PEGASUS_CIM_EXCEPTION(
1949 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1950 }
1951 }
1952
1953 if (!gotInstanceName)
1954 {
1955 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
1956 }
1957
1958 AutoPtr<CIMGetInstanceRequestMessage> request(
1959 new CIMGetInstanceRequestMessage(
1960 messageId,
1961 nameSpace,
1962 instanceName,
1963 false, // Bug 1985 localOnly is deprecated
|
1964 h.sterling 1.97 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
1965 kumpf 1.104 false,
|
1966 h.sterling 1.97 #else
|
1967 kumpf 1.104 includeQualifiers,
|
1968 h.sterling 1.97 #endif
|
1969 kumpf 1.104 includeClassOrigin,
1970 propertyList,
1971 QueueIdStack(queueId, _returnQueueId)));
1972
1973 STAT_SERVERSTART
1974
1975 return request.release();
1976 }
1977
1978 CIMModifyInstanceRequestMessage*
1979 CIMOperationRequestDecoder::decodeModifyInstanceRequest(
1980 Uint32 queueId,
1981 XmlParser& parser,
1982 const String& messageId,
1983 const CIMNamespaceName& nameSpace)
1984 {
1985 STAT_GETSTARTTIME
1986
1987 CIMInstance modifiedInstance;
1988 Boolean includeQualifiers = true;
1989 CIMPropertyList propertyList;
1990 kumpf 1.104 Boolean duplicateParameter = false;
1991 Boolean gotInstance = false;
1992 Boolean gotIncludeQualifiers = false;
1993 Boolean gotPropertyList = false;
1994 Boolean emptyTag;
1995
1996 for (const char* name;
1997 XmlReader::getIParamValueTag(parser, name, emptyTag); )
1998 {
1999 if (System::strcasecmp(name, "ModifiedInstance") == 0)
2000 {
2001 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2002 XmlReader::getNamedInstanceElement(parser, modifiedInstance);
2003 duplicateParameter = gotInstance;
2004 gotInstance = true;
2005 }
2006 else if (System::strcasecmp(name, "IncludeQualifiers") == 0)
2007 {
2008 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2009 XmlReader::getBooleanValueElement(parser, includeQualifiers, true);
2010 duplicateParameter = gotIncludeQualifiers;
2011 kumpf 1.104 gotIncludeQualifiers = true;
2012 }
2013 else if (System::strcasecmp(name, "PropertyList") == 0)
2014 {
2015 if (!emptyTag)
2016 {
2017 CIMValue pl;
2018 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
2019 {
2020 Array<String> propertyListArray;
2021 pl.get(propertyListArray);
2022 Array<CIMName> cimNameArray;
2023 for (Uint32 i = 0; i < propertyListArray.size(); i++)
2024 {
2025 cimNameArray.append(propertyListArray[i]);
2026 }
2027 propertyList.set(cimNameArray);
2028 }
2029 }
2030 duplicateParameter = gotPropertyList;
2031 gotPropertyList = true;
2032 kumpf 1.104 }
2033 else
2034 {
2035 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2036 }
2037
2038 if (!emptyTag)
2039 {
2040 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2041 }
2042
2043 if (duplicateParameter)
2044 {
2045 throw PEGASUS_CIM_EXCEPTION(
2046 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2047 }
2048 }
2049
2050 if (!gotInstance)
2051 {
2052 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2053 kumpf 1.104 }
2054
2055 AutoPtr<CIMModifyInstanceRequestMessage> request(
2056 new CIMModifyInstanceRequestMessage(
2057 messageId,
2058 nameSpace,
2059 modifiedInstance,
2060 includeQualifiers,
2061 propertyList,
2062 QueueIdStack(queueId, _returnQueueId)));
2063
2064 STAT_SERVERSTART
2065
2066 return request.release();
2067 }
2068
2069 CIMEnumerateInstancesRequestMessage*
2070 CIMOperationRequestDecoder::decodeEnumerateInstancesRequest(
2071 Uint32 queueId,
2072 XmlParser& parser,
2073 const String& messageId,
2074 kumpf 1.104 const CIMNamespaceName& nameSpace)
2075 {
2076 STAT_GETSTARTTIME
2077
2078 CIMName className;
2079 Boolean deepInheritance = true;
2080 Boolean localOnly = true;
2081 Boolean includeQualifiers = false;
2082 Boolean includeClassOrigin = false;
2083 CIMPropertyList propertyList;
2084 Boolean duplicateParameter = false;
2085 Boolean gotClassName = false;
2086 Boolean gotDeepInheritance = false;
2087 Boolean gotLocalOnly = false;
2088 Boolean gotIncludeQualifiers = false;
2089 Boolean gotIncludeClassOrigin = false;
2090 Boolean gotPropertyList = false;
2091 Boolean emptyTag;
2092
2093 for (const char* name;
2094 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2095 kumpf 1.104 {
2096 if (System::strcasecmp(name, "ClassName") == 0)
2097 {
2098 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2099 XmlReader::getClassNameElement(parser, className, true);
2100 duplicateParameter = gotClassName;
2101 gotClassName = true;
2102 }
2103 else if (System::strcasecmp(name, "DeepInheritance") == 0)
2104 {
2105 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2106 XmlReader::getBooleanValueElement(parser, deepInheritance, true);
2107 duplicateParameter = gotDeepInheritance;
2108 gotDeepInheritance = true;
2109 }
2110 else if (System::strcasecmp(name, "LocalOnly") == 0)
2111 {
2112 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2113 XmlReader::getBooleanValueElement(parser, localOnly, true);
2114 duplicateParameter = gotLocalOnly;
2115 gotLocalOnly = true;
2116 kumpf 1.104 }
2117 else if (System::strcasecmp(name, "IncludeQualifiers") == 0)
2118 {
2119 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2120 XmlReader::getBooleanValueElement(parser, includeQualifiers, true);
2121 duplicateParameter = gotIncludeQualifiers;
2122 gotIncludeQualifiers = true;
2123 }
2124 else if (System::strcasecmp(name, "IncludeClassOrigin") == 0)
2125 {
2126 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2127 XmlReader::getBooleanValueElement(parser, includeClassOrigin, true);
2128 duplicateParameter = gotIncludeClassOrigin;
2129 gotIncludeClassOrigin = true;
2130 }
2131 else if (System::strcasecmp(name, "PropertyList") == 0)
2132 {
2133 if (!emptyTag)
2134 {
2135 CIMValue pl;
2136 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
2137 kumpf 1.104 {
2138 Array<String> propertyListArray;
2139 pl.get(propertyListArray);
2140 Array<CIMName> cimNameArray;
2141 for (Uint32 i = 0; i < propertyListArray.size(); i++)
2142 {
2143 cimNameArray.append(propertyListArray[i]);
2144 }
2145 propertyList.set(cimNameArray);
2146 }
2147 }
2148 duplicateParameter = gotPropertyList;
2149 gotPropertyList = true;
2150 }
2151 else
2152 {
2153 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2154 }
2155
2156 if (!emptyTag)
2157 {
2158 kumpf 1.104 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2159 }
2160
2161 if (duplicateParameter)
2162 {
2163 throw PEGASUS_CIM_EXCEPTION(
2164 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2165 }
2166 }
2167
2168 if (!gotClassName)
2169 {
2170 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2171 }
2172
2173 AutoPtr<CIMEnumerateInstancesRequestMessage> request(
2174 new CIMEnumerateInstancesRequestMessage(
2175 messageId,
2176 nameSpace,
2177 className,
2178 deepInheritance,
2179 kumpf 1.104 false, // Bug 1985 localOnly is deprecated
|
2180 h.sterling 1.97 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
2181 kumpf 1.104 false,
|
2182 h.sterling 1.97 #else
|
2183 kumpf 1.104 includeQualifiers,
|
2184 h.sterling 1.97 #endif
|
2185 kumpf 1.104 includeClassOrigin,
2186 propertyList,
2187 QueueIdStack(queueId, _returnQueueId)));
2188
2189 STAT_SERVERSTART
2190
2191 return request.release();
2192 }
2193
2194 CIMEnumerateInstanceNamesRequestMessage*
2195 CIMOperationRequestDecoder::decodeEnumerateInstanceNamesRequest(
2196 Uint32 queueId,
2197 XmlParser& parser,
2198 const String& messageId,
2199 const CIMNamespaceName& nameSpace)
2200 {
2201 STAT_GETSTARTTIME
2202
2203 CIMName className;
2204 Boolean duplicateParameter = false;
2205 Boolean gotClassName = false;
2206 kumpf 1.104 Boolean emptyTag;
2207
2208 for (const char* name;
2209 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2210 {
2211 if (System::strcasecmp(name, "ClassName") == 0)
2212 {
2213 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2214 XmlReader::getClassNameElement(parser, className, true);
2215 duplicateParameter = gotClassName;
2216 gotClassName = true;
2217 }
2218 else
2219 {
2220 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2221 }
2222
2223 if (!emptyTag)
2224 {
2225 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2226 }
2227 kumpf 1.104
2228 if (duplicateParameter)
2229 {
2230 throw PEGASUS_CIM_EXCEPTION(
2231 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2232 }
2233 }
2234
2235 if (!gotClassName)
2236 {
2237 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2238 }
2239
2240 AutoPtr<CIMEnumerateInstanceNamesRequestMessage> request(
2241 new CIMEnumerateInstanceNamesRequestMessage(
2242 messageId,
2243 nameSpace,
2244 className,
2245 QueueIdStack(queueId, _returnQueueId)));
2246
2247 STAT_SERVERSTART
2248 kumpf 1.104
2249 return request.release();
2250 }
2251
2252 CIMDeleteInstanceRequestMessage*
2253 CIMOperationRequestDecoder::decodeDeleteInstanceRequest(
2254 Uint32 queueId,
2255 XmlParser& parser,
2256 const String& messageId,
2257 const CIMNamespaceName& nameSpace)
2258 {
2259 STAT_GETSTARTTIME
2260
2261 CIMObjectPath instanceName;
2262 Boolean duplicateParameter = false;
2263 Boolean gotInstanceName = false;
2264 Boolean emptyTag;
2265
2266 for (const char* name;
2267 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2268 {
2269 kumpf 1.104 if (System::strcasecmp(name, "InstanceName") == 0)
2270 {
2271 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2272 XmlReader::getInstanceNameElement(parser, instanceName);
2273 duplicateParameter = gotInstanceName;
2274 gotInstanceName = true;
2275 }
2276 else
2277 {
2278 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2279 }
2280
2281 if (!emptyTag)
2282 {
2283 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2284 }
2285
2286 if (duplicateParameter)
2287 {
2288 throw PEGASUS_CIM_EXCEPTION(
2289 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2290 kumpf 1.104 }
2291 }
2292
2293 if (!gotInstanceName)
2294 {
2295 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2296 }
2297
2298 AutoPtr<CIMDeleteInstanceRequestMessage> request(
2299 new CIMDeleteInstanceRequestMessage(
2300 messageId,
2301 nameSpace,
2302 instanceName,
2303 QueueIdStack(queueId, _returnQueueId)));
2304
2305 STAT_SERVERSTART
2306
2307 return request.release();
2308 }
2309
2310 CIMSetQualifierRequestMessage*
2311 kumpf 1.104 CIMOperationRequestDecoder::decodeSetQualifierRequest(
2312 Uint32 queueId,
2313 XmlParser& parser,
2314 const String& messageId,
2315 const CIMNamespaceName& nameSpace)
2316 {
2317 STAT_GETSTARTTIME
2318
2319 CIMQualifierDecl qualifierDeclaration;
2320 Boolean duplicateParameter = false;
2321 Boolean gotQualifierDeclaration = false;
2322 Boolean emptyTag;
2323
2324 for (const char* name;
2325 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2326 {
2327 if (System::strcasecmp(name, "QualifierDeclaration") == 0)
2328 {
2329 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2330 XmlReader::getQualifierDeclElement(parser, qualifierDeclaration);
2331 duplicateParameter = gotQualifierDeclaration;
2332 kumpf 1.104 gotQualifierDeclaration = true;
2333 }
2334 else
2335 {
2336 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2337 }
2338
2339 if (!emptyTag)
2340 {
2341 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2342 }
2343
2344 if (duplicateParameter)
2345 {
2346 throw PEGASUS_CIM_EXCEPTION(
2347 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2348 }
2349 }
2350
2351 if (!gotQualifierDeclaration)
2352 {
2353 kumpf 1.104 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2354 }
2355
2356 AutoPtr<CIMSetQualifierRequestMessage> request(
2357 new CIMSetQualifierRequestMessage(
2358 messageId,
2359 nameSpace,
2360 qualifierDeclaration,
2361 QueueIdStack(queueId, _returnQueueId)));
2362
2363 STAT_SERVERSTART
2364
2365 return request.release();
2366 }
2367
2368 CIMGetQualifierRequestMessage*
2369 CIMOperationRequestDecoder::decodeGetQualifierRequest(
2370 Uint32 queueId,
2371 XmlParser& parser,
2372 const String& messageId,
2373 const CIMNamespaceName& nameSpace)
2374 kumpf 1.104 {
2375 STAT_GETSTARTTIME
2376
2377 String qualifierNameString;
2378 CIMName qualifierName;
2379 Boolean duplicateParameter = false;
2380 Boolean gotQualifierName = false;
2381 Boolean emptyTag;
2382
2383 for (const char* name;
2384 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2385 {
2386 if (System::strcasecmp(name, "QualifierName") == 0)
2387 {
2388 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2389 XmlReader::getStringValueElement(parser, qualifierNameString, true);
2390 qualifierName = qualifierNameString;
2391 duplicateParameter = gotQualifierName;
2392 gotQualifierName = true;
2393 }
2394 else
2395 kumpf 1.104 {
2396 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2397 }
2398
2399 if (!emptyTag)
2400 {
2401 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2402 }
2403
2404 if (duplicateParameter)
2405 {
2406 throw PEGASUS_CIM_EXCEPTION(
2407 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2408 }
2409 }
2410
2411 if (!gotQualifierName)
2412 {
2413 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2414 }
2415
2416 kumpf 1.104 AutoPtr<CIMGetQualifierRequestMessage> request(
2417 new CIMGetQualifierRequestMessage(
2418 messageId,
2419 nameSpace,
2420 qualifierName,
2421 QueueIdStack(queueId, _returnQueueId)));
2422
2423 STAT_SERVERSTART
2424
2425 return request.release();
2426 }
2427
2428 CIMEnumerateQualifiersRequestMessage*
2429 CIMOperationRequestDecoder::decodeEnumerateQualifiersRequest(
2430 Uint32 queueId,
2431 XmlParser& parser,
2432 const String& messageId,
2433 const CIMNamespaceName& nameSpace)
2434 {
2435 STAT_GETSTARTTIME
2436 Boolean emptyTag;
2437 kumpf 1.104
2438 for (const char* name;
2439 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2440 {
2441 // No IPARAMVALUEs are defined for this operation
2442 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2443 }
2444
2445 AutoPtr<CIMEnumerateQualifiersRequestMessage> request(
2446 new CIMEnumerateQualifiersRequestMessage(
2447 messageId,
2448 nameSpace,
2449 QueueIdStack(queueId, _returnQueueId)));
2450
2451 STAT_SERVERSTART
2452
2453 return request.release();
2454 }
2455
2456 CIMDeleteQualifierRequestMessage*
2457 CIMOperationRequestDecoder::decodeDeleteQualifierRequest(
2458 kumpf 1.104 Uint32 queueId,
2459 XmlParser& parser,
2460 const String& messageId,
2461 const CIMNamespaceName& nameSpace)
2462 {
2463 STAT_GETSTARTTIME
2464
2465 String qualifierNameString;
2466 CIMName qualifierName;
2467 Boolean duplicateParameter = false;
2468 Boolean gotQualifierName = false;
2469 Boolean emptyTag;
2470
2471 for (const char* name;
2472 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2473 {
2474 if (System::strcasecmp(name, "QualifierName") == 0)
2475 {
2476 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2477 XmlReader::getStringValueElement(parser, qualifierNameString, true);
2478 qualifierName = qualifierNameString;
2479 kumpf 1.104 duplicateParameter = gotQualifierName;
2480 gotQualifierName = true;
2481 }
2482 else
2483 {
2484 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2485 }
2486
2487 if (!emptyTag)
2488 {
2489 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2490 }
2491
2492 if (duplicateParameter)
2493 {
2494 throw PEGASUS_CIM_EXCEPTION(
2495 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2496 }
2497 }
2498
2499 if (!gotQualifierName)
2500 kumpf 1.104 {
2501 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2502 }
2503
2504 AutoPtr<CIMDeleteQualifierRequestMessage> request(
2505 new CIMDeleteQualifierRequestMessage(
2506 messageId,
2507 nameSpace,
2508 qualifierName,
2509 QueueIdStack(queueId, _returnQueueId)));
2510
2511 STAT_SERVERSTART
2512
2513 return request.release();
2514 }
2515
2516 CIMReferenceNamesRequestMessage*
2517 CIMOperationRequestDecoder::decodeReferenceNamesRequest(
2518 Uint32 queueId,
2519 XmlParser& parser,
2520 const String& messageId,
2521 kumpf 1.104 const CIMNamespaceName& nameSpace)
2522 {
2523 STAT_GETSTARTTIME
2524
2525 CIMObjectPath objectName;
2526 CIMName resultClass;
2527 String role;
2528 Boolean duplicateParameter = false;
2529 Boolean gotObjectName = false;
2530 Boolean gotResultClass = false;
2531 Boolean gotRole = false;
2532 Boolean emptyTag;
2533
2534 for (const char* name;
2535 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2536 {
2537 if (System::strcasecmp(name, "ObjectName") == 0)
2538 {
2539 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2540 XmlReader::getObjectNameElement(parser, objectName);
2541 duplicateParameter = gotObjectName;
2542 kumpf 1.104 gotObjectName = true;
2543 }
2544 else if (System::strcasecmp(name, "ResultClass") == 0)
2545 {
2546 //
2547 // ResultClass may be NULL
2548 //
2549 if (!emptyTag)
2550 {
2551 XmlReader::getClassNameElement(parser, resultClass, false);
2552 }
2553 duplicateParameter = gotResultClass;
2554 gotResultClass = true;
2555 }
2556 else if (System::strcasecmp(name, "Role") == 0)
2557 {
2558 //
2559 // Role may be NULL
2560 //
2561 if (!emptyTag)
2562 {
2563 kumpf 1.104 XmlReader::getStringValueElement(parser, role, false);
2564 }
2565 duplicateParameter = gotRole;
2566 gotRole = true;
2567 }
2568 else
2569 {
2570 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2571 }
2572
2573 if (!emptyTag)
2574 {
2575 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2576 }
2577
2578 if (duplicateParameter)
2579 {
2580 throw PEGASUS_CIM_EXCEPTION(
2581 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2582 }
2583 }
2584 kumpf 1.104
2585 if (!gotObjectName)
2586 {
2587 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2588 }
2589
2590 AutoPtr<CIMReferenceNamesRequestMessage> request(
2591 new CIMReferenceNamesRequestMessage(
2592 messageId,
2593 nameSpace,
2594 objectName,
2595 resultClass,
2596 role,
2597 QueueIdStack(queueId, _returnQueueId)));
2598
2599 STAT_SERVERSTART
2600
2601 return request.release();
2602 }
2603
2604 CIMReferencesRequestMessage*
2605 kumpf 1.104 CIMOperationRequestDecoder::decodeReferencesRequest(
2606 Uint32 queueId,
2607 XmlParser& parser,
2608 const String& messageId,
2609 const CIMNamespaceName& nameSpace)
2610 {
2611 STAT_GETSTARTTIME
2612
2613 CIMObjectPath objectName;
2614 CIMName resultClass;
2615 String role;
2616 Boolean includeQualifiers = false;
2617 Boolean includeClassOrigin = false;
2618 CIMPropertyList propertyList;
2619 Boolean duplicateParameter = false;
2620 Boolean gotObjectName = false;
2621 Boolean gotResultClass = false;
2622 Boolean gotRole = false;
2623 Boolean gotIncludeQualifiers = false;
2624 Boolean gotIncludeClassOrigin = false;
2625 Boolean gotPropertyList = false;
2626 kumpf 1.104 Boolean emptyTag;
2627
2628 for (const char* name;
2629 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2630 {
2631 if (System::strcasecmp(name, "ObjectName") == 0)
2632 {
2633 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2634 XmlReader::getObjectNameElement(parser, objectName);
2635 duplicateParameter = gotObjectName;
2636 gotObjectName = true;
2637 }
2638 else if (System::strcasecmp(name, "ResultClass") == 0)
2639 {
2640 //
2641 // ResultClass may be NULL
2642 //
2643 if (!emptyTag)
2644 {
2645 XmlReader::getClassNameElement(parser, resultClass, false);
2646 }
2647 kumpf 1.104 duplicateParameter = gotResultClass;
2648 gotResultClass = true;
2649 }
2650 else if (System::strcasecmp(name, "Role") == 0)
2651 {
2652 //
2653 // Role may be NULL
2654 //
2655 if (!emptyTag)
2656 {
2657 XmlReader::getStringValueElement(parser, role, false);
2658 }
2659 duplicateParameter = gotRole;
2660 gotRole = true;
2661 }
2662 else if (System::strcasecmp(name, "IncludeQualifiers") == 0)
2663 {
2664 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2665 XmlReader::getBooleanValueElement(parser, includeQualifiers, true);
2666 duplicateParameter = gotIncludeQualifiers;
2667 gotIncludeQualifiers = true;
2668 kumpf 1.104 }
2669 else if (System::strcasecmp(name, "IncludeClassOrigin") == 0)
2670 {
2671 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2672 XmlReader::getBooleanValueElement(parser, includeClassOrigin, true);
2673 duplicateParameter = gotIncludeClassOrigin;
2674 gotIncludeClassOrigin = true;
2675 }
2676 else if (System::strcasecmp(name, "PropertyList") == 0)
2677 {
2678 if (!emptyTag)
2679 {
2680 CIMValue pl;
2681 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
2682 {
2683 Array<String> propertyListArray;
2684 pl.get(propertyListArray);
2685 Array<CIMName> cimNameArray;
2686 for (Uint32 i = 0; i < propertyListArray.size(); i++)
2687 {
2688 cimNameArray.append(propertyListArray[i]);
2689 kumpf 1.104 }
2690 propertyList.set(cimNameArray);
2691 }
2692 }
2693 duplicateParameter = gotPropertyList;
2694 gotPropertyList = true;
2695 }
2696 else
2697 {
2698 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2699 }
2700
2701 if (!emptyTag)
2702 {
2703 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2704 }
2705
2706 if (duplicateParameter)
2707 {
2708 throw PEGASUS_CIM_EXCEPTION(
2709 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2710 kumpf 1.104 }
2711 }
2712
2713 if (!gotObjectName)
2714 {
2715 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2716 }
2717
2718 AutoPtr<CIMReferencesRequestMessage> request(
2719 new CIMReferencesRequestMessage(
2720 messageId,
2721 nameSpace,
2722 objectName,
2723 resultClass,
2724 role,
2725 includeQualifiers,
2726 includeClassOrigin,
2727 propertyList,
2728 QueueIdStack(queueId, _returnQueueId)));
2729
2730 STAT_SERVERSTART
2731 kumpf 1.104
2732 return request.release();
2733 }
2734
2735 CIMAssociatorNamesRequestMessage*
2736 CIMOperationRequestDecoder::decodeAssociatorNamesRequest(
2737 Uint32 queueId,
2738 XmlParser& parser,
2739 const String& messageId,
2740 const CIMNamespaceName& nameSpace)
2741 {
2742 STAT_GETSTARTTIME
2743
2744 CIMObjectPath objectName;
2745 CIMName assocClass;
2746 CIMName resultClass;
2747 String role;
2748 String resultRole;
2749 Boolean duplicateParameter = false;
2750 Boolean gotObjectName = false;
2751 Boolean gotAssocClass = false;
2752 kumpf 1.104 Boolean gotResultClass = false;
2753 Boolean gotRole = false;
2754 Boolean gotResultRole = false;
2755 Boolean emptyTag;
2756
2757 for (const char* name;
2758 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2759 {
2760 if (System::strcasecmp(name, "ObjectName") == 0)
2761 {
2762 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2763 XmlReader::getObjectNameElement(parser, objectName);
2764 duplicateParameter = gotObjectName;
2765 gotObjectName = true;
2766 }
2767 else if (System::strcasecmp(name, "AssocClass") == 0)
2768 {
2769 //
2770 // AssocClass may be NULL
2771 //
2772 if (!emptyTag)
2773 kumpf 1.104 {
2774 XmlReader::getClassNameElement(parser, assocClass, false);
2775 }
2776 duplicateParameter = gotAssocClass;
2777 gotAssocClass = true;
2778 }
2779 else if (System::strcasecmp(name, "ResultClass") == 0)
2780 {
2781 //
2782 // ResultClass may be NULL
2783 //
2784 if (!emptyTag)
2785 {
2786 XmlReader::getClassNameElement(parser, resultClass, false);
2787 }
2788 duplicateParameter = gotResultClass;
2789 gotResultClass = true;
2790 }
2791 else if (System::strcasecmp(name, "Role") == 0)
2792 {
2793 //
2794 kumpf 1.104 // Role may be NULL
2795 //
2796 if (!emptyTag)
2797 {
2798 XmlReader::getStringValueElement(parser, role, false);
2799 }
2800 duplicateParameter = gotRole;
2801 gotRole = true;
2802 }
2803 else if (System::strcasecmp(name, "ResultRole") == 0)
2804 {
2805 //
2806 // ResultRole may be NULL
2807 //
2808 if (!emptyTag)
2809 {
2810 XmlReader::getStringValueElement(parser, resultRole, false);
2811 }
2812 duplicateParameter = gotResultRole;
2813 gotResultRole = true;
2814 }
2815 kumpf 1.104 else
2816 {
2817 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2818 }
2819
2820 if (!emptyTag)
2821 {
2822 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2823 }
2824
2825 if (duplicateParameter)
2826 {
2827 throw PEGASUS_CIM_EXCEPTION(
2828 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2829 }
2830 }
2831
2832 if (!gotObjectName)
2833 {
2834 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2835 }
2836 kumpf 1.104
2837 AutoPtr<CIMAssociatorNamesRequestMessage> request(
2838 new CIMAssociatorNamesRequestMessage(
2839 messageId,
2840 nameSpace,
2841 objectName,
2842 assocClass,
2843 resultClass,
2844 role,
2845 resultRole,
2846 QueueIdStack(queueId, _returnQueueId)));
2847
2848 STAT_SERVERSTART
2849
2850 return request.release();
2851 }
2852
2853 CIMAssociatorsRequestMessage*
2854 CIMOperationRequestDecoder::decodeAssociatorsRequest(
2855 Uint32 queueId,
2856 XmlParser& parser,
2857 kumpf 1.104 const String& messageId,
2858 const CIMNamespaceName& nameSpace)
2859 {
2860 STAT_GETSTARTTIME
2861
2862 CIMObjectPath objectName;
2863 CIMName assocClass;
2864 CIMName resultClass;
2865 String role;
2866 String resultRole;
2867 Boolean includeQualifiers = false;
2868 Boolean includeClassOrigin = false;
2869 CIMPropertyList propertyList;
2870 Boolean duplicateParameter = false;
2871 Boolean gotObjectName = false;
2872 Boolean gotAssocClass = false;
2873 Boolean gotResultClass = false;
2874 Boolean gotRole = false;
2875 Boolean gotResultRole = false;
2876 Boolean gotIncludeQualifiers = false;
2877 Boolean gotIncludeClassOrigin = false;
2878 kumpf 1.104 Boolean gotPropertyList = false;
2879 Boolean emptyTag;
2880
2881 for (const char* name;
2882 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2883 {
2884 if (System::strcasecmp(name, "ObjectName") == 0)
2885 {
2886 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2887 XmlReader::getObjectNameElement(parser, objectName);
2888 duplicateParameter = gotObjectName;
2889 gotObjectName = true;
2890 }
2891 else if (System::strcasecmp(name, "AssocClass") == 0)
2892 {
2893 //
2894 // AssocClass may be NULL
2895 //
2896 if (!emptyTag)
2897 {
2898 XmlReader::getClassNameElement(parser, assocClass, false);
2899 kumpf 1.104 }
2900 duplicateParameter = gotAssocClass;
2901 gotAssocClass = true;
2902 }
2903 else if (System::strcasecmp(name, "ResultClass") == 0)
2904 {
2905 //
2906 // ResultClass may be NULL
2907 //
2908 if (!emptyTag)
2909 {
2910 XmlReader::getClassNameElement(parser, resultClass, false);
2911 }
2912 duplicateParameter = gotResultClass;
2913 gotResultClass = true;
2914 }
2915 else if (System::strcasecmp(name, "Role") == 0)
2916 {
2917 //
2918 // Role may be NULL
2919 //
2920 kumpf 1.104 if (!emptyTag)
2921 {
2922 XmlReader::getStringValueElement(parser, role, false);
2923 }
2924 duplicateParameter = gotRole;
2925 gotRole = true;
2926 }
2927 else if (System::strcasecmp(name, "ResultRole") == 0)
2928 {
2929 //
2930 // ResultRole may be NULL
2931 //
2932 if (!emptyTag)
2933 {
2934 XmlReader::getStringValueElement(parser, resultRole, false);
2935 }
2936 duplicateParameter = gotResultRole;
2937 gotResultRole = true;
2938 }
2939 else if (System::strcasecmp(name, "IncludeQualifiers") == 0)
2940 {
2941 kumpf 1.104 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2942 XmlReader::getBooleanValueElement(parser, includeQualifiers, true);
2943 duplicateParameter = gotIncludeQualifiers;
2944 gotIncludeQualifiers = true;
2945 }
2946 else if (System::strcasecmp(name, "IncludeClassOrigin") == 0)
2947 {
2948 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2949 XmlReader::getBooleanValueElement(parser, includeClassOrigin, true);
2950 duplicateParameter = gotIncludeClassOrigin;
2951 gotIncludeClassOrigin = true;
2952 }
2953 else if (System::strcasecmp(name, "PropertyList") == 0)
2954 {
2955 if (!emptyTag)
2956 {
2957 CIMValue pl;
2958 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
2959 {
2960 Array<String> propertyListArray;
2961 pl.get(propertyListArray);
2962 kumpf 1.104 Array<CIMName> cimNameArray;
2963 for (Uint32 i = 0; i < propertyListArray.size(); i++)
2964 {
2965 cimNameArray.append(propertyListArray[i]);
2966 }
2967 propertyList.set(cimNameArray);
2968 }
2969 }
2970 duplicateParameter = gotPropertyList;
2971 gotPropertyList = true;
2972 }
2973 else
2974 {
2975 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
2976 }
2977
2978 if (!emptyTag)
2979 {
2980 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2981 }
2982
2983 kumpf 1.104 if (duplicateParameter)
2984 {
2985 throw PEGASUS_CIM_EXCEPTION(
2986 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2987 }
2988 }
2989
2990 if (!gotObjectName)
2991 {
2992 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
2993 }
2994
2995 AutoPtr<CIMAssociatorsRequestMessage> request(
2996 new CIMAssociatorsRequestMessage(
2997 messageId,
2998 nameSpace,
2999 objectName,
3000 assocClass,
3001 resultClass,
3002 role,
3003 resultRole,
3004 kumpf 1.104 includeQualifiers,
3005 includeClassOrigin,
3006 propertyList,
3007 QueueIdStack(queueId, _returnQueueId)));
3008
3009 STAT_SERVERSTART
3010
3011 return request.release();
3012 }
3013
3014 CIMGetPropertyRequestMessage*
3015 CIMOperationRequestDecoder::decodeGetPropertyRequest(
3016 Uint32 queueId,
3017 XmlParser& parser,
3018 const String& messageId,
3019 const CIMNamespaceName& nameSpace)
3020 {
3021 STAT_GETSTARTTIME
3022
3023 CIMObjectPath instanceName;
3024 String propertyName;
3025 kumpf 1.104 Boolean duplicateParameter = false;
3026 Boolean gotInstanceName = false;
3027 Boolean gotPropertyName = false;
3028 Boolean emptyTag;
3029
3030 for (const char* name;
3031 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3032 {
3033 if (System::strcasecmp(name, "InstanceName") == 0)
3034 {
3035 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3036 XmlReader::getInstanceNameElement(parser, instanceName);
3037 duplicateParameter = gotInstanceName;
3038 gotInstanceName = true;
3039 }
3040 else if (System::strcasecmp(name, "PropertyName") == 0)
3041 {
3042 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3043 XmlReader::getStringValueElement(parser, propertyName, true);
3044 duplicateParameter = gotPropertyName;
3045 gotPropertyName = true;
3046 kumpf 1.104 }
3047 else
3048 {
3049 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
3050 }
3051
3052 if (!emptyTag)
3053 {
3054 XmlReader::expectEndTag(parser, "IPARAMVALUE");
3055 }
3056
3057 if (duplicateParameter)
3058 {
3059 throw PEGASUS_CIM_EXCEPTION(
3060 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
3061 }
3062 }
3063
3064 if (!gotInstanceName || !gotPropertyName)
3065 {
3066 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
3067 kumpf 1.104 }
3068
3069 AutoPtr<CIMGetPropertyRequestMessage> request(
3070 new CIMGetPropertyRequestMessage(
3071 messageId,
3072 nameSpace,
3073 instanceName,
3074 propertyName,
3075 QueueIdStack(queueId, _returnQueueId)));
3076
3077 STAT_SERVERSTART
3078
3079 return request.release();
3080 }
3081
3082 CIMSetPropertyRequestMessage*
3083 CIMOperationRequestDecoder::decodeSetPropertyRequest(
3084 Uint32 queueId,
3085 XmlParser& parser,
3086 const String& messageId,
3087 const CIMNamespaceName& nameSpace)
3088 kumpf 1.104 {
3089 STAT_GETSTARTTIME
3090
3091 CIMObjectPath instanceName;
3092 String propertyName;
3093 CIMValue propertyValue;
3094 Boolean duplicateParameter = false;
3095 Boolean gotInstanceName = false;
3096 Boolean gotPropertyName = false;
3097 Boolean gotNewValue = false;
3098 Boolean emptyTag;
3099
3100 for (const char* name;
3101 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3102 {
3103 if (System::strcasecmp(name, "InstanceName") == 0)
3104 {
3105 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3106 XmlReader::getInstanceNameElement(parser, instanceName);
3107 duplicateParameter = gotInstanceName;
3108 gotInstanceName = true;
3109 kumpf 1.104 }
3110 else if (System::strcasecmp(name, "PropertyName") == 0)
3111 {
3112 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3113 XmlReader::getStringValueElement(parser, propertyName, true);
3114 duplicateParameter = gotPropertyName;
3115 gotPropertyName = true;
3116 }
3117 else if (System::strcasecmp(name, "NewValue") == 0)
3118 {
3119 if (emptyTag || !XmlReader::getPropertyValue(parser, propertyValue))
3120 {
3121 propertyValue.setNullValue(CIMTYPE_STRING, false);
3122 }
3123 duplicateParameter = gotNewValue;
3124 gotNewValue = true;
3125 }
3126 else
3127 {
3128 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
3129 }
3130 kumpf 1.104
3131 if (!emptyTag)
3132 {
3133 XmlReader::expectEndTag(parser, "IPARAMVALUE");
3134 }
3135
3136 if (duplicateParameter)
3137 {
3138 throw PEGASUS_CIM_EXCEPTION(
3139 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
3140 }
3141 }
3142
3143 if (!gotInstanceName || !gotPropertyName)
3144 {
3145 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
3146 }
3147
3148 AutoPtr<CIMSetPropertyRequestMessage> request(
3149 new CIMSetPropertyRequestMessage(
3150 messageId,
3151 kumpf 1.104 nameSpace,
3152 instanceName,
3153 propertyName,
3154 propertyValue,
3155 QueueIdStack(queueId, _returnQueueId)));
|
3156 kumpf 1.29
|
3157 kumpf 1.104 STAT_SERVERSTART
|
3158 sage 1.41
|
3159 kumpf 1.104 return request.release();
|
3160 kumpf 1.29 }
3161
3162 CIMExecQueryRequestMessage* CIMOperationRequestDecoder::decodeExecQueryRequest(
|
3163 kumpf 1.104 Uint32 queueId,
3164 XmlParser& parser,
3165 const String& messageId,
3166 const CIMNamespaceName& nameSpace)
3167 {
3168 STAT_GETSTARTTIME
3169
3170 String queryLanguage;
3171 String query;
3172 Boolean duplicateParameter = false;
3173 Boolean gotQueryLanguage = false;
3174 Boolean gotQuery = false;
3175 Boolean emptyTag;
3176
3177 for (const char* name;
3178 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3179 {
3180 if (System::strcasecmp(name, "QueryLanguage") == 0)
3181 {
3182 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3183 XmlReader::getStringValueElement(parser, queryLanguage, true);
3184 kumpf 1.104 duplicateParameter = gotQueryLanguage;
3185 gotQueryLanguage = true;
3186 }
3187 else if (System::strcasecmp(name, "Query") == 0)
3188 {
3189 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3190 XmlReader::getStringValueElement(parser, query, true);
3191 duplicateParameter = gotQuery;
3192 gotQuery = true;
3193 }
3194 else
3195 {
3196 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
3197 }
3198
3199 if (!emptyTag)
3200 {
3201 XmlReader::expectEndTag(parser, "IPARAMVALUE");
3202 }
3203
3204 if (duplicateParameter)
3205 kumpf 1.104 {
3206 throw PEGASUS_CIM_EXCEPTION(
3207 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
3208 }
3209 }
3210
3211 if (!gotQueryLanguage || !gotQuery)
3212 {
3213 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, String::EMPTY);
3214 }
3215
3216 AutoPtr<CIMExecQueryRequestMessage> request(
3217 new CIMExecQueryRequestMessage(
3218 messageId,
3219 nameSpace,
3220 queryLanguage,
3221 query,
3222 QueueIdStack(queueId, _returnQueueId)));
3223
3224 STAT_SERVERSTART
3225
3226 kumpf 1.104 return request.release();
3227 }
3228
3229 CIMInvokeMethodRequestMessage*
3230 CIMOperationRequestDecoder::decodeInvokeMethodRequest(
3231 Uint32 queueId,
3232 XmlParser& parser,
3233 const String& messageId,
3234 const CIMObjectPath& reference,
3235 const String& cimMethodName)
3236 {
3237 STAT_GETSTARTTIME
3238
3239 CIMParamValue paramValue;
3240 Array<CIMParamValue> inParameters;
3241
3242 while (XmlReader::getParamValueElement(parser, paramValue))
3243 {
3244 inParameters.append(paramValue);
3245 }
3246
3247 kumpf 1.104 AutoPtr<CIMInvokeMethodRequestMessage> request(
3248 new CIMInvokeMethodRequestMessage(
3249 messageId,
3250 reference.getNameSpace(),
3251 reference,
3252 cimMethodName,
3253 inParameters,
3254 QueueIdStack(queueId, _returnQueueId)));
|
3255 kumpf 1.9
|
3256 kumpf 1.104 STAT_SERVERSTART
|
3257 mike 1.2
|
3258 kumpf 1.104 return request.release();
|
3259 mike 1.2 }
3260
3261 void CIMOperationRequestDecoder::setServerTerminating(Boolean flag)
3262 {
|
3263 kumpf 1.104 _serverTerminating = flag;
|
3264 mike 1.2 }
3265
3266 PEGASUS_NAMESPACE_END
|
Return to
CIMOperationRequestDecoder.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Server