Hi Developers, I use Apache Axis2/C version 1.0.0, ported to OopenVMS, also used on Windows 2000 under VS 2005 (C/C++); so far greate stuff.
Now I have the follwoing problem and I think it is a bug in Axis2/C I have to deserialize my payload (build om from xml) and return to updated pointers to two hash tables, each keeping a set of fldnam (key) and fldval (val->value) pairs. The xml payload to be converted into an om model looks like this <root xmlns:e="element" xmlns:ws="workspace" xmlns:col="collection"> <col:wscol> <ws:wsinp> <e:blah01>yuck01</e:blah01> <e:blah02>yuck02</e:blah02> <e:blah03>yuck03</e:blah03> <e:blah04>yuck04</e:blah04> </ws:wsinp> <ws:wsold> <e:blah11>yuck11</e:blah11> <e:blah12>yuck12</e:blah12> <e:blah13>yuck13</e:blah13> <e:blah14>yuck14</e:blah14> </ws:wsold> </col:wscol> </root> The clue is that I can iterate over the hash tables and find my key/value pairs but only as long as I do not execute axiom_document_free(om_document,env); as done in code below. Once this call is executed, pointers to hash tables are still as before, but content, key and value pairs are gone, do no longer exist, and my routine writes out some rubbish. why? I asume this is a bug OR do I something wrong allocating storage for the hash tables key / value pairs? What has to be released from memeory (deallocated), I guess only the om model as I want it but not the key and values of my hash tables. And BTW, if one knows a faster way to deserialize my payload as I do it, just let me know. I will be very thank-full, because I am still a xml/om newby. Thanks for information and regards axis2_bool_t AXIS2_CALL axawl_deserialize_input_payload(axutil_env_t *env, const axis2_char_t *payload_inp, const axutil_hash_t **pphtwsinp, const axutil_hash_t **pphtwsold) { int retval = 0; unsigned __int16 scnt; char *tval2; long ii; const axis2_char_t *encoding = ENCODING; //#define ENCODING "ISO-8859-1" // const axis2_char_t *uri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; axiom_xml_reader_t *xml_reader = NULL; axiom_stax_builder_t *om_builder = NULL; axiom_document_t *om_document = NULL; axiom_node_t *root_node = NULL; axiom_node_t *body = NULL; axiom_node_t *root = NULL; axiom_node_t *wscol = NULL; axiom_node_t *ws = NULL; axiom_node_t *wsinp = NULL; axiom_node_t *wsold = NULL; axiom_node_t *wsout = NULL; axiom_node_t *ele = NULL; axiom_children_qname_iterator_t *children_iter = NULL; axis2_char_t *fldnam = NULL; a *fldval = NULL; const void *key = NULL; void *val = NULL; axutil_hash_index_t *hi; axutil_hash_t *htwsinp = NULL; axutil_hash_t *htwsold = NULL; int status = AXIS2_SUCCESS; env->log->level = AXIS2_LOG_LEVEL_DEBUG; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, " %s %d", "deserialize input payload", 2); scnt = strlen(payload_inp); /** create the parser ---- here we feed our P1 parameter = the input argument in string form */ xml_reader = axiom_xml_reader_create_for_memory(env, payload_inp, scnt, encoding, AXIS2_XML_PARSER_TYPE_BUFFER); if (!xml_reader) { printf("%s \n", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create xml_reader"); return AXIS2_FAILURE; } om_builder = axiom_stax_builder_create(env, xml_reader); if (!om_builder) { axiom_xml_reader_free(xml_reader, env); printf("%s \n", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create om_builder - ERROR CREATING PULLPARSER"); return AXIS2_FAILURE; } /** create an om document document is the container of om model created using builder */ om_document = axiom_stax_builder_get_document(om_builder, env); if (!om_document) { axiom_xml_reader_free(xml_reader, env); printf("%s \n", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create axiom document"); return AXIS2_FAILURE; } root_node = axiom_document_get_root_element(om_document, env); if(!root_node) { axiom_stax_builder_free(om_builder, env); printf("%s \n", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", axutil_error_get_message(env->error)); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create root node from om_document"); return AXIS2_FAILURE; } #ifdef __DEBUG__ lib$signal(SS$_DEBUG); #endif /** Pseudo Code to reflect what shall happen for each wscol in soap_body // we get c:root only for each ws in wscol // we get c:Text c:wsout c:wsold c:wsinp for each ele in ws // we get d:fldnam with fldval as text next ele next ws next **/ /** pre-condition: we have the document with the OM model in it action: we loop over the (sub-)tree and isolates the workspace collection, the workpsaces and the elements in it. workspace nodes are used to identify and create a corresponding hash table and then all elements in the workspace-node are loaded as key and value pairs to hash tables post-condition: after the loop terminates, we have hash tables established and tow are populated with key-value-pairs of strings; we have a hash table for wsinp, wsold and later wsout and htGWKSP But htwsout and htGWKSP are not established here as the intention of the code is jsut to deserialize for ws input and ws old (used to establish the process context, set process context to previous state when client calls in again) **/ // for (root = axiom_soap_body_get_base_node(soap_body, env);root;root = axiom_node_get_next_sibling(root, env)) { for (root = axiom_document_get_root_element(om_document, env);root;root = axiom_node_get_next_sibling(root, env)) { putnode(root, env); for (wscol = axiom_node_get_first_child(root, env);wscol;wscol = axiom_node_get_next_sibling(wscol, env)) { putnode(wscol, env); for (ws = axiom_node_get_first_child(wscol, env);ws; ws = axiom_node_get_next_sibling(ws, env)) { putnode(ws, env); for (ele = axiom_node_get_first_child(ws, env);ele;ele = axiom_node_get_next_sibling(ele, env)) { switch (getWorkspaceID(ele, env)) { case 1: if(!wsinp) wsinp = ws; if (!htwsinp) htwsinp = axutil_hash_make(env); fldval = (a *) AXIS2_MALLOC(env->allocator, sizeof(a)); fldval->value = getFLDVAL(ele, env); fldnam = getFLDNAM(ele, env); printf("\nfldval->value : %s",fldval->value); printf("\nfldnam : %s",fldnam); axutil_hash_set(htwsinp, fldnam, AXIS2_HASH_KEY_STRING, fldval); break; case 2: if(!wsold) wsold = ws; if (!htwsold) htwsold = axutil_hash_make(env); fldval = (a *) AXIS2_MALLOC(env->allocator, sizeof(a)); fldval->value = getFLDVAL(ele, env); fldnam = getFLDNAM(ele, env); printf("\nfldval->value : %s",fldval->value); printf("\nfldnam : %s",fldnam); axutil_hash_set(htwsold, fldnam, AXIS2_HASH_KEY_STRING, fldval); break; default: break; } } } } } for (hi = axutil_hash_first(htwsinp, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, &val); printf("\nkey\t: %s", key); printf("\tval\t: %s", ((a *) val)->value); } /** QUESTION: do we need the parsed in document and om model any longer? NO - we can safely free all of it, memory space and we create a new om_document with om as root wscol ws and elements in it later, after the warpper returns. **/ axiom_document_free(om_document,env); for (hi = axutil_hash_first(htwsinp, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, &val); printf("\nkey\t: %s", key); printf("\tval\t: %s", ((a *) val)->value); } /** let us update all our hash_table_pointers to use the hash_tables after we return to the caller of this routine. **/ *pphtwsinp = htwsinp; *pphtwsold = htwsold; return AXIS2_SUCCESS; }