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