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