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