result base_to_config(instance id, xmlnode x, void *arg)
{
if (id == NULL) {
jid j = jid_new(xmlnode_pool(x), xmlnode_get_data(x));
log_debug("base_to_config validating configuration\n");
if (j == NULL) {
xmlnode_put_attrib(x, "error",
"'to' tag must contain a jid to send log data to");
log_debug("Invalid Configuration for base_to");
return r_ERR;
}
return r_PASS;
}
log_debug("base_to configuring instance %s", id->id);
if (id->type != p_LOG) {
log_alert(NULL,
"ERROR in instance %s: <to>..</to> element only allowed in log sections",
id->id);
return r_ERR;
}
register_phandler(id, o_DELIVER, base_to_deliver,
(void *) xmlnode_get_data(x));
return r_DONE;
}
/**
* init the module, register callbacks
*
* builds a list of JabberIDs where presences should be blind carbon copied to.
* (Enclosing each in a <bcc/> element, which are contained in one <presence/>
* element in the session manager configuration.)
*
* registers mod_presence_session() as a callback, that gets notified on new sessions
* and mod_presence_deliver() as a callback to deliver presence stanzas locally.
*
* @param si the session manager instance
*/
JSM_FUNC void mod_presence(jsmi si)
{
xmlnode cfg = js_config(si, "presence");
modpres_conf conf =
(modpres_conf) pmalloco(si->p, sizeof(_modpres_conf));
log_debug("init");
for (cfg = xmlnode_get_firstchild(cfg); cfg != NULL;
cfg = xmlnode_get_nextsibling(cfg)) {
char *element_name = NULL;
if (xmlnode_get_type(cfg) != NTYPE_TAG)
continue;
element_name = xmlnode_get_name(cfg);
if (j_strcmp(element_name, "bcc") == 0) {
if (conf->bcc == NULL)
conf->bcc =
jid_new(si->p, xmlnode_get_data(cfg));
else
jid_append(conf->bcc,
jid_new(si->p,
xmlnode_get_data(cfg)));
} else if (j_strcmp(element_name, "presence2xdb") == 0) {
conf->pres_to_xdb++;
}
}
js_mapi_register(si, e_DELIVER, mod_presence_deliver, NULL);
js_mapi_register(si, e_SESSION, mod_presence_session,
(void *) conf);
}
static void
jabber_vcard_parse_avatar(JabberStream *js, const char *from,
JabberIqType type, const char *id,
xmlnode *packet, gpointer blah)
{
JabberBuddy *jb = NULL;
xmlnode *vcard, *photo, *binval, *fn, *nick;
char *text;
if(!from)
return;
jb = jabber_buddy_find(js, from, TRUE);
js->pending_avatar_requests = g_slist_remove(js->pending_avatar_requests, jb);
if((vcard = xmlnode_get_child(packet, "vCard")) ||
(vcard = xmlnode_get_child_with_namespace(packet, "query", "vcard-temp"))) {
/* The logic here regarding the nickname and full name is copied from
* buddy.c:jabber_vcard_parse. */
gchar *nickname = NULL;
if ((fn = xmlnode_get_child(vcard, "FN")))
nickname = xmlnode_get_data(fn);
if ((nick = xmlnode_get_child(vcard, "NICKNAME"))) {
char *tmp = xmlnode_get_data(nick);
char *bare_jid = jabber_get_bare_jid(from);
if (tmp && strstr(bare_jid, tmp) == NULL) {
g_free(nickname);
nickname = tmp;
} else if (tmp)
g_free(tmp);
g_free(bare_jid);
}
if (nickname) {
serv_got_alias(js->gc, from, nickname);
g_free(nickname);
}
if ((photo = xmlnode_get_child(vcard, "PHOTO")) &&
(binval = xmlnode_get_child(photo, "BINVAL")) &&
(text = xmlnode_get_data(binval))) {
guchar *data;
gsize size;
data = purple_base64_decode(text, &size);
if (data) {
gchar *hash = jabber_calculate_data_hash(data, size, "sha1");
purple_buddy_icons_set_for_user(js->gc->account, from, data,
size, hash);
g_free(hash);
}
g_free(text);
}
}
}
static gboolean
msn_soap_handle_body(MsnSoapConnection *conn, MsnSoapMessage *response)
{
xmlnode *body = xmlnode_get_child(response->xml, "Body");
xmlnode *fault = xmlnode_get_child(response->xml, "Fault");
if (fault) {
xmlnode *faultcode = xmlnode_get_child(fault, "faultcode");
if (faultcode != NULL) {
char *faultdata = xmlnode_get_data(faultcode);
if (faultdata && g_str_equal(faultdata, "psf:Redirect")) {
xmlnode *url = xmlnode_get_child(fault, "redirectUrl");
if (url) {
char *urldata = xmlnode_get_data(url);
if (urldata)
msn_soap_handle_redirect(conn, urldata);
g_free(urldata);
}
g_free(faultdata);
msn_soap_message_destroy(response);
return TRUE;
} else if (faultdata && g_str_equal(faultdata, "wsse:FailedAuthentication")) {
xmlnode *reason = xmlnode_get_child(fault, "faultstring");
char *reasondata = NULL;
if (reason)
reasondata = xmlnode_get_data(reason);
msn_soap_connection_sanitize(conn, TRUE);
msn_session_set_error(conn->session, MSN_ERROR_AUTH,
reasondata);
g_free(reasondata);
g_free(faultdata);
msn_soap_message_destroy(response);
return FALSE;
}
g_free(faultdata);
}
}
if (fault || body) {
if (conn->current_request) {
MsnSoapRequest *request = conn->current_request;
conn->current_request = NULL;
request->cb(request->message, response,
request->cb_data);
msn_soap_request_destroy(request, FALSE);
}
msn_soap_message_destroy(response);
}
return TRUE;
}
static gboolean
nexus_parse_token(MsnNexus *nexus, int id, xmlnode *node)
{
char *token_str, *expiry_str;
const char *id_str;
char **elems, **cur, **tokens;
xmlnode *token = xmlnode_get_child(node, "RequestedSecurityToken/BinarySecurityToken");
xmlnode *secret = xmlnode_get_child(node, "RequestedProofToken/BinarySecret");
xmlnode *expires = xmlnode_get_child(node, "LifeTime/Expires");
if (!token)
return FALSE;
/* Use the ID that the server sent us */
if (id == -1) {
id_str = xmlnode_get_attrib(token, "Id");
if (id_str == NULL)
return FALSE;
id = atol(id_str + 7) - 1; /* 'Compact#' or 'PPToken#' */
if (id >= nexus->token_len)
return FALSE; /* Where did this come from? */
}
token_str = xmlnode_get_data(token);
if (token_str == NULL)
return FALSE;
g_hash_table_remove_all(nexus->tokens[id].token);
elems = g_strsplit(token_str, "&", 0);
for (cur = elems; *cur != NULL; cur++) {
tokens = g_strsplit(*cur, "=", 2);
g_hash_table_insert(nexus->tokens[id].token, tokens[0], tokens[1]);
/* Don't free each of the tokens, only the array. */
g_free(tokens);
}
g_strfreev(elems);
g_free(token_str);
if (secret)
nexus->tokens[id].secret = xmlnode_get_data(secret);
else
nexus->tokens[id].secret = NULL;
/* Yay for MS using ISO-8601 */
expiry_str = xmlnode_get_data(expires);
nexus->tokens[id].expiry = purple_str_to_time(expiry_str,
FALSE, NULL, NULL, NULL);
g_free(expiry_str);
purple_debug_info("msn", "Updated ticket for domain '%s', expires at %" G_GINT64_FORMAT ".\n",
ticket_domains[id][SSO_VALID_TICKET_DOMAIN],
(gint64)nexus->tokens[id].expiry);
return TRUE;
}
int
main(){
xmlnode point;
xmlnode conf;
conf=xmlnode_file("./test.xml");
point=conf;
printf("\n");
printf("Tagname is %s.\n", xmlnode_get_name(point));
printf("Data is \"%s\"\n", xmlnode_get_data(point));
printf("Type is %d.\n", xmlnode_get_type(point));
point = xmlnode_get_firstchild(point);
printf("\n");
printf("Tagname is %s.\n", xmlnode_get_name(point));
printf("Data is \"%s\"\n", xmlnode_get_data(point));
printf("Type is %d.\n", xmlnode_get_type(point));
point = xmlnode_get_nextsibling(point);
printf("\n");
printf("Tagname is %s.\n", xmlnode_get_name(point));
printf("Data is %s.\n", xmlnode_get_data(point));
printf("Type is %d.\n", xmlnode_get_type(point));
point = xmlnode_get_nextsibling(point);
printf("\n");
printf("Tagname is %s.\n", xmlnode_get_name(point));
printf("Data is %s.\n", xmlnode_get_data(point));
printf("Type is %d.\n", xmlnode_get_type(point));
point = xmlnode_get_nextsibling(point);
printf("\n");
printf("Tagname is %s.\n", xmlnode_get_name(point));
printf("Data is %s.\n", xmlnode_get_data(point));
printf("Type is %d.\n", xmlnode_get_type(point));
point = xmlnode_get_nextsibling(point);
/*
point = xmlnode_get_nextsibling(point);
point = xmlnode_get_firstchild(point);
point = xmlnode_get_nextsibling(xmlnode_get_parent(point));
*/
xmlnode_free(conf);
} /* END MAIN */
/* 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);
}
/* returns the priority on a presence packet */
int jutil_priority(xmlnode x)
{
char *str;
int p;
if(x == NULL)
return -1;
if(xmlnode_get_attrib(x,"type") != NULL)
return -1;
x = xmlnode_get_tag(x,"priority");
if(x == NULL)
return 0;
str = xmlnode_get_data((x));
if(str == NULL)
return 0;
p = atoi(str);
if(p >= 0)
return p;
else
return 0;
}
JabberData *
jabber_data_create_from_xml(xmlnode *tag)
{
JabberData *data = g_new0(JabberData, 1);
gsize size;
gpointer raw_data = NULL;
if (data == NULL) {
purple_debug_error("jabber", "Could not allocate data object\n");
g_free(data);
return NULL;
}
/* check if this is a "data" tag */
if (strcmp(tag->name, "data") != 0) {
purple_debug_error("jabber", "Invalid data element");
g_free(data);
return NULL;
}
data->cid = g_strdup(xmlnode_get_attrib(tag, "cid"));
data->type = g_strdup(xmlnode_get_attrib(tag, "type"));
raw_data = xmlnode_get_data(tag);
data->data = purple_base64_decode(raw_data, &size);
data->size = size;
g_free(raw_data);
return data;
}
result base_to_deliver(instance id, dpacket p, void *arg)
{
char *log_data = xmlnode_get_data(p->x);
char *subject;
xmlnode message;
if (log_data == NULL)
return r_ERR;
message = xmlnode_new_tag("message");
xmlnode_insert_cdata(xmlnode_insert_tag(message, "body"), log_data,
-1);
subject =
spools(xmlnode_pool(message), "Log Packet from ",
xmlnode_get_attrib(p->x, "from"),
xmlnode_pool(message));
xmlnode_insert_cdata(xmlnode_insert_tag(message, "thread"),
shahash(subject), -1);
xmlnode_insert_cdata(xmlnode_insert_tag(message, "subject"),
subject, -1);
xmlnode_put_attrib(message, "from",
xmlnode_get_attrib(p->x, "from"));
xmlnode_put_attrib(message, "to", (char *) arg);
deliver(dpacket_new(message), id);
pool_free(p->p);
return r_DONE;
}
/* Parse the XML data,
* prepare to report the OIM to user
*/
static void
msn_oim_get_read_cb(MsnSoapMessage *request, MsnSoapMessage *response,
gpointer data)
{
MsnOimRecvData *rdata = data;
if (response != NULL) {
xmlnode *msg_node = xmlnode_get_child(response->xml,
"Body/GetMessageResponse/GetMessageResult");
if (msg_node) {
char *msg_str = xmlnode_get_data(msg_node);
msn_oim_report_to_user(rdata, msg_str);
g_free(msg_str);
} else {
char *str = xmlnode_to_str(response->xml, NULL);
purple_debug_info("msn", "Unknown OIM response: %s\n", str);
g_free(str);
msn_oim_recv_data_free(rdata);
}
} else {
purple_debug_info("msn", "Failed to get OIM\n");
msn_oim_recv_data_free(rdata);
}
}
result base_file_deliver(instance id, dpacket p, void* arg)
{
char* message = NULL;
basefile bf = (basefile) arg;
char date[50],buf[200];
struct tm *today;
unsigned long ltime;
FILE * f;
time( <ime );
/* once per second */
if ((ltime > bf->last_time) || (bf->f == NULL)) {
/* try to route */
bf->last_time = ltime;
/* lock */
pthread_mutex_lock(&(bf->sem));
today = localtime( <ime );
/* if day changed or new raport */
if ((bf->yesterday.tm_mday != today->tm_mday) || (bf->f == NULL)) {
memcpy(&(bf->yesterday),today,sizeof(struct tm));
strftime((char *)date,128,"%Y_%m_%d",today);
sprintf(buf,"%s_%s.log",bf->filename,date);
f = bf->f;
bf->f = fopen(buf,"at");
if (f)
fclose(f);
}
/* unlock */
pthread_mutex_unlock(&(bf->sem));
}
if (bf->f == NULL)
{
log_debug(ZONE,"base_file_deliver error: no file available to print to.\n");
return r_ERR;
}
message = xmlnode_get_data(p->x);
if (message == NULL) {
log_debug(ZONE,"base_file_deliver error: no message available to print.\n");
return r_ERR;
}
if (fprintf(bf->f,"%s\n", message) == EOF) {
log_debug(ZONE,"base_file_deliver error: error writing to file(%d).\n", errno);
return r_ERR;
}
fflush(bf->f);
/* Release the packet */
pool_free(p->p);
return r_DONE;
}
/* loop through both a and b comparing everything, attribs, cdata, children, etc */
int xmlnode_cmp(xmlnode a, xmlnode b)
{
int ret = 0;
while(1)
{
if(a == NULL && b == NULL)
return 0;
if(a == NULL || b == NULL)
return -1;
if(xmlnode_get_type(a) != xmlnode_get_type(b))
return -1;
switch(xmlnode_get_type(a))
{
case NTYPE_ATTRIB:
ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));
if(ret != 0)
return -1;
ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));
if(ret != 0)
return -1;
break;
case NTYPE_TAG:
ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));
if(ret != 0)
return -1;
ret = xmlnode_cmp(xmlnode_get_firstattrib(a), xmlnode_get_firstattrib(b));
if(ret != 0)
return -1;
ret = xmlnode_cmp(xmlnode_get_firstchild(a), xmlnode_get_firstchild(b));
if(ret != 0)
return -1;
break;
case NTYPE_CDATA:
ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));
if(ret != 0)
return -1;
}
a = xmlnode_get_nextsibling(a);
b = xmlnode_get_nextsibling(b);
}
}
void jabber_stream_error(Stream *s,xmlnode x){
char *data;
data=xmlnode_get_data(x);
if (data==NULL) data="-unknown-";
g_critical(L_("Stream error: %s"),data);
stream_close(s);
stop_it=1;
}
/* return the cdata from any tag */
char *xmlnode_get_tag_data(xmlnode parent, const char *name)
{
xmlnode tag;
tag = xmlnode_get_tag(parent, name);
if(tag == NULL) return NULL;
return xmlnode_get_data(tag);
}
CoinCoinMessage* coincoin_message_new(gint64 id, xmlnode* post)
{
CoinCoinMessage* msg;
xmlnode* message = xmlnode_get_child(post, "message");
xmlnode* info = xmlnode_get_child(post, "info");
xmlnode* login = xmlnode_get_child(post, "login");
gchar *data, *ptr;
static struct tm t;
time_t tt = time(NULL);
if(!message || !info || !login)
return NULL;
/* Parse time */
if (sscanf(xmlnode_get_attrib(post, "time"), "%4d%2d%2d%2d%2d%2d", &t.tm_year,&t.tm_mon,&t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec) == 6)
{
t.tm_year -= 1900;
t.tm_mon -= 1;
tt = mktime(&t);
}
/* Skip chars before message. */
ptr = data = xmlnode_get_data(message);
while(ptr && *ptr && (*ptr == '\t' || *ptr == '\n' || *ptr == '\r'))
++ptr;
msg = g_new0(CoinCoinMessage, 1);
if(!msg)
{
return NULL;
}
msg->message = g_strdup(ptr);
msg->info = xmlnode_get_data(info);
msg->from = xmlnode_get_data(login);
msg->timestamp = tt;
msg->id = id;
msg->ref = 1;
msg->multiple = FALSE;
g_free(data);
return msg;
}
void twitter_send_request_cb(PurpleUtilFetchUrlData *url_data, gpointer user_data,
const gchar *url_text, gsize len,
const gchar *server_error_message)
{
TwitterSendRequestData *request_data = user_data;
const gchar *error_message = NULL;
gchar *error_node_text = NULL;
xmlnode *response_node = NULL;
TwitterRequestErrorType error_type = TWITTER_REQUEST_ERROR_NONE;
purple_debug_info("twitter", "Response: %s\n", url_text);
if (server_error_message)
{
error_type = TWITTER_REQUEST_ERROR_SERVER;
error_message = server_error_message;
} else {
response_node = xmlnode_from_str(url_text, len);
if (!response_node)
{
error_type = TWITTER_REQUEST_ERROR_INVALID_XML;
error_message = url_text;
} else {
xmlnode *error_node;
if ((error_node = xmlnode_get_child(response_node, "error")) != NULL)
{
error_type = TWITTER_REQUEST_ERROR_TWITTER_GENERAL;
error_node_text = xmlnode_get_data(error_node);
error_message = error_node_text;
}
}
}
if (error_type != TWITTER_REQUEST_ERROR_NONE)
{
TwitterRequestErrorData *error_data = g_new0(TwitterRequestErrorData, 1);
error_data->type = error_type;
error_data->message = error_message;
//error_data->response_node = response_node;
if (request_data->error_func)
request_data->error_func(request_data->account, error_data, request_data->user_data);
g_free(error_data);
} else {
if (request_data->success_func)
request_data->success_func(request_data->account, response_node, request_data->user_data);
}
if (response_node != NULL)
xmlnode_free(response_node);
if (error_node_text != NULL)
g_free(error_node_text);
g_free(request_data);
}
char *
xmlnode_get_data_unescaped(xmlnode *node)
{
char *escaped = xmlnode_get_data(node);
char *unescaped = escaped ? purple_unescape_html(escaped) : NULL;
g_free(escaped);
return unescaped;
}
static JabberSaslState
jabber_cyrus_handle_challenge(JabberStream *js, xmlnode *packet,
xmlnode **reply, char **error)
{
char *enc_in = xmlnode_get_data(packet);
unsigned char *dec_in;
char *enc_out;
const char *c_out;
unsigned int clen;
gsize declen;
dec_in = purple_base64_decode(enc_in, &declen);
js->sasl_state = sasl_client_step(js->sasl, (char*)dec_in, declen,
NULL, &c_out, &clen);
g_free(enc_in);
g_free(dec_in);
if (js->sasl_state != SASL_CONTINUE && js->sasl_state != SASL_OK) {
gchar *tmp = g_strdup_printf(_("SASL error: %s"),
sasl_errdetail(js->sasl));
purple_debug_error("jabber", "Error is %d : %s\n",
js->sasl_state, sasl_errdetail(js->sasl));
*error = tmp;
return JABBER_SASL_STATE_FAIL;
} else {
xmlnode *response = xmlnode_new("response");
xmlnode_set_namespace(response, NS_XMPP_SASL);
if (clen > 0) {
/* Cyrus SASL 2.1.22 appears to contain code to add the charset
* to the response for DIGEST-MD5 but there is no possibility
* it will be executed.
*
* My reading of the digestmd5 plugin indicates the username and
* realm are always encoded in UTF-8 (they seem to be the values
* we pass in), so we need to ensure charset=utf-8 is set.
*/
if (!purple_strequal(js->current_mech, "DIGEST-MD5") ||
strstr(c_out, ",charset="))
/* If we're not using DIGEST-MD5 or Cyrus SASL is fixed */
enc_out = purple_base64_encode((unsigned char*)c_out, clen);
else {
char *tmp = g_strdup_printf("%s,charset=utf-8", c_out);
enc_out = purple_base64_encode((unsigned char*)tmp, clen + 14);
g_free(tmp);
}
xmlnode_insert_data(response, enc_out, -1);
g_free(enc_out);
}
*reply = response;
return JABBER_SASL_STATE_CONTINUE;
}
}
void jabber_oob_parse(JabberStream *js, const char *from, JabberIqType type,
const char *id, xmlnode *querynode) {
JabberOOBXfer *jox;
PurpleXfer *xfer;
char *filename;
char *url;
xmlnode *urlnode;
if(type != JABBER_IQ_SET)
return;
if(!from)
return;
if(!(urlnode = xmlnode_get_child(querynode, "url")))
return;
url = xmlnode_get_data(urlnode);
jox = g_new0(JabberOOBXfer, 1);
if (!purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL)) {
g_free(url);
return;
}
g_free(url);
jox->js = js;
jox->headers = g_string_new("");
jox->iq_id = g_strdup(id);
xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE, from);
if (xfer)
{
xfer->data = jox;
if(!(filename = g_strdup(g_strrstr(jox->page, "/"))))
filename = g_strdup(jox->page);
purple_xfer_set_filename(xfer, filename);
g_free(filename);
purple_xfer_set_init_fnc(xfer, jabber_oob_xfer_init);
purple_xfer_set_end_fnc(xfer, jabber_oob_xfer_end);
purple_xfer_set_request_denied_fnc(xfer, jabber_oob_xfer_recv_denied);
purple_xfer_set_cancel_recv_fnc(xfer, jabber_oob_xfer_recv_cancelled);
purple_xfer_set_read_fnc(xfer, jabber_oob_xfer_read);
purple_xfer_set_start_fnc(xfer, jabber_oob_xfer_start);
js->oob_file_transfers = g_list_append(js->oob_file_transfers, xfer);
purple_xfer_request(xfer);
}
}
/* places copy of node and node's siblings in parent */
void xmlnode_insert_node(xmlnode parent, xmlnode node)
{
if(node == NULL || parent == NULL)
return;
while(node != NULL)
{
switch(xmlnode_get_type(node))
{
case NTYPE_ATTRIB:
xmlnode_put_attrib(parent, xmlnode_get_name(node), xmlnode_get_data(node));
break;
case NTYPE_TAG:
xmlnode_insert_tag_node(parent, node);
break;
case NTYPE_CDATA:
xmlnode_insert_cdata(parent, xmlnode_get_data(node), xmlnode_get_datasz(node));
}
node = xmlnode_get_nextsibling(node);
}
}
/* we should be last in the list of modules */
JSM_FUNC void mod_log(jsmi si)
{
xmlnode cfg = js_config(si, "archive");
jid svcs = NULL;
log_debug("mod_log init");
/* look for archiving service too */
for (cfg = xmlnode_get_firstchild(cfg); cfg != NULL;
cfg = xmlnode_get_nextsibling(cfg)) {
if (xmlnode_get_type(cfg) != NTYPE_TAG
|| j_strcmp(xmlnode_get_name(cfg), "service") != 0)
continue;
if (svcs == NULL)
svcs = jid_new(si->p, xmlnode_get_data(cfg));
else
jid_append(svcs,
jid_new(si->p, xmlnode_get_data(cfg)));
}
js_mapi_register(si, e_SESSION, mod_log_session, (void *) svcs);
}
result base_file_config(instance id, xmlnode x, void *arg)
{
basefile bf;
if(id == NULL)
{
log_debug(ZONE,"base_file_config validating configuration");
if (xmlnode_get_data(x) == NULL)
{
log_debug(ZONE,"base_file_config error: no filename provided.");
xmlnode_put_attrib(x,"error","'file' tag must contain a filename to write to");
return r_ERR;
}
return r_PASS;
}
log_debug(ZONE,"base_file configuring instance %s",id->id);
if(id->type != p_LOG)
{
log_alert(NULL,"ERROR in instance %s: <file>..</file> element only allowed in log sections", id->id);
return r_ERR;
}
bf = pmalloco(id->p,sizeof(_basefile));
bf->filename = pstrdup(id->p,xmlnode_get_data(x));
bf->yesterday.tm_mday = -1;
bf->last_time = 0;
bf->f = NULL;
pthread_mutex_init(&(bf->sem),NULL);
/* Register a handler for this instance... */
register_phandler(id, o_DELIVER, base_file_deliver, (void*)bf);
pool_cleanup(id->p, _base_file_shutdown, (void*)bf);
return r_DONE;
}
void jabber_oob_parse(JabberStream *js, xmlnode *packet) {
JabberOOBXfer *jox;
PurpleXfer *xfer;
char *filename;
char *url;
const char *type;
xmlnode *querynode, *urlnode;
if(!(type = xmlnode_get_attrib(packet, "type")) || strcmp(type, "set"))
return;
if(!(querynode = xmlnode_get_child(packet, "query")))
return;
if(!(urlnode = xmlnode_get_child(querynode, "url")))
return;
url = xmlnode_get_data(urlnode);
jox = g_new0(JabberOOBXfer, 1);
purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL);
g_free(url);
jox->js = js;
jox->headers = g_string_new("");
jox->iq_id = g_strdup(xmlnode_get_attrib(packet, "id"));
xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE,
xmlnode_get_attrib(packet, "from"));
if (xfer)
{
xfer->data = jox;
if(!(filename = g_strdup(g_strrstr(jox->page, "/"))))
filename = g_strdup(jox->page);
purple_xfer_set_filename(xfer, filename);
g_free(filename);
purple_xfer_set_init_fnc(xfer, jabber_oob_xfer_init);
purple_xfer_set_end_fnc(xfer, jabber_oob_xfer_end);
purple_xfer_set_request_denied_fnc(xfer, jabber_oob_xfer_recv_denied);
purple_xfer_set_cancel_recv_fnc(xfer, jabber_oob_xfer_recv_canceled);
purple_xfer_set_read_fnc(xfer, jabber_oob_xfer_read);
purple_xfer_set_start_fnc(xfer, jabber_oob_xfer_start);
js->oob_file_transfers = g_list_append(js->oob_file_transfers, xfer);
purple_xfer_request(xfer);
}
}
static gboolean
nexus_parse_collection(MsnNexus *nexus, int id, xmlnode *collection)
{
xmlnode *node;
gboolean result;
node = xmlnode_get_child(collection, "RequestSecurityTokenResponse");
if (!node)
return FALSE;
result = TRUE;
for (; node && result; node = node->next) {
xmlnode *endpoint = xmlnode_get_child(node, "AppliesTo/EndpointReference/Address");
char *address = xmlnode_get_data(endpoint);
if (g_str_equal(address, "http://Passport.NET/tb")) {
/* This node contains the stuff for updating tokens. */
char *data;
xmlnode *cipher = xmlnode_get_child(node, "RequestedSecurityToken/EncryptedData/CipherData/CipherValue");
xmlnode *secret = xmlnode_get_child(node, "RequestedProofToken/BinarySecret");
g_free(nexus->cipher);
nexus->cipher = xmlnode_get_data(cipher);
data = xmlnode_get_data(secret);
g_free(nexus->secret);
nexus->secret = (char *)purple_base64_decode(data, NULL);
g_free(data);
} else {
result = nexus_parse_token(nexus, id, node);
}
g_free(address);
}
return result;
}
void dnsrv_process_xstream_io(int type, xmlnode x, void* arg)
{
dns_io di = (dns_io)arg;
char* hostname = NULL;
char* ipaddr = NULL;
char* resendhost = NULL;
dns_packet_list head = NULL;
dns_packet_list heado = NULL;
/* Node Format: <host ip="201.83.28.2">foo.org</host> */
if (type == XSTREAM_NODE)
{
log_debug(ZONE,"incoming resolution: %s",xmlnode2str(x));
hostname = xmlnode_get_data(x);
/* whatever the response was, let's cache it */
xmlnode_free((xmlnode)xhash_get(di->cache_table,hostname)); /* free any old cache, shouldn't ever be any */
xmlnode_put_vattrib(x,"t",(void*)time(NULL));
xhash_put(di->cache_table,hostname,(void*)x);
/* Get the hostname and look it up in the hashtable */
head = xhash_get(di->packet_table, hostname);
/* Process the packet list */
if (head != NULL)
{
ipaddr = xmlnode_get_attrib(x, "ip");
resendhost = xmlnode_get_attrib(x, "to");
/* Remove the list from the hashtable */
xhash_zap(di->packet_table, hostname);
/* Walk the list and insert IPs */
while(head != NULL)
{
heado = head;
/* Move to next.. */
head = head->next;
/* Deliver the packet */
dnsrv_resend(heado->packet->x, ipaddr, resendhost);
}
}
/* Host name was not found, something is _TERRIBLY_ wrong! */
else
log_debug(ZONE, "Resolved unknown host/ip request: %s\n", xmlnode2str(x));
return; /* we cached x above, so we don't free it below :) */
}
xmlnode_free(x);
}
static spool _xmlnode2spool(xmlnode node)
{
spool s;
int level=0,dir=0;
xmlnode tmp;
if(!node || xmlnode_get_type(node)!=NTYPE_TAG)
return NULL;
s = spool_new(xmlnode_pool(node));
if(!s) return(NULL);
while(1)
{
if(dir==0)
{
if(xmlnode_get_type(node) == NTYPE_TAG)
{
if(xmlnode_has_children(node))
{
_xmlnode_tag2str(s,node,1);
node = xmlnode_get_firstchild(node);
level++;
continue;
}else{
_xmlnode_tag2str(s,node,0);
}
}else{
spool_add(s,strescape(xmlnode_pool(node),xmlnode_get_data(node)));
}
}
tmp = xmlnode_get_nextsibling(node);
if(!tmp)
{
node = xmlnode_get_parent(node);
level--;
if(level>=0) _xmlnode_tag2str(s,node,2);
if(level<1) break;
dir = 1;
}else{
node = tmp;
dir = 0;
}
}
return s;
}
/* Get the PSM info from the XML node */
char *
msn_get_psm(xmlnode *payloadNode)
{
xmlnode *psmNode;
char *psm;
purple_debug_info("msn", "msn get PSM\n");
psmNode = xmlnode_get_child(payloadNode, "PSM");
if (psmNode == NULL) {
purple_debug_info("msn", "No PSM status Node\n");
return NULL;
}
psm = xmlnode_get_data(psmNode);
return psm;
}
static
void data_from_node(xmlnode *track, const char *name, char *result)
{
result[0] = 0;
xmlnode *node = xmlnode_get_child(track, name);
if (node)
{
char *value = xmlnode_get_data(node);
if (value)
{
strncpy(result, value, STRLEN);
result[STRLEN-1] = 0;
g_free(value);
}
}
}
/* get the CurrentMedia info from the XML node */
char *
msn_get_currentmedia(xmlnode *payloadNode)
{
xmlnode *currentmediaNode;
char *currentmedia;
purple_debug_info("msn", "Get CurrentMedia\n");
currentmediaNode = xmlnode_get_child(payloadNode, "CurrentMedia");
if (currentmediaNode == NULL) {
purple_debug_info("msn", "No CurrentMedia Node\n");
return NULL;
}
currentmedia = xmlnode_get_data(currentmediaNode);
return currentmedia;
}
