1 martin 1.136 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.137 //
|
3 martin 1.136 // 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.137 //
|
10 martin 1.136 // 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.137 //
|
17 martin 1.136 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.137 //
|
20 martin 1.136 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.137 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.136 // 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.137 //
|
28 martin 1.136 //////////////////////////////////////////////////////////////////////////
|
29 mike 1.23 //
30 //%/////////////////////////////////////////////////////////////////////////////
|
31 mday 1.45 #include <Pegasus/Common/Config.h>
|
32 thilo.boehm 1.131 #include <Pegasus/Common/Constants.h>
|
33 mike 1.120 #include <errno.h>
|
34 mike 1.23 #include <cctype>
35 #include <cstdio>
36 #include <cstdlib>
|
37 gs.keenan 1.107 #if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
|
38 kumpf 1.122 # include <errno.h>
|
39 mday 1.45 #endif
|
40 mike 1.23 #include "CIMName.h"
|
41 kumpf 1.135 #include "CIMNameCast.h"
|
42 mike 1.23 #include "XmlReader.h"
43 #include "XmlWriter.h"
44 #include "CIMQualifier.h"
45 #include "CIMQualifierDecl.h"
46 #include "CIMClass.h"
47 #include "CIMInstance.h"
48 #include "CIMObject.h"
|
49 mike 1.25 #include "CIMParamValue.h"
|
50 kumpf 1.72 #include "System.h"
|
51 humberto 1.91 #include "XmlConstants.h"
|
52 kumpf 1.122
|
53 humberto 1.85 #include <Pegasus/Common/MessageLoader.h>
|
54 kumpf 1.126 #include <Pegasus/Common/StringConversion.h>
|
55 joyce.j 1.112 #include <Pegasus/Common/AutoPtr.h>
|
56 humberto 1.85
|
57 mike 1.25 PEGASUS_USING_STD;
|
58 mike 1.23 PEGASUS_NAMESPACE_BEGIN
59
60 static const Uint32 MESSAGE_SIZE = 128;
61
62 //------------------------------------------------------------------------------
63 //
|
64 kumpf 1.49 // getXmlDeclaration()
65 //
66 // <?xml version="1.0" encoding="utf-8"?>
|
67 mike 1.23 //
68 //------------------------------------------------------------------------------
69
|
70 kumpf 1.49 void XmlReader::getXmlDeclaration(
|
71 kumpf 1.122 XmlParser& parser,
|
72 kumpf 1.49 const char*& xmlVersion,
73 const char*& xmlEncoding)
|
74 mike 1.23 {
|
75 kumpf 1.49 XmlEntry entry;
76
|
77 mike 1.23 if (!parser.next(entry) ||
|
78 kumpf 1.122 entry.type != XmlEntry::XML_DECLARATION ||
79 strcmp(entry.text, "xml") != 0)
|
80 mike 1.23 {
|
81 kumpf 1.122 MessageLoaderParms mlParms(
82 "Common.XmlReader.EXPECTED_XML_STYLE",
83 "Expected <?xml ... ?> style declaration");
84 throw XmlValidationError(parser.getLine(), mlParms);
|
85 kumpf 1.49 }
86
|
87 kumpf 1.122 if (!entry.getAttributeValue("version", xmlVersion))
88 {
89 MessageLoaderParms mlParms(
90 "Common.XmlReader.MISSING_XML_ATTRIBUTE",
91 "missing xml.version attribute");
92 throw XmlValidationError(parser.getLine(), mlParms);
|
93 humberto 1.85 }
|
94 kumpf 1.49
95 if (!entry.getAttributeValue("encoding", xmlEncoding))
96 {
97 // ATTN-RK-P3-20020403: Is there a default encoding?
|
98 mike 1.23 }
99 }
100
101 //------------------------------------------------------------------------------
102 //
|
103 mike 1.25 // testXmlDeclaration ()
104 //
105 //------------------------------------------------------------------------------
106
107 Boolean XmlReader::testXmlDeclaration (
108 XmlParser& parser,
109 XmlEntry& entry)
110 {
111 if (!parser.next (entry) ||
112 entry.type != XmlEntry::XML_DECLARATION ||
113 strcmp (entry.text, "xml") != 0)
114 {
115 parser.putBack (entry);
116 return false;
117 }
118
119 return true;
120 }
121
122 //------------------------------------------------------------------------------
123 //
|
124 mike 1.23 // expectStartTag()
125 //
126 //------------------------------------------------------------------------------
127
128 void XmlReader::expectStartTag(
|
129 kumpf 1.122 XmlParser& parser,
|
130 mike 1.23 XmlEntry& entry,
131 const char* tagName)
132 {
133 if (!parser.next(entry) ||
|
134 kumpf 1.122 entry.type != XmlEntry::START_TAG ||
135 strcmp(entry.text, tagName) != 0)
|
136 mike 1.23 {
|
137 kumpf 1.122 MessageLoaderParms mlParms(
138 "Common.XmlReader.EXPECTED_OPEN",
139 "Expected open of $0 element",
140 tagName);
141 throw XmlValidationError(parser.getLine(), mlParms);
|
142 mike 1.23 }
143 }
144
145 //------------------------------------------------------------------------------
146 //
147 // expectEndTag()
148 //
149 //------------------------------------------------------------------------------
150
151 void XmlReader::expectEndTag(XmlParser& parser, const char* tagName)
152 {
153 XmlEntry entry;
154
155 if (!parser.next(entry) ||
|
156 kumpf 1.122 entry.type != XmlEntry::END_TAG ||
157 strcmp(entry.text, tagName) != 0)
|
158 mike 1.23 {
|
159 kumpf 1.122 MessageLoaderParms mlParms(
160 "Common.XmlReader.EXPECTED_CLOSE",
161 "Expected close of $0 element, got $1 instead",
162 tagName,entry.text);
163 throw XmlValidationError(parser.getLine(), mlParms);
|
164 mike 1.23 }
165 }
166
167 //------------------------------------------------------------------------------
168 //
169 // expectStartTagOrEmptyTag()
170 //
171 //------------------------------------------------------------------------------
172
173 void XmlReader::expectStartTagOrEmptyTag(
|
174 kumpf 1.122 XmlParser& parser,
|
175 mike 1.23 XmlEntry& entry,
176 const char* tagName)
177 {
178 if (!parser.next(entry) ||
|
179 kumpf 1.122 (entry.type != XmlEntry::START_TAG &&
180 entry.type != XmlEntry::EMPTY_TAG) ||
181 strcmp(entry.text, tagName) != 0)
182 {
183 MessageLoaderParms mlParms(
184 "Common.XmlReader.EXPECTED_OPENCLOSE",
185 "Expected either open or open/close $0 element",
186 tagName);
187 throw XmlValidationError(parser.getLine(), mlParms);
|
188 mike 1.23 }
189 }
190
191 //------------------------------------------------------------------------------
192 //
193 // expectContentOrCData()
194 //
195 //------------------------------------------------------------------------------
196
197 Boolean XmlReader::expectContentOrCData(
|
198 kumpf 1.122 XmlParser& parser,
|
199 mike 1.23 XmlEntry& entry)
200 {
201 if (!parser.next(entry) ||
|
202 kumpf 1.122 (entry.type != XmlEntry::CONTENT &&
203 entry.type != XmlEntry::CDATA))
|
204 mike 1.23 {
|
205 kumpf 1.122 MessageLoaderParms mlParms(
206 "Common.XmlReader.EXPECTED_CDATA",
|
207 mike 1.143 "Expected content or CDATA");
|
208 kumpf 1.122 throw XmlValidationError(parser.getLine(), mlParms);
|
209 mike 1.23 }
210
211 return true;
212 }
213
214 //------------------------------------------------------------------------------
215 //
216 // testStartTag()
217 //
218 //------------------------------------------------------------------------------
219
220 Boolean XmlReader::testStartTag(
|
221 kumpf 1.122 XmlParser& parser,
|
222 mike 1.23 XmlEntry& entry,
223 const char* tagName)
224 {
225 if (!parser.next(entry) ||
|
226 kumpf 1.122 entry.type != XmlEntry::START_TAG ||
227 strcmp(entry.text, tagName) != 0)
|
228 mike 1.23 {
|
229 kumpf 1.122 parser.putBack(entry);
230 return false;
|
231 mike 1.23 }
232
233 return true;
234 }
235
236 //------------------------------------------------------------------------------
237 //
|
238 kumpf 1.48 // testEndTag()
|
239 mike 1.23 //
240 //------------------------------------------------------------------------------
241
242 Boolean XmlReader::testEndTag(XmlParser& parser, const char* tagName)
243 {
244 XmlEntry entry;
245
246 if (!parser.next(entry) ||
|
247 kumpf 1.122 entry.type != XmlEntry::END_TAG ||
248 strcmp(entry.text, tagName) != 0)
|
249 mike 1.23 {
|
250 kumpf 1.122 parser.putBack(entry);
251 return false;
|
252 mike 1.23 }
253
254 return true;
255 }
256
257 //------------------------------------------------------------------------------
258 //
259 // testStartTagOrEmptyTag()
260 //
261 //------------------------------------------------------------------------------
262
263 Boolean XmlReader::testStartTagOrEmptyTag(
|
264 kumpf 1.122 XmlParser& parser,
|
265 mike 1.23 XmlEntry& entry,
266 const char* tagName)
267 {
|
268 r.kieninger 1.142 if (!parser.next(entry))
269 {
270 return false;
271 }
272 if ((entry.type != XmlEntry::START_TAG &&
273 entry.type != XmlEntry::EMPTY_TAG) ||
|
274 kumpf 1.122 strcmp(entry.text, tagName) != 0)
|
275 mike 1.23 {
|
276 kumpf 1.122 parser.putBack(entry);
277 return false;
|
278 mike 1.23 }
279
280 return true;
281 }
282
283 //------------------------------------------------------------------------------
284 //
|
285 kumpf 1.95 // testStartTagOrEmptyTag()
286 //
287 //------------------------------------------------------------------------------
288
289 Boolean XmlReader::testStartTagOrEmptyTag(
|
290 kumpf 1.122 XmlParser& parser,
|
291 kumpf 1.95 XmlEntry& entry)
292 {
293 if (!parser.next(entry) ||
|
294 kumpf 1.122 (entry.type != XmlEntry::START_TAG &&
295 entry.type != XmlEntry::EMPTY_TAG))
|
296 kumpf 1.95 {
|
297 kumpf 1.122 parser.putBack(entry);
298 return false;
|
299 kumpf 1.95 }
300
301 return true;
302 }
303
304 //------------------------------------------------------------------------------
305 //
|
306 mike 1.23 // testContentOrCData()
307 //
308 //------------------------------------------------------------------------------
309
310 Boolean XmlReader::testContentOrCData(
|
311 kumpf 1.122 XmlParser& parser,
|
312 mike 1.23 XmlEntry& entry)
313 {
314 if (!parser.next(entry) ||
|
315 kumpf 1.122 (entry.type != XmlEntry::CONTENT &&
316 entry.type != XmlEntry::CDATA))
|
317 mike 1.23 {
|
318 kumpf 1.122 parser.putBack(entry);
319 return false;
|
320 mike 1.23 }
321
322 return true;
323 }
324
325 //------------------------------------------------------------------------------
326 //
|
327 kumpf 1.34 // getCimStartTag()
|
328 mike 1.23 //
329 // <!ELEMENT CIM (MESSAGE|DECLARATION)>
|
330 kumpf 1.122 // <!ATTRLIST CIM
|
331 mike 1.23 // CIMVERSION CDATA #REQUIRED
332 // DTDVERSION CDATA #REQUIRED>
333 //
334 //------------------------------------------------------------------------------
335
|
336 kumpf 1.34 void XmlReader::getCimStartTag(
|
337 kumpf 1.122 XmlParser& parser,
|
338 kumpf 1.34 const char*& cimVersion,
339 const char*& dtdVersion)
|
340 mike 1.23 {
341 XmlEntry entry;
342 XmlReader::expectStartTag(parser, entry, "CIM");
343
|
344 kumpf 1.122 if (!entry.getAttributeValue("CIMVERSION", cimVersion))
345 {
346 MessageLoaderParms mlParms(
347 "Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",
348 "missing CIM.CIMVERSION attribute");
349 throw XmlValidationError(parser.getLine(), mlParms);
|
350 humberto 1.85 }
351
|
352 kumpf 1.122 if (!entry.getAttributeValue("DTDVERSION", dtdVersion))
353 {
354 MessageLoaderParms mlParms(
355 "Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",
356 "missing CIM.DTDVERSION attribute");
357 throw XmlValidationError(parser.getLine(), mlParms);
|
358 humberto 1.85 }
|
359 mike 1.23 }
360
361 //------------------------------------------------------------------------------
362 //
363 // getCimNameAttribute()
364 //
365 // <!ENTITY % CIMName "NAME CDATA #REQUIRED">
366 //
367 //------------------------------------------------------------------------------
368
|
369 kumpf 1.74 CIMName XmlReader::getCimNameAttribute(
|
370 kumpf 1.122 Uint32 lineNumber,
|
371 mike 1.23 const XmlEntry& entry,
372 const char* elementName,
373 Boolean acceptNull)
374 {
|
375 mike 1.134 const char* name;
|
376 mike 1.23
377 if (!entry.getAttributeValue("NAME", name))
|
378 kumpf 1.122 {
379 char buffer[MESSAGE_SIZE];
380 sprintf(buffer, "%s.NAME", elementName);
381 MessageLoaderParms mlParms(
382 "Common.XmlReader.MISSING_ATTRIBUTE",
383 "missing $0 attribute",
384 buffer);
|
385 humberto 1.85
|
386 kumpf 1.122 throw XmlValidationError(lineNumber, mlParms);
|
387 mike 1.23 }
388
|
389 mike 1.134 if (acceptNull && *name == '\0')
390 return CIMName();
391
392 Uint32 size = CIMNameLegalASCII(name);
393
394 if (size)
395 {
396 String tmp(name, size);
397 return CIMName(CIMNameCast(tmp));
398 }
|
399 kumpf 1.122
|
400 mike 1.23 if (!CIMName::legal(name))
401 {
|
402 karl 1.78 #ifdef PEGASUS_SNIA_INTEROP_TEST
403 // In testing, replace illegal CIMName with this value to avoid the
|
404 kumpf 1.122 // exception and let xml parsing continue. THIS IS TEMP.
|
405 karl 1.78 name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT";
406 #else
|
407 humberto 1.85
|
408 kumpf 1.122 char buffer[MESSAGE_SIZE];
409 sprintf(buffer, "%s.NAME", elementName);
|
410 humberto 1.85
|
411 kumpf 1.122 MessageLoaderParms mlParms(
412 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
413 "Illegal value for $0 attribute",
414 buffer);
|
415 humberto 1.85
416 throw XmlSemanticError(lineNumber, mlParms);
417
|
418 karl 1.78 #endif
|
419 mike 1.23 }
|
420 mike 1.134
|
421 mike 1.133 return CIMNameCast(name);
|
422 mike 1.23 }
423
424 //------------------------------------------------------------------------------
425 //
426 // getClassNameAttribute()
427 //
428 // <!ENTITY % CIMName "CLASSNAME CDATA #REQUIRED">
429 //
430 //------------------------------------------------------------------------------
431
432 String XmlReader::getClassNameAttribute(
|
433 kumpf 1.122 Uint32 lineNumber,
|
434 mike 1.23 const XmlEntry& entry,
435 const char* elementName)
436 {
437 String name;
438
439 if (!entry.getAttributeValue("CLASSNAME", name))
440 {
|
441 kumpf 1.122 char buffer[MESSAGE_SIZE];
442 sprintf(buffer, "%s.CLASSNAME", elementName);
|
443 humberto 1.85
|
444 kumpf 1.122 MessageLoaderParms mlParms(
445 "Common.XmlReader.MISSING_ATTRIBUTE",
446 "missing $0 attribute",
447 buffer);
|
448 humberto 1.85
|
449 kumpf 1.122 throw XmlValidationError(lineNumber, mlParms);
|
450 mike 1.23 }
451
452 if (!CIMName::legal(name))
453 {
|
454 kumpf 1.122 char buffer[MESSAGE_SIZE];
455 sprintf(buffer, "%s.CLASSNAME", elementName);
|
456 humberto 1.85
|
457 kumpf 1.122 MessageLoaderParms mlParms(
458 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
459 "Illegal value for $0 attribute",
460 buffer);
461 throw XmlSemanticError(lineNumber, mlParms);
|
462 mike 1.23 }
463
464 return name;
465 }
466
467 //------------------------------------------------------------------------------
468 //
469 // getClassOriginAttribute()
470 //
471 // <!ENTITY % ClassOrigin "CLASSORIGIN CDATA #IMPLIED">
472 //
473 //------------------------------------------------------------------------------
474
|
475 kumpf 1.62 CIMName XmlReader::getClassOriginAttribute(
|
476 kumpf 1.122 Uint32 lineNumber,
|
477 mike 1.23 const XmlEntry& entry,
478 const char* tagName)
479 {
480 String name;
481
482 if (!entry.getAttributeValue("CLASSORIGIN", name))
|
483 kumpf 1.122 return CIMName();
|
484 mike 1.23
|
485 marek 1.140 /* Interoperability hack to make the C++ client of OpenPegasus able
486 to deal with the wbemservices CIMOM delivered with Sun Solaris.
487 The issue is that the wbemservices delivers Xml responses with
488 CLASSORIGIN=""
489 Originally this had been reported with Bug#537.
490 */
491 if (name.size()==0)
492 {
493 return CIMName();
494 }
495
|
496 mike 1.23 if (!CIMName::legal(name))
497 {
|
498 kumpf 1.122 char buffer[MESSAGE_SIZE];
499 sprintf(buffer, "%s.CLASSORIGIN", tagName);
|
500 humberto 1.85
|
501 kumpf 1.122 MessageLoaderParms mlParms(
502 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
503 "Illegal value for $0 attribute",
504 buffer);
505 throw XmlSemanticError(lineNumber, mlParms);
|
506 mike 1.23 }
|
507 kumpf 1.139 // The CIMName was already checked with legal() + String()
|
508 mike 1.133 return CIMNameCast(name);
|
509 mike 1.23 }
510
511 //------------------------------------------------------------------------------
512 //
|
513 dave.sudlik 1.109 // getEmbeddedObjectAttribute()
514 //
|
515 karl 1.129 // <!ENTITY % EmbeddedObject "EmbeddedObject (object | instance) #IMPLIED">
|
516 dave.sudlik 1.109 //
|
517 thilo.boehm 1.131 // EmbeddedObjectAttributeType:
518 // NO_EMBEDDED_OBJECT = 0,
519 // EMBEDDED_OBJECT_ATTR = 1,
520 // EMBEDDED_INSTANCE_ATTR = 2
521 //
|
522 dave.sudlik 1.109 //------------------------------------------------------------------------------
523
|
524 thilo.boehm 1.131 XmlReader::EmbeddedObjectAttributeType XmlReader::getEmbeddedObjectAttribute(
|
525 kumpf 1.122 Uint32 lineNumber,
|
526 dave.sudlik 1.109 const XmlEntry& entry,
|
527 thilo.boehm 1.131 const char* tagName)
|
528 dave.sudlik 1.109 {
|
529 thilo.boehm 1.131 const char* embeddedObject;
|
530 dave.sudlik 1.109
|
531 karl 1.129 // Check for both upper case and mixed case "EmbeddedObject"
532 // because of an error in an earlier pegasus version where we
533 // used upper case in the generation of the attribute name
534 // whereas the DMTF spec calls for mixed case.
535 if (!entry.getAttributeValue("EmbeddedObject", embeddedObject) &&
536 !entry.getAttributeValue("EMBEDDEDOBJECT", embeddedObject))
|
537 thilo.boehm 1.131 return NO_EMBEDDED_OBJECT;
|
538 dave.sudlik 1.109
539 // The embeddedObject attribute, if present, must have the string
540 // value "object" or "instance".
|
541 thilo.boehm 1.131 if (strcmp(embeddedObject, "object") == 0)
|
542 kumpf 1.122 {
|
543 thilo.boehm 1.131 return EMBEDDED_OBJECT_ATTR;
544 }
|
545 kumpf 1.139
|
546 thilo.boehm 1.131 if (strcmp(embeddedObject, "instance") == 0)
547 {
548 return EMBEDDED_INSTANCE_ATTR;
549 }
|
550 kumpf 1.122
|
551 thilo.boehm 1.131 char buffer[MESSAGE_SIZE];
552 sprintf(buffer, "%s.EmbeddedObject", tagName);
|
553 dave.sudlik 1.109
|
554 thilo.boehm 1.131 MessageLoaderParms mlParms(
555 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
556 "Illegal value for $0 attribute",
557 buffer);
558 throw XmlSemanticError(lineNumber, mlParms);
|
559 kumpf 1.139
|
560 thilo.boehm 1.131 return NO_EMBEDDED_OBJECT;
|
561 dave.sudlik 1.109 }
562
563 //------------------------------------------------------------------------------
564 //
|
565 mike 1.23 // getReferenceClassAttribute()
566 //
567 // <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">
568 //
569 //------------------------------------------------------------------------------
570
|
571 kumpf 1.62 CIMName XmlReader::getReferenceClassAttribute(
|
572 kumpf 1.122 Uint32 lineNumber,
|
573 mike 1.23 const XmlEntry& entry,
574 const char* elementName)
575 {
576 String name;
577
578 if (!entry.getAttributeValue("REFERENCECLASS", name))
|
579 kumpf 1.122 return CIMName();
|
580 mike 1.23
581 if (!CIMName::legal(name))
582 {
|
583 karl 1.79 #ifdef PEGASUS_SNIA_INTEROP_TEST
|
584 kumpf 1.122 name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";
585 return name;
586 #endif
|
587 humberto 1.85
|
588 kumpf 1.122 char buffer[MESSAGE_SIZE];
589 sprintf(buffer, "%s.REFERENCECLASS", elementName);
|
590 humberto 1.85
|
591 kumpf 1.122 MessageLoaderParms mlParms(
592 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
593 "Illegal value for $0 attribute",
594 buffer);
595 throw XmlSemanticError(lineNumber, mlParms);
|
596 mike 1.23 }
|
597 kumpf 1.139 // The CIMName was already checked with legal() + String()
|
598 mike 1.133 return CIMNameCast(name);
|
599 mike 1.23 }
600
601 //------------------------------------------------------------------------------
602 //
603 // getSuperClassAttribute()
604 //
605 // <!ENTITY % SuperClass "SUPERCLASS CDATA #IMPLIED">
606 //
607 //------------------------------------------------------------------------------
608
|
609 kumpf 1.62 CIMName XmlReader::getSuperClassAttribute(
|
610 kumpf 1.122 Uint32 lineNumber,
|
611 mike 1.23 const XmlEntry& entry,
612 const char* tagName)
613 {
614 String superClass;
615
616 if (!entry.getAttributeValue("SUPERCLASS", superClass))
|
617 kumpf 1.122 return CIMName();
|
618 mike 1.23
619 if (!CIMName::legal(superClass))
620 {
|
621 kumpf 1.122 char buffer[MESSAGE_SIZE];
622 sprintf(buffer, "%s.SUPERCLASS", tagName);
|
623 humberto 1.85
|
624 kumpf 1.122 MessageLoaderParms mlParms(
625 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
626 "Illegal value for $0 attribute",
627 buffer);
628 throw XmlSemanticError(lineNumber, mlParms);
|
629 mike 1.23 }
|
630 kumpf 1.139 // The CIMName was already checked with legal() + String()
|
631 mike 1.133 return CIMNameCast(superClass);
|
632 mike 1.23 }
633
634 //------------------------------------------------------------------------------
635 //
636 // getCimTypeAttribute()
637 //
|
638 kumpf 1.26 // This method can be used to get a TYPE attribute or a PARAMTYPE attribute.
639 // The only significant difference is that PARAMTYPE may specify a value of
640 // "reference" type. This method recognizes these attributes by name, and
641 // does not allow a "TYPE" attribute to be of "reference" type.
642 //
|
643 mike 1.23 // <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16
644 // |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)">
645 //
|
646 kumpf 1.26 // <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8
647 // |uint16|sint16|uint32|sint32|uint64|sint64|datetime|real32|real64
648 // |reference)">
649 //
|
650 mike 1.23 //------------------------------------------------------------------------------
651
|
652 kumpf 1.67 Boolean XmlReader::getCimTypeAttribute(
|
653 kumpf 1.122 Uint32 lineNumber,
654 const XmlEntry& entry,
|
655 kumpf 1.67 CIMType& cimType, // Output parameter
|
656 kumpf 1.26 const char* tagName,
657 const char* attributeName,
658 Boolean required)
|
659 mike 1.23 {
660 const char* typeName;
661
|
662 kumpf 1.26 if (!entry.getAttributeValue(attributeName, typeName))
|
663 mike 1.23 {
|
664 kumpf 1.26 if (required)
|
665 kumpf 1.122 {
666 char message[MESSAGE_SIZE];
667 sprintf(message, "%s.%s", tagName, attributeName);
|
668 humberto 1.85
|
669 kumpf 1.122 MessageLoaderParms mlParms(
670 "Common.XmlReader.MISSING_ATTRIBUTE",
671 "missing $0 attribute",
672 message);
673 throw XmlValidationError(lineNumber, mlParms);
674 }
675 else
676 {
677 return false;
678 }
|
679 mike 1.23 }
680
|
681 kumpf 1.67 CIMType type = CIMTYPE_BOOLEAN;
682 Boolean unrecognizedType = false;
|
683 mike 1.23
684 if (strcmp(typeName, "boolean") == 0)
|
685 kumpf 1.122 type = CIMTYPE_BOOLEAN;
|
686 mike 1.23 else if (strcmp(typeName, "string") == 0)
|
687 kumpf 1.122 type = CIMTYPE_STRING;
|
688 mike 1.23 else if (strcmp(typeName, "char16") == 0)
|
689 kumpf 1.122 type = CIMTYPE_CHAR16;
|
690 mike 1.23 else if (strcmp(typeName, "uint8") == 0)
|
691 kumpf 1.122 type = CIMTYPE_UINT8;
|
692 mike 1.23 else if (strcmp(typeName, "sint8") == 0)
|
693 kumpf 1.122 type = CIMTYPE_SINT8;
|
694 mike 1.23 else if (strcmp(typeName, "uint16") == 0)
|
695 kumpf 1.122 type = CIMTYPE_UINT16;
|
696 mike 1.23 else if (strcmp(typeName, "sint16") == 0)
|
697 kumpf 1.122 type = CIMTYPE_SINT16;
|
698 mike 1.23 else if (strcmp(typeName, "uint32") == 0)
|
699 kumpf 1.122 type = CIMTYPE_UINT32;
|
700 mike 1.23 else if (strcmp(typeName, "sint32") == 0)
|
701 kumpf 1.122 type = CIMTYPE_SINT32;
|
702 mike 1.23 else if (strcmp(typeName, "uint64") == 0)
|
703 kumpf 1.122 type = CIMTYPE_UINT64;
|
704 mike 1.23 else if (strcmp(typeName, "sint64") == 0)
|
705 kumpf 1.122 type = CIMTYPE_SINT64;
|
706 mike 1.23 else if (strcmp(typeName, "datetime") == 0)
|
707 kumpf 1.122 type = CIMTYPE_DATETIME;
|
708 mike 1.23 else if (strcmp(typeName, "real32") == 0)
|
709 kumpf 1.122 type = CIMTYPE_REAL32;
|
710 mike 1.23 else if (strcmp(typeName, "real64") == 0)
|
711 kumpf 1.122 type = CIMTYPE_REAL64;
|
712 kumpf 1.26 else if (strcmp(typeName, "reference") == 0)
|
713 kumpf 1.122 type = CIMTYPE_REFERENCE;
|
714 dave.sudlik 1.109 // PEP 194:
715 // Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a
|
716 kumpf 1.122 // Pegasus internal representation of an embedded object, so it won't be
717 // found here.
|
718 kumpf 1.67 else unrecognizedType = true;
|
719 mike 1.23
|
720 kumpf 1.67 if (unrecognizedType ||
|
721 kumpf 1.61 ((type == CIMTYPE_REFERENCE) &&
|
722 kumpf 1.26 (strcmp(attributeName, "PARAMTYPE") != 0)))
|
723 mike 1.23 {
|
724 kumpf 1.122 char buffer[MESSAGE_SIZE];
725 sprintf(buffer, "%s.%s", tagName, attributeName);
|
726 humberto 1.85
|
727 kumpf 1.122 MessageLoaderParms mlParms(
728 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
729 "Illegal value for $0 attribute",
730 buffer);
731
732 throw XmlSemanticError(lineNumber, mlParms);
|
733 mike 1.23 }
734
|
735 kumpf 1.67 cimType = type;
736 return true;
|
737 mike 1.23 }
738
739 //------------------------------------------------------------------------------
740 //
741 // getCimBooleanAttribute()
742 //
743 //------------------------------------------------------------------------------
744
745 Boolean XmlReader::getCimBooleanAttribute(
746 Uint32 lineNumber,
747 const XmlEntry& entry,
748 const char* tagName,
749 const char* attributeName,
750 Boolean defaultValue,
751 Boolean required)
752 {
753 const char* tmp;
754
755 if (!entry.getAttributeValue(attributeName, tmp))
756 {
|
757 kumpf 1.122 if (!required)
758 return defaultValue;
|
759 humberto 1.85
|
760 kumpf 1.126 char buffer[MESSAGE_SIZE];
|
761 kumpf 1.122 sprintf(buffer, "%s.%s", attributeName, tagName);
|
762 mike 1.23
|
763 kumpf 1.122 MessageLoaderParms mlParms(
764 "Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",
765 "missing required $0 attribute",
766 buffer);
767 throw XmlValidationError(lineNumber, mlParms);
|
768 mike 1.23 }
769
770 if (strcmp(tmp, "true") == 0)
|
771 kumpf 1.122 return true;
|
772 mike 1.23 else if (strcmp(tmp, "false") == 0)
|
773 kumpf 1.122 return false;
|
774 humberto 1.85
|
775 kumpf 1.126 char buffer[MESSAGE_SIZE];
|
776 humberto 1.85 sprintf(buffer, "%s.%s", attributeName, tagName);
777
|
778 kumpf 1.122 MessageLoaderParms mlParms(
779 "Common.XmlReader.INVALID_ATTRIBUTE",
780 "Invalid $0 attribute value",
781 buffer);
|
782 humberto 1.85
783 throw XmlSemanticError(lineNumber, mlParms);
784
|
785 mike 1.23 return false;
786 }
787
|
788 kumpf 1.82 // See http://www.ietf.org/rfc/rfc2396.txt section 2
|
789 chuck 1.88 //
790 // Also see the "CIM Operations over HTTP" spec, section 3.3.2 and
791 // 3.3.3, for the treatment of non US-ASCII chars (UTF-8)
|
792 kumpf 1.82 String XmlReader::decodeURICharacters(String uriString)
793 {
794 Uint32 i;
795
|
796 kumpf 1.138 Buffer utf8Chars;
|
797 chuck 1.88
|
798 kumpf 1.82 for (i=0; i<uriString.size(); i++)
799 {
800 if (uriString[i] == '%')
801 {
802 if (i+2 >= uriString.size())
803 {
|
804 kumpf 1.122 MessageLoaderParms mlParms(
805 "Common.XmlReader.INVALID_URI_ENCODING",
806 "Invalid URI encoding");
807 throw ParseError(MessageLoader::getMessage(mlParms));
|
808 kumpf 1.82 }
809
|
810 kumpf 1.126 Uint8 digit1 =
811 StringConversion::hexCharToNumeric(char(uriString[++i]));
812 Uint8 digit2 =
813 StringConversion::hexCharToNumeric(char(uriString[++i]));
|
814 kumpf 1.82 if ( (digit1 > 15) || (digit2 > 15) )
815 {
|
816 kumpf 1.122 MessageLoaderParms mlParms(
817 "Common.XmlReader.INVALID_URI_ENCODING",
818 "Invalid URI encoding");
819 throw ParseError(MessageLoader::getMessage(mlParms));
|
820 kumpf 1.82 }
821
822 Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);
|
823 kumpf 1.138 utf8Chars.append((char)decodedChar);
|
824 kumpf 1.82 }
825 else
826 {
|
827 kumpf 1.138 utf8Chars.append((char)uriString[i]);
|
828 kumpf 1.82 }
829 }
830
|
831 chuck 1.88 // If there was a string to decode...
832 if (uriString.size() > 0)
833 {
834 // Convert UTF-8 to UTF-16 and return the String
|
835 kumpf 1.138 return String(utf8Chars.getData(), utf8Chars.size());
|
836 chuck 1.88 }
837 else
838 {
839 return String();
840 }
|
841 kumpf 1.41 }
842
|
843 mike 1.23 //------------------------------------------------------------------------------
844 //
845 // stringToSignedInteger
846 //
|
847 kumpf 1.122 // [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
|
848 kumpf 1.41 // or
849 // [ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit
|
850 mike 1.23 //
851 //------------------------------------------------------------------------------
852
853 Boolean XmlReader::stringToSignedInteger(
|
854 kumpf 1.122 const char* stringValue,
|
855 mike 1.23 Sint64& x)
856 {
|
857 kumpf 1.126 return (StringConversion::stringToSint64(
858 stringValue, StringConversion::decimalStringToUint64, x) ||
859 StringConversion::stringToSint64(
860 stringValue, StringConversion::hexStringToUint64, x));
|
861 mike 1.23 }
862
863 //------------------------------------------------------------------------------
864 //
865 // stringToUnsignedInteger
866 //
|
867 kumpf 1.122 // ( positiveDecimalDigit *decimalDigit | "0" )
|
868 kumpf 1.41 // or
869 // ( "0x" | "0X" ) 1*hexDigit
|
870 mike 1.23 //
871 //------------------------------------------------------------------------------
872
873 Boolean XmlReader::stringToUnsignedInteger(
|
874 kumpf 1.122 const char* stringValue,
|
875 mike 1.23 Uint64& x)
876 {
|
877 kumpf 1.126 return (StringConversion::decimalStringToUint64(stringValue, x) ||
878 StringConversion::hexStringToUint64(stringValue, x));
|
879 mike 1.23 }
880
881 //------------------------------------------------------------------------------
882 //
883 // stringToValue()
884 //
|
885 karl 1.35 // Return: CIMValue. If the string input is zero length creates a CIMValue
886 // with value defined by the type. Else the value is inserted.
|
887 kumpf 1.122 //
|
888 karl 1.35 // Note that this does not set the CIMValue Null if the string is empty.
889 //
|
890 mike 1.23 //------------------------------------------------------------------------------
891
892 CIMValue XmlReader::stringToValue(
|
893 kumpf 1.122 Uint32 lineNumber,
894 const char* valueString,
|
895 mike 1.23 CIMType type)
896 {
|
897 venkat.puvvada 1.141 return stringToValue(lineNumber, valueString, strlen(valueString), type);
898 }
899
900 CIMValue XmlReader::stringToValue(
901 Uint32 lineNumber,
902 const char* valueString,
903 Uint32 valueStringLen,
904 CIMType type)
905 {
|
906 mike 1.23 // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
907
|
908 venkat.puvvada 1.141 // Char string must have been null terminated.
909 PEGASUS_ASSERT (!valueString[valueStringLen]);
910
|
911 karl 1.35 // Create value per type
|
912 mike 1.23 switch (type)
913 {
|
914 kumpf 1.122 case CIMTYPE_BOOLEAN:
915 {
916 if (System::strcasecmp(valueString, "TRUE") == 0)
917 return CIMValue(true);
918 else if (System::strcasecmp(valueString, "FALSE") == 0)
919 return CIMValue(false);
920 else
921 {
922 MessageLoaderParms mlParms(
923 "Common.XmlReader.INVALID_BOOLEAN_VALUE",
924 "Invalid boolean value");
925 throw XmlSemanticError(lineNumber, mlParms);
926 }
927 }
|
928 mike 1.23
|
929 kumpf 1.122 case CIMTYPE_STRING:
930 {
|
931 venkat.puvvada 1.141 return CIMValue(String(valueString, valueStringLen));
|
932 kumpf 1.122 }
933
934 case CIMTYPE_CHAR16:
935 {
936 // Converts UTF-8 to UTF-16
|
937 venkat.puvvada 1.141 String tmp(valueString, valueStringLen);
|
938 kumpf 1.122 if (tmp.size() != 1)
939 {
940 MessageLoaderParms mlParms(
941 "Common.XmlReader.INVALID_CHAR16_VALUE",
942 "Invalid char16 value");
943 throw XmlSemanticError(lineNumber, mlParms);
944 }
945
946 return CIMValue(tmp[0]);
947 }
948
949 case CIMTYPE_UINT8:
950 case CIMTYPE_UINT16:
951 case CIMTYPE_UINT32:
952 case CIMTYPE_UINT64:
953 {
954 Uint64 x;
955
956 if (!stringToUnsignedInteger(valueString, x))
957 {
958 MessageLoaderParms mlParms(
959 kumpf 1.122 "Common.XmlReader.INVALID_UI_VALUE",
960 "Invalid unsigned integer value");
961 throw XmlSemanticError(lineNumber, mlParms);
962 }
|
963 humberto 1.85
|
964 kumpf 1.122 switch (type)
965 {
966 case CIMTYPE_UINT8:
|
967 kumpf 1.37 {
|
968 kumpf 1.126 if (!StringConversion::checkUintBounds(x, type))
|
969 kumpf 1.122 {
970 MessageLoaderParms mlParms(
971 "Common.XmlReader.U8_VALUE_OUT_OF_RANGE",
972 "Uint8 value out of range");
973 throw XmlSemanticError(lineNumber, mlParms);
974 }
975 return CIMValue(Uint8(x));
|
976 kumpf 1.37 }
|
977 kumpf 1.122 case CIMTYPE_UINT16:
|
978 kumpf 1.37 {
|
979 kumpf 1.126 if (!StringConversion::checkUintBounds(x, type))
|
980 kumpf 1.122 {
981 MessageLoaderParms mlParms(
982 "Common.XmlReader.U16_VALUE_OUT_OF_RANGE",
983 "Uint16 value out of range");
984 throw XmlSemanticError(lineNumber, mlParms);
985 }
986 return CIMValue(Uint16(x));
|
987 kumpf 1.37 }
|
988 kumpf 1.122 case CIMTYPE_UINT32:
|
989 kumpf 1.37 {
|
990 kumpf 1.126 if (!StringConversion::checkUintBounds(x, type))
|
991 kumpf 1.122 {
992 MessageLoaderParms mlParms(
993 "Common.XmlReader.U32_VALUE_OUT_OF_RANGE",
994 "Uint32 value out of range");
995 throw XmlSemanticError(lineNumber, mlParms);
996 }
997 return CIMValue(Uint32(x));
998 }
999 case CIMTYPE_UINT64: return CIMValue(Uint64(x));
1000 default: break;
1001 }
1002 }
|
1003 humberto 1.85
|
1004 kumpf 1.122 case CIMTYPE_SINT8:
1005 case CIMTYPE_SINT16:
1006 case CIMTYPE_SINT32:
1007 case CIMTYPE_SINT64:
1008 {
1009 Sint64 x;
|
1010 humberto 1.85
|
1011 kumpf 1.122 if (!stringToSignedInteger(valueString, x))
1012 {
1013 MessageLoaderParms mlParms(
1014 "Common.XmlReader.INVALID_SI_VALUE",
1015 "Invalid signed integer value");
1016 throw XmlSemanticError(lineNumber, mlParms);
1017 }
|
1018 humberto 1.85
|
1019 kumpf 1.122 switch (type)
1020 {
1021 case CIMTYPE_SINT8:
1022 {
|
1023 kumpf 1.126 if (!StringConversion::checkSintBounds(x, type))
|
1024 kumpf 1.122 {
1025 MessageLoaderParms mlParms(
1026 "Common.XmlReader.S8_VALUE_OUT_OF_RANGE",
1027 "Sint8 value out of range");
1028 throw XmlSemanticError(lineNumber, mlParms);
1029 }
1030 return CIMValue(Sint8(x));
|
1031 kumpf 1.37 }
|
1032 kumpf 1.122 case CIMTYPE_SINT16:
|
1033 kumpf 1.37 {
|
1034 kumpf 1.126 if (!StringConversion::checkSintBounds(x, type))
|
1035 kumpf 1.122 {
1036 MessageLoaderParms mlParms(
1037 "Common.XmlReader.S16_VALUE_OUT_OF_RANGE",
1038 "Sint16 value out of range");
1039 throw XmlSemanticError(lineNumber, mlParms);
1040 }
1041 return CIMValue(Sint16(x));
|
1042 kumpf 1.37 }
|
1043 kumpf 1.122 case CIMTYPE_SINT32:
|
1044 kumpf 1.37 {
|
1045 kumpf 1.126 if (!StringConversion::checkSintBounds(x, type))
|
1046 kumpf 1.122 {
1047 MessageLoaderParms mlParms(
1048 "Common.XmlReader.S32_VALUE_OUT_OF_RANGE",
1049 "Sint32 value out of range");
1050 throw XmlSemanticError(lineNumber, mlParms);
1051 }
1052 return CIMValue(Sint32(x));
|
1053 kumpf 1.37 }
|
1054 kumpf 1.122 case CIMTYPE_SINT64: return CIMValue(Sint64(x));
1055 default: break;
1056 }
1057 }
|
1058 humberto 1.85
|
1059 kumpf 1.122 case CIMTYPE_DATETIME:
1060 {
1061 CIMDateTime tmp;
|
1062 humberto 1.85
|
1063 kumpf 1.122 try
1064 {
1065 // KS 20021002 - Exception if no datetime value. Test for
1066 // zero length and leave the NULL value in the variable
1067 // Bugzilla 137 Adds the following if line.
1068 // Expect this to become permanent but test only for now
|
1069 karl 1.76 #ifdef PEGASUS_SNIA_INTEROP_TEST
|
1070 venkat.puvvada 1.141 if (valueStringLen != 0)
|
1071 karl 1.76 #endif
|
1072 kumpf 1.122 tmp.set(valueString);
1073 }
1074 catch (InvalidDateTimeFormatException&)
1075 {
1076 MessageLoaderParms mlParms(
1077 "Common.XmlReader.INVALID_DATETIME_VALUE",
1078 "Invalid datetime value");
1079 throw XmlSemanticError(lineNumber, mlParms);
1080 }
|
1081 humberto 1.85
|
1082 kumpf 1.122 return CIMValue(tmp);
1083 }
|
1084 humberto 1.85
|
1085 kumpf 1.122 case CIMTYPE_REAL32:
1086 {
1087 Real64 x;
|
1088 humberto 1.85
|
1089 kumpf 1.126 if (!StringConversion::stringToReal64(valueString, x))
|
1090 kumpf 1.122 {
1091 MessageLoaderParms mlParms(
1092 "Common.XmlReader.INVALID_RN_VALUE",
1093 "Invalid real number value");
1094 throw XmlSemanticError(lineNumber, mlParms);
1095 }
1096 return CIMValue(Real32(x));
1097 }
|
1098 mike 1.23
|
1099 kumpf 1.122 case CIMTYPE_REAL64:
1100 {
1101 Real64 x;
|
1102 mike 1.23
|
1103 kumpf 1.126 if (!StringConversion::stringToReal64(valueString, x))
|
1104 kumpf 1.122 {
1105 MessageLoaderParms mlParms(
1106 "Common.XmlReader.INVALID_RN_VALUE",
1107 "Invalid real number value");
1108 throw XmlSemanticError(lineNumber, mlParms);
1109 }
1110 return CIMValue(x);
1111 }
|
1112 mike 1.23
|
1113 dave.sudlik 1.109 // PEP 194:
|
1114 kumpf 1.122 // Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but
1115 // just a Pegasus internal representation of an embedded object. However,
1116 // this case is used when decoding string representations of embedded objects.
1117 case CIMTYPE_OBJECT:
1118 case CIMTYPE_INSTANCE:
|
1119 dave.sudlik 1.109 {
|
1120 kumpf 1.122 CIMObject x;
|
1121 dave.sudlik 1.109
|
1122 kumpf 1.122 if (*valueString == '\0')
|
1123 dave.sudlik 1.109 {
|
1124 kumpf 1.122 return CIMValue(type, false, 0);
|
1125 dave.sudlik 1.109 }
1126 else
1127 {
|
1128 kumpf 1.122 // Convert the non-NULL string to a CIMObject (containing
1129 // either a CIMInstance or a CIMClass).
|
1130 dave.sudlik 1.109
|
1131 kumpf 1.122 // First we need to create a new "temporary" XmlParser that is
1132 // just the value of the Embedded Object in String
1133 // representation.
1134 AutoArrayPtr<char> tmp_buffer(
|
1135 venkat.puvvada 1.141 new char[valueStringLen + 1]);
1136 memcpy(tmp_buffer.get(), valueString, valueStringLen + 1);
|
1137 kumpf 1.122 XmlParser tmp_parser(tmp_buffer.get());
1138
1139 // The next bit of logic constructs a CIMObject from the
1140 // Embedded Object String. It is similar to the method
1141 // XmlReader::getValueObjectElement().
1142 CIMInstance cimInstance;
1143 CIMClass cimClass;
1144
1145 if (XmlReader::getInstanceElement(tmp_parser, cimInstance))
1146 {
1147 if (type == CIMTYPE_INSTANCE)
1148 return CIMValue(cimInstance);
1149 x = CIMObject(cimInstance);
1150 }
1151 else if (XmlReader::getClassElement(tmp_parser, cimClass))
|
1152 a.dunfey 1.118 {
|
1153 kumpf 1.122 x = CIMObject(cimClass);
|
1154 a.dunfey 1.118 }
1155 else
1156 {
|
1157 kumpf 1.122 if (type == CIMTYPE_OBJECT)
1158 {
1159 // change "element" to "embedded object"
1160 MessageLoaderParms mlParms(
1161 "Common.XmlReader."
1162 "EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
1163 "Expected INSTANCE or CLASS element");
1164 throw XmlValidationError(lineNumber, mlParms);
1165 }
1166 else
1167 {
1168 // change "element" to "embedded object"
1169 MessageLoaderParms mlParms(
1170 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
1171 "Expected INSTANCE element");
1172 throw XmlValidationError(lineNumber, mlParms);
1173 }
|
1174 a.dunfey 1.118 }
|
1175 kumpf 1.122 // Ok, now we can delete the storage for the temporary
1176 // XmlParser.
1177 tmp_buffer.reset();
|
1178 dave.sudlik 1.109 }
|
1179 kumpf 1.122 return CIMValue(x);
|
1180 dave.sudlik 1.109 }
1181
|
1182 kumpf 1.122 default:
1183 break;
|
1184 mike 1.23 }
1185
|
1186 kumpf 1.122 MessageLoaderParms mlParms(
1187 "Common.XmlReader.MALFORMED_XML",
1188 "malformed XML");
|
1189 humberto 1.85 throw XmlSemanticError(lineNumber, mlParms);
1190
|
1191 mike 1.23 return false;
1192 }
1193
1194 //------------------------------------------------------------------------------
1195 //
|
1196 kumpf 1.95 // skipElement()
1197 //
1198 //------------------------------------------------------------------------------
1199 void XmlReader::skipElement(
1200 XmlParser& parser,
1201 XmlEntry& entry)
1202 {
1203 const char * tag_name = entry.text;
1204
1205 if (entry.type == XmlEntry::EMPTY_TAG)
1206 {
|
1207 kumpf 1.122 return;
|
1208 kumpf 1.95 }
1209
1210 while (testStartTagOrEmptyTag(parser, entry))
1211 {
|
1212 kumpf 1.122 skipElement(parser, entry);
|
1213 kumpf 1.95 }
1214
1215 if (testContentOrCData(parser, entry))
1216 {
1217 ; // skip
1218 }
1219
1220 expectEndTag(parser, tag_name);
1221 return;
1222 }
1223
1224 //------------------------------------------------------------------------------
1225 //
|
1226 mike 1.23 // getValueElement()
1227 //
1228 // <!ELEMENT VALUE (#PCDATA)>
1229 //
|
1230 karl 1.35 // Return: false if no value element.
1231 //
|
1232 mike 1.23 //------------------------------------------------------------------------------
1233
1234 Boolean XmlReader::getValueElement(
|
1235 kumpf 1.122 XmlParser& parser,
1236 CIMType type,
|
1237 mike 1.23 CIMValue& value)
1238 {
|
1239 karl 1.35 // Get VALUE start tag: Return false if no VALUE start Tag
|
1240 mike 1.23
1241 XmlEntry entry;
1242 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
|
1243 dave.sudlik 1.111 {
|
1244 kumpf 1.122 return false;
|
1245 dave.sudlik 1.111 }
|
1246 mike 1.23
1247 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1248
|
1249 dave.sudlik 1.111 const char* valueString = "";
|
1250 venkat.puvvada 1.141 Uint32 valueStringLen = 0;
|
1251 dave.sudlik 1.111 if (!empty)
|
1252 mike 1.23 {
|
1253 dave.sudlik 1.111 if (testContentOrCData(parser, entry))
|
1254 dave.sudlik 1.109 {
1255 valueString = entry.text;
|
1256 venkat.puvvada 1.141 valueStringLen = entry.textLen;
|
1257 dave.sudlik 1.111 }
|
1258 mike 1.23
|
1259 dave.sudlik 1.109 expectEndTag(parser, "VALUE");
|
1260 mike 1.23 }
|
1261 dave.sudlik 1.111 #ifdef PEGASUS_SNIA_INTEROP_TEST
1262 // KS 20021004 - tries to put value in even if empty.
1263 // Think this is general problem with empty value
1264 // Need to check meaning of (#PCDATA) - Does it allow empty.
1265 // Bugzilla tbd
1266 if (!empty)
1267 #endif
|
1268 venkat.puvvada 1.141 value = stringToValue(
1269 parser.getLine(),
1270 valueString,
1271 valueStringLen,
1272 type);
|
1273 kumpf 1.122
|
1274 mike 1.23 return true;
1275 }
1276
1277 //------------------------------------------------------------------------------
1278 //
1279 // getStringValueElement()
1280 //
1281 // <!ELEMENT VALUE (#PCDATA)>
1282 //
1283 //------------------------------------------------------------------------------
1284
1285 Boolean XmlReader::getStringValueElement(
|
1286 kumpf 1.122 XmlParser& parser,
|
1287 mike 1.23 String& str,
1288 Boolean required)
1289 {
1290 XmlEntry entry;
1291
1292 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
1293 {
|
1294 kumpf 1.122 if (required)
1295 {
1296 MessageLoaderParms mlParms(
1297 "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
1298 "Expected VALUE element");
1299 throw XmlValidationError(parser.getLine(), mlParms);
1300 }
1301 return false;
|
1302 mike 1.23 }
1303
1304 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1305
1306 const char* valueString = "";
|
1307 venkat.puvvada 1.141 Uint32 valueStringLen = 0;
|
1308 mike 1.23
1309 if (!empty)
1310 {
|
1311 kumpf 1.122 if (testContentOrCData(parser, entry))
|
1312 venkat.puvvada 1.141 {
|
1313 kumpf 1.122 valueString = entry.text;
|
1314 venkat.puvvada 1.141 valueStringLen = entry.textLen;
1315 }
|
1316 mike 1.23
|
1317 kumpf 1.122 expectEndTag(parser, "VALUE");
|
1318 mike 1.23 }
1319
|
1320 venkat.puvvada 1.141 str = String(valueString, valueStringLen);
|
1321 mike 1.23 return true;
1322 }
1323
1324 //----------------------------------------------------------------------------
1325 //
1326 // getPropertyValue
|
1327 kumpf 1.30 // Use: Decode property value from SetProperty request and
1328 // GetProperty response.
|
1329 mike 1.23 //
|
1330 kumpf 1.30 // PropertyValue is one of:
|
1331 mike 1.23 //
1332 //
|
1333 kumpf 1.122 // <!ELEMENT VALUE.ARRAY (VALUE*)>
|
1334 karl 1.33 //
|
1335 kumpf 1.122 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1336 kumpf 1.30 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1337 //
1338 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1339 mike 1.23 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
1340 //
|
1341 kumpf 1.30 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
1342 //
|
1343 mike 1.23 //----------------------------------------------------------------------------
1344 Boolean XmlReader::getPropertyValue(
|
1345 kumpf 1.122 XmlParser& parser,
|
1346 mike 1.23 CIMValue& cimValue)
1347 {
|
1348 kumpf 1.30 // Can not test for value type, so assume String
|
1349 kumpf 1.61 const CIMType type = CIMTYPE_STRING;
|
1350 mike 1.23
|
1351 kumpf 1.30 // Test for VALUE element
|
1352 mike 1.23 if (XmlReader::getValueElement(parser, type, cimValue))
1353 {
|
1354 kumpf 1.122 return true;
|
1355 mike 1.23 }
1356
|
1357 kumpf 1.30 // Test for VALUE.ARRAY element
1358 if (XmlReader::getValueArrayElement(parser, type, cimValue))
1359 {
|
1360 mike 1.23 return true;
|
1361 kumpf 1.30 }
|
1362 mike 1.23
|
1363 kumpf 1.30 // Test for VALUE.REFERENCE element
|
1364 kumpf 1.54 CIMObjectPath reference;
|
1365 kumpf 1.30 if (XmlReader::getValueReferenceElement(parser, reference))
|
1366 mike 1.25 {
1367 cimValue.set(reference);
1368 return true;
1369 }
|
1370 mike 1.23
|
1371 kumpf 1.30 // Test for VALUE.REFARRAY element
1372 if (XmlReader::getValueReferenceArrayElement(parser, cimValue))
1373 {
1374 return true;
1375 }
1376
1377 return false;
|
1378 mike 1.23 }
1379
1380 //------------------------------------------------------------------------------
1381 //
1382 // stringArrayToValue()
1383 //
1384 //------------------------------------------------------------------------------
1385
1386 template<class T>
1387 CIMValue StringArrayToValueAux(
|
1388 kumpf 1.122 Uint32 lineNumber,
|
1389 venkat.puvvada 1.141 const Array<CharString>& stringArray,
|
1390 mike 1.23 CIMType type,
1391 T*)
1392 {
1393 Array<T> array;
1394
1395 for (Uint32 i = 0, n = stringArray.size(); i < n; i++)
1396 {
|
1397 kumpf 1.122 CIMValue value = XmlReader::stringToValue(
|
1398 venkat.puvvada 1.141 lineNumber,
1399 stringArray[i].value,
1400 stringArray[i].length,
1401 type);
|
1402 mike 1.23
|
1403 kumpf 1.122 T x;
1404 value.get(x);
1405 array.append(x);
|
1406 mike 1.23 }
1407
1408 return CIMValue(array);
1409 }
1410
1411 CIMValue XmlReader::stringArrayToValue(
|
1412 kumpf 1.122 Uint32 lineNumber,
|
1413 venkat.puvvada 1.141 const Array<const char*> &array,
1414 CIMType type)
1415 {
1416 Array<CharString> strArray;
1417
1418 for (Uint32 i = 0, n = array.size() ; i < n ; ++i)
1419 {
1420 strArray.append(CharString(array[i], strlen(array[i])));
1421 }
1422
1423 return _stringArrayToValue(lineNumber, strArray, type);
1424 }
1425
1426 CIMValue XmlReader::_stringArrayToValue(
1427 Uint32 lineNumber,
1428 const Array<CharString> &array,
|
1429 mike 1.23 CIMType type)
1430 {
1431 switch (type)
1432 {
|
1433 kumpf 1.122 case CIMTYPE_BOOLEAN:
1434 return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
|
1435 mike 1.23
|
1436 kumpf 1.122 case CIMTYPE_STRING:
1437 return StringArrayToValueAux(lineNumber, array, type, (String*)0);
|
1438 mike 1.23
|
1439 kumpf 1.122 case CIMTYPE_CHAR16:
1440 return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
|
1441 mike 1.23
|
1442 kumpf 1.122 case CIMTYPE_UINT8:
1443 return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
|
1444 mike 1.23
|
1445 kumpf 1.122 case CIMTYPE_UINT16:
1446 return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
|
1447 mike 1.23
|
1448 kumpf 1.122 case CIMTYPE_UINT32:
1449 return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
|
1450 mike 1.23
|
1451 kumpf 1.122 case CIMTYPE_UINT64:
1452 return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
|
1453 mike 1.23
|
1454 kumpf 1.122 case CIMTYPE_SINT8:
1455 return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
|
1456 mike 1.23
|
1457 kumpf 1.122 case CIMTYPE_SINT16:
1458 return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
|
1459 mike 1.23
|
1460 kumpf 1.122 case CIMTYPE_SINT32:
1461 return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
|
1462 mike 1.23
|
1463 kumpf 1.122 case CIMTYPE_SINT64:
1464 return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
|
1465 mike 1.23
|
1466 kumpf 1.122 case CIMTYPE_DATETIME:
1467 return StringArrayToValueAux(
1468 lineNumber, array, type, (CIMDateTime*)0);
|
1469 mike 1.23
|
1470 kumpf 1.122 case CIMTYPE_REAL32:
1471 return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
|
1472 mike 1.23
|
1473 kumpf 1.122 case CIMTYPE_REAL64:
1474 return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
|
1475 mike 1.23
|
1476 dave.sudlik 1.109 // PEP 194:
|
1477 kumpf 1.122 // Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but
1478 // just a Pegasus internal representation of an embedded object. However,
1479 // this case is used when decoding string representations of embedded objects.
1480 case CIMTYPE_OBJECT:
1481 return StringArrayToValueAux(
1482 lineNumber, array, type, (CIMObject*)0);
1483 case CIMTYPE_INSTANCE:
1484 return StringArrayToValueAux(
1485 lineNumber, array, type, (CIMInstance*)0);
1486 default:
1487 break;
|
1488 mike 1.23 }
1489
1490 // Unreachable:
1491 return CIMValue();
1492 }
1493
1494 //------------------------------------------------------------------------------
1495 //
1496 // getValueArrayElement()
1497 //
1498 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1499 //
|
1500 karl 1.35 // Return: Boolean. Returns false if there is no VALUE.ARRAY start element
1501 //
|
1502 mike 1.23 //------------------------------------------------------------------------------
1503
1504 Boolean XmlReader::getValueArrayElement(
|
1505 kumpf 1.122 XmlParser& parser,
1506 CIMType type,
|
1507 mike 1.23 CIMValue& value)
1508 {
|
1509 karl 1.35 // Clears any values from the Array. Assumes this is array CIMValue
|
1510 mike 1.23 value.clear();
1511
1512 // Get VALUE.ARRAY open tag:
1513
1514 XmlEntry entry;
|
1515 venkat.puvvada 1.141 Array<CharString> stringArray;
|
1516 mike 1.23
|
1517 karl 1.35 // If no VALUE.ARRAY start tag, return false
|
1518 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
|
1519 kumpf 1.122 return false;
|
1520 karl 1.33
|
1521 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
1522 {
|
1523 dave.sudlik 1.111 // For each VALUE element:
1524
1525 while (testStartTagOrEmptyTag(parser, entry, "VALUE"))
|
1526 dave.sudlik 1.109 {
|
1527 venkat.puvvada 1.141 // ATTN: NULL values in array will have VALUE.NULL subelement
1528 // See DSP0201 Version 2.3.0, Section 5.2.3.2
|
1529 dave.sudlik 1.111 if (entry.type == XmlEntry::EMPTY_TAG)
|
1530 dave.sudlik 1.109 {
|
1531 venkat.puvvada 1.141 stringArray.append(CharString("", 0));
|
1532 dave.sudlik 1.111 continue;
1533 }
|
1534 mike 1.23
|
1535 dave.sudlik 1.111 if (testContentOrCData(parser, entry))
|
1536 venkat.puvvada 1.141 {
1537 stringArray.append(CharString(entry.text, entry.textLen));
1538 }
|
1539 dave.sudlik 1.111 else
|
1540 venkat.puvvada 1.141 {
1541 stringArray.append(CharString("", 0));
1542 }
|
1543 dave.sudlik 1.111 expectEndTag(parser, "VALUE");
|
1544 dave.sudlik 1.109 }
|
1545 mike 1.23
|
1546 kumpf 1.32 expectEndTag(parser, "VALUE.ARRAY");
|
1547 mike 1.23 }
1548
|
1549 venkat.puvvada 1.141 value = _stringArrayToValue(parser.getLine(), stringArray, type);
|
1550 mike 1.23 return true;
1551 }
1552
1553 //------------------------------------------------------------------------------
1554 //
1555 // getFlavor()
1556 //
|
1557 kumpf 1.122 // <!ENTITY % QualifierFlavor
|
1558 mike 1.23 // "OVERRIDABLE (true|false) 'true'
1559 // TOSUBCLASS (true|false) 'true'
1560 // TOINSTANCE (true|false) 'false'
1561 // TRANSLATABLE (true|false) 'false'">
1562 //
1563 //------------------------------------------------------------------------------
1564
|
1565 kumpf 1.64 CIMFlavor XmlReader::getFlavor(
|
1566 kumpf 1.122 XmlEntry& entry,
1567 Uint32 lineNumber,
|
1568 mike 1.23 const char* tagName)
1569 {
1570 // Get QUALIFIER.OVERRIDABLE
1571
1572 Boolean overridable = getCimBooleanAttribute(
|
1573 kumpf 1.122 lineNumber, entry, tagName, "OVERRIDABLE", true, false);
|
1574 mike 1.23
1575 // Get QUALIFIER.TOSUBCLASS
1576
1577 Boolean toSubClass = getCimBooleanAttribute(
|
1578 kumpf 1.122 lineNumber, entry, tagName, "TOSUBCLASS", true, false);
|
1579 mike 1.23
1580 // Get QUALIFIER.TOINSTANCE
1581
1582 Boolean toInstance = getCimBooleanAttribute(
|
1583 kumpf 1.122 lineNumber, entry, tagName, "TOINSTANCE", false, false);
|
1584 mike 1.23
1585 // Get QUALIFIER.TRANSLATABLE
1586
1587 Boolean translatable = getCimBooleanAttribute(
|
1588 kumpf 1.122 lineNumber, entry, tagName, "TRANSLATABLE", false, false);
|
1589 mike 1.23
|
1590 kumpf 1.44 // Start with CIMFlavor::NONE. Defaults are specified in the
1591 // getCimBooleanAttribute() calls above.
|
1592 kumpf 1.64 CIMFlavor flavor = CIMFlavor (CIMFlavor::NONE);
|
1593 mike 1.23
1594 if (overridable)
|
1595 kumpf 1.64 flavor.addFlavor (CIMFlavor::OVERRIDABLE);
1596 else
1597 flavor.addFlavor (CIMFlavor::DISABLEOVERRIDE);
|
1598 mike 1.23
1599 if (toSubClass)
|
1600 kumpf 1.64 flavor.addFlavor (CIMFlavor::TOSUBCLASS);
1601 else
1602 flavor.addFlavor (CIMFlavor::RESTRICTED);
|
1603 mike 1.23
1604 if (toInstance)
|
1605 kumpf 1.64 flavor.addFlavor (CIMFlavor::TOINSTANCE);
|
1606 mike 1.23
1607 if (translatable)
|
1608 kumpf 1.64 flavor.addFlavor (CIMFlavor::TRANSLATABLE);
|
1609 mike 1.23
1610 return flavor;
1611 }
1612
1613 //------------------------------------------------------------------------------
1614 //
1615 // getOptionalScope()
1616 //
1617 // DTD:
1618 // <!ELEMENT SCOPE EMPTY>
|
1619 kumpf 1.122 // <!ATTLIST SCOPE
|
1620 mike 1.23 // CLASS (true|false) 'false'
1621 // ASSOCIATION (true|false) 'false'
1622 // REFERENCE (true|false) 'false'
1623 // PROPERTY (true|false) 'false'
1624 // METHOD (true|false) 'false'
1625 // PARAMETER (true|false) 'false'
1626 // INDICATION (true|false) 'false'>
1627 //
1628 //------------------------------------------------------------------------------
1629
|
1630 kumpf 1.63 CIMScope XmlReader::getOptionalScope(XmlParser& parser)
|
1631 mike 1.23 {
1632 XmlEntry entry;
|
1633 kumpf 1.65 CIMScope scope;
|
1634 mike 1.23
1635 if (!parser.next(entry))
|
1636 kumpf 1.122 return scope; // No SCOPE element found; return the empty scope
|
1637 mike 1.23
1638 Boolean isEmptyTag = entry.type == XmlEntry::EMPTY_TAG;
1639
|
1640 kumpf 1.122 if ((!isEmptyTag &&
1641 entry.type != XmlEntry::START_TAG) ||
1642 strcmp(entry.text, "SCOPE") != 0)
1643 {
1644 // No SCOPE element found; return the empty scope
1645 parser.putBack(entry);
1646 return scope;
|
1647 mike 1.23 }
1648
1649 Uint32 line = parser.getLine();
1650
1651 if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))
|
1652 kumpf 1.122 scope.addScope (CIMScope::CLASS);
|
1653 mike 1.23
1654 if (getCimBooleanAttribute(
|
1655 kumpf 1.122 line, entry, "SCOPE", "ASSOCIATION", false, false))
1656 scope.addScope (CIMScope::ASSOCIATION);
|
1657 mike 1.23
1658 if (getCimBooleanAttribute(
|
1659 kumpf 1.122 line, entry, "SCOPE", "REFERENCE", false, false))
1660 scope.addScope (CIMScope::REFERENCE);
|
1661 mike 1.23
1662 if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))
|
1663 kumpf 1.122 scope.addScope (CIMScope::PROPERTY);
|
1664 mike 1.23
1665 if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))
|
1666 kumpf 1.122 scope.addScope (CIMScope::METHOD);
|
1667 mike 1.23
1668 if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))
|
1669 kumpf 1.122 scope.addScope (CIMScope::PARAMETER);
|
1670 mike 1.23
1671 if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))
|
1672 kumpf 1.122 scope.addScope (CIMScope::INDICATION);
|
1673 mike 1.23
1674 if (!isEmptyTag)
|
1675 kumpf 1.122 expectEndTag(parser, "SCOPE");
|
1676 mike 1.23
1677 return scope;
1678 }
1679
1680 //------------------------------------------------------------------------------
1681 //
1682 // getQualifierElement()
1683 //
|
1684 kumpf 1.52 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>
|
1685 mike 1.23 // <!ATTLIST QUALIFIER
1686 // %CIMName;
1687 // %CIMType; #REQUIRED
1688 // %Propagated;
1689 // %QualifierFlavor;>
1690 //
1691 //------------------------------------------------------------------------------
1692
1693 Boolean XmlReader::getQualifierElement(
|
1694 kumpf 1.122 XmlParser& parser,
|
1695 mike 1.23 CIMQualifier& qualifier)
1696 {
1697 // Get QUALIFIER element:
1698
1699 XmlEntry entry;
|
1700 kumpf 1.103 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER"))
|
1701 kumpf 1.122 return false;
|
1702 mike 1.23
|
1703 kumpf 1.103 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1704
|
1705 mike 1.23 // Get QUALIFIER.NAME attribute:
1706
|
1707 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
|
1708 mike 1.23
1709 // Get QUALIFIER.TYPE attribute:
1710
|
1711 kumpf 1.67 CIMType type;
1712 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER");
|
1713 mike 1.23
1714 // Get QUALIFIER.PROPAGATED
1715
1716 Boolean propagated = getCimBooleanAttribute(
|
1717 kumpf 1.122 parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
|
1718 mike 1.23
1719 // Get flavor oriented attributes:
1720
|
1721 kumpf 1.64 CIMFlavor flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");
|
1722 mike 1.23
1723 // Get VALUE or VALUE.ARRAY element:
1724
1725 CIMValue value;
1726
|
1727 kumpf 1.103 if (empty)
|
1728 mike 1.23 {
|
1729 kumpf 1.52 value.setNullValue(type, false);
|
1730 mike 1.23 }
|
1731 kumpf 1.103 else
1732 {
1733 if (!getValueElement(parser, type, value) &&
|
1734 kumpf 1.122 !getValueArrayElement(parser, type, value))
|
1735 kumpf 1.103 {
1736 value.setNullValue(type, false);
1737 }
|
1738 mike 1.23
|
1739 kumpf 1.103 // Expect </QUALIFIER>:
|
1740 mike 1.23
|
1741 kumpf 1.103 expectEndTag(parser, "QUALIFIER");
1742 }
|
1743 mike 1.23
1744 // Build qualifier:
1745
1746 qualifier = CIMQualifier(name, value, flavor, propagated);
1747 return true;
1748 }
1749
1750 //------------------------------------------------------------------------------
1751 //
1752 // getQualifierElements()
1753 //
1754 //------------------------------------------------------------------------------
1755
1756 template<class CONTAINER>
1757 void getQualifierElements(XmlParser& parser, CONTAINER& container)
1758 {
1759 CIMQualifier qualifier;
1760
1761 while (XmlReader::getQualifierElement(parser, qualifier))
1762 {
|
1763 kumpf 1.122 try
1764 {
1765 container.addQualifier(qualifier);
1766 }
1767 catch (AlreadyExistsException&)
1768 {
1769 MessageLoaderParms mlParms(
1770 "Common.XmlReader.DUPLICATE_QUALIFIER",
1771 "duplicate qualifier");
1772 throw XmlSemanticError(parser.getLine(), mlParms);
1773 }
|
1774 mike 1.23 }
1775 }
1776
1777 //------------------------------------------------------------------------------
1778 //
1779 // getPropertyElement()
1780 //
1781 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
1782 // <!ATTLIST PROPERTY
1783 // %CIMName;
1784 // %ClassOrigin;
1785 // %Propagated;
|
1786 dave.sudlik 1.109 // %EmbeddedObject; #IMPLIED
|
1787 mike 1.23 // %CIMType; #REQUIRED>
1788 //
1789 //------------------------------------------------------------------------------
1790
1791 Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)
1792 {
1793 XmlEntry entry;
1794
1795 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY"))
|
1796 kumpf 1.122 return false;
|
1797 mike 1.23
1798 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1799
1800 // Get PROPERTY.NAME attribute:
1801
|
1802 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
|
1803 mike 1.23
1804 // Get PROPERTY.CLASSORIGIN attribute:
1805
|
1806 kumpf 1.122 CIMName classOrigin =
1807 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
|
1808 mike 1.23
1809 // Get PROPERTY.PROPAGATED
1810
1811 Boolean propagated = getCimBooleanAttribute(
|
1812 kumpf 1.122 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
|
1813 mike 1.23
|
1814 karl 1.129 // Get PROPERTY.EmbeddedObject attribute:
|
1815 dave.sudlik 1.109
|
1816 kumpf 1.139 EmbeddedObjectAttributeType embeddedObject =
|
1817 thilo.boehm 1.131 getEmbeddedObjectAttribute(parser.getLine(), entry, "PROPERTY");
|
1818 dave.sudlik 1.109
|
1819 mike 1.23 // Get PROPERTY.TYPE attribute:
1820
|
1821 kumpf 1.67 CIMType type;
1822 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
|
1823 mike 1.23
|
1824 karl 1.35 // Create property: Sets type and !isarray
|
1825 mike 1.23
|
1826 kumpf 1.56 CIMValue value(type, false);
|
1827 kumpf 1.62 property = CIMProperty(name, value, 0, CIMName(), classOrigin, propagated);
|
1828 mike 1.23
1829 if (!empty)
1830 {
|
1831 kumpf 1.122 // Get qualifiers. We need to do this before checking for the
1832 // property as an embedded object, because we need to also check
1833 // for the EmbeddedObject qualifier.
1834 getQualifierElements(parser, property);
|
1835 dave.sudlik 1.109 }
|
1836 mike 1.23
|
1837 dave.sudlik 1.110 Boolean embeddedObjectQualifierValue = false;
|
1838 thilo.boehm 1.131 Uint32 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT);
|
1839 dave.sudlik 1.110 if (ix != PEG_NOT_FOUND)
1840 {
1841 property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);
1842 }
|
1843 a.dunfey 1.118 String embeddedInstanceQualifierValue;
|
1844 thilo.boehm 1.131 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);
|
1845 a.dunfey 1.118 if (ix != PEG_NOT_FOUND)
1846 {
|
1847 kumpf 1.122 property.getQualifier(ix).getValue().get(
1848 embeddedInstanceQualifierValue);
|
1849 a.dunfey 1.118 }
|
1850 karl 1.129 // If the EmbeddedObject attribute is present with value "object"
|
1851 dave.sudlik 1.110 // or the EmbeddedObject qualifier exists on this property with value "true"
|
1852 karl 1.129 // then convert the EmbeddedObject-encoded string into a CIMObject
|
1853 thilo.boehm 1.131 Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||
|
1854 kumpf 1.122 embeddedObjectQualifierValue;
|
1855 thilo.boehm 1.131 Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||
|
1856 kumpf 1.122 embeddedInstanceQualifierValue.size() > 0;
|
1857 a.dunfey 1.118 if (isEmbeddedObject || isEmbeddedInstance)
1858 {
|
1859 karl 1.129 // The EmbeddedObject attribute is only valid on Properties of type
|
1860 kumpf 1.122 // string
|
1861 a.dunfey 1.118 if (type == CIMTYPE_STRING)
1862 {
|
1863 kumpf 1.122 if (isEmbeddedObject)
1864 type = CIMTYPE_OBJECT;
|
1865 a.dunfey 1.118 else
|
1866 kumpf 1.122 type = CIMTYPE_INSTANCE;
|
1867 a.dunfey 1.118 CIMValue new_value(type, false);
|
1868 kumpf 1.122 CIMProperty new_property = CIMProperty(
1869 name, new_value, 0, CIMName(), classOrigin, propagated);
1870
1871 // Copy the qualifiers from the String property to the CIMObject
1872 // property.
|
1873 kumpf 1.130 for (Uint32 i = 0; i < property.getQualifierCount(); ++i)
|
1874 a.dunfey 1.118 {
|
1875 kumpf 1.122 // All properties are copied, including the EmbeddedObject
1876 // qualifier. This way we don't have to keep track to know
1877 // that the EmbeddedObject qualifier needs to be added back
1878 // during the encode step.
|
1879 kumpf 1.130 new_property.addQualifier(property.getQualifier(i));
|
1880 a.dunfey 1.118 }
1881
1882 value = new_value;
1883 property = new_property;
1884 }
1885 else
1886 {
|
1887 kumpf 1.122 MessageLoaderParms mlParms(
1888 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
1889 karl 1.129 "The EmbeddedObject attribute is only valid on string types.");
|
1890 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
1891 }
1892 }
|
1893 dave.sudlik 1.109 // Continue on to get property value, if not empty.
1894 if (!empty)
1895 {
1896 if (getValueElement(parser, type, value))
1897 property.setValue(value);
1898 expectEndTag(parser, "PROPERTY");
|
1899 mike 1.23 }
1900
1901 return true;
1902 }
1903
1904 //------------------------------------------------------------------------------
1905 //
1906 // getArraySizeAttribute()
1907 //
1908 // Returns true if able to get array-size. Note that array size will
1909 // always be a positive integer.
1910 //
1911 // <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">
1912 //
1913 //------------------------------------------------------------------------------
1914
1915 Boolean XmlReader::getArraySizeAttribute(
1916 Uint32 lineNumber,
1917 const XmlEntry& entry,
1918 const char* tagName,
1919 Uint32& value)
1920 mike 1.23 {
1921 const char* tmp;
1922
1923 if (!entry.getAttributeValue("ARRAYSIZE", tmp))
|
1924 kumpf 1.122 return false;
|
1925 mike 1.23
1926 Uint64 arraySize;
1927
|
1928 kumpf 1.126 if (!stringToUnsignedInteger(tmp, arraySize) || (arraySize == 0) ||
1929 !StringConversion::checkUintBounds(arraySize, CIMTYPE_UINT32))
|
1930 mike 1.23 {
|
1931 kumpf 1.122 char message[128];
1932 sprintf(message, "%s.%s", tagName, "ARRAYSIZE");
1933
1934 MessageLoaderParms mlParms(
1935 "Common.XmlReader.ILLEGAL_VALUE",
1936 "Illegal value for $0",
1937 message);
1938 throw XmlSemanticError(lineNumber, mlParms);
|
1939 mike 1.23 }
1940
1941 value = Uint32(arraySize);
1942 return true;
1943 }
1944
1945 //------------------------------------------------------------------------------
1946 //
1947 // getPropertyArrayElement()
1948 //
1949 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
1950 // <!ATTLIST PROPERTY.ARRAY
1951 // %CIMName;
1952 // %CIMType; #REQUIRED
1953 // %ArraySize;
1954 // %ClassOrigin;
|
1955 dave.sudlik 1.109 // %Propagated;
1956 // %EmbeddedObject; #IMPLIED>
|
1957 mike 1.23 //
1958 //------------------------------------------------------------------------------
1959
1960 Boolean XmlReader::getPropertyArrayElement(
|
1961 kumpf 1.122 XmlParser& parser,
|
1962 mike 1.23 CIMProperty& property)
1963 {
1964 // Get PROPERTY element:
1965
1966 XmlEntry entry;
1967
1968 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.ARRAY"))
|
1969 kumpf 1.122 return false;
|
1970 mike 1.23
1971 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1972
1973 // Get PROPERTY.NAME attribute:
1974
|
1975 kumpf 1.122 CIMName name =
1976 getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
|
1977 mike 1.23
1978 // Get PROPERTY.TYPE attribute:
1979
|
1980 kumpf 1.67 CIMType type;
1981 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY.ARRAY");
|
1982 mike 1.23
1983 // Get PROPERTY.ARRAYSIZE attribute:
1984
1985 Uint32 arraySize = 0;
1986 getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);
1987
1988 // Get PROPERTY.CLASSORIGIN attribute:
1989
|
1990 kumpf 1.122 CIMName classOrigin =
1991 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
|
1992 mike 1.23
1993 // Get PROPERTY.ARRAY.PROPAGATED
1994
|
1995 kumpf 1.122 Boolean propagated = getCimBooleanAttribute(
1996 parser.getLine(),
1997 entry,
1998 "PROPERTY.ARRAY",
1999 "PROPAGATED",
2000 false,
2001 false);
|
2002 dave.sudlik 1.109
|
2003 karl 1.129 // Get PROPERTY.EmbeddedObject attribute:
|
2004 dave.sudlik 1.109
|
2005 thilo.boehm 1.131 EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(
|
2006 kumpf 1.122 parser.getLine(), entry, "PROPERTY.ARRAY");
|
2007 mike 1.23
2008 // Create property:
2009
|
2010 kumpf 1.56 CIMValue value(type, true, arraySize);
|
2011 kumpf 1.122 property = CIMProperty(
2012 name, value, arraySize, CIMName(), classOrigin, propagated);
|
2013 mike 1.23
2014 if (!empty)
2015 {
|
2016 dave.sudlik 1.109 // Get qualifiers:
2017 getQualifierElements(parser, property);
2018 }
|
2019 mike 1.23
|
2020 dave.sudlik 1.110 Boolean embeddedObjectQualifierValue = false;
|
2021 thilo.boehm 1.131 Uint32 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT);
|
2022 dave.sudlik 1.110 if (ix != PEG_NOT_FOUND)
2023 {
2024 property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);
2025 }
|
2026 a.dunfey 1.118 String embeddedInstanceQualifierValue;
|
2027 thilo.boehm 1.131 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);
|
2028 a.dunfey 1.118 if (ix != PEG_NOT_FOUND)
2029 {
|
2030 kumpf 1.122 property.getQualifier(ix).getValue().get(
2031 embeddedInstanceQualifierValue);
|
2032 a.dunfey 1.118 }
|
2033 karl 1.129 // If the EmbeddedObject attribute is present with value "object"
|
2034 dave.sudlik 1.110 // or the EmbeddedObject qualifier exists on this property with value "true"
|
2035 dave.sudlik 1.109 // then
2036 // Convert the EmbeddedObject-encoded string into a CIMObject
|
2037 thilo.boehm 1.131 Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||
|
2038 kumpf 1.122 embeddedObjectQualifierValue;
|
2039 thilo.boehm 1.131 Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||
|
2040 kumpf 1.122 embeddedInstanceQualifierValue.size() > 0;
|
2041 a.dunfey 1.118 if (isEmbeddedObject || isEmbeddedInstance)
2042 {
|
2043 karl 1.129 // The EmbeddedObject attribute is only valid on Properties of type
|
2044 kumpf 1.122 // string
|
2045 a.dunfey 1.118 if (type == CIMTYPE_STRING)
2046 {
|
2047 kumpf 1.122 if (isEmbeddedObject)
2048 type = CIMTYPE_OBJECT;
|
2049 a.dunfey 1.118 else
|
2050 kumpf 1.122 type = CIMTYPE_INSTANCE;
|
2051 a.dunfey 1.118 CIMValue new_value(type, true, arraySize);
|
2052 kumpf 1.122 CIMProperty new_property = CIMProperty(
2053 name, new_value, arraySize, CIMName(), classOrigin, propagated);
2054
2055 // Copy the qualifiers from the String property to the CIMObject
2056 // property.
|
2057 kumpf 1.130 for (Uint32 i = 0; i < property.getQualifierCount(); ++i)
|
2058 a.dunfey 1.118 {
|
2059 kumpf 1.122 // All properties are copied, including the EmbeddedObject
2060 // qualifier. This way we don't have to keep track to know
2061 // that the EmbeddedObject qualifier needs to be added back
2062 // during the encode step.
|
2063 kumpf 1.130 new_property.addQualifier(property.getQualifier(i));
|
2064 a.dunfey 1.118 }
|
2065 kumpf 1.122
|
2066 a.dunfey 1.118 value = new_value;
2067 property = new_property;
2068 }
2069 else
2070 {
|
2071 kumpf 1.122 MessageLoaderParms mlParms(
2072 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
2073 karl 1.129 "The EmbeddedObject attribute is only valid on string types.");
|
2074 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
2075 }
2076 }
|
2077 dave.sudlik 1.109 // Continue on to get property array value, if not empty.
2078 // Else not an embedded object, if not empty, get the property array value.
2079 if (!empty)
2080 {
2081 if (getValueArrayElement(parser, type, value))
2082 {
2083 if (arraySize && arraySize != value.getArraySize())
2084 {
|
2085 kumpf 1.122 MessageLoaderParms mlParms(
2086 "Common.XmlReader.ARRAY_SIZE_DIFFERENT",
2087 "ARRAYSIZE attribute and value-array size are different");
2088 throw XmlSemanticError(parser.getLine(), mlParms);
|
2089 dave.sudlik 1.109 }
|
2090 mike 1.23
|
2091 dave.sudlik 1.109 property.setValue(value);
2092 }
2093 expectEndTag(parser, "PROPERTY.ARRAY");
|
2094 mike 1.23 }
|
2095 kumpf 1.122
|
2096 mike 1.23 return true;
2097 }
2098
2099 //------------------------------------------------------------------------------
2100 //
2101 // getHostElement()
2102 //
2103 // <!ELEMENT HOST (#PCDATA)>
2104 //
2105 //------------------------------------------------------------------------------
2106
2107 Boolean XmlReader::getHostElement(
2108 XmlParser& parser,
2109 String& host)
2110 {
2111 XmlEntry entry;
2112
2113 if (!testStartTag(parser, entry, "HOST"))
|
2114 kumpf 1.122 return false;
|
2115 karl 1.78 #ifdef PEGASUS_SNIA_INTEROP_TEST
2116 // Temp code to allow empty HOST field.
2117 // SNIA CIMOMs return empty field particularly on enumerateinstance.
2118 // Simply substitute a string for the empty.
|
2119 kumpf 1.122 if (!parser.next(entry))
2120 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
|
2121 karl 1.78
|
2122 kumpf 1.122 if (entry.type == XmlEntry::CONTENT)
2123 host = String(entry.text);
2124 else
|
2125 karl 1.78 {
|
2126 kumpf 1.122 parser.putBack(entry);
|
2127 karl 1.78 host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT";
2128 }
2129
2130 #else
|
2131 mike 1.23
2132 if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
2133 {
|
2134 kumpf 1.122 MessageLoaderParms mlParms(
2135 "Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
2136 "expected content of HOST element");
2137 throw XmlValidationError(parser.getLine(), mlParms);
|
2138 mike 1.23 }
2139
|
2140 chuck 1.98 host = String(entry.text);
|
2141 karl 1.78 #endif
|
2142 mike 1.23 expectEndTag(parser, "HOST");
2143 return true;
2144 }
2145
2146 //------------------------------------------------------------------------------
2147 //
2148 // getNameSpaceElement()
|
2149 kumpf 1.122 //
|
2150 mike 1.23 // <!ELEMENT NAMESPACE EMPTY>
2151 // <!ATTLIST NAMESPACE %CIMName;>
2152 //
2153 //------------------------------------------------------------------------------
2154
2155 Boolean XmlReader::getNameSpaceElement(
2156 XmlParser& parser,
|
2157 kumpf 1.74 CIMName& nameSpaceComponent)
|
2158 mike 1.23 {
2159 XmlEntry entry;
2160
2161 if (!testStartTagOrEmptyTag(parser, entry, "NAMESPACE"))
|
2162 kumpf 1.122 return false;
|
2163 mike 1.23
2164 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2165
2166 nameSpaceComponent = getCimNameAttribute(
|
2167 kumpf 1.122 parser.getLine(), entry, "NAMESPACE");
|
2168 mike 1.23
2169 if (!empty)
|
2170 kumpf 1.122 expectEndTag(parser, "NAMESPACE");
|
2171 mike 1.23
2172 return true;
2173 }
2174
2175 //------------------------------------------------------------------------------
2176 //
2177 // getLocalNameSpacePathElement()
|
2178 kumpf 1.122 //
|
2179 mike 1.23 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
2180 //
2181 //------------------------------------------------------------------------------
2182
2183 Boolean XmlReader::getLocalNameSpacePathElement(
2184 XmlParser& parser,
2185 String& nameSpace)
2186 {
2187 XmlEntry entry;
2188
2189 if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
|
2190 kumpf 1.122 return false;
|
2191 mike 1.23
|
2192 kumpf 1.74 CIMName nameSpaceComponent;
|
2193 mike 1.23
2194 while (getNameSpaceElement(parser, nameSpaceComponent))
2195 {
|
2196 kumpf 1.122 if (nameSpace.size())
2197 nameSpace.append('/');
|
2198 mike 1.23
|
2199 kumpf 1.122 nameSpace.append(nameSpaceComponent.getString());
|
2200 mike 1.23 }
2201
2202 if (!nameSpace.size())
2203 {
|
2204 kumpf 1.122 MessageLoaderParms mlParms(
2205 "Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
2206 "Expected one or more NAMESPACE elements within "
2207 "LOCALNAMESPACEPATH element");
2208 throw XmlValidationError(parser.getLine(), mlParms);
|
2209 mike 1.23 }
2210
2211 expectEndTag(parser, "LOCALNAMESPACEPATH");
2212 return true;
2213 }
2214
2215 //------------------------------------------------------------------------------
2216 //
2217 // getNameSpacePathElement()
2218 //
2219 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
2220 //
2221 //------------------------------------------------------------------------------
2222
2223 Boolean XmlReader::getNameSpacePathElement(
2224 XmlParser& parser,
2225 String& host,
2226 String& nameSpace)
2227 {
2228 host.clear();
2229 nameSpace.clear();
2230 mike 1.23
2231 XmlEntry entry;
2232
2233 if (!testStartTag(parser, entry, "NAMESPACEPATH"))
|
2234 kumpf 1.122 return false;
|
2235 mike 1.23
|
2236 kumpf 1.122 if (!getHostElement(parser, host))
2237 {
2238 MessageLoaderParms mlParms(
2239 "Common.XmlReader.EXPECTED_HOST_ELEMENT",
2240 "expected HOST element");
2241 throw XmlValidationError(parser.getLine(), mlParms);
|
2242 humberto 1.85 }
|
2243 mike 1.23
2244 if (!getLocalNameSpacePathElement(parser, nameSpace))
2245 {
|
2246 kumpf 1.122 MessageLoaderParms mlParms(
2247 "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2248 "expected LOCALNAMESPACEPATH element");
2249 throw XmlValidationError(parser.getLine(), mlParms);
|
2250 mike 1.23 }
2251
2252 expectEndTag(parser, "NAMESPACEPATH");
2253
2254 return true;
2255 }
2256
2257 //------------------------------------------------------------------------------
2258 //
2259 // getClassNameElement()
2260 //
2261 // <!ELEMENT CLASSNAME EMPTY>
2262 // <!ATTLIST CLASSNAME %CIMName;>
2263 //
2264 //------------------------------------------------------------------------------
2265
2266 Boolean XmlReader::getClassNameElement(
2267 XmlParser& parser,
|
2268 kumpf 1.74 CIMName& className,
|
2269 mike 1.23 Boolean required)
2270 {
2271 XmlEntry entry;
2272
2273 if (!testStartTagOrEmptyTag(parser, entry, "CLASSNAME"))
2274 {
|
2275 kumpf 1.122 if (required)
2276 {
2277 MessageLoaderParms mlParms(
2278 "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2279 "expected CLASSNAME element");
2280 throw XmlValidationError(parser.getLine(), mlParms);
2281 }
2282 else
2283 return false;
|
2284 mike 1.23 }
2285 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2286
2287 className = getCimNameAttribute(
|
2288 kumpf 1.122 parser.getLine(), entry, "CLASSNAME", false);
|
2289 mike 1.23
2290 if (!empty)
|
2291 kumpf 1.122 expectEndTag(parser, "CLASSNAME");
|
2292 mike 1.23
2293 return true;
2294 }
2295
2296 //------------------------------------------------------------------------------
2297 //
2298 // getValueTypeAttribute()
2299 //
2300 // VALUETYPE (string|boolean|numeric) 'string'
2301 //
2302 //------------------------------------------------------------------------------
2303
|
2304 kumpf 1.73 CIMKeyBinding::Type XmlReader::getValueTypeAttribute(
|
2305 kumpf 1.122 Uint32 lineNumber,
|
2306 mike 1.23 const XmlEntry& entry,
2307 const char* elementName)
2308 {
|
2309 thilo.boehm 1.131 const char* tmp;
|
2310 mike 1.23
2311 if (!entry.getAttributeValue("VALUETYPE", tmp))
|
2312 kumpf 1.122 return CIMKeyBinding::STRING;
|
2313 mike 1.23
|
2314 thilo.boehm 1.131 if (strcmp(tmp, "string") == 0)
|
2315 kumpf 1.122 return CIMKeyBinding::STRING;
|
2316 thilo.boehm 1.131 else if (strcmp(tmp, "boolean") == 0)
|
2317 kumpf 1.122 return CIMKeyBinding::BOOLEAN;
|
2318 thilo.boehm 1.131 else if (strcmp(tmp, "numeric") == 0)
|
2319 kumpf 1.122 return CIMKeyBinding::NUMERIC;
|
2320 humberto 1.85
|
2321 mike 1.23 char buffer[MESSAGE_SIZE];
|
2322 humberto 1.85 sprintf(buffer, "%s.VALUETYPE", elementName);
|
2323 kumpf 1.122
2324 MessageLoaderParms mlParms(
2325 "Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
2326 "Illegal value for $0 attribute; CIMValue must be one of \"string\", "
2327 "\"boolean\", or \"numeric\"",
2328 buffer);
|
2329 humberto 1.85 throw XmlSemanticError(lineNumber, mlParms);
|
2330 mike 1.23
|
2331 kumpf 1.73 return CIMKeyBinding::BOOLEAN;
|
2332 mike 1.23 }
2333
2334 //------------------------------------------------------------------------------
2335 //
2336 // getKeyValueElement()
2337 //
2338 // <!ELEMENT KEYVALUE (#PCDATA)>
2339 // <!ATTLIST KEYVALUE
2340 // VALUETYPE (string|boolean|numeric) 'string'>
2341 //
2342 //------------------------------------------------------------------------------
2343
2344 Boolean XmlReader::getKeyValueElement(
2345 XmlParser& parser,
|
2346 kumpf 1.73 CIMKeyBinding::Type& type,
|
2347 mike 1.23 String& value)
2348 {
2349 XmlEntry entry;
2350
2351 if (!testStartTagOrEmptyTag(parser, entry, "KEYVALUE"))
|
2352 kumpf 1.122 return false;
|
2353 mike 1.23
2354 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2355
2356 type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");
2357
2358 value.clear();
2359
2360 if (!empty)
2361 {
|
2362 kumpf 1.122 if (!parser.next(entry))
2363 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
|
2364 mike 1.23
|
2365 kumpf 1.122 if (entry.type == XmlEntry::CONTENT)
2366 value = String(entry.text);
2367 else
2368 parser.putBack(entry);
|
2369 mike 1.23
|
2370 kumpf 1.122 expectEndTag(parser, "KEYVALUE");
|
2371 mike 1.23 }
2372
2373 return true;
2374 }
2375
2376 //------------------------------------------------------------------------------
2377 //
2378 // getKeyBindingElement()
2379 //
2380 // <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
2381 // <!ATTLIST KEYBINDING
2382 // %CIMName;>
2383 //
2384 //------------------------------------------------------------------------------
2385
2386 Boolean XmlReader::getKeyBindingElement(
2387 XmlParser& parser,
|
2388 kumpf 1.74 CIMName& name,
|
2389 mike 1.23 String& value,
|
2390 kumpf 1.73 CIMKeyBinding::Type& type)
|
2391 mike 1.23 {
2392 XmlEntry entry;
2393
2394 if (!testStartTag(parser, entry, "KEYBINDING"))
|
2395 kumpf 1.122 return false;
|
2396 mike 1.23
2397 name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");
2398
2399 if (!getKeyValueElement(parser, type, value))
|
2400 mike 1.25 {
|
2401 kumpf 1.54 CIMObjectPath reference;
|
2402 mike 1.25
2403 if (!getValueReferenceElement(parser, reference))
2404 {
|
2405 kumpf 1.122 MessageLoaderParms mlParms(
2406 "Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",
2407 "Expected KEYVALUE or VALUE.REFERENCE element");
2408 throw XmlValidationError(parser.getLine(), mlParms);
|
2409 mike 1.25 }
2410
|
2411 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2412 mike 1.25 value = reference.toString();
2413 }
|
2414 mike 1.23
2415 expectEndTag(parser, "KEYBINDING");
2416 return true;
2417 }
2418
2419 //------------------------------------------------------------------------------
2420 //
2421 // getInstanceNameElement()
2422 //
2423 // <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
2424 // <!ATTLIST INSTANCENAME
2425 // %ClassName;>
2426 //
|
2427 mike 1.25 // Note: An empty key name is used in the keyBinding when the INSTANCENAME is
2428 // specified using a KEYVALUE or a VALUE.REFERENCE.
|
2429 mike 1.23 //
2430 //------------------------------------------------------------------------------
2431
2432 Boolean XmlReader::getInstanceNameElement(
2433 XmlParser& parser,
2434 String& className,
|
2435 kumpf 1.73 Array<CIMKeyBinding>& keyBindings)
|
2436 mike 1.23 {
2437 className.clear();
2438 keyBindings.clear();
2439
2440 XmlEntry entry;
2441
2442 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCENAME"))
|
2443 kumpf 1.122 return false;
|
2444 mike 1.23
2445 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2446
2447 className = getClassNameAttribute(parser.getLine(), entry, "INSTANCENAME");
2448
|
2449 mike 1.25 if (empty)
|
2450 mike 1.23 {
|
2451 mike 1.25 return true;
2452 }
|
2453 mike 1.23
|
2454 kumpf 1.74 CIMName name;
|
2455 kumpf 1.73 CIMKeyBinding::Type type;
|
2456 mike 1.25 String value;
|
2457 kumpf 1.54 CIMObjectPath reference;
|
2458 mike 1.25
2459 if (getKeyValueElement(parser, type, value))
2460 {
2461 // Use empty key name because none was specified
|
2462 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2463 mike 1.25 }
2464 else if (getValueReferenceElement(parser, reference))
2465 {
2466 // Use empty key name because none was specified
|
2467 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2468 mike 1.25 value = reference.toString();
|
2469 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2470 mike 1.25 }
2471 else
2472 {
|
2473 kumpf 1.122 while (getKeyBindingElement(parser, name, value, type))
2474 keyBindings.append(CIMKeyBinding(name, value, type));
|
2475 mike 1.25 }
|
2476 mike 1.23
|
2477 mike 1.25 expectEndTag(parser, "INSTANCENAME");
|
2478 mike 1.23
2479 return true;
2480 }
2481
2482 Boolean XmlReader::getInstanceNameElement(
2483 XmlParser& parser,
|
2484 kumpf 1.54 CIMObjectPath& instanceName)
|
2485 mike 1.23 {
2486 String className;
|
2487 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2488 mike 1.23
2489 if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
|
2490 kumpf 1.122 return false;
|
2491 mike 1.23
|
2492 kumpf 1.62 instanceName.set(String(), CIMNamespaceName(), className, keyBindings);
|
2493 mike 1.23 return true;
2494 }
2495
2496 //------------------------------------------------------------------------------
2497 //
2498 // getInstancePathElement()
2499 //
2500 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2501 //
2502 //------------------------------------------------------------------------------
2503
2504 Boolean XmlReader::getInstancePathElement(
2505 XmlParser& parser,
|
2506 kumpf 1.54 CIMObjectPath& reference)
|
2507 mike 1.23 {
2508 XmlEntry entry;
2509
2510 if (!testStartTag(parser, entry, "INSTANCEPATH"))
|
2511 kumpf 1.122 return false;
|
2512 mike 1.23
2513 String host;
2514 String nameSpace;
2515
2516 if (!getNameSpacePathElement(parser, host, nameSpace))
2517 {
|
2518 kumpf 1.122 MessageLoaderParms mlParms(
2519 "Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2520 "expected NAMESPACEPATH element");
2521 throw XmlValidationError(parser.getLine(), mlParms);
|
2522 mike 1.23 }
2523
2524 String className;
|
2525 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2526 mike 1.23
2527 if (!getInstanceNameElement(parser, className, keyBindings))
2528 {
|
2529 kumpf 1.122 MessageLoaderParms mlParms(
2530 "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2531 "expected INSTANCENAME element");
2532 throw XmlValidationError(parser.getLine(), mlParms);
|
2533 mike 1.23 }
2534
2535 reference.set(host, nameSpace, className, keyBindings);
2536
2537 expectEndTag(parser, "INSTANCEPATH");
2538 return true;
2539 }
2540
2541 //------------------------------------------------------------------------------
2542 //
2543 // getLocalInstancePathElement()
2544 //
2545 // <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2546 //
2547 //------------------------------------------------------------------------------
2548
2549 Boolean XmlReader::getLocalInstancePathElement(
2550 XmlParser& parser,
|
2551 kumpf 1.54 CIMObjectPath& reference)
|
2552 mike 1.23 {
2553 XmlEntry entry;
2554
2555 if (!testStartTag(parser, entry, "LOCALINSTANCEPATH"))
|
2556 kumpf 1.122 return false;
|
2557 mike 1.23
2558 String nameSpace;
2559
2560 if (!getLocalNameSpacePathElement(parser, nameSpace))
2561 {
|
2562 kumpf 1.122 MessageLoaderParms mlParms(
2563 "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2564 "expected LOCALNAMESPACEPATH element");
2565 throw XmlValidationError(parser.getLine(), mlParms);
|
2566 mike 1.23 }
2567
2568 String className;
|
2569 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2570 mike 1.23
2571 if (!getInstanceNameElement(parser, className, keyBindings))
2572 {
|
2573 kumpf 1.122 MessageLoaderParms mlParms(
2574 "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2575 "expected INSTANCENAME element");
2576 throw XmlValidationError(parser.getLine(), mlParms);
|
2577 mike 1.23 }
2578
2579 reference.set(String(), nameSpace, className, keyBindings);
2580
2581 expectEndTag(parser, "LOCALINSTANCEPATH");
2582 return true;
2583 }
2584
2585 //------------------------------------------------------------------------------
2586 //
2587 // getClassPathElement()
2588 //
2589 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
2590 //
2591 //------------------------------------------------------------------------------
2592
2593 Boolean XmlReader::getClassPathElement(
2594 XmlParser& parser,
|
2595 kumpf 1.54 CIMObjectPath& reference)
|
2596 mike 1.23 {
2597 XmlEntry entry;
2598
2599 if (!testStartTag(parser, entry, "CLASSPATH"))
|
2600 kumpf 1.122 return false;
|
2601 mike 1.23
2602 String host;
2603 String nameSpace;
2604
2605 if (!getNameSpacePathElement(parser, host, nameSpace))
2606 {
|
2607 kumpf 1.122 MessageLoaderParms mlParms(
2608 "Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2609 "expected NAMESPACEPATH element");
2610 throw XmlValidationError(parser.getLine(), mlParms);
|
2611 mike 1.23 }
2612
|
2613 kumpf 1.74 CIMName className;
|
2614 mike 1.23
2615 if (!getClassNameElement(parser, className))
2616 {
|
2617 kumpf 1.122 MessageLoaderParms mlParms(
2618 "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2619 "expected CLASSNAME element");
2620 throw XmlValidationError(parser.getLine(), mlParms);
|
2621 mike 1.23 }
2622
2623 reference.set(host, nameSpace, className);
2624
2625 expectEndTag(parser, "CLASSPATH");
2626 return true;
2627 }
2628
2629 //------------------------------------------------------------------------------
2630 //
2631 // getLocalClassPathElement()
2632 //
2633 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>
2634 //
2635 //------------------------------------------------------------------------------
2636
2637 Boolean XmlReader::getLocalClassPathElement(
2638 XmlParser& parser,
|
2639 kumpf 1.54 CIMObjectPath& reference)
|
2640 mike 1.23 {
2641 XmlEntry entry;
2642
2643 if (!testStartTag(parser, entry, "LOCALCLASSPATH"))
|
2644 kumpf 1.122 return false;
|
2645 mike 1.23
2646 String nameSpace;
2647
2648 if (!getLocalNameSpacePathElement(parser, nameSpace))
2649 {
|
2650 kumpf 1.122 MessageLoaderParms mlParms(
2651 "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2652 "expected LOCALNAMESPACEPATH element");
2653 throw XmlValidationError(parser.getLine(), mlParms);
|
2654 mike 1.23 }
2655
|
2656 kumpf 1.74 CIMName className;
|
2657 mike 1.23
2658 if (!getClassNameElement(parser, className))
2659 {
|
2660 kumpf 1.122 MessageLoaderParms mlParms(
2661 "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2662 "expected CLASSNAME element");
2663 throw XmlValidationError(parser.getLine(), mlParms);
|
2664 mike 1.23 }
2665
2666 reference.set(String(), nameSpace, className);
2667
2668 expectEndTag(parser, "LOCALCLASSPATH");
2669
2670 return true;
2671 }
2672
2673 //------------------------------------------------------------------------------
2674 //
2675 // getValueReferenceElement()
2676 //
2677 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
2678 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
2679 //
2680 //
2681 //------------------------------------------------------------------------------
2682
2683 Boolean XmlReader::getValueReferenceElement(
2684 XmlParser& parser,
|
2685 kumpf 1.54 CIMObjectPath& reference)
|
2686 mike 1.23 {
2687 XmlEntry entry;
2688
2689 if (!testStartTag(parser, entry, "VALUE.REFERENCE"))
|
2690 kumpf 1.122 return false;
|
2691 mike 1.23
2692 if (!parser.next(entry))
|
2693 kumpf 1.122 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
|
2694 mike 1.23
|
2695 kumpf 1.122 if (entry.type != XmlEntry::START_TAG &&
2696 entry.type != XmlEntry::EMPTY_TAG)
|
2697 mike 1.23 {
|
2698 kumpf 1.122 MessageLoaderParms mlParms(
2699 "Common.XmlReader.EXPECTED_START_TAGS",
2700 "Expected one of the following start tags: CLASSPATH, "
2701 "LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, "
2702 "INSTANCENAME");
2703 throw XmlValidationError(parser.getLine(), mlParms);
|
2704 mike 1.23 }
2705
2706 if (strcmp(entry.text, "CLASSPATH") == 0)
2707 {
|
2708 kumpf 1.122 parser.putBack(entry);
2709 getClassPathElement(parser, reference);
|
2710 mike 1.23 }
2711 else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
2712 {
|
2713 kumpf 1.122 parser.putBack(entry);
2714 getLocalClassPathElement(parser, reference);
|
2715 mike 1.23 }
2716 else if (strcmp(entry.text, "CLASSNAME") == 0)
2717 {
|
2718 kumpf 1.122 parser.putBack(entry);
2719 CIMName className;
2720 getClassNameElement(parser, className);
2721 reference.set(String(), CIMNamespaceName(), className);
|
2722 mike 1.23 }
2723 else if (strcmp(entry.text, "INSTANCEPATH") == 0)
2724 {
|
2725 kumpf 1.122 parser.putBack(entry);
2726 getInstancePathElement(parser, reference);
|
2727 mike 1.23 }
2728 else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
2729 {
|
2730 kumpf 1.122 parser.putBack(entry);
2731 getLocalInstancePathElement(parser, reference);
|
2732 mike 1.23 }
2733 else if (strcmp(entry.text, "INSTANCENAME") == 0)
2734 {
|
2735 kumpf 1.122 parser.putBack(entry);
2736 String className;
2737 Array<CIMKeyBinding> keyBindings;
2738 getInstanceNameElement(parser, className, keyBindings);
2739 reference.set(String(), CIMNamespaceName(), className, keyBindings);
|
2740 mike 1.23 }
2741
2742 expectEndTag(parser, "VALUE.REFERENCE");
2743 return true;
2744 }
2745
2746 //------------------------------------------------------------------------------
2747 //
|
2748 kumpf 1.28 // getValueReferenceArrayElement()
2749 //
2750 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
2751 //
2752 //------------------------------------------------------------------------------
2753
2754 Boolean XmlReader::getValueReferenceArrayElement(
|
2755 kumpf 1.122 XmlParser& parser,
|
2756 kumpf 1.28 CIMValue& value)
2757 {
2758 XmlEntry entry;
|
2759 kumpf 1.54 Array<CIMObjectPath> referenceArray;
2760 CIMObjectPath reference;
|
2761 kumpf 1.28
2762 value.clear();
2763
2764 // Get VALUE.REFARRAY open tag:
2765
2766 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
|
2767 kumpf 1.122 return false;
|
2768 kumpf 1.28
|
2769 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
2770 {
2771 // For each VALUE.REFERENCE element:
|
2772 kumpf 1.28
|
2773 kumpf 1.32 while (getValueReferenceElement(parser, reference))
2774 {
|
2775 kumpf 1.122 referenceArray.append(reference);
|
2776 kumpf 1.32 }
|
2777 kumpf 1.28
|
2778 kumpf 1.32 expectEndTag(parser, "VALUE.REFARRAY");
|
2779 kumpf 1.28 }
2780
2781 value.set(referenceArray);
2782 return true;
2783 }
2784
2785 //------------------------------------------------------------------------------
2786 //
|
2787 mike 1.23 // getPropertyReferenceElement()
2788 //
2789 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>
2790 // <!ATTLIST PROPERTY.REFERENCE
2791 // %CIMName;
2792 // %ReferenceClass;
2793 // %ClassOrigin;
2794 // %Propagated;>
2795 //
2796 //------------------------------------------------------------------------------
2797
2798 Boolean XmlReader::getPropertyReferenceElement(
|
2799 kumpf 1.122 XmlParser& parser,
|
2800 mike 1.23 CIMProperty& property)
2801 {
2802 XmlEntry entry;
2803
2804 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))
|
2805 kumpf 1.122 return false;
|
2806 mike 1.23
2807 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2808
2809 // Get PROPERTY.NAME attribute:
2810
|
2811 kumpf 1.74 CIMName name = getCimNameAttribute(
|
2812 kumpf 1.122 parser.getLine(), entry, "PROPERTY.REFERENCE");
|
2813 mike 1.23
2814 // Get PROPERTY.REFERENCECLASS attribute:
2815
|
2816 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
2817 kumpf 1.122 parser.getLine(), entry, "PROPERTY.REFERENCE");
|
2818 mike 1.23
2819 // Get PROPERTY.CLASSORIGIN attribute:
2820
|
2821 kumpf 1.122 CIMName classOrigin =
2822 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
|
2823 mike 1.23
2824 // Get PROPERTY.PROPAGATED
2825
|
2826 kumpf 1.122 Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
2827 "PROPERTY.REFERENCE", "PROPAGATED", false, false);
|
2828 mike 1.23
2829 // Create property:
2830
|
2831 kumpf 1.61 CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);
|
2832 kumpf 1.54 // value.set(CIMObjectPath());
|
2833 mike 1.23 property = CIMProperty(
|
2834 kumpf 1.122 name, value, 0, referenceClass, classOrigin, propagated);
|
2835 mike 1.23
2836 if (!empty)
2837 {
|
2838 kumpf 1.122 getQualifierElements(parser, property);
|
2839 mike 1.23
|
2840 kumpf 1.122 CIMObjectPath reference;
|
2841 mike 1.23
|
2842 kumpf 1.122 if (getValueReferenceElement(parser, reference))
2843 property.setValue(reference);
|
2844 mike 1.23
|
2845 kumpf 1.122 expectEndTag(parser, "PROPERTY.REFERENCE");
|
2846 mike 1.23 }
2847
2848 return true;
2849 }
2850
2851 //------------------------------------------------------------------------------
2852 //
2853 // GetPropertyElements()
2854 //
2855 //------------------------------------------------------------------------------
2856
2857 template<class CONTAINER>
2858 void GetPropertyElements(XmlParser& parser, CONTAINER& container)
2859 {
2860 CIMProperty property;
2861
2862 while (XmlReader::getPropertyElement(parser, property) ||
|
2863 kumpf 1.122 XmlReader::getPropertyArrayElement(parser, property) ||
2864 XmlReader::getPropertyReferenceElement(parser, property))
|
2865 mike 1.23 {
|
2866 kumpf 1.122 try
2867 {
2868 container.addProperty(property);
2869 }
2870 catch (AlreadyExistsException&)
2871 {
2872 MessageLoaderParms mlParms(
2873 "Common.XmlReader.DUPLICATE_PROPERTY",
2874 "duplicate property");
2875 throw XmlSemanticError(parser.getLine(), mlParms);
2876 }
|
2877 mike 1.23 }
2878 }
2879
2880 //------------------------------------------------------------------------------
2881 //
2882 // getParameterElement()
2883 //
2884 // <!ELEMENT PARAMETER (QUALIFIER*)>
2885 // <!ATTLIST PARAMETER
2886 // %CIMName;
2887 // %CIMType; #REQUIRED>
2888 //
2889 //------------------------------------------------------------------------------
2890
2891 Boolean XmlReader::getParameterElement(
|
2892 kumpf 1.122 XmlParser& parser,
|
2893 mike 1.23 CIMParameter& parameter)
2894 {
2895 XmlEntry entry;
2896
2897 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER"))
|
2898 kumpf 1.122 return false;
|
2899 mike 1.23
2900 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2901
2902 // Get PARAMETER.NAME attribute:
2903
|
2904 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
|
2905 mike 1.23
2906 // Get PARAMETER.TYPE attribute:
2907
|
2908 kumpf 1.67 CIMType type;
2909 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER");
|
2910 mike 1.23
2911 // Create parameter:
2912
2913 parameter = CIMParameter(name, type);
2914
2915 if (!empty)
2916 {
|
2917 kumpf 1.122 getQualifierElements(parser, parameter);
|
2918 mike 1.23
|
2919 kumpf 1.122 expectEndTag(parser, "PARAMETER");
|
2920 mike 1.23 }
2921
2922 return true;
2923 }
2924
2925 //------------------------------------------------------------------------------
2926 //
2927 // getParameterArrayElement()
2928 //
2929 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
2930 // <!ATTLIST PARAMETER.ARRAY
2931 // %CIMName;
2932 // %CIMType; #REQUIRED
2933 // %ArraySize;>
2934 //
2935 //------------------------------------------------------------------------------
2936
2937 Boolean XmlReader::getParameterArrayElement(
|
2938 kumpf 1.122 XmlParser& parser,
|
2939 mike 1.23 CIMParameter& parameter)
2940 {
2941 XmlEntry entry;
2942
2943 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.ARRAY"))
|
2944 kumpf 1.122 return false;
|
2945 mike 1.23
2946 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2947
2948 // Get PARAMETER.ARRAY.NAME attribute:
2949
|
2950 kumpf 1.74 CIMName name = getCimNameAttribute(
|
2951 kumpf 1.122 parser.getLine(), entry, "PARAMETER.ARRAY");
|
2952 mike 1.23
2953 // Get PARAMETER.ARRAY.TYPE attribute:
2954
|
2955 kumpf 1.67 CIMType type;
2956 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER.ARRAY");
|
2957 mike 1.23
2958 // Get PARAMETER.ARRAYSIZE attribute:
2959
2960 Uint32 arraySize = 0;
2961 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);
2962
2963 // Create parameter:
2964
2965 parameter = CIMParameter(name, type, true, arraySize);
2966
2967 if (!empty)
2968 {
|
2969 kumpf 1.122 getQualifierElements(parser, parameter);
|
2970 mike 1.23
|
2971 kumpf 1.122 expectEndTag(parser, "PARAMETER.ARRAY");
|
2972 mike 1.23 }
2973
2974 return true;
2975 }
2976
2977 //------------------------------------------------------------------------------
2978 //
2979 // getParameterReferenceElement()
2980 //
2981 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
2982 // <!ATTLIST PARAMETER.REFERENCE
2983 // %CIMName;
2984 // %ReferenceClass;>
2985 //
2986 //------------------------------------------------------------------------------
2987
2988 Boolean XmlReader::getParameterReferenceElement(
|
2989 kumpf 1.122 XmlParser& parser,
|
2990 mike 1.23 CIMParameter& parameter)
2991 {
2992 XmlEntry entry;
2993
2994 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))
|
2995 kumpf 1.122 return false;
|
2996 mike 1.23
2997 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2998
2999 // Get PARAMETER.NAME attribute:
3000
|
3001 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3002 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFERENCE");
|
3003 mike 1.23
3004 // Get PARAMETER.REFERENCECLASS attribute:
3005
|
3006 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3007 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFERENCE");
|
3008 mike 1.23
3009 // Create parameter:
3010
|
3011 kumpf 1.61 parameter = CIMParameter(name, CIMTYPE_REFERENCE, false, 0, referenceClass);
|
3012 mike 1.23
3013 if (!empty)
3014 {
|
3015 kumpf 1.122 getQualifierElements(parser, parameter);
3016 expectEndTag(parser, "PARAMETER.REFERENCE");
|
3017 mike 1.23 }
3018
3019 return true;
3020 }
3021
3022 //------------------------------------------------------------------------------
3023 //
|
3024 kumpf 1.26 // getParameterReferenceArrayElement()
3025 //
3026 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
3027 // <!ATTLIST PARAMETER.REFARRAY
3028 // %CIMName;
3029 // %ReferenceClass;
3030 // %ArraySize;>
3031 //
3032 //------------------------------------------------------------------------------
3033
3034 Boolean XmlReader::getParameterReferenceArrayElement(
|
3035 kumpf 1.122 XmlParser& parser,
|
3036 kumpf 1.26 CIMParameter& parameter)
3037 {
3038 XmlEntry entry;
3039
3040 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))
|
3041 kumpf 1.122 return false;
|
3042 kumpf 1.26
3043 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3044
3045 // Get PARAMETER.NAME attribute:
3046
|
3047 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3048 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFARRAY");
|
3049 kumpf 1.26
3050 // Get PARAMETER.REFERENCECLASS attribute:
3051
|
3052 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3053 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFARRAY");
|
3054 kumpf 1.26
3055 // Get PARAMETER.ARRAYSIZE attribute:
3056
3057 Uint32 arraySize = 0;
|
3058 kumpf 1.122 getArraySizeAttribute(
3059 parser.getLine(), entry, "PARAMETER.REFARRAY", arraySize);
|
3060 kumpf 1.26
3061 // Create parameter:
3062
|
3063 kumpf 1.122 parameter = CIMParameter(
3064 name, CIMTYPE_REFERENCE, true, arraySize, referenceClass);
|
3065 kumpf 1.26
3066 if (!empty)
3067 {
|
3068 kumpf 1.122 getQualifierElements(parser, parameter);
3069 expectEndTag(parser, "PARAMETER.REFARRAY");
|
3070 kumpf 1.26 }
3071
3072 return true;
3073 }
3074
3075 //------------------------------------------------------------------------------
3076 //
|
3077 mike 1.23 // GetParameterElements()
3078 //
3079 //------------------------------------------------------------------------------
3080
3081 template<class CONTAINER>
3082 void GetParameterElements(XmlParser& parser, CONTAINER& container)
3083 {
3084 CIMParameter parameter;
3085
3086 while (XmlReader::getParameterElement(parser, parameter) ||
|
3087 kumpf 1.122 XmlReader::getParameterArrayElement(parser, parameter) ||
3088 XmlReader::getParameterReferenceElement(parser, parameter) ||
3089 XmlReader::getParameterReferenceArrayElement(parser, parameter))
3090 {
3091 try
3092 {
3093 container.addParameter(parameter);
3094 }
3095 catch (AlreadyExistsException&)
3096 {
3097 MessageLoaderParms mlParms(
3098 "Common.XmlReader.DUPLICATE_PARAMETER",
3099 "duplicate parameter");
3100 throw XmlSemanticError(parser.getLine(), mlParms);
3101 }
|
3102 mike 1.23 }
3103 }
3104
3105 //------------------------------------------------------------------------------
3106 //
3107 // getQualifierDeclElement()
3108 //
3109 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
|
3110 kumpf 1.122 // <!ATTLIST QUALIFIER.DECLARATION
3111 // %CIMName;
|
3112 mike 1.23 // %CIMType; #REQUIRED
3113 // ISARRAY (true|false) #IMPLIED
3114 // %ArraySize;
3115 // %QualifierFlavor;>
|
3116 kumpf 1.122 //
|
3117 mike 1.23 //------------------------------------------------------------------------------
3118
3119 Boolean XmlReader::getQualifierDeclElement(
|
3120 kumpf 1.122 XmlParser& parser,
|
3121 mike 1.23 CIMQualifierDecl& qualifierDecl)
3122 {
3123 XmlEntry entry;
3124
3125 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER.DECLARATION"))
|
3126 kumpf 1.122 return false;
|
3127 mike 1.23
3128 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3129
3130 // Get NAME attribute:
3131
|
3132 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3133 kumpf 1.122 parser.getLine(), entry, "QUALIFIER.DECLARATION");
|
3134 mike 1.23
3135 // Get TYPE attribute:
3136
|
3137 kumpf 1.67 CIMType type;
3138 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER.DECLARATION");
|
3139 mike 1.23
3140 // Get ISARRAY attribute:
3141
|
3142 mike 1.25 Boolean isArray = getCimBooleanAttribute(
3143 parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",
|
3144 kumpf 1.122 false, false);
|
3145 mike 1.23
3146 // Get ARRAYSIZE attribute:
3147
3148 Uint32 arraySize = 0;
3149 Boolean gotArraySize = getArraySizeAttribute(parser.getLine(),
|
3150 kumpf 1.122 entry, "QUALIFIER.DECLARATION", arraySize);
|
3151 mike 1.23
3152 // Get flavor oriented attributes:
3153
|
3154 kumpf 1.122 CIMFlavor flavor = getFlavor (entry, parser.getLine (),
|
3155 kumpf 1.64 "QUALIFIER.DECLARATION");
|
3156 mike 1.23
3157 // No need to look for interior elements if empty tag:
3158
|
3159 kumpf 1.63 CIMScope scope = CIMScope ();
|
3160 mike 1.23 CIMValue value;
|
3161 kumpf 1.67 Boolean gotValue = false;
|
3162 mike 1.23
3163 if (!empty)
3164 {
|
3165 kumpf 1.122 // Get the option SCOPE element:
|
3166 mike 1.23
|
3167 kumpf 1.122 scope = getOptionalScope(parser);
|
3168 mike 1.23
|
3169 kumpf 1.122 // Get VALUE or VALUE.ARRAY element:
|
3170 mike 1.23
|
3171 kumpf 1.122 if (getValueArrayElement(parser, type, value))
3172 {
3173 if (!isArray)
3174 {
3175 MessageLoaderParms mlParms(
3176 "Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
3177 "VALUE.ARRAY element encountered without ISARRAY "
3178 "attribute");
3179 throw XmlSemanticError(parser.getLine(), mlParms);
3180 }
|
3181 humberto 1.85
|
3182 kumpf 1.122 if (arraySize && arraySize != value.getArraySize())
3183 {
3184 MessageLoaderParms mlParms(
3185 "Common.XmlReader.ARRAY_SIZE_NOT_SAME",
3186 "VALUE.ARRAY size is not the same as ARRAYSIZE attribute");
3187 throw XmlSemanticError(parser.getLine(), mlParms);
3188 }
|
3189 kumpf 1.67
3190 gotValue = true;
|
3191 kumpf 1.122 }
3192 else if (getValueElement(parser, type, value))
3193 {
3194 if (isArray)
3195 {
3196 MessageLoaderParms mlParms(
3197 "Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
3198 "ISARRAY attribute used but VALUE element encountered");
3199 throw XmlSemanticError(parser.getLine(), mlParms);
3200 }
|
3201 kumpf 1.67
3202 gotValue = true;
|
3203 kumpf 1.122 }
|
3204 mike 1.23
|
3205 kumpf 1.122 // Now get the closing tag:
|
3206 mike 1.23
|
3207 kumpf 1.122 expectEndTag(parser, "QUALIFIER.DECLARATION");
|
3208 mike 1.23 }
3209
|
3210 kumpf 1.67 if (!gotValue)
|
3211 mike 1.23 {
|
3212 kumpf 1.122 if (isArray)
3213 value.setNullValue(type, true, arraySize);
3214 else
3215 value.setNullValue(type, false);
|
3216 mike 1.23 }
3217
3218 CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);
3219 qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);
3220 return true;
3221 }
3222
3223 //------------------------------------------------------------------------------
3224 // getMethodElement()
3225 //
3226 // <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|
3227 // PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
3228 // <!ATTLIST METHOD
3229 // %CIMName;
3230 // %CIMType; #IMPLIED
3231 // %ClassOrigin;
3232 // %Propagated;>
3233 //
3234 //------------------------------------------------------------------------------
3235
3236 Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)
3237 mike 1.23 {
3238 XmlEntry entry;
3239
3240 if (!testStartTagOrEmptyTag(parser, entry, "METHOD"))
|
3241 kumpf 1.122 return false;
|
3242 mike 1.23
3243 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3244
|
3245 kumpf 1.124 CIMName name = getCimNameAttribute(parser.getLine(), entry, "METHOD");
|
3246 mike 1.23
|
3247 kumpf 1.67 CIMType type;
|
3248 kumpf 1.124 getCimTypeAttribute(parser.getLine(), entry, type, "METHOD");
|
3249 mike 1.23
|
3250 kumpf 1.122 CIMName classOrigin =
|
3251 kumpf 1.124 getClassOriginAttribute(parser.getLine(), entry, "METHOD");
|
3252 mike 1.23
3253 Boolean propagated = getCimBooleanAttribute(
|
3254 kumpf 1.124 parser.getLine(), entry, "METHOD", "PROPAGATED", false, false);
|
3255 mike 1.23
3256 method = CIMMethod(name, type, classOrigin, propagated);
3257
3258 if (!empty)
3259 {
|
3260 kumpf 1.26 // ATTN-RK-P2-20020219: Decoding algorithm must not depend on the
3261 // ordering of qualifiers and parameters.
|
3262 kumpf 1.122 getQualifierElements(parser, method);
|
3263 mike 1.23
|
3264 kumpf 1.122 GetParameterElements(parser, method);
|
3265 mike 1.23
|
3266 kumpf 1.122 expectEndTag(parser, "METHOD");
|
3267 mike 1.23 }
3268
3269 return true;
3270 }
3271
3272 //------------------------------------------------------------------------------
3273 // getClassElement()
3274 //
3275 // <!ELEMENT CLASS (QUALIFIER*,
3276 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
3277 // <!ATTLIST CLASS %CIMName; %SuperClass;>
3278 //
3279 //------------------------------------------------------------------------------
3280
3281 Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)
3282 {
3283 XmlEntry entry;
3284
|
3285 a.dunfey 1.96 if (!testStartTagOrEmptyTag(parser, entry, "CLASS"))
|
3286 kumpf 1.122 return false;
|
3287 mike 1.23
|
3288 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
|
3289 mike 1.23
|
3290 kumpf 1.122 CIMName superClass =
3291 getSuperClassAttribute(parser.getLine(), entry,"CLASS");
|
3292 mike 1.23
3293 cimClass = CIMClass(name, superClass);
3294
|
3295 kumpf 1.122 if (entry.type != XmlEntry::EMPTY_TAG)
3296 {
3297 // Get QUALIFIER elements:
|
3298 a.dunfey 1.97
|
3299 kumpf 1.122 getQualifierElements(parser, cimClass);
|
3300 mike 1.23
|
3301 kumpf 1.122 // Get PROPERTY elements:
|
3302 mike 1.23
|
3303 kumpf 1.122 GetPropertyElements(parser, cimClass);
|
3304 mike 1.23
|
3305 kumpf 1.122 // Get METHOD elements:
|
3306 mike 1.23
|
3307 kumpf 1.122 CIMMethod method;
|
3308 mike 1.23
|
3309 kumpf 1.122 while (getMethodElement(parser, method))
3310 cimClass.addMethod(method);
|
3311 mike 1.23
|
3312 kumpf 1.122 // Get CLASS end tag:
|
3313 mike 1.23
|
3314 kumpf 1.122 expectEndTag(parser, "CLASS");
3315 }
|
3316 mike 1.23
3317 return true;
3318 }
3319
3320 //------------------------------------------------------------------------------
3321 // getInstanceElement()
3322 //
3323 // <!ELEMENT INSTANCE (QUALIFIER*,
3324 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >
3325 // <!ATTLIST INSTANCE
3326 // %ClassName;>
3327 //
3328 //------------------------------------------------------------------------------
3329
3330 Boolean XmlReader::getInstanceElement(
|
3331 kumpf 1.122 XmlParser& parser,
|
3332 mike 1.23 CIMInstance& cimInstance)
3333 {
3334 XmlEntry entry;
3335
|
3336 kumpf 1.89 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))
|
3337 kumpf 1.122 return false;
|
3338 mike 1.23
|
3339 kumpf 1.89 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3340
|
3341 mike 1.23 String className = getClassNameAttribute(
|
3342 kumpf 1.122 parser.getLine(), entry, "INSTANCE");
|
3343 mike 1.23
3344 cimInstance = CIMInstance(className);
3345
|
3346 kumpf 1.89 if (!empty)
3347 {
3348 // Get QUALIFIER elements:
3349 getQualifierElements(parser, cimInstance);
3350
3351 // Get PROPERTY elements:
3352 GetPropertyElements(parser, cimInstance);
3353
3354 // Get INSTANCE end tag:
3355 expectEndTag(parser, "INSTANCE");
3356 }
|
3357 mike 1.23
3358 return true;
3359 }
3360
3361 //------------------------------------------------------------------------------
|
3362 mike 1.25 // getNamedInstanceElement()
3363 //
3364 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
3365 //
3366 //------------------------------------------------------------------------------
3367
3368 Boolean XmlReader::getNamedInstanceElement(
|
3369 kumpf 1.122 XmlParser& parser,
|
3370 kumpf 1.55 CIMInstance& namedInstance)
|
3371 mike 1.25 {
3372 XmlEntry entry;
3373
3374 if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
|
3375 kumpf 1.122 return false;
|
3376 mike 1.25
|
3377 kumpf 1.54 CIMObjectPath instanceName;
|
3378 mike 1.25
3379 // Get INSTANCENAME elements:
3380
3381 if (!getInstanceNameElement(parser, instanceName))
3382 {
|
3383 kumpf 1.122 MessageLoaderParms mlParms(
3384 "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
3385 "expected INSTANCENAME element");
3386 throw XmlValidationError(parser.getLine(), mlParms);
|
3387 mike 1.25 }
3388
3389 // Get INSTANCE elements:
3390
|
3391 kumpf 1.55 if (!getInstanceElement(parser, namedInstance))
|
3392 mike 1.25 {
|
3393 kumpf 1.122 MessageLoaderParms mlParms(
3394 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3395 "expected INSTANCE element");
3396 throw XmlValidationError(parser.getLine(), mlParms);
|
3397 mike 1.25 }
3398
3399 // Get VALUE.NAMEDINSTANCE end tag:
3400
3401 expectEndTag(parser, "VALUE.NAMEDINSTANCE");
3402
|
3403 kumpf 1.55 namedInstance.setPath (instanceName);
|
3404 mike 1.25
3405 return true;
3406 }
3407
3408 //------------------------------------------------------------------------------
|
3409 mike 1.23 //
3410 // getObject()
3411 //
3412 //------------------------------------------------------------------------------
3413
3414 void XmlReader::getObject(XmlParser& parser, CIMClass& x)
3415 {
3416 if (!getClassElement(parser, x))
3417 {
|
3418 kumpf 1.122 MessageLoaderParms mlParms(
3419 "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3420 "expected CLASS element");
3421 throw XmlValidationError(parser.getLine(), mlParms);
|
3422 mike 1.23 }
3423 }
3424
3425 //------------------------------------------------------------------------------
3426 //
3427 // getObject()
3428 //
3429 //------------------------------------------------------------------------------
3430
3431 void XmlReader::getObject(XmlParser& parser, CIMInstance& x)
3432 {
3433 if (!getInstanceElement(parser, x))
3434 {
|
3435 kumpf 1.122 MessageLoaderParms mlParms(
3436 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3437 "expected INSTANCE element");
3438 throw XmlValidationError(parser.getLine(), mlParms);
|
3439 mike 1.23 }
3440 }
3441
3442 //------------------------------------------------------------------------------
3443 //
3444 // getObject()
3445 //
3446 //------------------------------------------------------------------------------
3447
3448 void XmlReader::getObject(XmlParser& parser, CIMQualifierDecl& x)
3449 {
3450 if (!getQualifierDeclElement(parser, x))
3451 {
|
3452 kumpf 1.122 MessageLoaderParms mlParms(
3453 "Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",
3454 "expected QUALIFIER.DECLARATION element");
3455 throw XmlValidationError(parser.getLine(), mlParms);
|
3456 mike 1.23 }
3457 }
3458
3459 //------------------------------------------------------------------------------
3460 //
3461 // getMessageStartTag()
3462 //
3463 //------------------------------------------------------------------------------
3464
3465 Boolean XmlReader::getMessageStartTag(
|
3466 kumpf 1.122 XmlParser& parser,
|
3467 mike 1.23 String& id,
|
3468 kumpf 1.34 String& protocolVersion)
|
3469 mike 1.23 {
3470 XmlEntry entry;
3471
3472 if (!testStartTag(parser, entry, "MESSAGE"))
|
3473 kumpf 1.122 return false;
|
3474 mike 1.23
3475 // Get MESSAGE.ID:
3476
|
3477 kumpf 1.122 if (!entry.getAttributeValue("ID", id))
3478 {
3479 MessageLoaderParms mlParms(
3480 "Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",
3481 "Invalid or missing MESSAGE.ID attribute");
3482 throw XmlValidationError(parser.getLine(), mlParms);
3483 }
|
3484 humberto 1.85
|
3485 mike 1.23
3486 // Get MESSAGE.PROTOCOLVERSION:
3487
|
3488 kumpf 1.122 if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))
3489 {
3490 MessageLoaderParms mlParms(
3491 "Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",
3492 "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
3493 throw XmlValidationError(parser.getLine(), mlParms);
3494 }
|
3495 humberto 1.85
|
3496 mike 1.23 return true;
3497 }
3498
3499 //------------------------------------------------------------------------------
3500 //
3501 // getIMethodCallStartTag()
3502 //
3503 //------------------------------------------------------------------------------
3504
3505 Boolean XmlReader::getIMethodCallStartTag(
|
3506 kumpf 1.122 XmlParser& parser,
|
3507 mike 1.23 const char*& name)
3508 {
3509 XmlEntry entry;
3510
3511 if (!testStartTag(parser, entry, "IMETHODCALL"))
|
3512 kumpf 1.122 return false;
|
3513 mike 1.23
3514 // Get IMETHODCALL.NAME attribute:
3515
|
3516 humberto 1.85
|
3517 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3518 {
3519 MessageLoaderParms mlParms(
3520 "Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",
3521 "Missing IMETHODCALL.NAME attribute");
3522 throw XmlValidationError(parser.getLine(), mlParms);
|
3523 humberto 1.85 }
3524
|
3525 mike 1.23
3526 return true;
3527 }
3528
3529 //------------------------------------------------------------------------------
3530 //
3531 // getIMethodResponseStartTag()
3532 //
3533 //------------------------------------------------------------------------------
3534
3535 Boolean XmlReader::getIMethodResponseStartTag(
|
3536 kumpf 1.122 XmlParser& parser,
|
3537 kumpf 1.101 const char*& name,
3538 Boolean& isEmptyTag)
|
3539 mike 1.23 {
3540 XmlEntry entry;
3541
|
3542 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))
|
3543 kumpf 1.122 return false;
|
3544 mike 1.23
|
3545 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3546
|
3547 mike 1.23 // Get IMETHODRESPONSE.NAME attribute:
3548
|
3549 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3550 {
3551 MessageLoaderParms mlParms(
3552 "Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",
3553 "Missing IMETHODRESPONSE.NAME attribute");
3554 throw XmlValidationError(parser.getLine(), mlParms);
|
3555 humberto 1.85 }
3556
|
3557 mike 1.23
3558 return true;
3559 }
3560
3561 //------------------------------------------------------------------------------
3562 //
3563 // getIParamValueTag()
3564 //
3565 //------------------------------------------------------------------------------
3566
3567 Boolean XmlReader::getIParamValueTag(
|
3568 kumpf 1.122 XmlParser& parser,
|
3569 kumpf 1.99 const char*& name,
3570 Boolean& isEmptyTag)
|
3571 mike 1.23 {
3572 XmlEntry entry;
3573
|
3574 kumpf 1.99 if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))
|
3575 kumpf 1.122 return false;
|
3576 mike 1.23
|
3577 kumpf 1.99 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3578
|
3579 mike 1.23 // Get IPARAMVALUE.NAME attribute:
3580
|
3581 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3582 {
3583 MessageLoaderParms mlParms(
3584 "Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",
3585 "Missing IPARAMVALUE.NAME attribute");
3586 throw XmlValidationError(parser.getLine(), mlParms);
|
3587 humberto 1.85 }
|
3588 mike 1.23
3589 return true;
3590 }
3591
3592 //------------------------------------------------------------------------------
3593 //
|
3594 kumpf 1.99 // rejectNullIParamValue()
3595 //
3596 //------------------------------------------------------------------------------
3597
3598 void XmlReader::rejectNullIParamValue(
|
3599 kumpf 1.122 XmlParser& parser,
|
3600 kumpf 1.99 Boolean isEmptyTag,
3601 const char* paramName)
3602 {
3603 if (isEmptyTag)
3604 {
3605 MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",
3606 "A null value is not valid for IPARAMVALUE \"$0\".",
3607 paramName);
3608 throw XmlValidationError(parser.getLine(), mlParms);
3609 }
3610 }
3611
3612 //------------------------------------------------------------------------------
3613 //
|
3614 mike 1.23 // getBooleanValueElement()
3615 //
3616 // Get an elements like: "<VALUE>FALSE</VALUE>"
3617 //
3618 //------------------------------------------------------------------------------
3619
3620 Boolean XmlReader::getBooleanValueElement(
|
3621 kumpf 1.122 XmlParser& parser,
|
3622 mike 1.23 Boolean& result,
3623 Boolean required)
3624 {
3625 XmlEntry entry;
3626
3627 if (!testStartTag(parser, entry, "VALUE"))
3628 {
|
3629 kumpf 1.122 if (required)
3630 {
3631 MessageLoaderParms mlParms(
3632 "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
3633 "Expected VALUE element");
3634 throw XmlValidationError(parser.getLine(), mlParms);
3635 }
3636 return false;
|
3637 mike 1.23 }
3638
3639 expectContentOrCData(parser, entry);
3640
|
3641 kumpf 1.72 if (System::strcasecmp(entry.text, "TRUE") == 0)
|
3642 kumpf 1.122 result = true;
|
3643 kumpf 1.72 else if (System::strcasecmp(entry.text, "FALSE") == 0)
|
3644 kumpf 1.122 result = false;
3645 else
3646 {
3647 MessageLoaderParms mlParms(
3648 "Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
3649 "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
3650 throw XmlSemanticError(parser.getLine(), mlParms);
|
3651 humberto 1.85 }
|
3652 mike 1.23
3653 expectEndTag(parser, "VALUE");
3654
3655 return true;
3656 }
3657
3658 //------------------------------------------------------------------------------
3659 //
|
3660 kumpf 1.95 // DMTF CR Pending
|
3661 mike 1.23 //
|
3662 kumpf 1.95 // <!ELEMENT ERROR (INSTANCE*)>
|
3663 kumpf 1.122 // <!ATTLIST ERROR
|
3664 mike 1.23 // CODE CDATA #REQUIRED
3665 // DESCRIPTION CDATA #IMPLIED>
3666 //
3667 //------------------------------------------------------------------------------
3668
3669 Boolean XmlReader::getErrorElement(
|
3670 kumpf 1.122 XmlParser& parser,
|
3671 kumpf 1.50 CIMException& cimException,
|
3672 mike 1.23 Boolean required)
3673 {
3674 XmlEntry entry;
3675
3676 if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
3677 {
|
3678 kumpf 1.122 if (required)
3679 {
3680 MessageLoaderParms mlParms(
3681 "Common.XmlReader.EXPECTED_ERROR_ELEMENT",
3682 "Expected ERROR element");
3683 throw XmlValidationError(parser.getLine(), mlParms);
3684 }
3685 return false;
|
3686 mike 1.23 }
3687
3688 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3689
3690 // Get ERROR.CODE
3691
3692 Uint32 tmpCode;
3693
|
3694 kumpf 1.122 if (!entry.getAttributeValue("CODE", tmpCode))
3695 {
3696 MessageLoaderParms mlParms(
3697 "Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",
3698 "missing ERROR.CODE attribute");
3699 throw XmlValidationError(parser.getLine(), mlParms);
|
3700 humberto 1.85 }
|
3701 mike 1.23
|
3702 kumpf 1.50 // Get ERROR.DESCRIPTION:
|
3703 mike 1.23
|
3704 kumpf 1.50 String tmpDescription;
|
3705 mike 1.23
|
3706 kumpf 1.50 entry.getAttributeValue("DESCRIPTION", tmpDescription);
|
3707 mike 1.23
|
3708 kumpf 1.122 cimException =
3709 PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
|
3710 karl 1.121
|
3711 mike 1.23 if (!empty)
|
3712 kumpf 1.95 {
|
3713 kumpf 1.122 CIMInstance instance;
|
3714 karl 1.121
|
3715 kumpf 1.122 while (getInstanceElement(parser, instance))
3716 {
3717 cimException.addError(instance);
3718 }
|
3719 kumpf 1.95
|
3720 kumpf 1.122 expectEndTag(parser, "ERROR");
|
3721 kumpf 1.95 }
|
3722 mike 1.23
3723 return true;
3724 }
3725
3726 //------------------------------------------------------------------------------
|
3727 kumpf 1.48 // getValueObjectElement()
3728 //
3729 // <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
3730 //
3731 //------------------------------------------------------------------------------
3732
3733 Boolean XmlReader::getValueObjectElement(
|
3734 kumpf 1.122 XmlParser& parser,
|
3735 kumpf 1.48 CIMObject& object)
3736 {
3737 XmlEntry entry;
3738
3739 if (!testStartTag(parser, entry, "VALUE.OBJECT"))
|
3740 kumpf 1.122 return false;
|
3741 kumpf 1.48
3742 CIMInstance cimInstance;
3743 CIMClass cimClass;
3744
3745 if (XmlReader::getInstanceElement(parser, cimInstance))
3746 {
|
3747 kumpf 1.122 object = CIMObject(cimInstance);
|
3748 kumpf 1.48 }
|
3749 dave.sudlik 1.104 else if (XmlReader::getClassElement(parser, cimClass))
|
3750 kumpf 1.48 {
|
3751 kumpf 1.122 object = CIMObject(cimClass);
|
3752 kumpf 1.48 }
3753 else
3754 {
|
3755 kumpf 1.122 MessageLoaderParms mlParms(
3756 "Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
3757 "Expected INSTANCE or CLASS element");
3758 throw XmlValidationError(parser.getLine(), mlParms);
|
3759 kumpf 1.48 }
3760
3761 expectEndTag(parser, "VALUE.OBJECT");
3762
3763 return true;
3764 }
3765
3766 //------------------------------------------------------------------------------
3767 // getValueObjectWithPathElement()
|
3768 mike 1.23 //
3769 // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
3770 //
3771 //------------------------------------------------------------------------------
3772
|
3773 kumpf 1.48 Boolean XmlReader::getValueObjectWithPathElement(
|
3774 kumpf 1.122 XmlParser& parser,
|
3775 kumpf 1.57 CIMObject& objectWithPath)
|
3776 mike 1.23 {
3777 XmlEntry entry;
3778
3779 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
|
3780 kumpf 1.122 return false;
|
3781 mike 1.23
|
3782 kumpf 1.54 CIMObjectPath reference;
|
3783 mike 1.23 Boolean isInstance = false;
3784
3785 if (XmlReader::getInstancePathElement(parser, reference))
|
3786 kumpf 1.122 isInstance = true;
|
3787 mike 1.23 else if (!XmlReader::getClassPathElement(parser, reference))
3788 {
|
3789 kumpf 1.122 MessageLoaderParms mlParms(
3790 "Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
3791 "Expected INSTANCEPATH or CLASSPATH element");
3792 throw XmlValidationError(parser.getLine(), mlParms);
|
3793 mike 1.23 }
3794
3795 if (isInstance)
3796 {
|
3797 kumpf 1.122 CIMInstance cimInstance;
|
3798 mike 1.23
|
3799 kumpf 1.122 if (!XmlReader::getInstanceElement(parser, cimInstance))
3800 {
3801 MessageLoaderParms mlParms(
3802 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3803 "Expected INSTANCE element");
3804 throw XmlValidationError(parser.getLine(), mlParms);
3805 }
3806 objectWithPath = CIMObject (cimInstance);
|
3807 kumpf 1.57 objectWithPath.setPath (reference);
|
3808 mike 1.23 }
3809 else
3810 {
|
3811 kumpf 1.122 CIMClass cimClass;
|
3812 mike 1.23
|
3813 kumpf 1.122 if (!XmlReader::getClassElement(parser, cimClass))
3814 {
3815 MessageLoaderParms mlParms(
3816 "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3817 "Expected CLASS element");
3818 throw XmlValidationError(parser.getLine(), mlParms);
3819 }
3820 objectWithPath = CIMObject (cimClass);
|
3821 kumpf 1.57 objectWithPath.setPath (reference);
|
3822 mike 1.23 }
3823
3824 expectEndTag(parser, "VALUE.OBJECTWITHPATH");
3825
3826 return true;
|
3827 kumpf 1.48 }
3828
3829 //------------------------------------------------------------------------------
3830 // getValueObjectWithLocalPathElement()
3831 //
3832 // <!ELEMENT VALUE.OBJECTWITHLOCALPATH
3833 // ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>
3834 //
3835 //------------------------------------------------------------------------------
3836
3837 Boolean XmlReader::getValueObjectWithLocalPathElement(
|
3838 kumpf 1.122 XmlParser& parser,
|
3839 kumpf 1.57 CIMObject& objectWithPath)
|
3840 kumpf 1.48 {
3841 XmlEntry entry;
3842
3843 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
|
3844 kumpf 1.122 return false;
|
3845 kumpf 1.48
|
3846 kumpf 1.54 CIMObjectPath reference;
|
3847 kumpf 1.48 Boolean isInstance = false;
3848
3849 if (XmlReader::getLocalInstancePathElement(parser, reference))
|
3850 kumpf 1.122 isInstance = true;
|
3851 kumpf 1.48 else if (!XmlReader::getLocalClassPathElement(parser, reference))
3852 {
|
3853 kumpf 1.122 MessageLoaderParms mlParms(
3854 "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
3855 MISSING_ELEMENT_LOCALPATH);
3856 throw XmlValidationError(parser.getLine(), mlParms);
|
3857 kumpf 1.48 }
3858
3859 if (isInstance)
3860 {
|
3861 kumpf 1.122 CIMInstance cimInstance;
|
3862 kumpf 1.48
|
3863 kumpf 1.122 if (!XmlReader::getInstanceElement(parser, cimInstance))
3864 {
3865 MessageLoaderParms mlParms(
3866 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3867 "Expected INSTANCE element");
3868 throw XmlValidationError(parser.getLine(), mlParms);
3869 }
3870 objectWithPath = CIMObject (cimInstance);
3871 objectWithPath.setPath (reference);
|
3872 kumpf 1.48 }
3873 else
3874 {
|
3875 kumpf 1.122 CIMClass cimClass;
|
3876 kumpf 1.48
|
3877 kumpf 1.122 if (!XmlReader::getClassElement(parser, cimClass))
3878 {
3879 MessageLoaderParms mlParms(
3880 "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3881 "Expected CLASS element");
3882 throw XmlValidationError(parser.getLine(), mlParms);
3883 }
3884 objectWithPath = CIMObject (cimClass);
3885 objectWithPath.setPath (reference);
|
3886 kumpf 1.48 }
3887
3888 expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
3889
3890 return true;
3891 }
3892
3893 //------------------------------------------------------------------------------
3894 // getObjectArray()
3895 //
3896 // <object>
3897 // (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)
3898 //
3899 //------------------------------------------------------------------------------
3900
3901 void XmlReader::getObjectArray(
|
3902 kumpf 1.122 XmlParser& parser,
|
3903 kumpf 1.57 Array<CIMObject>& objectArray)
|
3904 kumpf 1.48 {
3905 CIMObject object;
|
3906 kumpf 1.57 CIMObject objectWithPath;
|
3907 kumpf 1.48
3908 objectArray.clear();
3909
3910 if (getValueObjectElement(parser, object))
3911 {
|
3912 kumpf 1.57 objectArray.append(object);
|
3913 kumpf 1.48 while (getValueObjectElement(parser, object))
|
3914 kumpf 1.57 objectArray.append(object);
|
3915 kumpf 1.48 }
3916 else if (getValueObjectWithPathElement(parser, objectWithPath))
3917 {
3918 objectArray.append(objectWithPath);
3919 while (getValueObjectWithPathElement(parser, objectWithPath))
3920 objectArray.append(objectWithPath);
3921 }
3922 else if (getValueObjectWithLocalPathElement(parser, objectWithPath))
3923 {
3924 objectArray.append(objectWithPath);
3925 while (getValueObjectWithLocalPathElement(parser, objectWithPath))
3926 objectArray.append(objectWithPath);
3927 }
|
3928 mike 1.23 }
3929
3930 //------------------------------------------------------------------------------
3931 //
3932 // <objectName>: (CLASSNAME|INSTANCENAME)
3933 //
3934 //------------------------------------------------------------------------------
3935
3936 Boolean XmlReader::getObjectNameElement(
|
3937 kumpf 1.122 XmlParser& parser,
|
3938 kumpf 1.54 CIMObjectPath& objectName)
|
3939 mike 1.23 {
|
3940 kumpf 1.74 CIMName className;
|
3941 mike 1.23
3942 if (getClassNameElement(parser, className, false))
3943 {
|
3944 kumpf 1.122 objectName.set(String(), CIMNamespaceName(), className);
3945 return true;
|
3946 mike 1.23 }
|
3947 kumpf 1.128
3948 if (!getInstanceNameElement(parser, objectName))
|
3949 mike 1.23 {
|
3950 kumpf 1.122 MessageLoaderParms mlParms(
3951 "Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",
3952 "Expected CLASSNAME or INSTANCENAME element");
3953 throw XmlValidationError(parser.getLine(), mlParms);
|
3954 mike 1.23 }
3955
|
3956 kumpf 1.128 return true;
|
3957 mike 1.23 }
3958
3959 //------------------------------------------------------------------------------
3960 //
3961 // <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
3962 //
3963 //------------------------------------------------------------------------------
3964
3965 Boolean XmlReader::getObjectPathElement(
|
3966 kumpf 1.122 XmlParser& parser,
|
3967 kumpf 1.54 CIMObjectPath& objectPath)
|
3968 mike 1.23 {
3969 XmlEntry entry;
3970
3971 if (!testStartTag(parser, entry, "OBJECTPATH"))
|
3972 kumpf 1.122 return false;
|
3973 mike 1.23
|
3974 kumpf 1.128 if (!getClassPathElement(parser, objectPath) &&
3975 !getInstancePathElement(parser, objectPath))
|
3976 mike 1.23 {
|
3977 kumpf 1.122 MessageLoaderParms mlParms(
3978 "Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
3979 "expected INSTANCEPATH or CLASSPATH element");
3980 throw XmlValidationError(parser.getLine(), mlParms);
|
3981 mike 1.23 }
3982
|
3983 kumpf 1.128 expectEndTag(parser, "OBJECTPATH");
3984 return true;
|
3985 mike 1.25 }
3986
3987 //------------------------------------------------------------------------------
3988 //
3989 // getEMethodCallStartTag()
3990 //
3991 //------------------------------------------------------------------------------
3992
3993 Boolean XmlReader::getEMethodCallStartTag(
|
3994 kumpf 1.122 XmlParser& parser,
|
3995 mike 1.25 const char*& name)
3996 {
3997 XmlEntry entry;
3998
3999 if (!testStartTag(parser, entry, "EXPMETHODCALL"))
|
4000 kumpf 1.122 return false;
|
4001 mike 1.25
4002 // Get EXPMETHODCALL.NAME attribute:
4003
|
4004 humberto 1.85
|
4005 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4006 {
4007 MessageLoaderParms mlParms(
4008 "Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",
4009 "Missing EXPMETHODCALL.NAME attribute");
4010 throw XmlValidationError(parser.getLine(), mlParms);
4011 }
|
4012 mike 1.25
4013 return true;
4014 }
4015
4016 //------------------------------------------------------------------------------
4017 //
4018 // getEMethodResponseStartTag()
4019 //
4020 //------------------------------------------------------------------------------
4021
4022 Boolean XmlReader::getEMethodResponseStartTag(
|
4023 kumpf 1.122 XmlParser& parser,
|
4024 kumpf 1.101 const char*& name,
4025 Boolean& isEmptyTag)
|
4026 mike 1.25 {
4027 XmlEntry entry;
4028
|
4029 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))
|
4030 kumpf 1.122 return false;
|
4031 mike 1.25
|
4032 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
4033
|
4034 mike 1.25 // Get EXPMETHODRESPONSE.NAME attribute:
4035
|
4036 humberto 1.85
|
4037 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4038 {
4039 MessageLoaderParms mlParms(
4040 "Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",
4041 "Missing EXPMETHODRESPONSE.NAME attribute");
4042 throw XmlValidationError(parser.getLine(), mlParms);
4043 }
|
4044 mike 1.25
4045 return true;
4046 }
4047
4048 //------------------------------------------------------------------------------
4049 //
|
4050 kumpf 1.83 // getEParamValueTag()
4051 //
4052 //------------------------------------------------------------------------------
4053
4054 Boolean XmlReader::getEParamValueTag(
|
4055 kumpf 1.122 XmlParser& parser,
|
4056 kumpf 1.83 const char*& name)
4057 {
4058 XmlEntry entry;
4059
4060 if (!testStartTag(parser, entry, "EXPPARAMVALUE"))
|
4061 kumpf 1.122 return false;
|
4062 kumpf 1.83
4063 // Get EXPPARAMVALUE.NAME attribute:
4064
|
4065 humberto 1.85
|
4066 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4067 {
4068 MessageLoaderParms mlParms(
4069 "Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",
4070 "Missing EXPPARAMVALUE.NAME attribute");
4071 throw XmlValidationError(parser.getLine(), mlParms);
|
4072 humberto 1.85 }
4073
4074
|
4075 kumpf 1.83
4076 return true;
4077 }
4078
4079 //------------------------------------------------------------------------------
4080 //
|
4081 mike 1.25 // getMethodCallStartTag()
4082 //
4083 //------------------------------------------------------------------------------
4084
4085 Boolean XmlReader::getMethodCallStartTag(
|
4086 kumpf 1.122 XmlParser& parser,
|
4087 mike 1.25 const char*& name)
4088 {
4089 XmlEntry entry;
4090
4091 if (!testStartTag(parser, entry, "METHODCALL"))
|
4092 kumpf 1.122 return false;
|
4093 mike 1.25
4094 // Get METHODCALL.NAME attribute:
4095
|
4096 humberto 1.85
|
4097 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4098 {
4099 MessageLoaderParms mlParms(
4100 "Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",
4101 "Missing METHODCALL.NAME attribute");
4102 throw XmlValidationError(parser.getLine(), mlParms);
|
4103 humberto 1.85 }
4104
|
4105 mike 1.25
4106 return true;
4107 }
4108
4109 //------------------------------------------------------------------------------
4110 //
4111 // getMethodResponseStartTag()
4112 //
4113 //------------------------------------------------------------------------------
4114
4115 Boolean XmlReader::getMethodResponseStartTag(
|
4116 kumpf 1.122 XmlParser& parser,
|
4117 kumpf 1.101 const char*& name,
4118 Boolean& isEmptyTag)
|
4119 mike 1.25 {
4120 XmlEntry entry;
4121
|
4122 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))
|
4123 kumpf 1.122 return false;
|
4124 mike 1.25
|
4125 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
4126
|
4127 mike 1.25 // Get METHODRESPONSE.NAME attribute:
4128
|
4129 humberto 1.85
|
4130 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4131 {
4132 MessageLoaderParms mlParms(
4133 "Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",
4134 "Missing METHODRESPONSE.NAME attribute");
4135 throw XmlValidationError(parser.getLine(), mlParms);
|
4136 humberto 1.85 }
|
4137 mike 1.25
4138 return true;
4139 }
4140
4141 //------------------------------------------------------------------------------
4142 //
|
4143 kumpf 1.26 // getParamValueElement()
4144 //
4145 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
4146 // <!ATTLIST PARAMVALUE
4147 // %CIMName;
|
4148 dave.sudlik 1.109 // %EmbeddedObject; #IMPLIED
|
4149 kumpf 1.26 // %ParamType;>
|
4150 mike 1.25 //
4151 //------------------------------------------------------------------------------
4152
|
4153 kumpf 1.26 Boolean XmlReader::getParamValueElement(
|
4154 kumpf 1.122 XmlParser& parser,
|
4155 kumpf 1.26 CIMParamValue& paramValue)
|
4156 mike 1.25 {
4157 XmlEntry entry;
|
4158 kumpf 1.26 const char* name;
|
4159 marek 1.100 CIMType type=CIMTYPE_BOOLEAN;
|
4160 kumpf 1.26 CIMValue value;
|
4161 mike 1.25
|
4162 kumpf 1.26 if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
|
4163 kumpf 1.122 return false;
|
4164 mike 1.25
|
4165 kumpf 1.26 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
4166
4167 // Get PARAMVALUE.NAME attribute:
|
4168 mike 1.25
|
4169 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4170 {
4171 MessageLoaderParms mlParms(
4172 "Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",
4173 "Missing PARAMVALUE.NAME attribute");
4174 throw XmlValidationError(parser.getLine(), mlParms);
4175 }
|
4176 humberto 1.85
|
4177 karl 1.129 // Get PROPERTY.EmbeddedObject
|
4178 humberto 1.85
|
4179 thilo.boehm 1.131 EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(
|
4180 kumpf 1.122 parser.getLine(), entry, "PARAMVALUE");
|
4181 kumpf 1.26
4182 // Get PARAMVALUE.PARAMTYPE attribute:
4183
|
4184 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4185 "PARAMVALUE", "PARAMTYPE", false);
|
4186 kumpf 1.26
|
4187 kumpf 1.113 if (empty)
4188 {
4189 gotType = false; // Can't distinguish array and non-array types
4190 }
4191 else
|
4192 kumpf 1.26 {
4193 // Parse VALUE.REFERENCE and VALUE.REFARRAY type
|
4194 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4195 kumpf 1.26 {
|
4196 dave.sudlik 1.109 CIMObjectPath reference;
|
4197 kumpf 1.122 if (XmlReader::getValueReferenceElement(parser, reference))
4198 {
4199 value.set(reference);
4200 type = CIMTYPE_REFERENCE;
|
4201 kumpf 1.67 gotType = true;
|
4202 kumpf 1.122 }
|
4203 kumpf 1.28 else if (XmlReader::getValueReferenceArrayElement(parser, value))
|
4204 kumpf 1.122 {
4205 type = CIMTYPE_REFERENCE;
|
4206 kumpf 1.67 gotType = true;
|
4207 kumpf 1.122 }
|
4208 kumpf 1.139 else
|
4209 kumpf 1.127 {
4210 gotType = false; // Can't distinguish array and non-array types
4211 }
|
4212 kumpf 1.26 }
4213
4214 // Parse non-reference value
|
4215 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4216 kumpf 1.26 {
|
4217 kumpf 1.67 CIMType effectiveType;
4218 if (!gotType)
|
4219 kumpf 1.122 {
4220 // If we don't know what type the value is, read it as a String
4221 effectiveType = CIMTYPE_STRING;
4222 }
|
4223 kumpf 1.67 else
|
4224 kumpf 1.122 {
4225 effectiveType = type;
4226 }
|
4227 dave.sudlik 1.109
|
4228 karl 1.129 // If the EmbeddedObject attribute is present with value "object"
|
4229 dave.sudlik 1.109 // then
4230 // Convert the EmbeddedObject-encoded string into a CIMObject
|
4231 thilo.boehm 1.131 if (embeddedObject != NO_EMBEDDED_OBJECT)
|
4232 a.dunfey 1.118 {
|
4233 karl 1.129 // The EmbeddedObject attribute is only valid on Parameters
|
4234 kumpf 1.122 // of type string
|
4235 a.dunfey 1.118 // The type must have been specified.
4236 if (gotType && (type == CIMTYPE_STRING))
4237 {
|
4238 thilo.boehm 1.131 if (embeddedObject == EMBEDDED_OBJECT_ATTR)
|
4239 kumpf 1.122 // Used below by getValueElement() or
4240 // getValueArrayElement()
4241 effectiveType = CIMTYPE_OBJECT;
|
4242 a.dunfey 1.118 else
|
4243 kumpf 1.122 effectiveType = CIMTYPE_INSTANCE;
|
4244 a.dunfey 1.118 }
4245 else
4246 {
|
4247 kumpf 1.122 MessageLoaderParms mlParms(
4248 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
4249 karl 1.129 "The EmbeddedObject attribute is only valid on "
|
4250 kumpf 1.122 "string types.");
|
4251 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
4252 }
4253 }
|
4254 kumpf 1.122
4255 if (!XmlReader::getValueArrayElement(parser, effectiveType, value)
4256 && !XmlReader::getValueElement(parser, effectiveType, value))
|
4257 dave.sudlik 1.109 {
|
4258 kumpf 1.113 gotType = false; // Can't distinguish array and non-array types
4259 value.clear(); // Isn't necessary; should already be cleared
|
4260 dave.sudlik 1.109 }
|
4261 kumpf 1.26 }
4262
4263 expectEndTag(parser, "PARAMVALUE");
4264 }
4265
|
4266 kumpf 1.67 paramValue = CIMParamValue(name, value, gotType);
|
4267 kumpf 1.27
4268 return true;
4269 }
4270
4271 //------------------------------------------------------------------------------
4272 //
4273 // getReturnValueElement()
4274 //
4275 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
4276 // <!ATTLIST RETURNVALUE
|
4277 dave.sudlik 1.109 // %EmbeddedObject; #IMPLIED
|
4278 kumpf 1.27 // %ParamType;>
4279 //
4280 //------------------------------------------------------------------------------
4281
4282 Boolean XmlReader::getReturnValueElement(
|
4283 kumpf 1.122 XmlParser& parser,
|
4284 kumpf 1.27 CIMValue& returnValue)
4285 {
4286 XmlEntry entry;
4287 CIMType type;
4288 CIMValue value;
4289
4290 if (!testStartTag(parser, entry, "RETURNVALUE"))
|
4291 kumpf 1.122 return false;
|
4292 kumpf 1.27
|
4293 karl 1.129 // Get PROPERTY.EmbeddedObject
|
4294 dave.sudlik 1.109
|
4295 thilo.boehm 1.131 EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(
|
4296 kumpf 1.122 parser.getLine(), entry, "RETURNVALUE");
|
4297 dave.sudlik 1.109
|
4298 kumpf 1.27 // Get RETURNVALUE.PARAMTYPE attribute:
4299 // NOTE: Array type return values are not allowed (2/20/02)
4300
|
4301 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4302 "RETURNVALUE", "PARAMTYPE", false);
|
4303 kumpf 1.27
4304 // Parse VALUE.REFERENCE type
|
4305 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4306 kumpf 1.27 {
|
4307 kumpf 1.54 CIMObjectPath reference;
|
4308 kumpf 1.27 if (XmlReader::getValueReferenceElement(parser, reference))
4309 {
4310 returnValue.set(reference);
|
4311 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4312 kumpf 1.67 gotType = true;
|
4313 kumpf 1.27 }
|
4314 kumpf 1.61 else if (type == CIMTYPE_REFERENCE)
|
4315 kumpf 1.27 {
|
4316 kumpf 1.122 MessageLoaderParms mlParms(
4317 "Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",
4318 "expected VALUE.REFERENCE element");
4319 throw XmlValidationError(parser.getLine(), mlParms);
|
4320 kumpf 1.27 }
4321 }
4322
4323 // Parse non-reference return value
|
4324 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4325 kumpf 1.27 {
|
4326 kumpf 1.67 if (!gotType)
|
4327 kumpf 1.27 {
|
4328 kumpf 1.67 // If we don't know what type the value is, read it as a String
|
4329 kumpf 1.61 type = CIMTYPE_STRING;
|
4330 kumpf 1.27 }
|
4331 thilo.boehm 1.131 if (embeddedObject != NO_EMBEDDED_OBJECT)
|
4332 a.dunfey 1.118 {
4333 if (gotType && (type == CIMTYPE_STRING))
4334 {
|
4335 thilo.boehm 1.131 if (embeddedObject == EMBEDDED_OBJECT_ATTR)
|
4336 kumpf 1.122 // Used below by getValueElement() or getValueArrayElement()
4337 type = CIMTYPE_OBJECT;
|
4338 a.dunfey 1.118 else
4339 type = CIMTYPE_INSTANCE;
4340 }
4341 else
4342 {
|
4343 kumpf 1.122 MessageLoaderParms mlParms(
4344 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
4345 karl 1.129 "The EmbeddedObject attribute is only valid on string "
|
4346 kumpf 1.122 "types.");
|
4347 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
4348 }
4349 }
|
4350 kumpf 1.27 if ( !XmlReader::getValueElement(parser, type, returnValue) )
4351 {
|
4352 kumpf 1.122 MessageLoaderParms mlParms(
4353 "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
4354 "expected VALUE element");
4355 throw XmlValidationError(parser.getLine(), mlParms);
|
4356 kumpf 1.27 }
4357 }
4358
4359 expectEndTag(parser, "RETURNVALUE");
|
4360 mike 1.25
4361 return true;
|
4362 mike 1.23 }
4363
|
4364 karl 1.123 //-----------------------------------------------------------------------------
4365 //
4366 // The following is a common set of version tests used by the different
4367 // Pegasus Request and Response Decoders
|
4368 martin 1.137 //
|
4369 karl 1.123 //------------------------------------------------------------------------------
4370 //
4371 // isSupportedCIMVersion()
4372 // tests for valid CIMVersion number
4373 //
4374 // Reject cimVersion not in 2.[0-9]+
|
4375 martin 1.137 //
|
4376 karl 1.123 // CIMXML Secification, Version 2.2 Final, Sect 3.2.1.1
|
4377 kumpf 1.139 // The CIMVERSION attribute defines the version of the CIM Specification to
4378 // which the XML Document conforms. It MUST be in the form of "M.N". Where
4379 // M is the Major Version of the specification in numeric form and N is the
4380 // minor version of the specification in numeric form. For example, "2.0",
4381 // "2.1". Implementations must only validate the major version as all minor
4382 // versions are backward compatible. Implementations may look at the minor
4383 // version to determine additional capabilites.
|
4384 karl 1.123 //
4385 //------------------------------------------------------------------------------
4386 Boolean XmlReader::isSupportedCIMVersion(
4387 const char* cimVersion)
4388 {
4389 Boolean cimVersionAccepted = false;
4390 //printf("testCIMVersion %s \n", cimVersion);
4391 if ((cimVersion[0] == '2') &&
4392 (cimVersion[1] == '.') &&
4393 (cimVersion[2] != 0))
4394 {
4395 // Verify that all characters after the '.' are digits
4396 Uint32 index = 2;
4397 while (isdigit(cimVersion[index]))
4398 {
4399 index++;
4400 }
4401
4402 if (cimVersion[index] == 0)
4403 {
4404 cimVersionAccepted = true;
4405 karl 1.123 }
4406 }
4407 return cimVersionAccepted;
4408 }
4409
4410 //------------------------------------------------------------------------------
4411 //
4412 // isSupportedProtocolVersion()
4413 // tests for valid ProtocolVersion number
4414 //
4415 // Reject ProtocolVersion not 1.[0-9]
4416 //
4417 // cimxml spec 2.2 Final Section 3261
4418 // The PROTOCOLVERSION attribute defines the version of the CIM Operations to
4419 // which this message conforms. It MUST be in the form of "M.N". Where M is
4420 // the Major Version of the specification in numeric form and N is the minor
4421 // version of the specification in numeric form. For example, "1.0", "1.1".
4422 // Implementations must only validate the major version as all minor versions
4423 // are backward compatible. Implementations may look at the minor version to
4424 // determine additional capabilites.
|
4425 martin 1.137 //
|
4426 karl 1.123 //------------------------------------------------------------------------------
4427 Boolean XmlReader::isSupportedProtocolVersion(
4428 const String& protocolVersion)
4429 {
4430 Boolean protocolVersionAccepted = false;
4431
4432 //cout << "testProtocolVersion " << protocolVersion << endl;
4433 if ((protocolVersion.size() >= 3) &&
4434 (protocolVersion[0] == '1') &&
4435 (protocolVersion[1] == '.'))
4436 {
4437 // Verify that all characters after the '.' are digits
4438 Uint32 index = 2;
4439 while ((index < protocolVersion.size()) &&
4440 (protocolVersion[index] >= '0') &&
4441 (protocolVersion[index] <= '9'))
4442 {
4443 index++;
4444 }
4445
4446 if (index == protocolVersion.size())
4447 karl 1.123 {
4448 protocolVersionAccepted = true;
4449 }
4450 }
4451 return protocolVersionAccepted;
4452 }
4453
4454 //------------------------------------------------------------------------------
4455 //
4456 // isSupportedDTDVersion()
4457 // Tests for Valid dtdVersion number
4458 // We accept DTD version 2.[0-9]+ (see Bugzilla 1556)//
|
4459 martin 1.137 //
|
4460 karl 1.123 // CIM/XML Specification, V 2.2 Final, Section 3.2.1.1
|
4461 kumpf 1.139 // The DTDVERSION attribute defines the version of the CIM XML Mapping to
4462 // which the XML Document conforms. It MUST be in the form of "M.N". Where
4463 // M is the Major Version of the specification in numeric form and N is the
4464 // minor version of the specification in numeric form. For example, "2.0",
4465 // "2.1". Implementations must only validate the major version as all minor
4466 // versions are backward compatible. Implementations may look at the minor
4467 // version to determine additional capabilites.
|
4468 karl 1.123 //
4469 //------------------------------------------------------------------------------
4470 Boolean XmlReader::isSupportedDTDVersion(
4471 const char* dtdVersion)
4472 {
4473 Boolean dtdVersionAccepted = false;
4474
4475 //printf("testDTDVersion %s \n", dtdVersion);
4476 if ((dtdVersion[0] == '2') &&
4477 (dtdVersion[1] == '.') &&
4478 (dtdVersion[2] != 0))
4479 {
4480 // Verify that all characters after the '.' are digits
4481 Uint32 index = 2;
4482 while (isdigit(dtdVersion[index]))
4483 {
4484 index++;
4485 }
4486
4487 if (dtdVersion[index] == 0)
4488 {
4489 karl 1.123 dtdVersionAccepted = true;
4490 }
4491 }
4492 return dtdVersionAccepted;
4493 }
|
4494 mike 1.23 PEGASUS_NAMESPACE_END
|
Return to
XmlReader.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common