1 martin 1.121 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.122 //
|
3 martin 1.121 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
|
9 martin 1.122 //
|
10 martin 1.121 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
|
16 martin 1.122 //
|
17 martin 1.121 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.122 //
|
20 martin 1.121 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.122 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.121 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
27 martin 1.122 //
|
28 martin 1.121 //////////////////////////////////////////////////////////////////////////
|
29 mike 1.2 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include <Pegasus/Common/Config.h>
|
33 kumpf 1.28 #include <Pegasus/Common/Constants.h>
|
34 mike 1.2 #include <cctype>
35 #include <cstdio>
36 #include <Pegasus/Common/XmlParser.h>
37 #include <Pegasus/Common/XmlReader.h>
38 #include <Pegasus/Common/XmlWriter.h>
39 #include <Pegasus/Common/XmlConstants.h>
|
40 kumpf 1.51 #include <Pegasus/Common/System.h>
|
41 mike 1.2 #include <Pegasus/Common/Logger.h>
42 #include <Pegasus/Common/Tracer.h>
|
43 sage 1.41 #include <Pegasus/Common/StatisticalData.h>
|
44 mike 1.2 #include "CIMOperationRequestDecoder.h"
|
45 david 1.60 #include <Pegasus/Common/CommonUTF.h>
|
46 humberto 1.59 #include <Pegasus/Common/MessageLoader.h>
|
47 mike 1.120 #include <Pegasus/Common/BinaryCodec.h>
|
48 humberto 1.59
|
49 mike 1.2 PEGASUS_USING_STD;
50
51 PEGASUS_NAMESPACE_BEGIN
52
|
53 karl 1.127.2.5 /******************************************************************************
54 **
55 ** Local Functions
|
56 karl 1.127.2.4 **
57 ******************************************************************************/
58 // KS_TODO_PULL Expand use of these two functions to all operations.
59 // Create a propertyList with the internal tags set. Used for property
60 // lists that involve instances. Tags used in output Xml Processing
61 void _createPropertyListWithTags(XmlParser& parser, CIMPropertyList& pl)
62 {
63 CIMValue val;
64 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, val))
65 {
66 Array<String> propertyListArray;
67 val.get(propertyListArray);
68 pl.append(propertyListArray);
69 }
70 }
71
72 // Create a PropertyList without the propertyList internal tags. Used for
73 // propertylists on class operations.
74 void _createPropertyListWithoutTags(XmlParser& parser, CIMPropertyList& pl)
75 {
76 CIMValue val;
77 karl 1.127.2.4 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, val))
78 {
79 Array<String> propertyListArray;
80 val.get(propertyListArray);
81 Array<CIMName> cimNameArray;
82 for (Uint32 i = 0; i < propertyListArray.size(); i++)
83 {
84 cimNameArray.append(propertyListArray[i]);
85 }
86 pl.set(cimNameArray);
87 }
88 }
89
|
90 karl 1.127.2.5 /******************************************************************************
91 **
|
92 karl 1.127.2.4 ** CIMOperationRequestDecoder Class
93 **
94 ******************************************************************************/
|
95 karl 1.127.2.5 // throw CIM_ERR_NOT_SUPPORTED with no additional text
96 void _throwCIMExceptionCIMErrNotSupported(const String& param = String::EMPTY)
97 {
98 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, param);
99 }
100
101 // Throw CIM_ERR_INVALID_PARAMETER with optional parameter name(s)
102 void _throwCIMExceptionInvalidParameter(const String& param = String::EMPTY)
103 {
104 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, param);
105 }
106
107 // Common call for all cases where duplicate IparameterValues recieved
108 // in a single operation. Throw InvalidParameter exception with optional
109 // additional data.
110 void _throwCIMExceptionDuplicateParameter(const String& name = String::EMPTY)
111 {
112 _throwCIMExceptionInvalidParameter(name);
113 }
114
115 // Common call for cases where Invalid IParameterValue names recived
116 karl 1.127.2.5 void _throwCIMExceptionInvalidIParamName(const String& param = String::EMPTY)
117 {
118 _throwCIMExceptionCIMErrNotSupported(param);
119 }
120
|
121 mike 1.2 CIMOperationRequestDecoder::CIMOperationRequestDecoder(
|
122 sahana.prabhakar 1.126 MessageQueue* outputQueue,
|
123 kumpf 1.104 Uint32 returnQueueId)
124 : Base(PEGASUS_QUEUENAME_OPREQDECODER),
|
125 mday 1.16 _outputQueue(outputQueue),
126 _returnQueueId(returnQueueId),
127 _serverTerminating(false)
|
128 mike 1.2 {
129 }
130
131 CIMOperationRequestDecoder::~CIMOperationRequestDecoder()
132 {
133 }
134
135 void CIMOperationRequestDecoder::sendResponse(
|
136 kumpf 1.104 Uint32 queueId,
137 Buffer& message,
138 Boolean closeConnect)
139 {
140 MessageQueue* queue = MessageQueue::lookup(queueId);
141
142 if (queue)
143 {
144 AutoPtr<HTTPMessage> httpMessage(new HTTPMessage(message));
145 httpMessage->setCloseConnect(closeConnect);
146 queue->enqueue(httpMessage.release());
147 }
|
148 mike 1.2 }
149
|
150 kumpf 1.18 void CIMOperationRequestDecoder::sendIMethodError(
|
151 kumpf 1.104 Uint32 queueId,
152 HttpMethod httpMethod,
153 const String& messageId,
154 const String& iMethodName,
155 const CIMException& cimException,
156 Boolean closeConnect)
|
157 mday 1.16 {
|
158 mike 1.96 Buffer message;
|
159 kumpf 1.19 message = XmlWriter::formatSimpleIMethodErrorRspMessage(
160 iMethodName,
161 messageId,
|
162 kumpf 1.53 httpMethod,
|
163 kumpf 1.35 cimException);
|
164 kumpf 1.18
|
165 j.alex 1.95 sendResponse(queueId, message,closeConnect);
|
166 kumpf 1.18 }
|
167 mday 1.16
|
168 kumpf 1.18 void CIMOperationRequestDecoder::sendMethodError(
|
169 kumpf 1.104 Uint32 queueId,
170 HttpMethod httpMethod,
171 const String& messageId,
172 const String& methodName,
173 const CIMException& cimException,
174 Boolean closeConnect)
|
175 kumpf 1.18 {
|
176 mike 1.96 Buffer message;
|
177 kumpf 1.19 message = XmlWriter::formatSimpleMethodErrorRspMessage(
178 methodName,
179 messageId,
|
180 kumpf 1.53 httpMethod,
|
181 kumpf 1.35 cimException);
|
182 chip 1.92
|
183 j.alex 1.95 sendResponse(queueId, message,closeConnect);
|
184 mike 1.2 }
185
|
186 kumpf 1.33 void CIMOperationRequestDecoder::sendHttpError(
|
187 kumpf 1.104 Uint32 queueId,
188 const String& status,
189 const String& cimError,
190 const String& pegasusError,
191 Boolean closeConnect)
|
192 kumpf 1.21 {
|
193 mike 1.96 Buffer message;
|
194 kumpf 1.33 message = XmlWriter::formatHttpErrorRspMessage(
195 status,
196 cimError,
|
197 kumpf 1.37 pegasusError);
|
198 chip 1.92
|
199 j.alex 1.95 sendResponse(queueId, message,closeConnect);
|
200 kumpf 1.26 }
201
|
202 kumpf 1.104 void CIMOperationRequestDecoder::handleEnqueue(Message* message)
|
203 mike 1.2 {
|
204 kumpf 1.104 if (!message)
205 return;
|
206 mike 1.2
|
207 kumpf 1.104 switch (message->getType())
208 {
209 case HTTP_MESSAGE:
210 handleHTTPMessage((HTTPMessage*)message);
211 break;
|
212 kumpf 1.112
213 default:
214 // Unexpected message type
|
215 karl 1.127.2.5 PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
|
216 kumpf 1.112 break;
|
217 kumpf 1.104 }
|
218 mday 1.16
|
219 kumpf 1.104 delete message;
|
220 mday 1.16 }
|
221 mike 1.2
222
|
223 mday 1.16 void CIMOperationRequestDecoder::handleEnqueue()
224 {
|
225 kumpf 1.104 Message* message = dequeue();
226 if (message)
227 handleEnqueue(message);
|
228 mike 1.2 }
229
230 //------------------------------------------------------------------------------
231 //
232 // From the HTTP/1.1 Specification (RFC 2626):
233 //
|
234 chip 1.92 // Both types of message consist of a start-line, zero or more header fields
235 // (also known as "headers"), an empty line (i.e., a line with nothing
236 // preceding the CRLF) indicating the end of the header fields, and possibly
|
237 mike 1.2 // a message-body.
238 //
239 // Example CIM request:
240 //
|
241 chip 1.92 // M-POST /cimom HTTP/1.1
242 // HOST: www.erewhon.com
|
243 karl 1.127.2.2 // Content-Type: application/xml; charset=utf-8
|
244 chip 1.92 // Content-Length: xxxx
245 // Man: http://www.dmtf.org/cim/operation ; ns=73
246 // 73-CIMOperation: MethodCall
247 // 73-CIMMethod: EnumerateInstances
248 // 73-CIMObject: root/cimv2
249 //
|
250 mike 1.2 //------------------------------------------------------------------------------
251
252 void CIMOperationRequestDecoder::handleHTTPMessage(HTTPMessage* httpMessage)
253 {
|
254 kumpf 1.104 PEG_METHOD_ENTER(TRC_DISPATCHER,
255 "CIMOperationRequestDecoder::handleHTTPMessage()");
|
256 kumpf 1.20
|
257 kumpf 1.104 // Set the Accept-Language into the thread for this service.
258 // This will allow all code in this thread to get
259 // the languages for the messages returned to the client.
|
260 kumpf 1.114 Thread::setLanguages(httpMessage->acceptLanguages);
|
261 kumpf 1.104
262 // Save queueId:
263
264 Uint32 queueId = httpMessage->queueId;
265
266 // Save userName and authType:
267
268 String userName;
269 String authType;
270 Boolean closeConnect = httpMessage->getCloseConnect();
271
272 PEG_TRACE((
273 TRC_HTTP,
|
274 marek 1.118 Tracer::LEVEL4,
|
275 kumpf 1.104 "CIMOperationRequestDecoder::handleHTTPMessage()- "
276 "httpMessage->getCloseConnect() returned %d",
277 closeConnect));
278
|
279 sushma.fernandes 1.109 userName = httpMessage->authInfo->getAuthenticatedUser();
280 authType = httpMessage->authInfo->getAuthType();
|
281 kumpf 1.104
282 // Parse the HTTP message:
283
284 String startLine;
285 Array<HTTPHeader> headers;
286 char* content;
287 Uint32 contentLength;
288
289 httpMessage->parse(startLine, headers, contentLength);
290
291 // Parse the request line:
292
293 String methodName;
294 String requestUri;
295 String httpVersion;
296 HttpMethod httpMethod = HTTP_METHOD__POST;
297
298 HTTPMessage::parseRequestLine(
299 startLine, methodName, requestUri, httpVersion);
300
301 //
302 kumpf 1.104 // Set HTTP method for the request
303 //
304 if (methodName == "M-POST")
305 {
306 httpMethod = HTTP_METHOD_M_POST;
307 }
308
309 // Unsupported methods are caught in the HTTPAuthenticatorDelegator
310 PEGASUS_ASSERT(methodName == "M-POST" || methodName == "POST");
311
312 //
313 // Mismatch of method and version is caught in HTTPAuthenticatorDelegator
314 //
315 PEGASUS_ASSERT(!((httpMethod == HTTP_METHOD_M_POST) &&
316 (httpVersion == "HTTP/1.0")));
|
317 humberto 1.80
|
318 kumpf 1.104 // Process M-POST and POST messages:
|
319 humberto 1.80
|
320 kumpf 1.104 if (httpVersion == "HTTP/1.1")
321 {
322 // Validate the presence of a "Host" header. The HTTP/1.1 specification
323 // says this in section 14.23 regarding the Host header field:
324 //
325 // All Internet-based HTTP/1.1 servers MUST respond with a 400 (Bad
326 // Request) status code to any HTTP/1.1 request message which lacks
327 // a Host header field.
328 //
329 // Note: The Host header value is not validated.
330
|
331 kumpf 1.124 const char* hostHeader;
|
332 kumpf 1.104 Boolean hostHeaderFound = HTTPMessage::lookupHeader(
333 headers, "Host", hostHeader, false);
|
334 mike 1.2
|
335 kumpf 1.104 if (!hostHeaderFound)
336 {
337 MessageLoaderParms parms(
338 "Server.CIMOperationRequestDecoder.MISSING_HOST_HEADER",
339 "HTTP request message lacks a Host header field.");
340 sendHttpError(
341 queueId,
342 HTTP_STATUS_BADREQUEST,
343 "",
344 MessageLoader::getMessage(parms),
345 closeConnect);
346 PEG_METHOD_EXIT();
347 return;
348 }
349 }
|
350 mike 1.2
|
351 kumpf 1.104 // Validate the "CIMOperation" header:
|
352 mike 1.2
|
353 kumpf 1.124 const char* cimOperation;
|
354 karl 1.127.2.5
|
355 kumpf 1.104 // If the CIMOperation header was missing, the HTTPAuthenticatorDelegator
356 // would not have passed the message to us.
|
357 karl 1.127.2.5 PEGASUS_FCT_EXECUTE_AND_ASSERT(
358 true,
359 HTTPMessage::lookupHeader(headers, "CIMOperation", cimOperation, true));
|
360 kumpf 1.104
|
361 kumpf 1.124 if (System::strcasecmp(cimOperation, "MethodCall") != 0)
|
362 kumpf 1.104 {
363 // The Specification for CIM Operations over HTTP reads:
364 // 3.3.4. CIMOperation
365 // If a CIM Server receives CIM Operation request with this
366 // [CIMOperation] header, but with a missing value or a value
367 // that is not "MethodCall", then it MUST fail the request with
368 // status "400 Bad Request". The CIM Server MUST include a
369 // CIMError header in the response with a value of
370 // unsupported-operation.
371 MessageLoaderParms parms(
372 "Server.CIMOperationRequestDecoder."
373 "CIMOPERATION_VALUE_NOT_SUPPORTED",
374 "CIMOperation value \"$0\" is not supported.",cimOperation);
375 sendHttpError(
376 queueId,
377 HTTP_STATUS_BADREQUEST,
378 "unsupported-operation",
379 MessageLoader::getMessage(parms),
380 closeConnect);
381 PEG_METHOD_EXIT();
382 return;
383 kumpf 1.104 }
384
385 // Validate the "CIMBatch" header:
386
|
387 kumpf 1.124 const char* cimBatch;
388 if (HTTPMessage::lookupHeader(headers, "CIMBatch", cimBatch, true))
|
389 kumpf 1.104 {
390 // The Specification for CIM Operations over HTTP reads:
391 // 3.3.9. CIMBatch
392 // If a CIM Server receives CIM Operation Request for which the
393 // CIMBatch header is present, but the Server does not support
394 // Multiple Operations, then it MUST fail the request and
395 // return a status of "501 Not Implemented".
396 sendHttpError(
397 queueId,
398 HTTP_STATUS_NOTIMPLEMENTED,
399 "multiple-requests-unsupported",
400 String::EMPTY,
401 closeConnect);
402 PEG_METHOD_EXIT();
403 return;
404 }
405
406 // Save these headers for later checking
407
|
408 kumpf 1.124 const char* cimProtocolVersion;
|
409 kumpf 1.104 if (!HTTPMessage::lookupHeader(
410 headers, "CIMProtocolVersion", cimProtocolVersion, true))
411 {
412 // Mandated by the Specification for CIM Operations over HTTP
|
413 kumpf 1.124 cimProtocolVersion = "1.0";
|
414 kumpf 1.104 }
415
|
416 kumpf 1.124 String cimMethod;
|
417 kumpf 1.104 if (HTTPMessage::lookupHeader(headers, "CIMMethod", cimMethod, true))
418 {
419 if (cimMethod == String::EMPTY)
420 {
421 // This is not a valid value, and we use EMPTY to mean "absent"
422 MessageLoaderParms parms(
423 "Server.CIMOperationRequestDecoder.EMPTY_CIMMETHOD_VALUE",
424 "Empty CIMMethod value.");
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 mike 1.98
|
435 kumpf 1.104 try
436 {
437 cimMethod = XmlReader::decodeURICharacters(cimMethod);
438 }
439 catch (const ParseError&)
440 {
441 // The CIMMethod header value could not be decoded
442 MessageLoaderParms parms(
443 "Server.CIMOperationRequestDecoder."
444 "CIMMETHOD_VALUE_SYNTAX_ERROR",
445 "CIMMethod value syntax error.");
446 sendHttpError(
447 queueId,
448 HTTP_STATUS_BADREQUEST,
449 "header-mismatch",
450 MessageLoader::getMessage(parms),
451 closeConnect);
452 PEG_METHOD_EXIT();
453 return;
454 }
455 }
|
456 mike 1.2
|
457 kumpf 1.124 String cimObject;
|
458 kumpf 1.104 if (HTTPMessage::lookupHeader(headers, "CIMObject", cimObject, true))
459 {
460 if (cimObject == String::EMPTY)
461 {
462 // This is not a valid value, and we use EMPTY to mean "absent"
463 MessageLoaderParms parms(
464 "Server.CIMOperationRequestDecoder.EMPTY_CIMOBJECT_VALUE",
465 "Empty CIMObject value.");
466 sendHttpError(
467 queueId,
468 HTTP_STATUS_BADREQUEST,
469 "header-mismatch",
470 MessageLoader::getMessage(parms),
471 closeConnect);
472 PEG_METHOD_EXIT();
473 return;
474 }
|
475 mike 1.2
|
476 kumpf 1.104 try
477 {
478 cimObject = XmlReader::decodeURICharacters(cimObject);
479 }
480 catch (const ParseError&)
481 {
482 // The CIMObject header value could not be decoded
483 MessageLoaderParms parms(
484 "Server.CIMOperationRequestDecoder."
485 "CIMOBJECT_VALUE_SYNTAX_ERROR",
486 "CIMObject value syntax error.");
487 sendHttpError(
488 queueId,
489 HTTP_STATUS_BADREQUEST,
490 "header-mismatch",
491 MessageLoader::getMessage(parms),
492 closeConnect);
493 PEG_METHOD_EXIT();
494 return;
495 }
496 }
|
497 mike 1.2
|
498 kumpf 1.104 // Validate the "Content-Type" header:
|
499 mike 1.2
|
500 kumpf 1.124 const char* cimContentType;
|
501 kumpf 1.104 Boolean contentTypeHeaderFound = HTTPMessage::lookupHeader(
502 headers, "Content-Type", cimContentType, true);
|
503 kumpf 1.115 String type;
504 String charset;
|
505 mike 1.120 Boolean binaryRequest = false;
|
506 kumpf 1.115
|
507 kumpf 1.123 if (!contentTypeHeaderFound ||
|
508 kumpf 1.115 !HTTPMessage::parseContentTypeHeader(cimContentType, type, charset) ||
|
509 marek 1.127 (((!String::equalNoCase(type, "application/xml") &&
|
510 kumpf 1.115 !String::equalNoCase(type, "text/xml")) ||
|
511 kumpf 1.123 !String::equalNoCase(charset, "utf-8"))
512 && !(binaryRequest = String::equalNoCase(type,
|
513 mike 1.120 "application/x-openpegasus"))
|
514 marek 1.127 ))
|
515 kumpf 1.104 {
|
516 j.alex 1.95 MessageLoaderParms parms(
|
517 kumpf 1.104 "Server.CIMOperationRequestDecoder.CIMCONTENTTYPE_SYNTAX_ERROR",
|
518 kumpf 1.105 "HTTP Content-Type header error.");
|
519 j.alex 1.95 sendHttpError(
520 queueId,
521 HTTP_STATUS_BADREQUEST,
|
522 kumpf 1.105 "",
|
523 j.alex 1.95 MessageLoader::getMessage(parms),
524 closeConnect);
|
525 kumpf 1.104 PEG_METHOD_EXIT();
526 return;
527 }
|
528 karl 1.127.2.2 // Calculate the beginning of the content from the message size and
529 // the content length.
530 if (binaryRequest)
531 {
532 // binary the "Content" also contains a few padding '\0' to align
533 // data structures to 8byte boundary
534 // the padding '\0' are also part of the counted contentLength
535 Uint32 headerEnd = httpMessage->message.size() - contentLength;
536 Uint32 binContentStart = CIMBuffer::round(headerEnd);
537
538 contentLength = contentLength - (binContentStart - headerEnd);
539 content = (char*) httpMessage->message.getData() + binContentStart;
540 }
541 else
542 {
543 content = (char*) httpMessage->message.getData() +
544 httpMessage->message.size() - contentLength;
545 }
546
|
547 kumpf 1.104 // Validating content falls within UTF8
548 // (required to be complaint with section C12 of Unicode 4.0 spec,
549 // chapter 3.)
|
550 karl 1.127.2.2 if (!binaryRequest)
|
551 kumpf 1.104 {
552 Uint32 count = 0;
553 while(count<contentLength)
554 {
555 if (!(isUTF8((char*)&content[count])))
556 {
557 MessageLoaderParms parms(
558 "Server.CIMOperationRequestDecoder.INVALID_UTF8_CHARACTER",
559 "Invalid UTF-8 character detected.");
560 sendHttpError(
561 queueId,
562 HTTP_STATUS_BADREQUEST,
563 "request-not-valid",
564 MessageLoader::getMessage(parms),
565 closeConnect);
566
567 PEG_METHOD_EXIT();
|
568 mike 1.120 return;
|
569 kumpf 1.104 }
570 UTF8_NEXT(content,count);
571 }
572 }
573
|
574 kumpf 1.123 // Check for "Accept: application/x-openpegasus" HTTP header to see if
|
575 mike 1.120 // client can accept binary responses.
576
577 bool binaryResponse;
578
579 if (HTTPMessage::lookupHeader(headers, "Accept", type, true) &&
580 String::equalNoCase(type, "application/x-openpegasus"))
581 {
582 binaryResponse = true;
583 }
584 else
585 {
586 binaryResponse = false;
587 }
|
588 karl 1.127.2.2 httpMessage->binaryResponse=binaryResponse;
|
589 mike 1.120
|
590 kumpf 1.104 // If it is a method call, then dispatch it to be handled:
591
592 handleMethodCall(
593 queueId,
594 httpMethod,
595 content,
596 contentLength,
597 cimProtocolVersion,
598 cimMethod,
599 cimObject,
600 authType,
601 userName,
602 httpMessage->ipAddress,
603 httpMessage->acceptLanguages,
604 httpMessage->contentLanguages,
|
605 mike 1.120 closeConnect,
606 binaryRequest,
607 binaryResponse);
|
608 kumpf 1.104
609 PEG_METHOD_EXIT();
610 }
611
612 void CIMOperationRequestDecoder::handleMethodCall(
613 Uint32 queueId,
614 HttpMethod httpMethod,
615 char* content,
616 Uint32 contentLength, // used for statistics only
|
617 kumpf 1.124 const char* cimProtocolVersionInHeader,
|
618 kumpf 1.104 const String& cimMethodInHeader,
619 const String& cimObjectInHeader,
620 const String& authType,
621 const String& userName,
622 const String& ipAddress,
623 const AcceptLanguageList& httpAcceptLanguages,
624 const ContentLanguageList& httpContentLanguages,
|
625 mike 1.120 Boolean closeConnect,
626 Boolean binaryRequest,
627 Boolean binaryResponse)
|
628 kumpf 1.104 {
629 PEG_METHOD_ENTER(TRC_DISPATCHER,
630 "CIMOperationRequestDecoder::handleMethodCall()");
631
632 //
633 // If CIMOM is shutting down, return "Service Unavailable" response
634 //
635 if (_serverTerminating)
636 {
|
637 j.alex 1.95 MessageLoaderParms parms(
|
638 kumpf 1.104 "Server.CIMOperationRequestDecoder.CIMSERVER_SHUTTING_DOWN",
639 "CIM Server is shutting down.");
|
640 j.alex 1.95 sendHttpError(
641 queueId,
|
642 kumpf 1.104 HTTP_STATUS_SERVICEUNAVAILABLE,
643 String::EMPTY,
|
644 j.alex 1.95 MessageLoader::getMessage(parms),
645 closeConnect);
|
646 kumpf 1.104 PEG_METHOD_EXIT();
647 return;
648 }
649
|
650 karl 1.127.2.3 // Trace as binary display if binary request
|
651 karl 1.127.2.1 if(binaryRequest)
652 {
653 PEG_TRACE((TRC_XML,Tracer::LEVEL4,
654 "CIMOperationRequestdecoder - Binary content: Not Shown."));
655 }
656 else
657 {
658 PEG_TRACE((TRC_XML,Tracer::LEVEL4,
659 "CIMOperationRequestdecoder - XML content: %s",
660 content));
661 }
|
662 kumpf 1.104
|
663 mike 1.120 //
664 // Handle binary messages:
665 //
|
666 kumpf 1.104
667 AutoPtr<CIMOperationRequestMessage> request;
668
|
669 mike 1.120 if (binaryRequest)
|
670 kumpf 1.104 {
|
671 karl 1.127.2.2 CIMBuffer buf(content, contentLength);
672 CIMBufferReleaser buf_(buf);
|
673 mike 1.120
674 request.reset(BinaryCodec::decodeRequest(buf, queueId, _returnQueueId));
675
676 if (!request.get())
677 {
678 sendHttpError(
679 queueId,
680 HTTP_STATUS_BADREQUEST,
681 "Corrupt binary request message",
682 String::EMPTY,
683 closeConnect);
684 PEG_METHOD_EXIT();
685 return;
686 }
687 }
688 else try
689 {
690 XmlParser parser(content);
691 XmlEntry entry;
692 String messageId;
693 const char* cimMethodName = "";
694 mike 1.120
|
695 kumpf 1.104 //
696 // Process <?xml ... >
697 //
698
699 // These values are currently unused
700 const char* xmlVersion = 0;
701 const char* xmlEncoding = 0;
|
702 mike 1.2
|
703 kumpf 1.104 XmlReader::getXmlDeclaration(parser, xmlVersion, xmlEncoding);
|
704 mike 1.2
|
705 kumpf 1.104 // Expect <CIM ...>
|
706 chip 1.92
|
707 kumpf 1.104 const char* cimVersion = 0;
708 const char* dtdVersion = 0;
|
709 mike 1.2
|
710 kumpf 1.104 XmlReader::getCimStartTag(parser, cimVersion, dtdVersion);
|
711 mike 1.2
|
712 karl 1.108 if (!XmlReader::isSupportedCIMVersion(cimVersion))
|
713 kumpf 1.104 {
714 MessageLoaderParms parms(
715 "Server.CIMOperationRequestDecoder.CIM_VERSION_NOT_SUPPORTED",
716 "CIM version \"$0\" is not supported.",
717 cimVersion);
718 sendHttpError(
719 queueId,
720 HTTP_STATUS_NOTIMPLEMENTED,
721 "unsupported-cim-version",
722 MessageLoader::getMessage(parms),
723 closeConnect);
|
724 kumpf 1.23 PEG_METHOD_EXIT();
725 return;
|
726 kumpf 1.104 }
|
727 kumpf 1.23
|
728 karl 1.108 if (!XmlReader::isSupportedDTDVersion(dtdVersion))
|
729 kumpf 1.104 {
730 MessageLoaderParms parms(
731 "Server.CIMOperationRequestDecoder.DTD_VERSION_NOT_SUPPORTED",
732 "DTD version \"$0\" is not supported.",
733 dtdVersion);
734 sendHttpError(
|
735 j.alex 1.95 queueId,
|
736 kumpf 1.104 HTTP_STATUS_NOTIMPLEMENTED,
737 "unsupported-dtd-version",
738 MessageLoader::getMessage(parms),
|
739 j.alex 1.95 closeConnect);
|
740 kumpf 1.20 PEG_METHOD_EXIT();
|
741 kumpf 1.34 return;
|
742 kumpf 1.104 }
743
744 // Expect <MESSAGE ...>
745
746 String protocolVersion;
|
747 kumpf 1.73
|
748 kumpf 1.104 if (!XmlReader::getMessageStartTag(
749 parser, messageId, protocolVersion))
750 {
751 MessageLoaderParms mlParms(
752 "Server.CIMOperationRequestDecoder.EXPECTED_MESSAGE_ELEMENT",
753 "expected MESSAGE element");
|
754 mday 1.16
|
755 kumpf 1.104 throw XmlValidationError(parser.getLine(), mlParms);
756 }
|
757 mday 1.16
|
758 kumpf 1.104 // Validate that the protocol version in the header matches the XML
759 if (!String::equalNoCase(protocolVersion, cimProtocolVersionInHeader))
760 {
|
761 j.alex 1.95 MessageLoaderParms parms(
|
762 kumpf 1.104 "Server.CIMOperationRequestDecoder."
763 "CIMPROTOCOL_VERSION_MISMATCH",
764 "CIMProtocolVersion value \"$0\" does not match CIM request "
765 "protocol version \"$1\".",
766 cimProtocolVersionInHeader,
767 protocolVersion);
|
768 j.alex 1.95 sendHttpError(
769 queueId,
770 HTTP_STATUS_BADREQUEST,
771 "header-mismatch",
772 MessageLoader::getMessage(parms),
773 closeConnect);
|
774 kumpf 1.39 PEG_METHOD_EXIT();
775 return;
|
776 kumpf 1.104 }
|
777 kumpf 1.39
|
778 karl 1.108 // Accept protocol version 1.x (see Bugzilla 1556)
779 if (!XmlReader::isSupportedProtocolVersion(protocolVersion))
|
780 kumpf 1.104 {
781 // See Specification for CIM Operations over HTTP section 4.3
|
782 j.alex 1.95 MessageLoaderParms parms(
|
783 kumpf 1.104 "Server.CIMOperationRequestDecoder."
784 "CIMPROTOCOL_VERSION_NOT_SUPPORTED",
785 "CIMProtocolVersion \"$0\" is not supported.",
786 protocolVersion);
|
787 j.alex 1.95 sendHttpError(
788 queueId,
|
789 kumpf 1.104 HTTP_STATUS_NOTIMPLEMENTED,
790 "unsupported-protocol-version",
|
791 j.alex 1.95 MessageLoader::getMessage(parms),
792 closeConnect);
|
793 kumpf 1.23 PEG_METHOD_EXIT();
794 return;
|
795 kumpf 1.104 }
|
796 kumpf 1.23
|
797 kumpf 1.104 if (XmlReader::testStartTag(parser, entry, "MULTIREQ"))
798 {
799 // We wouldn't have gotten here if CIMBatch header was specified,
800 // so this must be indicative of a header mismatch
|
801 j.alex 1.95 MessageLoaderParms parms(
|
802 kumpf 1.104 "Server.CIMOperationRequestDecoder."
803 "MULTI_REQUEST_MISSING_CIMBATCH_HTTP_HEADER",
804 "Multi-request is missing CIMBatch HTTP header");
|
805 j.alex 1.95 sendHttpError(
806 queueId,
807 HTTP_STATUS_BADREQUEST,
808 "header-mismatch",
809 MessageLoader::getMessage(parms),
810 closeConnect);
|
811 kumpf 1.23 PEG_METHOD_EXIT();
812 return;
|
813 kumpf 1.104 // Future: When MULTIREQ is supported, must ensure CIMMethod and
814 // CIMObject headers are absent, and CIMBatch header is present.
815 }
816
817 // Expect <SIMPLEREQ ...>
818
819 XmlReader::expectStartTag(parser, entry, "SIMPLEREQ");
820
821 // Check for <IMETHODCALL ...>
822
823 if (XmlReader::getIMethodCallStartTag(parser, cimMethodName))
824 {
825 // The Specification for CIM Operations over HTTP reads:
826 // 3.3.6. CIMMethod
827 //
828 // This header MUST be present in any CIM Operation Request
829 // message that contains a Simple Operation Request.
830 //
831 // It MUST NOT be present in any CIM Operation Response message,
832 // nor in any CIM Operation Request message that is not a
833 // Simple Operation Request.
834 kumpf 1.104 //
835 // The name of the CIM method within a Simple Operation Request
836 // is defined to be the value of the NAME attribute of the
837 // <METHODCALL> or <IMETHODCALL> element.
838 //
839 // If a CIM Server receives a CIM Operation Request for which
840 // either:
841 //
842 // - The CIMMethod header is present but has an invalid value,
843 // or;
844 // - The CIMMethod header is not present but the Operation
845 // Request Message is a Simple Operation Request, or;
846 // - The CIMMethod header is present but the Operation Request
847 // Message is not a Simple Operation Request, or;
848 // - The CIMMethod header is present, the Operation Request
849 // Message is a Simple Operation Request, but the
850 // CIMIdentifier value (when unencoded) does not match the
851 // unique method name within the Simple Operation Request,
852 //
853 // then it MUST fail the request and return a status of
854 // "400 Bad Request" (and MUST include a CIMError header in the
855 kumpf 1.104 // response with a value of header-mismatch), subject to the
856 // considerations specified in Errors.
857 if (!String::equalNoCase(cimMethodName, cimMethodInHeader))
858 {
859 // ATTN-RK-P3-20020304: How to decode cimMethodInHeader?
860 if (cimMethodInHeader == String::EMPTY)
861 {
862 MessageLoaderParms parms(
863 "Server.CIMOperationRequestDecoder."
864 "MISSING_CIMMETHOD_HTTP_HEADER",
865 "Missing CIMMethod HTTP header.");
866 sendHttpError(
867 queueId,
868 HTTP_STATUS_BADREQUEST,
869 "header-mismatch",
870 MessageLoader::getMessage(parms),
871 closeConnect);
872 }
873 else
874 {
875 MessageLoaderParms parms(
876 kumpf 1.104 "Server.CIMOperationRequestDecoder."
877 "CIMMETHOD_VALUE_DOES_NOT_MATCH_REQUEST_METHOD",
878 "CIMMethod value \"$0\" does not match CIM request "
879 "method \"$1\".",
880 cimMethodInHeader,
881 cimMethodName);
882 sendHttpError(
883 queueId,
884 HTTP_STATUS_BADREQUEST,
885 "header-mismatch",
886 MessageLoader::getMessage(parms),
887 closeConnect);
888 }
889 PEG_METHOD_EXIT();
890 return;
891 }
|
892 kumpf 1.23
|
893 kumpf 1.104 // Expect <LOCALNAMESPACEPATH ...>
894
895 String nameSpace;
896
897 if (!XmlReader::getLocalNameSpacePathElement(parser, nameSpace))
898 {
899 MessageLoaderParms mlParms(
900 "Server.CIMOperationRequestDecoder."
901 "EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
902 "expected LOCALNAMESPACEPATH element");
903 throw XmlValidationError(parser.getLine(), mlParms);
904 }
905
906 // The Specification for CIM Operations over HTTP reads:
907 // 3.3.7. CIMObject
908 //
909 // This header MUST be present in any CIM Operation Request
910 // message that contains a Simple Operation Request.
911 //
912 // It MUST NOT be present in any CIM Operation Response message,
913 // nor in any CIM Operation Request message that is not a
914 kumpf 1.104 // Simple Operation Request.
915 //
916 // The header identifies the CIM object (which MUST be a Class
917 // or Instance for an extrinsic method, or a Namespace for an
918 // intrinsic method) on which the method is to be invoked, using
919 // a CIM object path encoded in an HTTP-safe representation.
920 //
921 // If a CIM Server receives a CIM Operation Request for which
922 // either:
923 //
924 // - The CIMObject header is present but has an invalid value,
925 // or;
926 // - The CIMObject header is not present but the Operation
927 // Request Message is a Simple Operation Request, or;
928 // - The CIMObject header is present but the Operation Request
929 // Message is not a Simple Operation Request, or;
930 // - The CIMObject header is present, the Operation Request
931 // Message is a Simple Operation Request, but the ObjectPath
932 // value does not match (where match is defined in the section
933 // section on Encoding CIM Object Paths) the Operation Request
934 // Message,
935 kumpf 1.104 //
936 // then it MUST fail the request and return a status of
937 // "400 Bad Request" (and MUST include a CIMError header in the
938 // response with a value of header-mismatch), subject to the
939 // considerations specified in Errors.
940 if (!String::equalNoCase(nameSpace, cimObjectInHeader))
941 {
942 if (cimObjectInHeader == String::EMPTY)
943 {
944 MessageLoaderParms parms(
945 "Server.CIMOperationRequestDecoder."
946 "MISSING_CIMOBJECT_HTTP_HEADER",
947 "Missing CIMObject HTTP header.");
948 sendHttpError(
949 queueId,
950 HTTP_STATUS_BADREQUEST,
951 "header-mismatch",
952 MessageLoader::getMessage(parms),
953 closeConnect);
954 }
955 else
956 kumpf 1.104 {
957 MessageLoaderParms parms(
958 "Server.CIMOperationRequestDecoder."
|
959 kumpf 1.113 "CIMOBJECT_VALUE_DOES_NOT_MATCH_REQUEST_OBJECT",
|
960 kumpf 1.104 "CIMObject value \"$0\" does not match CIM request "
961 "object \"$1\".",
962 cimObjectInHeader,
963 nameSpace);
964 sendHttpError(
965 queueId,
966 HTTP_STATUS_BADREQUEST,
967 "header-mismatch",
968 MessageLoader::getMessage(parms),
969 closeConnect);
970 }
971 PEG_METHOD_EXIT();
972 return;
973 }
974
975 // This try block only catches CIMExceptions, because they must be
976 // responded to with a proper IMETHODRESPONSE. Other exceptions are
977 // caught in the outer try block.
978 try
979 {
980 // Delegate to appropriate method to handle:
981 kumpf 1.104
982 if (System::strcasecmp(cimMethodName, "GetClass") == 0)
983 request.reset(decodeGetClassRequest(
984 queueId, parser, messageId, nameSpace));
985 else if (System::strcasecmp(cimMethodName, "GetInstance") == 0)
986 request.reset(decodeGetInstanceRequest(
987 queueId, parser, messageId, nameSpace));
988 else if (System::strcasecmp(
989 cimMethodName, "EnumerateClassNames") == 0)
990 request.reset(decodeEnumerateClassNamesRequest(
991 queueId, parser, messageId, nameSpace));
992 else if (System::strcasecmp(cimMethodName, "References") == 0)
993 request.reset(decodeReferencesRequest(
994 queueId, parser, messageId, nameSpace));
995 else if (System::strcasecmp(
996 cimMethodName, "ReferenceNames") == 0)
997 request.reset(decodeReferenceNamesRequest(
998 queueId, parser, messageId, nameSpace));
999 else if (System::strcasecmp(
1000 cimMethodName, "AssociatorNames") == 0)
1001 request.reset(decodeAssociatorNamesRequest(
1002 kumpf 1.104 queueId, parser, messageId, nameSpace));
1003 else if (System::strcasecmp(cimMethodName, "Associators") == 0)
1004 request.reset(decodeAssociatorsRequest(
1005 queueId, parser, messageId, nameSpace));
1006 else if (System::strcasecmp(
1007 cimMethodName, "CreateInstance") == 0)
1008 request.reset(decodeCreateInstanceRequest(
1009 queueId, parser, messageId, nameSpace));
1010 else if (System::strcasecmp(
1011 cimMethodName, "EnumerateInstanceNames")==0)
1012 request.reset(decodeEnumerateInstanceNamesRequest(
1013 queueId, parser, messageId, nameSpace));
1014 else if (System::strcasecmp(
1015 cimMethodName, "DeleteQualifier") == 0)
1016 request.reset(decodeDeleteQualifierRequest(
1017 queueId, parser, messageId, nameSpace));
1018 else if (System::strcasecmp(cimMethodName, "GetQualifier") == 0)
1019 request.reset(decodeGetQualifierRequest(
1020 queueId, parser, messageId, nameSpace));
1021 else if (System::strcasecmp(cimMethodName, "SetQualifier") == 0)
1022 request.reset(decodeSetQualifierRequest(
1023 kumpf 1.104 queueId, parser, messageId, nameSpace));
1024 else if (System::strcasecmp(
1025 cimMethodName, "EnumerateQualifiers") == 0)
1026 request.reset(decodeEnumerateQualifiersRequest(
1027 queueId, parser, messageId, nameSpace));
1028 else if (System::strcasecmp(
1029 cimMethodName, "EnumerateClasses") == 0)
1030 request.reset(decodeEnumerateClassesRequest(
1031 queueId, parser, messageId, nameSpace));
1032 else if (System::strcasecmp(
1033 cimMethodName, "EnumerateInstances") == 0)
1034 request.reset(decodeEnumerateInstancesRequest(
1035 queueId, parser, messageId, nameSpace));
1036 else if (System::strcasecmp(cimMethodName, "CreateClass") == 0)
1037 request.reset(decodeCreateClassRequest(
1038 queueId, parser, messageId, nameSpace));
1039 else if (System::strcasecmp(cimMethodName, "ModifyClass") == 0)
1040 request.reset(decodeModifyClassRequest(
1041 queueId, parser, messageId, nameSpace));
1042 else if (System::strcasecmp(
1043 cimMethodName, "ModifyInstance") == 0)
1044 kumpf 1.104 request.reset(decodeModifyInstanceRequest(
1045 queueId, parser, messageId, nameSpace));
1046 else if (System::strcasecmp(cimMethodName, "DeleteClass") == 0)
1047 request.reset(decodeDeleteClassRequest(
1048 queueId, parser, messageId, nameSpace));
1049 else if (System::strcasecmp(
1050 cimMethodName, "DeleteInstance") == 0)
1051 request.reset(decodeDeleteInstanceRequest(
1052 queueId, parser, messageId, nameSpace));
1053 else if (System::strcasecmp(cimMethodName, "GetProperty") == 0)
1054 request.reset(decodeGetPropertyRequest(
1055 queueId, parser, messageId, nameSpace));
1056 else if (System::strcasecmp(cimMethodName, "SetProperty") == 0)
1057 request.reset(decodeSetPropertyRequest(
1058 queueId, parser, messageId, nameSpace));
1059 else if (System::strcasecmp(cimMethodName, "ExecQuery") == 0)
1060 request.reset(decodeExecQueryRequest(
1061 queueId, parser, messageId, nameSpace));
|
1062 karl 1.127.2.1 // Pull Operations decoders
1063 else if (System::strcasecmp(
1064 cimMethodName, "OpenEnumerateInstances") == 0)
1065 request.reset(decodeOpenEnumerateInstancesRequest(
1066 queueId, parser, messageId, nameSpace));
1067
1068 else if (System::strcasecmp(
1069 cimMethodName, "OpenEnumerateInstancePaths") == 0)
1070 request.reset(decodeOpenEnumerateInstancePathsRequest(
1071 queueId, parser, messageId, nameSpace));
1072
1073 else if (System::strcasecmp(
1074 cimMethodName, "OpenReferenceInstances") == 0)
1075 request.reset(decodeOpenReferenceInstancesRequest(
1076 queueId, parser, messageId, nameSpace));
1077
1078 else if (System::strcasecmp(
1079 cimMethodName, "OpenReferenceInstancePaths") == 0)
1080 request.reset(decodeOpenReferenceInstancePathsRequest(
1081 queueId, parser, messageId, nameSpace));
1082
1083 karl 1.127.2.1 else if (System::strcasecmp(
1084 cimMethodName, "OpenAssociatorInstances") == 0)
1085 request.reset(decodeOpenAssociatorInstancesRequest(
1086 queueId, parser, messageId, nameSpace));
1087
1088 else if (System::strcasecmp(
1089 cimMethodName, "OpenAssociatorInstancePaths") == 0)
1090 request.reset(decodeOpenAssociatorInstancePathsRequest(
1091 queueId, parser, messageId, nameSpace));
1092
1093 else if (System::strcasecmp(
1094 cimMethodName, "PullInstancesWithPath") == 0)
1095 request.reset(decodePullInstancesWithPathRequest(
1096 queueId, parser, messageId, nameSpace));
1097
1098 else if (System::strcasecmp(
1099 cimMethodName, "PullInstancePaths") == 0)
1100 request.reset(decodePullInstancePathsRequest(
1101 queueId, parser, messageId, nameSpace));
1102
1103 else if (System::strcasecmp(
1104 karl 1.127.2.1 cimMethodName, "CloseEnumeration") == 0)
1105 request.reset(decodeCloseEnumerationRequest(
1106 queueId, parser, messageId, nameSpace));
1107
1108 else if (System::strcasecmp(
1109 cimMethodName, "EnumerationCount") == 0)
1110 request.reset(decodeEnumerationCountRequest(
1111 queueId, parser, messageId, nameSpace));
|
1112 karl 1.127.2.6
1113 else if (System::strcasecmp(
1114 cimMethodName, "OpenQueryInstances") == 0)
1115 request.reset(decodeOpenQueryInstancesRequest(
1116 queueId, parser, messageId, nameSpace));
|
1117 karl 1.127.2.1 // End Of Pull Operations
|
1118 kumpf 1.104 else
1119 {
1120 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
1121 MessageLoaderParms(
1122 "Server.CIMOperationRequestDecoder."
1123 "UNRECOGNIZED_INTRINSIC_METHOD",
1124 "Unrecognized intrinsic method: $0",
1125 cimMethodName));
1126 }
1127 }
1128 catch (CIMException& e)
1129 {
1130 sendIMethodError(
1131 queueId,
1132 httpMethod,
1133 messageId,
1134 cimMethodName,
1135 e,
1136 closeConnect);
1137
1138 PEG_METHOD_EXIT();
1139 kumpf 1.104 return;
1140 }
1141 catch (XmlException&)
1142 {
1143 // XmlExceptions are handled below
1144 throw;
1145 }
1146 catch (Exception& e)
1147 {
1148 // Caught an unexpected exception from decoding. Since we must
1149 // have had a problem reconstructing a CIM object, we'll treat
1150 // it as an invalid parameter
1151 sendIMethodError(
1152 queueId,
1153 httpMethod,
1154 messageId,
1155 cimMethodName,
1156 PEGASUS_CIM_EXCEPTION(
1157 CIM_ERR_INVALID_PARAMETER, e.getMessage()),
1158 closeConnect);
1159
1160 kumpf 1.104 PEG_METHOD_EXIT();
1161 return;
1162 }
1163
1164 // Expect </IMETHODCALL>
1165
1166 XmlReader::expectEndTag(parser, "IMETHODCALL");
1167 }
1168 // Expect <METHODCALL ...>
1169 else if (XmlReader::getMethodCallStartTag(parser, cimMethodName))
1170 {
1171 CIMObjectPath reference;
1172
1173 // The Specification for CIM Operations over HTTP reads:
1174 // 3.3.6. CIMMethod
1175 //
1176 // This header MUST be present in any CIM Operation Request
1177 // message that contains a Simple Operation Request.
1178 //
1179 // It MUST NOT be present in any CIM Operation Response message,
1180 // nor in any CIM Operation Request message that is not a
1181 kumpf 1.104 // Simple Operation Request.
1182 //
1183 // The name of the CIM method within a Simple Operation Request
1184 // is defined to be the value of the NAME attribute of the
1185 // <METHODCALL> or <IMETHODCALL> element.
1186 //
1187 // If a CIM Server receives a CIM Operation Request for which
1188 // either:
1189 //
1190 // - The CIMMethod header is present but has an invalid value,
1191 // or;
1192 // - The CIMMethod header is not present but the Operation
1193 // Request Message is a Simple Operation Request, or;
1194 // - The CIMMethod header is present but the Operation Request
1195 // Message is not a Simple Operation Request, or;
1196 // - The CIMMethod header is present, the Operation Request
1197 // Message is a Simple Operation Request, but the
1198 // CIMIdentifier value (when unencoded) does not match the
1199 // unique method name within the Simple Operation Request,
1200 //
1201 // then it MUST fail the request and return a status of
1202 kumpf 1.104 // "400 Bad Request" (and MUST include a CIMError header in the
1203 // response with a value of header-mismatch), subject to the
1204 // considerations specified in Errors.
1205
1206 // Extrinic methods can have UTF-8!
1207 String cimMethodNameUTF16(cimMethodName);
1208 if (cimMethodNameUTF16 != cimMethodInHeader)
1209 {
1210 // ATTN-RK-P3-20020304: How to decode cimMethodInHeader?
1211 if (cimMethodInHeader == String::EMPTY)
1212 {
1213 MessageLoaderParms parms(
1214 "Server.CIMOperationRequestDecoder."
1215 "MISSING_CIMMETHOD_HTTP_HEADER",
1216 "Missing CIMMethod HTTP header.");
1217 sendHttpError(
1218 queueId,
1219 HTTP_STATUS_BADREQUEST,
1220 "header-mismatch",
1221 MessageLoader::getMessage(parms),
1222 closeConnect);
1223 kumpf 1.104 }
1224 else
1225 {
1226 MessageLoaderParms parms(
1227 "Server.CIMOperationRequestDecoder."
1228 "CIMMETHOD_VALUE_DOES_NOT_MATCH_REQUEST_METHOD",
1229 "CIMMethod value \"$0\" does not match CIM request "
1230 "method \"$1\".",
1231 (const char*)cimMethodInHeader.getCString(),
1232 cimMethodName);
1233 sendHttpError(
1234 queueId,
1235 HTTP_STATUS_BADREQUEST,
1236 "header-mismatch",
1237 MessageLoader::getMessage(parms),
1238 closeConnect);
1239 }
1240 PEG_METHOD_EXIT();
1241 return;
1242 }
1243
1244 kumpf 1.104 //
1245 // Check for <LOCALINSTANCEPATHELEMENT> or <LOCALCLASSPATHELEMENT>
1246 //
1247 if (!(XmlReader::getLocalInstancePathElement(parser, reference) ||
1248 XmlReader::getLocalClassPathElement(parser, reference)))
1249 {
1250 MessageLoaderParms parms(
1251 "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
1252 MISSING_ELEMENT_LOCALPATH);
1253 // this throw is not updated with MLP because
1254 // MISSING_ELEMENT_LOCALPATH is a hardcoded variable,
1255 // not a message
1256 throw XmlValidationError(parser.getLine(), parms);
1257 }
1258
1259 // The Specification for CIM Operations over HTTP reads:
1260 // 3.3.7. CIMObject
1261 //
1262 // This header MUST be present in any CIM Operation Request
1263 // message that contains a Simple Operation Request.
1264 //
1265 kumpf 1.104 // It MUST NOT be present in any CIM Operation Response message,
1266 // nor in any CIM Operation Request message that is not a
1267 // Simple Operation Request.
1268 //
1269 // The header identifies the CIM object (which MUST be a Class
1270 // or Instance for an extrinsic method, or a Namespace for an
1271 // intrinsic method) on which the method is to be invoked, using
1272 // a CIM object path encoded in an HTTP-safe representation.
1273 //
1274 // If a CIM Server receives a CIM Operation Request for which
1275 // either:
1276 //
1277 // - The CIMObject header is present but has an invalid value,
1278 // or;
1279 // - The CIMObject header is not present but the Operation
1280 // Request Message is a Simple Operation Request, or;
1281 // - The CIMObject header is present but the Operation Request
1282 // Message is not a Simple Operation Request, or;
1283 // - The CIMObject header is present, the Operation Request
1284 // Message is a Simple Operation Request, but the ObjectPath
1285 // value does not match (where match is defined in the section
1286 kumpf 1.104 // section on Encoding CIM Object Paths) the Operation Request
1287 // Message,
1288 //
1289 // then it MUST fail the request and return a status of
1290 // "400 Bad Request" (and MUST include a CIMError header in the
1291 // response with a value of header-mismatch), subject to the
1292 // considerations specified in Errors.
1293 if (cimObjectInHeader == String::EMPTY)
1294 {
1295 MessageLoaderParms parms(
1296 "Server.CIMOperationRequestDecoder."
1297 "MISSING_CIMOBJECT_HTTP_HEADER",
1298 "Missing CIMObject HTTP header.");
1299 sendHttpError(
1300 queueId,
1301 HTTP_STATUS_BADREQUEST,
1302 "header-mismatch",
1303 MessageLoader::getMessage(parms),
1304 closeConnect);
1305 PEG_METHOD_EXIT();
1306 return;
1307 kumpf 1.104 }
1308
1309 CIMObjectPath headerObjectReference;
1310 try
1311 {
1312 headerObjectReference.set(cimObjectInHeader);
1313 }
1314 catch (Exception&)
1315 {
1316 MessageLoaderParms parms(
1317 "Server.CIMOperationRequestDecoder."
1318 "COULD_NOT_PARSE_CIMOBJECT_VALUE",
1319 "Could not parse CIMObject value \"$0\".",
1320 cimObjectInHeader);
1321 sendHttpError(
1322 queueId,
1323 HTTP_STATUS_BADREQUEST,
1324 "header-mismatch",
1325 MessageLoader::getMessage(parms),
1326 closeConnect);
1327 PEG_METHOD_EXIT();
1328 kumpf 1.104 return;
1329 }
1330
1331 if (!reference.identical(headerObjectReference))
1332 {
1333 MessageLoaderParms parms(
1334 "Server.CIMOperationRequestDecoder."
|
1335 kumpf 1.113 "CIMOBJECT_VALUE_DOES_NOT_MATCH_REQUEST_OBJECT",
|
1336 kumpf 1.104 "CIMObject value \"$0\" does not match CIM request "
1337 "object \"$1\".",
1338 cimObjectInHeader,
|
1339 kumpf 1.113 reference.toString());
|
1340 kumpf 1.104 sendHttpError(
1341 queueId,
1342 HTTP_STATUS_BADREQUEST,
1343 "header-mismatch",
1344 MessageLoader::getMessage(parms),
1345 closeConnect);
1346 PEG_METHOD_EXIT();
1347 return;
1348 }
1349
1350 // This try block only catches CIMExceptions, because they must be
1351 // responded to with a proper METHODRESPONSE. Other exceptions are
1352 // caught in the outer try block.
1353 try
1354 {
1355 // Delegate to appropriate method to handle:
1356
1357 request.reset(decodeInvokeMethodRequest(
1358 queueId,
1359 parser,
1360 messageId,
1361 kumpf 1.104 reference,
1362 cimMethodNameUTF16)); // contains UTF-16 converted from UTF-8
1363 }
1364 catch (CIMException& e)
1365 {
1366 sendMethodError(
1367 queueId,
1368 httpMethod,
1369 messageId,
1370 cimMethodNameUTF16, // contains UTF-16 converted from UTF-8
1371 e,
1372 closeConnect);
1373
1374 PEG_METHOD_EXIT();
1375 return;
1376 }
1377 catch (XmlException&)
1378 {
1379 // XmlExceptions are handled below
1380 throw;
1381 }
1382 kumpf 1.104 catch (Exception& e)
1383 {
1384 // Caught an unexpected exception from decoding. Since we must
1385 // have had a problem reconstructing a CIM object, we'll treata
1386 // it as an invalid parameter
1387 sendMethodError(
1388 queueId,
1389 httpMethod,
1390 messageId,
1391 cimMethodNameUTF16, // contains UTF-16 converted from UTF-8
1392 PEGASUS_CIM_EXCEPTION(
1393 CIM_ERR_INVALID_PARAMETER, e.getMessage()),
1394 closeConnect);
1395
1396 PEG_METHOD_EXIT();
1397 return;
1398 }
|
1399 kumpf 1.73
|
1400 kumpf 1.104 // Expect </METHODCALL>
|
1401 mday 1.16
|
1402 kumpf 1.104 XmlReader::expectEndTag(parser, "METHODCALL");
1403 }
1404 else
1405 {
1406 MessageLoaderParms mlParms(
1407 "Server.CIMOperationRequestDecoder.EXPECTED_IMETHODCALL_ELEMENT",
1408 "expected IMETHODCALL or METHODCALL element");
1409 throw XmlValidationError(parser.getLine(),mlParms);
1410 }
1411
1412 // Expect </SIMPLEREQ>
1413
1414 XmlReader::expectEndTag(parser, "SIMPLEREQ");
1415
1416 // Expect </MESSAGE>
1417
1418 XmlReader::expectEndTag(parser, "MESSAGE");
1419
1420 // Expect </CIM>
1421
1422 XmlReader::expectEndTag(parser, "CIM");
1423 kumpf 1.104 }
1424 catch (XmlValidationError& e)
1425 {
|
1426 thilo.boehm 1.119 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
|
1427 kumpf 1.104 "CIMOperationRequestDecoder::handleMethodCall - "
|
1428 marek 1.116 "XmlValidationError exception has occurred. Message: %s",
1429 (const char*) e.getMessage().getCString()));
|
1430 kumpf 1.24
|
1431 kumpf 1.104 sendHttpError(
1432 queueId,
1433 HTTP_STATUS_BADREQUEST,
1434 "request-not-valid",
1435 e.getMessage(),
1436 closeConnect);
1437 PEG_METHOD_EXIT();
1438 return;
1439 }
1440 catch (XmlSemanticError& e)
1441 {
|
1442 thilo.boehm 1.119 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
|
1443 kumpf 1.104 "CIMOperationRequestDecoder::handleMethodCall - "
|
1444 marek 1.116 "XmlSemanticError exception has occurred. Message: %s",
1445 (const char*) e.getMessage().getCString()));
|
1446 mday 1.16
|
1447 kumpf 1.104 // ATTN-RK-P2-20020404: Is this the correct response for these errors?
1448 sendHttpError(
1449 queueId,
1450 HTTP_STATUS_BADREQUEST,
1451 "request-not-valid",
1452 e.getMessage(),
1453 closeConnect);
1454 PEG_METHOD_EXIT();
1455 return;
1456 }
1457 catch (XmlException& e)
1458 {
|
1459 thilo.boehm 1.119 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
|
1460 kumpf 1.104 "CIMOperationRequestDecoder::handleMethodCall - "
|
1461 marek 1.116 "XmlException has occurred. Message: %s",
1462 (const char*) e.getMessage().getCString()));
|
1463 kumpf 1.104
1464 sendHttpError(
1465 queueId,
1466 HTTP_STATUS_BADREQUEST,
1467 "request-not-well-formed",
1468 e.getMessage(),
1469 closeConnect);
1470 PEG_METHOD_EXIT();
1471 return;
1472 }
|
1473 karl 1.127.2.5 catch (TooManyElementsException& e)
1474 {
1475 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
1476 "CIMOperationRequestDecoder::handleMethodCall - "
1477 "TooManyElementsException has occurred. Message: %s",
1478 (const char*) e.getMessage().getCString()));
1479
1480 sendHttpError(
1481 queueId,
1482 HTTP_STATUS_BADREQUEST,
1483 "request-with-too-many-elements",
1484 e.getMessage(),
1485 closeConnect);
1486 PEG_METHOD_EXIT();
1487 return;
1488 }
|
1489 kumpf 1.104 catch (Exception& e)
1490 {
1491 // Don't know why I got this exception. Seems like a bad thing.
1492 // Any exceptions we're expecting should be caught separately and
1493 // dealt with appropriately. This is a last resort.
1494 sendHttpError(
1495 queueId,
1496 HTTP_STATUS_INTERNALSERVERERROR,
1497 String::EMPTY,
1498 e.getMessage(),
1499 closeConnect);
1500 PEG_METHOD_EXIT();
1501 return;
1502 }
1503 catch (...)
1504 {
1505 // Don't know why I got whatever this is. Seems like a bad thing.
1506 // Any exceptions we're expecting should be caught separately and
1507 // dealt with appropriately. This is a last resort.
1508 sendHttpError(
1509 queueId,
1510 kumpf 1.104 HTTP_STATUS_INTERNALSERVERERROR,
1511 String::EMPTY,
1512 String::EMPTY,
1513 closeConnect);
1514 PEG_METHOD_EXIT();
1515 return;
1516 }
1517
1518 STAT_BYTESREAD
1519
1520 request->authType = authType;
1521 request->userName = userName;
1522 request->ipAddress = ipAddress;
1523 request->setHttpMethod (httpMethod);
|
1524 mike 1.120 request->binaryResponse = binaryResponse;
|
1525 sage 1.41
|
1526 chuck 1.58 //l10n start
1527 // l10n TODO - might want to move A-L and C-L to Message
1528 // to make this more maintainable
|
1529 kumpf 1.104 // Add the language headers to the request
1530 CIMMessage* cimmsg = dynamic_cast<CIMMessage*>(request.get());
1531 if (cimmsg != NULL)
1532 {
1533 cimmsg->operationContext.insert(IdentityContainer(userName));
1534 cimmsg->operationContext.set(
1535 AcceptLanguageListContainer(httpAcceptLanguages));
1536 cimmsg->operationContext.set(
1537 ContentLanguageListContainer(httpContentLanguages));
1538 }
1539 else
1540 {
1541 ; // l10n TODO - error back to client here
1542 }
|
1543 chip 1.92 // l10n end
|
1544 chuck 1.58
|
1545 kumpf 1.104 request->setCloseConnect(closeConnect);
1546 _outputQueue->enqueue(request.release());
|
1547 chip 1.92
|
1548 kumpf 1.104 PEG_METHOD_EXIT();
|
1549 mike 1.2 }
|
1550 karl 1.127.2.5 /**************************************************************************
1551 **
1552 ** Decode CIM Operation Type Common IParameter types.
1553 ** Each class defines processing for a particular IPARAM type
1554 ** (ex. boolean)or parameter name (i.e. propertyListIParam)
1555 ** Each struct defines:
1556 ** got - Boolean defines whether this parameter has been found
1557 ** value - The value container for this type
1558 ** iParamFound(...) - function sets the duplicate flag and the got flag
1559 ** get - Function to get the defined parameter from the
1560 ** parser
1561 ** NOTE: at least one has multiple get.. functions.
1562 ** NOTE: Some of these are defined for a particular attribute (ex.
1563 ** propertyListIparam) so the attribute name is integrated into the
1564 ** methods and others for a whole class of attributes (Boolean,
1565 ** String,ClassName etc.) so the attribute name is defined as part
1566 ** of the constructor.
1567 ***************************************************************************/
1568 // Common xml attribute accessor for all boolean attributes. The
1569 // attribute name is defined in the constructor.
1570 // The usage pattern is:
1571 karl 1.127.2.5 // Boolean duplicate; // Flag to indicate multiple calls
1572 //
1573 // booleanIParam xyz("xyz"); default is false for attribute xyz
1574 //
1575 // if(xyz.get(parser, name, emptyTag) // parses to test if name == xyz
1576 // iParamFound(duplicate); // set flag to indicate exists etc.
1577 class booleanIParam
1578 {
1579 public:
1580 Boolean got;
1581 Boolean value;
1582
1583 // constructor with default value = false
1584 booleanIParam(const char* name): got(false),value(false),iParamName(name){}
1585
1586 // constructor with initial value specifically set from the input
1587 booleanIParam(const char* name, Boolean _value):
1588 got(false),value(_value),iParamName(name){}
1589
1590 ~booleanIParam(){}
1591
1592 karl 1.127.2.5 void iParamFound(Boolean& duplicate)
1593 {
1594 duplicate = got;
1595 got = true;
1596 }
1597
1598 // get the value of the parameter if the parameter if it exists.
1599 // Note that the attribute name is defined in the constructor
1600 // Value is required.
1601 // @param parser
1602 // @param testName attribute name from parse.
1603 // @emptyTag returns true if emptyTag returned true from parser
1604 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
1605 {
1606 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
1607 {
1608 XmlReader::rejectNullIParamValue(parser, emptyTag,
1609 iParamName.getCString());
1610 XmlReader::getBooleanValueElement(parser, value, true);
1611 return true;
1612 }
1613 karl 1.127.2.5 return false;
1614 }
1615 private:
1616 String iParamName;
1617 // hide unused default constructor and assign, copy constructors
1618 booleanIParam();
1619 booleanIParam(const booleanIParam&);
1620 booleanIParam& operator = (const booleanIParam&);
1621 };
1622
1623 // decode Iparam to CIMName representing class names. This struct
1624 // has two get functions:
1625 // get - parse where the parameter value is required
1626 // getOptional - parse where the parameter value is optional
1627
1628 class classNameIParam
1629 {
1630 public:
1631 Boolean got;
1632 CIMName value;
1633
1634 karl 1.127.2.5 // Set the flag to inidcate that this IParam has been gotten and also
1635 // set the flag defined by the duplicate parameter
1636 // @param duplicate Boolean that is set to previous value of the got
1637 // variable indicating whether this is second call to this IParam
1638 void iParamFound(Boolean& duplicate)
1639 {
1640 duplicate = got;
1641 got = true;
1642 }
1643
1644 // construct an IParam definition with name.
1645 // @param name const char* defining name of IParam to match
1646 // @return true if IParam found with _attrName
1647 classNameIParam(const char* name): got(false), iParamName(name){}
1648
1649 ~classNameIParam(){}
1650
1651 // Get Required value element.Test for name parameter as IParam with
1652 // name and if found, if value not NULL, parse the className and
1653 // set into value
1654 Boolean get(XmlParser& parser, const char* name, Boolean& emptyTag)
1655 karl 1.127.2.5 {
1656 if (System::strcasecmp(name,iParamName.getCString()) == 0)
1657 {
1658 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1659 XmlReader::getClassNameElement(parser, value, true);
1660 return true;
1661 }
1662 return false;
1663 }
1664 // Get Iparam with optional value.
1665 Boolean getOptional(XmlParser& parser, const char* name,
1666 Boolean& emptyTag)
1667 {
1668 if (System::strcasecmp(name, iParamName.getCString()) == 0)
1669 {
1670 // value may be NULL
1671 if (!emptyTag)
1672 {
1673 XmlReader::getClassNameElement(parser, value, false);
1674 }
1675 return true;
1676 karl 1.127.2.5 }
1677 return false;
1678 }
1679 private:
1680 String iParamName;
1681 // hide unused default constructor and assign, copy constructors
1682 classNameIParam();
1683 classNameIParam(const classNameIParam&);
1684 classNameIParam& operator = (const classNameIParam&);
1685 };
1686
1687 // test for "InstanceName" iParam and if found, return CIMObjectPath
1688 // in value
1689 class instanceNameIParam
1690 {
1691 public:
1692 Boolean got;
1693 CIMObjectPath value;
1694
1695 void iParamFound(Boolean& duplicate)
1696 {
1697 karl 1.127.2.5 duplicate = got;
1698 got = true;
1699 }
1700 instanceNameIParam(): got(false){}
1701
1702 ~instanceNameIParam(){}
1703
1704 Boolean get(XmlParser& parser, const char * name, Boolean& emptyTag)
1705 {
1706 if (System::strcasecmp(name, "InstanceName") == 0)
1707 {
1708 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1709 XmlReader::getInstanceNameElement(parser, value);
1710 return true;
1711 }
1712 return false;
1713 }
1714 private:
1715 // hide unused assign, copy constructors
1716 instanceNameIParam(const instanceNameIParam&);
1717 instanceNameIParam& operator = (const instanceNameIParam&);
1718 karl 1.127.2.5 };
1719
1720 // test for "ObjectName" attribute and if found, return CIMObjectPath
1721 // This struct has an extra attribute, the flag isClassNameElement which
1722 // returns true if the objectName was a classPath and not an instance
1723 // path.
1724 // If Xmlreader returns true, this is class only element, no
1725 // key bindings. That state must be set into the request
1726 // message (ex. objectName.isClassElement)
1727 // @param (Optional) Name of IParam. Default is ObjectName. Note
1728 // that pull operations use InstanceName as IParamName.
1729 class objectNameIParam
1730 {
1731 public:
1732 Boolean got;
1733 CIMObjectPath value;
1734 Boolean isClassNameElement;
1735
1736 void iParamFound(Boolean& duplicate)
1737 {
1738 duplicate = got;
1739 karl 1.127.2.5 got = true;
1740 }
1741
1742 // Constructor using default IParam name
1743 objectNameIParam(): got(false), isClassNameElement(false),
1744 iParamName("ObjectName"){}
1745
1746 // Constructor with IParam name included
1747 objectNameIParam(const char* name): got(false), isClassNameElement(false),
1748 iParamName(name){}
1749
1750 ~objectNameIParam(){}
1751
1752 Boolean get(XmlParser& parser, const char * name, Boolean& emptyTag)
1753 {
1754 if (System::strcasecmp(name, iParamName.getCString()) == 0)
1755 {
1756 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1757 isClassNameElement =
1758 XmlReader::getObjectNameElement(parser, value);
1759 return true;
1760 karl 1.127.2.5 }
1761 return false;
1762 }
1763 private:
1764 String iParamName;
1765 // hide unused assign, copy constructors
1766 objectNameIParam(const objectNameIParam&);
1767 objectNameIParam& operator = (const objectNameIParam&);
1768 };
1769
1770 // test for "PropertyList" attribute and, if found, return property list
1771 // in the value element.
1772 class propertyListIParam
1773 {
1774 public:
1775 Boolean got;
1776 CIMPropertyList value;
1777
1778 void iParamFound(Boolean& duplicate)
1779 {
1780 duplicate = got;
1781 karl 1.127.2.5 got = true;
1782 }
1783
1784 // construct a propertyListIParam object
1785 propertyListIParam(): got(false){}
1786
1787 ~propertyListIParam(){}
1788
1789 Boolean get(XmlParser& parser, const char* name, Boolean& emptyTag)
1790 {
1791 if (System::strcasecmp(name, "PropertyList") == 0)
1792 {
1793 if (!emptyTag)
1794 {
1795 CIMValue pl;
1796 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
1797 {
1798 Array<String> propertyListArray;
1799 pl.get(propertyListArray);
1800 // NOTE: Cannot use the propertyList.set(...) method
1801 // here because set does not create propertyList tags
1802 karl 1.127.2.5 value.append(propertyListArray);
1803 }
1804 }
1805 return true;
1806 }
1807 return false;
1808 }
1809
1810 // This version of the get function usees the propertyList set function
1811 // to set the property list array into the propertyList object. It
1812 // can only be used for those Operations where the propertylist is NOT
1813 // used by the Server in the response (i.e. getClass and modifyInstance).
1814 //
1815 Boolean getSpecial(XmlParser& parser, const char* name, Boolean& emptyTag)
1816 {
1817 if (System::strcasecmp(name, "PropertyList") == 0)
1818 {
1819 if (!emptyTag)
1820 {
1821 CIMValue pl;
1822 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
1823 karl 1.127.2.5 {
1824 Array<String> propertyListArray;
1825 pl.get(propertyListArray);
1826 Array<CIMName> cimNameArray;
1827 // Map the strings to CIMNames.
1828 for (Uint32 i = 0; i < propertyListArray.size(); i++)
1829 {
1830 cimNameArray.append(propertyListArray[i]);
1831 }
1832 // use set to put list into property list without
1833 // setting propertyList tags.
1834 value.set(cimNameArray);
1835 }
1836 }
1837 return true;
1838 }
1839 return false;
1840 }
1841 private:
1842 // hide unused default assign, copy constructors
1843 propertyListIParam(const propertyListIParam&);
1844 karl 1.127.2.5 propertyListIParam& operator = (const propertyListIParam&);
1845 };
1846
1847 // Attribute decoder for String Parameters
1848 // The constructor MUST include the attribute name.
1849 // The second defines whether a value is required.
1850 // If true and there is no value, the XmlReader does an exception.
1851 class stringIParam
1852 {
1853 public:
1854 Boolean got;
1855 String value;
1856
1857 // constructor with definition of attribute and default for the
1858 // required flag.
1859 // @param name const char* with name of IParam to match
1860 // @param valueRequired Boolean that defines whether value is required
1861 stringIParam(const char* name, Boolean _valueRequired):
1862 got(false), iParamName(name), valueRequired(_valueRequired){}
1863
1864 ~stringIParam(){}
1865 karl 1.127.2.5
1866 void iParamFound(Boolean& duplicate)
1867 {
1868 duplicate = got;
1869 got = true;
1870 }
1871
1872 // get the attribute if it exists. The attribute name is defined in
1873 // the constructor
1874 // @param parser
1875 // @param testName attribute name from parse.
1876 // @emptyTag returns true if emptyTag returned true from parser
1877 // @return Returns true if testName matches the IParam defined by current
1878 // position in the parser
1879 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
1880 {
1881 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
1882 {
1883 if (!emptyTag)
1884 {
1885 XmlReader::getStringValueElement(parser, value, valueRequired);
1886 karl 1.127.2.5 }
1887 return true;
1888 }
1889 return false;
1890 }
1891 private:
1892 String iParamName;
1893 Boolean valueRequired;
1894 stringIParam();
1895 stringIParam(const stringIParam&);
1896 stringIParam& operator = (const stringIParam&);
1897 };
1898
1899 // Attribute decoder for Uint32Arg Parameters
1900 // The constructor MUST include the attribute name.
1901 // The second defines whether a value is required.
1902 // If true and there is no value, the XmlReader does an exception.
1903 //
|
1904 karl 1.127.2.6 //// KS_TODO NEED REVIEW ON THIS ONE
|
1905 karl 1.127.2.5 class uint32ArgIParam
1906 {
1907 public:
1908 Boolean got;
1909 Uint32Arg value;
1910
1911 // constructor with definition of iParam name and default for the
1912 // required flag (false). Default value of parameter is NULL if
1913 // no value is supplied.
1914 // @param name const char* with name of IParam to match
1915 uint32ArgIParam(const char* name):
1916 got(false), iParamName(name), valueRequired(false){}
1917
1918 // constructor with definition of iParam name and default for the
1919 // required flag (false). Default value of parameter is integer defined
1920 // by supplied value.
1921 // @param name const char* with name of IParam to match
1922 uint32ArgIParam(const char* name, Uint32 _int):
1923 got(false), value(_int), iParamName(name), valueRequired(false){}
1924
1925 // constructor with definition of attribute and default for the
1926 karl 1.127.2.5 // required flag.
1927 // @param name const char* with name of IParam to match
1928 // @param valueRequired Boolean that defines whether value is required
1929 //// uint32ArgIParam(const char* name, Boolean _valueRequired):
1930 //// got(false), iParamName(name), valueRequired(_valueRequired){}
1931
1932 ~uint32ArgIParam(){}
1933
1934 void iParamFound(Boolean& duplicate)
1935 {
1936 duplicate = got;
1937 got = true;
1938 }
1939
1940 // get the attribute if it exists. The attribute name is defined in
1941 // the constructor
1942 // @param parser
1943 // @param testName attribute name from parse.
1944 // @emptyTag returns true if emptyTag returned true from parser
1945 // @return Returns true if testName matches the IParam defined by current
1946 // position in the parser
1947 karl 1.127.2.5 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
1948 {
1949 if (valueRequired)
1950 {
1951 XmlReader::rejectNullIParamValue(parser, emptyTag, testName);
1952 }
1953 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
1954 {
1955 XmlReader::getUint32ArgValueElement(parser, value, true);
1956 return true;
1957 }
1958 return false;
1959 }
1960 private:
1961 String iParamName;
1962 Boolean valueRequired;
1963 uint32ArgIParam();
1964 uint32ArgIParam(const uint32ArgIParam&);
1965 uint32ArgIParam& operator = (const uint32ArgIParam&);
1966 };
1967
1968 karl 1.127.2.5 // Attribute decoder for Uint32 Parameters
1969 // The constructor MUST include the attribute name.
1970 // The second defines whether a value is required.
1971 // If true and there is no value, the XmlReader does an exception.
1972 class uint32IParam
1973 {
1974 public:
1975 Boolean got;
1976 Uint32 value;
1977
1978 // constructor with definition of iParam name and default for the
1979 // required flag (false). Default value of parameter is NULL if
1980 // no value is supplied.
1981 // @param name const char* with name of IParam to match
1982 uint32IParam(const char* name):
1983 got(false), iParamName(name), valueRequired(false){}
1984
1985 // constructor with definition of iParam name and default for the
1986 // required flag (false). Default value of parameter is integer defined
1987 // by supplied value.
1988 // @param name const char* with name of IParam to match
1989 karl 1.127.2.5 uint32IParam(const char* name, Uint32 _int):
1990 got(false), value(_int), iParamName(name), valueRequired(false){}
1991
1992 // constructor with definition of attribute and default for the
1993 // required flag.
1994 // @param name const char* with name of IParam to match
1995 // @param valueRequired Boolean that defines whether value is required
1996 //// uint32IParam(const char* name, Boolean _valueRequired):
1997 //// got(false), iParamName(name), valueRequired(_valueRequired){}
1998
1999 ~uint32IParam(){}
2000
2001 void iParamFound(Boolean& duplicate)
2002 {
2003 duplicate = got;
2004 got = true;
2005 }
2006
2007 // get the attribute if it exists. The attribute name is defined in
2008 // the constructor
2009 // @param parser
2010 karl 1.127.2.5 // @param testName attribute name from parse.
2011 // @emptyTag returns true if emptyTag returned true from parser
2012 // @return Returns true if testName matches the IParam defined by current
2013 // position in the parser
2014 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
2015 {
2016 if (valueRequired)
2017 {
2018 XmlReader::rejectNullIParamValue(parser, emptyTag, testName);
2019 }
2020 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
2021 {
2022 XmlReader::getUint32ValueElement(parser, value, true);
2023 return true;
2024 }
2025 return false;
2026 }
2027 private:
2028 String iParamName;
2029 Boolean valueRequired;
2030 uint32IParam();
2031 karl 1.127.2.5 uint32IParam(const uint32IParam&);
2032 uint32IParam& operator = (const uint32IParam&);
2033 };
2034
2035 /************************************************************************
2036 **
2037 ** Common functions used by the decoders to avoid duplicate code.
2038 **
2039 **************************************************************************/
2040 // test for valid end of XML and duplicate parameters on input
2041 // This function returns if OK or executes appropriate exceptions if there
2042 // is either a duplicate (duplicateParameter == true) or the
2043 // end tag IPARAMVALUE is not found.
2044 void _checkMissingEndTagOrDuplicateParamValue(
2045 XmlParser& parser, Boolean duplicateParameter, Boolean emptyTag)
2046 {
2047 if (!emptyTag)
2048 {
2049 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2050 }
2051
2052 karl 1.127.2.5 if (duplicateParameter)
2053 {
2054 _throwCIMExceptionDuplicateParameter();
2055 }
2056 }
2057
2058 // test if Required paramters exist (i.e. the got variable is
2059 // true. Generates exception if exist == false
2060 void _testRequiredParametersExist(Boolean exist)
2061 {
2062 if (!exist)
2063 {
2064 _throwCIMExceptionInvalidParameter();
2065 }
2066 }
2067 /**************************************************************************
2068 **
2069 ** Decode each CIMOperation type, processing the parameters for that type
2070 ** and producing either a CIMMessage of the appropriate type or
2071 ** an exception.
2072 **
2073 karl 1.127.2.5 ***************************************************************************/
|
2074 mike 1.2
|
2075 kumpf 1.104 CIMCreateClassRequestMessage*
2076 CIMOperationRequestDecoder::decodeCreateClassRequest(
2077 Uint32 queueId,
2078 XmlParser& parser,
2079 const String& messageId,
2080 const CIMNamespaceName& nameSpace)
2081 {
2082 STAT_GETSTARTTIME
2083
2084 CIMClass newClass;
|
2085 karl 1.127.2.5 Boolean gotNewClass = false;
2086
|
2087 kumpf 1.104 Boolean emptyTag;
|
2088 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2089 kumpf 1.104
2090 for (const char* name;
2091 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2092 {
2093 if (System::strcasecmp(name, "NewClass") == 0)
2094 {
2095 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
|
2096 kumpf 1.106 if (!XmlReader::getClassElement(parser, newClass))
2097 {
|
2098 karl 1.127.2.5 _throwCIMExceptionInvalidParameter("NewClass");
|
2099 kumpf 1.106 }
|
2100 karl 1.127.2.5 duplicateParameter = gotNewClass;
2101 gotNewClass = true;
|
2102 kumpf 1.104 }
2103 else
2104 {
|
2105 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2106 kumpf 1.104 }
|
2107 sage 1.41
|
2108 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2109 _checkMissingEndTagOrDuplicateParamValue(
2110 parser, duplicateParameter, emptyTag);
|
2111 kumpf 1.104 }
2112
|
2113 karl 1.127.2.5 _testRequiredParametersExist(gotNewClass);
|
2114 kumpf 1.104
2115 AutoPtr<CIMCreateClassRequestMessage> request(
2116 new CIMCreateClassRequestMessage(
2117 messageId,
2118 nameSpace,
2119 newClass,
2120 QueueIdStack(queueId, _returnQueueId)));
2121
2122 STAT_SERVERSTART
2123
2124 return request.release();
|
2125 mike 1.2 }
2126
2127 CIMGetClassRequestMessage* CIMOperationRequestDecoder::decodeGetClassRequest(
|
2128 kumpf 1.104 Uint32 queueId,
2129 XmlParser& parser,
2130 const String& messageId,
2131 const CIMNamespaceName& nameSpace)
2132 {
2133 STAT_GETSTARTTIME
2134
|
2135 karl 1.127.2.5 // GetClass Parameters
2136 classNameIParam className("ClassName");
2137 booleanIParam localOnly("localOnly",true);
2138 booleanIParam includeQualifiers("IncludeQualifiers", true);
2139 booleanIParam includeClassOrigin("IncludeClassOrigin");
2140 propertyListIParam propertyList;
2141
|
2142 kumpf 1.104 Boolean duplicateParameter = false;
2143 Boolean emptyTag;
2144
2145 for (const char* name;
2146 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2147 {
|
2148 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2149 kumpf 1.104 {
|
2150 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2151 kumpf 1.104 }
|
2152 karl 1.127.2.5 else if(localOnly.get(parser, name, emptyTag))
|
2153 kumpf 1.104 {
|
2154 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2155 kumpf 1.104 }
|
2156 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2157 kumpf 1.104 {
|
2158 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2159 kumpf 1.104 }
|
2160 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2161 kumpf 1.104 {
|
2162 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2163 kumpf 1.104 }
|
2164 karl 1.127.2.5 else if(propertyList.getSpecial(parser, name, emptyTag))
|
2165 kumpf 1.104 {
|
2166 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2167 kumpf 1.104 }
2168 else
2169 {
|
2170 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2171 kumpf 1.104 }
|
2172 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2173 _checkMissingEndTagOrDuplicateParamValue(
2174 parser, duplicateParameter, emptyTag);
|
2175 kumpf 1.104 }
2176
|
2177 karl 1.127.2.5 // test for required parameters
2178 _testRequiredParametersExist(className.got);
|
2179 kumpf 1.104
|
2180 karl 1.127.2.5 // Build message
|
2181 kumpf 1.104 AutoPtr<CIMGetClassRequestMessage> request(new CIMGetClassRequestMessage(
2182 messageId,
2183 nameSpace,
|
2184 karl 1.127.2.5 className.value,
2185 localOnly.value,
2186 includeQualifiers.value,
2187 includeClassOrigin.value,
2188 propertyList.value,
|
2189 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2190
2191 STAT_SERVERSTART
2192
2193 return request.release();
2194 }
2195
2196 CIMModifyClassRequestMessage*
2197 CIMOperationRequestDecoder::decodeModifyClassRequest(
2198 Uint32 queueId,
2199 XmlParser& parser,
2200 const String& messageId,
2201 const CIMNamespaceName& nameSpace)
2202 {
2203 STAT_GETSTARTTIME
2204
2205 CIMClass modifiedClass;
2206 Boolean gotClass = false;
|
2207 karl 1.127.2.5
|
2208 kumpf 1.104 Boolean emptyTag;
|
2209 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2210 kumpf 1.104
2211 for (const char* name;
2212 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2213 {
2214 if (System::strcasecmp(name, "ModifiedClass") == 0)
2215 {
2216 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
|
2217 kumpf 1.106 if (!XmlReader::getClassElement(parser, modifiedClass))
2218 {
|
2219 karl 1.127.2.5 _throwCIMExceptionInvalidParameter("ModifiedClass");
|
2220 kumpf 1.106 }
|
2221 kumpf 1.104 duplicateParameter = gotClass;
2222 gotClass = true;
2223 }
2224 else
2225 {
|
2226 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2227 kumpf 1.104 }
2228
|
2229 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2230 _checkMissingEndTagOrDuplicateParamValue(
2231 parser, duplicateParameter, emptyTag);
|
2232 kumpf 1.104 }
2233
|
2234 karl 1.127.2.5 _testRequiredParametersExist(gotClass);
|
2235 kumpf 1.104
2236 AutoPtr<CIMModifyClassRequestMessage> request(
2237 new CIMModifyClassRequestMessage(
2238 messageId,
2239 nameSpace,
2240 modifiedClass,
2241 QueueIdStack(queueId, _returnQueueId)));
2242
2243 STAT_SERVERSTART
2244
2245 return request.release();
2246 }
2247
2248 CIMEnumerateClassNamesRequestMessage*
2249 CIMOperationRequestDecoder::decodeEnumerateClassNamesRequest(
2250 Uint32 queueId,
2251 XmlParser& parser,
2252 const String& messageId,
2253 const CIMNamespaceName& nameSpace)
2254 {
2255 STAT_GETSTARTTIME
2256 kumpf 1.104
|
2257 karl 1.127.2.5 classNameIParam className("ClassName");
2258 booleanIParam deepInheritance("DeepInheritance");
2259
|
2260 kumpf 1.104 Boolean duplicateParameter = false;
2261 Boolean emptyTag;
2262
2263 for (const char* name;
2264 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2265 {
|
2266 karl 1.127.2.5 if(className.getOptional(parser, name, emptyTag))
|
2267 kumpf 1.104 {
|
2268 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2269 kumpf 1.104 }
|
2270 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
2271 kumpf 1.104 {
|
2272 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
2273 kumpf 1.104 }
2274 else
2275 {
|
2276 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2277 kumpf 1.104 }
2278
|
2279 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2280 _checkMissingEndTagOrDuplicateParamValue(
2281 parser, duplicateParameter, emptyTag);
|
2282 kumpf 1.104 }
2283
|
2284 karl 1.127.2.5 // NOTE: className not required for this operation
2285
|
2286 kumpf 1.104 AutoPtr<CIMEnumerateClassNamesRequestMessage> request(
2287 new CIMEnumerateClassNamesRequestMessage(
2288 messageId,
2289 nameSpace,
|
2290 karl 1.127.2.5 className.value,
2291 deepInheritance.value,
|
2292 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2293
2294 STAT_SERVERSTART
2295
2296 return request.release();
2297 }
2298
2299 CIMEnumerateClassesRequestMessage*
2300 CIMOperationRequestDecoder::decodeEnumerateClassesRequest(
2301 Uint32 queueId,
2302 XmlParser& parser,
2303 const String& messageId,
2304 const CIMNamespaceName& nameSpace)
2305 {
2306 STAT_GETSTARTTIME
2307
|
2308 karl 1.127.2.5 // EnumerateClasses Parameters
2309 classNameIParam className("ClassName");
2310 booleanIParam deepInheritance("deepInheritance");
2311 booleanIParam localOnly("localOnly",true);
2312 booleanIParam includeQualifiers("IncludeQualifiers", true);
2313 booleanIParam includeClassOrigin("IncludeClassOrigin");
2314
|
2315 kumpf 1.104 Boolean duplicateParameter = false;
2316 Boolean emptyTag;
2317
2318 for (const char* name;
2319 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2320 {
|
2321 karl 1.127.2.5 if(className.getOptional(parser, name, emptyTag))
|
2322 kumpf 1.104 {
|
2323 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2324 kumpf 1.104 }
|
2325 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
2326 kumpf 1.104 {
|
2327 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
2328 kumpf 1.104 }
|
2329 karl 1.127.2.5 else if(localOnly.get(parser, name, emptyTag))
|
2330 kumpf 1.104 {
|
2331 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2332 kumpf 1.104 }
|
2333 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2334 kumpf 1.104 {
|
2335 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2336 kumpf 1.104 }
|
2337 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2338 kumpf 1.104 {
|
2339 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2340 kumpf 1.104 }
2341 else
2342 {
|
2343 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2344 kumpf 1.104 }
2345
|
2346 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2347 _checkMissingEndTagOrDuplicateParamValue(
2348 parser, duplicateParameter, emptyTag);
|
2349 kumpf 1.104 }
2350
|
2351 karl 1.127.2.5 // NOTE: Class name not required for this enumerate.
2352
|
2353 kumpf 1.104 AutoPtr<CIMEnumerateClassesRequestMessage> request(
2354 new CIMEnumerateClassesRequestMessage(
2355 messageId,
2356 nameSpace,
|
2357 karl 1.127.2.5 className.value,
2358 deepInheritance.value,
2359 localOnly.value,
2360 includeQualifiers.value,
2361 includeClassOrigin.value,
|
2362 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2363
2364 STAT_SERVERSTART
2365
2366 return request.release();
2367 }
2368
2369 CIMDeleteClassRequestMessage*
2370 CIMOperationRequestDecoder::decodeDeleteClassRequest(
2371 Uint32 queueId,
2372 XmlParser& parser,
2373 const String& messageId,
2374 const CIMNamespaceName& nameSpace)
2375 {
2376 STAT_GETSTARTTIME
2377
|
2378 karl 1.127.2.5 classNameIParam className("ClassName");
2379
|
2380 kumpf 1.104 Boolean duplicateParameter = false;
2381 Boolean emptyTag;
2382
2383 for (const char* name;
2384 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2385 {
|
2386 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2387 kumpf 1.104 {
|
2388 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2389 kumpf 1.104 }
2390 else
2391 {
|
2392 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2393 kumpf 1.104 }
2394
|
2395 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2396 _checkMissingEndTagOrDuplicateParamValue(
2397 parser, duplicateParameter, emptyTag);
|
2398 kumpf 1.104 }
2399
|
2400 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
2401 kumpf 1.104
2402 AutoPtr<CIMDeleteClassRequestMessage> request(
2403 new CIMDeleteClassRequestMessage(
2404 messageId,
2405 nameSpace,
|
2406 karl 1.127.2.5 className.value,
|
2407 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2408
2409 STAT_SERVERSTART
2410
2411 return request.release();
2412 }
2413
2414 CIMCreateInstanceRequestMessage*
2415 CIMOperationRequestDecoder::decodeCreateInstanceRequest(
2416 Uint32 queueId,
2417 XmlParser& parser,
2418 const String& messageId,
2419 const CIMNamespaceName& nameSpace)
2420 {
2421 STAT_GETSTARTTIME
2422
2423 CIMInstance newInstance;
2424 Boolean gotInstance = false;
|
2425 karl 1.127.2.5
|
2426 kumpf 1.104 Boolean emptyTag;
|
2427 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2428 kumpf 1.104
2429 for (const char* name;
2430 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2431 {
2432 if (System::strcasecmp(name, "NewInstance") == 0)
2433 {
2434 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2435 XmlReader::getInstanceElement(parser, newInstance);
2436 duplicateParameter = gotInstance;
2437 gotInstance = true;
2438 }
2439 else
2440 {
|
2441 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2442 kumpf 1.104 }
2443
|
2444 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2445 _checkMissingEndTagOrDuplicateParamValue(
2446 parser, duplicateParameter, emptyTag);
|
2447 kumpf 1.104 }
2448
|
2449 karl 1.127.2.5
2450 _testRequiredParametersExist(gotInstance);
|
2451 kumpf 1.104
2452 AutoPtr<CIMCreateInstanceRequestMessage> request(
2453 new CIMCreateInstanceRequestMessage(
2454 messageId,
2455 nameSpace,
2456 newInstance,
2457 QueueIdStack(queueId, _returnQueueId)));
2458
2459 STAT_SERVERSTART
2460
2461 return request.release();
2462 }
2463
2464 CIMGetInstanceRequestMessage*
2465 CIMOperationRequestDecoder::decodeGetInstanceRequest(
2466 Uint32 queueId,
2467 XmlParser& parser,
2468 const String& messageId,
2469 const CIMNamespaceName& nameSpace)
2470 {
2471 STAT_GETSTARTTIME
2472 kumpf 1.104
|
2473 karl 1.127.2.5 instanceNameIParam instanceName;
2474 // This attribute is accepted for compatibility reasons, but is
2475 // not honored because it is deprecated.
2476 booleanIParam localOnly("localOnly",true);
2477 booleanIParam includeQualifiers("IncludeQualifiers");
2478 booleanIParam includeClassOrigin("IncludeClassOrigin");
2479 propertyListIParam propertyList;
2480
|
2481 kumpf 1.104 Boolean duplicateParameter = false;
2482 Boolean emptyTag;
2483
2484 for (const char* name;
2485 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2486 {
|
2487 karl 1.127.2.5 if(instanceName.get(parser, name, emptyTag))
|
2488 kumpf 1.104 {
|
2489 karl 1.127.2.5 instanceName.iParamFound(duplicateParameter);
|
2490 kumpf 1.104 }
|
2491 karl 1.127.2.5 // localOnly is accepted for compatibility reasons, but is
2492 // not honored because it is deprecated.
2493 else if(localOnly.get(parser, name, emptyTag))
|
2494 kumpf 1.104 {
|
2495 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2496 kumpf 1.104 }
|
2497 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2498 kumpf 1.104 {
|
2499 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2500 kumpf 1.104 }
|
2501 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2502 kumpf 1.104 {
|
2503 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2504 kumpf 1.104 }
|
2505 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
2506 kumpf 1.104 {
|
2507 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2508 kumpf 1.104 }
2509 else
2510 {
|
2511 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2512 kumpf 1.104 }
2513
|
2514 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2515 _checkMissingEndTagOrDuplicateParamValue(
2516 parser, duplicateParameter, emptyTag);
|
2517 kumpf 1.104 }
2518
|
2519 karl 1.127.2.5 _testRequiredParametersExist(instanceName.got);
|
2520 kumpf 1.104
2521 AutoPtr<CIMGetInstanceRequestMessage> request(
2522 new CIMGetInstanceRequestMessage(
2523 messageId,
2524 nameSpace,
|
2525 karl 1.127.2.5 instanceName.value,
|
2526 h.sterling 1.97 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
2527 kumpf 1.104 false,
|
2528 h.sterling 1.97 #else
|
2529 karl 1.127.2.5 includeQualifiers.value,
|
2530 h.sterling 1.97 #endif
|
2531 karl 1.127.2.5 includeClassOrigin.value,
2532 propertyList.value,
|
2533 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2534
2535 STAT_SERVERSTART
2536
2537 return request.release();
2538 }
2539
|
2540 karl 1.127.2.5
|
2541 kumpf 1.104 CIMModifyInstanceRequestMessage*
2542 CIMOperationRequestDecoder::decodeModifyInstanceRequest(
2543 Uint32 queueId,
2544 XmlParser& parser,
2545 const String& messageId,
2546 const CIMNamespaceName& nameSpace)
2547 {
2548 STAT_GETSTARTTIME
2549
2550 CIMInstance modifiedInstance;
2551 Boolean gotInstance = false;
|
2552 karl 1.127.2.5
2553 booleanIParam includeQualifiers("IncludeQualifiers", true);
2554 propertyListIParam propertyList;
2555
|
2556 kumpf 1.104 Boolean emptyTag;
|
2557 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2558 kumpf 1.104
2559 for (const char* name;
2560 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2561 {
2562 if (System::strcasecmp(name, "ModifiedInstance") == 0)
2563 {
2564 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2565 XmlReader::getNamedInstanceElement(parser, modifiedInstance);
2566 duplicateParameter = gotInstance;
2567 gotInstance = true;
2568 }
|
2569 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2570 kumpf 1.104 {
|
2571 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2572 kumpf 1.104 }
|
2573 karl 1.127.2.5 else if(propertyList.getSpecial(parser, name, emptyTag))
|
2574 kumpf 1.104 {
|
2575 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2576 kumpf 1.104 }
2577 else
2578 {
|
2579 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2580 kumpf 1.104 }
2581
|
2582 karl 1.127.2.5 _checkMissingEndTagOrDuplicateParamValue(
2583 parser, duplicateParameter, emptyTag);
|
2584 kumpf 1.104 }
2585
|
2586 karl 1.127.2.5 _testRequiredParametersExist(gotInstance);
|
2587 kumpf 1.104
2588 AutoPtr<CIMModifyInstanceRequestMessage> request(
2589 new CIMModifyInstanceRequestMessage(
2590 messageId,
2591 nameSpace,
2592 modifiedInstance,
|
2593 karl 1.127.2.5 includeQualifiers.value,
2594 propertyList.value,
|
2595 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2596
2597 STAT_SERVERSTART
2598
2599 return request.release();
2600 }
2601
2602 CIMEnumerateInstancesRequestMessage*
2603 CIMOperationRequestDecoder::decodeEnumerateInstancesRequest(
2604 Uint32 queueId,
2605 XmlParser& parser,
2606 const String& messageId,
2607 const CIMNamespaceName& nameSpace)
2608 {
2609 STAT_GETSTARTTIME
2610
|
2611 karl 1.127.2.5 // EnumerateInstance Parameters
2612 classNameIParam className("ClassName");
2613 booleanIParam deepInheritance("DeepInheritance", true);
2614 // localOnly is accepted for compatibility reasons, but is
2615 // not honored because it is deprecated.
2616 booleanIParam localOnly("localOnly", true);
2617 booleanIParam includeQualifiers("IncludeQualifiers");
2618 booleanIParam includeClassOrigin("IncludeClassOrigin");
2619 propertyListIParam propertyList;
2620
|
2621 kumpf 1.104 Boolean duplicateParameter = false;
2622 Boolean emptyTag;
2623
2624 for (const char* name;
2625 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2626 {
|
2627 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2628 kumpf 1.104 {
|
2629 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2630 kumpf 1.104 }
|
2631 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
2632 kumpf 1.104 {
|
2633 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
2634 kumpf 1.104 }
|
2635 karl 1.127.2.5 // This attribute is accepted for compatibility reasons, but is
2636 // not honored because it is deprecated.
2637 else if(localOnly.get(parser, name, emptyTag))
|
2638 kumpf 1.104 {
|
2639 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2640 kumpf 1.104 }
|
2641 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2642 kumpf 1.104 {
|
2643 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2644 kumpf 1.104 }
|
2645 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2646 kumpf 1.104 {
|
2647 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2648 kumpf 1.104 }
|
2649 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
2650 kumpf 1.104 {
|
2651 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2652 kumpf 1.104 }
|
2653 karl 1.127.2.5 else
|
2654 kumpf 1.104 {
|
2655 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2656 kumpf 1.104 }
2657
|
2658 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2659 _checkMissingEndTagOrDuplicateParamValue(
2660 parser, duplicateParameter, emptyTag);
|
2661 kumpf 1.104 }
2662
|
2663 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
2664 karl 1.127.2.3
|
2665 kumpf 1.104 AutoPtr<CIMEnumerateInstancesRequestMessage> request(
2666 new CIMEnumerateInstancesRequestMessage(
2667 messageId,
2668 nameSpace,
|
2669 karl 1.127.2.5 className.value,
2670 deepInheritance.value,
|
2671 h.sterling 1.97 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
2672 kumpf 1.104 false,
|
2673 h.sterling 1.97 #else
|
2674 karl 1.127.2.5 includeQualifiers.value,
|
2675 h.sterling 1.97 #endif
|
2676 karl 1.127.2.5 includeClassOrigin.value,
2677 propertyList.value,
|
2678 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2679
2680 STAT_SERVERSTART
2681
2682 return request.release();
2683 }
2684
2685 CIMEnumerateInstanceNamesRequestMessage*
2686 CIMOperationRequestDecoder::decodeEnumerateInstanceNamesRequest(
2687 Uint32 queueId,
2688 XmlParser& parser,
2689 const String& messageId,
2690 const CIMNamespaceName& nameSpace)
2691 {
2692 STAT_GETSTARTTIME
2693
|
2694 karl 1.127.2.5 classNameIParam className("ClassName");
2695
|
2696 kumpf 1.104 Boolean duplicateParameter = false;
2697 Boolean emptyTag;
2698
2699 for (const char* name;
2700 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2701 {
|
2702 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2703 kumpf 1.104 {
|
2704 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2705 kumpf 1.104 }
2706 else
2707 {
|
2708 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2709 kumpf 1.104 }
2710
|
2711 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2712 _checkMissingEndTagOrDuplicateParamValue(
2713 parser, duplicateParameter, emptyTag);
|
2714 kumpf 1.104 }
2715
|
2716 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
2717 kumpf 1.104
2718 AutoPtr<CIMEnumerateInstanceNamesRequestMessage> request(
2719 new CIMEnumerateInstanceNamesRequestMessage(
2720 messageId,
2721 nameSpace,
|
2722 karl 1.127.2.5 className.value,
|
2723 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2724
2725 STAT_SERVERSTART
2726
2727 return request.release();
2728 }
2729
2730 CIMDeleteInstanceRequestMessage*
2731 CIMOperationRequestDecoder::decodeDeleteInstanceRequest(
2732 Uint32 queueId,
2733 XmlParser& parser,
2734 const String& messageId,
2735 const CIMNamespaceName& nameSpace)
2736 {
2737 STAT_GETSTARTTIME
2738
|
2739 karl 1.127.2.5 instanceNameIParam instanceName;
2740
|
2741 kumpf 1.104 Boolean duplicateParameter = false;
2742 Boolean emptyTag;
2743
2744 for (const char* name;
2745 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2746 {
|
2747 karl 1.127.2.5 if(instanceName.get(parser, name, emptyTag))
|
2748 kumpf 1.104 {
|
2749 karl 1.127.2.5 instanceName.iParamFound(duplicateParameter);
|
2750 kumpf 1.104 }
2751 else
2752 {
|
2753 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2754 kumpf 1.104 }
2755
|
2756 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2757 _checkMissingEndTagOrDuplicateParamValue(
2758 parser, duplicateParameter, emptyTag);
|
2759 kumpf 1.104 }
2760
|
2761 karl 1.127.2.5 _testRequiredParametersExist(instanceName.got);
|
2762 kumpf 1.104
2763 AutoPtr<CIMDeleteInstanceRequestMessage> request(
2764 new CIMDeleteInstanceRequestMessage(
2765 messageId,
2766 nameSpace,
|
2767 karl 1.127.2.5 instanceName.value,
|
2768 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2769
2770 STAT_SERVERSTART
2771
2772 return request.release();
2773 }
2774
2775 CIMSetQualifierRequestMessage*
2776 CIMOperationRequestDecoder::decodeSetQualifierRequest(
2777 Uint32 queueId,
2778 XmlParser& parser,
2779 const String& messageId,
2780 const CIMNamespaceName& nameSpace)
2781 {
2782 STAT_GETSTARTTIME
2783
2784 CIMQualifierDecl qualifierDeclaration;
2785 Boolean duplicateParameter = false;
2786 Boolean gotQualifierDeclaration = false;
2787 Boolean emptyTag;
2788
2789 kumpf 1.104 for (const char* name;
2790 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2791 {
2792 if (System::strcasecmp(name, "QualifierDeclaration") == 0)
2793 {
2794 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2795 XmlReader::getQualifierDeclElement(parser, qualifierDeclaration);
2796 duplicateParameter = gotQualifierDeclaration;
2797 gotQualifierDeclaration = true;
2798 }
2799 else
2800 {
|
2801 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2802 kumpf 1.104 }
2803
|
2804 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2805 _checkMissingEndTagOrDuplicateParamValue(
2806 parser, duplicateParameter, emptyTag);
|
2807 kumpf 1.104 }
2808
|
2809 karl 1.127.2.5 _testRequiredParametersExist(gotQualifierDeclaration);
|
2810 kumpf 1.104
2811 AutoPtr<CIMSetQualifierRequestMessage> request(
2812 new CIMSetQualifierRequestMessage(
2813 messageId,
2814 nameSpace,
2815 qualifierDeclaration,
2816 QueueIdStack(queueId, _returnQueueId)));
2817
2818 STAT_SERVERSTART
2819
2820 return request.release();
2821 }
2822
2823 CIMGetQualifierRequestMessage*
2824 CIMOperationRequestDecoder::decodeGetQualifierRequest(
2825 Uint32 queueId,
2826 XmlParser& parser,
2827 const String& messageId,
2828 const CIMNamespaceName& nameSpace)
2829 {
2830 STAT_GETSTARTTIME
2831 kumpf 1.104
2832 String qualifierNameString;
2833 CIMName qualifierName;
2834 Boolean duplicateParameter = false;
2835 Boolean gotQualifierName = false;
2836 Boolean emptyTag;
2837
2838 for (const char* name;
2839 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2840 {
2841 if (System::strcasecmp(name, "QualifierName") == 0)
2842 {
2843 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2844 XmlReader::getStringValueElement(parser, qualifierNameString, true);
2845 qualifierName = qualifierNameString;
2846 duplicateParameter = gotQualifierName;
2847 gotQualifierName = true;
2848 }
2849 else
2850 {
|
2851 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2852 kumpf 1.104 }
2853
|
2854 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2855 _checkMissingEndTagOrDuplicateParamValue(
2856 parser, duplicateParameter, emptyTag);
|
2857 kumpf 1.104 }
2858
|
2859 karl 1.127.2.5 _testRequiredParametersExist(gotQualifierName);
|
2860 kumpf 1.104
2861 AutoPtr<CIMGetQualifierRequestMessage> request(
2862 new CIMGetQualifierRequestMessage(
2863 messageId,
2864 nameSpace,
2865 qualifierName,
2866 QueueIdStack(queueId, _returnQueueId)));
2867
2868 STAT_SERVERSTART
2869
2870 return request.release();
2871 }
2872
2873 CIMEnumerateQualifiersRequestMessage*
2874 CIMOperationRequestDecoder::decodeEnumerateQualifiersRequest(
2875 Uint32 queueId,
2876 XmlParser& parser,
2877 const String& messageId,
2878 const CIMNamespaceName& nameSpace)
2879 {
2880 STAT_GETSTARTTIME
2881 kumpf 1.104 Boolean emptyTag;
2882
2883 for (const char* name;
2884 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2885 {
2886 // No IPARAMVALUEs are defined for this operation
|
2887 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2888 kumpf 1.104 }
2889
2890 AutoPtr<CIMEnumerateQualifiersRequestMessage> request(
2891 new CIMEnumerateQualifiersRequestMessage(
2892 messageId,
2893 nameSpace,
2894 QueueIdStack(queueId, _returnQueueId)));
2895
2896 STAT_SERVERSTART
2897
2898 return request.release();
2899 }
2900
2901 CIMDeleteQualifierRequestMessage*
2902 CIMOperationRequestDecoder::decodeDeleteQualifierRequest(
2903 Uint32 queueId,
2904 XmlParser& parser,
2905 const String& messageId,
2906 const CIMNamespaceName& nameSpace)
2907 {
2908 STAT_GETSTARTTIME
2909 kumpf 1.104
2910 String qualifierNameString;
2911 CIMName qualifierName;
2912 Boolean gotQualifierName = false;
|
2913 karl 1.127.2.5
|
2914 kumpf 1.104 Boolean emptyTag;
|
2915 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2916 kumpf 1.104
2917 for (const char* name;
2918 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2919 {
2920 if (System::strcasecmp(name, "QualifierName") == 0)
2921 {
2922 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2923 XmlReader::getStringValueElement(parser, qualifierNameString, true);
2924 qualifierName = qualifierNameString;
2925 duplicateParameter = gotQualifierName;
2926 gotQualifierName = true;
2927 }
2928 else
2929 {
|
2930 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2931 kumpf 1.104 }
2932
2933
|
2934 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2935 _checkMissingEndTagOrDuplicateParamValue(
2936 parser, duplicateParameter, emptyTag);
|
2937 kumpf 1.104 }
2938
|
2939 karl 1.127.2.5 _testRequiredParametersExist(gotQualifierName);
|
2940 kumpf 1.104
2941 AutoPtr<CIMDeleteQualifierRequestMessage> request(
2942 new CIMDeleteQualifierRequestMessage(
2943 messageId,
2944 nameSpace,
2945 qualifierName,
2946 QueueIdStack(queueId, _returnQueueId)));
2947
2948 STAT_SERVERSTART
2949
2950 return request.release();
2951 }
2952
2953 CIMReferenceNamesRequestMessage*
2954 CIMOperationRequestDecoder::decodeReferenceNamesRequest(
2955 Uint32 queueId,
2956 XmlParser& parser,
2957 const String& messageId,
2958 const CIMNamespaceName& nameSpace)
2959 {
2960 STAT_GETSTARTTIME
|
2961 karl 1.127.2.5 objectNameIParam objectName;
2962 classNameIParam resultClass("ResultClass");
2963 stringIParam role("role", false);
|
2964 kumpf 1.104
2965 Boolean duplicateParameter = false;
2966 Boolean emptyTag;
2967
2968 for (const char* name;
|
2969 karl 1.127.2.5 XmlReader::getIParamValueTag(parser, name, emptyTag); )
|
2970 kumpf 1.104 {
|
2971 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
2972 kumpf 1.104 {
|
2973 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
2974 kumpf 1.104 }
|
2975 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
2976 kumpf 1.104 {
|
2977 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
2978 kumpf 1.104 }
|
2979 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
2980 kumpf 1.104 {
|
2981 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
2982 kumpf 1.104 }
2983 else
2984 {
|
2985 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2986 kumpf 1.104 }
2987
|
2988 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2989 _checkMissingEndTagOrDuplicateParamValue(
2990 parser, duplicateParameter, emptyTag);
|
2991 kumpf 1.104 }
2992
|
2993 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
2994 kumpf 1.104
2995 AutoPtr<CIMReferenceNamesRequestMessage> request(
2996 new CIMReferenceNamesRequestMessage(
2997 messageId,
2998 nameSpace,
|
2999 karl 1.127.2.5 objectName.value,
3000 resultClass.value,
3001 role.value,
3002 QueueIdStack(queueId, _returnQueueId),
3003 objectName.isClassNameElement));
|
3004 kumpf 1.104
3005 STAT_SERVERSTART
3006
3007 return request.release();
3008 }
3009
3010 CIMReferencesRequestMessage*
3011 CIMOperationRequestDecoder::decodeReferencesRequest(
3012 Uint32 queueId,
3013 XmlParser& parser,
3014 const String& messageId,
3015 const CIMNamespaceName& nameSpace)
3016 {
3017 STAT_GETSTARTTIME
3018
|
3019 karl 1.127.2.5 objectNameIParam objectName;
3020 classNameIParam resultClass("ResultClass");
3021 stringIParam role("role", false);
3022 booleanIParam includeQualifiers("IncludeQualifiers");
3023 booleanIParam includeClassOrigin("IncludeClassOrigin");
3024 propertyListIParam propertyList;
3025
|
3026 kumpf 1.104 Boolean duplicateParameter = false;
3027 Boolean emptyTag;
3028
3029 for (const char* name;
3030 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3031 {
|
3032 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3033 kumpf 1.104 {
|
3034 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3035 kumpf 1.104 }
|
3036 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3037 kumpf 1.104 {
|
3038 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3039 kumpf 1.104 }
|
3040 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3041 kumpf 1.104 {
|
3042 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3043 kumpf 1.104 }
|
3044 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
3045 kumpf 1.104 {
|
3046 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
3047 kumpf 1.104 }
|
3048 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3049 kumpf 1.104 {
|
3050 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3051 kumpf 1.104 }
|
3052 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3053 kumpf 1.104 {
|
3054 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3055 kumpf 1.104 }
3056 else
3057 {
|
3058 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3059 kumpf 1.104 }
3060
|
3061 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3062 _checkMissingEndTagOrDuplicateParamValue(
3063 parser, duplicateParameter, emptyTag);
|
3064 kumpf 1.104 }
3065
|
3066 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3067 kumpf 1.104
3068 AutoPtr<CIMReferencesRequestMessage> request(
3069 new CIMReferencesRequestMessage(
3070 messageId,
3071 nameSpace,
|
3072 karl 1.127.2.5 objectName.value,
3073 resultClass.value,
3074 role.value,
3075 includeQualifiers.value,
3076 includeClassOrigin.value,
3077 propertyList.value,
3078 QueueIdStack(queueId, _returnQueueId),
3079 objectName.isClassNameElement));
|
3080 kumpf 1.104
3081 STAT_SERVERSTART
3082
3083 return request.release();
3084 }
3085
3086 CIMAssociatorNamesRequestMessage*
3087 CIMOperationRequestDecoder::decodeAssociatorNamesRequest(
3088 Uint32 queueId,
3089 XmlParser& parser,
3090 const String& messageId,
3091 const CIMNamespaceName& nameSpace)
3092 {
3093 STAT_GETSTARTTIME
3094
|
3095 karl 1.127.2.5 objectNameIParam objectName;
3096 classNameIParam assocClass("AssocClass");
3097 classNameIParam resultClass("ResultClass");
3098 stringIParam role("role", false);
3099 stringIParam resultRole("Resultrole", false);
3100
|
3101 kumpf 1.104 Boolean emptyTag;
|
3102 karl 1.127.2.5 Boolean duplicateParameter = false;
|
3103 kumpf 1.104
3104 for (const char* name;
3105 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3106 {
|
3107 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3108 kumpf 1.104 {
|
3109 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3110 kumpf 1.104 }
|
3111 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
3112 kumpf 1.104 {
|
3113 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
3114 kumpf 1.104 }
|
3115 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3116 kumpf 1.104 {
|
3117 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3118 kumpf 1.104 }
|
3119 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3120 kumpf 1.104 {
|
3121 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3122 kumpf 1.104 }
|
3123 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
3124 kumpf 1.104 {
|
3125 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
3126 kumpf 1.104 }
3127 else
3128 {
|
3129 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3130 kumpf 1.104
3131 }
3132
|
3133 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3134 _checkMissingEndTagOrDuplicateParamValue(
3135 parser, duplicateParameter, emptyTag);
|
3136 kumpf 1.104 }
3137
|
3138 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3139 kumpf 1.104
3140 AutoPtr<CIMAssociatorNamesRequestMessage> request(
3141 new CIMAssociatorNamesRequestMessage(
3142 messageId,
3143 nameSpace,
|
3144 karl 1.127.2.5 objectName.value,
3145 assocClass.value,
3146 resultClass.value,
3147 role.value,
3148 resultRole.value,
3149 QueueIdStack(queueId, _returnQueueId),
3150 objectName.isClassNameElement));
|
3151 kumpf 1.104
3152 STAT_SERVERSTART
3153
3154 return request.release();
3155 }
3156
3157 CIMAssociatorsRequestMessage*
3158 CIMOperationRequestDecoder::decodeAssociatorsRequest(
3159 Uint32 queueId,
3160 XmlParser& parser,
3161 const String& messageId,
3162 const CIMNamespaceName& nameSpace)
3163 {
3164 STAT_GETSTARTTIME
3165
|
3166 karl 1.127.2.5 // Associator Operation Parameters
3167 objectNameIParam objectName;
3168 classNameIParam assocClass("AssocClass");
3169 classNameIParam resultClass("ResultClass");
3170 stringIParam resultRole("Resultrole", false);
3171 stringIParam role("role", false);
3172 booleanIParam includeQualifiers("IncludeQualifiers");
3173 booleanIParam includeClassOrigin("IncludeClassOrigin");
3174 propertyListIParam propertyList;
3175
|
3176 kumpf 1.104 Boolean duplicateParameter = false;
3177 Boolean emptyTag;
3178
3179 for (const char* name;
3180 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3181 {
|
3182 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3183 kumpf 1.104 {
|
3184 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3185 kumpf 1.104 }
|
3186 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
3187 kumpf 1.104 {
|
3188 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
3189 kumpf 1.104 }
|
3190 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3191 kumpf 1.104 {
|
3192 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3193 kumpf 1.104 }
|
3194 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3195 kumpf 1.104 {
|
3196 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3197 kumpf 1.104 }
|
3198 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
3199 kumpf 1.104 {
|
3200 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
3201 kumpf 1.104 }
|
3202 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
3203 kumpf 1.104 {
|
3204 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
3205 kumpf 1.104 }
|
3206 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3207 kumpf 1.104 {
|
3208 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3209 kumpf 1.104 }
|
3210 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3211 kumpf 1.104 {
|
3212 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3213 kumpf 1.104 }
3214 else
3215 {
|
3216 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3217 kumpf 1.104 }
3218
|
3219 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3220 _checkMissingEndTagOrDuplicateParamValue(
3221 parser, duplicateParameter, emptyTag);
|
3222 kumpf 1.104 }
3223
|
3224 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3225 kumpf 1.104
3226 AutoPtr<CIMAssociatorsRequestMessage> request(
3227 new CIMAssociatorsRequestMessage(
3228 messageId,
3229 nameSpace,
|
3230 karl 1.127.2.5 objectName.value,
3231 assocClass.value,
3232 resultClass.value,
3233 role.value,
3234 resultRole.value,
3235 includeQualifiers.value,
3236 includeClassOrigin.value,
3237 propertyList.value,
3238 QueueIdStack(queueId, _returnQueueId),
3239 objectName.isClassNameElement));
|
3240 kumpf 1.104
3241 STAT_SERVERSTART
3242
3243 return request.release();
3244 }
3245
3246 CIMGetPropertyRequestMessage*
3247 CIMOperationRequestDecoder::decodeGetPropertyRequest(
3248 Uint32 queueId,
3249 XmlParser& parser,
3250 const String& messageId,
3251 const CIMNamespaceName& nameSpace)
3252 {
3253 STAT_GETSTARTTIME
3254
3255 CIMObjectPath instanceName;
3256 String propertyName;
3257 Boolean duplicateParameter = false;
3258 Boolean gotInstanceName = false;
3259 Boolean gotPropertyName = false;
3260 Boolean emptyTag;
3261 kumpf 1.104
3262 for (const char* name;
3263 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3264 {
3265 if (System::strcasecmp(name, "InstanceName") == 0)
3266 {
3267 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3268 XmlReader::getInstanceNameElement(parser, instanceName);
3269 duplicateParameter = gotInstanceName;
3270 gotInstanceName = true;
3271 }
3272 else if (System::strcasecmp(name, "PropertyName") == 0)
3273 {
3274 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3275 XmlReader::getStringValueElement(parser, propertyName, true);
3276 duplicateParameter = gotPropertyName;
3277 gotPropertyName = true;
3278 }
3279 else
3280 {
|
3281 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3282 kumpf 1.104 }
3283
|
3284 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3285 _checkMissingEndTagOrDuplicateParamValue(
3286 parser, duplicateParameter, emptyTag);
|
3287 kumpf 1.104 }
3288
|
3289 karl 1.127.2.5 _testRequiredParametersExist(gotInstanceName && gotPropertyName);
|
3290 kumpf 1.104
3291 AutoPtr<CIMGetPropertyRequestMessage> request(
3292 new CIMGetPropertyRequestMessage(
3293 messageId,
3294 nameSpace,
3295 instanceName,
3296 propertyName,
3297 QueueIdStack(queueId, _returnQueueId)));
3298
3299 STAT_SERVERSTART
3300
3301 return request.release();
3302 }
3303
3304 CIMSetPropertyRequestMessage*
3305 CIMOperationRequestDecoder::decodeSetPropertyRequest(
3306 Uint32 queueId,
3307 XmlParser& parser,
3308 const String& messageId,
3309 const CIMNamespaceName& nameSpace)
3310 {
3311 kumpf 1.104 STAT_GETSTARTTIME
3312
3313 CIMObjectPath instanceName;
3314 String propertyName;
3315 CIMValue propertyValue;
3316 Boolean duplicateParameter = false;
3317 Boolean gotInstanceName = false;
3318 Boolean gotPropertyName = false;
3319 Boolean gotNewValue = false;
3320 Boolean emptyTag;
3321
3322 for (const char* name;
3323 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3324 {
3325 if (System::strcasecmp(name, "InstanceName") == 0)
3326 {
3327 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3328 XmlReader::getInstanceNameElement(parser, instanceName);
3329 duplicateParameter = gotInstanceName;
3330 gotInstanceName = true;
3331 }
3332 kumpf 1.104 else if (System::strcasecmp(name, "PropertyName") == 0)
3333 {
3334 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3335 XmlReader::getStringValueElement(parser, propertyName, true);
3336 duplicateParameter = gotPropertyName;
3337 gotPropertyName = true;
3338 }
3339 else if (System::strcasecmp(name, "NewValue") == 0)
3340 {
3341 if (emptyTag || !XmlReader::getPropertyValue(parser, propertyValue))
3342 {
3343 propertyValue.setNullValue(CIMTYPE_STRING, false);
3344 }
3345 duplicateParameter = gotNewValue;
3346 gotNewValue = true;
3347 }
3348 else
3349 {
|
3350 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3351 kumpf 1.104 }
3352
|
3353 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3354 _checkMissingEndTagOrDuplicateParamValue(
3355 parser, duplicateParameter, emptyTag);
|
3356 kumpf 1.104 }
3357
|
3358 karl 1.127.2.5 _testRequiredParametersExist(gotInstanceName && gotPropertyName);
|
3359 kumpf 1.104
3360 AutoPtr<CIMSetPropertyRequestMessage> request(
3361 new CIMSetPropertyRequestMessage(
3362 messageId,
3363 nameSpace,
3364 instanceName,
3365 propertyName,
3366 propertyValue,
3367 QueueIdStack(queueId, _returnQueueId)));
|
3368 kumpf 1.29
|
3369 kumpf 1.104 STAT_SERVERSTART
|
3370 sage 1.41
|
3371 kumpf 1.104 return request.release();
|
3372 kumpf 1.29 }
3373
3374 CIMExecQueryRequestMessage* CIMOperationRequestDecoder::decodeExecQueryRequest(
|
3375 kumpf 1.104 Uint32 queueId,
3376 XmlParser& parser,
3377 const String& messageId,
3378 const CIMNamespaceName& nameSpace)
3379 {
3380 STAT_GETSTARTTIME
3381
|
3382 karl 1.127.2.5 // define execQuery parameters. Values are required parameters exist.
3383 stringIParam queryLanguage("QueryLanguage", true);
3384 stringIParam query("Query", true);
3385
|
3386 kumpf 1.104 Boolean emptyTag;
|
3387 karl 1.127.2.5 Boolean duplicateParameter = false;
|
3388 kumpf 1.104
3389 for (const char* name;
3390 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3391 {
|
3392 karl 1.127.2.5 if(queryLanguage.get(parser, name, emptyTag))
|
3393 kumpf 1.104 {
|
3394 karl 1.127.2.5 queryLanguage.iParamFound(duplicateParameter);
|
3395 kumpf 1.104 }
|
3396 karl 1.127.2.5 else if(query.get(parser, name, emptyTag))
|
3397 kumpf 1.104 {
|
3398 karl 1.127.2.5 query.iParamFound(duplicateParameter);
|
3399 kumpf 1.104 }
3400 else
3401 {
|
3402 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3403 kumpf 1.104 }
3404
|
3405 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3406 _checkMissingEndTagOrDuplicateParamValue(parser,
3407 duplicateParameter, emptyTag);
|
3408 kumpf 1.104 }
3409
|
3410 karl 1.127.2.5 _testRequiredParametersExist(queryLanguage.got && query.got);
|
3411 kumpf 1.104
3412 AutoPtr<CIMExecQueryRequestMessage> request(
3413 new CIMExecQueryRequestMessage(
3414 messageId,
3415 nameSpace,
|
3416 karl 1.127.2.5 queryLanguage.value,
3417 query.value,
|
3418 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
3419
3420 STAT_SERVERSTART
3421
3422 return request.release();
3423 }
3424
3425 CIMInvokeMethodRequestMessage*
3426 CIMOperationRequestDecoder::decodeInvokeMethodRequest(
3427 Uint32 queueId,
3428 XmlParser& parser,
3429 const String& messageId,
3430 const CIMObjectPath& reference,
3431 const String& cimMethodName)
3432 {
3433 STAT_GETSTARTTIME
3434
3435 CIMParamValue paramValue;
3436 Array<CIMParamValue> inParameters;
3437
3438 while (XmlReader::getParamValueElement(parser, paramValue))
3439 kumpf 1.104 {
3440 inParameters.append(paramValue);
3441 }
3442
3443 AutoPtr<CIMInvokeMethodRequestMessage> request(
3444 new CIMInvokeMethodRequestMessage(
3445 messageId,
3446 reference.getNameSpace(),
3447 reference,
3448 cimMethodName,
3449 inParameters,
3450 QueueIdStack(queueId, _returnQueueId)));
|
3451 kumpf 1.9
|
3452 kumpf 1.104 STAT_SERVERSTART
|
3453 mike 1.2
|
3454 kumpf 1.104 return request.release();
|
3455 mike 1.2 }
3456
|
3457 karl 1.127.2.1 // EXP_PULL_BEGIN
3458 CIMOpenEnumerateInstancesRequestMessage*
3459 CIMOperationRequestDecoder::decodeOpenEnumerateInstancesRequest(
3460 Uint32 queueId,
3461 XmlParser& parser,
3462 const String& messageId,
3463 const CIMNamespaceName& nameSpace)
3464 {
3465 STAT_GETSTARTTIME
3466
|
3467 karl 1.127.2.5 // EnumerateInstance Parameters
3468 classNameIParam className("ClassName");
3469 booleanIParam deepInheritance("DeepInheritance", true);
3470 booleanIParam includeQualifiers("IncludeQualifiers");
3471 booleanIParam includeClassOrigin("IncludeClassOrigin");
3472 propertyListIParam propertyList;
3473 //// TODO confirm the false here
3474 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3475 stringIParam filterQuery("FilterQuery", false);
3476 booleanIParam continueOnError("ContinueOnError");
3477 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3478 uint32IParam maxObjectCount("MaxObjectCount", 0);
3479 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3480 uint32ArgIParam operationTimeout("OperationTimeout");
|
3481 karl 1.127.2.1
3482 Boolean duplicateParameter = false;
3483
3484 Boolean emptyTag;
3485
3486 for (const char* name;
3487 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3488 {
|
3489 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
3490 karl 1.127.2.1 {
|
3491 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
3492 karl 1.127.2.1 }
|
3493 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
3494 karl 1.127.2.1 {
|
3495 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
3496 karl 1.127.2.1 }
|
3497 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
3498 karl 1.127.2.1 {
|
3499 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
3500 karl 1.127.2.1 }
|
3501 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3502 karl 1.127.2.1 {
|
3503 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3504 karl 1.127.2.1 }
|
3505 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQueryLanguage = NULL,
3506 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3507 karl 1.127.2.1 {
|
3508 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3509 karl 1.127.2.1 }
|
3510 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQuery = NULL,
3511 else if(filterQuery.get(parser, name, emptyTag))
|
3512 karl 1.127.2.1 {
|
3513 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3514 karl 1.127.2.1 }
|
3515 karl 1.127.2.5 // [IN,OPTIONAL] Boolean ContinueOnError = false,
3516 else if (continueOnError.get(parser, name, emptyTag))
|
3517 karl 1.127.2.1 {
|
3518 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
3519 }
3520 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3521 else if (operationTimeout.get(parser, name, emptyTag))
3522 {
3523 operationTimeout.iParamFound(duplicateParameter);
|
3524 karl 1.127.2.1 }
3525 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
|
3526 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
3527 karl 1.127.2.1 {
|
3528 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3529 karl 1.127.2.1 }
|
3530 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3531 karl 1.127.2.1 {
|
3532 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3533 karl 1.127.2.1 }
3534 else
3535 {
|
3536 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName(name);
|
3537 karl 1.127.2.1 }
3538
|
3539 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3540 _checkMissingEndTagOrDuplicateParamValue(
3541 parser, duplicateParameter, emptyTag);
|
3542 karl 1.127.2.1
3543 }
3544
|
3545 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
3546 karl 1.127.2.1
3547 AutoPtr<CIMOpenEnumerateInstancesRequestMessage> request(
3548 new CIMOpenEnumerateInstancesRequestMessage(
3549 messageId,
3550 nameSpace,
|
3551 karl 1.127.2.5 className.value,
3552 deepInheritance.value,
3553 includeClassOrigin.value,
3554 propertyList.value,
3555 filterQueryLanguage.value,
3556 filterQuery.value,
3557 operationTimeout.value,
3558 continueOnError.value,
3559 maxObjectCount.value,
|
3560 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3561
3562 STAT_SERVERSTART
3563
3564 return request.release();
3565 }
3566
3567
3568 CIMOpenEnumerateInstancePathsRequestMessage*
3569 CIMOperationRequestDecoder::decodeOpenEnumerateInstancePathsRequest(
3570 Uint32 queueId,
3571 XmlParser& parser,
3572 const String& messageId,
3573 const CIMNamespaceName& nameSpace)
3574 {
3575 STAT_GETSTARTTIME
3576
|
3577 karl 1.127.2.5 // EnumerateInstance Parameters
3578 classNameIParam className("ClassName");
3579 //// TODO confirm the false here
3580 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3581 stringIParam filterQuery("FilterQuery", false);
3582 booleanIParam continueOnError("ContinueOnError");
3583 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3584 uint32IParam maxObjectCount("MaxObjectCount", 0);
3585 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3586 uint32ArgIParam operationTimeout("OperationTimeout");
|
3587 karl 1.127.2.1
3588 Boolean duplicateParameter = false;
3589 Boolean emptyTag;
3590
3591 for (const char* name;
3592 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3593 {
|
3594 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
3595 karl 1.127.2.1 {
|
3596 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
3597 karl 1.127.2.1 }
|
3598 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQueryLanguage = NULL,
3599 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3600 karl 1.127.2.1 {
|
3601 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3602 karl 1.127.2.1 }
|
3603 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQuery = NULL,
3604 else if(filterQuery.get(parser, name, emptyTag))
|
3605 karl 1.127.2.1 {
|
3606 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3607 karl 1.127.2.1 }
3608 // [IN,OPTIONAL] Boolean ContinueOnError = false,
|
3609 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
3610 karl 1.127.2.1 {
|
3611 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3612 karl 1.127.2.1 }
|
3613 karl 1.127.2.5 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3614 else if (operationTimeout.get(parser, name, emptyTag))
|
3615 karl 1.127.2.1 {
|
3616 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3617 karl 1.127.2.1 }
|
3618 karl 1.127.2.5 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3619 else if (maxObjectCount.get(parser, name, emptyTag))
|
3620 karl 1.127.2.1 {
|
3621 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3622 karl 1.127.2.1 }
|
3623 karl 1.127.2.5 else
|
3624 karl 1.127.2.1 {
|
3625 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName(name);
|
3626 karl 1.127.2.1 }
3627
|
3628 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3629 _checkMissingEndTagOrDuplicateParamValue(
3630 parser, duplicateParameter, emptyTag);
|
3631 karl 1.127.2.1
3632 }
3633
|
3634 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
3635 karl 1.127.2.1
3636 AutoPtr<CIMOpenEnumerateInstancePathsRequestMessage> request(
3637 new CIMOpenEnumerateInstancePathsRequestMessage(
3638 messageId,
3639 nameSpace,
|
3640 karl 1.127.2.5 className.value,
3641 filterQueryLanguage.value,
3642 filterQuery.value,
3643 operationTimeout.value,
3644 continueOnError.value,
3645 maxObjectCount.value,
|
3646 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3647
3648 STAT_SERVERSTART
3649
3650 return request.release();
3651 }
3652
3653 CIMOpenReferenceInstancesRequestMessage*
3654 CIMOperationRequestDecoder::decodeOpenReferenceInstancesRequest(
3655 Uint32 queueId,
3656 XmlParser& parser,
3657 const String& messageId,
3658 const CIMNamespaceName& nameSpace)
3659 {
3660 STAT_GETSTARTTIME
3661
|
3662 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3663 classNameIParam resultClass("ResultClass");
3664 stringIParam role("role", false);
3665 booleanIParam includeClassOrigin("IncludeClassOrigin");
3666 propertyListIParam propertyList;
3667
3668 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3669 stringIParam filterQuery("FilterQuery", false);
3670 booleanIParam continueOnError("ContinueOnError");
3671 uint32IParam maxObjectCount("MaxObjectCount", 0);
3672 uint32ArgIParam operationTimeout("OperationTimeout");
|
3673 karl 1.127.2.1
3674 Boolean duplicateParameter = false;
3675 Boolean emptyTag;
3676
|
3677 karl 1.127.2.5
|
3678 karl 1.127.2.1 for (const char* name;
3679 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3680 {
|
3681 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3682 karl 1.127.2.1 {
|
3683 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3684 karl 1.127.2.1 }
|
3685 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3686 karl 1.127.2.1 {
|
3687 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3688 karl 1.127.2.1 }
|
3689 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3690 karl 1.127.2.1 {
|
3691 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3692 karl 1.127.2.1 }
|
3693 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3694 karl 1.127.2.1 {
|
3695 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3696 karl 1.127.2.1 }
|
3697 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3698 karl 1.127.2.1 {
|
3699 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3700 karl 1.127.2.1 }
|
3701 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQueryLanguage = NULL,
3702 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3703 karl 1.127.2.1 {
|
3704 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3705 karl 1.127.2.1 }
|
3706 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQuery = NULL,
3707 else if(filterQuery.get(parser, name, emptyTag))
|
3708 karl 1.127.2.1 {
|
3709 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3710 karl 1.127.2.1 }
|
3711 karl 1.127.2.5 // [IN,OPTIONAL] Boolean ContinueOnError = false,
3712 else if (continueOnError.get(parser, name, emptyTag))
|
3713 karl 1.127.2.1 {
|
3714 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3715 karl 1.127.2.1 }
|
3716 karl 1.127.2.5 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3717 else if (operationTimeout.get(parser, name, emptyTag))
|
3718 karl 1.127.2.1 {
|
3719 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3720 karl 1.127.2.1 }
|
3721 karl 1.127.2.5 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3722 else if (maxObjectCount.get(parser, name, emptyTag))
|
3723 karl 1.127.2.1 {
|
3724 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3725 karl 1.127.2.1 }
3726 else
3727 {
|
3728 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3729 karl 1.127.2.1 }
3730
|
3731 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3732 _checkMissingEndTagOrDuplicateParamValue(
3733 parser, duplicateParameter, emptyTag);
|
3734 karl 1.127.2.1 }
3735
|
3736 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3737 karl 1.127.2.1
3738 AutoPtr<CIMOpenReferenceInstancesRequestMessage> request(
3739 new CIMOpenReferenceInstancesRequestMessage(
3740 messageId,
3741 nameSpace,
|
3742 karl 1.127.2.5 objectName.value,
3743 resultClass.value,
3744 role.value,
3745 includeClassOrigin.value,
3746 propertyList.value,
3747 filterQueryLanguage.value,
3748 filterQuery.value,
3749 operationTimeout.value,
3750 continueOnError.value,
3751 maxObjectCount.value,
|
3752 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3753
3754 STAT_SERVERSTART
3755
3756 return request.release();
3757 }
3758
3759
3760 CIMOpenReferenceInstancePathsRequestMessage*
3761 CIMOperationRequestDecoder::decodeOpenReferenceInstancePathsRequest(
3762 Uint32 queueId,
3763 XmlParser& parser,
3764 const String& messageId,
3765 const CIMNamespaceName& nameSpace)
3766 {
3767 STAT_GETSTARTTIME
3768
|
3769 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3770 classNameIParam resultClass("ResultClass");
3771 stringIParam role("role", false);
3772
3773 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3774 stringIParam filterQuery("FilterQuery", false);
3775 booleanIParam continueOnError("ContinueOnError");
3776 uint32IParam maxObjectCount("MaxObjectCount", 0);
3777 uint32ArgIParam operationTimeout("OperationTimeout");
|
3778 karl 1.127.2.1
3779 Boolean duplicateParameter = false;
3780 Boolean emptyTag;
3781
3782 for (const char* name;
3783 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3784 {
|
3785 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3786 karl 1.127.2.1 {
|
3787 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3788 karl 1.127.2.1 }
|
3789 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3790 karl 1.127.2.1 {
|
3791 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3792 karl 1.127.2.1 }
|
3793 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3794 karl 1.127.2.1 {
|
3795 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3796 karl 1.127.2.1 }
|
3797 karl 1.127.2.5 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3798 karl 1.127.2.1 {
|
3799 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3800 karl 1.127.2.1 }
|
3801 karl 1.127.2.5 else if(filterQuery.get(parser, name, emptyTag))
|
3802 karl 1.127.2.1 {
|
3803 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3804 karl 1.127.2.1 }
|
3805 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
3806 karl 1.127.2.1 {
|
3807 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3808 karl 1.127.2.1 }
|
3809 karl 1.127.2.5 else if (operationTimeout.get(parser, name, emptyTag))
|
3810 karl 1.127.2.1 {
|
3811 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3812 karl 1.127.2.1 }
|
3813 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
3814 karl 1.127.2.1 {
|
3815 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3816 karl 1.127.2.1 }
3817 else
3818 {
|
3819 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3820 karl 1.127.2.1 }
3821
|
3822 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3823 _checkMissingEndTagOrDuplicateParamValue(
3824 parser, duplicateParameter, emptyTag);
|
3825 karl 1.127.2.1 }
3826
|
3827 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3828 karl 1.127.2.1
3829 AutoPtr<CIMOpenReferenceInstancePathsRequestMessage> request(
3830 new CIMOpenReferenceInstancePathsRequestMessage(
3831 messageId,
3832 nameSpace,
|
3833 karl 1.127.2.5 objectName.value,
3834 resultClass.value,
3835 role.value,
3836 filterQueryLanguage.value,
3837 filterQuery.value,
3838 operationTimeout.value,
3839 continueOnError.value,
3840 maxObjectCount.value,
|
3841 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3842
3843 STAT_SERVERSTART
3844
3845 return request.release();
3846 }
3847
3848 CIMOpenAssociatorInstancesRequestMessage*
3849 CIMOperationRequestDecoder::decodeOpenAssociatorInstancesRequest(
3850 Uint32 queueId,
3851 XmlParser& parser,
3852 const String& messageId,
3853 const CIMNamespaceName& nameSpace)
3854 {
3855 STAT_GETSTARTTIME
3856
|
3857 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3858 classNameIParam assocClass("AssocClass");
3859 classNameIParam resultClass("ResultClass");
3860 stringIParam resultRole("Resultrole", false);
3861 stringIParam role("role", false);
3862 booleanIParam includeClassOrigin("IncludeClassOrigin");
3863 propertyListIParam propertyList;
3864
3865 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3866 stringIParam filterQuery("FilterQuery", false);
3867 booleanIParam continueOnError("ContinueOnError");
3868 uint32IParam maxObjectCount("MaxObjectCount", 0);
3869 uint32ArgIParam operationTimeout("OperationTimeout");
|
3870 karl 1.127.2.1
3871 Boolean duplicateParameter = false;
3872 Boolean emptyTag;
3873
3874 for (const char* name;
3875 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3876 {
|
3877 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3878 karl 1.127.2.1 {
|
3879 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3880 karl 1.127.2.1 }
|
3881 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
3882 karl 1.127.2.1 {
|
3883 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
3884 karl 1.127.2.1 }
|
3885 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3886 karl 1.127.2.1 {
|
3887 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3888 karl 1.127.2.1 }
|
3889 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3890 karl 1.127.2.1 {
|
3891 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3892 karl 1.127.2.1 }
|
3893 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
3894 karl 1.127.2.1 {
|
3895 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
3896 karl 1.127.2.1 }
|
3897 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3898 karl 1.127.2.1 {
|
3899 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3900 karl 1.127.2.1 }
|
3901 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3902 karl 1.127.2.1 {
|
3903 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3904 karl 1.127.2.1 }
|
3905 karl 1.127.2.5 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3906 karl 1.127.2.1 {
|
3907 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3908 karl 1.127.2.1 }
|
3909 karl 1.127.2.5 else if(filterQuery.get(parser, name, emptyTag))
|
3910 karl 1.127.2.1 {
|
3911 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3912 karl 1.127.2.1 }
|
3913 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
3914 karl 1.127.2.1 {
|
3915 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3916 karl 1.127.2.1 }
|
3917 karl 1.127.2.5 else if (operationTimeout.get(parser, name, emptyTag))
|
3918 karl 1.127.2.1 {
|
3919 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3920 karl 1.127.2.1 }
|
3921 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
3922 karl 1.127.2.1 {
|
3923 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3924 karl 1.127.2.1 }
3925 else
3926 {
|
3927 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3928 karl 1.127.2.1 }
3929
|
3930 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3931 _checkMissingEndTagOrDuplicateParamValue(
3932 parser, duplicateParameter, emptyTag);
|
3933 karl 1.127.2.1 }
3934
|
3935 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3936 karl 1.127.2.1
3937 AutoPtr<CIMOpenAssociatorInstancesRequestMessage> request(
3938 new CIMOpenAssociatorInstancesRequestMessage(
3939 messageId,
3940 nameSpace,
|
3941 karl 1.127.2.5 objectName.value,
3942 assocClass.value,
3943 resultClass.value,
3944 role.value,
3945 resultRole.value,
3946 includeClassOrigin.value,
3947 propertyList.value,
3948 filterQueryLanguage.value,
3949 filterQuery.value,
3950 operationTimeout.value,
3951 continueOnError.value,
3952 maxObjectCount.value,
|
3953 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3954
3955 STAT_SERVERSTART
3956
3957 return request.release();
3958 }
3959
3960 CIMOpenAssociatorInstancePathsRequestMessage*
3961 CIMOperationRequestDecoder::decodeOpenAssociatorInstancePathsRequest(
3962 Uint32 queueId,
3963 XmlParser& parser,
3964 const String& messageId,
3965 const CIMNamespaceName& nameSpace)
3966 {
3967 STAT_GETSTARTTIME
3968
|
3969 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3970 classNameIParam assocClass("AssocClass");
3971 classNameIParam resultClass("ResultClass");
3972 stringIParam resultRole("Resultrole", false);
3973 stringIParam role("role", false);
3974
3975 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3976 stringIParam filterQuery("FilterQuery", false);
3977 booleanIParam continueOnError("ContinueOnError");
3978 uint32IParam maxObjectCount("MaxObjectCount", 0);
3979 uint32ArgIParam operationTimeout("OperationTimeout");
|
3980 karl 1.127.2.1
3981 Boolean duplicateParameter = false;
3982 Boolean emptyTag;
3983
3984 for (const char* name;
3985 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3986 {
|
3987 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3988 karl 1.127.2.1 {
|
3989 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3990 karl 1.127.2.1 }
|
3991 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
3992 karl 1.127.2.1 {
|
3993 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
3994 karl 1.127.2.1 }
|
3995 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3996 karl 1.127.2.1 {
|
3997 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3998 karl 1.127.2.1 }
|
3999 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
4000 karl 1.127.2.1 {
|
4001 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
4002 karl 1.127.2.1 }
|
4003 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
4004 karl 1.127.2.1 {
|
4005 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
4006 karl 1.127.2.1 }
|
4007 karl 1.127.2.5 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
4008 karl 1.127.2.1 {
|
4009 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
4010 karl 1.127.2.1 }
|
4011 karl 1.127.2.5 else if(filterQuery.get(parser, name, emptyTag))
|
4012 karl 1.127.2.1 {
|
4013 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
4014 karl 1.127.2.1 }
|
4015 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
4016 karl 1.127.2.1 {
|
4017 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
4018 karl 1.127.2.1 }
|
4019 karl 1.127.2.5 else if (operationTimeout.get(parser, name, emptyTag))
|
4020 karl 1.127.2.1 {
|
4021 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
4022 karl 1.127.2.1 }
|
4023 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
4024 karl 1.127.2.1 {
|
4025 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
4026 karl 1.127.2.1 }
4027 else
4028 {
|
4029 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
4030 karl 1.127.2.1 }
4031
|
4032 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
4033 _checkMissingEndTagOrDuplicateParamValue(
4034 parser, duplicateParameter, emptyTag);
|
4035 karl 1.127.2.1 }
4036
|
4037 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
4038 karl 1.127.2.1
4039 AutoPtr<CIMOpenAssociatorInstancePathsRequestMessage> request(
4040 new CIMOpenAssociatorInstancePathsRequestMessage(
4041 messageId,
4042 nameSpace,
|
4043 karl 1.127.2.5 objectName.value,
4044 assocClass.value,
4045 resultClass.value,
4046 role.value,
4047 resultRole.value,
4048 filterQueryLanguage.value,
4049 filterQuery.value,
4050 operationTimeout.value,
4051 continueOnError.value,
4052 maxObjectCount.value,
|
4053 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
4054
4055 STAT_SERVERSTART
4056
4057 return request.release();
4058 }
4059
4060 CIMPullInstancesWithPathRequestMessage*
4061 CIMOperationRequestDecoder::decodePullInstancesWithPathRequest(
4062 Uint32 queueId,
4063 XmlParser& parser,
4064 const String& messageId,
4065 const CIMNamespaceName& nameSpace)
4066 {
4067 STAT_GETSTARTTIME
4068
4069 String enumerationContext = String::EMPTY;
|
4070 karl 1.127.2.5 Uint32 maxObjectCount = 0;
|
4071 karl 1.127.2.1
4072 Boolean duplicateParameter = false;
4073 Boolean gotEnumerationContext = false;
4074 Boolean gotMaxObjectCount = false;
4075
4076 Boolean emptyTag;
4077
4078 for (const char* name;
4079 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4080 {
4081 if (System::strcasecmp(name, "EnumerationContext") == 0)
4082 {
4083 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4084 XmlReader::getStringValueElement(parser, enumerationContext, true);
4085 duplicateParameter = gotEnumerationContext;
4086 gotEnumerationContext = true;
4087 }
4088
4089 else if (System::strcasecmp(name, "MaxObjectCount") == 0)
4090 {
4091 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4092 karl 1.127.2.1 XmlReader::getUint32ValueElement(parser, maxObjectCount, true);
4093 duplicateParameter = gotMaxObjectCount;
4094 gotMaxObjectCount = true;
4095 }
4096 else
4097 {
4098 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
4099 }
4100
4101 if (!emptyTag)
4102 {
4103 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4104 }
4105
4106 if (duplicateParameter)
4107 {
4108
4109 throw PEGASUS_CIM_EXCEPTION(
4110 CIM_ERR_INVALID_PARAMETER, "Duplicate IPARAM received");
4111 }
4112 }
4113 karl 1.127.2.1
4114 if (!gotEnumerationContext)
4115 {
4116 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4117 "EnumerationContext IPARAM required");
4118 }
4119
4120 if (!gotMaxObjectCount)
4121 {
4122 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4123 "MaxObjectCount IPARAM required");
4124 }
4125
4126 AutoPtr<CIMPullInstancesWithPathRequestMessage> request(
4127 new CIMPullInstancesWithPathRequestMessage(
4128 messageId,
4129 nameSpace,
4130 enumerationContext,
4131 maxObjectCount,
4132 QueueIdStack(queueId, _returnQueueId)));
4133
4134 karl 1.127.2.1 STAT_SERVERSTART
4135
4136 return request.release();
4137 }
4138
4139 CIMPullInstancePathsRequestMessage*
4140 CIMOperationRequestDecoder::decodePullInstancePathsRequest(
4141 Uint32 queueId,
4142 XmlParser& parser,
4143 const String& messageId,
4144 const CIMNamespaceName& nameSpace)
4145 {
4146 STAT_GETSTARTTIME
4147
4148 String enumerationContext = String::EMPTY;
|
4149 karl 1.127.2.5 Uint32 maxObjectCount = 0;
|
4150 karl 1.127.2.1
4151 Boolean duplicateParameter = false;
4152 Boolean gotEnumerationContext = false;
4153 Boolean gotMaxObjectCount = false;
4154
4155 Boolean emptyTag;
4156
4157 for (const char* name;
4158 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4159 {
4160 if (System::strcasecmp(name, "EnumerationContext") == 0)
4161 {
4162 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4163 XmlReader::getStringValueElement(parser, enumerationContext, true);
4164 duplicateParameter = gotEnumerationContext;
4165 gotEnumerationContext = true;
4166 }
4167
4168 else if (System::strcasecmp(name, "MaxObjectCount") == 0)
4169 {
4170 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4171 karl 1.127.2.1 XmlReader::getUint32ValueElement(parser, maxObjectCount, true);
4172 duplicateParameter = gotMaxObjectCount;
4173 gotMaxObjectCount = true;
4174 }
4175 else
4176 {
4177 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
4178 "Invalid IPARAMVALUE tag ");
4179 }
4180
4181 if (!emptyTag)
4182 {
4183 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4184 }
4185
4186 if (duplicateParameter)
4187 {
4188 throw PEGASUS_CIM_EXCEPTION(
4189 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
4190 }
4191 }
4192 karl 1.127.2.1
4193 if (!gotEnumerationContext)
4194 {
4195 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4196 "EnumerationContext IPARAM required");
4197 }
4198
4199 if (!gotMaxObjectCount)
4200 {
4201 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4202 "MaxObjectCount IPARAM required");
4203 }
4204
4205 AutoPtr<CIMPullInstancePathsRequestMessage> request(
4206 new CIMPullInstancePathsRequestMessage(
4207 messageId,
4208 nameSpace,
4209 enumerationContext,
4210 maxObjectCount,
4211 QueueIdStack(queueId, _returnQueueId)));
4212
4213 karl 1.127.2.1 STAT_SERVERSTART
4214
4215 return request.release();
4216 }
4217
4218 CIMCloseEnumerationRequestMessage*
4219 CIMOperationRequestDecoder::decodeCloseEnumerationRequest(
4220 Uint32 queueId,
4221 XmlParser& parser,
4222 const String& messageId,
4223 const CIMNamespaceName& nameSpace)
4224 {
4225 STAT_GETSTARTTIME
4226
4227 String enumerationContext = String::EMPTY;
4228 Boolean duplicateParameter = false;
4229 Boolean gotEnumerationContext = false;
4230
4231 Boolean emptyTag;
4232 for (const char* name;
4233 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4234 karl 1.127.2.1 {
4235 if (System::strcasecmp(name, "EnumerationContext") == 0)
4236 {
4237 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4238 XmlReader::getStringValueElement(parser, enumerationContext, true);
4239 duplicateParameter = gotEnumerationContext;
4240 gotEnumerationContext = true;
4241 }
4242 else
4243 {
4244 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
4245 }
4246
4247 if (!emptyTag)
4248 {
4249 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4250 }
4251
4252
4253 if (duplicateParameter)
4254 {
4255 karl 1.127.2.1 throw PEGASUS_CIM_EXCEPTION(
4256 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
4257 }
4258 }
4259
4260 if (!gotEnumerationContext)
4261 {
4262 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4263 "EnumerationContext IPARAM required");
4264 }
4265
4266 AutoPtr<CIMCloseEnumerationRequestMessage> request(
4267 new CIMCloseEnumerationRequestMessage(
4268 messageId,
4269 nameSpace,
4270 enumerationContext,
4271 QueueIdStack(queueId, _returnQueueId)));
4272
4273 STAT_SERVERSTART
4274
4275 return request.release();
4276 karl 1.127.2.1 }
4277
4278
4279 CIMEnumerationCountRequestMessage*
4280 CIMOperationRequestDecoder::decodeEnumerationCountRequest(
4281 Uint32 queueId,
4282 XmlParser& parser,
4283 const String& messageId,
4284 const CIMNamespaceName& nameSpace)
4285 {
4286 STAT_GETSTARTTIME
4287
4288 String enumerationContext = String::EMPTY;
4289 Boolean duplicateParameter = false;
4290 Boolean gotEnumerationContext = false;
4291
4292 Boolean emptyTag;
4293
4294 for (const char* name;
4295 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4296 {
4297 karl 1.127.2.1 if (System::strcasecmp(name, "EnumerationContext") == 0)
4298 {
4299 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4300 XmlReader::getStringValueElement(parser, enumerationContext, true);
4301 duplicateParameter = gotEnumerationContext;
4302 gotEnumerationContext = true;
4303 }
4304 else
4305 {
4306 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
4307 }
4308
4309 if (!emptyTag)
4310 {
4311 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4312 }
4313
4314 if (duplicateParameter)
4315 {
4316 throw PEGASUS_CIM_EXCEPTION(
4317 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
4318 karl 1.127.2.1 }
4319 }
4320
4321 if (!gotEnumerationContext)
4322 {
4323 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4324 "Missing EnumerationContext Parameter");
4325 }
4326
4327
4328 AutoPtr<CIMEnumerationCountRequestMessage> request(
4329 new CIMEnumerationCountRequestMessage(
4330 messageId,
4331 nameSpace,
4332 enumerationContext,
4333 QueueIdStack(queueId, _returnQueueId)));
4334
4335 STAT_SERVERSTART
4336
4337 return request.release();
4338 }
|
4339 karl 1.127.2.6
4340 CIMOpenQueryInstancesRequestMessage*
4341 CIMOperationRequestDecoder::decodeOpenQueryInstancesRequest(
4342 Uint32 queueId,
4343 XmlParser& parser,
4344 const String& messageId,
4345 const CIMNamespaceName& nameSpace)
4346 {
4347 STAT_GETSTARTTIME
4348
4349 stringIParam filterQueryLanguage("FilterQueryLanguage",true);
4350 stringIParam filterQuery("FilterQuery", true);
4351
4352 booleanIParam returnQueryResultClass("ReturnQueryResultClass");
4353 booleanIParam continueOnError("ContinueOnError");
4354 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
4355 uint32IParam maxObjectCount("MaxObjectCount", 0);
4356 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
4357 uint32ArgIParam operationTimeout("OperationTimeout");
4358
4359 Boolean duplicateParameter = false;
4360 karl 1.127.2.6 Boolean emptyTag;
4361
4362 for (const char* name;
4363 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4364 {
4365 // [IN,OPTIONAL,NULL] string FilterQueryLanguage = NULL,
4366 if(filterQueryLanguage.get(parser, name, emptyTag))
4367 {
4368 filterQueryLanguage.iParamFound(duplicateParameter);
4369 }
4370 // [IN,OPTIONAL,NULL] string FilterQuery = NULL,
4371 else if(filterQuery.get(parser, name, emptyTag))
4372 {
4373 filterQuery.iParamFound(duplicateParameter);
4374 }
4375 else if (returnQueryResultClass.get(parser, name, emptyTag))
4376 {
4377 returnQueryResultClass.iParamFound(duplicateParameter);
4378 }
4379 // [IN,OPTIONAL] Boolean ContinueOnError = false,
4380 else if (continueOnError.get(parser, name, emptyTag))
4381 karl 1.127.2.6 {
4382 continueOnError.iParamFound(duplicateParameter);
4383 }
4384 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
4385 else if (operationTimeout.get(parser, name, emptyTag))
4386 {
4387 operationTimeout.iParamFound(duplicateParameter);
4388 }
4389 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
4390 else if (maxObjectCount.get(parser, name, emptyTag))
4391 {
4392 maxObjectCount.iParamFound(duplicateParameter);
4393 }
4394 else
4395 {
4396 _throwCIMExceptionInvalidIParamName(name);
4397 }
4398
4399 // generate exception if endtag error or duplicate attributes
4400 _checkMissingEndTagOrDuplicateParamValue(
4401 parser, duplicateParameter, emptyTag);
4402 karl 1.127.2.6 }
4403
4404 _testRequiredParametersExist(filterQuery.got);
4405 _testRequiredParametersExist(filterQueryLanguage.got);
4406
4407 AutoPtr<CIMOpenQueryInstancesRequestMessage> request(
4408 new CIMOpenQueryInstancesRequestMessage(
4409 messageId,
4410 nameSpace,
4411 filterQuery.value,
4412 filterQueryLanguage.value,
4413 returnQueryResultClass.value,
4414 operationTimeout.value,
4415 continueOnError.value,
4416 maxObjectCount.value,
4417 QueueIdStack(queueId, _returnQueueId)));
4418
4419 STAT_SERVERSTART
4420
4421 return request.release();
4422 }
|
4423 karl 1.127.2.3 //EXP_PULL_END
|
4424 karl 1.127.2.1
|
4425 mike 1.2 void CIMOperationRequestDecoder::setServerTerminating(Boolean flag)
4426 {
|
4427 kumpf 1.104 _serverTerminating = flag;
|
4428 mike 1.2 }
4429
4430 PEGASUS_NAMESPACE_END
|
Return to
CIMOperationRequestDecoder.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Server