static void decline_invitation(event_muc_invitation *invitation, char *reason)

{

  // cut and paste from xmpp_room_invite

  LmMessage *m;

  LmMessageNode *x, *y;

  if (!invitation) return;

  if (!invitation->to || !invitation->from) return;

  m = lm_message_new(invitation->to, LM_MESSAGE_TYPE_MESSAGE);

  x = lm_message_node_add_child(m->node, "x", NULL);

  lm_message_node_set_attribute(x, "xmlns",

                                "http://jabber.org/protocol/muc#user");

  y = lm_message_node_add_child(x, "decline", NULL);

  lm_message_node_set_attribute(y, "to", invitation->from);

  if (reason)

    lm_message_node_add_child(y, "reason", reason);

  lm_connection_send(lconnection, m, NULL);

  lm_message_unref(m);

}

static int evscallback_invitation(eviqs *evp, guint evcontext)

{

  event_muc_invitation *invitation = evp->data;

  // Sanity check

  if (!invitation) {

    // Shouldn't happen.

    scr_LogPrint(LPRINT_LOGNORM, "Error in evs callback.");

    return 0;

  }

  if (evcontext == EVS_CONTEXT_TIMEOUT) {

    scr_LogPrint(LPRINT_LOGNORM, "Event %s timed out, cancelled.", evp->id);

    goto evscallback_invitation_free;

  }

  if (evcontext == EVS_CONTEXT_CANCEL) {

    scr_LogPrint(LPRINT_LOGNORM, "Event %s cancelled.", evp->id);

    goto evscallback_invitation_free;

  }

  if (!(evcontext & EVS_CONTEXT_USER))

    goto evscallback_invitation_free;

  // Ok, let's work now.

  // evcontext: 0, 1 == reject, accept

  if (evcontext & ~EVS_CONTEXT_USER) {

    char *nickname = default_muc_nickname(invitation->to);

    xmpp_room_join(invitation->to, nickname, invitation->passwd);

    g_free(nickname);

  } else {

    scr_LogPrint(LPRINT_LOGNORM, "Invitation to %s refused.", invitation->to);

    decline_invitation(invitation, NULL);

  }

evscallback_invitation_free:

  g_free(invitation->to);

  g_free(invitation->from);

  g_free(invitation->passwd);

  g_free(invitation->reason);

  g_free(invitation);

  evp->data = NULL;

  return 0;

}

// Join a MUC room

void xmpp_room_join(const char *room, const char *nickname, const char *passwd)

{

  LmMessage *x;

  LmMessageNode *y;

  gchar *roomid;

  GSList *room_elt;

  if (!lm_connection_is_authenticated(lconnection) || !room) return;

  if (!nickname)        return;

  roomid = g_strdup_printf("%s/%s", room, nickname);

  if (check_jid_syntax(roomid)) {

    scr_LogPrint(LPRINT_NORMAL, "<%s/%s> is not a valid Jabber room", room,

                 nickname);

    g_free(roomid);

    return;

  }

  room_elt = roster_find(room, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_ROOM);

  // Add room if it doesn't already exist

  if (!room_elt) {

    room_elt = roster_add_user(room, NULL, NULL, ROSTER_TYPE_ROOM,

                               sub_none, -1);

  } else {

    // Make sure this is a room (it can be a conversion user->room)

    buddy_settype(room_elt->data, ROSTER_TYPE_ROOM);

  }

  // If insideroom is TRUE, this is a nickname change and we don't care here

  if (!buddy_getinsideroom(room_elt->data)) {

    // We're trying to enter a room

    buddy_setnickname(room_elt->data, nickname);

  }

  // Send the XML request

  x = lm_message_new(roomid, LM_MESSAGE_TYPE_PRESENCE);

  x = lm_message_new_presence(mystatus, roomid, mystatusmsg);

  y = lm_message_node_add_child(x->node, "x", NULL);

  lm_message_node_set_attribute(y, "xmlns", "http://jabber.org/protocol/muc");

  if (passwd)

    lm_message_node_add_child(y, "password", passwd);

  lm_connection_send(lconnection, x, NULL);

  lm_message_unref(x);

  g_free(roomid);

}

// Invite a user to a MUC room

// room syntax: "room@server"

// reason can be null.

void xmpp_room_invite(const char *room, const char *fjid, const char *reason)

{

  LmMessage *msg;

  LmMessageNode *x, *y;

  if (!lm_connection_is_authenticated(lconnection) || !room || !fjid) return;

  msg = lm_message_new(room, LM_MESSAGE_TYPE_MESSAGE);

  x = lm_message_node_add_child(msg->node, "x", NULL);

  lm_message_node_set_attribute(x, "xmlns",

                                "http://jabber.org/protocol/muc#user");

  y = lm_message_node_add_child(x, "invite", NULL);

  lm_message_node_set_attribute(y, "to", fjid);

  if (reason)

    lm_message_node_add_child(y, "reason", reason);

  lm_connection_send(lconnection, msg, NULL);

  lm_message_unref(msg);

}

int xmpp_room_setattrib(const char *roomid, const char *fjid,

                        const char *nick, struct role_affil ra,

                        const char *reason)

{

  LmMessage *iq;

  LmMessageNode *query, *x;

  if (!lm_connection_is_authenticated(lconnection) || !roomid) return 1;

  if (!fjid && !nick) return 1;

  if (check_jid_syntax((char*)roomid)) {

    scr_LogPrint(LPRINT_NORMAL, "<%s> is not a valid Jabber id", roomid);

    return 1;

  }

  if (fjid && check_jid_syntax((char*)fjid)) {

    scr_LogPrint(LPRINT_NORMAL, "<%s> is not a valid Jabber id", fjid);

    return 1;

  }

  if (ra.type == type_affil && ra.val.affil == affil_outcast && !fjid)

    return 1; // Shouldn't happen (jid mandatory when banning)

  iq = lm_message_new_with_sub_type(roomid, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  query = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(query, "xmlns",

                                "http://jabber.org/protocol/muc#admin");

  x = lm_message_node_add_child(query, "item", NULL);

  if (fjid) {

    lm_message_node_set_attribute(x, "jid", fjid);

  } else { // nickname

    lm_message_node_set_attribute(x, "nick", nick);

  }

  if (ra.type == type_affil)

    lm_message_node_set_attribute(x, "affiliation", straffil[ra.val.affil]);

  else if (ra.type == type_role)

    lm_message_node_set_attribute(x, "role", strrole[ra.val.role]);

  if (reason)

    lm_message_node_add_child(x, "reason", reason);

  lm_connection_send(lconnection, iq, NULL);

  lm_message_unref(iq);

  return 0;

}

// Unlock a MUC room

// room syntax: "room@server"

void xmpp_room_unlock(const char *room)

{

  LmMessageNode *y, *z;

  LmMessage *iq;

  if (!lm_connection_is_authenticated(lconnection) || !room) return;

  iq = lm_message_new_with_sub_type(room, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  lm_message_node_set_attribute(iq->node, "xmlns",

                                "http://jabber.org/protocol/muc#owner");

  y = lm_message_node_add_child(iq->node, "query", NULL);

  z = lm_message_node_add_child(y, "x", NULL);

  lm_message_node_set_attribute(z, "xmlns", "jabber:x:data");

  lm_message_node_set_attribute(z, "type", "submit");

  lm_connection_send(lconnection, iq, NULL);

  lm_message_unref(iq);

}

// Destroy a MUC room

// room syntax: "room@server"

void xmpp_room_destroy(const char *room, const char *venue, const char *reason)

{

  LmMessage *iq;

  LmMessageNode *query, *x;

  if (!lm_connection_is_authenticated(lconnection) || !room) return;

  iq = lm_message_new_with_sub_type(room, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  query = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(query, "xmlns",

                                "http://jabber.org/protocol/muc#owner");

  x = lm_message_node_add_child(query, "destroy", NULL);

  if (venue && *venue)

    lm_message_node_set_attribute(x, "jid", venue);

  if (reason)

    lm_message_node_add_child(x, "reason", reason);

  lm_connection_send(lconnection, iq, NULL);

  lm_message_unref(iq);

}

//  muc_get_item_info(...)

// Get room member's information from xmlndata.

// The variables must be initialized before calling this function,

// because they are not touched if the relevant information is missing.

static void muc_get_item_info(const char *from, LmMessageNode *xmldata,

                              enum imrole *mbrole, enum imaffiliation *mbaffil,

                              const char **mbjid, const char **mbnick,

                              const char **actorjid, const char **reason)

{

  LmMessageNode *y, *z;

  const char *p;

  y = lm_message_node_find_child(xmldata, "item");

  if (!y)

    return;

  p = lm_message_node_get_attribute(y, "affiliation");

  if (p) {

    if (!strcmp(p, "owner"))        *mbaffil = affil_owner;

    else if (!strcmp(p, "admin"))   *mbaffil = affil_admin;

    else if (!strcmp(p, "member"))  *mbaffil = affil_member;

    else if (!strcmp(p, "outcast")) *mbaffil = affil_outcast;

    else if (!strcmp(p, "none"))    *mbaffil = affil_none;

    else scr_LogPrint(LPRINT_LOGNORM, "<%s>: Unknown affiliation \"%s\"",

                      from, p);

  }

  p = lm_message_node_get_attribute(y, "role");

  if (p) {

    if (!strcmp(p, "moderator"))        *mbrole = role_moderator;

    else if (!strcmp(p, "participant")) *mbrole = role_participant;

    else if (!strcmp(p, "visitor"))     *mbrole = role_visitor;

    else if (!strcmp(p, "none"))        *mbrole = role_none;

    else scr_LogPrint(LPRINT_LOGNORM, "<%s>: Unknown role \"%s\"",

                      from, p);

  }

  *mbjid = lm_message_node_get_attribute(y, "jid");

  *mbnick = lm_message_node_get_attribute(y, "nick");

  // For kick/ban, there can be actor and reason tags

  *reason = lm_message_node_get_child_value(y, "reason");

  z = lm_message_node_find_child(y, "actor");

  if (z)

    *actorjid = lm_message_node_get_attribute(z, "jid");

}

//  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)

{

  bool new_member = FALSE; // True if somebody else joins the room (not us)

  gchar *mbuf;

  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", rname);

      else

        mbuf = NULL;

      new_member = TRUE;

    }

  } else {

    mbuf = NULL;

    if (strcmp(ournick, rname)) {

      if (printstatus != status_none)

        mbuf = g_strdup_printf("%s has joined", rname);

      new_member = TRUE;

    }

  }

  if (mbuf) {

    guint msgflags = HBB_PREFIX_INFO;

    if (!settings_opt_get_int("muc_flag_joins"))

      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;

}

static 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)