int message_send_subject(struct stream_s *stream,const char *from,
const char *to,const char *subject,const char *message,time_t timestamp){
xmlnode msg;
xmlnode n;
struct tm *tm;
char buf[101];
msg=xmlnode_new_tag("message");
if (from!=NULL)
xmlnode_put_attrib(msg,"from",from);
else{
char *jid;
jid=jid_my_registered();
xmlnode_put_attrib(msg,"from",jid);
g_free(jid);
}
xmlnode_put_attrib(msg,"to",to);
n=xmlnode_insert_tag(msg,"subject");
xmlnode_insert_cdata(n,subject,-1);
n=xmlnode_insert_tag(msg,"body");
xmlnode_insert_cdata(n,message,-1);
if (timestamp){
n=xmlnode_insert_tag(msg,"x");
xmlnode_put_attrib(n,"xmlns","jabber:x:delay");
tm=gmtime(×tamp);
strftime(buf,100,"%Y%m%dT%H:%M:%S",tm);
xmlnode_put_attrib(n,"stamp",buf);
xmlnode_insert_cdata(n,"Delayed message",-1);
}
stream_write(stream,msg);
xmlnode_free(msg);
return 0;
}
int at_iq_time(ati ti, jpacket jp)
{
xmlnode x, q;
time_t t;
char *tstr;
if(jpacket_subtype(jp) != JPACKET__GET)
{
at_bounce(ti, jp, TERROR_BAD);
return 1;
}
x = jutil_iqresult(jp->x);
q = xmlnode_insert_tag(x,"query");
xmlnode_put_attrib(q,"xmlns",NS_TIME);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"utc"),jutil_timestamp(),-1);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"tz"),tzname[0],-1);
/* create nice display time */
t = time(NULL);
tstr = ctime(&t);
tstr[strlen(tstr) - 1] = '\0'; /* cut off newline */
xmlnode_insert_cdata(xmlnode_insert_tag(q,"display"),tstr,-1);
at_deliver(ti,x);
return 1;
}
int message_send_error(struct stream_s *stream,const char *from,
const char *to,const char *body,int code,const char *str){
xmlnode msg;
xmlnode n;
char *s;
msg=xmlnode_new_tag("message");
if (from!=NULL)
xmlnode_put_attrib(msg,"from",from);
else{
char *jid;
jid=jid_my_registered();
xmlnode_put_attrib(msg,"from",jid);
g_free(jid);
}
xmlnode_put_attrib(msg,"to",to);
xmlnode_put_attrib(msg,"type","error");
s=g_strdup_printf("%03u",code);
xmlnode_put_attrib(msg,"code",s);
g_free(s);
n=xmlnode_insert_tag(msg,"error");
xmlnode_insert_cdata(n,str,-1);
if (body){
n=xmlnode_insert_tag(msg,"body");
xmlnode_insert_cdata(n,body,-1);
}
stream_write(stream,msg);
xmlnode_free(msg);
return 0;
}
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;
}
int at_iq_version(ati ti, jpacket jp)
{
xmlnode os, x, q;
struct utsname un;
if(jpacket_subtype(jp) != JPACKET__GET)
{
at_bounce(ti, jp, TERROR_BAD);
return 1;
}
x = jutil_iqresult(jp->x);
q = xmlnode_insert_tag(x,"query");
xmlnode_put_attrib(q,"xmlns",NS_VERSION);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"name"),"AIM Transport",-1);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"version"), VERSION,-1);
uname(&un);
os = xmlnode_insert_tag(q,"os");
xmlnode_insert_cdata(os,un.sysname,-1);
xmlnode_insert_cdata(os," ",1);
xmlnode_insert_cdata(os,un.release,-1);
at_deliver(ti,x);
// AGAIN!?!
return 1;
}
/**
* utility for making message stanzas
*
* @param type the type of the message (as a string!)
* @param to the recipient of the message
* @param subj the subject of the message (NULL for no subject element)
* @param body the body of the message
* @return the xmlnode containing the new message stanza
*/
xmlnode jutil_msgnew(char *type, char *to, char *subj, char *body)
{
xmlnode msg;
msg = xmlnode_new_tag("message");
if (type != NULL) {
xmlnode_put_attrib(msg, "type", type);
}
if (to != NULL) {
xmlnode_put_attrib(msg, "to", to);
}
if (subj != NULL) {
xmlnode_insert_cdata(xmlnode_insert_tag(msg, "subject"),
subj, strlen(subj));
}
if (body != NULL) {
xmlnode_insert_cdata(xmlnode_insert_tag(msg, "body"), body,
strlen(body));
}
return msg;
}
/*
* adds an option to list field of jabber:x:data form
* returns the node added
*/
xmlnode form_add_option(xmlnode field,const char *label,const char *val){
xmlnode option,value;
option=xmlnode_insert_tag(field,"option");
xmlnode_put_attrib(option,"label",label);
value=xmlnode_insert_tag(option,"value");
xmlnode_insert_cdata(value,val,-1);
return option;
}
/*
* adds "fixed" field to a jabber:x:data form
* returns the field added
*/
xmlnode form_add_fixed(xmlnode form,const char *val){
xmlnode field,value;
field=xmlnode_insert_tag(form,"field");
xmlnode_put_attrib(field,"type","fixed");
value=xmlnode_insert_tag(field,"value");
xmlnode_insert_cdata(value,val,-1);
return field;
}
/*
* adds a value to a jabber:x:data report item
* returns the field added
*/
xmlnode form_add_result_value(xmlnode item,const char *var,const char *val){
xmlnode field,value;
field=xmlnode_insert_tag(item,"field");
xmlnode_put_attrib(field,"var",var);
value=xmlnode_insert_tag(field,"value");
if (val!=NULL)
xmlnode_insert_cdata(value,val,-1);
return field;
}
void mt_ns_msg(mpacket mp, session s)
{
xmlnode msg, oob;
char *body, *ctype, *ptr;
/* message body spool*/
pool p = pool_new();
spool sp = spool_new(p);
if (s->ti->inbox_headlines == 0)
return;
ctype = strchr(mt_packet_data(mp,5),':') + 2;
body = mt_packet_data(mp,mp->count - 1);
/* this message is a Hotmail inbox notification */
if ((strncmp(ctype,"text/x-msmsgsinitialemailnotification",37) != 0) &&
(strncmp(ctype,"text/x-msmsgsemailnotification",30) != 0))
return;
/* Fede <*****@*****.**> */
/* cut off the junk at the end */
if ((ptr = strstr(body,"Inbox-URL")) != NULL) {
*ptr = '\0';
spool_add(sp,body);
} else {
if ((ptr = strstr(body,"From:")) != NULL) {
char *p = strchr(ptr, '\r');
*p = '\0';
spooler(sp,"Mail from: ", ptr + 6,sp);
body = p + 1;
}
if ((ptr = strstr(body,"From-Addr:")) != NULL) {
*strchr(ptr, '\r') = '\0';
spooler(sp," <",ptr + 11,">",sp);
}
}
msg = xmlnode_new_tag("message");
xmlnode_put_attrib(msg,"to",jid_full(s->id));
xmlnode_put_attrib(msg,"from",s->host);
xmlnode_put_attrib(msg,"type","headline");
xmlnode_insert_cdata(xmlnode_insert_tag(msg,"subject"),"Hotmail",-1);
xmlnode_insert_cdata(xmlnode_insert_tag(msg,"body"),spool_print(sp),-1);
oob = xmlnode_insert_tag(msg,"x");
xmlnode_put_attrib(oob,"xmlns","jabber:x:oob");
xmlnode_insert_cdata(xmlnode_insert_tag(oob,"url"),"http://www.hotmail.com/cgi-bin/folders",-1);
xmlnode_insert_cdata(xmlnode_insert_tag(oob,"desc"),"Login to your Hotmail e-mail account",-1);
mt_deliver(s->ti,msg);
pool_free(p);
}
int at_iq_gateway(ati ti, jpacket jp)
{
if(jp->to->user != NULL)
{
at_bounce(ti, jp, TERROR_NOTALLOWED);
return 1;
}
switch(jpacket_subtype(jp))
{
case JPACKET__GET:
{
xmlnode q;
jutil_iqresult(jp->x);
q = xmlnode_insert_tag(jp->x,"query");
xmlnode_put_attrib(q,"xmlns",NS_GATEWAY);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"desc"),"Enter the user's screenname",-1);
xmlnode_insert_tag(q,"prompt");
break;
}
case JPACKET__SET:
{
char *user, *id;
user = xmlnode_get_tag_data(jp->iq,"prompt");
id = user ? spools(jp->p,at_normalize(user),"@",jp->to->server,jp->p) : NULL;
if (id)
{
xmlnode q;
jutil_iqresult(jp->x);
q = xmlnode_insert_tag(jp->x,"query");
xmlnode_put_attrib(q,"xmlns",NS_GATEWAY);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"prompt"),id,-1);
}
else
jutil_error(jp->x,TERROR_BAD);
break;
}
default:
jutil_error(jp->x,TERROR_BAD);
break;
}
at_deliver(ti,jp->x);
return 1;
}
int at_iq_last(ati ti, jpacket jp)
{
xmlnode last;
xmlnode q;
char str[10];
/* XXX I can do last if I track logouts in the XDB... not too hard */
if(jpacket_subtype(jp) != JPACKET__GET)
{
at_bounce(ti, jp, TERROR_BAD);
return 1;
}
if(jp->to->user != NULL)
{
at_session s;
at_buddy buddy;
char *res;
s = at_session_find_by_jid(ti, jp->from);
if(s == NULL)
{
at_bounce(ti, jp, TERROR_REGISTER);
return 1;
}
buddy = xhash_get(s->buddies, jp->to->user);
if(buddy == NULL)
{
at_bounce(ti, jp, TERROR_BAD);
return 1;
}
jutil_iqresult(jp->x);
last = xmlnode_insert_tag(jp->x, "query");
xmlnode_put_attrib(last,"xmlns",NS_LAST);
sprintf(str, "%d", buddy->idle_time);
xmlnode_put_attrib(last, "seconds", str);
at_deliver(ti,jp->x);
return 1;
}
jutil_iqresult(jp->x);
last = xmlnode_insert_tag(jp->x, "query");
xmlnode_put_attrib(last,"xmlns",NS_LAST);
sprintf(str, "%d", time(NULL) - ti->start_time);
xmlnode_put_attrib(last,"seconds", str);
at_deliver(ti,jp->x);
return 1;
}
void con_room_leaveall(gpointer key, gpointer data, gpointer arg)
{
cnu user = (cnu)data;
xmlnode info = (xmlnode)arg;
char *alt, *reason;
xmlnode presence;
xmlnode tag;
xmlnode element;
xmlnode node;
xmlnode destroy;
log_debug(NAME, "[%s] reason : %s", FZONE, xmlnode2str(info));
if(user == NULL)
{
log_warn(NAME, "[%s] Aborting - NULL user attribute found", FZONE);
return;
}
if (user->remote == 1)
return;
presence = jutil_presnew(JPACKET__UNAVAILABLE, NULL, NULL);
tag = xmlnode_insert_tag(presence,"x");
xmlnode_put_attrib(tag, "xmlns", NS_MUC_USER);
element = xmlnode_insert_tag(tag, "item");
xmlnode_put_attrib(element, "role", "none");
xmlnode_put_attrib(element, "affiliation", "none");
if (info != NULL)
{
destroy = xmlnode_insert_tag(tag, "destroy");
reason = xmlnode_get_tag_data(info, "reason");
node = xmlnode_insert_tag(destroy, "reason");
if(reason != NULL)
{
xmlnode_insert_cdata(node, reason, -1);
}
alt = xmlnode_get_attrib(info, "jid");
if (alt != NULL)
{
xmlnode_put_attrib(destroy, "jid", alt);
}
}
con_user_send(user, user, presence);
}
/*
* adds a field declaration to a jabber:x:data report
* returns the field added
*/
xmlnode form_add_result_field(xmlnode form,const char *var,const char *label,const char *type){
xmlnode rep,field;
rep=xmlnode_get_tag(form,"reported");
if (rep==NULL){
rep=xmlnode_insert_tag(form,"reported");
}
field=xmlnode_insert_tag(rep,"field");
xmlnode_put_attrib(field,"var",var);
xmlnode_put_attrib(field,"label",label);
if (type!=NULL)
xmlnode_put_attrib(field,"type",type);
return field;
}
/*
* adds a field to a jabber:x:data form
* returns the field added
*/
xmlnode form_add_field(xmlnode form,const char *type,const char *var,
const char *label,const char *val,int required){
xmlnode field,value;
field=xmlnode_insert_tag(form,"field");
xmlnode_put_attrib(field,"type",type);
xmlnode_put_attrib(field,"var",var);
if (required) xmlnode_insert_tag(field,"required");
xmlnode_put_attrib(field,"label",label);
if (val){
value=xmlnode_insert_tag(field,"value");
xmlnode_insert_cdata(value,val,-1);
}
return field;
}
int at_iq_vcard(ati ti, jpacket jp)
{
xmlnode data;
at_session s;
s = at_session_find_by_jid(ti, jp->from);
if(jpacket_subtype(jp) != JPACKET__GET ||
(s && ((!s->icq && jp->to->user) || (s->icq && s->icq_vcard_response))))
{
at_bounce(ti, jp, TERROR_BAD);
return 1;
}
if(!jp->to->user)
{
xmlnode_insert_node(jutil_iqresult(jp->x),ti->vcard);
at_deliver(ti,jp->x);
return 1;
}
if(!s)
return 0;
jutil_iqresult(jp->x);
jp->iq = data = xmlnode_insert_tag(jp->x,"vCard");
xmlnode_put_attrib(data,"xmlns",NS_VCARD);
xmlnode_put_attrib(data,"version","3.0");
xmlnode_put_attrib(data,"prodid","-//HandGen//NONSGML vGen v1.0//EN");
s->icq_vcard_response = jp;
aim_icq_getsimpleinfo(s->ass,
jp->to->user);
return 1;
}
int at_iq_disco_items(ati ti, jpacket jp)
{
xmlnode q;
if(jpacket_subtype(jp) != JPACKET__GET)
{
at_bounce(ti, jp, TERROR_BAD);
return 1;
}
if(xmlnode_get_attrib(xmlnode_get_tag(jp->x, "query"),"node") != NULL)
{
at_bounce(ti, jp, TERROR_NOTALLOWED);
return 1;
}
jutil_iqresult(jp->x);
q = xmlnode_insert_tag(jp->x, "query");
xmlnode_put_attrib(q, "xmlns", NS_DISCO_ITEMS);
at_deliver(ti,jp->x);
return 1;
}
mreturn mod_browse_reply(mapi m, void *arg)
{
xmlnode browse, ns, cur;
session s;
if (m->packet->type != JPACKET_IQ)
return M_IGNORE;
if (!NSCHECK(m->packet->iq, NS_BROWSE))
return M_PASS;
/* first, is this a valid request? */
switch (jpacket_subtype(m->packet)) {
case JPACKET__RESULT:
case JPACKET__ERROR:
return M_PASS;
case JPACKET__SET:
js_bounce(m->si, m->packet->x, TERROR_NOTALLOWED);
return M_HANDLED;
}
log_debug("handling query for user %s", m->user->user);
/* get this dudes browse info */
browse = mod_browse_get(m, m->packet->to);
/* insert the namespaces */
ns = xdb_get(m->si->xc, m->packet->to, NS_XDBNSLIST);
for (cur = xmlnode_get_firstchild(ns); cur != NULL;
cur = xmlnode_get_nextsibling(cur))
if (xmlnode_get_attrib(cur, "type") == NULL)
xmlnode_insert_tag_node(browse, cur); /* only include the generic <ns>foo</ns> */
xmlnode_free(ns);
/* include any connected resources if there's a s10n from them */
if (js_trust(m->user, m->packet->from)) {
SEM_LOCK(m->user->sem);
for (s = m->user->sessions; s != NULL; s = s->next) {
/* if(s->priority < 0) continue; *** include all resources I guess */
if (xmlnode_get_tag
(browse,
spools(m->packet->p, "?jid=", jid_full(s->id),
m->packet->p)) != NULL)
continue; /* already in the browse result */
cur = xmlnode_insert_tag(browse, "user");
xmlnode_put_attrib(cur, "type", "client");
xmlnode_put_attrib(cur, "jid", jid_full(s->id));
}
SEM_UNLOCK(m->user->sem);
}
/* XXX include iq:filter forwards */
jutil_iqresult(m->packet->x);
jpacket_reset(m->packet);
xmlnode_insert_tag_node(m->packet->x, browse);
js_deliver(m->si, m->packet);
xmlnode_free(browse);
return M_HANDLED;
}
/* util for making presence packets */
xmlnode jutil_presnew(int type, char *to, char *status)
{
xmlnode pres;
pres = xmlnode_new_tag("presence");
switch(type)
{
case JPACKET__SUBSCRIBE:
xmlnode_put_attrib(pres,"type","subscribe");
break;
case JPACKET__UNSUBSCRIBE:
xmlnode_put_attrib(pres,"type","unsubscribe");
break;
case JPACKET__SUBSCRIBED:
xmlnode_put_attrib(pres,"type","subscribed");
break;
case JPACKET__UNSUBSCRIBED:
xmlnode_put_attrib(pres,"type","unsubscribed");
break;
case JPACKET__PROBE:
xmlnode_put_attrib(pres,"type","probe");
break;
case JPACKET__UNAVAILABLE:
xmlnode_put_attrib(pres,"type","unavailable");
break;
}
if(to != NULL)
xmlnode_put_attrib(pres,"to",to);
if(status != NULL)
xmlnode_insert_cdata(xmlnode_insert_tag(pres,"status"),status,strlen(status));
return pres;
}
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;
}
/*
* creates a new jabber:x:data form
* returns the node created added
*/
xmlnode form_new(xmlnode parent,const char *title,const char *instructions){
xmlnode form,tag;
if (parent)
form=xmlnode_insert_tag(parent,"x");
else
form=xmlnode_new_tag("x");
xmlnode_put_attrib(form,"xmlns","jabber:x:data");
xmlnode_put_attrib(form,"type","form");
tag=xmlnode_insert_tag(form,"title");
xmlnode_insert_cdata(tag,title,-1);
tag=xmlnode_insert_tag(form,"instructions");
xmlnode_insert_cdata(tag,instructions,-1);
return form;
}
mreturn mod_browse_server(mapi m, void *arg)
{
xmlnode browse, query, x;
if (m->packet->type != JPACKET_IQ)
return M_IGNORE;
if (jpacket_subtype(m->packet) != JPACKET__GET
|| !NSCHECK(m->packet->iq, NS_BROWSE)
|| m->packet->to->resource != NULL)
return M_PASS;
/* get data from the config file */
if ((browse = js_config(m->si, "browse")) == NULL)
return M_PASS;
log_debug("handling browse query");
/* build the result IQ */
query =
xmlnode_insert_tag(jutil_iqresult(m->packet->x), "service");
xmlnode_put_attrib(query, "xmlns", NS_BROWSE);
xmlnode_put_attrib(query, "type", "jabber");
xmlnode_put_attrib(query, "jid", m->packet->to->server);
xmlnode_put_attrib(query, "name", xmlnode_get_data(js_config(m->si, "vCard/FN"))); /* pull name from the server vCard */
/* copy in the configured services */
xmlnode_insert_node(query, xmlnode_get_firstchild(browse));
/* list the admin stuff */
if (js_admin_jid(m->si, jid_user(m->packet->from), ADMIN_READ)) {
x = xmlnode_insert_tag(query, "item");
xmlnode_put_attrib(x, "jid",
spools(xmlnode_pool(x),
m->packet->to->server, "/admin",
xmlnode_pool(x)));
xmlnode_put_attrib(x, "name", "Online Users");
xmlnode_insert_cdata(xmlnode_insert_tag(query, "ns"),
NS_ADMIN, -1);
}
jpacket_reset(m->packet);
js_deliver(m->si, m->packet);
return M_HANDLED;
}
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;
}
/*
* creates a new jabber:x:data result form
* returns the node created added
*/
xmlnode form_new_result(const char *title){
xmlnode form,tag;
form=xmlnode_new_tag("x");
xmlnode_put_attrib(form,"xmlns","jabber:x:data");
xmlnode_put_attrib(form,"type","result");
tag=xmlnode_insert_tag(form,"title");
xmlnode_insert_cdata(tag,title,-1);
return form;
}
int presence_send(struct stream_s *stream,const char *from,
const char *to,int available,const char *show,
const char *status,GTime timestamp){
xmlnode pres;
xmlnode n;
pres=xmlnode_new_tag("presence");
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);
}
xmlnode_put_attrib(pres,"to",to);
if (available==-1) xmlnode_put_attrib(pres,"type","invisible");
else if (!available) xmlnode_put_attrib(pres,"type","unavailable");
if (show){
n=xmlnode_insert_tag(pres,"show");
xmlnode_insert_cdata(n,show,-1);
}
if (status){
n=xmlnode_insert_tag(pres,"status");
xmlnode_insert_cdata(n,string_from_gg(status),-1);
}
if (timestamp){
struct tm *tm;
time_t ttime = timestamp;
char buf[101];
n=xmlnode_insert_tag(pres,"x");
xmlnode_put_attrib(n,"xmlns","jabber:x:delay");
tm=gmtime(&ttime);
strftime(buf,100,"%Y%m%dT%H:%M:%S",tm);
xmlnode_put_attrib(n,"stamp",buf);
xmlnode_insert_cdata(n,"Presence update time",-1);
}
stream_write(stream,pres);
xmlnode_free(pres);
return 0;
}
void jutil_delay(xmlnode msg, char *reason)
{
xmlnode delay;
delay = xmlnode_insert_tag(msg,"x");
xmlnode_put_attrib(delay,"xmlns",NS_DELAY);
xmlnode_put_attrib(delay,"from",xmlnode_get_attrib(msg,"to"));
xmlnode_put_attrib(delay,"stamp",jutil_timestamp());
if(reason != NULL)
xmlnode_insert_cdata(delay,reason,strlen(reason));
}
xmlnode xmlnode_insert_tag_node(xmlnode parent, xmlnode node)
{
xmlnode child;
child = xmlnode_insert_tag(parent, xmlnode_get_name(node));
if (xmlnode_has_attribs(node))
xmlnode_insert_node(child, xmlnode_get_firstattrib(node));
if (xmlnode_has_children(node))
xmlnode_insert_node(child, xmlnode_get_firstchild(node));
return child;
}
void con_get_affiliate_list(gpointer key, gpointer data, gpointer arg)
{
xmlnode node;
cnr room;
taffil affiliation;
jid userid;
char *actor;
char *reason;
xmlnode result = (xmlnode)arg;
xmlnode item = (xmlnode)data;
if(result == NULL || item == NULL)
{
log_warn(NAME, "[%s] Aborting: NULL attribute(s) - <%s>", FZONE, (char *) key);
return;
}
actor = xmlnode_get_attrib(item, "actor");
reason = xmlnode_get_data(item);
room = (cnr)xmlnode_get_vattrib(result ,"cnr");
node = xmlnode_insert_tag(result, "item");
userid = jid_new(xmlnode_pool(node), key);
xmlnode_put_attrib(node, "jid", key);
affiliation = affiliation_level(room, userid);
xmlnode_put_attrib(node, "affiliation", affiliation.msg);
if(reason != NULL)
xmlnode_insert_cdata(xmlnode_insert_tag(node, "reason"), reason, -1);
if(actor != NULL)
xmlnode_insert_cdata(xmlnode_insert_tag(node, "actor"), actor, -1);
}
/* util for making message receipt packets */
xmlnode jutil_receiptnew(const char *to, const char *id)
{
xmlnode msg;
msg = xmlnode_new_tag("message");
xmlnode_put_attrib (msg, "to", to);
if(id != NULL)
xmlnode_put_attrib (msg, "id", id);
xmlnode_put_attrib(xmlnode_insert_tag (msg, "received"), "xmlns", "urn:xmpp:receipts");
return msg;
}
void xdb_file_startElement(void* arg, const char* name, const char** atts)
{
xf_parse xfp = (xf_parse)arg;
if (xfp->current == NULL)
{
xfp->current = xmlnode_new_tag_pool(xfp->p, name);
xmlnode_put_expat_attribs(xfp->current, atts);
}
else
{
xfp->current = xmlnode_insert_tag(xfp->current, name);
xmlnode_put_expat_attribs(xfp->current, atts);
}
}
