/* 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); }
/* 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); }
/** * 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 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; }
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; }
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_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; }
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; }
void jutil_tofrom(xmlnode x) { char *to, *from; to = xmlnode_get_attrib(x,"to"); from = xmlnode_get_attrib(x,"from"); xmlnode_put_attrib(x,"from",to); xmlnode_put_attrib(x,"to",from); }
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); }
/* * 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; }
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 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); }
/* util for making stream packets */ xmlnode jutil_header(char* xmlns, char* server) { xmlnode result; if ((xmlns == NULL)||(server == NULL)) return NULL; result = xmlnode_new_tag("stream:stream"); xmlnode_put_attrib(result, "xmlns:stream", "http://etherx.jabber.org/streams"); xmlnode_put_attrib(result, "xmlns", xmlns); xmlnode_put_attrib(result, "to", server); return result; }
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; }
void dnsrv_resend(xmlnode pkt, char *ip, char *to) { if(ip != NULL) { pkt = xmlnode_wrap(pkt,"route"); xmlnode_put_attrib(pkt, "to", to); xmlnode_put_attrib(pkt, "ip", ip); }else{ jutil_error(pkt, (terror){502, "Unable to resolve hostname."}); xmlnode_put_attrib(pkt, "iperror", ""); } deliver(dpacket_new(pkt),NULL); }
/* 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; }
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; }
/* * 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; }
/* actually deliver the xdb request */ void xdb_deliver(instance i, xdbcache xc, int another_thread) { xmlnode x; char ids[15]; x = xmlnode_new_tag("xdb"); if(xc->set) { xmlnode_put_attrib(x,"type","set"); xmlnode_insert_tag_node(x,xc->data); /* copy in the data */ if(xc->act != NULL) xmlnode_put_attrib(x,"action",xc->act); if(xc->match != NULL) xmlnode_put_attrib(x,"match",xc->match); } else { xmlnode_put_attrib(x,"type","get"); } xmlnode_put_attrib(x,"to",jid_full(xc->owner)); xmlnode_put_attrib(x,"from",i->id); xmlnode_put_attrib(x,"ns",xc->ns); sprintf(ids,"%d",xc->id); xmlnode_put_attrib(x,"id",ids); /* to track response */ if (another_thread) { xdb_resend cur = pmalloco(xmlnode_pool(x),sizeof(_xdb_resend)); cur->x = x; cur->i = i; mtq_send(NULL,NULL,resend_xdb,(void *)cur); } else { deliver(dpacket_new(x), i); } }
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); }
/* delivers a route packet to all listeners for this session */ static void js_session_route(session s, xmlnode in) { /* NULL means this is an error from the session ending */ if (in == NULL) { in = xmlnode_new_tag("route"); xmlnode_put_attrib(in, "type", "error"); xmlnode_put_attrib(in, "error", "Disconnected"); } else { in = xmlnode_wrap(in, "route"); } xmlnode_put_attrib(in, "from", jid_full(s->route)); xmlnode_put_attrib(in, "to", jid_full(s->sid)); deliver(dpacket_new(in), s->si->i); }
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; }
void con_room_forward_decline(cnr room, jpacket jp, xmlnode decline) { cnu user; jid user_jid; if (room == NULL || decline == NULL || jp == NULL) { log_warn(NAME, "[%s] Aborting - NULL attribute found", FZONE); xmlnode_free(jp->x); return; } user_jid=jid_new(decline->p,xmlnode_get_attrib(decline,"to")); if ((room->invitation == 1 && !is_member(room, jp->from) && !is_owner(room, jp->from)) || user_jid == NULL) { log_warn(NAME, "[%s] Aborting - User is not allowed to send a decline", FZONE); jutil_error(jp->x, TERROR_MUC_OUTSIDE); deliver(dpacket_new(jp->x), NULL); return; } if (user_jid->resource == NULL) { log_warn(NAME, "[%s] Aborting - cannot send back decline, bare jid found", FZONE); return; } if (room->visible == 1) { user = g_hash_table_lookup(room->remote, jid_full(jid_fix(user_jid))); } else { user = g_hash_table_lookup(room->local, user_jid->resource); } if (user == NULL){ log_warn(NAME, "[%s] Aborting - Decline recipient is not in the room", FZONE); jutil_error(jp->x, TERROR_MUC_OUTSIDE); deliver(dpacket_new(jp->x), NULL); return; } log_debug(NAME, "[%s] Sending invitation decline", FZONE); xmlnode_put_attrib(decline, "from", jid_full(jp->from)); xmlnode_hide_attrib(decline, "to"); xmlnode_put_attrib(jp->x, "to", jid_full(user->realid)); xmlnode_put_attrib(jp->x, "from", jid_full(room->id)); log_debug(NAME, "[%s] >>>%s<<<", FZONE, xmlnode2str(jp->x)); deliver(dpacket_new(jp->x), NULL); return; }
/* session thread */ mreturn mod_presence_in(mapi m, void *arg) { modpres mp = (modpres) arg; xmlnode pres; if (m->packet->type != JPACKET_PRESENCE) return M_IGNORE; log_debug("incoming filter for %s", jid_full(m->s->id)); if (jpacket_subtype(m->packet) == JPACKET__PROBE) { /* reply with our presence */ if (m->s->presence == NULL) { log_debug("probe from %s and no presence to return", jid_full(m->packet->from)); } else if (!mp->invisible && js_trust(m->user, m->packet->from) && !_mod_presence_search(m->packet->from, mp->I)) { /* compliment of I in T */ log_debug("got a probe, responding to %s", jid_full(m->packet->from)); pres = xmlnode_dup(m->s->presence); xmlnode_put_attrib(pres, "to", jid_full(m->packet->from)); js_session_from(m->s, jpacket_new(pres)); } else if (mp->invisible && js_trust(m->user, m->packet->from) && _mod_presence_search(m->packet->from, mp->A)) { /* when invisible, intersection of A and T */ log_debug("got a probe when invisible, responding to %s", jid_full(m->packet->from)); pres = jutil_presnew(JPACKET__AVAILABLE, jid_full(m->packet->from), NULL); js_session_from(m->s, jpacket_new(pres)); } else { log_debug("%s attempted to probe by someone not qualified", jid_full(m->packet->from)); } xmlnode_free(m->packet->x); return M_HANDLED; } if (jid_cmp(m->packet->from, m->s->id) == 0) { /* this is our presence, don't send to ourselves */ xmlnode_free(m->packet->x); return M_HANDLED; } /* if a presence packet bounced, remove from the A list */ if (jpacket_subtype(m->packet) == JPACKET__ERROR) mp->A = _mod_presence_whack(m->packet->from, mp->A); /* doh! this is a user, they should see invisibles as unavailables */ if (jpacket_subtype(m->packet) == JPACKET__INVISIBLE) xmlnode_put_attrib(m->packet->x, "type", "unavailable"); return M_PASS; }
void aim_transport(instance i, xmlnode x) { ati ti; xmlnode config; char *eightbitcode, *utf8code = "UTF-8", *latin1code = "CP1252"; ti = pmalloco(i->p, sizeof(_ati)); ti->i = i; ti->xc = xdb_cache(i); log_notice(i->id, "AIM-Transport starting up for instance %s...", i->id); config = xdb_get(ti->xc, jid_new(xmlnode_pool(x), "config@-internal"), "jabber:config:aimtrans"); ti->vcard = xmlnode_new_tag_pool(i->p,"vCard"); xmlnode_put_attrib(ti->vcard,"xmlns",NS_VCARD); xmlnode_insert_node(ti->vcard,xmlnode_get_firstchild(xmlnode_get_tag(config,"vCard"))); ti->start_time = time(NULL); ti->session__list=xhash_new(101); ti->iq__callbacks = xhash_new(23); ti->pending__buddies = xhash_new(101); /* The aim.exe binary should not be necessary any more. */ ti->aimbinarydir = pstrdup(i->p, xmlnode_get_tag_data(config, "aimbinarydir")); eightbitcode = pstrdup(i->p, xmlnode_get_tag_data(config, "charset")); if( eightbitcode == NULL ) { log_notice( i->id, "Charset is not specified, using CP1252" ); eightbitcode = latin1code; } xmlnode_free(config); fromutf8 = iconv_open(eightbitcode, utf8code); if(fromutf8 == (iconv_t)(-1)) { log_error(i->id, "Conversion from %s to %s is not supported", utf8code, eightbitcode); raise(SIGINT); } toutf8 = iconv_open(utf8code, eightbitcode); if(toutf8 == (iconv_t)(-1)) { log_error(i->id, "Conversion from %s to %s is not supported", eightbitcode, utf8code); raise(SIGINT); } ti->send_buf = NULL; ti->modname = NULL; pth_mutex_init(&ti->buddies_mutex); at_init_iqcbs(ti); register_phandler(i, o_DELIVER, at_phandler, ti); pool_cleanup(i->p, at_shutdown, (void*)i); }