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