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