// got_invite(from, to, reason, passwd, reply)
// This function should be called when receiving an invitation from user
// "from", to enter the room "to". Optional reason and room password can
// be provided.
void got_invite(const char* from, const char *to, const char* reason,
const char* passwd, gboolean reply)
{
GString *sbuf;
char *barejid;
GSList *room_elt;
sbuf = g_string_new("");
if (reason && reason[0]) {
g_string_printf(sbuf,
"Received an invitation to <%s>, from <%s>, reason: %s",
to, from, reason);
} else {
g_string_printf(sbuf, "Received an invitation to <%s>, from <%s>",
to, from);
}
barejid = jidtodisp(from);
scr_WriteIncomingMessage(barejid, sbuf->str, 0, HBB_PREFIX_INFO, 0);
scr_LogPrint(LPRINT_LOGNORM, "%s", sbuf->str);
{ // remove any equal older invites
GSList *iel = invitations;
while (iel) {
event_muc_invitation *invitation = iel->data;
iel = iel -> next;
if (!g_strcmp0(to, invitation->to) &&
!g_strcmp0(passwd, invitation->passwd)) {
// found a previous invitation
// We keep the old one, unless the current one is better and allows us
// to send a reply.
if (!reply || invitation->reply) {
g_free(barejid);
return;
}
scr_LogPrint(LPRINT_DEBUG, "Destroying previous invitation event %s.",
invitation->evid);
evs_del(invitation->evid);
}
}
}
{ // create event
const char *id;
char *desc = g_strdup_printf("<%s> invites you to %s", from, to);
event_muc_invitation *invitation;
invitation = g_new(event_muc_invitation, 1);
invitation->to = g_strdup(to);
invitation->from = g_strdup(from);
invitation->passwd = g_strdup(passwd);
invitation->reason = g_strdup(reason);
invitation->reply = reply;
invitation->evid = NULL;
invitations = g_slist_append(invitations, invitation);
id = evs_new(desc, NULL, 0, evscallback_invitation, invitation,
(GDestroyNotify)destroy_event_muc_invitation);
g_free(desc);
if (id) {
invitation->evid = g_strdup(id);
g_string_printf(sbuf, "Please use /event %s accept|reject", id);
} else
g_string_printf(sbuf, "Unable to create a new event!");
}
scr_WriteIncomingMessage(barejid, sbuf->str, 0, HBB_PREFIX_INFO, 0);
scr_LogPrint(LPRINT_LOGNORM, "%s", sbuf->str);
g_string_free(sbuf, TRUE);
g_free(barejid);
// Make sure the MUC room barejid is a room in the roster
barejid = jidtodisp(to);
room_elt = roster_find(barejid, jidsearch, 0);
if (room_elt)
buddy_settype(room_elt->data, ROSTER_TYPE_ROOM);
g_free(barejid);
}
static LmHandlerResult cb_ping(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer user_data)
{
struct timeval *timestamp = (struct timeval *)user_data;
struct timeval now;
time_t dsec;
suseconds_t dusec;
const gchar *fjid;
gchar *bjid, *mesg = NULL;
gettimeofday(&now, NULL);
dsec = now.tv_sec - timestamp->tv_sec;
if (now.tv_usec < timestamp->tv_usec) {
dusec = now.tv_usec + 1000000 - timestamp->tv_usec;
--dsec;
} else
dusec = now.tv_usec - timestamp->tv_usec;
// Check IQ result sender
fjid = lm_message_get_from(m);
if (!fjid)
fjid = lm_connection_get_jid(lconnection); // No from means our JID...
if (!fjid) {
scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:version result (no sender name).");
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
bjid = jidtodisp(fjid);
switch (lm_message_get_sub_type(m)) {
case LM_MESSAGE_SUB_TYPE_RESULT:
mesg = g_strdup_printf("Pong from <%s>: %d second%s %d ms.", fjid,
(int)dsec, dsec > 1 ? "s" : "",
(int)(dusec/1000L));
break;
case LM_MESSAGE_SUB_TYPE_ERROR:
display_server_error(lm_message_node_get_child(m->node, "error"),
fjid);
mesg = g_strdup_printf("Ping to <%s> failed. "
"Response time: %d second%s %d ms.",
fjid, (int)dsec, dsec > 1 ? "s" : "",
(int)(dusec/1000L));
break;
default:
g_free(bjid);
return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
break;
}
if (mesg)
scr_WriteIncomingMessage(bjid, mesg, 0, HBB_PREFIX_INFO, 0);
g_free(mesg);
g_free(bjid);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static LmHandlerResult cb_vcard(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer user_data)
{
LmMessageNode *ansqry;
const char *bjid;
char *buf, *tmp;
// Check IQ result sender
bjid = lm_message_get_from(m);
if (!bjid)
bjid = lm_connection_get_jid(lconnection); // No from means our JID...
if (!bjid) {
scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:vCard result (no sender name).");
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// Check for error message
if (lm_message_get_sub_type(m) == LM_MESSAGE_SUB_TYPE_ERROR) {
scr_LogPrint(LPRINT_LOGNORM, "Received error IQ message (%s)", bjid);
display_server_error(lm_message_node_get_child(m->node, "error"), NULL);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
buf = g_strdup_printf("Received IQ:vCard result from <%s>", bjid);
scr_LogPrint(LPRINT_LOGNORM, "%s", buf);
// Get the vCard node
ansqry = lm_message_node_get_child(m->node, "vCard");
if (!ansqry) {
scr_LogPrint(LPRINT_LOGNORM, "Empty IQ:vCard result!");
g_free(buf);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// bjid should really be the "bare JID", let's strip the resource
tmp = strchr(bjid, JID_RESOURCE_SEPARATOR);
if (tmp) *tmp = '\0';
scr_WriteIncomingMessage(bjid, buf, 0, HBB_PREFIX_INFO, 0);
g_free(buf);
// Get result data...
handle_vcard_node(bjid, ansqry);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static void display_vcard_item(const char *bjid, const char *label,
enum vcard_attr vcard_attrib, const char *text)
{
char *buf;
if (!text || !*text || !bjid || !label)
return;
buf = g_strdup_printf("%s: %s%s%s%s%s%s%s%s%s%s", label,
(vcard_attrib & vcard_home ? "[home]" : ""),
(vcard_attrib & vcard_work ? "[work]" : ""),
(vcard_attrib & vcard_postal ? "[postal]" : ""),
(vcard_attrib & vcard_voice ? "[voice]" : ""),
(vcard_attrib & vcard_fax ? "[fax]" : ""),
(vcard_attrib & vcard_cell ? "[cell]" : ""),
(vcard_attrib & vcard_inet ? "[inet]" : ""),
(vcard_attrib & vcard_pref ? "[pref]" : ""),
(vcard_attrib ? " " : ""),
text);
scr_WriteIncomingMessage(bjid, buf, 0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);
g_free(buf);
}
static LmHandlerResult cb_last(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer user_data)
{
LmMessageNode *ansqry;
const char *p, *bjid;
char *buf, *tmp;
// Check IQ result sender
bjid = lm_message_get_from(m);
if (!bjid)
bjid = lm_connection_get_jid(lconnection); // No from means our JID...
if (!bjid) {
scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:last result (no sender name).");
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// Check for error message
if (lm_message_get_sub_type(m) == LM_MESSAGE_SUB_TYPE_ERROR) {
scr_LogPrint(LPRINT_LOGNORM, "Received error IQ message (%s)", bjid);
display_server_error(lm_message_node_get_child(m->node, "error"), NULL);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// Check message contents
ansqry = lm_message_node_get_child(m->node, "query");
if (!ansqry) {
scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:version result from <%s>!", bjid);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
buf = g_strdup_printf("Received IQ:last result from <%s>", bjid);
scr_LogPrint(LPRINT_LOGNORM, "%s", buf);
// bjid should now really be the "bare JID", let's strip the resource
tmp = strchr(bjid, JID_RESOURCE_SEPARATOR);
if (tmp) *tmp = '\0';
scr_WriteIncomingMessage(bjid, buf, 0, HBB_PREFIX_INFO, 0);
g_free(buf);
// Get result data...
p = lm_message_node_get_attribute(ansqry, "seconds");
if (p) {
long int s;
GString *sbuf;
sbuf = g_string_new("Idle time: ");
s = atol(p);
// Days
if (s > 86400L) {
g_string_append_printf(sbuf, "%ldd ", s/86400L);
s %= 86400L;
}
// hh:mm:ss
g_string_append_printf(sbuf, "%02ld:", s/3600L);
s %= 3600L;
g_string_append_printf(sbuf, "%02ld:%02ld", s/60L, s%60L);
scr_WriteIncomingMessage(bjid, sbuf->str,
0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);
g_string_free(sbuf, TRUE);
} else {
scr_WriteIncomingMessage(bjid, "No idle time reported.",
0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);
}
p = lm_message_node_get_value(ansqry);
if (p) {
buf = g_strdup_printf("Status message: %s", p);
scr_WriteIncomingMessage(bjid, buf, 0, HBB_PREFIX_INFO, 0);
g_free(buf);
}
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static LmHandlerResult cb_time(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer user_data)
{
LmMessageNode *ansqry;
const char *p, *bjid;
char *buf, *tmp;
// Check IQ result sender
bjid = lm_message_get_from(m);
if (!bjid)
bjid = lm_connection_get_jid(lconnection); // No from means our JID...
if (!bjid) {
scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:time result (no sender name).");
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// Check for error message
if (lm_message_get_sub_type(m) == LM_MESSAGE_SUB_TYPE_ERROR) {
scr_LogPrint(LPRINT_LOGNORM, "Received error IQ message (%s)", bjid);
display_server_error(lm_message_node_get_child(m->node, "error"), NULL);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// Check message contents
ansqry = lm_message_node_get_child(m->node, "query");
if (!ansqry) {
scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:time result from <%s>!", bjid);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
buf = g_strdup_printf("Received IQ:time result from <%s>", bjid);
scr_LogPrint(LPRINT_LOGNORM, "%s", buf);
// bjid should now really be the "bare JID", let's strip the resource
tmp = strchr(bjid, JID_RESOURCE_SEPARATOR);
if (tmp) *tmp = '\0';
scr_WriteIncomingMessage(bjid, buf, 0, HBB_PREFIX_INFO, 0);
g_free(buf);
// Get result data...
p = lm_message_node_get_child_value(ansqry, "utc");
if (p && *p) {
buf = g_strdup_printf("UTC: %s", p);
scr_WriteIncomingMessage(bjid, buf,
0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);
g_free(buf);
}
p = lm_message_node_get_child_value(ansqry, "tz");
if (p && *p) {
buf = g_strdup_printf("TZ: %s", p);
scr_WriteIncomingMessage(bjid, buf,
0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);
g_free(buf);
}
p = lm_message_node_get_child_value(ansqry, "display");
if (p && *p) {
buf = g_strdup_printf("Time: %s", p);
scr_WriteIncomingMessage(bjid, buf,
0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);
g_free(buf);
}
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// Specific MUC message handling (for example invitation processing)
void got_muc_message(const char *from, LmMessageNode *x, time_t timestamp)
{
LmMessageNode *node;
// invitation
node = lm_message_node_get_child(x, "invite");
if (node) {
const char *invite_from;
const char *reason = NULL;
const char *password = NULL;
invite_from = lm_message_node_get_attribute(node, "from");
reason = lm_message_node_get_child_value(node, "reason");
password = lm_message_node_get_child_value(node, "password");
if (invite_from)
got_invite(invite_from, from, reason, password, TRUE);
}
// declined invitation
node = lm_message_node_get_child(x, "decline");
if (node) {
const char *decline_from = lm_message_node_get_attribute(node, "from");
const char *reason = lm_message_node_get_child_value(node, "reason");
if (decline_from) {
if (reason && reason[0])
scr_LogPrint(LPRINT_LOGNORM, "<%s> declined your invitation: %s.",
from, reason);
else
scr_LogPrint(LPRINT_LOGNORM, "<%s> declined your invitation.", from);
}
}
// status codes
for (node = x -> children; node; node = node -> next) {
if (!g_strcmp0(node -> name, "status")) {
const char *codestr = lm_message_node_get_attribute(node, "code");
if (codestr) {
const char *mesg = NULL;
switch (atoi(codestr)) {
// initial
case 100:
mesg = "The room is not anonymous.";
break;
case 101:
mesg = "Your affilation has changed while absent.";
break;
case 102:
mesg = "The room shows unavailable members.";
break;
case 103:
mesg = "The room does not show unavailable members.";
break;
case 104:
mesg = "The room configuration has changed.";
break;
case 170:
mesg = "The room is logged.";
break;
case 171:
mesg = "The room is not logged.";
break;
case 172:
mesg = "The room is not anonymous.";
break;
case 173:
mesg = "The room is semi-anonymous.";
break;
case 174:
mesg = "The room is anonymous.";
break;
default:
scr_LogPrint(LPRINT_DEBUG,
"got_muc_message: Unknown MUC status code: %s.",
codestr);
break;
}
if (mesg) {
scr_WriteIncomingMessage(from, mesg, timestamp,
HBB_PREFIX_INFO|HBB_PREFIX_NOFLAG, 0);
if (settings_opt_get_int("log_muc_conf"))
hlog_write_message(from, 0, -1, mesg);
}
}
}
}
}
void handle_muc_presence(const char *from, LmMessageNode *xmldata,
const char *roomjid, const char *rname,
enum imstatus ust, const char *ustmsg,
time_t usttime, char bpprio)
{
char *mbuf;
const char *ournick;
enum imrole mbrole = role_none;
enum imaffiliation mbaffil = affil_none;
enum room_printstatus printstatus;
enum room_autowhois autowhois;
enum room_flagjoins flagjoins;
const char *mbjid = NULL, *mbnick = NULL;
const char *reason = NULL;
char *actor = NULL;
bool new_member = FALSE; // True if somebody else joins the room (not us)
bool our_presence = FALSE; // True if this presence is from us (i.e. bears
// code 110)
guint statuscode = 0;
guint nickchange = 0;
GSList *room_elt;
int log_muc_conf;
guint msgflags;
log_muc_conf = settings_opt_get_int("log_muc_conf");
room_elt = roster_find(roomjid, jidsearch, 0);
if (!room_elt) {
// Add room if it doesn't already exist
// It shouldn't happen, there is probably something wrong (server or
// network issue?)
room_elt = roster_add_user(roomjid, NULL, NULL, ROSTER_TYPE_ROOM,
sub_none, -1);
scr_LogPrint(LPRINT_LOGNORM, "Strange MUC presence message");
} else {
// Make sure this is a room (it can be a conversion user->room)
buddy_settype(room_elt->data, ROSTER_TYPE_ROOM);
}
// Get room member's information
muc_get_item_info(from, xmldata, &mbrole, &mbaffil, &mbjid, &mbnick,
&actor, &reason);
// Get our room nickname
ournick = buddy_getnickname(room_elt->data);
if (!ournick) {
// It shouldn't happen, probably a server issue
const gchar msg[] = "Unexpected groupchat packet!";
scr_LogPrint(LPRINT_LOGNORM, msg);
scr_WriteIncomingMessage(roomjid, msg, 0, HBB_PREFIX_INFO, 0);
// Send back an unavailable packet
xmpp_setstatus(offline, roomjid, "", TRUE);
scr_draw_roster();
return;
}
#define SETSTATUSCODE(VALUE) \
{ \
if (G_UNLIKELY(statuscode)) \
scr_LogPrint(LPRINT_DEBUG, "handle_muc_presence: WARNING: " \
"replacing status code %u with %u.", statuscode, VALUE); \
statuscode = VALUE; \
}
{ // Get the status code
LmMessageNode *node;
for (node = xmldata -> children; node; node = node -> next) {
if (!g_strcmp0(node -> name, "status")) {
const char *codestr = lm_message_node_get_attribute(node, "code");
if (codestr) {
const char *mesg = NULL;
switch (atoi(codestr)) {
// initial
case 100:
mesg = "The room is not anonymous.";
break;
case 110: // It is our presence
our_presence = TRUE;
break;
// initial
case 170:
mesg = "The room is logged.";
break;
// initial
case 201: // Room created
SETSTATUSCODE(201);
break;
// initial
case 210: // Your nick change (on join)
// FIXME: print nick
mesg = "The room has changed your nick!";
buddy_setnickname(room_elt->data, rname);
ournick = rname;
break;
case 301: // User banned
SETSTATUSCODE(301);
break;
case 303: // Nick change
SETSTATUSCODE(303);
break;
case 307: // User kicked
SETSTATUSCODE(307);
break;
// XXX (next three)
case 321:
mesg = "User leaves room due to affilation change.";
break;
case 322:
mesg = "User leaves room, as room is only for members now.";
break;
case 332:
mesg = "User leaves room due to system shutdown.";
break;
default:
scr_LogPrint(LPRINT_DEBUG,
"handle_muc_presence: Unknown MUC status code: %s.",
codestr);
break;
}
if (mesg) {
scr_WriteIncomingMessage(roomjid, mesg, usttime,
HBB_PREFIX_INFO|HBB_PREFIX_NOFLAG, 0);
if (log_muc_conf)
hlog_write_message(roomjid, 0, -1, mesg);
}
}
}
}
}
#undef SETSTATUSCODE
if (!our_presence)
if (ournick && !strcmp(ournick, rname))
our_presence = TRUE;
// Get the room's "print_status" settings
printstatus = buddy_getprintstatus(room_elt->data);
if (printstatus == status_default) {
printstatus = (guint) settings_opt_get_int("muc_print_status");
if (printstatus > 3)
printstatus = status_default;
}
// A new room has been created; accept MUC default config
if (statuscode == 201)
xmpp_room_unlock(roomjid);
// Check for nickname change
if (statuscode == 303 && mbnick) {
mbuf = g_strdup_printf("%s is now known as %s", rname, mbnick);
scr_WriteIncomingMessage(roomjid, mbuf, usttime,
HBB_PREFIX_INFO|HBB_PREFIX_NOFLAG, 0);
if (log_muc_conf)
hlog_write_message(roomjid, 0, -1, mbuf);
g_free(mbuf);
buddy_resource_setname(room_elt->data, rname, mbnick);
// Maybe it's _our_ nickname...
if (our_presence)
buddy_setnickname(room_elt->data, mbnick);
nickchange = TRUE;
}
autowhois = buddy_getautowhois(room_elt->data);
if (autowhois == autowhois_default)
autowhois = (settings_opt_get_int("muc_auto_whois") ?
autowhois_on : autowhois_off);
// Check for departure/arrival
if (statuscode != 303 && ust == offline) {
// Somebody is leaving
enum { leave=0, kick, ban } how = leave;
if (statuscode == 307)
how = kick;
else if (statuscode == 301)
how = ban;
// If this is a leave, check if it is ourself
if (our_presence) {
buddy_setinsideroom(room_elt->data, FALSE);
buddy_setnickname(room_elt->data, NULL);
buddy_del_all_resources(room_elt->data);
buddy_settopic(room_elt->data, NULL);
scr_update_chat_status(FALSE);
update_roster = TRUE;
}
// The message depends on _who_ left, and _how_
if (how) {
gchar *mbuf_end;
gchar *reason_msg = NULL;
// Forced leave
if (actor) {
mbuf_end = g_strdup_printf("%s from %s by %s",
(how == ban ? "banned" : "kicked"),
roomjid, actor);
} else {
mbuf_end = g_strdup_printf("%s from %s",
(how == ban ? "banned" : "kicked"),
roomjid);
}
if (reason)
reason_msg = g_strdup_printf("\nReason: %s", reason);
if (our_presence)
mbuf = g_strdup_printf("You have been %s%s", mbuf_end,
reason_msg ? reason_msg : "");
else
mbuf = g_strdup_printf("%s has been %s%s", rname, mbuf_end,
reason_msg ? reason_msg : "");
g_free(reason_msg);
g_free(mbuf_end);
} else {
// Natural leave
if (our_presence) {
LmMessageNode *destroynode = lm_message_node_find_child(xmldata,
"destroy");
if (destroynode) {
reason = lm_message_node_get_child_value(destroynode, "reason");
if (reason && *reason) {
mbuf = g_strdup_printf("You have left %s, "
"the room has been destroyed: %s",
roomjid, reason);
} else {
mbuf = g_strdup_printf("You have left %s, "
"the room has been destroyed", roomjid);
}
} else {
mbuf = g_strdup_printf("You have left %s", roomjid);
}
} else {
if (ust != offline) {
// This can happen when a network failure occurs,
// this isn't an official leave but the user isn't there anymore.
mbuf = g_strdup_printf("%s has disappeared!", rname);
ust = offline;
} else {
if (ustmsg)
mbuf = g_strdup_printf("%s has left: %s", rname, ustmsg);
else
mbuf = g_strdup_printf("%s has left", rname);
}
}
}
g_free(actor);
// Display the mbuf message if we're concerned
// or if the print_status isn't set to none.
if (our_presence || printstatus != status_none) {
msgflags = HBB_PREFIX_INFO;
flagjoins = buddy_getflagjoins(room_elt->data);
if (flagjoins == flagjoins_default &&
settings_opt_get_int("muc_flag_joins") == 2)
flagjoins = flagjoins_all;
if (!our_presence && flagjoins != flagjoins_all)
msgflags |= HBB_PREFIX_NOFLAG;
//silent message if someone else joins, and we care about noone
scr_WriteIncomingMessage(roomjid, mbuf, usttime, msgflags, 0);
}
if (log_muc_conf)
hlog_write_message(roomjid, 0, -1, mbuf);
if (our_presence) {
scr_LogPrint(LPRINT_LOGNORM, "%s", mbuf);
g_free(mbuf);
return;
}
g_free(mbuf);
} else {
enum imstatus old_ust = buddy_getstatus(room_elt->data, rname);
if (old_ust == offline && ust != offline) {
// Somebody is joining
new_member = muc_handle_join(room_elt, rname, roomjid, ournick,
printstatus, usttime, log_muc_conf,
autowhois, mbjid);
} else {
// This is a simple member status change
if (printstatus == status_all && !nickchange) {
const char *old_ustmsg = buddy_getstatusmsg(room_elt->data, rname);
if (old_ust != ust || g_strcmp0(old_ustmsg, ustmsg)) {
mbuf = g_strdup_printf("%s [%c>%c] %s", rname, imstatus2char[old_ust],
imstatus2char[ust], ((ustmsg) ? ustmsg : ""));
scr_WriteIncomingMessage(roomjid, mbuf, usttime,
HBB_PREFIX_INFO|HBB_PREFIX_NOFLAG, 0);
g_free(mbuf);
}
}
}
}
// Sanity check, shouldn't happen...
if (!rname)
return;
// Update room member status
roster_setstatus(roomjid, rname, bpprio, ust, ustmsg, usttime,
mbrole, mbaffil, mbjid);
if (new_member && autowhois == autowhois_on) {
cmd_room_whois(room_elt->data, rname, FALSE);
}
scr_draw_roster();
}
// muc_handle_join(...)
// Handle a join event in a MUC room.
// This function will return the new_member value TRUE if somebody else joins
// the room (and FALSE if _we_ are joining the room).
static bool muc_handle_join(const GSList *room_elt, const char *rname,
const char *roomjid, const char *ournick,
enum room_printstatus printstatus,
time_t usttime, int log_muc_conf,
enum room_autowhois autowhois, const char *mbjid)
{
bool new_member = FALSE; // True if somebody else joins the room (not us)
gchar *nickjid;
gchar *mbuf;
enum room_flagjoins flagjoins;
char *tmp = NULL;
int printjid;
printjid = settings_opt_get_int("muc_print_jid");
if (mbjid && autowhois == autowhois_off && printjid) {
if (printjid == 1)
tmp = strchr(mbjid, JID_RESOURCE_SEPARATOR);
if (tmp) *tmp = '\0';
nickjid = g_strdup_printf("%s <%s>", rname, mbjid);
if (tmp) *tmp = JID_RESOURCE_SEPARATOR;
} else {
nickjid = g_strdup(rname);
}
if (!buddy_getinsideroom(room_elt->data)) {
// We weren't inside the room yet. Now we are.
// However, this could be a presence packet from another room member
buddy_setinsideroom(room_elt->data, TRUE);
// Set the message flag unless we're already in the room buffer window
scr_setmsgflag_if_needed(roomjid, FALSE);
// Add a message to the tracelog file
mbuf = g_strdup_printf("You have joined %s as \"%s\"", roomjid, ournick);
scr_LogPrint(LPRINT_LOGNORM, "%s", mbuf);
g_free(mbuf);
mbuf = g_strdup_printf("You have joined as \"%s\"", ournick);
// The 1st presence message could be for another room member
if (strcmp(ournick, rname)) {
// Display current mbuf and create a new message for the member
// Note: the usttime timestamp is related to the other member,
// so we use 0 here.
scr_WriteIncomingMessage(roomjid, mbuf, 0,
HBB_PREFIX_INFO|HBB_PREFIX_NOFLAG, 0);
if (log_muc_conf)
hlog_write_message(roomjid, 0, -1, mbuf);
g_free(mbuf);
if (printstatus != status_none)
mbuf = g_strdup_printf("%s has joined", nickjid);
else
mbuf = NULL;
new_member = TRUE;
}
} else {
mbuf = NULL;
if (strcmp(ournick, rname)) {
if (printstatus != status_none)
mbuf = g_strdup_printf("%s has joined", nickjid);
new_member = TRUE;
}
}
g_free(nickjid);
if (mbuf) {
guint msgflags = HBB_PREFIX_INFO;
flagjoins = buddy_getflagjoins(room_elt->data);
if (flagjoins == flagjoins_default &&
!settings_opt_get_int("muc_flag_joins"))
flagjoins = flagjoins_none;
if (flagjoins == flagjoins_none)
msgflags |= HBB_PREFIX_NOFLAG;
scr_WriteIncomingMessage(roomjid, mbuf, usttime, msgflags, 0);
if (log_muc_conf)
hlog_write_message(roomjid, 0, -1, mbuf);
g_free(mbuf);
}
return new_member;
}