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;
}
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;
}
/**
* 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;
}
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;
}
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;
}
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;
}
/*
* 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;
}
/* 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;
}
void xdb_file_charData(void* arg, const char* s, int len)
{
xf_parse xfp = (xf_parse)arg;
if (xfp->current != NULL)
xmlnode_insert_cdata(xfp->current, s, len);
}
void expat_charData(void* userdata, const char* s, int len)
{
xmlnode *x = userdata;
xmlnode current = *x;
xmlnode_insert_cdata(current, s, len);
}
mreturn mod_agents_agent(mapi m)
{
xmlnode ret, retq, info, agents, reg;
/* get data from the config file */
info = js_config(m->si, "vCard");
agents = js_config(m->si, "agents");
reg = js_config(m->si, "register");
/* if we don't have anything to say, bounce */
if (info == NULL && agents == NULL && reg == NULL)
return M_PASS;
log_debug("handling agent query");
/* build the result IQ */
ret = jutil_iqresult(m->packet->x);
retq = xmlnode_insert_tag(ret, "query");
xmlnode_put_attrib(retq, "xmlns", NS_AGENT);
/* copy in the vCard info */
xmlnode_insert_cdata(xmlnode_insert_tag(retq, "name"),
xmlnode_get_tag_data(info, "FN"), -1);
xmlnode_insert_cdata(xmlnode_insert_tag(retq, "url"),
xmlnode_get_tag_data(info, "URL"), -1);
xmlnode_insert_cdata(xmlnode_insert_tag(retq, "service"), "jabber",
6);
/* set the flags */
if (agents != NULL)
xmlnode_insert_tag(retq, "agents");
if (reg != NULL)
xmlnode_insert_tag(retq, "register");
jpacket_reset(m->packet);
if (m->s != NULL) { /* XXX null session hack! */
xmlnode_put_attrib(m->packet->x, "from",
m->packet->from->server);
js_session_to(m->s, m->packet);
} else {
js_deliver(m->si, m->packet);
}
return M_HANDLED;
}
/*
* 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;
}
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;
}
/*
* 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;
}
/*
* 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;
}
int at_iq_browse(ati ti, jpacket jp)
{
xmlnode q;
if(jpacket_subtype(jp) != JPACKET__GET)
{
at_bounce(ti, jp, TERROR_BAD);
return 1;
}
if(jp->to->user != NULL)
{
q = xmlnode_insert_tag(jutil_iqresult(jp->x),"item");
xmlnode_put_attrib(q,"xmlns",NS_BROWSE);
xmlnode_put_attrib(q,"category","user");
xmlnode_put_attrib(q,"type","client");
xmlnode_put_attrib(q,"jid",jid_full(jp->to));
xmlnode_put_attrib(q,"name", jp->to->user);
at_deliver(ti,jp->x);
return 1;
}
q = xmlnode_insert_tag(jutil_iqresult(jp->x),"item");
xmlnode_put_attrib(q,"xmlns",NS_BROWSE);
xmlnode_put_attrib(q,"category","service");
xmlnode_put_attrib(q,"type","aim");
xmlnode_put_attrib(q,"jid",jp->to->server);
xmlnode_put_attrib(q,"name",xmlnode_get_tag_data(ti->vcard,"FN"));
xmlnode_insert_cdata(xmlnode_insert_tag(q,"ns"),NS_DISCO_INFO,-1);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"ns"),NS_DISCO_ITEMS,-1);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"ns"),NS_REGISTER,-1);
xmlnode_insert_cdata(xmlnode_insert_tag(q,"ns"),NS_GATEWAY,-1);
at_deliver(ti,jp->x);
// WHY! DAMNIT! WHY?
return 1;
}
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));
}
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);
}
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);
}
void at_bounce(ati ti, jpacket p, terror terr)
{
char *to, *from;
xmlnode err, x = p->x;
char code[4];
to = xmlnode_get_attrib(x, "to");
from = xmlnode_get_attrib(x, "from");
xmlnode_put_attrib(x, "from", to);
xmlnode_put_attrib(x, "to", from);
if(p->type == JPACKET_S10N && jpacket_subtype(p) == JPACKET__SUBSCRIBE)
{ /* bounce subscriptions only */
xmlnode_put_attrib(x, "type", "unsubscribed");
xmlnode_insert_cdata(xmlnode_insert_tag(x, "status"), terr.msg, -1);
at_deliver(ti,x);
return;
}
if(jpacket_subtype(p) == JPACKET__ERROR || p->type == JPACKET_PRESENCE || p->type == JPACKET_S10N)
{ /* presence/error packets are just dropped */
xmlnode_free(x);
return;
}
xmlnode_put_attrib(x,"type", "error");
err = xmlnode_insert_tag(x, "error");
snprintf(code, 4, "%d", terr.code);
xmlnode_put_attrib(err, "code", code);
if(terr.msg != NULL)
xmlnode_insert_cdata(err, terr.msg, strlen(terr.msg));
at_deliver(ti,x);
}
void jutil_error(xmlnode x, terror E)
{
xmlnode err;
char code[4];
xmlnode_put_attrib(x,"type","error");
err = xmlnode_insert_tag(x,"error");
snprintf(code,4,"%d",E.code);
xmlnode_put_attrib(err,"code",code);
if(E.msg != NULL)
xmlnode_insert_cdata(err,E.msg,strlen(E.msg));
jutil_tofrom(x);
}
/*
* 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_auth_user(ati ti, jpacket jp)
{
char *name;
char *pass;
xmlnode res;
at_session s;
xmlnode x;
/* get login data */
x = at_xdb_get(ti, jp->from, AT_NS_AUTH);
if(x == NULL)
{
/* convert pre-2003 (hashed) XDB files */
at_xdb_convert(ti, xmlnode_get_attrib(jp->x,"origfrom"), jp->from);
x = at_xdb_get(ti, jp->from, AT_NS_AUTH);
}
if(x == NULL)
{
xmlnode err, m;
log_warn(ZONE, "[AT] No auth data for %s found", jid_full(jp->from));
m = xmlnode_new_tag("message");
xmlnode_put_attrib(m, "type", "error");
xmlnode_put_attrib(m, "from", jid_full(jp->to));
xmlnode_put_attrib(m, "to", jid_full(jp->from));
err = xmlnode_insert_tag(m, "error");
xmlnode_put_attrib(err, "code", "407");
xmlnode_insert_cdata(err, "No logon data found", -1);
at_deliver(ti,m);
xmlnode_free(jp->x);
return 1;
}
log_debug(ZONE,"[AT] logging in session");
at_session_create(ti, x, jp);
xmlnode_free(x);
xmlnode_free(jp->x);
return 1;
}
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;
}
/* Hostname lookup requested */
void dnsrv_lookup(dns_io d, dpacket p)
{
dns_packet_list l, lnew;
xmlnode req;
char *reqs;
/* make sure we have a child! */
if(d->out <= 0)
{
deliver_fail(p, "DNS Resolver Error");
return;
}
/* Attempt to lookup this hostname in the packet table */
l = (dns_packet_list)xhash_get(d->packet_table, p->host);
/* IF: hashtable has the hostname, a lookup is already pending,
so push the packet on the top of the list (most recent at the top) */
if (l != NULL)
{
log_debug(ZONE, "dnsrv: Adding lookup request for %s to pending queue.", p->host);
lnew = pmalloco(p->p, sizeof(_dns_packet_list));
lnew->packet = p;
lnew->stamp = time(NULL);
lnew->next = l;
xhash_put(d->packet_table, p->host, lnew);
return;
}
/* insert the packet into the packet_table using the hostname
as the key and send a request to the coprocess */
log_debug(ZONE, "dnsrv: Creating lookup request queue for %s", p->host);
l = pmalloco(p->p, sizeof(_dns_packet_list));
l->packet = p;
l->stamp = time(NULL);
xhash_put(d->packet_table, p->host, l);
req = xmlnode_new_tag_pool(p->p,"host");
xmlnode_insert_cdata(req,p->host,-1);
reqs = xmlnode2str(req);
log_debug(ZONE, "dnsrv: Transmitting lookup request: %s", reqs);
pth_write(d->out, reqs, strlen(reqs));
}
void jabber_stream_start(Stream *s,xmlnode x){
char hashbuf[50];
char *str;
xmlnode tag;
if (jabber_state!=JS_NONE){
g_warning(N_("unexpected <stream:stream/>"));
return;
}
stream_id=xmlnode_get_attrib(x,"id");
str=g_strdup_printf("%s%s",stream_id,secret);
shahash_r(str,hashbuf);
g_free(str);
tag=xmlnode_new_tag("handshake");
xmlnode_insert_cdata(tag,hashbuf,-1);
stream_write(s,tag);
xmlnode_free(tag);
jabber_state=JS_HANDSHAKE;
}
