static void shinima_message_links_foreach(gchar **message, void(*foreach_func)(xmlnode*, const gchar*, gchar**, gboolean*, gpointer), gboolean *_changed, gpointer *user_data) { xmlnode *root, *a; gboolean *changed = (_changed != NULL) ? changed : g_malloc(sizeof(gboolean)); g_return_if_fail(foreach_func != NULL); root = xmlnode_from_str(*message, -1); for(a=xmlnode_get_child(root, "a"); a; a=xmlnode_get_next_twin(a)) { const gchar *href = xmlnode_get_attrib(a, "href"); if(href) foreach_func(a, href, message, changed, user_data); } if(changed) { g_free(*message); *message = xmlnode_to_str(root, NULL); } if(_changed == NULL) g_free(changed); xmlnode_free(root); }
static void purple_smileys_load(void) { xmlnode *root_node, *profile_node; xmlnode *smileyset_node = NULL; xmlnode *smiley_node; smileys_loaded = TRUE; root_node = purple_util_read_xml_from_file(XML_FILE_NAME, _(SMILEYS_LOG_ID)); if (root_node == NULL) return; /* See the top comments above to understand why initial tag elements * are not being considered by now. */ profile_node = xmlnode_get_child(root_node, XML_PROFILE_TAG); if (profile_node) smileyset_node = xmlnode_get_child(profile_node, XML_SMILEY_SET_TAG); if (smileyset_node) { smiley_node = xmlnode_get_child(smileyset_node, XML_SMILEY_TAG); for (; smiley_node != NULL; smiley_node = xmlnode_get_next_twin(smiley_node)) { PurpleSmiley *smiley; smiley = parse_smiley(smiley_node); } } xmlnode_free(root_node); }
void campfire_xaction_free(CampfireSslTransaction *xaction) { if (xaction) { if (xaction->http_request) { g_string_free(xaction->http_request, TRUE); } if (xaction->http_response.response) { g_string_free(xaction->http_response.response, TRUE); } if (xaction->http_response.header) { g_string_free(xaction->http_response.header, TRUE); } if (xaction->http_response.content) { g_string_free(xaction->http_response.content, TRUE); } if (xaction->xml_response) { xmlnode_free(xaction->xml_response); } if (xaction->room_id) { g_free(xaction->room_id); } g_list_free_full(xaction->messages, &campfire_message_free); xaction->campfire->num_xaction_free++; /* valgrind investigation */ purple_debug_info("campfire", "xaction: %p, num_xaction_malloc:%d: num_xaction_free:%d\n", xaction, xaction->campfire->num_xaction_malloc, xaction->campfire->num_xaction_free); g_free(xaction); } }
/* destroys Session object */ static int session_destroy(Session *s){ GList *it; g_message(L_("Deleting session for '%s'"),s->jid); if (s->ping_timeout_func) g_source_remove(s->ping_timeout_func); if (s->timeout_func) g_source_remove(s->timeout_func); if (s->ping_timer) g_timer_destroy(s->ping_timer); session_remove_g_source(s); while(s->resources) resource_remove((Resource *)s->resources->data,0); if (s->ggs){ if (s->connected){ debug("gg_logoff(%p)",s->ggs); gg_logoff(s->ggs); } gg_free_session(s->ggs); s->ggs=NULL; } if (s->connected && s->s && s->jid){ for(it=g_list_first(s->user->contacts);it;it=g_list_next(it)){ Contact *c=(Contact *)it->data; if (!GG_S_NA(c->status) && c->status!=-1){ char *ujid; ujid=jid_build_full(c->uin); presence_send(s->s,ujid,s->user->jid,0,NULL,NULL,0); g_free(ujid); } } } if (s->query) xmlnode_free(s->query); if (s->user) user_unref(s->user); g_free(s->gg_status_descr); g_free(s); return 0; }
void jabber_chat_change_nick(JabberChat *chat, const char *nick) { xmlnode *presence; char *full_jid; PurplePresence *gpresence; PurpleStatus *status; JabberBuddyState state; char *msg; int priority; if(!chat->muc) { purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), "", _("Nick changing not supported in non-MUC chatrooms"), PURPLE_MESSAGE_SYSTEM, time(NULL)); return; } gpresence = purple_account_get_presence(chat->js->gc->account); status = purple_presence_get_active_status(gpresence); purple_status_to_jabber(status, &state, &msg, &priority); presence = jabber_presence_create(state, msg, priority); full_jid = g_strdup_printf("%s@%s/%s", chat->room, chat->server, nick); xmlnode_set_attrib(presence, "to", full_jid); g_free(full_jid); g_free(msg); jabber_send(chat->js, presence); xmlnode_free(presence); }
/* thread safe with sem */ mreturn mod_presence_deliver(mapi m, void *arg) { session cur; if (m->packet->type != JPACKET_PRESENCE) return M_IGNORE; log_debug("deliver phase"); /* only if we HAVE a user, and it was sent to ONLY the user@server, and there is at least one session available */ if (m->user != NULL && m->packet->to->resource == NULL && js_session_primary_all_sem(m->user) != NULL) { log_debug("broadcasting to %s", m->user->user); /* broadcast */ for (cur = m->user->sessions; cur != NULL; cur = cur->next) { if (cur->priority < -128) continue; js_session_to(cur, jpacket_new(xmlnode_dup(m->packet->x))); } SEM_UNLOCK(m->user->sem); if (jpacket_subtype(m->packet) != JPACKET__PROBE) { /* probes get handled by the offline thread as well? */ xmlnode_free(m->packet->x); return M_HANDLED; } } return M_PASS; }
/* bounces packet for unknown users with the appropriate error */ void mt_unknown_bounce(void *arg) { jpacket jp = (jpacket) arg; mti ti = (mti) jp->aux1; xmlnode reg; lowercase(jp->from->user); lowercase(jp->from->server); if ((reg = xdb_get(ti->xc,mt_xdb_id(jp->p,jp->from,jp->to->server),NS_REGISTER)) != NULL) { xmlnode p = xmlnode_new_tag("presence"); xmlnode_put_attrib(p,"to",jid_full(jp->from)); xmlnode_put_attrib(p,"from",jp->to->server); xmlnode_put_attrib(p,"type","probe"); mt_deliver(ti,p); jutil_error(jp->x,TERROR_NOTFOUND); xmlnode_free(reg); } else jutil_error(jp->x,TERROR_REGISTER); mt_deliver(ti,jp->x); }
static char* format_message(char *sender, char *message) { GString* format_message = g_string_new(""); xmlnode* message_node = xmlnode_from_str(message, -1); /* raw */ if ( !message_node || !( strcmp(message_node->name, "html")==0 || strcmp(message_node->name, "body")==0 )) { g_string_printf(format_message, "%s: %s", sender, message); return g_string_free(format_message, FALSE); } xmlnode* body_node = (strcmp(message_node->name, "body")) ? xmlnode_get_child(message_node, "body") : message_node; char* message_content = xmlnode_get_content(body_node); g_string_printf(format_message, "%s: %s", sender, message_content); g_free(message_content); xmlnode_free(message_node); return g_string_free(format_message, FALSE); }
xmlnode xmlnode_str(char *str, int len) { XML_Parser p; xmlnode *x, node; /* pointer to an xmlnode */ if(NULL == str) return NULL; x = malloc(sizeof(void *)); *x = NULL; /* pointer to NULL */ p = XML_ParserCreate(NULL); XML_SetUserData(p, x); XML_SetElementHandler(p, expat_startElement, expat_endElement); XML_SetCharacterDataHandler(p, expat_charData); if(!XML_Parse(p, str, len, 1)) { /* jdebug(ZONE,"xmlnode_str_error: %s",(char *)XML_ErrorString(XML_GetErrorCode(p)));*/ xmlnode_free(*x); *x = NULL; } node = *x; free(x); XML_ParserFree(p); return node; /* return the xmlnode x points to */ }
void jabber_presence_send(GaimConnection *gc, const char *state, const char *msg) { JabberStream *js = gc->proto_data; xmlnode *presence; char *stripped = NULL; if(msg) { gaim_markup_html_to_xhtml(msg, NULL, &stripped); } else if(!state || strcmp(state, GAIM_AWAY_CUSTOM)) { /* i can't wait until someone re-writes the status/away stuff */ stripped = g_strdup(""); } if(gc->away) g_free(gc->away); gc->away = stripped; presence = jabber_presence_create(state, stripped); jabber_send(js, presence); g_hash_table_foreach(js->chats, chats_send_presence_foreach, presence); xmlnode_free(presence); jabber_presence_fake_to_self(js, state, stripped); }
int presence_send_error(struct stream_s *stream,const char *from,const char *to, int code,const char *string){ xmlnode pres; xmlnode error; char *jid; char *str; pres=xmlnode_new_tag("presence"); jid=jid_my_registered(); if (from!=NULL) xmlnode_put_attrib(pres,"from",from); else{ char *jid; jid=jid_my_registered(); xmlnode_put_attrib(pres,"from",jid); g_free(jid); } g_free(jid); xmlnode_put_attrib(pres,"to",to); xmlnode_put_attrib(pres,"type","error"); error=xmlnode_insert_tag(pres,"error"); if (code>0){ str=g_strdup_printf("%03u",(unsigned)code); xmlnode_put_attrib(error,"code",str); g_free(str); } xmlnode_insert_cdata(error,string,-1); stream_write(stream,pres); xmlnode_free(pres); return 0; }
gint xmpp_message_send(XmppStream *stream, const gchar *text, const gchar *to) { xmlnode *root; xmlnode *node; gchar *xml_string; g_return_val_if_fail(stream != NULL, HYBRID_ERROR); g_return_val_if_fail(text != NULL, HYBRID_ERROR); g_return_val_if_fail(to != NULL, HYBRID_ERROR); root = xmlnode_create("message"); xmlnode_new_prop(root, "from", stream->jid); xmlnode_new_prop(root, "to", to); xmlnode_new_prop(root, "type", "chat"); node = xmlnode_new_child(root, "body"); xmlnode_set_content(node, text); xml_string = xmlnode_to_string(root); xmlnode_free(root); hybrid_debug_info("xmpp", "send message to %s:\n%s", to, xml_string); if (hybrid_ssl_write(stream->ssl, xml_string, strlen(xml_string)) == -1) { hybrid_debug_error("xmpp", "send message to %s failed\n", to); g_free(xml_string); return HYBRID_ERROR; } g_free(xml_string); return HYBRID_OK; }
void GetBuddyInfo(struct fetion_account_data *sip, const char *who) { gint xml_len; xmlnode *root, *son, *item; gchar *body; root = xmlnode_new("args"); g_return_if_fail(root != NULL); son = xmlnode_new_child(root, "contacts"); xmlnode_set_attrib(son, "attributes", "all"); //xmlnode_set_attrib(son,"extended-attributes","score-level"); g_return_if_fail(son != NULL); item = xmlnode_new_child(son, "contact"); g_return_if_fail(item != NULL); xmlnode_set_attrib(item, "uri", who); body = g_strdup_printf("%s",xmlnode_to_str(root, &xml_len)); purple_debug_info("fetion:", "GetBuddyInfo:body=[%s]", body); send_sip_request(sip->gc, "S", "", "", "N: GetContactsInfo\r\n", body, NULL, (TransCallback) GetBuddyInfo_cb); xmlnode_free(root); g_free(body); }
/* Coprocess functionality */ void dnsrv_child_process_xstream_io(int type, xmlnode x, void* args) { dns_io di = (dns_io)args; char* hostname; char* str = NULL; dns_resend_list iternode = NULL; if (type == XSTREAM_NODE) { /* Get the hostname out... */ hostname = xmlnode_get_data(x); log_debug(ZONE, "dnsrv: Recv'd lookup request for %s", hostname); if (hostname != NULL) { /* For each entry in the svclist, try and resolve using the specified service and resend it to the specified host */ iternode = di->svclist; while (iternode != NULL) { str = srv_lookup(x->p, iternode->service, hostname); if (str != NULL) { log_debug(ZONE, "Resolved %s(%s): %s\tresend to:%s", hostname, iternode->service, str, iternode->host); xmlnode_put_attrib(x, "ip", str); xmlnode_put_attrib(x, "to", iternode->host); break; } iternode = iternode->next; } str = xmlnode2str(x); write(di->out, str, strlen(str)); } } xmlnode_free(x); }
static gchar* generate_handle_request_body(const gchar *sipuri, const gchar *userid, const gchar *alias, const gchar *groupid, gboolean accept) { xmlnode *root; xmlnode *node; gchar *res; root = xmlnode_create("args"); node = xmlnode_new_child(root, "contacts"); node = xmlnode_new_child(node, "buddies"); node = xmlnode_new_child(node, "buddy"); xmlnode_new_prop(node, "user-id", userid); xmlnode_new_prop(node, "uri", sipuri); xmlnode_new_prop(node, "result", accept ? "1": "0"); xmlnode_new_prop(node, "buddy-lists", groupid); xmlnode_new_prop(node, "expose-mobile-no", "1"); xmlnode_new_prop(node, "expose-name", "1"); xmlnode_new_prop(node, "local-name", alias); res = xmlnode_to_string(root); xmlnode_free(root); return res; }
void xmlnode_handle_end(void *data, const char *name) { session_t *s = (session_t *) data; xmlnode_t *n; jabber_private_t *j; if (!s || !(j = s->priv) || !name) { debug_error("[jabber] xmlnode_handle_end() invalid parameters\n"); return; } if (!(n = j->node)) { /* XXX: dj, maybe we set some sessionvar here, * and then take a look at it before submitting PROTOCOL_DISCONNECTED * with some weird error? */ debug("[jabber] end tag within <stream>, ignoring\n"); return; } if (!n->parent) { jabber_handle(data, n); xmlnode_free(n); j->node = NULL; return; } else { j->node = n->parent; } }
/** Convert XML to something based on MSIM_XMLNODE_CONVERT. */ static gchar * msim_convert_xml(MsimSession *session, const gchar *raw, MSIM_XMLNODE_CONVERT f) { xmlnode *root; GString *str; gchar *enclosed_raw; g_return_val_if_fail(raw != NULL, NULL); /* Enclose text in one root tag, to try to make it valid XML for parsing. */ enclosed_raw = g_strconcat("<root>", raw, "</root>", NULL); root = xmlnode_from_str(enclosed_raw, -1); if (!root) { purple_debug_warning("msim", "msim_markup_to_html: couldn't parse " "%s as XML, returning raw: %s\n", enclosed_raw, raw); /* TODO: msim_unrecognized */ g_free(enclosed_raw); return g_strdup(raw); } g_free(enclosed_raw); str = g_string_new(NULL); msim_convert_xmlnode(session, str, root, f, 0); xmlnode_free(root); purple_debug_info("msim", "msim_markup_to_html: returning %s\n", str->str); return g_string_free(str, FALSE); }
static void msn_oim_request_helper(MsnOimRequestData *data) { MsnSession *session = data->oim->session; if (data->send) { /* The Sending of OIM's uses a different token for some reason. */ xmlnode *ticket; ticket = xmlnode_get_child(data->body, "Header/Ticket"); xmlnode_set_attrib(ticket, "passport", msn_nexus_get_token_str(session->nexus, MSN_AUTH_LIVE_SECURE)); } else { xmlnode *passport; xmlnode *xml_t; xmlnode *xml_p; GHashTable *token; const char *msn_t; const char *msn_p; token = msn_nexus_get_token(session->nexus, MSN_AUTH_MESSENGER_WEB); g_return_if_fail(token != NULL); msn_t = g_hash_table_lookup(token, "t"); msn_p = g_hash_table_lookup(token, "p"); g_return_if_fail(msn_t != NULL); g_return_if_fail(msn_p != NULL); passport = xmlnode_get_child(data->body, "Header/PassportCookie"); xml_t = xmlnode_get_child(passport, "t"); xml_p = xmlnode_get_child(passport, "p"); /* frees old token text, or the 'EMPTY' text if first time */ xmlnode_free(xml_t->child); xmlnode_free(xml_p->child); xmlnode_insert_data(xml_t, msn_t, -1); xmlnode_insert_data(xml_p, msn_p, -1); } msn_soap_message_send(session, msn_soap_message_new(data->action, xmlnode_copy(data->body)), data->host, data->url, FALSE, msn_oim_request_cb, data); }
result dnsrv_deliver(instance i, dpacket p, void* args) { dns_io di = (dns_io)args; xmlnode c; int timeout = di->cache_timeout; char *ip; jid to; /* if we get a route packet, it has to be to *us* and have the child as the real packet */ if(p->type == p_ROUTE) { if(j_strcmp(p->host,i->id) != 0 || (to = jid_new(p->p,xmlnode_get_attrib(xmlnode_get_firstchild(p->x),"to"))) == NULL) return r_ERR; p->x=xmlnode_get_firstchild(p->x); p->id = to; p->host = to->server; } /* Ensure this packet doesn't already have an IP */ if(xmlnode_get_attrib(p->x, "ip") || xmlnode_get_attrib(p->x, "iperror")) { log_notice(p->host, "dropping looping dns lookup request: %s", xmlnode2str(p->x)); xmlnode_free(p->x); return r_DONE; } /* try the cache first */ if((c = xhash_get(di->cache_table, p->host)) != NULL) { /* if there's no IP, cached failed lookup, time those out 10 times faster! (weird, I know, *shrug*) */ if((ip = xmlnode_get_attrib(c,"ip")) == NULL) timeout = timeout / 10; if((time(NULL) - (int)xmlnode_get_vattrib(c,"t")) > timeout) { /* timed out of the cache, lookup again */ xmlnode_free(c); xhash_zap(di->cache_table,p->host); }else{ /* yay, send back right from the cache */ dnsrv_resend(p->x, ip, xmlnode_get_attrib(c,"to")); return r_DONE; } } dnsrv_lookup(di, p); return r_DONE; }
void jabber_iq_free(JabberIq *iq) { g_return_if_fail(iq != NULL); g_free(iq->id); xmlnode_free(iq->node); g_free(iq); }
gchar* get_province_name(const gchar *province) { xmlnode *root; xmlnode *node; gchar *name; gchar *value; g_return_val_if_fail(province != NULL, NULL); if (!(root = xmlnode_root_from_file(FETION_RES_DIR"province.xml"))) { return NULL; } if (!(node = xmlnode_child(root)) || g_strcmp0(node->name, "Province")) { hybrid_debug_error("fetion", "get full province name"); return NULL; } for (; node; node = xmlnode_next(node)) { if (!xmlnode_has_prop(node, "id")) { continue; } value = xmlnode_prop(node, "id"); if (g_strcmp0(value, province) == 0) { name = xmlnode_content(node); /* found, do cleanup. */ g_free(value); xmlnode_free(root); return name; } g_free(value); } xmlnode_free(root); return NULL; }
/* match will find a child in the parent, and either replace (if it's an insert) or remove (if data is NULL) */ int xdb_act(xdbcache xc, jid owner, char *ns, char *act, char *match, xmlnode data) { xdbrequest_p cur; struct timeval tv; if (xc->shutdown) return 1; if (xc == NULL || owner == NULL || ns == NULL) { log_alert("xdb_set", "Programming Error: xdb_set() called with NULL\n"); return 1; } log_debug("XDB SET"); cur = malloc(sizeof(xdbrequest_t)); memset(cur, 0, sizeof(xdbrequest_t)); cur->set = 1; cur->data = data; cur->ns = ns; cur->owner = owner; cur->act = act; cur->match = match; gettimeofday(&tv, NULL); cur->sent = tv.tv_sec; SEM_LOCK(xc->sem); cur->id = xc->id++; cur->next = xc->first; xc->first = cur; SEM_UNLOCK(xc->sem); /* send it on it's way */ xdb_deliver(xc->i, cur, 0); cur->external = 1; /* if it hasn't already returned, we should block here until it returns */ while (cur->preblock != 1) usleep(10); /* if it didn't actually get set, flag that */ if (cur->data == NULL) { free(cur); return 1; } xmlnode_free(cur->data); free(cur); return 0; }
static void twitter_multipage_all_request_data_free(TwitterMultiPageAllRequestData * request_data_all) { GList *l = request_data_all->nodes; for (l = request_data_all->nodes; l; l = l->next) { xmlnode_free(l->data); } g_list_free(request_data_all->nodes); g_free(request_data_all); }
mreturn mod_roster_auto_in_s10n(mapi m, void *arg) { xmlnode reply, x; log_debug("AUTO ROSTER"); //in not s10n if (m->packet->type != JPACKET_S10N) return M_IGNORE; //if no to if (m->packet->to == NULL) return M_PASS; //if from me if (jid_cmpx(m->s->uid, m->packet->from, JID_USER | JID_SERVER) == 0) return M_PASS; log_debug("handling incoming s10n"); switch (jpacket_subtype(m->packet)) { case JPACKET__SUBSCRIBE: log_debug("SUBSCRIBE"); reply = jutil_presnew(JPACKET__SUBSCRIBED, jid_full(m->packet->from), NULL); js_session_from(m->s, jpacket_new(reply)); reply = jutil_presnew(JPACKET__SUBSCRIBE, jid_full(m->packet->from), NULL); js_session_from(m->s, jpacket_new(reply)); break; case JPACKET__SUBSCRIBED: break; case JPACKET__UNSUBSCRIBE: log_debug("UNSUBSCRIBE"); //reply = jutil_presnew(JPACKET__UNSUBSCRIBED, jid_full(m->packet->from),NULL); //js_session_from(m->s, jpacket_new(reply)); //remove account. reply = jutil_iqnew(JPACKET__SET, NS_ROSTER); x = xmlnode_get_tag(reply, "query"); x = xmlnode_insert_tag(x, "item"); xmlnode_put_attrib(x, "jid", jid_full(jid_user(m->packet->from))); xmlnode_put_attrib(x, "subscription", "remove"); js_session_from(m->s, jpacket_new(reply)); // reply = jutil_iqnewpresnew(JPACKET__UNSUBSCRIBE, jid_full(m->packet->from),NULL); // js_session_from(m->s, jpacket_new(reply)); break; case JPACKET__UNSUBSCRIBED: break; } xmlnode_free(m->packet->x); return M_HANDLED; }
/* child that handles packets from the user */ void _js_session_from(void *arg) { jpacket p = (jpacket) arg; session s = (session) (p->aux1); /* if this session is dead */ if (s->exit_flag) { /* send the packet into oblivion */ xmlnode_free(p->x); return; } /* at least we must have a valid packet */ if (p->type == JPACKET_UNKNOWN) { /* send an error back */ jutil_error(p->x, TERROR_BAD); jpacket_reset(p); js_session_to(s, p); return; } /* debug message */ log_debug("THREAD:SESSION:FROM received a packet!"); /* increment packet out count */ s->si->stats->packets_out++; s->c_out++; /* make sure we have our from set correctly for outgoing packets */ if (jid_cmpx(p->from, s->id, JID_USER | JID_SERVER) != 0) { /* nope, fix it */ xmlnode_put_attrib(p->x, "from", jid_full(s->id)); p->from = jid_new(p->p, jid_full(s->id)); } /* if you use to="yourself@yourhost" it's the same as not having a to, the modules use the NULL as a self-flag */ if (jid_cmp(p->to, s->uid) == 0) { /* xmlnode_hide_attrib(p->x,"to"); */ p->to = NULL; } /* let the modules have their heyday */ if (js_mapi_call(NULL, es_OUT, p, s->u, s)) return; /* no module handled it, so restore the to attrib to us */ if (p->to == NULL) { xmlnode_put_attrib(p->x, "to", jid_full(s->uid)); p->to = jid_new(p->p, jid_full(s->uid)); } js_post_out_main(s, p); /* pass these to the general delivery function */ // js_deliver(s->si, p); }
static gchar *twitter_xml_text_parse_error(const gchar * response) { xmlnode *response_node; if (response && (response_node = xmlnode_from_str(response, strlen(response)))) { gchar *message = twitter_xml_node_parse_error(response_node); xmlnode_free(response_node); return message; } return NULL; }
/** * Frees the whole tree of an xml node * * First determines the root of the xml tree and then frees the whole tree * from there. * * @param node The node to free the tree from */ static void xmlnode_free_tree(xmlnode *node) { g_return_if_fail(node != NULL); while(xmlnode_get_parent(node)) node = xmlnode_get_parent(node); xmlnode_free(node); }
void hybrid_logs_destroy(HybridLogs *log) { if (log) { g_free(log->log_path); g_free(log->id); xmlnode_free(log->root); g_free(log); } }
static void msn_soap_message_destroy(MsnSoapMessage *message) { g_slist_foreach(message->headers, (GFunc)g_free, NULL); g_slist_free(message->headers); g_free(message->action); if (message->xml) xmlnode_free(message->xml); g_free(message); }
/** * A replacement for xdb_set * returns 0 if the set succeeded, 1 if not */ int xdb_set(void *noop, jid fn, char *ns, xmlnode x) { extern jcr_instance jcr; char buf[512]; xmlnode n, s, xdb; int rc; n = xdb_get(noop, fn, NULL); if (n == NULL) { memset(buf, 0, 512); snprintf(buf, 511, "%s/%s.xml", jcr->spool_dir, fn->user); xdb = xmlnode_new_tag("xdb"); if (ns != NULL) xmlnode_put_attrib(x, "xdbns", ns); // log_debug(JDBG, "node not found, creating %s", xmlnode2str(x)); xmlnode_insert_node(xdb, x); // log_debug(JDBG, "\nwriting '%s'\n\n", xmlnode2str(xdb)); rc = xmlnode2file(buf, xdb); xmlnode_free(xdb); return rc; } else { s = NULL; // log_debug(JDBG, "node found '%s'", xmlnode2str(n)); if (ns == NULL) { s = xmlnode_get_tag(n, xmlnode_get_name(x)); } else { memset(buf, 0, 512); snprintf(buf, 511, "%s?xdbns=%s", xmlnode_get_name(x), ns); // log_debug(JDBG, "search for '%s'", buf); s = xmlnode_get_tag(n, buf); } // log_debug(JDBG, "removing '%s'", xmlnode2str(s)); xmlnode_hide(s); if (ns != NULL) xmlnode_put_attrib(x, "xdbns", ns); xmlnode_insert_tag_node(n, x); } snprintf(buf, 511, "%s/%s.xml", jcr->spool_dir, fn->user); rc = xmlnode2file(buf, n); xmlnode_free(n); log_debug(JDBG, "xdb_set: rc == %d", rc); return 0; }