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 // End Of Pull Operations
|
1113 kumpf 1.104 else
1114 {
1115 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
1116 MessageLoaderParms(
1117 "Server.CIMOperationRequestDecoder."
1118 "UNRECOGNIZED_INTRINSIC_METHOD",
1119 "Unrecognized intrinsic method: $0",
1120 cimMethodName));
1121 }
1122 }
1123 catch (CIMException& e)
1124 {
1125 sendIMethodError(
1126 queueId,
1127 httpMethod,
1128 messageId,
1129 cimMethodName,
1130 e,
1131 closeConnect);
1132
1133 PEG_METHOD_EXIT();
1134 kumpf 1.104 return;
1135 }
1136 catch (XmlException&)
1137 {
1138 // XmlExceptions are handled below
1139 throw;
1140 }
1141 catch (Exception& e)
1142 {
1143 // Caught an unexpected exception from decoding. Since we must
1144 // have had a problem reconstructing a CIM object, we'll treat
1145 // it as an invalid parameter
1146 sendIMethodError(
1147 queueId,
1148 httpMethod,
1149 messageId,
1150 cimMethodName,
1151 PEGASUS_CIM_EXCEPTION(
1152 CIM_ERR_INVALID_PARAMETER, e.getMessage()),
1153 closeConnect);
1154
1155 kumpf 1.104 PEG_METHOD_EXIT();
1156 return;
1157 }
1158
1159 // Expect </IMETHODCALL>
1160
1161 XmlReader::expectEndTag(parser, "IMETHODCALL");
1162 }
1163 // Expect <METHODCALL ...>
1164 else if (XmlReader::getMethodCallStartTag(parser, cimMethodName))
1165 {
1166 CIMObjectPath reference;
1167
1168 // The Specification for CIM Operations over HTTP reads:
1169 // 3.3.6. CIMMethod
1170 //
1171 // This header MUST be present in any CIM Operation Request
1172 // message that contains a Simple Operation Request.
1173 //
1174 // It MUST NOT be present in any CIM Operation Response message,
1175 // nor in any CIM Operation Request message that is not a
1176 kumpf 1.104 // Simple Operation Request.
1177 //
1178 // The name of the CIM method within a Simple Operation Request
1179 // is defined to be the value of the NAME attribute of the
1180 // <METHODCALL> or <IMETHODCALL> element.
1181 //
1182 // If a CIM Server receives a CIM Operation Request for which
1183 // either:
1184 //
1185 // - The CIMMethod header is present but has an invalid value,
1186 // or;
1187 // - The CIMMethod header is not present but the Operation
1188 // Request Message is a Simple Operation Request, or;
1189 // - The CIMMethod header is present but the Operation Request
1190 // Message is not a Simple Operation Request, or;
1191 // - The CIMMethod header is present, the Operation Request
1192 // Message is a Simple Operation Request, but the
1193 // CIMIdentifier value (when unencoded) does not match the
1194 // unique method name within the Simple Operation Request,
1195 //
1196 // then it MUST fail the request and return a status of
1197 kumpf 1.104 // "400 Bad Request" (and MUST include a CIMError header in the
1198 // response with a value of header-mismatch), subject to the
1199 // considerations specified in Errors.
1200
1201 // Extrinic methods can have UTF-8!
1202 String cimMethodNameUTF16(cimMethodName);
1203 if (cimMethodNameUTF16 != cimMethodInHeader)
1204 {
1205 // ATTN-RK-P3-20020304: How to decode cimMethodInHeader?
1206 if (cimMethodInHeader == String::EMPTY)
1207 {
1208 MessageLoaderParms parms(
1209 "Server.CIMOperationRequestDecoder."
1210 "MISSING_CIMMETHOD_HTTP_HEADER",
1211 "Missing CIMMethod HTTP header.");
1212 sendHttpError(
1213 queueId,
1214 HTTP_STATUS_BADREQUEST,
1215 "header-mismatch",
1216 MessageLoader::getMessage(parms),
1217 closeConnect);
1218 kumpf 1.104 }
1219 else
1220 {
1221 MessageLoaderParms parms(
1222 "Server.CIMOperationRequestDecoder."
1223 "CIMMETHOD_VALUE_DOES_NOT_MATCH_REQUEST_METHOD",
1224 "CIMMethod value \"$0\" does not match CIM request "
1225 "method \"$1\".",
1226 (const char*)cimMethodInHeader.getCString(),
1227 cimMethodName);
1228 sendHttpError(
1229 queueId,
1230 HTTP_STATUS_BADREQUEST,
1231 "header-mismatch",
1232 MessageLoader::getMessage(parms),
1233 closeConnect);
1234 }
1235 PEG_METHOD_EXIT();
1236 return;
1237 }
1238
1239 kumpf 1.104 //
1240 // Check for <LOCALINSTANCEPATHELEMENT> or <LOCALCLASSPATHELEMENT>
1241 //
1242 if (!(XmlReader::getLocalInstancePathElement(parser, reference) ||
1243 XmlReader::getLocalClassPathElement(parser, reference)))
1244 {
1245 MessageLoaderParms parms(
1246 "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
1247 MISSING_ELEMENT_LOCALPATH);
1248 // this throw is not updated with MLP because
1249 // MISSING_ELEMENT_LOCALPATH is a hardcoded variable,
1250 // not a message
1251 throw XmlValidationError(parser.getLine(), parms);
1252 }
1253
1254 // The Specification for CIM Operations over HTTP reads:
1255 // 3.3.7. CIMObject
1256 //
1257 // This header MUST be present in any CIM Operation Request
1258 // message that contains a Simple Operation Request.
1259 //
1260 kumpf 1.104 // It MUST NOT be present in any CIM Operation Response message,
1261 // nor in any CIM Operation Request message that is not a
1262 // Simple Operation Request.
1263 //
1264 // The header identifies the CIM object (which MUST be a Class
1265 // or Instance for an extrinsic method, or a Namespace for an
1266 // intrinsic method) on which the method is to be invoked, using
1267 // a CIM object path encoded in an HTTP-safe representation.
1268 //
1269 // If a CIM Server receives a CIM Operation Request for which
1270 // either:
1271 //
1272 // - The CIMObject header is present but has an invalid value,
1273 // or;
1274 // - The CIMObject header is not present but the Operation
1275 // Request Message is a Simple Operation Request, or;
1276 // - The CIMObject header is present but the Operation Request
1277 // Message is not a Simple Operation Request, or;
1278 // - The CIMObject header is present, the Operation Request
1279 // Message is a Simple Operation Request, but the ObjectPath
1280 // value does not match (where match is defined in the section
1281 kumpf 1.104 // section on Encoding CIM Object Paths) the Operation Request
1282 // Message,
1283 //
1284 // then it MUST fail the request and return a status of
1285 // "400 Bad Request" (and MUST include a CIMError header in the
1286 // response with a value of header-mismatch), subject to the
1287 // considerations specified in Errors.
1288 if (cimObjectInHeader == String::EMPTY)
1289 {
1290 MessageLoaderParms parms(
1291 "Server.CIMOperationRequestDecoder."
1292 "MISSING_CIMOBJECT_HTTP_HEADER",
1293 "Missing CIMObject HTTP header.");
1294 sendHttpError(
1295 queueId,
1296 HTTP_STATUS_BADREQUEST,
1297 "header-mismatch",
1298 MessageLoader::getMessage(parms),
1299 closeConnect);
1300 PEG_METHOD_EXIT();
1301 return;
1302 kumpf 1.104 }
1303
1304 CIMObjectPath headerObjectReference;
1305 try
1306 {
1307 headerObjectReference.set(cimObjectInHeader);
1308 }
1309 catch (Exception&)
1310 {
1311 MessageLoaderParms parms(
1312 "Server.CIMOperationRequestDecoder."
1313 "COULD_NOT_PARSE_CIMOBJECT_VALUE",
1314 "Could not parse CIMObject value \"$0\".",
1315 cimObjectInHeader);
1316 sendHttpError(
1317 queueId,
1318 HTTP_STATUS_BADREQUEST,
1319 "header-mismatch",
1320 MessageLoader::getMessage(parms),
1321 closeConnect);
1322 PEG_METHOD_EXIT();
1323 kumpf 1.104 return;
1324 }
1325
1326 if (!reference.identical(headerObjectReference))
1327 {
1328 MessageLoaderParms parms(
1329 "Server.CIMOperationRequestDecoder."
|
1330 kumpf 1.113 "CIMOBJECT_VALUE_DOES_NOT_MATCH_REQUEST_OBJECT",
|
1331 kumpf 1.104 "CIMObject value \"$0\" does not match CIM request "
1332 "object \"$1\".",
1333 cimObjectInHeader,
|
1334 kumpf 1.113 reference.toString());
|
1335 kumpf 1.104 sendHttpError(
1336 queueId,
1337 HTTP_STATUS_BADREQUEST,
1338 "header-mismatch",
1339 MessageLoader::getMessage(parms),
1340 closeConnect);
1341 PEG_METHOD_EXIT();
1342 return;
1343 }
1344
1345 // This try block only catches CIMExceptions, because they must be
1346 // responded to with a proper METHODRESPONSE. Other exceptions are
1347 // caught in the outer try block.
1348 try
1349 {
1350 // Delegate to appropriate method to handle:
1351
1352 request.reset(decodeInvokeMethodRequest(
1353 queueId,
1354 parser,
1355 messageId,
1356 kumpf 1.104 reference,
1357 cimMethodNameUTF16)); // contains UTF-16 converted from UTF-8
1358 }
1359 catch (CIMException& e)
1360 {
1361 sendMethodError(
1362 queueId,
1363 httpMethod,
1364 messageId,
1365 cimMethodNameUTF16, // contains UTF-16 converted from UTF-8
1366 e,
1367 closeConnect);
1368
1369 PEG_METHOD_EXIT();
1370 return;
1371 }
1372 catch (XmlException&)
1373 {
1374 // XmlExceptions are handled below
1375 throw;
1376 }
1377 kumpf 1.104 catch (Exception& e)
1378 {
1379 // Caught an unexpected exception from decoding. Since we must
1380 // have had a problem reconstructing a CIM object, we'll treata
1381 // it as an invalid parameter
1382 sendMethodError(
1383 queueId,
1384 httpMethod,
1385 messageId,
1386 cimMethodNameUTF16, // contains UTF-16 converted from UTF-8
1387 PEGASUS_CIM_EXCEPTION(
1388 CIM_ERR_INVALID_PARAMETER, e.getMessage()),
1389 closeConnect);
1390
1391 PEG_METHOD_EXIT();
1392 return;
1393 }
|
1394 kumpf 1.73
|
1395 kumpf 1.104 // Expect </METHODCALL>
|
1396 mday 1.16
|
1397 kumpf 1.104 XmlReader::expectEndTag(parser, "METHODCALL");
1398 }
1399 else
1400 {
1401 MessageLoaderParms mlParms(
1402 "Server.CIMOperationRequestDecoder.EXPECTED_IMETHODCALL_ELEMENT",
1403 "expected IMETHODCALL or METHODCALL element");
1404 throw XmlValidationError(parser.getLine(),mlParms);
1405 }
1406
1407 // Expect </SIMPLEREQ>
1408
1409 XmlReader::expectEndTag(parser, "SIMPLEREQ");
1410
1411 // Expect </MESSAGE>
1412
1413 XmlReader::expectEndTag(parser, "MESSAGE");
1414
1415 // Expect </CIM>
1416
1417 XmlReader::expectEndTag(parser, "CIM");
1418 kumpf 1.104 }
1419 catch (XmlValidationError& e)
1420 {
|
1421 thilo.boehm 1.119 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
|
1422 kumpf 1.104 "CIMOperationRequestDecoder::handleMethodCall - "
|
1423 marek 1.116 "XmlValidationError exception has occurred. Message: %s",
1424 (const char*) e.getMessage().getCString()));
|
1425 kumpf 1.24
|
1426 kumpf 1.104 sendHttpError(
1427 queueId,
1428 HTTP_STATUS_BADREQUEST,
1429 "request-not-valid",
1430 e.getMessage(),
1431 closeConnect);
1432 PEG_METHOD_EXIT();
1433 return;
1434 }
1435 catch (XmlSemanticError& e)
1436 {
|
1437 thilo.boehm 1.119 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
|
1438 kumpf 1.104 "CIMOperationRequestDecoder::handleMethodCall - "
|
1439 marek 1.116 "XmlSemanticError exception has occurred. Message: %s",
1440 (const char*) e.getMessage().getCString()));
|
1441 mday 1.16
|
1442 kumpf 1.104 // ATTN-RK-P2-20020404: Is this the correct response for these errors?
1443 sendHttpError(
1444 queueId,
1445 HTTP_STATUS_BADREQUEST,
1446 "request-not-valid",
1447 e.getMessage(),
1448 closeConnect);
1449 PEG_METHOD_EXIT();
1450 return;
1451 }
1452 catch (XmlException& e)
1453 {
|
1454 thilo.boehm 1.119 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
|
1455 kumpf 1.104 "CIMOperationRequestDecoder::handleMethodCall - "
|
1456 marek 1.116 "XmlException has occurred. Message: %s",
1457 (const char*) e.getMessage().getCString()));
|
1458 kumpf 1.104
1459 sendHttpError(
1460 queueId,
1461 HTTP_STATUS_BADREQUEST,
1462 "request-not-well-formed",
1463 e.getMessage(),
1464 closeConnect);
1465 PEG_METHOD_EXIT();
1466 return;
1467 }
|
1468 karl 1.127.2.5 catch (TooManyElementsException& e)
1469 {
1470 PEG_TRACE((TRC_XML,Tracer::LEVEL1,
1471 "CIMOperationRequestDecoder::handleMethodCall - "
1472 "TooManyElementsException has occurred. Message: %s",
1473 (const char*) e.getMessage().getCString()));
1474
1475 sendHttpError(
1476 queueId,
1477 HTTP_STATUS_BADREQUEST,
1478 "request-with-too-many-elements",
1479 e.getMessage(),
1480 closeConnect);
1481 PEG_METHOD_EXIT();
1482 return;
1483 }
|
1484 kumpf 1.104 catch (Exception& e)
1485 {
1486 // Don't know why I got this exception. Seems like a bad thing.
1487 // Any exceptions we're expecting should be caught separately and
1488 // dealt with appropriately. This is a last resort.
1489 sendHttpError(
1490 queueId,
1491 HTTP_STATUS_INTERNALSERVERERROR,
1492 String::EMPTY,
1493 e.getMessage(),
1494 closeConnect);
1495 PEG_METHOD_EXIT();
1496 return;
1497 }
1498 catch (...)
1499 {
1500 // Don't know why I got whatever this is. Seems like a bad thing.
1501 // Any exceptions we're expecting should be caught separately and
1502 // dealt with appropriately. This is a last resort.
1503 sendHttpError(
1504 queueId,
1505 kumpf 1.104 HTTP_STATUS_INTERNALSERVERERROR,
1506 String::EMPTY,
1507 String::EMPTY,
1508 closeConnect);
1509 PEG_METHOD_EXIT();
1510 return;
1511 }
1512
1513 STAT_BYTESREAD
1514
1515 request->authType = authType;
1516 request->userName = userName;
1517 request->ipAddress = ipAddress;
1518 request->setHttpMethod (httpMethod);
|
1519 mike 1.120 request->binaryResponse = binaryResponse;
|
1520 sage 1.41
|
1521 chuck 1.58 //l10n start
1522 // l10n TODO - might want to move A-L and C-L to Message
1523 // to make this more maintainable
|
1524 kumpf 1.104 // Add the language headers to the request
1525 CIMMessage* cimmsg = dynamic_cast<CIMMessage*>(request.get());
1526 if (cimmsg != NULL)
1527 {
1528 cimmsg->operationContext.insert(IdentityContainer(userName));
1529 cimmsg->operationContext.set(
1530 AcceptLanguageListContainer(httpAcceptLanguages));
1531 cimmsg->operationContext.set(
1532 ContentLanguageListContainer(httpContentLanguages));
1533 }
1534 else
1535 {
1536 ; // l10n TODO - error back to client here
1537 }
|
1538 chip 1.92 // l10n end
|
1539 chuck 1.58
|
1540 kumpf 1.104 request->setCloseConnect(closeConnect);
1541 _outputQueue->enqueue(request.release());
|
1542 chip 1.92
|
1543 kumpf 1.104 PEG_METHOD_EXIT();
|
1544 mike 1.2 }
|
1545 karl 1.127.2.5 /**************************************************************************
1546 **
1547 ** Decode CIM Operation Type Common IParameter types.
1548 ** Each class defines processing for a particular IPARAM type
1549 ** (ex. boolean)or parameter name (i.e. propertyListIParam)
1550 ** Each struct defines:
1551 ** got - Boolean defines whether this parameter has been found
1552 ** value - The value container for this type
1553 ** iParamFound(...) - function sets the duplicate flag and the got flag
1554 ** get - Function to get the defined parameter from the
1555 ** parser
1556 ** NOTE: at least one has multiple get.. functions.
1557 ** NOTE: Some of these are defined for a particular attribute (ex.
1558 ** propertyListIparam) so the attribute name is integrated into the
1559 ** methods and others for a whole class of attributes (Boolean,
1560 ** String,ClassName etc.) so the attribute name is defined as part
1561 ** of the constructor.
1562 ***************************************************************************/
1563 // Common xml attribute accessor for all boolean attributes. The
1564 // attribute name is defined in the constructor.
1565 // The usage pattern is:
1566 karl 1.127.2.5 // Boolean duplicate; // Flag to indicate multiple calls
1567 //
1568 // booleanIParam xyz("xyz"); default is false for attribute xyz
1569 //
1570 // if(xyz.get(parser, name, emptyTag) // parses to test if name == xyz
1571 // iParamFound(duplicate); // set flag to indicate exists etc.
1572 class booleanIParam
1573 {
1574 public:
1575 Boolean got;
1576 Boolean value;
1577
1578 // constructor with default value = false
1579 booleanIParam(const char* name): got(false),value(false),iParamName(name){}
1580
1581 // constructor with initial value specifically set from the input
1582 booleanIParam(const char* name, Boolean _value):
1583 got(false),value(_value),iParamName(name){}
1584
1585 ~booleanIParam(){}
1586
1587 karl 1.127.2.5 void iParamFound(Boolean& duplicate)
1588 {
1589 duplicate = got;
1590 got = true;
1591 }
1592
1593 // get the value of the parameter if the parameter if it exists.
1594 // Note that the attribute name is defined in the constructor
1595 // Value is required.
1596 // @param parser
1597 // @param testName attribute name from parse.
1598 // @emptyTag returns true if emptyTag returned true from parser
1599 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
1600 {
1601 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
1602 {
1603 XmlReader::rejectNullIParamValue(parser, emptyTag,
1604 iParamName.getCString());
1605 XmlReader::getBooleanValueElement(parser, value, true);
1606 return true;
1607 }
1608 karl 1.127.2.5 return false;
1609 }
1610 private:
1611 String iParamName;
1612 // hide unused default constructor and assign, copy constructors
1613 booleanIParam();
1614 booleanIParam(const booleanIParam&);
1615 booleanIParam& operator = (const booleanIParam&);
1616 };
1617
1618 // decode Iparam to CIMName representing class names. This struct
1619 // has two get functions:
1620 // get - parse where the parameter value is required
1621 // getOptional - parse where the parameter value is optional
1622
1623 class classNameIParam
1624 {
1625 public:
1626 Boolean got;
1627 CIMName value;
1628
1629 karl 1.127.2.5 // Set the flag to inidcate that this IParam has been gotten and also
1630 // set the flag defined by the duplicate parameter
1631 // @param duplicate Boolean that is set to previous value of the got
1632 // variable indicating whether this is second call to this IParam
1633 void iParamFound(Boolean& duplicate)
1634 {
1635 duplicate = got;
1636 got = true;
1637 }
1638
1639 // construct an IParam definition with name.
1640 // @param name const char* defining name of IParam to match
1641 // @return true if IParam found with _attrName
1642 classNameIParam(const char* name): got(false), iParamName(name){}
1643
1644 ~classNameIParam(){}
1645
1646 // Get Required value element.Test for name parameter as IParam with
1647 // name and if found, if value not NULL, parse the className and
1648 // set into value
1649 Boolean get(XmlParser& parser, const char* name, Boolean& emptyTag)
1650 karl 1.127.2.5 {
1651 if (System::strcasecmp(name,iParamName.getCString()) == 0)
1652 {
1653 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1654 XmlReader::getClassNameElement(parser, value, true);
1655 return true;
1656 }
1657 return false;
1658 }
1659 // Get Iparam with optional value.
1660 Boolean getOptional(XmlParser& parser, const char* name,
1661 Boolean& emptyTag)
1662 {
1663 if (System::strcasecmp(name, iParamName.getCString()) == 0)
1664 {
1665 // value may be NULL
1666 if (!emptyTag)
1667 {
1668 XmlReader::getClassNameElement(parser, value, false);
1669 }
1670 return true;
1671 karl 1.127.2.5 }
1672 return false;
1673 }
1674 private:
1675 String iParamName;
1676 // hide unused default constructor and assign, copy constructors
1677 classNameIParam();
1678 classNameIParam(const classNameIParam&);
1679 classNameIParam& operator = (const classNameIParam&);
1680 };
1681
1682 // test for "InstanceName" iParam and if found, return CIMObjectPath
1683 // in value
1684 class instanceNameIParam
1685 {
1686 public:
1687 Boolean got;
1688 CIMObjectPath value;
1689
1690 void iParamFound(Boolean& duplicate)
1691 {
1692 karl 1.127.2.5 duplicate = got;
1693 got = true;
1694 }
1695 instanceNameIParam(): got(false){}
1696
1697 ~instanceNameIParam(){}
1698
1699 Boolean get(XmlParser& parser, const char * name, Boolean& emptyTag)
1700 {
1701 if (System::strcasecmp(name, "InstanceName") == 0)
1702 {
1703 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1704 XmlReader::getInstanceNameElement(parser, value);
1705 return true;
1706 }
1707 return false;
1708 }
1709 private:
1710 // hide unused assign, copy constructors
1711 instanceNameIParam(const instanceNameIParam&);
1712 instanceNameIParam& operator = (const instanceNameIParam&);
1713 karl 1.127.2.5 };
1714
1715 // test for "ObjectName" attribute and if found, return CIMObjectPath
1716 // This struct has an extra attribute, the flag isClassNameElement which
1717 // returns true if the objectName was a classPath and not an instance
1718 // path.
1719 // If Xmlreader returns true, this is class only element, no
1720 // key bindings. That state must be set into the request
1721 // message (ex. objectName.isClassElement)
1722 // @param (Optional) Name of IParam. Default is ObjectName. Note
1723 // that pull operations use InstanceName as IParamName.
1724 class objectNameIParam
1725 {
1726 public:
1727 Boolean got;
1728 CIMObjectPath value;
1729 Boolean isClassNameElement;
1730
1731 void iParamFound(Boolean& duplicate)
1732 {
1733 duplicate = got;
1734 karl 1.127.2.5 got = true;
1735 }
1736
1737 // Constructor using default IParam name
1738 objectNameIParam(): got(false), isClassNameElement(false),
1739 iParamName("ObjectName"){}
1740
1741 // Constructor with IParam name included
1742 objectNameIParam(const char* name): got(false), isClassNameElement(false),
1743 iParamName(name){}
1744
1745 ~objectNameIParam(){}
1746
1747 Boolean get(XmlParser& parser, const char * name, Boolean& emptyTag)
1748 {
1749 if (System::strcasecmp(name, iParamName.getCString()) == 0)
1750 {
1751 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
1752 isClassNameElement =
1753 XmlReader::getObjectNameElement(parser, value);
1754 return true;
1755 karl 1.127.2.5 }
1756 return false;
1757 }
1758 private:
1759 String iParamName;
1760 // hide unused assign, copy constructors
1761 objectNameIParam(const objectNameIParam&);
1762 objectNameIParam& operator = (const objectNameIParam&);
1763 };
1764
1765 // test for "PropertyList" attribute and, if found, return property list
1766 // in the value element.
1767 class propertyListIParam
1768 {
1769 public:
1770 Boolean got;
1771 CIMPropertyList value;
1772
1773 void iParamFound(Boolean& duplicate)
1774 {
1775 duplicate = got;
1776 karl 1.127.2.5 got = true;
1777 }
1778
1779 // construct a propertyListIParam object
1780 propertyListIParam(): got(false){}
1781
1782 ~propertyListIParam(){}
1783
1784 Boolean get(XmlParser& parser, const char* name, Boolean& emptyTag)
1785 {
1786 if (System::strcasecmp(name, "PropertyList") == 0)
1787 {
1788 if (!emptyTag)
1789 {
1790 CIMValue pl;
1791 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
1792 {
1793 Array<String> propertyListArray;
1794 pl.get(propertyListArray);
1795 // NOTE: Cannot use the propertyList.set(...) method
1796 // here because set does not create propertyList tags
1797 karl 1.127.2.5 value.append(propertyListArray);
1798 }
1799 }
1800 return true;
1801 }
1802 return false;
1803 }
1804
1805 // This version of the get function usees the propertyList set function
1806 // to set the property list array into the propertyList object. It
1807 // can only be used for those Operations where the propertylist is NOT
1808 // used by the Server in the response (i.e. getClass and modifyInstance).
1809 //
1810 Boolean getSpecial(XmlParser& parser, const char* name, Boolean& emptyTag)
1811 {
1812 if (System::strcasecmp(name, "PropertyList") == 0)
1813 {
1814 if (!emptyTag)
1815 {
1816 CIMValue pl;
1817 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, pl))
1818 karl 1.127.2.5 {
1819 Array<String> propertyListArray;
1820 pl.get(propertyListArray);
1821 Array<CIMName> cimNameArray;
1822 // Map the strings to CIMNames.
1823 for (Uint32 i = 0; i < propertyListArray.size(); i++)
1824 {
1825 cimNameArray.append(propertyListArray[i]);
1826 }
1827 // use set to put list into property list without
1828 // setting propertyList tags.
1829 value.set(cimNameArray);
1830 }
1831 }
1832 return true;
1833 }
1834 return false;
1835 }
1836 private:
1837 // hide unused default assign, copy constructors
1838 propertyListIParam(const propertyListIParam&);
1839 karl 1.127.2.5 propertyListIParam& operator = (const propertyListIParam&);
1840 };
1841
1842 // Attribute decoder for String Parameters
1843 // The constructor MUST include the attribute name.
1844 // The second defines whether a value is required.
1845 // If true and there is no value, the XmlReader does an exception.
1846 class stringIParam
1847 {
1848 public:
1849 Boolean got;
1850 String value;
1851
1852 // constructor with definition of attribute and default for the
1853 // required flag.
1854 // @param name const char* with name of IParam to match
1855 // @param valueRequired Boolean that defines whether value is required
1856 stringIParam(const char* name, Boolean _valueRequired):
1857 got(false), iParamName(name), valueRequired(_valueRequired){}
1858
1859 ~stringIParam(){}
1860 karl 1.127.2.5
1861 void iParamFound(Boolean& duplicate)
1862 {
1863 duplicate = got;
1864 got = true;
1865 }
1866
1867 // get the attribute if it exists. The attribute name is defined in
1868 // the constructor
1869 // @param parser
1870 // @param testName attribute name from parse.
1871 // @emptyTag returns true if emptyTag returned true from parser
1872 // @return Returns true if testName matches the IParam defined by current
1873 // position in the parser
1874 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
1875 {
1876 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
1877 {
1878 if (!emptyTag)
1879 {
1880 XmlReader::getStringValueElement(parser, value, valueRequired);
1881 karl 1.127.2.5 }
1882 return true;
1883 }
1884 return false;
1885 }
1886 private:
1887 String iParamName;
1888 Boolean valueRequired;
1889 stringIParam();
1890 stringIParam(const stringIParam&);
1891 stringIParam& operator = (const stringIParam&);
1892 };
1893
1894 // Attribute decoder for Uint32Arg Parameters
1895 // The constructor MUST include the attribute name.
1896 // The second defines whether a value is required.
1897 // If true and there is no value, the XmlReader does an exception.
1898 //
1899 //// KS_TODO This one not done yet. Need to sort our required, etc.
1900 class uint32ArgIParam
1901 {
1902 karl 1.127.2.5 public:
1903 Boolean got;
1904 Uint32Arg value;
1905
1906 // constructor with definition of iParam name and default for the
1907 // required flag (false). Default value of parameter is NULL if
1908 // no value is supplied.
1909 // @param name const char* with name of IParam to match
1910 uint32ArgIParam(const char* name):
1911 got(false), iParamName(name), valueRequired(false){}
1912
1913 // constructor with definition of iParam name and default for the
1914 // required flag (false). Default value of parameter is integer defined
1915 // by supplied value.
1916 // @param name const char* with name of IParam to match
1917 uint32ArgIParam(const char* name, Uint32 _int):
1918 got(false), value(_int), iParamName(name), valueRequired(false){}
1919
1920 // constructor with definition of attribute and default for the
1921 // required flag.
1922 // @param name const char* with name of IParam to match
1923 karl 1.127.2.5 // @param valueRequired Boolean that defines whether value is required
1924 //// uint32ArgIParam(const char* name, Boolean _valueRequired):
1925 //// got(false), iParamName(name), valueRequired(_valueRequired){}
1926
1927 ~uint32ArgIParam(){}
1928
1929 void iParamFound(Boolean& duplicate)
1930 {
1931 duplicate = got;
1932 got = true;
1933 }
1934
1935 // get the attribute if it exists. The attribute name is defined in
1936 // the constructor
1937 // @param parser
1938 // @param testName attribute name from parse.
1939 // @emptyTag returns true if emptyTag returned true from parser
1940 // @return Returns true if testName matches the IParam defined by current
1941 // position in the parser
1942 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
1943 {
1944 karl 1.127.2.5 if (valueRequired)
1945 {
1946 XmlReader::rejectNullIParamValue(parser, emptyTag, testName);
1947 }
1948 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
1949 {
1950 XmlReader::getUint32ArgValueElement(parser, value, true);
1951 return true;
1952 }
1953 return false;
1954 }
1955 private:
1956 String iParamName;
1957 Boolean valueRequired;
1958 uint32ArgIParam();
1959 uint32ArgIParam(const uint32ArgIParam&);
1960 uint32ArgIParam& operator = (const uint32ArgIParam&);
1961 };
1962
1963 // Attribute decoder for Uint32 Parameters
1964 // The constructor MUST include the attribute name.
1965 karl 1.127.2.5 // The second defines whether a value is required.
1966 // If true and there is no value, the XmlReader does an exception.
1967 class uint32IParam
1968 {
1969 public:
1970 Boolean got;
1971 Uint32 value;
1972
1973 // constructor with definition of iParam name and default for the
1974 // required flag (false). Default value of parameter is NULL if
1975 // no value is supplied.
1976 // @param name const char* with name of IParam to match
1977 uint32IParam(const char* name):
1978 got(false), iParamName(name), valueRequired(false){}
1979
1980 // constructor with definition of iParam name and default for the
1981 // required flag (false). Default value of parameter is integer defined
1982 // by supplied value.
1983 // @param name const char* with name of IParam to match
1984 uint32IParam(const char* name, Uint32 _int):
1985 got(false), value(_int), iParamName(name), valueRequired(false){}
1986 karl 1.127.2.5
1987 // constructor with definition of attribute and default for the
1988 // required flag.
1989 // @param name const char* with name of IParam to match
1990 // @param valueRequired Boolean that defines whether value is required
1991 //// uint32IParam(const char* name, Boolean _valueRequired):
1992 //// got(false), iParamName(name), valueRequired(_valueRequired){}
1993
1994 ~uint32IParam(){}
1995
1996 void iParamFound(Boolean& duplicate)
1997 {
1998 duplicate = got;
1999 got = true;
2000 }
2001
2002 // get the attribute if it exists. The attribute name is defined in
2003 // the constructor
2004 // @param parser
2005 // @param testName attribute name from parse.
2006 // @emptyTag returns true if emptyTag returned true from parser
2007 karl 1.127.2.5 // @return Returns true if testName matches the IParam defined by current
2008 // position in the parser
2009 Boolean get(XmlParser& parser, const char * testName, Boolean& emptyTag)
2010 {
2011 if (valueRequired)
2012 {
2013 XmlReader::rejectNullIParamValue(parser, emptyTag, testName);
2014 }
2015 if (System::strcasecmp(iParamName.getCString(), testName) == 0)
2016 {
2017 XmlReader::getUint32ValueElement(parser, value, true);
2018 return true;
2019 }
2020 return false;
2021 }
2022 private:
2023 String iParamName;
2024 Boolean valueRequired;
2025 uint32IParam();
2026 uint32IParam(const uint32IParam&);
2027 uint32IParam& operator = (const uint32IParam&);
2028 karl 1.127.2.5 };
2029
2030 /************************************************************************
2031 **
2032 ** Common functions used by the decoders to avoid duplicate code.
2033 **
2034 **************************************************************************/
2035 // test for valid end of XML and duplicate parameters on input
2036 // This function returns if OK or executes appropriate exceptions if there
2037 // is either a duplicate (duplicateParameter == true) or the
2038 // end tag IPARAMVALUE is not found.
2039 void _checkMissingEndTagOrDuplicateParamValue(
2040 XmlParser& parser, Boolean duplicateParameter, Boolean emptyTag)
2041 {
2042 if (!emptyTag)
2043 {
2044 XmlReader::expectEndTag(parser, "IPARAMVALUE");
2045 }
2046
2047 if (duplicateParameter)
2048 {
2049 karl 1.127.2.5 _throwCIMExceptionDuplicateParameter();
2050 }
2051 }
2052
2053 // test if Required paramters exist (i.e. the got variable is
2054 // true. Generates exception if exist == false
2055 void _testRequiredParametersExist(Boolean exist)
2056 {
2057 if (!exist)
2058 {
2059 _throwCIMExceptionInvalidParameter();
2060 }
2061 }
2062 /**************************************************************************
2063 **
2064 ** Decode each CIMOperation type, processing the parameters for that type
2065 ** and producing either a CIMMessage of the appropriate type or
2066 ** an exception.
2067 **
2068 ***************************************************************************/
|
2069 mike 1.2
|
2070 kumpf 1.104 CIMCreateClassRequestMessage*
2071 CIMOperationRequestDecoder::decodeCreateClassRequest(
2072 Uint32 queueId,
2073 XmlParser& parser,
2074 const String& messageId,
2075 const CIMNamespaceName& nameSpace)
2076 {
2077 STAT_GETSTARTTIME
2078
2079 CIMClass newClass;
|
2080 karl 1.127.2.5 Boolean gotNewClass = false;
2081
|
2082 kumpf 1.104 Boolean emptyTag;
|
2083 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2084 kumpf 1.104
2085 for (const char* name;
2086 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2087 {
2088 if (System::strcasecmp(name, "NewClass") == 0)
2089 {
2090 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
|
2091 kumpf 1.106 if (!XmlReader::getClassElement(parser, newClass))
2092 {
|
2093 karl 1.127.2.5 _throwCIMExceptionInvalidParameter("NewClass");
|
2094 kumpf 1.106 }
|
2095 karl 1.127.2.5 duplicateParameter = gotNewClass;
2096 gotNewClass = true;
|
2097 kumpf 1.104 }
2098 else
2099 {
|
2100 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2101 kumpf 1.104 }
|
2102 sage 1.41
|
2103 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2104 _checkMissingEndTagOrDuplicateParamValue(
2105 parser, duplicateParameter, emptyTag);
|
2106 kumpf 1.104 }
2107
|
2108 karl 1.127.2.5 _testRequiredParametersExist(gotNewClass);
|
2109 kumpf 1.104
2110 AutoPtr<CIMCreateClassRequestMessage> request(
2111 new CIMCreateClassRequestMessage(
2112 messageId,
2113 nameSpace,
2114 newClass,
2115 QueueIdStack(queueId, _returnQueueId)));
2116
2117 STAT_SERVERSTART
2118
2119 return request.release();
|
2120 mike 1.2 }
2121
2122 CIMGetClassRequestMessage* CIMOperationRequestDecoder::decodeGetClassRequest(
|
2123 kumpf 1.104 Uint32 queueId,
2124 XmlParser& parser,
2125 const String& messageId,
2126 const CIMNamespaceName& nameSpace)
2127 {
2128 STAT_GETSTARTTIME
2129
|
2130 karl 1.127.2.5 // GetClass Parameters
2131 classNameIParam className("ClassName");
2132 booleanIParam localOnly("localOnly",true);
2133 booleanIParam includeQualifiers("IncludeQualifiers", true);
2134 booleanIParam includeClassOrigin("IncludeClassOrigin");
2135 propertyListIParam propertyList;
2136
|
2137 kumpf 1.104 Boolean duplicateParameter = false;
2138 Boolean emptyTag;
2139
2140 for (const char* name;
2141 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2142 {
|
2143 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2144 kumpf 1.104 {
|
2145 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2146 kumpf 1.104 }
|
2147 karl 1.127.2.5 else if(localOnly.get(parser, name, emptyTag))
|
2148 kumpf 1.104 {
|
2149 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2150 kumpf 1.104 }
|
2151 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2152 kumpf 1.104 {
|
2153 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2154 kumpf 1.104 }
|
2155 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2156 kumpf 1.104 {
|
2157 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2158 kumpf 1.104 }
|
2159 karl 1.127.2.5 else if(propertyList.getSpecial(parser, name, emptyTag))
|
2160 kumpf 1.104 {
|
2161 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2162 kumpf 1.104 }
2163 else
2164 {
|
2165 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2166 kumpf 1.104 }
|
2167 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2168 _checkMissingEndTagOrDuplicateParamValue(
2169 parser, duplicateParameter, emptyTag);
|
2170 kumpf 1.104 }
2171
|
2172 karl 1.127.2.5 // test for required parameters
2173 _testRequiredParametersExist(className.got);
|
2174 kumpf 1.104
|
2175 karl 1.127.2.5 // Build message
|
2176 kumpf 1.104 AutoPtr<CIMGetClassRequestMessage> request(new CIMGetClassRequestMessage(
2177 messageId,
2178 nameSpace,
|
2179 karl 1.127.2.5 className.value,
2180 localOnly.value,
2181 includeQualifiers.value,
2182 includeClassOrigin.value,
2183 propertyList.value,
|
2184 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2185
2186 STAT_SERVERSTART
2187
2188 return request.release();
2189 }
2190
2191 CIMModifyClassRequestMessage*
2192 CIMOperationRequestDecoder::decodeModifyClassRequest(
2193 Uint32 queueId,
2194 XmlParser& parser,
2195 const String& messageId,
2196 const CIMNamespaceName& nameSpace)
2197 {
2198 STAT_GETSTARTTIME
2199
2200 CIMClass modifiedClass;
2201 Boolean gotClass = false;
|
2202 karl 1.127.2.5
|
2203 kumpf 1.104 Boolean emptyTag;
|
2204 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2205 kumpf 1.104
2206 for (const char* name;
2207 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2208 {
2209 if (System::strcasecmp(name, "ModifiedClass") == 0)
2210 {
2211 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
|
2212 kumpf 1.106 if (!XmlReader::getClassElement(parser, modifiedClass))
2213 {
|
2214 karl 1.127.2.5 _throwCIMExceptionInvalidParameter("ModifiedClass");
|
2215 kumpf 1.106 }
|
2216 kumpf 1.104 duplicateParameter = gotClass;
2217 gotClass = true;
2218 }
2219 else
2220 {
|
2221 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2222 kumpf 1.104 }
2223
|
2224 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2225 _checkMissingEndTagOrDuplicateParamValue(
2226 parser, duplicateParameter, emptyTag);
|
2227 kumpf 1.104 }
2228
|
2229 karl 1.127.2.5 _testRequiredParametersExist(gotClass);
|
2230 kumpf 1.104
2231 AutoPtr<CIMModifyClassRequestMessage> request(
2232 new CIMModifyClassRequestMessage(
2233 messageId,
2234 nameSpace,
2235 modifiedClass,
2236 QueueIdStack(queueId, _returnQueueId)));
2237
2238 STAT_SERVERSTART
2239
2240 return request.release();
2241 }
2242
2243 CIMEnumerateClassNamesRequestMessage*
2244 CIMOperationRequestDecoder::decodeEnumerateClassNamesRequest(
2245 Uint32 queueId,
2246 XmlParser& parser,
2247 const String& messageId,
2248 const CIMNamespaceName& nameSpace)
2249 {
2250 STAT_GETSTARTTIME
2251 kumpf 1.104
|
2252 karl 1.127.2.5 classNameIParam className("ClassName");
2253 booleanIParam deepInheritance("DeepInheritance");
2254
|
2255 kumpf 1.104 Boolean duplicateParameter = false;
2256 Boolean emptyTag;
2257
2258 for (const char* name;
2259 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2260 {
|
2261 karl 1.127.2.5 if(className.getOptional(parser, name, emptyTag))
|
2262 kumpf 1.104 {
|
2263 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2264 kumpf 1.104 }
|
2265 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
2266 kumpf 1.104 {
|
2267 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
2268 kumpf 1.104 }
2269 else
2270 {
|
2271 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2272 kumpf 1.104 }
2273
|
2274 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2275 _checkMissingEndTagOrDuplicateParamValue(
2276 parser, duplicateParameter, emptyTag);
|
2277 kumpf 1.104 }
2278
|
2279 karl 1.127.2.5 // NOTE: className not required for this operation
2280
|
2281 kumpf 1.104 AutoPtr<CIMEnumerateClassNamesRequestMessage> request(
2282 new CIMEnumerateClassNamesRequestMessage(
2283 messageId,
2284 nameSpace,
|
2285 karl 1.127.2.5 className.value,
2286 deepInheritance.value,
|
2287 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2288
2289 STAT_SERVERSTART
2290
2291 return request.release();
2292 }
2293
2294 CIMEnumerateClassesRequestMessage*
2295 CIMOperationRequestDecoder::decodeEnumerateClassesRequest(
2296 Uint32 queueId,
2297 XmlParser& parser,
2298 const String& messageId,
2299 const CIMNamespaceName& nameSpace)
2300 {
2301 STAT_GETSTARTTIME
2302
|
2303 karl 1.127.2.5 // EnumerateClasses Parameters
2304 classNameIParam className("ClassName");
2305 booleanIParam deepInheritance("deepInheritance");
2306 booleanIParam localOnly("localOnly",true);
2307 booleanIParam includeQualifiers("IncludeQualifiers", true);
2308 booleanIParam includeClassOrigin("IncludeClassOrigin");
2309
|
2310 kumpf 1.104 Boolean duplicateParameter = false;
2311 Boolean emptyTag;
2312
2313 for (const char* name;
2314 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2315 {
|
2316 karl 1.127.2.5 if(className.getOptional(parser, name, emptyTag))
|
2317 kumpf 1.104 {
|
2318 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2319 kumpf 1.104 }
|
2320 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
2321 kumpf 1.104 {
|
2322 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
2323 kumpf 1.104 }
|
2324 karl 1.127.2.5 else if(localOnly.get(parser, name, emptyTag))
|
2325 kumpf 1.104 {
|
2326 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2327 kumpf 1.104 }
|
2328 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2329 kumpf 1.104 {
|
2330 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2331 kumpf 1.104 }
|
2332 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2333 kumpf 1.104 {
|
2334 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2335 kumpf 1.104 }
2336 else
2337 {
|
2338 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2339 kumpf 1.104 }
2340
|
2341 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2342 _checkMissingEndTagOrDuplicateParamValue(
2343 parser, duplicateParameter, emptyTag);
|
2344 kumpf 1.104 }
2345
|
2346 karl 1.127.2.5 // NOTE: Class name not required for this enumerate.
2347
|
2348 kumpf 1.104 AutoPtr<CIMEnumerateClassesRequestMessage> request(
2349 new CIMEnumerateClassesRequestMessage(
2350 messageId,
2351 nameSpace,
|
2352 karl 1.127.2.5 className.value,
2353 deepInheritance.value,
2354 localOnly.value,
2355 includeQualifiers.value,
2356 includeClassOrigin.value,
|
2357 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2358
2359 STAT_SERVERSTART
2360
2361 return request.release();
2362 }
2363
2364 CIMDeleteClassRequestMessage*
2365 CIMOperationRequestDecoder::decodeDeleteClassRequest(
2366 Uint32 queueId,
2367 XmlParser& parser,
2368 const String& messageId,
2369 const CIMNamespaceName& nameSpace)
2370 {
2371 STAT_GETSTARTTIME
2372
|
2373 karl 1.127.2.5 classNameIParam className("ClassName");
2374
|
2375 kumpf 1.104 Boolean duplicateParameter = false;
2376 Boolean emptyTag;
2377
2378 for (const char* name;
2379 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2380 {
|
2381 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2382 kumpf 1.104 {
|
2383 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2384 kumpf 1.104 }
2385 else
2386 {
|
2387 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2388 kumpf 1.104 }
2389
|
2390 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2391 _checkMissingEndTagOrDuplicateParamValue(
2392 parser, duplicateParameter, emptyTag);
|
2393 kumpf 1.104 }
2394
|
2395 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
2396 kumpf 1.104
2397 AutoPtr<CIMDeleteClassRequestMessage> request(
2398 new CIMDeleteClassRequestMessage(
2399 messageId,
2400 nameSpace,
|
2401 karl 1.127.2.5 className.value,
|
2402 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2403
2404 STAT_SERVERSTART
2405
2406 return request.release();
2407 }
2408
2409 CIMCreateInstanceRequestMessage*
2410 CIMOperationRequestDecoder::decodeCreateInstanceRequest(
2411 Uint32 queueId,
2412 XmlParser& parser,
2413 const String& messageId,
2414 const CIMNamespaceName& nameSpace)
2415 {
2416 STAT_GETSTARTTIME
2417
2418 CIMInstance newInstance;
2419 Boolean gotInstance = false;
|
2420 karl 1.127.2.5
|
2421 kumpf 1.104 Boolean emptyTag;
|
2422 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2423 kumpf 1.104
2424 for (const char* name;
2425 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2426 {
2427 if (System::strcasecmp(name, "NewInstance") == 0)
2428 {
2429 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2430 XmlReader::getInstanceElement(parser, newInstance);
2431 duplicateParameter = gotInstance;
2432 gotInstance = true;
2433 }
2434 else
2435 {
|
2436 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2437 kumpf 1.104 }
2438
|
2439 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2440 _checkMissingEndTagOrDuplicateParamValue(
2441 parser, duplicateParameter, emptyTag);
|
2442 kumpf 1.104 }
2443
|
2444 karl 1.127.2.5
2445 _testRequiredParametersExist(gotInstance);
|
2446 kumpf 1.104
2447 AutoPtr<CIMCreateInstanceRequestMessage> request(
2448 new CIMCreateInstanceRequestMessage(
2449 messageId,
2450 nameSpace,
2451 newInstance,
2452 QueueIdStack(queueId, _returnQueueId)));
2453
2454 STAT_SERVERSTART
2455
2456 return request.release();
2457 }
2458
2459 CIMGetInstanceRequestMessage*
2460 CIMOperationRequestDecoder::decodeGetInstanceRequest(
2461 Uint32 queueId,
2462 XmlParser& parser,
2463 const String& messageId,
2464 const CIMNamespaceName& nameSpace)
2465 {
2466 STAT_GETSTARTTIME
2467 kumpf 1.104
|
2468 karl 1.127.2.5 instanceNameIParam instanceName;
2469 // This attribute is accepted for compatibility reasons, but is
2470 // not honored because it is deprecated.
2471 booleanIParam localOnly("localOnly",true);
2472 booleanIParam includeQualifiers("IncludeQualifiers");
2473 booleanIParam includeClassOrigin("IncludeClassOrigin");
2474 propertyListIParam propertyList;
2475
|
2476 kumpf 1.104 Boolean duplicateParameter = false;
2477 Boolean emptyTag;
2478
2479 for (const char* name;
2480 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2481 {
|
2482 karl 1.127.2.5 if(instanceName.get(parser, name, emptyTag))
|
2483 kumpf 1.104 {
|
2484 karl 1.127.2.5 instanceName.iParamFound(duplicateParameter);
|
2485 kumpf 1.104 }
|
2486 karl 1.127.2.5 // localOnly is accepted for compatibility reasons, but is
2487 // not honored because it is deprecated.
2488 else if(localOnly.get(parser, name, emptyTag))
|
2489 kumpf 1.104 {
|
2490 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2491 kumpf 1.104 }
|
2492 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2493 kumpf 1.104 {
|
2494 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2495 kumpf 1.104 }
|
2496 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2497 kumpf 1.104 {
|
2498 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2499 kumpf 1.104 }
|
2500 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
2501 kumpf 1.104 {
|
2502 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2503 kumpf 1.104 }
2504 else
2505 {
|
2506 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2507 kumpf 1.104 }
2508
|
2509 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2510 _checkMissingEndTagOrDuplicateParamValue(
2511 parser, duplicateParameter, emptyTag);
|
2512 kumpf 1.104 }
2513
|
2514 karl 1.127.2.5 _testRequiredParametersExist(instanceName.got);
|
2515 kumpf 1.104
2516 AutoPtr<CIMGetInstanceRequestMessage> request(
2517 new CIMGetInstanceRequestMessage(
2518 messageId,
2519 nameSpace,
|
2520 karl 1.127.2.5 instanceName.value,
|
2521 h.sterling 1.97 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
2522 kumpf 1.104 false,
|
2523 h.sterling 1.97 #else
|
2524 karl 1.127.2.5 includeQualifiers.value,
|
2525 h.sterling 1.97 #endif
|
2526 karl 1.127.2.5 includeClassOrigin.value,
2527 propertyList.value,
|
2528 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2529
2530 STAT_SERVERSTART
2531
2532 return request.release();
2533 }
2534
|
2535 karl 1.127.2.5
|
2536 kumpf 1.104 CIMModifyInstanceRequestMessage*
2537 CIMOperationRequestDecoder::decodeModifyInstanceRequest(
2538 Uint32 queueId,
2539 XmlParser& parser,
2540 const String& messageId,
2541 const CIMNamespaceName& nameSpace)
2542 {
2543 STAT_GETSTARTTIME
2544
2545 CIMInstance modifiedInstance;
2546 Boolean gotInstance = false;
|
2547 karl 1.127.2.5
2548 booleanIParam includeQualifiers("IncludeQualifiers", true);
2549 propertyListIParam propertyList;
2550
|
2551 kumpf 1.104 Boolean emptyTag;
|
2552 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2553 kumpf 1.104
2554 for (const char* name;
2555 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2556 {
2557 if (System::strcasecmp(name, "ModifiedInstance") == 0)
2558 {
2559 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2560 XmlReader::getNamedInstanceElement(parser, modifiedInstance);
2561 duplicateParameter = gotInstance;
2562 gotInstance = true;
2563 }
|
2564 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2565 kumpf 1.104 {
|
2566 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2567 kumpf 1.104 }
|
2568 karl 1.127.2.5 else if(propertyList.getSpecial(parser, name, emptyTag))
|
2569 kumpf 1.104 {
|
2570 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2571 kumpf 1.104 }
2572 else
2573 {
|
2574 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2575 kumpf 1.104 }
2576
|
2577 karl 1.127.2.5 _checkMissingEndTagOrDuplicateParamValue(
2578 parser, duplicateParameter, emptyTag);
|
2579 kumpf 1.104 }
2580
|
2581 karl 1.127.2.5 _testRequiredParametersExist(gotInstance);
|
2582 kumpf 1.104
2583 AutoPtr<CIMModifyInstanceRequestMessage> request(
2584 new CIMModifyInstanceRequestMessage(
2585 messageId,
2586 nameSpace,
2587 modifiedInstance,
|
2588 karl 1.127.2.5 includeQualifiers.value,
2589 propertyList.value,
|
2590 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2591
2592 STAT_SERVERSTART
2593
2594 return request.release();
2595 }
2596
2597 CIMEnumerateInstancesRequestMessage*
2598 CIMOperationRequestDecoder::decodeEnumerateInstancesRequest(
2599 Uint32 queueId,
2600 XmlParser& parser,
2601 const String& messageId,
2602 const CIMNamespaceName& nameSpace)
2603 {
2604 STAT_GETSTARTTIME
2605
|
2606 karl 1.127.2.5 // EnumerateInstance Parameters
2607 classNameIParam className("ClassName");
2608 booleanIParam deepInheritance("DeepInheritance", true);
2609 // localOnly is accepted for compatibility reasons, but is
2610 // not honored because it is deprecated.
2611 booleanIParam localOnly("localOnly", true);
2612 booleanIParam includeQualifiers("IncludeQualifiers");
2613 booleanIParam includeClassOrigin("IncludeClassOrigin");
2614 propertyListIParam propertyList;
2615
|
2616 kumpf 1.104 Boolean duplicateParameter = false;
2617 Boolean emptyTag;
2618
2619 for (const char* name;
2620 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2621 {
|
2622 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2623 kumpf 1.104 {
|
2624 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2625 kumpf 1.104 }
|
2626 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
2627 kumpf 1.104 {
|
2628 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
2629 kumpf 1.104 }
|
2630 karl 1.127.2.5 // This attribute is accepted for compatibility reasons, but is
2631 // not honored because it is deprecated.
2632 else if(localOnly.get(parser, name, emptyTag))
|
2633 kumpf 1.104 {
|
2634 karl 1.127.2.5 localOnly.iParamFound(duplicateParameter);
|
2635 kumpf 1.104 }
|
2636 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
2637 kumpf 1.104 {
|
2638 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
2639 kumpf 1.104 }
|
2640 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
2641 kumpf 1.104 {
|
2642 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
2643 kumpf 1.104 }
|
2644 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
2645 kumpf 1.104 {
|
2646 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
2647 kumpf 1.104 }
|
2648 karl 1.127.2.5 else
|
2649 kumpf 1.104 {
|
2650 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2651 kumpf 1.104 }
2652
|
2653 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2654 _checkMissingEndTagOrDuplicateParamValue(
2655 parser, duplicateParameter, emptyTag);
|
2656 kumpf 1.104 }
2657
|
2658 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
2659 karl 1.127.2.3
|
2660 kumpf 1.104 AutoPtr<CIMEnumerateInstancesRequestMessage> request(
2661 new CIMEnumerateInstancesRequestMessage(
2662 messageId,
2663 nameSpace,
|
2664 karl 1.127.2.5 className.value,
2665 deepInheritance.value,
|
2666 h.sterling 1.97 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
|
2667 kumpf 1.104 false,
|
2668 h.sterling 1.97 #else
|
2669 karl 1.127.2.5 includeQualifiers.value,
|
2670 h.sterling 1.97 #endif
|
2671 karl 1.127.2.5 includeClassOrigin.value,
2672 propertyList.value,
|
2673 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2674
2675 STAT_SERVERSTART
2676
2677 return request.release();
2678 }
2679
2680 CIMEnumerateInstanceNamesRequestMessage*
2681 CIMOperationRequestDecoder::decodeEnumerateInstanceNamesRequest(
2682 Uint32 queueId,
2683 XmlParser& parser,
2684 const String& messageId,
2685 const CIMNamespaceName& nameSpace)
2686 {
2687 STAT_GETSTARTTIME
2688
|
2689 karl 1.127.2.5 classNameIParam className("ClassName");
2690
|
2691 kumpf 1.104 Boolean duplicateParameter = false;
2692 Boolean emptyTag;
2693
2694 for (const char* name;
2695 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2696 {
|
2697 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
2698 kumpf 1.104 {
|
2699 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
2700 kumpf 1.104 }
2701 else
2702 {
|
2703 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2704 kumpf 1.104 }
2705
|
2706 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2707 _checkMissingEndTagOrDuplicateParamValue(
2708 parser, duplicateParameter, emptyTag);
|
2709 kumpf 1.104 }
2710
|
2711 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
2712 kumpf 1.104
2713 AutoPtr<CIMEnumerateInstanceNamesRequestMessage> request(
2714 new CIMEnumerateInstanceNamesRequestMessage(
2715 messageId,
2716 nameSpace,
|
2717 karl 1.127.2.5 className.value,
|
2718 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2719
2720 STAT_SERVERSTART
2721
2722 return request.release();
2723 }
2724
2725 CIMDeleteInstanceRequestMessage*
2726 CIMOperationRequestDecoder::decodeDeleteInstanceRequest(
2727 Uint32 queueId,
2728 XmlParser& parser,
2729 const String& messageId,
2730 const CIMNamespaceName& nameSpace)
2731 {
2732 STAT_GETSTARTTIME
2733
|
2734 karl 1.127.2.5 instanceNameIParam instanceName;
2735
|
2736 kumpf 1.104 Boolean duplicateParameter = false;
2737 Boolean emptyTag;
2738
2739 for (const char* name;
2740 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2741 {
|
2742 karl 1.127.2.5 if(instanceName.get(parser, name, emptyTag))
|
2743 kumpf 1.104 {
|
2744 karl 1.127.2.5 instanceName.iParamFound(duplicateParameter);
|
2745 kumpf 1.104 }
2746 else
2747 {
|
2748 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2749 kumpf 1.104 }
2750
|
2751 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2752 _checkMissingEndTagOrDuplicateParamValue(
2753 parser, duplicateParameter, emptyTag);
|
2754 kumpf 1.104 }
2755
|
2756 karl 1.127.2.5 _testRequiredParametersExist(instanceName.got);
|
2757 kumpf 1.104
2758 AutoPtr<CIMDeleteInstanceRequestMessage> request(
2759 new CIMDeleteInstanceRequestMessage(
2760 messageId,
2761 nameSpace,
|
2762 karl 1.127.2.5 instanceName.value,
|
2763 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
2764
2765 STAT_SERVERSTART
2766
2767 return request.release();
2768 }
2769
2770 CIMSetQualifierRequestMessage*
2771 CIMOperationRequestDecoder::decodeSetQualifierRequest(
2772 Uint32 queueId,
2773 XmlParser& parser,
2774 const String& messageId,
2775 const CIMNamespaceName& nameSpace)
2776 {
2777 STAT_GETSTARTTIME
2778
2779 CIMQualifierDecl qualifierDeclaration;
2780 Boolean duplicateParameter = false;
2781 Boolean gotQualifierDeclaration = false;
2782 Boolean emptyTag;
2783
2784 kumpf 1.104 for (const char* name;
2785 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2786 {
2787 if (System::strcasecmp(name, "QualifierDeclaration") == 0)
2788 {
2789 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2790 XmlReader::getQualifierDeclElement(parser, qualifierDeclaration);
2791 duplicateParameter = gotQualifierDeclaration;
2792 gotQualifierDeclaration = true;
2793 }
2794 else
2795 {
|
2796 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2797 kumpf 1.104 }
2798
|
2799 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2800 _checkMissingEndTagOrDuplicateParamValue(
2801 parser, duplicateParameter, emptyTag);
|
2802 kumpf 1.104 }
2803
|
2804 karl 1.127.2.5 _testRequiredParametersExist(gotQualifierDeclaration);
|
2805 kumpf 1.104
2806 AutoPtr<CIMSetQualifierRequestMessage> request(
2807 new CIMSetQualifierRequestMessage(
2808 messageId,
2809 nameSpace,
2810 qualifierDeclaration,
2811 QueueIdStack(queueId, _returnQueueId)));
2812
2813 STAT_SERVERSTART
2814
2815 return request.release();
2816 }
2817
2818 CIMGetQualifierRequestMessage*
2819 CIMOperationRequestDecoder::decodeGetQualifierRequest(
2820 Uint32 queueId,
2821 XmlParser& parser,
2822 const String& messageId,
2823 const CIMNamespaceName& nameSpace)
2824 {
2825 STAT_GETSTARTTIME
2826 kumpf 1.104
2827 String qualifierNameString;
2828 CIMName qualifierName;
2829 Boolean duplicateParameter = false;
2830 Boolean gotQualifierName = false;
2831 Boolean emptyTag;
2832
2833 for (const char* name;
2834 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2835 {
2836 if (System::strcasecmp(name, "QualifierName") == 0)
2837 {
2838 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2839 XmlReader::getStringValueElement(parser, qualifierNameString, true);
2840 qualifierName = qualifierNameString;
2841 duplicateParameter = gotQualifierName;
2842 gotQualifierName = true;
2843 }
2844 else
2845 {
|
2846 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2847 kumpf 1.104 }
2848
|
2849 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2850 _checkMissingEndTagOrDuplicateParamValue(
2851 parser, duplicateParameter, emptyTag);
|
2852 kumpf 1.104 }
2853
|
2854 karl 1.127.2.5 _testRequiredParametersExist(gotQualifierName);
|
2855 kumpf 1.104
2856 AutoPtr<CIMGetQualifierRequestMessage> request(
2857 new CIMGetQualifierRequestMessage(
2858 messageId,
2859 nameSpace,
2860 qualifierName,
2861 QueueIdStack(queueId, _returnQueueId)));
2862
2863 STAT_SERVERSTART
2864
2865 return request.release();
2866 }
2867
2868 CIMEnumerateQualifiersRequestMessage*
2869 CIMOperationRequestDecoder::decodeEnumerateQualifiersRequest(
2870 Uint32 queueId,
2871 XmlParser& parser,
2872 const String& messageId,
2873 const CIMNamespaceName& nameSpace)
2874 {
2875 STAT_GETSTARTTIME
2876 kumpf 1.104 Boolean emptyTag;
2877
2878 for (const char* name;
2879 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2880 {
2881 // No IPARAMVALUEs are defined for this operation
|
2882 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2883 kumpf 1.104 }
2884
2885 AutoPtr<CIMEnumerateQualifiersRequestMessage> request(
2886 new CIMEnumerateQualifiersRequestMessage(
2887 messageId,
2888 nameSpace,
2889 QueueIdStack(queueId, _returnQueueId)));
2890
2891 STAT_SERVERSTART
2892
2893 return request.release();
2894 }
2895
2896 CIMDeleteQualifierRequestMessage*
2897 CIMOperationRequestDecoder::decodeDeleteQualifierRequest(
2898 Uint32 queueId,
2899 XmlParser& parser,
2900 const String& messageId,
2901 const CIMNamespaceName& nameSpace)
2902 {
2903 STAT_GETSTARTTIME
2904 kumpf 1.104
2905 String qualifierNameString;
2906 CIMName qualifierName;
2907 Boolean gotQualifierName = false;
|
2908 karl 1.127.2.5
|
2909 kumpf 1.104 Boolean emptyTag;
|
2910 karl 1.127.2.5 Boolean duplicateParameter = false;
|
2911 kumpf 1.104
2912 for (const char* name;
2913 XmlReader::getIParamValueTag(parser, name, emptyTag); )
2914 {
2915 if (System::strcasecmp(name, "QualifierName") == 0)
2916 {
2917 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
2918 XmlReader::getStringValueElement(parser, qualifierNameString, true);
2919 qualifierName = qualifierNameString;
2920 duplicateParameter = gotQualifierName;
2921 gotQualifierName = true;
2922 }
2923 else
2924 {
|
2925 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2926 kumpf 1.104 }
2927
2928
|
2929 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2930 _checkMissingEndTagOrDuplicateParamValue(
2931 parser, duplicateParameter, emptyTag);
|
2932 kumpf 1.104 }
2933
|
2934 karl 1.127.2.5 _testRequiredParametersExist(gotQualifierName);
|
2935 kumpf 1.104
2936 AutoPtr<CIMDeleteQualifierRequestMessage> request(
2937 new CIMDeleteQualifierRequestMessage(
2938 messageId,
2939 nameSpace,
2940 qualifierName,
2941 QueueIdStack(queueId, _returnQueueId)));
2942
2943 STAT_SERVERSTART
2944
2945 return request.release();
2946 }
2947
2948 CIMReferenceNamesRequestMessage*
2949 CIMOperationRequestDecoder::decodeReferenceNamesRequest(
2950 Uint32 queueId,
2951 XmlParser& parser,
2952 const String& messageId,
2953 const CIMNamespaceName& nameSpace)
2954 {
2955 STAT_GETSTARTTIME
|
2956 karl 1.127.2.5 objectNameIParam objectName;
2957 classNameIParam resultClass("ResultClass");
2958 stringIParam role("role", false);
|
2959 kumpf 1.104
2960 Boolean duplicateParameter = false;
2961 Boolean emptyTag;
2962
2963 for (const char* name;
|
2964 karl 1.127.2.5 XmlReader::getIParamValueTag(parser, name, emptyTag); )
|
2965 kumpf 1.104 {
|
2966 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
2967 kumpf 1.104 {
|
2968 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
2969 kumpf 1.104 }
|
2970 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
2971 kumpf 1.104 {
|
2972 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
2973 kumpf 1.104 }
|
2974 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
2975 kumpf 1.104 {
|
2976 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
2977 kumpf 1.104 }
2978 else
2979 {
|
2980 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
2981 kumpf 1.104 }
2982
|
2983 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
2984 _checkMissingEndTagOrDuplicateParamValue(
2985 parser, duplicateParameter, emptyTag);
|
2986 kumpf 1.104 }
2987
|
2988 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
2989 kumpf 1.104
2990 AutoPtr<CIMReferenceNamesRequestMessage> request(
2991 new CIMReferenceNamesRequestMessage(
2992 messageId,
2993 nameSpace,
|
2994 karl 1.127.2.5 objectName.value,
2995 resultClass.value,
2996 role.value,
2997 QueueIdStack(queueId, _returnQueueId),
2998 objectName.isClassNameElement));
|
2999 kumpf 1.104
3000 STAT_SERVERSTART
3001
3002 return request.release();
3003 }
3004
3005 CIMReferencesRequestMessage*
3006 CIMOperationRequestDecoder::decodeReferencesRequest(
3007 Uint32 queueId,
3008 XmlParser& parser,
3009 const String& messageId,
3010 const CIMNamespaceName& nameSpace)
3011 {
3012 STAT_GETSTARTTIME
3013
|
3014 karl 1.127.2.5 objectNameIParam objectName;
3015 classNameIParam resultClass("ResultClass");
3016 stringIParam role("role", false);
3017 booleanIParam includeQualifiers("IncludeQualifiers");
3018 booleanIParam includeClassOrigin("IncludeClassOrigin");
3019 propertyListIParam propertyList;
3020
|
3021 kumpf 1.104 Boolean duplicateParameter = false;
3022 Boolean emptyTag;
3023
3024 for (const char* name;
3025 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3026 {
|
3027 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3028 kumpf 1.104 {
|
3029 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3030 kumpf 1.104 }
|
3031 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3032 kumpf 1.104 {
|
3033 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3034 kumpf 1.104 }
|
3035 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3036 kumpf 1.104 {
|
3037 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3038 kumpf 1.104 }
|
3039 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
3040 kumpf 1.104 {
|
3041 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
3042 kumpf 1.104 }
|
3043 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3044 kumpf 1.104 {
|
3045 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3046 kumpf 1.104 }
|
3047 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3048 kumpf 1.104 {
|
3049 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3050 kumpf 1.104 }
3051 else
3052 {
|
3053 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3054 kumpf 1.104 }
3055
|
3056 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3057 _checkMissingEndTagOrDuplicateParamValue(
3058 parser, duplicateParameter, emptyTag);
|
3059 kumpf 1.104 }
3060
|
3061 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3062 kumpf 1.104
3063 AutoPtr<CIMReferencesRequestMessage> request(
3064 new CIMReferencesRequestMessage(
3065 messageId,
3066 nameSpace,
|
3067 karl 1.127.2.5 objectName.value,
3068 resultClass.value,
3069 role.value,
3070 includeQualifiers.value,
3071 includeClassOrigin.value,
3072 propertyList.value,
3073 QueueIdStack(queueId, _returnQueueId),
3074 objectName.isClassNameElement));
|
3075 kumpf 1.104
3076 STAT_SERVERSTART
3077
3078 return request.release();
3079 }
3080
3081 CIMAssociatorNamesRequestMessage*
3082 CIMOperationRequestDecoder::decodeAssociatorNamesRequest(
3083 Uint32 queueId,
3084 XmlParser& parser,
3085 const String& messageId,
3086 const CIMNamespaceName& nameSpace)
3087 {
3088 STAT_GETSTARTTIME
3089
|
3090 karl 1.127.2.5 objectNameIParam objectName;
3091 classNameIParam assocClass("AssocClass");
3092 classNameIParam resultClass("ResultClass");
3093 stringIParam role("role", false);
3094 stringIParam resultRole("Resultrole", false);
3095
|
3096 kumpf 1.104 Boolean emptyTag;
|
3097 karl 1.127.2.5 Boolean duplicateParameter = false;
|
3098 kumpf 1.104
3099 for (const char* name;
3100 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3101 {
|
3102 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3103 kumpf 1.104 {
|
3104 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3105 kumpf 1.104 }
|
3106 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
3107 kumpf 1.104 {
|
3108 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
3109 kumpf 1.104 }
|
3110 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3111 kumpf 1.104 {
|
3112 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3113 kumpf 1.104 }
|
3114 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3115 kumpf 1.104 {
|
3116 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3117 kumpf 1.104 }
|
3118 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
3119 kumpf 1.104 {
|
3120 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
3121 kumpf 1.104 }
3122 else
3123 {
|
3124 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3125 kumpf 1.104
3126 }
3127
|
3128 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3129 _checkMissingEndTagOrDuplicateParamValue(
3130 parser, duplicateParameter, emptyTag);
|
3131 kumpf 1.104 }
3132
|
3133 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3134 kumpf 1.104
3135 AutoPtr<CIMAssociatorNamesRequestMessage> request(
3136 new CIMAssociatorNamesRequestMessage(
3137 messageId,
3138 nameSpace,
|
3139 karl 1.127.2.5 objectName.value,
3140 assocClass.value,
3141 resultClass.value,
3142 role.value,
3143 resultRole.value,
3144 QueueIdStack(queueId, _returnQueueId),
3145 objectName.isClassNameElement));
|
3146 kumpf 1.104
3147 STAT_SERVERSTART
3148
3149 return request.release();
3150 }
3151
3152 CIMAssociatorsRequestMessage*
3153 CIMOperationRequestDecoder::decodeAssociatorsRequest(
3154 Uint32 queueId,
3155 XmlParser& parser,
3156 const String& messageId,
3157 const CIMNamespaceName& nameSpace)
3158 {
3159 STAT_GETSTARTTIME
3160
|
3161 karl 1.127.2.5 // Associator Operation Parameters
3162 objectNameIParam objectName;
3163 classNameIParam assocClass("AssocClass");
3164 classNameIParam resultClass("ResultClass");
3165 stringIParam resultRole("Resultrole", false);
3166 stringIParam role("role", false);
3167 booleanIParam includeQualifiers("IncludeQualifiers");
3168 booleanIParam includeClassOrigin("IncludeClassOrigin");
3169 propertyListIParam propertyList;
3170
|
3171 kumpf 1.104 Boolean duplicateParameter = false;
3172 Boolean emptyTag;
3173
3174 for (const char* name;
3175 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3176 {
|
3177 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3178 kumpf 1.104 {
|
3179 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3180 kumpf 1.104 }
|
3181 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
3182 kumpf 1.104 {
|
3183 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
3184 kumpf 1.104 }
|
3185 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3186 kumpf 1.104 {
|
3187 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3188 kumpf 1.104 }
|
3189 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3190 kumpf 1.104 {
|
3191 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3192 kumpf 1.104 }
|
3193 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
3194 kumpf 1.104 {
|
3195 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
3196 kumpf 1.104 }
|
3197 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
3198 kumpf 1.104 {
|
3199 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
3200 kumpf 1.104 }
|
3201 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3202 kumpf 1.104 {
|
3203 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3204 kumpf 1.104 }
|
3205 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3206 kumpf 1.104 {
|
3207 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3208 kumpf 1.104 }
3209 else
3210 {
|
3211 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3212 kumpf 1.104 }
3213
|
3214 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3215 _checkMissingEndTagOrDuplicateParamValue(
3216 parser, duplicateParameter, emptyTag);
|
3217 kumpf 1.104 }
3218
|
3219 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3220 kumpf 1.104
3221 AutoPtr<CIMAssociatorsRequestMessage> request(
3222 new CIMAssociatorsRequestMessage(
3223 messageId,
3224 nameSpace,
|
3225 karl 1.127.2.5 objectName.value,
3226 assocClass.value,
3227 resultClass.value,
3228 role.value,
3229 resultRole.value,
3230 includeQualifiers.value,
3231 includeClassOrigin.value,
3232 propertyList.value,
3233 QueueIdStack(queueId, _returnQueueId),
3234 objectName.isClassNameElement));
|
3235 kumpf 1.104
3236 STAT_SERVERSTART
3237
3238 return request.release();
3239 }
3240
3241 CIMGetPropertyRequestMessage*
3242 CIMOperationRequestDecoder::decodeGetPropertyRequest(
3243 Uint32 queueId,
3244 XmlParser& parser,
3245 const String& messageId,
3246 const CIMNamespaceName& nameSpace)
3247 {
3248 STAT_GETSTARTTIME
3249
3250 CIMObjectPath instanceName;
3251 String propertyName;
3252 Boolean duplicateParameter = false;
3253 Boolean gotInstanceName = false;
3254 Boolean gotPropertyName = false;
3255 Boolean emptyTag;
3256 kumpf 1.104
3257 for (const char* name;
3258 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3259 {
3260 if (System::strcasecmp(name, "InstanceName") == 0)
3261 {
3262 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3263 XmlReader::getInstanceNameElement(parser, instanceName);
3264 duplicateParameter = gotInstanceName;
3265 gotInstanceName = true;
3266 }
3267 else if (System::strcasecmp(name, "PropertyName") == 0)
3268 {
3269 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3270 XmlReader::getStringValueElement(parser, propertyName, true);
3271 duplicateParameter = gotPropertyName;
3272 gotPropertyName = true;
3273 }
3274 else
3275 {
|
3276 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3277 kumpf 1.104 }
3278
|
3279 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3280 _checkMissingEndTagOrDuplicateParamValue(
3281 parser, duplicateParameter, emptyTag);
|
3282 kumpf 1.104 }
3283
|
3284 karl 1.127.2.5 _testRequiredParametersExist(gotInstanceName && gotPropertyName);
|
3285 kumpf 1.104
3286 AutoPtr<CIMGetPropertyRequestMessage> request(
3287 new CIMGetPropertyRequestMessage(
3288 messageId,
3289 nameSpace,
3290 instanceName,
3291 propertyName,
3292 QueueIdStack(queueId, _returnQueueId)));
3293
3294 STAT_SERVERSTART
3295
3296 return request.release();
3297 }
3298
3299 CIMSetPropertyRequestMessage*
3300 CIMOperationRequestDecoder::decodeSetPropertyRequest(
3301 Uint32 queueId,
3302 XmlParser& parser,
3303 const String& messageId,
3304 const CIMNamespaceName& nameSpace)
3305 {
3306 kumpf 1.104 STAT_GETSTARTTIME
3307
3308 CIMObjectPath instanceName;
3309 String propertyName;
3310 CIMValue propertyValue;
3311 Boolean duplicateParameter = false;
3312 Boolean gotInstanceName = false;
3313 Boolean gotPropertyName = false;
3314 Boolean gotNewValue = false;
3315 Boolean emptyTag;
3316
3317 for (const char* name;
3318 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3319 {
3320 if (System::strcasecmp(name, "InstanceName") == 0)
3321 {
3322 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3323 XmlReader::getInstanceNameElement(parser, instanceName);
3324 duplicateParameter = gotInstanceName;
3325 gotInstanceName = true;
3326 }
3327 kumpf 1.104 else if (System::strcasecmp(name, "PropertyName") == 0)
3328 {
3329 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
3330 XmlReader::getStringValueElement(parser, propertyName, true);
3331 duplicateParameter = gotPropertyName;
3332 gotPropertyName = true;
3333 }
3334 else if (System::strcasecmp(name, "NewValue") == 0)
3335 {
3336 if (emptyTag || !XmlReader::getPropertyValue(parser, propertyValue))
3337 {
3338 propertyValue.setNullValue(CIMTYPE_STRING, false);
3339 }
3340 duplicateParameter = gotNewValue;
3341 gotNewValue = true;
3342 }
3343 else
3344 {
|
3345 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3346 kumpf 1.104 }
3347
|
3348 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3349 _checkMissingEndTagOrDuplicateParamValue(
3350 parser, duplicateParameter, emptyTag);
|
3351 kumpf 1.104 }
3352
|
3353 karl 1.127.2.5 _testRequiredParametersExist(gotInstanceName && gotPropertyName);
|
3354 kumpf 1.104
3355 AutoPtr<CIMSetPropertyRequestMessage> request(
3356 new CIMSetPropertyRequestMessage(
3357 messageId,
3358 nameSpace,
3359 instanceName,
3360 propertyName,
3361 propertyValue,
3362 QueueIdStack(queueId, _returnQueueId)));
|
3363 kumpf 1.29
|
3364 kumpf 1.104 STAT_SERVERSTART
|
3365 sage 1.41
|
3366 kumpf 1.104 return request.release();
|
3367 kumpf 1.29 }
3368
3369 CIMExecQueryRequestMessage* CIMOperationRequestDecoder::decodeExecQueryRequest(
|
3370 kumpf 1.104 Uint32 queueId,
3371 XmlParser& parser,
3372 const String& messageId,
3373 const CIMNamespaceName& nameSpace)
3374 {
3375 STAT_GETSTARTTIME
3376
|
3377 karl 1.127.2.5 // define execQuery parameters. Values are required parameters exist.
3378 stringIParam queryLanguage("QueryLanguage", true);
3379 stringIParam query("Query", true);
3380
|
3381 kumpf 1.104 Boolean emptyTag;
|
3382 karl 1.127.2.5 Boolean duplicateParameter = false;
|
3383 kumpf 1.104
3384 for (const char* name;
3385 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3386 {
|
3387 karl 1.127.2.5 if(queryLanguage.get(parser, name, emptyTag))
|
3388 kumpf 1.104 {
|
3389 karl 1.127.2.5 queryLanguage.iParamFound(duplicateParameter);
|
3390 kumpf 1.104 }
|
3391 karl 1.127.2.5 else if(query.get(parser, name, emptyTag))
|
3392 kumpf 1.104 {
|
3393 karl 1.127.2.5 query.iParamFound(duplicateParameter);
|
3394 kumpf 1.104 }
3395 else
3396 {
|
3397 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3398 kumpf 1.104 }
3399
|
3400 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3401 _checkMissingEndTagOrDuplicateParamValue(parser,
3402 duplicateParameter, emptyTag);
|
3403 kumpf 1.104 }
3404
|
3405 karl 1.127.2.5 _testRequiredParametersExist(queryLanguage.got && query.got);
|
3406 kumpf 1.104
3407 AutoPtr<CIMExecQueryRequestMessage> request(
3408 new CIMExecQueryRequestMessage(
3409 messageId,
3410 nameSpace,
|
3411 karl 1.127.2.5 queryLanguage.value,
3412 query.value,
|
3413 kumpf 1.104 QueueIdStack(queueId, _returnQueueId)));
3414
3415 STAT_SERVERSTART
3416
3417 return request.release();
3418 }
3419
3420 CIMInvokeMethodRequestMessage*
3421 CIMOperationRequestDecoder::decodeInvokeMethodRequest(
3422 Uint32 queueId,
3423 XmlParser& parser,
3424 const String& messageId,
3425 const CIMObjectPath& reference,
3426 const String& cimMethodName)
3427 {
3428 STAT_GETSTARTTIME
3429
3430 CIMParamValue paramValue;
3431 Array<CIMParamValue> inParameters;
3432
3433 while (XmlReader::getParamValueElement(parser, paramValue))
3434 kumpf 1.104 {
3435 inParameters.append(paramValue);
3436 }
3437
3438 AutoPtr<CIMInvokeMethodRequestMessage> request(
3439 new CIMInvokeMethodRequestMessage(
3440 messageId,
3441 reference.getNameSpace(),
3442 reference,
3443 cimMethodName,
3444 inParameters,
3445 QueueIdStack(queueId, _returnQueueId)));
|
3446 kumpf 1.9
|
3447 kumpf 1.104 STAT_SERVERSTART
|
3448 mike 1.2
|
3449 kumpf 1.104 return request.release();
|
3450 mike 1.2 }
3451
|
3452 karl 1.127.2.1 // EXP_PULL_BEGIN
3453 CIMOpenEnumerateInstancesRequestMessage*
3454 CIMOperationRequestDecoder::decodeOpenEnumerateInstancesRequest(
3455 Uint32 queueId,
3456 XmlParser& parser,
3457 const String& messageId,
3458 const CIMNamespaceName& nameSpace)
3459 {
3460 STAT_GETSTARTTIME
3461
|
3462 karl 1.127.2.5 // EnumerateInstance Parameters
3463 classNameIParam className("ClassName");
3464 booleanIParam deepInheritance("DeepInheritance", true);
3465 booleanIParam includeQualifiers("IncludeQualifiers");
3466 booleanIParam includeClassOrigin("IncludeClassOrigin");
3467 propertyListIParam propertyList;
3468 //// TODO confirm the false here
3469 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3470 stringIParam filterQuery("FilterQuery", false);
3471 booleanIParam continueOnError("ContinueOnError");
3472 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3473 uint32IParam maxObjectCount("MaxObjectCount", 0);
3474 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3475 uint32ArgIParam operationTimeout("OperationTimeout");
|
3476 karl 1.127.2.1
3477 Boolean duplicateParameter = false;
3478
3479 Boolean emptyTag;
3480
3481 for (const char* name;
3482 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3483 {
|
3484 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
3485 karl 1.127.2.1 {
|
3486 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
3487 karl 1.127.2.1 }
|
3488 karl 1.127.2.5 else if(deepInheritance.get(parser, name, emptyTag))
|
3489 karl 1.127.2.1 {
|
3490 karl 1.127.2.5 deepInheritance.iParamFound(duplicateParameter);
|
3491 karl 1.127.2.1 }
|
3492 karl 1.127.2.5 else if(includeQualifiers.get(parser, name, emptyTag))
|
3493 karl 1.127.2.1 {
|
3494 karl 1.127.2.5 includeQualifiers.iParamFound(duplicateParameter);
|
3495 karl 1.127.2.1 }
|
3496 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3497 karl 1.127.2.1 {
|
3498 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3499 karl 1.127.2.1 }
|
3500 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQueryLanguage = NULL,
3501 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3502 karl 1.127.2.1 {
|
3503 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3504 karl 1.127.2.1 }
|
3505 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQuery = NULL,
3506 else if(filterQuery.get(parser, name, emptyTag))
|
3507 karl 1.127.2.1 {
|
3508 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3509 karl 1.127.2.1 }
|
3510 karl 1.127.2.5 // [IN,OPTIONAL] Boolean ContinueOnError = false,
3511 else if (continueOnError.get(parser, name, emptyTag))
|
3512 karl 1.127.2.1 {
|
3513 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
3514 }
3515 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3516 else if (operationTimeout.get(parser, name, emptyTag))
3517 {
3518 operationTimeout.iParamFound(duplicateParameter);
|
3519 karl 1.127.2.1 }
3520 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
|
3521 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
3522 karl 1.127.2.1 {
|
3523 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3524 karl 1.127.2.1 }
|
3525 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3526 karl 1.127.2.1 {
|
3527 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3528 karl 1.127.2.1 }
3529 else
3530 {
|
3531 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName(name);
|
3532 karl 1.127.2.1 }
3533
|
3534 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3535 _checkMissingEndTagOrDuplicateParamValue(
3536 parser, duplicateParameter, emptyTag);
|
3537 karl 1.127.2.1
3538 }
3539
|
3540 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
3541 karl 1.127.2.1
3542 AutoPtr<CIMOpenEnumerateInstancesRequestMessage> request(
3543 new CIMOpenEnumerateInstancesRequestMessage(
3544 messageId,
3545 nameSpace,
|
3546 karl 1.127.2.5 className.value,
3547 deepInheritance.value,
3548 includeClassOrigin.value,
3549 propertyList.value,
3550 filterQueryLanguage.value,
3551 filterQuery.value,
3552 operationTimeout.value,
3553 continueOnError.value,
3554 maxObjectCount.value,
|
3555 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3556
3557 STAT_SERVERSTART
3558
3559 return request.release();
3560 }
3561
3562
3563 CIMOpenEnumerateInstancePathsRequestMessage*
3564 CIMOperationRequestDecoder::decodeOpenEnumerateInstancePathsRequest(
3565 Uint32 queueId,
3566 XmlParser& parser,
3567 const String& messageId,
3568 const CIMNamespaceName& nameSpace)
3569 {
3570 STAT_GETSTARTTIME
3571
|
3572 karl 1.127.2.5 // EnumerateInstance Parameters
3573 classNameIParam className("ClassName");
3574 //// TODO confirm the false here
3575 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3576 stringIParam filterQuery("FilterQuery", false);
3577 booleanIParam continueOnError("ContinueOnError");
3578 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3579 uint32IParam maxObjectCount("MaxObjectCount", 0);
3580 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3581 uint32ArgIParam operationTimeout("OperationTimeout");
|
3582 karl 1.127.2.1
3583 Boolean duplicateParameter = false;
3584 Boolean emptyTag;
3585
3586 for (const char* name;
3587 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3588 {
|
3589 karl 1.127.2.5 if(className.get(parser, name, emptyTag))
|
3590 karl 1.127.2.1 {
|
3591 karl 1.127.2.5 className.iParamFound(duplicateParameter);
|
3592 karl 1.127.2.1 }
|
3593 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQueryLanguage = NULL,
3594 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3595 karl 1.127.2.1 {
|
3596 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3597 karl 1.127.2.1 }
|
3598 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQuery = NULL,
3599 else if(filterQuery.get(parser, name, emptyTag))
|
3600 karl 1.127.2.1 {
|
3601 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3602 karl 1.127.2.1 }
3603 // [IN,OPTIONAL] Boolean ContinueOnError = false,
|
3604 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
3605 karl 1.127.2.1 {
|
3606 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3607 karl 1.127.2.1 }
|
3608 karl 1.127.2.5 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3609 else if (operationTimeout.get(parser, name, emptyTag))
|
3610 karl 1.127.2.1 {
|
3611 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3612 karl 1.127.2.1 }
|
3613 karl 1.127.2.5 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3614 else if (maxObjectCount.get(parser, name, emptyTag))
|
3615 karl 1.127.2.1 {
|
3616 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3617 karl 1.127.2.1 }
|
3618 karl 1.127.2.5 else
|
3619 karl 1.127.2.1 {
|
3620 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName(name);
|
3621 karl 1.127.2.1 }
3622
|
3623 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3624 _checkMissingEndTagOrDuplicateParamValue(
3625 parser, duplicateParameter, emptyTag);
|
3626 karl 1.127.2.1
3627 }
3628
|
3629 karl 1.127.2.5 _testRequiredParametersExist(className.got);
|
3630 karl 1.127.2.1
3631 AutoPtr<CIMOpenEnumerateInstancePathsRequestMessage> request(
3632 new CIMOpenEnumerateInstancePathsRequestMessage(
3633 messageId,
3634 nameSpace,
|
3635 karl 1.127.2.5 className.value,
3636 filterQueryLanguage.value,
3637 filterQuery.value,
3638 operationTimeout.value,
3639 continueOnError.value,
3640 maxObjectCount.value,
|
3641 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3642
3643 STAT_SERVERSTART
3644
3645 return request.release();
3646 }
3647
3648 CIMOpenReferenceInstancesRequestMessage*
3649 CIMOperationRequestDecoder::decodeOpenReferenceInstancesRequest(
3650 Uint32 queueId,
3651 XmlParser& parser,
3652 const String& messageId,
3653 const CIMNamespaceName& nameSpace)
3654 {
3655 STAT_GETSTARTTIME
3656
|
3657 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3658 classNameIParam resultClass("ResultClass");
3659 stringIParam role("role", false);
3660 booleanIParam includeClassOrigin("IncludeClassOrigin");
3661 propertyListIParam propertyList;
3662
3663 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3664 stringIParam filterQuery("FilterQuery", false);
3665 booleanIParam continueOnError("ContinueOnError");
3666 uint32IParam maxObjectCount("MaxObjectCount", 0);
3667 uint32ArgIParam operationTimeout("OperationTimeout");
3668 // KS_TODO REMOVE FOLLOWING
3669 // CIMObjectPath objectName;
3670 // CIMName resultClass;
3671 // String role;
3672 // Boolean includeClassOrigin = false;
3673 // CIMPropertyList propertyList;
3674 // String filterQueryLanguage = String::EMPTY;
3675 // String filterQuery = String::EMPTY;
3676 // Uint32Arg operationTimeout = 0;
3677 // Boolean continueOnError = false;
3678 karl 1.127.2.5 // Uint32 maxObjectCount = 0;
3679 // String enumerationContext = String::EMPTY;
3680 //
3681 // Boolean gotObjectName = false;
3682 // Boolean gotIncludeClassOrigin = false;
3683 // Boolean gotResultClass = false;
3684 // Boolean gotRole = false;
3685 // Boolean gotPropertyList = false;
3686 // Boolean gotFilterQueryLanguage = false;
3687 // Boolean gotFilterQuery = false;
3688 // Boolean gotOperationTimeout = false;
3689 // Boolean gotContinueOnError = false;
3690 // Boolean gotMaxObjectCount = false;
|
3691 karl 1.127.2.1
3692 Boolean duplicateParameter = false;
3693 Boolean emptyTag;
3694
|
3695 karl 1.127.2.5
|
3696 karl 1.127.2.1 for (const char* name;
3697 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3698 {
|
3699 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3700 karl 1.127.2.1 {
|
3701 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3702 karl 1.127.2.1 }
|
3703 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3704 karl 1.127.2.1 {
|
3705 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3706 karl 1.127.2.1 }
|
3707 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3708 karl 1.127.2.1 {
|
3709 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3710 karl 1.127.2.1 }
|
3711 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3712 karl 1.127.2.1 {
|
3713 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3714 karl 1.127.2.1 }
|
3715 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3716 karl 1.127.2.1 {
|
3717 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3718 karl 1.127.2.1 }
|
3719 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQueryLanguage = NULL,
3720 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3721 karl 1.127.2.1 {
|
3722 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3723 karl 1.127.2.1 }
|
3724 karl 1.127.2.5 // [IN,OPTIONAL,NULL] string FilterQuery = NULL,
3725 else if(filterQuery.get(parser, name, emptyTag))
|
3726 karl 1.127.2.1 {
|
3727 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3728 karl 1.127.2.1 }
|
3729 karl 1.127.2.5 // [IN,OPTIONAL] Boolean ContinueOnError = false,
3730 else if (continueOnError.get(parser, name, emptyTag))
|
3731 karl 1.127.2.1 {
|
3732 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3733 karl 1.127.2.1 }
|
3734 karl 1.127.2.5 // [IN,OPTIONAL,NULL] uint32 OperationTimeout = NULL,
3735 else if (operationTimeout.get(parser, name, emptyTag))
|
3736 karl 1.127.2.1 {
|
3737 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3738 karl 1.127.2.1 }
|
3739 karl 1.127.2.5 // [IN,OPTIONAL] uint32 MaxObjectCount = 0
3740 else if (maxObjectCount.get(parser, name, emptyTag))
|
3741 karl 1.127.2.1 {
|
3742 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3743 karl 1.127.2.1 }
3744 else
3745 {
|
3746 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3747 karl 1.127.2.1 }
3748
|
3749 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3750 _checkMissingEndTagOrDuplicateParamValue(
3751 parser, duplicateParameter, emptyTag);
|
3752 karl 1.127.2.1 }
3753
|
3754 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3755 karl 1.127.2.1
3756 AutoPtr<CIMOpenReferenceInstancesRequestMessage> request(
3757 new CIMOpenReferenceInstancesRequestMessage(
3758 messageId,
3759 nameSpace,
|
3760 karl 1.127.2.5 objectName.value,
3761 resultClass.value,
3762 role.value,
3763 includeClassOrigin.value,
3764 propertyList.value,
3765 filterQueryLanguage.value,
3766 filterQuery.value,
3767 operationTimeout.value,
3768 continueOnError.value,
3769 maxObjectCount.value,
|
3770 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3771
3772 STAT_SERVERSTART
3773
3774 return request.release();
3775 }
3776
3777
3778 CIMOpenReferenceInstancePathsRequestMessage*
3779 CIMOperationRequestDecoder::decodeOpenReferenceInstancePathsRequest(
3780 Uint32 queueId,
3781 XmlParser& parser,
3782 const String& messageId,
3783 const CIMNamespaceName& nameSpace)
3784 {
3785 STAT_GETSTARTTIME
3786
|
3787 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3788 classNameIParam resultClass("ResultClass");
3789 stringIParam role("role", false);
3790
3791 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3792 stringIParam filterQuery("FilterQuery", false);
3793 booleanIParam continueOnError("ContinueOnError");
3794 uint32IParam maxObjectCount("MaxObjectCount", 0);
3795 uint32ArgIParam operationTimeout("OperationTimeout");
|
3796 karl 1.127.2.1
3797 Boolean duplicateParameter = false;
3798 Boolean emptyTag;
3799
3800 for (const char* name;
3801 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3802 {
|
3803 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3804 karl 1.127.2.1 {
|
3805 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3806 karl 1.127.2.1 }
|
3807 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3808 karl 1.127.2.1 {
|
3809 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3810 karl 1.127.2.1 }
|
3811 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3812 karl 1.127.2.1 {
|
3813 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3814 karl 1.127.2.1 }
|
3815 karl 1.127.2.5 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3816 karl 1.127.2.1 {
|
3817 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3818 karl 1.127.2.1 }
|
3819 karl 1.127.2.5 else if(filterQuery.get(parser, name, emptyTag))
|
3820 karl 1.127.2.1 {
|
3821 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3822 karl 1.127.2.1 }
|
3823 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
3824 karl 1.127.2.1 {
|
3825 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3826 karl 1.127.2.1 }
|
3827 karl 1.127.2.5 else if (operationTimeout.get(parser, name, emptyTag))
|
3828 karl 1.127.2.1 {
|
3829 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3830 karl 1.127.2.1 }
|
3831 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
3832 karl 1.127.2.1 {
|
3833 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3834 karl 1.127.2.1 }
3835 else
3836 {
|
3837 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3838 karl 1.127.2.1 }
3839
|
3840 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3841 _checkMissingEndTagOrDuplicateParamValue(
3842 parser, duplicateParameter, emptyTag);
|
3843 karl 1.127.2.1 }
3844
|
3845 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3846 karl 1.127.2.1
3847 AutoPtr<CIMOpenReferenceInstancePathsRequestMessage> request(
3848 new CIMOpenReferenceInstancePathsRequestMessage(
3849 messageId,
3850 nameSpace,
|
3851 karl 1.127.2.5 objectName.value,
3852 resultClass.value,
3853 role.value,
3854 filterQueryLanguage.value,
3855 filterQuery.value,
3856 operationTimeout.value,
3857 continueOnError.value,
3858 maxObjectCount.value,
|
3859 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3860
3861 STAT_SERVERSTART
3862
3863 return request.release();
3864 }
3865
3866 CIMOpenAssociatorInstancesRequestMessage*
3867 CIMOperationRequestDecoder::decodeOpenAssociatorInstancesRequest(
3868 Uint32 queueId,
3869 XmlParser& parser,
3870 const String& messageId,
3871 const CIMNamespaceName& nameSpace)
3872 {
3873 STAT_GETSTARTTIME
3874
|
3875 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3876 classNameIParam assocClass("AssocClass");
3877 classNameIParam resultClass("ResultClass");
3878 stringIParam resultRole("Resultrole", false);
3879 stringIParam role("role", false);
3880 booleanIParam includeClassOrigin("IncludeClassOrigin");
3881 propertyListIParam propertyList;
3882
3883 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3884 stringIParam filterQuery("FilterQuery", false);
3885 booleanIParam continueOnError("ContinueOnError");
3886 uint32IParam maxObjectCount("MaxObjectCount", 0);
3887 uint32ArgIParam operationTimeout("OperationTimeout");
|
3888 karl 1.127.2.1
3889 Boolean duplicateParameter = false;
3890 Boolean emptyTag;
3891
3892 for (const char* name;
3893 XmlReader::getIParamValueTag(parser, name, emptyTag); )
3894 {
|
3895 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
3896 karl 1.127.2.1 {
|
3897 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
3898 karl 1.127.2.1 }
|
3899 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
3900 karl 1.127.2.1 {
|
3901 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
3902 karl 1.127.2.1 }
|
3903 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
3904 karl 1.127.2.1 {
|
3905 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
3906 karl 1.127.2.1 }
|
3907 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
3908 karl 1.127.2.1 {
|
3909 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
3910 karl 1.127.2.1 }
|
3911 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
3912 karl 1.127.2.1 {
|
3913 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
3914 karl 1.127.2.1 }
|
3915 karl 1.127.2.5 else if(includeClassOrigin.get(parser, name, emptyTag))
|
3916 karl 1.127.2.1 {
|
3917 karl 1.127.2.5 includeClassOrigin.iParamFound(duplicateParameter);
|
3918 karl 1.127.2.1 }
|
3919 karl 1.127.2.5 else if(propertyList.get(parser, name, emptyTag))
|
3920 karl 1.127.2.1 {
|
3921 karl 1.127.2.5 propertyList.iParamFound(duplicateParameter);
|
3922 karl 1.127.2.1 }
|
3923 karl 1.127.2.5 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
3924 karl 1.127.2.1 {
|
3925 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
3926 karl 1.127.2.1 }
|
3927 karl 1.127.2.5 else if(filterQuery.get(parser, name, emptyTag))
|
3928 karl 1.127.2.1 {
|
3929 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
3930 karl 1.127.2.1 }
|
3931 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
3932 karl 1.127.2.1 {
|
3933 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
3934 karl 1.127.2.1 }
|
3935 karl 1.127.2.5 else if (operationTimeout.get(parser, name, emptyTag))
|
3936 karl 1.127.2.1 {
|
3937 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
3938 karl 1.127.2.1 }
|
3939 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
3940 karl 1.127.2.1 {
|
3941 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
3942 karl 1.127.2.1 }
3943 else
3944 {
|
3945 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
3946 karl 1.127.2.1 }
3947
|
3948 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
3949 _checkMissingEndTagOrDuplicateParamValue(
3950 parser, duplicateParameter, emptyTag);
|
3951 karl 1.127.2.1 }
3952
|
3953 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
3954 karl 1.127.2.1
3955 AutoPtr<CIMOpenAssociatorInstancesRequestMessage> request(
3956 new CIMOpenAssociatorInstancesRequestMessage(
3957 messageId,
3958 nameSpace,
|
3959 karl 1.127.2.5 objectName.value,
3960 assocClass.value,
3961 resultClass.value,
3962 role.value,
3963 resultRole.value,
3964 includeClassOrigin.value,
3965 propertyList.value,
3966 filterQueryLanguage.value,
3967 filterQuery.value,
3968 operationTimeout.value,
3969 continueOnError.value,
3970 maxObjectCount.value,
|
3971 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
3972
3973 STAT_SERVERSTART
3974
3975 return request.release();
3976 }
3977
3978 CIMOpenAssociatorInstancePathsRequestMessage*
3979 CIMOperationRequestDecoder::decodeOpenAssociatorInstancePathsRequest(
3980 Uint32 queueId,
3981 XmlParser& parser,
3982 const String& messageId,
3983 const CIMNamespaceName& nameSpace)
3984 {
3985 STAT_GETSTARTTIME
3986
|
3987 karl 1.127.2.5 objectNameIParam objectName("InstanceName");
3988 classNameIParam assocClass("AssocClass");
3989 classNameIParam resultClass("ResultClass");
3990 stringIParam resultRole("Resultrole", false);
3991 stringIParam role("role", false);
3992
3993 stringIParam filterQueryLanguage("FilterQueryLanguage",false);
3994 stringIParam filterQuery("FilterQuery", false);
3995 booleanIParam continueOnError("ContinueOnError");
3996 uint32IParam maxObjectCount("MaxObjectCount", 0);
3997 uint32ArgIParam operationTimeout("OperationTimeout");
|
3998 karl 1.127.2.1
3999 Boolean duplicateParameter = false;
4000 Boolean emptyTag;
4001
4002 for (const char* name;
4003 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4004 {
|
4005 karl 1.127.2.5 if(objectName.get(parser, name, emptyTag))
|
4006 karl 1.127.2.1 {
|
4007 karl 1.127.2.5 objectName.iParamFound(duplicateParameter);
|
4008 karl 1.127.2.1 }
|
4009 karl 1.127.2.5 else if (assocClass.getOptional(parser, name, emptyTag))
|
4010 karl 1.127.2.1 {
|
4011 karl 1.127.2.5 assocClass.iParamFound(duplicateParameter);
|
4012 karl 1.127.2.1 }
|
4013 karl 1.127.2.5 else if (resultClass.getOptional(parser, name, emptyTag))
|
4014 karl 1.127.2.1 {
|
4015 karl 1.127.2.5 resultClass.iParamFound(duplicateParameter);
|
4016 karl 1.127.2.1 }
|
4017 karl 1.127.2.5 else if(role.get(parser, name, emptyTag))
|
4018 karl 1.127.2.1 {
|
4019 karl 1.127.2.5 role.iParamFound(duplicateParameter);
|
4020 karl 1.127.2.1 }
|
4021 karl 1.127.2.5 else if(resultRole.get(parser, name, emptyTag))
|
4022 karl 1.127.2.1 {
|
4023 karl 1.127.2.5 resultRole.iParamFound(duplicateParameter);
|
4024 karl 1.127.2.1 }
|
4025 karl 1.127.2.5 else if(filterQueryLanguage.get(parser, name, emptyTag))
|
4026 karl 1.127.2.1 {
|
4027 karl 1.127.2.5 filterQueryLanguage.iParamFound(duplicateParameter);
|
4028 karl 1.127.2.1 }
|
4029 karl 1.127.2.5 else if(filterQuery.get(parser, name, emptyTag))
|
4030 karl 1.127.2.1 {
|
4031 karl 1.127.2.5 filterQuery.iParamFound(duplicateParameter);
|
4032 karl 1.127.2.1 }
|
4033 karl 1.127.2.5 else if (continueOnError.get(parser, name, emptyTag))
|
4034 karl 1.127.2.1 {
|
4035 karl 1.127.2.5 continueOnError.iParamFound(duplicateParameter);
|
4036 karl 1.127.2.1 }
|
4037 karl 1.127.2.5 else if (operationTimeout.get(parser, name, emptyTag))
|
4038 karl 1.127.2.1 {
|
4039 karl 1.127.2.5 operationTimeout.iParamFound(duplicateParameter);
|
4040 karl 1.127.2.1 }
|
4041 karl 1.127.2.5 else if (maxObjectCount.get(parser, name, emptyTag))
|
4042 karl 1.127.2.1 {
|
4043 karl 1.127.2.5 maxObjectCount.iParamFound(duplicateParameter);
|
4044 karl 1.127.2.1 }
4045 else
4046 {
|
4047 karl 1.127.2.5 _throwCIMExceptionInvalidIParamName();
|
4048 karl 1.127.2.1 }
4049
|
4050 karl 1.127.2.5 // generate exception if endtag error or duplicate attributes
4051 _checkMissingEndTagOrDuplicateParamValue(
4052 parser, duplicateParameter, emptyTag);
|
4053 karl 1.127.2.1 }
4054
|
4055 karl 1.127.2.5 _testRequiredParametersExist(objectName.got);
|
4056 karl 1.127.2.1
4057 AutoPtr<CIMOpenAssociatorInstancePathsRequestMessage> request(
4058 new CIMOpenAssociatorInstancePathsRequestMessage(
4059 messageId,
4060 nameSpace,
|
4061 karl 1.127.2.5 objectName.value,
4062 assocClass.value,
4063 resultClass.value,
4064 role.value,
4065 resultRole.value,
4066 filterQueryLanguage.value,
4067 filterQuery.value,
4068 operationTimeout.value,
4069 continueOnError.value,
4070 maxObjectCount.value,
|
4071 karl 1.127.2.1 QueueIdStack(queueId, _returnQueueId)));
4072
4073 STAT_SERVERSTART
4074
4075 return request.release();
4076 }
4077
4078 CIMPullInstancesWithPathRequestMessage*
4079 CIMOperationRequestDecoder::decodePullInstancesWithPathRequest(
4080 Uint32 queueId,
4081 XmlParser& parser,
4082 const String& messageId,
4083 const CIMNamespaceName& nameSpace)
4084 {
4085 STAT_GETSTARTTIME
4086
4087 String enumerationContext = String::EMPTY;
|
4088 karl 1.127.2.5 Uint32 maxObjectCount = 0;
|
4089 karl 1.127.2.1
4090 Boolean duplicateParameter = false;
4091 Boolean gotEnumerationContext = false;
4092 Boolean gotMaxObjectCount = false;
4093
4094 Boolean emptyTag;
4095
4096 for (const char* name;
4097 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4098 {
4099 if (System::strcasecmp(name, "EnumerationContext") == 0)
4100 {
4101 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4102 XmlReader::getStringValueElement(parser, enumerationContext, true);
4103 duplicateParameter = gotEnumerationContext;
4104 gotEnumerationContext = true;
4105 }
4106
4107 else if (System::strcasecmp(name, "MaxObjectCount") == 0)
4108 {
4109 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4110 karl 1.127.2.1 XmlReader::getUint32ValueElement(parser, maxObjectCount, true);
4111 duplicateParameter = gotMaxObjectCount;
4112 gotMaxObjectCount = true;
4113 }
4114 else
4115 {
4116 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
4117 }
4118
4119 if (!emptyTag)
4120 {
4121 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4122 }
4123
4124 if (duplicateParameter)
4125 {
4126
4127 throw PEGASUS_CIM_EXCEPTION(
4128 CIM_ERR_INVALID_PARAMETER, "Duplicate IPARAM received");
4129 }
4130 }
4131 karl 1.127.2.1
4132 if (!gotEnumerationContext)
4133 {
4134 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4135 "EnumerationContext IPARAM required");
4136 }
4137
4138 if (!gotMaxObjectCount)
4139 {
4140 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4141 "MaxObjectCount IPARAM required");
4142 }
4143
4144 AutoPtr<CIMPullInstancesWithPathRequestMessage> request(
4145 new CIMPullInstancesWithPathRequestMessage(
4146 messageId,
4147 nameSpace,
4148 enumerationContext,
4149 maxObjectCount,
4150 QueueIdStack(queueId, _returnQueueId)));
4151
4152 karl 1.127.2.1 STAT_SERVERSTART
4153
4154 return request.release();
4155 }
4156
4157 CIMPullInstancePathsRequestMessage*
4158 CIMOperationRequestDecoder::decodePullInstancePathsRequest(
4159 Uint32 queueId,
4160 XmlParser& parser,
4161 const String& messageId,
4162 const CIMNamespaceName& nameSpace)
4163 {
4164 STAT_GETSTARTTIME
4165
4166 String enumerationContext = String::EMPTY;
|
4167 karl 1.127.2.5 Uint32 maxObjectCount = 0;
|
4168 karl 1.127.2.1
4169 Boolean duplicateParameter = false;
4170 Boolean gotEnumerationContext = false;
4171 Boolean gotMaxObjectCount = false;
4172
4173 Boolean emptyTag;
4174
4175 for (const char* name;
4176 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4177 {
4178 if (System::strcasecmp(name, "EnumerationContext") == 0)
4179 {
4180 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4181 XmlReader::getStringValueElement(parser, enumerationContext, true);
4182 duplicateParameter = gotEnumerationContext;
4183 gotEnumerationContext = true;
4184 }
4185
4186 else if (System::strcasecmp(name, "MaxObjectCount") == 0)
4187 {
4188 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4189 karl 1.127.2.1 XmlReader::getUint32ValueElement(parser, maxObjectCount, true);
4190 duplicateParameter = gotMaxObjectCount;
4191 gotMaxObjectCount = true;
4192 }
4193 else
4194 {
4195 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
4196 "Invalid IPARAMVALUE tag ");
4197 }
4198
4199 if (!emptyTag)
4200 {
4201 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4202 }
4203
4204 if (duplicateParameter)
4205 {
4206 throw PEGASUS_CIM_EXCEPTION(
4207 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
4208 }
4209 }
4210 karl 1.127.2.1
4211 if (!gotEnumerationContext)
4212 {
4213 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4214 "EnumerationContext IPARAM required");
4215 }
4216
4217 if (!gotMaxObjectCount)
4218 {
4219 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4220 "MaxObjectCount IPARAM required");
4221 }
4222
4223 AutoPtr<CIMPullInstancePathsRequestMessage> request(
4224 new CIMPullInstancePathsRequestMessage(
4225 messageId,
4226 nameSpace,
4227 enumerationContext,
4228 maxObjectCount,
4229 QueueIdStack(queueId, _returnQueueId)));
4230
4231 karl 1.127.2.1 STAT_SERVERSTART
4232
4233 return request.release();
4234 }
4235
4236 CIMCloseEnumerationRequestMessage*
4237 CIMOperationRequestDecoder::decodeCloseEnumerationRequest(
4238 Uint32 queueId,
4239 XmlParser& parser,
4240 const String& messageId,
4241 const CIMNamespaceName& nameSpace)
4242 {
4243 STAT_GETSTARTTIME
4244
4245 String enumerationContext = String::EMPTY;
4246 Boolean duplicateParameter = false;
4247 Boolean gotEnumerationContext = false;
4248
4249 Boolean emptyTag;
4250 for (const char* name;
4251 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4252 karl 1.127.2.1 {
4253 if (System::strcasecmp(name, "EnumerationContext") == 0)
4254 {
4255 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4256 XmlReader::getStringValueElement(parser, enumerationContext, true);
4257 duplicateParameter = gotEnumerationContext;
4258 gotEnumerationContext = true;
4259 }
4260 else
4261 {
4262 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
4263 }
4264
4265 if (!emptyTag)
4266 {
4267 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4268 }
4269
4270
4271 if (duplicateParameter)
4272 {
4273 karl 1.127.2.1 throw PEGASUS_CIM_EXCEPTION(
4274 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
4275 }
4276 }
4277
4278 if (!gotEnumerationContext)
4279 {
4280 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4281 "EnumerationContext IPARAM required");
4282 }
4283
4284 AutoPtr<CIMCloseEnumerationRequestMessage> request(
4285 new CIMCloseEnumerationRequestMessage(
4286 messageId,
4287 nameSpace,
4288 enumerationContext,
4289 QueueIdStack(queueId, _returnQueueId)));
4290
4291 STAT_SERVERSTART
4292
4293 return request.release();
4294 karl 1.127.2.1 }
4295
4296
4297 CIMEnumerationCountRequestMessage*
4298 CIMOperationRequestDecoder::decodeEnumerationCountRequest(
4299 Uint32 queueId,
4300 XmlParser& parser,
4301 const String& messageId,
4302 const CIMNamespaceName& nameSpace)
4303 {
4304 STAT_GETSTARTTIME
4305
4306 String enumerationContext = String::EMPTY;
4307 Boolean duplicateParameter = false;
4308 Boolean gotEnumerationContext = false;
4309
4310 Boolean emptyTag;
4311
4312 for (const char* name;
4313 XmlReader::getIParamValueTag(parser, name, emptyTag); )
4314 {
4315 karl 1.127.2.1 if (System::strcasecmp(name, "EnumerationContext") == 0)
4316 {
4317 XmlReader::rejectNullIParamValue(parser, emptyTag, name);
4318 XmlReader::getStringValueElement(parser, enumerationContext, true);
4319 duplicateParameter = gotEnumerationContext;
4320 gotEnumerationContext = true;
4321 }
4322 else
4323 {
4324 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
4325 }
4326
4327 if (!emptyTag)
4328 {
4329 XmlReader::expectEndTag(parser, "IPARAMVALUE");
4330 }
4331
4332 if (duplicateParameter)
4333 {
4334 throw PEGASUS_CIM_EXCEPTION(
4335 CIM_ERR_INVALID_PARAMETER, String::EMPTY);
4336 karl 1.127.2.1 }
4337 }
4338
4339 if (!gotEnumerationContext)
4340 {
4341 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
4342 "Missing EnumerationContext Parameter");
4343 }
4344
4345
4346 AutoPtr<CIMEnumerationCountRequestMessage> request(
4347 new CIMEnumerationCountRequestMessage(
4348 messageId,
4349 nameSpace,
4350 enumerationContext,
4351 QueueIdStack(queueId, _returnQueueId)));
4352
4353 STAT_SERVERSTART
4354
4355 return request.release();
4356 }
|
4357 karl 1.127.2.3 //EXP_PULL_END
|
4358 karl 1.127.2.1
|
4359 mike 1.2 void CIMOperationRequestDecoder::setServerTerminating(Boolean flag)
4360 {
|
4361 kumpf 1.104 _serverTerminating = flag;
|
4362 mike 1.2 }
4363
4364 PEGASUS_NAMESPACE_END
|
Return to
CIMOperationRequestDecoder.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Server