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