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