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