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