/* parse "create station" answer (it returns a new station structure) * @param piano handle * @param xml document * @return nothing yet */ PianoReturn_t PianoXmlParseCreateStation (PianoHandle_t *ph, char *xml) { ezxml_t xmlDoc, dataNode; PianoStation_t *tmpStation; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } dataNode = ezxml_get (xmlDoc, "params", 0, "param", 0, "value", 0, "struct", -1); if ((tmpStation = calloc (1, sizeof (*tmpStation))) == NULL) { ezxml_free (xmlDoc); return PIANO_RET_OUT_OF_MEMORY; } PianoXmlStructParser (dataNode, PianoXmlParseStationsCb, tmpStation); /* FIXME: copy & waste */ /* start new linked list or append */ if (ph->stations == NULL) { ph->stations = tmpStation; } else { PianoStation_t *curStation = ph->stations; while (curStation->next != NULL) { curStation = curStation->next; } curStation->next = tmpStation; } ezxml_free (xmlDoc); return PIANO_RET_OK; }
bool CMsnProto::MSN_StoreCreateRelationships(bool allowRecurse) { char* reqHdr; ezxml_t tbdy; ezxml_t xmlp = storeSoapHdr("CreateRelationships", "RoamingIdentityChanged", tbdy, reqHdr); ezxml_t rels = ezxml_add_child(tbdy, "relationships", 0); ezxml_t rel = ezxml_add_child(rels, "Relationship", 0); ezxml_t node = ezxml_add_child(rel, "SourceID", 0); ezxml_set_txt(node, expresid); node = ezxml_add_child(rel, "SourceType", 0); ezxml_set_txt(node, "SubProfile"); node = ezxml_add_child(rel, "TargetID", 0); ezxml_set_txt(node, photoid); node = ezxml_add_child(rel, "TargetType", 0); ezxml_set_txt(node, "Photo"); node = ezxml_add_child(rel, "RelationshipName", 0); ezxml_set_txt(node, "ProfilePhoto"); char* szData = ezxml_toxml(xmlp, true); ezxml_free(xmlp); unsigned status = 0; char *storeUrl = NULL, *tResult = NULL; for (int k = 4; --k;) { mir_free(storeUrl); storeUrl = GetStoreHost("CreateRelationships"); tResult = getSslResult(&storeUrl, szData, reqHdr, status); if (tResult == NULL) UpdateStoreHost("CreateRelationships", NULL); else break; } mir_free(reqHdr); free(szData); if (tResult != NULL) { UpdateStoreHost("CreateRelationships", storeUrl); if (status == 500) { ezxml_t xmlm = ezxml_parse_str(tResult, strlen(tResult)); const char* szErr = ezxml_txt(getSoapFault(xmlm, true)); if (strcmp(szErr, "PassportAuthFail") == 0 && allowRecurse) { MSN_GetPassportAuth(); status = MSN_StoreCreateRelationships(false) ? 200 : 500; } ezxml_free(xmlm); } } mir_free(tResult); mir_free(storeUrl); return status == 200; }
void CMsnProto::getMetaData(void) { char* getReqHdr; ezxml_t reqbdy; ezxml_t xmlreq = oimRecvHdr("GetMetadata", reqbdy, getReqHdr); char* szData = ezxml_toxml(xmlreq, true); ezxml_free(xmlreq); unsigned status; char* url = (char*)mir_strdup(oimRecvUrl); char* tResult = getSslResult(&url, szData, getReqHdr, status); mir_free(url); free(szData); mir_free(getReqHdr); if (tResult != NULL && status == 200) { ezxml_t xmlm = ezxml_parse_str(tResult, mir_strlen(tResult)); ezxml_t xmli = ezxml_get(xmlm, "s:Body", 0, "GetMetadataResponse", 0, "MD", -1); if (!xmli) xmli = ezxml_get(xmlm, "soap:Body", 0, "GetMetadataResponse", 0, "MD", -1); getOIMs(xmli); ezxml_free(xmlm); } mir_free(tResult); }
/* parse stations returned by pandora * @param piano handle * @param xml returned by pandora * @return _RET_OK or error */ PianoReturn_t PianoXmlParseStations (PianoHandle_t *ph, char *xml) { ezxml_t xmlDoc, dataNode; PianoReturn_t ret; char **quickMixIds = NULL, **curQuickMixId = NULL; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } dataNode = ezxml_get (xmlDoc, "params", 0, "param", 0, "value", 0, "array", 0, "data", -1); for (dataNode = ezxml_child (dataNode, "value"); dataNode; dataNode = dataNode->next) { PianoStation_t *tmpStation; if ((tmpStation = calloc (1, sizeof (*tmpStation))) == NULL) { ezxml_free (xmlDoc); return PIANO_RET_OUT_OF_MEMORY; } PianoXmlStructParser (ezxml_child (dataNode, "struct"), PianoXmlParseStationsCb, tmpStation); /* get stations selected for quickmix */ if (tmpStation->isQuickMix) { PianoXmlStructParser (ezxml_child (dataNode, "struct"), PianoXmlParseQuickMixStationsCb, &quickMixIds); } /* start new linked list or append */ if (ph->stations == NULL) { ph->stations = tmpStation; } else { PianoStation_t *curStation = ph->stations; while (curStation->next != NULL) { curStation = curStation->next; } curStation->next = tmpStation; } } /* set quickmix flags after all stations are read */ if (quickMixIds != NULL) { curQuickMixId = quickMixIds; while (*curQuickMixId != NULL) { PianoStation_t *curStation = PianoFindStationById (ph->stations, *curQuickMixId); if (curStation != NULL) { curStation->useQuickMix = 1; } free (*curQuickMixId); curQuickMixId++; } free (quickMixIds); } ezxml_free (xmlDoc); return PIANO_RET_OK; }
bool CMsnProto::MSN_StoreCreateProfile(bool allowRecurse) { char* reqHdr; ezxml_t tbdy; ezxml_t xmlp = storeSoapHdr("CreateProfile", "RoamingSeed", tbdy, reqHdr); ezxml_t pro = ezxml_add_child(tbdy, "profile", 0); ezxml_t node; pro = ezxml_add_child(pro, "ExpressionProfile", 0); ezxml_add_child(pro, "PersonalStatus", 0); node = ezxml_add_child(pro, "RoleDefinitionName", 0); ezxml_set_txt(node, "ExpressionProfileDefault"); char* szData = ezxml_toxml(xmlp, true); ezxml_free(xmlp); unsigned status = 0; char *storeUrl, *tResult = NULL; storeUrl = mir_strdup("https://storage.msn.com/storageservice/SchematizedStore.asmx"); tResult = getSslResult(&storeUrl, szData, reqHdr, status); mir_free(reqHdr); free(szData); if (tResult != NULL) { if (status == 200) { ezxml_t xmlm = ezxml_parse_str(tResult, strlen(tResult)); UpdateStoreCacheKey(xmlm); ezxml_t body = getSoapResponse(xmlm, "CreateProfile"); MSN_StoreShareItem(ezxml_txt(body)); MSN_SharingMyProfile(); ezxml_free(xmlm); } else if (status == 500) { ezxml_t xmlm = ezxml_parse_str(tResult, strlen(tResult)); const char* szErr = ezxml_txt(getSoapFault(xmlm, true)); if (strcmp(szErr, "PassportAuthFail") == 0 && allowRecurse) { MSN_GetPassportAuth(); status = MSN_StoreCreateProfile(false) ? 200 : 500; } ezxml_free(xmlm); } } mir_free(tResult); mir_free(storeUrl); return status == 200; }
externC void cyg_start( void ) { ezxml_t f1, team, driver; const char * teamname; int i; CYG_TEST_INIT(); f1 = ezxml_parse_str(document, sizeof(document)); for (team = ezxml_child(f1, "team"); team; team = team->next) { teamname = ezxml_attr(team, "name"); for (i=0,driver = ezxml_child(team, "driver"); driver; driver = driver->next,i++) { if (strcmp(results[i].driver, ezxml_child(driver, "name")->txt) || strcmp(results[i].team, teamname) || strcmp(results[i].points, ezxml_child(driver, "points")->txt)) CYG_TEST_FAIL("Parser failed first test"); } } if (strcmp(ezxml_get(f1, "team", 0, "driver", 1, "name", -1)->txt, "David Coultard")) CYG_TEST_FAIL_FINISH("Parser failed second test"); else CYG_TEST_PASS_FINISH("Parser passed"); ezxml_free(f1); }
int main(int argc, char* argv[]) { int i; if((EzxmlBase = OpenLibrary("ezxml.library", 8))) { ezxml_t xml; char *s; if (argc != 2) return Printf("usage: %s xmlfile\n", argv[0]); xml = ezxml_parse_file(argv[1]); Printf("%s\n", (s = ezxml_toxml(xml))); FreeVec(s); i = Printf("%s", ezxml_error(xml)); ezxml_free(xml); CloseLibrary(EzxmlBase); } else PutStr("Error: Could not open ezxml.library\n"); return (i) ? 1 : 0; }
int main() { int kanji[200][2]; int i = 0; int8_t test = 8; ezxml_t f1 = ezxml_parse_file("4e86.xml"), stroke, point; const char *teamname; for (stroke = ezxml_child(f1, "stroke"); stroke; stroke = stroke->next) { printf("new stroke\n"); for (point = ezxml_child(stroke, "point"); point; point = point->next) { kanji[i][0] = atoi(ezxml_attr(point,"x")); kanji[i][1] = atoi(ezxml_attr(point,"y")); i++; // printf("%i",i); // printf("%s \n", ezxml_attr(point,"x")); } } ezxml_free(f1); for(int j = 0;j<50;j++) { printf("j: %i, x: %i, y: %i\n", j, kanji[j][0], kanji[j][1]); } return 0; }
bool xml_parse_browse_album(struct album_browse* a, unsigned char* xml, int len) { ezxml_t top = ezxml_parse_str(xml, len); parse_browse_album(top, a); ezxml_free(top); return true; }
static int osfy_artistbrowse_browse_callback(struct browse_callback_ctx *brctx) { sp_artistbrowse *arb; int i; struct buf *xml; ezxml_t root; for(i = 0; i < brctx->num_in_request; i++) { arb = brctx->data.artistbrowses[brctx->num_browsed + i]; /* Set defaults */ arb->is_loaded = 0; arb->error = SP_ERROR_OTHER_TRANSIENT; } /* Might happen because of a channel error */ if(brctx->buf == NULL) return 0; xml = despotify_inflate(brctx->buf->ptr, brctx->buf->len); #ifdef DEBUG { FILE *fd; DSFYDEBUG("Decompresed %d bytes data, xml=%p\n", brctx->buf->len, xml); fd = fopen("browse-artistbrowse.xml", "w"); if(fd) { fwrite(xml->ptr, xml->len, 1, fd); fclose(fd); } } #endif root = ezxml_parse_str((char *) xml->ptr, xml->len); if(root == NULL) { DSFYDEBUG("Failed to parse XML\n"); buf_free(xml); return -1; } for(i = 0; i < brctx->num_in_request; i++) { arb = brctx->data.artistbrowses[brctx->num_browsed + i]; osfy_artistbrowse_load_from_xml(brctx->session, arb, root); arb->is_loaded = 1; arb->error = SP_ERROR_OK; } ezxml_free(root); buf_free(xml); /* Release references made in sp_artistbrowse_create() */ for(i = 0; i < brctx->num_in_request; i++) sp_artistbrowse_release(brctx->data.artistbrowses[brctx->num_browsed + i]); return 0; }
void FreeXMLData(const Category cat) { free(pData[cat]); pData[cat] = NULL; ezxml_free(doc[cat]); doc[cat] = NULL; dataLength[cat] = 0; }
/* Generate a tag with escaped character content. */ char* xml_gen_tag(char* name, char* content) { ezxml_t tag = ezxml_new(name); ezxml_set_txt(tag, content); char* ret = ezxml_toxml(tag); ezxml_free(tag); return ret; }
void xml_parse_prodinfo(struct user_info* u, unsigned char* xml, int len) { ezxml_t top = ezxml_parse_str(xml, len); xmlstrncpy(u->type, sizeof u->type, top, "product", 0, "type", -1); unsigned int expiry; xmlatoi(&expiry, top, "product", 0, "expiry", -1); u->expiry = expiry; ezxml_free(top); }
Book *book_load_file(const char *path) { Book *book; ezxml_t beyonwiz_xml, timerlist_xml, timer_xml; Timer *timer; int i; const char *fname; book = (Book *)malloc(sizeof(Book)); book->n_timers = 0; book->timers = NULL; beyonwiz_xml = ezxml_parse_file(path); timerlist_xml = ezxml_child(beyonwiz_xml, "TimerList"); //FIXME check to make sure we are reading a version 5 timerlist. if(timerlist_xml) { for(timer_xml = ezxml_child(timerlist_xml, "Timer"); timer_xml; timer_xml = timer_xml->next) { book->n_timers++; } printf("number of timers = %d\n", book->n_timers); timer = (Timer *)malloc(sizeof(Timer) * book->n_timers); book->timers = timer; for(i=0,timer_xml = ezxml_child(timerlist_xml, "Timer"); timer_xml; timer_xml = timer_xml->next,i++) { fname = ezxml_attr(timer_xml, "fname"); timer->filename = (char *)malloc(strlen(fname) + 1); strcpy(timer->filename, fname); timer->startmjd = atoi(ezxml_attr(timer_xml, "startMjd")); timer->nextmjd = atoi(ezxml_attr(timer_xml, "nextMjd")); timer->start = atoi(ezxml_attr(timer_xml, "start")); timer->duration = atoi(ezxml_attr(timer_xml, "duration")); timer->repeat = atoi(ezxml_attr(timer_xml, "repeat")); timer->play = atoi(ezxml_attr(timer_xml, "play")); timer->lock = atoi(ezxml_attr(timer_xml, "lock")); timer->onid = atoi(ezxml_attr(timer_xml, "onId")); timer->tsid = atoi(ezxml_attr(timer_xml, "tsId")); timer->svcid = atoi(ezxml_attr(timer_xml, "svcId")); printf("timer fname = %s, startMjd = %d, start = %d\n", timer->filename, timer->startmjd, timer->start); timer++; } } ezxml_free(beyonwiz_xml); return book; }
bool xml_parse_browse_album(struct ds_album_browse* a, unsigned char* xml, int len, bool high_bitrate) { ezxml_t top = ezxml_parse_str(xml, len); parse_browse_album(top, a, high_bitrate); ezxml_free(top); return true; }
bool CMsnProto::MSN_StoreShareItem(const char* id, bool allowRecurse) { char* reqHdr; ezxml_t tbdy; ezxml_t xmlp = storeSoapHdr("ShareItem", "RoamingSeed", tbdy, reqHdr); ezxml_t node = ezxml_add_child(tbdy, "resourceID", 0); ezxml_set_txt(node, id); node = ezxml_add_child(tbdy, "displayName", 0); ezxml_set_txt(node, "Messenger Roaming Identity"); char* szData = ezxml_toxml(xmlp, true); ezxml_free(xmlp); unsigned status = 0; char *storeUrl, *tResult = NULL; storeUrl = mir_strdup("https://storage.msn.com/storageservice/SchematizedStore.asmx"); tResult = getSslResult(&storeUrl, szData, reqHdr, status); mir_free(reqHdr); free(szData); if (tResult != NULL && status == 500) { ezxml_t xmlm = ezxml_parse_str(tResult, strlen(tResult)); const char* szErr = ezxml_txt(getSoapFault(xmlm, true)); if (strcmp(szErr, "PassportAuthFail") == 0 && allowRecurse) { MSN_GetPassportAuth(); status = MSN_StoreCreateProfile(false) ? 200 : 500; } ezxml_free(xmlm); } mir_free(tResult); mir_free(storeUrl); return status == 200; }
/* check for exception only * @param xml string * @return _OK or error */ PianoReturn_t PianoXmlParseSimple (char *xml) { ezxml_t xmlDoc; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } ezxml_free (xmlDoc); return ret; }
void dom_node_unref(dom_node *node) { assert(node); if (MAGIC_DOCUMENT_NODE == node->ref) { ezxml_free(node->node); free(node); } else { node->ref--; if (0 == node->ref) { free(node); } } }
/* dummy function, only checks for errors * @param xml doc * @return _OK or error */ PianoReturn_t PianoXmlParseTranformStation (char *xml) { ezxml_t xmlDoc; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } ezxml_free (xmlDoc); return PIANO_RET_OK; }
/* ------------------------------------------------------------------------- */ void Reg_Free(Reg_TRegistry* reg) { if (!reg) return; if (Mem_IsUnique(reg)) { free((char*)reg->m_file_name); ezxml_free(reg->m_root); } Mem_Free(reg); }
int xml_parse_tracklist(struct track* firsttrack, unsigned char* xml, int len, bool ordered) { ezxml_t top = ezxml_parse_str(xml, len); ezxml_t tracks = ezxml_get(top, "tracks",-1); int num_tracks = parse_tracks(tracks, firsttrack, ordered); ezxml_free(top); return num_tracks; }
/* parses playlist; used when searching too * @param piano handle * @param xml document * @param return: playlist */ PianoReturn_t PianoXmlParsePlaylist (PianoHandle_t *ph, char *xml, PianoSong_t **retPlaylist) { ezxml_t xmlDoc, dataNode; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } dataNode = ezxml_get (xmlDoc, "params", 0, "param", 0, "value", 0, "array", 0, "data", -1); for (dataNode = ezxml_child (dataNode, "value"); dataNode; dataNode = dataNode->next) { PianoSong_t *tmpSong; if ((tmpSong = calloc (1, sizeof (*tmpSong))) == NULL) { ezxml_free (xmlDoc); return PIANO_RET_OUT_OF_MEMORY; } PianoXmlStructParser (ezxml_child (dataNode, "struct"), PianoXmlParsePlaylistCb, tmpSong); /* begin linked list or append */ if (*retPlaylist == NULL) { *retPlaylist = tmpSong; } else { PianoSong_t *curSong = *retPlaylist; while (curSong->next != NULL) { curSong = curSong->next; } curSong->next = tmpSong; } } ezxml_free (xmlDoc); return PIANO_RET_OK; }
/* create xml parser from string * @param xml document * @param returns document pointer (needed to free memory later) * @param returns document root * @return _OK or error */ static PianoReturn_t PianoXmlInitDoc (char *xmlStr, ezxml_t *xmlDoc) { PianoReturn_t ret; if ((*xmlDoc = ezxml_parse_str (xmlStr, strlen (xmlStr))) == NULL) { return PIANO_RET_XML_INVALID; } if ((ret = PianoXmlIsFault (*xmlDoc)) != PIANO_RET_OK) { ezxml_free (*xmlDoc); return ret; } return PIANO_RET_OK; }
int xml_parse_search(struct search_result* search, struct track* firsttrack, unsigned char* xml, int len, bool high_bitrate) { ezxml_t top = ezxml_parse_str(xml, len); xmlstrncpy(search->suggestion, sizeof search->suggestion, top, "did-you-mean", -1); xmlatoi(&search->total_artists, top, "total-artists", -1); xmlatoi(&search->total_albums, top, "total-albums", -1); xmlatoi(&search->total_tracks, top, "total-tracks", -1); ezxml_t artists = ezxml_get(top, "artists",-1); struct artist *prev = NULL; struct artist *artist = calloc(1, sizeof(struct artist)); search->artists = artist; ezxml_t xa; for (xa = ezxml_get(artists, "artist", -1); xa; xa = xa->next) { if(prev) { artist = calloc(1, sizeof(struct artist)); prev->next = artist; } parse_artist(xa, artist); prev = artist; } ezxml_t albums = ezxml_get(top, "albums",-1); struct album *aprev = NULL; struct album *album = calloc(1, sizeof(struct album)); search->albums = album; for (xa = ezxml_get(albums, "album", -1); xa; xa = xa->next) { if(aprev) { album = calloc(1, sizeof(struct album)); aprev->next = album; } parse_album(xa, album); aprev = album; } ezxml_t tracks = ezxml_get(top, "tracks",-1); int num_tracks = parse_tracks(tracks, firsttrack, false, high_bitrate); ezxml_free(top); return num_tracks; }
API_REGISTER_METHOD( wlan, getClientList, EWF_HTTP_REQUEST_METHOD_GET, API_ACCESS_POLICY_PRIVATE ) { char ipaddr[NBU_NET_SIZEOF_IPADDR]; int ret; int n = 0; char *buf_xml = NULL; size_t buf_xml_size; ezxml_t xmln_root, xmln_mac; ret = nbd_wlan_list_assoc(NULL, &buf_xml, &buf_xml_size); if(ret == NBD_SUCCESS) { xmln_root = ezxml_parse_str(buf_xml, buf_xml_size); if(xmln_root != NULL) { n = 0; for(xmln_mac = ezxml_get(xmln_root, "assoclist", 0, "mac", -1); xmln_mac; xmln_mac = xmln_mac->next) { ++n; nbu_string_printf( buffer, sizeof buffer, "wlan.clients.%d.mac_addr", n ); api_set_value(buffer, ezxml_txt(xmln_mac)); if(nbd_lan_mac2ip(ezxml_txt(xmln_mac), ipaddr, sizeof(ipaddr)) != NBD_SUCCESS) { ipaddr[0] = '\0'; } nbu_string_printf( buffer, sizeof buffer, "wlan.clients.%d.ip_addr", n ); api_set_value( buffer, ipaddr ); } ezxml_free(xmln_root); } free(buf_xml); } }
bool xml_parse_confirm(struct playlist* pl, unsigned char* xml, int len) { ezxml_t top = ezxml_parse_str(xml, len); bool confirm = !strncmp(top->name, "confirm", 7); if (confirm) { xml_parse_version(pl, top, "version", -1); } ezxml_free(top); return confirm; }
/* parses userinfos sent by pandora as login response * @param piano handle * @param utf-8 string * @return _RET_OK or error */ PianoReturn_t PianoXmlParseUserinfo (PianoHandle_t *ph, char *xml) { ezxml_t xmlDoc, structNode; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } /* <methodResponse> <params> <param> <value> <struct> */ structNode = ezxml_get (xmlDoc, "params", 0, "param", 0, "value", 0, "struct", -1); PianoXmlStructParser (structNode, PianoXmlParseUserinfoCb, &ph->user); ezxml_free (xmlDoc); return PIANO_RET_OK; }
/* parse getStation response */ PianoReturn_t PianoXmlParseGetStationInfo (char *xml, PianoStationInfo_t *stationInfo) { ezxml_t xmlDoc, dataNode; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } dataNode = ezxml_get (xmlDoc, "params", 0, "param", 0, "value", 0, "struct", -1); PianoXmlStructParser (dataNode, PianoXmlParseGetStationInfoCb, stationInfo); ezxml_free (xmlDoc); return PIANO_RET_OK; }
/* parses "why did you play ...?" answer * @param xml * @param returns the answer * @return _OK or error */ PianoReturn_t PianoXmlParseNarrative (char *xml, char **retNarrative) { ezxml_t xmlDoc, dataNode; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } /* <methodResponse> <params> <param> <value> $textnode */ dataNode = ezxml_get (xmlDoc, "params", 0, "param", 0, "value", -1); *retNarrative = strdup (ezxml_txt (dataNode)); ezxml_free (xmlDoc); return ret; }
/* parse "add seed" answer, nearly the same as ParseCreateStation * @param piano handle * @param xml document * @param update this station */ PianoReturn_t PianoXmlParseAddSeed (char *xml, PianoStation_t *station) { ezxml_t xmlDoc, dataNode; PianoReturn_t ret; if ((ret = PianoXmlInitDoc (xml, &xmlDoc)) != PIANO_RET_OK) { return ret; } dataNode = ezxml_get (xmlDoc, "params", 0, "param", 0, "value", 0, "struct", -1); PianoDestroyStation (station); PianoXmlStructParser (dataNode, PianoXmlParseStationsCb, station); ezxml_free (xmlDoc); return PIANO_RET_OK; }