/* 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;
}
