| /******************************************************************************* |
| * Copyright (C) 2004-2006 Intel Corp. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * - Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * - Neither the name of Intel Corp. nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| *******************************************************************************/ |
| |
| /** |
| * @author Vadim Revyakin |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <time.h> |
| |
| #include "u/libu.h" |
| #include "wsman-soap.h" |
| #include "wsman-xml.h" |
| #include "wsman-xml-serializer.h" |
| #include "wsman-xml-serialize.h" |
| #include "wsman-epr.h" |
| #include "wsman-debug.h" |
| |
| #define CLASSNAME "Sample" |
| |
| |
| |
| static void example1(void) |
| { |
| |
| #define EX1_NS "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem" |
| |
| XML_TYPE_UINT16 myshorts[] = { 5, 11, 14, 19, 27, 36 }; |
| SER_TYPEINFO_UINT16; |
| struct __Sample_Servie { |
| XML_TYPE_BOOL AcceptPause; |
| XML_TYPE_BOOL AcceptStop; |
| XML_TYPE_STR Caption; |
| XML_TYPE_UINT32 CheckPoint; |
| XML_TYPE_STR CreationClassName; |
| XML_TYPE_STR Description; |
| XML_TYPE_BOOL DesktopInteract; |
| XML_TYPE_STR DisplayName; |
| XML_TYPE_STR ErrorControl; |
| XML_TYPE_UINT32 ExitCode; |
| XML_TYPE_STR InstallDate; |
| XML_TYPE_STR Name; |
| XML_TYPE_STR PathName; |
| XML_TYPE_UINT32 ProcessId; |
| XML_TYPE_UINT32 ServiceSpecificExitCode; |
| XML_TYPE_STR ServiceType; |
| XML_TYPE_BOOL Started; |
| XML_TYPE_STR StartMode; |
| XML_TYPE_STR StartName; |
| XML_TYPE_STR State; |
| XML_TYPE_STR Status; |
| XML_TYPE_STR SystemCreationClassName; |
| XML_TYPE_STR SystemName; |
| XML_TYPE_UINT32 TagId; |
| XML_TYPE_UINT32 WaitHint; |
| XML_TYPE_UINT64 Uint64; |
| XML_TYPE_DYN_ARRAY shorts; |
| }; |
| typedef struct __Sample_Servie Sample_Servie; |
| |
| Sample_Servie servie = { |
| 0, |
| 1, |
| "Caption", |
| 30, |
| "CreationClassName", |
| "Description", |
| 1, |
| "DisplayName", |
| "ErrorControl", |
| 50, |
| "InstallDate", |
| "Name", |
| "PathName", |
| 60, |
| 70, |
| "ServiceType", |
| 0, |
| "StartMode", |
| "StartName", |
| "State", |
| "Status", |
| "SystemCreationClassName", |
| "SystemName", |
| 90, |
| 100, |
| 1000000, |
| {6, myshorts } |
| }; |
| |
| SER_START_ITEMS(Sample_Servie) |
| SER_BOOL("AcceptPause", 1), |
| SER_BOOL("AcceptStop", 1), |
| SER_STR("Caption", 1), |
| SER_UINT32("CheckPoint", 1), |
| SER_STR("CreationClassName", 1), |
| SER_STR("Description", 1), |
| SER_BOOL("DesktopInteract", 1), |
| SER_NS_STR(EX1_NS, "DisplayName", 1), |
| SER_STR("ErrorControl", 1), |
| SER_UINT32("ExitCode", 1), |
| SER_STR("InstallDate", 1), |
| SER_STR("Name", 1), |
| SER_STR("PathName", 1), |
| SER_UINT32("ProcessId", 1), |
| SER_UINT32("ServiceSpecificExitCode", 1), |
| SER_STR("ServiceType", 1), |
| SER_BOOL("Started", 1), |
| SER_STR("StartMode", 1), |
| SER_STR("StartName", 1), |
| SER_STR("State", 1), |
| SER_STR("Status", 1), |
| SER_STR("SystemCreationClassName", 1), |
| SER_STR("SystemName", 1), |
| SER_UINT32("TagId", 1), |
| SER_UINT32("WaitHint", 1), |
| SER_UINT64("Uint64", 1), |
| SER_DYN_ARRAY("shorts", 0, 1000, uint16), |
| SER_END_ITEMS(Sample_Servie); |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf("\n\n ******** example1. Basic types ********\n"); |
| |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &servie, Sample_Servie_TypeInfo, |
| CLASSNAME, NULL, NULL, 0); |
| printf("ws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| node = ws_xml_get_doc_root(doc); |
| |
| //WsXmlDocH xx = ws_xml_read_file( ws_context_get_runtime(cntx), "./test.xml", "UTF-8", 0 ); |
| //node = ws_xml_get_doc_root(xx); |
| Sample_Servie *cs = (Sample_Servie *) ws_deserialize(cntx, |
| node, |
| Sample_Servie_TypeInfo, |
| CLASSNAME, |
| NULL, NULL, |
| 0, 0); |
| if (cs == NULL) { |
| printf("Error in ws_serialize\n"); |
| return; |
| } |
| |
| |
| retval = memcmp(cs, &servie, sizeof(servie)); |
| if (retval) { |
| printf("Not compared (%d) - FAILED\n", retval); |
| printf("%d : %d\n", servie.AcceptPause, cs->AcceptPause); |
| printf("%d : %d\n", servie.AcceptStop, cs->AcceptStop); |
| printf("%s : %s\n", servie.Caption, cs->Caption); |
| } |
| } |
| |
| |
| |
| |
| static void example2(void) |
| { |
| |
| typedef struct { |
| XML_TYPE_UINT8 byte1; |
| XML_TYPE_UINT32 int1; |
| XML_TYPE_UINT8 byte2; |
| } Foo; |
| |
| typedef struct { |
| XML_TYPE_UINT8 byte1; |
| XML_TYPE_UINT16 short1; |
| XML_TYPE_UINT32 int1; |
| char *string1; |
| Foo foo; |
| } Sample; |
| |
| |
| Sample sample = { 1, 2, 4, "string", {5, 196, 8} }; |
| |
| SER_START_ITEMS(Foo) |
| SER_UINT8("FOOBYTE1", 1), |
| SER_UINT32("FOOINT32", 1), |
| SER_UINT8("FOOBYTE2", 1), |
| SER_END_ITEMS(Foo); |
| |
| |
| SER_START_ITEMS(Sample) |
| SER_UINT8("BYTE", 1), |
| SER_UINT16("SHORT", 1), |
| SER_UINT32("INT32", 1), |
| SER_STR("STRING", 1), |
| SER_STRUCT("FOO", 1, Foo), |
| SER_END_ITEMS(Sample); |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf |
| ("\n\n ******** example2. Structure with pads. ********\n"); |
| |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, 0); |
| printf("ws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| node = ws_xml_get_doc_root(doc); |
| Sample *cs = (Sample *) ws_deserialize(cntx, |
| node, |
| Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, |
| 0, 0); |
| if (cs == NULL) { |
| printf("Errror ws_deserialize\n"); |
| return; |
| } |
| |
| printf("\n initial and deserialized structures\n"); |
| printf(" byte1 = %d : %d\n", sample.byte1, cs->byte1); |
| printf(" short1 = %d : %d\n", sample.short1, cs->short1); |
| printf(" int1 = %d : %d\n", sample.int1, cs->int1); |
| printf(" string1 = <%s> : <%s>\n", sample.string1, |
| cs->string1); |
| printf(" foo :\n"); |
| printf(" byte1 = %d : %d\n", sample.foo.byte1, |
| cs->foo.byte1); |
| printf(" int1 = %d : %d\n", sample.foo.int1, |
| cs->foo.int1); |
| printf(" byte2 = %d : %d\n", sample.foo.byte2, |
| cs->foo.byte2); |
| } |
| |
| |
| |
| static void example3(void) |
| { |
| typedef struct { |
| XML_TYPE_UINT8 a; |
| XML_TYPE_UINT8 b; |
| XML_TYPE_UINT8 c; |
| XML_TYPE_UINT8 pad; |
| XML_TYPE_STR string; |
| } Sample; |
| |
| |
| |
| SER_START_ITEMS(Sample) |
| SER_UINT8("a", 1), |
| SER_UINT8("b", 1), |
| SER_UINT8("c", 1), |
| SER_IN_UINT8("pad", 1), |
| SER_STR("string", 1), SER_END_ITEMS(Sample); |
| |
| Sample sample = { 'a', 'b', 'c', 'x', "simple string" }; |
| // Sample *p = NULL; |
| |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf("\n\n ******** example3. Skip elements. ********\n"); |
| |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, 0); |
| printf("ws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| printf("\n\nws_deserialize (prints original : result):\n"); |
| |
| node = ws_xml_get_doc_root(doc); |
| Sample *cs = (Sample *) ws_deserialize(cntx, |
| node, |
| Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, |
| 0, 0); |
| if (cs == NULL) { |
| printf("Errror ws_serialize\n"); |
| return; |
| } |
| |
| printf("a = %c : %c\n", sample.a, cs->a); |
| printf("b = %c : %c\n", sample.b, cs->b); |
| printf("c = %c : %c\n", sample.c, cs->c); |
| printf("pad = %c(%d) : %c(%d)\n", sample.pad, sample.pad, |
| cs->pad, cs->pad); |
| printf("string = <%s> : <%s>\n", sample.string, cs->string); |
| } |
| |
| |
| static void example4(void) |
| { |
| |
| typedef struct { |
| XML_TYPE_BOOL a; |
| XML_TYPE_STR string; |
| XML_TYPE_BOOL b; |
| } Embed; |
| |
| typedef struct { |
| XML_TYPE_UINT32 A; |
| Embed EMBED[2]; |
| XML_TYPE_STR STRING; |
| } Sample; |
| |
| |
| Sample sample = { |
| 10, |
| {{1, "string 1", 0}, {0, "string 2", 1},}, |
| "STRING", |
| }; |
| |
| SER_START_ITEMS(Embed) |
| SER_BOOL("a", 1), |
| SER_STR("string", 1), SER_BOOL("b", 1), SER_END_ITEMS(Embed); |
| |
| SER_START_ITEMS(Sample) |
| SER_UINT32("A", 1), |
| SER_STRUCT("EMBED", 2, Embed), |
| SER_STR("STRING", 1), SER_END_ITEMS(Sample); |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf |
| ("\n\n ******** example4. Static structure array ********\n"); |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc(NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, 0); |
| printf("ws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| } |
| |
| |
| |
| |
| |
| static void example5(void) |
| { |
| |
| |
| typedef struct { |
| XML_TYPE_BOOL AcceptPause; |
| XML_TYPE_STR Caption; |
| } Foo; |
| |
| Foo foos[] = { |
| {1, "Caption 1"}, |
| {0, "Caption 2"}, |
| {1, "Caption 1",}, |
| {0, "Caption 2",}, |
| }; |
| |
| |
| SER_START_ITEMS(Foo) |
| SER_BOOL("AcceptPause", 1), |
| SER_STR("Caption", 1), SER_END_ITEMS(Foo); |
| |
| XML_TYPE_UINT16 myshorts[] = { 5, 11, 14, 19, 27, 36 }; |
| SER_TYPEINFO_UINT16; |
| |
| typedef struct { |
| XML_TYPE_STR city; |
| XML_TYPE_DYN_ARRAY shorts; |
| XML_TYPE_DYN_ARRAY foos; |
| XML_TYPE_UINT16 tag; |
| } Sample; |
| |
| Sample sample = { "Moscow", {6, myshorts}, {2, foos}, 99 }; |
| |
| SER_START_ITEMS(Sample) |
| SER_STR("city", 1), |
| SER_DYN_ARRAY("shorts", 0, 1000, uint16), |
| SER_DYN_ARRAY("foos", 0, 1000, Foo), |
| SER_UINT16("tag", 1), SER_END_ITEMS(Sample); |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf("\n\n ******** example 5: Dynamic arrays ********\n"); |
| |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, 0); |
| printf("\n\nws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| node = ws_xml_get_doc_root(doc); |
| |
| printf("\n\nws_deserialize:\n"); |
| Sample *cs = (Sample *) ws_deserialize(cntx, |
| node, |
| Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, |
| 0, 0); |
| if (cs == NULL) { |
| printf("Error ws_deserialize\n"); |
| return; |
| } |
| int i; |
| printf("shorts count = %d\n", cs->shorts.count); |
| printf("foos count = %d\n", cs->foos.count); |
| printf("\n"); |
| printf(" city = <%s>\n", cs->city); |
| if (cs->shorts.data == NULL) { |
| printf("No uint16 objects\n"); |
| goto AFTER_SHORTS; |
| } |
| unsigned short *newuints = (unsigned short *) cs->shorts.data; |
| printf(" shorts = {"); |
| for (i = 0; i < cs->shorts.count; i++) { |
| printf("%u, ", *newuints); |
| newuints++; |
| } |
| printf("}\n"); |
| AFTER_SHORTS: |
| if (cs->foos.data == NULL) { |
| printf("No foo objects\n"); |
| goto AFTER_FOOS; |
| } |
| Foo *newfoos = cs->foos.data; |
| for (i = 0; i < cs->foos.count; i++) { |
| printf(" ==== Foo %d =====\n", i); |
| printf(" AcceptPause = %d\n", newfoos->AcceptPause); |
| printf(" Caption = <%s>\n", newfoos->Caption); |
| printf(" ==== End of Foo %d =====\n", i); |
| newfoos++; |
| } |
| AFTER_FOOS: |
| printf(" tag = %d\n", cs->tag); |
| } |
| |
| static void example6(void) |
| { |
| typedef struct { |
| struct { |
| XML_TYPE_UINT8 body; |
| XML_NODE_ATTR *attrs; |
| } uint8_with_attrs; |
| struct { |
| XML_TYPE_UINT16 body; |
| XML_NODE_ATTR *attrs; |
| } uint16_with_attrs; |
| struct { |
| XML_TYPE_UINT32 body; |
| XML_NODE_ATTR *attrs; |
| } uint32_with_attrs; |
| struct { |
| XML_TYPE_BOOL body; |
| XML_NODE_ATTR *attrs; |
| } bool_with_attrs; |
| struct { |
| XML_TYPE_STR body; |
| XML_NODE_ATTR *attrs; |
| } str_with_attrs; |
| } Dummy; |
| |
| typedef struct { |
| struct { |
| Dummy body; |
| XML_NODE_ATTR *attrs; |
| } struct_with_attrs; |
| } Sample; |
| |
| XML_NODE_ATTR attrs[] = { |
| {NULL, NULL, "Uint8AttrName1", "Uint8AttrValue1"}, |
| {NULL, NULL, "Uint16AttrName1", "Uint16AttrValue1"}, |
| {NULL, NULL, "Uint32AttrName1", "Uint32AttrValue1"}, |
| {NULL, NULL, "BoolAttrName1", "BoolAttrValue1"}, |
| {NULL, NULL, "StringAttrName1", "StringAttrValue1"}, |
| }; |
| XML_NODE_ATTR str_attrs[3] = { |
| {NULL, NULL, "AttrName1", "AttrValue1"}, |
| {NULL, NULL, "AttrName2", "AttrValue2"}, |
| {NULL, XML_NS_ADDRESSING, "AttrQName", "AttrValue3"}, |
| }; |
| Sample sample = { |
| { |
| { |
| {8, &attrs[0]}, |
| {16, &attrs[1]}, |
| {32, &attrs[2]}, |
| {0, &attrs[3]}, |
| {"string", &attrs[4]}, |
| }, |
| &str_attrs[0] |
| } |
| }; |
| str_attrs[0].next = &str_attrs[1]; |
| str_attrs[1].next = &str_attrs[2]; |
| |
| SER_START_ITEMS(Dummy) |
| SER_ATTR_NS_UINT8_FLAGS(NULL, "UINT8", 1, 0), |
| SER_ATTR_NS_UINT16_FLAGS(NULL, "UINT16", 1, 0), |
| SER_ATTR_NS_UINT32_FLAGS(NULL, "UINT32", 1, 0), |
| SER_ATTR_NS_BOOL_FLAGS(NULL, "BOOL", 1, 0), |
| SER_ATTR_NS_STR_FLAGS(NULL, "STRING", 1, 0), |
| SER_END_ITEMS(Dummy); |
| |
| SER_START_ITEMS(Sample) |
| SER_ATTR_NS_STRUCT_FLAGS(XML_NS_WS_MAN, "STRUCT", 1, 0, Dummy), |
| SER_END_ITEMS(Sample); |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf |
| ("\n\n ******** example 6. Nodes with attributes ********\n"); |
| |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, |
| CLASSNAME, XML_NS_WS_MAN, NULL, 0); |
| printf("\n\nws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| Sample *news; |
| printf("\n\nws_deserialize:\n"); |
| news = (Sample *) ws_deserialize(cntx, |
| node, |
| Sample_TypeInfo, |
| CLASSNAME, |
| XML_NS_ADDRESSING, NULL, 0, 0); |
| if (news == NULL) { |
| printf("Errror ws_deserialize\n"); |
| return; |
| } |
| |
| XML_NODE_ATTR *nattrs; |
| Dummy *dm = &(news->struct_with_attrs.body); |
| printf("**** Deserialized document %p *****\n", news); |
| printf("struct_with_attrs.body ("); |
| nattrs = news->struct_with_attrs.attrs; |
| while (nattrs) { |
| printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, |
| nattrs->value); |
| nattrs = nattrs->next; |
| } |
| printf(")\n"); |
| |
| printf(" uint8_with_attrs = %d (", dm->uint8_with_attrs.body); |
| nattrs = dm->uint8_with_attrs.attrs; |
| while (nattrs) { |
| printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, |
| nattrs->value); |
| nattrs = nattrs->next; |
| } |
| printf(")\n"); |
| |
| printf(" uint16_with_attrs = %d (", dm->uint16_with_attrs.body); |
| nattrs = dm->uint16_with_attrs.attrs; |
| while (nattrs) { |
| printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, |
| nattrs->value); |
| nattrs = nattrs->next; |
| } |
| printf(")\n"); |
| |
| printf(" uint32_with_attrs = %d (", dm->uint32_with_attrs.body); |
| nattrs = dm->uint32_with_attrs.attrs; |
| while (nattrs) { |
| printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, |
| nattrs->value); |
| nattrs = nattrs->next; |
| } |
| printf(")\n"); |
| |
| printf(" bool_with_attrs = %d (", dm->bool_with_attrs.body); |
| nattrs = dm->bool_with_attrs.attrs; |
| while (nattrs) { |
| printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, |
| nattrs->value); |
| nattrs = nattrs->next; |
| } |
| printf(")\n"); |
| |
| printf(" str_with_attrs = %s (", dm->str_with_attrs.body); |
| nattrs = dm->str_with_attrs.attrs; |
| while (nattrs) { |
| printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, |
| nattrs->value); |
| nattrs = nattrs->next; |
| } |
| printf(")\n"); |
| } |
| |
| |
| |
| |
| static void example7(void) |
| { |
| typedef struct { |
| XML_TYPE_STR value; |
| XML_NODE_ATTR *attrs; |
| } Selector; |
| |
| SER_TYPEINFO_STRING_ATTR; |
| |
| |
| typedef struct { |
| XML_TYPE_DYN_ARRAY selectors; |
| } SelectorSet; |
| |
| SER_START_ITEMS(SelectorSet) |
| SER_NS_DYN_ARRAY(XML_NS_WS_MAN, WSM_SELECTOR, 0, 1000, |
| string_attr), SER_END_ITEMS(SelectorSet); |
| |
| |
| typedef struct { |
| XML_TYPE_STR uri; |
| SelectorSet selectorset; |
| } ReferenceParameters; |
| |
| SER_START_ITEMS(ReferenceParameters) |
| SER_NS_STR(XML_NS_WS_MAN, WSM_RESOURCE_URI, 1), |
| SER_NS_STRUCT(XML_NS_WS_MAN, WSM_SELECTOR_SET, 1, SelectorSet), |
| SER_END_ITEMS(ReferenceParameters); |
| |
| typedef struct { |
| XML_TYPE_STR address; |
| ReferenceParameters refparams; |
| } EPR; |
| |
| SER_START_ITEMS(EPR) |
| SER_NS_STR(XML_NS_ADDRESSING, WSA_ADDRESS, 1), |
| SER_NS_STRUCT(XML_NS_ADDRESSING, WSA_REFERENCE_PARAMETERS, 1, |
| ReferenceParameters), SER_END_ITEMS(EPR); |
| |
| XML_NODE_ATTR attrs[3] = { |
| {NULL, NULL, "Name", "SelName1"}, |
| {NULL, NULL, "Name", "SelName2"}, |
| {NULL, NULL, "Name", "SelName3"}, |
| }; |
| Selector selectors[] = { |
| {"selector1", &attrs[0]}, |
| {"selector2", &attrs[1]}, |
| {"selector3", &attrs[2]} |
| }; |
| EPR Epr = { |
| "http://localhost:8889/wsman", |
| {"http://acme.org/hardware/2005/02/storage/physDisk", |
| {{3, selectors}} |
| } |
| }; |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf |
| ("\n\n ******** example7. Endpoint Reference ********\n"); |
| |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &Epr, EPR_TypeInfo, |
| "EndpointReference", XML_NS_ADDRESSING, NULL, |
| 0); |
| printf("\n\nws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| EPR *newEPR; |
| node = ws_xml_get_doc_root(doc); |
| |
| printf("\n\nws_deserialize:\n"); |
| newEPR = (EPR *) ws_deserialize(cntx, |
| node, |
| EPR_TypeInfo, |
| "EndpointReference", |
| XML_NS_ADDRESSING, NULL, 0, 0); |
| if (newEPR == NULL) { |
| printf("Errror ws_deserialize\n"); |
| return; |
| } |
| |
| printf("**** Deserialized document *****\n"); |
| printf("address = %s\n", newEPR->address); |
| printf("refparams.uri = %s\n", newEPR->refparams.uri); |
| int i; |
| Selector *ss = |
| (Selector *) newEPR->refparams.selectorset.selectors.data; |
| if (ss == NULL) { |
| printf |
| (" !!!! newEPR->refparams.selectors.data == NULL\n"); |
| return; |
| } |
| for (i = 0; i < newEPR->refparams.selectorset.selectors.count; i++) { |
| Selector *s; |
| s = ss + i; |
| printf(" Selector("); |
| XML_NODE_ATTR *a = s->attrs; |
| while (a) { |
| printf("%s:%s=%s", |
| a->ns ? a->ns : "", a->name, a->value); |
| a = a->next; |
| } |
| printf(") = %s\n", s->value); |
| } |
| } |
| |
| |
| |
| static void example8(void) |
| { |
| |
| printf |
| ("\n\n ******** example8. XML datetime deserialization ********\n"); |
| |
| char xml_dttm[] = "2007-02-13T12:39:14-03:30"; |
| XML_DATETIME dttm; |
| |
| if (ws_deserialize_datetime(xml_dttm, &dttm)) { |
| printf("deserialization failed\n"); |
| return; |
| } |
| printf("XML datetime = %s\n", xml_dttm); |
| printf("deserialed = %u-%u-%uT%u:%u:%u %i\n", dttm.tm.tm_year, |
| dttm.tm.tm_mon, dttm.tm.tm_mday, dttm.tm.tm_hour, |
| dttm.tm.tm_min, dttm.tm.tm_sec, dttm.tz_min); |
| } |
| |
| |
| |
| |
| |
| // No serialization examples(shttpd_0) |
| |
| #if 0 |
| static void example106() |
| { |
| char *data = |
| "<dummy><qq>This is qq body</qq><pp>This is pp</pp></dummy>"; |
| // WsXmlDocH response; |
| WsManClient *cl = wsman_create_client("mstevbakrov.ims.intel.com", |
| 8889, |
| "/wsman", |
| "http", |
| "wsman", |
| "secret"); |
| |
| client_opt_t *options = wsmc_options_init(); |
| |
| WsXmlDocH request = wsmc_create_request(cl, |
| "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem", |
| options, |
| WSMAN_ACTION_TRANSFER_CREATE, |
| NULL, NULL); |
| WsXmlDocH d = |
| wsmc_read_memory(cl, data, strlen(data), NULL, 0); |
| ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(d)); |
| // WsXmlNodeH n = ws_xml_get_doc_root(d); |
| |
| ws_xml_duplicate_tree(ws_xml_get_soap_body(request), |
| ws_xml_get_doc_root(d)); |
| ws_xml_destroy_doc(d); |
| // ws_xml_copy_node(ws_xml_get_doc_root(d), ws_xml_get_soap_body(request)); |
| ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(request)); |
| wsman_release_client(cl); |
| ws_xml_destroy_doc(request); |
| } |
| |
| #endif |
| |
| |
| static void example9(void) |
| { |
| typedef struct { |
| }empty; |
| SER_START_ITEMS(empty) |
| SER_END_ITEMS(empty); |
| char xmlstring[] = "<example></example>"; |
| WsXmlDocH doc = ws_xml_read_memory(xmlstring, strlen(xmlstring), "UTF-8", 0); |
| WsXmlNodeH node = ws_xml_get_doc_root(doc); |
| WsSerializerContextH cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| void *ptr = NULL; |
| ptr = ws_deserialize(cntx, |
| node, |
| empty_TypeItems, |
| NULL, |
| NULL, NULL, 0, 0); |
| printf("ptr = %p\n", ptr); |
| ws_serializer_cleanup(cntx); |
| |
| } |
| |
| static void example10() |
| { |
| char xmlstring[] = "<example><PowerState xsi:nil=\"true\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"/></example>"; |
| // char xmlstring[] = "<example><PowerState state = \"critical\">5</PowerState></example>"; |
| typedef struct { |
| XML_TYPE_STR value; |
| XML_NODE_ATTR *attrs; |
| } item; |
| SER_TYPEINFO_STRING_ATTR; |
| WsXmlDocH doc = ws_xml_read_memory(xmlstring, strlen(xmlstring), "UTF-8", 0); |
| WsXmlNodeH node = ws_xml_get_doc_root(doc); |
| printf |
| ("\n\n ******** example10. xsi:nil attibute test ********\n"); |
| WsSerializerContextH cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| item *value = (item *)ws_deserialize(cntx, node, string_attr_TypeInfo, "PowerState", NULL, NULL, 0, 0); |
| if(value->attrs) |
| printf("*********attrs->ns = %s attrs->name = %s attrs->value = %s*********\n", value->attrs->ns, value->attrs->name, value->attrs->value); |
| if(ws_havenilvalue(value->attrs)) |
| printf("******** the attribute has xsi:nil ********\n"); |
| ws_xml_destroy_doc(doc); |
| ws_serializer_cleanup(cntx); |
| } |
| |
| static void example11() |
| { |
| typedef struct { |
| XML_TYPE_INT8 byte1; |
| XML_TYPE_INT32 int1; |
| XML_TYPE_INT8 byte2; |
| } Foo; |
| |
| typedef struct { |
| XML_TYPE_INT8 byte1; |
| XML_TYPE_INT16 short1; |
| XML_TYPE_INT32 int1; |
| char *string1; |
| Foo foo; |
| } Sample; |
| |
| |
| Sample sample = { -1, -127, 4, "string", {-12, 196, 8} }; |
| |
| SER_START_ITEMS(Foo) |
| SER_INT8("FOOBYTE1", 1), |
| SER_INT32("FOOINT32", 1), |
| SER_INT8("FOOBYTE2", 1), |
| SER_END_ITEMS(Foo); |
| |
| |
| SER_START_ITEMS(Sample) |
| SER_INT8("BYTE", 1), |
| SER_INT16("SHORT", 1), |
| SER_INT32("INT32", 1), |
| SER_STR("STRING", 1), |
| SER_STRUCT("FOO", 1, Foo), |
| SER_END_ITEMS(Sample); |
| |
| WsSerializerContextH cntx; |
| WsXmlDocH doc; |
| WsXmlNodeH node; |
| int retval; |
| |
| printf |
| ("\n\n ******** example11. Structure with pads (signed int test). ********\n"); |
| |
| cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, 0); |
| printf("ws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| node = ws_xml_get_doc_root(doc); |
| Sample *cs = (Sample *) ws_deserialize(cntx, |
| node, |
| Sample_TypeInfo, |
| CLASSNAME, NULL, NULL, |
| 0, 0); |
| if (cs == NULL) { |
| printf("Errror ws_deserialize\n"); |
| return; |
| } |
| |
| printf("\n initial and deserialized structures\n"); |
| printf(" byte1 = %d : %d\n", sample.byte1, cs->byte1); |
| printf(" short1 = %d : %d\n", sample.short1, cs->short1); |
| printf(" int1 = %d : %d\n", sample.int1, cs->int1); |
| printf(" string1 = <%s> : <%s>\n", sample.string1, |
| cs->string1); |
| printf(" foo :\n"); |
| printf(" byte1 = %d : %d\n", sample.foo.byte1, |
| cs->foo.byte1); |
| printf(" int1 = %d : %d\n", sample.foo.int1, |
| cs->foo.int1); |
| printf(" byte2 = %d : %d\n", sample.foo.byte2, |
| cs->foo.byte2); |
| } |
| |
| static void example12() |
| { |
| typedef struct { |
| XML_TYPE_REAL32 value; |
| XML_NODE_ATTR *attrs; |
| } item; |
| item org = {1.257,NULL}; |
| SER_TYPEINFO_REAL32_ATTR; |
| WsXmlDocH doc; |
| WsXmlNodeH node = ws_xml_get_doc_root(doc); |
| printf |
| ("\n\n ******** example12. real32/64 deserialize/serialize ********\n"); |
| WsSerializerContextH cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| doc = ws_xml_create_doc( NULL, "example"); |
| node = ws_xml_get_doc_root(doc); |
| |
| int retval = ws_serialize(cntx, node, &org, real32_TypeInfo, |
| "PowerState", NULL, NULL, 0); |
| printf("ws_serialize: %d\n", retval); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| item *con = (item *)ws_deserialize(cntx, node, real32_TypeInfo, "PowerState", NULL, NULL, 0, 0); |
| if(con->value != org.value) { |
| printf("Mismatched! org.value = %f con->value = %f\n", org.value, con->value); |
| } |
| ws_xml_destroy_doc(doc); |
| ws_serializer_cleanup(cntx); |
| } |
| |
| static void example13() |
| { |
| XML_TYPE_UINT8 myshorts[] = { 5, 11, 14}; |
| typedef struct { |
| XML_TYPE_UINT16 id; |
| XML_TYPE_DYN_ARRAY shorts; |
| }item; |
| XML_TYPE_DYN_ARRAY array_int8; |
| SER_TYPEINFO_UINT8; |
| SER_TYPEINFO_UINT16; |
| SER_START_ITEMS(item) |
| SER_INT16("id", 1), |
| SER_DYN_ARRAY("temp", 0, 100, uint8), |
| SER_END_ITEMS(item); |
| char xmlstring[] = "<example><Sample><id>3</id></Sample></example>"; |
| printf |
| ("\n\n ****** example 13. de-serialize to int8 array (empty array de-serialization test) ******\n"); |
| WsXmlDocH doc = ws_xml_read_memory(xmlstring, strlen(xmlstring), "UTF-8", 0); |
| WsXmlNodeH node = ws_xml_get_doc_root(doc); |
| |
| WsSerializerContextH cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| item *desvalue = (item *)ws_deserialize(cntx, node, item_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); |
| printf("desvlaue = %p\n", desvalue); |
| array_int8 = desvalue->shorts; |
| int i = 0; |
| printf("id = %d, array_int8->count = %d\n",desvalue->id, array_int8.count); |
| while(i < array_int8.count) { |
| printf("%d ", ((char *)array_int8.data)[i]); |
| i++; |
| } |
| printf("\n"); |
| ws_serializer_cleanup(cntx); |
| } |
| |
| static void example14() |
| { |
| typedef struct{ |
| }empty; |
| SER_START_ITEMS(empty) |
| SER_END_ITEMS(empty); |
| typedef struct { |
| XML_TYPE_INT16 num; |
| empty empty1; |
| }A; |
| SER_TYPEINFO_INT16; |
| SER_START_ITEMS(A) |
| SER_INT16("id",1), |
| SER_NS_STRUCT(NULL, "empty", 1, empty), |
| SER_END_ITEMS(A); |
| A a1 = {-12, {}}; |
| printf |
| ("\n\n ******* example 14. serialize/de-serialze with empty t_TypeItems *******\n"); |
| WsSerializerContextH cntx = ws_serializer_init(); |
| if (cntx == NULL) { |
| printf("Error ws_create_runtime\n"); |
| return; |
| } |
| WsXmlDocH doc = ws_xml_create_doc(NULL, "example"); |
| WsXmlNodeH node = ws_xml_get_doc_root(doc); |
| empty values = {}; |
| int ret = ws_serialize(cntx, node, &values, A_TypeInfo, CLASSNAME, NULL, NULL, 0); |
| printf("serialize %i bytes\n", ret); |
| ws_xml_dump_node_tree(stdout, node); |
| |
| void *ptr = ws_deserialize(cntx, node, A_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); |
| printf("ptr = %p\n", ptr); |
| ws_serializer_cleanup(cntx); |
| } |
| |
| static void initialize_logging(void) |
| { |
| debug_add_handler(wsman_debug_message_handler, DEBUG_LEVEL_ALWAYS, |
| NULL); |
| } |
| |
| int debug_level = 0; |
| int main(int argc, char **argv) |
| { |
| int num; |
| int i; |
| char retval = 0; |
| u_error_t *error = NULL; |
| u_option_entry_t opt[] = { |
| {"debug", 'd', U_OPTION_ARG_INT, &debug_level, |
| "Set the verbosity of debugging output.", "1-6"} |
| }; |
| u_option_context_t *opt_ctx; |
| opt_ctx = u_option_context_new(""); |
| u_option_context_set_ignore_unknown_options(opt_ctx, FALSE); |
| u_option_context_add_main_entries(opt_ctx, opt, "wsmid_identify"); |
| retval = u_option_context_parse(opt_ctx, &argc, &argv, &error); |
| |
| u_option_context_free(opt_ctx); |
| |
| if (error) { |
| if (error->message) |
| printf("%s\n", error->message); |
| u_error_free(error); |
| return 1; |
| } |
| u_error_free(error); |
| |
| if (debug_level) { |
| initialize_logging(); |
| wsman_debug_set_level(debug_level); |
| } |
| |
| if (argc == 1) { |
| // execute all |
| example1(); |
| example2(); |
| example3(); |
| example4(); |
| example5(); |
| example6(); |
| example7(); |
| example8(); |
| example9(); |
| example10(); |
| example11(); |
| example12(); |
| example13(); |
| example14(); |
| return 0; |
| } |
| |
| for (i = 1; i < argc; i++) { |
| num = atoi(argv[i]); |
| switch (num) { |
| case 1: |
| example1(); |
| break; |
| case 2: |
| example2(); |
| break; |
| case 3: |
| example3(); |
| break; |
| case 4: |
| example4(); |
| break; |
| case 5: |
| example5(); |
| break; |
| case 6: |
| example6(); |
| break; |
| case 7: |
| example7(); |
| break; |
| case 8: |
| example8(); |
| break; |
| case 9: |
| example9(); |
| break; |
| case 10: |
| example10(); |
| break; |
| case 11: |
| example11(); |
| break; |
| case 12: |
| example12(); |
| break; |
| case 13: |
| example13(); |
| break; |
| case 14: |
| example14(); |
| break; |
| default: |
| printf("\n No example%d()\n", num); |
| break; |
| } |
| } |
| return 0; |
| } |