2012-11-04 18:31:49 -05:00
|
|
|
/*
|
2013-01-11 20:01:39 -05:00
|
|
|
* muc.c
|
2019-11-13 06:11:05 -05:00
|
|
|
* vim: expandtab:ts=4:sts=4:sw=4
|
2012-11-04 18:31:49 -05:00
|
|
|
*
|
2019-01-22 05:31:45 -05:00
|
|
|
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
|
2012-11-04 18:31:49 -05:00
|
|
|
*
|
|
|
|
* This file is part of Profanity.
|
|
|
|
*
|
|
|
|
* Profanity is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Profanity is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2016-07-23 20:14:49 -04:00
|
|
|
* along with Profanity. If not, see <https://www.gnu.org/licenses/>.
|
2012-11-04 18:31:49 -05:00
|
|
|
*
|
2014-08-24 15:57:39 -04:00
|
|
|
* In addition, as a special exception, the copyright holders give permission to
|
|
|
|
* link the code of portions of this program with the OpenSSL library under
|
|
|
|
* certain conditions as described in each individual source file, and
|
|
|
|
* distribute linked combinations including the two.
|
|
|
|
*
|
|
|
|
* You must obey the GNU General Public License in all respects for all of the
|
|
|
|
* code used other than OpenSSL. If you modify file(s) with this exception, you
|
|
|
|
* may extend this exception to your version of the file(s), but you are not
|
|
|
|
* obligated to do so. If you do not wish to do so, delete this exception
|
|
|
|
* statement from your version. If you delete this exception statement from all
|
|
|
|
* source files in the program, then also delete it here.
|
|
|
|
*
|
2012-11-04 18:31:49 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2015-06-17 14:49:55 -04:00
|
|
|
#include <assert.h>
|
2012-11-04 18:31:49 -05:00
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
|
2014-05-21 16:39:31 -04:00
|
|
|
#include "common.h"
|
2013-02-02 16:43:59 -05:00
|
|
|
#include "tools/autocomplete.h"
|
2014-07-08 19:35:43 -04:00
|
|
|
#include "ui/ui.h"
|
2016-07-24 10:14:46 -04:00
|
|
|
#include "ui/window_list.h"
|
2016-07-24 10:43:51 -04:00
|
|
|
#include "xmpp/jid.h"
|
|
|
|
#include "xmpp/muc.h"
|
|
|
|
#include "xmpp/contact.h"
|
2014-09-27 20:55:24 -04:00
|
|
|
|
2020-01-20 08:28:13 -05:00
|
|
|
#ifdef HAVE_OMEMO
|
|
|
|
#include "omemo/omemo.h"
|
|
|
|
#endif
|
|
|
|
|
2012-11-04 18:31:49 -05:00
|
|
|
typedef struct _muc_room_t {
|
2013-01-11 19:33:35 -05:00
|
|
|
char *room; // e.g. test@conference.server
|
|
|
|
char *nick; // e.g. Some User
|
2014-09-27 20:55:24 -04:00
|
|
|
muc_role_t role;
|
|
|
|
muc_affiliation_t affiliation;
|
2014-04-20 17:02:55 -04:00
|
|
|
char *password;
|
2013-01-11 18:57:03 -05:00
|
|
|
char *subject;
|
2014-07-15 17:46:29 -04:00
|
|
|
char *autocomplete_prefix;
|
2014-09-03 17:56:33 -04:00
|
|
|
gboolean pending_config;
|
2014-05-05 15:13:22 -04:00
|
|
|
GList *pending_broadcasts;
|
2014-04-20 19:37:04 -04:00
|
|
|
gboolean autojoin;
|
2012-11-18 17:49:01 -05:00
|
|
|
gboolean pending_nick_change;
|
2012-11-07 19:05:32 -05:00
|
|
|
GHashTable *roster;
|
2020-01-20 08:28:13 -05:00
|
|
|
GHashTable *members;
|
2013-01-24 20:11:49 -05:00
|
|
|
Autocomplete nick_ac;
|
2014-10-06 17:59:25 -04:00
|
|
|
Autocomplete jid_ac;
|
2012-11-18 16:46:58 -05:00
|
|
|
GHashTable *nick_changes;
|
2012-11-07 17:59:48 -05:00
|
|
|
gboolean roster_received;
|
2015-03-28 18:51:41 -04:00
|
|
|
muc_member_type_t member_type;
|
2019-04-17 05:07:57 -04:00
|
|
|
muc_anonymity_type_t anonymity_type;
|
2013-01-12 19:08:45 -05:00
|
|
|
} ChatRoom;
|
2012-11-04 18:31:49 -05:00
|
|
|
|
2012-11-05 19:00:25 -05:00
|
|
|
GHashTable *rooms = NULL;
|
2015-03-28 22:16:41 -04:00
|
|
|
GHashTable *invite_passwords = NULL;
|
2019-10-06 13:00:46 -04:00
|
|
|
Autocomplete invite_ac = NULL;
|
|
|
|
Autocomplete confservers_ac = NULL;
|
2012-11-05 19:00:25 -05:00
|
|
|
|
2013-01-12 19:08:45 -05:00
|
|
|
static void _free_room(ChatRoom *room);
|
2014-09-29 19:16:01 -04:00
|
|
|
static gint _compare_occupants(Occupant *a, Occupant *b);
|
2015-10-25 20:52:33 -04:00
|
|
|
static muc_role_t _role_from_string(const char *const role);
|
|
|
|
static muc_affiliation_t _affiliation_from_string(const char *const affiliation);
|
2014-09-27 20:55:24 -04:00
|
|
|
static char* _role_to_string(muc_role_t role);
|
|
|
|
static char* _affiliation_to_string(muc_affiliation_t affiliation);
|
2015-10-25 20:52:33 -04:00
|
|
|
static Occupant* _muc_occupant_new(const char *const nick, const char *const jid, muc_role_t role,
|
|
|
|
muc_affiliation_t affiliation, resource_presence_t presence, const char *const status);
|
2014-09-29 19:16:01 -04:00
|
|
|
static void _occupant_free(Occupant *occupant);
|
2012-11-04 18:31:49 -05:00
|
|
|
|
2013-04-24 18:50:47 -04:00
|
|
|
void
|
|
|
|
muc_init(void)
|
|
|
|
{
|
|
|
|
invite_ac = autocomplete_new();
|
2018-02-05 16:40:32 -05:00
|
|
|
confservers_ac = autocomplete_new();
|
2014-09-25 19:43:00 -04:00
|
|
|
rooms = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_free_room);
|
2015-03-28 22:16:41 -04:00
|
|
|
invite_passwords = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
|
2013-04-24 18:50:47 -04:00
|
|
|
}
|
|
|
|
|
2014-01-30 18:15:39 -05:00
|
|
|
void
|
|
|
|
muc_close(void)
|
|
|
|
{
|
|
|
|
autocomplete_free(invite_ac);
|
2018-02-05 16:40:32 -05:00
|
|
|
autocomplete_free(confservers_ac);
|
2014-09-25 19:43:00 -04:00
|
|
|
g_hash_table_destroy(rooms);
|
2015-03-28 22:16:41 -04:00
|
|
|
g_hash_table_destroy(invite_passwords);
|
2014-09-25 19:43:00 -04:00
|
|
|
rooms = NULL;
|
2015-03-28 22:16:41 -04:00
|
|
|
invite_passwords = NULL;
|
2019-10-06 13:00:46 -04:00
|
|
|
invite_ac = NULL;
|
|
|
|
confservers_ac = NULL;
|
2014-01-30 18:15:39 -05:00
|
|
|
}
|
|
|
|
|
2018-02-05 16:40:32 -05:00
|
|
|
void
|
|
|
|
muc_confserver_add(const char *const server)
|
|
|
|
{
|
|
|
|
autocomplete_add(confservers_ac, server);
|
|
|
|
}
|
|
|
|
|
2013-04-24 18:50:47 -04:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_invites_add(const char *const room, const char *const password)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
2013-08-25 20:29:50 -04:00
|
|
|
autocomplete_add(invite_ac, room);
|
2015-03-28 22:16:41 -04:00
|
|
|
if (password) {
|
|
|
|
g_hash_table_replace(invite_passwords, strdup(room), strdup(password));
|
|
|
|
}
|
2013-04-24 18:50:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_invites_remove(const char *const room)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
|
|
|
autocomplete_remove(invite_ac, room);
|
2015-03-28 22:16:41 -04:00
|
|
|
g_hash_table_remove(invite_passwords, room);
|
2013-04-24 18:50:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
2014-09-28 17:09:20 -04:00
|
|
|
muc_invites_count(void)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
|
|
|
return autocomplete_length(invite_ac);
|
|
|
|
}
|
|
|
|
|
2017-03-31 19:27:11 -04:00
|
|
|
GList*
|
2014-09-28 17:09:20 -04:00
|
|
|
muc_invites(void)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
2014-09-25 19:06:50 -04:00
|
|
|
return autocomplete_create_list(invite_ac);
|
2013-04-24 18:50:47 -04:00
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_invite_password(const char *const room)
|
2015-03-28 22:16:41 -04:00
|
|
|
{
|
|
|
|
return g_hash_table_lookup(invite_passwords, room);
|
|
|
|
}
|
|
|
|
|
2013-04-24 18:50:47 -04:00
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_invites_contain(const char *const room)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
2017-03-31 19:27:11 -04:00
|
|
|
GList *invites = autocomplete_create_list(invite_ac);
|
|
|
|
GList *curr = invites;
|
2014-09-25 19:27:58 -04:00
|
|
|
while (curr) {
|
2013-04-24 18:50:47 -04:00
|
|
|
if (strcmp(curr->data, room) == 0) {
|
2017-03-31 19:27:11 -04:00
|
|
|
g_list_free_full(invites, g_free);
|
2013-04-24 18:50:47 -04:00
|
|
|
return TRUE;
|
|
|
|
} else {
|
2017-03-31 19:27:11 -04:00
|
|
|
curr = g_list_next(curr);
|
2013-04-24 18:50:47 -04:00
|
|
|
}
|
|
|
|
}
|
2017-03-31 19:27:11 -04:00
|
|
|
g_list_free_full(invites, g_free);
|
2014-09-25 19:27:58 -04:00
|
|
|
|
2013-04-24 18:50:47 -04:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-09-28 17:09:20 -04:00
|
|
|
muc_invites_reset_ac(void)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
|
|
|
autocomplete_reset(invite_ac);
|
|
|
|
}
|
|
|
|
|
2018-02-05 16:40:32 -05:00
|
|
|
void
|
|
|
|
muc_confserver_reset_ac(void)
|
|
|
|
{
|
|
|
|
autocomplete_reset(confservers_ac);
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
2020-01-30 17:44:43 -05:00
|
|
|
muc_invites_find(const char *const search_str, gboolean previous, void *context)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
2017-03-31 19:27:11 -04:00
|
|
|
return autocomplete_complete(invite_ac, search_str, TRUE, previous);
|
2013-04-24 18:50:47 -04:00
|
|
|
}
|
|
|
|
|
2018-02-05 16:40:32 -05:00
|
|
|
char*
|
2020-01-30 17:44:43 -05:00
|
|
|
muc_confserver_find(const char *const search_str, gboolean previous, void *context)
|
2018-02-05 16:40:32 -05:00
|
|
|
{
|
|
|
|
return autocomplete_complete(confservers_ac, search_str, TRUE, previous);
|
|
|
|
}
|
|
|
|
|
2013-04-24 18:50:47 -04:00
|
|
|
void
|
2014-09-28 17:09:20 -04:00
|
|
|
muc_invites_clear(void)
|
2013-04-24 18:50:47 -04:00
|
|
|
{
|
|
|
|
autocomplete_clear(invite_ac);
|
2015-07-26 19:04:48 -04:00
|
|
|
if (invite_passwords) {
|
|
|
|
g_hash_table_remove_all(invite_passwords);
|
|
|
|
}
|
2013-04-24 18:50:47 -04:00
|
|
|
}
|
|
|
|
|
2018-02-05 16:40:32 -05:00
|
|
|
void
|
|
|
|
muc_confserver_clear(void)
|
|
|
|
{
|
|
|
|
autocomplete_clear(confservers_ac);
|
|
|
|
}
|
|
|
|
|
2012-11-04 18:31:49 -05:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_join(const char *const room, const char *const nick, const char *const password, gboolean autojoin)
|
2012-11-04 18:31:49 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *new_room = malloc(sizeof(ChatRoom));
|
2012-11-10 13:24:33 -05:00
|
|
|
new_room->room = strdup(room);
|
2012-11-04 18:31:49 -05:00
|
|
|
new_room->nick = strdup(nick);
|
2014-09-27 20:55:24 -04:00
|
|
|
new_room->role = MUC_ROLE_NONE;
|
|
|
|
new_room->affiliation = MUC_AFFILIATION_NONE;
|
2014-07-15 17:46:29 -04:00
|
|
|
new_room->autocomplete_prefix = NULL;
|
2014-09-25 19:27:58 -04:00
|
|
|
if (password) {
|
2014-04-20 17:02:55 -04:00
|
|
|
new_room->password = strdup(password);
|
|
|
|
} else {
|
|
|
|
new_room->password = NULL;
|
|
|
|
}
|
2013-01-13 13:21:26 -05:00
|
|
|
new_room->subject = NULL;
|
2014-05-05 15:13:22 -04:00
|
|
|
new_room->pending_broadcasts = NULL;
|
2014-09-03 17:56:33 -04:00
|
|
|
new_room->pending_config = FALSE;
|
2014-09-29 19:16:01 -04:00
|
|
|
new_room->roster = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_occupant_free);
|
2020-01-20 08:28:13 -05:00
|
|
|
new_room->members = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
|
2013-01-24 20:11:49 -05:00
|
|
|
new_room->nick_ac = autocomplete_new();
|
2014-10-06 17:59:25 -04:00
|
|
|
new_room->jid_ac = autocomplete_new();
|
2014-09-29 19:16:01 -04:00
|
|
|
new_room->nick_changes = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
|
2012-11-07 17:59:48 -05:00
|
|
|
new_room->roster_received = FALSE;
|
2012-11-18 17:49:01 -05:00
|
|
|
new_room->pending_nick_change = FALSE;
|
2014-04-20 19:37:04 -04:00
|
|
|
new_room->autojoin = autojoin;
|
2015-03-28 18:51:41 -04:00
|
|
|
new_room->member_type = MUC_MEMBER_TYPE_UNKNOWN;
|
2019-04-17 05:07:57 -04:00
|
|
|
new_room->anonymity_type = MUC_ANONYMITY_TYPE_UNKNOWN;
|
2012-11-04 18:31:49 -05:00
|
|
|
|
2012-11-10 13:24:33 -05:00
|
|
|
g_hash_table_insert(rooms, strdup(room), new_room);
|
2012-11-05 19:00:25 -05:00
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_leave(const char *const room)
|
2013-01-11 19:33:35 -05:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
g_hash_table_remove(rooms, room);
|
2013-01-11 19:33:35 -05:00
|
|
|
}
|
|
|
|
|
2014-09-03 17:56:33 -04:00
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_requires_config(const char *const room)
|
2014-09-03 17:56:33 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:43:00 -04:00
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->pending_config;
|
|
|
|
} else {
|
2014-09-03 17:56:33 -04:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_set_requires_config(const char *const room, gboolean val)
|
2014-09-03 17:56:33 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:43:00 -04:00
|
|
|
if (chat_room) {
|
|
|
|
chat_room->pending_config = val;
|
2014-09-03 17:56:33 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-28 20:21:18 -04:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_set_features(const char *const room, GSList *features)
|
2015-03-28 20:21:18 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room && features) {
|
|
|
|
if (g_slist_find_custom(features, "muc_membersonly", (GCompareFunc)g_strcmp0)) {
|
|
|
|
chat_room->member_type = MUC_MEMBER_TYPE_MEMBERS_ONLY;
|
|
|
|
} else {
|
|
|
|
chat_room->member_type = MUC_MEMBER_TYPE_PUBLIC;
|
|
|
|
}
|
2019-04-17 05:07:57 -04:00
|
|
|
if (g_slist_find_custom(features, "muc_nonanonymous", (GCompareFunc)g_strcmp0)) {
|
|
|
|
chat_room->anonymity_type = MUC_ANONYMITY_TYPE_NONANONYMOUS;
|
|
|
|
} else if (g_slist_find_custom(features, "muc_semianonymous", (GCompareFunc)g_strcmp0)) {
|
|
|
|
chat_room->anonymity_type = MUC_ANONYMITY_TYPE_SEMIANONYMOUS;
|
|
|
|
} else {
|
|
|
|
chat_room->anonymity_type = MUC_ANONYMITY_TYPE_UNKNOWN;
|
|
|
|
}
|
2015-03-28 20:21:18 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 20:34:09 -05:00
|
|
|
/*
|
|
|
|
* Returns TRUE if the user is currently in the room
|
|
|
|
*/
|
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_active(const char *const room)
|
2013-01-11 20:34:09 -05:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
return (chat_room != NULL);
|
2013-01-11 20:34:09 -05:00
|
|
|
}
|
|
|
|
|
2014-04-20 19:37:04 -04:00
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_autojoin(const char *const room)
|
2014-04-20 19:37:04 -04:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->autojoin;
|
|
|
|
} else {
|
|
|
|
return FALSE;
|
2014-04-20 19:37:04 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-05 15:13:22 -04:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_set_subject(const char *const room, const char *const subject)
|
2014-05-05 15:13:22 -04:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
free(chat_room->subject);
|
2014-10-04 22:05:46 -04:00
|
|
|
if (subject) {
|
|
|
|
chat_room->subject = strdup(subject);
|
|
|
|
} else {
|
|
|
|
chat_room->subject = NULL;
|
|
|
|
}
|
2014-05-05 15:13:22 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_subject(const char *const room)
|
2014-05-05 15:13:22 -04:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->subject;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
2014-05-05 15:13:22 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_pending_broadcasts_add(const char *const room, const char *const message)
|
2014-05-05 15:13:22 -04:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
chat_room->pending_broadcasts = g_list_append(chat_room->pending_broadcasts, strdup(message));
|
2014-05-05 15:13:22 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
GList*
|
|
|
|
muc_pending_broadcasts(const char *const room)
|
2014-05-05 15:13:22 -04:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->pending_broadcasts;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
2014-05-05 15:13:22 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_old_nick(const char *const room, const char *const new_nick)
|
2013-08-05 16:20:07 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room && chat_room->pending_nick_change) {
|
2013-08-05 16:20:07 -04:00
|
|
|
return g_hash_table_lookup(chat_room->nick_changes, new_nick);
|
2014-09-25 19:43:00 -04:00
|
|
|
} else {
|
|
|
|
return NULL;
|
2013-08-05 16:20:07 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Flag that the user has sent a nick change to the service
|
|
|
|
* and is awaiting the response
|
|
|
|
*/
|
2012-11-18 17:49:01 -05:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_nick_change_start(const char *const room, const char *const new_nick)
|
2012-11-18 17:49:01 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2012-11-18 17:49:01 -05:00
|
|
|
chat_room->pending_nick_change = TRUE;
|
2013-08-05 16:20:07 -04:00
|
|
|
g_hash_table_insert(chat_room->nick_changes, strdup(new_nick), strdup(chat_room->nick));
|
2012-11-18 17:49:01 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Returns TRUE if the room is awaiting the result of a
|
|
|
|
* nick change
|
|
|
|
*/
|
2012-11-18 17:49:01 -05:00
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_nick_change_pending(const char *const room)
|
2012-11-18 17:49:01 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2012-11-18 17:49:01 -05:00
|
|
|
return chat_room->pending_nick_change;
|
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
2015-02-17 04:52:37 -05:00
|
|
|
* Change the current nick name for the room, call once
|
2013-01-11 19:33:35 -05:00
|
|
|
* the service has responded
|
|
|
|
*/
|
2012-11-18 13:36:17 -05:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_nick_change_complete(const char *const room, const char *const nick)
|
2012-11-18 13:36:17 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2014-10-09 21:25:52 -04:00
|
|
|
g_hash_table_remove(chat_room->roster, chat_room->nick);
|
|
|
|
autocomplete_remove(chat_room->nick_ac, chat_room->nick);
|
2012-11-18 13:36:17 -05:00
|
|
|
free(chat_room->nick);
|
|
|
|
chat_room->nick = strdup(nick);
|
2012-11-18 17:49:01 -05:00
|
|
|
chat_room->pending_nick_change = FALSE;
|
2013-08-05 16:20:07 -04:00
|
|
|
g_hash_table_remove(chat_room->nick_changes, nick);
|
2012-11-18 13:36:17 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Return a list of room names
|
|
|
|
* The contents of the list are owned by the chat room and should not be
|
|
|
|
* modified or freed.
|
|
|
|
*/
|
2015-10-25 20:52:33 -04:00
|
|
|
GList*
|
2014-09-28 17:09:20 -04:00
|
|
|
muc_rooms(void)
|
2012-11-19 19:33:11 -05:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
return g_hash_table_get_keys(rooms);
|
2012-11-19 19:33:11 -05:00
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Return current users nickname for the specified room
|
|
|
|
* The nickname is owned by the chat room and should not be modified or freed
|
|
|
|
*/
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_nick(const char *const room)
|
2012-11-05 16:36:32 -05:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->nick;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
2012-11-05 16:36:32 -05:00
|
|
|
}
|
2012-11-05 19:00:25 -05:00
|
|
|
}
|
2012-11-05 16:36:32 -05:00
|
|
|
|
2014-04-23 17:19:14 -04:00
|
|
|
/*
|
|
|
|
* Return password for the specified room
|
|
|
|
* The password is owned by the chat room and should not be modified or freed
|
|
|
|
*/
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_password(const char *const room)
|
2014-04-23 17:19:14 -04:00
|
|
|
{
|
2014-09-25 19:43:00 -04:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->password;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
2014-04-23 17:19:14 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Returns TRUE if the specified nick exists in the room's roster
|
|
|
|
*/
|
2012-11-18 19:26:31 -05:00
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_roster_contains_nick(const char *const room, const char *const nick)
|
2012-11-18 19:26:31 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 15:59:59 -04:00
|
|
|
if (chat_room) {
|
2014-09-29 19:16:01 -04:00
|
|
|
Occupant *occupant = g_hash_table_lookup(chat_room->roster, nick);
|
|
|
|
return (occupant != NULL);
|
2014-09-25 19:43:00 -04:00
|
|
|
} else {
|
|
|
|
return FALSE;
|
2012-11-18 19:26:31 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Add a new chat room member to the room's roster
|
|
|
|
*/
|
2012-11-18 18:58:57 -05:00
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_roster_add(const char *const room, const char *const nick, const char *const jid, const char *const role,
|
|
|
|
const char *const affiliation, const char *const show, const char *const status)
|
2012-11-07 17:24:50 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2012-11-18 18:58:57 -05:00
|
|
|
gboolean updated = FALSE;
|
2014-09-29 19:16:01 -04:00
|
|
|
resource_presence_t new_presence = resource_presence_from_string(show);
|
2012-11-07 17:24:50 -05:00
|
|
|
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2014-09-29 19:16:01 -04:00
|
|
|
Occupant *old = g_hash_table_lookup(chat_room->roster, nick);
|
2012-11-18 18:58:57 -05:00
|
|
|
|
2014-09-25 19:27:58 -04:00
|
|
|
if (!old) {
|
2012-11-18 18:58:57 -05:00
|
|
|
updated = TRUE;
|
2013-08-25 20:29:50 -04:00
|
|
|
autocomplete_add(chat_room->nick_ac, nick);
|
2014-09-29 19:16:01 -04:00
|
|
|
} else if (old->presence != new_presence ||
|
|
|
|
(g_strcmp0(old->status, status) != 0)) {
|
2012-11-18 18:58:57 -05:00
|
|
|
updated = TRUE;
|
|
|
|
}
|
2014-09-25 19:27:58 -04:00
|
|
|
|
2014-09-29 19:16:01 -04:00
|
|
|
resource_presence_t presence = resource_presence_from_string(show);
|
2014-09-30 14:46:35 -04:00
|
|
|
muc_role_t role_t = _role_from_string(role);
|
|
|
|
muc_affiliation_t affiliation_t = _affiliation_from_string(affiliation);
|
2014-10-01 08:27:01 -04:00
|
|
|
Occupant *occupant = _muc_occupant_new(nick, jid, role_t, affiliation_t, presence, status);
|
2014-09-29 19:16:01 -04:00
|
|
|
g_hash_table_replace(chat_room->roster, strdup(nick), occupant);
|
2014-10-06 17:59:25 -04:00
|
|
|
|
|
|
|
if (jid) {
|
|
|
|
Jid *jidp = jid_create(jid);
|
|
|
|
if (jidp->barejid) {
|
|
|
|
autocomplete_add(chat_room->jid_ac, jidp->barejid);
|
|
|
|
}
|
|
|
|
jid_destroy(jidp);
|
|
|
|
}
|
2012-11-07 19:05:32 -05:00
|
|
|
}
|
2012-11-18 18:58:57 -05:00
|
|
|
|
|
|
|
return updated;
|
2012-11-07 19:05:32 -05:00
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Remove a room member from the room's roster
|
|
|
|
*/
|
2012-11-07 19:05:32 -05:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_roster_remove(const char *const room, const char *const nick)
|
2012-11-07 19:05:32 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2012-11-10 13:24:33 -05:00
|
|
|
g_hash_table_remove(chat_room->roster, nick);
|
2013-01-24 20:11:49 -05:00
|
|
|
autocomplete_remove(chat_room->nick_ac, nick);
|
2012-11-07 17:24:50 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
Occupant*
|
|
|
|
muc_roster_item(const char *const room, const char *const nick)
|
2013-01-14 19:02:23 -05:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2014-09-29 19:16:01 -04:00
|
|
|
Occupant *occupant = g_hash_table_lookup(chat_room->roster, nick);
|
|
|
|
return occupant;
|
2014-09-25 19:43:00 -04:00
|
|
|
} else {
|
|
|
|
return NULL;
|
2013-01-14 19:02:23 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Return a list of PContacts representing the room members in the room's roster
|
|
|
|
*/
|
2015-10-25 20:52:33 -04:00
|
|
|
GList*
|
|
|
|
muc_roster(const char *const room)
|
2012-11-07 17:24:50 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2013-05-30 17:05:52 -04:00
|
|
|
GList *result = NULL;
|
2014-11-03 16:27:41 -05:00
|
|
|
GList *occupants = g_hash_table_get_values(chat_room->roster);
|
2013-05-30 17:05:52 -04:00
|
|
|
|
2014-11-03 16:27:41 -05:00
|
|
|
GList *curr = occupants;
|
|
|
|
while (curr) {
|
|
|
|
result = g_list_insert_sorted(result, curr->data, (GCompareFunc)_compare_occupants);
|
|
|
|
curr = g_list_next(curr);
|
2013-05-30 17:05:52 -04:00
|
|
|
}
|
|
|
|
|
2014-11-03 16:27:41 -05:00
|
|
|
g_list_free(occupants);
|
|
|
|
|
2013-05-30 17:05:52 -04:00
|
|
|
return result;
|
2012-11-07 17:24:50 -05:00
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
2013-01-24 20:11:49 -05:00
|
|
|
* Return a Autocomplete representing the room member's in the roster
|
2013-01-11 19:33:35 -05:00
|
|
|
*/
|
2013-01-24 20:11:49 -05:00
|
|
|
Autocomplete
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_roster_ac(const char *const room)
|
2013-01-10 19:48:58 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2013-01-10 19:48:58 -05:00
|
|
|
return chat_room->nick_ac;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-06 17:59:25 -04:00
|
|
|
Autocomplete
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_roster_jid_ac(const char *const room)
|
2014-10-06 17:59:25 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->jid_ac;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
2014-08-27 07:26:11 -04:00
|
|
|
* Set to TRUE when the rooms roster has been fully received
|
2013-01-11 19:33:35 -05:00
|
|
|
*/
|
2012-11-07 17:59:48 -05:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_roster_set_complete(const char *const room)
|
2012-11-07 17:59:48 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2012-11-10 13:24:33 -05:00
|
|
|
chat_room->roster_received = TRUE;
|
2012-11-07 17:59:48 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
2014-08-27 07:26:11 -04:00
|
|
|
* Returns TRUE id the rooms roster has been fully received
|
2013-01-11 19:33:35 -05:00
|
|
|
*/
|
2012-11-07 17:59:48 -05:00
|
|
|
gboolean
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_roster_complete(const char *const room)
|
2012-11-07 17:59:48 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2012-11-10 13:24:33 -05:00
|
|
|
return chat_room->roster_received;
|
2012-11-07 17:59:48 -05:00
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-29 19:16:01 -04:00
|
|
|
gboolean
|
|
|
|
muc_occupant_available(Occupant *occupant)
|
|
|
|
{
|
|
|
|
return (occupant->presence == RESOURCE_ONLINE || occupant->presence == RESOURCE_CHAT);
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
const char*
|
2014-09-30 16:58:18 -04:00
|
|
|
muc_occupant_affiliation_str(Occupant *occupant)
|
|
|
|
{
|
|
|
|
return _affiliation_to_string(occupant->affiliation);
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
const char*
|
2014-09-30 16:58:18 -04:00
|
|
|
muc_occupant_role_str(Occupant *occupant)
|
|
|
|
{
|
|
|
|
return _role_to_string(occupant->role);
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
GSList*
|
|
|
|
muc_occupants_by_role(const char *const room, muc_role_t role)
|
2014-09-30 19:27:25 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
GSList *result = NULL;
|
|
|
|
GHashTableIter iter;
|
|
|
|
gpointer key;
|
|
|
|
gpointer value;
|
|
|
|
|
|
|
|
g_hash_table_iter_init(&iter, chat_room->roster);
|
|
|
|
while (g_hash_table_iter_next(&iter, &key, &value)) {
|
|
|
|
Occupant *occupant = (Occupant *)value;
|
|
|
|
if (occupant->role == role) {
|
|
|
|
result = g_slist_insert_sorted(result, value, (GCompareFunc)_compare_occupants);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
GSList*
|
|
|
|
muc_occupants_by_affiliation(const char *const room, muc_affiliation_t affiliation)
|
2014-09-30 19:46:58 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
GSList *result = NULL;
|
|
|
|
GHashTableIter iter;
|
|
|
|
gpointer key;
|
|
|
|
gpointer value;
|
|
|
|
|
|
|
|
g_hash_table_iter_init(&iter, chat_room->roster);
|
|
|
|
while (g_hash_table_iter_next(&iter, &key, &value)) {
|
|
|
|
Occupant *occupant = (Occupant *)value;
|
|
|
|
if (occupant->affiliation == affiliation) {
|
|
|
|
result = g_slist_insert_sorted(result, value, (GCompareFunc)_compare_occupants);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Remove the old_nick from the roster, and flag that a pending nickname change
|
|
|
|
* is in progress
|
|
|
|
*/
|
2012-11-18 16:46:58 -05:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_occupant_nick_change_start(const char *const room, const char *const new_nick, const char *const old_nick)
|
2012-11-18 16:46:58 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2012-11-18 16:46:58 -05:00
|
|
|
g_hash_table_insert(chat_room->nick_changes, strdup(new_nick), strdup(old_nick));
|
2014-09-28 17:09:20 -04:00
|
|
|
muc_roster_remove(room, old_nick);
|
2012-11-18 16:46:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:33:35 -05:00
|
|
|
/*
|
|
|
|
* Complete the pending nick name change for a contact in the room's roster
|
|
|
|
* The new nick name will be added to the roster
|
|
|
|
* The old nick name will be returned in a new string which must be freed by
|
|
|
|
* the caller
|
|
|
|
*/
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_roster_nick_change_complete(const char *const room, const char *const nick)
|
2012-11-18 16:46:58 -05:00
|
|
|
{
|
2013-01-12 19:08:45 -05:00
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (chat_room) {
|
2012-11-18 17:02:54 -05:00
|
|
|
char *old_nick = g_hash_table_lookup(chat_room->nick_changes, nick);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (old_nick) {
|
2014-04-25 19:36:36 -04:00
|
|
|
char *old_nick_cpy = strdup(old_nick);
|
2012-11-19 19:33:11 -05:00
|
|
|
g_hash_table_remove(chat_room->nick_changes, nick);
|
|
|
|
|
|
|
|
return old_nick_cpy;
|
2012-11-18 16:46:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
2017-03-31 19:27:11 -04:00
|
|
|
muc_autocomplete(ProfWin *window, const char *const input, gboolean previous)
|
2014-07-08 19:35:43 -04:00
|
|
|
{
|
2018-02-09 15:47:41 -05:00
|
|
|
if (window->type != WIN_MUC) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-07-15 17:46:29 -04:00
|
|
|
|
2018-02-09 15:47:41 -05:00
|
|
|
ProfMucWin *mucwin = (ProfMucWin*)window;
|
|
|
|
assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK);
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, mucwin->roomjid);
|
|
|
|
if (chat_room == NULL || chat_room->nick_ac == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char * search_str = NULL;
|
|
|
|
|
|
|
|
gchar *last_space = g_strrstr(input, " ");
|
|
|
|
if (!last_space) {
|
|
|
|
search_str = input;
|
|
|
|
if (!chat_room->autocomplete_prefix) {
|
|
|
|
chat_room->autocomplete_prefix = strdup("");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
search_str = last_space+1;
|
|
|
|
if (!chat_room->autocomplete_prefix) {
|
|
|
|
chat_room->autocomplete_prefix = g_strndup(input, search_str - input);
|
2014-07-15 18:52:08 -04:00
|
|
|
}
|
2014-07-15 17:46:29 -04:00
|
|
|
}
|
2015-01-16 17:50:40 -05:00
|
|
|
|
2018-02-09 15:47:41 -05:00
|
|
|
char *result = autocomplete_complete(chat_room->nick_ac, search_str, FALSE, previous);
|
|
|
|
if (result == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
GString *replace_with = g_string_new(chat_room->autocomplete_prefix);
|
|
|
|
g_string_append(replace_with, result);
|
|
|
|
|
|
|
|
if (strlen(chat_room->autocomplete_prefix) == 0) {
|
|
|
|
g_string_append(replace_with, ": ");
|
|
|
|
}
|
|
|
|
g_free(result);
|
|
|
|
result = replace_with->str;
|
|
|
|
g_string_free(replace_with, FALSE);
|
|
|
|
return result;
|
2014-07-15 17:46:29 -04:00
|
|
|
}
|
|
|
|
|
2014-10-06 17:59:25 -04:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_jid_autocomplete_reset(const char *const room)
|
2014-10-06 17:59:25 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
if (chat_room->jid_ac) {
|
|
|
|
autocomplete_reset(chat_room->jid_ac);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_jid_autocomplete_add_all(const char *const room, GSList *jids)
|
2014-10-06 17:59:25 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
if (chat_room->jid_ac) {
|
|
|
|
GSList *curr_jid = jids;
|
|
|
|
while (curr_jid) {
|
2016-04-27 06:31:28 -04:00
|
|
|
const char *jid = curr_jid->data;
|
2014-10-06 17:59:25 -04:00
|
|
|
Jid *jidp = jid_create(jid);
|
|
|
|
if (jidp) {
|
|
|
|
if (jidp->barejid) {
|
|
|
|
autocomplete_add(chat_room->jid_ac, jidp->barejid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
jid_destroy(jidp);
|
|
|
|
curr_jid = g_slist_next(curr_jid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-15 17:46:29 -04:00
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_autocomplete_reset(const char *const room)
|
2014-07-15 17:46:29 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
2014-09-25 19:43:00 -04:00
|
|
|
if (chat_room) {
|
|
|
|
if (chat_room->nick_ac) {
|
|
|
|
autocomplete_reset(chat_room->nick_ac);
|
|
|
|
}
|
2014-07-15 17:46:29 -04:00
|
|
|
|
2014-09-25 19:43:00 -04:00
|
|
|
if (chat_room->autocomplete_prefix) {
|
|
|
|
free(chat_room->autocomplete_prefix);
|
|
|
|
chat_room->autocomplete_prefix = NULL;
|
|
|
|
}
|
2014-07-08 19:35:43 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_role_str(const char *const room)
|
2014-09-27 20:55:24 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return _role_to_string(chat_room->role);
|
|
|
|
} else {
|
|
|
|
return "none";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_set_role(const char *const room, const char *const role)
|
2014-09-27 20:55:24 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
chat_room->role = _role_from_string(role);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
muc_affiliation_str(const char *const room)
|
2014-09-27 20:55:24 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return _affiliation_to_string(chat_room->affiliation);
|
|
|
|
} else {
|
|
|
|
return "none";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_set_affiliation(const char *const room, const char *const affiliation)
|
2014-09-27 20:55:24 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
chat_room->affiliation = _affiliation_from_string(affiliation);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-28 18:51:41 -04:00
|
|
|
muc_member_type_t
|
2015-10-25 20:52:33 -04:00
|
|
|
muc_member_type(const char *const room)
|
2015-03-28 18:51:41 -04:00
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->member_type;
|
|
|
|
} else {
|
|
|
|
return MUC_MEMBER_TYPE_UNKNOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-17 05:07:57 -04:00
|
|
|
muc_anonymity_type_t
|
|
|
|
muc_anonymity_type(const char *const room)
|
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return chat_room->anonymity_type;
|
|
|
|
} else {
|
|
|
|
return MUC_ANONYMITY_TYPE_UNKNOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-20 08:28:13 -05:00
|
|
|
/*
|
|
|
|
* Return the list of jid affiliated as member in the room
|
|
|
|
*/
|
|
|
|
GList*
|
|
|
|
muc_members(const char *const room)
|
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
return g_hash_table_get_keys(chat_room->members);
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
muc_members_add(const char *const room, const char *const jid)
|
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
if (g_hash_table_insert(chat_room->members, strdup(jid), NULL)) {
|
|
|
|
#ifdef HAVE_OMEMO
|
2020-04-17 13:53:34 -04:00
|
|
|
if(chat_room->anonymity_type == MUC_ANONYMITY_TYPE_NONANONYMOUS ) {
|
2020-05-25 07:04:19 -04:00
|
|
|
char *our_barejid = connection_get_barejid();
|
|
|
|
if (strcmp(jid, our_barejid) != 0) {
|
2020-04-17 13:53:34 -04:00
|
|
|
omemo_start_session(jid);
|
|
|
|
}
|
2020-05-25 07:04:19 -04:00
|
|
|
free(our_barejid);
|
2020-01-20 08:28:13 -05:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
muc_members_remove(const char *const room, const char *const jid)
|
|
|
|
{
|
|
|
|
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
|
|
|
|
if (chat_room) {
|
|
|
|
g_hash_table_remove(chat_room->members, jid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
muc_members_update(const char *const room, const char *const jid, const char *const affiliation)
|
|
|
|
{
|
|
|
|
if (strcmp(affiliation, "outcast") == 0 || strcmp(affiliation, "none") == 0) {
|
|
|
|
muc_members_remove(room, jid);
|
|
|
|
} else if (strcmp(affiliation, "member") == 0 || strcmp(affiliation, "admin") == 0 || strcmp(affiliation, "owner") == 0) {
|
|
|
|
muc_members_add(room, jid);
|
|
|
|
}
|
|
|
|
}
|
2015-03-28 18:51:41 -04:00
|
|
|
|
2012-11-05 19:00:25 -05:00
|
|
|
static void
|
2013-01-12 19:08:45 -05:00
|
|
|
_free_room(ChatRoom *room)
|
2012-11-05 19:00:25 -05:00
|
|
|
{
|
2014-09-25 19:27:58 -04:00
|
|
|
if (room) {
|
2013-08-03 07:27:07 -04:00
|
|
|
free(room->room);
|
|
|
|
free(room->nick);
|
|
|
|
free(room->subject);
|
2014-04-20 17:02:55 -04:00
|
|
|
free(room->password);
|
2014-09-25 19:27:58 -04:00
|
|
|
free(room->autocomplete_prefix);
|
|
|
|
if (room->roster) {
|
2014-06-15 17:39:46 -04:00
|
|
|
g_hash_table_destroy(room->roster);
|
2012-11-07 17:24:50 -05:00
|
|
|
}
|
2020-01-20 08:28:13 -05:00
|
|
|
if (room->members) {
|
|
|
|
g_hash_table_destroy(room->members);
|
|
|
|
}
|
2014-09-25 19:48:48 -04:00
|
|
|
autocomplete_free(room->nick_ac);
|
2014-10-06 17:59:25 -04:00
|
|
|
autocomplete_free(room->jid_ac);
|
2014-09-25 19:27:58 -04:00
|
|
|
if (room->nick_changes) {
|
2014-06-15 17:39:46 -04:00
|
|
|
g_hash_table_destroy(room->nick_changes);
|
2012-11-18 16:46:58 -05:00
|
|
|
}
|
2014-09-25 19:27:58 -04:00
|
|
|
if (room->pending_broadcasts) {
|
2014-05-05 15:13:22 -04:00
|
|
|
g_list_free_full(room->pending_broadcasts, free);
|
|
|
|
}
|
2014-06-15 15:37:03 -04:00
|
|
|
free(room);
|
2012-11-05 19:00:25 -05:00
|
|
|
}
|
2012-11-05 16:36:32 -05:00
|
|
|
}
|
2013-05-30 17:05:52 -04:00
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
static gint
|
|
|
|
_compare_occupants(Occupant *a, Occupant *b)
|
2013-05-30 17:05:52 -04:00
|
|
|
{
|
2015-05-06 19:26:24 -04:00
|
|
|
const char * utf8_str_a = a->nick_collate_key;
|
|
|
|
const char * utf8_str_b = b->nick_collate_key;
|
2013-05-30 17:05:52 -04:00
|
|
|
|
2015-05-06 19:26:24 -04:00
|
|
|
gint result = g_strcmp0(utf8_str_a, utf8_str_b);
|
2013-05-30 17:05:52 -04:00
|
|
|
|
|
|
|
return result;
|
2014-04-25 19:36:36 -04:00
|
|
|
}
|
2014-09-27 20:55:24 -04:00
|
|
|
|
|
|
|
static muc_role_t
|
2015-10-25 20:52:33 -04:00
|
|
|
_role_from_string(const char *const role)
|
2014-09-27 20:55:24 -04:00
|
|
|
{
|
|
|
|
if (role) {
|
|
|
|
if (g_strcmp0(role, "visitor") == 0) {
|
|
|
|
return MUC_ROLE_VISITOR;
|
|
|
|
} else if (g_strcmp0(role, "participant") == 0) {
|
|
|
|
return MUC_ROLE_PARTICIPANT;
|
|
|
|
} else if (g_strcmp0(role, "moderator") == 0) {
|
|
|
|
return MUC_ROLE_MODERATOR;
|
|
|
|
} else {
|
|
|
|
return MUC_ROLE_NONE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return MUC_ROLE_NONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
static char*
|
2014-09-27 20:55:24 -04:00
|
|
|
_role_to_string(muc_role_t role)
|
|
|
|
{
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
switch (role) {
|
|
|
|
case MUC_ROLE_NONE:
|
|
|
|
result = "none";
|
|
|
|
break;
|
|
|
|
case MUC_ROLE_VISITOR:
|
|
|
|
result = "visitor";
|
|
|
|
break;
|
|
|
|
case MUC_ROLE_PARTICIPANT:
|
|
|
|
result = "participant";
|
|
|
|
break;
|
|
|
|
case MUC_ROLE_MODERATOR:
|
|
|
|
result = "moderator";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result = "none";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static muc_affiliation_t
|
2015-10-25 20:52:33 -04:00
|
|
|
_affiliation_from_string(const char *const affiliation)
|
2014-09-27 20:55:24 -04:00
|
|
|
{
|
|
|
|
if (affiliation) {
|
|
|
|
if (g_strcmp0(affiliation, "outcast") == 0) {
|
|
|
|
return MUC_AFFILIATION_OUTCAST;
|
|
|
|
} else if (g_strcmp0(affiliation, "member") == 0) {
|
|
|
|
return MUC_AFFILIATION_MEMBER;
|
|
|
|
} else if (g_strcmp0(affiliation, "admin") == 0) {
|
|
|
|
return MUC_AFFILIATION_ADMIN;
|
|
|
|
} else if (g_strcmp0(affiliation, "owner") == 0) {
|
|
|
|
return MUC_AFFILIATION_OWNER;
|
|
|
|
} else {
|
|
|
|
return MUC_AFFILIATION_NONE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return MUC_AFFILIATION_NONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
static char*
|
2014-09-27 20:55:24 -04:00
|
|
|
_affiliation_to_string(muc_affiliation_t affiliation)
|
|
|
|
{
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
switch (affiliation) {
|
|
|
|
case MUC_AFFILIATION_NONE:
|
|
|
|
result = "none";
|
|
|
|
break;
|
|
|
|
case MUC_AFFILIATION_OUTCAST:
|
|
|
|
result = "outcast";
|
|
|
|
break;
|
|
|
|
case MUC_AFFILIATION_MEMBER:
|
|
|
|
result = "member";
|
|
|
|
break;
|
|
|
|
case MUC_AFFILIATION_ADMIN:
|
|
|
|
result = "admin";
|
|
|
|
break;
|
|
|
|
case MUC_AFFILIATION_OWNER:
|
|
|
|
result = "owner";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result = "none";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2014-09-29 19:16:01 -04:00
|
|
|
|
|
|
|
static Occupant*
|
2015-10-25 20:52:33 -04:00
|
|
|
_muc_occupant_new(const char *const nick, const char *const jid, muc_role_t role, muc_affiliation_t affiliation,
|
|
|
|
resource_presence_t presence, const char *const status)
|
2014-09-29 19:16:01 -04:00
|
|
|
{
|
|
|
|
Occupant *occupant = malloc(sizeof(Occupant));
|
|
|
|
|
|
|
|
if (nick) {
|
|
|
|
occupant->nick = strdup(nick);
|
2015-05-06 19:26:24 -04:00
|
|
|
occupant->nick_collate_key = g_utf8_collate_key(occupant->nick, -1);
|
2014-09-29 19:16:01 -04:00
|
|
|
} else {
|
|
|
|
occupant->nick = NULL;
|
2015-05-06 19:26:24 -04:00
|
|
|
occupant->nick_collate_key = NULL;
|
2014-09-29 19:16:01 -04:00
|
|
|
}
|
|
|
|
|
2014-10-01 08:27:01 -04:00
|
|
|
if (jid) {
|
|
|
|
occupant->jid = strdup(jid);
|
|
|
|
} else {
|
|
|
|
occupant->jid = NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-29 19:16:01 -04:00
|
|
|
occupant->presence = presence;
|
|
|
|
|
|
|
|
if (status) {
|
|
|
|
occupant->status = strdup(status);
|
|
|
|
} else {
|
|
|
|
occupant->status = NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-30 14:46:35 -04:00
|
|
|
occupant->role = role;
|
|
|
|
occupant->affiliation = affiliation;
|
2014-09-29 19:16:01 -04:00
|
|
|
|
|
|
|
return occupant;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_occupant_free(Occupant *occupant)
|
|
|
|
{
|
|
|
|
if (occupant) {
|
|
|
|
free(occupant->nick);
|
2015-05-06 19:26:24 -04:00
|
|
|
free(occupant->nick_collate_key);
|
2014-10-01 08:27:01 -04:00
|
|
|
free(occupant->jid);
|
2014-09-29 19:16:01 -04:00
|
|
|
free(occupant->status);
|
|
|
|
free(occupant);
|
|
|
|
}
|
2015-06-15 14:26:28 -04:00
|
|
|
}
|